STORE_FAST followed by LOAD_FAST of the same thing

[iritkatriel]

I came across this sequence, where we store and then load the same thing:

STORE_FAST x
LOAD_FAST x

it can be replaced by

COPY 1
STORE_FAST x

COPY 1 is probably faster than LOAD_FAST.

I counted them with count_opcodes and it's not very rare - about 0.3% of the opcodes.

Total: 81 errors
19,321 files
423,546 code objects
6,853,770 lines
57,447,759 opcodes
2,800,587 total size of co_consts
344,874 number of co_consts
170,661 store and load same thing

[iritkatriel]

Implemented in a branch so we can measure the impact:

python/cpython@main...iritkatriel:STORE_LOAD_FAST

[gvanrossum]

Hm... LOAD_FAST and COPY do the same except for the NULL check in the former, but that's so fast I doubt there's much gain to be had here. Happy to be proven wrong even by a microbenchmark.

[iritkatriel]

I was thinking GET_LOCAL might be slower than PEEK.

Micro benchmarks show a small impact, maybe too small to matter.

iritkatriel@Irits-MBP cpython-654 % ./vanilla_python.exe -m timeit "x = 42"  "y=x"
20000000 loops, best of 5: 11.9 nsec per loop
iritkatriel@Irits-MBP cpython-654 % ./vanilla_python.exe -m timeit "x = 42"  "y=x"
20000000 loops, best of 5: 11.9 nsec per loop
iritkatriel@Irits-MBP cpython-654 % ./vanilla_python.exe -m timeit "x = 42"  "y=x"
20000000 loops, best of 5: 11.9 nsec per loop


iritkatriel@Irits-MBP cpython-654 % ./opt_python.exe -m timeit "x = 42"  "y=x"
20000000 loops, best of 5: 11.5 nsec per loop
iritkatriel@Irits-MBP cpython-654 % ./opt_python.exe -m timeit "x = 42"  "y=x"
20000000 loops, best of 5: 11.5 nsec per loop
iritkatriel@Irits-MBP cpython-654 % ./opt_python.exe -m timeit "x = 42"  "y=x"
20000000 loops, best of 5: 11.6 nsec per loop

[sweeneyde]

How would this affect line tracing?

def f():
    x = 10
    y \
        = \
        x

def trace(frame, event, arg):
    if event == "line":
        print(frame.f_lineno)
        print(frame.f_locals)
    return trace

import sys
sys.settrace(trace)
f()

Current result

2
{}       
5        
{'x': 10}
3        
{'x': 10}

A super-instruction might be another solution with different tradeoffs (less worry about tracing, a hair more code in the eval loop).

[iritkatriel]

I get

2
{}
3
{'x': 10}

Not sure where 5 went. I thought swapping the line numbers between the instructions would be enough.

I don't think this is big enough to justify a superinstruction. Maybe we can do something more clever later when we look at control flow analysis for reducing refcounts.