Remove static initializers

Author: chrdavis

src/loader/loader_core.cpp

@@ -44,11 +44,18 @@
 #include <string>
 #include <utility>
 #include <vector>
+
 // Global lock to prevent reading JSON manifest files at the same time.
-static std::mutex g_loader_json_mutex;
+std::mutex &GetLoaderJsonMutex() {
+    static std::mutex loader_json_mutex;
+    return loader_json_mutex;
+}
 
 // Global lock to prevent simultaneous instance creation/destruction
-static std::mutex g_instance_create_destroy_mutex;
+std::mutex &GetInstanceCreateDestroyMutex() {
+    static std::mutex instance_create_destroy_mutex;
+    return instance_create_destroy_mutex;
+}
 
 // Terminal functions needed by xrCreateInstance.
 XRAPI_ATTR XrResult XRAPI_CALL LoaderXrTermGetInstanceProcAddr(XrInstance, const char *, PFN_xrVoidFunction *);
@@ -84,7 +91,7 @@ LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateApiLayerProperties(uint3
     LoaderLogger::LogVerboseMessage("xrEnumerateApiLayerProperties", "Entering loader trampoline");
 
     // Make sure only one thread is attempting to read the JSON files at a time.
-    std::unique_lock<std::mutex> json_lock(g_loader_json_mutex);
+    std::unique_lock<std::mutex> json_lock(GetLoaderJsonMutex());
 
     XrResult result = ApiLayerInterface::GetApiLayerProperties("xrEnumerateApiLayerProperties", propertyCapacityInput,
                                                                propertyCountOutput, properties);
@@ -118,7 +125,7 @@ xrEnumerateInstanceExtensionProperties(const char *layerName, uint32_t propertyC
 
     {
         // Make sure only one thread is attempting to read the JSON files at a time.
-        std::unique_lock<std::mutex> json_lock(g_loader_json_mutex);
+        std::unique_lock<std::mutex> json_lock(GetLoaderJsonMutex());
 
         // Get the layer extension properties
         result = ApiLayerInterface::GetInstanceExtensionProperties("xrEnumerateInstanceExtensionProperties", layerName,
@@ -235,7 +242,7 @@ LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrCreateInstance(const XrInstanceCr
         return XR_ERROR_VALIDATION_FAILURE;
     }
 
-    std::unique_lock<std::mutex> instance_lock(g_instance_create_destroy_mutex);
+    std::unique_lock<std::mutex> instance_lock(GetInstanceCreateDestroyMutex());
 
     // Check if there is already an XrInstance that is alive. If so, another instance cannot be created.
     // The loader does not support multiple simultaneous instances because the loader is intended to be
@@ -252,7 +259,7 @@ LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrCreateInstance(const XrInstanceCr
 
     // Make sure only one thread is attempting to read the JSON files and use the instance.
     {
-        std::unique_lock<std::mutex> json_lock(g_loader_json_mutex);
+        std::unique_lock<std::mutex> json_lock(GetLoaderJsonMutex());
         // Load the available runtime
         result = RuntimeInterface::LoadRuntime("xrCreateInstance");
         if (XR_FAILED(result)) {
@@ -329,7 +336,7 @@ LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrDestroyInstance(XrInstance instan
         return XR_ERROR_HANDLE_INVALID;
     }
 
-    std::unique_lock<std::mutex> loader_instance_lock(g_instance_create_destroy_mutex);
+    std::unique_lock<std::mutex> loader_instance_lock(GetInstanceCreateDestroyMutex());
 
     LoaderInstance *loader_instance;
     XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrDestroyInstance");
@@ -657,7 +664,7 @@ XRAPI_ATTR XrResult XRAPI_CALL LoaderXrTermCreateDebugUtilsMessengerEXT(XrInstan
         *messenger = reinterpret_cast<XrDebugUtilsMessengerEXT>(temp_mess_ptr);
     }
     if (XR_SUCCEEDED(result)) {
-        LoaderLogger::GetInstance().AddLogRecorderForXrInstance(instance, MakeDebugUtilsLoaderLogRecorder(createInfo, *messenger));
+        LoaderLogger::GetInstance().AddLogRecorder(MakeDebugUtilsLoaderLogRecorder(createInfo, *messenger));
         RuntimeInterface::GetRuntime().TrackDebugMessenger(instance, *messenger);
     }
     LoaderLogger::LogVerboseMessage("xrCreateDebugUtilsMessengerEXT", "Completed loader terminator");

src/loader/loader_instance.cpp

@@ -44,22 +44,25 @@
 #include <vector>
 
 namespace {
-std::unique_ptr<LoaderInstance> g_current_loader_instance;
+std::unique_ptr<LoaderInstance>& GetSetCurrentLoaderInstance() {
+    static std::unique_ptr<LoaderInstance> current_loader_instance;
+    return current_loader_instance;
 }
+}  // namespace
 
 namespace ActiveLoaderInstance {
 XrResult Set(std::unique_ptr<LoaderInstance> loader_instance, const char* log_function_name) {
-    if (g_current_loader_instance != nullptr) {
+    if (GetSetCurrentLoaderInstance() != nullptr) {
         LoaderLogger::LogErrorMessage(log_function_name, "Active XrInstance handle already exists");
         return XR_ERROR_LIMIT_REACHED;
     }
 
-    g_current_loader_instance = std::move(loader_instance);
+    GetSetCurrentLoaderInstance() = std::move(loader_instance);
     return XR_SUCCESS;
 }
 
 XrResult Get(LoaderInstance** loader_instance, const char* log_function_name) {
-    *loader_instance = g_current_loader_instance.get();
+    *loader_instance = GetSetCurrentLoaderInstance().get();
     if (*loader_instance == nullptr) {
         LoaderLogger::LogErrorMessage(log_function_name, "No active XrInstance handle.");
         return XR_ERROR_HANDLE_INVALID;
@@ -68,9 +71,9 @@ XrResult Get(LoaderInstance** loader_instance, const char* log_function_name) {
     return XR_SUCCESS;
 }
 
-bool IsAvailable() { return g_current_loader_instance != nullptr; }
+bool IsAvailable() { return GetSetCurrentLoaderInstance() != nullptr; }
 
-void Remove() { g_current_loader_instance.release(); }
+void Remove() { GetSetCurrentLoaderInstance().release(); }
 }  // namespace ActiveLoaderInstance
 
 // Extensions that are supported by the loader, but may not be supported

src/loader/loader_logger.cpp

@@ -38,9 +38,6 @@
 #include <utility>
 #include <vector>
 
-std::unique_ptr<LoaderLogger> LoaderLogger::_instance;
-std::once_flag LoaderLogger::_once_flag;
-
 bool LoaderLogRecorder::LogDebugUtilsMessage(XrDebugUtilsMessageSeverityFlagsEXT /*message_severity*/,
                                              XrDebugUtilsMessageTypeFlagsEXT /*message_type*/,
                                              const XrDebugUtilsMessengerCallbackDataEXT* /*callback_data*/) {

src/loader/loader_logger.hpp

@@ -122,8 +122,8 @@ class LoaderLogRecorder {
 class LoaderLogger {
    public:
     static LoaderLogger& GetInstance() {
-        std::call_once(LoaderLogger::_once_flag, []() { _instance.reset(new LoaderLogger); });
-        return *(_instance.get());
+        static LoaderLogger instance;
+        return instance;
     }
 
     void AddLogRecorder(std::unique_ptr<LoaderLogRecorder>&& recorder);
@@ -184,9 +184,6 @@ class LoaderLogger {
    private:
     LoaderLogger();
 
-    static std::unique_ptr<LoaderLogger> _instance;
-    static std::once_flag _once_flag;
-
     // List of *all* available recorder objects (including created specifically for an Instance)
     std::vector<std::unique_ptr<LoaderLogRecorder>> _recorders;
 

src/loader/runtime_interface.cpp

@@ -37,12 +37,11 @@
 #include <utility>
 #include <vector>
 
-std::unique_ptr<RuntimeInterface> RuntimeInterface::_single_runtime_interface;
 uint32_t RuntimeInterface::_single_runtime_count = 0;
 
 XrResult RuntimeInterface::LoadRuntime(const std::string& openxr_command) {
     // If something's already loaded, we're done here.
-    if (_single_runtime_interface != nullptr) {
+    if (GetInstance() != nullptr) {
         _single_runtime_count++;
         return XR_SUCCESS;
     }
@@ -150,19 +149,19 @@ XrResult RuntimeInterface::LoadRuntime(const std::string& openxr_command) {
             LoaderLogger::LogInfoMessage(openxr_command, info_message);
 
             // Use this runtime
-            _single_runtime_interface.reset(new RuntimeInterface(runtime_library, runtime_info.getInstanceProcAddr));
+            GetInstance().reset(new RuntimeInterface(runtime_library, runtime_info.getInstanceProcAddr));
             _single_runtime_count++;
 
             // Grab the list of extensions this runtime supports for easy filtering after the
             // xrCreateInstance call
             std::vector<std::string> supported_extensions;
             std::vector<XrExtensionProperties> extension_properties;
-            _single_runtime_interface->GetInstanceExtensionProperties(extension_properties);
+            GetInstance()->GetInstanceExtensionProperties(extension_properties);
             supported_extensions.reserve(extension_properties.size());
             for (XrExtensionProperties ext_prop : extension_properties) {
                 supported_extensions.emplace_back(ext_prop.extensionName);
             }
-            _single_runtime_interface->SetSupportedExtensions(supported_extensions);
+            GetInstance()->SetSupportedExtensions(supported_extensions);
 
             // If we load one, clear all errors.
             any_loaded = true;
@@ -186,22 +185,22 @@ XrResult RuntimeInterface::LoadRuntime(const std::string& openxr_command) {
 void RuntimeInterface::UnloadRuntime(const std::string& openxr_command) {
     if (_single_runtime_count == 1) {
         _single_runtime_count = 0;
-        _single_runtime_interface.reset();
+        GetInstance().reset();
     } else if (_single_runtime_count > 0) {
         --_single_runtime_count;
     }
     LoaderLogger::LogInfoMessage(openxr_command, "RuntimeInterface being unloaded.");
 }
 
 XrResult RuntimeInterface::GetInstanceProcAddr(XrInstance instance, const char* name, PFN_xrVoidFunction* function) {
-    return _single_runtime_interface->_get_instance_proc_addr(instance, name, function);
+    return GetInstance()->_get_instance_proc_addr(instance, name, function);
 }
 
 const XrGeneratedDispatchTable* RuntimeInterface::GetDispatchTable(XrInstance instance) {
     XrGeneratedDispatchTable* table = nullptr;
-    std::lock_guard<std::mutex> mlock(_single_runtime_interface->_dispatch_table_mutex);
-    auto it = _single_runtime_interface->_dispatch_table_map.find(instance);
-    if (it != _single_runtime_interface->_dispatch_table_map.end()) {
+    std::lock_guard<std::mutex> mlock(GetInstance()->_dispatch_table_mutex);
+    auto it = GetInstance()->_dispatch_table_map.find(instance);
+    if (it != GetInstance()->_dispatch_table_map.end()) {
         table = it->second.get();
     }
     return table;
@@ -210,9 +209,9 @@ const XrGeneratedDispatchTable* RuntimeInterface::GetDispatchTable(XrInstance in
 const XrGeneratedDispatchTable* RuntimeInterface::GetDebugUtilsMessengerDispatchTable(XrDebugUtilsMessengerEXT messenger) {
     XrInstance runtime_instance = XR_NULL_HANDLE;
     {
-        std::lock_guard<std::mutex> mlock(_single_runtime_interface->_messenger_to_instance_mutex);
-        auto it = _single_runtime_interface->_messenger_to_instance_map.find(messenger);
-        if (it != _single_runtime_interface->_messenger_to_instance_map.end()) {
+        std::lock_guard<std::mutex> mlock(GetInstance()->_messenger_to_instance_mutex);
+        auto it = GetInstance()->_messenger_to_instance_map.find(messenger);
+        if (it != GetInstance()->_messenger_to_instance_map.end()) {
             runtime_instance = it->second;
         }
     }

src/loader/runtime_interface.hpp

@@ -40,7 +40,7 @@ class RuntimeInterface {
     // Helper functions for loading and unloading the runtime (but only when necessary)
     static XrResult LoadRuntime(const std::string& openxr_command);
     static void UnloadRuntime(const std::string& openxr_command);
-    static RuntimeInterface& GetRuntime() { return *(_single_runtime_interface.get()); }
+    static RuntimeInterface& GetRuntime() { return *(GetInstance().get()); }
     static XrResult GetInstanceProcAddr(XrInstance instance, const char* name, PFN_xrVoidFunction* function);
 
     // Get the direct dispatch table to this runtime, without API layers or loader terminators.
@@ -65,7 +65,11 @@ class RuntimeInterface {
     RuntimeInterface(LoaderPlatformLibraryHandle runtime_library, PFN_xrGetInstanceProcAddr get_instance_proc_addr);
     void SetSupportedExtensions(std::vector<std::string>& supported_extensions);
 
-    static std::unique_ptr<RuntimeInterface> _single_runtime_interface;
+    static std::unique_ptr<RuntimeInterface>& GetInstance() {
+        static std::unique_ptr<RuntimeInterface> instance;
+        return instance;
+    }
+
     static uint32_t _single_runtime_count;
     LoaderPlatformLibraryHandle _runtime_library;
     PFN_xrGetInstanceProcAddr _get_instance_proc_addr;