PushbackQueue Class Reference

#include <pushback-queue.h>

Inheritance diagram for PushbackQueue:

[legend]Collaboration diagram for PushbackQueue:

[legend]List of all members.

Public Member Functions
	PushbackQueue (const char *const)
virtual void	reportDrop (Packet *pkt)
void	enque (Packet *p)
int	command (int, const char *const *)
void	timeout (int)
double	getBW ()
double	getRate ()
double	getDropRate ()
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,...)
Public Attributes
PushbackAgent *	pushback_
int	verbose_
RateLimitSessionList *	rlsList_
RateEstimator *	rateEstimator_
Protected Member Functions
virtual Packet *	pickPacketForECN (Packet *pkt)
virtual Packet *	pickPacketToDrop ()
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)
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	pushbackID_
int	src_
int	dst_
int	rate_limiting_
EDQueueMonitor *	qmon_
PushbackQueueTimer *	timer_
NsObject *	RLDropTrace_
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

PushbackQueue::PushbackQueue (  const char *  const  )

Definition at line 59 of file pushback-queue.cc. References PushbackAgent::last_index_, pushback_, pushbackID_, rate_limiting_, rateEstimator_, TimerHandler::resched(), rlsList_, SUSTAINED_CONGESTION_PERIOD, timer_, PushbackAgent::verbose_, and verbose_. : pushbackID_(-1), src_(-1), dst_(-1), qmon_(NULL), RLDropTrace_(NULL) { pushback_ = (PushbackAgent *)TclObject::lookup(pba); if (pushback_ == NULL) { printf("Wrong Argument for Pushback Queue Constructor\n"); exit(-1); } bind("pushbackID_", &pushbackID_); bind_bool("rate_limiting_", &rate_limiting_); verbose_ = pushback_->verbose_; timer_ = new PushbackQueueTimer(this); timer_->resched(SUSTAINED_CONGESTION_PERIOD); rateEstimator_=new RateEstimator(); rlsList_ = new RateLimitSessionList(); if (verbose_) printf("pushback queue instantiated %d\n",pushback_->last_index_); }

Here is the call graph for this function:

---

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 PushbackQueue::command (  int  , const char *const *  )  [virtual]

Reimplemented from REDQueue. Definition at line 91 of file pushback-queue.cc. References REDQueue::command(), NsObject::debug_, dst_, qmon_, RLDropTrace_, and src_. { Tcl& tcl = Tcl::instance(); if (argc==2) { if (strcmp(argv[1], "rldrop-trace") == 0) { if (RLDropTrace_ != NULL) { tcl.resultf("%s", RLDropTrace_->name()); } else { tcl.resultf("0"); } return (TCL_OK); } } else if (argc == 3) { if (strcmp(argv[1], "set-monitor") == 0) { qmon_ = (EDQueueMonitor *)TclObject::lookup(argv[2]); if (qmon_ == NULL) { tcl.resultf("Got Invalid Queue Monitor\n"); return TCL_ERROR; } return TCL_OK; } else if (strcmp(argv[1], "rldrop-trace") == 0) { RLDropTrace_ = (NsObject *) TclObject::lookup(argv[2]); if (RLDropTrace_ == NULL) { if (debug_) printf("Error Attaching Trace\n"); return (TCL_ERROR); } if (debug_) printf("PBQ: RLDropTrace Set to %s\n", RLDropTrace_->name()); return (TCL_OK); } } else if (argc == 4) { if (strcmp(argv[1], "set-src-dst") == 0) { src_ = atoi(argv[2]); dst_ = atoi(argv[3]); if (src_ < 0 || dst_ < 0) { tcl.resultf("Got Invalid Source or Destination\n"); return TCL_ERROR; } return TCL_OK; } } return REDQueue::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 PushbackQueue::enque (  Packet *  p  )  [virtual]

Reimplemented from REDQueue. Definition at line 193 of file pushback-queue.cc. References PacketQueue::byteLength(), NsObject::debug_, dst_, REDQueue::edp_, REDQueue::edv_, REDQueue::enque(), PacketQueue::enqueHead(), RateEstimator::estimateRate(), RateLimitSessionList::filter(), Packet::free(), getDropRate(), HDR_CMN, PacketQueue::length(), EDQueueMonitor::mon_edrop(), RateLimitSessionList::noSessions_, PT_PUSHBACK, hdr_cmn::ptype(), hdr_cmn::ptype_, REDQueue::q_, REDQueue::qib_, qmon_, rateEstimator_, RLDropTrace_, rlsList_, src_, TARGET_DROPRATE, edp::th_min, edv::v_ave, and verbose_. { hdr_cmn * hdr = HDR_CMN(p); if (debug_) printf("In queue enque with ptype %d %d\n", hdr->ptype(), PT_PUSHBACK); if (hdr->ptype_ == PT_PUSHBACK) { if (verbose_) printf("PBQ:(%d:%d). Got a pushback packet.\n",src_, dst_); q_->enqueHead(p); return; } int dropped = 0; //set lowDemand to 0 to switch off the low-demand feature. int qlen = qib_ ? q_->byteLength() : q_->length(); int lowDemand = (edv_.v_ave < edp_.th_min || qlen < 1 || getDropRate() < 0.1*TARGET_DROPRATE ); // lowDemand = 0; //this would // 1. check to see if a packet belongs to any of the aggregate being rate-limited // 2. if yes, log the packet and // 3. drop it if necessary (based on rate-limiting dynamics). // 4. dropped = 1, if dropped. if (rlsList_->noSessions_) dropped = rlsList_->filter(p, lowDemand); if (dropped) { //first trace the monitored early drop if (RLDropTrace_!= NULL) ((Trace *)RLDropTrace_)->recvOnly(p); qmon_->mon_edrop(p); //this is buggy. //this drop is not recorded by any other monitor attached to the link. Packet::free(p); return; } //estimate rate only for enqued packets (insignificant bw of pushback messages). //also counts packet not dropped because of low demand (minor effects to overall demand calculations I believe). rateEstimator_->estimateRate(p); REDQueue::enque(p); }

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:

double PushbackQueue::getBW (   )

Definition at line 247 of file pushback-queue.cc. References LinkDelay::bandwidth(), and REDQueue::link_. Referenced by getDropRate(), and PushbackAgent::pushbackRefresh(). { return link_->bandwidth(); }

Here is the call graph for this function:

double PushbackQueue::getDropRate (   )

Definition at line 252 of file pushback-queue.cc. References RateEstimator::estRate_, getBW(), and rateEstimator_. Referenced by enque(), and timeout(). { if (rateEstimator_->estRate_ < getBW()) { return 0; } else { return 1 - getBW()/rateEstimator_->estRate_; } }

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_; }

double PushbackQueue::getRate (   )

Definition at line 242 of file pushback-queue.cc. References RateEstimator::estRate_, and rateEstimator_. Referenced by PushbackAgent::pushbackRefresh(). { return rateEstimator_->estRate_; }

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 * REDQueue::pickPacketForECN (  Packet *  pkt  )  [protected, virtual, inherited]

Reimplemented in SemanticREDQueue, and SemanticRIOQueue. Definition at line 506 of file red.cc. Referenced by REDQueue::drop_early(), RIOQueue::drop_in_early(), RIOQueue::drop_out_early(), RIOQueue::enque(), and REDQueue::enque(). { return pkt; /* pick the packet that just arrived */ }

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

Reimplemented in SemanticREDQueue, and SemanticRIOQueue. Definition at line 517 of file red.cc. References REDQueue::drop_front_, REDQueue::drop_rand_, Random::integer(), PacketQueue::length(), PacketQueue::lookup(), min, and REDQueue::q_. Referenced by RIOQueue::enque(), and REDQueue::enque(). { int victim; if (drop_front_) victim = min(1, q_->length()-1); else if (drop_rand_) victim = Random::integer(q_->length()); else /* default is drop_tail_ */ victim = q_->length() - 1; return(q_->lookup(victim)); }

Here is the call graph for this function:

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

void PushbackQueue::reportDrop (  Packet *  pkt  )  [virtual]

Reimplemented from REDQueue. Definition at line 81 of file pushback-queue.cc. References NsObject::debug_, dst_, pushback_, pushbackID_, rate_limiting_, PushbackAgent::reportDrop(), and src_. { if (debug_) printf("PBQ:(%d:%d) rate limiting = %d\n", src_, dst_, rate_limiting_); if (rate_limiting_) pushback_->reportDrop(pushbackID_, p); }

Here is the call graph for this function:

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 PushbackQueue::timeout (  int   )

Definition at line 142 of file pushback-queue.cc. References LinkDelay::bandwidth(), QueueMonitor::barrivals(), QueueMonitor::bdepartures(), QueueMonitor::bdrops(), PushbackAgent::calculateLowerBound(), dst_, RateEstimator::estRate_, getDropRate(), PushbackAgent::identifyAggregate(), Scheduler::instance(), REDQueue::link_, LOWER_BOUND_MODE, EDQueueMonitor::mon_ebdrops(), PushbackAgent::node_, Node::nodeid(), RateLimitSessionList::noMySessions(), pushback_, pushbackID_, qmon_, rate_limiting_, rateEstimator_, TimerHandler::resched(), PushbackAgent::resetDropLog(), rlsList_, src_, SUSTAINED_CONGESTION_DROPRATE, SUSTAINED_CONGESTION_PERIOD, timer_, and verbose_. Referenced by PushbackQueueTimer::expire(). { int barrivals = qmon_->barrivals() - qmon_->mon_ebdrops(); int bdrops = qmon_->bdrops() - qmon_->mon_ebdrops(); int bdeps = qmon_->bdepartures(); // an alternate way of calculating this is using the arrivals and drops from above, // but the below is more accurate as RED avg queue takes time to come down and // hence drop rate goes down much slower. double dropRate1= getDropRate(); double dropRate2= ((double)bdrops/barrivals); if (dropRate1 > 0 || dropRate2 > 0) { if (verbose_) printf("PBQ:(%d:%d) (%g) arrs %d drops %d deps %d mdrops %d dr %g %g\n", src_, dst_, Scheduler::instance().clock(), barrivals*8, bdrops*8, bdeps*8, qmon_->mon_ebdrops()*8, dropRate1, dropRate2); fflush(stdout); } Tcl& tcl = Tcl::instance(); tcl.evalf("%s reset",qmon_->name()); if (rate_limiting_ && dropRate1 >= SUSTAINED_CONGESTION_DROPRATE && dropRate2 >= SUSTAINED_CONGESTION_DROPRATE/2) { if (verbose_) { printf("PBQ:(%d:%d) (%g) Arr: %d (%g) Drops: %d (%g %g) BW: %g\n", src_, dst_, Scheduler::instance().clock(), barrivals, rateEstimator_->estRate_, bdrops, dropRate1, dropRate2, link_->bandwidth()); fflush(stdout); } // this function call would // 1) start a rate limiting session, // 2) insert it in the queues rate limiting session list. // 3) will also set up appropriate timers. pushback_->identifyAggregate(pushbackID_, rateEstimator_->estRate_, link_->bandwidth()); } else if (rlsList_->noMySessions(pushback_->node_->nodeid()) && LOWER_BOUND_MODE == 1) { pushback_->calculateLowerBound(pushbackID_, rateEstimator_->estRate_); } //reset the drop history at the agent pushback_->resetDropLog(pushbackID_); timer_->resched(SUSTAINED_CONGESTION_PERIOD); }

Here is the call graph for this function:

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(), command(), NsObject::debug(), NsObject::delay_bind_dispatch(), RedPDQueue::enque(), enque(), NsObject::isdebug(), NsObject::NsObject(), TfrcAgent::recv(), 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().

int PushbackQueue::dst_ [protected]

Definition at line 74 of file pushback-queue.h. Referenced by command(), enque(), reportDrop(), and timeout().

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

PushbackAgent* PushbackQueue::pushback_

Definition at line 60 of file pushback-queue.h. Referenced by PushbackQueue(), reportDrop(), and timeout().

int PushbackQueue::pushbackID_ [protected]

Definition at line 72 of file pushback-queue.h. Referenced by PushbackQueue(), reportDrop(), and timeout().

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

EDQueueMonitor* PushbackQueue::qmon_ [protected]

Definition at line 76 of file pushback-queue.h. Referenced by command(), enque(), and timeout().

int PushbackQueue::rate_limiting_ [protected]

Definition at line 75 of file pushback-queue.h. Referenced by PushbackQueue(), reportDrop(), and timeout().

RateEstimator* PushbackQueue::rateEstimator_

Definition at line 69 of file pushback-queue.h. Referenced by enque(), getDropRate(), getRate(), PushbackQueue(), and timeout().

NsObject* PushbackQueue::RLDropTrace_ [protected]

Definition at line 79 of file pushback-queue.h. Referenced by command(), and enque().

RateLimitSessionList* PushbackQueue::rlsList_

Definition at line 68 of file pushback-queue.h. Referenced by enque(), PushbackAgent::identifyAggregate(), PushbackAgent::processPushbackCancel(), PushbackAgent::processPushbackRefresh(), PushbackAgent::processPushbackRequest(), PushbackAgent::processPushbackStatus(), PushbackQueue(), PushbackAgent::pushbackRefresh(), and timeout().

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 PushbackQueue::src_ [protected]

Definition at line 73 of file pushback-queue.h. Referenced by command(), enque(), reportDrop(), and timeout().

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

PushbackQueueTimer* PushbackQueue::timer_ [protected]

Definition at line 77 of file pushback-queue.h. Referenced by PushbackQueue(), and timeout().

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

int PushbackQueue::verbose_

Definition at line 66 of file pushback-queue.h. Referenced by enque(), PushbackQueue(), and timeout().

---

The documentation for this class was generated from the following files:

• pushback-queue.h
• pushback-queue.cc

---