Struct mmtk::policy::immix::immixspace::ImmixSpace

pub struct ImmixSpace<VM: VMBinding> {
    common: CommonSpace<VM>,
    pr: BlockPageResource<VM, Block>,
    pub chunk_map: ChunkMap,
    pub line_mark_state: AtomicU8,
    line_unavail_state: AtomicU8,
    pub reusable_blocks: ReusableBlockPool,
    pub(super) defrag: Defrag,
    lines_consumed: AtomicUsize,
    mark_state: u8,
    scheduler: Arc<GCWorkScheduler<VM>>,
    space_args: ImmixSpaceArgs,
}

Fields

common: CommonSpace<VM>

pr: BlockPageResource<VM, Block>

chunk_map: ChunkMap

Allocation status for all chunks in immix space

line_mark_state: AtomicU8

Current line mark state

line_unavail_state: AtomicU8

Line mark state in previous GC

reusable_blocks: ReusableBlockPool

A list of all reusable blocks

defrag: Defrag

Defrag utilities

lines_consumed: AtomicUsize

How many lines have been consumed since last GC?

mark_state: u8

Object mark state

scheduler: Arc<GCWorkScheduler<VM>>

Work packet scheduler

space_args: ImmixSpaceArgs

Some settings for this space

Implementations

impl<VM: VMBinding> ImmixSpace<VM>

const UNMARKED_STATE: u8 = 0u8

const MARKED_STATE: u8 = 1u8

fn side_metadata_specs() -> Vec<SideMetadataSpec>

Get side metadata specs

pub fn new( args: PlanCreateSpaceArgs<'_, VM>, space_args: ImmixSpaceArgs ) -> Self

pub fn flush_page_resource(&self)

Flush the thread-local queues in BlockPageResource

pub fn defrag_headroom_pages(&self) -> usize

Get the number of defrag headroom pages.

pub fn in_defrag(&self) -> bool

Check if current GC is a defrag GC.

pub fn decide_whether_to_defrag( &self, emergency_collection: bool, collect_whole_heap: bool, collection_attempts: usize, user_triggered_collection: bool, full_heap_system_gc: bool ) -> bool

check if the current GC should do defragmentation.

fn scheduler(&self) -> &GCWorkScheduler<VM>

Get work packet scheduler

pub fn prepare(&mut self, major_gc: bool, plan_stats: StatsForDefrag)

pub fn release(&mut self, major_gc: bool)

Release for the immix space.

pub fn end_of_gc(&mut self) -> bool

This is called when a GC finished. Return whether this GC was a defrag GC, as a plan may want to know this.

fn generate_sweep_tasks(&self) -> Vec<Box<dyn GCWork<VM>>>

Generate chunk sweep tasks

pub fn release_block(&self, block: Block)

Release a block.

pub fn get_clean_block(&self, tls: VMThread, copy: bool) -> Option<Block>

Allocate a clean block.

pub fn get_reusable_block(&self, copy: bool) -> Option<Block>

Pop a reusable block from the reusable block list.

pub fn trace_object_without_moving( &self, queue: &mut impl ObjectQueue, object: ObjectReference ) -> ObjectReference

Trace and mark objects without evacuation.

pub fn trace_object_with_opportunistic_copy( &self, queue: &mut impl ObjectQueue, object: ObjectReference, semantics: CopySemantics, worker: &mut GCWorker<VM>, nursery_collection: bool ) -> ObjectReference

Trace object and do evacuation if required.

fn unlog_object_if_needed(&self, object: ObjectReference)

pub fn mark_lines(&self, object: ObjectReference)

Mark all the lines that the given object spans.

fn attempt_mark(&self, object: ObjectReference, mark_state: u8) -> bool

Atomically mark an object.

fn is_marked_with(&self, object: ObjectReference, mark_state: u8) -> bool

Check if an object is marked.

pub(crate) fn is_marked(&self, object: ObjectReference) -> bool

fn is_pinned(&self, _object: ObjectReference) -> bool

Check if an object is pinned.

pub fn get_next_available_lines( &self, search_start: Line ) -> Option<(Line, Line)>

Hole searching.

Linearly scan lines in a block to search for the next hole, starting from the given line. If we find available lines, return a tuple of the start line and the end line (non-inclusive).

Returns None if the search could not find any more holes.

pub fn is_last_gc_exhaustive(did_defrag_for_last_gc: bool) -> bool

pub(crate) fn get_pages_allocated(&self) -> usize

fn post_copy(&self, object: ObjectReference, _bytes: usize)

Post copy routine for Immix copy contexts

Trait Implementations

impl<VM: VMBinding> PolicyTraceObject<VM> for ImmixSpace<VM>

fn trace_object<Q: ObjectQueue, const KIND: u8>( &self, queue: &mut Q, object: ObjectReference, copy: Option<CopySemantics>, worker: &mut GCWorker<VM> ) -> ObjectReference

Trace object in the policy. If the policy copies objects, we should expect copy to be a Some value.

fn post_scan_object(&self, object: ObjectReference)

Policy-specific post-scan-object hook. It is called after scanning each object in this space.

fn may_move_objects<const KIND: u8>() -> bool

Return whether the policy moves objects.

impl<VM: VMBinding> SFT for ImmixSpace<VM>

fn name(&self) -> &str

The space name

fn get_forwarded_object( &self, object: ObjectReference ) -> Option<ObjectReference>

Get forwarding pointer if the object is forwarded.

fn is_live(&self, object: ObjectReference) -> bool

Is the object live, determined by the policy?

fn pin_object(&self, object: ObjectReference) -> bool

fn unpin_object(&self, object: ObjectReference) -> bool

fn is_object_pinned(&self, object: ObjectReference) -> bool

fn is_movable(&self) -> bool

Is the object movable, determined by the policy? E.g. the policy is non-moving, or the object is pinned.

fn is_sane(&self) -> bool

Is the object sane? A policy should return false if there is any abnormality about object - the sanity checker will fail if an object is not sane.

fn initialize_object_metadata(&self, _object: ObjectReference, _alloc: bool)

Initialize object metadata (in the header, or in the side metadata).

fn is_mmtk_object(&self, addr: Address) -> Option<ObjectReference>

Is addr a valid object reference to an object allocated in this space? This default implementation works for all spaces that use MMTk’s mapper to allocate memory. Some spaces, like MallocSpace, use third-party libraries to allocate memory. Such spaces needs to override this method.

fn find_object_from_internal_pointer( &self, ptr: Address, max_search_bytes: usize ) -> Option<ObjectReference>

fn sft_trace_object( &self, _queue: &mut VectorObjectQueue, _object: ObjectReference, _worker: GCWorkerMutRef<'_> ) -> ObjectReference

Trace objects through SFT. This along with SFTProcessEdges provides an easy way for most plans to trace objects without the need to implement any plan-specific code. However, tracing objects for some policies are more complicated, and they do not provide an implementation of this method. For example, mark compact space requires trace twice in each GC. Immix has defrag trace and fast trace.

fn is_reachable(&self, object: ObjectReference) -> bool

Is the object reachable, determined by the policy? Note: Objects in ImmortalSpace may have is_live = true but are actually unreachable.

fn is_in_space(&self, _object: ObjectReference) -> bool

Is the object managed by MMTk? For most cases, if we find the sft for an object, that means the object is in the space and managed by MMTk. However, for some spaces, like MallocSpace, we mark the entire chunk in the SFT table as a malloc space, but only some of the addresses in the space contain actual MMTk objects. So they need a further check.

impl<VM: VMBinding> Space<VM> for ImmixSpace<VM>

fn as_space(&self) -> &dyn Space<VM>

fn as_sft(&self) -> &(dyn SFT + Sync + 'static)

fn get_page_resource(&self) -> &dyn PageResource<VM>

fn maybe_get_page_resource_mut(&mut self) -> Option<&mut dyn PageResource<VM>>

Get a mutable reference to the underlying page resource, or None if the space does not have a page resource.

fn common(&self) -> &CommonSpace<VM>

fn initialize_sft(&self, sft_map: &mut dyn SFTMap)

Initialize entires in SFT map for the space. This is called when the Space object has a non-moving address, as we will use the address to set sft. Currently after we create a boxed plan, spaces in the plan have a non-moving address.

fn release_multiple_pages(&mut self, _start: Address)

fn set_copy_for_sft_trace(&mut self, _semantics: Option<CopySemantics>)

What copy semantic we should use for this space if we copy objects from this space. This is only needed for plans that use SFTProcessEdges

fn enumerate_objects(&self, enumerator: &mut dyn ObjectEnumerator)

Enumerate objects in the current space.

fn will_oom_on_acquire(&self, tls: VMThread, size: usize) -> bool

A check for the obvious out-of-memory case: if the requested size is larger than the heap size, it is definitely an OOM. We would like to identify that, and allows the binding to deal with OOM. Without this check, we will attempt to allocate from the page resource. If the requested size is unrealistically large (such as usize::MAX), it breaks the assumptions of our implementation of page resource, vm map, etc. This check prevents that, and allows us to handle the OOM case. Each allocator that may request an arbitrary size should call this method before acquring memory from the space. For example, bump pointer allocator and large object allocator need to call this method. On the other hand, allocators that only allocate memory in fixed size blocks do not need to call this method. An allocator should call this method before doing any computation on the size to avoid arithmatic overflow. If we have to do computation in the allocation fastpath and overflow happens there, there is nothing we can do about it. Return a boolean to indicate if we will be out of memory, determined by the check.

fn acquire(&self, tls: VMThread, pages: usize) -> Address

fn address_in_space(&self, start: Address) -> bool

fn in_space(&self, object: ObjectReference) -> bool

fn grow_space(&self, start: Address, bytes: usize, new_chunk: bool)

This is called after we get result from page resources. The space may tap into the hook to monitor heap growth. The call is made from within the page resources’ critical region, immediately before yielding the lock.

fn ensure_mapped(&self)

Ensure this space is marked as mapped – used when the space is already mapped (e.g. for a vm image which is externally mmapped.)

fn reserved_pages(&self) -> usize

fn available_physical_pages(&self) -> usize

Return the number of physical pages available.

fn get_name(&self) -> &'static str

fn get_gc_trigger(&self) -> &GCTrigger<VM>

fn verify_side_metadata_sanity( &self, side_metadata_sanity_checker: &mut SideMetadataSanity )

Ensure that the current space’s metadata context does not have any issues. Panics with a suitable message if any issue is detected. It also initialises the sanity maps which will then be used if the extreme_assertions feature is active. Internally this calls verify_metadata_context() from util::metadata::sanity

impl<VM: VMBinding> Sync for ImmixSpace<VM>