SingletonPtr: API extensions, make constexpr

* Adjust definition to make the default constructor `constexpr`.
  This permits use in classes that want lazy initialization and their
  own `constexpr` constructor, such as `mstd::mutex`.

* Add `get_no_init()` method to allow an explicit optimisation for
  paths that know they won be the first call (such as
  `mstd::mutex::unlock`).

* Add `destroy()` method to permit destruction of the contained object.
  (`SingletonPtr`'s destructor does not call its destructor - a cheat
  to omit destructors of static objects). Needed if using in a class
  that needs proper destruction.

Author: kjbracey

platform/SingletonPtr.h

@@ -86,20 +86,25 @@ inline static void singleton_unlock(void)
 template <class T>
 struct SingletonPtr {
 
+    // Initializers are required to make default constructor constexpr
+    // If we were ever used as an automatic object, the explicit zero-initialization of
+    // _data would be pointless runtime cost, but as a static object it's free.
+    constexpr SingletonPtr() : _ptr(), _data() { }
+
     /** Get a pointer to the underlying singleton
      *
      * @returns
      *   A pointer to the singleton
      */
     T *get() const
     {
-        T *p = static_cast<T *>(core_util_atomic_load_ptr(&_ptr));
+        T *p = core_util_atomic_load(&_ptr);
         if (p == NULL) {
             singleton_lock();
-            p = static_cast<T *>(_ptr);
+            p = _ptr;
             if (p == NULL) {
                 p = new (_data) T();
-                core_util_atomic_store_ptr(&_ptr, p);
+                core_util_atomic_store(&_ptr, p);
             }
             singleton_unlock();
         }
@@ -129,14 +134,48 @@ struct SingletonPtr {
         return *get();
     }
 
-    // This is zero initialized when in global scope
-    mutable void *_ptr;
+    /** Get a pointer to the underlying singleton
+     *
+     * Gets a pointer without initialization - can be
+     * used as an optimization when it is known that
+     * initialization must have already occurred.
+     *
+     * @returns
+     *   A pointer to the singleton, or NULL if not
+     *   initialized.
+     */
+    T *get_no_init() const
+    {
+        return _ptr;
+    }
+
+    /** Destroy the underlying singleton
+     *
+     * The underlying singleton is never automatically destroyed;
+     * this is a potential optimization to avoid destructors
+     * being pulled into an embedded image on the exit path,
+     * which should never occur. The destructor can be
+     * manually invoked via this call.
+     *
+     * Unlike construction, this is not thread-safe. After this call,
+     * no further operations on the object are permitted.
+     *
+     * Is a no-op if the object has not been constructed.
+     */
+    void destroy()
+    {
+        if (_ptr) {
+            _ptr->~T();
+        }
+    }
+
+    mutable T *_ptr;
 #if __cplusplus >= 201103L && !defined __CC_ARM
     // Align data appropriately (ARM Compiler 5 does not support alignas in C++11 mode)
     alignas(T) mutable char _data[sizeof(T)];
 #else
     // Force data to be 8 byte aligned
-    mutable uint64_t _data[(sizeof(T) + sizeof(uint64_t) - 1) / sizeof(uint64_t)];
+    mutable uint64_t _data[(sizeof(T) + sizeof(uint64_t) - 1) / sizeof(uint64_t)] = { };
 #endif
 };
 

tools/test/travis-ci/doxy-spellchecker/ignore.en.pws

@@ -46,7 +46,9 @@ retval
 dequeue
 assertation
 destructor
+destructors
 constructor
+constructors
 ctor
 dtor
 dereference