CXX-890 Don't use objects requiring dynamic init/fini for instance::current

Author: acmorrow

src/mongocxx/instance.cpp

@@ -15,6 +15,7 @@
 #include <mongocxx/instance.hpp>
 
 #include <mutex>
+#include <type_traits>
 #include <utility>
 
 #include <bsoncxx/stdx/make_unique.hpp>
@@ -60,9 +61,10 @@ void user_log_handler(::mongoc_log_level_t mongoc_log_level, const char *log_dom
                                         stdx::string_view{log_domain}, stdx::string_view{message});
 }
 
-std::recursive_mutex instance_mutex;
-instance *current_instance = nullptr;
-std::unique_ptr<instance> global_instance;
+std::atomic<instance*> current_instance{nullptr};
+static_assert(std::is_standard_layout<decltype(current_instance)>::value, "Must be standard layout");
+static_assert(std::is_trivially_constructible<decltype(current_instance)>::value, "Must be trivially constructible");
+static_assert(std::is_trivially_destructible<decltype(current_instance)>::value, "Must be trivially destructible");
 
 }  // namespace
 
@@ -94,31 +96,25 @@ instance::instance() : instance(nullptr) {
 }
 
 instance::instance(std::unique_ptr<logger> logger) {
-    std::lock_guard<std::recursive_mutex> lock(instance_mutex);
-    if (current_instance) {
+    instance* expected = nullptr;
+    if (!current_instance.compare_exchange_strong(expected, this))
         throw logic_error{error_code::k_instance_already_exists};
-    }
     _impl = stdx::make_unique<impl>(std::move(logger));
-    current_instance = this;
 }
 
 instance::instance(instance &&) noexcept = default;
 instance &instance::operator=(instance &&) noexcept = default;
 
 instance::~instance() {
-    std::lock_guard<std::recursive_mutex> lock(instance_mutex);
-    if (current_instance != this) std::abort();
     _impl.reset();
-    current_instance = nullptr;
+    current_instance.store(nullptr);
 }
 
 instance &instance::current() {
-    std::lock_guard<std::recursive_mutex> lock(instance_mutex);
-    if (!current_instance) {
-        global_instance.reset(new instance);
-        current_instance = global_instance.get();
+    if (!current_instance.load()) {
+         static instance the_instance;
     }
-    return *current_instance;
+    return *current_instance.load();
 }
 
 MONGOCXX_INLINE_NAMESPACE_END

src/mongocxx/instance.hpp

@@ -57,10 +57,19 @@ class MONGOCXX_API instance {
     ~instance();
 
     ///
-    /// Returns the current unique instance of the driver. If an
-    /// instance was explicitly created, that will be returned. If no
-    /// instance has yet been created, a default instance will be
-    /// constructed and returned.
+    /// Returns the current unique instance of the driver. If an instance was explicitly created,
+    /// that will be returned. If no instance has yet been created, a default instance will be
+    /// constructed and returned. If a default instance is constructed, its destruction will be
+    /// sequenced according to the rules for the destruction of static local variables at program
+    /// exit (see http://en.cppreference.com/w/cpp/utility/program/exit).
+    ///
+    /// Note that, if you need to configure the instance in any way (e.g. with a logger), you cannot
+    /// use this method to cause the instance to be constructed. You must explicitly create an
+    /// properly configured instance object. You can, however, use this method to obtain that
+    /// configured instance object.
+    ///
+    /// @note This method is intended primarily for test authors, where managing the lifetime of the
+    /// instance w.r.t. the test framework can be problematic.
     ///
     static instance& current();
 

src/mongocxx/test/instance.cpp

@@ -57,11 +57,18 @@ TEST_CASE("a user-provided log handler will be used for logging output", "[insta
     std::vector<test_log_handler::event> events;
     mongocxx::instance driver{stdx::make_unique<test_log_handler>(&events)};
 
+    REQUIRE(&mongocxx::instance::current() == &driver);
+
     // The mocking system doesn't play well with varargs functions, so we use a bare
     // mongoc_log call here.
     mongoc_log(::MONGOC_LOG_LEVEL_ERROR, "foo", "bar");
 
     REQUIRE(events.size() == 1);
     REQUIRE(events[0] == std::make_tuple(log_level::k_error, "foo", "bar"));
 }
+
+TEST_CASE("after destroying a user constructed instance the instance::current method works") {
+    mongocxx::instance::current();
+}
+
 }  // namespace