bpo-36356: Destroy the GIL at exit (GH-12453)

vstinner · web-flow · commit b36e5d627d42 · 2019-04-29T11:15:56.000+02:00
* Add _PyEval_FiniThreads2(). _PyEval_FiniThreads() now only clears
  the pending lock, whereas _PyEval_FiniThreads2() destroys the GIL.
* pymain_free() now calls _PyEval_FiniThreads2().
* Py_FinalizeEx() now calls _PyEval_FiniThreads().
diff --git a/Include/ceval.h b/Include/ceval.h
@@ -192,9 +192,6 @@ PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *);
 
 PyAPI_FUNC(int)  PyEval_ThreadsInitialized(void);
 PyAPI_FUNC(void) PyEval_InitThreads(void);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) _PyEval_FiniThreads(void);
-#endif /* !Py_LIMITED_API */
 PyAPI_FUNC(void) PyEval_AcquireLock(void) Py_DEPRECATED(3.2);
 PyAPI_FUNC(void) PyEval_ReleaseLock(void) /* Py_DEPRECATED(3.2) */;
 PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate);
diff --git a/Include/internal/pycore_ceval.h b/Include/internal/pycore_ceval.h
@@ -54,6 +54,9 @@ struct _ceval_runtime_state {
 
 PyAPI_FUNC(void) _PyEval_Initialize(struct _ceval_runtime_state *);
 
+PyAPI_FUNC(void) _PyEval_FiniThreads(void);
+PyAPI_FUNC(void) _PyEval_FiniThreads2(void);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/Modules/main.c b/Modules/main.c
@@ -1,6 +1,7 @@
 /* Python interpreter main program */
 
 #include "Python.h"
+#include "pycore_ceval.h"   /* _PyEval_FiniThreads2() */
 #include "pycore_coreconfig.h"
 #include "pycore_pylifecycle.h"
 #include "pycore_pymem.h"
@@ -525,15 +526,15 @@ pymain_run_python(int *exitcode)
 
 /* --- pymain_main() ---------------------------------------------- */
 
+/* Free global variables which cannot be freed in Py_Finalize():
+   configuration options set before Py_Initialize() which should
+   remain valid after Py_Finalize(), since
+   Py_Initialize()-Py_Finalize() can be called multiple times. */
 static void
 pymain_free(void)
 {
     _PyImport_Fini2();
-
-    /* Free global variables which cannot be freed in Py_Finalize():
-       configuration options set before Py_Initialize() which should
-       remain valid after Py_Finalize(), since
-       Py_Initialize()-Py_Finalize() can be called multiple times. */
+    _PyEval_FiniThreads2();
     _PyPathConfig_ClearGlobal();
     _Py_ClearStandardStreamEncoding();
     _Py_ClearArgcArgv();
diff --git a/Python/ceval.c b/Python/ceval.c
@@ -188,20 +188,26 @@ PyEval_InitThreads(void)
     }
 }
 
+
 void
 _PyEval_FiniThreads(void)
+{
+    if (_PyRuntime.ceval.pending.lock != NULL) {
+        PyThread_free_lock(_PyRuntime.ceval.pending.lock);
+        _PyRuntime.ceval.pending.lock = NULL;
+    }
+}
+
+
+void
+_PyEval_FiniThreads2(void)
 {
     if (!gil_created()) {
         return;
     }
 
     destroy_gil();
     assert(!gil_created());
-
-    if (_PyRuntime.ceval.pending.lock != NULL) {
-        PyThread_free_lock(_PyRuntime.ceval.pending.lock);
-        _PyRuntime.ceval.pending.lock = NULL;
-    }
 }
 
 static inline void
diff --git a/Python/pylifecycle.c b/Python/pylifecycle.c
@@ -4,8 +4,9 @@
 
 #include "Python-ast.h"
 #undef Yield   /* undefine macro conflicting with <winbase.h> */
-#include "pycore_coreconfig.h"
+#include "pycore_ceval.h"   /* _PyEval_FiniThreads() */
 #include "pycore_context.h"
+#include "pycore_coreconfig.h"
 #include "pycore_fileutils.h"
 #include "pycore_hamt.h"
 #include "pycore_pathconfig.h"
@@ -555,12 +556,11 @@ pycore_create_interpreter(_PyRuntimeState *runtime,
         return _Py_INIT_ERR("can't make first thread");
     (void) PyThreadState_Swap(tstate);
 
-    /* We can't call _PyEval_FiniThreads() in Py_FinalizeEx because
-       destroying the GIL might fail when it is being referenced from
-       another running thread (see issue #9901).
+    /* Destroying the GIL in Py_FinalizeEx might fail when it is being
+       referenced from another running thread (see bpo-9901).
        Instead we destroy the previously created GIL here, which ensures
        that we can call Py_Initialize / Py_FinalizeEx multiple times. */
-    _PyEval_FiniThreads();
+    _PyEval_FiniThreads2();
 
     /* Auto-thread-state API */
     _PyGILState_Init(runtime, interp, tstate);
@@ -1357,6 +1357,7 @@ Py_FinalizeEx(void)
 
     call_ll_exitfuncs(runtime);
 
+    _PyEval_FiniThreads();
     _PyRuntime_Finalize();
     return status;
 }

Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,9 @@ struct _ceval_runtime_state {`
`54`	`54`
`55`	`55`	`PyAPI_FUNC(void) _PyEval_Initialize(struct _ceval_runtime_state *);`
`56`	`56`
	`57`	`+PyAPI_FUNC(void) _PyEval_FiniThreads(void);`
	`58`	`+PyAPI_FUNC(void) _PyEval_FiniThreads2(void);`
	`59`	`+`
`57`	`60`	`#ifdef __cplusplus`
`58`	`61`	`}`
`59`	`62`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -188,20 +188,26 @@ PyEval_InitThreads(void)`
`188`	`188`	`}`
`189`	`189`	`}`
`190`	`190`
	`191`	`+`
`191`	`192`	`void`
`192`	`193`	`_PyEval_FiniThreads(void)`
	`194`	`+{`
	`195`	`+ if (_PyRuntime.ceval.pending.lock != NULL) {`
	`196`	`+ PyThread_free_lock(_PyRuntime.ceval.pending.lock);`
	`197`	`+ _PyRuntime.ceval.pending.lock = NULL;`
	`198`	`+ }`
	`199`	`+}`
	`200`	`+`
	`201`	`+`
	`202`	`+void`
	`203`	`+_PyEval_FiniThreads2(void)`
`193`	`204`	`{`
`194`	`205`	`if (!gil_created()) {`
`195`	`206`	`return;`
`196`	`207`	`}`
`197`	`208`
`198`	`209`	`destroy_gil();`
`199`	`210`	`assert(!gil_created());`
`200`		`-`
`201`		`- if (_PyRuntime.ceval.pending.lock != NULL) {`
`202`		`- PyThread_free_lock(_PyRuntime.ceval.pending.lock);`
`203`		`- _PyRuntime.ceval.pending.lock = NULL;`
`204`		`- }`
`205`	`211`	`}`
`206`	`212`
`207`	`213`	`static inline void`