Struct rayon::Configuration
[−]
[src]
pub struct Configuration { /* fields omitted */ }Contains the rayon thread pool configuration.
Methods
impl Configuration[src]
fn new() -> Configuration
Creates and return a valid rayon thread pool configuration, but does not initialize it.
fn thread_name<F>(self, closure: F) -> Configuration where
F: FnMut(usize) -> String + 'static,
F: FnMut(usize) -> String + 'static,
Set a closure which takes a thread index and returns the thread's name.
fn num_threads(self, num_threads: usize) -> Configuration
Set the number of threads to be used in the rayon threadpool.
If you specify a non-zero number of threads using this function, then the resulting thread-pools are guaranteed to start at most this number of threads.
If num_threads is 0, or you do not call this function, then
the Rayon runtime will select the number of threads
automatically. At present, this is based on the
RAYON_RS_NUM_CPUS (if set), or the number of logical CPUs
(otherwise). In the future, however, the default behavior may
change to dynamically add or remove threads as needed.
Future compatibility warning: Given the default behavior
may change in the future, if you wish to rely on a fixed
number of threads, you should use this function to specify
that number. To reproduce the current default behavior, you
may wish to use the num_cpus
crate to query the number
of CPUs dynamically.
fn panic_handler<H>(self, panic_handler: H) -> Configuration where
H: Fn(Box<Any + 'static + Send>) -> () + Send + Sync + 'static,
H: Fn(Box<Any + 'static + Send>) -> () + Send + Sync + 'static,
Normally, whenever Rayon catches a panic, it tries to
propagate it to someplace sensible, to try and reflect the
semantics of sequential execution. But in some cases,
particularly with the spawn_async() APIs, there is no
obvious place where we should propagate the panic to.
In that case, this panic handler is invoked.
If no panic handler is set, the default is to abort the process, under the principle that panics should not go unobserved.
If the panic handler itself panics, this will abort the
process. To prevent this, wrap the body of your panic handler
in a call to std::panic::catch_unwind().
fn stack_size(self, stack_size: usize) -> Configuration
Set the stack size of the worker threads
fn start_handler<H>(self, start_handler: H) -> Configuration where
H: Fn(usize) -> () + Send + Sync + 'static,
H: Fn(usize) -> () + Send + Sync + 'static,
Set a callback to be invoked on thread start.
If this closure panics, the panic will be passed to the panic handler. If that handler returns, then startup will continue normally.
fn exit_handler<H>(self, exit_handler: H) -> Configuration where
H: Fn(usize) -> () + Send + Sync + 'static,
H: Fn(usize) -> () + Send + Sync + 'static,
Set a callback to be invoked on thread exit.
If this closure panics, the panic will be passed to the panic handler. If that handler returns, then the thread will exit normally.