NS2.26SourcesOriginal: WebServer class Reference

00034                                          {
00035   web_pool_ = webpool;
00036   
00037   // clean busy flag
00038   busy_ = 0;
00039   
00040   // Initialize function flag:
00041   // 0: there's no server processing delay
00042   // 1: server processing delay from FCFS scheduling policy
00043   // 2: server processing delay from STF scheduling policy
00044   set_mode(0);
00045   
00046   // Initialize server processing raste
00047   set_rate(1);
00048   
00049   // initialize the job queue
00050   head = tail = NULL;
00051   queue_size_ = 0;
00052   queue_limit_ = 0;
00053 
00054   //cancel();
00055 }

00032 {
00033         if (status_ != TIMER_PENDING) {
00034                 fprintf(stderr,
00035                   "Attempting to cancel timer at %p which is not scheduled\n",
00036                   this);
00037                 abort();
00038         }
00039         _cancel();
00040         status_ = TIMER_IDLE;
00041 }

00191                                {
00192   job_departure();
00193 }

00060                                    {    // cancel!
00061                 if (status_ == TIMER_PENDING) {
00062                         _cancel();
00063                         status_ = TIMER_IDLE;
00064                 }
00065         }

00074                        {
00075   return(node->nodeid());
00076 }

00083                           {
00084   return(node);
00085 }

00070 {
00071         if (status_ != TIMER_PENDING)   // sanity check
00072                 abort();
00073         status_ = TIMER_HANDLING;
00074         expire(e);
00075         // if it wasn't rescheduled, it's done
00076         if (status_ == TIMER_HANDLING)
00077                 status_ = TIMER_IDLE;
00078 }

00087                                                                                                   {
00088   // There's no server processing delay
00089   if (! mode_) {
00090     web_pool_->launchResp(obj_id, node, clnt, tcp, snk, size, data);
00091 
00092     return 1;
00093   }
00094 
00095   //printf("%d %d\n", queue_limit_, queue_size_);
00096   if (!queue_limit_ || queue_size_ < queue_limit_) {
00097     // Insert the new job to the job queue
00098     job_s *new_job = new(job_s);
00099     new_job->obj_id = obj_id;
00100     new_job->clnt = clnt;
00101     new_job->tcp = tcp;
00102     new_job->snk = snk;
00103     new_job->size = size;
00104     new_job->data = data;
00105     new_job->next = NULL; 
00106 
00107     // always insert the new job to the tail.
00108     if (tail)
00109       tail->next = new_job;
00110     else
00111       head = new_job;
00112     tail = new_job;
00113 
00114     queue_size_++;
00115   } else {
00116     // drop the incoming job
00117     //printf("server drop job\n");
00118     return 0;
00119   }
00120 
00121   // Schedule the dequeue time when there's no job being processed
00122   if (!busy_) 
00123     schedule_next_job();
00124   
00125   return 1;
00126 }

00129                                 {
00130   if (head) {
00131     web_pool_->launchResp(head->obj_id, node, head->clnt, head->tcp, head->snk, head->size, head->data);
00132     
00133     // delete the first job
00134     job_s *p = head;
00135     if (head->next)
00136       head = head->next;
00137     else 
00138       head = tail = NULL;
00139     
00140     delete(p);
00141     queue_size_--;
00142   }
00143   
00144   // Schedule next job
00145   schedule_next_job();
00146   return 0;
00147 }

00061 {
00062         if (status_ == TIMER_PENDING)
00063                 _cancel();
00064         _sched(delay);
00065         status_ = TIMER_PENDING;
00066 }

00050 {
00051         if (status_ != TIMER_IDLE) {
00052                 fprintf(stderr,"Couldn't schedule timer");
00053                 abort();
00054         }
00055         _sched(delay);
00056         status_ = TIMER_PENDING;
00057 }

00149                                   {
00150   job_s *p, *q;
00151   
00152   if (head) {
00153     // do shortest task first scheduling
00154     if (mode_ == STF_DELAY) { 
00155       // find the shortest task
00156       p = q = head;
00157       while (q) {
00158         if (p->size > q->size)
00159           p = q;
00160         
00161         q = q->next;
00162       }
00163       
00164       // exchange the queue head with the shortest job
00165       int obj_id = p->obj_id;
00166       Node *clnt = p->clnt;
00167       int size = p->size;
00168       void *data = p->data;
00169       
00170       p->obj_id = head->obj_id;
00171       p->clnt = head->clnt;
00172       p->size = head->size;
00173       p->data = head->data;
00174 
00175       head->obj_id = obj_id;
00176       head->clnt = clnt;
00177       head->size = size;
00178       head->data = data;
00179     }
00180     
00181     // Schedule the processing timer
00182     double delay_ = head->size / rate_;
00183     resched(delay_);
00184     busy_ = 1;
00185     //  printf("%d, %f, %f\n", head->size, rate_, delay_);
00186   } else
00187     busy_ = 0;
00188 }

00063                                    {
00064   mode_ = s_mode;
00065 }

00079                                 {
00080   node = n;
00081 }

00068                                          {
00069   queue_limit_ = limit;
00070 }

00058                                       {
00059   rate_ = s_rate;
00060 }

00067 { return status_; };

WebServer Class Reference

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Types
enum	TimerStatus { TIMER_IDLE, TIMER_PENDING, TIMER_HANDLING }
Public Member Functions
	WebServer (WebTrafPool *)
void	set_node (Node *)
Node *	get_node ()
int	get_nid ()
void	set_rate (double)
void	set_mode (int)
void	set_queue_limit (int)
double	job_arrival (int, Node , Agent , Agent , int, void )
void	sched (double delay)
void	resched (double delay)
void	cancel ()
void	force_cancel ()
int	status ()
Protected Member Functions
virtual void	handle (Event *)
Protected Attributes
int	status_
Event	event_
Private Member Functions
virtual void	expire (Event *e)
double	job_departure ()
void	schedule_next_job ()
Private Attributes
WebTrafPool *	web_pool_
Node *	node
double	rate_
int	mode_
job_s *	head
job_s *	tail
int	queue_size_
int	queue_limit_
int	busy_