Struct Manual 

pub struct Manual<S> { /* private fields */ }

A strategy wrapper for manually partitioned work.

Built via Strategy::manual, this disables adaptive policy decisions (including spawn placement) for operations that callers have already split into partitions, and carries the parallelism used to plan those partitions.

Implementations

impl<S> Manual<S>

pub const fn parallelism(&self) -> usize

Returns the parallelism to use for manually partitioned work.

Trait Implementations

impl<S: Clone> Clone for Manual<S>

fn clone(&self) -> Manual<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for Manual<S>

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

Formats the value using the given formatter.

impl<S: Strategy> Strategy for Manual<S>

Available on neither commonware_stability_DELTA nor commonware_stability_EPSILON nor commonware_stability_GAMMA nor commonware_stability_RESERVED.

fn manual(&self) -> Manual<Self>

Returns a strategy wrapper for manually partitioned work.

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,

Submit one CPU-bound job to this strategy, running it inline on the calling task when it is measured cheaper than the round trip of offloading it to the pool.

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

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