Eliminate redundant refcounting from UNPACK_SEQUENCE family

Author: cocolato

Include/internal/pycore_opcode_metadata.h

@@ -433,6 +433,75 @@ def testfunc(n, m):
         uops = get_opnames(ex)
         self.assertIn("_FOR_ITER_TIER_TWO", uops)
 
+    def test_unpack_sequence_generic(self):
+        def testfunc(x):
+            i = 0
+            while i < x:
+                i += 1
+                # Use an iterator to force generic UNPACK_SEQUENCE
+                a, b = iter((1, 2))
+            return a, b
+
+        res = testfunc(TIER2_THRESHOLD)
+        self.assertEqual(res, (1, 2))
+
+        ex = get_first_executor(testfunc)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertIn("_UNPACK_SEQUENCE", uops)
+
+    def test_unpack_sequence_two_tuple(self):
+        def testfunc(x):
+            i = 0
+            while i < x:
+                i += 1
+                t = (i, i)
+                a, b = t
+            return a, b
+
+        res = testfunc(TIER2_THRESHOLD)
+        self.assertEqual(res, (TIER2_THRESHOLD, TIER2_THRESHOLD))
+
+        ex = get_first_executor(testfunc)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertIn("_UNPACK_SEQUENCE_TWO_TUPLE", uops)
+        self.assertNotIn("_POP_TOP", uops)
+
+    def test_unpack_sequence_tuple(self):
+        def testfunc(x):
+            i = 0
+            while i < x:
+                i += 1
+                t = (i, i, i)
+                a, b, c = t
+            return a, b, c
+
+        res = testfunc(TIER2_THRESHOLD)
+        self.assertEqual(res, (TIER2_THRESHOLD, TIER2_THRESHOLD, TIER2_THRESHOLD))
+
+        ex = get_first_executor(testfunc)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertIn("_UNPACK_SEQUENCE_TUPLE", uops)
+        self.assertNotIn("_POP_TOP", uops)
+
+    def test_unpack_sequence_list(self):
+        def testfunc(x):
+            i = 0
+            while i < x:
+                i += 1
+                a, b = [1, 2]
+            return a, b
+
+        res = testfunc(TIER2_THRESHOLD)
+        self.assertEqual(res, (1, 2))
+
+        ex = get_first_executor(testfunc)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertIn("_UNPACK_SEQUENCE_LIST", uops)
+
 
 @requires_specialization
 @unittest.skipIf(Py_GIL_DISABLED, "optimizer not yet supported in free-threaded builds")

Include/internal/pycore_uop_ids.h

@@ -1576,33 +1576,38 @@ dummy_func(
             (void)counter;
         }
 
-        op(_UNPACK_SEQUENCE, (seq -- unused[oparg], top[0])) {
-            PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq);
+        op(_UNPACK_SEQUENCE, (seq -- unused[oparg], top[0], s)) {
+            PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq);
             int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg, -1, top);
-            Py_DECREF(seq_o);
-            ERROR_IF(res == 0);
+            if (res == 0) {
+                PyStackRef_CLOSE(seq);
+                ERROR_IF(1);
+            }
+            s = seq;
+            INPUTS_DEAD();
         }
 
-        macro(UNPACK_SEQUENCE) = _SPECIALIZE_UNPACK_SEQUENCE + _UNPACK_SEQUENCE;
+        macro(UNPACK_SEQUENCE) = _SPECIALIZE_UNPACK_SEQUENCE + _UNPACK_SEQUENCE + POP_TOP;
 
         macro(UNPACK_SEQUENCE_TWO_TUPLE) =
-            _GUARD_TOS_TUPLE + unused/1 + _UNPACK_SEQUENCE_TWO_TUPLE;
+            _GUARD_TOS_TUPLE + unused/1 + _UNPACK_SEQUENCE_TWO_TUPLE + POP_TOP;
 
-        op(_UNPACK_SEQUENCE_TWO_TUPLE, (seq -- val1, val0)) {
+        op(_UNPACK_SEQUENCE_TWO_TUPLE, (seq -- val1, val0, s)) {
             assert(oparg == 2);
             PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq);
             assert(PyTuple_CheckExact(seq_o));
             DEOPT_IF(PyTuple_GET_SIZE(seq_o) != 2);
             STAT_INC(UNPACK_SEQUENCE, hit);
             val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0));
             val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1));
-            PyStackRef_CLOSE(seq);
+            s = seq;
+            INPUTS_DEAD();
         }
 
         macro(UNPACK_SEQUENCE_TUPLE) =
-            _GUARD_TOS_TUPLE + unused/1 + _UNPACK_SEQUENCE_TUPLE;
+            _GUARD_TOS_TUPLE + unused/1 + _UNPACK_SEQUENCE_TUPLE + POP_TOP;
 
-        op(_UNPACK_SEQUENCE_TUPLE, (seq -- values[oparg])) {
+        op(_UNPACK_SEQUENCE_TUPLE, (seq -- values[oparg], s)) {
             PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq);
             assert(PyTuple_CheckExact(seq_o));
             DEOPT_IF(PyTuple_GET_SIZE(seq_o) != oparg);
@@ -1611,13 +1616,14 @@ dummy_func(
             for (int i = oparg; --i >= 0; ) {
                 *values++ = PyStackRef_FromPyObjectNew(items[i]);
             }
-            DECREF_INPUTS();
+            s = seq;
+            INPUTS_DEAD();
         }
 
         macro(UNPACK_SEQUENCE_LIST) =
-            _GUARD_TOS_LIST + unused/1 + _UNPACK_SEQUENCE_LIST;
+            _GUARD_TOS_LIST + unused/1 + _UNPACK_SEQUENCE_LIST + POP_TOP;
 
-        op(_UNPACK_SEQUENCE_LIST, (seq -- values[oparg])) {
+        op(_UNPACK_SEQUENCE_LIST, (seq -- values[oparg], s)) {
             PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq);
             assert(PyList_CheckExact(seq_o));
             DEOPT_IF(!LOCK_OBJECT(seq_o));
@@ -1631,7 +1637,8 @@ dummy_func(
                 *values++ = PyStackRef_FromPyObjectNew(items[i]);
             }
             UNLOCK_OBJECT(seq_o);
-            DECREF_INPUTS();
+            s = seq;
+            INPUTS_DEAD();
         }
 
         inst(UNPACK_EX, (seq -- unused[oparg & 0xFF], unused, unused[oparg >> 8], top[0])) {