Struct RingExecutor 

pub struct RingExecutor { /* private fields */ }

A hardware-shaped pool of worker threads draining an unbounded set of tasks through per-worker SubEtha ready-ring shards.

Implementations

impl RingExecutor

pub fn with_available_parallelism(max_tasks: usize) -> Self

Build an executor whose worker count matches the host’s logical core count (std::thread::available_parallelism). The ready queue gets one shard per worker; max_tasks is the peak number of simultaneously-live tasks the queue must hold.

pub fn new(n_workers: usize, max_tasks: usize) -> Self

Build an executor with n_workers worker threads (one ready shard each) and a ready queue sized to hold at least max_tasks simultaneously-live task handles, spread across the shards.

pub fn spawn(&self, future: impl Future<Output = ()> + Send + 'static)

Spawn a future. It runs to completion on the pool, suspending (off-thread) whenever it awaits, with no thread dedicated to it.

pub fn pending(&self) -> usize

Number of tasks not yet complete.

pub fn worker_count(&self) -> usize

Number of worker threads (one ready shard each).

pub fn shard_count(&self) -> usize

Number of ready-ring shards (equals worker count).

pub fn pinned_workers(&self) -> usize

How many workers were pinned to a distinct core (best-effort; 0 on hosts without an affinity API). Read after the workers have started.

pub fn shard_capacity(&self) -> usize

Per-shard slot capacity (power of two).

pub fn wait_idle(&self)

Spin until every spawned task has completed.

pub fn shutdown(self)

Stop the workers (after the rings drain) and join them. Call once the spawned work has completed.