Trait ParallelRunner 

pub trait ParallelRunner {
    type Executor: ParallelExecutor;
    type ThreadPool: ParThreadPool;

    // Required methods
    fn thread_pool(&self) -> &Self::ThreadPool;
    fn thread_pool_mut(&mut self) -> &mut Self::ThreadPool;

    // Provided methods
    fn new_executor(
        &self,
        kind: ComputationKind,
        params: Params,
        initial_input_len: Option<usize>,
    ) -> Self::Executor { ... }
    fn run_all<I, F>(
        &mut self,
        params: Params,
        iter: I,
        kind: ComputationKind,
        thread_do: F,
    ) -> NumSpawned
       where I: ConcurrentIter,
             F: Fn(NumSpawned, &I, &<Self::Executor as ParallelExecutor>::SharedState, <Self::Executor as ParallelExecutor>::ThreadExecutor) + Sync { ... }
    fn map_all<F, I, M, T>(
        &mut self,
        params: Params,
        iter: I,
        kind: ComputationKind,
        thread_map: M,
    ) -> (NumSpawned, Result<Vec<T>, <F as Fallibility>::Error>)
       where F: Fallibility,
             I: ConcurrentIter,
             M: Fn(NumSpawned, &I, &<Self::Executor as ParallelExecutor>::SharedState, <Self::Executor as ParallelExecutor>::ThreadExecutor) -> Result<T, <F as Fallibility>::Error> + Sync,
             T: Send,
             <F as Fallibility>::Error: Send { ... }
    fn map_infallible<I, M, T>(
        &mut self,
        params: Params,
        iter: I,
        kind: ComputationKind,
        thread_map: M,
    ) -> (NumSpawned, Result<Vec<T>, Never>)
       where I: ConcurrentIter,
             M: Fn(NumSpawned, &I, &<Self::Executor as ParallelExecutor>::SharedState, <Self::Executor as ParallelExecutor>::ThreadExecutor) -> Result<T, Never> + Sync,
             T: Send { ... }
    fn max_num_threads_for_computation(
        &self,
        params: Params,
        iter_len: Option<usize>,
    ) -> NonZero<usize> { ... }
}

Parallel runner defining how the threads must be spawned and job must be distributed.

Required Associated Types

type Executor: ParallelExecutor

Parallel executor responsible for distribution of tasks to the threads.

type ThreadPool: ParThreadPool

Thread pool responsible for providing threads to the parallel computation.

Required Methods

fn thread_pool(&self) -> &Self::ThreadPool

Reference to the underlying thread pool.

fn thread_pool_mut(&mut self) -> &mut Self::ThreadPool

Mutable reference to the underlying thread pool.

Provided Methods

fn new_executor( &self, kind: ComputationKind, params: Params, initial_input_len: Option<usize>, ) -> Self::Executor

Creates a new parallel executor for a parallel computation.

fn run_all<I, F>( &mut self, params: Params, iter: I, kind: ComputationKind, thread_do: F, ) -> NumSpawned

where I: ConcurrentIter, F: Fn(NumSpawned, &I, &<Self::Executor as ParallelExecutor>::SharedState, <Self::Executor as ParallelExecutor>::ThreadExecutor) + Sync,

Runs thread_do using threads provided by the thread pool.

fn map_all<F, I, M, T>( &mut self, params: Params, iter: I, kind: ComputationKind, thread_map: M, ) -> (NumSpawned, Result<Vec<T>, <F as Fallibility>::Error>)

where F: Fallibility, I: ConcurrentIter, M: Fn(NumSpawned, &I, &<Self::Executor as ParallelExecutor>::SharedState, <Self::Executor as ParallelExecutor>::ThreadExecutor) -> Result<T, <F as Fallibility>::Error> + Sync, T: Send, <F as Fallibility>::Error: Send,

Runs thread_map using threads provided by the thread pool.

fn map_infallible<I, M, T>( &mut self, params: Params, iter: I, kind: ComputationKind, thread_map: M, ) -> (NumSpawned, Result<Vec<T>, Never>)

where I: ConcurrentIter, M: Fn(NumSpawned, &I, &<Self::Executor as ParallelExecutor>::SharedState, <Self::Executor as ParallelExecutor>::ThreadExecutor) -> Result<T, Never> + Sync, T: Send,

Runs infallible thread_map using threads provided by the thread pool.

fn max_num_threads_for_computation( &self, params: Params, iter_len: Option<usize>, ) -> NonZero<usize>

Returns the maximum number of threads that can be used for the computation defined by the params and input iter_len.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<O> ParallelRunner for &mut O

where O: ParallelRunner,

type Executor = <O as ParallelRunner>::Executor

type ThreadPool = <O as ParallelRunner>::ThreadPool

fn thread_pool(&self) -> &<&mut O as ParallelRunner>::ThreadPool

fn thread_pool_mut(&mut self) -> &mut <&mut O as ParallelRunner>::ThreadPool

Implementors

impl<P, R> ParallelRunner for RunnerWithPool<P, R>

where P: ParThreadPool, R: ParallelExecutor,

type Executor = R

type ThreadPool = P