Struct executors::crossbeam_workstealing_pool::ThreadPool

pub struct ThreadPool<P> where
    P: Parker + Clone + 'static,  { /* fields omitted */ }

A handle associated with the thread pool structure

Implementations

impl<P> ThreadPool<P> where
    P: Parker + Clone + 'static, 

pub fn new(threads: usize, parker: P) -> ThreadPool<P>

Creates a new thread pool capable of executing threads number of jobs concurrently.

Must supply a parker that can handle the requested number of threads.

Panics

• This function will panic if threads is 0.
• It will also panic if threads is larger than the ThreadData::MAX_THREADS value of the provided parker.

Core Affinity

If compiled with thread-pinning it will assign a worker to each cores, until it runs out of cores or workers. If there are more workers than cores, the extra workers will be "floating", i.e. not pinned.

Examples

Create a new thread pool capable of executing four jobs concurrently:

use executors::*;
use executors::crossbeam_workstealing_pool::ThreadPool;

let pool = ThreadPool::new(4, parker::small());

pub fn with_affinity(
    cores: &[CoreId],
    floating: usize,
    parker: P
) -> ThreadPool<P>

Creates a new thread pool capable of executing threads number of jobs concurrently with a particular core affinity.

For each core id in the core slice, it will generate a single thread pinned to that id. Additionally, it will create floating number of unpinned threads.

Panics

• This function will panic if cores.len() + floating is 0.
• This function will panic if cores.len() + floating is greater than parker.max_threads().
• This function will panic if no core ids can be accessed.

pub fn with_numa_affinity(
    cores: &[CoreId],
    floating: usize,
    parker: P,
    pu_distance: ProcessingUnitDistance
) -> ThreadPool<P>

Creates a new thread pool capable of executing threads number of jobs concurrently with a particular core affinity.

For each core id in the core slice, it will generate a single thread pinned to that id. Additionally, it will create floating number of unpinned threads.

Internally the stealers will use the provided PU distance matrix to prioritise stealing from queues that are "closer" by, in order to try and reduce memory movement across caches and NUMA nodes.

Panics

• This function will panic if cores.len() + floating is 0.
• This function will panic if cores.len() + floating is greater than parker.max_threads().
• This function will panic if no core ids can be accessed.

Trait Implementations

impl<P> CanExecute for ThreadPool<P> where
    P: Parker + Clone + 'static, 

fn execute_job(&self, job: Box<dyn FnOnce() + Send + 'static>)

Executes the function job on the Executor.

impl<P: Clone> Clone for ThreadPool<P> where
    P: Parker + Clone + 'static, 

fn clone(&self) -> ThreadPool<P>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P: Debug> Debug for ThreadPool<P> where
    P: Parker + Clone + 'static, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ThreadPool<DynParker>

Create a thread pool with one thread per CPU. On machines with hyperthreading, this will create one thread per hyperthread.

fn default() -> Self

Returns the "default value" for a type.

impl<P> Executor for ThreadPool<P> where
    P: Parker + Clone + 'static, 

fn shutdown_async(&self)

Shutdown the Executor without waiting.

fn shutdown_borrowed(&self) -> Result<(), String>

Same as shutdown but without consuming self

fn execute<F>(&self, job: F) where
    F: FnOnce() + Send + 'static, 

Executes the function job on the Executor.

fn shutdown(self) -> Result<(), String>

Shutdown an Executor and wait for it to shut down all workers.

impl<P> FuturesExecutor for ThreadPool<P> where
    P: Parker + Clone + 'static, 

fn spawn<R: Send + 'static>(
    &self,
    future: impl Future<Output = R> + 'static + Send
) -> JoinHandle<R>

Spawn future on the pool and return a handle to the result