[−][src]Struct rustc_rayon::ThreadPool

[+] Show declaration

pub struct ThreadPool { /* fields omitted */ }

[−]

Represents a user created thread-pool.

Use a ThreadPoolBuilder to specify the number and/or names of threads in the pool. After calling ThreadPoolBuilder::build(), you can then execute functions explicitly within this ThreadPool using ThreadPool::install(). By contrast, top level rayon functions (like join()) will execute implicitly within the current thread-pool.

Creating a ThreadPool

let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap();

install() executes a closure in one of the ThreadPool's threads. In addition, any other rayon operations called inside of install() will also execute in the context of the ThreadPool.

When the ThreadPool is dropped, that's a signal for the threads it manages to terminate, they will complete executing any remaining work that you have spawned, and automatically terminate.

Methods

`impl ThreadPool`[src][−]

`pub fn new( configuration: Configuration ) -> Result<ThreadPool, Box<dyn Error + 'static>>`[src][+]

Deprecated:

Use ThreadPoolBuilder::build

Deprecated in favor of ThreadPoolBuilder::build.

`pub fn scoped_pool<F, R, H>( builder: ThreadPoolBuilder, main_handler: H, with_pool: F ) -> Result<R, ThreadPoolBuildError> where F: FnOnce(&ThreadPool) -> R, H: Fn(&mut dyn FnMut()) + Send + Sync,` [src][+]

Creates a scoped thread pool

`pub fn install<OP, R>(&self, op: OP) -> R where OP: FnOnce() -> R + Send, R: Send,` [src][+]

Executes op within the threadpool. Any attempts to use join, scope, or parallel iterators will then operate within that threadpool.

Warning: thread-local data

Because op is executing within the Rayon thread-pool, thread-local data from the current thread will not be accessible.

Panics

If op should panic, that panic will be propagated.

Using `install()`

   fn main() {
        let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap();
        let n = pool.install(|| fib(20));
        println!("{}", n);
   }

   fn fib(n: usize) -> usize {
        if n == 0 || n == 1 {
            return n;
        }
        let (a, b) = rayon::join(|| fib(n - 1), || fib(n - 2)); // runs inside of `pool`
        return a + b;
    }

`pub fn current_num_threads(&self) -> usize`[src][+]

Returns the (current) number of threads in the thread pool.

Future compatibility note

Note that unless this thread-pool was created with a ThreadPoolBuilder that specifies the number of threads, then this number may vary over time in future versions (see the num_threads() method for details).

`pub fn current_thread_index(&self) -> Option<usize>`[src][+]

If called from a Rayon worker thread in this thread-pool, returns the index of that thread; if not called from a Rayon thread, or called from a Rayon thread that belongs to a different thread-pool, returns None.

The index for a given thread will not change over the thread's lifetime. However, multiple threads may share the same index if they are in distinct thread-pools.

Future compatibility note

Currently, every thread-pool (including the global thread-pool) has a fixed number of threads, but this may change in future Rayon versions (see the num_threads() method for details). In that case, the index for a thread would not change during its lifetime, but thread indices may wind up being reused if threads are terminated and restarted.

`pub fn current_thread_has_pending_tasks(&self) -> Option<bool>`[src][+]

Returns true if the current worker thread currently has "local tasks" pending. This can be useful as part of a heuristic for deciding whether to spawn a new task or execute code on the current thread, particularly in breadth-first schedulers. However, keep in mind that this is an inherently racy check, as other worker threads may be actively "stealing" tasks from our local deque.

Background: Rayon's uses a work-stealing scheduler. The key idea is that each thread has its own deque of tasks. Whenever a new task is spawned -- whether through join(), Scope::spawn(), or some other means -- that new task is pushed onto the thread's local deque. Worker threads have a preference for executing their own tasks; if however they run out of tasks, they will go try to "steal" tasks from other threads. This function therefore has an inherent race with other active worker threads, which may be removing items from the local deque.

`pub fn join<A, B, RA, RB>(&self, oper_a: A, oper_b: B) -> (RA, RB) where A: FnOnce() -> RA + Send, B: FnOnce() -> RB + Send, RA: Send, RB: Send,` [src][+]

Execute oper_a and oper_b in the thread-pool and return the results. Equivalent to self.install(|| join(oper_a, oper_b)).

`pub fn scope<'scope, OP, R>(&self, op: OP) -> R where OP: for<'s> FnOnce(&'s Scope<'scope>) -> R + 'scope + Send, R: Send,` [src][+]

Creates a scope that executes within this thread-pool. Equivalent to self.install(|| scope(...)).

`pub fn spawn<OP>(&self, op: OP) where OP: FnOnce() + Send + 'static,` [src][+]

Spawns an asynchronous task in this thread-pool. This task will run in the implicit, global scope, which means that it may outlast the current stack frame -- therefore, it cannot capture any references onto the stack (you will likely need a move closure).