Fix and refactor the controlling thread ownership logic

CHANGES.md

@@ -8,12 +8,18 @@
 - When OpenBLAS uses a non-OpenMP threading layer, you can only set the size of
   its thread pool from a single controlling thread; since it has a shared
   process-wide thread pool, having multiple Python threads fight over control
-  wouldn't work well. A new API
-  ``OpenBLASController.clear_controlling_thread()`` allows resetting which
-  thread controlls OpenBLAS in these cases, and decorator and context manager
-  limit APIs will automatically call that API when they are done.
+  wouldn't work well. Each loaded OpenBLAS library has its own pool and its own
+  controlling thread. A plain ``threadpool_limits(...)`` call or a direct
+  ``set_num_threads()`` keeps that role until ``clear_controlling_thread()`` on
+  that library. ``OpenBLASController.clear_all_controlling_threads()`` drops
+  every loaded OpenBLAS library. Context managers and decorators release it when the
+  outermost scope that took the claim exits. A thread that has finished no
+  longer holds the claim; the next ``set_num_threads()`` can take it. The
+  ``CONTROLLING_THREAD_OWNERSHIP`` singleton can be used to manually manage the
+  scope of ``set_num_threads`` calls.
   https://github.com/joblib/threadpoolctl/pull/275
   https://github.com/joblib/threadpoolctl/pull/289
+  https://github.com/joblib/threadpoolctl/pull/290
 
 - Add a new API to get a cached `ThreadpoolController` instance
   (`get_cached_controller()`), as an optimization for cases where limits are set

README.md

@@ -274,13 +274,17 @@ OpenBLAS+pthreads) and in each worker thread.
 
 > **Why you need both:** When setting a limit on OpenBLAS with pthreads or the
 > Windows threading layer, setting the limit affects the whole process, because
-> it uses a process-wide shared thread pool. (This in contrast to some other
-> BLAS/OpenMP libraries, or OpenBLAS backed by OpenMP, that allow setting the
-> limit per-thread.) Having multiple Python threads set limits in this case
-> makes no sense, since they would effectively be arguing over a globally shared
-> resource. ``threadpoolctl`` therefore constrains the limiting API in the
-> OpenBLAS pthreads/Windows case to only work from the first thread that uses
-> it, the so-called controlling thread.
+> each loaded OpenBLAS library uses one process-wide shared thread pool. (This in
+> contrast to some other BLAS/OpenMP libraries, or OpenBLAS backed by OpenMP,
+> that allow setting the limit per-thread.) A process can load more than one
+> OpenBLAS library, for example one bundled with NumPy and another bundled with
+> SciPy, and each has its own pool. Having multiple Python threads set limits on
+> the same library makes no sense, since they would be arguing over its pool.
+> So each loaded OpenBLAS library has its own controlling thread: the first
+> thread to set thread limits on it. Other threads do nothing. The controlling
+> thread is released automatically when the ``with`` block or decorated function
+> that took it exits, and once that thread has finished. See the docstring of
+> ``OpenBLASController`` for more details.
 >
 > For many other libraries, for example OpenMP, the limit is set per thread. As
 > a result, you want to set limits both ways in generic code that doesn't know

conftest.py

@@ -1,3 +1,5 @@
+import warnings
+
 import pytest
 
 collect_ignore = [
@@ -9,11 +11,41 @@
 ]
 
 
+def _ensure_openblas_thread_count_is_restorable():
+    """Replace an unset non-OpenMP OpenBLAS count with the processor count.
+
+    ``get_num_threads() == 0`` means OpenBLAS has not chosen an active count.
+    ``set_num_threads(0)`` does not return to that state: a non-positive value
+    means the number of worker threads already created, and that number only
+    grows. A positive count can be saved and restored.
+    """
+    from threadpoolctl import OpenBLASController, ThreadpoolController
+
+    # Building a controller warns when libomp and libiomp are both loaded.
+    # That warning is the subject of test_libomp_libiomp_warning, and pytest
+    # runs with -W error, so the fixture must not emit it.
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            message=r"\s*Found Intel OpenMP",
+            category=RuntimeWarning,
+        )
+        controller = ThreadpoolController().select(internal_api="openblas")
+    if controller:
+        for lib in controller.lib_controllers:
+            if lib.threading_layer == "openmp" or lib.get_num_threads() != 0:
+                continue
+            get_num_procs = lib._get_symbol("openblas_get_num_procs")
+            nprocs = get_num_procs() if get_num_procs is not None else 1
+            if nprocs >= 1:
+                lib.set_num_threads(nprocs)
+    OpenBLASController.clear_all_controlling_threads(force=True)
+
+
 @pytest.fixture(autouse=True)
 def reset_openblas_controlling_thread():
-    from threadpoolctl import OpenBLASController
-
+    _ensure_openblas_thread_count_is_restorable()
     try:
         yield
     finally:
-        OpenBLASController.clear_controlling_thread(force=True)
+        _ensure_openblas_thread_count_is_restorable()

continuous_integration/check_no_test_skipped.py

@@ -36,6 +36,8 @@
 # numpy or scipy and we don't want to pin old versions of these libraries.
 SAFE_SKIPPED_TESTS = [
     "test_multiple_shipped_openblas",
+    # Runs only when two distinct non-OpenMP OpenBLAS copies are loaded.
+    "test_openblas_controlling_thread_is_per_library",
     "test_threadpool_limits_by_prefix[1-libblas]",
     "test_threadpool_limits_by_prefix[3-libblas]",
 ]