Add test for multi-threaded import of multi-phase module

test/fabscript

@@ -124,15 +124,15 @@ tests.append(extension_test('shared_ptr',
 #tests.append(extension_test('auto_ptr',
 #                            condition=set.define.contains('HAS_CXX11')))
 
-import_ = binary('import_', ['import_.cpp', src.bpl], features=features|python_libs)
 if platform.os == 'Windows':
-    command = """set PATH=$(runpath);%PATH%
+    command2arg = """set PATH=$(runpath);%PATH%
 $(>[0]) $(>[1])"""
 else:
-    command = 'LD_LIBRARY_PATH=$(runpath) $(>[0]) $(>[1])'
+    command2arg = 'LD_LIBRARY_PATH=$(runpath) $(>[0]) $(>[1])'
 
+import_ = binary('import_', ['import_.cpp', src.bpl], features=features|python_libs)
 tests.append(test('import', [import_, 'import_.py'],
-                  run=action('run', command),
+                  run=action('run', command2arg),
                   features=features))
 
 tests.append(extension_test('calling_conventions',
@@ -183,4 +183,17 @@ tests.append(extension_test("module_multi_phase_nogil",
 tests.append(extension_test("module_multi_phase_state",
                             condition=python_version_major > 3 or (python_version_major == 3 and python_version_minor >= 5)))
 
+
+if platform.os == 'Windows':
+    command1arg = """set PATH=$(runpath);%PATH%
+$(>[0])"""
+else:
+    command1arg = 'LD_LIBRARY_PATH=$(runpath) $(>[0])'
+
+multi_thread_import_ = binary('multi_thread_import_', ['multi_thread_import_.cpp', src.bpl], features=features|python_libs)
+tests.append(test('multi_thread_import', [multi_thread_import_],
+                  run=action('run', command1arg),
+                  features=features,
+                  condition=python_version_major > 3 or (python_version_major == 3 and python_version_minor >= 5)))
+
 default = report('report', tests, fail_on_failures=True)

test/multi_thread_import_.cpp

@@ -0,0 +1,165 @@
+// Copyright Stefan Seefeld 2007.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/python.hpp>
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/bind/bind.hpp>
+#include <iostream>
+#include <thread>
+
+namespace bpl = boost::python;
+
+struct TestState 
+{
+  int x;
+};
+
+int get_state()
+{
+  TestState* state = reinterpret_cast<TestState*>(PyModule_GetState(bpl::import("multi_thread_import_").ptr()));
+  if (state)
+  {
+    return state->x;
+  }
+  return -2;
+}
+
+bool set_state(int value)
+{
+  TestState* state = reinterpret_cast<TestState*>(PyModule_GetState(bpl::import("multi_thread_import_").ptr()));
+  if (state)
+  {
+    state->x = value;
+    return true;
+  }
+  return false;
+}
+
+BOOST_PYTHON_MODULE_WITH_STATE(multi_thread_import_, TestState) {
+  state->x = -1;
+  bpl::def("get_state", get_state);
+  bpl::def("set_state", set_state);
+}
+
+void import_test(int thread_id)
+{
+  // Retrieve the main module
+  bpl::object import_ = bpl::import("multi_thread_import_");
+  bool result = bpl::extract<bool>(import_.attr("set_state")(thread_id)) BOOST_EXTRACT_WORKAROUND;
+  BOOST_TEST(result);
+
+  PyThreadState* _save = PyEval_SaveThread();
+  std::this_thread::sleep_for(std::chrono::milliseconds(50));
+  PyEval_RestoreThread(_save);
+
+  import_ = bpl::import("multi_thread_import_");
+  int value = bpl::extract<int>(import_.attr("get_state")()) BOOST_EXTRACT_WORKAROUND;
+  std::cout << "Thread " << thread_id << ": " << value << std::endl;
+  BOOST_TEST(value == thread_id);
+}
+
+void thread_func(int thread_id, PyInterpreterState* main_interp)
+{
+  // Initialize thread state for main interpreter in sub thread
+  PyThreadState* main_tstate = PyThreadState_New(main_interp);
+
+  if (!main_tstate) {
+    BOOST_ERROR("Failed to create main thread state");
+    return;
+  }
+
+  // Lock GIL before create sub interpreter
+  PyEval_AcquireThread(main_tstate);
+
+  // Create sub interpreter
+  PyThreadState* sub_thread_state = Py_NewInterpreter();
+
+  if (!sub_thread_state) {
+    BOOST_ERROR("Failed to create sub-interpreter");
+    // Release GIL
+    PyEval_ReleaseThread(main_tstate);
+    // Delete sub thread state
+    PyThreadState_Delete(main_tstate);
+    return;
+  }
+
+  if (bpl::handle_exception(boost::bind(import_test, thread_id)))
+  {
+    if (PyErr_Occurred())
+    {
+      BOOST_ERROR("Python Error detected");
+      PyErr_Print();
+    }
+    else
+    {
+        BOOST_ERROR("A C++ exception was thrown  for which "
+                    "there was no exception handler registered.");
+    }
+  }
+
+  // Finish sub interpreter
+  Py_EndInterpreter(sub_thread_state);
+
+  // Lock GIL again after for main interpreter
+  PyEval_AcquireThread(main_tstate);
+  // Release GIL
+  PyEval_ReleaseThread(main_tstate);
+  // Delete sub thread state
+  PyThreadState_Delete(main_tstate);
+}
+
+int main(int argc, char **argv)
+{
+  BOOST_TEST(argc == 1);
+
+  // Register the module with the interpreter
+  if (PyImport_AppendInittab(const_cast<char*>("multi_thread_import_"),
+#if PY_VERSION_HEX >= 0x03000000 
+                             PyInit_multi_thread_import_
+#else 
+                             multi_thread_import_
+#endif 
+                             ) == -1)
+  {
+    BOOST_ERROR("Failed to add import2_ to the interpreter's "
+                 "builtin modules");
+  }
+
+  // Initialize the interpreter
+  Py_Initialize();
+
+  // Capture main interpreter state to pass it to sub threads
+  PyInterpreterState* main_interp = PyThreadState_Get()->interp;
+
+  const int num_threads = 5;
+  std::vector<std::thread> threads;
+
+  // Release the main thread's GIL
+  PyThreadState* main_thread_state = PyEval_SaveThread();
+
+  for (int i = 0; i < num_threads; ++i)
+  {
+    threads.emplace_back(thread_func, i, main_interp);
+  }
+
+  for (auto& t : threads)
+  {
+    t.join();
+  }
+
+  // Restore the main thread's GIL
+  PyEval_RestoreThread(main_thread_state);
+
+  // Boost.Python doesn't support Py_Finalize yet.
+  // Py_Finalize();
+  return boost::report_errors();
+}
+
+// Including this file makes sure
+// that on Windows, any crashes (e.g. null pointer dereferences) invoke
+// the debugger immediately, rather than being translated into structured
+// exceptions that can interfere with debugging.
+#include "module_tail.cpp"