finished queue sharing

src/libCom/timer/epicsTimerPrivate.h

@@ -105,12 +105,13 @@ class timerQueueThreaded : public epicsTimerQueueThreaded,
     public timerQueueThreadedMgrPrivate,
     public tsDLNode < timerQueueThreaded > {
 public:
-    timerQueueThreaded ( unsigned priority );
+    timerQueueThreaded ( bool okToShare, unsigned priority );
     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 ();
@@ -119,6 +120,7 @@ private:
     epicsEvent rescheduleEvent;
     epicsEvent exitEvent;
     epicsThread thread;
+    bool okToShare;
     bool exitFlag;
     bool terminateFlag;
     void run ();
@@ -134,7 +136,8 @@ public:
     void release ( timerQueueThreaded & );
 private:
     epicsMutex mutex;
-    tsDLList < timerQueueThreaded > queueList;
+    tsDLList < timerQueueThreaded > sharedQueueList;
+    tsDLList < timerQueueThreaded > privateQueueList;
 };
 
 inline void * timer::operator new ( size_t size )
@@ -161,6 +164,16 @@ inline double timer::privateDelayToFirstExpire () const
     }
 }
 
+inline bool timerQueueThreaded::sharingOK () const
+{
+    return this->okToShare;
+}
+
+inline int timerQueueThreaded::threadPriority () const
+{
+    return thread.getPriority ();
+}
+
 inline void * timerQueueThreaded::operator new ( size_t size )
 {
     return timerQueueThreaded::freeList.allocate ( size );

src/libCom/timer/timerQueueThreaded.cpp

@@ -42,10 +42,10 @@ epicsTimerQueueThreaded &epicsTimerQueueThreaded::create ( bool okToShare, int t
 
 tsFreeList < class timerQueueThreaded, 0x8 > timerQueueThreaded::freeList;
 
-timerQueueThreaded::timerQueueThreaded ( unsigned priority ) :
-    thread ( *this, "epicsTimerQueue",
+timerQueueThreaded::timerQueueThreaded ( bool okToShareIn, unsigned priority ) :
+    queue ( *this ), thread ( *this, "epicsTimerQueue",
         epicsThreadGetStackSize ( epicsThreadStackMedium ), priority ),
-    queue ( *this ), exitFlag ( false ), terminateFlag ( false )
+    okToShare (okToShareIn), exitFlag ( false ), terminateFlag ( false )
 {
     this->thread.start ();
 }
@@ -61,11 +61,6 @@ timerQueueThreaded::~timerQueueThreaded ()
     this->exitEvent.signal ();
 }
 
-int timerQueueThreaded::threadPriority () const
-{
-    return thread.getPriority ();
-}
-
 void timerQueueThreaded::release ()
 {
     queueMgr.release ( *this );

src/libCom/timer/timerQueueThreadedMgr.cpp

@@ -36,7 +36,11 @@
 timerQueueThreadedMgr::~timerQueueThreadedMgr ()
 {
     epicsAutoMutex locker ( this->mutex );
-    while ( timerQueueThreaded * pQ = this->queueList.get () ) {
+    while ( timerQueueThreaded * pQ = this->sharedQueueList.get () ) {
+        timerQueueThreadedMgrPrivate *pPriv = pQ;
+        delete pPriv;
+    }
+    while ( timerQueueThreaded * pQ = this->privateQueueList.get () ) {
         timerQueueThreadedMgrPrivate *pPriv = pQ;
         delete pPriv;
     }
@@ -46,20 +50,27 @@ timerQueueThreaded & timerQueueThreadedMgr::create (
         bool okToShare, int threadPriority )
 {
     epicsAutoMutex locker ( this->mutex );
-    tsDLIterBD < timerQueueThreaded > iter = this->queueList.firstIter ();
-    while ( iter.valid () ) {
-        if ( iter->threadPriority () == threadPriority ) {
-            assert ( iter->timerQueueThreadedMgrPrivate::referenceCount < UINT_MAX );
-            iter->timerQueueThreadedMgrPrivate::referenceCount++;
-            return *iter;
+    if ( okToShare ) {
+        tsDLIterBD < timerQueueThreaded > iter = this->sharedQueueList.firstIter ();
+        while ( iter.valid () ) {
+            if ( iter->threadPriority () == threadPriority ) {
+                assert ( iter->timerQueueThreadedMgrPrivate::referenceCount < UINT_MAX );
+                iter->timerQueueThreadedMgrPrivate::referenceCount++;
+                return *iter;
+            }
         }
     }
-    timerQueueThreaded *pQueue = new timerQueueThreaded ( threadPriority );
+    timerQueueThreaded *pQueue = new timerQueueThreaded ( okToShare, threadPriority );
     if ( ! pQueue ) {
         throwWithLocation ( timer::noMemory () );
     }
     pQueue->timerQueueThreadedMgrPrivate::referenceCount = 1u;
-    this->queueList.add ( *pQueue );
+    if ( okToShare ) {
+        this->sharedQueueList.add ( *pQueue );
+    }
+    else {
+        this->privateQueueList.add ( *pQueue );
+    }
     return *pQueue;
 }
 
@@ -69,7 +80,12 @@ void timerQueueThreadedMgr::release ( timerQueueThreaded &queue )
     assert ( queue.timerQueueThreadedMgrPrivate::referenceCount > 0u );
     queue.timerQueueThreadedMgrPrivate::referenceCount--;
     if ( queue.timerQueueThreadedMgrPrivate::referenceCount == 0u ) {
-        this->queueList.remove ( queue );
+        if ( queue.sharingOK () ) {
+            this->sharedQueueList.remove ( queue );
+        }
+        else {
+            this->privateQueueList.remove ( queue );
+        }
         timerQueueThreadedMgrPrivate *pPriv = &queue;
         delete pPriv;
     }
@@ -82,4 +98,4 @@ timerQueueThreadedMgrPrivate::timerQueueThreadedMgrPrivate () :
 
 timerQueueThreadedMgrPrivate::~timerQueueThreadedMgrPrivate () 
 {
-}
+}