00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037 #ifndef ns_queue_h
00038 #define ns_queue_h
00039
00040 #include "connector.h"
00041 #include "packet.h"
00042 #include "ip.h"
00043 class Packet;
00044
00045 class PacketQueue : public TclObject {
00046 public:
00047 PacketQueue() : head_(0), tail_(0), len_(0), bytes_(0) {}
00048 virtual int length() const { return (len_); }
00049 virtual int byteLength() const { return (bytes_); }
00050 virtual Packet* enque(Packet* p) {
00051 Packet* pt = tail_;
00052 if (!tail_) head_= tail_= p;
00053 else {
00054 tail_->next_= p;
00055 tail_= p;
00056 }
00057 tail_->next_= 0;
00058 ++len_;
00059 bytes_ += hdr_cmn::access(p)->size();
00060 return pt;
00061 }
00062 virtual Packet* deque() {
00063 if (!head_) return 0;
00064 Packet* p = head_;
00065 head_= p->next_;
00066 if (p == tail_) head_= tail_= 0;
00067 --len_;
00068 bytes_ -= hdr_cmn::access(p)->size();
00069 return p;
00070 }
00071 Packet* lookup(int n) {
00072 for (Packet* p = head_; p != 0; p = p->next_) {
00073 if (--n < 0)
00074 return (p);
00075 }
00076 return (0);
00077 }
00078
00079 virtual void remove(Packet*);
00080
00081 void remove(Packet *, Packet *);
00082 Packet* head() { return head_; }
00083 Packet* tail() { return tail_; }
00084
00085 virtual inline void enqueHead(Packet* p) {
00086 if (!head_) tail_ = p;
00087 p->next_ = head_;
00088 head_ = p;
00089 ++len_;
00090 bytes_ += hdr_cmn::access(p)->size();
00091 }
00092 void resetIterator() {iter = head_;}
00093 Packet* getNext() {
00094 if (!iter) return 0;
00095 Packet *tmp = iter; iter = iter->next_;
00096 return tmp;
00097 }
00098
00099 protected:
00100 Packet* head_;
00101 Packet* tail_;
00102 int len_;
00103 int bytes_;
00104
00105
00106
00107 private:
00108 Packet *iter;
00109 };
00110
00111 class Queue;
00112
00113 class QueueHandler : public Handler {
00114 public:
00115 inline QueueHandler(Queue& q) : queue_(q) {}
00116 void handle(Event*);
00117 private:
00118 Queue& queue_;
00119 };
00120
00121
00122 class Queue : public Connector {
00123 public:
00124 virtual void enque(Packet*) = 0;
00125 virtual Packet* deque() = 0;
00126 virtual void recv(Packet*, Handler*);
00127 virtual void updateStats(int queuesize);
00128 void resume();
00129
00130 int blocked() const { return (blocked_ == 1); }
00131 void unblock() { blocked_ = 0; }
00132 void block() { blocked_ = 1; }
00133 int limit() { return qlim_; }
00134 int length() { return pq_->length(); }
00135
00136 int byteLength() { return pq_->byteLength(); }
00137
00138
00139 virtual double utilization (void);
00140
00141
00142
00143 double peak_utilization(void);
00144 virtual ~Queue();
00145 protected:
00146 Queue();
00147 void reset();
00148 int qlim_;
00149 int blocked_;
00150 int unblock_on_resume_;
00151 QueueHandler qh_;
00152 PacketQueue *pq_;
00153
00154
00155 double true_ave_;
00156 double total_time_;
00157
00158
00159 void utilUpdate(double int_begin, double int_end, int link_state);
00160 double last_change_;
00161 double old_util_;
00162 double util_weight_;
00163 double util_check_intv_;
00164
00165 double period_begin_;
00166
00167 double cur_util_;
00168 int buf_slot_;
00169 double *util_buf_;
00170 int util_records_;
00171
00172
00173
00174
00175 };
00176
00177 #endif