GH-111843: Tier 2 exponential backoff

Include/cpython/optimizer.h

@@ -45,8 +45,8 @@ typedef int (*optimize_func)(_PyOptimizerObject* self, PyCodeObject *code, _Py_C
 typedef struct _PyOptimizerObject {
     PyObject_HEAD
     optimize_func optimize;
-    uint16_t resume_threshold;
-    uint16_t backedge_threshold;
+    uint32_t resume_threshold;
+    uint32_t backedge_threshold;
     /* Data needed by the optimizer goes here, but is opaque to the VM */
 } _PyOptimizerObject;
 
@@ -76,6 +76,8 @@ PyAPI_FUNC(PyObject *)PyUnstable_Optimizer_NewCounter(void);
 PyAPI_FUNC(PyObject *)PyUnstable_Optimizer_NewUOpOptimizer(void);
 
 #define OPTIMIZER_BITS_IN_COUNTER 4
+/* Minimum of 16 additional executions before retry */
+#define MINIMUM_TIER2_BACKOFF 4
 
 #ifdef __cplusplus
 }

Misc/NEWS.d/next/Core and Builtins/2023-11-05-06-40-35.gh-issue-111843.c045cB.rst

@@ -0,0 +1,2 @@
+Use exponential backoff to reduce the number of failed tier 2 optimization
+attempts by over 99%.

Python/bytecodes.c

@@ -2335,19 +2335,29 @@ dummy_func(
             JUMPBY(-oparg);
             #if ENABLE_SPECIALIZATION
             this_instr[1].cache += (1 << OPTIMIZER_BITS_IN_COUNTER);
-            if (this_instr[1].cache > tstate->interp->optimizer_backedge_threshold &&
+            uint16_t counter = this_instr[1].cache;
+            if (counter == tstate->interp->optimizer_backedge_threshold) {
                 // Double-check that the opcode isn't instrumented or something:
-                this_instr->op.code == JUMP_BACKWARD)
-            {
+                assert(this_instr->op.code == JUMP_BACKWARD);
                 OPT_STAT_INC(attempts);
                 int optimized = _PyOptimizer_BackEdge(frame, this_instr, next_instr, stack_pointer);
                 ERROR_IF(optimized < 0, error);
                 if (optimized) {
                     // Rewind and enter the executor:
                     assert(this_instr->op.code == ENTER_EXECUTOR);
                     next_instr = this_instr;
+                    this_instr[1].cache &= ((1 << OPTIMIZER_BITS_IN_COUNTER) - 1);
+                }
+                else {
+                    int backoff = counter & ((1 << OPTIMIZER_BITS_IN_COUNTER) - 1);
+                    if (backoff < OPTIMIZER_BITS_IN_COUNTER + MINIMUM_TIER2_BACKOFF) {
+                        backoff = OPTIMIZER_BITS_IN_COUNTER + MINIMUM_TIER2_BACKOFF;
+                    }
+                    else if (backoff < 15) {
+                        backoff++;
+                    }
+                    this_instr[1].cache = (0U - (1 << backoff)) | backoff;
                 }
-                this_instr[1].cache &= ((1 << OPTIMIZER_BITS_IN_COUNTER) - 1);
             }
             #endif  /* ENABLE_SPECIALIZATION */
         }

Python/optimizer.c

@@ -122,8 +122,8 @@ PyTypeObject _PyDefaultOptimizer_Type = {
 _PyOptimizerObject _PyOptimizer_Default = {
     PyObject_HEAD_INIT(&_PyDefaultOptimizer_Type)
     .optimize = error_optimize,
-    .resume_threshold = UINT16_MAX,
-    .backedge_threshold = UINT16_MAX,
+    .resume_threshold = UINT16_MAX+1,
+    .backedge_threshold = UINT16_MAX+1,
 };
 
 _PyOptimizerObject *

Python/pylifecycle.c

@@ -1240,6 +1240,7 @@ init_interp_main(PyThreadState *tstate)
         if (_Py_get_xoption(&config->xoptions, L"uops") != NULL) {
             enabled = 1;
         }
+        enabled = 1;
         if (enabled) {
             PyObject *opt = PyUnstable_Optimizer_NewUOpOptimizer();
             if (opt == NULL) {