Struct CommonSpace 

pub struct CommonSpace<VM: VMBinding> {

    pub name: &'static str,
    pub descriptor: SpaceDescriptor,
    pub vmrequest: VMRequest,
    pub copy: Option<CopySemantics>,
    pub immortal: bool,
    pub movable: bool,
    pub contiguous: bool,
    pub zeroed: bool,
    pub permission_exec: bool,
    pub start: Address,
    pub extent: usize,
    pub vm_map: &'static dyn VMMap,
    pub mmapper: &'static dyn Mmapper,
    pub(crate) metadata: SideMetadataContext,
    pub needs_log_bit: bool,
    pub unlog_allocated_object: bool,
    pub unlog_traced_object: bool,
    pub acquire_lock: Mutex<()>,
    pub gc_trigger: Arc<GCTrigger<VM>>,
    pub global_state: Arc<GlobalState>,
    pub options: Arc<Options>,
    pub allocate_as_live: AtomicBool,
    p: PhantomData<VM>,
}

Fields

name: &'static str

descriptor: SpaceDescriptor

vmrequest: VMRequest

copy: Option<CopySemantics>

For a copying space that allows sft_trace_object(), this should be set before each GC so we know

immortal: bool

movable: bool

contiguous: bool

zeroed: bool

permission_exec: bool

start: Address

extent: usize

vm_map: &'static dyn VMMap

mmapper: &'static dyn Mmapper

metadata: SideMetadataContext

needs_log_bit: bool

This field equals to needs_log_bit in the plan constraints.

unlog_allocated_object: bool

unlog_traced_object: bool

acquire_lock: Mutex<()>

A lock used during acquire() to make sure only one thread can allocate.

gc_trigger: Arc<GCTrigger<VM>>

global_state: Arc<GlobalState>

options: Arc<Options>

allocate_as_live: AtomicBool

p: PhantomData<VM>

Implementations

impl<VM: VMBinding> CommonSpace<VM>

pub fn new(args: PolicyCreateSpaceArgs<'_, VM>) -> Self

pub fn estimate_reasonable_contiguous_extent( options: &Options, gc_trigger: &GCTrigger<VM>, vm_map: &dyn VMMap, extent: usize, ) -> usize

This function return an estimate value of required virtual memory for the heap size. Considering virtual memory fragmentation, we may need more virtual memory than the actual heap size. When a space needs to quarantine a virtual memory range, it can use this function to get an estimate of the required virtual memory, and use that to decide how much virtual memory to quarantine.

pub fn initialize_sft( &self, sft: &(dyn SFT + Sync + 'static), sft_map: &mut dyn SFTMap, )

pub fn vm_map(&self) -> &'static dyn VMMap

pub fn mmap_protection(&self) -> MmapProtection

pub(crate) fn debug_print_object_global_info(&self, object: ObjectReference)