Merge ~johill-lanl/epics-base/+git/epics-base:timer-queue-fix into epics-base:7.0

[Jeff Hill]

o changed timer library to use heap algorithm
o merged thread private C++ allocator - AllocatorArena
o merged compiler, and compiler version, independent thread safe static C++ object library
o merged compiler independent C++ symbol demangler
o added C++ 11 compatibility keywords to compiler dependent library
o upgraded and or added tests
o updated valgrind header versions to newer version, added missing valgrind header files
o added mechanism to turn off valgrind macros, which have runtime penalty in optimized builds

Changed timer queue library to use heap algorithm.

Also upgraded the timer test coverage, and accuracy statistics emitted as diagnostics during the tests.

In order to simplify the merge I moved the timer library to a modernized thread private C++ STL compliant allocation library - AllocatorArena. This avoids (personal) difficulties with maintaining two different versions {EPICS 7.0, LANSCE DAR} using the original cxx free list library interface, and an enhanced newer template interface version of that original library. If you prefer I could change the timer library to just use new and delete as the timer objects themselves may not be created and destroyed periodically by users (difficult to speculate). I could also rebase on the older version of the cxx free list library, but again I would have more maintenance labor to attend to over time.

The AllocatorArena also pulls in the (small) static instance library and the C++ demangle libraries. There are also some tests for these layered components.

I have also added some c++ 11 compatibility macros to the compiler dependencies library. I also removed the throw compatibility macro because no code uses it, and no one should be using the C++ throw specification on new code (according to C++ standards committee, Meyers, and many others).

Updated valgrind header versions to newer version, and added missing valgrind header files. Added mechanism to turn off valgrind macros, which have runtime penalty in optimized builds.

BTW: On a similar note, I would also prefer to see assert tests removed from optimized builds. Otherwise developers may leave out assert calls for fear of runtime penalty. I have not made that change here, however.

[Martin Konrad (info-martin-konrad)]

I haven't looked at the code, yet, but it builds fine on Ubuntu 19.10 with GCC 9.2: no warnings, all tests pass :-) A few compiler/OS combinations fail to build on Travis (https://travis-ci.com/github/mark0n/epics-base/builds/161843145) and AppVeyor (https://ci.appveyor.com/project/MartinKonrad/epics-base/builds/32416944), though.

Before digging into the code, I benchmarked the old and the proposed timer queue implementation. You can find the results here:

https://www.martin-konrad.net/nextcloud/index.php/s/mYHXWQxbJFz4LkL

The old implementation takes more than 100 us to create and start a new timer if there are already 30,000 timers in the queue (this number is based on a real-world scenario with Asyn/Stream at FRIB) and the new timer needs to be inserted at the beginning of the list (30,000 existing timers with 60 s, the new timer has 30 s duration). In this case the old code has to walk a linked list from the back all the way to the front (the code was optimized for inserting timers with the same duration). The new implementation performs two orders of magnitude better in this scenario. Not bad! None of the cases I benchmarked is performing significantly worse than with the old implementation. For comparison I also benchmarked boost::asio's timers - its performance is in the same order of magnitude.

See https://github.com/mark0n/benchmark_timerqueue for my benchmark code.

[Jeff Hill (johill-lanl)]

Martin,

I will hopefully attend to to the build errors tomorrow. Suspect that MSVC will never work with valgrind? If so we can simply ifdef the valgrind macros out? Need to take closer look.

Also need to look at your performance metrics.

Jeff

________________________________
From: <email address hidden> <email address hidden> on behalf of Martin Konrad <email address hidden>
Sent: Friday, April 24, 2020 1:27 PM
To: Hill, Jeff
Subject: [EXTERNAL] Re: [Merge] ~johill-lanl/epics-base/+git/epics-base:timer-queue-fix into epics-base:7.0

I haven't looked at the code, yet, but it builds fine on Ubuntu 19.10 with GCC 9.2: no warnings, all tests pass :-) A few compiler/OS combinations fail to build on Travis (https://travis-ci.com/github/mark0n/epics-base/builds/161843145) and AppVeyor (https://ci.appveyor.com/project/MartinKonrad/epics-base/builds/32416944), though.

Before digging into the code, I benchmarked the old and the proposed timer queue implementation. You can find the results here:

https://www.martin-konrad.net/nextcloud/index.php/s/mYHXWQxbJFz4LkL

The old implementation takes more than 100 us to create and start a new timer if there are already 30,000 timers in the queue (this number is based on a real-world scenario with Asyn/Stream at FRIB) and the new timer needs to be inserted at the beginning of the list (30,000 existing timers with 60 s, the new timer has 30 s duration). In this case the old code has to walk a linked list from the back all the way to the front (the code was optimized for inserting timers with the same duration). The new implementation performs two orders of magnitude better in this scenario. Not bad! None of the cases I benchmarked is performing significantly worse than with the old implementation. For comparison I also benchmarked boost::asio's timers - its performance is in the same order of magnitude.

See https://github.com/mark0n/benchmark_timerqueue for my benchmark code.
--
https://code.launchpad.net/~johill-lanl/epics-base/+git/epics-base/+merge/382887
You are the owner of ~johill-lanl/epics-base/+git/epics-base:timer-queue-fix.

[Martin Konrad (info-martin-konrad)]

I have pushed a few suggestions to https://github.com/mark0n/epics-base/tree/timer-queue-fix-mk that among other things fix the failing builds with clang. I'll keep adding to this branch as I review the code.

9b266f7... by Jeff Hill on 2020-04-30

fixed bug occuring when timer restarted from within timer callback

1eee997... by Jeff Hill on 2020-04-30

merged from 7.0

85b70eb... by Jeff Hill on 2020-04-30

Merge branch 'timer-queue-fix' of git+ssh://git.launchpad.net/~johill-lanl/epics-base/+git/epics-base into timer-queue-fix

437efa7... by Jeff Hill on 2020-05-01

improved comments

854b08a... by Jeff Hill on 2020-05-01

test timer callback restarts timer path

78b49c4... by Jeff Hill on 2020-05-01

cosmetics

[Jeff Hill (johill-lanl)]

Hi Martin,

Sorry about delayed response; I have been focusing on another project.

I had a quick look at your branch, and all of it looks in principal good. My spelling is unfortunately egregious and of course the doc is a needed upgrade. Some of the macros I use in other codes, to ease into C++ 11, but if some of them are already in 7.0 under different names then I will need to switch to those names of course. I don't recall seeing these duplications under different names; I will need to look closer.

The API on the gnu demangler function is unfortunately tricky to use, and I had to make some adjustments in the demangler support early on, but haven't touched that code for a year or so. I haven't looked at support for other compilers such as clang, but perhaps it (clang) will be compatible to gcc. As I recall the MSVC provides names from type_info::name already in human readable form.

I have another merge request in progress which actually uses some of the c++ 11 compatibility macros you are removing. They could be added back in for that proposal of course.

I could merge, probably all of, your changes into my branch. Is that how you want to proceed?

Jeff

________________________________
From: <email address hidden> <email address hidden> on behalf of Martin Konrad <email address hidden>
Sent: Monday, April 27, 2020 11:30 AM
To: Hill, Jeff
Subject: [EXTERNAL] Re: [Merge] ~johill-lanl/epics-base/+git/epics-base:timer-queue-fix into epics-base:7.0

I have pushed a few suggestions to https://github.com/mark0n/epics-base/tree/timer-queue-fix-mk that among other things fix the failing builds with clang. I'll keep adding to this branch as I review the code.
--
https://code.launchpad.net/~johill-lanl/epics-base/+git/epics-base/+merge/382887
You are the owner of ~johill-lanl/epics-base/+git/epics-base:timer-queue-fix.

Unmerged commits

78b49c4... by Jeff Hill on 2020-05-01

cosmetics

854b08a... by Jeff Hill on 2020-05-01

test timer callback restarts timer path

437efa7... by Jeff Hill on 2020-05-01

improved comments

85b70eb... by Jeff Hill on 2020-04-30

Merge branch 'timer-queue-fix' of git+ssh://git.launchpad.net/~johill-lanl/epics-base/+git/epics-base into timer-queue-fix

1eee997... by Jeff Hill on 2020-04-30

merged from 7.0

9b266f7... by Jeff Hill on 2020-04-30

fixed bug occuring when timer restarted from within timer callback

c112d69... by Jeff Hill on 2020-04-23

Merge branch '7.0' into timer-queue-fix

099c0ea... by Jeff Hill on 2020-04-21

fixed spelling in comment

eb4fa08... by Jeff Hill on 2020-04-20

o switched from epicsTime :: getCurrent to epicsTime :: getMonotonic as per EPICS 7 convention

Nevertheless, personally I have some concerns
---------------------------------------------

I do understand that general time can cause time discontinuities, and that discontinuities are
bad for a timer queue. However, I also worry about this being a backward incompatible API change,
and about users subtracting monotonic epicsTime time from ordinary epicsTime to produce a garbage
difference amount. Perhaps a different user defined type should have been used for monotonic
time. Also, does monotonic epicsTime convert to a date the same as ordinary epicsTime?

9dafde4... by Jeff Hill on 2020-04-20

resrve heap space during timer instantiation

diff --git a/.ci b/.ci
 deleted file mode 160000
index e91a588..0000000
--- a/.ci
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit e91a5883704e9fa57792953436eb7020baf37063
diff --git a/configure/CONFIG.gnuCommon b/configure/CONFIG.gnuCommon
index c4fd8ce..96eab65 100644
--- a/configure/CONFIG.gnuCommon
+++ b/configure/CONFIG.gnuCommon
@@ -35,7 +35,7 @@ CODE_CFLAGS += $(ASAN_FLAGS_$(ENABLE_ASAN))
 WARN_CFLAGS_YES = -Wall
 WARN_CFLAGS_NO = -w
 OPT_CFLAGS_YES = -O3
-OPT_CFLAGS_NO = -g
+OPT_CFLAGS_NO = -g -DMEMCHECK
 
 PROF_CXXFLAGS_YES = -p
 GPROF_CXXFLAGS_YES = -pg
@@ -44,7 +44,7 @@ CODE_CXXFLAGS += $(ASAN_FLAGS_$(ENABLE_ASAN))
 WARN_CXXFLAGS_YES = -Wall
 WARN_CXXFLAGS_NO = -w
 OPT_CXXFLAGS_YES = -O3
-OPT_CXXFLAGS_NO = -g
+OPT_CXXFLAGS_NO = -g -DMEMCHECK
 
 CODE_LDFLAGS = $(PROF_CXXFLAGS_$(PROFILE)) $(GPROF_CXXFLAGS_$(GPROF))
 CODE_LDFLAGS += $(ASAN_LDFLAGS_$(ENABLE_ASAN))
diff --git a/modules/libcom/src/Makefile b/modules/libcom/src/Makefile
index 57533ba..c966e2c 100644
--- a/modules/libcom/src/Makefile
+++ b/modules/libcom/src/Makefile
@@ -15,6 +15,8 @@ include $(TOP)/configure/CONFIG
 #USR_CFLAGS += -DNVALGRIND
 
 INC += valgrind/valgrind.h
+INC += valgrind/memcheck.h
+INC += valgrind/epicsMemChk.h
 
 INC += libComVersion.h
 INC += libComVersionNum.h
diff --git a/modules/libcom/src/misc/AllocatorArena.h b/modules/libcom/src/misc/AllocatorArena.h
 new file mode 100644
index 0000000..33a46c5
--- /dev/null
+++ b/modules/libcom/src/misc/AllocatorArena.h
@@ -0,0 +1,944 @@
+
+/*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ * Author Jeffrey O. Hill
+ */
+
+//
+// Arena Allocator
+//
+// A thread private allocator for N of type T allocated in-mass, and
+// deallocated in-mass. The individual calls to allocate run very
+// efficiently because they simply return a pointer to preallocated
+// space for a type T, and advance the index identifying the space for
+// the next allocation, using thread private storage sans mutex
+// protection overhead. The in-bulk deallocation is postponed until 
+// the last active T, residing within a bulk allocated block, is 
+// deallocated.
+//
+// The allocator falls back to ordinary global new/delete if the user 
+// requests more than one element for allocation using the vector 
+// form of new.
+//
+// This facility is fully safe for use in a multi-threaded environment.
+// A thread private variable, and a thread private cleanup, are used to
+// maintain a thread private context so that the overhead associated
+// with a mutual exclusion locking can be avoided.
+//
+// Be aware that the storage overhead for any type T is sizeof ( T ) plus 
+// sizeof ( void * ), a substantial consideration probably only if small 
+// objects are stored, and storage efficency is more important than 
+// performance considerations. Furthermore, storage overhead increases 
+// for C++ compilers predating C++ 11.
+//
+// In this code a contiguous bulk block of storage for N of type T 
+// is template type Rack<S,A,N> where S is the size of T, and A is the 
+// required alignment. The thread-private allocaton occurs when peeling 
+// off storage for an individual T from the thread's private Rack. When 
+// the thread's private Rack is exausted, then a new Rack is allocated 
+// from the specified Rack allocator type. Currently two global Rack 
+// allocator implementations are provided. One that uses ordinary global 
+// new/delete, and one that uses a mutex protected global free list 
+// (the default) designated by rack allocator policies rap_pool and 
+// rap_freeList respectively.
+//
+// Define ALLOCATOR_ARENA_MEMORY_ACCESS_INSPECTION_ACTIVE in order to
+// temporarily bypass bulk allocation and return to ordinary global
+// operator new and delete, so that memory access inspectors such as 
+// purify or valgrind might be more effective. Furthermore, when the 
+// allocator _is_ active, and it is a debug build, specialized
+// valgrind macros document with valgrind memory regions owned by this 
+// allocater for which ownership has not yet passed to an end application 
+// so that they do not appear as undesireable noise in valgrind leak 
+// reports.
+//
+
+#ifndef epicsAllocatorArena_h
+#define epicsAllocatorArena_h
+
+// see comment above
+#if 0
+#define ALLOCATOR_ARENA_MEMORY_ACCESS_INSPECTION_ACTIVE
+#endif
+
+#if __cplusplus >= 201103L
+#   include <cstdint>
+#endif
+
+#include <new>
+#include <cstdlib>
+#include <string>
+#include <cstdio>
+#include <typeinfo>
+
+#include "epicsAtomic.h"
+#include "epicsMutex.h"
+#include "epicsThread.h"
+#include "epicsStaticInstance.h"
+#include "compilerDependencies.h"
+#include "valgrind/epicsMemChk.h"
+#include "shareLib.h"
+
+
+#if __cplusplus >= 201103L
+#   if defined ( __GNUC__ ) 
+#       define GCC_VERSION_AA \
+            (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+        // perhaps the nios2 cross compiler doesnt properly implement 
+        // alignment even at gcc 4.8, based on experimental evidence
+#       define ALIGNAS_CMPLR_OK ( GCC_VERSION_AA >= 50000 )
+#   else
+#       define ALIGNAS_CMPLR_OK 1
+#   endif
+#else
+#   define ALIGNAS_CMPLR_OK 0
+#endif
+
+#ifndef SIZE_MAX
+#   define SIZE_MAX ( static_cast < size_t > ( -1L ) )
+#endif
+
+namespace epics {
+namespace _impl {
+
+using std :: size_t;
+using std :: type_info;
+using std :: ptrdiff_t;
+using std :: allocator;
+using std :: bad_alloc;
+
+//
+// S - the allocation size (the size of T)
+// A - the required alignment
+// N - the block size for pool allocation 
+//     (pool allocation size will be approximately S * N)
+//
+template < size_t S, size_t A, size_t N = 256 > class Rack;
+
+//
+// R - the rack type
+// P - the allocation policy type
+// TRACE - if true, print a message each time that a new racks allocated
+//         counter power of two is exceeded for a particular allocation type
+//
+enum RackAllocPolicy { rap_pool, rap_freeList };
+template < typename R, RackAllocPolicy P, bool TRACE > class RackAlloc;
+
+//
+// T - the allocation type
+// G - the discriminator for the thread private variable group
+//     (proper scaling requires an independent thread private variable
+//      group for each library) any type is allowed and appropriate for
+//      identifying an independent thread private context
+// N - the block size for pool allocation 
+// A - the rack allocator
+//
+// on old compilers prior to ALIGNAS_CMPLR_OK all blocks are aligned 
+// for worst case alignment requirements
+//
+template < typename T, typename G, size_t N = 256, 
+            RackAllocPolicy P = rap_freeList, bool TRACE = false >
+class AllocatorArena {
+public:
+    typedef T value_type;
+    typedef value_type * pointer;
+    typedef const value_type * const_pointer;
+    typedef value_type & reference;
+    typedef const value_type & const_reference;
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef typename allocator < void > :: const_pointer void_const_pointer;
+    typedef typename allocator < void > :: pointer void_pointer;
+
+    template < typename T0 >
+    struct rebind {
+        typedef AllocatorArena < T0, G, N, P, TRACE > other;
+    };
+
+    AllocatorArena ();
+
+    template < typename Y >
+    AllocatorArena ( const Y & );
+
+    //    address
+    static pointer address ( reference r );
+    static const_pointer address ( const_reference r );
+
+    //    memory allocation
+    static pointer allocate ( size_type nAlloc,
+                                void_const_pointer pNearbyHint = 0 );
+    static void deallocate ( const pointer p, size_type nAlloc );
+
+    // helpers, for creating class specific operator new and delete
+    static void * allocateOctets ( size_type size );
+    static void * allocateOctets ( size_type size, const std :: nothrow_t & );
+    static void deallocateOctets ( void * p, size_type size );
+
+    // remove the allocator's thread private reference to any partially
+    // consumed block so that it can be released back into system pool
+    // (this action is automated at thread exit)
+    static void cleanup ();
+
+    //    size
+    static size_type max_size ();
+
+    // construction / destruction of target
+#if __cplusplus >= 201103L  
+    template < typename T0, typename ... Args >
+    static void construct ( T0 *, Args && ... ); // depricated in c++ 17
+#else
+    template < typename T0, typename A0 >
+    static void construct ( T0 *, A0 ); 
+    template < typename T0, typename A0, typename A1 >
+    static void construct ( T0 *, A0, A1 ); 
+    template < typename T0, typename A0, typename A1, typename A2 >
+    static void construct ( T0 *, A0, A1, A2 ); 
+    template < typename T0, typename A0, typename A1, typename A2, 
+                            typename A3 >
+    static void construct ( T0 *, A0, A1, A2, A3 ); 
+    template < typename T0, typename A0, typename A1, typename A2, 
+                            typename A3, typename A4 >
+    static void construct ( T0 *, A0, A1, A2, A3, A4 ); 
+#endif
+    template < class U >
+    static void destroy ( U * ); // depricated in c++ 17
+
+    bool operator == ( AllocatorArena const & );
+    bool operator != ( AllocatorArena const & );
+
+    static size_t rackCount ();
+    static size_t byteCount ();
+private:
+#if ALIGNAS_CMPLR_OK
+    typedef Rack < sizeof ( T ), alignof ( T ), N > M_Rack;
+#else
+    /* worst case alignment is used */
+    typedef Rack < sizeof ( T ), 0u, N > M_Rack;
+#endif
+    typedef RackAlloc < M_Rack, P, TRACE > M_RackAlloc;
+    static pointer m_threadPrivateAlloc ();
+    static void m_rackCleanup ( void * );
+}; // end of class AllocatorArena
+
+class epicsShareClass ThreadPrivateIdBadAlloc : public bad_alloc 
+{
+    const char * what () const throw ();
+};
+
+class epicsShareClass AtThreadExitBadAlloc : public bad_alloc 
+{
+    const char * what () const throw ();
+};
+
+#if __cplusplus >= 201103L
+    typedef std :: uint8_t Octet;
+#else
+    typedef unsigned char Octet;
+#endif
+
+typedef Octet * POctet;
+
+// align for all possible types, similar to malloc
+union MaxAlign {
+    struct SomeStruct {};
+    long double m_ld;
+    long long m_ll;
+    long double * m_pd;
+    SomeStruct * m_pss;
+    void (* m_pf) ();
+    long double SomeStruct :: * m_pmd;
+    void ( SomeStruct :: * m_pmf ) ();
+    /*
+     * eye of newt ...
+     */
+};
+
+template < size_t S, size_t A, size_t N >
+class Rack {
+public:
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+
+    Rack ();
+    ~Rack ();
+    bool empty () const;
+    void * alloc ();
+    size_t removeReference ();
+    void addReference ();
+
+    static const size_t number;
+    static const size_t alignment;
+    static Rack * dealloc ( void * );
+private:
+    struct M_Wrapper {
+        VALGRIND_RED_ZONE ( m_redZoneBefore )
+#       if ALIGNAS_CMPLR_OK
+            alignas ( A ) Octet m_bufForObj [ S ];
+#       else
+            union {
+                Octet m_bufForObj [ S ];
+                MaxAlign m_maxAlign;
+            };
+#       endif
+        VALGRIND_RED_ZONE ( m_redZoneAfter )
+        void * m_pRack;
+    };
+    typedef M_Wrapper * PWrapper;
+    M_Wrapper m_wrapped[N];
+    size_t m_nAlloc;
+    size_t m_refCount;
+#if __cplusplus >= 201103L
+    Rack ( const Rack & ) = delete;
+    Rack & operator = ( const Rack & ) = delete;
+#endif
+};
+
+struct RackManager {
+    void * m_pRack;
+    void ( *m_pThreadExitFunc )( void * pRack );
+};
+
+class epicsShareClass AllocCtxCom {
+public:
+    AllocCtxCom ();
+    RackManager * getRackHandlerPtr ( size_t idx );
+    void cleanup ( size_t idx );
+    size_t allocIdx ();
+private:
+    epicsThreadPrivateId m_threadPrivateId;
+    size_t m_curIdx;
+    static void m_threadExitFunc ( void * const pPriv );
+    static const size_t m_initialCapacity;
+};
+
+//
+// G - the discriminator for the thread private variable group
+//     (proper scaling requires an indepent thread private variable
+//      group for each library) any type is allowed and appropriate 
+//      for identifying an independent thread private context
+//
+template < typename G > class AllocCtxGrouped : public AllocCtxCom {};
+
+//
+// G - the discriminator for the thread private variable group
+//     (proper scaling requires an indepent thread private variable
+//      group for each library) any type is allowed and appropriate 
+//      for identifying an independent thread private context
+//
+template < typename G >
+class AllocCtx {
+public:
+    AllocCtx ();
+    void cleanup ();
+    RackManager * getRackHandlerPtr ();
+private:
+    size_t m_idx;
+};
+
+//
+// T - the allocation type
+// G - the discriminator for the thread private variable group
+//     (proper scaling requires an indepent thread private variable
+//      group for each library) any type is allowed and appropriate 
+//      for identifying an independent thread private context
+//
+template < typename T, typename G > 
+class AllocCtxTyped : public AllocCtx < G > {};
+
+template < bool TRACE >
+class epicsShareClass AllocCounter;
+
+template <>
+class epicsShareClass AllocCounter < true > {
+public:
+    AllocCounter ();
+    void increment ( size_t nBytesThisTime, const type_info & );
+    void decrement ( size_t nBytesThisTime );
+    size_t rackCount () const { return m_nRacks; }
+    size_t byteCount () const { return m_bytes; }
+    void show ( const type_info & ) const;
+private:
+    size_t m_nRacksTrace;
+    size_t m_nRacks;
+    size_t m_bytes;
+};
+
+template <>
+class epicsShareClass AllocCounter < false > {
+public:
+    void increment ( size_t nBytesThisTime,
+                        const type_info & ) {}
+    void decrement ( size_t nBytesThisTime ) {}
+    size_t rackCount () const { return 0u; }
+    size_t byteCount () const { return 0u; }
+    void show ( const char * pContext ) const {}
+};
+
+template < typename R, bool TRACE >
+class RackAlloc < R, rap_pool, TRACE > {
+public:
+    typedef R Rack;
+    template < typename R0 >
+    struct rebind {
+        typedef RackAlloc < R0, rap_pool, TRACE > other;
+    };
+    static R * create ( const type_info & ti );
+    static void destroy ( R * p );
+    static size_t rackCount ();
+    static size_t byteCount ();
+private:
+    static AllocCounter < TRACE > m_counter;
+};
+
+template < typename R, bool TRACE >
+class RackAlloc < R, rap_freeList, TRACE > {
+public:
+    template < typename R0 >
+    struct rebind {
+        typedef RackAlloc < R0, rap_freeList, TRACE > other;
+    };
+    typedef R Rack;
+    RackAlloc ();
+    ~RackAlloc ();
+    R * create ( const type_info & );
+    void destroy ( R * p );
+    size_t rackCount () const;
+    size_t byteCount () const;
+private:
+    typedef epicsMutex Mutex;
+    typedef epicsGuard < epicsMutex > Guard;
+    struct M_Alias {
+        VALGRIND_RED_ZONE ( m_redZoneBefore )
+        union {
+#           if ALIGNAS_CMPLR_OK
+                alignas ( R :: alignment ) 
+                    Octet m_rackBuf [ sizeof ( R ) ];
+#           else
+                union {
+                    Octet m_rackBuf [ sizeof ( R ) ];
+                    MaxAlign m_maxAlign;
+                };  
+#           endif
+            struct M_Alias * m_pNext;
+        };
+        VALGRIND_RED_ZONE ( m_redZoneAfter )
+    };
+    M_Alias * m_pAlias;
+    Mutex m_mutex;
+    AllocCounter < TRACE > m_counter;
+    RackAlloc ( const RackAlloc & ) epicsDeleteMethod;
+    RackAlloc operator = ( const RackAlloc & ) epicsDeleteMethod;
+};
+
+template < typename G >
+inline AllocCtx < G > :: AllocCtx () :
+    m_idx ( staticInstance < AllocCtxGrouped < G > > ().allocIdx () )
+{ 
+}
+
+template < typename G >
+inline RackManager * AllocCtx < G > :: getRackHandlerPtr () 
+{ 
+    AllocCtxCom & grp = staticInstance < AllocCtxGrouped < G > > ();
+    return grp.getRackHandlerPtr ( m_idx );
+}
+
+template < typename G >
+void AllocCtx < G > :: cleanup () 
+{ 
+    AllocCtxCom & grp = staticInstance < AllocCtxGrouped < G > > ();
+    grp.cleanup ( m_idx );
+}
+
+template < typename R, bool TRACE >
+inline R * RackAlloc < R, rap_pool, TRACE > :: create ( const type_info & ti )
+{
+    R * const p = new R ();
+    m_counter.increment ( sizeof ( R ), ti );
+    return p;
+}
+
+template < typename R, bool TRACE >
+inline void RackAlloc < R, rap_pool, TRACE > :: destroy ( R * p )
+{
+    m_counter.decrement ( sizeof ( R ) );
+    delete p;
+}
+
+template < typename R, bool TRACE >
+inline size_t RackAlloc < R, rap_pool, TRACE > :: rackCount ()
+{ 
+    return m_counter.rackCount (); 
+}
+
+template < typename R, bool TRACE >
+inline size_t RackAlloc < R, rap_pool, TRACE > :: byteCount ()
+{ 
+    return m_counter.byteCount (); 
+}
+
+template < typename R, bool TRACE >
+inline RackAlloc < R, rap_freeList, TRACE > :: RackAlloc () : 
+    m_pAlias ( 0 )
+{
+    VALGRIND_CREATE_MEMPOOL_EXT ( this, sizeof (epicsMemChkRedZone), 
+                                false, VALGRIND_MEMPOOL_METAPOOL );
+}
+
+template < typename R, bool TRACE >
+RackAlloc < R, rap_freeList, TRACE > :: ~RackAlloc ()
+{
+    Guard guard ( m_mutex );
+    M_Alias * p = m_pAlias;
+    while ( p ) {
+        M_Alias * pNext = p->m_pNext;
+        {
+            delete p;
+        }
+        p = pNext;
+    };
+    VALGRIND_DESTROY_MEMPOOL ( this );
+}
+
+template < typename R, bool TRACE >
+R * RackAlloc < R, rap_freeList, TRACE > :: create ( 
+                                        const type_info & ti )
+{
+    M_Alias * pA = 0;
+    {
+        Guard guard ( m_mutex );
+        if ( m_pAlias ) {
+            pA = m_pAlias;
+            m_pAlias = m_pAlias->m_pNext;
+        }
+    }
+    if ( ! pA ) {
+        pA = new M_Alias;
+        VALGRIND_MAKE_MEM_NOACCESS ( pA, sizeof ( *pA ) );
+    }
+    VALGRIND_MEMPOOL_ALLOC ( this, pA->m_rackBuf, 
+                                        sizeof ( pA->m_rackBuf ) );
+    m_counter.increment ( sizeof ( R ), ti );
+
+    return new ( pA->m_rackBuf ) R ();
+}
+
+template < typename R, bool TRACE >
+void RackAlloc < R, rap_freeList, TRACE > :: destroy ( R * const pR )
+{
+    if ( pR ) {
+        pR->~R ();
+        static const size_t bufOffset = offsetof ( M_Alias, m_rackBuf );
+        const POctet pOctets = reinterpret_cast < POctet > ( pR ) - bufOffset;
+        M_Alias * const pA = reinterpret_cast < M_Alias * > ( pOctets );
+        VALGRIND_MEMPOOL_FREE ( this, pA->m_rackBuf );
+        VALGRIND_MAKE_MEM_UNDEFINED ( &pA->m_pNext, sizeof ( pA->m_pNext ) );
+        {
+            Guard guard ( m_mutex );
+            pA->m_pNext = m_pAlias;
+            m_pAlias = pA;
+        }
+        VALGRIND_MAKE_MEM_DEFINED ( &pA->m_pNext, sizeof ( pA->m_pNext ) );
+        m_counter.decrement ( sizeof ( R ) );
+    }
+}
+
+template < typename R, bool TRACE >
+inline size_t RackAlloc < R, rap_freeList, TRACE > :: rackCount () const
+{ 
+    return m_counter.rackCount (); 
+}
+
+template < typename R, bool TRACE >
+inline size_t RackAlloc < R, rap_freeList, TRACE > :: byteCount () const
+{ 
+    return m_counter.byteCount (); 
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline AllocatorArena < T, G, N, P, TRACE > :: AllocatorArena ()
+{
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+template < typename Y >
+inline AllocatorArena < T, G, N, P, TRACE > :: AllocatorArena ( const Y & ) 
+{
+}
+
+//    address
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline typename AllocatorArena < T, G, N, P, TRACE > :: pointer
+    AllocatorArena < T, G, N, P, TRACE > :: address ( reference r )
+{
+    return & r;
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline typename AllocatorArena < T, G, N, P, TRACE > :: const_pointer
+    AllocatorArena < T, G, N, P, TRACE > :: address ( const_reference r )
+{
+    return & r;
+}
+
+//
+//    memory allocation
+//    (inline arranges for pNearbyHint to be eliminated 
+//      at compile time)
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline typename AllocatorArena < T, G, N, P, TRACE > :: pointer
+    AllocatorArena < T, G, N, P, TRACE > :: allocate ( size_type nAlloc,
+                                        void_const_pointer pNearbyHint )
+{
+    pointer p;
+    if ( nAlloc == 1u ) {
+#if defined ( ALLOCATOR_ARENA_MEMORY_ACCESS_INSPECTION_ACTIVE )
+#       if __cplusplus >= 201703L
+            void * const pVoid = :: operator new ( sizeof (T), 
+                                                    alignof ( T ) );
+#       else
+            // This function is required to return a pointer suitably 
+            // aligned to hold an object of any fundamental alignment.
+            void * const pVoid = :: operator new ( sizeof (T) );
+#       endif
+        p = static_cast < pointer > ( pVoid );
+#else
+        p = m_threadPrivateAlloc ();
+#endif
+    }
+    else {
+#       if __cplusplus >= 201703L
+            void * const pVoid = :: operator new ( sizeof (T) * nAlloc, 
+                                                    alignof ( T ) );
+#       else
+            // This function is required to return a pointer suitably 
+            // aligned to hold an object of any fundamental alignment.
+            void * const pVoid = :: operator new ( sizeof (T) * nAlloc );
+#       endif
+        p = static_cast < pointer > ( pVoid );
+    }
+    return p;
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline void AllocatorArena < T, G, N, P, TRACE > :: deallocate ( const pointer p,
+                                                                size_type nAlloc )
+{
+    if ( nAlloc == 1u ) {
+#if defined ( ALLOCATOR_ARENA_MEMORY_ACCESS_INSPECTION_ACTIVE )
+        :: operator delete ( p );
+#else
+        M_Rack * const pRack = M_Rack :: dealloc ( p );
+        if ( pRack ) {
+            staticInstance < M_RackAlloc > ().destroy ( pRack );
+        }
+#endif
+    }
+    else {
+        :: operator delete ( p );
+    }
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline void * AllocatorArena < T, G, N, P, TRACE > :: 
+                                allocateOctets ( size_type sz )
+{
+    if ( sz == sizeof ( T ) ) {
+        return AllocatorArena :: allocate ( 1u );
+    }
+    else {
+        // This function is required to return a pointer suitably 
+        // aligned to hold an object of any fundamental alignment.
+        return :: operator new ( sz );
+    }
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline void * AllocatorArena < T, G, N, P, TRACE > :: 
+                                allocateOctets ( size_type sz, 
+                                        const std :: nothrow_t & )
+{
+    if ( sz == sizeof ( T ) ) {
+        try {
+            return AllocatorArena :: allocate ( 1u );
+        }
+        catch ( const std :: bad_alloc & ) {
+            return static_cast < void * > ( 0 );
+        }
+    }
+    else {
+        // This function is required to return a pointer suitably 
+        // aligned to hold an object of any fundamental alignment.
+        return :: operator new ( sz, std :: nothrow );
+    }
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline void AllocatorArena < T, G, N, P, TRACE > :: 
+                            deallocateOctets ( void * const p, size_type sz )
+{
+    if ( sz == sizeof ( T ) ) {
+        T * const pT = static_cast < T * > ( p );
+        AllocatorArena :: deallocate ( pT, 1u );
+    }
+    else {
+#if __cplusplus >= 201400L
+        :: operator delete ( p, sz );
+#else
+        :: operator delete ( p );
+#endif
+    }
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline typename AllocatorArena < T, G, N, P, TRACE > :: size_type
+    AllocatorArena < T, G, N, P, TRACE > :: max_size ()
+{
+    // This class is intended only for use with an allocation size of one;
+    // if requests for more than one object occur it falls back to ordinary
+    // new and delete based allocation.
+    return 1u;
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+typename AllocatorArena < T, G, N, P, TRACE > :: pointer
+    AllocatorArena < T, G, N, P, TRACE > :: m_threadPrivateAlloc ()
+{
+    AllocCtx < G > & ctx = staticInstance < AllocCtxTyped < T, G > > ();
+    RackManager * const pRM = ctx.getRackHandlerPtr ();
+    M_Rack * pRack = static_cast < M_Rack * > ( pRM->m_pRack );
+    if ( pRack ) {
+        pointer p = static_cast < T * > ( pRack->alloc () );
+        if ( p ) {
+            if ( pRack->empty () ) {
+                assert ( pRM->m_pThreadExitFunc );
+                ( *pRM->m_pThreadExitFunc ) ( pRack );
+                pRM->m_pThreadExitFunc = 0;
+                pRM->m_pRack = 0;
+            }
+            return p;
+        }
+        assert ( pRM->m_pThreadExitFunc );
+        ( *pRM->m_pThreadExitFunc ) ( pRack );
+        pRM->m_pThreadExitFunc = 0;
+        pRM->m_pRack = 0;
+    }
+    pRack = staticInstance < M_RackAlloc > ().create ( typeid ( T ) );
+    assert ( pRack );
+    pRack->addReference ();
+    pRM->m_pThreadExitFunc = m_rackCleanup;
+    pRM->m_pRack = pRack;
+    pointer p = static_cast < pointer > ( pRack->alloc () );
+    assert ( p );
+    return p;
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+void AllocatorArena < T, G, N, P, TRACE > :: m_rackCleanup ( void * const pPriv )
+{
+    assert ( pPriv );
+    M_Rack * pRack = static_cast < M_Rack * > ( pPriv );
+    if ( pRack->removeReference () == 0u ) {
+        staticInstance < M_RackAlloc > ().destroy ( pRack );
+    }
+}
+
+#if __cplusplus >= 201103L
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+template < typename T0, typename ... Args >
+inline void AllocatorArena < T, G, N, P, TRACE > :: construct ( T0 * p, 
+                                                Args && ... args )
+{
+    void * const pvoid = p;
+    :: new ( pvoid ) T0 ( std :: forward <Args> ( args ) ... );
+}
+#else
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+template < typename T0, typename A0 >
+inline void AllocatorArena < T, G, N, P, TRACE > :: construct (
+                                    T0 * p, A0 a0 )
+{
+    new ( p ) T ( a0 );
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+template < typename T0, typename A0, typename A1 >
+inline void AllocatorArena < T, G, N, P, TRACE > :: construct (
+                                    T0 * p, A0 a0, A1 a1 )
+{
+    new ( p ) T ( a0, a1 );
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+template < typename T0, typename A0, typename A1, typename A2 >
+inline void AllocatorArena < T, G, N, P, TRACE > :: construct (
+                                    T0 * p, A0 a0, A1 a1, A2 a2 )
+{
+    new ( p ) T ( a0, a1, a2 );
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+template < typename T0, typename A0, typename A1, typename A2,
+            typename A3 >
+inline void AllocatorArena < T, G, N, P, TRACE > :: construct (
+                                    T0 * p, A0 a0, A1 a1, A2 a2, A3 a3 )
+{
+    new ( p ) T ( a0, a1, a2, a3 );
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+template < typename T0, typename A0, typename A1, typename A2,
+            typename A3, typename A4 >
+inline void AllocatorArena < T, G, N, P, TRACE > :: construct (
+                                    T0 * p, A0 a0, A1 a1, A2 a2, A3 a3, 
+                                    A4 a4 )
+{
+    new ( p ) T ( a0, a1, a2, a3, a4 );
+}
+
+#endif
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+template < class U >
+inline void AllocatorArena < T, G, N, P, TRACE > :: destroy ( U * p )
+{
+    p->~U();
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline bool AllocatorArena < T, G, N, P, TRACE > :: operator == (
+                                        AllocatorArena const & ao )
+{
+    return true;
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline bool AllocatorArena < T, G, N, P, TRACE > :: operator != (
+                                        AllocatorArena const & a )
+{
+    return ! operator == ( a );
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline void AllocatorArena < T, G, N, P, TRACE > :: cleanup ()
+{
+    AllocCtx < G > & ctx = staticInstance < AllocCtxTyped < T, G > > ();
+    ctx.cleanup ();
+}
+ 
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline size_t AllocatorArena < T, G, N, P, TRACE > :: rackCount ()
+{
+    return staticInstance < M_RackAlloc > ().rackCount();
+}
+
+template < typename T, typename G, size_t N, RackAllocPolicy P, bool TRACE >
+inline size_t AllocatorArena < T, G, N, P, TRACE > :: byteCount ()
+{
+    return staticInstance < M_RackAlloc > ().byteCount();
+}
+
+template < size_t S, size_t A, size_t N >
+const size_t Rack < S, A, N > :: number = N;
+
+template < size_t S, size_t A, size_t N >
+const size_t Rack < S, A, N > :: alignment = A;
+
+template < size_t S, size_t A, size_t N >
+inline Rack < S, A, N > :: Rack () :
+    m_nAlloc ( 0u ),
+    m_refCount ( 0u )
+{
+    VALGRIND_MAKE_MEM_NOACCESS ( m_wrapped, sizeof ( m_wrapped ) );
+}
+
+template < size_t S, size_t A, size_t N >
+inline Rack < S, A, N > :: ~Rack ()
+{
+    // if a Rack allocating free list is destroyed, and it destroys 
+    // a rack with outstanding references remaining then  problems 
+    // will ensue 
+    assert ( m_refCount == 0u );
+    VALGRIND_MAKE_MEM_NOACCESS ( m_wrapped, sizeof ( m_wrapped ) );
+}
+
+template < size_t S, size_t A, size_t N >
+inline bool Rack < S, A, N > :: empty () const
+{
+    return m_nAlloc >= N;
+}
+
+template < size_t S, size_t A, size_t N >
+void * Rack < S, A, N > :: alloc ()
+{
+    void * p = 0;
+    if ( m_nAlloc < N ) {
+        M_Wrapper * const pAlloc = & m_wrapped[m_nAlloc];
+        m_nAlloc++;
+        this->addReference ();
+        VALGRIND_MAKE_MEM_UNDEFINED ( &pAlloc->m_pRack, 
+                                    sizeof ( pAlloc->m_pRack ) );
+        atomic :: set ( pAlloc->m_pRack, this );
+        VALGRIND_MAKE_MEM_DEFINED ( &pAlloc->m_pRack,
+                                    sizeof ( pAlloc->m_pRack ) );
+        p = static_cast < void * > ( pAlloc->m_bufForObj );
+        VALGRIND_MALLOCLIKE_BLOCK ( pAlloc->m_bufForObj, 
+                                    sizeof ( pAlloc->m_bufForObj ),
+                                    sizeof ( epicsMemChkRedZone ),
+                                    false );
+    }
+    return p;
+}
+
+template < size_t S, size_t A, size_t N >
+Rack < S, A , N > * Rack < S, A, N > :: dealloc ( void * const p )
+{
+    static const size_t bufOffset = offsetof ( M_Wrapper, m_bufForObj );
+    const POctet pOctets = static_cast < POctet > ( p ) - bufOffset; 
+    const PWrapper pDealloc = reinterpret_cast < PWrapper > ( pOctets );
+    VALGRIND_FREELIKE_BLOCK ( pDealloc->m_bufForObj,
+                                sizeof ( epicsMemChkRedZone ) );
+    Rack * const pRack = static_cast < Rack * > 
+                            ( atomic :: get ( pDealloc->m_pRack ) );
+    pDealloc->m_pRack = 0; // for imperfect error detection purposes 
+    assert ( pRack );
+    if ( pRack->removeReference () == 0u ) {
+        return pRack;
+    }
+    return 0;
+}
+
+template < size_t S, size_t A, size_t N >
+inline void Rack < S, A, N > :: addReference ()
+{
+    assert ( m_refCount < SIZE_MAX );
+    atomic :: increment ( m_refCount );
+}
+
+template < size_t S, size_t A, size_t N >
+inline size_t Rack < S, A, N > :: removeReference ()
+{
+    assert ( m_refCount > 0u );
+    return atomic :: decrement ( m_refCount );
+}
+
+} // end of name space _impl
+
+using _impl :: Rack;
+using _impl :: RackAlloc;
+using _impl :: RackAllocPolicy;
+using _impl :: rap_pool;
+using _impl :: rap_freeList;
+using _impl :: AllocatorArena;
+
+} // end of name space epics
+
+#endif // if not defined epicsAllocatorArena_h
+
diff --git a/modules/libcom/src/misc/AllocatorArenaUntyped.cpp b/modules/libcom/src/misc/AllocatorArenaUntyped.cpp
 new file mode 100644
index 0000000..91693a2
--- /dev/null
+++ b/modules/libcom/src/misc/AllocatorArenaUntyped.cpp
@@ -0,0 +1,199 @@
+
+/*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ * Author Jeffrey O. Hill
+ */
+ 
+#include <cstdio>
+#include <memory>
+
+#define epicsExportSharedSymbols
+#include "AllocatorArena.h"
+#include "errlog.h"
+#include "epicsTypes.h"
+#include "epicsExit.h"
+#include "epicsDemangle.h"
+
+namespace epics {
+namespace _impl {
+
+const char * ThreadPrivateIdBadAlloc :: what () const throw () 
+{
+    return "epicsThreadPrivateCreate returned nill";
+}
+
+const char * AtThreadExitBadAlloc :: what () const throw () 
+{
+    return "epicsAtThreadExit was unsuccessful";
+}
+
+const size_t AllocCtxCom :: m_initialCapacity = 16u;
+
+AllocCtxCom :: AllocCtxCom () :
+    m_threadPrivateId ( epicsThreadPrivateCreate () ),
+    m_curIdx ( 0 )
+{
+}
+
+union RackManagerUnion {
+    RackManager m_entry;
+    size_t m_capacity;
+};
+    
+size_t AllocCtxCom :: allocIdx ()
+{
+    return atomic :: increment ( m_curIdx );
+}
+
+/* 
+ * from the bit twiddling hacks web site
+ */
+static inline epicsUInt32 nextPwrOf2 ( epicsUInt32 v )
+{
+    v--;
+    v |= v >> 1u;
+    v |= v >> 2u;
+    v |= v >> 4u;
+    v |= v >> 8u;
+    v |= v >> 16u;
+    v++;
+    return v;
+}
+
+RackManager * AllocCtxCom :: getRackHandlerPtr ( const size_t idx )
+{
+    void * const pPriv = epicsThreadPrivateGet ( m_threadPrivateId );
+    RackManagerUnion * pThrPriv;
+    if ( pPriv ) {
+        pThrPriv = static_cast < RackManagerUnion * > ( pPriv );
+        if ( idx >= pThrPriv->m_capacity ) {
+            const size_t newCapacity = nextPwrOf2 ( idx + 1u );
+            RackManagerUnion * const pThrPrivNew = 
+                                    new RackManagerUnion [newCapacity];
+            assert ( newCapacity > idx );
+            size_t i;
+            for ( i = 1u; i < pThrPriv->m_capacity; i++ ) {
+                pThrPrivNew[i] = pThrPriv[i];
+            }
+            for ( i = pThrPriv->m_capacity; i < newCapacity; i++ ) {
+                pThrPrivNew[i].m_entry.m_pRack = 0;
+                pThrPrivNew[i].m_entry.m_pThreadExitFunc = 0;
+            }
+            pThrPrivNew->m_capacity = newCapacity;
+            delete [] pThrPriv;
+            epicsThreadPrivateSet ( m_threadPrivateId, pThrPrivNew );
+            pThrPriv = pThrPrivNew;
+        }
+    }
+    else {
+        size_t capacity;
+        if ( idx >= m_initialCapacity ) {
+            capacity = nextPwrOf2 ( idx + 1u );
+        }
+        else {
+            capacity = m_initialCapacity;
+        }
+        pThrPriv = new RackManagerUnion [capacity];
+        pThrPriv->m_capacity = capacity;
+        for ( size_t i = 1u; i < capacity; i++ ) {
+            pThrPriv[i].m_entry.m_pRack = 0;
+            pThrPriv[i].m_entry.m_pThreadExitFunc = 0;
+        }
+        int status = epicsAtThreadExit ( m_threadExitFunc, this );
+        if ( status != 0 ) {
+            delete [] pThrPriv;
+            throw AtThreadExitBadAlloc ();
+        }
+        epicsThreadPrivateSet ( m_threadPrivateId, pThrPriv );
+    }
+    return & pThrPriv[idx].m_entry;
+}
+
+void AllocCtxCom :: cleanup ( const size_t idx )
+{
+    void * const pPriv = epicsThreadPrivateGet ( m_threadPrivateId );
+    if ( pPriv ) {
+        RackManagerUnion * pThrPriv = 
+                            static_cast < RackManagerUnion * > ( pPriv );
+        if ( idx < pThrPriv->m_capacity ) {
+            if ( pThrPriv[idx].m_entry.m_pThreadExitFunc && 
+                                            pThrPriv[idx].m_entry.m_pRack ) {
+                ( *pThrPriv[idx].m_entry.m_pThreadExitFunc )
+                                    ( pThrPriv[idx].m_entry.m_pRack );
+                pThrPriv[idx].m_entry.m_pRack = 0;
+                pThrPriv[idx].m_entry.m_pThreadExitFunc = 0;
+            }
+        }
+    }
+}
+
+void AllocCtxCom :: m_threadExitFunc ( void * const pPriv ) 
+{
+    AllocCtxCom * const pCtx = static_cast < AllocCtxCom * > ( pPriv );
+    void * const pThrPrivVoid = epicsThreadPrivateGet ( pCtx->m_threadPrivateId );
+    if ( pThrPrivVoid ) {
+        RackManagerUnion * const pThrPriv = 
+                        static_cast < RackManagerUnion * > ( pThrPrivVoid );
+        for ( size_t i = 1u; i < pThrPriv->m_capacity; i++ ) {
+            if ( pThrPriv[i].m_entry.m_pThreadExitFunc && 
+                                            pThrPriv[i].m_entry.m_pRack ) {
+                ( *pThrPriv[i].m_entry.m_pThreadExitFunc )
+                                    ( pThrPriv[i].m_entry.m_pRack );
+            }
+        }
+        delete [] pThrPriv;
+        epicsThreadPrivateSet ( pCtx->m_threadPrivateId, 0 );
+    }
+}
+
+AllocCounter < true > :: AllocCounter ()
+{
+    atomic :: set ( m_nRacks, 0u );
+    atomic :: set ( m_bytes, 0u );
+    atomic :: set ( m_nRacksTrace, 8 );
+}
+
+static size_t m_nRacksTotal = 0u;
+static size_t m_bytesTotal = 0u;
+
+void AllocCounter < true > :: increment ( size_t nBytesThisTime,
+                                            const type_info & ti )
+{
+    const size_t newNRacksVal = atomic :: increment ( m_nRacks );
+    atomic :: increment ( m_nRacksTotal );
+    atomic :: add ( m_bytes, nBytesThisTime );
+    atomic :: add ( m_bytesTotal, nBytesThisTime );
+    if ( newNRacksVal >= m_nRacksTrace ) {
+        atomic :: add ( m_nRacksTrace, m_nRacksTrace );
+        this->show ( ti );
+    }
+}
+
+void AllocCounter < true > :: decrement ( size_t nBytesThisTime )
+{
+    atomic :: decrement ( m_nRacks );
+    atomic :: decrement ( m_nRacksTotal );
+    atomic :: subtract ( m_bytes, nBytesThisTime );
+    atomic :: subtract ( m_bytesTotal, nBytesThisTime );
+}
+
+void AllocCounter < true > :: show ( const type_info & ti ) const
+{
+    const std :: string name = epicsDemangleTypeName ( ti );
+    errlogPrintf ( 
+            "AA C=%08lu SZ=%08lu CT=%08lu SZT=%08lu \"%s\"\n", 
+            ( unsigned long ) m_nRacks,
+            ( unsigned long ) m_bytes,
+            ( unsigned long ) m_nRacksTotal,
+            ( unsigned long ) m_bytesTotal,
+            name.c_str () );
+}
+
+} // end of name space _impl
+} // end of name space epics
diff --git a/modules/libcom/src/misc/Makefile b/modules/libcom/src/misc/Makefile
index 3d5412d..fb94ec9 100644
--- a/modules/libcom/src/misc/Makefile
+++ b/modules/libcom/src/misc/Makefile
@@ -27,6 +27,7 @@ INC += ipAddrToAsciiAsynchronous.h
 INC += compilerDependencies.h
 INC += epicsUnitTest.h
 INC += testMain.h
+INC += AllocatorArena.h
 
 # epicsVersion.h is created by this Makefile
 INC += epicsVersion.h
@@ -42,3 +43,5 @@ Com_SRCS += epicsString.c
 Com_SRCS += truncateFile.c
 Com_SRCS += ipAddrToAsciiAsynchronous.cpp
 Com_SRCS += epicsUnitTest.c
+Com_SRCS += AllocatorArenaUntyped.cpp
+
diff --git a/modules/libcom/src/osi/Makefile b/modules/libcom/src/osi/Makefile
index f0108e6..9e1dcee 100644
--- a/modules/libcom/src/osi/Makefile
+++ b/modules/libcom/src/osi/Makefile
@@ -9,8 +9,16 @@
 
 SRC_DIRS += $(LIBCOM)/osi
 
+# compiler specific
 INC += compilerDependencies.h
 INC += compilerSpecific.h
+INC += epicsStaticInstance.h
+INC += epicsStaticInstanceCD.h
+INC += epicsStaticInstanceSaneCmplr.h
+INC += epicsStaticInstanceSketchyCmplr.h
+
+Com_SRCS += epicsStaticInstanceSketchyCmplr.cpp
+Com_SRCS += compilerDependentDemangle.cpp
 
 INC += osiFileName.h
 INC += osiSock.h
@@ -57,6 +65,7 @@ INC += epicsStdioRedirect.h
 INC += epicsTempFile.h
 INC += epicsGetopt.h
 INC += epicsStackTrace.h
+INC += epicsDemangle.h
 
 INC += devLib.h
 INC += devLibVME.h
@@ -157,3 +166,4 @@ Com_SRCS_WIN32 += forceBadAllocException.cpp
 Com_SRCS += epicsStackTrace.c
 Com_SRCS += osdBackTrace.cpp
 Com_SRCS += osdFindAddr.c
+
diff --git a/modules/libcom/src/osi/compiler/clang/compilerSpecific.h b/modules/libcom/src/osi/compiler/clang/compilerSpecific.h
index 0498f6e..c06272f 100644
--- a/modules/libcom/src/osi/compiler/clang/compilerSpecific.h
+++ b/modules/libcom/src/osi/compiler/clang/compilerSpecific.h
@@ -1,4 +1,6 @@
 /*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2008 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
@@ -29,6 +31,8 @@
 /* Expands to a 'const char*' which describes the name of the current function scope */
 #define EPICS_FUNCTION __PRETTY_FUNCTION__
 
+#define NO_RETURN __attribute__((noreturn))
+
 #ifdef __cplusplus
 
 /*
@@ -36,6 +40,8 @@
  */
 #define CXX_PLACEMENT_DELETE
 
+#define USING_BASE_TYPE(B,T) using typename B :: T;
+
 #endif /* __cplusplus */
 
 /*
diff --git a/modules/libcom/src/osi/compiler/clang/epicsAtomicCD.h b/modules/libcom/src/osi/compiler/clang/epicsAtomicCD.h
index 763cb05..515129b 100644
--- a/modules/libcom/src/osi/compiler/clang/epicsAtomicCD.h
+++ b/modules/libcom/src/osi/compiler/clang/epicsAtomicCD.h
@@ -1,7 +1,7 @@
 
 /*************************************************************************\
-* Copyright (c) 2011 LANS LLC, as Operator of
-*     Los Alamos National Laboratory.
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2011 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * EPICS BASE is distributed subject to a Software License Agreement found
diff --git a/modules/libcom/src/osi/compiler/default/compilerDependentDemangle.cpp b/modules/libcom/src/osi/compiler/default/compilerDependentDemangle.cpp
 new file mode 100644
index 0000000..4a1f404
--- /dev/null
+++ b/modules/libcom/src/osi/compiler/default/compilerDependentDemangle.cpp
@@ -0,0 +1,28 @@
+
+/*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ * Author: Jeffrey O. Hill
+ */
+#include <exception>
+#include <cstdlib>
+
+#define epicsExportSharedSymbols
+#include "epicsDemangle.h"
+
+using std :: string;
+
+std :: string epicsDemangle ( const char * const pMangledName )
+{
+    return std :: string ( pMangledName );
+}
+
+std :: string epicsDemangleTypeName ( const std :: type_info & ti )
+{
+    return epicsDemangle ( ti.name () );
+}
diff --git a/modules/libcom/src/osi/compiler/default/compilerSpecific.h b/modules/libcom/src/osi/compiler/default/compilerSpecific.h
index 8af1727..3c64c39 100644
--- a/modules/libcom/src/osi/compiler/default/compilerSpecific.h
+++ b/modules/libcom/src/osi/compiler/default/compilerSpecific.h
@@ -1,4 +1,6 @@
 /*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2008 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
@@ -26,15 +28,18 @@
  
 #ifdef __cplusplus
 
+#define NO_RETURN 
+
+
 /*
  * CXX_PLACEMENT_DELETE - defined if compiler supports placement delete
- * CXX_THROW_SPECIFICATION - defined if compiler supports throw specification
  *
  * (our default guess is that the compiler implements the C++ 97 standard)
  */
-#define CXX_THROW_SPECIFICATION
 #define CXX_PLACEMENT_DELETE
 
+#define USING_BASE_TYPE(B,T) using typename B :: T;
+
 #endif /* __cplusplus */
 
 
diff --git a/modules/libcom/src/osi/compiler/default/epicsAtomicCD.h b/modules/libcom/src/osi/compiler/default/epicsAtomicCD.h
index 585a39c..55e4ab7 100644
--- a/modules/libcom/src/osi/compiler/default/epicsAtomicCD.h
+++ b/modules/libcom/src/osi/compiler/default/epicsAtomicCD.h
@@ -1,7 +1,7 @@
 
 /*************************************************************************\
-* Copyright (c) 2011 LANS LLC, as Operator of
-*     Los Alamos National Laboratory.
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2011 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * EPICS BASE is distributed subject to a Software License Agreement found
diff --git a/modules/libcom/src/osi/compiler/default/epicsStaticInstanceCD.h b/modules/libcom/src/osi/compiler/default/epicsStaticInstanceCD.h
 new file mode 100644
index 0000000..094e7a9
--- /dev/null
+++ b/modules/libcom/src/osi/compiler/default/epicsStaticInstanceCD.h
@@ -0,0 +1,20 @@
+
+/*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+
+/*
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
+ */
+
+#ifndef epicsStaticInstanceCD_h
+#define epicsStaticInstanceCD_h
+
+// we dont trust compilers we dont know
+#   include "epicsStaticInstanceSketchyCmplr.h"
+
+#endif /* epicsStaticInstanceCD_h */
diff --git a/modules/libcom/src/osi/compiler/gcc/compilerDependentDemangle.cpp b/modules/libcom/src/osi/compiler/gcc/compilerDependentDemangle.cpp
 new file mode 100644
index 0000000..a0f0429
--- /dev/null
+++ b/modules/libcom/src/osi/compiler/gcc/compilerDependentDemangle.cpp
@@ -0,0 +1,168 @@
+
+/*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ * Author: Jeffrey O. Hill
+ */
+#include <exception>
+#include <cstdlib>
+
+#if ( __GNUC__ * 100 + __GNUC_MINOR__ ) >= 300
+#   include <cxxabi.h>
+#endif
+
+#include "epicsThread.h"
+#include "epicsAtomic.h"
+#include "epicsExit.h"
+#include "epicsAssert.h"
+
+#include "epicsDemangle.h"
+
+using std :: string;
+
+union ThreadPrivateId {
+    ThreadPrivateId () : m_epics ( 0 ) {}
+    epicsThreadPrivateId m_epics;
+    void * m_cmpAndSwap;
+};
+
+class ThreadPrivate {
+public:
+    ThreadPrivate ();
+    ~ThreadPrivate ();
+    string demangle ( const char * pMangledName );
+    static ThreadPrivate * get ();
+    static void epicsExit ( void * /* arg */ );
+private:
+    char * m_pBuf;
+    size_t m_bufSize;
+    static const size_t m_bufSizeInit;
+    static ThreadPrivateId m_privateId;
+};
+
+const size_t ThreadPrivate :: m_bufSizeInit = 256u;
+ThreadPrivateId ThreadPrivate :: m_privateId;
+
+//
+// __cxa_demangle doc indicates that buffer passed must be allocated 
+// with malloc
+//
+ThreadPrivate :: ThreadPrivate () :
+    m_pBuf ( static_cast < char * > ( malloc ( m_bufSizeInit ) ) ),
+    m_bufSize ( m_pBuf ? m_bufSizeInit : 0u )
+{
+}
+
+ThreadPrivate :: ~ThreadPrivate ()
+{
+    //
+    // __cxa_demangle doc indicates that buffer passed must be allocated 
+    // with malloc
+    //
+    free ( m_pBuf );
+}
+
+string ThreadPrivate :: demangle ( const char * const pMangledName )
+{
+    if ( ! m_pBuf ) {
+        //
+        // __cxa_demangle doc indicates that buffer passed must be 
+        // allocated with malloc
+        //
+        m_pBuf = static_cast < char * > ( malloc ( m_bufSizeInit ) );
+        if ( m_pBuf ) {
+            m_bufSize = m_bufSizeInit; 
+        }
+        else {
+            m_bufSize = 0u; 
+            return pMangledName;
+        }
+    }
+    int status = -1000;
+    size_t sz = m_bufSize;
+    char * const pBufResult =
+            abi :: __cxa_demangle ( pMangledName, m_pBuf, 
+                                        & sz, & status );
+    if ( pBufResult ) {
+        m_pBuf = pBufResult;
+        m_bufSize = sz;
+        if ( status == 0 ) {
+            return string ( pBufResult );
+        }
+        else {
+            return string ( pMangledName );
+        }
+    }
+    return string ( pMangledName );
+}
+
+void ThreadPrivate :: epicsExit ( void * p )
+{
+    if ( m_privateId.m_epics ) {
+        epicsThreadPrivateSet ( m_privateId.m_epics, 0 );
+    }
+    ThreadPrivate * const pPriv = static_cast < ThreadPrivate * > ( p );
+    delete pPriv;
+}
+
+inline ThreadPrivate * ThreadPrivate :: get ()
+{
+    STATIC_ASSERT ( sizeof ( m_privateId.m_cmpAndSwap ) ==
+                      sizeof ( m_privateId.m_epics ) );
+    if ( ! m_privateId.m_epics ) {
+        ThreadPrivateId newId;
+        newId.m_epics = epicsThreadPrivateCreate ();
+        if ( ! newId.m_epics ) {
+            return 0;
+        }
+        const EpicsAtomicPtrT pBefore =
+            epicsAtomicCmpAndSwapPtrT ( & m_privateId.m_cmpAndSwap,
+                                        0, newId.m_cmpAndSwap );
+        if ( pBefore ) {
+            epicsThreadPrivateDelete ( newId.m_epics );
+        }
+    }
+    void * const p = epicsThreadPrivateGet ( m_privateId.m_epics );
+    ThreadPrivate * pPriv = static_cast < ThreadPrivate * > ( p );
+    if ( ! pPriv ) {
+        pPriv = new ( std :: nothrow ) ThreadPrivate ();
+        if ( pPriv ) {
+            const int status = 
+                    epicsAtThreadExit ( ThreadPrivate :: epicsExit, pPriv );
+            if ( status < 0 ) {
+                delete pPriv;
+                pPriv = 0;
+            }
+            epicsThreadPrivateSet ( m_privateId.m_epics, pPriv );
+        }
+    }
+    return pPriv;
+}
+
+std :: string epicsDemangle ( const char * const pMangledName )
+{
+    if ( pMangledName ) {
+#       if ( __GNUC__ * 100 + __GNUC_MINOR__ ) >= 300
+            ThreadPrivate * const pPriv = ThreadPrivate :: get ();
+            if ( ! pPriv ) {
+                return pMangledName;
+            }
+            return pPriv->demangle ( pMangledName );
+#       else
+            return pMangledName;
+#       endif
+    }
+    else {
+        return "<nil type name>";
+    }
+}
+
+std :: string epicsDemangleTypeName ( const std :: type_info & ti )
+{
+    return epicsDemangle ( ti.name () );
+}
diff --git a/modules/libcom/src/osi/compiler/gcc/compilerSpecific.h b/modules/libcom/src/osi/compiler/gcc/compilerSpecific.h
index 3342308..3a75150 100644
--- a/modules/libcom/src/osi/compiler/gcc/compilerSpecific.h
+++ b/modules/libcom/src/osi/compiler/gcc/compilerSpecific.h
@@ -1,4 +1,6 @@
 /*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2008 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
@@ -29,6 +31,8 @@
 /* Expands to a 'const char*' which describes the name of the current function scope */
 #define EPICS_FUNCTION __PRETTY_FUNCTION__
  
+#define NO_RETURN __attribute__((noreturn))
+
 #ifdef __cplusplus
 
 /*
@@ -50,6 +54,12 @@
  */
 #define EPICS_PRINTF_STYLE(f,a) __attribute__((format(__printf__,f,a)))
 
+#if __GNUC__ > 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 8 )
+#   define USING_BASE_TYPE(B,T) using typename B :: T;
+#else
+#   define USING_BASE_TYPE(B,T) typedef typename B :: T T;
+#endif
+
 /*
  * Deprecation marker
  */
diff --git a/modules/libcom/src/osi/compiler/gcc/epicsAtomicCD.h b/modules/libcom/src/osi/compiler/gcc/epicsAtomicCD.h
index 15b9a6c..d268803 100644
--- a/modules/libcom/src/osi/compiler/gcc/epicsAtomicCD.h
+++ b/modules/libcom/src/osi/compiler/gcc/epicsAtomicCD.h
@@ -1,7 +1,7 @@
 
 /*************************************************************************\
-* Copyright (c) 2011 LANS LLC, as Operator of
-*     Los Alamos National Laboratory.
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2011 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * EPICS BASE is distributed subject to a Software License Agreement found
diff --git a/modules/libcom/src/osi/compiler/gcc/epicsStaticInstanceCD.h b/modules/libcom/src/osi/compiler/gcc/epicsStaticInstanceCD.h
 new file mode 100644
index 0000000..d7d974e
--- /dev/null
+++ b/modules/libcom/src/osi/compiler/gcc/epicsStaticInstanceCD.h
@@ -0,0 +1,26 @@
+
+/*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+
+/*
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
+ */
+
+#ifndef epicsStaticInstanceCD_h
+#define epicsStaticInstanceCD_h
+
+#if ( __GNUC__ * 100 + __GNUC_MINOR__ ) >= 401
+    // any gcc version that has -fno-threadsafe-statics
+    // should be ok
+#   include "epicsStaticInstanceSaneCmplr.h"
+#else // ( __GNUC__ * 100 + __GNUC_MINOR__ ) >= 401
+    // other gcc maybe cant be trusted without more testing
+#   include "epicsStaticInstanceSketchyCmplr.h"
+#endif // ( __GNUC__ * 100 + __GNUC_MINOR__ ) >= 401
+
+#endif // epicsStaticInstanceCD_h
diff --git a/modules/libcom/src/osi/compiler/msvc/compilerSpecific.h b/modules/libcom/src/osi/compiler/msvc/compilerSpecific.h
index 4e282db..ab4e134 100644
--- a/modules/libcom/src/osi/compiler/msvc/compilerSpecific.h
+++ b/modules/libcom/src/osi/compiler/msvc/compilerSpecific.h
@@ -1,4 +1,6 @@
 /*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2008 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
@@ -21,6 +23,8 @@
 #endif
 
 #define EPICS_ALWAYS_INLINE __forceinline
+#define NO_RETURN __declspec(noreturn)
+
 
 /* Expands to a 'const char*' which describes the name of the current function scope */
 #define EPICS_FUNCTION __FUNCTION__
@@ -36,10 +40,10 @@
  
 /*
  * CXX_PLACEMENT_DELETE - defined if compiler supports placement delete
- * CXX_THROW_SPECIFICATION - defined if compiler supports throw specification
  */
 #define CXX_PLACEMENT_DELETE
-#define CXX_THROW_SPECIFICATION
+
+#define USING_BASE_TYPE(B,T) using typename B :: T;
 
 #endif /* __cplusplus */
 
diff --git a/modules/libcom/src/osi/compiler/msvc/epicsAtomicCD.h b/modules/libcom/src/osi/compiler/msvc/epicsAtomicCD.h
index e7d1c4b..f9ddc79 100644
--- a/modules/libcom/src/osi/compiler/msvc/epicsAtomicCD.h
+++ b/modules/libcom/src/osi/compiler/msvc/epicsAtomicCD.h
@@ -1,7 +1,7 @@
 
 /*************************************************************************\
-* Copyright (c) 2011 LANS LLC, as Operator of
-*     Los Alamos National Laboratory.
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2011 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * EPICS BASE is distributed subject to a Software License Agreement found
diff --git a/modules/libcom/src/osi/compiler/msvc/epicsStaticInstanceCD.h b/modules/libcom/src/osi/compiler/msvc/epicsStaticInstanceCD.h
 new file mode 100644
index 0000000..1859595
--- /dev/null
+++ b/modules/libcom/src/osi/compiler/msvc/epicsStaticInstanceCD.h
@@ -0,0 +1,32 @@
+
+/*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+
+/*
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
+ */
+
+#ifndef epicsStaticInstanceCD_h
+#define epicsStaticInstanceCD_h
+
+// visual c++ has some issues 
+// --------------------------
+//
+// 1) it lacks mutual exclusion protecting concurrent on demand
+// initialization of block scope static variables
+//
+// 2) it silently adds the path to the .cpp file to the very beginning
+// of the include search list so if a msvc specific version of this
+// file does not exist and we use the default version then it will 
+// also use compiler/default/ version, despite the existence 
+// of a more specialized version, and even if not told to do so on 
+// the command line
+//
+#   include "epicsStaticInstanceSketchyCmplr.h"
+
+#endif epicsStaticInstanceCD_h
diff --git a/modules/libcom/src/osi/compiler/solStudio/compilerSpecific.h b/modules/libcom/src/osi/compiler/solStudio/compilerSpecific.h
index a9d59a5..20065e2 100644
--- a/modules/libcom/src/osi/compiler/solStudio/compilerSpecific.h
+++ b/modules/libcom/src/osi/compiler/solStudio/compilerSpecific.h
@@ -1,4 +1,6 @@
 /*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2008 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
@@ -31,11 +33,9 @@
 
 /*
  * CXX_PLACEMENT_DELETE - defined if compiler supports placement delete
- * CXX_THROW_SPECIFICATION - defined if compiler supports throw specification
  *
  * (our default guess is that the compiler implements the C++ 97 standard)
  */
-#define CXX_THROW_SPECIFICATION
 #define CXX_PLACEMENT_DELETE
 
 #endif /* __cplusplus */
diff --git a/modules/libcom/src/osi/compiler/solStudio/epicsAtomicCD.h b/modules/libcom/src/osi/compiler/solStudio/epicsAtomicCD.h
index 8a733a5..b92e36a 100644
--- a/modules/libcom/src/osi/compiler/solStudio/epicsAtomicCD.h
+++ b/modules/libcom/src/osi/compiler/solStudio/epicsAtomicCD.h
@@ -1,7 +1,7 @@
 
 /*************************************************************************\
-* Copyright (c) 2011 LANS LLC, as Operator of
-*     Los Alamos National Laboratory.
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2011 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * EPICS BASE is distributed subject to a Software License Agreement found
diff --git a/modules/libcom/src/osi/compilerDependencies.h b/modules/libcom/src/osi/compilerDependencies.h
index 0b333d7..509687a 100644
--- a/modules/libcom/src/osi/compilerDependencies.h
+++ b/modules/libcom/src/osi/compilerDependencies.h
@@ -1,4 +1,6 @@
 /*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2008 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
@@ -20,6 +22,46 @@
 
 #ifdef __cplusplus
 
+#if __cplusplus >= 201103L
+#define epicsOverride override
+#else
+#define epicsOverride 
+#endif
+
+#if __cplusplus >= 201103L
+#define epicsFinal final
+#else
+#define epicsFinal
+#endif
+
+#if __cplusplus >= 201103L
+#define epicsNoexcept noexcept
+#else
+#define epicsNoexcept throw()
+#endif
+
+#if __cplusplus >= 201103L
+#define epicsConstexpr constexpr
+#else
+#define epicsConstexpr 
+#endif
+
+#if __cplusplus >= 201103L
+#define epicsMove(A) std::move(A)
+#else
+#define epicsMove(A) (A)
+#endif
+
+/*
+ * deleted method should also be declared private as per convention
+ * with old compilers
+ */
+#if __cplusplus >= 201103L
+#define epicsDeleteMethod =delete
+#else
+#define epicsDeleteMethod 
+#endif
+
 /*
  * usage: epicsPlacementDeleteOperator (( void *, myMemoryManager & ))
  */
diff --git a/modules/libcom/src/osi/epicsDemangle.h b/modules/libcom/src/osi/epicsDemangle.h
 new file mode 100644
index 0000000..07bd299
--- /dev/null
+++ b/modules/libcom/src/osi/epicsDemangle.h
@@ -0,0 +1,26 @@
+
+/*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ * Author: Jeffrey O. Hill
+ */
+
+#ifndef epicsDemangleh
+#define epicsDemangleh
+
+#include <string>
+#include <typeinfo>
+
+#include "shareLib.h"
+
+epicsShareFunc std :: string 
+        epicsDemangle ( const char * const pMangledName );
+epicsShareFunc std :: string 
+        epicsDemangleTypeName ( const std :: type_info & );
+
+#endif /* epicsDemangleh */
diff --git a/modules/libcom/src/osi/epicsStaticInstance.h b/modules/libcom/src/osi/epicsStaticInstance.h
 new file mode 100644
index 0000000..8e8d469
--- /dev/null
+++ b/modules/libcom/src/osi/epicsStaticInstance.h
@@ -0,0 +1,52 @@
+/*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
+ */
+
+#ifndef epicsStaticInstance_h
+#define epicsStaticInstance_h
+
+namespace epics {
+
+//
+// c++ 11 specifies the behavior for concurrent
+// access to block scope statics but some compiler
+// writers, lacking clear guidance in the earlier
+// c++ standards, curiously implement thread unsafe
+// block static variables despite ensuring for
+// proper multi-threaded behavior for many other
+// aspects of the compiler runtime infrastructure
+// such as runtime support for exception handling
+//
+// T - the type of the initialized once only static
+//
+template < typename T > T & staticInstance ();
+
+//
+// !!!! perhaps we need versions here that pass parameters 
+// !!!! to the constructor using templates also
+//
+
+} // end of name space epics
+
+//
+// if the compiler claims its c++ 11 then we are optimistic, ref:
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf
+// (see section 6.7)
+//
+#if __cplusplus >= 201103L
+#   include "epicsStaticInstanceSaneCmplr.h"
+#else
+    // otherwise we can implement compiler specific behavior
+#   include "epicsStaticInstanceCD.h"
+#endif
+
+#endif // ifndef epicsStaticInstance_h
+
diff --git a/modules/libcom/src/osi/epicsStaticInstanceSaneCmplr.h b/modules/libcom/src/osi/epicsStaticInstanceSaneCmplr.h
 new file mode 100644
index 0000000..523e509
--- /dev/null
+++ b/modules/libcom/src/osi/epicsStaticInstanceSaneCmplr.h
@@ -0,0 +1,45 @@
+
+/*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
+ */
+
+#ifndef epicsStaticInstanceSaneCmplr_h
+#define epicsStaticInstanceSaneCmplr_h
+
+namespace epics {
+
+// c++ 11 specifies the behavior for concurrent
+// access to block scope statics but some compiler
+// writers, lacking clear guidance in the earlier
+// c++ standards, curiously implement thread unsafe
+// block static variables despite ensuring for
+// proper multi-threaded behavior for many other
+// aspects of the compiler infrastructure such as
+// runtime support for exception handling
+//
+// if the compiler claims its c++ 11 then we are optimistic, ref:
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf
+// (see section 6.7)
+// "If control enters the (block-scope variable with static storage duration)
+// declaration concurrently while the variable is being initialized, the 
+// concurrent execution shall wait for completion of the initialization."
+// 
+// also see c++ FAQ, how do I prevent the
+// "static initialization order fiasco"?
+template < typename T > T & staticInstance ()
+{
+    static T * const m_pInstance = new T;
+    return * m_pInstance;
+}
+
+} // end of name space epics
+
+#endif // ifndef epicsStaticInstanceSaneCmplr_h
diff --git a/modules/libcom/src/osi/epicsStaticInstanceSketchyCmplr.cpp b/modules/libcom/src/osi/epicsStaticInstanceSketchyCmplr.cpp
 new file mode 100644
index 0000000..9581618
--- /dev/null
+++ b/modules/libcom/src/osi/epicsStaticInstanceSketchyCmplr.cpp
@@ -0,0 +1,88 @@
+
+/*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
+ */
+
+#include <cstddef>
+
+#define epicsExportSharedSymbols
+#include "errlog.h"
+#include "epicsThread.h"
+#include "epicsAssert.h"
+#include "epicsStaticInstanceSketchyCmplr.h"
+
+namespace epics {
+
+epicsShareDef char staticInstanceBusy;
+
+//
+// c++ 0x specifies the behavior for concurrent
+// access to block scope statics but some compiler
+// writers, lacking clear guidance in the earlier
+// c++ standards, curiously implement thread unsafe
+// block static variables despite ensuring for
+// proper multi-threaded behavior for many other
+// aspects of the compiler infrastructure such as
+// runtime support for exception handling
+//
+// see also c++ faq, static initialization order fiasco
+//
+// This implementation is active if we don't
+// know for certain that we can trust the compiler.
+// This implementation is substantially more efficient 
+// at runtime than epicsThreadOnce
+//
+// we are careful to create T no more than once here
+//
+EpicsAtomicPtrT staticInstanceInit ( EpicsAtomicPtrT & target,
+                            const PStaticInstanceFactory pFactory )
+{
+    static const std :: size_t spinDownInit = 1000u;
+    static const std :: size_t spinCount = 10u;
+    STATIC_ASSERT ( spinDownInit > spinCount );
+    static const std :: size_t spinThresh = spinDownInit - spinCount;
+    std :: size_t spinDown = spinDownInit;
+    EpicsAtomicPtrT pCur = 0;
+    while ( true ) {
+        pCur = epics :: atomic :: compareAndSwap ( target, 
+                                                pStaticInstanceInit,
+                                                & staticInstanceBusy );
+        if ( pCur == pStaticInstanceInit ) {
+            try {
+                pCur = ( * pFactory ) ();
+                epics :: atomic :: set ( target, pCur );
+                break;
+            }
+            catch ( ... ) {
+                epics :: atomic :: set ( target,
+                                    pStaticInstanceInit );
+                throw;
+            }
+        }
+        else if ( pCur != & staticInstanceBusy ) {
+            break;
+        }
+        if ( spinDown <= spinThresh ) {
+            epicsThreadSleep ( epicsThreadSleepQuantum () );
+        }
+        if ( spinDown > 0u ) {
+            spinDown--;
+        }
+        else {
+            errlogPrintf ( "staticInstanceInit: waiting for another "
+                    "thread to finish creating the static instance\n" );
+            spinDown = spinThresh;
+        }
+    }
+    return pCur;
+}
+
+} // end of name space epics
diff --git a/modules/libcom/src/osi/epicsStaticInstanceSketchyCmplr.h b/modules/libcom/src/osi/epicsStaticInstanceSketchyCmplr.h
 new file mode 100644
index 0000000..33765d9
--- /dev/null
+++ b/modules/libcom/src/osi/epicsStaticInstanceSketchyCmplr.h
@@ -0,0 +1,53 @@
+/*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
+ */
+
+#ifndef epicsStaticInstanceSketchyCmplr_h
+#define epicsStaticInstanceSketchyCmplr_h
+
+#include "epicsAtomic.h"
+
+#include "shareLib.h"
+
+namespace epics {
+
+typedef EpicsAtomicPtrT ( * PStaticInstanceFactory ) ();
+
+epicsShareFunc EpicsAtomicPtrT staticInstanceInit ( EpicsAtomicPtrT & target,
+                                    const PStaticInstanceFactory pFactory );
+                                    
+epicsShareExtern char staticInstanceBusy;
+
+namespace {
+    template < typename T >
+    EpicsAtomicPtrT staticInstanceFactory ()
+    {
+        return new T ();
+    }
+    static const EpicsAtomicPtrT pStaticInstanceInit = 0;
+}
+
+// this should _not_ be an in line function so that
+// we guarantee that only one instance of type T per
+// executable is created
+template < typename T > T & staticInstance ()
+{
+    static EpicsAtomicPtrT pInstance = pStaticInstanceInit;
+    EpicsAtomicPtrT pCur = epics :: atomic :: get ( pInstance );
+    if ( pCur == pStaticInstanceInit || pCur == & staticInstanceBusy ) {
+        pCur = staticInstanceInit ( pInstance, staticInstanceFactory < T > );
+    }
+    return * reinterpret_cast < T * > ( pCur );
+}
+
+} // end of name space epics
+
+#endif // ifndef epicsStaticInstanceSketchyCmplr_h
diff --git a/modules/libcom/src/timer/epicsTimer.cpp b/modules/libcom/src/timer/epicsTimer.cpp
index e55280e..96bfa31 100644
--- a/modules/libcom/src/timer/epicsTimer.cpp
+++ b/modules/libcom/src/timer/epicsTimer.cpp
@@ -1,4 +1,6 @@
 /*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2015 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
@@ -12,151 +14,144 @@
  *              505 665 1831
  */
 
+#include <cstdio>
 #include <string>
 #include <stdexcept>
 
 #define epicsExportSharedSymbols
 #include "epicsMath.h"
 #include "epicsTimer.h"
-#include "epicsGuard.h"
 #include "timerPrivate.h"
 
-#ifdef _MSC_VER
-#   pragma warning ( push )
-#   pragma warning ( disable:4660 )
-#endif
-
-#ifdef _MSC_VER
-#   pragma warning ( pop )
-#endif
-
-template class tsFreeList < epicsTimerForC, 0x20 >;
-
 epicsTimer::~epicsTimer () {}
 
-epicsTimerQueueNotify::~epicsTimerQueueNotify () {}
+void epicsTimerNotify :: show ( unsigned /* level */ ) const {}
 
-epicsTimerNotify::~epicsTimerNotify  () {}
-
-void epicsTimerNotify::show ( unsigned /* level */ ) const {}
-
-epicsTimerForC::epicsTimerForC ( timerQueue &queue, epicsTimerCallback pCBIn, void *pPrivateIn ) :
-    timer ( queue ), pCallBack ( pCBIn ), pPrivate ( pPrivateIn )
+TimerForC :: TimerForC ( timerQueue & queue, epicsTimerCallback const pCB, 
+                                                    void * const pPrivate ) :
+    m_pTimer ( & queue.createTimerImpl () ), 
+    m_pCallBack ( pCB ), 
+    m_pPrivate ( pPrivate )
 {
 }
 
-epicsTimerForC::~epicsTimerForC ()
+TimerForC :: ~TimerForC ()
 {
+    m_pTimer->destroy ();
 }
 
-void epicsTimerForC::destroy ()
+void TimerForC :: show ( unsigned level ) const
 {
-    timerQueue & queueTmp = this->queue;
-    this->~epicsTimerForC ();
-    queueTmp.timerForCFreeList.release ( this );
+    printf ( "TimerForC: callback ptr %p private ptr %p\n", 
+                m_pCallBack, m_pPrivate );
+    if ( level > 1 && m_pTimer ) {
+        m_pTimer->show ( level - 1 );
+    }
 }
 
-epicsTimerNotify::expireStatus epicsTimerForC::expire ( const epicsTime & )
+epicsTimerNotify :: expireStatus 
+    TimerForC :: expire ( const epicsTime & )
 {
-    ( *this->pCallBack ) ( this->pPrivate );
+    ( *m_pCallBack ) ( m_pPrivate );
     return noRestart;
 }
 
 epicsTimerQueueActiveForC ::
-    epicsTimerQueueActiveForC ( RefMgr & refMgr, 
-        bool okToShare, unsigned priority ) :
-    timerQueueActive ( refMgr, okToShare, priority )
+        epicsTimerQueueActiveForC ( bool okToShare, unsigned priority ) :
+    timerQueueActive ( okToShare, priority )
 {
-    timerQueueActive::start();
 }
 
-epicsTimerQueueActiveForC::~epicsTimerQueueActiveForC ()
+epicsTimerQueueActiveForC :: ~epicsTimerQueueActiveForC ()
 {
 }
 
-void epicsTimerQueueActiveForC::release ()
+void epicsTimerQueueActiveForC :: release ()
 {
-    _refMgr->release ( *this );
+    timerQueueActiveMgr :: master ().release ( *this );
 }
 
-epicsTimerQueuePassiveForC::epicsTimerQueuePassiveForC ( 
-    epicsTimerQueueNotifyReschedule pRescheduleCallbackIn, 
-    epicsTimerQueueNotifyQuantum pSleepQuantumCallbackIn,
-    void * pPrivateIn ) :
-        timerQueuePassive ( * static_cast < epicsTimerQueueNotify * > ( this ) ), 
-        pRescheduleCallback ( pRescheduleCallbackIn ), 
-        pSleepQuantumCallback ( pSleepQuantumCallbackIn ),
-        pPrivate ( pPrivateIn )
+epicsTimerQueuePassiveForC :: epicsTimerQueuePassiveForC ( 
+        epicsTimerQueueNotifyReschedule pRescheduleCallback, 
+        epicsTimerQueueNotifyQuantum pSleepQuantumCallback,
+        void * pPrivate ) :
+    timerQueuePassive ( 
+        * static_cast < epicsTimerQueueNotify * > ( this ) ), 
+    m_pRescheduleCallback ( pRescheduleCallback ), 
+    m_pSleepQuantumCallback ( pSleepQuantumCallback ),
+    m_pPrivate ( pPrivate )
 {
 }
 
-epicsTimerQueuePassiveForC::~epicsTimerQueuePassiveForC () 
+epicsTimerQueuePassiveForC :: ~epicsTimerQueuePassiveForC () 
 {
 }
 
-void epicsTimerQueuePassiveForC::reschedule ()
+void epicsTimerQueuePassiveForC :: reschedule ()
 {
-    (*this->pRescheduleCallback) ( this->pPrivate );
+    ( *m_pRescheduleCallback ) ( m_pPrivate );
 }
 
-double epicsTimerQueuePassiveForC::quantum ()
-{
-    return (*this->pSleepQuantumCallback) ( this->pPrivate );
-}
-
-void epicsTimerQueuePassiveForC::destroy ()
+void epicsTimerQueuePassiveForC :: destroy ()
 {
     delete this;
 }
 
-epicsShareFunc epicsTimerNotify::expireStatus::expireStatus ( restart_t restart ) : 
-    delay ( - DBL_MAX )
+epicsShareFunc epicsTimerNotify :: expireStatus :: 
+                            expireStatus ( restart_t restart ) : 
+    m_delay ( -DBL_MAX )
 {
     if ( restart != noRestart ) {
         throw std::logic_error 
-            ( "timer restart was requested without specifying a delay?" );
+            ( "timer restart was requested "
+                "without specifying a delay?" );
     }
 }
 
-epicsShareFunc epicsTimerNotify::expireStatus::expireStatus 
-    ( restart_t restartIn, const double & expireDelaySec ) :
-    delay ( expireDelaySec )
+epicsShareFunc epicsTimerNotify :: expireStatus :: expireStatus 
+            ( restart_t restartIn, const double & expireDelaySec ) :
+    m_delay ( expireDelaySec )
 {
-    if ( restartIn != epicsTimerNotify::restart ) {
+    if ( restartIn != epicsTimerNotify :: restart ) {
         throw std::logic_error 
-            ( "no timer restart was requested, but a delay was specified?" );
+            ( "no timer restart was requested, "
+                "but a delay was specified?" );
     }
-    if ( this->delay < 0.0 || !finite(this->delay) ) {
+    if ( m_delay < 0.0 || ! finite ( m_delay ) ) {
         throw std::logic_error 
-            ( "timer restart was requested, but a negative delay was specified?" );
+            ( "timer restart was requested, but a "
+                "negative delay was specified?" );
     }
 }
 
-epicsShareFunc bool epicsTimerNotify::expireStatus::restart () const
+epicsShareFunc bool 
+        epicsTimerNotify :: expireStatus :: restart () const
 {
-    return this->delay >= 0.0 && finite(this->delay);
+    return m_delay >= 0.0 && finite ( m_delay );
 }
 
-epicsShareFunc double epicsTimerNotify::expireStatus::expirationDelay () const
+epicsShareFunc double 
+        epicsTimerNotify :: expireStatus :: expirationDelay () const
 {
-    if ( this->delay < 0.0 || !finite(this->delay) ) {
+    if ( m_delay < 0.0 || ! finite ( m_delay ) ) {
         throw std::logic_error 
-            ( "no timer restart was requested, but you are asking for a restart delay?" );
+            ( "no timer restart was requested, "
+                "but you are asking for a restart delay?" );
     }
-    return this->delay;
+    return m_delay;
 }
 
 extern "C" epicsTimerQueuePassiveId epicsShareAPI
     epicsTimerQueuePassiveCreate ( 
-        epicsTimerQueueNotifyReschedule pRescheduleCallbackIn, 
-        epicsTimerQueueNotifyQuantum pSleepQuantumCallbackIn,
-        void * pPrivateIn )
+        const epicsTimerQueueNotifyReschedule pRescheduleCallback, 
+        const epicsTimerQueueNotifyQuantum pSleepQuantumCallback,
+        void * const pPrivate )
 {
     try {
         return new epicsTimerQueuePassiveForC ( 
-            pRescheduleCallbackIn, 
-            pSleepQuantumCallbackIn,
-            pPrivateIn );
+                                    pRescheduleCallback, 
+                                    pSleepQuantumCallback,
+                                    pPrivate );
     }
     catch ( ... ) {
         return 0;
@@ -173,28 +168,31 @@ extern "C" double epicsShareAPI
     epicsTimerQueuePassiveProcess ( epicsTimerQueuePassiveId pQueue )
 {
     try {
-        return pQueue->process ( epicsTime::getCurrent() );
+        return pQueue->process ( epicsTime :: getCurrent () );
     }
     catch ( ... ) {
         return 1.0;
     }
 }
 
-extern "C" epicsTimerId epicsShareAPI epicsTimerQueuePassiveCreateTimer (
-    epicsTimerQueuePassiveId pQueue, epicsTimerCallback pCallback, void *pArg )
+extern "C" epicsTimerId epicsShareAPI 
+        epicsTimerQueuePassiveCreateTimer ( 
+                            epicsTimerQueuePassiveId pQueue, 
+                            epicsTimerCallback pCallback, void *pArg )
 {
     try {
-        return  & pQueue->createTimerForC ( pCallback, pArg );
+        return & pQueue->createTimerForC ( pCallback, pArg );
     }
     catch ( ... ) {
         return 0;
     }
 }
 
-extern "C" epicsShareFunc void epicsShareAPI epicsTimerQueuePassiveDestroyTimer ( 
-    epicsTimerQueuePassiveId /* pQueue */, epicsTimerId pTmr )
+extern "C" epicsShareFunc void epicsShareAPI 
+    epicsTimerQueuePassiveDestroyTimer (   
+        epicsTimerQueuePassiveId pQueue, epicsTimerId pTmr )
 {
-    pTmr->destroy ();
+    delete pTmr;
 }
 
 extern "C" void  epicsShareAPI epicsTimerQueuePassiveShow (
@@ -207,11 +205,10 @@ extern "C" epicsTimerQueueId epicsShareAPI
     epicsTimerQueueAllocate ( int okToShare, unsigned int threadPriority )
 {
     try {
-        epicsSingleton < timerQueueActiveMgr > :: reference ref = 
-            timerQueueMgrEPICS.getReference ();
         epicsTimerQueueActiveForC & tmr = 
-            ref->allocate ( ref, okToShare ? true : false, threadPriority );
-        return &tmr;
+            timerQueueActiveMgr :: master ().
+                allocate ( okToShare ? true : false, threadPriority );
+        return & tmr;
     }
     catch ( ... ) {
         return 0;
@@ -223,8 +220,10 @@ extern "C" void epicsShareAPI epicsTimerQueueRelease ( epicsTimerQueueId pQueue 
     pQueue->release ();
 }
 
-extern "C" epicsTimerId epicsShareAPI epicsTimerQueueCreateTimer (
-    epicsTimerQueueId pQueue, epicsTimerCallback pCallback, void *pArg )
+extern "C" epicsTimerId epicsShareAPI 
+    epicsTimerQueueCreateTimer (
+        epicsTimerQueueId pQueue, 
+        epicsTimerCallback pCallback, void *pArg )
 {
     try {
         return & pQueue->createTimerForC ( pCallback, pArg );
@@ -234,43 +233,49 @@ extern "C" epicsTimerId epicsShareAPI epicsTimerQueueCreateTimer (
     }
 }
 
-extern "C" void  epicsShareAPI epicsTimerQueueShow (
-    epicsTimerQueueId pQueue, unsigned int level )
+extern "C" void  epicsShareAPI 
+    epicsTimerQueueShow (
+        epicsTimerQueueId pQueue, unsigned int level )
 {
     pQueue->show ( level );
 }
 
-extern "C" void epicsShareAPI epicsTimerQueueDestroyTimer ( 
-    epicsTimerQueueId /* pQueue */, epicsTimerId pTmr )
+extern "C" void epicsShareAPI 
+    epicsTimerQueueDestroyTimer ( 
+        epicsTimerQueueId pQueue, epicsTimerId pTmr )
 {
-    pTmr->destroy ();
+    delete pTmr;
 }
 
-extern "C" void  epicsShareAPI epicsTimerStartTime (
-    epicsTimerId pTmr, const epicsTimeStamp *pTime )
+extern "C" unsigned epicsShareAPI 
+    epicsTimerStartTime ( 
+        epicsTimerId pTmr, const epicsTimeStamp *pTime )
 {
-    pTmr->start ( *pTmr, *pTime );
+    return pTmr->start ( *pTime );
 }
 
-extern "C" void  epicsShareAPI epicsTimerStartDelay (
-    epicsTimerId pTmr, double delaySeconds )
+extern "C" unsigned epicsShareAPI 
+    epicsTimerStartDelay ( 
+        epicsTimerId pTmr, double delaySeconds )
 {
-    pTmr->start ( *pTmr, delaySeconds );
+    return pTmr->start ( delaySeconds );
 }
 
-extern "C" void  epicsShareAPI epicsTimerCancel ( epicsTimerId pTmr )
+extern "C" int epicsShareAPI 
+    epicsTimerCancel ( epicsTimerId pTmr )
 {
-    pTmr->cancel ();
+    return pTmr->cancel ();
 }
 
-extern "C" double  epicsShareAPI epicsTimerGetExpireDelay ( epicsTimerId pTmr )
+extern "C" double  epicsShareAPI 
+    epicsTimerGetExpireDelay ( epicsTimerId pTmr )
 {
     return pTmr->getExpireDelay ();
 }
 
-extern "C" void  epicsShareAPI epicsTimerShow (
-    epicsTimerId pTmr, unsigned int level )
+extern "C" void  epicsShareAPI 
+    epicsTimerShow ( epicsTimerId pTmr, unsigned int level )
 {
-    pTmr->timer::show ( level );
+    pTmr->show ( level );
 }
 
diff --git a/modules/libcom/src/timer/epicsTimer.h b/modules/libcom/src/timer/epicsTimer.h
index 72270f2..45c6b29 100644
--- a/modules/libcom/src/timer/epicsTimer.h
+++ b/modules/libcom/src/timer/epicsTimer.h
@@ -1,11 +1,12 @@
 /*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2002 The University of Chicago, as Operator of Argonne
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
 *     Operator of Los Alamos National Laboratory.
-* EPICS BASE Versions 3.13.7
-* and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 /* epicsTimer.h */
 
@@ -14,50 +15,80 @@
 #ifndef epicsTimerH
 #define epicsTimerH
 
-#include <float.h>
-
-#include "shareLib.h"
 #include "epicsTime.h"
 #include "epicsThread.h"
+#include "shareLib.h"
 
 #ifdef __cplusplus
 
+#include <cfloat>
+
 /*
  * Notes:
- * 1) epicsTimer does not hold its lock when calling callbacks.
+ * 1) The timer queue process method does not hold the timer 
+ * queue lock when calling callbacks, to avoid deadlocks.
+ *
+ * 2) The timer start method has three different possible outcomes
+ *
+ * 2a) If start is called and the timer isnt pending in the timer
+ * queue, and the timer callback isnt currently being orchestrated,
+ * then the timer is schedualed in the queue and start returns 
+ * 1u, indicating that the timer callback will run once as a 
+ * direct consequence of this invocation of start.
+ *
+ * 2b) If start is called and the timer is already pending in 
+ * the timer queue, then the timer is reschedualed back into
+ * a new positon in the queue and start returns 0u. The 
+ * timer callback will run once as a reschedualed (postponed) 
+ * consequence of a previous invocation of start, but zero 
+ * times as a direct consequence of this call to start.
+ *
+ * 2c) If start is called and the timer isnt pending in the timer 
+ * queue, but the timer callback _is_ currently being orchestrated
+ * then it is reschedualed in the queue for a new expiration 
+ * time, and start returns 1u. The timer callback will run twice.
+ * Once as a consequence of this invocation of start, and once 
+ * as a consequence of a previous call to start.
+ *
+ * 3) Cancel returns true if the timer was pending in the queue
+ * when cancel was called, and false otherwise.
  */
 
 /* code using a timer must implement epicsTimerNotify */
 class epicsShareClass epicsTimerNotify {
 public:
     enum restart_t { noRestart, restart };
-    class expireStatus {
+    class epicsShareClass expireStatus {
     public:
-        epicsShareFunc expireStatus ( restart_t );
-        epicsShareFunc expireStatus ( restart_t, const double & expireDelaySec );
-        epicsShareFunc bool restart () const;
-        epicsShareFunc double expirationDelay () const;
+        expireStatus ( restart_t );
+        expireStatus ( restart_t, const double & expireDelaySec );
+        bool restart () const;
+        double expirationDelay () const;
     private:
-        double delay;
+        double m_delay;
     };
 
-    virtual ~epicsTimerNotify () = 0;
     /* return "noRestart" or "expireStatus ( restart, 30.0 )" */
     virtual expireStatus expire ( const epicsTime & currentTime ) = 0;
     virtual void show ( unsigned int level ) const;
+protected:
+    virtual ~epicsTimerNotify () {} // protected disables delete through intf
 };
 
 class epicsShareClass epicsTimer {
 public:
     /* calls cancel (see warning below) and then destroys the timer */
     virtual void destroy () = 0;
-    virtual void start ( epicsTimerNotify &, const epicsTime & ) = 0;
-    virtual void start ( epicsTimerNotify &, double delaySeconds ) = 0;
-    /* WARNING: A deadlock will occur if you hold a lock while
+    /* see note 2 above for the significance of the return value */
+    virtual unsigned start ( epicsTimerNotify &, const epicsTime & ) = 0;
+    virtual unsigned start ( epicsTimerNotify &, double delaySeconds ) = 0;
+    /* see note 3 for the significance of the return value
+     *
+     * WARNING: A deadlock will occur if you hold a lock while
      * calling this function that you also take within the timer 
      * expiration callback.
      */
-    virtual void cancel () = 0;
+    virtual bool cancel () = 0;
     struct expireInfo {
         expireInfo ( bool active, const epicsTime & expireTime );
         bool active;
@@ -67,7 +98,7 @@ public:
     double getExpireDelay ();
     virtual void show ( unsigned int level ) const = 0;
 protected:
-    virtual ~epicsTimer () = 0; /* protected => delete() must not be called */
+    virtual ~epicsTimer () = 0; /* disable delete */
 };
 
 class epicsTimerQueue {
@@ -75,7 +106,7 @@ public:
     virtual epicsTimer & createTimer () = 0;
     virtual void show ( unsigned int level ) const = 0;
 protected:
-    epicsShareFunc virtual ~epicsTimerQueue () = 0;
+    virtual ~epicsTimerQueue () {} /* disable delete */
 };
 
 class epicsTimerQueueActive
@@ -85,7 +116,7 @@ public:
         bool okToShare, unsigned threadPriority = epicsThreadPriorityMin + 10 );
     virtual void release () = 0; 
 protected:
-    epicsShareFunc virtual ~epicsTimerQueueActive () = 0;
+    virtual ~epicsTimerQueueActive () {} /* disable delete */
 };
 
 class epicsTimerQueueNotify {
@@ -93,18 +124,14 @@ public:
     /* called when a new timer is inserted into the queue and the */
     /* delay to the next expire has changed */
     virtual void reschedule () = 0;
-    /* if there is a quantum in the scheduling of timer intervals */
-    /* return this quantum in seconds. If unknown then return zero. */
-    virtual double quantum () = 0;
 protected:
-    epicsShareFunc virtual ~epicsTimerQueueNotify () = 0;
+    virtual ~epicsTimerQueueNotify () {} /* disable delete */
 };
 
-class epicsTimerQueuePassive
-    : public epicsTimerQueue {
+class epicsTimerQueuePassive : public epicsTimerQueue {
 public:
     static epicsShareFunc epicsTimerQueuePassive & create ( epicsTimerQueueNotify & );
-    epicsShareFunc virtual ~epicsTimerQueuePassive () = 0; /* ok to call delete */
+    virtual ~epicsTimerQueuePassive () {} /* ok to call delete */
     virtual double process ( const epicsTime & currentTime ) = 0; /* returns delay to next expire */
 };
 
@@ -114,11 +141,11 @@ inline epicsTimer::expireInfo::expireInfo ( bool activeIn,
 {
 }
 
-inline double epicsTimer::getExpireDelay ()
+inline double epicsTimer :: getExpireDelay ()
 {
     epicsTimer::expireInfo info = this->getExpireInfo ();
     if ( info.active ) {
-        double delay = info.expireTime - epicsTime::getCurrent ();
+        double delay = info.expireTime - epicsTime :: getCurrent ();
         if ( delay < 0.0 ) {
             delay = 0.0;
         }
@@ -130,7 +157,7 @@ inline double epicsTimer::getExpireDelay ()
 extern "C" {
 #endif /* __cplusplus */
 
-typedef struct epicsTimerForC * epicsTimerId;
+typedef struct TimerForC * epicsTimerId;
 typedef void ( *epicsTimerCallback ) ( void *pPrivate );
 
 /* thread managed timer queue */
@@ -167,11 +194,11 @@ epicsShareFunc void  epicsShareAPI
     epicsTimerQueuePassiveShow ( epicsTimerQueuePassiveId id, unsigned int level );
 
 /* timer */
-epicsShareFunc void epicsShareAPI 
+epicsShareFunc unsigned epicsShareAPI 
     epicsTimerStartTime ( epicsTimerId id, const epicsTimeStamp *pTime );
-epicsShareFunc void epicsShareAPI 
+epicsShareFunc unsigned epicsShareAPI 
     epicsTimerStartDelay ( epicsTimerId id, double delaySeconds );
-epicsShareFunc void epicsShareAPI 
+epicsShareFunc int epicsShareAPI 
     epicsTimerCancel ( epicsTimerId id );
 epicsShareFunc double epicsShareAPI 
     epicsTimerGetExpireDelay ( epicsTimerId id );
diff --git a/modules/libcom/src/timer/timer.cpp b/modules/libcom/src/timer/timer.cpp
index 35d6e47..2c49f7e 100644
--- a/modules/libcom/src/timer/timer.cpp
+++ b/modules/libcom/src/timer/timer.cpp
@@ -1,11 +1,12 @@
 /*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2002 The University of Chicago, as Operator of Argonne
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
 *     Operator of Los Alamos National Laboratory.
-* EPICS BASE Versions 3.13.7
-* and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 /*
@@ -17,227 +18,226 @@
 #include <typeinfo>
 #include <string>
 #include <stdexcept>
-#include <stdio.h>
+#include <cstdio>
 
 #define epicsExportSharedSymbols
-#include "epicsGuard.h"
 #include "timerPrivate.h"
 #include "errlog.h"
 
-#ifdef _MSC_VER
-#   pragma warning ( push )
-#   pragma warning ( disable:4660 )
-#endif
-
-template class tsFreeList < timer, 0x20 >;
-
-#ifdef _MSC_VER
-#   pragma warning ( pop )
-#endif
-
-timer::timer ( timerQueue & queueIn ) :
-    queue ( queueIn ), curState ( stateLimbo ), pNotify ( 0 ) 
+Timer :: Timer ( timerQueue & queueIn ) :
+    m_queue ( queueIn ), 
+    m_curState ( stateLimbo ), 
+    m_pNotify ( 0 ),
+    m_index ( m_invalidIndex ) 
 {
 }
 
-timer::~timer ()
+Timer :: ~Timer ()
 {
-    this->cancel ();
+    M_CancelStatus cs = { false, false };
+    {
+        Guard guard ( m_queue );
+        cs = m_cancelPvt ( guard );
+        m_queue.m_numTimers--;
+    }
+    // we are careful to wakeup the timer queue thread after
+    // we nolonger hold the lock
+    if ( cs.reschedule ) {
+        m_queue.m_notify.reschedule ();
+    }
 }
 
-void timer::destroy () 
+void Timer :: destroy () 
 {
-    timerQueue & queueTmp = this->queue;
-    this->~timer ();
-    queueTmp.timerFreeList.release ( this );
+    delete this;    
 }
 
-void timer::start ( epicsTimerNotify & notify, double delaySeconds )
+unsigned Timer :: start ( epicsTimerNotify & notify, double delaySeconds )
 {
-    this->start ( notify, epicsTime::getCurrent () + delaySeconds );
+    const epicsTime current = epicsTime :: getCurrent ();
+    const epicsTime exp = current + delaySeconds;
+    const Timer :: M_StartReturn sr = m_privateStart ( notify, exp );
+    // we are careful to wakeup the timer queue thread after
+    // we nolonger hold the lock
+    if ( sr.resched ) {
+        m_queue.m_notify.reschedule ();
+    }
+    return sr.numNew;
 }
 
-void timer::start ( epicsTimerNotify & notify, const epicsTime & expire )
+unsigned Timer :: start ( epicsTimerNotify & notify, 
+                            const epicsTime & expire )
 {
-    epicsGuard < epicsMutex > locker ( this->queue.mutex );
-    this->privateStart ( notify, expire );
+    Timer :: M_StartReturn sr = m_privateStart ( notify, expire );
+    // we are careful to wakeup the timer queue thread after
+    // we nolonger hold the lock
+    if ( sr.resched ) {
+        m_queue.m_notify.reschedule ();
+    }
+    return sr.numNew;
 }
 
-void timer::privateStart ( epicsTimerNotify & notify, const epicsTime & expire )
+Timer :: M_StartReturn 
+    Timer :: m_privateStart ( epicsTimerNotify & notify, 
+                                    const epicsTime & expire )
 {
-    this->pNotify = & notify;
-    this->exp = expire - ( this->queue.notify.quantum () / 2.0 );
-
-    bool reschedualNeeded = false;
-    if ( this->curState == stateActive ) {
-        // above expire time and notify will override any restart parameters
-        // that may be returned from the timer expire callback
-        return;
-    }
-    else if ( this->curState == statePending ) {
-        this->queue.timerList.remove ( *this );
-        if ( this->queue.timerList.first() == this && 
-                this->queue.timerList.count() > 0 ) {
-            reschedualNeeded = true;
+    Timer :: M_StartReturn sr;
+    Guard locker ( m_queue );
+    m_pNotify = & notify;
+    if ( m_curState == statePending ) {
+        const epicsTime oldExp = m_queue.m_heap.front ()->m_exp;
+        m_exp = expire;
+        if ( ! m_queue.m_fixParent ( m_index ) ) {
+            m_queue.m_fixChildren ( m_index );
+        }
+        if ( m_queue.m_pExpTmr == this ) {
+            // new expire time and notify will override 
+            // any restart parameters that may be returned 
+            // from the timer expire callback
+            sr.numNew = 1u;
+            sr.resched = false;
+        }
+        else {
+            sr.numNew = 0u;
+            sr.resched = ( oldExp > m_queue.m_heap.front ()->m_exp ); 
         }
     }
-
-#   ifdef DEBUG
-        unsigned preemptCount=0u;
-#   endif
-
-    //
-    // insert into the pending queue
-    //
-    // Finds proper time sorted location using a linear search.
-    //
-    // **** this should use a binary tree ????
-    //
-    tsDLIter < timer > pTmr = this->queue.timerList.lastIter ();
-    while ( true ) {
-        if ( ! pTmr.valid () ) {
-            //
-            // add to the beginning of the list
-            //
-            this->queue.timerList.push ( *this );
-            reschedualNeeded = true;
-            break;
+    else {
+        sr.numNew = 1u;
+        m_curState = Timer :: statePending;
+        m_index = m_queue.m_heap.size ();
+        if ( m_index > 0u ) {
+            const epicsTime oldExp = m_queue.m_heap.front ()->m_exp;
+            m_exp = expire;
+            m_queue.m_heap.push_back ( this );
+            m_queue.m_fixParent ( m_index );
+            sr.resched = ( oldExp > m_queue.m_heap.front ()->m_exp ); 
         }
-        if ( pTmr->exp <= this->exp ) {
-            //
-            // add after the item found that expires earlier
-            //
-            this->queue.timerList.insertAfter ( *this, *pTmr );
-            break;
+        else {
+            m_exp = expire;
+            m_queue.m_heap.push_back ( this );
+            sr.resched = true;
         }
-#       ifdef DEBUG
-            preemptCount++;
-#       endif
-        --pTmr;
     }
+    debugPrintf ( ("Start of \"%s\" with delay %f at %p\n",
+                    m_pNotify ? 
+                        typeid ( *m_pNotify ).name () :
+                        typeid ( m_pNotify ).name (),
+                    m_exp - epicsTime :: getCurrent (),
+                    this ) );
+    return sr;
+}
 
-    this->curState = timer::statePending;
-
-    if ( reschedualNeeded ) {
-        this->queue.notify.reschedule ();
-    }
-    
-#   if defined(DEBUG) && 0
-        this->show ( 10u );
-        this->queue.show ( 10u );
-#   endif
-
-    debugPrintf ( ("Start of \"%s\" with delay %f at %p preempting %u\n", 
-        typeid ( this->notify ).name (), 
-        expire - epicsTime::getCurrent (), 
-        this, preemptCount ) );
+void Timer :: m_remove ( Guard & guard )
+{
+    Timer * const pMoved = m_queue.m_heap.back ();
+    m_queue.m_heap.pop_back ();
+    if ( m_index != m_queue.m_heap.size () ) {
+        const size_t oldIndex = m_index;
+        m_queue.m_heap[oldIndex] = pMoved;
+        pMoved->m_index = oldIndex;
+        if ( ! m_queue.m_fixParent ( oldIndex ) ) {
+            m_queue.m_fixChildren ( oldIndex );
+        }
+    }
+    m_index = m_invalidIndex;
+    m_curState = stateLimbo;
 }
 
-void timer::cancel ()
+bool Timer :: cancel ()
 {
-    bool reschedual = false;
-    bool wakeupCancelBlockingThreads = false;
+    M_CancelStatus cs = { false, false };
     {
-        epicsGuard < epicsMutex > locker ( this->queue.mutex );
-        this->pNotify = 0;
-        if ( this->curState == statePending ) {
-            this->queue.timerList.remove ( *this );
-            this->curState = stateLimbo;
-            if ( this->queue.timerList.first() == this && 
-                    this->queue.timerList.count() > 0 ) {
-                reschedual = true;
-            }
-        }
-        else if ( this->curState == stateActive ) {
-            this->queue.cancelPending = true;
-            this->curState = timer::stateLimbo;
-            if ( this->queue.processThread != epicsThreadGetIdSelf() ) {
-                // make certain timer expire() does not run after cancel () returns,
-                // but dont require that lock is applied while calling expire()
-                while ( this->queue.cancelPending && 
-                        this->queue.pExpireTmr == this ) {
-                    epicsGuardRelease < epicsMutex > autoRelease ( locker );
-                    this->queue.cancelBlockingEvent.wait ();
+        Guard guard ( m_queue );
+        cs = m_cancelPvt ( guard );
+    }
+    // we are careful to wakeup the timer queue thread after
+    // we nolonger hold the lock
+    if ( cs.reschedule ) {
+        m_queue.m_notify.reschedule ();
+    }
+    return cs.wasPending;
+}
+
+Timer :: M_CancelStatus Timer :: m_cancelPvt ( Guard & gd )
+{
+    gd.assertIdenticalMutex ( m_queue );
+    M_CancelStatus cs = { false, false };
+    Guard guard ( m_queue );
+    if ( m_curState == statePending ) {
+        const epicsTime oldExp = m_queue.m_heap.front ()->m_exp;
+        m_remove ( guard );
+        m_queue.m_cancelPending = ( m_queue.m_pExpTmr == this );
+        if ( m_queue.m_cancelPending ) {
+            if ( m_queue.m_processThread != epicsThreadGetIdSelf() ) {
+                // 1) make certain timer expire cllback does not run 
+                // after this cancel method returns
+                // 2) dont require that lock is applied while calling 
+                // expire callback 
+                // 3) assume that timer could be deleted in its 
+                // expire callback so we dont touch this after lock
+                // is released
+                timerQueue & queue = m_queue;
+                while ( queue.m_cancelPending && 
+                                    queue.m_pExpTmr == this ) {
+                    GuardRelease unguard ( guard );
+                    queue.m_cancelBlockingEvent.wait ();
                 }
                 // in case other threads are waiting
-                wakeupCancelBlockingThreads = true;
+                queue.m_cancelBlockingEvent.signal ();
+            }
+        }
+        else {
+            cs.wasPending = true;
+            if ( oldExp > m_queue.m_heap.front ()->m_exp ) {
+                cs.reschedule = true;
             }
         }
     }
-    if ( reschedual ) {
-        this->queue.notify.reschedule ();
-    }
-    if ( wakeupCancelBlockingThreads ) {
-        this->queue.cancelBlockingEvent.signal ();
-    }
+    return cs;
 }
 
-epicsTimer::expireInfo timer::getExpireInfo () const
+epicsTimer :: expireInfo Timer :: getExpireInfo () const
 {
     // taking a lock here guarantees that users will not 
     // see brief intervals when a timer isnt active because
     // it is is canceled when start is called
-    epicsGuard < epicsMutex > locker ( this->queue.mutex );
-    if ( this->curState == statePending || this->curState == stateActive ) {
-        return expireInfo ( true, this->exp );
+    Guard locker ( m_queue );
+    if ( m_curState == statePending ) {
+        return expireInfo ( true, m_exp );
     }
     return expireInfo ( false, epicsTime() );
 }
 
-void timer::show ( unsigned int level ) const
+void Timer :: show ( unsigned int level ) const
 {
-    epicsGuard < epicsMutex > locker ( this->queue.mutex );
+    Guard locker ( m_queue );
     double delay;
-    if ( this->curState == statePending || this->curState == stateActive ) {
+    if ( m_curState == statePending ) {
         try {
-            delay = this->exp - epicsTime::getCurrent();
+            delay = m_exp - epicsTime :: getCurrent ();
         }
         catch ( ... ) {
-            delay = - DBL_MAX;
+            delay = -DBL_MAX;
         }
     }
     else {
         delay = -DBL_MAX;
     }
     const char *pStateName;
-    if ( this->curState == statePending ) {
+    if ( m_curState == statePending ) {
         pStateName = "pending";
     }
-    else if ( this->curState == stateActive ) {
-        pStateName = "active";
-    }
-    else if ( this->curState == stateLimbo ) {
+    else if ( m_curState == stateLimbo ) {
         pStateName = "limbo";
     }
     else {
         pStateName = "corrupt";
     }
-    printf ( "timer, state = %s, delay = %f\n",
-        pStateName, delay );
-    if ( level >= 1u && this->pNotify ) {
-        this->pNotify->show ( level - 1u );
+    printf ( "Timer, state = %s, index = %lu, delay = %f\n",
+            pStateName, (unsigned long ) m_index, delay );
+    if ( level >= 1u && m_pNotify ) {
+        m_pNotify->show ( level - 1u );
     }
 }
 
-void timer::operator delete ( void * )
-{
-    // Visual C++ .net appears to require operator delete if
-    // placement operator delete is defined? I smell a ms rat
-    // because if I declare placement new and delete, but
-    // comment out the placement delete definition there are
-    // no undefined symbols.
-    errlogPrintf ( "%s:%d this compiler is confused about placement delete - memory was probably leaked",
-        __FILE__, __LINE__ );
-}
-
-void epicsTimerForC::operator delete ( void * )
-{
-    // Visual C++ .net appears to require operator delete if
-    // placement operator delete is defined? I smell a ms rat
-    // because if I declare placement new and delete, but
-    // comment out the placement delete definition there are
-    // no undefined symbols.
-    errlogPrintf ( "%s:%d this compiler is confused about placement delete - memory was probably leaked",
-        __FILE__, __LINE__ );
-}
-
diff --git a/modules/libcom/src/timer/timerPrivate.h b/modules/libcom/src/timer/timerPrivate.h
index 259afae..8ca0e67 100644
--- a/modules/libcom/src/timer/timerPrivate.h
+++ b/modules/libcom/src/timer/timerPrivate.h
@@ -1,5 +1,7 @@
 /*************************************************************************\
-* Copyright (c) 2015 UChicago Argonne LLC, as Operator of Argonne
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
+* Copyright (c) 2002 The University of Chicago, as Operator of Argonne
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
 *     Operator of Los Alamos National Laboratory.
@@ -7,6 +9,7 @@
 * in file LICENSE that is included with this distribution.
 \*************************************************************************/
 /*
+ *
  *      Author  Jeffrey O. Hill
  *              [e-mail]
  *              505 665 1831
@@ -16,12 +19,15 @@
 #define epicsTimerPrivate_h
 
 #include <typeinfo>
+#include <vector>
 
-#include "tsFreeList.h"
-#include "epicsSingleton.h"
 #include "tsDLList.h"
 #include "epicsTimer.h"
+#include "epicsMutex.h"
+#include "epicsGuard.h"
 #include "compilerDependencies.h"
+#include "epicsStaticInstance.h"
+#include "AllocatorArena.h"
 
 #ifdef DEBUG
 #   define debugPrintf(ARGSINPAREN) printf ARGSINPAREN
@@ -29,90 +35,130 @@
 #   define debugPrintf(ARGSINPAREN)
 #endif
 
-template < class T > class epicsGuard;
+using std :: type_info;
+
+class Timer;
+class timerQueue;
 
-class timer : public epicsTimer, public tsDLNode < timer > {
+bool operator < ( const Timer &, const Timer & );
+bool operator > ( const Timer &, const Timer & );
+bool operator <= ( const Timer &, const Timer & );
+bool operator >= ( const Timer &, const Timer & );
+
+class Timer : public epicsTimer {
 public:
+    typedef epicsMutex Mutex;
+    typedef epicsGuard < Mutex > Guard;
+    typedef epicsGuardRelease < Mutex > GuardRelease;
+    Timer ( timerQueue & );
+    ~Timer ();
     void destroy ();
-    void start ( class epicsTimerNotify &, const epicsTime & );
-    void start ( class epicsTimerNotify &, double delaySeconds );
-    void cancel ();
+    unsigned start ( class epicsTimerNotify &, const epicsTime & );
+    unsigned start ( class epicsTimerNotify &, double delaySeconds );
+    bool cancel ();
     expireInfo getExpireInfo () const;
+    double getExpireDelay ( const epicsTime & currentTime );
     void show ( unsigned int level ) const;
-    void * operator new ( size_t size, tsFreeList < timer, 0x20 > & );
-    epicsPlacementDeleteOperator (( void *, tsFreeList < timer, 0x20 > & ))
+    static void * operator new ( size_t sz );
+    static void operator delete ( void * ptr, size_t sz );
 protected:
-    timer ( class timerQueue & );
-    ~timer (); 
-    timerQueue & queue;
+    timerQueue & m_queue;
 private:
-    enum state { statePending = 45, stateActive = 56, stateLimbo = 78 };
-    epicsTime exp; // experation time 
-    state curState; // current state 
-    epicsTimerNotify * pNotify; // callback
-    void privateStart ( epicsTimerNotify & notify, const epicsTime & );
-    timer & operator = ( const timer & );
-    // Visual C++ .net appears to require operator delete if
-    // placement operator delete is defined? I smell a ms rat
-    // because if I declare placement new and delete, but
-    // comment out the placement delete definition there are
-    // no undefined symbols.
-    void operator delete ( void * ); 
+    typedef epics :: AllocatorArena < Timer, timerQueue, 16u > M_Allocator;
+    enum state {
+        statePending = 45,
+        stateLimbo = 78 };
+    epicsTime m_exp; // experation time
+    state m_curState; // current state
+    epicsTimerNotify * m_pNotify; // callback
+    size_t m_index;
+    static const size_t m_invalidIndex = 
+			~ static_cast < size_t > ( 0u );
+    struct M_StartReturn {
+        unsigned numNew;
+        bool resched;
+    };
+    M_StartReturn m_privateStart ( epicsTimerNotify & notify, 
+	                                const epicsTime & expire );
+    struct M_CancelStatus {
+        bool reschedule;
+        bool wasPending;
+    };
+    M_CancelStatus m_cancelPvt ( Guard & );
+    void m_remove ( Guard & guard );
+    Timer & operator = ( const Timer & );
     friend class timerQueue;
+    friend bool operator < ( const Timer &, const Timer & );
+    friend bool operator > ( const Timer &, const Timer & );
+    friend bool operator <= ( const Timer &, const Timer & );
+    friend bool operator >= ( const Timer &, const Timer & );
 };
 
-struct epicsTimerForC : public epicsTimerNotify, public timer {
+struct TimerForC : public epicsTimerNotify {
 public:
-    void destroy ();
-protected:
-    epicsTimerForC ( timerQueue &, epicsTimerCallback, void *pPrivateIn );
-    ~epicsTimerForC (); 
-    void * operator new ( size_t size, tsFreeList < epicsTimerForC, 0x20 > & );
-    epicsPlacementDeleteOperator (( void *, tsFreeList < epicsTimerForC, 0x20 > & ))
-private:
-    epicsTimerCallback pCallBack;
-    void * pPrivate;
+    typedef epicsMutex Mutex;
+    typedef epicsGuard < Mutex > Guard;
+    TimerForC ( class timerQueue &, epicsTimerCallback, void * pPrivateIn );
+    ~TimerForC ();
+    unsigned start ( const epicsTime & );
+    unsigned start ( double delaySeconds );
+    bool cancel ();
+    void show ( unsigned level ) const;
     expireStatus expire ( const epicsTime & currentTime );
-    epicsTimerForC & operator = ( const epicsTimerForC & );
-    // Visual C++ .net appears to require operator delete if
-    // placement operator delete is defined? I smell a ms rat
-    // because if I declare placement new and delete, but
-    // comment out the placement delete definition there are
-    // no undefined symbols.
-    void operator delete ( void * ); 
-    friend class timerQueue;
-};
-
-using std :: type_info;
+    double getExpireDelay ();
+    static void * operator new ( size_t sz );
+    static void operator delete ( void * ptr, size_t sz );
+private:
+    typedef epics :: AllocatorArena < TimerForC, timerQueue, 16u > M_Allocator;
+    Timer * m_pTimer;
+    epicsTimerCallback m_pCallBack;
+    void * m_pPrivate;
+    TimerForC & operator = ( const TimerForC & );
+}; 
 
-class timerQueue : public epicsTimerQueue {
+class timerQueue : 
+    public epicsTimerQueue, 
+    public epicsMutex {
 public:
+    typedef epicsMutex Mutex;
+    typedef epicsGuard < Mutex > Guard;
+    typedef epicsGuardRelease < Mutex > GuardRelease;
     timerQueue ( epicsTimerQueueNotify &notify );
     virtual ~timerQueue ();
     epicsTimer & createTimer ();
-    epicsTimerForC & createTimerForC ( epicsTimerCallback pCallback, void *pArg );
+    Timer & createTimerImpl ();
+    TimerForC & createTimerForC (
+        epicsTimerCallback pCallback, void *pArg );
     double process ( const epicsTime & currentTime );
+    double process ( Guard &, const epicsTime & currentTime );
     void show ( unsigned int level ) const;
+    void show ( Guard &, unsigned int level ) const;
 private:
-    tsFreeList < timer, 0x20 > timerFreeList;
-    tsFreeList < epicsTimerForC, 0x20 > timerForCFreeList;
-    mutable epicsMutex mutex;
-    epicsEvent cancelBlockingEvent;
-    tsDLList < timer > timerList;
-    epicsTimerQueueNotify & notify;
-    timer * pExpireTmr;
-    epicsThreadId processThread;
-    epicsTime exceptMsgTimeStamp;
-    bool cancelPending;
-    static const double exceptMsgMinPeriod;
-    void printExceptMsg ( const char * pName,
-                const type_info & type );
+    epicsEvent m_cancelBlockingEvent;
+    std :: vector < Timer * > m_heap;
+    epicsTime m_exceptMsgTimeStamp;
+    epicsTimerQueueNotify & m_notify;
+    Timer * m_pExpTmr;
+    epicsThreadId m_processThread;
+    size_t m_numTimers;
+    bool m_cancelPending;
+    static const double m_exceptMsgMinPeriod;
 	timerQueue ( const timerQueue & );
     timerQueue & operator = ( const timerQueue & );
-    friend class timer;
-    friend struct epicsTimerForC;
+    void m_printExceptMsg ( const char * pName, const type_info & type );
+    bool m_fixParent ( size_t childIdx );
+    void m_fixChildren ( size_t parentIdx );
+    void m_swapEntries ( size_t idx0, size_t idx1 );
+    double m_expDelay ( const epicsTime & currentTime );
+    static size_t m_parent ( size_t childIdx );
+    static size_t m_leftChild ( size_t parentIdx );
+    static size_t m_rightChild ( size_t parentIdx );
+    friend class Timer;
+    friend struct TimerForC;
 };
 
+class timerQueueActiveMgr;
+
 class timerQueueActiveMgrPrivate {
 public:
     timerQueueActiveMgrPrivate ();
@@ -123,101 +169,95 @@ private:
     friend class timerQueueActiveMgr;
 };
 
-class timerQueueActiveMgr;
-
-class timerQueueActive : public epicsTimerQueueActive, 
-    public epicsThreadRunable, public epicsTimerQueueNotify,
+class timerQueueActive :
+    public epicsTimerQueueActive,
+    public epicsThreadRunable,
+    public epicsTimerQueueNotify,
     public timerQueueActiveMgrPrivate {
 public:
-    typedef epicsSingleton < timerQueueActiveMgr > :: reference RefMgr;
-    timerQueueActive ( RefMgr &, bool okToShare, unsigned priority );
-    void start ();
+    timerQueueActive ( bool okToShare, unsigned priority );
     epicsTimer & createTimer ();
-    epicsTimerForC & createTimerForC ( epicsTimerCallback pCallback, void *pArg );
+    TimerForC & createTimerForC (
+        epicsTimerCallback pCallback, void *pArg );
+    void run ();
+    void reschedule ();
+    epicsTimerQueue & getEpicsTimerQueue ();
     void show ( unsigned int level ) const;
     bool sharingOK () const;
     unsigned threadPriority () const;
 protected:
     ~timerQueueActive ();
-    RefMgr _refMgr;
 private:
-    timerQueue queue;
-    epicsEvent rescheduleEvent;
-    epicsEvent exitEvent;
-    epicsThread thread;
-    const double sleepQuantum;
-    bool okToShare;
-    int exitFlag; // use atomic ops
-    bool terminateFlag;
-    void run ();
-    void reschedule ();
-    double quantum ();
-    void _printLastChanceExceptionMessage ( 
-                const char * pExceptionTypeName,
-                const char * pExceptionContext );
-    epicsTimerQueue & getEpicsTimerQueue ();
+    typedef epicsMutex Mutex;
+    typedef epicsGuard < Mutex > Guard;
+    typedef epicsGuardRelease < Mutex > GuardRelease;
+    timerQueue m_queue;
+    epicsEvent m_rescheduleEvent;
+    epicsEvent m_exitEvent;
+    epicsThread m_thread;
+    bool m_okToShare;
+    bool m_exitFlag;
+    bool m_terminateFlag;
 	timerQueueActive ( const timerQueueActive & );
     timerQueueActive & operator = ( const timerQueueActive & );
 };
 
 class timerQueueActiveMgr {
 public:
-    typedef epicsSingleton < timerQueueActiveMgr > :: reference RefThis;
+    static timerQueueActiveMgr & master ();
 	timerQueueActiveMgr ();
     ~timerQueueActiveMgr ();
-    epicsTimerQueueActiveForC & allocate ( RefThis &, bool okToShare, 
+    epicsTimerQueueActiveForC & allocate ( bool okToShare,
         unsigned threadPriority = epicsThreadPriorityMin + 10 );
     void release ( epicsTimerQueueActiveForC & );
 private:
-    epicsMutex mutex;
-    tsDLList < epicsTimerQueueActiveForC > sharedQueueList;
+    typedef epicsMutex Mutex;
+    typedef epicsGuard < Mutex > Guard;
+    Mutex m_mutex;
+    tsDLList < epicsTimerQueueActiveForC > m_sharedQueueList;
 	timerQueueActiveMgr ( const timerQueueActiveMgr & );
     timerQueueActiveMgr & operator = ( const timerQueueActiveMgr & );
 };
 
-extern epicsSingleton < timerQueueActiveMgr > timerQueueMgrEPICS;
-
 class timerQueuePassive : public epicsTimerQueuePassive {
 public:
     timerQueuePassive ( epicsTimerQueueNotify & );
     epicsTimer & createTimer ();
-    epicsTimerForC & createTimerForC ( epicsTimerCallback pCallback, void *pArg );
+    TimerForC & createTimerForC (
+        epicsTimerCallback pCallback, void *pArg );
     void show ( unsigned int level ) const;
     double process ( const epicsTime & currentTime );
+    epicsTimerQueue & getEpicsTimerQueue ();
 protected:
-    timerQueue queue;
+    timerQueue m_queue;
     ~timerQueuePassive ();
-    epicsTimerQueue & getEpicsTimerQueue ();
 	timerQueuePassive ( const timerQueuePassive & );
     timerQueuePassive & operator = ( const timerQueuePassive & );
 };
 
-struct epicsTimerQueuePassiveForC : 
-    public epicsTimerQueueNotify, public timerQueuePassive {
+struct epicsTimerQueuePassiveForC :
+    public epicsTimerQueueNotify, 
+    public timerQueuePassive {
 public:
-    epicsTimerQueuePassiveForC ( 
-        epicsTimerQueueNotifyReschedule, 
+    epicsTimerQueuePassiveForC (
+        epicsTimerQueueNotifyReschedule,
         epicsTimerQueueNotifyQuantum,
         void * pPrivate );
     void destroy ();
+    void reschedule ();
 protected:
     ~epicsTimerQueuePassiveForC ();
 private:
-    epicsTimerQueueNotifyReschedule pRescheduleCallback;
-    epicsTimerQueueNotifyQuantum pSleepQuantumCallback;
-    void * pPrivate;
-    static epicsSingleton < tsFreeList < epicsTimerQueuePassiveForC, 0x10 > > pFreeList;
-    void reschedule ();
-    double quantum ();
+    epicsTimerQueueNotifyReschedule m_pRescheduleCallback;
+    epicsTimerQueueNotifyQuantum m_pSleepQuantumCallback;
+    void * m_pPrivate;
 };
 
-struct epicsTimerQueueActiveForC : public timerQueueActive, 
+struct epicsTimerQueueActiveForC : public timerQueueActive,
     public tsDLNode < epicsTimerQueueActiveForC > {
 public:
-    epicsTimerQueueActiveForC ( RefMgr &, bool okToShare, unsigned priority );
+    epicsTimerQueueActiveForC ( bool okToShare, unsigned priority );
     void release ();
-    void * operator new ( size_t );
-    void operator delete ( void * );
 protected:
     virtual ~epicsTimerQueueActiveForC ();
 private:
@@ -225,52 +265,106 @@ private:
     epicsTimerQueueActiveForC & operator = ( const epicsTimerQueueActiveForC & );
 };
 
-inline bool timerQueueActive::sharingOK () const
+inline double Timer :: getExpireDelay ( const epicsTime & currentTime )
+{
+	return m_exp - currentTime;
+}
+
+inline void * Timer :: operator new  ( size_t sz )
+{
+    return M_Allocator :: allocateOctets ( sz );
+}
+
+inline void Timer :: operator delete ( void * p, size_t sz )
 {
-    return this->okToShare;
+    M_Allocator :: deallocateOctets ( p,  sz );
+}
+
+inline bool operator < ( const Timer & lhs, const Timer & rhs )
+{ 
+    return lhs.m_exp < rhs.m_exp;
+}
+
+inline bool operator > ( const Timer & lhs, const Timer & rhs )
+{ 
+    return rhs < lhs; 
+}
+
+inline bool operator <= ( const Timer & lhs, const Timer & rhs )
+{ 
+    return ! ( lhs > rhs ); 
 }
 
-inline unsigned timerQueueActive::threadPriority () const
+inline bool operator >= ( const Timer & lhs, const Timer & rhs )
+{ 
+    return ! ( lhs < rhs ); 
+}
+
+inline size_t timerQueue :: m_parent ( const size_t childIdx )
 {
-    return thread.getPriority ();
+    return ( childIdx + ( childIdx & 1u ) ) / 2u - 1u;
 }
 
-inline void * timer::operator new ( size_t size, 
-                     tsFreeList < timer, 0x20 > & freeList ) 
+inline size_t timerQueue :: m_leftChild ( const size_t parentIdx )
 {
-    return freeList.allocate ( size );
+    return ( parentIdx + 1u ) * 2u - 1u;
 }
 
-#ifdef CXX_PLACEMENT_DELETE
-inline void timer::operator delete ( void * pCadaver, 
-                     tsFreeList < timer, 0x20 > & freeList ) 
+inline size_t timerQueue :: m_rightChild ( const size_t parentIdx )
 {
-    freeList.release ( pCadaver );
+    return ( parentIdx + 1u ) * 2u;
 }
-#endif
 
-inline void * epicsTimerForC::operator new ( size_t size,
-                        tsFreeList < epicsTimerForC, 0x20 > & freeList ) 
+inline void timerQueue :: m_swapEntries ( size_t idx0, size_t idx1 )
 {
-    return freeList.allocate ( size );
+    std :: swap ( m_heap[idx0], m_heap[idx1] );
+    m_heap[idx0]->m_index = idx0;
+    m_heap[idx1]->m_index = idx1;
 }
 
-#ifdef CXX_PLACEMENT_DELETE
-inline void epicsTimerForC::operator delete ( void * pCadaver, 
-                        tsFreeList < epicsTimerForC, 0x20 > & freeList ) 
+inline bool timerQueueActive :: sharingOK () const
 {
-    freeList.release ( pCadaver );
+    return m_okToShare;
+}
+
+inline unsigned timerQueueActive :: threadPriority () const
+{
+    return m_thread.getPriority ();
+}
+
+inline unsigned TimerForC :: start ( const epicsTime & expTime )
+{
+    return m_pTimer->start ( *this, expTime );
+}
+
+inline unsigned TimerForC :: start ( double delaySeconds )
+{
+    return m_pTimer->start ( *this, delaySeconds );
+}
+
+inline bool TimerForC :: cancel ()
+{
+    return m_pTimer->cancel ();
+}
+
+inline double TimerForC :: getExpireDelay ()
+{
+    return m_pTimer->getExpireDelay ( epicsTime :: getCurrent () );
+}
+
+inline void * TimerForC :: operator new  ( size_t sz )
+{
+    return M_Allocator :: allocateOctets ( sz );
 }
-#endif
 
-inline void * epicsTimerQueueActiveForC::operator new ( size_t size )
+inline void TimerForC :: operator delete ( void * p, size_t sz )
 {
-    return ::operator new ( size );
+    M_Allocator :: deallocateOctets ( p,  sz );
 }
 
-inline void epicsTimerQueueActiveForC::operator delete ( void * pCadaver )
+inline timerQueueActiveMgr & timerQueueActiveMgr :: master ()
 {
-    ::operator delete ( pCadaver );
+    return epics :: staticInstance < timerQueueActiveMgr > ();
 }
 
 #endif // epicsTimerPrivate_h
diff --git a/modules/libcom/src/timer/timerQueue.cpp b/modules/libcom/src/timer/timerQueue.cpp
index 8f7f98e..5948941 100644
--- a/modules/libcom/src/timer/timerQueue.cpp
+++ b/modules/libcom/src/timer/timerQueue.cpp
@@ -1,4 +1,6 @@
 /*************************************************************************\
+* Copyright (c) 2020 Triad National Security, as operator of Los Alamos 
+*     National Laboratory
 * Copyright (c) 2002 The University of Chicago, as Operator of Argonne
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
@@ -12,56 +14,45 @@
  *              505 665 1831
  */
 
-#include <stdio.h>
-#include <float.h>
+#include <cstdio>
 
 #define epicsExportSharedSymbols
-#include "epicsGuard.h"
-#include "timerPrivate.h"
 #include "errlog.h"
+#include "timerPrivate.h"
 
-const double timerQueue :: exceptMsgMinPeriod = 60.0 * 5.0; // seconds
-
-epicsTimerQueue::~epicsTimerQueue () {}
+const double timerQueue :: m_exceptMsgMinPeriod = 60.0 * 5.0; // seconds
 
-timerQueue::timerQueue ( epicsTimerQueueNotify & notifyIn ) :
-    mutex(__FILE__, __LINE__),
-    notify ( notifyIn ), 
-    pExpireTmr ( 0 ),  
-    processThread ( 0 ), 
-    exceptMsgTimeStamp ( 
-        epicsTime :: getCurrent () - exceptMsgMinPeriod ),
-    cancelPending ( false )
+timerQueue :: timerQueue ( epicsTimerQueueNotify & notifyIn ) :
+    Mutex ( __FILE__, __LINE__ ),
+    m_exceptMsgTimeStamp ( epicsTime :: getCurrent ()
+                                    - m_exceptMsgMinPeriod ),
+    m_notify ( notifyIn ),
+    m_pExpTmr ( 0 ),  
+    m_processThread ( 0 ), 
+    m_numTimers ( 0u ),
+    m_cancelPending ( false )
 {
 }
 
-timerQueue::~timerQueue ()
+timerQueue :: ~timerQueue ()
 {
-    timer *pTmr;
-    while ( ( pTmr = this->timerList.get () ) ) {    
-        pTmr->curState = timer::stateLimbo;
+    if ( m_heap.size () ) {
+        while ( Timer * const pTmr = m_heap.back () ) {    
+            pTmr->m_curState = Timer :: stateLimbo;
+            m_heap.pop_back ();
+        }
     }
 }
 
 void timerQueue ::
-    printExceptMsg ( const char * pName, const type_info & type )
+    m_printExceptMsg ( const char * pName, const type_info & type )
 {
-    char date[64];
-    double delay;
-    try {
-        epicsTime cur = epicsTime :: getCurrent ();
-        delay = cur - this->exceptMsgTimeStamp;
-        cur.strftime ( date, sizeof ( date ), 
-                        "%a %b %d %Y %H:%M:%S.%f" );
-        if ( delay >= exceptMsgMinPeriod ) {
-            this->exceptMsgTimeStamp = cur;
-        }
-    }
-    catch ( ... ) {
-        delay = DBL_MAX;
-        strcpy ( date, "UKN DATE" );
-    }
-    if ( delay >= exceptMsgMinPeriod ) {
+    const epicsTime cur = epicsTime :: getCurrent ();
+    const double delay = cur - m_exceptMsgTimeStamp;
+    if ( delay >= m_exceptMsgMinPeriod ) {
+        m_exceptMsgTimeStamp = cur;
+        char date[64];
+        cur.strftime ( date, sizeof ( date ), "%a %b %d %Y %H:%M:%S.%f" );
         // we dont touch the typeid for the timer expiration
         // notify interface here because they might have 
         // destroyed the timer during its callback
@@ -72,155 +63,212 @@ void timerQueue ::
             pName, 
             type.name (), 
             date );
+        errlogPrintf ( "!!!! WARNING - PERIODIC TIMER MAY NOT RESTART !!!!\n" );
         errlogFlush ();
     }
 }
 
-double timerQueue::process ( const epicsTime & currentTime )
-{  
-    epicsGuard < epicsMutex > guard ( this->mutex );
+inline double timerQueue :: m_expDelay ( const epicsTime & currentTime )
+{
+    double delay = DBL_MAX;
+    if ( m_heap.size () > 0u ) {
+        delay = m_heap.front ()->m_exp - currentTime;
+    }
+    return delay;
+}
+
+double timerQueue :: process ( const epicsTime & currentTime )
+{
+    Guard guard ( *this );
+    return this->process ( guard, currentTime );
+}
 
-    if ( this->pExpireTmr ) {
+double timerQueue :: process ( Guard & guard,
+                                const epicsTime & currentTime )
+{  
+    guard.assertIdenticalMutex ( *this );
+    if ( m_processThread ) {
         // if some other thread is processing the queue
         // (or if this is a recursive call)
-        timer * pTmr = this->timerList.first ();
-        if ( pTmr ) {
-            double delay = pTmr->exp - currentTime;
-            if ( delay < 0.0 ) {
-                delay = 0.0;
-            }
-            return delay;
-        }
-        else {
-            return DBL_MAX;
+        double delay = m_expDelay ( currentTime );
+        if ( delay <= 0.0 ) {
+            delay = 0.0;
         }
-    }
-
-    //
-    // Tag current epired tmr so that we can detect if call back
-    // is in progress when canceling the timer.
-    //
-    if ( this->timerList.first () ) {
-        if ( currentTime >= this->timerList.first ()->exp ) {
-            this->pExpireTmr = this->timerList.first ();
-            this->timerList.remove ( *this->pExpireTmr ); 
-            this->pExpireTmr->curState = timer::stateActive;
-            this->processThread = epicsThreadGetIdSelf ();
-#           ifdef DEBUG
-                this->pExpireTmr->show ( 0u );
-#           endif 
-        }
-        else {
-            double delay = this->timerList.first ()->exp - currentTime;
-            debugPrintf ( ( "no activity process %f to next\n", delay ) );
-            return delay;
-        }
-    }
-    else {
-        return DBL_MAX;
+        return delay;
     }
 
 #   ifdef DEBUG
         unsigned N = 0u;
 #   endif
 
-    double delay = DBL_MAX;
-    while ( true ) {
-        epicsTimerNotify *pTmpNotify = this->pExpireTmr->pNotify;
-        this->pExpireTmr->pNotify = 0;
-        epicsTimerNotify::expireStatus expStat ( epicsTimerNotify::noRestart );
-
-        {
-            epicsGuardRelease < epicsMutex > unguard ( guard );
-
+    m_processThread = epicsThreadGetIdSelf ();
+    double delay = m_expDelay ( currentTime );
+    while ( delay <= 0.0 ) {
+        //
+        // if delay is zero or less we know at least one timer is on 
+        // the queue
+        //
+        // tag current expired tmr so that we can detect if call back
+        // is in progress when canceling the timer
+        //
+        delay = 0.0;
+        m_pExpTmr = m_heap.front ();
+        epicsTimerNotify * const pTmpNotify = m_pExpTmr->m_pNotify;
+        m_pExpTmr->m_pNotify = 0;
+        epicsTimerNotify :: expireStatus 
+                            expStat ( epicsTimerNotify :: noRestart );
+        if ( pTmpNotify ) {
+            GuardRelease unguard ( guard );
             debugPrintf ( ( "%5u expired \"%s\" with error %f sec\n", 
-                N++, typeid ( this->pExpireTmr->notify ).name (), 
-                currentTime - this->pExpireTmr->exp ) );
+                N++, 
+                typeid ( *pTmpNotify ).name (), 
+                currentTime - m_pExpTmr->m_exp ) );
             try {
                 expStat = pTmpNotify->expire ( currentTime );
             }
             catch ( std::exception & except ) {
-                printExceptMsg ( except.what (), typeid ( except ) );
+                m_printExceptMsg ( except.what (), typeid ( except ) );
             }
             catch ( ... ) {
-                printExceptMsg ( "non-standard exception", typeid ( void ) );
+                m_printExceptMsg ( "non-standard exception", typeid ( void ) );
             }
         }
 
         //
-        // only restart if they didnt cancel() the timer
-        // while the call back was running
+        // !! The position of a timer in the queue is allowed to change 
+        // !! while its timer callback is running. This happens 
+        // !! potentially when they reschedule a timer or cancel a
+        // !! timer. A small amount of additional labor is expended
+        // !! to properly handle this type of change below (we
+        // !! test the return from fix_parent and conditionally 
+        // !! call fix_child, instead of calling only fix_child).
         //
-        if ( this->cancelPending ) {
+        if ( m_cancelPending ) {
+            //
+            // only restart if they didnt cancel() the currently
+            // expiring timer while its call-back is running
+            //
             // 1) if another thread is canceling then cancel() waits for 
             // the event below
             // 2) if this thread is canceling in the timer callback then
             // dont touch timer or notify here because the cancel might 
             // have occurred because they destroyed the timer in the 
             // callback
-            this->cancelPending = false;
-            this->cancelBlockingEvent.signal ();
+            // 3) timer::cancel sets timer state to limbo and timer index
+            // to invalid
+            //
+            m_cancelPending = false;
+            m_cancelBlockingEvent.signal ();
         }
         else {
-            this->pExpireTmr->curState = timer::stateLimbo;
-            if ( this->pExpireTmr->pNotify ) {
-                // pNotify was cleared above so if it is valid now we know that
-                // someone has started the timer from another thread and that 
-                // predominates over the restart parameters from expire.
-                this->pExpireTmr->privateStart ( 
-                    *this->pExpireTmr->pNotify, this->pExpireTmr->exp );
+            if ( m_pExpTmr->m_pNotify ) {
+                // pNotify was cleared above; if its valid now we 
+                // know that someone has restarted the timer when
+                // its callback is currently running either 
+                // asynchronously from another thread or from 
+                // within the currently running expire callback,
+                // possibly moving its position in the heap. As 
+                // a defined policy either of these situations
+                // overrides any restart request parameters 
+                // returned from expire
             }
             else if ( expStat.restart() ) {
                 // restart as nec
-                this->pExpireTmr->privateStart ( 
-                    *pTmpNotify, currentTime + expStat.expirationDelay() );
-            }
-        }
-        this->pExpireTmr = 0;
-
-        if ( this->timerList.first () ) {
-            if ( currentTime >= this->timerList.first ()->exp ) {
-                this->pExpireTmr = this->timerList.first ();
-                this->timerList.remove ( *this->pExpireTmr ); 
-                this->pExpireTmr->curState = timer::stateActive;
-#               ifdef DEBUG
-                    this->pExpireTmr->show ( 0u );
-#               endif 
+                m_pExpTmr->m_pNotify = pTmpNotify;
+                m_pExpTmr->m_exp = currentTime + expStat.expirationDelay ();
+                if ( ! m_fixParent ( m_pExpTmr->m_index ) ) {
+                    m_fixChildren ( m_pExpTmr->m_index );
+                }
             }
             else {
-                delay = this->timerList.first ()->exp - currentTime;
-                this->processThread = 0;
-                break;
+                m_pExpTmr->m_remove ( guard );
             }
         }
-        else {
-            this->processThread = 0;
-            delay = DBL_MAX;
+        delay = m_expDelay ( currentTime );
+    }
+    m_pExpTmr = 0; 
+    m_processThread = 0;
+    return delay;
+}
+
+bool timerQueue :: m_fixParent ( size_t childIdx )
+{
+    bool itMoved = false;
+    while ( childIdx != 0u ) {
+        const size_t parentIdx = m_parent ( childIdx );
+        if ( *m_heap[parentIdx] <= *m_heap[childIdx] ) { 
             break;
         }
+        m_swapEntries ( parentIdx, childIdx );
+        childIdx = parentIdx;
+        itMoved = true;
     }
-    return delay;
+    return itMoved;
 }
 
-epicsTimer & timerQueue::createTimer ()
+void timerQueue :: m_fixChildren ( size_t parentIdx )
 {
-    return * new ( this->timerFreeList ) timer ( * this );
+    const size_t hpsz = m_heap.size ();
+    while ( true ) {
+        const size_t leftChildIdx = m_leftChild ( parentIdx );  
+        const size_t rightChildIdx = m_rightChild ( parentIdx );  
+        size_t smallestIdx = parentIdx;
+        if ( leftChildIdx < hpsz ) {
+            if ( *m_heap[parentIdx] > *m_heap[leftChildIdx] ) {
+                smallestIdx = leftChildIdx;
+            }
+        }
+        if ( rightChildIdx < hpsz ) {
+            if ( *m_heap[smallestIdx] > *m_heap[rightChildIdx] ) {
+                smallestIdx = rightChildIdx;
+            }
+        }
+        if ( smallestIdx == parentIdx ) {
+            break;
+        }
+        m_swapEntries ( parentIdx, smallestIdx );
+        parentIdx = smallestIdx;
+    } 
+}
+
+Timer & timerQueue :: createTimerImpl ()
+{
+    // better to throw now in contrast with later during start
+    Guard guard ( *this );
+    m_numTimers++;
+    m_heap.reserve ( m_numTimers );
+    return * new Timer ( * this );
 }
 
-epicsTimerForC & timerQueue::createTimerForC ( epicsTimerCallback pCallback, void *pArg )
+epicsTimer & timerQueue :: createTimer ()
 {
-    return * new ( this->timerForCFreeList ) epicsTimerForC ( *this, pCallback, pArg );
+    return createTimerImpl ();
 }
 
-void timerQueue::show ( unsigned level ) const
+TimerForC & timerQueue :: createTimerForC ( 
+    epicsTimerCallback pCallback, void *pArg )
 {
-    epicsGuard < epicsMutex > locker ( this->mutex );
-    printf ( "epicsTimerQueue with %u items pending\n", this->timerList.count () );
+    return * new TimerForC ( *this, pCallback, pArg );
+}
+
+void timerQueue :: show ( unsigned level ) const
+{
+    Guard guard ( const_cast < timerQueue & > ( *this ) );
+    this->show ( guard, level );
+}
+
+void timerQueue :: show ( Guard & guard, unsigned level ) const
+{
+    guard.assertIdenticalMutex ( *this );
+    printf ( "epicsTimerQueue with %lu items pending\n",