| /********** |
| This library is free software; you can redistribute it and/or modify it under |
| the terms of the GNU Lesser General Public License as published by the |
| Free Software Foundation; either version 2.1 of the License, or (at your |
| option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.) |
| |
| This library is distributed in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
| FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for |
| more details. |
| |
| You should have received a copy of the GNU Lesser General Public License |
| along with this library; if not, write to the Free Software Foundation, Inc., |
| 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| **********/ |
| // Copyright (c) 1996-2015 Live Networks, Inc. All rights reserved. |
| // Basic Usage Environment: for a simple, non-scripted, console application |
| // Implementation |
| |
| |
| #include "BasicUsageEnvironment.hh" |
| #include "HandlerSet.hh" |
| #include <stdio.h> |
| #if defined(_QNX4) |
| #include <sys/select.h> |
| #include <unix.h> |
| #endif |
| |
| ////////// BasicTaskScheduler ////////// |
| |
| BasicTaskScheduler* BasicTaskScheduler::createNew(unsigned maxSchedulerGranularity) { |
| return new BasicTaskScheduler(maxSchedulerGranularity); |
| } |
| |
| BasicTaskScheduler::BasicTaskScheduler(unsigned maxSchedulerGranularity) |
| : fMaxSchedulerGranularity(maxSchedulerGranularity), fMaxNumSockets(0) |
| #if defined(__WIN32__) || defined(_WIN32) |
| , fDummySocketNum(-1) |
| #endif |
| { |
| FD_ZERO(&fReadSet); |
| FD_ZERO(&fWriteSet); |
| FD_ZERO(&fExceptionSet); |
| |
| if (maxSchedulerGranularity > 0) schedulerTickTask(); // ensures that we handle events frequently |
| } |
| |
| BasicTaskScheduler::~BasicTaskScheduler() { |
| #if defined(__WIN32__) || defined(_WIN32) |
| if (fDummySocketNum >= 0) closeSocket(fDummySocketNum); |
| #endif |
| } |
| |
| void BasicTaskScheduler::schedulerTickTask(void* clientData) { |
| ((BasicTaskScheduler*)clientData)->schedulerTickTask(); |
| } |
| |
| void BasicTaskScheduler::schedulerTickTask() { |
| scheduleDelayedTask(fMaxSchedulerGranularity, schedulerTickTask, this); |
| } |
| |
| #ifndef MILLION |
| #define MILLION 1000000 |
| #endif |
| |
| void BasicTaskScheduler::SingleStep(unsigned maxDelayTime) { |
| fd_set readSet = fReadSet; // make a copy for this select() call |
| fd_set writeSet = fWriteSet; // ditto |
| fd_set exceptionSet = fExceptionSet; // ditto |
| |
| 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, &writeSet, &exceptionSet, &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 = EINTR; |
| // To stop this from happening again, create a dummy socket: |
| if (fDummySocketNum >= 0) closeSocket(fDummySocketNum); |
| fDummySocketNum = socket(AF_INET, SOCK_DGRAM, 0); |
| FD_SET((unsigned)fDummySocketNum, &fReadSet); |
| } |
| if (err != EINTR) { |
| #else |
| if (errno != EINTR && errno != EAGAIN) { |
| #endif |
| // Unexpected error - treat this as fatal: |
| #if !defined(_WIN32_WCE) |
| perror("BasicTaskScheduler::SingleStep(): select() fails"); |
| // Because this failure is often "Bad file descriptor" - which is caused by an invalid socket number (i.e., a socket number |
| // that had already been closed) being used in "select()" - we print out the sockets that were being used in "select()", |
| // to assist in debugging: |
| fprintf(stderr, "socket numbers used in the select() call:"); |
| for (int i = 0; i < 10000; ++i) { |
| if (FD_ISSET(i, &fReadSet) || FD_ISSET(i, &fWriteSet) || FD_ISSET(i, &fExceptionSet)) { |
| fprintf(stderr, " %d(", i); |
| if (FD_ISSET(i, &fReadSet)) fprintf(stderr, "r"); |
| if (FD_ISSET(i, &fWriteSet)) fprintf(stderr, "w"); |
| if (FD_ISSET(i, &fExceptionSet)) fprintf(stderr, "e"); |
| fprintf(stderr, ")"); |
| } |
| } |
| fprintf(stderr, "\n"); |
| #endif |
| internalError(); |
| } |
| } |
| |
| // Call the handler function for one readable socket: |
| HandlerIterator iter(*fHandlers); |
| 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) { |
| int sock = handler->socketNum; // alias |
| int resultConditionSet = 0; |
| if (FD_ISSET(sock, &readSet) && FD_ISSET(sock, &fReadSet)/*sanity check*/) resultConditionSet |= SOCKET_READABLE; |
| if (FD_ISSET(sock, &writeSet) && FD_ISSET(sock, &fWriteSet)/*sanity check*/) resultConditionSet |= SOCKET_WRITABLE; |
| if (FD_ISSET(sock, &exceptionSet) && FD_ISSET(sock, &fExceptionSet)/*sanity check*/) resultConditionSet |= SOCKET_EXCEPTION; |
| if ((resultConditionSet&handler->conditionSet) != 0 && handler->handlerProc != NULL) { |
| fLastHandledSocketNum = sock; |
| // Note: we set "fLastHandledSocketNum" before calling the handler, |
| // in case the handler calls "doEventLoop()" reentrantly. |
| (*handler->handlerProc)(handler->clientData, resultConditionSet); |
| 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) { |
| int sock = handler->socketNum; // alias |
| int resultConditionSet = 0; |
| if (FD_ISSET(sock, &readSet) && FD_ISSET(sock, &fReadSet)/*sanity check*/) resultConditionSet |= SOCKET_READABLE; |
| if (FD_ISSET(sock, &writeSet) && FD_ISSET(sock, &fWriteSet)/*sanity check*/) resultConditionSet |= SOCKET_WRITABLE; |
| if (FD_ISSET(sock, &exceptionSet) && FD_ISSET(sock, &fExceptionSet)/*sanity check*/) resultConditionSet |= SOCKET_EXCEPTION; |
| if ((resultConditionSet&handler->conditionSet) != 0 && handler->handlerProc != NULL) { |
| fLastHandledSocketNum = sock; |
| // Note: we set "fLastHandledSocketNum" before calling the handler, |
| // in case the handler calls "doEventLoop()" reentrantly. |
| (*handler->handlerProc)(handler->clientData, resultConditionSet); |
| break; |
| } |
| } |
| if (handler == NULL) fLastHandledSocketNum = -1;//because we didn't call a handler |
| } |
| |
| // Also handle any newly-triggered event (Note that we do this *after* calling a socket handler, |
| // in case the triggered event handler modifies The set of readable sockets.) |
| if (fTriggersAwaitingHandling != 0) { |
| if (fTriggersAwaitingHandling == fLastUsedTriggerMask) { |
| // Common-case optimization for a single event trigger: |
| fTriggersAwaitingHandling &=~ fLastUsedTriggerMask; |
| if (fTriggeredEventHandlers[fLastUsedTriggerNum] != NULL) { |
| (*fTriggeredEventHandlers[fLastUsedTriggerNum])(fTriggeredEventClientDatas[fLastUsedTriggerNum]); |
| } |
| } else { |
| // Look for an event trigger that needs handling (making sure that we make forward progress through all possible triggers): |
| unsigned i = fLastUsedTriggerNum; |
| EventTriggerId mask = fLastUsedTriggerMask; |
| |
| do { |
| i = (i+1)%MAX_NUM_EVENT_TRIGGERS; |
| mask >>= 1; |
| if (mask == 0) mask = 0x80000000; |
| |
| if ((fTriggersAwaitingHandling&mask) != 0) { |
| fTriggersAwaitingHandling &=~ mask; |
| if (fTriggeredEventHandlers[i] != NULL) { |
| (*fTriggeredEventHandlers[i])(fTriggeredEventClientDatas[i]); |
| } |
| |
| fLastUsedTriggerMask = mask; |
| fLastUsedTriggerNum = i; |
| break; |
| } |
| } while (i != fLastUsedTriggerNum); |
| } |
| } |
| |
| // Also handle any delayed event that may have come due. |
| fDelayQueue.handleAlarm(); |
| } |
| |
| void BasicTaskScheduler |
| ::setBackgroundHandling(int socketNum, int conditionSet, BackgroundHandlerProc* handlerProc, void* clientData) { |
| if (socketNum < 0) return; |
| #if !defined(__WIN32__) && !defined(_WIN32) && defined(FD_SETSIZE) |
| if (socketNum >= (int)(FD_SETSIZE)) return; |
| #endif |
| FD_CLR((unsigned)socketNum, &fReadSet); |
| FD_CLR((unsigned)socketNum, &fWriteSet); |
| FD_CLR((unsigned)socketNum, &fExceptionSet); |
| if (conditionSet == 0) { |
| fHandlers->clearHandler(socketNum); |
| if (socketNum+1 == fMaxNumSockets) { |
| --fMaxNumSockets; |
| } |
| } else { |
| fHandlers->assignHandler(socketNum, conditionSet, handlerProc, clientData); |
| if (socketNum+1 > fMaxNumSockets) { |
| fMaxNumSockets = socketNum+1; |
| } |
| if (conditionSet&SOCKET_READABLE) FD_SET((unsigned)socketNum, &fReadSet); |
| if (conditionSet&SOCKET_WRITABLE) FD_SET((unsigned)socketNum, &fWriteSet); |
| if (conditionSet&SOCKET_EXCEPTION) FD_SET((unsigned)socketNum, &fExceptionSet); |
| } |
| } |
| |
| void BasicTaskScheduler::moveSocketHandling(int oldSocketNum, int newSocketNum) { |
| if (oldSocketNum < 0 || newSocketNum < 0) return; // sanity check |
| #if !defined(__WIN32__) && !defined(_WIN32) && defined(FD_SETSIZE) |
| if (oldSocketNum >= (int)(FD_SETSIZE) || newSocketNum >= (int)(FD_SETSIZE)) return; // sanity check |
| #endif |
| if (FD_ISSET(oldSocketNum, &fReadSet)) {FD_CLR((unsigned)oldSocketNum, &fReadSet); FD_SET((unsigned)newSocketNum, &fReadSet);} |
| if (FD_ISSET(oldSocketNum, &fWriteSet)) {FD_CLR((unsigned)oldSocketNum, &fWriteSet); FD_SET((unsigned)newSocketNum, &fWriteSet);} |
| if (FD_ISSET(oldSocketNum, &fExceptionSet)) {FD_CLR((unsigned)oldSocketNum, &fExceptionSet); FD_SET((unsigned)newSocketNum, &fExceptionSet);} |
| fHandlers->moveHandler(oldSocketNum, newSocketNum); |
| |
| if (oldSocketNum+1 == fMaxNumSockets) { |
| --fMaxNumSockets; |
| } |
| if (newSocketNum+1 > fMaxNumSockets) { |
| fMaxNumSockets = newSocketNum+1; |
| } |
| } |