Main Page | Namespace List | Class Hierarchy | Alphabetical List | Compound List | File List | Compound Members | File Members

CalendarScheduler Class Reference

#include <scheduler.h>

Inheritance diagram for CalendarScheduler:

Inheritance graph
[legend]
Collaboration diagram for CalendarScheduler:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 CalendarScheduler ()
 ~CalendarScheduler ()
void cancel (Event *)
void insert (Event *)
Event * lookup (scheduler_uid_t uid)
Event * deque ()
const Event * head ()
void schedule (Handler *, Event *, double delay)
virtual void run ()
double clock () const
virtual void sync ()
virtual double start ()
virtual void reset ()

Static Public Member Functions

Scheduler & instance ()

Protected Member Functions

virtual void reinit (int nbuck, double bwidth, double start)
virtual void resize (int newsize, double start)
virtual double newwidth (int newsize)
void dumpq ()
void dispatch (Event *)
void dispatch (Event *, double)
int command (int argc, const char *const *argv)

Protected Attributes

double width_
double diff0_
double diff1_
double diff2_
int stat_qsize_
int nbuckets_
int lastbucket_
int top_threshold_
int bot_threshold_
CalendarScheduler::Bucket * buckets_
int qsize_
double clock_
int halted_

Static Protected Attributes

Scheduler * instance_
scheduler_uid_t uid_ = 1

Private Member Functions

virtual void insert2 (Event *)

Private Attributes

double cal_clock_

Constructor & Destructor Documentation

CalendarScheduler::CalendarScheduler (   ) 
 

Definition at line 582 of file scheduler.cc.

References cal_clock_, and reinit(). 

00582                                      : cal_clock_(clock_) {
00583         reinit(4, 1.0, cal_clock_);
00584 }

Here is the call graph for this function:

CalendarScheduler::~CalendarScheduler (   ) 
 

Definition at line 586 of file scheduler.cc.

References buckets_, qsize_, and stat_qsize_. 

00586                                       {
00587         // XXX free events?
00588         delete [] buckets_;
00589         qsize_ = 0;
00590         stat_qsize_ = 0;
00591 }

Member Function Documentation

void CalendarScheduler::cancel (  Event *   )  [virtual]
 

Implements Scheduler.

Definition at line 892 of file scheduler.cc.

References buckets_, CALENDAR_HASH, CalendarScheduler::Bucket::count_, CalendarScheduler::Bucket::list_, Event::next_, Event::prev_, qsize_, stat_qsize_, Event::time_, and Event::uid_. 

00893 {
00894         if (e->uid_ <= 0)       // event not in queue
00895                 return;
00896 
00897         int i = CALENDAR_HASH(e->time_);
00898 
00899         assert(e->prev_->next_ == e);
00900         assert(e->next_->prev_ == e);
00901 
00902         if (e->next_ == e || 
00903             (e->next_->time_ != e->time_ &&
00904             (e->prev_->time_ != e->time_))) { 
00905                 --stat_qsize_;
00906                 assert(stat_qsize_ >= 0);
00907                 --buckets_[i].count_;
00908                 assert(buckets_[i].count_ >= 0);
00909         }
00910 
00911         if (e->next_ == e) {
00912                 assert(buckets_[i].list_ == e);
00913                 buckets_[i].list_ = 0;
00914         } else {
00915                 e->next_->prev_ = e->prev_;
00916                 e->prev_->next_ = e->next_;
00917                 if (buckets_[i].list_ == e)
00918                         buckets_[i].list_ = e->next_;
00919         }
00920 
00921         if (buckets_[i].count_ == 0)
00922                 assert(buckets_[i].list_ == 0);
00923 
00924         e->uid_ = -e->uid_;
00925         e->next_ = e->prev_ = NULL;
00926 
00927         --qsize_;
00928 
00929         return;
00930 }

double Scheduler::clock (   )  const [inline, inherited]
 

Definition at line 90 of file scheduler.h.

References Scheduler::clock_.

Referenced by TcpSink::ack(), QSTcpSink::ack(), HttpMInvalCache::add_nbr(), Agent::addAgentTrace(), JoBS::adjustRatesRDC(), Trace::annotate(), SFDPolicy::applyMeter(), TRTCMPolicy::applyMeter(), SRTCMPolicy::applyMeter(), TBPolicy::applyMeter(), TSW3CMPolicy::applyMeter(), TSW2CMPolicy::applyMeter(), DumbPolicy::applyMeter(), EWPolicy::applyPolicer(), dsREDQueue::applyTSWMeter(), JoBS::arvAccounting(), JoBS::assignRateDropsADC(), MacCsma::backoff(), FlowTable::cleanup(), CorresHost::closecwnd(), Scheduler::command(), RedPDQueue::command(), PingAgent::command(), ProxyTracePagePool::command(), HttpYucInvalServer::command(), HttpApp::command(), redQueue::config(), PeriodicErrorModel::corrupt(), MultiStateErrorModel::corrupt(), TfrcAgent::decrease_rate(), REDQueue::deque(), JoBS::deque(), GK::deque(), Demarker::deque(), WRR_CBQueue::deque(), CBQueue::deque(), QA::DrainBuffers(), QueueMonitor::drop(), Scheduler::dumpq(), MacCsma::endofContention(), Vq::enque(), RIOQueue::enque(), REDQueue::enque(), RedPDQueue::enque(), Marker::enque(), JoBS::enque(), GK::enque(), redQueue::enque(), ClientPagePool::enter_page(), MClientPagePool::enter_page(), TfrcSinkAgent::est_thput(), RateEstimator::estimateRate(), QueueMonitor::estimateRate(), REDQueue::estimator(), MacTimer::expire(), MacTdmaTimer::expire(), PromotionTimer::expire(), FlowMon::fformat(), Tagger::fformat(), Trace::format(), SatTrace::format(), CMUTrace::format_mac(), LandmarkAgent::ForwardPacket(), DSDV_Agent::forwardPacket(), SensorQueryAgent::generate_query(), PcapFileNetwork::gents(), PcapLiveNetwork::gents(), QA::get_data(), DSRAgent::getRouteForPacket(), GetTime(), TBF::getupdatedtokens(), PositionHandler::handle(), AdaptiveFidelityEntity::handle(), DSDVTriggerHandler::handle(), AckRecons::handle(), LmsReceiver::handle_lms_pkt(), DSRAgent::handleFlowForwarding(), DSRAgent::handleForwarding(), SRForwarder::handlePktWithoutSR(), DSDV_Agent::helper_callback(), QueueMonitorCompat::in(), QueueMonitor::in(), TfrcAgent::increase_rate(), PushbackAgent::initialUpdate(), Agent::initpkt(), redQueue::initREDStateVar(), SSMSRMAgent::is_active(), Mac802_11::is_idle(), WebTrafPool::launchReq(), EmpWebTrafSession::launchReq(), WebTrafPool::launchResp(), MobileNode::log_energy(), MobileNode::log_movement(), LoggingDataStruct::LoggingDataStruct(), IvsReceiver::lossMeter(), Internet::makeip(), LandmarkAgent::makeUpdate(), DSDV_Agent::makeUpdate(), AggSpec::member(), JoBS::minRatesNeeded(), Agent::monitorAgentTrace(), CMUTrace::nam_format(), DSDV_Agent::needTriggeredUpdate(), TcpAgent::newack(), TcpSessionAgent::newack(), SackRHTcpAgent::newack(), RFC793eduTcpAgent::newack(), FlowTable::noticeDeadLink(), FullTcpAgent::now(), BayFullTcpAgent::now(), TapAgent::now(), FtpSrvrAgent::now(), FtpClientAgent::now(), FackTcpAgent::oldack(), QueueMonitorCompat::out(), QueueMonitor::out(), TcpAgent::output(), VegasTcpAgent::output(), RFC793eduTcpAgent::output(), QSNewRenoTcpAgent::output(), IntTcpAgent::output(), IntTcpAgent::output_helper(), TcpFsAgent::output_helper(), BackoffTimer::pause(), LandmarkAgent::periodic_callback(), JoBS::pickDroppedRLC(), Sack1TcpAgent::plot(), SackRHTcpAgent::plot(), FackTcpAgent::plot(), TfrcSinkAgent::print_loss(), TfrcSinkAgent::print_loss_all(), PushbackAgent::printMsg(), QueueMonitor::printRTTs(), QueueMonitor::printSeqnos(), QueueMonitor::printStats(), TcpAgent::process_qoption_after_send(), DSRAgent::processBrokenRouteError(), LandmarkAgent::ProcessHierUpdate(), LogWebTrafPool::processLog(), TCPTapAgent::processpkt(), TcpAgent::processQuickStart(), DSDV_Agent::processUpdate(), JoBS::projDelay(), PushbackAgent::pushbackCancel(), PushbackEvent::PushbackEvent(), PushbackAgent::pushbackRefresh(), QueueMonitor::QueueMonitor(), RTPAgent::rate_change(), RateEstimator::RateEstimator(), TokenBucketRateLimiter::rateLimit(), RateLimitSession::RateLimitSession(), RateLimitStrategy::RateLimitStrategy(), DequeTrace::recv(), TfrcAgent::recv(), TfrcSinkAgent::recv(), QSNewRenoTcpAgent::recv(), NewRenoTcpAgent::recv(), BayFullTcpAgent::recv(), TcpAsymSink::recv(), TBF::recv(), SRForwarder::recv(), SensorQueryAgent::recv(), SatDequeTrace::recv(), SALink::recv(), Queue< T >::recv(), PingAgent::recv(), IPNetwork::recv(), UDPIPNetwork::recv(), MIPMHAgent::recv(), LossMonitor::recv(), PLMLossMonitor::recv(), LmsReceiver::recv(), LmsAgent::recv(), IvsReceiver::recv(), FQ::recv(), FloodAgent::recv(), CBQClass::recv(), AdaptiveRcvr::recv(), AckRecons::recv(), SSMSRMAgent::recv_glb_sess(), HttpMInvalCache::recv_heartbeat(), TcpFsAgent::recv_helper(), SSMSRMAgent::recv_loc_sess(), TcpFsAgent::recv_newack_helper(), TcpAsymAgent::recv_newack_helper(), SSMSRMAgent::recv_rep_sess(), SRMAgent::recv_sess(), HttpMInvalCache::recv_upd(), toraAgent::recvCLR(), toraAgent::recvQRY(), toraAgent::recvUPD(), RateLimitSession::refreshed(), DSRAgent::replyFromRouteCache(), TcpAgent::reset(), TcpSink::reset(), REDQueue::reset(), TokenBucketRateLimiter::reset(), RateEstimator::reset(), TcpAgent::reset_qoption(), Queue< T >::resume(), BackoffTimer::resume(), DSRAgent::returnSrcRouteToRequestor(), TcpAgent::rtt_counting(), TcpAgent::rtt_update(), RFC793eduTcpAgent::rtt_update(), EWdetector::run(), TBrateLimitor::run(), Snoop::savepkt_(), SmacCounterTimer::sched(), SmacNeighNavTimer::sched(), SmacRecvTimer::sched(), SrmNode::sched_nack(), PushbackTimer::schedule(), TcpApp::send(), MacCsmaCa::send(), MacCsma::send(), SSMSRMAgent::send_glb_sess(), LmsSender::send_lms_pkt(), SSMSRMAgent::send_loc_sess(), TcpAgent::send_much(), TcpSessionAgent::send_much(), LmsReceiver::send_nak(), SSMSRMAgent::send_rep_sess(), SRMAgent::send_sess(), LmsSender::send_spm(), AckRecons::sendack(), DSRAgent::sendBufferCheck(), DiffusionAgent::SendBufferCheck(), LandmarkAgent::SendChangedTagListUpdate(), UdpAgent::sendmsg(), SimpleTcpAgent::sendmsg(), LmsSender::sendmsg(), DSRAgent::sendOutPacketWithRoute(), DSRAgent::sendOutRtReq(), TfrcAgent::sendpkt(), TfrcSinkAgent::sendpkt(), SA_Agent::sendpkt(), RTPAgent::sendpkt(), IvsSource::sendpkt(), DSRAgent::sendRouteShortening(), Mac802_3::sendUp(), MobileNode::set_destination(), Mac802_11::set_nav(), EnergyModel::set_node_sleep(), EnergyModel::set_node_state(), TfrcAgent::slowstart(), Snoop::snoop_insert(), LLSnoop::snoop_rtt(), Snoop::snoop_rtt(), Snoop::snoop_rxmit(), RapAgent::start(), BackoffTimer::start(), DeferTimer::start(), MacTimer::start(), MacTdmaTimer::start(), LogWebTrafPool::start(), EnergyModel::start_powersaving(), DSDV_Agent::startUp(), OmniMcastAgent::StickPacketInSendBuffer(), DSRAgent::stickPacketInSendBuffer(), DiffusionAgent::StickPacketInSendBuffer(), RapAgent::stop(), TaggerTBFlow::tagging(), TaggerTSWFlow::tagging(), DSRAgent::tap(), TBrateLimitor::TBrateLimitor(), MIPMHAgent::timeout(), LmsReceiver::timeout(), SSMSRMAgent::timeout_info(), SmacNeighNavTimer::timeToExpire(), SmacRecvTimer::timeToExpire(), SmacCounterTimer::timeToSleep(), TokenBucketRateLimiter::TokenBucketRateLimiter(), TORANeighbor::TORANeighbor(), Vq::trace(), Trace::trace(), SALink::trace(), RIOQueue::trace(), REMQueue::trace(), REDQueue::trace(), PIQueue::trace(), Param_ADC::trace(), LDPAgent::trace(), GK::trace(), Estimator::trace(), TcpAgent::trace_event(), TcpAgent::traceAll(), TcpAsymAgent::traceAll(), TcpAgent::traceVar(), TcpSessionAgent::traceVar(), TcpAsymAgent::traceVar(), TransHistoryEntry::TransHistoryEntry(), MobileNode::update_position(), SMAC::updateNav(), SMAC::updateNeighNav(), ParentChildrenList::UpdatePotlChild(), ParentChildrenList::UpdatePotlParent(), redQueue::updateREDStateVar(), DSDV_Agent::updateRoute(), Queue< T >::updateStats(), JoBS::updateStats(), Queue< T >::utilization(), VegasTcpAgent::vegastime(), and DSRAgent::xmitFlowFailed(). 

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

int Scheduler::command (  int  argc,
const char *const *  argv
)  [protected, inherited]
 

Definition at line 188 of file scheduler.cc.

References at_handler, Scheduler::cancel(), Scheduler::clock(), MemTrace::diff(), Scheduler::dumpq(), Scheduler::halted_, Scheduler::instance_, Scheduler::lookup(), AtEvent::proc_, Scheduler::reset(), Scheduler::run(), Scheduler::schedule(), STRTOUID, Event::uid_, and UID_PRINTF_FORMAT. 

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 }

Here is the call graph for this function:

Event * CalendarScheduler::deque (   )  [virtual]
 

Implements Scheduler.

Definition at line 763 of file scheduler.cc.

References bot_threshold_, buckets_, cal_clock_, CalendarScheduler::Bucket::count_, head(), lastbucket_, CalendarScheduler::Bucket::list_, nbuckets_, Event::next_, Event::prev_, qsize_, resize(), stat_qsize_, and Event::time_.

Referenced by RealTimeScheduler::run(). 

00764 {
00765         Event *e = const_cast<Event *>(head());
00766 
00767         if (!e)
00768                 return 0;
00769 
00770         int l = lastbucket_;
00771 
00772         // update stats and unlink
00773         if (e->next_ == e || e->next_->time_ != e->time_) {
00774                 --stat_qsize_;
00775                 //assert(stat_qsize_ >= 0);
00776                 --buckets_[l].count_;
00777                 //assert(buckets_[l].count_ >= 0);
00778 
00779         }
00780         --qsize_;
00781 
00782         if (e->next_ == e)
00783                 buckets_[l].list_ = 0;
00784         else {
00785                 e->next_->prev_ = e->prev_;
00786                 e->prev_->next_ = e->next_;
00787                 buckets_[l].list_ = e->next_;
00788         }
00789 
00790         e->next_ = e->prev_ = NULL;
00791 
00792 
00793         //if (buckets_[l].count_ == 0)
00794         //      assert(buckets_[l].list_ == 0);
00795 
00796         if (stat_qsize_ < bot_threshold_) {
00797                 resize(nbuckets_ >> 1, cal_clock_);
00798         }
00799 
00800         return e;
00801 }

Here is the call graph for this function:

void Scheduler::dispatch (  Event *  ,
double 
)  [protected, inherited]
 

Definition at line 140 of file scheduler.cc.

References abort(), Scheduler::clock_, Handler::handle(), Event::handler_, and Event::uid_. 

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 }

Here is the call graph for this function:

void Scheduler::dispatch (  Event *   )  [protected, inherited]
 

Definition at line 153 of file scheduler.cc.

References Event::time_.

Referenced by RealTimeScheduler::run(), and Scheduler::run(). 

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

void Scheduler::dumpq (   )  [protected, inherited]
 

Definition at line 279 of file scheduler.cc.

References Scheduler::clock(), Scheduler::deque(), Event::handler_, Event::time_, Event::uid_, and UID_PRINTF_FORMAT.

Referenced by Scheduler::command(). 

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 }

Here is the call graph for this function:

const Event * CalendarScheduler::head (   )  [virtual]
 

Implements Scheduler.

Definition at line 701 of file scheduler.cc.

References buckets_, cal_clock_, lastbucket_, CalendarScheduler::Bucket::list_, nbuckets_, qsize_, and Event::time_.

Referenced by deque(), insert(), insert2(), lookup(), and RealTimeScheduler::run(). 

00702 {
00703         if (qsize_ == 0)
00704                 return NULL;
00705 
00706         int l, i = lastbucket_;
00707         int lastbucket_dec = (lastbucket_) ? lastbucket_ - 1 : nbuckets_ - 1;
00708         double diff;
00709         Event *e, *min_e = NULL;
00710 #define CAL_DEQUEUE(x)                                          \
00711 do {                                                            \
00712         if ((e = buckets_[i].list_) != NULL) {                  \
00713                 diff = e->time_ - cal_clock_;                   \
00714                 if (diff < diff##x##_)  {                       \
00715                         l = i;                                  \
00716                         goto found_l;                           \
00717                 }                                               \
00718                 if (min_e == NULL || min_e->time_ > e->time_) { \
00719                         min_e = e;                              \
00720                         l = i;                                  \
00721                 }                                               \
00722         }                                                       \
00723         if (++i == nbuckets_) i = 0;                            \
00724 } while (0)
00725                  
00726         // CAL_DEQUEUE applied successively will find the event to
00727         // dequeue (within one year) and keep track of the
00728         // minimum-priority event seen so far; the argument controls
00729         // the criteria used to decide whether the event should be
00730         // considered `within one year'.  Importantly, the number of
00731         // buckets should not be less than 4.
00732         CAL_DEQUEUE(0); 
00733         CAL_DEQUEUE(1); 
00734         for (; i != lastbucket_dec; ) {
00735                 CAL_DEQUEUE(2);
00736         }
00737         // one last bucket is left unchecked - take the minimum
00738         // [could have done CAL_DEQUEUE(3) with diff3_ = bwidth*(nbuck*3/2-1)]
00739         e = buckets_[i].list_;
00740         if (min_e != NULL && 
00741             (e == NULL || min_e->time_ < e->time_))
00742                 e = min_e;
00743         else {
00744                 //assert(e);
00745                 l = i;
00746         }
00747  found_l:
00748         //assert(buckets_[l].count_ >= 0);
00749         //assert(buckets_[l].list_ == e);
00750 
00751         /* l is the index of the bucket to dequeue, e is the event */
00752         /* 
00753          * still want to advance lastbucket_ and cal_clock_ to save
00754          * time when deque() follows. 
00755          */
00756         lastbucket_ = l;
00757         cal_clock_  = e->time_;
00758         
00759         return e;
00760 }

void CalendarScheduler::insert (  Event *   )  [virtual]
 

Implements Scheduler.

Definition at line 594 of file scheduler.cc.

References buckets_, cal_clock_, CALENDAR_HASH, head(), lastbucket_, CalendarScheduler::Bucket::list_, nbuckets_, Event::next_, Event::prev_, qsize_, resize(), stat_qsize_, Event::time_, and top_threshold_. 

00595 {
00596         int i;
00597         if (cal_clock_ > e->time_) {
00598                 // may happen in RT scheduler
00599                 cal_clock_ = e->time_;
00600                 i = lastbucket_ = CALENDAR_HASH(cal_clock_);
00601         } else
00602                 i = CALENDAR_HASH(e->time_);
00603 
00604         Event *head = buckets_[i].list_;
00605         Event *before=0;
00606 
00607         if (!head) {
00608                 buckets_[i].list_ = e;
00609                 e->next_ = e->prev_ = e;
00610                 ++stat_qsize_; 
00611                 ++buckets_[i].count_;
00612         } else {
00613                 bool newhead;
00614                 if (e->time_ >= head->prev_->time_) {
00615                         // insert at the tail
00616                         before = head;
00617                         newhead = false;
00618                 } else {
00619                         // insert event in time sorted order, FIFO for sim-time events
00620                         for (before = head; e->time_ >= before->time_; before = before->next_)
00621                                 ;
00622                         newhead = (before == head);
00623                 }
00624 
00625                 e->next_ = before;
00626                 e->prev_ = before->prev_;
00627                 before->prev_ = e;
00628                 e->prev_->next_ = e;
00629                 if (newhead) {
00630                         buckets_[i].list_ = e;
00631                         //assert(e->time_ <= e->next_->time_);
00632                 }
00633                 //assert(e->prev_ != e);
00634                 if (e->prev_->time_ != e->time_) {
00635                         // unique timing
00636                         ++stat_qsize_; 
00637                         ++buckets_[i].count_;
00638                 }
00639         }
00640         ++qsize_;
00641         //assert(e == buckets_[i].list_ ||  e->prev_->time_ <= e->time_);
00642         //assert(e == buckets_[i].list_->prev_ || e->next_->time_ >= e->time_);
00643 
00644         if (stat_qsize_ > top_threshold_) {
00645                 resize(nbuckets_ << 1, cal_clock_);
00646                 return;
00647         }
00648 }

Here is the call graph for this function:

void CalendarScheduler::insert2 (  Event *   )  [private, virtual]
 

Definition at line 651 of file scheduler.cc.

References buckets_, CALENDAR_HASH, head(), CalendarScheduler::Bucket::list_, Event::next_, Event::prev_, qsize_, stat_qsize_, and Event::time_.

Referenced by resize(). 

00652 {
00653         // Same as insert, but for inserts e *before* any same-time-events, if
00654         //   there should be any.  Since it is used only by CalendarScheduler::newwidth(),
00655         //   some important checks present in insert() need not be performed.
00656 
00657         int i = CALENDAR_HASH(e->time_);
00658         Event *head = buckets_[i].list_;
00659         Event *before=0;
00660         if (!head) {
00661                 buckets_[i].list_ = e;
00662                 e->next_ = e->prev_ = e;
00663                 ++stat_qsize_; 
00664                 ++buckets_[i].count_;
00665         } else {
00666                 bool newhead;
00667                 if (e->time_ > head->prev_->time_) { //strict LIFO, so > and not >=
00668                         // insert at the tail
00669                         before = head;
00670                         newhead = false;
00671                 } else {
00672                         // insert event in time sorted order, LIFO for sim-time events
00673                         for (before = head; e->time_ > before->time_; before = before->next_)
00674                                 ;
00675                         newhead = (before == head);
00676                 }
00677 
00678                 e->next_ = before;
00679                 e->prev_ = before->prev_;
00680                 before->prev_ = e;
00681                 e->prev_->next_ = e;
00682                 if (newhead) {
00683                         buckets_[i].list_ = e;
00684                         //assert(e->time_ <= e->next_->time_);
00685                 }
00686 
00687                 if (e != e->next_ && e->next_->time_ != e->time_) {
00688                         // unique timing
00689                         ++stat_qsize_; 
00690                         ++buckets_[i].count_;
00691                 }
00692         }
00693         //assert(e == buckets_[i].list_ ||  e->prev_->time_ <= e->time_);
00694         //assert(e == buckets_[i].list_->prev_ || e->next_->time_ >= e->time_);
00695 
00696         ++qsize_;
00697         // no need to check resizing
00698 }

Here is the call graph for this function:

Scheduler& Scheduler::instance (   )  [inline, static, inherited]
 

Definition at line 80 of file scheduler.h.

Referenced by TimerHandler::_cancel(), TimerHandler::_sched(), DSRAgent::acceptRouteReply(), TcpSink::ack(), QSTcpSink::ack(), HttpMInvalCache::add_nbr(), Agent::addAgentTrace(), LandmarkAgent::AddMobileTag(), Cache::addRoute(), JoBS::adjustRatesRDC(), Trace::annotate(), Sacker::append_ack(), SFDPolicy::applyMeter(), TRTCMPolicy::applyMeter(), SRTCMPolicy::applyMeter(), TBPolicy::applyMeter(), TSW3CMPolicy::applyMeter(), TSW2CMPolicy::applyMeter(), DumbPolicy::applyMeter(), EWPolicy::applyPolicer(), dsREDQueue::applyTSWMeter(), ARPTable::arpinput(), ARPTable::arprequest(), JoBS::arvAccounting(), JoBS::assignRateDropsADC(), MacCsma::backoff(), MacHandlerRetx::cancel(), MacHandlerRecv::cancel(), Mac8023HandlerSend::cancel(), MacHandler::cancel(), imepTimer::cancel(), CorresHost::cancel(), SRM_Request::cancel_timer(), DSDV_Agent::cancelTriggersBefore(), HttpMInvalCache::check_sstate(), FlowTable::cleanup(), CorresHost::closecwnd(), RedPDQueue::command(), PingAgent::command(), ProxyTracePagePool::command(), CompMathPagePool::command(), MathPagePool::command(), TracePagePool::command(), MobiCache::command(), MediaApp::command(), LandmarkAgent::command(), HttpMInvalCache::command(), HttpYucInvalServer::command(), HttpApp::command(), DSRAgent::command(), DSDV_Agent::command(), redQueue::config(), PeriodicErrorModel::corrupt(), MultiStateErrorModel::corrupt(), QA::debug(), TfrcAgent::decrease_rate(), Agent::deleteAgentTrace(), REDQueue::deque(), JoBS::deque(), GK::deque(), DropTail::deque(), Demarker::deque(), WRR_CBQueue::deque(), CBQueue::deque(), TapAgent::dispatch(), EmpWebPage::doneObject(), QA::DrainBuffers(), QueueMonitor::drop(), DSRAgent::dropSendBuff(), MacTdma::dump(), Mac802_11::dump(), UnslottedAlohaMac::end_of_contention(), MacCsma::endofContention(), Vq::enque(), RIOQueue::enque(), REDQueue::enque(), RedPDQueue::enque(), Marker::enque(), JoBS::enque(), GK::enque(), redQueue::enque(), ClientPagePool::enter_page(), MClientPagePool::enter_page(), TfrcSinkAgent::est_thput(), RateEstimator::estimateRate(), QueueMonitor::estimateRate(), REDQueue::estimator(), MacTimer::expire(), MacTdmaTimer::expire(), PromotionTimer::expire(), FlowMon::fformat(), Tagger::fformat(), RateLimitSessionList::filter(), SemanticPacketQueue::filterAcks(), MobiCache::findRoute(), Agent::flushAVar(), Trace::format(), SatTrace::format(), CMUTrace::format_mac(), toraAgent::forward(), AODV::forward(), LandmarkAgent::ForwardPacket(), DSDV_Agent::forwardPacket(), SensorQueryAgent::generate_query(), PcapFileNetwork::gents(), PcapLiveNetwork::gents(), QA::get_data(), DSRAgent::getRouteForPacket(), GetTime(), TBF::getupdatedtokens(), Snoop::handle(), PositionHandler::handle(), BackoffHandler::handle(), PollAckHandler::handle(), PollHandler::handle(), AdaptiveFidelityEntity::handle(), SoftNeighborHandler::handle(), DSDVTriggerHandler::handle(), RouteCacheTimer::handle(), NeighborTimer::handle(), HelloTimer::handle(), BroadcastTimer::handle(), AckRecons::handle(), LmsReceiver::handle_lms_pkt(), HttpMInvalCache::handle_node_failure(), DSRAgent::handleFlowForwarding(), DSRAgent::handleForwarding(), SRForwarder::handlePktWithoutSR(), DSRAgent::handlePktWithoutSR(), DSRAgent::handleRouteRequest(), DSDV_Agent::helper_callback(), QueueMonitorCompat::in(), QueueMonitor::in(), TfrcAgent::increase_rate(), PushbackAgent::initialUpdate(), Agent::initpkt(), redQueue::initREDStateVar(), MPLSAddressClassifier::install(), RapAgent::IpgTimeout(), SSMSRMAgent::is_active(), Mac802_11::is_idle(), WebTrafPool::launchReq(), EmpWebTrafSession::launchReq(), WebTrafPool::launchResp(), AODV::local_rt_repair(), MediaApp::log(), HttpApp::log(), MobileNode::log_energy(), MobileNode::log_movement(), CMUPriQueue::log_stats(), LoggingDataStruct::LoggingDataStruct(), RapAgent::LossHandler(), IvsReceiver::lossMeter(), DSDV_Agent::lost_link(), OmniMcastAgent::MACsend(), FloodingAgent::MACsend(), DiffusionAgent::MACsend(), Internet::makeip(), LandmarkAgent::makeUpdate(), DSDV_Agent::makeUpdate(), AggSpec::member(), JoBS::minRatesNeeded(), Agent::monitorAgentTrace(), LandmarkAgent::MoveTags(), CMUTrace::nam_format(), DSDV_Agent::needTriggeredUpdate(), GridKeeper::new_moves(), TcpAgent::newack(), TcpSessionAgent::newack(), SackRHTcpAgent::newack(), RFC793eduTcpAgent::newack(), Cache::noticeDeadLink(), MobiCache::noticeDeadLink(), FlowTable::noticeDeadLink(), FullTcpAgent::now(), BayFullTcpAgent::now(), TapAgent::now(), FtpSrvrAgent::now(), FtpClientAgent::now(), FackTcpAgent::oldack(), QueueMonitorCompat::out(), QueueMonitor::out(), TcpAgent::output(), VegasTcpAgent::output(), RFC793eduTcpAgent::output(), QSNewRenoTcpAgent::output(), IntTcpAgent::output(), IntTcpAgent::output_helper(), TcpFsAgent::output_helper(), DSDV_Agent::output_rte(), QA::panic(), BackoffTimer::pause(), LandmarkAgent::periodic_callback(), JoBS::pickDroppedRLC(), Cache::pickVictim(), Sack1TcpAgent::plot(), SackRHTcpAgent::plot(), FackTcpAgent::plot(), MultihopMac::poll(), TwoRayGround::Pr(), RouteCache::pre_addRoute(), TfrcSinkAgent::print_loss(), TfrcSinkAgent::print_loss_all(), PushbackAgent::printMsg(), QueueMonitor::printRTTs(), QueueMonitor::printSeqnos(), QueueMonitor::printStats(), TcpAgent::process_qoption_after_send(), DSRAgent::processBrokenRouteError(), LandmarkAgent::ProcessHierUpdate(), LogWebTrafPool::processLog(), TCPTapAgent::processpkt(), TcpAgent::processQuickStart(), DSRAgent::processUnknownFlowError(), DSDV_Agent::processUpdate(), JoBS::projDelay(), PushbackAgent::pushbackCancel(), PushbackEvent::PushbackEvent(), PushbackAgent::pushbackRefresh(), QueueMonitor::QueueMonitor(), RTPAgent::rate_change(), RateEstimator::RateEstimator(), TokenBucketRateLimiter::rateLimit(), RateLimitSession::RateLimitSession(), RateLimitStrategy::RateLimitStrategy(), DequeTrace::recv(), TfrcAgent::recv(), TfrcSinkAgent::recv(), TcpApp::recv(), QSNewRenoTcpAgent::recv(), NewRenoTcpAgent::recv(), BayFullTcpAgent::recv(), TcpAsymSink::recv(), TBF::recv(), SRMAgent::recv(), SSMSRMAgent::recv(), SRForwarder::recv(), LLSnoop::recv(), SessionHelper::recv(), SensorQueryAgent::recv(), SatDequeTrace::recv(), SALink::recv(), RapAgent::recv(), Queue< T >::recv(), PingResponder::recv(), PingAgent::recv(), IPNetwork::recv(), UDPIPNetwork::recv(), MIPMHAgent::recv(), MultihopMac::recv(), LossMonitor::recv(), PLMLossMonitor::recv(), LmsReceiver::recv(), LmsAgent::recv(), IvsReceiver::recv(), FQ::recv(), FloodAgent::recv(), ErrorModel::recv(), DSRAgent::recv(), DelayModel::recv(), LinkDelay::recv(), NoDupChannel::recv(), CBQClass::recv(), AdaptiveRcvr::recv(), AckRecons::recv(), SSMSRMAgent::recv_glb_sess(), HttpMInvalCache::recv_heartbeat(), TcpFsAgent::recv_helper(), HttpMInvalCache::recv_leave(), SSMSRMAgent::recv_loc_sess(), TcpFsAgent::recv_newack_helper(), TcpAsymAgent::recv_newack_helper(), SSMSRMAgent::recv_rep_sess(), SRMAgent::recv_sess(), HttpMInvalCache::recv_upd(), toraAgent::recvCLR(), TapAgent::recvpkt(), toraAgent::recvQRY(), toraAgent::recvUPD(), RateLimitSession::refreshed(), MClientPagePool::repl_atomic(), MClientPagePool::repl_finegrain(), DSRAgent::replyFromRouteCache(), TcpAgent::reset(), TcpSink::reset(), Snoop::reset(), RIOQueue::reset(), REDQueue::reset(), TokenBucketRateLimiter::reset(), RateEstimator::reset(), LinkDelay::reset(), TcpAgent::reset_qoption(), RateLimitStrategy::restrictPacketType(), Queue< T >::resume(), BackoffTimer::resume(), MacCsma::resume(), DSRAgent::returnSrcRouteToRequestor(), toraAgent::rt_resolve(), toraAgent::rtNotifyLinkUP(), TcpAgent::rtt_counting(), TcpAgent::rtt_update(), RFC793eduTcpAgent::rtt_update(), RapAgent::RttTimeout(), EWdetector::run(), TBrateLimitor::run(), Snoop::savepkt_(), SmacCounterTimer::sched(), SmacNeighNavTimer::sched(), SmacRecvTimer::sched(), CBQueue::sched(), SrmNode::sched_nack(), PushbackTimer::schedule(), MacHandlerIFS::schedule(), MacHandlerRetx::schedule(), MacHandlerRecv::schedule(), Mac8023HandlerSend::schedule(), TcpApp::send(), SrmNode::send(), MultihopMac::send(), MacCsmaCa::send(), MacCsma::send(), SSMSRMAgent::send_glb_sess(), LmsSender::send_lms_pkt(), SSMSRMAgent::send_loc_sess(), TcpAgent::send_much(), TcpSessionAgent::send_much(), LmsReceiver::send_nak(), SSMSRMAgent::send_rep_sess(), SRMAgent::send_sess(), LmsSender::send_spm(), AckRecons::sendack(), DSRAgent::sendBufferCheck(), DiffusionAgent::SendBufferCheck(), LandmarkAgent::SendChangedTagListUpdate(), SatMac::sendDown(), SatLL::sendDown(), Mac::sendDown(), LL::sendDown(), AODV::sendError(), EmpFtpTrafSession::sendFile(), AODV::sendHello(), UdpAgent::sendmsg(), SimpleTcpAgent::sendmsg(), LmsSender::sendmsg(), DSRAgent::sendOutBCastPkt(), DSDV_Agent::sendOutBCastPkt(), DSRAgent::sendOutPacketWithRoute(), DSRAgent::sendOutRtReq(), TfrcAgent::sendpkt(), TfrcSinkAgent::sendpkt(), SA_Agent::sendpkt(), RTPAgent::sendpkt(), IvsSource::sendpkt(), toraAgent::sendQRY(), AODV::sendReply(), AODV::sendRequest(), DSRAgent::sendRouteShortening(), DSRAgent::sendUnknownFlow(), WirelessPhy::sendUp(), SatMac::sendUp(), SatLL::sendUp(), Mac::sendUp(), Mac802_3::sendUp(), LL::sendUp(), Channel::sendUp(), MobileNode::set_destination(), Mac802_11::set_nav(), EnergyModel::set_node_sleep(), EnergyModel::set_node_state(), TBrateLimitor::setRate(), TfrcAgent::slowstart(), Snoop::snoop_cleanbufs_(), Snoop::snoop_data(), Snoop::snoop_insert(), LLSnoop::snoop_rtt(), Snoop::snoop_rtt(), Snoop::snoop_rxmit(), RapAgent::start(), MobileNode::start(), BackoffTimer::start(), DeferTimer::start(), MacTimer::start(), MacTdmaTimer::start(), LogWebTrafPool::start(), imepTimer::start(), AdaptiveFidelityEntity::start(), SoftNeighborHandler::start(), MobiHandler::start(), EnergyModel::start_powersaving(), LandmarkAgent::startUp(), DSDV_Agent::startUp(), OmniMcastAgent::StickPacketInSendBuffer(), DSRAgent::stickPacketInSendBuffer(), DiffusionAgent::StickPacketInSendBuffer(), SensorQueryAgent::stop(), RapAgent::stop(), MacTimer::stop(), MacTdmaTimer::stop(), LandmarkAgent::stop(), TaggerTBFlow::tagging(), TaggerTSWFlow::tagging(), DSRAgent::tap(), TBrateLimitor::TBrateLimitor(), PushbackQueue::timeout(), MIPMHAgent::timeout(), LmsReceiver::timeout(), SSMSRMAgent::timeout_info(), SmacNeighNavTimer::timeToExpire(), SmacRecvTimer::timeToExpire(), SmacCounterTimer::timeToSleep(), TokenBucketRateLimiter::TokenBucketRateLimiter(), TORANeighbor::TORANeighbor(), Vq::trace(), Trace::trace(), SALink::trace(), RIOQueue::trace(), REMQueue::trace(), REDQueue::trace(), PIQueue::trace(), Param_ADC::trace(), LDPAgent::trace(), GK::trace(), Estimator::trace(), MPLSAddressClassifier::trace(), Agent::trace(), TcpAgent::trace_event(), TcpAgent::traceAll(), TcpAsymAgent::traceAll(), TcpAgent::traceVar(), TcpSessionAgent::traceVar(), TcpAsymAgent::traceVar(), TransHistoryEntry::TransHistoryEntry(), DSRAgent::undeliverablePkt(), Acker::update(), MobileNode::update_position(), SMAC::updateNav(), SMAC::updateNeighNav(), ParentChildrenList::UpdatePotlChild(), ParentChildrenList::UpdatePotlParent(), redQueue::updateREDStateVar(), DSDV_Agent::updateRoute(), QA::UpdateState(), Queue< T >::updateStats(), JoBS::updateStats(), Queue< T >::utilization(), PingResponder::validate(), VegasTcpAgent::vegastime(), DSRAgent::xmitFailed(), DSRAgent::xmitFlowFailed(), and ParentChildrenList::~ParentChildrenList(). 

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

Event * CalendarScheduler::lookup (  scheduler_uid_t  uid  )  [virtual]
 

Implements Scheduler.

Definition at line 933 of file scheduler.cc.

References buckets_, head(), CalendarScheduler::Bucket::list_, nbuckets_, Event::next_, and Event::uid_. 

00934 {
00935         for (int i = 0; i < nbuckets_; i++) {
00936                 Event* head =  buckets_[i].list_;
00937                 Event* p = head;
00938                 if (p) {
00939                         do {
00940                                 if (p->uid_== uid) 
00941                                         return p;
00942                                 p = p->next_;
00943                         } while (p != head);
00944                 }
00945         }
00946         return NULL;
00947 }

Here is the call graph for this function:

double CalendarScheduler::newwidth (  int  newsize  )  [protected, virtual]
 

Definition at line 862 of file scheduler.cc.

References buckets_, CalendarScheduler::Bucket::count_, nbuckets_, and width_.

Referenced by resize(). 

00863 {
00864         int i;
00865         short max_bucket = 0; // index of the fullest bucket
00866         for (i = 1; i < nbuckets_; ++i) {
00867                 if (buckets_[i].count_ > buckets_[max_bucket].count_)
00868                         max_bucket = i;
00869         }
00870         int nsamples = buckets_[max_bucket].count_;
00871 
00872         if (nsamples <= 4) return width_;
00873         
00874         double nw = buckets_[max_bucket].list_->prev_->time_ 
00875                 - buckets_[max_bucket].list_->time_;
00876         assert(nw > 0);
00877         
00878         nw /= ((newsize < nsamples) ? newsize : nsamples); // min (newsize, nsamples)
00879         nw *= 4.0;
00880         
00881         return nw;
00882 }

void CalendarScheduler::reinit (  int  nbuck,
double  bwidth,
double  start
)  [protected, virtual]
 

Definition at line 804 of file scheduler.cc.

References bot_threshold_, buckets_, CALENDAR_HASH, diff0_, diff1_, diff2_, lastbucket_, nbuckets_, qsize_, stat_qsize_, top_threshold_, and width_.

Referenced by CalendarScheduler(), and resize(). 

00805 {
00806         buckets_ = new Bucket[nbuck];
00807 
00808         memset(buckets_, 0, sizeof(Bucket)*nbuck); //faster than ctor
00809 
00810         width_ = bwidth;
00811         nbuckets_ = nbuck;
00812         qsize_ = 0;
00813         stat_qsize_ = 0;
00814 
00815         lastbucket_ =  CALENDAR_HASH(start);
00816 
00817         diff0_ = bwidth*nbuck/2;
00818         diff1_ = diff0_ + bwidth;
00819         diff2_ = bwidth*nbuck;
00820         //diff3_ = bwidth*(nbuck*3/2-1);
00821 
00822         bot_threshold_ = (nbuck >> 1) - 2;
00823         top_threshold_ = (nbuck << 1);
00824 }

void Scheduler::reset (   )  [virtual, inherited]
 

Reimplemented in RealTimeScheduler.

Definition at line 182 of file scheduler.cc.

References Scheduler::clock_, and SCHED_START.

Referenced by Scheduler::command(). 

00183 {
00184         clock_ = SCHED_START;
00185 }

void CalendarScheduler::resize (  int  newsize,
double  start
)  [protected, virtual]
 

Definition at line 827 of file scheduler.cc.

References buckets_, insert2(), CalendarScheduler::Bucket::list_, nbuckets_, newwidth(), Event::next_, Event::prev_, and reinit().

Referenced by deque(), and insert(). 

00828 {
00829         double bwidth = newwidth(newsize);
00830 
00831         if (newsize < 4)
00832                 newsize = 4;
00833 
00834         Bucket *oldb = buckets_;
00835         int oldn = nbuckets_;
00836 
00837         reinit(newsize, bwidth, start);
00838 
00839         // copy events to new buckets
00840         int i;
00841 
00842         for (i = 0; i < oldn; ++i) {
00843                 // we can do inserts faster, if we use insert2, but to
00844                 // preserve FIFO, we have to start from the end of
00845                 // each bucket and use insert2
00846                 if  (oldb[i].list_) {
00847                         Event *tail = oldb[i].list_->prev_;
00848                         Event *e = tail; 
00849                         do {
00850                                 Event* ep = e->prev_;
00851                                 e->next_ = e->prev_ = 0;
00852                                 insert2(e);
00853                                 e = ep;
00854                         } while (e != tail);
00855                 }
00856         }
00857         delete [] oldb;
00858 }

Here is the call graph for this function:

void Scheduler::run (   )  [virtual, inherited]
 

Reimplemented in RealTimeScheduler.

Definition at line 118 of file scheduler.cc.

References Scheduler::deque(), Scheduler::dispatch(), Scheduler::halted_, and Scheduler::instance_.

Referenced by Scheduler::command(). 

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 }

Here is the call graph for this function:

void Scheduler::schedule (  Handler *  ,
Event *  ,
double  delay
)  [inherited]
 

Definition at line 83 of file scheduler.cc.

References abort(), Scheduler::clock_, Event::handler_, Scheduler::insert(), Event::time_, Scheduler::uid_, and Event::uid_.

Referenced by TimerHandler::_sched(), LandmarkAgent::AddMobileTag(), ARPTable::arpinput(), ARPTable::arprequest(), MacCsma::backoff(), Scheduler::command(), LandmarkAgent::command(), UnslottedAlohaMac::end_of_contention(), MacCsma::endofContention(), PromotionTimer::expire(), toraAgent::forward(), AODV::forward(), LandmarkAgent::ForwardPacket(), SensorQueryAgent::generate_query(), Snoop::handle(), PositionHandler::handle(), BackoffHandler::handle(), PollHandler::handle(), AdaptiveFidelityEntity::handle(), SoftNeighborHandler::handle(), DSDVTriggerHandler::handle(), RouteCacheTimer::handle(), NeighborTimer::handle(), HelloTimer::handle(), BroadcastTimer::handle(), DSRAgent::handleFlowForwarding(), DSDV_Agent::helper_callback(), AODV::local_rt_repair(), OmniMcastAgent::MACsend(), FloodingAgent::MACsend(), DiffusionAgent::MACsend(), LandmarkAgent::MoveTags(), DSDV_Agent::needTriggeredUpdate(), GridKeeper::new_moves(), LandmarkAgent::periodic_callback(), MultihopMac::poll(), LandmarkAgent::ProcessHierUpdate(), DSDV_Agent::processUpdate(), LLSnoop::recv(), SessionHelper::recv(), MultihopMac::recv(), FloodAgent::recv(), ErrorModel::recv(), DSRAgent::recv(), DelayModel::recv(), LinkDelay::recv(), NoDupChannel::recv(), TapAgent::recvpkt(), BackoffTimer::resume(), MacCsma::resume(), DSRAgent::returnSrcRouteToRequestor(), CBQueue::sched(), SrmNode::sched_nack(), MacHandlerIFS::schedule(), MacHandlerRetx::schedule(), MacHandlerRecv::schedule(), Mac8023HandlerSend::schedule(), SrmNode::send(), MultihopMac::send(), MacCsma::send(), AckRecons::sendack(), LandmarkAgent::SendChangedTagListUpdate(), SatMac::sendDown(), SatLL::sendDown(), Mac::sendDown(), LL::sendDown(), AODV::sendError(), AODV::sendHello(), DSRAgent::sendOutBCastPkt(), DSDV_Agent::sendOutBCastPkt(), DSRAgent::sendOutPacketWithRoute(), AODV::sendReply(), AODV::sendRequest(), SatMac::sendUp(), SatLL::sendUp(), Mac::sendUp(), LL::sendUp(), Channel::sendUp(), Snoop::snoop_cleanbufs_(), Snoop::snoop_data(), Snoop::snoop_rxmit(), MobileNode::start(), BackoffTimer::start(), DeferTimer::start(), MacTimer::start(), MacTdmaTimer::start(), imepTimer::start(), AdaptiveFidelityEntity::start(), SoftNeighborHandler::start(), MobiHandler::start(), LandmarkAgent::startUp(), and DSDV_Agent::startUp(). 

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 }

Here is the call graph for this function:

virtual double Scheduler::start (  void   )  [inline, virtual, inherited]
 

Definition at line 94 of file scheduler.h.

References SCHED_START. 

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

virtual void Scheduler::sync (   )  [inline, virtual, inherited]
 

Reimplemented in RealTimeScheduler.

Definition at line 93 of file scheduler.h.

Referenced by TapAgent::dispatch(). 

00093 {};

Member Data Documentation

int CalendarScheduler::bot_threshold_ [protected]
 

Definition at line 163 of file scheduler.h.

Referenced by deque(), and reinit().

struct CalendarScheduler::Bucket * CalendarScheduler::buckets_ [protected]
 

Referenced by cancel(), deque(), head(), insert(), insert2(), lookup(), newwidth(), reinit(), resize(), and ~CalendarScheduler().

double CalendarScheduler::cal_clock_ [private]
 

Definition at line 178 of file scheduler.h.

Referenced by CalendarScheduler(), deque(), head(), and insert().

double Scheduler::clock_ [protected, inherited]
 

Definition at line 105 of file scheduler.h.

Referenced by Scheduler::clock(), Scheduler::dispatch(), RealTimeScheduler::reset(), Scheduler::reset(), RealTimeScheduler::run(), Scheduler::schedule(), and RealTimeScheduler::sync().

double CalendarScheduler::diff0_ [protected]
 

Definition at line 157 of file scheduler.h.

Referenced by reinit().

double CalendarScheduler::diff1_ [protected]
 

Definition at line 157 of file scheduler.h.

Referenced by reinit().

double CalendarScheduler::diff2_ [protected]
 

Definition at line 157 of file scheduler.h.

Referenced by reinit().

int Scheduler::halted_ [protected, inherited]
 

Definition at line 106 of file scheduler.h.

Referenced by Scheduler::command(), RealTimeScheduler::run(), and Scheduler::run().

Scheduler * Scheduler::instance_ [static, protected, inherited]
 

Definition at line 55 of file scheduler.cc.

Referenced by Scheduler::command(), RealTimeScheduler::run(), Scheduler::run(), and Scheduler::~Scheduler().

int CalendarScheduler::lastbucket_ [protected]
 

Definition at line 161 of file scheduler.h.

Referenced by deque(), head(), insert(), and reinit().

int CalendarScheduler::nbuckets_ [protected]
 

Definition at line 160 of file scheduler.h.

Referenced by deque(), head(), insert(), lookup(), newwidth(), reinit(), and resize().

int CalendarScheduler::qsize_ [protected]
 

Definition at line 170 of file scheduler.h.

Referenced by cancel(), deque(), head(), insert(), insert2(), reinit(), and ~CalendarScheduler().

int CalendarScheduler::stat_qsize_ [protected]
 

Definition at line 159 of file scheduler.h.

Referenced by cancel(), deque(), insert(), insert2(), reinit(), and ~CalendarScheduler().

int CalendarScheduler::top_threshold_ [protected]
 

Definition at line 162 of file scheduler.h.

Referenced by insert(), and reinit().

scheduler_uid_t Scheduler::uid_ = 1 [static, protected, inherited]
 

Definition at line 56 of file scheduler.cc.

Referenced by Scheduler::schedule().

double CalendarScheduler::width_ [protected]
 

Definition at line 156 of file scheduler.h.

Referenced by newwidth(), and reinit().

The documentation for this class was generated from the following files:
Generated on Tue Apr 20 12:35:13 2004 for NS2.26SourcesOriginal by doxygen 1.3.3