Struct ArenaState 

struct ArenaState {
    map: MaybeUninit<BTreeMap<usize, Entry>>,
    backing: SEXP,
    capacity: usize,
    len: usize,
    free_list: Vec<usize>,
    next_slot: usize,
}

Core arena state without interior mutability.

This is used internally by both RefCountedArena (with RefCell) and ThreadLocalArena (with UnsafeCell).

Fields

map: MaybeUninit<BTreeMap<usize, Entry>>

Map from SEXP pointer to entry

backing: SEXP

Backing VECSXP (preserved via R_PreserveObject)

capacity: usize

Current capacity

len: usize

Number of active entries

free_list: Vec<usize>

Free list for slot reuse

next_slot: usize

Monotonic write cursor: next index to hand out on the fresh-slot path. Distinct from len (live count) — after release cycles len can be lower than the highest index ever handed out, so using len as the cursor can return an index that is already on the free-list.

Implementations

impl ArenaState

const INITIAL_CAPACITY: usize = 16

Initial capacity for the backing VECSXP.

This is suitable for light usage (a handful of protected values). For ppsize-scale workloads (hundreds or thousands of protected values), use RefCountedArena::with_capacity or ThreadLocalArena::init_with_capacity to avoid repeated backing VECSXP growth and map rehashing.

const MAX_CAPACITY: usize

Maximum capacity: the backing VECSXP is indexed by R_xlen_t (isize), so the capacity must fit in a non-negative R_xlen_t.

fn capacity_as_r_xlen(cap: usize) -> R_xlen_t

Convert a usize capacity to R_xlen_t, panicking on overflow.

const fn uninit() -> Self

Create uninitialized state (for thread_local).

unsafe fn init(&mut self, capacity: usize)

Initialize the state.

Safety

Must be called exactly once before using the state.

unsafe fn new(capacity: usize) -> Self

Create initialized state.

unsafe fn init_backing(&mut self, capacity: usize)

Initialize just the backing (map already initialized).

fn map(&self) -> &BTreeMap<usize, Entry>

Get a reference to the map.

fn map_mut(&mut self) -> &mut BTreeMap<usize, Entry>

Get a mutable reference to the map.

fn decrement_and_maybe_remove(&mut self, key: &usize) -> Option<(bool, usize)>

Decrement the count for a key and remove if zero.

Returns Some((true, index)) if the entry was found and removed, Some((false, index)) if the entry was found but count > 0 after decrement, None if the entry was not found.

unsafe fn protect(&mut self, x: SEXP) -> SEXP

Protect a SEXP from garbage collection.

Safety

Must be called from the R main thread. The SEXP must be valid.

unsafe fn unprotect(&mut self, x: SEXP)

Unprotect a SEXP, allowing garbage collection when refcount reaches zero.

Safety

Must be called from the R main thread. The SEXP must have been previously protected by this arena.

unsafe fn try_unprotect(&mut self, x: SEXP) -> bool

Try to unprotect a SEXP. Returns false if not protected by this arena.

Safety

Must be called from the R main thread.

fn is_protected(&self, x: SEXP) -> bool

Returns true if this arena currently protects x.

fn ref_count(&self, x: SEXP) -> usize

Returns the current reference count for x in this arena.

Returns 0 if x is not protected or is SEXP::nil().

fn allocate_slot(&mut self) -> usize

unsafe fn grow(&mut self)

unsafe fn clear(&mut self)

Clear all protected values from the arena.

Safety

Must be called from the R main thread.

unsafe fn release_backing(&mut self)

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 80 bytes