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.
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.
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.
Executes op within every thread in the current threadpool. If this is
called from a non-Rayon thread, it will execute in the global threadpool.
Any attempts to use join, scope, or parallel iterators will then operate
within that threadpool. When the call has completed on each thread, returns
a vector containing all of their return values.
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.
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.
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.
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.
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.
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.
Puts the task into the Rayon threadpool’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.
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).
Fires off a task into the Rayon threadpool 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.