Make generator (and coroutine) creation explicit in the bytecode. #217

markshannon · 2022-01-10T12:20:56Z

markshannon
Jan 10, 2022
Collaborator

The basic idea is to have a instruction that makes a generator (or coroutine) from the current frame and immediately returns it.
So the code for

def gen():
     yield 1

would change from

              POP_TOP

  1           RESUME                   0

  2           LOAD_CONST               1 (1)
              YIELD_VALUE
              RESUME                   1
              POP_TOP
              LOAD_CONST               0 (None)
              RETURN_VALUE

to

              GEN_CREATE
              RETURN_VALUE
              POP_TOP

  1           RESUME                   0

  2           LOAD_CONST               1 (1)
              YIELD_VALUE
              RESUME                   1
              POP_TOP
              LOAD_CONST               0 (None)
              RETURN_VALUE

The GEN_CREATE instruction would create the generator and clear the current frame. The reason for clearing the current frame, is to avoid lots of Py_INCREFs. Moving all references from the frame to the generator can be done cheaply with a memcpy.

I've been in two minds about this change until recently.
It has a certain elegance, and removes the code for special casing calls to generator functions.
But, until now, it was not the most efficient way to create a generator.

Treating calls to generator functions specially had the advantage that we could potentially specialize calls to generator functions at the call site, which would be more efficient than making the call and returning a generator.

However, with #210, specialization for generator creation would effectively need us to call a special generator-creating function, which is what we will be doing anyway with the new bytecode. In other words, this approach is now the fastest approach that I am aware of, plus it is simpler and doesn't prevent specializations of complex calls.