Как лучше всего распараллелить код, изменяя несколько фрагментов одного и того же вектора Rust?

Я бы предложил сначала преобразовать slice_pairs в последовательность изменяемых срезов, а затем использовать все эти срезы параллельно.

Разделение целого среза на несколько независимых подфрагментов (с точки зрения средства проверки заимствований) можно выполнить с помощью среза::split_at_mut().
Конечно, индексы в slice_pairs должны быть упорядочены и не должны перекрываться, чтобы эти подсрезы были правильными.

Обратите внимание, что я пытался использовать .map().collect() вместо явного цикла с .push(), чтобы построить последовательность срезов, но мне это не удалось...
Компилятор сообщил, что замыкание FnMut в .map() не может вернуть ссылку; может быть кто-то сможет исправить мой код...

use rayon::prelude::*;

fn main() {
    let mut data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let slice_pairs = vec![(0, 3), (4, 7), (8, 10)];

    // build a sequence of mutable slices
    let mut slices = Vec::with_capacity(slice_pairs.len());
    let mut remaining = data.as_mut_slice();
    let mut idx = 0;
    for (start, end) in slice_pairs {
        let (_skip, tail) = remaining.split_at_mut(start - idx);
        let (sl, tail) = tail.split_at_mut(end - start);
        remaining = tail;
        idx = end;
        slices.push(sl);
    }
    println!("slices: {:?}", slices);

    // parallel usage of the mutable slices
    slices.into_par_iter().for_each(|sl| {
        for elem in sl.iter_mut() {
            *elem *= 2;
        }
    });

    println!("data: {:?}", data);
}
/*
slices: [[1, 2, 3], [5, 6, 7], [9, 10]]
data: [2, 4, 6, 4, 10, 12, 14, 8, 18, 20]
*/

Вы можете использовать split_at_mut(), чтобы разбить фрагмент на несколько фрагментов, используя безопасный код:

fn split_many<'a, T>(mut slice: &'a mut [T], regions: &[(usize, usize)]) -> Vec<&'a mut [T]> {
    let mut regions = regions.to_vec();
    regions.sort_by_key(|&(b, _e)| b);
    let mut ret = vec![];
    let mut offset = 0;
    for (b, e) in regions {
        assert!(b >= offset && e >= b); // prohibit overlaps
        let (chosen, rest) = slice.split_at_mut(e - offset);
        ret.push(&mut chosen[b - offset..]);
        offset = e;
        slice = rest;
    }
    ret
}

Имея этот помощник, вы можете выразить параллельную манипуляцию на месте «очевидным» способом:

fn main() {
    let mut data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let slice_pairs = vec![(0, 3), (4, 7), (8, 10)];

    split_many(&mut data, &slice_pairs)
        .into_par_iter()
        .for_each(|region| {
            for elem in region.iter_mut() {
                *elem *= 2;
            }
        });

    println!("{:?}", data);
}

Детская площадка

Обратите внимание: пока регионы представлены произвольными индексами, предоставленными во время выполнения, необходимо выполнить первоначальный проход через них, чтобы убедиться, что они не перекрываются (split_many() паникует, если обнаруживает перекрытие). Невыполнение этого требования было бы неразумно, поскольку простой выбор перекрывающихся регионов привел бы к неопределенному поведению. Однако если вы контролируете код, генерирующий регионы, и знаете, что они не перекрываются, вы можете создать более быструю небезопасную версию split_many(). Опираясь на внешние гарантии, ему не нужно ни сортировать, ни выделять новый набор регионов, и он может даже напрямую вернуть ParallelIterator:

/// Split `slice` into `regions` and iterate over them in parallel.
/// Safety: regions must not overlap.
unsafe fn split_many_unchecked<'a, T: Send + Sync>(
    slice: &'a mut [T],
    regions: &'a [(usize, usize)],
) -> impl ParallelIterator<Item = &'a mut [T]> + 'a {
    struct Wrap<T>(*mut T);
    unsafe impl<T> Sync for Wrap<T> {}
    unsafe impl<T> Send for Wrap<T> {}
    let slice = Wrap(slice.as_mut_ptr());
    regions.par_iter().map(move |&(b, e)| {
        let _ = &slice; // prevent closure from capturing slice.0
        std::slice::from_raw_parts_mut(slice.0.add(b), e - b)
    })
}

Детская площадка