fix leak, fix peepholer

python · Fidget-Spinner · Jan 13, 2024 · Jan 13, 2024 · Jan 13, 2024 · Jan 13, 2024
commit 1de0ccb5979e719fa62c120bf6e43b997fe43d85
diff --git a/Lib/test/test_capi/test_opt.py b/Lib/test/test_capi/test_opt.py
@@ -566,6 +566,28 @@ def testfunc(loops):
         uops = {opname for opname, _, _ in ex}
         self.assertNotIn("_SHRINK_STACK", uops)
 
+    def test_int_constant_propagation_many(self):
+        def testfunc(loops):
+            num = 0
+            for _ in range(loops):
+                x = 0
+                y = 1
+                a = x + y + x + y + x + y + x + y
+            return a
+
+        opt = _testinternalcapi.get_uop_optimizer()
+        res = None
+        with temporary_optimizer(opt):
+            res = testfunc(64)
+
+        ex = get_first_executor(testfunc)
+        self.assertIsNotNone(ex)
+        self.assertEqual(res, 4)
+        binop_count = [opname for opname, _, _ in ex if opname == "_BINARY_OP_ADD_INT"]
+        self.assertEqual(len(binop_count), 0)
+        uops = {opname for opname, _, _ in ex}
+        self.assertNotIn("_SHRINK_STACK", uops)
+
     def test_int_type_propagation(self):
         def testfunc(loops):
             num = 0

@@ -23,6 +23,8 @@
 
 #define OVERALLOCATE_FACTOR 3
 
+#define PEEPHOLE_MAX_ATTEMPTS 10
+
 #ifdef Py_DEBUG
     static const char *const DEBUG_ENV = "PYTHON_OPT_DEBUG";
     #define DPRINTF(level, ...) \
@@ -227,6 +229,7 @@ abstractinterp_dealloc(PyObject *o)
     }
     PyMem_Free(self->t_arena.arena);
     PyMem_Free(self->s_arena.arena);
+    PyMem_Free(self->frame_info.arena);
     Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
@@ -1207,7 +1210,7 @@ uop_abstract_interpret_single_inst(
 
 }
 
-int
+static int
 uop_abstract_interpret(
     PyCodeObject *co,
     _PyUOpInstruction *trace,
@@ -1323,34 +1326,56 @@ remove_unneeded_uops(_PyUOpInstruction *buffer, int buffer_size)
     }
 }
 
-static void
+static inline bool
+op_is_zappable(int opcode)
+{
+    switch(opcode) {
+        case _SET_IP:
+        case _CHECK_VALIDITY:
+        case _LOAD_CONST_INLINE:
+        case _LOAD_CONST:
+        case _LOAD_FAST:
+        case _LOAD_CONST_INLINE_BORROW:
+            return true;
+        default:
+            return false;
+    }
+}
+
+static inline bool
+op_is_load(int opcode)
+{
+    return (opcode == _LOAD_CONST_INLINE ||
+        opcode == _LOAD_CONST ||
+        opcode == LOAD_FAST ||
+        opcode == _LOAD_CONST_INLINE_BORROW);
+}
+
+static int
 peephole_optimizations(_PyUOpInstruction *buffer, int buffer_size)
 {
+    bool done = true;
     for (int i = 0; i < buffer_size; i++) {
         _PyUOpInstruction *curr = buffer + i;
         int oparg = curr->oparg;
         switch(curr->opcode) {
             case _SHRINK_STACK: {
                 // If all that precedes a _SHRINK_STACK is a bunch of LOAD_FAST,
                 // then we can safely eliminate that without side effects.
-                int load_fast_count = 0;
+                int load_count = 0;
                 _PyUOpInstruction *back = curr-1;
-                while((back->opcode == _SET_IP ||
-                    back->opcode == _CHECK_VALIDITY ||
-                    back->opcode == LOAD_FAST) &&
-                    load_fast_count < oparg) {
-                    load_fast_count += back->opcode == LOAD_FAST;
+                while(op_is_zappable(back->opcode) &&
+                    load_count < oparg) {
+                    load_count += op_is_load(back->opcode);
                     back--;
                 }
-                if (load_fast_count == oparg) {
+                if (load_count == oparg) {
+                    done = false;
                     curr->opcode = NOP;
                     back = curr-1;
-                    load_fast_count = 0;
-                    while((back->opcode == _SET_IP ||
-                           back->opcode == _CHECK_VALIDITY ||
-                           back->opcode == LOAD_FAST) &&
-                          load_fast_count < oparg) {
-                        load_fast_count += back->opcode == LOAD_FAST;
+                    load_count = 0;
+                    while(load_count < oparg) {
+                        load_count += op_is_load(back->opcode);
                         back->opcode = NOP;
                         back--;
                     }
@@ -1368,6 +1393,7 @@ peephole_optimizations(_PyUOpInstruction *buffer, int buffer_size)
                 break;
         }
     }
+    return done;
 }
 
 
@@ -1396,7 +1422,11 @@ _Py_uop_analyze_and_optimize(
         goto error;
     }
 
-    peephole_optimizations(temp_writebuffer, new_trace_len);
+    for (int peephole_attempts = 0; peephole_attempts < PEEPHOLE_MAX_ATTEMPTS &&
+        !peephole_optimizations(temp_writebuffer, new_trace_len);
+         peephole_attempts++) {
+
+    }
 
     remove_unneeded_uops(temp_writebuffer, new_trace_len);