Struct ZeroPool 

pub struct ZeroPool { /* private fields */ }

A high-performance thread pool with lock-free task dispatch.

ZeroPool coordinates tasks across worker threads using a single lock-free FIFO queue and cooperative memory reclamation. Tasks write their results directly to caller-provided memory via function pointers without virtual dispatch.

Implementations

impl ZeroPool

pub fn new() -> Self

Creates a new thread pool with worker count equal to available parallelism.

Worker count is determined by std::thread::available_parallelism(), falling back to 1 if unavailable. This is usually the optimal choice for CPU-bound workloads.

Examples

use zero_pool::ZeroPool;
let pool = ZeroPool::new();

pub fn with_workers(worker_count: NonZeroUsize) -> Self

Creates a new thread pool with the specified number of workers.

Use this when you need precise control over the worker count, for example when coordinating with other thread pools or when you know the optimal count for your specific workload.

Examples

use std::num::NonZeroUsize;
use zero_pool::ZeroPool;
let pool = ZeroPool::with_workers(NonZeroUsize::new(4).unwrap());

pub fn scope<'env, F, R>(&'env self, f: F) -> R

where F: for<'scope> FnOnce(&'scope Scope<'scope, 'env>) -> R,

Creates a scope for executing concurrent tasks that can borrow from the stack.

All tasks are guaranteed to complete before scope returns.

Examples

use zero_pool::ZeroPool;

struct Params { value: u64, result: *mut u64 }
fn compute(p: &Params) { unsafe { *p.result = p.value * 2; } }

let pool = ZeroPool::new();
let mut r1 = 0;
let mut r2 = 0;

let p1 = [Params { value: 10, result: &raw mut r1 }];
let p2 = [Params { value: 20, result: &raw mut r2 }];

pool.scope(|s| {
    s.run(compute, &p1);
    s.run(compute, &p2);
});

assert_eq!(r1, 20);
assert_eq!(r2, 40);

pub fn run<T>(&self, task_fn: fn(&T), params: &[T])

Submits tasks and waits for all to complete.

use zero_pool::ZeroPool;

struct Params { value: u64, result: *mut u64 }
fn compute(p: &Params) { unsafe { *p.result = p.value * 2; } }

let pool = ZeroPool::new();
let mut result = 0;
pool.run(compute, &[Params { value: 42, result: &raw mut result }]);
assert_eq!(result, 84);

pub unsafe fn run_detached<T>(&self, task_fn: fn(&T), params: *const [T])

Submits tasks without waiting for completion.

Safety

The caller must ensure that params remains valid until all tasks finish.

Trait Implementations

impl Default for ZeroPool

fn default() -> Self

Creates a new thread pool with default settings

Equivalent to calling ZeroPool::new(). Worker count is determined by std::thread::available_parallelism(), falling back to 1 if unavailable.

impl Drop for ZeroPool

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.