Struct WorkerPool 

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

A fixed-size thread pool that processes tasks of type T and emits results of type R.

Tasks are distributed to worker threads via an internal sync_channel; results are collected through a standard mpsc::channel.

Example

use scirs2_core::distributed::primitives::WorkerPool;
use std::time::Duration;

let pool = WorkerPool::new(4, |x: i32| x * x).expect("pool creation failed");
pool.submit(7).expect("submit failed");
let result = pool.collect_result(Some(Duration::from_secs(5)));
assert_eq!(result, Some(49));
pool.shutdown();

Implementations

impl<T: Send + 'static, R: Send + 'static> WorkerPool<T, R>

pub fn new<F>(n_workers: usize, worker_fn: F) -> Result<Self, DistributedError>

where F: Fn(T) -> R + Send + Clone + 'static,

Create a new pool with n_workers threads.

Each thread calls worker_fn(task) and sends the result to the pool’s internal result channel.

A None sentinel in the task channel signals workers to stop; the pool sends one sentinel per worker on shutdown.

Errors

DistributedError::InvalidArgument if n_workers == 0.

pub fn n_workers(&self) -> usize

Number of worker threads in this pool.

pub fn submit(&self, task: T) -> Result<(), DistributedError>

Submit a task to the pool.

Blocks briefly if the internal task buffer (capacity n_workers * 4) is full.

Errors

DistributedError::Disconnected if all workers have exited.

pub fn collect_result(&self, timeout: Option<Duration>) -> Option<R>

Collect one result.

• timeout = None → block indefinitely.
• timeout = Some(d) → return None if no result arrives within d.

pub fn collect_all(&self, expected: usize, timeout: Duration) -> Vec<R>

Collect up to expected results, waiting at most timeout per result.

Returns fewer items if individual receives time out.

pub fn shutdown(self)

Signal all workers to stop and join their threads.

In-flight tasks complete normally; tasks still in the buffer may be discarded once a worker picks up its sentinel.