BasicTaskScheduler Class Reference

#include <BasicUsageEnvironment.hh>

Inheritance diagram for BasicTaskScheduler:

Inheritance graph
[legend]
Collaboration diagram for BasicTaskScheduler:

Collaboration graph
[legend]

Public Types

typedef void BackgroundHandlerProc (void *clientData, int mask)

Public Member Functions

virtual ~BasicTaskScheduler ()
virtual TaskToken scheduleDelayedTask (int64_t microseconds, TaskFunc *proc, void *clientData)
virtual void unscheduleDelayedTask (TaskToken &prevTask)
virtual void doEventLoop (char *watchVariable)
virtual EventTriggerId createEventTrigger (TaskFunc *eventHandlerProc)
virtual void deleteEventTrigger (EventTriggerId eventTriggerId)
virtual void triggerEvent (EventTriggerId eventTriggerId, void *clientData=NULL)
virtual void rescheduleDelayedTask (TaskToken &task, int64_t microseconds, TaskFunc *proc, void *clientData)
virtual void setBackgroundHandling (int socketNum, int conditionSet, BackgroundHandlerProc *handlerProc, void *clientData)=0
void disableBackgroundHandling (int socketNum)
void turnOnBackgroundReadHandling (int socketNum, BackgroundHandlerProc *handlerProc, void *clientData)
void turnOffBackgroundReadHandling (int socketNum)
virtual void internalError ()

Static Public Member Functions

static BasicTaskScheduler * createNew ()

Protected Member Functions

 BasicTaskScheduler ()
virtual void SingleStep (unsigned maxDelayTime)
virtual void setBackgroundHandling (int socketNum, int conditionSet, BackgroundHandlerProc *handlerProc, void *clientData)
virtual void moveSocketHandling (int oldSocketNum, int newSocketNum)

Protected Attributes

int fMaxNumSockets
fd_set fReadSet
fd_set fWriteSet
fd_set fExceptionSet
DelayQueue fDelayQueue
HandlerSet * fHandlers
int fLastHandledSocketNum
EventTriggerId fTriggersAwaitingHandling
EventTriggerId fLastUsedTriggerMask
TaskFunc * fTriggeredEventHandlers [MAX_NUM_EVENT_TRIGGERS]
void * fTriggeredEventClientDatas [MAX_NUM_EVENT_TRIGGERS]
unsigned fLastUsedTriggerNum

Detailed Description

Definition at line 47 of file BasicUsageEnvironment.hh.

Member Typedef Documentation

typedef void TaskScheduler::BackgroundHandlerProc(void *clientData, int mask) [inherited]

Definition at line 128 of file UsageEnvironment.hh.

Constructor & Destructor Documentation

BasicTaskScheduler::~BasicTaskScheduler (  )  [virtual]

Definition at line 49 of file BasicTaskScheduler.cpp.

00049                                         {
00050 }

BasicTaskScheduler::BasicTaskScheduler (  )  [protected]

Definition at line 40 of file BasicTaskScheduler.cpp.

References fExceptionSet, fReadSet, fWriteSet, and schedulerTickTask().

Referenced by createNew().

00041   : fMaxNumSockets(0) {
00042   FD_ZERO(&fReadSet);
00043   FD_ZERO(&fWriteSet);
00044   FD_ZERO(&fExceptionSet);
00045 
00046   schedulerTickTask(this); // ensures that we handle events frequently
00047 }

Member Function Documentation

BasicTaskScheduler * BasicTaskScheduler::createNew (  )  [static]

Definition at line 31 of file BasicTaskScheduler.cpp.

References BasicTaskScheduler().

Referenced by main().

00031                                                   {
00032         return new BasicTaskScheduler();
00033 }

void BasicTaskScheduler::SingleStep ( unsigned  maxDelayTime  )  [protected, virtual]

Implements BasicTaskScheduler0.

Definition at line 56 of file BasicTaskScheduler.cpp.

References HandlerDescriptor::clientData, HandlerDescriptor::conditionSet, BasicTaskScheduler0::fDelayQueue, fExceptionSet, BasicTaskScheduler0::fHandlers, BasicTaskScheduler0::fLastHandledSocketNum, BasicTaskScheduler0::fLastUsedTriggerMask, BasicTaskScheduler0::fLastUsedTriggerNum, fMaxNumSockets, fReadSet, BasicTaskScheduler0::fTriggeredEventClientDatas, BasicTaskScheduler0::fTriggeredEventHandlers, BasicTaskScheduler0::fTriggersAwaitingHandling, fWriteSet, DelayQueue::handleAlarm(), HandlerDescriptor::handlerProc, TaskScheduler::internalError(), iter, MAX_NUM_EVENT_TRIGGERS, MILLION, MediaSubsessionIterator::next(), NULL, MediaSubsessionIterator::reset(), Timeval::seconds(), setBackgroundHandling(), SOCKET_EXCEPTION, SOCKET_READABLE, SOCKET_WRITABLE, HandlerDescriptor::socketNum, DelayQueue::timeToNextAlarm(), and Timeval::useconds().

00056                                                          {
00057   fd_set readSet = fReadSet; // make a copy for this select() call
00058   fd_set writeSet = fWriteSet; // ditto
00059   fd_set exceptionSet = fExceptionSet; // ditto
00060 
00061   DelayInterval const& timeToDelay = fDelayQueue.timeToNextAlarm();
00062   struct timeval tv_timeToDelay;
00063   tv_timeToDelay.tv_sec = timeToDelay.seconds();
00064   tv_timeToDelay.tv_usec = timeToDelay.useconds();
00065   // Very large "tv_sec" values cause select() to fail.
00066   // Don't make it any larger than 1 million seconds (11.5 days)
00067   const long MAX_TV_SEC = MILLION;
00068   if (tv_timeToDelay.tv_sec > MAX_TV_SEC) {
00069     tv_timeToDelay.tv_sec = MAX_TV_SEC;
00070   }
00071   // Also check our "maxDelayTime" parameter (if it's > 0):
00072   if (maxDelayTime > 0 &&
00073       (tv_timeToDelay.tv_sec > (long)maxDelayTime/MILLION ||
00074        (tv_timeToDelay.tv_sec == (long)maxDelayTime/MILLION &&
00075         tv_timeToDelay.tv_usec > (long)maxDelayTime%MILLION))) {
00076     tv_timeToDelay.tv_sec = maxDelayTime/MILLION;
00077     tv_timeToDelay.tv_usec = maxDelayTime%MILLION;
00078   }
00079 
00080   int selectResult = select(fMaxNumSockets, &readSet, &writeSet, &exceptionSet, &tv_timeToDelay);
00081   if (selectResult < 0) {
00082 #if defined(__WIN32__) || defined(_WIN32)
00083     int err = WSAGetLastError();
00084     // For some unknown reason, select() in Windoze sometimes fails with WSAEINVAL if
00085     // it was called with no entries set in "readSet".  If this happens, ignore it:
00086     if (err == WSAEINVAL && readSet.fd_count == 0) {
00087       err = EINTR;
00088       // To stop this from happening again, create a dummy socket:
00089       int dummySocketNum = socket(AF_INET, SOCK_DGRAM, 0);
00090       FD_SET((unsigned)dummySocketNum, &fReadSet);
00091     }
00092     if (err != EINTR) {
00093 #else
00094     if (errno != EINTR && errno != EAGAIN) {
00095 #endif
00096         // Unexpected error - treat this as fatal:
00097 #if !defined(_WIN32_WCE)
00098         perror("BasicTaskScheduler::SingleStep(): select() fails");
00099 #endif
00100         internalError();
00101       }
00102   }
00103 
00104   // Call the handler function for one readable socket:
00105   HandlerIterator iter(*fHandlers);
00106   HandlerDescriptor* handler;
00107   // To ensure forward progress through the handlers, begin past the last
00108   // socket number that we handled:
00109   if (fLastHandledSocketNum >= 0) {
00110     while ((handler = iter.next()) != NULL) {
00111       if (handler->socketNum == fLastHandledSocketNum) break;
00112     }
00113     if (handler == NULL) {
00114       fLastHandledSocketNum = -1;
00115       iter.reset(); // start from the beginning instead
00116     }
00117   }
00118   while ((handler = iter.next()) != NULL) {
00119     int sock = handler->socketNum; // alias
00120     int resultConditionSet = 0;
00121     if (FD_ISSET(sock, &readSet) && FD_ISSET(sock, &fReadSet)/*sanity check*/) resultConditionSet |= SOCKET_READABLE;
00122     if (FD_ISSET(sock, &writeSet) && FD_ISSET(sock, &fWriteSet)/*sanity check*/) resultConditionSet |= SOCKET_WRITABLE;
00123     if (FD_ISSET(sock, &exceptionSet) && FD_ISSET(sock, &fExceptionSet)/*sanity check*/) resultConditionSet |= SOCKET_EXCEPTION;
00124     if ((resultConditionSet&handler->conditionSet) != 0 && handler->handlerProc != NULL) {
00125       fLastHandledSocketNum = sock;
00126           // Note: we set "fLastHandledSocketNum" before calling the handler,
00127           // in case the handler calls "doEventLoop()" reentrantly.
00128       (*handler->handlerProc)(handler->clientData, resultConditionSet);
00129       break;
00130     }
00131   }
00132   if (handler == NULL && fLastHandledSocketNum >= 0) {
00133     // We didn't call a handler, but we didn't get to check all of them,
00134     // so try again from the beginning:
00135     iter.reset();
00136     while ((handler = iter.next()) != NULL) {
00137       int sock = handler->socketNum; // alias
00138       int resultConditionSet = 0;
00139       if (FD_ISSET(sock, &readSet) && FD_ISSET(sock, &fReadSet)/*sanity check*/) resultConditionSet |= SOCKET_READABLE;
00140       if (FD_ISSET(sock, &writeSet) && FD_ISSET(sock, &fWriteSet)/*sanity check*/) resultConditionSet |= SOCKET_WRITABLE;
00141       if (FD_ISSET(sock, &exceptionSet) && FD_ISSET(sock, &fExceptionSet)/*sanity check*/) resultConditionSet |= SOCKET_EXCEPTION;
00142       if ((resultConditionSet&handler->conditionSet) != 0 && handler->handlerProc != NULL) {
00143         fLastHandledSocketNum = sock;
00144             // Note: we set "fLastHandledSocketNum" before calling the handler,
00145             // in case the handler calls "doEventLoop()" reentrantly.
00146         (*handler->handlerProc)(handler->clientData, resultConditionSet);
00147         break;
00148       }
00149     }
00150     if (handler == NULL) fLastHandledSocketNum = -1;//because we didn't call a handler
00151   }
00152 
00153   // Also handle any newly-triggered event (Note that we do this *after* calling a socket handler,
00154   // in case the triggered event handler modifies The set of readable sockets.)
00155   if (fTriggersAwaitingHandling != 0) {
00156     if (fTriggersAwaitingHandling == fLastUsedTriggerMask) {
00157       // Common-case optimization for a single event trigger:
00158       fTriggersAwaitingHandling = 0;
00159       if (fTriggeredEventHandlers[fLastUsedTriggerNum] != NULL) {
00160         (*fTriggeredEventHandlers[fLastUsedTriggerNum])(fTriggeredEventClientDatas[fLastUsedTriggerNum]);
00161       }
00162     } else {
00163       // Look for an event trigger that needs handling (making sure that we make forward progress through all possible triggers):
00164       unsigned i = fLastUsedTriggerNum;
00165       EventTriggerId mask = fLastUsedTriggerMask;
00166 
00167       do {
00168         i = (i+1)%MAX_NUM_EVENT_TRIGGERS;
00169         mask >>= 1;
00170         if (mask == 0) mask = 0x80000000;
00171 
00172         if ((fTriggersAwaitingHandling&mask) != 0) {
00173           fTriggersAwaitingHandling &=~ mask;
00174           if (fTriggeredEventHandlers[i] != NULL) {
00175             (*fTriggeredEventHandlers[i])(fTriggeredEventClientDatas[i]);
00176           }
00177 
00178           fLastUsedTriggerMask = mask;
00179           fLastUsedTriggerNum = i;
00180           break;
00181         }
00182       } while (i != fLastUsedTriggerNum);
00183     }
00184   }
00185 
00186   // Also handle any delayed event that may have come due.
00187   fDelayQueue.handleAlarm();
00188 }

void BasicTaskScheduler::setBackgroundHandling ( int  socketNum,
int  conditionSet,
BackgroundHandlerProc *  handlerProc,
void *  clientData 
) [protected, virtual]

Definition at line 191 of file BasicTaskScheduler.cpp.

References HandlerSet::assignHandler(), HandlerSet::clearHandler(), fExceptionSet, BasicTaskScheduler0::fHandlers, fMaxNumSockets, fReadSet, fWriteSet, SOCKET_EXCEPTION, SOCKET_READABLE, and SOCKET_WRITABLE.

Referenced by SingleStep().

00191                                                                                                                {
00192   if (socketNum < 0) return;
00193   FD_CLR((unsigned)socketNum, &fReadSet);
00194   FD_CLR((unsigned)socketNum, &fWriteSet);
00195   FD_CLR((unsigned)socketNum, &fExceptionSet);
00196   if (conditionSet == 0) {
00197     fHandlers->clearHandler(socketNum);
00198     if (socketNum+1 == fMaxNumSockets) {
00199       --fMaxNumSockets;
00200     }
00201   } else {
00202     fHandlers->assignHandler(socketNum, conditionSet, handlerProc, clientData);
00203     if (socketNum+1 > fMaxNumSockets) {
00204       fMaxNumSockets = socketNum+1;
00205     }
00206     if (conditionSet&SOCKET_READABLE) FD_SET((unsigned)socketNum, &fReadSet);
00207     if (conditionSet&SOCKET_WRITABLE) FD_SET((unsigned)socketNum, &fWriteSet);
00208     if (conditionSet&SOCKET_EXCEPTION) FD_SET((unsigned)socketNum, &fExceptionSet);
00209   }
00210 }

void BasicTaskScheduler::moveSocketHandling ( int  oldSocketNum,
int  newSocketNum 
) [protected, virtual]

Implements TaskScheduler.

Definition at line 212 of file BasicTaskScheduler.cpp.

References fExceptionSet, BasicTaskScheduler0::fHandlers, fMaxNumSockets, fReadSet, fWriteSet, and HandlerSet::moveHandler().

00212                                                                               {
00213   if (oldSocketNum < 0 || newSocketNum < 0) return; // sanity check
00214   if (FD_ISSET(oldSocketNum, &fReadSet)) {FD_CLR((unsigned)oldSocketNum, &fReadSet); FD_SET((unsigned)newSocketNum, &fReadSet);}
00215   if (FD_ISSET(oldSocketNum, &fWriteSet)) {FD_CLR((unsigned)oldSocketNum, &fWriteSet); FD_SET((unsigned)newSocketNum, &fWriteSet);}
00216   if (FD_ISSET(oldSocketNum, &fExceptionSet)) {FD_CLR((unsigned)oldSocketNum, &fExceptionSet); FD_SET((unsigned)newSocketNum, &fExceptionSet);}
00217   fHandlers->moveHandler(oldSocketNum, newSocketNum);
00218 
00219   if (oldSocketNum+1 == fMaxNumSockets) {
00220     --fMaxNumSockets;
00221   }
00222   if (newSocketNum+1 > fMaxNumSockets) {
00223     fMaxNumSockets = newSocketNum+1;
00224   }
00225 }

TaskToken BasicTaskScheduler0::scheduleDelayedTask ( int64_t  microseconds,
TaskFunc *  proc,
void *  clientData 
) [virtual, inherited]

Implements TaskScheduler.

Definition at line 59 of file BasicTaskScheduler0.cpp.

References DelayQueue::addEntry(), BasicTaskScheduler0::fDelayQueue, and DelayQueueEntry::token().

00061                                                                    {
00062   if (microseconds < 0) microseconds = 0;
00063   DelayInterval timeToDelay((long)(microseconds/1000000), (long)(microseconds%1000000));
00064   AlarmHandler* alarmHandler = new AlarmHandler(proc, clientData, timeToDelay);
00065   fDelayQueue.addEntry(alarmHandler);
00066 
00067   return (void*)(alarmHandler->token());
00068 }

void BasicTaskScheduler0::unscheduleDelayedTask ( TaskToken &  prevTask  )  [virtual, inherited]

Implements TaskScheduler.

Definition at line 70 of file BasicTaskScheduler0.cpp.

References BasicTaskScheduler0::fDelayQueue, NULL, and DelayQueue::removeEntry().

00070                                                                    {
00071   DelayQueueEntry* alarmHandler = fDelayQueue.removeEntry((intptr_t)prevTask);
00072   prevTask = NULL;
00073   delete alarmHandler;
00074 }

void BasicTaskScheduler0::doEventLoop ( char *  watchVariable  )  [virtual, inherited]

Implements TaskScheduler.

Definition at line 76 of file BasicTaskScheduler0.cpp.

References NULL, and BasicTaskScheduler0::SingleStep().

00076                                                          {
00077   // Repeatedly loop, handling readble sockets and timed events:
00078   while (1) {
00079     if (watchVariable != NULL && *watchVariable != 0) break;
00080     SingleStep();
00081   }
00082 }

EventTriggerId BasicTaskScheduler0::createEventTrigger ( TaskFunc *  eventHandlerProc  )  [virtual, inherited]

Implements TaskScheduler.

Definition at line 84 of file BasicTaskScheduler0.cpp.

References BasicTaskScheduler0::fLastUsedTriggerMask, BasicTaskScheduler0::fLastUsedTriggerNum, BasicTaskScheduler0::fTriggeredEventClientDatas, BasicTaskScheduler0::fTriggeredEventHandlers, MAX_NUM_EVENT_TRIGGERS, and NULL.

00084                                                                                  {
00085   unsigned i = fLastUsedTriggerNum;
00086   EventTriggerId mask = fLastUsedTriggerMask;
00087 
00088   do {
00089     i = (i+1)%MAX_NUM_EVENT_TRIGGERS;
00090     mask >>= 1;
00091     if (mask == 0) mask = 0x80000000;
00092 
00093     if (fTriggeredEventHandlers[i] == NULL) {
00094       // This trigger number is free; use it:
00095       fTriggeredEventHandlers[i] = eventHandlerProc;
00096       fTriggeredEventClientDatas[i] = NULL; // sanity
00097 
00098       fLastUsedTriggerMask = mask;
00099       fLastUsedTriggerNum = i;
00100 
00101       return mask;
00102     }
00103   } while (i != fLastUsedTriggerNum);
00104 
00105   // All available event triggers are allocated; return 0 instead:
00106   return 0;
00107 }

void BasicTaskScheduler0::deleteEventTrigger ( EventTriggerId  eventTriggerId  )  [virtual, inherited]

Implements TaskScheduler.

Definition at line 109 of file BasicTaskScheduler0.cpp.

References BasicTaskScheduler0::fLastUsedTriggerMask, BasicTaskScheduler0::fLastUsedTriggerNum, BasicTaskScheduler0::fTriggeredEventClientDatas, BasicTaskScheduler0::fTriggeredEventHandlers, BasicTaskScheduler0::fTriggersAwaitingHandling, MAX_NUM_EVENT_TRIGGERS, and NULL.

00109                                                                           {
00110   fTriggersAwaitingHandling &=~ eventTriggerId;
00111 
00112   if (eventTriggerId == fLastUsedTriggerMask) { // common-case optimization:
00113     fTriggeredEventHandlers[fLastUsedTriggerNum] = NULL;
00114     fTriggeredEventClientDatas[fLastUsedTriggerNum] = NULL;
00115   } else {
00116     // "eventTriggerId" should have just one bit set.
00117     // However, we do the reasonable thing if the user happened to 'or' together two or more "EventTriggerId"s:
00118     EventTriggerId mask = 0x80000000;
00119     for (unsigned i = 0; i < MAX_NUM_EVENT_TRIGGERS; ++i) {
00120       if ((eventTriggerId&mask) != 0) {
00121         fTriggeredEventHandlers[i] = NULL;
00122         fTriggeredEventClientDatas[i] = NULL;
00123       }
00124       mask >>= 1;
00125     }
00126   }
00127 }

void BasicTaskScheduler0::triggerEvent ( EventTriggerId  eventTriggerId,
void *  clientData = NULL 
) [virtual, inherited]

Implements TaskScheduler.

Definition at line 129 of file BasicTaskScheduler0.cpp.

References BasicTaskScheduler0::fLastUsedTriggerMask, BasicTaskScheduler0::fLastUsedTriggerNum, BasicTaskScheduler0::fTriggeredEventClientDatas, BasicTaskScheduler0::fTriggersAwaitingHandling, and MAX_NUM_EVENT_TRIGGERS.

00129                                                                                       {
00130   // First, record the "clientData":
00131   if (eventTriggerId == fLastUsedTriggerMask) { // common-case optimization:
00132     fTriggeredEventClientDatas[fLastUsedTriggerNum] = clientData;
00133   } else {
00134     EventTriggerId mask = 0x80000000;
00135     for (unsigned i = 0; i < MAX_NUM_EVENT_TRIGGERS; ++i) {
00136       if ((eventTriggerId&mask) != 0) {
00137         fTriggeredEventClientDatas[i] = clientData;
00138 
00139         fLastUsedTriggerMask = mask;
00140         fLastUsedTriggerNum = i;
00141       }
00142       mask >>= 1;
00143     }
00144   }
00145 
00146   // Then, note this event as being ready to be handled.
00147   // (Note that because this function (unlike others in the library) can be called from an external thread, we do this last, to
00148   //  reduce the risk of a race condition.)
00149   fTriggersAwaitingHandling |= eventTriggerId;
00150 }

void TaskScheduler::rescheduleDelayedTask ( TaskToken &  task,
int64_t  microseconds,
TaskFunc *  proc,
void *  clientData 
) [virtual, inherited]

Definition at line 46 of file UsageEnvironment.cpp.

References TaskScheduler::scheduleDelayedTask(), and TaskScheduler::unscheduleDelayedTask().

Referenced by RTSPServer::RTSPClientSession::noteLiveness().

00048                                                             {
00049   unscheduleDelayedTask(task);
00050   task = scheduleDelayedTask(microseconds, proc, clientData);
00051 }

virtual void TaskScheduler::setBackgroundHandling ( int  socketNum,
int  conditionSet,
BackgroundHandlerProc *  handlerProc,
void *  clientData 
) [pure virtual, inherited]

Referenced by RTSPClient::connectionHandler1(), RTSPClient::connectToServer(), TaskScheduler::disableBackgroundHandling(), RTSPClient::openConnection(), TCPStreamSink::processBuffer(), and TaskScheduler::turnOnBackgroundReadHandling().

void TaskScheduler::disableBackgroundHandling ( int  socketNum  )  [inline, inherited]

Definition at line 135 of file UsageEnvironment.hh.

References NULL, and TaskScheduler::setBackgroundHandling().

Referenced by RTSPClient::connectionHandler1(), RTSPClient::resetTCPSockets(), TCPStreamSink::socketWritableHandler1(), and TaskScheduler::turnOffBackgroundReadHandling().

00135 { setBackgroundHandling(socketNum, 0, NULL, NULL); }

void TaskScheduler::turnOnBackgroundReadHandling ( int  socketNum,
BackgroundHandlerProc *  handlerProc,
void *  clientData 
) [inline, inherited]

Definition at line 155 of file UsageEnvironment.hh.

References TaskScheduler::setBackgroundHandling(), and SOCKET_READABLE.

Referenced by RTSPServer::RTSPClientSession::changeClientInputSocket(), ByteStreamFileSource::doGetNextFrame(), BasicUDPSource::doGetNextFrame(), SIPClient::invite1(), RTSPServer::RTSPClientSession::RTSPClientSession(), RTSPServer::RTSPServer(), and RTSPServer::setUpTunnelingOverHTTP().

00155                                                                                                          {
00156     setBackgroundHandling(socketNum, SOCKET_READABLE, handlerProc, clientData);
00157   }

void TaskScheduler::turnOffBackgroundReadHandling ( int  socketNum  )  [inline, inherited]

Definition at line 158 of file UsageEnvironment.hh.

References TaskScheduler::disableBackgroundHandling().

Referenced by RTCPInstance::addStreamSocket(), RTSPServer::RTSPClientSession::changeClientInputSocket(), Socket::changePort(), RTSPServer::RTSPClientSession::closeSockets(), SocketDescriptor::deregisterRTPInterface(), ByteStreamFileSource::doStopGettingFrames(), BasicUDPSource::doStopGettingFrames(), SIPClient::invite1(), RTPInterface::stopNetworkReading(), SocketDescriptor::tcpReadHandler1(), BasicUDPSource::~BasicUDPSource(), ByteStreamFileSource::~ByteStreamFileSource(), and RTSPServer::~RTSPServer().

00158 { disableBackgroundHandling(socketNum); }

void TaskScheduler::internalError (  )  [virtual, inherited]

Definition at line 54 of file UsageEnvironment.cpp.

Referenced by SingleStep().

00054                                   {
00055   abort();
00056 }

Field Documentation

int BasicTaskScheduler::fMaxNumSockets [protected]

Definition at line 65 of file BasicUsageEnvironment.hh.

Referenced by moveSocketHandling(), setBackgroundHandling(), and SingleStep().

fd_set BasicTaskScheduler::fReadSet [protected]

Definition at line 66 of file BasicUsageEnvironment.hh.

Referenced by BasicTaskScheduler(), moveSocketHandling(), setBackgroundHandling(), and SingleStep().

fd_set BasicTaskScheduler::fWriteSet [protected]

Definition at line 67 of file BasicUsageEnvironment.hh.

Referenced by BasicTaskScheduler(), moveSocketHandling(), setBackgroundHandling(), and SingleStep().

fd_set BasicTaskScheduler::fExceptionSet [protected]

Definition at line 68 of file BasicUsageEnvironment.hh.

Referenced by BasicTaskScheduler(), moveSocketHandling(), setBackgroundHandling(), and SingleStep().

DelayQueue BasicTaskScheduler0::fDelayQueue [protected, inherited]

Definition at line 100 of file BasicUsageEnvironment0.hh.

Referenced by BasicTaskScheduler0::scheduleDelayedTask(), SingleStep(), and BasicTaskScheduler0::unscheduleDelayedTask().

HandlerSet* BasicTaskScheduler0::fHandlers [protected, inherited]

Definition at line 103 of file BasicUsageEnvironment0.hh.

Referenced by BasicTaskScheduler0::BasicTaskScheduler0(), moveSocketHandling(), setBackgroundHandling(), SingleStep(), and BasicTaskScheduler0::~BasicTaskScheduler0().

int BasicTaskScheduler0::fLastHandledSocketNum [protected, inherited]

Definition at line 104 of file BasicUsageEnvironment0.hh.

Referenced by SingleStep().

EventTriggerId BasicTaskScheduler0::fTriggersAwaitingHandling [protected, inherited]

Definition at line 107 of file BasicUsageEnvironment0.hh.

Referenced by BasicTaskScheduler0::deleteEventTrigger(), SingleStep(), and BasicTaskScheduler0::triggerEvent().

EventTriggerId BasicTaskScheduler0::fLastUsedTriggerMask [protected, inherited]

Definition at line 107 of file BasicUsageEnvironment0.hh.

Referenced by BasicTaskScheduler0::createEventTrigger(), BasicTaskScheduler0::deleteEventTrigger(), SingleStep(), and BasicTaskScheduler0::triggerEvent().

TaskFunc* BasicTaskScheduler0::fTriggeredEventHandlers[MAX_NUM_EVENT_TRIGGERS] [protected, inherited]

Definition at line 108 of file BasicUsageEnvironment0.hh.

Referenced by BasicTaskScheduler0::BasicTaskScheduler0(), BasicTaskScheduler0::createEventTrigger(), BasicTaskScheduler0::deleteEventTrigger(), and SingleStep().

void* BasicTaskScheduler0::fTriggeredEventClientDatas[MAX_NUM_EVENT_TRIGGERS] [protected, inherited]

Definition at line 109 of file BasicUsageEnvironment0.hh.

Referenced by BasicTaskScheduler0::BasicTaskScheduler0(), BasicTaskScheduler0::createEventTrigger(), BasicTaskScheduler0::deleteEventTrigger(), SingleStep(), and BasicTaskScheduler0::triggerEvent().

unsigned BasicTaskScheduler0::fLastUsedTriggerNum [protected, inherited]

Definition at line 110 of file BasicUsageEnvironment0.hh.

Referenced by BasicTaskScheduler0::createEventTrigger(), BasicTaskScheduler0::deleteEventTrigger(), SingleStep(), and BasicTaskScheduler0::triggerEvent().

The documentation for this class was generated from the following files:
Generated on Thu Feb 2 23:54:42 2012 for live by  doxygen 1.5.2