Struct RefCountHelper 

#[repr(transparent)]
pub struct RefCountHelper<VM: VMBinding>(PhantomData<VM>);

A zero-sized helper type providing methods to read and update per-object reference count metadata for LXR’s reference counting plan.

Tuple Fields

0: PhantomData<VM>

Implementations

impl<VM: VMBinding> RefCountHelper<VM>

pub const NEW: Self

A singleton instance of RefCountHelper (the type is zero-sized, so it can be freely copied/cloned).

pub const SANITY: bool = true

Whether extra reference-counting sanity checks are enabled (debug builds or the sanity feature).

pub fn inc_buffer_size(&self) -> usize

Returns the current size of the global increment buffer, i.e. the number of pending reference count increments that have been enqueued but not yet processed.

pub fn increase_inc_buffer_size(&self, delta: usize)

Increases the global increment buffer size counter by delta.

pub fn reset_inc_buffer_size(&self)

Resets the global increment buffer size counter to zero.

pub fn fetch_update( &self, o: ObjectReference, f: impl FnMut(u8) -> Option<u8>, ) -> Result<u8, u8>

Atomically updates the reference count of object o by applying f to its current value, following the same semantics as AtomicU8::fetch_update.

pub fn is_stuck(&self, o: ObjectReference) -> bool

Returns true if object o’s reference count has saturated at MAX_REF_COUNT (sticky).

pub fn stick(&self, o: ObjectReference) -> Result<u8, u8>

Forces object o’s reference count to MAX_REF_COUNT, permanently marking it as sticky so it is never reclaimed by reference counting.

pub fn inc(&self, o: ObjectReference) -> Result<u8, u8>

Increments object o’s reference count by one, leaving it unchanged (saturating) once it has reached MAX_REF_COUNT.

pub fn dec(&self, o: ObjectReference) -> Result<u8, u8>

Decrements object o’s reference count by one, unless it is already zero or has saturated at MAX_REF_COUNT (sticky), in which case it is left unchanged.

pub fn set(&self, o: ObjectReference, count: u8)

Atomically sets object o’s reference count to count.

pub fn set_relaxed(&self, o: ObjectReference, count: u8)

Sets object o’s reference count to count using a non-atomic store, for use where the caller can guarantee there is no concurrent access.

pub fn set_line_relaxed(&self, line: Line, count: u8)

Sets the reference count for the line containing object o to count using a non-atomic store, for use where the caller can guarantee there is no concurrent access.

pub fn count(&self, o: ObjectReference) -> u8

Returns object o’s current reference count.

pub fn count_by_address(&self, addr: Address) -> u8

Returns the reference count stored in the RC table at address addr. If this returns a non-zero value, it indicates that addr is the address of an object reference, or the start of a straddle line.

pub fn object_or_line_is_dead(&self, o: ObjectReference) -> bool

Returns true if the RC table entry at o’s address is zero. Used for both individual objects and line-granularity entries (e.g. straddle line markers), which share the same table.

pub fn rc_table_range<UInt: Sized>(&self, b: Block) -> &'static [UInt]

Returns a slice view over the raw RC table memory covering block b, reinterpreted as an array of UInt, allowing the block’s reference counts to be scanned in bulk.

pub fn is_dead(&self, o: ObjectReference) -> bool

Returns true if object o’s reference count is zero.

pub fn is_dead_or_stuck(&self, o: ObjectReference) -> bool

Returns true if object o’s reference count is zero (dead) or has saturated at MAX_REF_COUNT (sticky).

pub fn object_is_in_straddle_line_no_rc_check(&self, o: ObjectReference) -> bool

Returns true if object o is in a straddle line. The function does not check rc table.

pub fn object_is_in_straddle_line(&self, o: ObjectReference) -> bool

Returns true if address a falls within a live object whose containing line is marked as a straddle line.

fn mark_straddle_object_with_size(&self, o: ObjectReference, size: usize)

pub fn mark_straddle_object(&self, o: ObjectReference)

Marks every line (other than the first) spanned by object o as a straddle line, so the object can be identified from any of the lines it straddles.

pub fn unmark_straddle_object(&self, o: ObjectReference)

Clears the straddle-line and reference-count markers set by mark_straddle_object for every line (other than the first) spanned by object o.

pub fn assert_zero_ref_count(&self, o: ObjectReference)

Debug assertion that every MIN_OBJECT_SIZE granule within object o has a reference count of zero, used to verify that a reclaimed object has been fully cleared.

pub fn promote(&self, o: ObjectReference)

Called when object o is promoted to mature space; marks it as a straddle object if it spans more than one line, deriving its size from the VM binding.

pub fn promote_with_size(&self, o: ObjectReference, size: usize)

Same as promote, but with the object’s size supplied by the caller instead of being queried from the VM binding.

Trait Implementations

impl<VM: VMBinding> Clone for RefCountHelper<VM>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<VM: Debug + VMBinding> Debug for RefCountHelper<VM>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<VM: Copy + VMBinding> Copy for RefCountHelper<VM>