Struct mmtk::util::alloc::large_object_allocator::LargeObjectAllocator

#[repr(C)]
pub struct LargeObjectAllocator<VM: VMBinding> {
    pub tls: VMThread,
    space: &'static LargeObjectSpace<VM>,
    context: Arc<AllocatorContext<VM>>,
}

An allocator that only allocates at page granularity. This is intended for large objects.

Fields

tls: VMThread

VMThread associated with this allocator instance

space: &'static LargeObjectSpace<VM>

Space instance associated with this allocator instance.

context: Arc<AllocatorContext<VM>>

Implementations

impl<VM: VMBinding> LargeObjectAllocator<VM>

pub(crate) fn new( tls: VMThread, space: &'static LargeObjectSpace<VM>, context: Arc<AllocatorContext<VM>> ) -> Self

Trait Implementations

impl<VM: VMBinding> Allocator<VM> for LargeObjectAllocator<VM>

fn get_tls(&self) -> VMThread

Return the VMThread associated with this allocator instance.

fn get_context(&self) -> &AllocatorContext<VM>

Return the context for the allocator.

fn get_space(&self) -> &'static dyn Space<VM>

Return the Space instance associated with this allocator instance.

fn does_thread_local_allocation(&self) -> bool

Return if this allocator can do thread local allocation. If an allocator does not do thread local allocation, each allocation will go to slowpath and will have a check for GC polls.

fn alloc(&mut self, size: usize, align: usize, offset: usize) -> Address

An allocation attempt. The implementation of this function depends on the allocator used. If an allocator supports thread local allocations, then the allocation will be serviced from its TLAB, otherwise it will default to using the slowpath, i.e. alloc_slow.

fn alloc_slow_once( &mut self, size: usize, align: usize, _offset: usize ) -> Address

Single slow path allocation attempt. This is called by alloc_slow_inline. The implementation of this function depends on the allocator used. Generally, if an allocator supports thread local allocations, it will try to allocate more TLAB space here. If it doesn’t, then (generally) the allocator simply allocates enough space for the current object.

fn get_thread_local_buffer_granularity(&self) -> usize

Return at which granularity the allocator acquires memory from the global space and use them as thread local buffer. For example, the BumpAllocator acquires memory at 32KB blocks. Depending on the actual size for the current object, they always acquire memory of N*32KB (N>=1). Thus the BumpAllocator returns 32KB for this method. Only allocators that do thread local allocation need to implement this method.

fn alloc_slow(&mut self, size: usize, align: usize, offset: usize) -> Address

Slowpath allocation attempt. This function is explicitly not inlined for performance considerations.

fn alloc_slow_inline( &mut self, size: usize, align: usize, offset: usize ) -> Address

Slowpath allocation attempt. This function executes the actual slowpath allocation. A slowpath allocation in MMTk attempts to allocate the object using the per-allocator definition of alloc_slow_once. This function also accounts for increasing the allocation bytes in order to support stress testing. In case precise stress testing is being used, the alloc_slow_once_precise_stress function is used instead.

fn alloc_slow_once_traced( &mut self, size: usize, align: usize, offset: usize ) -> Address

A wrapper method for alloc_slow_once to insert USDT tracepoints.

fn alloc_slow_once_precise_stress( &mut self, size: usize, align: usize, offset: usize, need_poll: bool ) -> Address

Single slowpath allocation attempt for stress test. When the stress factor is set (e.g. to N), we would expect for every N bytes allocated, we will trigger a stress GC. However, for allocators that do thread local allocation, they may allocate from their thread local buffer which does not have a GC poll check, and they may even allocate with the JIT generated allocation fastpath which is unaware of stress test GC. For both cases, we are not able to guarantee a stress GC is triggered every N bytes. To solve this, when the stress factor is set, we will call this method instead of the normal alloc_slow_once(). We expect the implementation of this slow allocation will trick the fastpath so every allocation will fail in the fastpath, jump to the slow path and eventually call this method again for the actual allocation.

fn on_mutator_destroy(&mut self)

The crate::plan::Mutator that includes this allocator is going to be destroyed. Some allocators may need to save/transfer its thread local data to the space.