Struct Rayon 

pub struct Rayon { /* private fields */ }

A parallel execution strategy backed by a rayon thread pool.

This strategy executes fold operations in parallel across multiple threads. It wraps a rayon ThreadPool and uses it to schedule work.

Thread Pool Ownership

Rayon holds an Arc<ThreadPool>, so it can be cheaply cloned and shared across threads. Multiple Rayon instances can share the same underlying thread 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 const fn with_pool(thread_pool: ThreadPool) -> Self

Creates a new Rayon strategy with the given ThreadPool.

Trait Implementations

impl Clone for Rayon

fn clone(&self) -> Rayon

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

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 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<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 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.