Wrap module_def initialization in a static so it only happens once.

If it happens concurrently in multiple threads, badness ensues....

Author: b-pass

include/pybind11/detail/common.h

@@ -401,17 +401,19 @@ PYBIND11_WARNING_DISABLE_CLANG("-Wgnu-zero-variadic-macro-arguments")
     PYBIND11_PLUGIN_IMPL(name) {                                                                  \
         PYBIND11_CHECK_PYTHON_VERSION                                                             \
         PYBIND11_ENSURE_INTERNALS_READY                                                           \
-        auto &slots = PYBIND11_CONCAT(pybind11_module_slots_, name);                              \
-        slots[0]                                                                                  \
-            = {Py_mod_exec, reinterpret_cast<void *>(&PYBIND11_CONCAT(pybind11_exec_, name))};    \
-        slots[1] = {0, nullptr};                                                                  \
-        auto m = ::pybind11::module_::initialize_multiphase_module_def(                           \
-            PYBIND11_TOSTRING(name),                                                              \
-            nullptr,                                                                              \
-            &PYBIND11_CONCAT(pybind11_module_def_, name),                                         \
-            slots,                                                                                \
-            ##__VA_ARGS__);                                                                       \
-        return m.ptr();                                                                           \
+        static auto result = []() {                                                               \
+            auto &slots = PYBIND11_CONCAT(pybind11_module_slots_, name);                          \
+            slots[0] = {Py_mod_exec,                                                              \
+                        reinterpret_cast<void *>(&PYBIND11_CONCAT(pybind11_exec_, name))};        \
+            slots[1] = {0, nullptr};                                                              \
+            return ::pybind11::module_::initialize_multiphase_module_def(                         \
+                PYBIND11_TOSTRING(name),                                                          \
+                nullptr,                                                                          \
+                &PYBIND11_CONCAT(pybind11_module_def_, name),                                     \
+                slots,                                                                            \
+                ##__VA_ARGS__);                                                                   \
+        }();                                                                                      \
+        return result.ptr();                                                                      \
     }                                                                                             \
     int PYBIND11_CONCAT(pybind11_exec_, name)(PyObject * pm) {                                    \
         pybind11::detail::get_num_interpreters_seen() += 1;                                       \

tests/test_embed/test_interpreter.cpp

@@ -465,10 +465,9 @@ TEST_CASE("Per-Subinterpreter GIL") {
     auto main_int
         = py::module_::import("external_module").attr("internals_at")().cast<uintptr_t>();
 
-    std::atomic<int> started, sync, finished, failure;
+    std::atomic<int> started, sync, failure;
     started = 0;
     sync = 0;
-    finished = 0;
     failure = 0;
 
 // REQUIRE throws on failure, so we can't use it within the thread
@@ -541,9 +540,7 @@ TEST_CASE("Per-Subinterpreter GIL") {
         T_REQUIRE(sub_int != main_int);
 
         Py_EndInterpreter(sub);
-
-        ++finished;
-
+        
         PyThreadState_Swap(
             main_tstate); // switch back so the scoped_acquire can release the GIL properly
     };
@@ -583,16 +580,11 @@ TEST_CASE("Per-Subinterpreter GIL") {
         // so we move sync so that thread 2 can finish executing
         ++sync;
 
-        ++finished;
-
         // now wait for both threads to complete
-        while (finished != 3)
-            std::this_thread::sleep_for(std::chrono::microseconds(1));
+        t1.join();
+        t2.join();
     }
 
-    t1.join();
-    t2.join();
-
     // now we have the gil again, sanity check
     REQUIRE(py::cast<std::string>(py::module_::import("external_module").attr("multi_interp"))
             == "1");