Enum Par 

pub enum Par<'team> {
    Seq,
    Rayon(NonZeroUsize),
    // some variants omitted
}

determines the parallelization configuration, and carries the right to execute with it

Par is neither Copy nor Clone: a Team owns exclusive authority over reserved threads, so a duplicate could hand the same threads to two concurrent children. Every function that runs work takes Par by value; a caller that needs another phase lends the parallelism with Par::reborrow, and concurrent children are created by splitting (see utils::thread::split), never by copying. Queries that only need the size (workspace requirements, thresholds) use ParShape or Par::degree.

use faer::{Par, ParShape};
// sizes are plain values
fn is_copy<T: Copy>() {}
is_copy::<ParShape>();
// phases lend, they do not copy
fn phase(_: Par<'_>) {}
let mut par = Par::Seq;
phase(par.reborrow());
phase(par);

Not Copy:

fn is_copy<T: Copy>() {}
is_copy::<faer::Par<'static>>();

Not Clone:

fn is_clone<T: Clone>() {}
is_clone::<faer::Par<'static>>();

A phase that takes the parallelism consumes it:

fn phase(_: faer::Par<'_>) {}
let par = faer::Par::Seq;
phase(par);
phase(par);

Concurrent children cannot both use the parent:

fn phase(_: faer::Par<'_>) {}
let par = faer::Par::Seq;
faer::utils::thread::join_raw(|_| phase(par), |_| phase(par), faer::Par::Seq);

Variants

Seq

sequential, non portable across different platforms

Rayon(NonZeroUsize)

parallelized using the global rayon threadpool, non portable across different platforms

Implementations

impl Par<'_>

pub fn reborrow(&mut self) -> Par<'_>

lends the parallelism for one phase. The parent is exclusively borrowed and unusable while the lent value lives, so a phase sequence never holds the authority twice.

pub fn shape(&self) -> ParShape

the shape of this parallelism, without the right to execute with it

pub fn rayon(nthreads: usize) -> Self

returns Par::Rayon(nthreads) if nthreads is non-zero, or Par::Rayon(rayon::current_num_threads()) otherwise

pub fn degree(&self) -> usize

the number of threads that should ideally execute an operation with the given parallelism

Trait Implementations

impl<'team> Debug for Par<'team>

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

Formats the value using the given formatter.