Struct RayonComm 

pub struct RayonComm;

Shared-memory communicator using Rayon for parallelism.

Implements the Comm trait for shared-memory parallelism. All collective operations are no-ops or local, as there is no inter-process communication.

Implementations

impl RayonComm

pub fn new() -> Self

Creates a new RayonComm and initializes the global Rayon thread pool to use all available CPU cores.

If the global thread pool is already initialized, this is a no-op.

Trait Implementations

impl Clone for RayonComm

fn clone(&self) -> RayonComm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Comm for RayonComm

fn rank(&self) -> usize

Returns the rank of the current process (always 0 in shared memory).

fn size(&self) -> usize

Returns the number of parallel workers (number of CPU cores).

fn barrier(&self)

Synchronization barrier (no-op in shared memory, but uses a Rayon scope for API compatibility).

fn scatter<T: Clone>(&self, global: &[T], out: &mut [T], root: usize)

Mimics scatter operation by copying a chunk of the global array to the output buffer.

Arguments

• global - The global data array.
• out - The output buffer to fill.
• root - The root rank (used as an offset multiplier).

fn gather<T: Clone>(&self, local: &[T], out: &mut Vec<T>, _root: usize)

Mimics gather operation by copying the local buffer into the output vector.

Arguments

• local - The local data buffer.
• out - The output vector to fill.
• _root - The root rank (unused).

fn all_reduce(&self, x: f64) -> f64

All-reduce operation (no-op, returns input value).

In shared memory, all-reduce is unnecessary, so this just returns the input.

fn all_reduce_f64(&self, local: f64) -> f64

All‐reduce a scalar (sum) across ranks - new trait method

fn split(&self, _color: i32, _key: i32) -> UniverseComm

Split this communicator into sub‐colors

fn parallel_mat_vec(&self, a: &Mat<f64>, x: &[f64], y: &mut [f64])

Parallel matrix-vector multiplication using Rayon.

Arguments

• a - Matrix (faer::Mat).
• x - Input vector.
• y - Output vector (will be overwritten).

type Vec = Vec<f64>

type Request<'a> = ()

fn irecv_from<'a>(&'a self, _buf: &'a mut [f64], _src: i32) -> Self::Request<'a>

Nonblocking receive into buf from src.

fn isend_to<'a>(&'a self, _buf: &'a [f64], _dest: i32) -> Self::Request<'a>

Nonblocking send of buf to dest.

fn irecv_from_u64<'a>( &'a self, _buf: &'a mut [u64], _src: i32, ) -> Self::Request<'a>

Nonblocking receive of u64 words.

fn isend_to_u64<'a>(&'a self, _buf: &'a [u64], _dest: i32) -> Self::Request<'a>

Nonblocking send of u64 words.

fn wait_all<'a>(&self, _reqs: &mut [Self::Request<'a>])

Wait for all requests to complete.

fn allreduce_sum(&self, x: f64) -> f64

Reduce one scalar (sum) across ranks.

fn allreduce_sum2(&self, a: f64, b: f64) -> (f64, f64)

Reduce two scalars (sum) in a single collective. Default: two single reductions.

fn allreduce_sum_slice(&self, v: &mut [f64])

Reduce a slice of scalars in place (sum).

fn dot(&self, a: &[f64], b: &[f64]) -> f64

impl Default for RayonComm

fn default() -> Self

Returns the “default value” for a type.