[pull] main from python:main

Include/datetime.h

@@ -1,8 +1,8 @@
 /*  datetime.h
  */
 #ifndef Py_LIMITED_API
-#ifndef DATETIME_H
-#define DATETIME_H
+#ifndef Py_DATETIME_H
+#define Py_DATETIME_H
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -263,5 +263,5 @@ static PyDateTime_CAPI *PyDateTimeAPI = NULL;
 #ifdef __cplusplus
 }
 #endif
-#endif
+#endif /* !Py_DATETIME_H */
 #endif /* !Py_LIMITED_API */

Include/internal/pycore_code.h

@@ -311,8 +311,8 @@ PyAPI_FUNC(void) _Py_Specialize_LoadGlobal(PyObject *globals, PyObject *builtins
                                       _Py_CODEUNIT *instr, PyObject *name);
 PyAPI_FUNC(void) _Py_Specialize_StoreSubscr(_PyStackRef container, _PyStackRef sub,
                                        _Py_CODEUNIT *instr);
-PyAPI_FUNC(void) _Py_Specialize_Call(_PyStackRef callable, _Py_CODEUNIT *instr,
-                                int nargs);
+PyAPI_FUNC(void) _Py_Specialize_Call(_PyStackRef callable, _PyStackRef self_or_null,
+                                _Py_CODEUNIT *instr, int nargs);
 PyAPI_FUNC(void) _Py_Specialize_CallKw(_PyStackRef callable, _Py_CODEUNIT *instr,
                                   int nargs);
 PyAPI_FUNC(void) _Py_Specialize_BinaryOp(_PyStackRef lhs, _PyStackRef rhs, _Py_CODEUNIT *instr,

Lib/test/test_opcache.py

@@ -1872,6 +1872,33 @@ def for_iter_generator():
         self.assert_specialized(for_iter_generator, "FOR_ITER_GEN")
         self.assert_no_opcode(for_iter_generator, "FOR_ITER")
 
+    @cpython_only
+    @requires_specialization_ft
+    def test_call_list_append(self):
+        # gh-141367: only exact lists should use
+        # CALL_LIST_APPEND instruction after specialization.
+
+        r = range(_testinternalcapi.SPECIALIZATION_THRESHOLD)
+
+        def list_append(l):
+            for _ in r:
+                l.append(1)
+
+        list_append([])
+        self.assert_specialized(list_append, "CALL_LIST_APPEND")
+        self.assert_no_opcode(list_append, "CALL_METHOD_DESCRIPTOR_O")
+        self.assert_no_opcode(list_append, "CALL")
+
+        def my_list_append(l):
+            for _ in r:
+                l.append(1)
+
+        class MyList(list): pass
+        my_list_append(MyList())
+        self.assert_specialized(my_list_append, "CALL_METHOD_DESCRIPTOR_O")
+        self.assert_no_opcode(my_list_append, "CALL_LIST_APPEND")
+        self.assert_no_opcode(my_list_append, "CALL")
+
 
 if __name__ == "__main__":
     unittest.main()

Misc/NEWS.d/next/Core_and_Builtins/2025-11-11-13-40-45.gh-issue-141367.I5KY7F.rst

@@ -0,0 +1,2 @@
+Specialize ``CALL_LIST_APPEND`` instruction only for lists, not for list
+subclasses, to avoid unnecessary deopt. Patch by Mikhail Efimov.

Misc/NEWS.d/next/Core_and_Builtins/2025-11-14-16-25-15.gh-issue-114203.n3tlQO.rst

@@ -0,0 +1 @@
+Skip locking if object is already locked by two-mutex critical section.

Modules/_testinternalcapi/test_critical_sections.c

@@ -284,10 +284,111 @@ test_critical_sections_gc(PyObject *self, PyObject *Py_UNUSED(args))
 
 #endif
 
+#ifdef Py_GIL_DISABLED
+
+static PyObject *
+test_critical_section1_reacquisition(PyObject *self, PyObject *Py_UNUSED(args))
+{
+    PyObject *a = PyDict_New();
+    assert(a != NULL);
+
+    PyCriticalSection cs1, cs2;
+    // First acquisition of critical section on object locks it
+    PyCriticalSection_Begin(&cs1, a);
+    assert(PyMutex_IsLocked(&a->ob_mutex));
+    assert(_PyCriticalSection_IsActive(PyThreadState_GET()->critical_section));
+    assert(_PyThreadState_GET()->critical_section == (uintptr_t)&cs1);
+    // Attempting to re-acquire critical section on same object which
+    // is already locked by top-most critical section is a no-op.
+    PyCriticalSection_Begin(&cs2, a);
+    assert(PyMutex_IsLocked(&a->ob_mutex));
+    assert(_PyCriticalSection_IsActive(PyThreadState_GET()->critical_section));
+    assert(_PyThreadState_GET()->critical_section == (uintptr_t)&cs1);
+    // Releasing second critical section is a no-op.
+    PyCriticalSection_End(&cs2);
+    assert(PyMutex_IsLocked(&a->ob_mutex));
+    assert(_PyCriticalSection_IsActive(PyThreadState_GET()->critical_section));
+    assert(_PyThreadState_GET()->critical_section == (uintptr_t)&cs1);
+    // Releasing first critical section unlocks the object
+    PyCriticalSection_End(&cs1);
+    assert(!PyMutex_IsLocked(&a->ob_mutex));
+
+    Py_DECREF(a);
+    Py_RETURN_NONE;
+}
+
+static PyObject *
+test_critical_section2_reacquisition(PyObject *self, PyObject *Py_UNUSED(args))
+{
+    PyObject *a = PyDict_New();
+    assert(a != NULL);
+    PyObject *b = PyDict_New();
+    assert(b != NULL);
+
+    PyCriticalSection2 cs;
+    // First acquisition of critical section on objects locks them
+    PyCriticalSection2_Begin(&cs, a, b);
+    assert(PyMutex_IsLocked(&a->ob_mutex));
+    assert(PyMutex_IsLocked(&b->ob_mutex));
+    assert(_PyCriticalSection_IsActive(PyThreadState_GET()->critical_section));
+    assert((_PyThreadState_GET()->critical_section &
+                  ~_Py_CRITICAL_SECTION_MASK) == (uintptr_t)&cs);
+
+    // Attempting to re-acquire critical section on either of two
+    // objects already locked by top-most critical section is a no-op.
+
+    // Check re-acquiring on first object
+    PyCriticalSection a_cs;
+    PyCriticalSection_Begin(&a_cs, a);
+    assert(PyMutex_IsLocked(&a->ob_mutex));
+    assert(PyMutex_IsLocked(&b->ob_mutex));
+    assert(_PyCriticalSection_IsActive(PyThreadState_GET()->critical_section));
+    assert((_PyThreadState_GET()->critical_section &
+                  ~_Py_CRITICAL_SECTION_MASK) == (uintptr_t)&cs);
+    // Releasing critical section on either object is a no-op.
+    PyCriticalSection_End(&a_cs);
+    assert(PyMutex_IsLocked(&a->ob_mutex));
+    assert(PyMutex_IsLocked(&b->ob_mutex));
+    assert(_PyCriticalSection_IsActive(PyThreadState_GET()->critical_section));
+    assert((_PyThreadState_GET()->critical_section &
+                  ~_Py_CRITICAL_SECTION_MASK) == (uintptr_t)&cs);
+
+    // Check re-acquiring on second object
+    PyCriticalSection b_cs;
+    PyCriticalSection_Begin(&b_cs, b);
+    assert(PyMutex_IsLocked(&a->ob_mutex));
+    assert(PyMutex_IsLocked(&b->ob_mutex));
+    assert(_PyCriticalSection_IsActive(PyThreadState_GET()->critical_section));
+    assert((_PyThreadState_GET()->critical_section &
+                  ~_Py_CRITICAL_SECTION_MASK) == (uintptr_t)&cs);
+    // Releasing critical section on either object is a no-op.
+    PyCriticalSection_End(&b_cs);
+    assert(PyMutex_IsLocked(&a->ob_mutex));
+    assert(PyMutex_IsLocked(&b->ob_mutex));
+    assert(_PyCriticalSection_IsActive(PyThreadState_GET()->critical_section));
+    assert((_PyThreadState_GET()->critical_section &
+                  ~_Py_CRITICAL_SECTION_MASK) == (uintptr_t)&cs);
+
+    // Releasing critical section on both objects unlocks them
+    PyCriticalSection2_End(&cs);
+    assert(!PyMutex_IsLocked(&a->ob_mutex));
+    assert(!PyMutex_IsLocked(&b->ob_mutex));
+
+    Py_DECREF(a);
+    Py_DECREF(b);
+    Py_RETURN_NONE;
+}
+
+#endif // Py_GIL_DISABLED
+
 static PyMethodDef test_methods[] = {
     {"test_critical_sections", test_critical_sections, METH_NOARGS},
     {"test_critical_sections_nest", test_critical_sections_nest, METH_NOARGS},
     {"test_critical_sections_suspend", test_critical_sections_suspend, METH_NOARGS},
+#ifdef Py_GIL_DISABLED
+    {"test_critical_section1_reacquisition", test_critical_section1_reacquisition, METH_NOARGS},
+    {"test_critical_section2_reacquisition", test_critical_section2_reacquisition, METH_NOARGS},
+#endif
 #ifdef Py_CAN_START_THREADS
     {"test_critical_sections_threads", test_critical_sections_threads, METH_NOARGS},
     {"test_critical_sections_gc", test_critical_sections_gc, METH_NOARGS},

Python/bytecodes.c

@@ -3689,7 +3689,7 @@ dummy_func(
             #if ENABLE_SPECIALIZATION_FT
             if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
                 next_instr = this_instr;
-                _Py_Specialize_Call(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null));
+                _Py_Specialize_Call(callable, self_or_null, next_instr, oparg + !PyStackRef_IsNull(self_or_null));
                 DISPATCH_SAME_OPARG();
             }
             OPCODE_DEFERRED_INC(CALL);
@@ -4395,7 +4395,6 @@ dummy_func(
             assert(oparg == 1);
             PyObject *self_o = PyStackRef_AsPyObjectBorrow(self);
 
-            DEOPT_IF(!PyList_CheckExact(self_o));
             DEOPT_IF(!LOCK_OBJECT(self_o));
             STAT_INC(CALL, hit);
             int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg));

Python/critical_section.c

@@ -24,11 +24,24 @@ _PyCriticalSection_BeginSlow(PyCriticalSection *c, PyMutex *m)
     // As an optimisation for locking the same object recursively, skip
     // locking if the mutex is currently locked by the top-most critical
     // section.
-    if (tstate->critical_section &&
-        untag_critical_section(tstate->critical_section)->_cs_mutex == m) {
-        c->_cs_mutex = NULL;
-        c->_cs_prev = 0;
-        return;
+    // If the top-most critical section is a two-mutex critical section,
+    // then locking is skipped if either mutex is m.
+    if (tstate->critical_section) {
+        PyCriticalSection *prev = untag_critical_section(tstate->critical_section);
+        if (prev->_cs_mutex == m) {
+            c->_cs_mutex = NULL;
+            c->_cs_prev = 0;
+            return;
+        }
+        if (tstate->critical_section & _Py_CRITICAL_SECTION_TWO_MUTEXES) {
+            PyCriticalSection2 *prev2 = (PyCriticalSection2 *)
+                untag_critical_section(tstate->critical_section);
+            if (prev2->_cs_mutex2 == m) {
+                c->_cs_mutex = NULL;
+                c->_cs_prev = 0;
+                return;
+            }
+        }
     }
     c->_cs_mutex = NULL;
     c->_cs_prev = (uintptr_t)tstate->critical_section;

Python/specialize.c

@@ -1602,8 +1602,8 @@ specialize_class_call(PyObject *callable, _Py_CODEUNIT *instr, int nargs)
 }
 
 static int
-specialize_method_descriptor(PyMethodDescrObject *descr, _Py_CODEUNIT *instr,
-                             int nargs)
+specialize_method_descriptor(PyMethodDescrObject *descr, PyObject *self_or_null,
+                             _Py_CODEUNIT *instr, int nargs)
 {
     switch (descr->d_method->ml_flags &
         (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O |
@@ -1627,8 +1627,11 @@ specialize_method_descriptor(PyMethodDescrObject *descr, _Py_CODEUNIT *instr,
             bool pop = (next.op.code == POP_TOP);
             int oparg = instr->op.arg;
             if ((PyObject *)descr == list_append && oparg == 1 && pop) {
-                specialize(instr, CALL_LIST_APPEND);
-                return 0;
+                assert(self_or_null != NULL);
+                if (PyList_CheckExact(self_or_null)) {
+                    specialize(instr, CALL_LIST_APPEND);
+                    return 0;
+                }
             }
             specialize(instr, CALL_METHOD_DESCRIPTOR_O);
             return 0;
@@ -1766,7 +1769,7 @@ specialize_c_call(PyObject *callable, _Py_CODEUNIT *instr, int nargs)
 }
 
 Py_NO_INLINE void
-_Py_Specialize_Call(_PyStackRef callable_st, _Py_CODEUNIT *instr, int nargs)
+_Py_Specialize_Call(_PyStackRef callable_st, _PyStackRef self_or_null_st, _Py_CODEUNIT *instr, int nargs)
 {
     PyObject *callable = PyStackRef_AsPyObjectBorrow(callable_st);
 
@@ -1784,7 +1787,9 @@ _Py_Specialize_Call(_PyStackRef callable_st, _Py_CODEUNIT *instr, int nargs)
         fail = specialize_class_call(callable, instr, nargs);
     }
     else if (Py_IS_TYPE(callable, &PyMethodDescr_Type)) {
-        fail = specialize_method_descriptor((PyMethodDescrObject *)callable, instr, nargs);
+        PyObject *self_or_null = PyStackRef_AsPyObjectBorrow(self_or_null_st);
+        fail = specialize_method_descriptor((PyMethodDescrObject *)callable,
+                                            self_or_null, instr, nargs);
     }
     else if (PyMethod_Check(callable)) {
         PyObject *func = ((PyMethodObject *)callable)->im_func;