Parallel computing of array elements in rust [duplicate] - arrays

Question

This question already has answers here:
Processing vec in parallel: how to do safely, or without using unstable features?
(2 answers)
Closed 7 years ago.
I'm novice to Rust (v1.0.0) and thread-programming.
I try to calculate elements of b-array using a-array. Each element of the b-array can be calculated independently of the others (parallel).
extern crate rand;
use rand::Rng;
use std::io;
use std::thread;
use std::sync::{Arc, Mutex};
fn main() {
let mut a : [u32; 10] = [0; 10];
let mut b = Arc::new(Mutex::new([0; 10]));
let mut rng = rand::thread_rng();
for x in 0..9 {
a[x] = (rng.gen::<u32>() % 1000) + 1;
};
for x in 0..4 {
let b = b.clone();
thread::spawn(move || { let mut b = b.lock().unwrap();
for y in 0..4 {
b[x] += a[y] * a[y*2+1];
b[x+5] += a[y+1] * a[y*2];
}
});
};
thread::sleep_ms(1000);
for x in 0..a.len() {
println!("a({0})={1}, b({0})={2}", x, a[x], b[x]);
};
}
Can you help me:
if I use: let mut b = Arc::new(Mutex::new([u32; 10] = [0; 10])); -> I get error unresolved name 'u32'. Did you mean 'a'? How can I set the type of array element ?
thread::sleep_ms(1000) - It is so rudely. How can I check that all thread is finished?
How can I get back my calculated b[i] and/or gather thread-calculated b-arrays in the final one ? Now I've got error: cannot index a value of type 'alloc::arc::Arc<std::sync::mutex::Mutex<[u32; 10]>>'
Can I use only one b-array in memory and send into thread (using pointers) to calculating two elements of b-array?
Thank for solutions.
Working code is (I've modified it for show problem):
extern crate rand;
use rand::Rng;
use std::thread;
use std::sync::{Arc, Mutex};
fn main() {
let mut a : [u32; 10000] = [0; 10000];
let b = Arc::new(Mutex::new([0u32; 10]));
let mut rng = rand::thread_rng();
for x in 0..10000 {
a[x] = (rng.gen::<u32>() % 10) + 1;
};
for x in 0..5 {
let b = b.clone();
thread::spawn(move || { let mut b = b.lock().unwrap();
println!("thread {} started", x);
for y in 0..5000 {
b[x] += a[y] * a[y*2+1];
b[x+5] += a[y+1] * a[y*2];
};
b[x] += a[x];
b[x+5] -= a[x];
println!("thread {} finished", x);
});
};
thread::sleep_ms(1000);
for x in 0..10 {
println!("b({0})={1}", x, b.lock().unwrap()[x]);
};
}
The output is:
thread 1 started
thread 1 finished
thread 3 started
thread 3 finished
thread 0 started
thread 0 finished
thread 2 started
thread 2 finished
thread 4 started
thread 4 finished
b(0)=149482
...
b(9)=149065
Threads are processed step-by-step.

Answer 1

Note that the clone() method on the Arc object does not "clone" the array, simply it increments the reference counter of the Arc.
I think you are asking for a general strategy to process data in parallel in Rust. Your code lock the b array in each thread, so you have no parallel processing.
To do real parallel processing you would need a mutable access to the array without a lock on the entire array but you cannot do that in safe Rust.
To do that you have to use some sort of unsafe mechanism, such raw pointers.
This is a simple example to process a (non mutable) input vector into a (mutable) output vector concurrently:
use std::thread;
use std::sync::Arc;
fn main() {
let input = Arc::new([1u32, 2, 3, 4]);
let output = Arc::new([0; 4]);
let mut handles = Vec::new();
for t in 0..4 {
let inp = input.clone();
let out = output.clone();
let handle = thread::spawn(move || unsafe {
let p = (out.as_ptr() as *mut u32).offset(t as isize);
*p = inp[t] + (t as u32 + 1);
});
handles.push(handle);
}
for h in handles {
h.join().unwrap();
}
println!("{:?}", output);
}
You still need to use Arc to pass data into the threads and to have a proper lifetime management.
Then inside the thread you need to get a mutable pointer to the data (out.as_ptr() as *mut u32), then the item processed in that thread using the offset method.