Struct ThreadPool 

pub struct ThreadPool<'scope, Output> {
    threads: Vec<WorkerThreadHandle<'scope, Output>>,
    num_active_threads: Arc<AtomicUsize>,
    round: Cell<RoundColor>,
    worker_status: Arc<Status<WorkerStatus>>,
    main_status: Arc<Status<MainStatus>>,
    range_orchestrator: Box<dyn RangeOrchestrator>,
}

A thread pool tied to a scope, that can process inputs into the given output type.

Fields

threads: Vec<WorkerThreadHandle<'scope, Output>>

Handles to all the worker threads in the pool.

num_active_threads: Arc<AtomicUsize>

Number of worker threads active in the current round.

round: Cell<RoundColor>

Color of the current round.

worker_status: Arc<Status<WorkerStatus>>

Status of the worker threads.

main_status: Arc<Status<MainStatus>>

Status of the main thread.

range_orchestrator: Box<dyn RangeOrchestrator>

Orchestrator for the work ranges distributed to the threads. This is a dynamic object to avoid making the range type a parameter of everything.

Implementations

impl<'scope, Output: Send + 'scope> ThreadPool<'scope, Output>

pub fn new<'env, Input: Sync, Accum: ThreadAccumulator<Input, Output> + Send + 'scope>( thread_scope: &'scope Scope<'scope, 'env>, num_threads: NonZeroUsize, range_strategy: RangeStrategy, input: &'env [Input], new_accumulator: impl Fn() -> Accum, ) -> Self

Creates a new pool tied to the given scope, spawning the given number of threads and using the given input slice.

fn new_with_factory<'env, RnFactory: RangeFactory, Input: Sync, Accum: ThreadAccumulator<Input, Output> + Send + 'scope>( thread_scope: &'scope Scope<'scope, 'env>, num_threads: usize, range_factory: RnFactory, input: &'env [Input], new_accumulator: impl Fn() -> Accum, ) -> Self

where RnFactory::Rn: 'scope + Send, RnFactory::Orchestrator: 'static,

pub fn process_inputs(&self) -> impl Iterator<Item = Output> + '_

Performs a computation round, processing the input slice in parallel and returning an iterator over the threads’ outputs.

Trait Implementations

impl<Output> Drop for ThreadPool<'_, Output>

fn drop(&mut self)

Joins all the threads in the pool.