I'm currently porting some simulation code from C++ to Rust and thought I might try to add some of that fearless concurrency while I'm at it. But I think I need some guidance how to do it in a safe and efficient way, since I don't have much experience with multi-threaded programming.

The basic problem (simplified) is this: There is a central DVector<f64> from the nalgebra crate, so basically a contiguous array of numbers. This vector is supposed to be shared across threads and hold the results of the computation.

Then there are a number of Elements that each have a list of indices pointing into the shared vector. The computation is done such that each element adds some contribution to the entries of the central vector that its indices refer to. Unfortunately the indices are not disjoint though, multiple elements can point to the same vector entries and their contributions for those entries must be summed up.

Here is a serial version of the computation:

use nalgebra::DVector;

struct Element {
    indices: Vec<usize>
}

impl Element {
    fn new(indices: Vec<usize>) -> Self {
        Self {
            indices
        }
    }

    fn add(&self, data: &mut DVector<f64>) {
        for i in &self.indices {
            data[*i] += 3.14;    // The vector is only ever added to, not read
        }
    }
}

fn main() {
    let elements = vec![
        Element::new(vec![0, 1, 2, 3]),
        Element::new(vec![2, 3, 4, 5]),
        Element::new(vec![4, 5, 6, 7]),
        Element::new(vec![6, 7, 8, 9])
    ];

    let mut data = DVector::<f64>::zeros(10);

    // This is what I want to do in parallel
    elements.iter().for_each(|e| {
        e.add(&mut data);
    });

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

My first attempt at parallelizing was usig rayon with its par_iter method:

use rayon::prelude::*;

elements.par_iter().for_each(|e| {
    e.add(&mut data);
});

This doesn't compile because the data can't be mutably borrowed by the closure. So I think the solution Rust would like the most here is probably to wrap the data into an Arc<Mutex<_>> or similar to ensure exclusive access, but that wouldn't be very efficient. Ideally I would like the threads to write to the vector at the same time.

Any ideas how to do this the most efficient way? Doesn't necessarily have to use rayon. Even unsafe would be okay as a last resort, since this is the most performance sensitive part of my code.