Make global instance init thread-safe.

Use local statics except for Visual C++ < 2015.

src/Dispatcher.cpp

@@ -14,7 +14,7 @@ using namespace nt;
 
 #define DEBUG(str) puts(str)
 
-std::unique_ptr<Dispatcher> Dispatcher::m_instance;
+ATOMIC_STATIC_INIT(Dispatcher)
 
 Dispatcher::Dispatcher()
     : m_server(false),

src/Dispatcher.h

@@ -18,6 +18,7 @@
 
 #include "llvm/StringRef.h"
 
+#include "atomic_static.h"
 #include "NetworkConnection.h"
 #include "Storage.h"
 
@@ -28,8 +29,8 @@ namespace nt {
 class Dispatcher {
  public:
   static Dispatcher& GetInstance() {
-    if (!m_instance) m_instance.reset(new Dispatcher);
-    return *m_instance;
+    ATOMIC_STATIC(Dispatcher, instance);
+    return instance;
   }
   ~Dispatcher();
 
@@ -96,8 +97,7 @@ class Dispatcher {
   mutable std::mutex m_idmap_mutex;
   std::vector<std::shared_ptr<StorageEntry>> m_idmap;
 
-  // Global instance
-  static std::unique_ptr<Dispatcher> m_instance;
+  ATOMIC_STATIC_DECL(Dispatcher)
 };
 
 }  // namespace nt

src/Storage.cpp

@@ -15,7 +15,7 @@
 
 using namespace nt;
 
-std::unique_ptr<Storage> Storage::m_instance;
+ATOMIC_STATIC_INIT(Storage)
 
 Storage::Storage() {
   m_updates_enabled = false;

src/Storage.h

@@ -17,6 +17,7 @@
 
 #include "llvm/StringMap.h"
 #include "support/ConcurrentQueue.h"
+#include "atomic_static.h"
 #include "ntcore_cpp.h"
 #include "SequenceNumber.h"
 
@@ -75,8 +76,8 @@ class Storage {
   friend class StorageTest;
  public:
   static Storage& GetInstance() {
-    if (!m_instance) m_instance.reset(new Storage);
-    return *m_instance;
+    ATOMIC_STATIC(Storage, instance);
+    return instance;
   }
   ~Storage();
 
@@ -128,7 +129,7 @@ class Storage {
   UpdateQueue m_updates;
   std::atomic_bool m_updates_enabled;
 
-  static std::unique_ptr<Storage> m_instance;
+  ATOMIC_STATIC_DECL(Storage)
 };
 
 }  // namespace nt

src/atomic_static.h

@@ -0,0 +1,49 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) FIRST 2015. All Rights Reserved.                             */
+/* Open Source Software - may be modified and shared by FRC teams. The code   */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project.                                                               */
+/*----------------------------------------------------------------------------*/
+
+#ifndef NT_ATOMIC_STATIC_H_
+#define NT_ATOMIC_STATIC_H_
+
+#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
+
+// Just use a local static.  This is thread-safe per
+// http://preshing.com/20130930/double-checked-locking-is-fixed-in-cpp11/
+
+// Per https://msdn.microsoft.com/en-us/library/Hh567368.aspx "Magic Statics"
+// are supported in Visual Studio 2015 but not in earlier versions.
+#define ATOMIC_STATIC(cls, inst) static cls inst
+#define ATOMIC_STATIC_DECL(cls)
+#define ATOMIC_STATIC_INIT(cls)
+
+#else
+// From http://preshing.com/20130930/double-checked-locking-is-fixed-in-cpp11/
+#include <atomic>
+#include <mutex>
+
+#define ATOMIC_STATIC(cls, inst) \
+    cls* inst##tmp = m_instance.load(std::memory_order_acquire); \
+    if (inst##tmp == nullptr) { \
+      std::lock_guard<std::mutex> lock(m_instance_mutex); \
+      inst##tmp = m_instance.load(std::memory_order_relaxed); \
+      if (inst##tmp == nullptr) { \
+        inst##tmp = new cls; \
+        m_instance.store(inst##tmp, std::memory_order_release); \
+      } \
+    } \
+    cls& inst = *inst##tmp
+
+#define ATOMIC_STATIC_DECL(cls) \
+    static std::atomic<cls*> m_instance; \
+    static std::mutex m_instance_mutex;
+
+#define ATOMIC_STATIC_INIT(cls) \
+    std::atomic<cls*> cls::m_instance; \
+    std::mutex cls::m_instance_mutex;
+
+#endif
+
+#endif  // NT_ATOMIC_STATIC_H_