Trait ParallelSlice

pub trait ParallelSlice<T: Sync>: AsRef<[T]> {
    // Provided methods
    fn par_chunk_map<F, R>(
        &self,
        task_pool: &TaskPool,
        chunk_size: usize,
        f: F,
    ) -> Vec<R>
       where F: Fn(usize, &[T]) -> R + Send + Sync,
             R: Send + 'static { ... }
    fn par_splat_map<F, R>(
        &self,
        task_pool: &TaskPool,
        max_tasks: Option<usize>,
        f: F,
    ) -> Vec<R>
       where F: Fn(usize, &[T]) -> R + Send + Sync,
             R: Send + 'static { ... }
}

Provides functions for mapping read-only slices across a provided TaskPool.

Provided Methods

fn par_chunk_map<F, R>( &self, task_pool: &TaskPool, chunk_size: usize, f: F, ) -> Vec<R>

where F: Fn(usize, &[T]) -> R + Send + Sync, R: Send + 'static,

Splits the slice in chunks of size chunks_size or less and maps the chunks in parallel across the provided task_pool. One task is spawned in the task pool for every chunk.

The iteration function takes the index of the chunk in the original slice as the first argument, and the chunk as the second argument.

Returns a Vec of the mapped results in the same order as the input.

Example

let task_pool = TaskPool::new();
let counts = (0..10000).collect::<Vec<u32>>();
let incremented = counts.par_chunk_map(&task_pool, 100, |_index, chunk| {
  let mut results = Vec::new();
  for count in chunk {
    results.push(*count + 2);
  }
  results
});

See Also

• ParallelSliceMut::par_chunk_map_mut for mapping mutable slices.
• ParallelSlice::par_splat_map for mapping when a specific chunk size is unknown.

fn par_splat_map<F, R>( &self, task_pool: &TaskPool, max_tasks: Option<usize>, f: F, ) -> Vec<R>

where F: Fn(usize, &[T]) -> R + Send + Sync, R: Send + 'static,

Splits the slice into a maximum of max_tasks chunks, and maps the chunks in parallel across the provided task_pool. One task is spawned in the task pool for every chunk.

If max_tasks is None, this function will attempt to use one chunk per thread in task_pool.

The iteration function takes the index of the chunk in the original slice as the first argument, and the chunk as the second argument.

Returns a Vec of the mapped results in the same order as the input.

Example

let task_pool = TaskPool::new();
let counts = (0..10000).collect::<Vec<u32>>();
let incremented = counts.par_splat_map(&task_pool, None, |_index, chunk| {
  let mut results = Vec::new();
  for count in chunk {
    results.push(*count + 2);
  }
  results
});

See Also

ParallelSliceMut::par_splat_map_mut for mapping mutable slices. ParallelSlice::par_chunk_map for mapping when a specific chunk size is desirable.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<S, T: Sync> ParallelSlice<T> for S

where S: AsRef<[T]>,