Trait bevy_internal::tasks::ParallelSliceMut

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

Provides functions for mapping mutable slices across a provided TaskPool.

Provided Methods

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

where F: Fn(&mut [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.

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

Example

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

assert_eq!(counts, (5..10005).collect::<Vec<u32>>());

See Also

ParallelSlice::par_chunk_map for mapping immutable slices. ParallelSliceMut::par_splat_map_mut for mapping when a specific chunk size is unknown.

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

where F: Fn(&mut [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.

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

Example

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

assert_eq!(counts, (5..10005).collect::<Vec<u32>>());

See Also

ParallelSlice::par_splat_map for mapping immutable slices. ParallelSliceMut::par_chunk_map_mut for mapping when a specific chunk size is desirable.

Object Safety

This trait is not object safe.

Implementors

impl<S, T> ParallelSliceMut<T> for S

where T: Send, S: AsMut<[T]>,