Struct Rayon 

pub struct Rayon { /* private fields */ }

A parallel execution strategy backed by a Commonware thread pool.

This strategy adaptively executes collection operations serially or through its backing pool. It records wall-clock estimates by callsite, input-size and work-size buckets, and planning parallelism so small inputs can avoid thread-pool scheduling overhead without disabling parallel execution for larger inputs.

Nested calls at the same callsite share estimates across parent paths, so use distinct callsites (propagating #[track_caller] through helpers as needed) to tune them separately.

Thread Pool Ownership

Rayon shares its rayon::ThreadPool through an Arc, so it can be cheaply cloned and shared across threads. Multiple strategies can share the same pool.

When to Use

Use Rayon when:

• Processing large collections where parallelism overhead is justified
• The fold/reduce operations are CPU-bound
• You want to utilize multiple cores

Consider Sequential instead when:

• The collection is small
• Operations are I/O-bound rather than CPU-bound
• Deterministic execution order is required for debugging

Examples

use commonware_parallel::{Strategy, Rayon};
use std::num::NonZeroUsize;

let strategy = Rayon::new(NonZeroUsize::new(2).unwrap()).unwrap();

let data: Vec<i64> = (0..1000).collect();
let sum = strategy.fold(&data, || 0i64, |acc, &n| acc + n, |a, b| a + b);
assert_eq!(sum, 499500);

Implementations

impl Rayon

pub fn new(num_threads: NonZeroUsize) -> Result<Self, ThreadPoolBuildError>

Creates a Rayon strategy with a ThreadPool that is configured with the given number of threads.

pub fn with_pool(thread_pool: ThreadPool) -> Self

Creates a new Rayon strategy with the given ThreadPool.

Build the pool with ThreadPoolBuilder and wrap it in an Arc.

pub const fn with_parallelism(self, parallelism: NonZeroUsize) -> Self

Overrides the parallelism assumed for planning decisions.

This does not resize the backing pool. By default a strategy plans with the pool’s thread count; override it when the strategy should expose a different parallelism (e.g. a runtime that executes strategy work inline on a single thread).

Trait Implementations

impl Clone for Rayon

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Rayon

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Strategy for Rayon

Available on (crate features std) and neither commonware_stability_DELTA nor commonware_stability_EPSILON nor commonware_stability_GAMMA nor commonware_stability_RESERVED only.

fn spawn<F, T>( &self, len: usize, f: F, ) -> impl Future<Output = T> + Send + 'static

where F: FnOnce(Self) -> T + Send + 'static, T: Send + 'static,

A pool worker that awaits the result runs queued jobs on its own stack while it waits, so blocking waits inside jobs must allow nesting. For example, futures::executor::block_on panics if a nested job calls it on a thread that is already inside it.

fn run<R, SEQ, PAR>(&self, len: usize, serial: SEQ, parallel: PAR) -> R

where R: Send, SEQ: FnOnce() -> R + Send, PAR: FnOnce() -> R + Send,

Runs either a serial or parallel body.

fn try_run<R, E, SEQ, PAR>( &self, len: usize, serial: SEQ, parallel: PAR, ) -> Result<R, E>

where R: Send, E: Send, SEQ: FnOnce() -> Result<R, E> + Send, PAR: FnOnce() -> Result<R, E> + Send,

Like run, but for fallible work.

fn try_run_batches<R, E, F>( &self, len: usize, minimum_batch_len: NonZeroUsize, multiplier: usize, run: F, ) -> Result<R, E>

where R: Send, E: Send, F: for<'scope> FnOnce(Batches<'scope, Self>) -> Result<R, E> + Send,

Like run_batches, but for fallible work.

fn run_tiles<R, F>( &self, len: usize, grids: &[Grid], multiplier: usize, run: F, ) -> R

where R: Send, F: for<'scope> FnOnce(Tiles<'scope, Self>) -> R + Send,

Run an operation on strategy-provided tiles over len columns.

fn fold_init<I, INIT, T, R, ID, F, RD>( &self, iter: I, init: INIT, identity: ID, fold_op: F, reduce_op: RD, ) -> R

where I: IntoIterator<IntoIter: Send, Item: Send> + Send, INIT: Fn() -> T + Send + Sync, T: Send, R: Send, ID: Fn() -> R + Send + Sync, F: Fn(R, &mut T, I::Item) -> R + Send + Sync, RD: Fn(R, R) -> R + Send + Sync,

Reduces a collection to a single value with per-partition initialization.

fn map_collect_vec<I, F, T>(&self, iter: I, map_op: F) -> Vec<T>

where I: IntoIterator<IntoIter: Send, Item: Send> + Send, F: Fn(I::Item) -> T + Send + Sync, T: Send,

Maps each element and collects results into a Vec.

fn try_map_collect_vec<I, F, T, E>( &self, iter: I, map_op: F, ) -> Result<Vec<T>, E>

where I: IntoIterator<IntoIter: Send, Item: Send> + Send, F: Fn(I::Item) -> Result<T, E> + Send + Sync, T: Send, E: Send,

Maps each element with a fallible operation and collects results into a Vec.

fn map_init_collect_vec<I, INIT, T, F, R>( &self, iter: I, init: INIT, map_op: F, ) -> Vec<R>

where I: IntoIterator<IntoIter: Send, Item: Send> + Send, INIT: Fn() -> T + Send + Sync, T: Send, F: Fn(&mut T, I::Item) -> R + Send + Sync, R: Send,

Maps each element with per-partition state and collects results into a Vec.

fn map_init_collect_vec_with_multiplier<I, INIT, T, F, R>( &self, iter: I, multiplier: usize, init: INIT, map_op: F, ) -> Vec<R>

where I: IntoIterator<IntoIter: Send, Item: Send> + Send, INIT: Fn() -> T + Send + Sync, T: Send, F: Fn(&mut T, I::Item) -> R + Send + Sync, R: Send,

Maps each element with per-partition state and a per-item work multiplier.

fn try_fold<I, R, E, ID, F, RD>( &self, iter: I, identity: ID, fold_op: F, reduce_op: RD, ) -> Result<R, E>

where I: IntoIterator<IntoIter: Send, Item: Send> + Send, R: Send, E: Send, ID: Fn() -> R + Send + Sync, F: Fn(R, I::Item) -> Result<R, E> + Send + Sync, RD: Fn(R, R) -> R + Send + Sync,

Reduces a collection to a single value using a fallible fold operation.

fn join<A, B, RA, RB>(&self, a: A, b: B) -> (RA, RB)

where A: FnOnce() -> RA + Send, B: FnOnce() -> RB + Send, RA: Send, RB: Send,

Executes two closures, potentially in parallel, and returns both results.

fn sort_by<T, C>(&self, items: &mut [T], compare: C)

where T: Send, C: Fn(&T, &T) -> Ordering + Send + Sync,

Sorts a slice with a comparator, preserving the order of equal elements.

fn sort_unstable_by<T, C>(&self, items: &mut [T], compare: C)

where T: Send, C: Fn(&T, &T) -> Ordering + Send + Sync,

Sorts a slice with a comparator, without preserving the order of equal elements.

fn run_batches<R, F>( &self, len: usize, minimum_batch_len: NonZeroUsize, multiplier: usize, run: F, ) -> R

where R: Send, F: for<'scope> FnOnce(Batches<'scope, Self>) -> R + Send,

Run an operation on strategy-provided batches.

fn fold<I, R, ID, F, RD>( &self, iter: I, identity: ID, fold_op: F, reduce_op: RD, ) -> R

where I: IntoIterator<IntoIter: Send, Item: Send> + Send, R: Send, ID: Fn() -> R + Send + Sync, F: Fn(R, I::Item) -> R + Send + Sync, RD: Fn(R, R) -> R + Send + Sync,

Reduces a collection to a single value using fold and reduce operations.

fn map_collect_vec_with_multiplier<I, F, R>( &self, iter: I, multiplier: usize, map_op: F, ) -> Vec<R>

where I: IntoIterator<IntoIter: Send, Item: Send> + Send, F: Fn(I::Item) -> R + Send + Sync, R: Send,

Maps each element with a per-item work multiplier.

fn map_partition_collect_vec<I, F, K, U>( &self, iter: I, map_op: F, ) -> (Vec<U>, Vec<K>)

where I: IntoIterator<IntoIter: Send, Item: Send> + Send, F: Fn(I::Item) -> (K, Option<U>) + Send + Sync, K: Send, U: Send,

Maps each element, filtering out None results and tracking their keys.