Struct WorkerPool 

pub struct WorkerPool<const N: usize> { /* private fields */ }

A bounded, per-role set of persistent threads that connections borrow.

N is the set size — three for the PVA server (conn, reader, writer), two for a blocking client’s circuit (reader, writer). Worker and SetLease are not generic over N, so a leased worker crosses into the byte-pump seam without spreading a const parameter through every signature.

Implementations

impl<const N: usize> WorkerPool<N>

pub fn new( name_prefix: &'static str, roster: [WorkerRole; N], capacity: usize, ) -> Self

Declare a role’s pool. Lazy: no thread exists until the first acquire that cannot reuse an idle set.

capacity is the most sets that may ever exist, and for a server it is the connection limit — admission refuses past it. Not const, because a pool owns heap state; a process-lifetime pool is a LazyLock<WorkerPool>, a server-lifetime pool is a field dropped with the server.

pub fn acquire(&self) -> Result<(SetLease, [Worker; N]), AcquireError>

Borrow a whole set, or refuse.

• an idle set exists → reuse it (no thread created);
• none, and created < capacity → grow by one set (N threads);
• none, and at capacity → AcquireError::AtCapacity carrying the bound that was reached;
• a thread could not be created → AcquireError::SpawnFailed, with created left exactly as it was found.

The refusals are a sum type and not an io::Error because they mean opposite things — a full process versus a target out of thread resources — and as io::Error they were indistinguishable: both are ErrorKind::WouldBlock. See AcquireError.

pub fn worker_count(&self) -> usize

Threads this pool has created, ever — never more than capacity × N. The bound made observable: the number the per-connection shape grew without limit.

pub fn set_usage(&self) -> (usize, usize, usize)

(busy_sets, created_sets, capacity) — the admission state.

Deliberately not queue_depth: there is no queue, admission refuses, and a name that promised one would be the dual meaning this design removes.

Trait Implementations

impl<const N: usize> Drop for WorkerPool<N>

fn drop(&mut self)

Retire every worker thread. A process-lifetime pool (a static LazyLock) never reaches here; a server-lifetime pool does, at server drop, and must be dropped after the server’s connections have been asked to stop, so the Stops do not queue behind a live connection forever.

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.