NS2.26SourcesOriginal: DropTail class Reference

00049                    { 
00050                 q_ = new PacketQueue; 
00051                 pq_ = q_;
00052                 bind_bool("drop_front_", &drop_front_);
00053                 bind_bool("summarystats_", &summarystats);
00054                 bind_bool("queue_in_bytes_", &qib_);  // boolean: q in bytes?
00055                 bind("mean_pktsize_", &mean_pktsize_);
00056                 //              _RENAMED("drop-front_", "drop_front_");
00057         }

00058                     {
00059                 delete q_;
00060         }

00131 { blocked_ = 1; }

00129 { return (blocked_ == 1); }

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

00056                                                   {
00057 
00058         if (argc==2) {
00059                 if (strcmp(argv[1], "printstats") == 0) {
00060                         print_summarystats();
00061                         return (TCL_OK);
00062                 }
00063         }
00064         if (argc == 3) {
00065                 if (!strcmp(argv[1], "packetqueue-attach")) {
00066                         delete q_;
00067                         if (!(q_ = (PacketQueue*) TclObject::lookup(argv[2])))
00068                                 return (TCL_ERROR);
00069                         else {
00070                                 pq_ = q_;
00071                                 return (TCL_OK);
00072                         }
00073                 }
00074         }
00075         return Queue::command(argc, argv);
00076 }

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

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

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

00104 {
00105         if (summarystats && &Scheduler::instance() != NULL) {
00106                 Queue::updateStats(qib_?q_->byteLength():q_->length());
00107         }
00108         return q_->deque();
00109 }

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

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

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

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

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

00082 {
00083         if (summarystats) {
00084                 Queue::updateStats(qib_?q_->byteLength():q_->length());
00085         }
00086 
00087         int qlimBytes = qlim_ * mean_pktsize_;
00088         if ((!qib_ && (q_->length() + 1) >= qlim_) ||
00089         (qib_ && (q_->byteLength() + hdr_cmn::access(p)->size()) >= qlimBytes)){
00090                 // if the queue would overflow if we added this packet...
00091                 if (drop_front_) { /* remove from head of queue */
00092                         q_->enque(p);
00093                         Packet *pp = q_->deque();
00094                         drop(pp);
00095                 } else {
00096                         drop(p);
00097                 }
00098         } else {
00099                 q_->enque(p);
00100         }
00101 }

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

00411 { return head_; }

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

00412 { return (size_ == 0); }

00061 { return debug_; }

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

00132 { return qlim_; }

00112 {
00113         //double now = Scheduler::instance().clock();
00114         printf("True average queue: %5.3f", true_ave_);
00115         if (qib_)
00116                 printf(" (in bytes)");
00117         printf(" time: %5.3f\n", total_time_);
00118 }

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

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

00051 {
00052         Queue::reset();
00053 }

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

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

00413 { return size_; }

00048 { return target_; }

00130 { blocked_ = 0; }

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

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

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


Public Member Functions
	DropTail ()
	~DropTail ()
virtual void	recv (Packet , Handler )
virtual void	recv (Packet p, const char s)
virtual void	updateStats (int queuesize)
void	resume ()
int	blocked () const
void	unblock ()
void	block ()
int	limit ()
int	length ()
int	byteLength ()
virtual double	utilization (void)
virtual void	destroy ()
void	enqueue (QueueElem< T > *e)
QueueElem< T > *	dequeue ()
void	detach (QueueElem< T > *e)
QueueElem< T > *	getHead ()
int	is_empty () const
int	size () const
NsObject *	target ()
virtual void	drop (Packet *p)
virtual void	recvOnly (Packet *)
virtual void	delay_bind_init_all ()
virtual int	delay_bind_dispatch (const char varName, const char localName, TclObject *tracer)
int	isdebug () const
virtual void	debug (const char *fmt,...)
Protected Member Functions
void	reset ()
int	command (int argc, const char const argv)
void	enque (Packet *)
Packet *	deque ()
void	print_summarystats ()
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
PacketQueue *	q_
int	drop_front_
int	summarystats
int	qib_
int	mean_pktsize_
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_

DropTail Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation