factor out tracing decision, try making _JIT faster

Author: Fidget-Spinner

Include/internal/pycore_optimizer.h

@@ -361,6 +361,8 @@ _PyJit_TryInitializeTracing(PyThreadState *tstate, _PyInterpreterFrame *frame,
     int oparg, _PyExecutorObject *current_executor);
 
 PyAPI_FUNC(void) _PyJit_FinalizeTracing(PyThreadState *tstate, int err);
+PyAPI_FUNC(bool) _PyJit_EnterExecutorShouldStopTracing(int og_opcode);
+
 void _PyPrintExecutor(_PyExecutorObject *executor, const _PyUOpInstruction *marker);
 void _PyJit_TracerFree(_PyThreadStateImpl *_tstate);
 

Modules/_testinternalcapi/test_cases.c.h

@@ -3118,8 +3118,8 @@ dummy_func(
         #ifdef _Py_TIER2
             bool is_resume = this_instr->op.code == RESUME_CHECK_JIT;
             _Py_BackoffCounter counter = this_instr[1].counter;
-            if (!IS_JIT_TRACING() &&
-                (backoff_counter_triggers(counter) &&
+            if ((backoff_counter_triggers(counter) &&
+                !IS_JIT_TRACING() &&
                 (this_instr->op.code == JUMP_BACKWARD_JIT || is_resume)) &&
                 next_instr->op.code != ENTER_EXECUTOR) {
                 /* Back up over EXTENDED_ARGs so executor is inserted at the correct place */
@@ -3186,9 +3186,7 @@ dummy_func(
                 int og_opcode = executor->vm_data.opcode;
                 int og_oparg = (oparg & ~255) | executor->vm_data.oparg;
                 next_instr = this_instr;
-                // Continue tracing (skip over the executor). If it's a RESUME
-                // trace to form longer, more optimizeable traces.
-                if (og_opcode == RESUME_CHECK_JIT) {
+                if (_PyJit_EnterExecutorShouldStopTracing(og_opcode)) {
                     if (_PyOpcode_Caches[_PyOpcode_Deopt[opcode]]) {
                         PAUSE_ADAPTIVE_COUNTER(this_instr[1].counter);
                     }

Python/bytecodes.c

@@ -632,9 +632,6 @@ _PyJit_translate_single_bytecode_to_trace(
         target--;
     }
 
-    // We want to trace over RESUME traces. Otherwise, functions with lots of RESUME
-    // end up with many fragmented traces which perform badly.
-    // See for example, the richards benchmark in pyperformance.
     if (opcode == ENTER_EXECUTOR) {
         _PyExecutorObject *executor = old_code->co_executors->executors[oparg & 255];
         opcode = executor->vm_data.opcode;
@@ -1104,6 +1101,19 @@ _PyJit_FinalizeTracing(PyThreadState *tstate, int err)
     tracer->is_tracing = false;
 }
 
+bool
+_PyJit_EnterExecutorShouldStopTracing(int og_opcode)
+{
+    // Continue tracing (skip over the executor). If it's a RESUME
+    // trace to form longer, more optimizeable traces.
+    // We want to trace over RESUME traces. Otherwise, functions with lots of RESUME
+    // end up with many fragmented traces which perform badly.
+    // See for example, the richards benchmark in pyperformance.
+    // For consideration: We may want to consider tracing over side traces
+    // inserted into bytecode as well in the future.
+    return og_opcode == RESUME_CHECK_JIT;
+}
+
 void
 _PyJit_TracerFree(_PyThreadStateImpl *_tstate)
 {