Main Page | Namespace List | Class Hierarchy | Alphabetical List | Compound List | File List | Compound Members | File Members

SemanticRIOQueue Class Reference

Inheritance diagram for SemanticRIOQueue:

Inheritance graph
[legend]
Collaboration diagram for SemanticRIOQueue:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 SemanticRIOQueue ()
Packet * pickPacketToDrop ()
Packet * pickPacketForECN (Packet *pkt)
virtual void recv (Packet *, Handler *)
virtual void recv (Packet *p, const char *s)
virtual void updateStats (int queuesize)
void resume ()
int blocked () const
void unblock ()
void block ()
int limit ()
int length ()
int byteLength ()
virtual double utilization (void)
virtual void destroy ()
void enqueue (QueueElem< T > *e)
QueueElem< T > * dequeue ()
void detach (QueueElem< T > *e)
QueueElem< T > * getHead ()
int is_empty () const
int size () const
NsObject * target ()
virtual void drop (Packet *p)
virtual void recvOnly (Packet *)
virtual void delay_bind_init_all ()
virtual int delay_bind_dispatch (const char *varName, const char *localName, TclObject *tracer)
int isdebug () const
virtual void debug (const char *fmt,...)

Protected Member Functions

void enque (Packet *pkt)
Packet * deque ()
void reset ()
void run_out_estimator (int out, int total, int m)
int drop_in_early (Packet *pkt)
int drop_out_early (Packet *pkt)
void trace (TracedVar *)
void print_edp ()
void print_edv ()
int command (int argc, const char *const *argv)
void initialize_params ()
void run_estimator (int nqueued, int m)
double estimator (int nqueued, int m, double ave, double q_w)
void updateMaxP (double new_ave, double now)
void updateMaxPFeng (double new_ave)
int drop_early (Packet *pkt)
double modify_p (double p, int count, int count_bytes, int bytes, int mean_pktsize, int wait, int size)
double calculate_p_new (double v_ave, double th_max, int gentle, double v_a, double v_b, double v_c, double v_d, double max_p)
double calculate_p (double v_ave, double th_max, int gentle, double v_a, double v_b, double v_c, double v_d, double max_p_inv)
virtual void reportDrop (Packet *pkt)
void print_summarystats ()
int bcount_ ()
void utilUpdate (double int_begin, double int_end, int link_state)
virtual void drop (Packet *p, const char *s)
void send (Packet *p, Handler *h)
void handle (Event *)

Protected Attributes

int in_len_
int in_bcount_
int priority_method_
edp_rio edp_in_
edp_rio edp_out_
int in_idle_
double in_idletime_
edv_rio edv_in_
edv_rio edv_out_
int summarystats_
LinkDelay * link_
int fifo_
PacketQueue * q_
int qib_
NsObject * de_drop_
NsObject * EDTrace
char traceType [20]
Tcl_Channel tchan_
TracedInt curq_
int drop_tail_
int drop_front_
int drop_rand_
int ns1_compat_
edp edp_
int doubleq_
int dqthresh_
int idle_
double idletime_
edv edv_
int first_reset_
int qlim_
int blocked_
int unblock_on_resume_
QueueHandler qh_
PacketQueue * pq_
double true_ave_
double total_time_
double last_change_
double old_util_
double util_weight_
QueueElem< T > * head_
QueueElem< T > * tail_
int size_
NsObject * target_
NsObject * drop_
int debug_

Constructor & Destructor Documentation

SemanticRIOQueue::SemanticRIOQueue (   )  [inline]
 

Definition at line 14 of file semantic-rio.cc. 

00014 : RIOQueue() {}

Member Function Documentation

int REDQueue::bcount_ (   )  [inline, protected, inherited]
 

Definition at line 167 of file red.h.

References PacketQueue::byteLength(), and REDQueue::q_. 

00167 { return q_->byteLength(); };

Here is the call graph for this function:

template<class T>
void Queue< T >::block (   )  [inline, inherited]
 

Definition at line 131 of file queue.h.

References Queue< T >::blocked_. 

00131 { blocked_ = 1; }

template<class T>
int Queue< T >::blocked (   )  const [inline, inherited]
 

Definition at line 129 of file queue.h.

References Queue< T >::blocked_.

Referenced by CBQClass::recv(). 

00129 { return (blocked_ == 1); }

template<class T>
int Queue< T >::byteLength (   )  [inline, inherited]
 

Definition at line 135 of file queue.h.

References PacketQueue::byteLength(), and Queue< T >::pq_. 

00135 { return pq_->byteLength(); }   /* number of bytes *

Here is the call graph for this function:

double REDQueue::calculate_p (  double  v_ave,
double  th_max,
int  gentle,
double  v_a,
double  v_b,
double  v_c,
double  v_d,
double  max_p_inv
)  [protected, inherited]
 

Definition at line 394 of file red.cc.

References REDQueue::calculate_p_new().

Referenced by RIOQueue::drop_in_early(), and RIOQueue::drop_out_early(). 

00396 {
00397         double p = calculate_p_new(v_ave, th_max, gentle, v_a,
00398                 v_b, v_c, v_d, 1.0 / max_p_inv);
00399         return p;
00400 }

Here is the call graph for this function:

double REDQueue::calculate_p_new (  double  v_ave,
double  th_max,
int  gentle,
double  v_a,
double  v_b,
double  v_c,
double  v_d,
double  max_p
)  [protected, inherited]
 

Definition at line 370 of file red.cc.

Referenced by REDQueue::calculate_p(), and REDQueue::drop_early(). 

00372 {
00373         double p;
00374         if (gentle && v_ave >= th_max) {
00375                 // p ranges from max_p to 1 as the average queue
00376                 // size ranges from th_max to twice th_max 
00377                 p = v_c * v_ave + v_d;
00378         } else {
00379                 // p ranges from 0 to max_p as the average queue
00380                 // size ranges from th_min to th_max 
00381                 p = v_a * v_ave + v_b;
00382                 p *= max_p;
00383         }
00384         if (p > 1.0)
00385                 p = 1.0;
00386         return p;
00387 }

int REDQueue::command (  int  argc,
const char *const *  argv
)  [protected, virtual, inherited]
 

Reimplemented from Connector.

Reimplemented in PushbackQueue, and RedPDQueue.

Definition at line 692 of file red.cc.

References LinkDelay::bandwidth(), Connector::command(), REDQueue::de_drop_, NsObject::debug_, LinkDelay::delay(), edp::delay, REDQueue::edp_, REDQueue::EDTrace, REDQueue::initialize_params(), REDQueue::link_, edp::mean_pktsize, Queue< T >::pq_, REDQueue::print_summarystats(), edp::ptc, REDQueue::q_, edp::q_w, REDQueue::reset(), REDQueue::tchan_, edp::th_max_pkts, edp::th_min_pkts, and REDQueue::traceType.

Referenced by RedPDQueue::command(), and PushbackQueue::command(). 

00693 {
00694         Tcl& tcl = Tcl::instance();
00695         if (argc == 2) {
00696                 if (strcmp(argv[1], "reset") == 0) {
00697                         reset();
00698                         return (TCL_OK);
00699                 }
00700                 if (strcmp(argv[1], "early-drop-target") == 0) {
00701                         if (de_drop_ != NULL)
00702                                 tcl.resultf("%s", de_drop_->name());
00703                         return (TCL_OK);
00704                 }
00705                 if (strcmp(argv[1], "edrop-trace") == 0) {
00706                         if (EDTrace != NULL) {
00707                                 tcl.resultf("%s", EDTrace->name());
00708                                 if (debug_) 
00709                                         printf("edrop trace exists according to RED\n");
00710                         }
00711                         else {
00712                                 if (debug_)
00713                                         printf("edrop trace doesn't exist according to RED\n");
00714                                 tcl.resultf("0");
00715                         }
00716                         return (TCL_OK);
00717                 }
00718                 if (strcmp(argv[1], "trace-type") == 0) {
00719                         tcl.resultf("%s", traceType);
00720                         return (TCL_OK);
00721                 }
00722                 if (strcmp(argv[1], "printstats") == 0) {
00723                         print_summarystats();
00724                         return (TCL_OK);
00725                 }
00726         } 
00727         else if (argc == 3) {
00728                 // attach a file for variable tracing
00729                 if (strcmp(argv[1], "attach") == 0) {
00730                         int mode;
00731                         const char* id = argv[2];
00732                         tchan_ = Tcl_GetChannel(tcl.interp(), (char*)id, &mode);
00733                         if (tchan_ == 0) {
00734                                 tcl.resultf("RED: trace: can't attach %s for writing", id);
00735                                 return (TCL_ERROR);
00736                         }
00737                         return (TCL_OK);
00738                 }
00739                 // tell RED about link stats
00740                 if (strcmp(argv[1], "link") == 0) {
00741                         LinkDelay* del = (LinkDelay*)TclObject::lookup(argv[2]);
00742                         if (del == 0) {
00743                                 tcl.resultf("RED: no LinkDelay object %s",
00744                                         argv[2]);
00745                                 return(TCL_ERROR);
00746                         }
00747                         // set ptc now
00748                         link_ = del;
00749                         edp_.ptc = link_->bandwidth() /
00750                                 (8. * edp_.mean_pktsize);
00751                         edp_.delay = link_->delay();
00752                         if (
00753                           (edp_.q_w <= 0.0 || edp_.th_min_pkts == 0 ||
00754                                         edp_.th_max_pkts == 0))
00755                                 initialize_params();
00756                         return (TCL_OK);
00757                 }
00758                 if (strcmp(argv[1], "early-drop-target") == 0) {
00759                         NsObject* p = (NsObject*)TclObject::lookup(argv[2]);
00760                         if (p == 0) {
00761                                 tcl.resultf("no object %s", argv[2]);
00762                                 return (TCL_ERROR);
00763                         }
00764                         de_drop_ = p;
00765                         return (TCL_OK);
00766                 }
00767                 if (strcmp(argv[1], "edrop-trace") == 0) {
00768                         if (debug_) 
00769                                 printf("Ok, Here\n");
00770                         NsObject * t  = (NsObject *)TclObject::lookup(argv[2]);
00771                         if (debug_)  
00772                                 printf("Ok, Here too\n");
00773                         if (t == 0) {
00774                                 tcl.resultf("no object %s", argv[2]);
00775                                 return (TCL_ERROR);
00776                         }
00777                         EDTrace = t;
00778                         if (debug_)  
00779                                 printf("Ok, Here too too too %d\n", ((Trace *)EDTrace)->type_);
00780                         return (TCL_OK);
00781                 }
00782                 if (!strcmp(argv[1], "packetqueue-attach")) {
00783                         delete q_;
00784                         if (!(q_ = (PacketQueue*) TclObject::lookup(argv[2])))
00785                                 return (TCL_ERROR);
00786                         else {
00787                                 pq_ = q_;
00788                                 return (TCL_OK);
00789                         }
00790                 }
00791         }
00792         return (Queue::command(argc, argv));
00793 }

Here is the call graph for this function:

void NsObject::debug (  const char *  fmt,
... 
)  [virtual, inherited]
 

Definition at line 102 of file object.cc.

References NsObject::debug_. 

00103 {
00104         if (!debug_)
00105                 return;
00106         va_list ap;
00107         va_start(ap, fmt);
00108         vprintf(fmt, ap);
00109 }

int NsObject::delay_bind_dispatch (  const char *  varName,
const char *  localName,
TclObject *  tracer
)  [virtual, inherited]
 

Reimplemented in BayFullTcpAgent, Agent, MPLSAddressClassifier, LDPAgent, FullTcpAgent, SackFullTcpAgent, RFC793eduTcpAgent, TcpSink, TcpAgent, and VegasTcpAgent.

Definition at line 63 of file object.cc.

References NsObject::debug_.

Referenced by MPLSAddressClassifier::delay_bind_dispatch(), and Agent::delay_bind_dispatch(). 

00064 {
00065         if (delay_bind_bool(varName, localName, "debug_", &debug_, tracer)) 
00066                 return TCL_OK;
00067         return TclObject::delay_bind_dispatch(varName, localName, tracer);
00068 }

void NsObject::delay_bind_init_all (   )  [virtual, inherited]
 

Reimplemented in BayFullTcpAgent, Agent, MPLSAddressClassifier, LDPAgent, FullTcpAgent, SackFullTcpAgent, RFC793eduTcpAgent, TcpSink, TcpAgent, and VegasTcpAgent.

Definition at line 57 of file object.cc.

Referenced by MPLSAddressClassifier::delay_bind_init_all(), and Agent::delay_bind_init_all(). 

00058 {
00059         delay_bind_init_one("debug_");
00060 }

Packet * RIOQueue::deque (   )  [protected, virtual, inherited]
 

Reimplemented from REDQueue.

Definition at line 164 of file rio.cc.

References hdr_cmn::access(), hdr_flags::access(), REDQueue::deque(), RIOQueue::in_bcount_, RIOQueue::in_idle_, RIOQueue::in_len_, hdr_flags::pri_, and hdr_cmn::size(). 

00165 {
00166         Packet *p;
00167         p = REDQueue::deque();
00168         // printf( "qlen %d %d\n", q_->length(), length());
00169         if (p != 0) {
00170                 hdr_flags* hf = hdr_flags::access(p);
00171                 if (hf->pri_) {   
00172                   /* Regular In packets */
00173                   in_idle_ = 0;
00174                   in_bcount_ -= hdr_cmn::access(p)->size();
00175                   --in_len_;
00176                 }
00177         } else {
00178                 in_idle_ = 1;
00179         }
00180         return (p);
00181 }

Here is the call graph for this function:

template<class T>
QueueElem<T>* Queue< T >::dequeue (   )  [inline, inherited]
 

Definition at line 378 of file mcache.h.

References Queue< T >::head_, QueueElem< T >::next(), QueueElem< T >::next_, Queue< T >::size_, and Queue< T >::tail_.

Referenced by Queue< T >::detach(), and MediaServer::get_next_segment(). 

00378                                 {
00379                 QueueElem<T> *p = head_;
00380                 if (head_ != 0) 
00381                         head_ = head_->next();
00382                 if (head_ == 0)
00383                         tail_ = 0;
00384                 p->next_ = 0;
00385                 size_--;
00386                 if (size_ == 0) 
00387                         assert((head_ == 0) && (tail_ == 0));
00388                 return p;
00389         }

Here is the call graph for this function:

template<class T>
virtual void Queue< T >::destroy (   )  [inline, virtual, inherited]
 

Definition at line 358 of file mcache.h.

References QueueElem< T >::data(), Queue< T >::head_, and QueueElem< T >::next(). 

00358                                {
00359                 QueueElem<T> *p = head_, *q;
00360                 while (p != NULL) {
00361                         q = p;
00362                         p = p->next();
00363                         delete q->data();
00364                         delete q;
00365                 }
00366                 head_ = NULL;
00367         }

Here is the call graph for this function:

template<class T>
void Queue< T >::detach (  QueueElem< T > *  e  )  [inline, inherited]
 

Definition at line 390 of file mcache.h.

References Queue< T >::dequeue(), Queue< T >::head_, QueueElem< T >::next_, Queue< T >::size_, and Queue< T >::tail_.

Referenced by MediaServer::command(). 

00390                                      {
00391                 assert(head_ != 0);
00392                 if (head_ == e) {
00393                         dequeue();
00394                         return;
00395                 }
00396                 QueueElem<T> *p = head_;
00397                 while (p != NULL) {
00398                         if (p->next_ != e)
00399                                 p = p->next_;
00400                         else
00401                                 break;
00402                 }
00403                 assert(p != NULL);
00404                 p->next_ = e->next_;
00405                 if (tail_ == e)
00406                         tail_ = p;
00407                 size_--;
00408                 if (size_ == 0) 
00409                         assert((head_ == 0) && (tail_ == 0));
00410         }

Here is the call graph for this function:

void Connector::drop (  Packet *  p,
const char *  s
)  [protected, virtual, inherited]
 

Definition at line 114 of file connector.cc.

References Connector::drop_, Packet::free(), and NsObject::recv(). 

00115 {
00116         if (drop_ != 0)
00117                 drop_->recv(p, s);
00118         else
00119                 Packet::free(p);
00120 }

Here is the call graph for this function:

void Connector::drop (  Packet *  p  )  [virtual, inherited]
 

Definition at line 106 of file connector.cc.

References Connector::drop_, Packet::free(), and NsObject::recv().

Referenced by DSRAgent::acceptRouteReply(), ARPTable::arpresolve(), JoBS::dropFront(), Vq::dropPacketForECN(), DSRAgent::dropSendBuff(), JoBS::dropTail(), dsREDQueue::edrop(), Vq::enque(), SRR::enque(), SimpleIntServ::enque(), SFQ::enque(), rtqueue::enque(), RIOQueue::enque(), REMQueue::enque(), REDQueue::enque(), RedPDQueue::enque(), PIQueue::enque(), Marker::enque(), GK::enque(), dsREDQueue::enque(), DRR::enque(), DropTail::enque(), Demarker::enque(), aodv_rqueue::enque(), toraAgent::forward(), AODV::forward(), LandmarkAgent::ForwardPacket(), DSDV_Agent::forwardPacket(), DSRAgent::getRouteForPacket(), Snoop::handle(), DSRAgent::handleFlowForwarding(), DSRAgent::handleForwarding(), DSDV_Agent::lost_link(), TCPTapAgent::processpkt(), CMUPriQueue::prq_enqueue(), rtqueue::purge(), imepAgent::purgeReXmitQ(), SessionTTLChecker::recv(), TTLChecker::recv(), toraAgent::recv(), FullTcpAgent::recv(), BayFullTcpAgent::recv(), TBF::recv(), SatLL::recv(), LL::recv(), GAFPartner::recv(), FloodAgent::recv(), Filter::recv(), DynamicLink::recv(), DSDV_Agent::recv(), AODV::recv(), AODV::recvError(), PriQueue::recvHighPriority(), AODV::recvReply(), toraAgent::reset(), Queue< T >::reset(), LinkDelay::reset(), AODV::rt_ll_failed(), AODV::rt_purge(), AODV::rt_resolve(), toraAgent::rtRoutePacket(), TCPTapAgent::sendpkt(), TapAgent::sendpkt(), IPTapAgent::sendpkt(), AODV::sendRequest(), SatLL::sendUp(), LL::sendUp(), PriQueue::Terminate(), DSRAgent::Terminate(), CMUPriQueue::Terminate(), ARPTable::Terminate(), and DSRAgent::undeliverablePkt(). 

00107 {
00108         if (drop_ != 0)
00109                 drop_->recv(p);
00110         else
00111                 Packet::free(p);
00112 }

Here is the call graph for this function:

int REDQueue::drop_early (  Packet *  pkt  )  [protected, inherited]
 

Definition at line 441 of file red.cc.

References hdr_flags::access(), hdr_cmn::access(), PacketQueue::byteLength(), edp::bytes, REDQueue::calculate_p_new(), edp::cautious, hdr_flags::ce(), edv::count, edv::count_bytes, edv::cur_max_p, hdr_flags::ect(), REDQueue::edp_, REDQueue::edv_, edp::gentle, PacketQueue::length(), edp::mark_p, edp::mean_pktsize, REDQueue::modify_p(), REDQueue::pickPacketForECN(), pow(), edp::ptc, REDQueue::q_, edp::q_w, REDQueue::qib_, edp::setbit, hdr_cmn::size(), edp::th_max, Random::uniform(), edv::v_a, edv::v_ave, edv::v_b, edv::v_c, edv::v_d, edv::v_prob, edv::v_prob1, and edp::wait.

Referenced by REDQueue::enque(). 

00442 {
00443         hdr_cmn* ch = hdr_cmn::access(pkt);
00444 
00445         edv_.v_prob1 = calculate_p_new(edv_.v_ave, edp_.th_max, edp_.gentle, 
00446           edv_.v_a, edv_.v_b, edv_.v_c, edv_.v_d, edv_.cur_max_p);
00447         edv_.v_prob = modify_p(edv_.v_prob1, edv_.count, edv_.count_bytes,
00448           edp_.bytes, edp_.mean_pktsize, edp_.wait, ch->size());
00449 
00450         // drop probability is computed, pick random number and act
00451         if (edp_.cautious == 1) {
00452                  // Don't drop/mark if the instantaneous queue is much
00453                  //  below the average.
00454                  // For experimental purposes only.
00455                 int qsize = qib_?q_->byteLength():q_->length();
00456                 // pkts: the number of packets arriving in 50 ms
00457                 double pkts = edp_.ptc * 0.05;
00458                 double fraction = pow( (1-edp_.q_w), pkts);
00459                 // double fraction = 0.9;
00460                 if ((double) qsize < fraction * edv_.v_ave) {
00461                         // queue could have been empty for 0.05 seconds
00462                         // printf("fraction: %5.2f\n", fraction);
00463                         return (0);
00464                 }
00465         }
00466         double u = Random::uniform();
00467         if (edp_.cautious == 2) {
00468                 // Decrease the drop probability if the instantaneous
00469                 //   queue is much below the average.
00470                 // For experimental purposes only.
00471                 int qsize = qib_?q_->byteLength():q_->length();
00472                 // pkts: the number of packets arriving in 50 ms
00473                 double pkts = edp_.ptc * 0.05;
00474                 double fraction = pow( (1-edp_.q_w), pkts);
00475                 // double fraction = 0.9;
00476                 double ratio = qsize / (fraction * edv_.v_ave);
00477                 if (ratio < 1.0) {
00478                         // printf("ratio: %5.2f\n", ratio);
00479                         u *= 1.0 / ratio;
00480                 }
00481         }
00482         if (u <= edv_.v_prob) {
00483                 // DROP or MARK
00484                 edv_.count = 0;
00485                 edv_.count_bytes = 0;
00486                 hdr_flags* hf = hdr_flags::access(pickPacketForECN(pkt));
00487                 if (edp_.setbit && hf->ect() && edv_.v_prob1 < edp_.mark_p) { 
00488                         hf->ce() = 1;   // mark Congestion Experienced bit
00489                         // Tell the queue monitor here - call emark(pkt)
00490                         return (0);     // no drop
00491                 } else {
00492                         return (1);     // drop
00493                 }
00494         }
00495         return (0);                     // no DROP/mark
00496 }

Here is the call graph for this function:

int RIOQueue::drop_in_early (  Packet *  pkt  )  [protected, inherited]
 

Definition at line 187 of file rio.cc.

References hdr_flags::access(), hdr_cmn::access(), edp::bytes, REDQueue::calculate_p(), hdr_flags::ce(), edv_rio::count, edv_rio::count_bytes, hdr_flags::ect(), REDQueue::edp_, RIOQueue::edp_in_, RIOQueue::edv_in_, edp_rio::gentle, edp_rio::max_p_inv, edp::mean_pktsize, REDQueue::modify_p(), REDQueue::pickPacketForECN(), edp::setbit, hdr_cmn::size(), edp_rio::th_max, Random::uniform(), edv_rio::v_a, edv_rio::v_ave, edv_rio::v_b, edv_rio::v_c, edv_rio::v_d, edv_rio::v_prob, edv_rio::v_prob1, and edp::wait.

Referenced by RIOQueue::enque(). 

00188 {
00189         hdr_cmn* ch = hdr_cmn::access(pkt);
00190 
00191         edv_in_.v_prob1 = REDQueue::calculate_p(edv_in_.v_ave, edp_in_.th_max, 
00192           edp_in_.gentle, edv_in_.v_a, edv_in_.v_b, edv_in_.v_c, 
00193           edv_in_.v_d, edp_in_.max_p_inv);
00194         edv_in_.v_prob = REDQueue::modify_p(edv_in_.v_prob1, edv_in_.count, 
00195           edv_in_.count_bytes, edp_.bytes, edp_.mean_pktsize, edp_.wait, 
00196           ch->size());
00197 
00198         // drop probability is computed, pick random number and act
00199         double u = Random::uniform();
00200         if (u <= edv_in_.v_prob) {
00201                 // DROP or MARK
00202                 edv_in_.count = 0;
00203                 edv_in_.count_bytes = 0;
00204                 hdr_flags* hf = hdr_flags::access(pickPacketForECN(pkt));
00205                 if (edp_.setbit && hf->ect() && 
00206                                 edv_in_.v_ave < edp_in_.th_max) {
00207                         hf->ce() = 1;   // mark Congestion Experienced bit
00208                         return (0);     // no drop
00209                 } else {
00210                         return (1);     // drop
00211                 }
00212         }
00213         return (0);                     // no DROP/mark
00214 }

Here is the call graph for this function:

int RIOQueue::drop_out_early (  Packet *  pkt  )  [protected, inherited]
 

Definition at line 224 of file rio.cc.

References hdr_flags::access(), hdr_cmn::access(), edp::bytes, REDQueue::calculate_p(), hdr_flags::ce(), edv_rio::count, edv_rio::count_bytes, hdr_flags::ecn_capable_, REDQueue::edp_, RIOQueue::edp_out_, REDQueue::edv_, RIOQueue::edv_out_, edp_rio::gentle, edp::max_p_inv, edp::mean_pktsize, REDQueue::modify_p(), REDQueue::pickPacketForECN(), edp::setbit, hdr_cmn::size(), edp_rio::th_max, Random::uniform(), edv_rio::v_a, edv::v_ave, edv_rio::v_b, edv_rio::v_c, edv_rio::v_d, edv_rio::v_prob, edv_rio::v_prob1, and edp::wait.

Referenced by RIOQueue::enque(). 

00225 {
00226         hdr_cmn* ch = hdr_cmn::access(pkt);
00227 
00228         edv_out_.v_prob1 = REDQueue::calculate_p(edv_.v_ave, edp_out_.th_max, 
00229           edp_out_.gentle, edv_out_.v_a, edv_out_.v_b, edv_out_.v_c, 
00230           edv_out_.v_d, edp_.max_p_inv);
00231         edv_out_.v_prob = REDQueue::modify_p(edv_out_.v_prob1, edv_out_.count, 
00232           edv_out_.count_bytes, edp_.bytes, edp_.mean_pktsize, edp_.wait, 
00233           ch->size());
00234 
00235         // drop probability is computed, pick random number and act
00236         double u = Random::uniform();
00237         if (u <= edv_out_.v_prob) {
00238                 // DROP or MARK
00239                 edv_out_.count = 0;
00240                 edv_out_.count_bytes = 0;
00241                 hdr_flags* hf = hdr_flags::access(pickPacketForECN(pkt));
00242                 if (edp_.setbit && hf->ecn_capable_ &&
00243                                 edv_.v_ave < edp_out_.th_max) {
00244                         hf->ce() = 1;   // mark Congestion Experienced bit
00245                         return (0);     // no drop
00246                 } else {
00247                         return (1);
00248                 }
00249         }
00250         return (0);  // no DROP/mark
00251 }

Here is the call graph for this function:

void RIOQueue::enque (  Packet *  pkt  )  [protected, virtual, inherited]
 

Reimplemented from REDQueue.

Definition at line 274 of file rio.cc.

References hdr_cmn::access(), hdr_ip::access(), hdr_flags::access(), PacketQueue::byteLength(), Scheduler::clock(), edv_rio::count, edv::count, edv_rio::count_bytes, edv::count_bytes, REDQueue::curq_, REDQueue::de_drop_, Connector::drop(), RIOQueue::drop_in_early(), RIOQueue::drop_out_early(), DTYPE_FORCED, DTYPE_NONE, DTYPE_UNFORCED, REDQueue::edp_, RIOQueue::edp_in_, RIOQueue::edp_out_, REDQueue::edv_, RIOQueue::edv_in_, RIOQueue::edv_out_, PacketQueue::enque(), REDQueue::estimator(), hdr_ip::flowid(), edp_rio::gentle, REDQueue::idle_, REDQueue::idletime_, RIOQueue::in_bcount_, RIOQueue::in_idle_, RIOQueue::in_len_, Scheduler::instance(), PacketQueue::length(), edp::mean_pktsize, REDQueue::ns1_compat_, edv_rio::old, REDQueue::pickPacketForECN(), REDQueue::pickPacketToDrop(), hdr_flags::pri_, RIOQueue::priority_method_, edp::ptc, REDQueue::q_, edp::q_w, REDQueue::qib_, Queue< T >::qlim_, NsObject::recv(), PacketQueue::remove(), hdr_cmn::size(), edp_rio::th_max, edp_rio::th_min, edv_rio::v_ave, edv::v_ave, and edv_rio::v_prob. 

00275 {
00276         /* Duplicate the RED algorithm to carry out a separate
00277          * calculation for Out packets -- Wenjia */
00278         hdr_flags* hf = hdr_flags::access(pkt);
00279         hdr_ip* iph = hdr_ip::access(pkt);
00280         if (priority_method_ == 1) {
00281                 hf->pri_ = iph->flowid();
00282         }
00283 
00284         //printf("RIOQueue::enque queue %d queue-length %d priority %d\n", 
00285         //      q_, q_->length(), hf->pri_);
00286         if (hf->pri_) {  /* Regular In packets */
00287 
00288         /*
00289          * if we were idle, we pretend that m packets arrived during
00290          * the idle period.  m is set to be the ptc times the amount
00291          * of time we've been idle for
00292          */
00293 
00294         int m = 0;
00295         int m_in = 0;
00296         double now = Scheduler::instance().clock();
00297         /* To account for the period when the queue was empty.  */
00298         if (in_idle_) {
00299                 in_idle_ = 0;
00300                 m_in = int(edp_.ptc * (now - idletime_));
00301         } 
00302         if (idle_) {
00303                 idle_ = 0;
00304                 m = int(edp_.ptc * (now - idletime_));
00305         }
00306 
00307         /*
00308          * Run the estimator with either 1 new packet arrival, or with
00309          * the scaled version above [scaled by m due to idle time]
00310          */
00311 
00312         // printf( "qlen %d\n", q_->length());
00313         edv_.v_ave = REDQueue::estimator(qib_ ? q_->byteLength() : q_->length(), m + 1,
00314                 edv_.v_ave, edp_.q_w);
00315         edv_in_.v_ave = REDQueue::estimator(qib_ ? in_bcount_ : in_len_,
00316                 m_in + 1, edv_in_.v_ave, edp_.q_w);
00317 
00318         /*
00319          * count and count_bytes keeps a tally of arriving traffic
00320          * that has not been dropped (i.e. how long, in terms of traffic,
00321          * it has been since the last early drop)
00322          */
00323 
00324         hdr_cmn* ch = hdr_cmn::access(pkt);
00325         ++edv_.count;
00326         edv_.count_bytes += ch->size();
00327 
00328         /* added by Yun */
00329         ++edv_in_.count;
00330         edv_in_.count_bytes += ch->size();
00331 
00332         /*
00333          * DROP LOGIC:
00334          *      q = current q size, ~q = averaged q size
00335          *      1> if ~q > maxthresh, this is a FORCED drop
00336          *      2> if minthresh < ~q < maxthresh, this may be an UNFORCED drop
00337          *      3> if (q+1) > hard q limit, this is a FORCED drop
00338          */
00339 
00340         // register double qavg = edv_.v_ave;
00341         register double in_qavg = edv_in_.v_ave;
00342         int droptype = DTYPE_NONE;
00343         int qlen = qib_ ? q_->byteLength() : q_->length();
00344         int in_qlen = qib_ ? in_bcount_ : in_len_;
00345         int qlim = qib_ ? (qlim_ * edp_.mean_pktsize) : qlim_;
00346 
00347         curq_ = qlen;   // helps to trace queue during arrival, if enabled
00348 
00349         if (in_qavg >= edp_in_.th_min && in_qlen > 1) {
00350                 if ((!edp_in_.gentle && in_qavg >= edp_in_.th_max) ||
00351                         (edp_in_.gentle && in_qavg >= 2 * edp_in_.th_max)) {
00352                         droptype = DTYPE_FORCED;
00353                 } else if (edv_in_.old == 0) {
00354                         /* 
00355                          * The average queue size has just crossed the
00356                          * threshold from below to above "minthresh", or
00357                          * from above "minthresh" with an empty queue to
00358                          * above "minthresh" with a nonempty queue.
00359                          */
00360                         edv_in_.count = 1;
00361                         edv_in_.count_bytes = ch->size();
00362                         edv_in_.old = 1;
00363                 } else if (drop_in_early(pkt)) {
00364                         droptype = DTYPE_UNFORCED;
00365                 }
00366         } else {
00367                 /* No packets are being dropped.  */
00368                 edv_in_.v_prob = 0.0;
00369                 edv_in_.old = 0;                
00370         }
00371         if (qlen >= qlim) {
00372                 // see if we've exceeded the queue size
00373                 droptype = DTYPE_FORCED;
00374         }
00375 
00376         if (droptype == DTYPE_UNFORCED) {
00377                 /* pick packet for ECN, which is dropping in this case */
00378                 Packet *pkt_to_drop = pickPacketForECN(pkt);
00379                 /* 
00380                  * If the packet picked is different that the one that just
00381                  * arrived, add it to the queue and remove the chosen packet.
00382                  */
00383                 if (pkt_to_drop != pkt) {
00384                         q_->enque(pkt);
00385                         // printf( "in: qlen %d %d\n", q_->length(), length());
00386                         ++in_len_;
00387                         in_bcount_ += ch->size();
00388                         q_->remove(pkt_to_drop);
00389                         // printf("remove qlen %d %d\n",q_->length(),length());
00390                         if (hdr_flags::access(pkt_to_drop)->pri_)
00391                            {
00392                              in_bcount_ -= 
00393                                      hdr_cmn::access(pkt_to_drop)->size();
00394                              --in_len_;
00395                            }
00396                         pkt = pkt_to_drop; /* ok 'cause pkt not needed anymore */
00397                 }
00398                 // deliver to special "edrop" target, if defined
00399                 if (de_drop_ != NULL)
00400                         de_drop_->recv(pkt);
00401                 else
00402                         drop(pkt);
00403         } else {
00404                 /* forced drop, or not a drop: first enqueue pkt */
00405                 q_->enque(pkt);
00406                 // printf( "in: qlen %d %d\n", q_->length(), length());
00407                 ++in_len_;
00408                 in_bcount_ += ch->size();
00409 
00410                 /* drop a packet if we were told to */
00411                 if (droptype == DTYPE_FORCED) {
00412                         /* drop random victim or last one */
00413                         pkt = pickPacketToDrop();
00414                         q_->remove(pkt);
00415                         // printf("remove qlen %d %d\n",q_->length(),length());
00416                         if (hdr_flags::access(pkt)->pri_) {
00417                           in_bcount_ -= hdr_cmn::access(pkt)->size(); 
00418                           --in_len_;
00419                           }
00420                         drop(pkt);
00421                         if (!ns1_compat_) {
00422                                 // bug-fix from Philip Liu, <phill@ece.ubc.ca>
00423                                 edv_.count = 0;
00424                                 edv_.count_bytes = 0;
00425                                 edv_in_.count = 0;
00426                                 edv_in_.count_bytes = 0;
00427                         }
00428                 }
00429             }
00430         }
00431 
00432         else {     /* Out packets and default regular packets */
00433           /*
00434            * count and count_bytes keeps a tally of arriving traffic
00435            * that has not been dropped (i.e. how long, in terms of traffic,
00436            * it has been since the last early drop)
00437            */
00438 
00439           hdr_cmn* ch = hdr_cmn::access(pkt);
00440           ++edv_.count;
00441           edv_.count_bytes += ch->size();
00442 
00443           /* added by Yun */
00444           ++edv_out_.count;
00445           edv_out_.count_bytes += ch->size();
00446 
00447           /*
00448            * DROP LOGIC:
00449            *    q = current q size, ~q = averaged q size
00450            *    1> if ~q > maxthresh, this is a FORCED drop
00451            *    2> if minthresh < ~q < maxthresh, this may be an UNFORCED drop
00452            *    3> if (q+1) > hard q limit, this is a FORCED drop
00453            */
00454 
00455                 /* if the average queue is below the out_th_min
00456                  * then we have no need to worry.
00457                  */
00458 
00459           register double qavg = edv_.v_ave;
00460           // register double in_qavg = edv_in_.v_ave;
00461           int droptype = DTYPE_NONE;
00462           int qlen = qib_ ? q_->byteLength() : q_->length();
00463           /* added by Yun, seems not useful */
00464           // int out_qlen = qib_ ? out_bcount_ : q_->out_length();
00465 
00466           int qlim = qib_ ?  (qlim_ * edp_.mean_pktsize) : qlim_;
00467 
00468           curq_ = qlen; // helps to trace queue during arrival, if enabled
00469 
00470           if (qavg >= edp_out_.th_min && qlen > 1) {
00471                   if (!edp_out_.gentle && qavg >= edp_out_.th_max ||
00472                       (edp_out_.gentle && qavg >= 2 * edp_out_.th_max)) {
00473                         droptype = DTYPE_FORCED;  // ? not sure, Yun
00474                   } else if (edv_out_.old == 0) {
00475                         /* 
00476                          * The average queue size has just crossed the
00477                          * threshold from below to above "minthresh", or
00478                          * from above "minthresh" with an empty queue to
00479                          * above "minthresh" with a nonempty queue.
00480                          */
00481                         edv_out_.count = 1;
00482                         edv_out_.count_bytes = ch->size();
00483                         edv_out_.old = 1;
00484                   } else if (drop_out_early(pkt)) {
00485                         droptype = DTYPE_UNFORCED; // ? not sure, Yun
00486                   }
00487           } else {
00488                   edv_out_.v_prob = 0.0;
00489                   edv_out_.old = 0;              // explain
00490           }
00491           if (qlen >= qlim) {
00492                   // see if we've exceeded the queue size
00493                   droptype = DTYPE_FORCED;   //need more consideration, Yun
00494           }
00495 
00496           if (droptype == DTYPE_UNFORCED) {
00497                   /* pick packet for ECN, which is dropping in this case */
00498                   Packet *pkt_to_drop = pickPacketForECN(pkt);
00499                   /*
00500                    * If the packet picked is different that the one that just
00501                    * arrived, add it to the queue and remove the chosen packet.
00502                    */
00503                   if (pkt_to_drop != pkt) {
00504                           q_->enque(pkt);
00505                           //printf("out: qlen %d %d\n", q_->length(), length());
00506                           q_->remove(pkt_to_drop);
00507                           //printf("remove qlen %d %d\n",q_->length(),length());
00508                           if (hdr_flags::access(pkt_to_drop)->pri_)
00509                           {
00510                              in_bcount_ -=hdr_cmn::access(pkt_to_drop)->size();
00511                              --in_len_;
00512                           }
00513                           pkt = pkt_to_drop;/* ok cause pkt not needed anymore */
00514                   }
00515                   // deliver to special "edrop" target, if defined
00516                   if (de_drop_ != NULL)
00517                           de_drop_->recv(pkt);
00518                   else
00519                           drop(pkt);
00520           } else {
00521                   /* forced drop, or not a drop: first enqueue pkt */
00522                   q_->enque(pkt);
00523                   //printf("out: qlen %d %d\n", q_->length(), length());
00524 
00525                   /* drop a packet if we were told to */
00526                   if (droptype == DTYPE_FORCED) {
00527                           /* drop random victim or last one */
00528                           pkt = pickPacketToDrop();
00529                           q_->remove(pkt);
00530                           //printf("remove qlen %d %d\n",q_->length(),length());
00531                           if (hdr_flags::access(pkt)->pri_)
00532                           {
00533                             in_bcount_ -= hdr_cmn::access(pkt)->size();
00534                             --in_len_;
00535                           }
00536                           drop(pkt);
00537                   }
00538           }
00539         }
00540 
00541         return;
00542 }

Here is the call graph for this function:

template<class T>
void Queue< T >::enqueue (  QueueElem< T > *  e  )  [inline, inherited]
 

Definition at line 369 of file mcache.h.

References QueueElem< T >::append(), Queue< T >::head_, Queue< T >::size_, and Queue< T >::tail_.

Referenced by MediaServer::command(), and MediaServer::get_next_segment(). 

00369                                       {
00370                 if (tail_ == 0)
00371                         head_ = tail_ = e;
00372                 else {
00373                         tail_->append(e);
00374                         tail_ = e;
00375                 }
00376                 size_++;
00377         }

Here is the call graph for this function:

double REDQueue::estimator (  int  nqueued,
int  m,
double  ave,
double  q_w
)  [protected, inherited]
 

Definition at line 319 of file red.cc.

References edp::adaptive, Scheduler::clock(), REDQueue::edp_, REDQueue::edv_, edp::feng_adaptive, Scheduler::instance(), edp::interval, edv::lastset, REDQueue::updateMaxP(), and REDQueue::updateMaxPFeng().

Referenced by RIOQueue::enque(), and REDQueue::enque(). 

00320 {
00321         double new_ave, old_ave;
00322 
00323         new_ave = ave;
00324         while (--m >= 1) {
00325                 new_ave *= 1.0 - q_w;
00326         }
00327         old_ave = new_ave;
00328         new_ave *= 1.0 - q_w;
00329         new_ave += q_w * nqueued;
00330         
00331         double now = Scheduler::instance().clock();
00332         if (edp_.adaptive == 1) {
00333                 if (edp_.feng_adaptive == 1)
00334                         updateMaxPFeng(new_ave);
00335                 else if (now > edv_.lastset + edp_.interval)
00336                         updateMaxP(new_ave, now);
00337         }
00338         return new_ave;
00339 }

Here is the call graph for this function:

template<class T>
QueueElem<T>* Queue< T >::getHead (   )  [inline, inherited]
 

Definition at line 411 of file mcache.h.

References Queue< T >::head_.

Referenced by MediaServer::find_prefinfo(). 

00411 { return head_; }

void NsObject::handle (  Event *   )  [protected, virtual, inherited]
 

Implements Handler.

Reimplemented in LinkDelay, LL, AckRecons, and Snoop.

Definition at line 91 of file object.cc.

References NsObject::recv(). 

00092 {
00093         recv((Packet*)e);
00094 }

Here is the call graph for this function:

void REDQueue::initialize_params (   )  [protected, inherited]
 

Definition at line 167 of file red.cc.

References edp::delay, REDQueue::edp_, edp::ptc, edp::q_w, edp::targetdelay, edp::th_max_pkts, and edp::th_min_pkts.

Referenced by REDQueue::command(), and REDQueue::reset(). 

00168 {
00169 /*
00170  * If q_weight=0, set it to a reasonable value of 1-exp(-1/C)
00171  * This corresponds to choosing q_weight to be of that value for
00172  * which the packet time constant -1/ln(1-q_weight) per default RTT 
00173  * of 100ms is an order of magnitude more than the link capacity, C.
00174  *
00175  * If q_weight=-1, then the queue weight is set to be a function of
00176  * the bandwidth and the link propagation delay.  In particular, 
00177  * the default RTT is assumed to be three times the link delay and 
00178  * transmission delay, if this gives a default RTT greater than 100 ms. 
00179  *
00180  * If q_weight=-2, set it to a reasonable value of 1-exp(-10/C).
00181  */
00182         if (edp_.q_w == 0.0) {
00183                 edp_.q_w = 1.0 - exp(-1.0/edp_.ptc);
00184         } else if (edp_.q_w == -1.0) {
00185                 double rtt = 3.0*(edp_.delay+1.0/edp_.ptc);
00186                 //printf("delay: %5.4f rtt: %5.4f\n", edp_.delay, rtt);
00187                 if (rtt < 0.1) 
00188                         rtt = 0.1;
00189                 edp_.q_w = 1.0 - exp(-1.0/(10*rtt*edp_.ptc));
00190         } else if (edp_.q_w == -2.0) {
00191                 edp_.q_w = 1.0 - exp(-10.0/edp_.ptc);
00192         }
00193 
00194         // printf("ptc: %7.5f bandwidth: %5.3f pktsize: %d\n", edp_.ptc, link_->bandwidth(), edp_.mean_pktsize);
00195         // printf("th_min_pkts: %7.5f th_max_pkts: %7.5f\n", edp_.th_min_pkts, edp_.th_max);
00196         if (edp_.th_min_pkts == 0) {
00197                 edp_.th_min_pkts = 5.0;
00198                 // set th_min_pkts to half of targetqueue, if this is greater
00199                 //  than 5 packets.
00200                 double targetqueue = edp_.targetdelay * edp_.ptc;
00201                 if (edp_.th_min_pkts < targetqueue / 2.0 )
00202                         edp_.th_min_pkts = targetqueue / 2.0 ;
00203         }
00204         if (edp_.th_max_pkts == 0) 
00205                 edp_.th_max_pkts = 3.0 * edp_.th_min_pkts;
00206         //printf("th_min_pkts: %7.5f th_max_pkts: %7.5f\n", edp_.th_min_pkts, edp_.th_max);
00207         //printf("q_w: %7.5f\n", edp_.q_w);
00208 }

template<class T>
int Queue< T >::is_empty (   )  const [inline, inherited]
 

Definition at line 412 of file mcache.h.

References Queue< T >::size_.

Referenced by MediaServer::command(), and MediaServer::get_next_segment(). 

00412 { return (size_ == 0); }

int NsObject::isdebug (   )  const [inline, inherited]
 

Definition at line 61 of file object.h.

References NsObject::debug_. 

00061 { return debug_; }

template<class T>
int Queue< T >::length (   )  [inline, inherited]
 

Reimplemented in DRR, and SRR.

Definition at line 133 of file queue.h.

References PacketQueue::length(), and Queue< T >::pq_.

Referenced by REMQueue::run_updaterule(), Snoop::snoop_data(), and JoBS::updateStats(). 

00133 { return pq_->length(); }       /* number of pkts currently in

Here is the call graph for this function:

template<class T>
int Queue< T >::limit (   )  [inline, inherited]
 

Definition at line 132 of file queue.h.

References Queue< T >::qlim_.

Referenced by dsREDQueue::reset(), and Snoop::snoop_data(). 

00132 { return qlim_; }

double REDQueue::modify_p (  double  p,
int  count,
int  count_bytes,
int  bytes,
int  mean_pktsize,
int  wait,
int  size
)  [protected, inherited]
 

Definition at line 406 of file red.cc.

Referenced by REDQueue::drop_early(), RIOQueue::drop_in_early(), RIOQueue::drop_out_early(), and RedPDQueue::enque(). 

00408 {
00409         double count1 = (double) count;
00410         if (bytes)
00411                 count1 = (double) (count_bytes/mean_pktsize);
00412         if (wait) {
00413                 if (count1 * p < 1.0)
00414                         p = 0.0;
00415                 else if (count1 * p < 2.0)
00416                         p /= (2 - count1 * p);
00417                 else
00418                         p = 1.0;
00419         } else {
00420                 if (count1 * p < 1.0)
00421                         p /= (1.0 - count1 * p);
00422                 else
00423                         p = 1.0;
00424         }
00425         if (bytes && p < 1.0) {
00426                 p = p * size / mean_pktsize;
00427         }
00428         if (p > 1.0)
00429                 p = 1.0;
00430         return p;
00431 }

Packet* SemanticRIOQueue::pickPacketForECN (  Packet *  pkt  )  [inline, virtual]
 

Reimplemented from REDQueue.

Definition at line 18 of file semantic-rio.cc.

References Queue< T >::pq_. 

00018                                               {
00019                 return(((SemanticPacketQueue*) pq_)->pickPacketForECN(pkt));
00020         }

Packet* SemanticRIOQueue::pickPacketToDrop (   )  [inline, virtual]
 

Reimplemented from REDQueue.

Definition at line 15 of file semantic-rio.cc.

References Queue< T >::pq_. 

00015                                    {
00016                 return(((SemanticPacketQueue*) pq_)->pickPacketToDrop());
00017         }

void RIOQueue::print_edp (   )  [protected, inherited]
 

Reimplemented from REDQueue.

Definition at line 587 of file rio.cc.

References RIOQueue::edp_in_, RIOQueue::edp_out_, RIOQueue::in_idletime_, REDQueue::print_edp(), Queue< T >::qlim_, edp_rio::th_max, and edp_rio::th_min. 

00588 {
00589         REDQueue::print_edp();
00590         printf("in_minth: %f, in_maxth: %f\n", edp_in_.th_min, edp_in_.th_max);
00591         printf("out_minth: %f, out_maxth: %f\n", 
00592                 edp_out_.th_min, edp_out_.th_max);
00593         printf("qlim: %d, in_idletime: %f\n", qlim_, in_idletime_);
00594         printf("=========\n");
00595 }

Here is the call graph for this function:

void RIOQueue::print_edv (   )  [protected, inherited]
 

Reimplemented from REDQueue.

Definition at line 597 of file rio.cc.

References RIOQueue::edv_in_, RIOQueue::edv_out_, REDQueue::print_edv(), edv_rio::v_a, and edv_rio::v_b. 

00598 {
00599         REDQueue::print_edv();
00600         printf("in_v_a: %f, in_v_b: %f\n", edv_in_.v_a, edv_in_.v_b);
00601         printf("out_v_a: %f, out_v_b: %f\n", edv_out_.v_a, edv_out_.v_b);
00602 }

Here is the call graph for this function:

void REDQueue::print_summarystats (   )  [protected, inherited]
 

Definition at line 852 of file red.cc.

References REDQueue::qib_, Queue< T >::total_time_, and Queue< T >::true_ave_.

Referenced by REDQueue::command(). 

00853 {
00854         //double now = Scheduler::instance().clock();
00855         printf("True average queue: %5.3f", true_ave_);
00856         if (qib_) 
00857                 printf(" (in bytes)");
00858         printf(" time: %5.3f\n", total_time_);
00859 }

void NsObject::recv (  Packet *  p,
const char *  s
)  [virtual, inherited]
 

Reimplemented in CMUTrace.

Definition at line 96 of file object.cc.

References Packet::free(). 

00097 {
00098         Packet::free(p);
00099 }

Here is the call graph for this function:

template<class T>
void Queue< T >::recv (  Packet *  ,
Handler * 
)  [virtual, inherited]
 

Reimplemented from Connector.

Reimplemented in CBQueue, FQ, and PriQueue.

Definition at line 101 of file queue.cc.

References Queue< T >::blocked_, Scheduler::clock(), Queue< T >::deque(), Queue< T >::enque(), Scheduler::instance(), Queue< T >::last_change_, Queue< T >::qh_, NsObject::recv(), Connector::target_, and Queue< T >::utilUpdate().

Referenced by PriQueue::recv(). 

00102 {
00103         double now = Scheduler::instance().clock();
00104         enque(p);
00105         if (!blocked_) {
00106                 /*
00107                  * We're not blocked.  Get a packet and send it on.
00108                  * We perform an extra check because the queue
00109                  * might drop the packet even if it was
00110                  * previously empty!  (e.g., RED can do this.)
00111                  */
00112                 p = deque();
00113                 if (p != 0) {
00114                         utilUpdate(last_change_, now, blocked_);
00115                         last_change_ = now;
00116                         blocked_ = 1;
00117                         target_->recv(p, &qh_);
00118                 }
00119         }
00120 }

Here is the call graph for this function:

virtual void NsObject::recvOnly (  Packet *   )  [inline, virtual, inherited]
 

Reimplemented in Agent, and Trace.

Definition at line 56 of file object.h.

Referenced by Trace::recvOnly(). 

00056 {};

virtual void REDQueue::reportDrop (  Packet *  pkt  )  [inline, protected, virtual, inherited]
 

Reimplemented in PushbackQueue.

Definition at line 159 of file red.h.

Referenced by REDQueue::enque(). 

00159 {}  //pushback

void RIOQueue::reset (   )  [protected, virtual, inherited]
 

Reimplemented from REDQueue.

Definition at line 105 of file rio.cc.

References edv_rio::count, edv_rio::count_bytes, edv_rio::drops, REDQueue::edp_, RIOQueue::edp_in_, RIOQueue::edp_out_, RIOQueue::edv_in_, RIOQueue::edv_out_, edp_rio::gentle, edp::gentle, RIOQueue::in_idle_, RIOQueue::in_idletime_, Scheduler::instance(), edp::max_p_inv, edp_rio::max_p_inv, edp::mean_pktsize, edv_rio::old, REDQueue::qib_, REDQueue::reset(), edp_rio::th_max, edp_rio::th_min, edv_rio::v_a, edv_rio::v_ave, edv_rio::v_b, edv_rio::v_c, edv_rio::v_d, and edv_rio::v_slope. 

00106 {
00107         /*
00108          * If queue is measured in bytes, scale min/max thresh
00109          * by the size of an average packet (which is specified by user).
00110          */
00111 
00112         if (qib_) {
00113                 edp_in_.th_min *= edp_.mean_pktsize;
00114                 edp_in_.th_max *= edp_.mean_pktsize;
00115 
00116                 edp_out_.th_min *= edp_.mean_pktsize;
00117                 edp_out_.th_max *= edp_.mean_pktsize;
00118         }
00119 
00120         //modified - ratul
00121         if (edp_.gentle) {
00122                 edp_in_.gentle = true;
00123                 edp_out_.gentle = true;
00124         }
00125         if (edp_in_.gentle) {
00126                 edv_in_.v_c = ( 1.0 - 1 / edp_in_.max_p_inv ) / edp_in_.th_max;
00127                 edv_in_.v_d = 2 / edp_in_.max_p_inv - 1.0;
00128         }               
00129         if (edp_out_.gentle) {
00130                 edv_out_.v_c = ( 1.0 - 1 / edp_.max_p_inv ) / edp_out_.th_max;
00131                 edv_out_.v_d = 2 / edp_.max_p_inv - 1.0;
00132         }
00133 
00134         /* Added by Wenjia */
00135         edv_in_.v_ave = 0.0;
00136         edv_in_.v_slope = 0.0;
00137         edv_in_.drops = 0;
00138         edv_in_.count = 0;
00139         edv_in_.count_bytes = 0;
00140         edv_in_.old = 0;
00141         edv_in_.v_a = 1 / (edp_in_.th_max - edp_in_.th_min);
00142         edv_in_.v_b = - edp_in_.th_min / (edp_in_.th_max - edp_in_.th_min);
00143 
00144         /* Added by Wenjia */
00145         edv_out_.v_ave = 0.0;
00146         edv_out_.v_slope = 0.0;
00147         edv_out_.drops = 0;
00148         edv_out_.count = 0;
00149         edv_out_.count_bytes = 0;
00150         edv_out_.old = 0;
00151         edv_out_.v_a = 1 / (edp_out_.th_max - edp_out_.th_min);
00152         edv_out_.v_b = - edp_out_.th_min / (edp_out_.th_max - edp_out_.th_min);
00153 
00154         in_idle_ = 1;
00155         if (&Scheduler::instance() == NULL) {
00156                 in_idletime_ = 0.0; /* sched not instantiated yet */
00157         }     
00158         REDQueue::reset();
00159 }

Here is the call graph for this function:

template<class T>
void Queue< T >::resume (   )  [inherited]
 

Definition at line 154 of file queue.cc.

References Queue< T >::blocked_, Scheduler::clock(), Queue< T >::deque(), Scheduler::instance(), Queue< T >::last_change_, Queue< T >::qh_, NsObject::recv(), Connector::target_, Queue< T >::unblock_on_resume_, and Queue< T >::utilUpdate().

Referenced by WRR_CBQueue::deque(), CBQueue::deque(), and QueueHandler::handle(). 

00155 {
00156         double now = Scheduler::instance().clock();
00157         Packet* p = deque();
00158         if (p != 0) {
00159                 target_->recv(p, &qh_);
00160         } else {
00161                 if (unblock_on_resume_) {
00162                         utilUpdate(last_change_, now, blocked_);
00163                         last_change_ = now;
00164                         blocked_ = 0;
00165                 }
00166                 else {
00167                         utilUpdate(last_change_, now, blocked_);
00168                         last_change_ = now;
00169                         blocked_ = 1;
00170                 }
00171         }
00172 }

Here is the call graph for this function:

void REDQueue::run_estimator (  int  nqueued,
int  m
)  [protected, inherited]
 

Definition at line 872 of file red.cc.

References REDQueue::edp_, REDQueue::edv_, edp::q_w, edv::v_ave, and edv::v_slope. 

00873 {
00874         double f, f_sl, f_old;
00875 
00876         f = edv_.v_ave;
00877         f_sl = edv_.v_slope;
00878 #define RED_EWMA
00879 #ifdef RED_EWMA
00880         while (--m >= 1) {
00881                 f_old = f;
00882                 f *= 1.0 - edp_.q_w;
00883         }
00884         f_old = f;
00885         f *= 1.0 - edp_.q_w;
00886         f += edp_.q_w * nqueued;
00887 #endif
00888 #ifdef RED_HOLT_WINTERS
00889         while (--m >= 1) {
00890                 f_old = f;
00891                 f += f_sl;
00892                 f *= 1.0 - edp_.q_w;
00893                 f_sl *= 1.0 - 0.5 * edp_.q_w;
00894                 f_sl += 0.5 * edp_.q_w * (f - f_old);
00895         }
00896         f_old = f;
00897         f += f_sl;
00898         f *= 1.0 - edp_.q_w;
00899         f += edp_.q_w * nqueued;
00900         f_sl *= 1.0 - 0.5 * edp_.q_w;
00901         f_sl += 0.5 * edp_.q_w * (f - f_old);
00902 #endif
00903         edv_.v_ave = f;
00904         edv_.v_slope = f_sl;
00905 }

void RIOQueue::run_out_estimator (  int  out,
int  total,
int  m
)  [protected, inherited]
 

void Connector::send (  Packet *  p,
Handler *  h
)  [inline, protected, inherited]
 

Reimplemented in Agent, and LinkDelay.

Definition at line 54 of file connector.h.

References NsObject::recv(), and Connector::target_.

Referenced by SessionTTLChecker::recv(), TTLChecker::recv(), DequeTrace::recv(), Trace::recv(), TraceIpMac::recv(), TraceIp::recv(), SatDequeTrace::recv(), SALink::recv(), SnoopQueueEDrop::recv(), SnoopQueueTagger::recv(), SnoopQueueDrop::recv(), SnoopQueueOut::recv(), SnoopQueueIn::recv(), PktCounter::recv(), NetworkInterface::recv(), MeasureMod::recv(), Filter::recv(), Connector::recv(), CMUTrace::recv(), CBQClass::recv(), and AddSR::recv(). 

00054 { target_->recv(p, h); }

Here is the call graph for this function:

template<class T>
int Queue< T >::size (   )  const [inline, inherited]
 

Definition at line 413 of file mcache.h.

References Queue< T >::size_.

Referenced by JoBS::arvAccounting(), JoBS::assignRateDropsADC(), dsREDQueue::deque(), JoBS::dropFront(), JoBS::dropTail(), RedPDQueue::enque(), JoBS::enque(), MediaServer::get_next_segment(), JoBS::pickDroppedRLC(), and FQ::recv(). 

00413 { return size_; }

NsObject* Connector::target (   )  [inline, inherited]
 

Definition at line 48 of file connector.h.

References Connector::target_.

Referenced by JoBS::assignRateDropsADC(), FQ::deque(), QSAgent::recv(), and MIPMHAgent::reg(). 

00048 { return target_; }

void RIOQueue::trace (  TracedVar *   )  [protected, inherited]
 

Reimplemented from REDQueue.

Definition at line 552 of file rio.cc.

References Scheduler::clock(), Scheduler::instance(), and REDQueue::tchan_. 

00553 {
00554         char wrk[500], *p;
00555 
00556         if (((p = strstr(v->name(), "ave")) == NULL) &&
00557             ((p = strstr(v->name(), "in_ave")) == NULL) &&
00558             ((p = strstr(v->name(), "out_ave")) == NULL) &&
00559             ((p = strstr(v->name(), "prob")) == NULL) &&
00560             ((p = strstr(v->name(), "in_prob")) == NULL) &&
00561             ((p = strstr(v->name(), "out_prob")) == NULL) &&
00562             ((p = strstr(v->name(), "curq")) == NULL)) {
00563                 fprintf(stderr, "RIO:unknown trace var %s\n",
00564                         v->name());
00565                 return;
00566         }
00567 
00568         if (tchan_) {
00569                 int n;
00570                 double t = Scheduler::instance().clock();
00571                 // XXX: be compatible with nsv1 RED trace entries
00572                 if (*p == 'c') {
00573                         sprintf(wrk, "Q %g %d", t, int(*((TracedInt*) v)));
00574                 } else {
00575                         sprintf(wrk, "%c %g %g", *p, t,
00576                                 double(*((TracedDouble*) v)));
00577                 }
00578                 n = strlen(wrk);
00579                 wrk[n] = '\n'; 
00580                 wrk[n+1] = 0;
00581                 (void)Tcl_Write(tchan_, wrk, n+1);
00582         }
00583         return; 
00584 }

Here is the call graph for this function:

template<class T>
void Queue< T >::unblock (   )  [inline, inherited]
 

Definition at line 130 of file queue.h.

References Queue< T >::blocked_. 

00130 { blocked_ = 0; }

void REDQueue::updateMaxP (  double  new_ave,
double  now
)  [protected, inherited]
 

Definition at line 297 of file red.cc.

References edp::alpha, edp::beta, edp::bottom, edv::cur_max_p, REDQueue::edp_, REDQueue::edv_, edv::lastset, edp::th_max, edp::th_min, and edp::top.

Referenced by REDQueue::estimator(). 

00298 {
00299         double part = 0.4*(edp_.th_max - edp_.th_min);
00300         // AIMD rule to keep target Q~1/2(th_min+th_max)
00301         if ( new_ave < edp_.th_min + part && edv_.cur_max_p > edp_.bottom) {
00302                 // we increase the average queue size, so decrease max_p
00303                 edv_.cur_max_p = edv_.cur_max_p * edp_.beta;
00304                 edv_.lastset = now;
00305         } else if (new_ave > edp_.th_max - part && edp_.top > edv_.cur_max_p ) {
00306                 // we decrease the average queue size, so increase max_p
00307                 double alpha = edp_.alpha;
00308                         if ( alpha > 0.25*edv_.cur_max_p )
00309                         alpha = 0.25*edv_.cur_max_p;
00310                 edv_.cur_max_p = edv_.cur_max_p + alpha;
00311                 edv_.lastset = now;
00312         } 
00313 }

void REDQueue::updateMaxPFeng (  double  new_ave  )  [protected, inherited]
 

Definition at line 274 of file red.cc.

References edv::Above, edp::alpha, edv::Below, edp::beta, edv::Between, edv::cur_max_p, REDQueue::edp_, REDQueue::edv_, edv::status, edp::th_max, and edp::th_min.

Referenced by REDQueue::estimator(). 

00275 {
00276         if ( edp_.th_min < new_ave && new_ave < edp_.th_max) {
00277                 edv_.status = edv_.Between;
00278         }
00279         if (new_ave < edp_.th_min && edv_.status != edv_.Below) {
00280                 edv_.status = edv_.Below;
00281                 edv_.cur_max_p = edv_.cur_max_p / edp_.alpha;
00282                 //double max = edv_.cur_max_p; double param = edp_.alpha;
00283                 //printf("max: %5.2f alpha: %5.2f\n", max, param);
00284         }
00285         if (new_ave > edp_.th_max && edv_.status != edv_.Above) {
00286                 edv_.status = edv_.Above;
00287                 edv_.cur_max_p = edv_.cur_max_p * edp_.beta;
00288                 //double max = edv_.cur_max_p; double param = edp_.alpha;
00289                 //printf("max: %5.2f beta: %5.2f\n", max, param);
00290         }
00291 }

template<class T>
void Queue< T >::updateStats (  int  queuesize  )  [virtual, inherited]
 

Definition at line 141 of file queue.cc.

References Scheduler::clock(), Scheduler::instance(), Queue< T >::total_time_, and Queue< T >::true_ave_.

Referenced by REDQueue::deque(), DropTail::deque(), REDQueue::enque(), and DropTail::enque(). 

00142 {
00143         double now = Scheduler::instance().clock();
00144         double newtime = now - total_time_;
00145         if (newtime > 0.0) {
00146                 double oldave = true_ave_;
00147                 double oldtime = total_time_;
00148                 double newtime = now - total_time_;
00149                 true_ave_ = (oldtime * oldave + newtime * queuesize) /now;
00150                 total_time_ = now;
00151         }
00152 }

Here is the call graph for this function:

template<class T>
double Queue< T >::utilization (  void   )  [virtual, inherited]
 

Definition at line 130 of file queue.cc.

References Queue< T >::blocked_, Scheduler::clock(), Scheduler::instance(), Queue< T >::last_change_, Queue< T >::old_util_, and Queue< T >::utilUpdate().

Referenced by QSAgent::recv(). 

00131 {
00132         double now = Scheduler::instance().clock();
00133         
00134         utilUpdate(last_change_, now, blocked_);
00135         last_change_ = now;
00136 
00137         return old_util_;
00138                         
00139 }

Here is the call graph for this function:

template<class T>
void Queue< T >::utilUpdate (  double  int_begin,
double  int_end,
int  link_state
)  [protected, inherited]
 

Definition at line 122 of file queue.cc.

References Queue< T >::old_util_, and Queue< T >::util_weight_.

Referenced by Queue< T >::recv(), Queue< T >::resume(), and Queue< T >::utilization(). 

00122                                                                        {
00123 double decay;
00124 
00125         decay = exp(-util_weight_ * (int_end - int_begin));
00126         old_util_ = link_state + (old_util_ - link_state) * decay;
00127 
00128 }

Member Data Documentation

template<class T>
int Queue< T >::blocked_ [protected, inherited]
 

Definition at line 143 of file queue.h.

Referenced by Queue< T >::block(), Queue< T >::blocked(), Queue< T >::Queue(), Queue< T >::recv(), FQ::recv(), CBQueue::recv(), PriQueue::recvHighPriority(), Queue< T >::resume(), CBQueue::sched(), Queue< T >::unblock(), and Queue< T >::utilization().

TracedInt REDQueue::curq_ [protected, inherited]
 

Definition at line 179 of file red.h.

Referenced by RIOQueue::enque(), REDQueue::enque(), and REDQueue::REDQueue().

NsObject* REDQueue::de_drop_ [protected, inherited]
 

Definition at line 170 of file red.h.

Referenced by REDQueue::command(), RedPDQueue::command(), RIOQueue::enque(), and REDQueue::enque().

int NsObject::debug_ [protected, inherited]
 

Reimplemented in FECModel, FloodAgent, and LandmarkAgent.

Definition at line 66 of file object.h.

Referenced by REDQueue::command(), RedPDQueue::command(), PushbackQueue::command(), NsObject::debug(), NsObject::delay_bind_dispatch(), RedPDQueue::enque(), PushbackQueue::enque(), NsObject::isdebug(), NsObject::NsObject(), TfrcAgent::recv(), PushbackQueue::reportDrop(), and REDQueue::reset().

int REDQueue::doubleq_ [protected, inherited]
 

Definition at line 192 of file red.h.

int REDQueue::dqthresh_ [protected, inherited]
 

Definition at line 193 of file red.h.

NsObject* Connector::drop_ [protected, inherited]
 

Definition at line 57 of file connector.h.

Referenced by Connector::command(), Connector::drop(), and ErrorModel::recv().

int REDQueue::drop_front_ [protected, inherited]
 

Definition at line 186 of file red.h.

Referenced by REDQueue::pickPacketToDrop(), and REDQueue::REDQueue().

int REDQueue::drop_rand_ [protected, inherited]
 

Definition at line 187 of file red.h.

Referenced by REDQueue::pickPacketToDrop(), and REDQueue::REDQueue().

int REDQueue::drop_tail_ [protected, inherited]
 

Definition at line 185 of file red.h.

Referenced by REDQueue::REDQueue().

edp REDQueue::edp_ [protected, inherited]
 

Definition at line 191 of file red.h.

Referenced by REDQueue::command(), REDQueue::drop_early(), RIOQueue::drop_in_early(), RIOQueue::drop_out_early(), RIOQueue::enque(), REDQueue::enque(), RedPDQueue::enque(), PushbackQueue::enque(), REDQueue::estimator(), REDQueue::initialize_params(), REDQueue::print_edp(), REDQueue::REDQueue(), RIOQueue::reset(), REDQueue::reset(), REDQueue::run_estimator(), REDQueue::updateMaxP(), and REDQueue::updateMaxPFeng().

edp_rio RIOQueue::edp_in_ [protected, inherited]
 

Definition at line 113 of file rio.h.

Referenced by RIOQueue::drop_in_early(), RIOQueue::enque(), RIOQueue::print_edp(), RIOQueue::reset(), and RIOQueue::RIOQueue().

edp_rio RIOQueue::edp_out_ [protected, inherited]
 

Definition at line 114 of file rio.h.

Referenced by RIOQueue::drop_out_early(), RIOQueue::enque(), RIOQueue::print_edp(), RIOQueue::reset(), and RIOQueue::RIOQueue().

NsObject* REDQueue::EDTrace [protected, inherited]
 

Definition at line 174 of file red.h.

Referenced by REDQueue::command(), and REDQueue::enque().

edv REDQueue::edv_ [protected, inherited]
 

Definition at line 200 of file red.h.

Referenced by REDQueue::drop_early(), RIOQueue::drop_out_early(), RIOQueue::enque(), REDQueue::enque(), RedPDQueue::enque(), PushbackQueue::enque(), REDQueue::estimator(), REDQueue::print_edp(), REDQueue::print_edv(), REDQueue::REDQueue(), REDQueue::reset(), REDQueue::run_estimator(), REDQueue::updateMaxP(), and REDQueue::updateMaxPFeng().

edv_rio RIOQueue::edv_in_ [protected, inherited]
 

Definition at line 123 of file rio.h.

Referenced by RIOQueue::drop_in_early(), RIOQueue::enque(), RIOQueue::print_edv(), RIOQueue::reset(), and RIOQueue::RIOQueue().

edv_rio RIOQueue::edv_out_ [protected, inherited]
 

Definition at line 124 of file rio.h.

Referenced by RIOQueue::drop_out_early(), RIOQueue::enque(), RIOQueue::print_edv(), RIOQueue::reset(), and RIOQueue::RIOQueue().

int REDQueue::fifo_ [protected, inherited]
 

Definition at line 164 of file red.h.

int REDQueue::first_reset_ [protected, inherited]
 

Definition at line 201 of file red.h.

template<class T>
QueueElem<T>* Queue< T >::head_ [protected, inherited]
 

Definition at line 416 of file mcache.h.

Referenced by Queue< T >::dequeue(), Queue< T >::destroy(), Queue< T >::detach(), Queue< T >::enqueue(), Queue< T >::getHead(), Queue< T >::Queue(), Queue< T >::reset(), and Queue< T >::~Queue().

int REDQueue::idle_ [protected, inherited]
 

Definition at line 198 of file red.h.

Referenced by REDQueue::deque(), RIOQueue::enque(), REDQueue::enque(), and REDQueue::reset().

double REDQueue::idletime_ [protected, inherited]
 

Definition at line 199 of file red.h.

Referenced by REDQueue::deque(), RIOQueue::enque(), REDQueue::enque(), REDQueue::print_edp(), and REDQueue::reset().

int RIOQueue::in_bcount_ [protected, inherited]
 

Definition at line 103 of file rio.h.

Referenced by RIOQueue::deque(), and RIOQueue::enque().

int RIOQueue::in_idle_ [protected, inherited]
 

Definition at line 120 of file rio.h.

Referenced by RIOQueue::deque(), RIOQueue::enque(), and RIOQueue::reset().

double RIOQueue::in_idletime_ [protected, inherited]
 

Definition at line 121 of file rio.h.

Referenced by RIOQueue::print_edp(), and RIOQueue::reset().

int RIOQueue::in_len_ [protected, inherited]
 

Definition at line 102 of file rio.h.

Referenced by RIOQueue::deque(), and RIOQueue::enque().

template<class T>
double Queue< T >::last_change_ [protected, inherited]
 

Definition at line 154 of file queue.h.

Referenced by Queue< T >::recv(), Queue< T >::resume(), and Queue< T >::utilization().

LinkDelay* REDQueue::link_ [protected, inherited]
 

Definition at line 163 of file red.h.

Referenced by REDQueue::command(), PushbackQueue::getBW(), REDQueue::reset(), and PushbackQueue::timeout().

int REDQueue::ns1_compat_ [protected, inherited]
 

Definition at line 188 of file red.h.

Referenced by RIOQueue::enque(), REDQueue::enque(), and REDQueue::REDQueue().

template<class T>
double Queue< T >::old_util_ [protected, inherited]
 

Definition at line 155 of file queue.h.

Referenced by Queue< T >::utilization(), and Queue< T >::utilUpdate().

template<class T>
PacketQueue* Queue< T >::pq_ [protected, inherited]
 

Definition at line 146 of file queue.h.

Referenced by Queue< T >::byteLength(), Vq::command(), REMQueue::command(), REDQueue::command(), PIQueue::command(), GK::command(), DropTail::command(), DropTail::DropTail(), GK::GK(), Queue< T >::length(), pickPacketForECN(), SemanticREDQueue::pickPacketForECN(), pickPacketToDrop(), SemanticREDQueue::pickPacketToDrop(), PIQueue::PIQueue(), REDQueue::REDQueue(), REMQueue::REMQueue(), and Vq::Vq().

int RIOQueue::priority_method_ [protected, inherited]
 

Definition at line 110 of file rio.h.

Referenced by RIOQueue::enque(), and RIOQueue::RIOQueue().

PacketQueue* REDQueue::q_ [protected, inherited]
 

Definition at line 165 of file red.h.

Referenced by REDQueue::bcount_(), REDQueue::command(), REDQueue::deque(), REDQueue::drop_early(), RIOQueue::enque(), REDQueue::enque(), RedPDQueue::enque(), PushbackQueue::enque(), REDQueue::pickPacketToDrop(), and REDQueue::REDQueue().

template<class T>
QueueHandler Queue< T >::qh_ [protected, inherited]
 

Definition at line 145 of file queue.h.

Referenced by Queue< T >::recv(), FQ::recv(), PriQueue::recvHighPriority(), Queue< T >::resume(), and CBQueue::sched().

int REDQueue::qib_ [protected, inherited]
 

Definition at line 169 of file red.h.

Referenced by REDQueue::deque(), REDQueue::drop_early(), RIOQueue::enque(), REDQueue::enque(), RedPDQueue::enque(), PushbackQueue::enque(), REDQueue::print_summarystats(), REDQueue::REDQueue(), RIOQueue::reset(), and REDQueue::reset().

template<class T>
int Queue< T >::qlim_ [protected, inherited]
 

Definition at line 142 of file queue.h.

Referenced by Vq::checkPacketForECN(), Vq::enque(), SRR::enque(), RIOQueue::enque(), REMQueue::enque(), REDQueue::enque(), PIQueue::enque(), Marker::enque(), JoBS::enque(), GK::enque(), DropTail::enque(), Demarker::enque(), Queue< T >::limit(), RIOQueue::print_edp(), REDQueue::print_edp(), Queue< T >::Queue(), and PriQueue::recvHighPriority().

template<class T>
int Queue< T >::size_ [protected, inherited]
 

Definition at line 417 of file mcache.h.

Referenced by Queue< T >::dequeue(), Queue< T >::detach(), Queue< T >::enqueue(), Queue< T >::is_empty(), Queue< T >::Queue(), and Queue< T >::size().

int REDQueue::summarystats_ [protected, inherited]
 

Definition at line 161 of file red.h.

Referenced by REDQueue::deque(), REDQueue::enque(), and REDQueue::REDQueue().

template<class T>
QueueElem<T> * Queue< T >::tail_ [protected, inherited]
 

Definition at line 416 of file mcache.h.

Referenced by Queue< T >::dequeue(), Queue< T >::detach(), Queue< T >::enqueue(), and Queue< T >::Queue().

NsObject* Connector::target_ [protected, inherited]
 

Definition at line 56 of file connector.h.

Referenced by SRAgent::command(), SA_Agent::command(), IvsReceiver::command(), MultiFieldFilter::command(), Filter::command(), Connector::command(), DiffusionAgent::DiffusionAgent(), DSRAgent::DSRAgent(), PromotionTimer::expire(), FloodingAgent::FloodingAgent(), toraAgent::forward(), AODV::forward(), LandmarkAgent::ForwardPacket(), DSDV_Agent::forwardPacket(), SensorQueryAgent::generate_query(), DSDVTriggerHandler::handle(), AckRecons::handle(), DSRAgent::handlePacketReceipt(), DSDV_Agent::helper_callback(), AODV::initialized(), DSDV_Agent::lost_link(), OmniMcastAgent::OmniMcastAgent(), LandmarkAgent::periodic_callback(), LandmarkAgent::ProcessHierUpdate(), TCPTapAgent::processpkt(), IPTapAgent::processpkt(), CMUPriQueue::prq_enqueue(), CMUPriQueue::prq_resume(), DequeTrace::recv(), Trace::recv(), TraceIpMac::recv(), TraceIp::recv(), TBF::recv(), SRMAgent::recv(), SSMSRMAgent::recv(), SatDequeTrace::recv(), SAack_Agent::recv(), Queue< T >::recv(), PingResponder::recv(), MIPEncapsulator::recv(), LmsAgent::recv(), HackLossyLink::recv(), GAFPartner::recv(), FQ::recv(), FloodAgent::recv(), ErrorModel::recv(), DynamicLink::recv(), DumbAgent::recv(), DSRAgent::recv(), DelayModel::recv(), LinkDelay::recv(), CtrMcastDecap::recv(), CtrMcastEncap::recv(), CMUTrace::recv(), PriQueue::recvHighPriority(), Trace::recvOnly(), TapAgent::recvpkt(), Queue< T >::resume(), LinkDelay::send(), Connector::send(), Agent::send(), MIPBSAgent::send_ads(), SRMAgent::send_ctrl(), SSMSRMAgent::send_ctrl(), MFTPSndAgent::send_data(), LmsSender::send_dmcast(), LmsReceiver::send_dmcast(), LmsAgent::send_downstream(), SSMSRMAgent::send_glb_sess(), LmsSender::send_lms_pkt(), SSMSRMAgent::send_loc_sess(), MFTPRcvAgent::send_nak(), LmsReceiver::send_nak(), LmsReceiver::send_refresh(), SSMSRMAgent::send_rep_sess(), SRMAgent::send_sess(), MIPMHAgent::send_sols(), LmsSender::send_spm(), MFTPSndAgent::send_status_request(), LmsAgent::send_upstream(), LandmarkAgent::SendChangedTagListUpdate(), AODV::sendError(), AODV::sendHello(), UdpAgent::sendmsg(), SRMAgent::sendmsg(), SA_Agent::sendmsg(), RTPAgent::sendmsg(), LmsSender::sendmsg(), DSDV_Agent::sendOutBCastPkt(), SA_Agent::sendpkt(), rtProtoDV::sendpkt(), RTPAgent::sendpkt(), RTCPAgent::sendpkt(), IvsSource::sendpkt(), AODV::sendReply(), AODV::sendRequest(), LmsSender::solicit_naks(), Connector::target(), TBF::timeout(), and toraAgent::tora_output().

Tcl_Channel REDQueue::tchan_ [protected, inherited]
 

Definition at line 178 of file red.h.

Referenced by REDQueue::command(), RIOQueue::trace(), and REDQueue::trace().

template<class T>
double Queue< T >::total_time_ [protected, inherited]
 

Definition at line 150 of file queue.h.

Referenced by REDQueue::print_summarystats(), DropTail::print_summarystats(), Queue< T >::reset(), and Queue< T >::updateStats().

char REDQueue::traceType[20] [protected, inherited]
 

Definition at line 175 of file red.h.

Referenced by REDQueue::command(), and REDQueue::REDQueue().

template<class T>
double Queue< T >::true_ave_ [protected, inherited]
 

Definition at line 149 of file queue.h.

Referenced by REDQueue::print_summarystats(), DropTail::print_summarystats(), Queue< T >::reset(), and Queue< T >::updateStats().

template<class T>
int Queue< T >::unblock_on_resume_ [protected, inherited]
 

Definition at line 144 of file queue.h.

Referenced by Queue< T >::Queue(), and Queue< T >::resume().

template<class T>
double Queue< T >::util_weight_ [protected, inherited]
 

Definition at line 156 of file queue.h.

Referenced by Queue< T >::Queue(), and Queue< T >::utilUpdate().

The documentation for this class was generated from the following file:
Generated on Tue Apr 20 13:21:45 2004 for NS2.26SourcesOriginal by doxygen 1.3.3