Execute early finalization handlers in a loop

Author: ZeroIntensity

Include/internal/pycore_ceval.h

@@ -43,7 +43,7 @@ PyAPI_FUNC(int) _PyEval_MakePendingCalls(PyThreadState *);
 #  define Py_DEFAULT_RECURSION_LIMIT 1000
 #endif
 
-extern void _Py_FinishPendingCalls(PyThreadState *tstate);
+extern int _Py_FinishPendingCalls(PyThreadState *tstate);
 extern void _PyEval_InitState(PyInterpreterState *);
 extern void _PyEval_SignalReceived(void);
 

Include/internal/pycore_pylifecycle.h

@@ -85,7 +85,7 @@ extern void _PyErr_DisplayException(PyObject *file, PyObject *exc);
 
 extern void _PyThreadState_DeleteCurrent(PyThreadState *tstate);
 
-extern void _PyAtExit_Call(PyInterpreterState *interp);
+extern int _PyAtExit_Call(PyInterpreterState *interp);
 
 extern int _Py_IsCoreInitialized(void);
 

Lib/threading.py

@@ -1558,7 +1558,7 @@ def _shutdown():
     # mark it done here.
     if _main_thread._os_thread_handle.is_done() and _is_main_interpreter():
         # _shutdown() was already called
-        return
+        return False
 
     global _SHUTTING_DOWN
     _SHUTTING_DOWN = True
@@ -1572,7 +1572,7 @@ def _shutdown():
         _main_thread._os_thread_handle._set_done()
 
     # Wait for all non-daemon threads to exit.
-    _thread_shutdown()
+    return _thread_shutdown()
 
 
 def main_thread():

Modules/_threadmodule.c

@@ -2345,6 +2345,7 @@ thread_shutdown(PyObject *self, PyObject *args)
 {
     PyThread_ident_t ident = PyThread_get_thread_ident_ex();
     thread_module_state *state = get_thread_state(self);
+    int found_thread = 0;
 
     for (;;) {
         ThreadHandle *handle = NULL;
@@ -2353,6 +2354,7 @@ thread_shutdown(PyObject *self, PyObject *args)
         HEAD_LOCK(&_PyRuntime);
         struct llist_node *node;
         llist_for_each_safe(node, &state->shutdown_handles) {
+            found_thread = 1;
             ThreadHandle *cur = llist_data(node, ThreadHandle, shutdown_node);
             if (cur->ident != ident) {
                 ThreadHandle_incref(cur);
@@ -2373,13 +2375,13 @@ thread_shutdown(PyObject *self, PyObject *args)
             PyErr_FormatUnraisable("Exception ignored while joining a thread "
                                    "in _thread._shutdown()");
             ThreadHandle_decref(handle);
-            Py_RETURN_NONE;
+            return PyBool_FromLong(found_thread);
         }
 
         ThreadHandle_decref(handle);
     }
 
-    Py_RETURN_NONE;
+    return PyBool_FromLong(found_thread);
 }
 
 PyDoc_STRVAR(shutdown_doc,

Modules/atexitmodule.c

@@ -99,7 +99,7 @@ _PyAtExit_Fini(PyInterpreterState *interp)
     }
 }
 
-static void
+static int
 atexit_callfuncs(struct atexit_state *state)
 {
     assert(!PyErr_Occurred());
@@ -112,10 +112,13 @@ atexit_callfuncs(struct atexit_state *state)
     {
         PyErr_FormatUnraisable("Exception ignored while "
                                "copying atexit callbacks");
-        return;
+        return 0;
     }
 
+    int called = 0;
+
     for (Py_ssize_t i = 0; i < PyList_GET_SIZE(copy); ++i) {
+        called = 1;
         // We don't have to worry about evil borrowed references, because
         // no other threads can access this list.
         PyObject *tuple = PyList_GET_ITEM(copy, i);
@@ -141,14 +144,15 @@ atexit_callfuncs(struct atexit_state *state)
     atexit_cleanup(state);
 
     assert(!PyErr_Occurred());
+    return called;
 }
 
 
-void
+int
 _PyAtExit_Call(PyInterpreterState *interp)
 {
     struct atexit_state *state = &interp->atexit;
-    atexit_callfuncs(state);
+    return atexit_callfuncs(state);
 }
 
 

Python/ceval_gil.c

@@ -837,10 +837,11 @@ handle_signals(PyThreadState *tstate)
 }
 
 static int
-_make_pending_calls(struct _pending_calls *pending, int32_t *p_npending)
+_make_pending_calls(struct _pending_calls *pending, int32_t *p_npending, int *p_called)
 {
     int res = 0;
     int32_t npending = -1;
+    int called = 0;
 
     assert(sizeof(pending->max) <= sizeof(size_t)
             && ((size_t)pending->max) <= Py_ARRAY_LENGTH(pending->calls));
@@ -868,6 +869,8 @@ _make_pending_calls(struct _pending_calls *pending, int32_t *p_npending)
             break;
         }
 
+        called = 1;
+
         /* having released the lock, perform the callback */
         res = func(arg);
         if ((flags & _Py_PENDING_RAWFREE) && arg != NULL) {
@@ -881,6 +884,7 @@ _make_pending_calls(struct _pending_calls *pending, int32_t *p_npending)
 
 finally:
     *p_npending = npending;
+    *p_called = called;
     return res;
 }
 
@@ -917,7 +921,7 @@ clear_pending_handling_thread(struct _pending_calls *pending)
 }
 
 static int
-make_pending_calls(PyThreadState *tstate)
+make_pending_calls_with_count(PyThreadState *tstate)
 {
     PyInterpreterState *interp = tstate->interp;
     struct _pending_calls *pending = &interp->ceval.pending;
@@ -947,7 +951,8 @@ make_pending_calls(PyThreadState *tstate)
     unsignal_pending_calls(tstate, interp);
 
     int32_t npending;
-    if (_make_pending_calls(pending, &npending) != 0) {
+    int called;
+    if (_make_pending_calls(pending, &npending, &called) != 0) {
         clear_pending_handling_thread(pending);
         /* There might not be more calls to make, but we play it safe. */
         signal_pending_calls(tstate, interp);
@@ -958,8 +963,9 @@ make_pending_calls(PyThreadState *tstate)
         signal_pending_calls(tstate, interp);
     }
 
+    int main_called = 0;
     if (_Py_IsMainThread() && _Py_IsMainInterpreter(interp)) {
-        if (_make_pending_calls(pending_main, &npending) != 0) {
+        if (_make_pending_calls(pending_main, &npending, &main_called) != 0) {
             clear_pending_handling_thread(pending);
             /* There might not be more calls to make, but we play it safe. */
             signal_pending_calls(tstate, interp);
@@ -972,6 +978,16 @@ make_pending_calls(PyThreadState *tstate)
     }
 
     clear_pending_handling_thread(pending);
+    return Py_MAX(called, main_called);
+}
+
+static int
+make_pending_calls(PyThreadState *tstate)
+{
+    if (make_pending_calls_with_count(tstate) < 0) {
+        return -1;
+    }
+
     return 0;
 }
 
@@ -994,7 +1010,7 @@ _Py_unset_eval_breaker_bit_all(PyInterpreterState *interp, uintptr_t bit)
     _Py_FOR_EACH_TSTATE_END(interp);
 }
 
-void
+int
 _Py_FinishPendingCalls(PyThreadState *tstate)
 {
     _Py_AssertHoldsTstate();
@@ -1011,13 +1027,18 @@ _Py_FinishPendingCalls(PyThreadState *tstate)
 #ifndef NDEBUG
     int32_t npending_prev = INT32_MAX;
 #endif
+    int called = 0;
     do {
-        if (make_pending_calls(tstate) < 0) {
+        int res = make_pending_calls_with_count(tstate);
+        if (res < 0) {
             PyObject *exc = _PyErr_GetRaisedException(tstate);
             PyErr_BadInternalCall();
             _PyErr_ChainExceptions1(exc);
             _PyErr_Print(tstate);
         }
+        if (res != 0) {
+            called = 1;
+        }
 
         npending = _Py_atomic_load_int32_relaxed(&pending->npending);
         if (pending_main != NULL) {
@@ -1028,6 +1049,8 @@ _Py_FinishPendingCalls(PyThreadState *tstate)
         npending_prev = npending;
 #endif
     } while (npending > 0);
+
+    return called;
 }
 
 int

Python/pylifecycle.c

@@ -96,7 +96,7 @@ static PyStatus init_android_streams(PyThreadState *tstate);
 #if defined(__APPLE__) && HAS_APPLE_SYSTEM_LOG
 static PyStatus init_apple_streams(PyThreadState *tstate);
 #endif
-static void wait_for_thread_shutdown(PyThreadState *tstate);
+static int wait_for_thread_shutdown(PyThreadState *tstate);
 static void finalize_subinterpreters(void);
 static void call_ll_exitfuncs(_PyRuntimeState *runtime);
 
@@ -2003,6 +2003,39 @@ resolve_final_tstate(_PyRuntimeState *runtime)
     return main_tstate;
 }
 
+static void
+make_pre_finalization_calls(PyThreadState *tstate)
+{
+    /* Each of these functions can start one another, e.g. a pending call
+     * could start a thread or vice versa. To ensure that we properly clean
+     * call everything, we run these in a loop until none of them run anything. */
+    for (;;) {
+        int called = 0;
+
+        // Wrap up existing "threading"-module-created, non-daemon threads.
+        called = Py_MAX(called, wait_for_thread_shutdown(tstate));
+
+        // Make any remaining pending calls.
+        called = Py_MAX(called, _Py_FinishPendingCalls(tstate));
+
+        /* The interpreter is still entirely intact at this point, and the
+        * exit funcs may be relying on that.  In particular, if some thread
+        * or exit func is still waiting to do an import, the import machinery
+        * expects Py_IsInitialized() to return true.  So don't say the
+        * runtime is uninitialized until after the exit funcs have run.
+        * Note that Threading.py uses an exit func to do a join on all the
+        * threads created thru it, so this also protects pending imports in
+        * the threads created via Threading.
+        */
+
+        called = Py_MAX(called, _PyAtExit_Call(tstate->interp));
+
+        if (called == 0) {
+            break;
+        }
+    }
+}
+
 static int
 _Py_Finalize(_PyRuntimeState *runtime)
 {
@@ -2019,23 +2052,7 @@ _Py_Finalize(_PyRuntimeState *runtime)
     // Block some operations.
     tstate->interp->finalizing = 1;
 
-    // Wrap up existing "threading"-module-created, non-daemon threads.
-    wait_for_thread_shutdown(tstate);
-
-    // Make any remaining pending calls.
-    _Py_FinishPendingCalls(tstate);
-
-    /* The interpreter is still entirely intact at this point, and the
-     * exit funcs may be relying on that.  In particular, if some thread
-     * or exit func is still waiting to do an import, the import machinery
-     * expects Py_IsInitialized() to return true.  So don't say the
-     * runtime is uninitialized until after the exit funcs have run.
-     * Note that Threading.py uses an exit func to do a join on all the
-     * threads created thru it, so this also protects pending imports in
-     * the threads created via Threading.
-     */
-
-    _PyAtExit_Call(tstate->interp);
+    make_pre_finalization_calls(tstate);
 
     assert(_PyThreadState_GET() == tstate);
 
@@ -3442,7 +3459,7 @@ Py_ExitStatusException(PyStatus status)
    the threading module was imported in the first place.
    The shutdown routine will wait until all non-daemon
    "threading" threads have completed. */
-static void
+static int
 wait_for_thread_shutdown(PyThreadState *tstate)
 {
     PyObject *result;
@@ -3452,16 +3469,19 @@ wait_for_thread_shutdown(PyThreadState *tstate)
             PyErr_FormatUnraisable("Exception ignored on threading shutdown");
         }
         /* else: threading not imported */
-        return;
+        return 0;
     }
+    int called = 0;
     result = PyObject_CallMethodNoArgs(threading, &_Py_ID(_shutdown));
     if (result == NULL) {
         PyErr_FormatUnraisable("Exception ignored on threading shutdown");
     }
     else {
-        Py_DECREF(result);
+        assert(PyBool_Check(result) && _Py_IsImmortal(result));
+        called = result == Py_True;
     }
     Py_DECREF(threading);
+    return called;
 }
 
 int Py_AtExit(void (*func)(void))