perf: improve general performance

We try to use sets for quick lookups and cache the result of some
repetitive operations to speed up some operations. We also remove
a good deal of asserts embedded within the code that adde extra
overhead.

Author: P403n1x87

src/bytecode/cfg.py

@@ -57,7 +57,7 @@ def __iter__(self) -> Iterator[Union[Instr, SetLineno, TryBegin, TryEnd]]:
                     isinstance(self[i], Instr) for i in range(index, len(self))
                 ):
                     raise ValueError(
-                        "Only the last instruction of a basic " "block can be a jump"
+                        "Only the last instruction of a basic block can be a jump"
                     )
 
                 if not isinstance(instr.arg, BasicBlock):
@@ -579,7 +579,6 @@ def compute_stacksize(
             if compute_exception_stack_depths:
                 for tb in common.try_begins:
                     size = common.exception_block_startsize[id(tb.target)]
-                    assert size >= 0
                     tb.stack_depth = size
 
             return args
@@ -825,7 +824,6 @@ def from_bytecode(bytecode: _bytecode.Bytecode) -> "ControlFlowGraph":
                 # The last instruction is final, if the current instruction is a
                 # TryEnd insert it in the same block and move to the next instruction
                 if last_instr.is_final() and isinstance(instr, TryEnd):
-                    assert active_try_begin
                     nte = instr.copy()
                     nte.entry = try_begins[active_try_begin][-1]
                     old_block.append(nte)
@@ -874,7 +872,6 @@ def from_bytecode(bytecode: _bytecode.Bytecode) -> "ControlFlowGraph":
             if isinstance(instr, (Instr, TryBegin, TryEnd)):
                 new = instr.copy()
                 if isinstance(instr, TryBegin):
-                    assert active_try_begin is None
                     active_try_begin = instr
                     try_begin_inserted_in_block = True
                     assert isinstance(new, TryBegin)
@@ -968,9 +965,7 @@ def to_bytecode(self) -> _bytecode.Bytecode:
                         # If due to jumps and split TryBegin, we encounter a TryBegin
                         # while we still have a TryBegin ensure they can be fused.
                         if last_try_begin is not None:
-                            cfg_tb, byt_tb = last_try_begin
-                            assert instr.target is cfg_tb.target
-                            assert instr.push_lasti == cfg_tb.push_lasti
+                            _, byt_tb = last_try_begin
                             byt_tb.stack_depth = min(
                                 byt_tb.stack_depth, instr.stack_depth
                             )
@@ -989,7 +984,6 @@ def to_bytecode(self) -> _bytecode.Bytecode:
                                 # If we did not yet compute the required stack depth
                                 # keep the value as UNSET
                                 if entry.stack_depth is UNSET:
-                                    assert instr.stack_depth is UNSET
                                     byt_te.entry.stack_depth = UNSET
                                 else:
                                     byt_te.entry.stack_depth = min(

src/bytecode/concrete.py

@@ -55,6 +55,12 @@
 # - dis displays bytes
 OFFSET_AS_INSTRUCTION = sys.version_info >= (3, 10)
 
+HAS_CONST = set(_opcode.hasconst)
+HAS_LOCAL = set(_opcode.haslocal)
+HAS_NAME = set(_opcode.hasname)
+HAS_FREE = set(_opcode.hasfree)
+HAS_COMPARE = set(_opcode.hascompare)
+
 
 def _set_docstring(code: _bytecode.BaseBytecode, consts: Sequence) -> None:
     if not consts:
@@ -458,9 +464,6 @@ def _assemble_lnotab(
                 doff = 0
                 dlineno -= 127
 
-            assert 0 <= doff <= 255
-            assert -128 <= dlineno <= 127
-
             lnotab.append(struct.pack("Bb", doff, dlineno))
 
         return b"".join(lnotab)
@@ -480,7 +483,6 @@ def _pack_linetable(
                 linetable.append(struct.pack("Bb", 0, 127))
                 dlineno -= 127
 
-            assert -127 <= dlineno <= 127
         else:
             dlineno = -128
 
@@ -500,8 +502,6 @@ def _pack_linetable(
         else:
             linetable.append(struct.pack("Bb", doff, dlineno))
 
-        assert 0 <= doff <= 254
-
     # Used on 3.10
     def _assemble_linestable(
         self,
@@ -620,9 +620,6 @@ def _pack_location(
 
         # We enforce the end_lineno to be defined
         else:
-            assert end_lineno is not None
-            assert end_col_offset is not None
-
             # Short forms
             if (
                 end_lineno == l_lineno
@@ -792,7 +789,6 @@ def _parse_varint(except_table_iterator: Iterator[int]) -> int:
     def _parse_exception_table(
         self, exception_table: bytes
     ) -> List[ExceptionTableEntry]:
-        assert sys.version_info >= (3, 11)
         table = []
         iterator = iter(exception_table)
         try:
@@ -813,7 +809,6 @@ def _encode_varint(value: int, set_begin_marker: bool = False) -> Iterator[int]:
         # Encode value as a varint on 7 bits (MSB should come first) and set
         # the begin marker if requested.
         temp: List[int] = []
-        assert value >= 0
         while value:
             temp.append(value & 63 | (64 if temp else 0))
             value >>= 6
@@ -949,7 +944,6 @@ def to_bytecode(
         for entry in self.exception_table:
             # Ensure we do not have more than one entry with identical starting
             # offsets
-            assert entry.start_offset not in ex_start
             ex_start[entry.start_offset] = entry
             ex_end.setdefault(entry.stop_offset, []).append(entry)
 
@@ -1018,33 +1012,35 @@ def to_bytecode(
             # We are careful to first advance the offset and check that the CACHE
             # is not a jump target. It should never be the case but we double check.
             if prune_caches and c_instr.name == "CACHE":
-                assert jump_target is None
+                if jump_target is not None:
+                    msg = "cache instruction cannot have jump target"
+                    raise ValueError(msg)
 
             # We may need to insert a TryEnd after a CACHE so we need to run the
             # through the last block.
             else:
                 arg: InstrArg
                 c_arg = c_instr.arg
                 # FIXME: better error reporting
-                if c_instr.opcode in _opcode.hasconst:
+                if c_instr.opcode in HAS_CONST:
                     arg = self.consts[c_arg]
-                elif c_instr.opcode in _opcode.haslocal:
+                elif c_instr.opcode in HAS_LOCAL:
                     arg = self.varnames[c_arg]
-                elif c_instr.opcode in _opcode.hasname:
+                elif c_instr.opcode in HAS_NAME:
                     if c_instr.name in BITFLAG_INSTRUCTIONS:
                         arg = (bool(c_arg & 1), self.names[c_arg >> 1])
                     elif c_instr.name in BITFLAG2_INSTRUCTIONS:
                         arg = (bool(c_arg & 1), bool(c_arg & 2), self.names[c_arg >> 2])
                     else:
                         arg = self.names[c_arg]
-                elif c_instr.opcode in _opcode.hasfree:
+                elif c_instr.opcode in HAS_FREE:
                     if c_arg < ncells:
                         name = cells_lookup[c_arg]
                         arg = CellVar(name)
                     else:
                         name = self.freevars[c_arg - ncells]
                         arg = FreeVar(name)
-                elif c_instr.opcode in _opcode.hascompare:
+                elif c_instr.opcode in HAS_COMPARE:
                     arg = Compare(
                         (c_arg >> 4) if sys.version_info >= (3, 12) else c_arg
                     )
@@ -1120,7 +1116,6 @@ class _ConvertBytecodeToConcrete:
     _compute_jumps_passes = 10
 
     def __init__(self, code: _bytecode.Bytecode) -> None:
-        assert isinstance(code, _bytecode.Bytecode)
         self.bytecode = code
 
         # temporary variables
@@ -1180,8 +1175,8 @@ def concrete_instructions(self) -> None:
                             ConcreteInstr(
                                 "CACHE", 0, location=self.instructions[-1].location
                             )
-                            for i in range(self.required_caches)
                         ]
+                        * self.required_caches
                     )
                     self.required_caches = 0
                     self.seen_manual_cache = False
@@ -1201,7 +1196,6 @@ def concrete_instructions(self) -> None:
 
             if isinstance(instr, TryBegin):
                 # We expect the stack depth to have be provided or computed earlier
-                assert instr.stack_depth is not UNSET
                 # NOTE here we store the index of the instruction at which the
                 # exception table entry starts. This is not the final value we want,
                 # we want the offset in the bytecode but that requires to compute
@@ -1235,43 +1229,28 @@ def concrete_instructions(self) -> None:
                 # fake value, real value is set in compute_jumps()
                 arg = 0
                 is_jump = True
-            elif instr.opcode in _opcode.hasconst:
+            elif instr.opcode in HAS_CONST:
                 arg = self.add_const(arg)
-            elif instr.opcode in _opcode.haslocal:
+            elif instr.opcode in HAS_LOCAL:
                 assert isinstance(arg, str)
                 arg = self.add(self.varnames, arg)
-            elif instr.opcode in _opcode.hasname:
+            elif instr.opcode in HAS_NAME:
                 if instr.name in BITFLAG_INSTRUCTIONS:
-                    assert (
-                        isinstance(arg, tuple)
-                        and len(arg) == 2
-                        and isinstance(arg[0], bool)
-                        and isinstance(arg[1], str)
-                    ), arg
                     index = self.add(self.names, arg[1])
                     arg = int(arg[0]) + (index << 1)
                 elif instr.name in BITFLAG2_INSTRUCTIONS:
-                    assert (
-                        isinstance(arg, tuple)
-                        and len(arg) == 3
-                        and isinstance(arg[0], bool)
-                        and isinstance(arg[1], bool)
-                        and isinstance(arg[2], str)
-                    ), arg
                     index = self.add(self.names, arg[2])
                     arg = int(arg[0]) + 2 * int(arg[1]) + (index << 2)
                 else:
-                    assert isinstance(arg, str), f"Got {arg}, expected a str"
                     arg = self.add(self.names, arg)
-            elif instr.opcode in _opcode.hasfree:
+            elif instr.opcode in HAS_FREE:
                 if isinstance(arg, CellVar):
                     cell_instrs.append(len(self.instructions))
                     arg = self.bytecode.cellvars.index(arg.name)
                 else:
-                    assert isinstance(arg, FreeVar)
                     free_instrs.append(len(self.instructions))
                     arg = self.bytecode.freevars.index(arg.name)
-            elif instr.opcode in _opcode.hascompare:
+            elif instr.opcode in HAS_COMPARE:
                 if isinstance(arg, Compare):
                     # In Python 3.12 the 4 lowest bits are used for caching
                     # See compare_masks in compile.c
@@ -1284,7 +1263,6 @@ def concrete_instructions(self) -> None:
                     arg = arg.value
 
             # The above should have performed all the necessary conversion
-            assert isinstance(arg, int)
             c_instr = ConcreteInstr(instr.name, arg, location=instr.location)
             if is_jump:
                 self.jumps.append((len(self.instructions), label, c_instr))

src/bytecode/instr.py

@@ -4,6 +4,7 @@
 import sys
 from abc import abstractmethod
 from dataclasses import dataclass
+from functools import cache
 from marshal import dumps as _dumps
 from typing import Any, Callable, Dict, Generic, Optional, Tuple, TypeVar, Union
 
@@ -21,23 +22,23 @@
 # Instructions relying on a bit to modify its behavior.
 # The lowest bit is used to encode custom behavior.
 BITFLAG_INSTRUCTIONS = (
-    ("LOAD_GLOBAL", "LOAD_ATTR")
+    {"LOAD_GLOBAL", "LOAD_ATTR"}
     if sys.version_info >= (3, 12)
-    else ("LOAD_GLOBAL",)
+    else {"LOAD_GLOBAL"}
     if sys.version_info >= (3, 11)
-    else ()
+    else set()
 )
 
-BITFLAG2_INSTRUCTIONS = ("LOAD_SUPER_ATTR",) if sys.version_info >= (3, 12) else ()
+BITFLAG2_INSTRUCTIONS = {"LOAD_SUPER_ATTR"} if sys.version_info >= (3, 12) else set()
 
 # Intrinsic related opcodes
 INTRINSIC_1OP = (
-    (_opcode.opmap["CALL_INTRINSIC_1"],) if sys.version_info >= (3, 12) else ()
+    {_opcode.opmap["CALL_INTRINSIC_1"]} if sys.version_info >= (3, 12) else set()
 )
 INTRINSIC_2OP = (
-    (_opcode.opmap["CALL_INTRINSIC_2"],) if sys.version_info >= (3, 12) else ()
+    {_opcode.opmap["CALL_INTRINSIC_2"]} if sys.version_info >= (3, 12) else set()
 )
-INTRINSIC = INTRINSIC_1OP + INTRINSIC_2OP
+INTRINSIC = INTRINSIC_1OP | INTRINSIC_2OP
 
 
 # Used for COMPARE_OP opcode argument
@@ -242,25 +243,26 @@ class FreeVar(_Variable):
 def _check_arg_int(arg: Any, name: str) -> TypeGuard[int]:
     if not isinstance(arg, int):
         raise TypeError(
-            "operation %s argument must be an int, "
-            "got %s" % (name, type(arg).__name__)
+            "operation %s argument must be an int, got %s" % (name, type(arg).__name__)
         )
 
     if not (0 <= arg <= 2147483647):
         raise ValueError(
-            "operation %s argument must be in " "the range 0..2,147,483,647" % name
+            "operation %s argument must be in the range 0..2,147,483,647" % name
         )
 
     return True
 
 
 if sys.version_info >= (3, 12):
 
+    @cache
     def opcode_has_argument(opcode: int) -> bool:
         return opcode in dis.hasarg
 
 else:
 
+    @cache
     def opcode_has_argument(opcode: int) -> bool:
         return opcode >= dis.HAVE_ARGUMENT
 
@@ -628,11 +630,9 @@ def stack_effect(self, jump: Optional[bool] = None) -> int:
         # 3.11 where LOAD_GLOBAL arg encode whether or we push a null
         # 3.12 does the same for LOAD_ATTR
         elif self.name in BITFLAG_INSTRUCTIONS and isinstance(self._arg, tuple):
-            assert len(self._arg) == 2
             arg = self._arg[0]
         # 3.12 does a similar trick for LOAD_SUPER_ATTR
         elif self.name in BITFLAG2_INSTRUCTIONS and isinstance(self._arg, tuple):
-            assert len(self._arg) == 3
             arg = self._arg[0]
         elif not isinstance(self._arg, int) or self._opcode in _opcode.hasconst:
             # Argument is either a non-integer or an integer constant,
@@ -845,13 +845,9 @@ def _check_arg(self, name: str, opcode: int, arg: InstrArg) -> None:
 
         elif opcode in _opcode.hasconst:
             if isinstance(arg, Label):
-                raise ValueError(
-                    "label argument cannot be used " "in %s operation" % name
-                )
+                raise ValueError("label argument cannot be used in %s operation" % name)
             if isinstance(arg, _bytecode.BasicBlock):
-                raise ValueError(
-                    "block argument cannot be used " "in %s operation" % name
-                )
+                raise ValueError("block argument cannot be used in %s operation" % name)
 
         elif opcode in _opcode.hascompare:
             if not isinstance(arg, Compare):