Move tstate_current out of _PyRuntimeState.gilstate.

ericsnowcurrently · ericsnowcurrently · commit 6281edb2c5d4 · 2023-01-19T08:38:58.000-07:00
diff --git a/Include/internal/pycore_pystate.h b/Include/internal/pycore_pystate.h
@@ -67,12 +67,12 @@ _Py_ThreadCanHandlePendingCalls(void)
 static inline PyThreadState*
 _PyRuntimeState_GetThreadState(_PyRuntimeState *runtime)
 {
-    return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->gilstate.tstate_current);
+    return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->tstate_current);
 }
 
 /* Get the current Python thread state.
 
-   Efficient macro reading directly the 'gilstate.tstate_current' atomic
+   Efficient macro reading directly the 'tstate_current' atomic
    variable. The macro is unsafe: it does not check for error and it can
    return NULL.
 
diff --git a/Include/internal/pycore_runtime.h b/Include/internal/pycore_runtime.h
@@ -41,9 +41,6 @@ struct _gilstate_runtime_state {
     /* bpo-26558: Flag to disable PyGILState_Check().
        If set to non-zero, PyGILState_Check() always return 1. */
     int check_enabled;
-    /* Assuming the current thread holds the GIL, this is the
-       PyThreadState for the current thread. */
-    _Py_atomic_address tstate_current;
     /* The single PyInterpreterState used by this process'
        GILState implementation
     */
@@ -124,6 +121,10 @@ typedef struct pyruntimestate {
 
     unsigned long main_thread;
 
+    /* Assuming the current thread holds the GIL, this is the
+       PyThreadState for the current thread. */
+    _Py_atomic_address tstate_current;
+
     PyWideStringList orig_argv;
 
     struct _parser_runtime_state parser;
diff --git a/Python/pystate.c b/Python/pystate.c
@@ -48,25 +48,22 @@ static inline PyThreadState *
 current_fast_get(_PyRuntimeState *runtime)
 {
     // The GIL must be held by the current thread.
-    return (PyThreadState*)_Py_atomic_load_relaxed(
-                &runtime->gilstate.tstate_current);
+    return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->tstate_current);
 }
 
 static inline void
 current_fast_set(_PyRuntimeState *runtime, PyThreadState *tstate)
 {
     // The GIL must be held by the current thread.
     assert(tstate != NULL);
-    _Py_atomic_store_relaxed(&runtime->gilstate.tstate_current,
-                             (uintptr_t)tstate);
+    _Py_atomic_store_relaxed(&runtime->tstate_current, (uintptr_t)tstate);
 }
 
 static inline void
 current_fast_clear(_PyRuntimeState *runtime)
 {
     // The GIL must be held by the current thread.
-    _Py_atomic_store_relaxed(&runtime->gilstate.tstate_current,
-                             (uintptr_t)NULL);
+    _Py_atomic_store_relaxed(&runtime->tstate_current, (uintptr_t)NULL);
 }
 
 

Original file line number	Diff line number	Diff line change
`@@ -67,12 +67,12 @@ _Py_ThreadCanHandlePendingCalls(void)`
`67`	`67`	`static inline PyThreadState*`
`68`	`68`	`_PyRuntimeState_GetThreadState(_PyRuntimeState *runtime)`
`69`	`69`	`{`
`70`		`- return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->gilstate.tstate_current);`
	`70`	`+ return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->tstate_current);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`/* Get the current Python thread state.`
`74`	`74`
`75`		`- Efficient macro reading directly the 'gilstate.tstate_current' atomic`
	`75`	`+ Efficient macro reading directly the 'tstate_current' atomic`
`76`	`76`	`variable. The macro is unsafe: it does not check for error and it can`
`77`	`77`	`return NULL.`
`78`	`78`
Original file line number	Diff line number	Diff line change
`@@ -48,25 +48,22 @@ static inline PyThreadState *`
`48`	`48`	`current_fast_get(_PyRuntimeState *runtime)`
`49`	`49`	`{`
`50`	`50`	`// The GIL must be held by the current thread.`
`51`		`- return (PyThreadState*)_Py_atomic_load_relaxed(`
`52`		`- &runtime->gilstate.tstate_current);`
	`51`	`+ return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->tstate_current);`
`53`	`52`	`}`
`54`	`53`
`55`	`54`	`static inline void`
`56`	`55`	`current_fast_set(_PyRuntimeState runtime, PyThreadState tstate)`
`57`	`56`	`{`
`58`	`57`	`// The GIL must be held by the current thread.`
`59`	`58`	`assert(tstate != NULL);`
`60`		`- _Py_atomic_store_relaxed(&runtime->gilstate.tstate_current,`
`61`		`- (uintptr_t)tstate);`
	`59`	`+ _Py_atomic_store_relaxed(&runtime->tstate_current, (uintptr_t)tstate);`
`62`	`60`	`}`
`63`	`61`
`64`	`62`	`static inline void`
`65`	`63`	`current_fast_clear(_PyRuntimeState *runtime)`
`66`	`64`	`{`
`67`	`65`	`// The GIL must be held by the current thread.`
`68`		`- _Py_atomic_store_relaxed(&runtime->gilstate.tstate_current,`
`69`		`- (uintptr_t)NULL);`
	`66`	`+ _Py_atomic_store_relaxed(&runtime->tstate_current, (uintptr_t)NULL);`
`70`	`67`	`}`
`71`	`68`
`72`	`69`