Struct Sidecar 

pub struct Sidecar { /* private fields */ }

The sidecar singleton. Internally a pool of one NodeSidecar per detected NUMA node; each node has its own scanning thread + Vec of registered primitive instances. Registration routes by current_numa_node() so cross-NUMA cache traffic on the scan path stays minimal. InstanceId encodes (node_index, slot) so unregister

• stats can find the right node’s vec.

Implementations

impl Sidecar

pub unsafe fn register_raw( &self, header: NonNull<HandshakeHeader>, ring: NonNull<ObservationRing>, instance: Option<NonNull<dyn AdaptiveInstance>>, policy: Box<dyn Policy>, ) -> InstanceId

Register a primitive instance.

Safety

header, ring, and (when provided) instance must remain valid until unregister(id) returns for the returned id. Prefer SidecarBox which enforces this invariant automatically.

pub fn unregister(&self, id: InstanceId)

Remove a registered instance.

Blocks until any in-flight scan iteration finishes, so the caller can safely drop the underlying header/ring memory immediately after this returns.

pub fn instance_count(&self) -> usize

Currently-registered instance count.

pub fn max_instances(&self) -> usize

Configured maximum simultaneously-registered instances. See DEFAULT_MAX_INSTANCES for the default and Self::set_max_instances to change it.

pub fn set_max_instances(&self, cap: usize)

Raise or lower the instance cap. Intentional heavy-registration workloads (e.g., a server that legitimately wants > 10,000 adaptive primitives live at once) should call this once at startup. The cap is per-process; the global Sidecar inherits it via global().

pub fn stats(&self, id: InstanceId) -> Option<InstanceStats>

Snapshot the stats for a registered instance.

pub fn scan_now(&self)

Force one scan iteration synchronously across all NUMA nodes. Useful for tests where we don’t want to wait for the poll interval.

pub fn node_count(&self) -> usize

Number of NUMA-pinned sidecar threads in this pool.

Trait Implementations

impl Drop for Sidecar

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.