epics/pcas
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

dont use struct for C++ class defs

Browse Source
This commit is contained in:
Jeff Hill
2001-02-22 19:52:09 +00:00
parent aca1c5f76e
commit 3fa13a1d8f
8 changed files with 236 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

194
src/libCom/timer/epicsTimer.cpp
View File

@@ -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 );
}

56
src/libCom/timer/epicsTimer.h
View File

@@ -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

2
src/libCom/timer/timer.cpp
View File

@@ -30,7 +30,7 @@
*/
#define epicsExportSharedSymbols
#include "epicsTimerPrivate.h"
#include "timerPrivate.h"
tsFreeList < class timer, 0x20 > timer::freeList;

91
src/libCom/timer/epicsTimerPrivate.h → src/libCom/timer/timerPrivate.h
View File

@@ -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

2
src/libCom/timer/timerQueue.cpp
View File

@@ -29,7 +29,7 @@
*/
#define epicsExportSharedSymbols
#include "epicsTimerPrivate.h"
#include "timerPrivate.h"
timerQueue::timerQueue ( epicsTimerQueueNotify &notifyIn ) :
notify ( notifyIn ), pExpireTmr ( 0 ),

27
src/libCom/timer/timerQueueThreaded.cpp → src/libCom/timer/timerQueueActive.cpp
View File

@@ -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 <const void *> ( this ) );

30
src/libCom/timer/timerQueueThreadedMgr.cpp → src/libCom/timer/timerQueueActiveMgr.cpp
View File

@@ -31,57 +31,57 @@
#include <limits.h>
#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 ()
{
}

22
src/libCom/timer/timerQueueNonThreaded.cpp → src/libCom/timer/timerQueuePassive.cpp
View File

@@ -29,25 +29,27 @@
*/
#define epicsExportSharedSymbols
#include "epicsTimerPrivate.h"
#include "timerPrivate.h"
epicsTimerQueueNonThreaded::~epicsTimerQueueNonThreaded () {}
tsFreeList < class timerQueuePassive, 0x8 > timerQueuePassive::freeList;
epicsTimerQueueNonThreaded &epicsTimerQueueNonThreaded::create ( epicsTimerQueueNotify &notify )
epicsTimerQueuePassive::~epicsTimerQueuePassive () {}
epicsTimerQueuePassive &epicsTimerQueuePassive::create ( epicsTimerQueueNotify &notify )
{
timerQueueNonThreaded *pQueue = new timerQueueNonThreaded ( notify );
timerQueuePassive *pQueue = new timerQueuePassive ( notify );
if ( ! pQueue ) {
throwWithLocation ( timer::noMemory () );
}
return *pQueue;
}
timerQueueNonThreaded::timerQueueNonThreaded ( epicsTimerQueueNotify &notifyIn ) :
timerQueuePassive::timerQueuePassive ( epicsTimerQueueNotify &notifyIn ) :
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 <const void *> ( this ) );