Finish migration to the new API.

Author: ZeroIntensity

Include/cpython/pystate.h

@@ -282,9 +282,11 @@ PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameFunc(
     PyInterpreterState *interp,
     _PyFrameEvalFunction eval_frame);
 
-/* Strong interpreter references */
+/* Interpreter locks */
 
 typedef uintptr_t PyInterpreterLock;
+typedef uintptr_t PyInterpreterView;
+
 
 PyAPI_FUNC(PyInterpreterLock) PyInterpreterLock_FromCurrent(void);
 PyAPI_FUNC(PyInterpreterLock) PyInterpreterLock_Copy(PyInterpreterLock lock);
@@ -294,7 +296,7 @@ PyAPI_FUNC(PyInterpreterLock) PyInterpreterLock_FromView(PyInterpreterView view)
 
 #define PyInterpreterLock_Release(lock) do {    \
     PyInterpreterLock_Release(lock);            \
-    ref = 0;                                    \
+    lock = 0;                                   \
 } while (0)
 
 /* Interpreter views */
@@ -304,8 +306,6 @@ typedef struct _PyInterpreterView {
     Py_ssize_t refcount;
 } _PyInterpreterView;
 
-typedef uintptr_t PyInterpreterView;
-
 PyAPI_FUNC(PyInterpreterView) PyInterpreterView_FromCurrent(void);
 PyAPI_FUNC(PyInterpreterView) PyInterpreterView_Copy(PyInterpreterView view);
 PyAPI_FUNC(void) PyInterpreterView_Close(PyInterpreterView view);
@@ -314,7 +314,7 @@ PyAPI_FUNC(PyInterpreterView) PyUnstable_InterpreterView_FromDefault(void);
 
 #define PyInterpreterView_Close(view) do {    \
     PyInterpreterView_Close(view);            \
-    ref = 0;                                  \
+    view = 0;                                 \
 } while (0)
 
 

Modules/_testcapimodule.c

@@ -2562,24 +2562,16 @@ toggle_reftrace_printer(PyObject *ob, PyObject *arg)
     Py_RETURN_NONE;
 }
 
-static PyInterpreterLock
-get_strong_ref(void)
-{
-    PyInterpreterLock ref;
-    if (PyInterpreterLock_FromCurrent(&ref) < 0) {
-        Py_FatalError("strong reference should not have failed");
-    }
-    return ref;
-}
-
 static void
-test_interp_ref_common(void)
+test_interp_locks_common(void)
 {
     PyInterpreterState *interp = PyInterpreterState_Get();
-    PyInterpreterLock ref = get_strong_ref();
+    PyInterpreterLock ref = PyInterpreterLock_FromCurrent();
+    assert(ref != 0);
     assert(PyInterpreterLock_GetInterpreter(ref) == interp);
 
     PyInterpreterLock ref_2 = PyInterpreterLock_Copy(ref);
+    assert(ref_2 != 0);
     assert(PyInterpreterLock_GetInterpreter(ref_2) == interp);
 
     // We can close the references in any order
@@ -2588,15 +2580,15 @@ test_interp_ref_common(void)
 }
 
 static PyObject *
-test_interpreter_refs(PyObject *self, PyObject *unused)
+test_interpreter_locks(PyObject *self, PyObject *unused)
 {
     // Test the main interpreter
-    test_interp_ref_common();
+    test_interp_locks_common();
 
     // Test a (legacy) subinterpreter
     PyThreadState *save_tstate = PyThreadState_Swap(NULL);
     PyThreadState *interp_tstate = Py_NewInterpreter();
-    test_interp_ref_common();
+    test_interp_locks_common();
     Py_EndInterpreter(interp_tstate);
 
     // Test an isolated subinterpreter
@@ -2612,7 +2604,7 @@ test_interpreter_refs(PyObject *self, PyObject *unused)
         return NULL;
     }
 
-    test_interp_ref_common();
+    test_interp_locks_common();
     Py_EndInterpreter(isolated_interp_tstate);
     PyThreadState_Swap(save_tstate);
     Py_RETURN_NONE;
@@ -2621,21 +2613,25 @@ test_interpreter_refs(PyObject *self, PyObject *unused)
 static PyObject *
 test_thread_state_ensure_nested(PyObject *self, PyObject *unused)
 {
-    PyInterpreterLock ref = get_strong_ref();
+    PyInterpreterLock lock = PyInterpreterLock_FromCurrent();
+    if (lock == 0) {
+        return NULL;
+    }
     PyThreadState *save_tstate = PyThreadState_Swap(NULL);
     assert(PyGILState_GetThisThreadState() == save_tstate);
-    PyThreadView refs[10];
+    PyThreadView thread_views[10];
 
     for (int i = 0; i < 10; ++i) {
         // Test reactivation of the detached tstate.
-        if (PyThreadState_Ensure(ref, &refs[i]) < 0) {
-            PyInterpreterLock_Release(ref);
+        thread_views[i] = PyThreadState_Ensure(lock);
+        if (thread_views[i] == 0) {
+            PyInterpreterLock_Release(lock);
             return PyErr_NoMemory();
         }
 
         // No new thread state should've been created.
         assert(PyThreadState_Get() == save_tstate);
-        PyThreadState_Release(refs[i]);
+        PyThreadState_Release(thread_views[i]);
     }
 
     assert(PyThreadState_GetUnchecked() == NULL);
@@ -2644,10 +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) {
-        if (PyThreadState_Ensure(ref, &refs[i]) < 0) {
+        thread_views[i] = PyThreadState_Ensure(lock);
+        if (thread_views[i] == 0) {
             // This will technically leak other thread states, but it doesn't
             // matter because this is a test.
-            PyInterpreterLock_Release(ref);
+            PyInterpreterLock_Release(lock);
             return PyErr_NoMemory();
         }
 
@@ -2656,23 +2653,23 @@ test_thread_state_ensure_nested(PyObject *self, PyObject *unused)
 
     for (int i = 0; i < 10; ++i) {
         assert(PyThreadState_Get() == save_tstate);
-        PyThreadState_Release(refs[i]);
+        PyThreadState_Release(thread_views[i]);
     }
 
     assert(PyThreadState_GetUnchecked() == NULL);
-    PyInterpreterLock_Release(ref);
+    PyInterpreterLock_Release(lock);
     PyThreadState_Swap(save_tstate);
     Py_RETURN_NONE;
 }
 
 static PyObject *
 test_thread_state_ensure_crossinterp(PyObject *self, PyObject *unused)
 {
-    PyInterpreterLock ref = get_strong_ref();
+    PyInterpreterLock lock = PyInterpreterLock_FromCurrent();
     PyThreadState *save_tstate = PyThreadState_Swap(NULL);
     PyThreadState *interp_tstate = Py_NewInterpreter();
     if (interp_tstate == NULL) {
-        PyInterpreterLock_Release(ref);
+        PyInterpreterLock_Release(lock);
         return PyErr_NoMemory();
     }
 
@@ -2689,79 +2686,69 @@ test_thread_state_ensure_crossinterp(PyObject *self, PyObject *unused)
        interp = interpreters.create()
        interp.exec(some_func)
        */
-    PyThreadView thread_ref;
-    PyThreadView other_thread_ref;
-    if (PyThreadState_Ensure(ref, &thread_ref) < 0) {
-        PyInterpreterLock_Release(ref);
+    PyThreadView thread_view = PyThreadState_Ensure(lock);
+    if (thread_view == 0) {
+        PyInterpreterLock_Release(lock);
         return PyErr_NoMemory();
     }
 
     PyThreadState *ensured_tstate = PyThreadState_Get();
     assert(ensured_tstate != save_tstate);
-    assert(PyInterpreterState_Get() == PyInterpreterLock_GetInterpreter(ref));
+    assert(PyInterpreterState_Get() == PyInterpreterLock_GetInterpreter(lock));
     assert(PyGILState_GetThisThreadState() == ensured_tstate);
 
     // Now though, we should reactivate the thread state
-    if (PyThreadState_Ensure(ref, &other_thread_ref) < 0) {
-        PyInterpreterLock_Release(ref);
+    PyThreadView other_thread_view = PyThreadState_Ensure(lock);
+    if (other_thread_view == 0) {
+        PyThreadState_Release(thread_view);
+        PyInterpreterLock_Release(lock);
         return PyErr_NoMemory();
     }
 
     assert(PyThreadState_Get() == ensured_tstate);
-    PyThreadState_Release(other_thread_ref);
+    PyThreadState_Release(other_thread_view);
 
     // Ensure that we're restoring the prior thread state
-    PyThreadState_Release(thread_ref);
+    PyThreadState_Release(thread_view);
     assert(PyThreadState_Get() == interp_tstate);
     assert(PyGILState_GetThisThreadState() == interp_tstate);
 
     PyThreadState_Swap(interp_tstate);
     Py_EndInterpreter(interp_tstate);
 
-    PyInterpreterLock_Release(ref);
+    PyInterpreterLock_Release(lock);
     PyThreadState_Swap(save_tstate);
     Py_RETURN_NONE;
 }
 
 static PyObject *
-test_weak_interpreter_ref_after_shutdown(PyObject *self, PyObject *unused)
+test_interp_view_after_shutdown(PyObject *self, PyObject *unused)
 {
     PyThreadState *save_tstate = PyThreadState_Swap(NULL);
-    PyInterpreterView wref;
     PyThreadState *interp_tstate = Py_NewInterpreter();
     if (interp_tstate == NULL) {
         return PyErr_NoMemory();
     }
 
-    int res = PyInterpreterView_FromCurrent(&wref);
-    (void)res;
-    assert(res == 0);
+    PyInterpreterView view = PyInterpreterView_FromCurrent();
+    if (view == 0) {
+        return PyErr_NoMemory();
+    }
 
-    // As a sanity check, ensure that the weakref actually works
-    PyInterpreterLock ref;
-    res = PyInterpreterLock_FromView(wref, &ref);
-    assert(res == 0);
-    PyInterpreterLock_Release(ref);
+    // As a sanity check, ensure that the view actually works
+    PyInterpreterLock lock = PyInterpreterLock_FromView(view);
+    PyInterpreterLock_Release(lock);
 
-    // Now, destroy the interpreter and try to acquire a weak reference.
+    // Now, destroy the interpreter and try to acquire a lock from a view.
     // It should fail.
     Py_EndInterpreter(interp_tstate);
-    res = PyInterpreterLock_FromView(wref, &ref);
-    assert(res == -1);
+    lock = PyInterpreterLock_FromView(view);
+    assert(lock == 0);
 
     PyThreadState_Swap(save_tstate);
     Py_RETURN_NONE;
 }
 
-static PyObject *
-foo(PyObject *self, PyObject *foo)
-{
-    PyInterpreterLock ref;
-    PyInterpreterLock_FromCurrent(&ref);
-    PyInterpreterLock_Release(ref);
-    Py_RETURN_NONE;
-}
-
 static PyMethodDef TestMethods[] = {
     {"set_errno",               set_errno,                       METH_VARARGS},
     {"test_config",             test_config,                     METH_NOARGS},
@@ -2856,11 +2843,10 @@ static PyMethodDef TestMethods[] = {
     {"test_atexit", test_atexit, METH_NOARGS},
     {"code_offset_to_line", _PyCFunction_CAST(code_offset_to_line), METH_FASTCALL},
     {"toggle_reftrace_printer", toggle_reftrace_printer, METH_O},
-    {"test_interpreter_refs", test_interpreter_refs, METH_NOARGS},
+    {"test_interpreter_lock", test_interpreter_locks, METH_NOARGS},
     {"test_thread_state_ensure_nested", test_thread_state_ensure_nested, METH_NOARGS},
     {"test_thread_state_ensure_crossinterp", test_thread_state_ensure_crossinterp, METH_NOARGS},
-    {"test_weak_interpreter_ref_after_shutdown", test_weak_interpreter_ref_after_shutdown, METH_NOARGS},
-    {"foo", foo, METH_NOARGS},
+    {"test_interp_view_after_shutdown", test_interp_view_after_shutdown, METH_NOARGS},
     {NULL, NULL} /* sentinel */
 };
 

Modules/_testinternalcapi.c

@@ -2418,59 +2418,57 @@ set_vectorcall_nop(PyObject *self, PyObject *func)
     Py_RETURN_NONE;
 }
 
-#define NUM_REFS 100
+#define NUM_LOCKS 100
 
 static PyObject *
-test_interp_refcount(PyObject *self, PyObject *unused)
+test_interp_lock_countdown(PyObject *self, PyObject *unused)
 {
     PyInterpreterState *interp = PyInterpreterState_Get();
     assert(_PyInterpreterState_LockCountdown(interp) == 0);
-    PyInterpreterLock refs[NUM_REFS];
-    for (int i = 0; i < NUM_REFS; ++i) {
-        int res = PyInterpreterLock_FromCurrent(&refs[i]);
-        (void)res;
-        assert(res == 0);
+    PyInterpreterLock locks[NUM_LOCKS];
+    for (int i = 0; i < NUM_LOCKS; ++i) {
+        locks[i] = PyInterpreterLock_FromCurrent();
+        assert(locks[i] != 0);
         assert(_PyInterpreterState_LockCountdown(interp) == i + 1);
     }
 
-    for (int i = 0; i < NUM_REFS; ++i) {
-        PyInterpreterLock_Release(refs[i]);
-        assert(_PyInterpreterState_LockCountdown(interp) == (NUM_REFS - i - 1));
+    for (int i = 0; i < NUM_LOCKS; ++i) {
+        PyInterpreterLock_Release(locks[i]);
+        assert(_PyInterpreterState_LockCountdown(interp) == (NUM_LOCKS - i - 1));
     }
 
     Py_RETURN_NONE;
 }
 
 static PyObject *
-test_interp_weakref_incref(PyObject *self, PyObject *unused)
+test_interp_view_countdown(PyObject *self, PyObject *unused)
 {
     PyInterpreterState *interp = PyInterpreterState_Get();
-    PyInterpreterView wref;
-    if (PyInterpreterView_FromCurrent(&wref) < 0) {
+    PyInterpreterView view = PyInterpreterView_FromCurrent();
+    if (view == 0) {
         return NULL;
     }
     assert(_PyInterpreterState_LockCountdown(interp) == 0);
 
-    PyInterpreterLock refs[NUM_REFS];
+    PyInterpreterLock locks[NUM_LOCKS];
 
-    for (int i = 0; i < NUM_REFS; ++i) {
-        int res = PyInterpreterLock_FromView(wref, &refs[i]);
-        (void)res;
-        assert(res == 0);
-        assert(PyInterpreterLock_GetInterpreter(refs[i]) == interp);
+    for (int i = 0; i < NUM_LOCKS; ++i) {
+        locks[i] = PyInterpreterLock_FromView(view);
+        assert(locks[i] != 0);
+        assert(PyInterpreterLock_GetInterpreter(locks[i]) == interp);
         assert(_PyInterpreterState_LockCountdown(interp) == i + 1);
     }
 
-    for (int i = 0; i < NUM_REFS; ++i) {
-        PyInterpreterLock_Release(refs[i]);
-        assert(_PyInterpreterState_LockCountdown(interp) == (NUM_REFS - i - 1));
+    for (int i = 0; i < NUM_LOCKS; ++i) {
+        PyInterpreterLock_Release(locks[i]);
+        assert(_PyInterpreterState_LockCountdown(interp) == (NUM_LOCKS - i - 1));
     }
 
-    PyInterpreterView_Close(wref);
+    PyInterpreterView_Close(view);
     Py_RETURN_NONE;
 }
 
-#undef NUM_REFS
+#undef NUM_LOCKS
 
 static PyMethodDef module_functions[] = {
     {"get_configs", get_configs, METH_NOARGS},
@@ -2581,8 +2579,8 @@ static PyMethodDef module_functions[] = {
 #endif
     {"set_vectorcall_nop", set_vectorcall_nop, METH_O},
     {"simple_pending_call", simple_pending_call, METH_O},
-    {"test_interp_refcount", test_interp_refcount, METH_NOARGS},
-    {"test_interp_weakref_incref", test_interp_weakref_incref, METH_NOARGS},
+    {"test_interp_lock_countdown", test_interp_lock_countdown, METH_NOARGS},
+    {"test_interp_view_countdown", test_interp_view_countdown, METH_NOARGS},
     {NULL, NULL} /* sentinel */
 };