Move periodic check to before the call

markshannon · markshannon · commit 070195fdf3d7 · 2025-07-29T10:10:03.000+01:00
diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
@@ -4737,6 +4737,8 @@ class PyMiscIOTest(MiscIOTest):
     extra_exported = "BlockingIOError", "open_code",
     not_exported = "valid_seek_flags",
 
+def nop():
+    pass
 
 @unittest.skipIf(os.name == 'nt', 'POSIX signals required for this test.')
 class SignalsTest(unittest.TestCase):
@@ -4806,6 +4808,8 @@ def _read():
             # The buffered IO layer must check for pending signal
             # handlers, which in this case will invoke alarm_interrupt().
             signal.alarm(1)
+            # Force VM to check for signals
+            nop()
             try:
                 self.assertRaises(ZeroDivisionError, wio.write, large_data)
             finally:
diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py
@@ -1439,10 +1439,13 @@ def handler(a, b):
     def test__thread_interrupt_main(self):
         # See https://github.com/python/cpython/issues/102397
         code = """if 1:
+        def nop():
+            pass
         import _thread
         class Foo():
             def __del__(self):
                 _thread.interrupt_main()
+                nop()
 
         x = Foo()
         """
@@ -1451,6 +1454,9 @@ def __del__(self):
         self.assertIn(b'OSError: Signal 2 ignored due to race condition', err)
 
 
+def nop():
+    pass
+
 
 class PidfdSignalTest(unittest.TestCase):
 
@@ -1472,6 +1478,8 @@ def test_pidfd_send_signal(self):
             signal.pidfd_send_signal(my_pidfd, signal.SIGINT, object(), 0)
         with self.assertRaises(KeyboardInterrupt):
             signal.pidfd_send_signal(my_pidfd, signal.SIGINT)
+            # Force VM to check for signal
+            nop()
 
 def tearDownModule():
     support.reap_children()
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
@@ -2366,6 +2366,10 @@ def work():
         self.assertEqual(name2, "new name")
 
 
+def nop():
+    pass
+
+
 class InterruptMainTests(unittest.TestCase):
     def check_interrupt_main_with_signal_handler(self, signum):
         def handler(signum, frame):
@@ -2376,6 +2380,9 @@ def handler(signum, frame):
 
         with self.assertRaises(ZeroDivisionError):
             _thread.interrupt_main()
+            # Force VM to check for interrupts
+            nop()
+
 
     def check_interrupt_main_noerror(self, signum):
         handler = signal.getsignal(signum)
@@ -2400,13 +2407,17 @@ def call_interrupt():
         with self.assertRaises(KeyboardInterrupt):
             t.start()
             t.join()
+            # Force VM to check for interrupts
+            nop()
         t.join()
 
     def test_interrupt_main_mainthread(self):
         # Make sure that if interrupt_main is called in main thread that
         # KeyboardInterrupt is raised instantly.
         with self.assertRaises(KeyboardInterrupt):
             _thread.interrupt_main()
+            # Force VM to check for interrupts
+            nop()
 
     def test_interrupt_main_with_signal_handler(self):
         self.check_interrupt_main_with_signal_handler(signal.SIGINT)
diff --git a/Lib/threading.py b/Lib/threading.py
@@ -368,12 +368,20 @@ def wait(self, timeout=None):
                     gotit = waiter.acquire(False)
             return gotit
         finally:
-            self._acquire_restore(saved_state)
+            e = None
+            try:
+                # If a keybord interrupt is pending it will trigger here
+                self._acquire_restore(saved_state)
+            except KeyboardInterrupt as ex:
+                self._acquire_restore(saved_state)
+                e = ex
             if not gotit:
                 try:
                     self._waiters.remove(waiter)
                 except ValueError:
                     pass
+            if e is not None:
+                raise e from None
 
     def wait_for(self, predicate, timeout=None):
         """Wait until a condition evaluates to True.
diff --git a/Lib/unittest/case.py b/Lib/unittest/case.py
@@ -206,6 +206,9 @@ def _raiseFailure(self, standardMsg):
         msg = self.test_case._formatMessage(self.msg, standardMsg)
         raise self.test_case.failureException(msg)
 
+def nop():
+    pass
+
 class _AssertRaisesBaseContext(_BaseTestCaseContext):
 
     def __init__(self, expected, test_case, expected_regex=None):
@@ -243,6 +246,8 @@ def handle(self, name, args, kwargs):
                 self.obj_name = str(callable_obj)
             with self:
                 callable_obj(*args, **kwargs)
+                # Force asynchronous exceptions
+                nop()
         finally:
             # bpo-23890: manually break a reference cycle
             self = None
diff --git a/Python/bytecodes.c b/Python/bytecodes.c
@@ -3790,8 +3790,8 @@ dummy_func(
             ERROR_IF(err);
         }
 
-        macro(CALL) = _SPECIALIZE_CALL + unused/2 + _MAYBE_EXPAND_METHOD + _DO_CALL + _CHECK_PERIODIC;
-        macro(INSTRUMENTED_CALL) = unused/3 + _MAYBE_EXPAND_METHOD + _MONITOR_CALL + _DO_CALL + _CHECK_PERIODIC;
+        macro(CALL) = _SPECIALIZE_CALL + _CHECK_PERIODIC + unused/2 + _MAYBE_EXPAND_METHOD + _DO_CALL;
+        macro(INSTRUMENTED_CALL) = _CHECK_PERIODIC + unused/3 + _MAYBE_EXPAND_METHOD + _MONITOR_CALL + _DO_CALL;
 
         op(_PY_FRAME_GENERAL, (callable, self_or_null, args[oparg] -- new_frame)) {
             PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
@@ -3911,8 +3911,8 @@ dummy_func(
             unused/1 + // Skip over the counter
             unused/2 +
             _CHECK_IS_NOT_PY_CALLABLE +
-            _CALL_NON_PY_GENERAL +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _CALL_NON_PY_GENERAL;
 
         op(_CHECK_CALL_BOUND_METHOD_EXACT_ARGS, (callable, null, unused[oparg] -- callable, null, unused[oparg])) {
             EXIT_IF(!PyStackRef_IsNull(null));
@@ -4068,8 +4068,8 @@ dummy_func(
             unused/2 +
             _GUARD_NOS_NULL +
             _GUARD_CALLABLE_STR_1 +
-            _CALL_STR_1 +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _CALL_STR_1;
 
         op(_GUARD_CALLABLE_TUPLE_1, (callable, unused, unused -- callable, unused, unused)) {
             PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
@@ -4096,8 +4096,8 @@ dummy_func(
             unused/2 +
             _GUARD_NOS_NULL +
             _GUARD_CALLABLE_TUPLE_1 +
-            _CALL_TUPLE_1 +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _CALL_TUPLE_1;
 
         op(_CHECK_AND_ALLOCATE_OBJECT, (type_version/2, callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) {
             PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
@@ -4192,8 +4192,8 @@ dummy_func(
         macro(CALL_BUILTIN_CLASS) =
             unused/1 +
             unused/2 +
-            _CALL_BUILTIN_CLASS +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _CALL_BUILTIN_CLASS;
 
         op(_CALL_BUILTIN_O, (callable, self_or_null, args[oparg] -- res)) {
             /* Builtin METH_O functions */
@@ -4227,8 +4227,8 @@ dummy_func(
         macro(CALL_BUILTIN_O) =
             unused/1 +
             unused/2 +
-            _CALL_BUILTIN_O +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _CALL_BUILTIN_O;
 
         op(_CALL_BUILTIN_FAST, (callable, self_or_null, args[oparg] -- res)) {
             /* Builtin METH_FASTCALL functions, without keywords */
@@ -4264,8 +4264,8 @@ dummy_func(
         macro(CALL_BUILTIN_FAST) =
             unused/1 +
             unused/2 +
-            _CALL_BUILTIN_FAST +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _CALL_BUILTIN_FAST;
 
         op(_CALL_BUILTIN_FAST_WITH_KEYWORDS, (callable, self_or_null, args[oparg] -- res)) {
             /* Builtin METH_FASTCALL | METH_KEYWORDS functions */
@@ -4300,8 +4300,8 @@ dummy_func(
         macro(CALL_BUILTIN_FAST_WITH_KEYWORDS) =
             unused/1 +
             unused/2 +
-            _CALL_BUILTIN_FAST_WITH_KEYWORDS +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _CALL_BUILTIN_FAST_WITH_KEYWORDS;
 
         macro(CALL_LEN) =
             unused/1 +
@@ -4438,8 +4438,8 @@ dummy_func(
         macro(CALL_METHOD_DESCRIPTOR_O) =
             unused/1 +
             unused/2 +
-            _CALL_METHOD_DESCRIPTOR_O +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _CALL_METHOD_DESCRIPTOR_O;
 
         op(_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, (callable, self_or_null, args[oparg] -- res)) {
             PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
@@ -4480,8 +4480,8 @@ dummy_func(
         macro(CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS) =
             unused/1 +
             unused/2 +
-            _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS;
 
         op(_CALL_METHOD_DESCRIPTOR_NOARGS, (callable, self_or_null, args[oparg] -- res)) {
             assert(oparg == 0 || oparg == 1);
@@ -4518,8 +4518,8 @@ dummy_func(
         macro(CALL_METHOD_DESCRIPTOR_NOARGS) =
             unused/1 +
             unused/2 +
-            _CALL_METHOD_DESCRIPTOR_NOARGS +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _CALL_METHOD_DESCRIPTOR_NOARGS;
 
         op(_CALL_METHOD_DESCRIPTOR_FAST, (callable, self_or_null, args[oparg] -- res)) {
             PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
@@ -4559,8 +4559,8 @@ dummy_func(
         macro(CALL_METHOD_DESCRIPTOR_FAST) =
             unused/1 +
             unused/2 +
-            _CALL_METHOD_DESCRIPTOR_FAST +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _CALL_METHOD_DESCRIPTOR_FAST;
 
         // Cache layout: counter/1, func_version/2
         family(CALL_KW, INLINE_CACHE_ENTRIES_CALL_KW) = {
@@ -4815,8 +4815,8 @@ dummy_func(
             unused/1 + // Skip over the counter
             unused/2 +
             _CHECK_IS_NOT_PY_CALLABLE_KW +
-            _CALL_KW_NON_PY +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _CALL_KW_NON_PY;
 
         op(_MAKE_CALLARGS_A_TUPLE, (func, unused, callargs, kwargs -- func, unused, callargs, kwargs)) {
             PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
@@ -4916,13 +4916,13 @@ dummy_func(
 
         macro(CALL_FUNCTION_EX) =
             _MAKE_CALLARGS_A_TUPLE +
-            _DO_CALL_FUNCTION_EX +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _DO_CALL_FUNCTION_EX;
 
         macro(INSTRUMENTED_CALL_FUNCTION_EX) =
             _MAKE_CALLARGS_A_TUPLE +
-            _DO_CALL_FUNCTION_EX +
-            _CHECK_PERIODIC;
+            _CHECK_PERIODIC +
+            _DO_CALL_FUNCTION_EX;
 
         inst(MAKE_FUNCTION, (codeobj_st -- func)) {
             PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st);
diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h
