How do I pass disjoint slices from a vector to different threads?

by

Let’s start with the code:

// cargo-deps: crossbeam="0.7.3"
extern crate crossbeam;

const CHUNKS: usize = 10;
const CHUNK_SIZE: usize = 10;

fn main() {
    let mut table = [0; CHUNKS * CHUNK_SIZE];

    // Scoped threads allow the compiler to prove that no threads will outlive
    // table (which would be bad).
    let _ = crossbeam::scope(|scope| {
        // Chop `table` into disjoint sub-slices.
        for slice in table.chunks_mut(CHUNK_SIZE) {
            // Spawn a thread operating on that subslice.
            scope.spawn(move |_| write_slice(slice));
        }
        // `crossbeam::scope` ensures that *all* spawned threads join before
        // returning control back from this closure.
    });

    // At this point, all threads have joined, and we have exclusive access to
    // `table` again.  Huzzah for 100% safe multi-threaded stack mutation!
    println!("{:?}", &table[..]);
}

fn write_slice(slice: &mut [i32]) {
    for (i, e) in slice.iter_mut().enumerate() {
        *e = i as i32;
    }
}

One thing to note is that this needs the crossbeam crate. Rust used to have a similar “scoped” construct, but a soundness hole was found right before 1.0, so it was deprecated with no time to replace it. crossbeam is basically the replacement.

What Rust lets you do here is express the idea that, whatever the code does, none of the threads created within the call to crossbeam::scoped will survive that scope. As such, anything borrowed from outside that scope will live longer than the threads. Thus, the threads can freely access those borrows without having to worry about things like, say, a thread outliving the stack frame that table is defined by and scribbling over the stack.

So this should do more or less the same thing as the C code, though without that nagging worry that you might have missed something. 🙂

Finally, here’s the same thing using scoped_threadpool instead. The only real practical difference is that this allows us to control how many threads are used.

// cargo-deps: scoped_threadpool="0.1.6"
extern crate scoped_threadpool;

const CHUNKS: usize = 10;
const CHUNK_SIZE: usize = 10;

fn main() {
    let mut table = [0; CHUNKS * CHUNK_SIZE];

    let mut pool = scoped_threadpool::Pool::new(CHUNKS as u32);

    pool.scoped(|scope| {
        for slice in table.chunks_mut(CHUNK_SIZE) {
            scope.execute(move || write_slice(slice));
        }
    });

    println!("{:?}", &table[..]);
}

fn write_slice(slice: &mut [i32]) {
    for (i, e) in slice.iter_mut().enumerate() {
        *e = i as i32;
    }
}

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  3. Initialize a large, fixed-size array with non-Copy types
  4. Sending trait objects between threads in Rust
  5. Why would I implement methods on a trait instead of as part of the trait?
  6. How to initialize struct fields which reference each other
  7. “Expected fn item, found a different fn item” when working with function pointers
  8. How do you unwrap a Result on Ok or return from the function on Err?
  9. How do I read the entire body of a Tokio-based Hyper request?
  10. How can I downcast from Box to a trait object type?
  11. How do I ‘pass down’ feature flags to subdependencies in Cargo?
  12. How does Rust pattern matching determine if the bound variable will be a reference or a value?
  13. Using generic trait methods like .into() when type inference is impossible
  14. What is a crate attribute and where do I add it?
  15. Parameter type may not live long enough?
  16. How to model complex recursive data structures (graphs)?
  17. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  18. print! macro not executed until pressing Enter
  19. How can I define an async method in a trait?
  20. How do I specify the linker path in Rust?
  21. Why am I getting “parameter is never used [E0392]”?
  22. How do I specify that a struct field must implement a trait?
  23. How do I print an integer in binary with leading zeros?
  24. What does Rust’s unary || (parallel pipe) mean?
  25. How to create and write to memory mapped files?
  26. How does Rust’s type inference work across multiple statements?
  27. Downcast traits inside Rc for AST manipulation
  28. How to check in Rust if architecture is 32 or 64 bit?
  29. Is there any way to restrict a generic type to one of several types?
  30. How to pass rustc flags to cargo?

Leave a Comment