Struct Pipeline 

pub struct Pipeline<T: Send + 'static> { /* private fields */ }

One class’s standing fan: N workers, built once, parked until there is work.

Implementations

impl<T: Send + 'static> Pipeline<T>

pub fn start<F>( class: OpClass, workers: usize, depth: usize, run: F, ) -> Pipeline<T>

where F: Fn(T) + Send + Sync + 'static,

Build the fan and START it. Threads are spawned HERE, at boot — never on the request path. That is the entire point of the type.

pub fn start_with_arena<A, M, F>( class: OpClass, workers: usize, depth: usize, make: M, run: F, ) -> Pipeline<T>

where A: Send + 'static, M: Fn(usize) -> A + Send + Sync + 'static, F: Fn(&mut A, T) + Send + Sync + 'static,

The same fan, but each worker owns an ARENA built once at boot.

This is the half of “zero initialisation” the plain start does not give you. A standing fan removes the thread spawn; it does not remove the buffer. If the work still does Vec::with_capacity per operation, the kernel still zeroes fresh pages for it — which is kernel_init_pages, 4.7% of the top profile on a linux.git clone, the single largest kernel cost measured there.

make runs once per worker, at boot. run receives &mut A, so the buffer that was grown for the first operation is still there, at capacity, for the ten-thousandth. The caller is responsible for clear()-ing rather than reallocating — clear keeps capacity, which is the whole point, and is why this takes &mut A instead of handing back an owned buffer per call.

pub fn submit(&self, item: T) -> Result<usize, SubmitError>

Hand an operation to the standing fan. Allocates nothing but the queue slot; spawns nothing.

pub fn class(&self) -> OpClass

The class this fan serves.

pub fn served(&self) -> u64

Operations a worker has actually picked up.

pub fn queued(&self) -> usize

Items waiting for a worker.

pub fn workers(&self) -> usize

Threads standing in this fan.

pub fn shutdown(&self)

Stop accepting work, drain what is queued, and JOIN every worker.

Joining rather than detaching: a worker that outlives the pipeline holds an Arc on the queue and on whatever the closure captured, which on a server means a repository handle that never closes.

Trait Implementations

impl<T: Send + 'static> Drop for Pipeline<T>

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.