Despite our best intentions, we currently don't handle polymorphism at all in tier two, since our current forward progress requirement means that we need to deopt the first instruction of every new trace.

This changes our trace stitching for side exits to not require progress until a certain tree depth is reached (currently four). It also changes the optimizer to rejoin with any traces encountered during projection, since this does a better job of keeping us on trace in loops (we can take four side exits per iteration before requiring progress) and keeps the amount of tier two code from exploding.

As a simple microbenchmark, this goes from ~10% slower when run with the JIT enabled to ~25% faster after this change.

class A:
    def f(self):
        return True

class B:
    def f(self):
        return False

def main():
    a, b = A(), B()
    for _ in range(100_000_000):
        a, b = b, a
        a.f()

main()

Overall, the benchmarks are 0.6% faster, including nice improvements on all of our interpreter-heavy benchmarks. The stats show that we're actually executing more traces and a bit (~1%) more tier one code now, but that's expected since side exit chains require up to 4x as much "warming up" as before.

• Issue: Increase fraction of code executed by tier 2. #118093