delete timer via timer queue

src/libCom/fdmgr/fdManager.h

@@ -103,6 +103,7 @@ public:
     epicsShareFunc class fdReg *lookUpFD (const SOCKET fd, const fdRegType type);
 
     epicsTimer & createTimer ();
+    void destroyTimer ( epicsTimer & );
 
 private:
     tsDLList<fdReg> regList;
@@ -211,5 +212,10 @@ inline epicsTimer & fdManager::createTimer ()
     return this->pTimerQueue->createTimer ();
 }
 
+inline void fdManager::destroyTimer ( epicsTimer & tmr ) 
+{
+    this->pTimerQueue->destroyTimer ( tmr );
+}
+
 #endif // fdManagerH_included
  

src/libCom/fdmgr/fdmgr.cpp

@@ -134,13 +134,8 @@ timerForOldFdmgr::timerForOldFdmgr ( oldFdmgr &fdmgrIn,
 
 timerForOldFdmgr::~timerForOldFdmgr ()
 {
-    if (this->pFunc==NULL) {
-        throwWithLocation ( doubleDelete () );
-    }
-    this->pFunc = NULL;
-    this->pParam = NULL;
     this->fdmgr.resTbl.remove ( this->getId() );
-    delete & this->timer;
+    this->fdmgr.destroyTimer ( this->timer );
 }
 
 epicsTimerNotify::expireStatus timerForOldFdmgr::expire ( const epicsTime & )

src/libCom/test/epicsTimerTest.cpp

@@ -49,6 +49,7 @@ public:
 protected:
     virtual ~delayVerify ();
 private:
+    epicsTimerQueue &queue;
     epicsTimer &timer;
     epicsTime beginStamp;
     epicsTime expireStamp;
@@ -61,14 +62,15 @@ private:
 static unsigned expireCount;
 static epicsEvent expireEvent;
 
-delayVerify::delayVerify ( double expectedDelayIn, epicsTimerQueue &queue ) :
-    timer ( queue.createTimer() ), expectedDelay ( expectedDelayIn )
+delayVerify::delayVerify ( double expectedDelayIn, epicsTimerQueue &queueIn ) :
+    queue ( queueIn ), timer ( queueIn.createTimer() ), 
+        expectedDelay ( expectedDelayIn )
 {
 }
 
 delayVerify::~delayVerify ()
 {
-    delete & this->timer;
+    this->queue.destroyTimer ( this->timer );
 }
 
 inline void delayVerify::setBegin ( const epicsTime &beginIn )
@@ -163,6 +165,7 @@ public:
 protected:
     virtual ~cancelVerify ();
 private:
+    epicsTimerQueue &queue;
     epicsTimer &timer;
     bool failOutIfExpireIsCalled;
     expireStatus expire ( const epicsTime & );
@@ -170,14 +173,15 @@ private:
     static epicsMutex freeListMutex;
 };
 
-cancelVerify::cancelVerify ( epicsTimerQueue &queue ) :
-    timer ( queue.createTimer () ), failOutIfExpireIsCalled ( false )
+cancelVerify::cancelVerify ( epicsTimerQueue &queueIn ) :
+    queue ( queueIn ), timer ( queueIn.createTimer () ), 
+        failOutIfExpireIsCalled ( false )
 {
 }
 
 cancelVerify::~cancelVerify ()
 {
-    delete & this->timer;
+    this->queue.destroyTimer ( this->timer );
 }
 
 inline void cancelVerify::start ( const epicsTime &expireTime )
@@ -255,22 +259,24 @@ public:
 protected:
     virtual ~periodicVerify ();
 private:
-    unsigned nExpire;
+    epicsTimerQueue &queue;
     epicsTimer &timer;
+    unsigned nExpire;
     bool failOutIfExpireIsCalled;
     expireStatus expire ( const epicsTime & );
     static tsFreeList < class periodicVerify, 0x20 > freeList;
     static epicsMutex freeListMutex;
 };
 
-periodicVerify::periodicVerify ( epicsTimerQueue &queue ) :
-    nExpire ( 0u ), timer ( queue.createTimer () ), failOutIfExpireIsCalled ( false )
+periodicVerify::periodicVerify ( epicsTimerQueue & queueIn ) :
+    queue ( queueIn ), timer ( queueIn.createTimer () ), 
+        nExpire ( 0u ), failOutIfExpireIsCalled ( false )
 {
 }
 
 periodicVerify::~periodicVerify ()
 {
-    delete & this->timer;
+    this->queue.destroyTimer ( this->timer );
 }
 
 inline void periodicVerify::start ( const epicsTime &expireTime )

src/libCom/timer/epicsTimer.cpp

@@ -32,22 +32,6 @@
 #include "epicsTimer.h"
 #include "timerPrivate.h"
 
-struct epicsTimerForC : public epicsTimerNotify, public timer {
-public:
-    epicsTimerForC ( timerQueue &, epicsTimerCallback, void *pPrivateIn );
-    void destroy ();
-    void * operator new ( size_t size );
-    void operator delete ( void *pCadaver, size_t size );
-protected:
-    virtual ~epicsTimerForC ();
-private:
-    epicsTimerCallback pCallBack;
-    void * pPrivate;
-    expireStatus expire ( const epicsTime & currentTime );
-    static tsFreeList < epicsTimerForC > freeList;
-    static epicsMutex freeListMutex;
-};
-
 struct epicsTimerQueuePassiveForC : public epicsTimerQueueNotify, public timerQueuePassive {
 public:
     epicsTimerQueuePassiveForC ( epicsTimerQueueRescheduleCallback pCallback, void *pPrivate );
@@ -66,33 +50,14 @@ private:
 
 void epicsTimerNotify::show ( unsigned /* level */ ) const {}
 
-tsFreeList < epicsTimerForC > epicsTimerForC::freeList;
-epicsMutex epicsTimerForC::freeListMutex;
-
 epicsTimerForC::epicsTimerForC ( timerQueue &queue, epicsTimerCallback pCBIn, void *pPrivateIn ) :
     timer ( queue ), pCallBack ( pCBIn ), pPrivate ( pPrivateIn )
 {
 }
 
-epicsTimerForC::~epicsTimerForC () 
-{
-}
-
 inline void epicsTimerForC::destroy ()
 {
-    delete this;
-}
-
-inline void * epicsTimerForC::operator new ( size_t size )
-{ 
-    epicsAutoMutex locker ( epicsTimerForC::freeListMutex );
-    return epicsTimerForC::freeList.allocate ( size );
-}
-
-inline void epicsTimerForC::operator delete ( void *pCadaver, size_t size )
-{ 
-    epicsAutoMutex locker ( epicsTimerForC::freeListMutex );
-    epicsTimerForC::freeList.release ( pCadaver, size );
+    this->destroyTimerForC ( *this );
 }
 
 epicsTimerNotify::expireStatus epicsTimerForC::expire ( const epicsTime & )

src/libCom/timer/epicsTimer.h

@@ -46,23 +46,25 @@ public:
 
 class epicsTimer {
 public:
-    virtual ~epicsTimer () = 0;
     virtual void start ( epicsTimerNotify &, const epicsTime & ) = 0;
     virtual void start ( epicsTimerNotify &, double delaySeconds ) = 0;
     virtual void cancel () = 0;
     struct expireInfo {
-        expireInfo ( bool active, const epicsTime &expireTime );
+        expireInfo ( bool active, const epicsTime & expireTime );
         bool active;
         epicsTime expireTime;
     };
     virtual expireInfo getExpireInfo () const = 0;
     double getExpireDelay ();
     virtual void show ( unsigned int level ) const = 0;
+private:
+    ~epicsTimer (); // intentionally not implemented ( see destroy )
 };
 
 class epicsTimerQueue {
 public:
     virtual epicsTimer & createTimer () = 0;
+    virtual void destroyTimer ( epicsTimer & ) = 0;
     virtual void show ( unsigned int level ) const = 0;
 protected:
     virtual ~epicsTimerQueue () = 0;
@@ -151,6 +153,8 @@ epicsShareFunc void epicsShareAPI
 epicsShareFunc epicsTimerId epicsShareAPI 
     epicsTimerQueueCreateTimer ( epicsTimerQueueId queueid, 
         epicsTimerCallback callback, void *arg );
+epicsShareFunc void epicsShareAPI 
+    epicsTimerQueueDestroyTimer ( epicsTimerQueueId queueid, epicsTimerId id );
 epicsShareFunc void  epicsShareAPI 
     epicsTimerQueueShow ( epicsTimerQueueId id, unsigned int level );
 
@@ -164,14 +168,14 @@ epicsShareFunc void epicsShareAPI
 epicsShareFunc epicsTimerId epicsShareAPI 
     epicsTimerQueuePassiveCreateTimer (
         epicsTimerQueuePassiveId queueid, epicsTimerCallback pCallback, void *pArg );
+epicsShareFunc void epicsShareAPI 
+    epicsTimerQueuePassiveDestroyTimer ( epicsTimerQueuePassiveId queueid, epicsTimerId id );
 epicsShareFunc double epicsShareAPI 
     epicsTimerQueuePassiveProcess ( epicsTimerQueuePassiveId );
 epicsShareFunc void  epicsShareAPI epicsTimerQueuePassiveShow (
     epicsTimerQueuePassiveId id, unsigned int level );
 
 /* timer */
-epicsShareFunc void epicsShareAPI 
-    epicsTimerDestroy ( epicsTimerId id );
 epicsShareFunc void epicsShareAPI 
     epicsTimerStartTime ( epicsTimerId id, const epicsTimeStamp *pTime );
 epicsShareFunc void epicsShareAPI 

src/libCom/timer/timer.cpp

@@ -32,19 +32,16 @@
 #define epicsExportSharedSymbols
 #include "timerPrivate.h"
 
-tsFreeList < class timer, 0x20 > timer::freeList;
-epicsMutex timer::freeListMutex;
-
-epicsTimer::~epicsTimer () {}
-
 timer::timer ( timerQueue &queueIn ) :
     curState ( stateLimbo ), pNotify ( 0 ), queue ( queueIn )
 {
 }
 
-timer::~timer()
+void timer::destroyTimerForC ( epicsTimerForC &cTmr )
 {
-    this->cancel ();
+    epicsAutoMutex autoLock ( this->queue.mutex );
+    this->privateCancel ();
+    this->queue.cTimerfreeList.release ( &cTmr, sizeof(cTmr) );
 }
 
 void timer::start ( epicsTimerNotify & notify, double delaySeconds )

src/libCom/timer/timerPrivate.h

@@ -43,18 +43,16 @@
 
 class timer : public epicsTimer, public tsDLNode < timer > {
 public:
-    timer ( class timerQueue & );
     void start ( class epicsTimerNotify &, const epicsTime & );
     void start ( class epicsTimerNotify &, double delaySeconds );
     void cancel ();
     expireInfo getExpireInfo () const;
     void show ( unsigned int level ) const;
-    void * operator new ( size_t size );
-    void operator delete ( void *pCadaver, size_t size );
-    class noMemory {}; // exception
+    void destroyTimerForC ( epicsTimerForC & );
 protected:
-    ~timer ();
+    timer ( class timerQueue & );
 private:
+    ~timer (); // intentionally not implemented ( see destroy )
     enum state { statePending = 45, stateLimbo = 78 };
     epicsTime exp; // experation time 
     state curState; // current state 
@@ -62,19 +60,34 @@ private:
     timerQueue &queue;
     void privateStart ( epicsTimerNotify & notify, const epicsTime & );
     void privateCancel ();
-    static tsFreeList < class timer, 0x20 > freeList;
-    static epicsMutex freeListMutex;
     friend class timerQueue;
 };
 
+struct epicsTimerForC : public epicsTimerNotify, public timer {
+public:
+    epicsTimerForC ( timerQueue &, epicsTimerCallback, void *pPrivateIn );
+    void destroy ();
+private:
+    epicsTimerCallback pCallBack;
+    void * pPrivate;
+    expireStatus expire ( const epicsTime & currentTime );
+    ~epicsTimerForC (); // intentionally not implemented ( see destroy )
+};
+
 class timerQueue {
 public:
     timerQueue ( epicsTimerQueueNotify &notify );
     ~timerQueue ();
     double process ( const epicsTime & currentTime );
     void show ( unsigned int level ) const;
+    timer & createTimer ();
+    void destroyTimer ( timer & );
+    epicsTimerForC & createTimerForC ( epicsTimerCallback, void *pPrivateIn );
+    void destroyTimerForC ( epicsTimerForC & );
 private:
     mutable epicsMutex mutex;
+    tsFreeList < class timer, 0x20 > timerFreeList;
+    tsFreeList < epicsTimerForC, 0x20 > cTimerfreeList;
     epicsEvent cancelBlockingEvent;
     tsDLList < timer > timerList;
     epicsTimerQueueNotify &notify;
@@ -101,6 +114,7 @@ public:
     timerQueueActive ( bool okToShare, unsigned priority );
     ~timerQueueActive () = 0;
     epicsTimer & createTimer ();
+    void destroyTimer ( epicsTimer & );
     void show ( unsigned int level ) const;
     bool sharingOK () const;
     int threadPriority () const;
@@ -148,6 +162,7 @@ class timerQueuePassive : public epicsTimerQueuePassive {
 public:
     timerQueuePassive ( epicsTimerQueueNotify & );
     epicsTimer & createTimer ();
+    void destroyTimer ( epicsTimer & );
     double process ( const epicsTime & currentTime );
     void show ( unsigned int level ) const;
     void release ();
@@ -158,16 +173,15 @@ private:
     timerQueue queue;
 };
 
-inline void * timer::operator new ( size_t size )
+inline epicsTimerForC & timerQueue::createTimerForC 
+    ( epicsTimerCallback pCB, void *pPriv )
 {
-    epicsAutoMutex locker ( timer::freeListMutex );
-    return timer::freeList.allocate ( size );
-}
-
-inline void timer::operator delete ( void *pCadaver, size_t size )
-{
-    epicsAutoMutex locker ( timer::freeListMutex );
-    timer::freeList.release ( pCadaver, size );
+    epicsAutoMutex autoLock ( this->mutex );
+    void *pBuf = this->cTimerfreeList.allocate ( sizeof (epicsTimerForC) );
+    if ( ! pBuf ) {
+        throw std::bad_alloc();
+    }
+    return * new ( pBuf ) epicsTimerForC ( *this, pCB, pPriv );
 }
 
 inline bool timerQueueActive::sharingOK () const

src/libCom/timer/timerQueue.cpp

@@ -153,6 +153,23 @@ double timerQueue::process ( const epicsTime & currentTime )
     }
 }
 
+timer & timerQueue::createTimer ()
+{
+    epicsAutoMutex autoLock ( this->mutex );
+    void *pBuf = this->timerFreeList.allocate ( sizeof (timer) );
+    if ( ! pBuf ) {
+        throw std::bad_alloc();
+    }
+    return * new ( pBuf ) timer ( *this );
+}
+
+void timerQueue::destroyTimer ( timer & tmr ) 
+{
+    epicsAutoMutex autoLock ( this->mutex );
+    tmr.privateCancel ();
+    this->timerFreeList.release ( &tmr, sizeof( tmr ) );
+}
+
 void timerQueue::show ( unsigned level ) const
 {
     epicsAutoMutex locker ( this->mutex );

src/libCom/timer/timerQueueActive.cpp

@@ -73,11 +73,13 @@ void timerQueueActive::run ()
 
 epicsTimer & timerQueueActive::createTimer ()
 {
-    timer *pTmr = new timer ( this->queue );
-    if ( ! pTmr ) {
-        throwWithLocation ( timer::noMemory () );
-    }
-    return *pTmr;
+    return this->queue.createTimer ();
+}
+
+void timerQueueActive::destroyTimer ( epicsTimer & et )
+{
+    timer & tmr = dynamic_cast < timer & > ( et );
+    this->queue.destroyTimer ( tmr );
 }
 
 void timerQueueActive::reschedule ()

src/libCom/timer/timerQueueActiveMgr.cpp

@@ -54,7 +54,7 @@ epicsTimerQueueActiveForC & timerQueueActiveMgr::allocate (
     }
     epicsTimerQueueActiveForC *pQueue = new epicsTimerQueueActiveForC ( okToShare, threadPriority );
     if ( ! pQueue ) {
-        throwWithLocation ( timer::noMemory () );
+        throw std::bad_alloc ();
     }
     pQueue->timerQueueActiveMgrPrivate::referenceCount = 1u;
     if ( okToShare ) {

src/libCom/timer/timerQueuePassive.cpp

@@ -45,7 +45,7 @@ epicsTimerQueuePassive &epicsTimerQueuePassive::create ( epicsTimerQueueNotify &
 {
     timerQueuePassive *pQueue = new timerQueuePassive ( notify );
     if ( ! pQueue ) {
-        throwWithLocation ( timer::noMemory () );
+        throw std::bad_alloc ();
     }
     return *pQueue;
 }
@@ -57,11 +57,13 @@ timerQueuePassive::~timerQueuePassive () {}
 
 epicsTimer & timerQueuePassive::createTimer ()
 {
-    timer *pTmr = new timer ( this->queue );
-    if ( ! pTmr ) {
-        throwWithLocation ( timer::noMemory () );
-    }
-    return *pTmr;
+    return this->queue.createTimer ();
+}
+
+void timerQueuePassive::destroyTimer ( epicsTimer & et )
+{
+    timer & tmr = dynamic_cast < timer & > ( et );
+    this->queue.destroyTimer ( tmr );
 }
 
 double timerQueuePassive::process ( const epicsTime & currentTime )