BasicTaskScheduler Class Reference

#include <BasicUsageEnvironment.hh>

Inheritance diagram for BasicTaskScheduler:

[legend]Collaboration diagram for BasicTaskScheduler:

[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 void	rescheduleDelayedTask (TaskToken &task, int64_t microseconds, TaskFunc *proc, void *clientData)
virtual void	turnOnBackgroundReadHandling (int socketNum, BackgroundHandlerProc *handlerProc, void *clientData)=0
Static Public Member Functions
static BasicTaskScheduler *	createNew ()
Protected Member Functions
	BasicTaskScheduler ()
virtual void	SingleStep (unsigned maxDelayTime)
virtual void	turnOnBackgroundReadHandling (int socketNum, BackgroundHandlerProc *handlerProc, void *clientData)
virtual void	turnOffBackgroundReadHandling (int socketNum)
Protected Attributes
int	fMaxNumSockets
fd_set	fReadSet
DelayQueue	fDelayQueue
HandlerSet *	fReadHandlers
int	fLastHandledSocketNum

---

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 121 of file UsageEnvironment.hh.

---

Constructor & Destructor Documentation

BasicTaskScheduler::~BasicTaskScheduler

(

)

[virtual]

Definition at line 41 of file BasicTaskScheduler.cpp.

                                        {
}

BasicTaskScheduler::BasicTaskScheduler

(

)

[protected]

Definition at line 36 of file BasicTaskScheduler.cpp.

References fReadSet.

Referenced by createNew().

  : fMaxNumSockets(0) {
  FD_ZERO(&fReadSet);
}

---

Member Function Documentation

BasicTaskScheduler * BasicTaskScheduler::createNew

(

)

[static]

Definition at line 32 of file BasicTaskScheduler.cpp.

References BasicTaskScheduler().

Referenced by main().

                                                  {
        return new BasicTaskScheduler();
}

void BasicTaskScheduler::SingleStep

(

unsigned

maxDelayTime

)

[protected, virtual]

Implements BasicTaskScheduler0.

Definition at line 48 of file BasicTaskScheduler.cpp.

References HandlerDescriptor::clientData, BasicTaskScheduler0::fDelayQueue, BasicTaskScheduler0::fLastHandledSocketNum, fMaxNumSockets, BasicTaskScheduler0::fReadHandlers, fReadSet, DelayQueue::handleAlarm(), HandlerDescriptor::handlerProc, iter, MILLION, MediaSubsessionIterator::next(), NULL, MediaSubsessionIterator::reset(), Timeval::seconds(), SOCKET_READABLE, HandlerDescriptor::socketNum, DelayQueue::timeToNextAlarm(), and Timeval::useconds().

                                                         {
  fd_set readSet = fReadSet; // make a copy for this select() call
  
  DelayInterval const& timeToDelay = fDelayQueue.timeToNextAlarm();
  struct timeval tv_timeToDelay;
  tv_timeToDelay.tv_sec = timeToDelay.seconds();
  tv_timeToDelay.tv_usec = timeToDelay.useconds();
  // Very large "tv_sec" values cause select() to fail.
  // Don't make it any larger than 1 million seconds (11.5 days)
  const long MAX_TV_SEC = MILLION;
  if (tv_timeToDelay.tv_sec > MAX_TV_SEC) {
    tv_timeToDelay.tv_sec = MAX_TV_SEC;
  }
  // Also check our "maxDelayTime" parameter (if it's > 0):
  if (maxDelayTime > 0 &&
      (tv_timeToDelay.tv_sec > (long)maxDelayTime/MILLION ||
       (tv_timeToDelay.tv_sec == (long)maxDelayTime/MILLION &&
        tv_timeToDelay.tv_usec > (long)maxDelayTime%MILLION))) {
    tv_timeToDelay.tv_sec = maxDelayTime/MILLION;
    tv_timeToDelay.tv_usec = maxDelayTime%MILLION;
  }
  
  int selectResult = select(fMaxNumSockets, &readSet, NULL, NULL,
                            &tv_timeToDelay);
  if (selectResult < 0) {
#if defined(__WIN32__) || defined(_WIN32)
    int err = WSAGetLastError();
    // For some unknown reason, select() in Windoze sometimes fails with WSAEINVAL if
    // it was called with no entries set in "readSet".  If this happens, ignore it:
    if (err == WSAEINVAL && readSet.fd_count == 0) {
      err = 0;
      // To stop this from happening again, create a dummy readable socket:
      int dummySocketNum = socket(AF_INET, SOCK_DGRAM, 0);
      FD_SET((unsigned)dummySocketNum, &fReadSet);
    }
    if (err != 0) {
#else
    if (errno != EINTR && errno != EAGAIN) {
#endif
        // Unexpected error - treat this as fatal:
#if !defined(_WIN32_WCE)
        perror("BasicTaskScheduler::SingleStep(): select() fails");
#endif
        exit(0);
      }
  }
  
  // Handle any delayed event that may have come due:
  fDelayQueue.handleAlarm();
  
  // Call the handler function for one readable socket:
  HandlerIterator iter(*fReadHandlers);
  HandlerDescriptor* handler;
  // To ensure forward progress through the handlers, begin past the last
  // socket number that we handled:
  if (fLastHandledSocketNum >= 0) {
    while ((handler = iter.next()) != NULL) {
      if (handler->socketNum == fLastHandledSocketNum) break;
    }
    if (handler == NULL) {
      fLastHandledSocketNum = -1;
      iter.reset(); // start from the beginning instead
    }
  }
  while ((handler = iter.next()) != NULL) {
    if (FD_ISSET(handler->socketNum, &readSet) &&
        FD_ISSET(handler->socketNum, &fReadSet) /* sanity check */ &&
        handler->handlerProc != NULL) {
      fLastHandledSocketNum = handler->socketNum;
          // Note: we set "fLastHandledSocketNum" before calling the handler,
          // in case the handler calls "doEventLoop()" reentrantly.
      (*handler->handlerProc)(handler->clientData, SOCKET_READABLE);
      break;
    }
  }
  if (handler == NULL && fLastHandledSocketNum >= 0) {
    // We didn't call a handler, but we didn't get to check all of them,
    // so try again from the beginning:
    iter.reset();
    while ((handler = iter.next()) != NULL) {
      if (FD_ISSET(handler->socketNum, &readSet) &&
          FD_ISSET(handler->socketNum, &fReadSet) /* sanity check */ &&
          handler->handlerProc != NULL) {
        fLastHandledSocketNum = handler->socketNum;
            // Note: we set "fLastHandledSocketNum" before calling the handler,
            // in case the handler calls "doEventLoop()" reentrantly.
        (*handler->handlerProc)(handler->clientData, SOCKET_READABLE);
        break;
      }
    }
    if (handler == NULL) fLastHandledSocketNum = -1;//because we didn't call a handler
  }
}

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

Definition at line 142 of file BasicTaskScheduler.cpp.

References HandlerSet::assignHandler(), fMaxNumSockets, BasicTaskScheduler0::fReadHandlers, and fReadSet.

                                                  {
  if (socketNum < 0) return;
  FD_SET((unsigned)socketNum, &fReadSet);
  fReadHandlers->assignHandler(socketNum, handlerProc, clientData);

  if (socketNum+1 > fMaxNumSockets) {
    fMaxNumSockets = socketNum+1;
  }
}

void BasicTaskScheduler::turnOffBackgroundReadHandling

(

int

socketNum

)

[protected, virtual]

Implements TaskScheduler.

Definition at line 154 of file BasicTaskScheduler.cpp.

References fMaxNumSockets, BasicTaskScheduler0::fReadHandlers, fReadSet, and HandlerSet::removeHandler().

                                                                    {
  if (socketNum < 0) return;
  FD_CLR((unsigned)socketNum, &fReadSet);
  fReadHandlers->removeHandler(socketNum);

  if (socketNum+1 == fMaxNumSockets) {
    --fMaxNumSockets;
  }
}

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

Implements TaskScheduler.

Definition at line 55 of file BasicTaskScheduler0.cpp.

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

                                                                   {
  if (microseconds < 0) microseconds = 0;
  DelayInterval timeToDelay((long)(microseconds/1000000), (long)(microseconds%1000000));
  AlarmHandler* alarmHandler = new AlarmHandler(proc, clientData, timeToDelay);
  fDelayQueue.addEntry(alarmHandler);

  return (void*)(alarmHandler->token()); 
}

void BasicTaskScheduler0::unscheduleDelayedTask

(

TaskToken &

prevTask

)

[virtual, inherited]

Implements TaskScheduler.

Definition at line 66 of file BasicTaskScheduler0.cpp.

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

                                                                   {
  DelayQueueEntry* alarmHandler = fDelayQueue.removeEntry((long)prevTask);
  prevTask = NULL;
  delete alarmHandler;
}

void BasicTaskScheduler0::doEventLoop

(

char *

watchVariable

)

[virtual, inherited]

Implements TaskScheduler.

Definition at line 72 of file BasicTaskScheduler0.cpp.

References NULL, and BasicTaskScheduler0::SingleStep().

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

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

Definition at line 40 of file UsageEnvironment.cpp.

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

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

                                                            {
  unscheduleDelayedTask(task);
  task = scheduleDelayedTask(microseconds, proc, clientData);
}

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

Referenced by ByteStreamFileSource::doGetNextFrame(), BasicUDPSource::doGetNextFrame(), RTSPOverHTTPServer::HTTPClientConnection::HTTPClientConnection(), SIPClient::invite1(), RTSPClient::playMediaSession(), RTSPServer::RTSPClientSession::RTSPClientSession(), RTSPOverHTTPServer::RTSPOverHTTPServer(), and RTSPServer::RTSPServer().

---

Field Documentation

int BasicTaskScheduler::fMaxNumSockets [protected]

Definition at line 67 of file BasicUsageEnvironment.hh.

Referenced by SingleStep(), turnOffBackgroundReadHandling(), and turnOnBackgroundReadHandling().

fd_set BasicTaskScheduler::fReadSet [protected]

Definition at line 68 of file BasicUsageEnvironment.hh.

Referenced by BasicTaskScheduler(), SingleStep(), turnOffBackgroundReadHandling(), and turnOnBackgroundReadHandling().

DelayQueue BasicTaskScheduler0::fDelayQueue [protected, inherited]

Definition at line 94 of file BasicUsageEnvironment0.hh.

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

HandlerSet* BasicTaskScheduler0::fReadHandlers [protected, inherited]

Definition at line 97 of file BasicUsageEnvironment0.hh.

Referenced by BasicTaskScheduler0::BasicTaskScheduler0(), SingleStep(), turnOffBackgroundReadHandling(), turnOnBackgroundReadHandling(), and BasicTaskScheduler0::~BasicTaskScheduler0().

int BasicTaskScheduler0::fLastHandledSocketNum [protected, inherited]

Definition at line 98 of file BasicUsageEnvironment0.hh.

Referenced by SingleStep().

---

The documentation for this class was generated from the following files:

• BasicUsageEnvironment/include/BasicUsageEnvironment.hh
• BasicUsageEnvironment/BasicTaskScheduler.cpp

---