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 initialize_sft( &self, sft: &(dyn SFT + Sync + 'static), sft_map: &mut dyn SFTMap, )

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

pub fn mmap_strategy(&self) -> MmapStrategy

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