Module rayon

This crate provides a subset of the rayon API to allow conditional compilation without rayon. This is useful for profiling single-threaded code, as it simplifies call stacks significantly. The initial code was taken from the maybe-rayon crate, but many changes were made to support the usage of ParallelIterator and IndexedParallelIterator methods, which have different signatures from std::iter::Iterator. Some of these changes may be potentially backward-incompatible, and given the absence of tests in the original crate, it is very unlikely that it is possible to commit the changes back to the original crate.

Modules

array

Parallel iterator types for arrays ([T; N])

collections

Parallel iterator types for standard collections

config

iter

Traits for writing parallel programs using an iterator-style interface

option

Parallel iterator types for options

prelude

The rayon prelude imports the various ParallelIterator traits. The intention is that one can include use rayon::prelude::* and have easy access to the various traits and methods you will need.

range

Parallel iterator types for ranges, the type for values created by a..b expressions

range_inclusive

Parallel iterator types for inclusive ranges, the type for values created by a..=b expressions

result

Parallel iterator types for results

slice

Parallel iterator types for slices

str

Parallel iterator types for strings

string

This module contains the parallel iterator types for owned strings (String). You will rarely need to interact with it directly unless you have need to name one of the iterator types.

vec

Parallel iterator types for vectors (Vec<T>)

Structs

BroadcastContext

Provides context to a closure called by broadcast.

FnContext

Provides the calling context to a closure called by join_context.

Scope

Represents a fork-join scope which can be used to spawn any number of tasks. See scope() for more information.

ScopeFifo

Represents a fork-join scope which can be used to spawn any number of tasks. Those spawned from the same thread are prioritized in relative FIFO order. See scope_fifo() for more information.

ThreadBuilder

Thread builder used for customization via ThreadPoolBuilder::spawn_handler().

ThreadPool

Represents a user-created thread pool.

ThreadPoolBuildError

Error when initializing a thread pool.

ThreadPoolBuilder

Used to create a new ThreadPool or to configure the global rayon thread pool.

Enums

Yield

Result of yield_now() or yield_local().

Functions

broadcast

Executes op within every thread in the current thread pool. If this is called from a non-Rayon thread, it will execute in the global thread pool. Any attempts to use join, scope, or parallel iterators will then operate within that thread pool. When the call has completed on each thread, returns a vector containing all of their return values.

current_num_threads

Returns the number of threads in the current registry. If this code is executing within a Rayon thread pool, then this will be the number of threads for the thread pool of the current thread. Otherwise, it will be the number of threads for the global thread pool.

current_thread_index

If called from a Rayon worker thread, returns the index of that thread within its current pool; if not called from a Rayon thread, returns None.

in_place_scope

Creates a “fork-join” scope s and invokes the closure with a reference to s. This closure can then spawn asynchronous tasks into s. Those tasks may run asynchronously with respect to the closure; they may themselves spawn additional tasks into s. When the closure returns, it will block until all tasks that have been spawned into s complete.

in_place_scope_fifo

Creates a “fork-join” scope s with FIFO order, and invokes the closure with a reference to s. This closure can then spawn asynchronous tasks into s. Those tasks may run asynchronously with respect to the closure; they may themselves spawn additional tasks into s. When the closure returns, it will block until all tasks that have been spawned into s complete.

join

Takes two closures and potentially runs them in parallel. It returns a pair of the results from those closures.

join_context

Identical to join, except that the closures have a parameter that provides context for the way the closure has been called, especially indicating whether they’re executing on a different thread than where join_context was called. This will occur if the second job is stolen by a different thread, or if join_context was called from outside the thread pool to begin with.

max_num_threads

Returns the maximum number of threads that Rayon supports in a single thread pool.

scope

Creates a “fork-join” scope s and invokes the closure with a reference to s. This closure can then spawn asynchronous tasks into s. Those tasks may run asynchronously with respect to the closure; they may themselves spawn additional tasks into s. When the closure returns, it will block until all tasks that have been spawned into s complete.

scope_fifo

Creates a “fork-join” scope s with FIFO order, and invokes the closure with a reference to s. This closure can then spawn asynchronous tasks into s. Those tasks may run asynchronously with respect to the closure; they may themselves spawn additional tasks into s. When the closure returns, it will block until all tasks that have been spawned into s complete.

spawn

Puts the task into the Rayon thread pool’s job queue in the “static” or “global” scope. Just like a standard thread, this task is not tied to the current stack frame, and hence it cannot hold any references other than those with 'static lifetime. If you want to spawn a task that references stack data, use the scope() function to create a scope.

spawn_broadcast

Spawns an asynchronous task on every thread 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).

spawn_fifo

Fires off a task into the Rayon thread pool in the “static” or “global” scope. Just like a standard thread, this task is not tied to the current stack frame, and hence it cannot hold any references other than those with 'static lifetime. If you want to spawn a task that references stack data, use the scope_fifo() function to create a scope.

yield_local

Cooperatively yields execution to local Rayon work.

yield_now

Cooperatively yields execution to Rayon.