Fix memory ordering for the event reset.

Author: ZeroIntensity

Include/internal/pycore_lock.h

@@ -87,6 +87,10 @@ PyAPI_FUNC(int) _PyEvent_IsSet(PyEvent *evt);
 // Export for '_testinternalcapi' shared extension
 PyAPI_FUNC(void) _PyEvent_Notify(PyEvent *evt);
 
+
+// Reset an event. There must be no active waiters.
+void _PyEvent_Reset(PyEvent *evt);
+
 // Wait for the event to be set. If the event is already set, then this returns
 // immediately.
 PyAPI_FUNC(void) PyEvent_Wait(PyEvent *evt);

Python/lock.c

@@ -313,6 +313,15 @@ _PyEvent_Notify(PyEvent *evt)
     }
 }
 
+void
+_PyEvent_Reset(PyEvent *evt)
+{
+    assert(evt != NULL);
+    // It's not safe to reset an event with active waiters.
+    assert(_Py_atomic_load_uint8(&evt->v) != _Py_HAS_PARKED);
+    _Py_atomic_store_uint8(&evt->v, _Py_UNLOCKED);
+}
+
 void
 PyEvent_Wait(PyEvent *evt)
 {

Python/pystate.c

@@ -3347,14 +3347,20 @@ try_acquire_interp_guard(PyInterpreterState *interp, PyInterpreterGuard *guard)
 
     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
+        // it will get trapped waiting on the RW lock, so we don't have to worry about
+        // another active waiter while we reset the event.
+        _PyEvent_Notify(&interp->finalization_guards.done);
+        // Now, when the finalization thread goes to check the countdown
+        // 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));
+        // It is worth noting that this event is intentionally a non-atomic check
+        // for remaining finalization guards (that is, even if the event is set,
+        // it is not necessarily guaranteed that countdown is zero). We use it
+        // to simply prevent the finalization from constantly spinning and
+        // atomically reading the countdown.
+        _PyEvent_Reset(&interp->finalization_guards.done);
     }
     _PyRWMutex_RUnlock(&interp->finalization_guards.lock);