Allocate JIT memory in large chunks near the executable

By allocating JIT memory in large chunks we can reduce the overhead of compilation and possibly speed up the compiled code a bit.

Currently, when we need to allocate memory for the JIT, we ask the OS for a sufficiently large chunk of virtual memory. This is simple and reasonably efficient. It does have a few flaws:

1. We need to create DWARF debug info and register it for each trace
2. We need to make a syscall to get memory for each trace
3. We have no control over the location of the jitted code, meaning that calls in the executable may need trampolines

By allocating large chunks we can reduce the overhead of (1) and (2) to once per-chunk, not per trace.
By allocating large chunks we can also afford the additional overhead of requesting memory near to the executable.

How it would work:

• When we need memory for jitted code, we request it from our special allocator.
• When the allocator needs memory, it requests it from the OS, making several requests for it near the executable before accepting an location
• The allocator itself will be a standard obmalloc/jemalloc style block allocator

Size classes and fragmentation:

All jitted code will need to page aligned, so blocks will need to a multiple of the page size.
With 4 size classes per power of 2 increase in size (like jemalloc) and assuming 2M chunks we get relatively little internal fragmentation, but potential quite a lot of external fragmentation as there would be around 20 size classes.
The external fragmentation can be mitigated by allowing the OS to lazily allocate the pages on demand.

API

The _PyObject_VirtualAlloc function will need extending (or a new function added) to allow the desired address to be passed, so the allocator can get blocks near the executable.

The jit_alloc function's API will be unchanged.

首先跟踪通过 _PyObject_VirtualAlloc 和 jit_alloc 的 JIT 分配路径，然后检查现有的虚拟内存分配行为。当 JIT 内存从可执行文件附近的大型页对齐块中获取、每个块都进行 DWARF 注册且 jit_alloc API 保持不变时，这项工作就完成了。