Struct JitAllocator 

pub struct JitAllocator { /* private fields */ }

A simple implementation of memory manager that uses virtual_memory. functions to manage virtual memory for JIT compiled code.

Implementation notes:

• Granularity of allocated blocks is different than granularity for a typical C malloc. In addition, the allocator can use several memory pools having a different granularity to minimize the maintenance overhead. Multiple pools feature requires use_multiple_pools flag to be set.

• The allocator doesn’t store any information in executable memory, instead, the implementation uses two bit-vectors to manage allocated memory of each allocator-block. The first bit-vector called ‘used’ is used to track used memory (where each bit represents memory size defined by granularity) and the second bit vector called ‘stop’ is used as a sentinel to mark where the allocated area ends.

• Internally, the allocator also uses RB tree to keep track of all blocks across all pools. Each inserted block is added to the tree so it can be matched fast during release() and shrink().

Implementations

impl JitAllocator

pub fn new(params: JitAllocatorOptions) -> Box<Self>

Creates a new JitAllocator instance.

pub unsafe fn reset(&mut self, reset_policy: ResetPolicy)

Resets current allocator by emptying all pools and blocks.

Frees all memory is ResetPolicy::Hard is specified or immediate_release in JitAllocatorOptions is specific.

pub fn alloc(&mut self, size: usize) -> Result<Span, AsmError>

Allocates size bytes in the executable memory region. Returns two pointers. One points to Read-Execute mapping and another to Read-Write mapping. All code writes must go to the Read-Write mapping.

pub unsafe fn release(&mut self, rx_ptr: *const u8) -> Result<(), AsmError>

Releases the memory allocated by alloc.

SAFETY

• rx_ptr must have been returned from alloc
• rx_ptr must have been allocaetd from this allocator
• rx_ptr must not have been passed to release before
• rx_ptr must point to read-execute part of memory returned from alloc.

pub unsafe fn shrink( &mut self, rx_ptr: *const u8, new_size: usize, ) -> Result<(), AsmError>

Shrinks the memory allocated by alloc.

SAFETY

rx_ptr must be a pointer returned by alloc.

pub fn query(&self, rx_ptr: *const u8) -> Result<Span, AsmError>

Takes a pointer into the JIT memory and tries to query RX, RW mappings and size of the allocation.

pub unsafe fn write( &mut self, span: &mut Span, write_func: impl FnMut(&mut Span), ) -> Result<(), AsmError>

Writes to the memory referenced by span using write_func and then flushes the instruction cache for that memory range.

SAFETY

• span must reference a valid memory range allocated by this allocator.
• write_func must only write to the memory range referenced by span.
• After write_func is called, the memory range referenced by span must contain valid executable code.
• The caller must ensure that no other threads are executing code in the memory range referenced by span while write_func is modifying it.

pub unsafe fn copy_from_slice( &mut self, span: &mut Span, offset: usize, slice: &[u8], ) -> Result<(), AsmError>

Trait Implementations

impl Send for JitAllocator