Reduce strength of binary guards when one side is known type.

python · markshannon · Apr 22, 2024 · Apr 17, 2024 · Apr 18, 2024 · Apr 19, 2024
commit 646672c41aeb2b795ff1e2cf0a0c979c896bbf82
diff --git a/Include/internal/pycore_optimizer.h b/Include/internal/pycore_optimizer.h
@@ -98,6 +98,7 @@ extern bool _Py_uop_sym_set_type(_Py_UopsSymbol *sym, PyTypeObject *typ);
 extern bool _Py_uop_sym_set_const(_Py_UopsSymbol *sym, PyObject *const_val);
 extern bool _Py_uop_sym_is_bottom(_Py_UopsSymbol *sym);
 extern int _Py_uop_sym_truthiness(_Py_UopsSymbol *sym);
+extern PyTypeObject *_Py_uop_sym_get_type(_Py_UopsSymbol *sym);


 extern int _Py_uop_abstractcontext_init(_Py_UOpsContext *ctx);

diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h
diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h
diff --git a/Lib/test/test_capi/test_opt.py b/Lib/test/test_capi/test_opt.py
@@ -903,10 +903,50 @@ def testfunc(n):
        self.assertTrue(res)
        self.assertIsNotNone(ex)
        uops = get_opnames(ex)
-        guard_both_float_count = [opname for opname in iter_opnames(ex) if opname == "_GUARD_BOTH_INT"]
-        self.assertLessEqual(len(guard_both_float_count), 1)
+        guard_both_int_count = [opname for opname in iter_opnames(ex) if opname == "_GUARD_BOTH_INT"]
+        self.assertLessEqual(len(guard_both_int_count), 1)
        self.assertIn("_COMPARE_OP_INT", uops)

+    def test_compare_op_type_propagation_int_partial(self):
+        def testfunc(n):
+            a = 1
+            for _ in range(n):
+                if a > 2:
+                    x = 0
+                if a < 2:
+                    x = 1
+            return x
+
+        res, ex = self._run_with_optimizer(testfunc, 32)
+        self.assertEqual(res, 1)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        guard_left_int_count = [opname for opname in iter_opnames(ex) if opname == "_GUARD_NOS_INT"]
+        guard_both_int_count = [opname for opname in iter_opnames(ex) if opname == "_GUARD_BOTH_INT"]
+        self.assertLessEqual(len(guard_left_int_count), 1)
+        self.assertEqual(len(guard_both_int_count), 0)
+        self.assertIn("_COMPARE_OP_INT", uops)
+
+    def test_compare_op_type_propagation_float_partial(self):
+        def testfunc(n):
+            a = 1.0
+            for _ in range(n):
+                if a > 2.0:
+                    x = 0
+                if a < 2.0:
+                    x = 1
+            return x
+
+        res, ex = self._run_with_optimizer(testfunc, 32)
+        self.assertEqual(res, 1)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        guard_left_float_count = [opname for opname in iter_opnames(ex) if opname == "_GUARD_NOS_FLOAT"]
+        guard_both_float_count = [opname for opname in iter_opnames(ex) if opname == "_GUARD_BOTH_FLOAT"]
+        self.assertLessEqual(len(guard_left_float_count), 1)
+        self.assertEqual(len(guard_both_float_count), 0)
+        self.assertIn("_COMPARE_OP_FLOAT", uops)
+
    def test_compare_op_type_propagation_unicode(self):
        def testfunc(n):
            a = ""

@@ -424,6 +424,14 @@ dummy_func(
            EXIT_IF(!PyLong_CheckExact(right));
        }

+        op(_GUARD_NOS_INT, (left, unused -- left, unused)) {
+            EXIT_IF(!PyLong_CheckExact(left));
+        }
+
+        op(_GUARD_TOS_INT, (value -- value)) {
+            EXIT_IF(!PyLong_CheckExact(value));
+        }
+
        pure op(_BINARY_OP_MULTIPLY_INT, (left, right -- res)) {
            STAT_INC(BINARY_OP, hit);
            res = _PyLong_Multiply((PyLongObject *)left, (PyLongObject *)right);
@@ -460,6 +468,14 @@ dummy_func(
            EXIT_IF(!PyFloat_CheckExact(right));
        }

+        op(_GUARD_NOS_FLOAT, (left, unused -- left, unused)) {
+            EXIT_IF(!PyFloat_CheckExact(left));
+        }
+
+        op(_GUARD_TOS_FLOAT, (value -- value)) {
+            EXIT_IF(!PyFloat_CheckExact(value));
+        }
+
        pure op(_BINARY_OP_MULTIPLY_FLOAT, (left, right -- res)) {
            STAT_INC(BINARY_OP, hit);
            double dres =