pub const fn is_parallel() -> bool {
cfg!(all(feature = "parallel", not(target_arch = "wasm32")))
}
pub const MIN_PARALLEL: usize = 128;
#[cfg(all(feature = "parallel", not(target_arch = "wasm32")))]
pub fn par_map<T, R, F>(items: &[T], f: F) -> Vec<R>
where
T: Sync,
R: Send,
F: Fn(&T) -> R + Sync + Send,
{
use rayon::prelude::*;
if items.len() < MIN_PARALLEL {
return items.iter().map(f).collect();
}
items.par_iter().map(f).collect()
}
#[cfg(not(all(feature = "parallel", not(target_arch = "wasm32"))))]
pub fn par_map<T, R, F>(items: &[T], f: F) -> Vec<R>
where
T: Sync,
R: Send,
F: Fn(&T) -> R + Sync + Send,
{
items.iter().map(f).collect()
}
#[cfg(all(feature = "parallel", not(target_arch = "wasm32")))]
pub fn par_map_indexed<T, R, F>(items: &[T], f: F) -> Vec<R>
where
T: Sync,
R: Send,
F: Fn(usize, &T) -> R + Sync + Send,
{
use rayon::prelude::*;
if items.len() < MIN_PARALLEL {
return items.iter().enumerate().map(|(i, t)| f(i, t)).collect();
}
items.par_iter().enumerate().map(|(i, t)| f(i, t)).collect()
}
#[cfg(not(all(feature = "parallel", not(target_arch = "wasm32"))))]
pub fn par_map_indexed<T, R, F>(items: &[T], f: F) -> Vec<R>
where
T: Sync,
R: Send,
F: Fn(usize, &T) -> R + Sync + Send,
{
items.iter().enumerate().map(|(i, t)| f(i, t)).collect()
}
#[cfg(all(feature = "parallel", not(target_arch = "wasm32")))]
pub fn par_map_range<R, F>(len: usize, f: F) -> Vec<R>
where
R: Send,
F: Fn(usize) -> R + Sync + Send,
{
use rayon::prelude::*;
if len < MIN_PARALLEL {
return (0..len).map(f).collect();
}
(0..len).into_par_iter().map(f).collect()
}
#[cfg(not(all(feature = "parallel", not(target_arch = "wasm32"))))]
pub fn par_map_range<R, F>(len: usize, f: F) -> Vec<R>
where
R: Send,
F: Fn(usize) -> R + Sync + Send,
{
(0..len).map(f).collect()
}
#[cfg(all(feature = "parallel", not(target_arch = "wasm32")))]
pub fn par_map_range_coarse<R, F>(len: usize, f: F) -> Vec<R>
where
R: Send,
F: Fn(usize) -> R + Sync + Send,
{
use rayon::prelude::*;
(0..len).into_par_iter().map(f).collect()
}
#[cfg(not(all(feature = "parallel", not(target_arch = "wasm32"))))]
pub fn par_map_range_coarse<R, F>(len: usize, f: F) -> Vec<R>
where
R: Send,
F: Fn(usize) -> R + Sync + Send,
{
(0..len).map(f).collect()
}
#[cfg(all(feature = "parallel", not(target_arch = "wasm32")))]
pub fn par_fill_chunks<T, F>(out: &mut [T], chunk: usize, f: F)
where
T: Send,
F: Fn(usize, &mut [T]) + Sync + Send,
{
use rayon::prelude::*;
if chunk == 0 {
return;
}
if out.len() < MIN_PARALLEL {
out.chunks_mut(chunk).enumerate().for_each(|(i, c)| f(i, c));
return;
}
out.par_chunks_mut(chunk)
.enumerate()
.for_each(|(i, c)| f(i, c));
}
#[cfg(not(all(feature = "parallel", not(target_arch = "wasm32"))))]
pub fn par_fill_chunks<T, F>(out: &mut [T], chunk: usize, f: F)
where
T: Send,
F: Fn(usize, &mut [T]) + Sync + Send,
{
if chunk == 0 {
return;
}
out.chunks_mut(chunk).enumerate().for_each(|(i, c)| f(i, c));
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn par_map_preserves_order() {
let input: Vec<u32> = (0..1000).collect();
let out = par_map(&input, |&n| n * 2);
assert_eq!(out.len(), 1000);
for (i, v) in out.iter().enumerate() {
assert_eq!(*v, i as u32 * 2, "order changed at {i}");
}
}
#[test]
fn par_map_indexed_sees_the_right_index() {
let input = vec!['a', 'b', 'c'];
let out = par_map_indexed(&input, |i, c| (i, *c));
assert_eq!(out, vec![(0, 'a'), (1, 'b'), (2, 'c')]);
}
#[test]
fn par_map_range_covers_the_whole_range_in_order() {
let out = par_map_range(500, |i| i * i);
assert_eq!(out.len(), 500);
assert_eq!(out[0], 0);
assert_eq!(out[499], 499 * 499);
}
#[test]
fn empty_input_is_fine() {
let empty: Vec<u32> = Vec::new();
assert!(par_map(&empty, |&n| n).is_empty());
assert!(par_map_range(0, |i| i).is_empty());
}
#[test]
fn par_fill_chunks_writes_every_element_where_it_belongs() {
let (len, chunk) = (1003usize, 10usize);
let mut out = vec![u32::MAX; len];
par_fill_chunks(&mut out, chunk, |i, c| {
for (j, slot) in c.iter_mut().enumerate() {
*slot = (i * chunk + j) as u32;
}
});
for (i, v) in out.iter().enumerate() {
assert_eq!(*v, i as u32, "wrong value at {i}");
}
}
#[test]
fn par_fill_chunks_handles_the_degenerate_cases() {
let mut empty: Vec<u32> = Vec::new();
par_fill_chunks(&mut empty, 4, |_, _| unreachable!("nothing to fill"));
let mut untouched = vec![7u32; 3];
par_fill_chunks(&mut untouched, 0, |_, c| c.fill(0));
assert_eq!(untouched, vec![7, 7, 7]);
let mut short = vec![0u32; 3];
par_fill_chunks(&mut short, 100, |i, c| {
assert_eq!(i, 0);
c.fill(5);
});
assert_eq!(short, vec![5, 5, 5]);
}
}