ns2 Network Simulator 2.29: Scheduler Class Reference

Detailed Description

Definition at line 79 of file scheduler.h.


Public Member Functions
virtual void	cancel (Event *)=0
double	clock () const
virtual Event *	deque ()=0
virtual const Event *	head ()=0
virtual void	insert (Event *)=0
virtual Event *	lookup (scheduler_uid_t uid)=0
virtual void	reset ()
virtual void	run ()
void	schedule (Handler , Event , double delay)
virtual double	start ()
virtual void	sync ()
Static Public Member Functions
static Scheduler &	instance ()
Protected Member Functions
int	command (int argc, const char const argv)
void	dispatch (Event *, double)
void	dispatch (Event *)
void	dumpq ()
	Scheduler ()
virtual	~Scheduler ()
Protected Attributes
double	clock_
int	halted_
Static Protected Attributes
static Scheduler *	instance_
static scheduler_uid_t	uid_ = 1

Constructor & Destructor Documentation

Scheduler::Scheduler ( ) [protected]

Definition at line 63 of file scheduler.cc.

00063                      : clock_(SCHED_START), halted_(0)
00064 {
00065 }

Scheduler::~Scheduler ( ) [protected, virtual]

Definition at line 67 of file scheduler.cc.

References instance_.

00067                      {
00068     instance_ = NULL ;
00069 }

00190 {
00191     Tcl& tcl = Tcl::instance();
00192     if (instance_ == 0)
00193         instance_ = this;
00194     if (argc == 2) {
00195         if (strcmp(argv[1], "run") == 0) {
00196             /* set global to 0 before calling object reset methods */
00197             reset();    // sets clock to zero
00198             run();
00199             return (TCL_OK);
00200         } else if (strcmp(argv[1], "now") == 0) {
00201             sprintf(tcl.buffer(), "%.17g", clock());
00202             tcl.result(tcl.buffer());
00203             return (TCL_OK);
00204         } else if (strcmp(argv[1], "resume") == 0) {
00205             halted_ = 0;
00206             run();
00207             return (TCL_OK);
00208         } else if (strcmp(argv[1], "halt") == 0) {
00209             halted_ = 1;
00210             return (TCL_OK);
00211 
00212         } else if (strcmp(argv[1], "clearMemTrace") == 0) {
00213 #ifdef MEMDEBUG_SIMULATIONS
00214             extern MemTrace *globalMemTrace;
00215             if (globalMemTrace)
00216                 globalMemTrace->diff("Sim.");
00217 #endif
00218             return (TCL_OK);
00219         } else if (strcmp(argv[1], "is-running") == 0) {
00220             sprintf(tcl.buffer(), "%d", !halted_);
00221             return (TCL_OK);
00222         } else if (strcmp(argv[1], "dumpq") == 0) {
00223             if (!halted_) {
00224                 fprintf(stderr, "Scheduler: dumpq only allowed while halted\n");
00225                 tcl.result("0");
00226                 return (TCL_ERROR);
00227             }
00228             dumpq();
00229             return (TCL_OK);
00230         }
00231     } else if (argc == 3) {
00232         if (strcmp(argv[1], "at") == 0 ||
00233             strcmp(argv[1], "cancel") == 0) {
00234             Event* p = lookup(STRTOUID(argv[2]));
00235             if (p != 0) {
00236                 /*XXX make sure it really is an atevent*/
00237                 cancel(p);
00238                 AtEvent* ae = (AtEvent*)p;
00239                 delete ae;
00240             }
00241         } else if (strcmp(argv[1], "at-now") == 0) {
00242             const char* proc = argv[2];
00243 
00244             // "at [$ns now]" may not work because of tcl's 
00245             // string number resolution
00246             AtEvent* e = new AtEvent;
00247             int n = strlen(proc);
00248             e->proc_ = new char[n + 1];
00249             strcpy(e->proc_, proc);
00250             schedule(&at_handler, e, 0);
00251             sprintf(tcl.buffer(), UID_PRINTF_FORMAT, e->uid_);
00252             tcl.result(tcl.buffer());
00253         }
00254         return (TCL_OK);
00255     } else if (argc == 4) {
00256         if (strcmp(argv[1], "at") == 0) {
00257             /* t < 0 means relative time: delay = -t */
00258             double delay, t = atof(argv[2]);
00259             const char* proc = argv[3];
00260 
00261             AtEvent* e = new AtEvent;
00262             int n = strlen(proc);
00263             e->proc_ = new char[n + 1];
00264             strcpy(e->proc_, proc);
00265             delay = (t < 0) ? -t : t - clock();
00266             if (delay < 0) {
00267                 tcl.result("can't schedule command in past");
00268                 return (TCL_ERROR);
00269             }
00270             schedule(&at_handler, e, delay);
00271             sprintf(tcl.buffer(), UID_PRINTF_FORMAT, e->uid_);
00272             tcl.result(tcl.buffer());
00273             return (TCL_OK);
00274         }
00275     }
00276     return (TclObject::command(argc, argv));
00277 }

00142 { 00143 if (t < clock_) { 00144 fprintf(stderr, "ns: scheduler going backwards in time from %f to %f.\n", clock_, t); 00145 abort(); 00146 } 00147 00148 clock_ = t; 00149 p->uid_ = -p->uid_; // being dispatched 00150 p->handler_->handle(p); // dispatch 00151 }

00281 { 00282 Event *p; 00283 00284 printf("Contents of scheduler queue (events) [cur time: %f]---\n", 00285 clock()); 00286 while ((p = deque()) != NULL) { 00287 printf("t:%f uid: ", p->time_); 00288 printf(UID_PRINTF_FORMAT, p->uid_); 00289 printf(" handler: %p\n", p->handler_); 00290 } 00291 }

00120 { 00121 instance_ = this; 00122 Event *p; 00123 /* 00124 * The order is significant: if halted_ is checked later, 00125 * event p could be lost when the simulator resumes. 00126 * Patch by Thomas Kaemer <Thomas.Kaemer@eas.iis.fhg.de>. 00127 */ 00128 while (!halted_ && (p = deque())) { 00129 dispatch(p, p->time_); 00130 } 00131 }

00084 { 00085 // handler should ALWAYS be set... if it's not, it's a bug in the caller 00086 if (!h) { 00087 fprintf(stderr, 00088 "Scheduler: attempt to schedule an event with a NULL handler." 00089 " Don't DO that.\n"); 00090 abort(); 00091 }; 00092 00093 if (e->uid_ > 0) { 00094 printf("Scheduler: Event UID not valid!\n\n"); 00095 abort(); 00096 } 00097 00098 if (delay < 0) { 00099 // You probably don't want to do this 00100 // (it probably represents a bug in your simulation). 00101 fprintf(stderr, 00102 "warning: ns Scheduler::schedule: scheduling event\n\t" 00103 "with negative delay (%f) at time %f.\n", delay, clock_); 00104 } 00105 00106 if (uid_ < 0) { 00107 fprintf(stderr, "Scheduler: UID space exhausted!\n"); 00108 abort(); 00109 } 00110 e->uid_ = uid_++; 00111 e->handler_ = h; 00112 double t = clock_ + delay; 00113 00114 e->time_ = t; 00115 insert(e); 00116 }

Field Documentation

Generated on Tue Mar 6 17:29:45 2007 for ns2 Network Simulator 2.29 by

1.4.6

Scheduler Class Reference

Detailed Description

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation