NS2.26SourcesOriginal: Scheduler class Reference

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

00067                      {
00068         instance_ = NULL ;
00069 }

00090                              {                  // simulator virtual time
00091                 return (clock_);
00092         }

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

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

00154 {
00155         dispatch(p, p->time_);
00156 }

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

00080                                      {
00081                 return (*instance_);            // general access to scheduler
00082         }

00183 {
00184         clock_ = SCHED_START;
00185 }

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

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         if (e->uid_ > 0) {
00093                 printf("Scheduler: Event UID not valid!\n\n");
00094                 abort();
00095         }
00096         
00097         if (delay < 0) {
00098                 // You probably don't want to do this
00099                 // (it probably represents a bug in your simulation).
00100                 fprintf(stderr, 
00101                         "warning: ns Scheduler::schedule: scheduling event\n\t"
00102                         "with negative delay (%f) at time %f.\n", delay, clock_);
00103         }
00104 
00105         if (uid_ < 0) {
00106                 fprintf(stderr, "Scheduler: UID space exhausted!\n");
00107                 abort();
00108         }
00109         e->uid_ = uid_++;
00110         e->handler_ = h;
00111         double t = clock_ + delay;
00112 
00113         e->time_ = t;
00114         insert(e);
00115 }

00094                                {                // start time
00095                 return SCHED_START;
00096         }


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

Scheduler Class Reference

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation