Skip to main content

JitAllocator

Struct JitAllocator 

Source
pub struct JitAllocator { /* private fields */ }
Expand description

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().

Like asmjit’s JitAllocator, this is a low-level interface: Spans are plain handles that do not own their memory. Allocations live until they are passed to JitAllocator::release, or until the allocator is reset or dropped, and it is up to the caller not to use a span past that point.

Implementations§

Source§

impl JitAllocator

Source

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

Creates a new JIT allocator.

Source

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.

§Safety
  • The caller must ensure that no code is currently executing from the memory managed by this allocator.
  • The caller must ensure that no references to the memory managed by this allocator are used after calling this function.
  • The caller must ensure that no other thread is currently accessing the memory managed by this allocator.
Source

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

Allocates size bytes in the executable memory region.

The returned Span holds two pointers. One points to Read-Execute mapping and another to Read-Write mapping. All code writes must go to the Read-Write mapping.

Source

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 on this allocator.
  • rx_ptr must not have been passed to release/shrink before.
  • rx_ptr must point to the read-execute mapping returned by alloc, and no pointer into the released area may be used afterwards.
Source

pub unsafe fn shrink( &mut self, span: &mut Span, new_size: usize, ) -> Result<(), AsmError>

Shrinks the memory allocated by alloc and updates span.size() to match.

A new_size of zero releases the allocation.

§Safety

span must describe a live allocation returned by alloc on this allocator; no pointer into the released tail may be used afterwards.

Source

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

Takes a pointer to the start of an allocation and returns a Span describing its RX and RW mappings and size.

Source

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

Writes through a span and synchronizes the instruction cache.

Makes JIT memory writable for the duration of write_func (MAP_JIT platforms), then flushes the instruction cache for the whole span.

§Safety

span must describe a live allocation of this allocator, write_func must only write inside it and leave valid executable code there, and no thread may execute it while the closure is modifying it.

Source

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

Copies slice into span at offset and synchronizes the written instruction-cache range.

§Safety

span must describe a live allocation of this allocator, and no thread may execute the written range while it is being modified. The range is bounds-checked against span.size().

Trait Implementations§

Source§

impl Drop for JitAllocator

Source§

fn drop(&mut self)

Executes the destructor for this type. Read more
Source§

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)
Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.