Specialize UNARY_NOT

python · brandtbucher · Jun 29, 2023 · Jun 6, 2023 · Jun 6, 2023 · Jun 7, 2023
commit 5289c7f69e7e2ba75cafa076da55dd9f179cae7c
diff --git a/Include/internal/pycore_code.h b/Include/internal/pycore_code.h
@@ -101,6 +101,12 @@ typedef struct {
 
 #define INLINE_CACHE_ENTRIES_SEND CACHE_ENTRIES(_PySendCache)
 
+typedef struct {
+    uint16_t counter;
+} _PyUnaryNotCache;
+
+#define INLINE_CACHE_ENTRIES_UNARY_NOT CACHE_ENTRIES(_PyUnaryNotCache)
+
 // Borrowed references to common callables:
 struct callable_cache {
     PyObject *isinstance;
@@ -246,6 +252,7 @@ extern void _Py_Specialize_UnpackSequence(PyObject *seq, _Py_CODEUNIT *instr,
                                           int oparg);
 extern void _Py_Specialize_ForIter(PyObject *iter, _Py_CODEUNIT *instr, int oparg);
 extern void _Py_Specialize_Send(PyObject *receiver, _Py_CODEUNIT *instr);
+extern void _Py_Specialize_UnaryNot(PyObject *value, _Py_CODEUNIT *instr);
 
 /* Finalizer function for static codeobjects used in deepfreeze.py */
 extern void _PyStaticCode_Fini(PyCodeObject *co);

diff --git a/Include/internal/pycore_opcode.h b/Include/internal/pycore_opcode.h
diff --git a/Include/opcode.h b/Include/opcode.h
diff --git a/Lib/opcode.py b/Lib/opcode.py
@@ -438,6 +438,13 @@ def pseudo_op(name, op, real_ops):
     "SEND": [
         "SEND_GEN",
     ],
+    "UNARY_NOT": [
+        "UNARY_NOT_BOOL",
+        "UNARY_NOT_INT",
+        "UNARY_NOT_LIST",
+        "UNARY_NOT_NONE",
+        "UNARY_NOT_STR",
+    ]
 }
 _specialized_instructions = [
     opcode for family in _specializations.values() for opcode in family
@@ -492,6 +499,9 @@ def pseudo_op(name, op, real_ops):
     "JUMP_BACKWARD": {
         "counter": 1,
     },
+    "UNARY_NOT": {
+        "counter": 1,
+    },
 }
 
 _inline_cache_entries = [

diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
@@ -260,7 +260,26 @@ dummy_func(
             ERROR_IF(res == NULL, error);
         }
 
-        inst(UNARY_NOT, (value -- res)) {
+        family(unary_not, INLINE_CACHE_ENTRIES_UNARY_NOT) = {
+            UNARY_NOT,
+            UNARY_NOT_BOOL,
+            UNARY_NOT_INT,
+            UNARY_NOT_LIST,
+            UNARY_NOT_NONE,
+            UNARY_NOT_STR,
+        };
+
+        inst(UNARY_NOT, (unused/1, value -- res)) {
+            #if ENABLE_SPECIALIZATION
+            _PyUnaryNotCache *cache = (_PyUnaryNotCache *)next_instr;
+            if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
+                next_instr--;
+                _Py_Specialize_UnaryNot(value, next_instr);
+                DISPATCH_SAME_OPARG();
+            }
+            STAT_INC(UNARY_NOT, deferred);
+            DECREMENT_ADAPTIVE_COUNTER(cache->counter);
+            #endif  /* ENABLE_SPECIALIZATION */
             int err = PyObject_IsTrue(value);
             DECREF_INPUTS();
             ERROR_IF(err < 0, error);
@@ -272,6 +291,63 @@ dummy_func(
             }
         }
 
+        inst(UNARY_NOT_BOOL, (unused/1, value -- res)) {
+            DEOPT_IF(!PyBool_Check(value), UNARY_NOT);
+            STAT_INC(UNARY_NOT, hit);
+            if (Py_IsFalse(value)) {
+                res = Py_True;
+            }
+            else {
+                res = Py_False;
+            }
+        }
+
+        inst(UNARY_NOT_INT, (unused/1, value -- res)) {
+            DEOPT_IF(!PyLong_CheckExact(value), UNARY_NOT);
+            STAT_INC(UNARY_NOT, hit);
+            if (_PyLong_IsZero((PyLongObject *)value)) {
+                assert(_Py_IsImmortal(value));
+                res = Py_True;
+            }
+            else {
+                DECREF_INPUTS();
+                res = Py_False;
+            }
+        }
+
+        inst(UNARY_NOT_LIST, (unused/1, value -- res)) {
+            DEOPT_IF(!PyList_CheckExact(value), UNARY_NOT);
+            STAT_INC(UNARY_NOT, hit);
+            if (!Py_SIZE(value)) {
+                res = Py_True;
+            }
+            else {
+                res = Py_False;
+            }
+            DECREF_INPUTS();
+        }
+
+        inst(UNARY_NOT_NONE, (unused/1, value -- res)) {
+            // This one is a bit weird, because we expect *some* failures:
+            DEOPT_IF(!Py_IsNone(value), UNARY_NOT);
+            STAT_INC(UNARY_NOT, hit);
+            res = Py_True;
+        }
+
+        inst(UNARY_NOT_STR, (unused/1, value -- res)) {
+            DEOPT_IF(!PyUnicode_CheckExact(value), UNARY_NOT);
+            STAT_INC(UNARY_NOT, hit);
+            if (Py_Is(value, &_Py_STR(empty))) {
+                assert(_Py_IsImmortal(value));
+                res = Py_True;
+            }
+            else {
+                assert(Py_SIZE(value));
+                DECREF_INPUTS();
+                res = Py_False;
+            }
+        }
+
         inst(UNARY_INVERT, (value -- res)) {
             res = PyNumber_Invert(value);
             DECREF_INPUTS();