diff --git a/src/libCom/timer/epicsTimer.cpp b/src/libCom/timer/epicsTimer.cpp index 81f9b7071..bd4dc6d77 100644 --- a/src/libCom/timer/epicsTimer.cpp +++ b/src/libCom/timer/epicsTimer.cpp @@ -30,95 +30,126 @@ #define epicsExportSharedSymbols #include "epicsTimer.h" -#include "epicsTimerPrivate.h" +#include "timerPrivate.h" -void epicsTimerNotify::show ( unsigned /* level */ ) const {} - -class epicsTimerNotifyForC : public epicsTimerNotify { +struct epicsTimerForC : public epicsTimerNotify, public timer { public: - epicsTimerNotifyForC ( epicsTimerCallback, void *pPrivateIn ); + epicsTimerForC ( timerQueue &, epicsTimerCallback, void *pPrivateIn ); + void destroy (); void * operator new ( size_t size ); void operator delete ( void *pCadaver, size_t size ); protected: - virtual ~epicsTimerNotifyForC (); + virtual ~epicsTimerForC (); private: epicsTimerCallback pCallBack; void * pPrivate; expireStatus expire (); - static tsFreeList < epicsTimerNotifyForC > freeList; + static tsFreeList < epicsTimerForC > freeList; }; -class epicsTimerQueueNotifyForC : public epicsTimerQueueNotify { +struct epicsTimerQueuePassiveForC : public epicsTimerQueueNotify, public timerQueuePassive { public: - epicsTimerQueueNotifyForC ( epicsTimerQueueRescheduleCallback pCallback, void *pPrivate ); + epicsTimerQueuePassiveForC ( epicsTimerQueueRescheduleCallback pCallback, void *pPrivate ); + void destroy (); void * operator new ( size_t size ); void operator delete ( void *pCadaver, size_t size ); protected: - virtual ~epicsTimerQueueNotifyForC (); + virtual ~epicsTimerQueuePassiveForC (); private: epicsTimerQueueRescheduleCallback pCallback; void *pPrivate; void reschedule (); - static tsFreeList < epicsTimerQueueNotifyForC > freeList; + static tsFreeList < epicsTimerQueuePassiveForC > freeList; }; -tsFreeList < epicsTimerNotifyForC > epicsTimerNotifyForC::freeList; +void epicsTimerNotify::show ( unsigned /* level */ ) const {} -inline void * epicsTimerNotifyForC::operator new ( size_t size ) -{ - return epicsTimerNotifyForC::freeList.allocate ( size ); +tsFreeList < epicsTimerForC > epicsTimerForC::freeList; + +epicsTimerForC::epicsTimerForC ( timerQueue &queue, epicsTimerCallback pCBIn, void *pPrivateIn ) : + timer ( *this, queue ), pCallBack ( pCBIn ), pPrivate ( pPrivateIn ) +{ } -inline void epicsTimerNotifyForC::operator delete ( void *pCadaver, size_t size ) -{ - epicsTimerNotifyForC::freeList.release ( pCadaver, size ); +epicsTimerForC::~epicsTimerForC () +{ } -epicsTimerNotifyForC::epicsTimerNotifyForC ( epicsTimerCallback pCBIn, void *pPrivateIn ) : - pCallBack ( pCBIn ), pPrivate ( pPrivateIn ) {} +inline void epicsTimerForC::destroy () +{ + delete this; +} -epicsTimerNotifyForC::~epicsTimerNotifyForC () {} +inline void * epicsTimerForC::operator new ( size_t size ) +{ + return epicsTimerForC::freeList.allocate ( size ); +} -epicsTimerNotify::expireStatus epicsTimerNotifyForC::expire () +inline void epicsTimerForC::operator delete ( void *pCadaver, size_t size ) +{ + epicsTimerForC::freeList.release ( pCadaver, size ); +} + +epicsTimerNotify::expireStatus epicsTimerForC::expire () { ( *this->pCallBack ) ( this->pPrivate ); return noRestart; } -tsFreeList < epicsTimerQueueNotifyForC > epicsTimerQueueNotifyForC::freeList; +tsFreeList < epicsTimerQueueForC > epicsTimerQueueForC::freeList; -inline void * epicsTimerQueueNotifyForC::operator new ( size_t size ) -{ - return epicsTimerQueueNotifyForC::freeList.allocate ( size ); +epicsTimerQueueForC::epicsTimerQueueForC ( bool okToShare, unsigned priority ) : + timerQueueActive ( okToShare, priority ) +{ } -inline void epicsTimerQueueNotifyForC::operator delete ( void *pCadaver, size_t size ) -{ - epicsTimerQueueNotifyForC::freeList.release ( pCadaver, size ); +epicsTimerQueueForC::~epicsTimerQueueForC () +{ } +void epicsTimerQueueForC::release () +{ + queueMgr.release ( *this ); +} -epicsTimerQueueNotifyForC::epicsTimerQueueNotifyForC ( epicsTimerQueueRescheduleCallback pCallbackIn, void *pPrivateIn ) : - pCallback ( pCallbackIn ), pPrivate ( pPrivateIn ) {} +tsFreeList < epicsTimerQueuePassiveForC > epicsTimerQueuePassiveForC::freeList; -epicsTimerQueueNotifyForC::~epicsTimerQueueNotifyForC () {} +inline void * epicsTimerQueuePassiveForC::operator new ( size_t size ) +{ + return epicsTimerQueuePassiveForC::freeList.allocate ( size ); +} -void epicsTimerQueueNotifyForC::reschedule () +inline void epicsTimerQueuePassiveForC::operator delete ( void *pCadaver, size_t size ) +{ + epicsTimerQueuePassiveForC::freeList.release ( pCadaver, size ); +} + +epicsTimerQueuePassiveForC::epicsTimerQueuePassiveForC + ( epicsTimerQueueRescheduleCallback pCallbackIn, void * pPrivateIn ) : + timerQueuePassive ( * static_cast < epicsTimerQueueNotify * > ( this ) ), + pCallback ( pCallbackIn ), pPrivate ( pPrivateIn ) +{ +} + +epicsTimerQueuePassiveForC::~epicsTimerQueuePassiveForC () +{ +} + +void epicsTimerQueuePassiveForC::reschedule () { (*this->pCallback) ( this->pPrivate ); } -extern "C" epicsTimerQueueNonThreadedId epicsShareAPI - epicsTimerQueueNonThreadedCreate ( epicsTimerQueueRescheduleCallback pCallbackIn, void *pPrivateIn ) +inline void epicsTimerQueuePassiveForC::destroy () +{ + delete this; +} + +extern "C" epicsTimerQueuePassiveId epicsShareAPI + epicsTimerQueuePassiveCreate ( epicsTimerQueueRescheduleCallback pCallbackIn, void *pPrivateIn ) { try { - epicsTimerQueueNotifyForC *pNotify = new epicsTimerQueueNotifyForC ( pCallbackIn, pPrivateIn ); - if ( ! pNotify ) { - throw timer::noMemory (); - } - epicsTimerQueueNonThreaded &queue = - epicsTimerQueueNonThreaded::create ( *pNotify ); - return &queue; + return new epicsTimerQueuePassiveForC ( pCallbackIn, pPrivateIn ); } catch ( ... ) { return 0; @@ -126,75 +157,46 @@ extern "C" epicsTimerQueueNonThreadedId epicsShareAPI } extern "C" void epicsShareAPI - epicsTimerQueueNonThreadedDestroy ( epicsTimerQueueNonThreadedId pQueue ) + epicsTimerQueuePassiveDestroy ( epicsTimerQueuePassiveId pQueue ) { - delete pQueue; + pQueue->destroy (); } extern "C" void epicsShareAPI - epicsTimerQueueNonThreadedProcess ( epicsTimerQueueNonThreadedId pQueue ) + epicsTimerQueuePassiveProcess ( epicsTimerQueuePassiveId pQueue ) { pQueue->process (); } extern "C" double epicsShareAPI - epicsTimerQueueNonThreadedGetDelayToNextExpire ( - epicsTimerQueueNonThreadedId pQueue ) + epicsTimerQueuePassiveGetDelayToNextExpire ( + epicsTimerQueuePassiveId pQueue ) { return pQueue->getNextExpireDelay (); } -extern "C" epicsTimerId epicsShareAPI epicsTimerQueueNonThreadedCreateTimer ( - epicsTimerQueueNonThreadedId pQueue, - epicsTimerCallback pCallback, void *pArg ) +extern "C" epicsTimerId epicsShareAPI epicsTimerQueuePassiveCreateTimer ( + epicsTimerQueuePassiveId pQueue, epicsTimerCallback pCallback, void *pArg ) { try { - epicsTimerNotifyForC *pNotify = new epicsTimerNotifyForC ( pCallback, pArg ); - if ( ! pNotify ) { - throw timer::noMemory (); - } - epicsTimer &tmr = pQueue->createTimer ( *pNotify ); - return &tmr; + return new epicsTimerForC ( pQueue->getTimerQueue (), pCallback, pArg ); } catch ( ... ) { return 0; } } -extern "C" void epicsShareAPI epicsTimerQueueNonThreadedShow ( - epicsTimerQueueNonThreadedId pQueue, unsigned int level ) +extern "C" void epicsShareAPI epicsTimerQueuePassiveShow ( + epicsTimerQueuePassiveId pQueue, unsigned int level ) { pQueue->show ( level ); } -extern "C" epicsTimerQueueThreadedId epicsShareAPI - epicsTimerQueueThreadedCreate ( int okToShare, unsigned int threadPriority ) +extern "C" epicsTimerQueueId epicsShareAPI + epicsTimerQueueCreate ( int okToShare, unsigned int threadPriority ) { try { - epicsTimerQueueThreaded & queue = - epicsTimerQueueThreaded::allocate - ( okToShare ? true : false, threadPriority ); - return &queue; - } - catch ( ... ) { - return 0; - } -} - -extern "C" void epicsShareAPI epicsTimerQueueThreadedDelete ( epicsTimerQueueThreadedId pQueue ) -{ - pQueue->release (); -} - -extern "C" epicsTimerId epicsShareAPI epicsTimerQueueThreadedCreateTimer ( - epicsTimerQueueThreadedId pQueue, epicsTimerCallback pCallback, void *pArg ) -{ - try { - epicsTimerNotifyForC *pNotify = new epicsTimerNotifyForC ( pCallback, pArg ); - if ( ! pNotify ) { - throw timer::noMemory (); - } - epicsTimer &tmr = pQueue->createTimer ( *pNotify ); + epicsTimerQueueForC &tmr = queueMgr.allocate ( okToShare ? true : false, threadPriority ); return &tmr; } catch ( ... ) { @@ -202,15 +204,31 @@ extern "C" epicsTimerId epicsShareAPI epicsTimerQueueThreadedCreateTimer ( } } -extern "C" void epicsShareAPI epicsTimerQueueThreadedShow ( - epicsTimerQueueThreadedId pQueue, unsigned int level ) +extern "C" void epicsShareAPI epicsTimerQueueDelete ( epicsTimerQueueId pQueue ) +{ + pQueue->release (); +} + +extern "C" epicsTimerId epicsShareAPI epicsTimerQueueCreateTimer ( + epicsTimerQueueId pQueue, epicsTimerCallback pCallback, void *pArg ) +{ + try { + return new epicsTimerForC ( pQueue->getTimerQueue (), pCallback, pArg ); + } + catch ( ... ) { + return 0; + } +} + +extern "C" void epicsShareAPI epicsTimerQueueShow ( + epicsTimerQueueId pQueue, unsigned int level ) { pQueue->show ( level ); } extern "C" void epicsShareAPI epicsTimerDestroy ( epicsTimerId pTmr ) { - delete pTmr; + pTmr->destroy (); } extern "C" void epicsShareAPI epicsTimerStartTime ( @@ -238,6 +256,6 @@ extern "C" double epicsShareAPI epicsTimerGetExpireDelay ( epicsTimerId pTmr ) extern "C" void epicsShareAPI epicsTimerShow ( epicsTimerId pTmr, unsigned int level ) { - pTmr->show ( level ); + pTmr->timer::show ( level ); } diff --git a/src/libCom/timer/epicsTimer.h b/src/libCom/timer/epicsTimer.h index a7c08281b..8aaa7be9e 100644 --- a/src/libCom/timer/epicsTimer.h +++ b/src/libCom/timer/epicsTimer.h @@ -39,7 +39,7 @@ public: virtual void show ( unsigned int level ) const; }; -struct epicsShareClass epicsTimer { +class epicsShareClass epicsTimer { public: virtual ~epicsTimer () = 0; virtual void start ( const epicsTime & ) = 0; @@ -49,15 +49,15 @@ public: virtual void show ( unsigned int level ) const = 0; }; -struct epicsShareClass epicsTimerQueueThreaded { +class epicsShareClass epicsTimerQueue { public: - static epicsTimerQueueThreaded & allocate ( + static epicsTimerQueue & allocate ( bool okToShare, int threadPriority = epicsThreadPriorityMin + 10 ); virtual void release () = 0; virtual epicsTimer & createTimer ( epicsTimerNotify & ) = 0; virtual void show ( unsigned int level ) const = 0; protected: - virtual ~epicsTimerQueueThreaded () = 0; + virtual ~epicsTimerQueue () = 0; }; class epicsTimerQueueNotify { @@ -67,10 +67,10 @@ public: virtual void reschedule () = 0; }; -struct epicsShareClass epicsTimerQueueNonThreaded { +class epicsShareClass epicsTimerQueuePassive { public: - static epicsTimerQueueNonThreaded & create ( epicsTimerQueueNotify & ); - virtual ~epicsTimerQueueNonThreaded () = 0; + static epicsTimerQueuePassive & create ( epicsTimerQueueNotify & ); + virtual ~epicsTimerQueuePassive () = 0; virtual epicsTimer & createTimer ( epicsTimerNotify & ) = 0; virtual void process () = 0; virtual double getNextExpireDelay () const = 0; @@ -104,40 +104,40 @@ inline double epicsTimerNotify::expireStatus::expirationDelay () const extern "C" { #endif /* __cplusplus */ -typedef struct epicsTimer * epicsTimerId; +typedef struct epicsTimerForC * epicsTimerId; typedef void ( *epicsTimerCallback ) ( void *pPrivate ); -/* threaded timer queue management */ -typedef struct epicsTimerQueueThreaded * epicsTimerQueueThreadedId; -epicsShareFunc epicsTimerQueueThreadedId epicsShareAPI - epicsTimerQueueThreadedAllocate ( int okToShare, unsigned int threadPriority ); +/* thread managed timer queue */ +typedef struct epicsTimerQueueForC * epicsTimerQueueId; +epicsShareFunc epicsTimerQueueId epicsShareAPI + epicsTimerQueueAllocate ( int okToShare, unsigned int threadPriority ); epicsShareFunc void epicsShareAPI - epicsTimerQueueThreadedRelease ( epicsTimerQueueThreadedId ); + epicsTimerQueueRelease ( epicsTimerQueueId ); epicsShareFunc epicsTimerId epicsShareAPI - epicsTimerQueueThreadedCreateTimer ( epicsTimerQueueThreadedId queueid, + epicsTimerQueueCreateTimer ( epicsTimerQueueId queueid, epicsTimerCallback callback, void *arg ); epicsShareFunc void epicsShareAPI - epicsTimerQueueThreadedShow ( epicsTimerQueueThreadedId id, unsigned int level ); + epicsTimerQueueShow ( epicsTimerQueueId id, unsigned int level ); -/* non-threaded timer queue management */ -typedef struct epicsTimerQueueNonThreaded * epicsTimerQueueNonThreadedId; +/* passive timer queue */ +typedef struct epicsTimerQueuePassiveForC * epicsTimerQueuePassiveId; typedef void ( *epicsTimerQueueRescheduleCallback ) ( void *pPrivate ); -epicsShareFunc epicsTimerQueueNonThreadedId epicsShareAPI - epicsTimerQueueNonThreadedCreate ( epicsTimerQueueRescheduleCallback, void *pPrivate ); +epicsShareFunc epicsTimerQueuePassiveId epicsShareAPI + epicsTimerQueuePassiveCreate ( epicsTimerQueueRescheduleCallback, void *pPrivate ); epicsShareFunc void epicsShareAPI - epicsTimerQueueNonThreadedDestroy ( epicsTimerQueueNonThreadedId ); + epicsTimerQueuePassiveDestroy ( epicsTimerQueuePassiveId ); epicsShareFunc epicsTimerId epicsShareAPI - epicsTimerQueueNonThreadedCreateTimer ( - epicsTimerQueueNonThreadedId queueid, epicsTimerCallback pCallback, void *pArg ); + epicsTimerQueuePassiveCreateTimer ( + epicsTimerQueuePassiveId queueid, epicsTimerCallback pCallback, void *pArg ); epicsShareFunc void epicsShareAPI - epicsTimerQueueNonThreadedProcess ( epicsTimerQueueNonThreadedId ); + epicsTimerQueuePassiveProcess ( epicsTimerQueuePassiveId ); epicsShareFunc double epicsShareAPI - epicsTimerQueueNonThreadedGetDelayToNextExpire ( - epicsTimerQueueNonThreadedId ); -epicsShareFunc void epicsShareAPI epicsTimerQueueNonThreadedShow ( - epicsTimerQueueNonThreadedId id, unsigned int level ); + epicsTimerQueuePassiveGetDelayToNextExpire ( + epicsTimerQueuePassiveId ); +epicsShareFunc void epicsShareAPI epicsTimerQueuePassiveShow ( + epicsTimerQueuePassiveId id, unsigned int level ); -/* timer management */ +/* timer */ epicsShareFunc void epicsShareAPI epicsTimerDestroy ( epicsTimerId id ); epicsShareFunc void epicsShareAPI diff --git a/src/libCom/timer/timer.cpp b/src/libCom/timer/timer.cpp index 7149d1f00..bfd69cd09 100644 --- a/src/libCom/timer/timer.cpp +++ b/src/libCom/timer/timer.cpp @@ -30,7 +30,7 @@ */ #define epicsExportSharedSymbols -#include "epicsTimerPrivate.h" +#include "timerPrivate.h" tsFreeList < class timer, 0x20 > timer::freeList; diff --git a/src/libCom/timer/epicsTimerPrivate.h b/src/libCom/timer/timerPrivate.h similarity index 66% rename from src/libCom/timer/epicsTimerPrivate.h rename to src/libCom/timer/timerPrivate.h index 127840ca5..9a7335862 100644 --- a/src/libCom/timer/epicsTimerPrivate.h +++ b/src/libCom/timer/timerPrivate.h @@ -85,31 +85,27 @@ private: friend class timer; }; -class timerQueueThreadedMgrPrivate { +class timerQueueActiveMgrPrivate { public: - timerQueueThreadedMgrPrivate (); + timerQueueActiveMgrPrivate (); protected: - virtual ~timerQueueThreadedMgrPrivate () = 0; + virtual ~timerQueueActiveMgrPrivate () = 0; private: unsigned referenceCount; - friend class timerQueueThreadedMgr; + friend class timerQueueActiveMgr; }; -class timerQueueThreaded : public epicsTimerQueueThreaded, +class timerQueueActive : public epicsTimerQueue, public epicsThreadRunable, public epicsTimerQueueNotify, - public timerQueueThreadedMgrPrivate, - public tsDLNode < timerQueueThreaded > { + public timerQueueActiveMgrPrivate { public: - timerQueueThreaded ( bool okToShare, unsigned priority ); + timerQueueActive ( bool okToShare, unsigned priority ); + ~timerQueueActive () = 0; epicsTimer & createTimer ( epicsTimerNotify & ); void show ( unsigned int level ) const; - void * operator new ( size_t size ); - void operator delete ( void *pCadaver, size_t size ); - void release (); bool sharingOK () const; int threadPriority () const; -protected: - ~timerQueueThreaded (); + timerQueue & getTimerQueue (); private: timerQueue queue; epicsEvent rescheduleEvent; @@ -120,31 +116,50 @@ private: bool terminateFlag; void run (); void reschedule (); - static tsFreeList < class timerQueueThreaded, 0x8 > freeList; }; -class timerQueueThreadedMgr { +struct epicsTimerQueueForC : public timerQueueActive, + public tsDLNode < epicsTimerQueueForC > { public: - ~timerQueueThreadedMgr (); - timerQueueThreaded & allocate ( bool okToShare, + epicsTimerQueueForC ( bool okToShare, unsigned priority ); + void release (); + void * operator new ( size_t size ); + void operator delete ( void *pCadaver, size_t size ); +protected: + virtual ~epicsTimerQueueForC (); +private: + static tsFreeList < epicsTimerQueueForC > freeList; +}; + +class timerQueueActiveMgr { +public: + ~timerQueueActiveMgr (); + epicsTimerQueueForC & allocate ( bool okToShare, int threadPriority = epicsThreadPriorityMin + 10 ); - void release ( timerQueueThreaded & ); + void release ( epicsTimerQueueForC & ); private: epicsMutex mutex; - tsDLList < timerQueueThreaded > sharedQueueList; + tsDLList < epicsTimerQueueForC > sharedQueueList; }; -class timerQueueNonThreaded : public epicsTimerQueueNonThreaded { +extern timerQueueActiveMgr queueMgr; + +class timerQueuePassive : public epicsTimerQueuePassive { public: - timerQueueNonThreaded ( epicsTimerQueueNotify & ); - ~timerQueueNonThreaded (); + timerQueuePassive ( epicsTimerQueueNotify & ); epicsTimer & createTimer ( epicsTimerNotify & ); void process (); double getNextExpireDelay () const; void show ( unsigned int level ) const; void release (); + timerQueue & getTimerQueue (); + void * operator new ( size_t size ); + void operator delete ( void *pCadaver, size_t size ); +protected: + ~timerQueuePassive (); private: timerQueue queue; + static tsFreeList < class timerQueuePassive, 0x8 > freeList; }; inline void * timer::operator new ( size_t size ) @@ -171,24 +186,44 @@ inline double timer::privateDelayToFirstExpire () const } } -inline bool timerQueueThreaded::sharingOK () const +inline bool timerQueueActive::sharingOK () const { return this->okToShare; } -inline int timerQueueThreaded::threadPriority () const +inline int timerQueueActive::threadPriority () const { return thread.getPriority (); } -inline void * timerQueueThreaded::operator new ( size_t size ) +inline timerQueue & timerQueueActive::getTimerQueue () { - return timerQueueThreaded::freeList.allocate ( size ); + return this->queue; } -inline void timerQueueThreaded::operator delete ( void *pCadaver, size_t size ) +inline void * timerQueuePassive::operator new ( size_t size ) { - timerQueueThreaded::freeList.release ( pCadaver, size ); + return timerQueuePassive::freeList.allocate ( size ); +} + +inline void timerQueuePassive::operator delete ( void *pCadaver, size_t size ) +{ + timerQueuePassive::freeList.release ( pCadaver, size ); +} + +inline timerQueue & timerQueuePassive::getTimerQueue () +{ + return this->queue; +} + +inline void * epicsTimerQueueForC::operator new ( size_t size ) +{ + return epicsTimerQueueForC::freeList.allocate ( size ); +} + +inline void epicsTimerQueueForC::operator delete ( void *pCadaver, size_t size ) +{ + epicsTimerQueueForC::freeList.release ( pCadaver, size ); } #endif // epicsTimerPrivate_h diff --git a/src/libCom/timer/timerQueue.cpp b/src/libCom/timer/timerQueue.cpp index 29c0bb17b..fbfd2348d 100644 --- a/src/libCom/timer/timerQueue.cpp +++ b/src/libCom/timer/timerQueue.cpp @@ -29,7 +29,7 @@ */ #define epicsExportSharedSymbols -#include "epicsTimerPrivate.h" +#include "timerPrivate.h" timerQueue::timerQueue ( epicsTimerQueueNotify ¬ifyIn ) : notify ( notifyIn ), pExpireTmr ( 0 ), diff --git a/src/libCom/timer/timerQueueThreaded.cpp b/src/libCom/timer/timerQueueActive.cpp similarity index 79% rename from src/libCom/timer/timerQueueThreaded.cpp rename to src/libCom/timer/timerQueueActive.cpp index f7ad8b0de..5ed6d7bd2 100644 --- a/src/libCom/timer/timerQueueThreaded.cpp +++ b/src/libCom/timer/timerQueueActive.cpp @@ -29,20 +29,18 @@ */ #define epicsExportSharedSymbols -#include "epicsTimerPrivate.h" +#include "timerPrivate.h" -static timerQueueThreadedMgr queueMgr; +timerQueueActiveMgr queueMgr; -epicsTimerQueueThreaded::~epicsTimerQueueThreaded () {} +epicsTimerQueue::~epicsTimerQueue () {} -epicsTimerQueueThreaded &epicsTimerQueueThreaded::allocate ( bool okToShare, int threadPriority ) +epicsTimerQueue &epicsTimerQueue::allocate ( bool okToShare, int threadPriority ) { return queueMgr.allocate ( okToShare, threadPriority ); } -tsFreeList < class timerQueueThreaded, 0x8 > timerQueueThreaded::freeList; - -timerQueueThreaded::timerQueueThreaded ( bool okToShareIn, unsigned priority ) : +timerQueueActive::timerQueueActive ( bool okToShareIn, unsigned priority ) : queue ( *this ), thread ( *this, "epicsTimerQueue", epicsThreadGetStackSize ( epicsThreadStackMedium ), priority ), okToShare ( okToShareIn ), exitFlag ( false ), terminateFlag ( false ) @@ -50,7 +48,7 @@ timerQueueThreaded::timerQueueThreaded ( bool okToShareIn, unsigned priority ) : this->thread.start (); } -timerQueueThreaded::~timerQueueThreaded () +timerQueueActive::~timerQueueActive () { this->terminateFlag = true; this->rescheduleEvent.signal (); @@ -61,12 +59,7 @@ timerQueueThreaded::~timerQueueThreaded () this->exitEvent.signal (); } -void timerQueueThreaded::release () -{ - queueMgr.release ( *this ); -} - -void timerQueueThreaded::run () +void timerQueueActive::run () { this->exitFlag = false; while ( ! this->terminateFlag ) { @@ -83,7 +76,7 @@ void timerQueueThreaded::run () this->exitEvent.signal (); // no access to queue after exitEvent signal } -epicsTimer & timerQueueThreaded::createTimer ( epicsTimerNotify & notify ) +epicsTimer & timerQueueActive::createTimer ( epicsTimerNotify & notify ) { timer *pTmr = new timer ( notify, this->queue ); if ( ! pTmr ) { @@ -92,12 +85,12 @@ epicsTimer & timerQueueThreaded::createTimer ( epicsTimerNotify & notify ) return *pTmr; } -void timerQueueThreaded::reschedule () +void timerQueueActive::reschedule () { this->rescheduleEvent.signal (); } -void timerQueueThreaded::show ( unsigned int level ) const +void timerQueueActive::show ( unsigned int level ) const { printf ( "EPICS threaded timer queue at %p\n", static_cast ( this ) ); diff --git a/src/libCom/timer/timerQueueThreadedMgr.cpp b/src/libCom/timer/timerQueueActiveMgr.cpp similarity index 63% rename from src/libCom/timer/timerQueueThreadedMgr.cpp rename to src/libCom/timer/timerQueueActiveMgr.cpp index 9fd7e893d..623efd42f 100644 --- a/src/libCom/timer/timerQueueThreadedMgr.cpp +++ b/src/libCom/timer/timerQueueActiveMgr.cpp @@ -31,57 +31,57 @@ #include #define epicsExportSharedSymbols -#include "epicsTimerPrivate.h" +#include "timerPrivate.h" -timerQueueThreadedMgr::~timerQueueThreadedMgr () +timerQueueActiveMgr::~timerQueueActiveMgr () { epicsAutoMutex locker ( this->mutex ); } -timerQueueThreaded & timerQueueThreadedMgr::allocate ( +epicsTimerQueueForC & timerQueueActiveMgr::allocate ( bool okToShare, int threadPriority ) { epicsAutoMutex locker ( this->mutex ); if ( okToShare ) { - tsDLIterBD < timerQueueThreaded > iter = this->sharedQueueList.firstIter (); + tsDLIterBD < epicsTimerQueueForC > iter = this->sharedQueueList.firstIter (); while ( iter.valid () ) { if ( iter->threadPriority () == threadPriority ) { - assert ( iter->timerQueueThreadedMgrPrivate::referenceCount < UINT_MAX ); - iter->timerQueueThreadedMgrPrivate::referenceCount++; + assert ( iter->timerQueueActiveMgrPrivate::referenceCount < UINT_MAX ); + iter->timerQueueActiveMgrPrivate::referenceCount++; return *iter; } } } - timerQueueThreaded *pQueue = new timerQueueThreaded ( okToShare, threadPriority ); + epicsTimerQueueForC *pQueue = new epicsTimerQueueForC ( okToShare, threadPriority ); if ( ! pQueue ) { throwWithLocation ( timer::noMemory () ); } - pQueue->timerQueueThreadedMgrPrivate::referenceCount = 1u; + pQueue->timerQueueActiveMgrPrivate::referenceCount = 1u; if ( okToShare ) { this->sharedQueueList.add ( *pQueue ); } return *pQueue; } -void timerQueueThreadedMgr::release ( timerQueueThreaded &queue ) +void timerQueueActiveMgr::release ( epicsTimerQueueForC &queue ) { epicsAutoMutex locker ( this->mutex ); - assert ( queue.timerQueueThreadedMgrPrivate::referenceCount > 0u ); - queue.timerQueueThreadedMgrPrivate::referenceCount--; - if ( queue.timerQueueThreadedMgrPrivate::referenceCount == 0u ) { + assert ( queue.timerQueueActiveMgrPrivate::referenceCount > 0u ); + queue.timerQueueActiveMgrPrivate::referenceCount--; + if ( queue.timerQueueActiveMgrPrivate::referenceCount == 0u ) { if ( queue.sharingOK () ) { this->sharedQueueList.remove ( queue ); } - timerQueueThreadedMgrPrivate *pPriv = &queue; + timerQueueActiveMgrPrivate *pPriv = &queue; delete pPriv; } } -timerQueueThreadedMgrPrivate::timerQueueThreadedMgrPrivate () : +timerQueueActiveMgrPrivate::timerQueueActiveMgrPrivate () : referenceCount ( 0u ) { } -timerQueueThreadedMgrPrivate::~timerQueueThreadedMgrPrivate () +timerQueueActiveMgrPrivate::~timerQueueActiveMgrPrivate () { } diff --git a/src/libCom/timer/timerQueueNonThreaded.cpp b/src/libCom/timer/timerQueuePassive.cpp similarity index 70% rename from src/libCom/timer/timerQueueNonThreaded.cpp rename to src/libCom/timer/timerQueuePassive.cpp index 5c7de1795..d8ed2ddd1 100644 --- a/src/libCom/timer/timerQueueNonThreaded.cpp +++ b/src/libCom/timer/timerQueuePassive.cpp @@ -29,25 +29,27 @@ */ #define epicsExportSharedSymbols -#include "epicsTimerPrivate.h" +#include "timerPrivate.h" -epicsTimerQueueNonThreaded::~epicsTimerQueueNonThreaded () {} +tsFreeList < class timerQueuePassive, 0x8 > timerQueuePassive::freeList; -epicsTimerQueueNonThreaded &epicsTimerQueueNonThreaded::create ( epicsTimerQueueNotify ¬ify ) +epicsTimerQueuePassive::~epicsTimerQueuePassive () {} + +epicsTimerQueuePassive &epicsTimerQueuePassive::create ( epicsTimerQueueNotify ¬ify ) { - timerQueueNonThreaded *pQueue = new timerQueueNonThreaded ( notify ); + timerQueuePassive *pQueue = new timerQueuePassive ( notify ); if ( ! pQueue ) { throwWithLocation ( timer::noMemory () ); } return *pQueue; } -timerQueueNonThreaded::timerQueueNonThreaded ( epicsTimerQueueNotify ¬ifyIn ) : +timerQueuePassive::timerQueuePassive ( epicsTimerQueueNotify ¬ifyIn ) : queue ( notifyIn ) {} -timerQueueNonThreaded::~timerQueueNonThreaded () {} +timerQueuePassive::~timerQueuePassive () {} -epicsTimer & timerQueueNonThreaded::createTimer ( epicsTimerNotify & notifyIn ) +epicsTimer & timerQueuePassive::createTimer ( epicsTimerNotify & notifyIn ) { timer *pTmr = new timer ( notifyIn, this->queue ); if ( ! pTmr ) { @@ -56,17 +58,17 @@ epicsTimer & timerQueueNonThreaded::createTimer ( epicsTimerNotify & notifyIn ) return *pTmr; } -void timerQueueNonThreaded::process () +void timerQueuePassive::process () { this->queue.process (); } -double timerQueueNonThreaded::getNextExpireDelay () const +double timerQueuePassive::getNextExpireDelay () const { return this->queue.delayToFirstExpire (); } -void timerQueueNonThreaded::show ( unsigned int level ) const +void timerQueuePassive::show ( unsigned int level ) const { printf ( "EPICS non-threaded timer queue at %p\n", static_cast ( this ) );