Struct SATBBarrierSemantics

pub struct SATBBarrierSemantics<VM: VMBinding, P: ConcurrentPlan<VM = VM> + PlanTraceObject<VM>, const KIND: u8> {
    mmtk: &'static MMTK<VM>,
    tls: VMMutatorThread,
    satb: VectorQueue<ObjectReference>,
    refs: VectorQueue<ObjectReference>,
    plan: &'static P,
}

Fields

mmtk: &'static MMTK<VM>

tls: VMMutatorThread

satb: VectorQueue<ObjectReference>

refs: VectorQueue<ObjectReference>

plan: &'static P

Implementations

impl<VM: VMBinding, P: ConcurrentPlan<VM = VM> + PlanTraceObject<VM>, const KIND: u8> SATBBarrierSemantics<VM, P, KIND>

pub fn new(mmtk: &'static MMTK<VM>, tls: VMMutatorThread) -> Self

fn slow( &mut self, _src: Option<ObjectReference>, _slot: VM::VMSlot, old: ObjectReference, )

fn enqueue_node( &mut self, src: Option<ObjectReference>, slot: VM::VMSlot, _new: Option<ObjectReference>, ) -> bool

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

Attempt to atomically log an object. Returns true if the object is not logged previously.

fn flush_satb(&mut self)

fn flush_weak_refs(&mut self)

fn should_create_satb_packets(&self) -> bool

Trait Implementations

impl<VM: VMBinding, P: ConcurrentPlan<VM = VM> + PlanTraceObject<VM>, const KIND: u8> BarrierSemantics for SATBBarrierSemantics<VM, P, KIND>

fn load_weak_reference(&mut self, o: ObjectReference)

Enqueue the referent during concurrent marking.

Note: During concurrent marking, a collector based on snapshot-at-the-beginning (SATB) will not reach objects that were weakly reachable at the time of InitialMark. But if a mutator loads from a weak reference field during concurrent marking, it will make the referent strongly reachable, yet the referent is still not part of the SATB. We must conservatively enqueue the referent even though its reachability has not yet been established, otherwise it (and its children) may be treated as garbage if it happened to be weakly reachable at the time of InitialMark.

type VM = VM

fn flush(&mut self)

Flush thread-local buffers or remembered sets. Normally this is called by the slow-path implementation whenever the thread-local buffers are full. This will also be called externally by the VM, when the thread is being destroyed.

fn object_reference_write_slow( &mut self, src: ObjectReference, _slot: <Self::VM as VMBinding>::VMSlot, _target: Option<ObjectReference>, )

Slow-path call for object field write operations.

fn memory_region_copy_slow( &mut self, _src: <Self::VM as VMBinding>::VMMemorySlice, dst: <Self::VM as VMBinding>::VMMemorySlice, )

Slow-path call for mempry slice copy operations. For example, array-copy operations.

fn object_probable_write_slow(&mut self, obj: ObjectReference)

Object will probably be modified

const UNLOG_BIT_SPEC: MetadataSpec = _