Update to use new "PyInterpreterGuard" names.

ZeroIntensity · ZeroIntensity · commit 4371c15607e5 · 2025-10-26T21:49:26.000-04:00
diff --git a/Include/cpython/pystate.h b/Include/cpython/pystate.h
@@ -284,20 +284,22 @@ PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameFunc(
 
 /* Interpreter locks */
 
-typedef uintptr_t PyInterpreterLock;
+typedef uintptr_t PyInterpreterGuard;
 typedef uintptr_t PyInterpreterView;
 
 
-PyAPI_FUNC(PyInterpreterLock) PyInterpreterLock_FromCurrent(void);
-PyAPI_FUNC(PyInterpreterLock) PyInterpreterLock_Copy(PyInterpreterLock lock);
-PyAPI_FUNC(void) PyInterpreterLock_Release(PyInterpreterLock lock);
-PyAPI_FUNC(PyInterpreterState *) PyInterpreterLock_GetInterpreter(PyInterpreterLock lock);
-PyAPI_FUNC(PyInterpreterLock) PyInterpreterLock_FromView(PyInterpreterView view);
+PyAPI_FUNC(PyInterpreterGuard) PyInterpreterGuard_FromCurrent(void);
+PyAPI_FUNC(PyInterpreterGuard) PyInterpreterGuard_Copy(PyInterpreterGuard guard);
+PyAPI_FUNC(void) PyInterpreterGuard_Release(PyInterpreterGuard guard);
+PyAPI_FUNC(PyInterpreterState *) PyInterpreterGuard_GetInterpreter(PyInterpreterGuard guard);
+PyAPI_FUNC(PyInterpreterGuard) PyInterpreterGuard_FromView(PyInterpreterView view);
 
-#define PyInterpreterLock_Release(lock) do {    \
-    PyInterpreterLock_Release(lock);            \
-    lock = 0;                                   \
+#ifdef Py_DEBUG
+#define PyInterpreterGuard_Release(guard) do {    \
+    PyInterpreterGuard_Release(guard);            \
+    guard = 0;                                    \
 } while (0)
+#endif
 
 /* Interpreter views */
 
@@ -312,16 +314,17 @@ PyAPI_FUNC(void) PyInterpreterView_Close(PyInterpreterView view);
 PyAPI_FUNC(PyInterpreterView) PyUnstable_InterpreterView_FromDefault(void);
 
 
+#ifdef Py_DEBUG
 #define PyInterpreterView_Close(view) do {    \
     PyInterpreterView_Close(view);            \
     view = 0;                                 \
 } while (0)
-
+#endif
 
 /* Thread views */
 
 typedef uintptr_t PyThreadView;
 
-PyAPI_FUNC(PyThreadView) PyThreadState_Ensure(PyInterpreterLock lock);
+PyAPI_FUNC(PyThreadView) PyThreadState_Ensure(PyInterpreterGuard guard);
 
 PyAPI_FUNC(void) PyThreadState_Release(PyThreadView thread_ref);
diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c
@@ -2563,32 +2563,32 @@ toggle_reftrace_printer(PyObject *ob, PyObject *arg)
 }
 
 static void
-test_interp_locks_common(void)
+test_interp_guards_common(void)
 {
     PyInterpreterState *interp = PyInterpreterState_Get();
-    PyInterpreterLock lock = PyInterpreterLock_FromCurrent();
-    assert(lock != 0);
-    assert(PyInterpreterLock_GetInterpreter(lock) == interp);
+    PyInterpreterGuard guard = PyInterpreterGuard_FromCurrent();
+    assert(guard != 0);
+    assert(PyInterpreterGuard_GetInterpreter(guard) == interp);
 
-    PyInterpreterLock lock_2 = PyInterpreterLock_Copy(lock);
-    assert(lock_2 != 0);
-    assert(PyInterpreterLock_GetInterpreter(lock_2) == interp);
+    PyInterpreterGuard guard_2 = PyInterpreterGuard_Copy(guard);
+    assert(guard_2 != 0);
+    assert(PyInterpreterGuard_GetInterpreter(guard_2) == interp);
 
     // We can close the references in any order
-    PyInterpreterLock_Release(lock_2);
-    PyInterpreterLock_Release(lock);
+    PyInterpreterGuard_Release(guard_2);
+    PyInterpreterGuard_Release(guard);
 }
 
 static PyObject *
 test_interpreter_locks(PyObject *self, PyObject *unused)
 {
     // Test the main interpreter
-    test_interp_locks_common();
+    test_interp_guards_common();
 
     // Test a (legacy) subinterpreter
     PyThreadState *save_tstate = PyThreadState_Swap(NULL);
     PyThreadState *interp_tstate = Py_NewInterpreter();
-    test_interp_locks_common();
+    test_interp_guards_common();
     Py_EndInterpreter(interp_tstate);
 
     // Test an isolated subinterpreter
@@ -2604,7 +2604,7 @@ test_interpreter_locks(PyObject *self, PyObject *unused)
         return NULL;
     }
 
-    test_interp_locks_common();
+    test_interp_guards_common();
     Py_EndInterpreter(isolated_interp_tstate);
     PyThreadState_Swap(save_tstate);
     Py_RETURN_NONE;
@@ -2613,8 +2613,8 @@ test_interpreter_locks(PyObject *self, PyObject *unused)
 static PyObject *
 test_thread_state_ensure_nested(PyObject *self, PyObject *unused)
 {
-    PyInterpreterLock lock = PyInterpreterLock_FromCurrent();
-    if (lock == 0) {
+    PyInterpreterGuard guard = PyInterpreterGuard_FromCurrent();
+    if (guard == 0) {
         return NULL;
     }
     PyThreadState *save_tstate = PyThreadState_Swap(NULL);
@@ -2623,9 +2623,9 @@ test_thread_state_ensure_nested(PyObject *self, PyObject *unused)
 
     for (int i = 0; i < 10; ++i) {
         // Test reactivation of the detached tstate.
-        thread_views[i] = PyThreadState_Ensure(lock);
+        thread_views[i] = PyThreadState_Ensure(guard);
         if (thread_views[i] == 0) {
-            PyInterpreterLock_Release(lock);
+            PyInterpreterGuard_Release(guard);
             return PyErr_NoMemory();
         }
 
@@ -2640,11 +2640,11 @@ test_thread_state_ensure_nested(PyObject *self, PyObject *unused)
     // If the (detached) gilstate matches the interpreter, then it shouldn't
     // create a new thread state.
     for (int i = 0; i < 10; ++i) {
-        thread_views[i] = PyThreadState_Ensure(lock);
+        thread_views[i] = PyThreadState_Ensure(guard);
         if (thread_views[i] == 0) {
             // This will technically leak other thread states, but it doesn't
             // matter because this is a test.
-            PyInterpreterLock_Release(lock);
+            PyInterpreterGuard_Release(guard);
             return PyErr_NoMemory();
         }
 
@@ -2657,19 +2657,19 @@ test_thread_state_ensure_nested(PyObject *self, PyObject *unused)
     }
 
     assert(PyThreadState_GetUnchecked() == NULL);
-    PyInterpreterLock_Release(lock);
+    PyInterpreterGuard_Release(guard);
     PyThreadState_Swap(save_tstate);
     Py_RETURN_NONE;
 }
 
 static PyObject *
 test_thread_state_ensure_crossinterp(PyObject *self, PyObject *unused)
 {
-    PyInterpreterLock lock = PyInterpreterLock_FromCurrent();
+    PyInterpreterGuard guard = PyInterpreterGuard_FromCurrent();
     PyThreadState *save_tstate = PyThreadState_Swap(NULL);
     PyThreadState *interp_tstate = Py_NewInterpreter();
     if (interp_tstate == NULL) {
-        PyInterpreterLock_Release(lock);
+        PyInterpreterGuard_Release(guard);
         return PyErr_NoMemory();
     }
 
@@ -2686,22 +2686,22 @@ test_thread_state_ensure_crossinterp(PyObject *self, PyObject *unused)
        interp = interpreters.create()
        interp.exec(some_func)
        */
-    PyThreadView thread_view = PyThreadState_Ensure(lock);
+    PyThreadView thread_view = PyThreadState_Ensure(guard);
     if (thread_view == 0) {
-        PyInterpreterLock_Release(lock);
+        PyInterpreterGuard_Release(guard);
         return PyErr_NoMemory();
     }
 
     PyThreadState *ensured_tstate = PyThreadState_Get();
     assert(ensured_tstate != save_tstate);
-    assert(PyInterpreterState_Get() == PyInterpreterLock_GetInterpreter(lock));
+    assert(PyInterpreterState_Get() == PyInterpreterGuard_GetInterpreter(guard));
     assert(PyGILState_GetThisThreadState() == ensured_tstate);
 
     // Now though, we should reactivate the thread state
-    PyThreadView other_thread_view = PyThreadState_Ensure(lock);
+    PyThreadView other_thread_view = PyThreadState_Ensure(guard);
     if (other_thread_view == 0) {
         PyThreadState_Release(thread_view);
-        PyInterpreterLock_Release(lock);
+        PyInterpreterGuard_Release(guard);
         return PyErr_NoMemory();
     }
 
@@ -2716,7 +2716,7 @@ test_thread_state_ensure_crossinterp(PyObject *self, PyObject *unused)
     PyThreadState_Swap(interp_tstate);
     Py_EndInterpreter(interp_tstate);
 
-    PyInterpreterLock_Release(lock);
+    PyInterpreterGuard_Release(guard);
     PyThreadState_Swap(save_tstate);
     Py_RETURN_NONE;
 }
@@ -2736,14 +2736,14 @@ test_interp_view_after_shutdown(PyObject *self, PyObject *unused)
     }
 
     // As a sanity check, ensure that the view actually works
-    PyInterpreterLock lock = PyInterpreterLock_FromView(view);
-    PyInterpreterLock_Release(lock);
+    PyInterpreterGuard guard = PyInterpreterGuard_FromView(view);
+    PyInterpreterGuard_Release(guard);
 
     // Now, destroy the interpreter and try to acquire a lock from a view.
     // It should fail.
     Py_EndInterpreter(interp_tstate);
-    lock = PyInterpreterLock_FromView(view);
-    assert(lock == 0);
+    guard = PyInterpreterGuard_FromView(view);
+    assert(guard == 0);
 
     PyThreadState_Swap(save_tstate);
     Py_RETURN_NONE;
diff --git a/Modules/_testinternalcapi.c b/Modules/_testinternalcapi.c
@@ -2418,23 +2418,23 @@ set_vectorcall_nop(PyObject *self, PyObject *func)
     Py_RETURN_NONE;
 }
 
-#define NUM_LOCKS 100
+#define NUM_GUARDS 100
 
 static PyObject *
-test_interp_lock_countdown(PyObject *self, PyObject *unused)
+test_interp_guard_countdown(PyObject *self, PyObject *unused)
 {
     PyInterpreterState *interp = PyInterpreterState_Get();
     assert(_PyInterpreterState_LockCountdown(interp) == 0);
-    PyInterpreterLock locks[NUM_LOCKS];
-    for (int i = 0; i < NUM_LOCKS; ++i) {
-        locks[i] = PyInterpreterLock_FromCurrent();
-        assert(locks[i] != 0);
+    PyInterpreterGuard guards[NUM_GUARDS];
+    for (int i = 0; i < NUM_GUARDS; ++i) {
+        guards[i] = PyInterpreterGuard_FromCurrent();
+        assert(guards[i] != 0);
         assert(_PyInterpreterState_LockCountdown(interp) == i + 1);
     }
 
-    for (int i = 0; i < NUM_LOCKS; ++i) {
-        PyInterpreterLock_Release(locks[i]);
-        assert(_PyInterpreterState_LockCountdown(interp) == (NUM_LOCKS - i - 1));
+    for (int i = 0; i < NUM_GUARDS; ++i) {
+        PyInterpreterGuard_Release(guards[i]);
+        assert(_PyInterpreterState_LockCountdown(interp) == (NUM_GUARDS - i - 1));
     }
 
     Py_RETURN_NONE;
@@ -2450,18 +2450,18 @@ test_interp_view_countdown(PyObject *self, PyObject *unused)
     }
     assert(_PyInterpreterState_LockCountdown(interp) == 0);
 
-    PyInterpreterLock locks[NUM_LOCKS];
+    PyInterpreterGuard guards[NUM_GUARDS];
 
-    for (int i = 0; i < NUM_LOCKS; ++i) {
-        locks[i] = PyInterpreterLock_FromView(view);
-        assert(locks[i] != 0);
-        assert(PyInterpreterLock_GetInterpreter(locks[i]) == interp);
+    for (int i = 0; i < NUM_GUARDS; ++i) {
+        guards[i] = PyInterpreterGuard_FromView(view);
+        assert(guards[i] != 0);
+        assert(PyInterpreterGuard_GetInterpreter(guards[i]) == interp);
         assert(_PyInterpreterState_LockCountdown(interp) == i + 1);
     }
 
-    for (int i = 0; i < NUM_LOCKS; ++i) {
-        PyInterpreterLock_Release(locks[i]);
-        assert(_PyInterpreterState_LockCountdown(interp) == (NUM_LOCKS - i - 1));
+    for (int i = 0; i < NUM_GUARDS; ++i) {
+        PyInterpreterGuard_Release(guards[i]);
+        assert(_PyInterpreterState_LockCountdown(interp) == (NUM_GUARDS - i - 1));
     }
 
     PyInterpreterView_Close(view);
@@ -2579,7 +2579,7 @@ static PyMethodDef module_functions[] = {
 #endif
     {"simple_pending_call", simple_pending_call, METH_O},
     {"set_vectorcall_nop", set_vectorcall_nop, METH_O},
-    {"test_interp_lock_countdown", test_interp_lock_countdown, METH_NOARGS},
+    {"test_interp_guard_countdown", test_interp_guard_countdown, METH_NOARGS},
     {"test_interp_view_countdown", test_interp_view_countdown, METH_NOARGS},
     {NULL, NULL} /* sentinel */
 };
diff --git a/Programs/_testembed.c b/Programs/_testembed.c
@@ -2319,7 +2319,7 @@ const char *THREAD_CODE = \
     "fib(10)";
 
 typedef struct {
-    PyInterpreterLock lock;
+    PyInterpreterGuard guard;
     int done;
 } ThreadData;
 
@@ -2328,11 +2328,11 @@ do_tstate_ensure(void *arg)
 {
     ThreadData *data = (ThreadData *)arg;
     PyThreadView refs[4];
-    refs[0] = PyThreadState_Ensure(data->lock);
-    refs[1] = PyThreadState_Ensure(data->lock);
-    refs[2] = PyThreadState_Ensure(data->lock);
+    refs[0] = PyThreadState_Ensure(data->guard);
+    refs[1] = PyThreadState_Ensure(data->guard);
+    refs[2] = PyThreadState_Ensure(data->guard);
     PyGILState_STATE gstate = PyGILState_Ensure();
-    refs[3] = PyThreadState_Ensure(data->lock);
+    refs[3] = PyThreadState_Ensure(data->guard);
     assert(refs[0] != 0);
     assert(refs[1] != 0);
     assert(refs[2] != 0);
@@ -2344,7 +2344,7 @@ do_tstate_ensure(void *arg)
     PyThreadState_Release(refs[2]);
     PyThreadState_Release(refs[1]);
     PyThreadState_Release(refs[0]);
-    PyInterpreterLock_Release(data->lock);
+    PyInterpreterGuard_Release(data->guard);
     data->done = 1;
 }
 
@@ -2354,17 +2354,17 @@ test_thread_state_ensure(void)
     _testembed_initialize();
     PyThread_handle_t handle;
     PyThread_ident_t ident;
-    PyInterpreterLock ref = PyInterpreterLock_FromCurrent();
-    if (ref == 0) {
+    PyInterpreterGuard guard = PyInterpreterGuard_FromCurrent();
+    if (guard == 0) {
         return -1;
     };
-    ThreadData data = { ref };
+    ThreadData data = { guard };
     if (PyThread_start_joinable_thread(do_tstate_ensure, &data,
                                        &ident, &handle) < 0) {
-        PyInterpreterLock_Release(ref);
+        PyInterpreterGuard_Release(guard);
         return -1;
     }
-    // We hold a strong interpreter reference, so we don't
+    // We hold an interpreter guard, so we don't
     // have to worry about the interpreter shutting down before
     // we finalize.
     Py_Finalize();
@@ -2381,15 +2381,15 @@ test_main_interpreter_view(void)
     PyInterpreterView view = PyUnstable_InterpreterView_FromDefault();
     assert(view != 0);
 
-    PyInterpreterLock lock = PyInterpreterLock_FromView(view);
-    assert(lock != 0);
-    PyInterpreterLock_Release(lock);
+    PyInterpreterGuard guard = PyInterpreterGuard_FromView(view);
+    assert(guard != 0);
+    PyInterpreterGuard_Release(guard);
 
     Py_Finalize();
 
     // We shouldn't be able to get locks for the interpreter now
-    lock = PyInterpreterLock_FromView(view);
-    assert(lock == 0);
+    guard = PyInterpreterGuard_FromView(view);
+    assert(guard == 0);
 
     PyInterpreterView_Close(view);
 
diff --git a/Python/pystate.c b/Python/pystate.c
