Compact code object marshaled form and pre-quicken bytecode when unmarshaling

[markshannon]

Currently we go through a two stage process to get to the adaptive form of instructions.
The explanation below uses CALL, but it applies to all specializable instructions.

1. When unmarshaling the code object we create the bytecode CALL, oparg, 0, 0, 0 ... where the zeros are the cache.
2. When executing, check a counter and quicken when that counter reaches zero.
3. When quickening, replace all CALLs with CALL_ADAPTIVEs.

Instead we should quicken when unmarshaling, so that we create:

(CALL_ADAPTIVE oparg)
7 # uint16_t not byte pair
...

instead of

(CALL oparg)
(0 0)

The marshaled form only needs one byte for instructions without an oparg and two for other instructions. No space is needed for the cache.

[ericsnowcurrently]

Presumably the same idea would apply to deep-frozen code objects?

[gvanrossum]

I see loading marshalled code as equivalent to compiling it. So if we want unmarshalling to put the adaptive bytecodes in, we should do the same for the compiler -- IOW we should quicken everything immediately.

Unmarshalling results in exactly the same tree of code objects (module -> classes -> methods etc.) and compiling.

[markshannon]

Yes, it is the same, provided that [un]marshaling handles the bytecode as an array of code units which it compresses, not just an array of bytes.

[gvanrossum]

Yes, it is the same

Was this in response to Eric's question about deepfreeze, or mine about unmarshal vs. compiler?

[markshannon]

Yes, it is the same

Was this in response to Eric's question about deepfreeze, or mine about unmarshal vs. compiler?

Yours.
The compiler would emit the adaptive instructions directly (we can drop the non-adaptive forms), then mashal would store them in the compact form, and unmarshal would expand them.

[markshannon]

But we need to change marshaling first, so that it understands that code is made up of 16bit code units, not just bytes.

[gvanrossum]

But we need to change marshaling first, so that it understands that code is made up of 16bit code units, not just bytes.

To marshal a code object, we get the bytecode as a bytes object by calling _PyCode_GetCode(co). Any compression that requires knowledge of the code format can be placed in that function, as long as we also update the corresponding unmarshalling code, which calls _PyCode_Validate() and _PyCode_New().

(Likely we would design a new, slightly different API, but my point is that we can implement and test the bytecode compression first, and then using it from marshal.c would be straightforward.)