Remove specialize_counter

Author: Fidget-Spinner

Include/internal/pycore_backoff.h

@@ -95,6 +95,14 @@ backoff_counter_triggers(_Py_BackoffCounter counter)
     return counter.value_and_backoff < UNREACHABLE_BACKOFF;
 }
 
+static inline _Py_BackoffCounter
+trigger_backoff_counter(void)
+{
+    _Py_BackoffCounter result;
+    result.value_and_backoff = 0;
+    return result;
+}
+
 // Initial JUMP_BACKWARD counter.
 // Must be larger than ADAPTIVE_COOLDOWN_VALUE, otherwise when JIT code is
 // invalidated we may construct a new trace before the bytecode has properly
@@ -134,14 +142,6 @@ initial_unreachable_backoff_counter(void)
     return make_backoff_counter(0, UNREACHABLE_BACKOFF);
 }
 
-// Required to not get stuck in infinite specialization loops due to specialization failure.
-// We use 2 here as there are a few scenarios:
-// 1. Freshly specialized from unspecialized, in which case the counter will be 1.
-// 2. Re-specialized from deopt, in which case the counter will be 1.
-// 3. Deopt -> Specialize -> Deopt -> Specialize, in which case the counter will be 2.
-// We do not want the 3rd case.
-#define MAX_SPECIALIZATION_TRIES 2
-
 #ifdef __cplusplus
 }
 #endif

Include/internal/pycore_tstate.h

@@ -41,7 +41,6 @@ typedef struct _PyJitTracerPreviousState {
     int code_curr_size;
     int instr_oparg;
     int instr_stacklevel;
-    int specialize_counter;
     _Py_CODEUNIT *instr;
     PyCodeObject *instr_code; // Strong
     struct _PyInterpreterFrame *instr_frame;

Python/bytecodes.c

@@ -5249,7 +5249,7 @@ dummy_func(
                 ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame))
                 + exit->target;
             OPT_HIST(trace_uop_execution_counter, trace_run_length_hist);
-            if (frame->lltrace >= 2) {
+            if (frame->lltrace >= 3) {
                 printf("SIDE EXIT: [UOp ");
                 _PyUOpPrint(&next_uop[-1]);
                 printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n",
@@ -5267,7 +5267,7 @@ dummy_func(
             _PyExitData *exit = (_PyExitData *)exit_p;
             _Py_CODEUNIT *target = frame->instr_ptr;
             OPT_HIST(trace_uop_execution_counter, trace_run_length_hist);
-            if (frame->lltrace >= 2) {
+            if (frame->lltrace >= 3) {
                 printf("DYNAMIC EXIT: [UOp ");
                 _PyUOpPrint(&next_uop[-1]);
                 printf(", exit %tu, temp %d, target %d -> %s]\n",
@@ -5663,7 +5663,6 @@ dummy_func(
             else {
                 _tstate->jit_state.prev_state.instr = next_instr;
             }
-            _tstate->jit_state.prev_state.specialize_counter = 0;
             PyObject *prev_code = PyStackRef_AsPyObjectBorrow(frame->f_executable);
             if (_tstate->jit_state.prev_state.instr_code != (PyCodeObject *)prev_code) {
                 Py_SETREF(_tstate->jit_state.prev_state.instr_code, (PyCodeObject*)Py_NewRef((prev_code)));
@@ -5672,6 +5671,9 @@ dummy_func(
             _tstate->jit_state.prev_state.instr_frame = frame;
             _tstate->jit_state.prev_state.instr_oparg = oparg;
             _tstate->jit_state.prev_state.instr_stacklevel = PyStackRef_IsNone(frame->f_executable) ? 2 : STACK_LEVEL();
+            if (_PyOpcode_Caches[_PyOpcode_Deopt[opcode]]) {
+                (&next_instr[1])->counter = trigger_backoff_counter();
+            }
             DISPATCH_GOTO_NON_TRACING();
 #else
             Py_FatalError("JIT label executed in non-jit build.");

Python/ceval_macros.h

@@ -134,14 +134,12 @@
 
 #if (_Py_TAIL_CALL_INTERP || USE_COMPUTED_GOTOS) && _Py_TIER2
 #  define IS_JIT_TRACING() (DISPATCH_TABLE_VAR == TRACING_DISPATCH_TABLE)
-#  define IS_JIT_TRACING_MAKING_PROGRESS() (IS_JIT_TRACING() && ((_PyThreadStateImpl *)tstate)->jit_state.prev_state.specialize_counter < MAX_SPECIALIZATION_TRIES)
 #  define ENTER_TRACING() \
     DISPATCH_TABLE_VAR = TRACING_DISPATCH_TABLE;
 #  define LEAVE_TRACING() \
     DISPATCH_TABLE_VAR = DISPATCH_TABLE;
 #else
 #  define IS_JIT_TRACING() (0)
-#  define IS_JIT_TRACING_MAKING_PROGRESS() (0)
 #  define ENTER_TRACING()
 #  define LEAVE_TRACING()
 #endif
@@ -308,7 +306,7 @@ GETITEM(PyObject *v, Py_ssize_t i) {
  * which is always an integral type. */
 // Force re-specialization when tracing a side exit to get good side exits.
 #define ADAPTIVE_COUNTER_TRIGGERS(COUNTER) \
-    backoff_counter_triggers(forge_backoff_counter((COUNTER))) || IS_JIT_TRACING_MAKING_PROGRESS()
+    backoff_counter_triggers(forge_backoff_counter((COUNTER)))
 
 #define ADVANCE_ADAPTIVE_COUNTER(COUNTER) \
     do { \

Python/executor_cases.c.h

@@ -129,6 +129,7 @@ _PyOptimizer_Optimize(
     if (_tstate->jit_state.initial_state.func == NULL) {
         return 0;
     }
+    assert(_tstate->jit_state.initial_state.func != NULL);
     interp->compiling = true;
     // The first executor in a chain and the MAX_CHAIN_DEPTH'th executor *must*
     // make progress in order to avoid infinite loops or excessively-long
@@ -584,10 +585,6 @@ _PyJit_translate_single_bytecode_to_trace(
     // We must point to the first EXTENDED_ARG when deopting.
     int oparg = _tstate->jit_state.prev_state.instr_oparg;
     int opcode = this_instr->op.code;
-    // Failed specialization many times. Deopt!
-    if (_tstate->jit_state.prev_state.specialize_counter >= MAX_SPECIALIZATION_TRIES) {
-        opcode = _PyOpcode_Deopt[opcode];
-    }
     int rewind_oparg = oparg;
     while (rewind_oparg > 255) {
         rewind_oparg >>= 8;
@@ -736,6 +733,7 @@ _PyJit_translate_single_bytecode_to_trace(
             _Py_CODEUNIT *computed_jump_instr = computed_next_instr_without_modifiers + oparg;
             assert(next_instr == computed_next_instr || next_instr == computed_jump_instr);
             int jump_happened = computed_jump_instr == next_instr;
+            assert(jump_happened == (target_instr[1].cache & 1));
             uint32_t uopcode = BRANCH_TO_GUARD[opcode - POP_JUMP_IF_FALSE][jump_happened];
             ADD_TO_TRACE(uopcode, 0, 0, INSTR_IP(jump_happened ? computed_next_instr : computed_jump_instr, old_code));
             break;
@@ -974,7 +972,10 @@ _PyJit_TryInitializeTracing(
             return 0;
         }
     }
-
+    PyObject *func = PyStackRef_AsPyObjectBorrow(frame->f_funcobj);
+    if (func == NULL) {
+        return 0;
+    }
     PyCodeObject *code = _PyFrame_GetCode(frame);
 #ifdef Py_DEBUG
     char *python_lltrace = Py_GETENV("PYTHON_LLTRACE");
@@ -999,13 +1000,12 @@ _PyJit_TryInitializeTracing(
     _tstate->jit_state.initial_state.start_instr = start_instr;
     _tstate->jit_state.initial_state.close_loop_instr = close_loop_instr;
     _tstate->jit_state.initial_state.code = (PyCodeObject *)Py_NewRef(code);
-    _tstate->jit_state.initial_state.func = (PyFunctionObject *)Py_XNewRef(PyStackRef_AsPyObjectBorrow(frame->f_funcobj));
+    _tstate->jit_state.initial_state.func = (PyFunctionObject *)Py_NewRef(func);
     _tstate->jit_state.initial_state.exit = exit;
     _tstate->jit_state.initial_state.stack_depth = curr_stackdepth;
     _tstate->jit_state.initial_state.chain_depth = chain_depth;
     _tstate->jit_state.prev_state.instr_frame = frame;
     _tstate->jit_state.prev_state.dependencies_still_valid = true;
-    _tstate->jit_state.prev_state.specialize_counter = 0;
     _tstate->jit_state.prev_state.instr_code = (PyCodeObject *)Py_NewRef(_PyFrame_GetCode(frame));
     _tstate->jit_state.prev_state.instr = curr_instr;
     _tstate->jit_state.prev_state.instr_frame = frame;
@@ -1014,7 +1014,10 @@ _PyJit_TryInitializeTracing(
     _tstate->jit_state.prev_state.instr_is_super = false;
     assert(curr_instr->op.code == JUMP_BACKWARD_JIT || (exit != NULL));
     _tstate->jit_state.initial_state.jump_backward_instr = curr_instr;
-    assert(curr_instr->op.code == JUMP_BACKWARD_JIT || (exit != NULL));
+
+    if (_PyOpcode_Caches[_PyOpcode_Deopt[close_loop_instr->op.code]]) {
+        close_loop_instr[1].counter = trigger_backoff_counter();
+    }
     _Py_BloomFilter_Init(&_tstate->jit_state.prev_state.dependencies);
     return 1;
 }
@@ -1366,9 +1369,10 @@ uop_optimize(
     assert(length < UOP_MAX_TRACE_LENGTH);
     OPT_STAT_INC(traces_created);
     if (!is_noopt) {
-        length = _Py_uop_analyze_and_optimize(_tstate->jit_state.initial_state.func, buffer,
-                                           length,
-                                           curr_stackentries, &new_dependencies);
+        length = _Py_uop_analyze_and_optimize(
+            _tstate->jit_state.initial_state.func,
+            buffer,length,
+            curr_stackentries, &new_dependencies);
         if (length <= 0) {
             return length;
         }

Python/generated_cases.c.h

@@ -360,9 +360,10 @@ optimize_uops(
     }
     if (ctx->contradiction) {
         // Attempted to push a "bottom" (contradiction) symbol onto the stack.
-        // This means that the abstract interpreter has hit unreachable code.
+        // This means that the abstract interpreter has optimized to trace
+        // to an unreachable estate.
         // We *could* generate an _EXIT_TRACE or _FATAL_ERROR here, but hitting
-        // bottom indicates type instability, so we are probably better off
+        // bottom usually indicates an optimizer bug, so we are probably better off
         // retrying later.
         DPRINTF(3, "\n");
         DPRINTF(1, "Hit bottom in abstract interpreter\n");

Python/optimizer.c

@@ -342,7 +342,6 @@ dummy_func(void) {
         int already_bool = optimize_to_bool(this_instr, ctx, value, &value);
         if (!already_bool) {
             sym_set_type(value, &PyBool_Type);
-            value = sym_new_truthiness(ctx, value, true);
         }
     }