GH-96793: Specialize FOR_ITER for generators.

[markshannon]

Performance results seem to be just noise. I suspect there aren't enough uses of generators in the benchmark suite for this to make a difference.

• Issue: Enable specialization of iteration over generators, for gen():, and awaiting coroutines, await coro() #96793

[markshannon]

There is a bug in this. It doesn't set the gi_exc_state stack.

[markshannon]

https://github.com/python/cpython/compare/main...faster-cpython:cpython:specialize-for-iter-gen-handle-exc-stack?expand=1
fixes the gi_exc_state issue, but is messy. I think this would benefit from merging #96319 first

[iritkatriel]

Why is this called "yield_offset", is it not the relative offset to jump by when the generator is exhausted? (the same as the arg to FOR_ITER?)

[markshannon]

Because it's the offset for YIELD_VALUE to return to relative to RETURN_VALUE
https://github.com/python/cpython/pull/98772/files#diff-c22186367cbe20233e843261998dc027ae5f1f8c0d2e778abfa454ae74cc59deR2087

[kumaraditya303]

I suspect there aren't enough uses of generators in the benchmark suite for this to make a difference.

You can run https://github.com/python/pyperformance/blob/main/pyperformance/data-files/benchmarks/bm_generators/run_benchmark.py, it is specifically designed to benchmark generators (microbenchmark).

[markshannon]

I'll run that benchmark if pyperformance ever does another release.

[markshannon]

I'm seeing a 35% speedup on this benchmark:

Tree iterator

import timeit

class Tree:
    def __init__(self, left, value, right):
        self.left = left
        self.value = value
        self.right = right


    def __iter__(self):
        if self.left:
            for item in self.left:
                yield item
        yield self.value
        if self.right:
            for item in self.right:
                yield item

def tree(input: range) -> Tree | None:
    n = len(input)
    if n == 0:
        return None
    i = n // 2
    return Tree(tree(input[:i]), input[i], tree(input[i + 1:]))

def setup():
    global iterable
    assert list(tree(range(10))) == list(range(10))
    iterable = tree(range(100000))
    
print(timeit.timeit("for _ in iterable: pass", "setup()", globals=globals(), number=10))

Note that this uses yield not yield from. yield from compiles to the SEND instruction which is for another PR.

---

And a 36% speedup on this one:

Flat iterator

import timeit

class RangeWrapper:
    def __init__(self, n):
        self.r = range(n)

    def __iter__(self):
        for item in self.r:
            yield item

def setup():
    global iterable
    iterable = RangeWrapper(1000000)

print(timeit.timeit("for _ in iterable: pass", "setup()", globals=globals(), number=10))

---

Comparing the fastest of 6 runs for main and this PR.