Use an event for waiting on guards.

Author: ZeroIntensity

Include/cpython/pystate.h

@@ -337,4 +337,4 @@ PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameAllowSpecialization(
     PyInterpreterState *interp,
     int allow_specialization);
 PyAPI_FUNC(int) _PyInterpreterState_IsSpecializationEnabled(
-    PyInterpreterState *interp);
+    PyInterpreterState *interp);

Include/internal/pycore_interp_structs.h

@@ -1053,6 +1053,7 @@ struct _is {
     struct {
         _PyRWMutex lock;
         Py_ssize_t countdown;
+        PyEvent done;
     } finalization_guards;
 
     /* the initial PyInterpreterState.threads.head */

Python/pylifecycle.c

@@ -2309,16 +2309,25 @@ make_pre_finalization_calls(PyThreadState *tstate, int subinterpreters)
 
         if (subinterpreters) {
             /* Clean up any lingering subinterpreters.
-
-            Two preconditions need to be met here:
-
-                - This has to happen before _PyRuntimeState_SetFinalizing is
-                called, or else threads might get prematurely blocked.
-                - The world must not be stopped, as finalizers can run.
-            */
+             * Two preconditions need to be met here:
+             * 1. This has to happen before _PyRuntimeState_SetFinalizing is
+             *    called, or else threads might get prematurely blocked.
+             * 2. The world must not be stopped, as finalizers can run.
+             */
             finalize_subinterpreters();
         }
 
+        /* Wait on finalization guards.
+         *
+         * To avoid eating CPU cycles, we use an event to signal when we reach
+         * zero remaining guards. But, this isn't atomic! This event can be reset
+         * later if another thread creates a new finalization guard. The actual
+         * atomic check is made below, when we hold the finalization guard lock.
+         * Again, this is purely an optimization to avoid overloading the CPU.
+         */
+        if (_Py_atomic_load_ssize_relaxed(&interp->finalization_guards.countdown) > 0) {
+            PyEvent_Wait(&interp->finalization_guards.done);
+        }
 
         /* Stop the world to prevent other threads from creating threads or
          * atexit callbacks. On the default build, this is simply locked by

Python/pystate.c

@@ -3356,7 +3356,17 @@ try_acquire_interp_guard(PyInterpreterState *interp, PyInterpreterGuard *guard)
         return -1;
     }
 
-    _Py_atomic_add_ssize(&interp->finalization_guards.countdown, 1);
+    Py_ssize_t old_value = _Py_atomic_add_ssize(&interp->finalization_guards.countdown, 1);
+    if (old_value == 0) {
+        // Reset the event.
+        // We first have to notify the finalization thread if it's waiting on us, but
+        // it will get trapped waiting on the RW lock. When it goes to check
+        // again after we release the lock, it will see that the countdown is
+        // non-zero and begin waiting again (hence why we need to reset the
+        // event).
+        _PyEvent_Notify(&interp->finalization_guards.done);
+        memset(&interp->finalization_guards.done, 0, sizeof(PyEvent));
+    }
     _PyRWMutex_RUnlock(&interp->finalization_guards.lock);
 
     guard->interp = interp;
@@ -3393,6 +3403,9 @@ PyInterpreterGuard_Close(PyInterpreterGuard *guard)
 
     _PyRWMutex_RLock(&interp->finalization_guards.lock);
     Py_ssize_t old = _Py_atomic_add_ssize(&interp->finalization_guards.countdown, -1);
+    if (old == 1) {
+        _PyEvent_Notify(&interp->finalization_guards.done);
+    }
     _PyRWMutex_RUnlock(&interp->finalization_guards.lock);
 
     assert(old > 0);