| array.rs |
Parallel iterator types for [arrays] (`[T; N]`)
You will rarely need to interact with this module directly unless you need
to name one of the iterator types.
[arrays]: https://doc.rust-lang.org/std/primitive.array.html |
2184 |
| collections |
|
|
| compile_fail |
|
|
| delegate.rs |
Macros for delegating newtype iterators to inner types. |
2995 |
| iter |
|
|
| lib.rs |
Rayon is a data-parallelism library that makes it easy to convert sequential
computations into parallel.
It is lightweight and convenient for introducing parallelism into existing
code. It guarantees data-race free executions and takes advantage of
parallelism when sensible, based on work-load at runtime.
# How to use Rayon
There are two ways to use Rayon:
- **High-level parallel constructs** are the simplest way to use Rayon and also
typically the most efficient.
- [Parallel iterators][iter module] make it easy to convert a sequential iterator to
execute in parallel.
- The [`ParallelIterator`] trait defines general methods for all parallel iterators.
- The [`IndexedParallelIterator`] trait adds methods for iterators that support random
access.
- The [`par_sort`] method sorts `&mut [T]` slices (or vectors) in parallel.
- [`par_extend`] can be used to efficiently grow collections with items produced
by a parallel iterator.
- **Custom tasks** let you divide your work into parallel tasks yourself.
- [`join`] is used to subdivide a task into two pieces.
- [`scope`] creates a scope within which you can create any number of parallel tasks.
- [`ThreadPoolBuilder`] can be used to create your own thread pools or customize
the global one.
[iter module]: iter/index.html
[`join`]: fn.join.html
[`scope`]: fn.scope.html
[`par_sort`]: slice/trait.ParallelSliceMut.html#method.par_sort
[`par_extend`]: iter/trait.ParallelExtend.html#tymethod.par_extend
[`ThreadPoolBuilder`]: struct.ThreadPoolBuilder.html
# Basic usage and the Rayon prelude
First, you will need to add `rayon` to your `Cargo.toml`.
Next, to use parallel iterators or the other high-level methods,
you need to import several traits. Those traits are bundled into
the module [`rayon::prelude`]. It is recommended that you import
all of these traits at once by adding `use rayon::prelude::*` at
the top of each module that uses Rayon methods.
These traits give you access to the `par_iter` method which provides
parallel implementations of many iterative functions such as [`map`],
[`for_each`], [`filter`], [`fold`], and [more].
[`rayon::prelude`]: prelude/index.html
[`map`]: iter/trait.ParallelIterator.html#method.map
[`for_each`]: iter/trait.ParallelIterator.html#method.for_each
[`filter`]: iter/trait.ParallelIterator.html#method.filter
[`fold`]: iter/trait.ParallelIterator.html#method.fold
[more]: iter/trait.ParallelIterator.html#provided-methods
[`ParallelIterator`]: iter/trait.ParallelIterator.html
[`IndexedParallelIterator`]: iter/trait.IndexedParallelIterator.html
# Crate Layout
Rayon extends many of the types found in the standard library with
parallel iterator implementations. The modules in the `rayon`
crate mirror [`std`] itself: so, e.g., the `option` module in
Rayon contains parallel iterators for the `Option` type, which is
found in [the `option` module of `std`]. Similarly, the
`collections` module in Rayon offers parallel iterator types for
[the `collections` from `std`]. You will rarely need to access
these submodules unless you need to name iterator types
explicitly.
[the `option` module of `std`]: https://doc.rust-lang.org/std/option/index.html
[the `collections` from `std`]: https://doc.rust-lang.org/std/collections/index.html
[`std`]: https://doc.rust-lang.org/std/
# Targets without threading
Rayon has limited support for targets without `std` threading implementations.
See the [`rayon_core`] documentation for more information about its global fallback.
# Other questions?
See [the Rayon FAQ][faq].
[faq]: https://github.com/rayon-rs/rayon/blob/main/FAQ.md |
6096 |
| math.rs |
|
1576 |
| option.rs |
Parallel iterator types for [options][std::option]
You will rarely need to interact with this module directly unless you need
to name one of the iterator types.
[std::option]: https://doc.rust-lang.org/stable/std/option/ |
5438 |
| par_either.rs |
|
1904 |
| prelude.rs |
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. |
744 |
| private.rs |
The public parts of this private module are used to create traits
that cannot be implemented outside of our own crate. This way we
can feel free to extend those traits without worrying about it
being a breaking change for other implementations. |
886 |
| range.rs |
Parallel iterator types for [ranges][std::range],
the type for values created by `a..b` expressions
You will rarely need to interact with this module directly unless you have
need to name one of the iterator types.
```
use rayon::prelude::*;
let r = (0..100u64).into_par_iter()
.sum();
// compare result with sequential calculation
assert_eq!((0..100).sum::<u64>(), r);
```
[std::range]: https://doc.rust-lang.org/core/ops/struct.Range.html |
13301 |
| range_inclusive.rs |
Parallel iterator types for [inclusive ranges][std::range],
the type for values created by `a..=b` expressions
You will rarely need to interact with this module directly unless you have
need to name one of the iterator types.
```
use rayon::prelude::*;
let r = (0..=100u64).into_par_iter()
.sum();
// compare result with sequential calculation
assert_eq!((0..=100).sum::<u64>(), r);
```
[std::range]: https://doc.rust-lang.org/core/ops/struct.RangeInclusive.html |
11315 |
| result.rs |
Parallel iterator types for [results][std::result]
You will rarely need to interact with this module directly unless you need
to name one of the iterator types.
[std::result]: https://doc.rust-lang.org/stable/std/result/ |
3409 |
| slice |
|
|
| split_producer.rs |
Common splitter for strings and slices
This module is private, so these items are effectively `pub(super)` |
4681 |
| str.rs |
Parallel iterator types for [strings][std::str]
You will rarely need to interact with this module directly unless you need
to name one of the iterator types.
Note: [`ParallelString::par_split()`] and [`par_split_terminator()`]
reference a `Pattern` trait which is not visible outside this crate.
This trait is intentionally kept private, for use only by Rayon itself.
It is implemented for `char`, `&[char]`, `[char; N]`, `&[char; N]`,
and any function or closure `F: Fn(char) -> bool + Sync + Send`.
[`ParallelString::par_split()`]: trait.ParallelString.html#method.par_split
[`par_split_terminator()`]: trait.ParallelString.html#method.par_split_terminator
[std::str]: https://doc.rust-lang.org/stable/std/str/ |
29800 |
| string.rs |
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. |
1266 |
| vec.rs |
Parallel iterator types for [vectors][std::vec] (`Vec<T>`)
You will rarely need to interact with this module directly unless you need
to name one of the iterator types.
[std::vec]: https://doc.rust-lang.org/stable/std/vec/ |
8371 |