SemanticREDQueue Class Reference

Inheritance diagram for SemanticREDQueue:

[legend]Collaboration diagram for SemanticREDQueue:

[legend]List of all members.

Public Member Functions
	SemanticREDQueue ()
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
int	command (int argc, const char *const *argv)
void	enque (Packet *pkt)
Packet *	deque ()
void	initialize_params ()
void	reset ()
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	trace (TracedVar *)
void	print_edp ()
void	print_edv ()
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	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

SemanticREDQueue::SemanticREDQueue (   )  [inline]

Definition at line 14 of file semantic-red.cc. : REDQueue() {}

---

Member Function Documentation

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

Definition at line 167 of file red.h. References PacketQueue::byteLength(), and REDQueue::q_. { 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_. { 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(). { 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_. { 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(). { double p = calculate_p_new(v_ave, th_max, gentle, v_a, v_b, v_c, v_d, 1.0 / max_p_inv); return p; }

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(). { double p; if (gentle && v_ave >= th_max) { // p ranges from max_p to 1 as the average queue // size ranges from th_max to twice th_max p = v_c * v_ave + v_d; } else { // p ranges from 0 to max_p as the average queue // size ranges from th_min to th_max p = v_a * v_ave + v_b; p *= max_p; } if (p > 1.0) p = 1.0; return p; }

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(). { Tcl& tcl = Tcl::instance(); if (argc == 2) { if (strcmp(argv[1], "reset") == 0) { reset(); return (TCL_OK); } if (strcmp(argv[1], "early-drop-target") == 0) { if (de_drop_ != NULL) tcl.resultf("%s", de_drop_->name()); return (TCL_OK); } if (strcmp(argv[1], "edrop-trace") == 0) { if (EDTrace != NULL) { tcl.resultf("%s", EDTrace->name()); if (debug_) printf("edrop trace exists according to RED\n"); } else { if (debug_) printf("edrop trace doesn't exist according to RED\n"); tcl.resultf("0"); } return (TCL_OK); } if (strcmp(argv[1], "trace-type") == 0) { tcl.resultf("%s", traceType); return (TCL_OK); } if (strcmp(argv[1], "printstats") == 0) { print_summarystats(); return (TCL_OK); } } else if (argc == 3) { // attach a file for variable tracing if (strcmp(argv[1], "attach") == 0) { int mode; const char* id = argv[2]; tchan_ = Tcl_GetChannel(tcl.interp(), (char*)id, &mode); if (tchan_ == 0) { tcl.resultf("RED: trace: can't attach %s for writing", id); return (TCL_ERROR); } return (TCL_OK); } // tell RED about link stats if (strcmp(argv[1], "link") == 0) { LinkDelay* del = (LinkDelay*)TclObject::lookup(argv[2]); if (del == 0) { tcl.resultf("RED: no LinkDelay object %s", argv[2]); return(TCL_ERROR); } // set ptc now link_ = del; edp_.ptc = link_->bandwidth() / (8. * edp_.mean_pktsize); edp_.delay = link_->delay(); if ( (edp_.q_w <= 0.0 || edp_.th_min_pkts == 0 || edp_.th_max_pkts == 0)) initialize_params(); return (TCL_OK); } if (strcmp(argv[1], "early-drop-target") == 0) { NsObject* p = (NsObject*)TclObject::lookup(argv[2]); if (p == 0) { tcl.resultf("no object %s", argv[2]); return (TCL_ERROR); } de_drop_ = p; return (TCL_OK); } if (strcmp(argv[1], "edrop-trace") == 0) { if (debug_) printf("Ok, Here\n"); NsObject * t = (NsObject *)TclObject::lookup(argv[2]); if (debug_) printf("Ok, Here too\n"); if (t == 0) { tcl.resultf("no object %s", argv[2]); return (TCL_ERROR); } EDTrace = t; if (debug_) printf("Ok, Here too too too %d\n", ((Trace *)EDTrace)->type_); return (TCL_OK); } if (!strcmp(argv[1], "packetqueue-attach")) { delete q_; if (!(q_ = (PacketQueue*) TclObject::lookup(argv[2]))) return (TCL_ERROR); else { pq_ = q_; return (TCL_OK); } } } return (Queue::command(argc, argv)); }

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_. { if (!debug_) return; va_list ap; va_start(ap, fmt); vprintf(fmt, ap); }

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(). { if (delay_bind_bool(varName, localName, "debug_", &debug_, tracer)) return TCL_OK; return TclObject::delay_bind_dispatch(varName, localName, tracer); }

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(). { delay_bind_init_one("debug_"); }

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

Implements Queue< T >. Reimplemented in RIOQueue. Definition at line 344 of file red.cc. References PacketQueue::byteLength(), Scheduler::clock(), PacketQueue::deque(), REDQueue::idle_, REDQueue::idletime_, Scheduler::instance(), PacketQueue::length(), REDQueue::q_, REDQueue::qib_, REDQueue::summarystats_, and Queue< T >::updateStats(). Referenced by RIOQueue::deque(). { Packet *p; if (summarystats_ && &Scheduler::instance() != NULL) { Queue::updateStats(qib_?q_->byteLength():q_->length()); } p = q_->deque(); if (p != 0) { idle_ = 0; } else { idle_ = 1; // deque() may invoked by Queue::reset at init // time (before the scheduler is instantiated). // deal with this case if (&Scheduler::instance() != NULL) idletime_ = Scheduler::instance().clock(); else idletime_ = 0.0; } return (p); }

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(). { QueueElem<T> *p = head_; if (head_ != 0) head_ = head_->next(); if (head_ == 0) tail_ = 0; p->next_ = 0; size_--; if (size_ == 0) assert((head_ == 0) && (tail_ == 0)); return p; }

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(). { QueueElem<T> *p = head_, *q; while (p != NULL) { q = p; p = p->next(); delete q->data(); delete q; } head_ = NULL; }

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(). { assert(head_ != 0); if (head_ == e) { dequeue(); return; } QueueElem<T> *p = head_; while (p != NULL) { if (p->next_ != e) p = p->next_; else break; } assert(p != NULL); p->next_ = e->next_; if (tail_ == e) tail_ = p; size_--; if (size_ == 0) assert((head_ == 0) && (tail_ == 0)); }

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(). { if (drop_ != 0) drop_->recv(p, s); else Packet::free(p); }

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(). { if (drop_ != 0) drop_->recv(p); else Packet::free(p); }

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(). { hdr_cmn* ch = hdr_cmn::access(pkt); edv_.v_prob1 = calculate_p_new(edv_.v_ave, edp_.th_max, edp_.gentle, edv_.v_a, edv_.v_b, edv_.v_c, edv_.v_d, edv_.cur_max_p); edv_.v_prob = modify_p(edv_.v_prob1, edv_.count, edv_.count_bytes, edp_.bytes, edp_.mean_pktsize, edp_.wait, ch->size()); // drop probability is computed, pick random number and act if (edp_.cautious == 1) { // Don't drop/mark if the instantaneous queue is much // below the average. // For experimental purposes only. int qsize = qib_?q_->byteLength():q_->length(); // pkts: the number of packets arriving in 50 ms double pkts = edp_.ptc * 0.05; double fraction = pow( (1-edp_.q_w), pkts); // double fraction = 0.9; if ((double) qsize < fraction * edv_.v_ave) { // queue could have been empty for 0.05 seconds // printf("fraction: %5.2f\n", fraction); return (0); } } double u = Random::uniform(); if (edp_.cautious == 2) { // Decrease the drop probability if the instantaneous // queue is much below the average. // For experimental purposes only. int qsize = qib_?q_->byteLength():q_->length(); // pkts: the number of packets arriving in 50 ms double pkts = edp_.ptc * 0.05; double fraction = pow( (1-edp_.q_w), pkts); // double fraction = 0.9; double ratio = qsize / (fraction * edv_.v_ave); if (ratio < 1.0) { // printf("ratio: %5.2f\n", ratio); u *= 1.0 / ratio; } } if (u <= edv_.v_prob) { // DROP or MARK edv_.count = 0; edv_.count_bytes = 0; hdr_flags* hf = hdr_flags::access(pickPacketForECN(pkt)); if (edp_.setbit && hf->ect() && edv_.v_prob1 < edp_.mark_p) { hf->ce() = 1; // mark Congestion Experienced bit // Tell the queue monitor here - call emark(pkt) return (0); // no drop } else { return (1); // drop } } return (0); // no DROP/mark }

Here is the call graph for this function:

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

Implements Queue< T >. Reimplemented in PushbackQueue, RedPDQueue, and RIOQueue. Definition at line 552 of file red.cc. References hdr_cmn::access(), PacketQueue::byteLength(), edp::cautious, Scheduler::clock(), edv::count, edv::count_bytes, REDQueue::curq_, REDQueue::de_drop_, Connector::drop(), REDQueue::drop_early(), DTYPE_FORCED, DTYPE_NONE, DTYPE_UNFORCED, REDQueue::edp_, REDQueue::EDTrace, REDQueue::edv_, PacketQueue::enque(), REDQueue::estimator(), edp::gentle, REDQueue::idle_, edp::idle_pktsize, REDQueue::idletime_, Scheduler::instance(), PacketQueue::length(), edp::mean_pktsize, REDQueue::ns1_compat_, edv::old, REDQueue::pickPacketForECN(), REDQueue::pickPacketToDrop(), edp::ptc, REDQueue::q_, edp::q_w, REDQueue::qib_, Queue< T >::qlim_, NsObject::recv(), PacketQueue::remove(), REDQueue::reportDrop(), hdr_cmn::size(), REDQueue::summarystats_, edp::th_max, edp::th_min, Queue< T >::updateStats(), edv::v_ave, and edv::v_prob. Referenced by RedPDQueue::enque(), and PushbackQueue::enque(). { /* * if we were idle, we pretend that m packets arrived during * the idle period. m is set to be the ptc times the amount * of time we've been idle for */ int m = 0; if (idle_) { // A packet that arrives to an idle queue will never // be dropped. double now = Scheduler::instance().clock(); /* To account for the period when the queue was empty. */ idle_ = 0; // Use idle_pktsize instead of mean_pktsize, for // a faster response to idle times. if (edp_.cautious == 3) { double ptc = edp_.ptc * edp_.mean_pktsize / edp_.idle_pktsize; m = int(ptc * (now - idletime_)); } else m = int(edp_.ptc * (now - idletime_)); } /* * Run the estimator with either 1 new packet arrival, or with * the scaled version above [scaled by m due to idle time] */ edv_.v_ave = estimator(qib_ ? q_->byteLength() : q_->length(), m + 1, edv_.v_ave, edp_.q_w); //printf("v_ave: %6.4f (%13.12f) q: %d)\n", // double(edv_.v_ave), double(edv_.v_ave), q_->length()); if (summarystats_) { /* compute true average queue size for summary stats */ Queue::updateStats(qib_?q_->byteLength():q_->length()); } /* * count and count_bytes keeps a tally of arriving traffic * that has not been dropped (i.e. how long, in terms of traffic, * it has been since the last early drop) */ hdr_cmn* ch = hdr_cmn::access(pkt); ++edv_.count; edv_.count_bytes += ch->size(); /* * DROP LOGIC: * q = current q size, ~q = averaged q size * 1> if ~q > maxthresh, this is a FORCED drop * 2> if minthresh < ~q < maxthresh, this may be an UNFORCED drop * 3> if (q+1) > hard q limit, this is a FORCED drop */ register double qavg = edv_.v_ave; int droptype = DTYPE_NONE; int qlen = qib_ ? q_->byteLength() : q_->length(); int qlim = qib_ ? (qlim_ * edp_.mean_pktsize) : qlim_; curq_ = qlen; // helps to trace queue during arrival, if enabled if (qavg >= edp_.th_min && qlen > 1) { if ((!edp_.gentle && qavg >= edp_.th_max) || (edp_.gentle && qavg >= 2 * edp_.th_max)) { droptype = DTYPE_FORCED; } else if (edv_.old == 0) { /* * The average queue size has just crossed the * threshold from below to above "minthresh", or * from above "minthresh" with an empty queue to * above "minthresh" with a nonempty queue. */ edv_.count = 1; edv_.count_bytes = ch->size(); edv_.old = 1; } else if (drop_early(pkt)) { droptype = DTYPE_UNFORCED; } } else { /* No packets are being dropped. */ edv_.v_prob = 0.0; edv_.old = 0; } if (qlen >= qlim) { // see if we've exceeded the queue size droptype = DTYPE_FORCED; } if (droptype == DTYPE_UNFORCED) { /* pick packet for ECN, which is dropping in this case */ Packet *pkt_to_drop = pickPacketForECN(pkt); /* * If the packet picked is different that the one that just arrived, * add it to the queue and remove the chosen packet. */ if (pkt_to_drop != pkt) { q_->enque(pkt); q_->remove(pkt_to_drop); pkt = pkt_to_drop; /* XXX okay because pkt is not needed anymore */ } // deliver to special "edrop" target, if defined if (de_drop_ != NULL) { //trace first if asked // if no snoop object (de_drop_) is defined, // this packet will not be traced as a special case. if (EDTrace != NULL) ((Trace *)EDTrace)->recvOnly(pkt); reportDrop(pkt); de_drop_->recv(pkt); } else { reportDrop(pkt); drop(pkt); } } else { /* forced drop, or not a drop: first enqueue pkt */ q_->enque(pkt); /* drop a packet if we were told to */ if (droptype == DTYPE_FORCED) { /* drop random victim or last one */ pkt = pickPacketToDrop(); q_->remove(pkt); reportDrop(pkt); drop(pkt); if (!ns1_compat_) { // bug-fix from Philip Liu, <phill@ece.ubc.ca> edv_.count = 0; edv_.count_bytes = 0; } } } return; }

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(). { if (tail_ == 0) head_ = tail_ = e; else { tail_->append(e); tail_ = e; } size_++; }

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(). { double new_ave, old_ave; new_ave = ave; while (--m >= 1) { new_ave *= 1.0 - q_w; } old_ave = new_ave; new_ave *= 1.0 - q_w; new_ave += q_w * nqueued; double now = Scheduler::instance().clock(); if (edp_.adaptive == 1) { if (edp_.feng_adaptive == 1) updateMaxPFeng(new_ave); else if (now > edv_.lastset + edp_.interval) updateMaxP(new_ave, now); } return new_ave; }

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(). { 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(). { recv((Packet*)e); }

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(). { /* * If q_weight=0, set it to a reasonable value of 1-exp(-1/C) * This corresponds to choosing q_weight to be of that value for * which the packet time constant -1/ln(1-q_weight) per default RTT * of 100ms is an order of magnitude more than the link capacity, C. * * If q_weight=-1, then the queue weight is set to be a function of * the bandwidth and the link propagation delay. In particular, * the default RTT is assumed to be three times the link delay and * transmission delay, if this gives a default RTT greater than 100 ms. * * If q_weight=-2, set it to a reasonable value of 1-exp(-10/C). */ if (edp_.q_w == 0.0) { edp_.q_w = 1.0 - exp(-1.0/edp_.ptc); } else if (edp_.q_w == -1.0) { double rtt = 3.0*(edp_.delay+1.0/edp_.ptc); //printf("delay: %5.4f rtt: %5.4f\n", edp_.delay, rtt); if (rtt < 0.1) rtt = 0.1; edp_.q_w = 1.0 - exp(-1.0/(10*rtt*edp_.ptc)); } else if (edp_.q_w == -2.0) { edp_.q_w = 1.0 - exp(-10.0/edp_.ptc); } // printf("ptc: %7.5f bandwidth: %5.3f pktsize: %d\n", edp_.ptc, link_->bandwidth(), edp_.mean_pktsize); // printf("th_min_pkts: %7.5f th_max_pkts: %7.5f\n", edp_.th_min_pkts, edp_.th_max); if (edp_.th_min_pkts == 0) { edp_.th_min_pkts = 5.0; // set th_min_pkts to half of targetqueue, if this is greater // than 5 packets. double targetqueue = edp_.targetdelay * edp_.ptc; if (edp_.th_min_pkts < targetqueue / 2.0 ) edp_.th_min_pkts = targetqueue / 2.0 ; } if (edp_.th_max_pkts == 0) edp_.th_max_pkts = 3.0 * edp_.th_min_pkts; //printf("th_min_pkts: %7.5f th_max_pkts: %7.5f\n", edp_.th_min_pkts, edp_.th_max); //printf("q_w: %7.5f\n", edp_.q_w); }

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(). { return (size_ == 0); }

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

Definition at line 61 of file object.h. References NsObject::debug_. { 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(). { 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(). { 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(). { double count1 = (double) count; if (bytes) count1 = (double) (count_bytes/mean_pktsize); if (wait) { if (count1 * p < 1.0) p = 0.0; else if (count1 * p < 2.0) p /= (2 - count1 * p); else p = 1.0; } else { if (count1 * p < 1.0) p /= (1.0 - count1 * p); else p = 1.0; } if (bytes && p < 1.0) { p = p * size / mean_pktsize; } if (p > 1.0) p = 1.0; return p; }

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

Reimplemented from REDQueue. Definition at line 18 of file semantic-red.cc. References Queue< T >::pq_. { return(((SemanticPacketQueue*) pq_)->pickPacketForECN(pkt)); }

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

Reimplemented from REDQueue. Definition at line 15 of file semantic-red.cc. References Queue< T >::pq_. { return(((SemanticPacketQueue*) pq_)->pickPacketToDrop()); }

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

Reimplemented in RIOQueue. Definition at line 835 of file red.cc. References edp::bytes, edv::cur_max_p, REDQueue::edp_, REDQueue::edv_, REDQueue::idletime_, edp::mean_pktsize, edp::ptc, edp::q_w, Queue< T >::qlim_, edp::setbit, edp::th_max, edp::th_min, and edp::wait. Referenced by RIOQueue::print_edp(), and REDQueue::REDQueue(). { printf("mean_pktsz: %d\n", edp_.mean_pktsize); printf("bytes: %d, wait: %d, setbit: %d\n", edp_.bytes, edp_.wait, edp_.setbit); printf("minth: %f, maxth: %f\n", edp_.th_min, edp_.th_max); printf("max_p: %f, qw: %f, ptc: %f\n", (double) edv_.cur_max_p, edp_.q_w, edp_.ptc); printf("qlim: %d, idletime: %f\n", qlim_, idletime_); printf("=========\n"); }

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

Reimplemented in RIOQueue. Definition at line 847 of file red.cc. References REDQueue::edv_, edv::v_a, and edv::v_b. Referenced by RIOQueue::print_edv(), and REDQueue::REDQueue(). { printf("v_a: %f, v_b: %f\n", edv_.v_a, edv_.v_b); }

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(). { //double now = Scheduler::instance().clock(); printf("True average queue: %5.3f", true_ave_); if (qib_) printf(" (in bytes)"); printf(" time: %5.3f\n", total_time_); }

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

Reimplemented in CMUTrace. Definition at line 96 of file object.cc. References Packet::free(). { Packet::free(p); }

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(). { double now = Scheduler::instance().clock(); enque(p); if (!blocked_) { /* * We're not blocked. Get a packet and send it on. * We perform an extra check because the queue * might drop the packet even if it was * previously empty! (e.g., RED can do this.) */ p = deque(); if (p != 0) { utilUpdate(last_change_, now, blocked_); last_change_ = now; blocked_ = 1; target_->recv(p, &qh_); } } }

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(). {};

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(). {} //pushback

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

Reimplemented from Queue< T >. Reimplemented in RedPDQueue, and RIOQueue. Definition at line 210 of file red.cc. References LinkDelay::bandwidth(), Scheduler::clock(), edv::count, edv::count_bytes, edv::cur_max_p, NsObject::debug_, REDQueue::edp_, REDQueue::edv_, edp::gentle, REDQueue::idle_, REDQueue::idletime_, REDQueue::initialize_params(), Scheduler::instance(), edv::lastset, REDQueue::link_, edp::max_p_inv, edp::mean_pktsize, edv::old, edp::ptc, REDQueue::qib_, Queue< T >::reset(), edp::th_max, edp::th_max_pkts, edp::th_min, edp::th_min_pkts, edv::v_a, edv::v_ave, edv::v_b, edv::v_c, edv::v_d, and edv::v_slope. Referenced by REDQueue::command(), RIOQueue::reset(), and RedPDQueue::reset(). { //printf("3: th_min_pkts: %5.2f\n", edp_.th_min_pkts); /* * Compute the "packet time constant" if we know the * link bandwidth. The ptc is the max number of (avg sized) * pkts per second which can be placed on the link. * The link bw is given in bits/sec, so scale mean psize * accordingly. */ if (link_) { edp_.ptc = link_->bandwidth() / (8. * edp_.mean_pktsize); initialize_params(); } if (edp_.th_max_pkts == 0) edp_.th_max_pkts = 3.0 * edp_.th_min_pkts; /* * If queue is measured in bytes, scale min/max thresh * by the size of an average packet (which is specified by user). */ if (qib_) { //printf("1: th_min in pkts: %5.2f mean_pktsize: %d \n", edp_.th_min_pkts, edp_.mean_pktsize); edp_.th_min = edp_.th_min_pkts * edp_.mean_pktsize; edp_.th_max = edp_.th_max_pkts * edp_.mean_pktsize; //printf("2: th_min in bytes (if qib): %5.2f mean_pktsize: %d \n", edp_.th_min, edp_.mean_pktsize); } else { edp_.th_min = edp_.th_min_pkts; edp_.th_max = edp_.th_max_pkts; } edv_.v_ave = 0.0; edv_.v_slope = 0.0; edv_.count = 0; edv_.count_bytes = 0; edv_.old = 0; edv_.v_a = 1 / (edp_.th_max - edp_.th_min); edv_.cur_max_p = 1.0 / edp_.max_p_inv; edv_.v_b = - edp_.th_min / (edp_.th_max - edp_.th_min); edv_.lastset = 0.0; if (edp_.gentle) { edv_.v_c = ( 1.0 - edv_.cur_max_p ) / edp_.th_max; edv_.v_d = 2 * edv_.cur_max_p - 1.0; } idle_ = 1; if (&Scheduler::instance() != NULL) idletime_ = Scheduler::instance().clock(); else idletime_ = 0.0; /* sched not instantiated yet */ if (debug_) printf("Doing a queue reset\n"); Queue::reset(); if (debug_) printf("Done queue reset\n"); }

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(). { double now = Scheduler::instance().clock(); Packet* p = deque(); if (p != 0) { target_->recv(p, &qh_); } else { if (unblock_on_resume_) { utilUpdate(last_change_, now, blocked_); last_change_ = now; blocked_ = 0; } else { utilUpdate(last_change_, now, blocked_); last_change_ = now; blocked_ = 1; } } }

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. { double f, f_sl, f_old; f = edv_.v_ave; f_sl = edv_.v_slope; #define RED_EWMA #ifdef RED_EWMA while (--m >= 1) { f_old = f; f *= 1.0 - edp_.q_w; } f_old = f; f *= 1.0 - edp_.q_w; f += edp_.q_w * nqueued; #endif #ifdef RED_HOLT_WINTERS while (--m >= 1) { f_old = f; f += f_sl; f *= 1.0 - edp_.q_w; f_sl *= 1.0 - 0.5 * edp_.q_w; f_sl += 0.5 * edp_.q_w * (f - f_old); } f_old = f; f += f_sl; f *= 1.0 - edp_.q_w; f += edp_.q_w * nqueued; f_sl *= 1.0 - 0.5 * edp_.q_w; f_sl += 0.5 * edp_.q_w * (f - f_old); #endif edv_.v_ave = f; edv_.v_slope = f_sl; }

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(). { 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(). { 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(). { return target_; }

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

Reimplemented in RIOQueue. Definition at line 803 of file red.cc. References Scheduler::clock(), Scheduler::instance(), and REDQueue::tchan_. Referenced by REDQueue::REDQueue(). { char wrk[500], *p; if (((p = strstr(v->name(), "ave")) == NULL) && ((p = strstr(v->name(), "prob")) == NULL) && ((p = strstr(v->name(), "curq")) == NULL) && ((p = strstr(v->name(), "cur_max_p"))==NULL) ) { fprintf(stderr, "RED:unknown trace var %s\n", v->name()); return; } if (tchan_) { int n; double t = Scheduler::instance().clock(); // XXX: be compatible with nsv1 RED trace entries if (strstr(v->name(), "curq") != NULL) { sprintf(wrk, "Q %g %d", t, int(*((TracedInt*) v))); } else { sprintf(wrk, "%c %g %g", *p, t, double(*((TracedDouble*) v))); } n = strlen(wrk); wrk[n] = '\n'; wrk[n+1] = 0; (void)Tcl_Write(tchan_, wrk, n+1); } return; }

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_. { 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(). { double part = 0.4*(edp_.th_max - edp_.th_min); // AIMD rule to keep target Q~1/2(th_min+th_max) if ( new_ave < edp_.th_min + part && edv_.cur_max_p > edp_.bottom) { // we increase the average queue size, so decrease max_p edv_.cur_max_p = edv_.cur_max_p * edp_.beta; edv_.lastset = now; } else if (new_ave > edp_.th_max - part && edp_.top > edv_.cur_max_p ) { // we decrease the average queue size, so increase max_p double alpha = edp_.alpha; if ( alpha > 0.25*edv_.cur_max_p ) alpha = 0.25*edv_.cur_max_p; edv_.cur_max_p = edv_.cur_max_p + alpha; edv_.lastset = now; } }

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(). { if ( edp_.th_min < new_ave && new_ave < edp_.th_max) { edv_.status = edv_.Between; } if (new_ave < edp_.th_min && edv_.status != edv_.Below) { edv_.status = edv_.Below; edv_.cur_max_p = edv_.cur_max_p / edp_.alpha; //double max = edv_.cur_max_p; double param = edp_.alpha; //printf("max: %5.2f alpha: %5.2f\n", max, param); } if (new_ave > edp_.th_max && edv_.status != edv_.Above) { edv_.status = edv_.Above; edv_.cur_max_p = edv_.cur_max_p * edp_.beta; //double max = edv_.cur_max_p; double param = edp_.alpha; //printf("max: %5.2f beta: %5.2f\n", max, param); } }

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(). { double now = Scheduler::instance().clock(); double newtime = now - total_time_; if (newtime > 0.0) { double oldave = true_ave_; double oldtime = total_time_; double newtime = now - total_time_; true_ave_ = (oldtime * oldave + newtime * queuesize) /now; total_time_ = now; } }

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(). { double now = Scheduler::instance().clock(); utilUpdate(last_change_, now, blocked_); last_change_ = now; return old_util_; }

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(). { double decay; decay = exp(-util_weight_ * (int_end - int_begin)); old_util_ = link_state + (old_util_ - link_state) * decay; }

---

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().

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().

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().

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(), SemanticRIOQueue::pickPacketForECN(), pickPacketForECN(), SemanticRIOQueue::pickPacketToDrop(), pickPacketToDrop(), PIQueue::PIQueue(), REDQueue::REDQueue(), REMQueue::REMQueue(), and Vq::Vq().

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:

• semantic-red.cc

---