Peephole Optimizer

Peephole optimizer: optimize Python code objects. It is implemented with the BytecodeBlocks class.

It is based on the peephole optimizer of CPython 3.6 which is written in C.

API

Content of the bytecode.peephole_opt module:

class PeepholeOptimizer

optimize(code: types.CodeType) → types.CodeType

Optimize a Python code object.

Return a new optimized Python code object.

Note: This method will disassemble code to a ConcreteBytecode, then a Bytecode, then a ControlFlowGraph. Then the CFG is optimized. And then the optimized CFG is converted back to a Bytecode, ConcreteBytecode, and then code. Depending on what you are doing you may get better performance by calling optimize_cfg().

optimize_cfg(cfg: ControlFlowGraph): Optimizes an existing ControlFlowGraph. The specified CFG is modified in-place.

class CodeTransformer

Code transformer for the API of the PEP 511 (API for code transformers).

code_transformer(code, context)

Run the PeepholeOptimizer optimizer on the code.

Return a new optimized Python code object.

Example

Code:

import dis
from bytecode.peephole_opt import PeepholeOptimizer

code = compile('print(5+5)', '<string>', 'exec')
print("Non-optimized:")
dis.dis(code)
print()

code = PeepholeOptimizer().optimize(code)
print("Optimized:")
dis.dis(code)

Output of Python 3.6 patched with the PEP 511 with python -o noopt (to disable the builtin peephole optimizer):

Non-optimized:
  1           0 LOAD_NAME                0 (print)
              3 LOAD_CONST               0 (5)
              6 LOAD_CONST               0 (5)
              9 BINARY_ADD
             10 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             13 POP_TOP
             14 LOAD_CONST               1 (None)
             17 RETURN_VALUE

Optimized:
  1           0 LOAD_NAME                0 (print)
              3 LOAD_CONST               0 (10)
              6 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
              9 POP_TOP
             10 LOAD_CONST               1 (None)
             13 RETURN_VALUE

Optimizations

Optimizations implemented in the peephole optimizer:

Constant folding
- unary operations: +a, -a, ~a
- binary operations:
  - a + b, a - b, a * b, a / b, a // b, a % b, a ** b
  - a << b, a >> b, a & b, a | b, a ^ b
- BUILD_TUPLE: convert to a constant
- Replace BUILD_TUPLE <n> + UNPACK_SEQUENCE <n> and BUILD_LIST <n> + UNPACK_SEQUENCE <n> with ROT_TWO (2 arguments) or ROT_THREE+ROT_TWO (3 arguments). For BUILD_LIST, if inputs are LOAD_CONST, rewrite LOAD_CONST in the reverse order.
- BUILD_LIST + COMPARE_OP(in/not in): convert list to tuple
- BUILD_SET + COMPARE_OP(in/not in): convert set to frozenset
- COMPARE_OP:
  - replace not(a is b) with a is not b
  - replace not(a is not b) with a is b
  - replace not(a in b) with a not in b
  - replace not(a not in b) with a in b
Remove NOP instructions
Dead code elimination
- Remove unreachable code after a final operation (Instr.is_final())
- Remove unreachable blocks (Block)
Replace UNARY_NOT+POP_JUMP_IF_FALSE with POP_JUMP_IF_TRUE
Optimize jumps
- Replace unconditional jumps to RETURN_VALUE with RETURN_VALUE
- Replace jumps to unconditional jumps with jumps to the final target
- Remove unconditional jumps to the following block

For tuples, constant folding is only run if the result has 20 items or less.

By design, only basic optimizations can be implemented. A peephole optimizer has a narrow view on the bytecode (a few instructions) and only a very limited knownledge of the code.

Note

3 < 5 or (1, 2, 3)[1] are not optimized.