Don't freeze code objects

[markshannon]

Code objects are immutable in Python, but the underlying memory is mutated a lot.
Consequently we have various workarounds fixing things up at startup and closedown and don't save much time at startup.

It might be better to deepfreeze the marshal data, rather than the code object.
That way, the marshal data can be marked const.

We can use a more compact form of the bytecode in the marshal format, and generate the adaptive form when marshaling.
This should simplify a number of things, and may well be faster.

• No oparg instructions: 1 byte.
• Instruction with oparg: 2 bytes.
• Caches: 0 bytes (implicit in preceding instruction).

[gvanrossum]

Definitely worth an experiment.

The simplest experiment would be to revert back to just frozen objects, which is marshalled objects (but doesn't have compact bytecode, just unspecialized).

Designing a more compact instruction stream format could be a separate experiment (to be timed using PYC files).

[kumaraditya303]

The main point of deepfreeze is to avoid the expensive un-marshalling step. If immortal objects PEP is accepted then some of the issues related to fixing up at shutdown would be eliminated. Even if un-marshalling process is speed up with using more compact form of the bytecode, still it would require un-marshaling though.

Definitely worth an experiment. The simplest experiment would be to revert back to just frozen objects, which is marshalled objects

IIRC, I had left an option in freeze_module.py to switch to frozen objects instead of deepfrozen code objects.

[lpereira]

One thing to explore is use something like Huffman encoding to try and have a smaller instruction stream for marshalled opcodes. With a hardcoded tree, the decoder can be quite efficient, and we can potentially save up quite a bit.