bpo-46008: Stop calling _PyThreadState_Init() in new_threadstate(). (gh-29973)

ericsnowcurrently · web-flow · commit 1f384e318481 · 2021-12-07T17:26:29.000-07:00
This simplifies new_threadstate(). We also rename _PyThreadState_Init() to _PyThreadState_SetCurrent() to reflect what it actually does. https://bugs.python.org/issue46008
diff --git a/Include/internal/pycore_pystate.h b/Include/internal/pycore_pystate.h
@@ -127,6 +127,8 @@ static inline PyInterpreterState* _PyInterpreterState_GET(void) {
 
 // PyThreadState functions
 
+PyAPI_FUNC(void) _PyThreadState_SetCurrent(PyThreadState *tstate);
+// We keep this around exclusively for stable ABI compatibility.
 PyAPI_FUNC(void) _PyThreadState_Init(
     PyThreadState *tstate);
 PyAPI_FUNC(void) _PyThreadState_DeleteExcept(
diff --git a/Modules/_threadmodule.c b/Modules/_threadmodule.c
@@ -6,7 +6,7 @@
 #include "pycore_interp.h"        // _PyInterpreterState.threads.count
 #include "pycore_moduleobject.h"  // _PyModule_GetState()
 #include "pycore_pylifecycle.h"
-#include "pycore_pystate.h"       // _PyThreadState_Init()
+#include "pycore_pystate.h"       // _PyThreadState_SetCurrent()
 #include <stddef.h>               // offsetof()
 #include "structmember.h"         // PyMemberDef
 
@@ -1087,7 +1087,7 @@ thread_run(void *boot_raw)
 #else
     tstate->native_thread_id = 0;
 #endif
-    _PyThreadState_Init(tstate);
+    _PyThreadState_SetCurrent(tstate);
     PyEval_AcquireThread(tstate);
     tstate->interp->threads.count++;
 
diff --git a/Python/pystate.c b/Python/pystate.c
@@ -631,7 +631,7 @@ allocate_chunk(int size_in_bytes, _PyStackChunk* previous)
 }
 
 static PyThreadState *
-new_threadstate(PyInterpreterState *interp, int init)
+new_threadstate(PyInterpreterState *interp)
 {
     _PyRuntimeState *runtime = interp->runtime;
     PyThreadState *tstate = (PyThreadState *)PyMem_RawCalloc(1, sizeof(PyThreadState));
@@ -662,10 +662,6 @@ new_threadstate(PyInterpreterState *interp, int init)
     tstate->datastack_top = &tstate->datastack_chunk->data[1];
     tstate->datastack_limit = (PyObject **)(((char *)tstate->datastack_chunk) + DATA_STACK_CHUNK_SIZE);
 
-    if (init) {
-        _PyThreadState_Init(tstate);
-    }
-
     HEAD_LOCK(runtime);
     tstate->id = ++interp->threads.next_unique_id;
     tstate->next = interp->threads.head;
@@ -680,17 +676,27 @@ new_threadstate(PyInterpreterState *interp, int init)
 PyThreadState *
 PyThreadState_New(PyInterpreterState *interp)
 {
-    return new_threadstate(interp, 1);
+    PyThreadState *tstate = new_threadstate(interp);
+    _PyThreadState_SetCurrent(tstate);
+    return tstate;
 }
 
 PyThreadState *
 _PyThreadState_Prealloc(PyInterpreterState *interp)
 {
-    return new_threadstate(interp, 0);
+    return new_threadstate(interp);
 }
 
+// We keep this around for (accidental) stable ABI compatibility.
+// Realisically, no extensions are using it.
 void
 _PyThreadState_Init(PyThreadState *tstate)
+{
+    Py_FatalError("_PyThreadState_Init() is for internal use only");
+}
+
+void
+_PyThreadState_SetCurrent(PyThreadState *tstate)
 {
     _PyGILState_NoteThreadState(&tstate->interp->runtime->gilstate, tstate);
 }

Original file line number	Diff line number	Diff line change
`@@ -631,7 +631,7 @@ allocate_chunk(int size_in_bytes, _PyStackChunk* previous)`
`631`	`631`	`}`
`632`	`632`
`633`	`633`	`static PyThreadState *`
`634`		`-new_threadstate(PyInterpreterState *interp, int init)`
	`634`	`+new_threadstate(PyInterpreterState *interp)`
`635`	`635`	`{`
`636`	`636`	`_PyRuntimeState *runtime = interp->runtime;`
`637`	`637`	`PyThreadState tstate = (PyThreadState )PyMem_RawCalloc(1, sizeof(PyThreadState));`
`@@ -662,10 +662,6 @@ new_threadstate(PyInterpreterState *interp, int init)`
`662`	`662`	`tstate->datastack_top = &tstate->datastack_chunk->data[1];`
`663`	`663`	`tstate->datastack_limit = (PyObject *)(((char )tstate->datastack_chunk) + DATA_STACK_CHUNK_SIZE);`
`664`	`664`
`665`		`- if (init) {`
`666`		`- _PyThreadState_Init(tstate);`
`667`		`- }`
`668`		`-`
`669`	`665`	`HEAD_LOCK(runtime);`
`670`	`666`	`tstate->id = ++interp->threads.next_unique_id;`
`671`	`667`	`tstate->next = interp->threads.head;`
`@@ -680,17 +676,27 @@ new_threadstate(PyInterpreterState *interp, int init)`
`680`	`676`	`PyThreadState *`
`681`	`677`	`PyThreadState_New(PyInterpreterState *interp)`
`682`	`678`	`{`
`683`		`- return new_threadstate(interp, 1);`
	`679`	`+ PyThreadState *tstate = new_threadstate(interp);`
	`680`	`+ _PyThreadState_SetCurrent(tstate);`
	`681`	`+ return tstate;`
`684`	`682`	`}`
`685`	`683`
`686`	`684`	`PyThreadState *`
`687`	`685`	`_PyThreadState_Prealloc(PyInterpreterState *interp)`
`688`	`686`	`{`
`689`		`- return new_threadstate(interp, 0);`
	`687`	`+ return new_threadstate(interp);`
`690`	`688`	`}`
`691`	`689`
	`690`	`+// We keep this around for (accidental) stable ABI compatibility.`
	`691`	`+// Realisically, no extensions are using it.`
`692`	`692`	`void`
`693`	`693`	`_PyThreadState_Init(PyThreadState *tstate)`
	`694`	`+{`
	`695`	`+ Py_FatalError("_PyThreadState_Init() is for internal use only");`
	`696`	`+}`
	`697`	`+`
	`698`	`+void`
	`699`	`+_PyThreadState_SetCurrent(PyThreadState *tstate)`
`694`	`700`	`{`
`695`	`701`	`_PyGILState_NoteThreadState(&tstate->interp->runtime->gilstate, tstate);`
`696`	`702`	`}`