I'm trying to speed up a computationally-heavy Rust function by making it concurrent using only the built-in thread support. In particular, I want to alternate between quick single-threaded phases (where the main thread has mutable access to a big structure) and concurrent phases (where many worker threads run with read-only access to the structure). I don't want to make extra copies of the structure or force it to be 'static. Where I'm having trouble is convincing the borrow checker that the worker threads have finished.

Ignoring the borrow checker, an Arc reference seems like does all that is needed. The reference count in the Arc increases with the .clone() for each worker, then decreases as the workers conclude and I join all the worker threads. If (and only if) the Arc reference count is 1, it should be safe for the main thread to resume. The borrow checker, however, doesn't seem to know about Arc reference counts, and insists that my structure needs to be 'static.

Here's some sample code which works fine if I don't use threads, but won't compile if I switch the comments to enable the multi-threaded case.

struct BigStruct { 
    data: Vec<usize>
    // Lots more
}
pub fn main() {
    let ref_bigstruct = &mut BigStruct { data: Vec::new() };
    for i in 0..3 {
        ref_bigstruct.data.push(i);    // Phase where main thread has write access
        run_threads(ref_bigstruct);    // Phase where worker threads have read-only access
    }
}

fn run_threads(ref_bigstruct: &BigStruct) {
    let arc_bigstruct = Arc::new(ref_bigstruct);
    {
        let arc_clone_for_worker = arc_bigstruct.clone();

        // SINGLE-THREADED WORKS:
        worker_thread(arc_clone_for_worker);

        // MULTI-THREADED DOES NOT COMPILE:
        // let handle = thread::spawn(move || { worker_thread(arc_clone_for_worker); } );
        // handle.join();
    }
    assert!(Arc::strong_count(&arc_bigstruct) == 1);
    println!("??? How can I tell the borrow checker that all borrows of ref_bigstruct are done?")
}

fn worker_thread(my_struct: Arc<&BigStruct>) {
    println!("   worker says len()={}", my_struct.data.len()); 
}

I'm still learning about Rust lifetimes, but what I think (fear?) what I need is an operation that will take an ordinary (not 'static) reference to my structure and give me an Arc that I can clone into immutable references with a 'static lifetime for use by the workers. Once all the the worker Arc references are dropped, the borrow checker needs to allow my thread-spawning function to return. For safety, I assume this would panic if the the reference count is >1. While this seems like it would generally confirm with Rust's safety requirements, I don't see how to do it.

CodePudding user response：

The underlying problem is not the borrowing checker not following Arc and the solution is not to use Arc. The problem is the borrow checker being unable to understand that the reason a thread must be 'static is because it may outlive the spawning thread, and thus if I immediately .join() it it is fine.

And the solution is to use scoped threads, that is, threads that allow you to use non-'static data because they always immediately .join(), and thus the spawned thread cannot outlive the spawning thread. Problem is, there are no worker threads on the standard library. Well, there are, however they're unstable.

So if you insist on not using crates, for some reason, you have no choice but to use unsafe code (don't, really). But if you can use external crates, then you can use the well-known crossbeam crate with its crossbeam::scope function, at least til std's scoped threads are stabilized.

CodePudding user response：

I hope I understand your problem correctly.

In Rust Arc< T>, T is per definition immutable. Which means in order to use Arc, to make threads access data that is going to change, you also need it to wrap in some type that is interiorly mutable. Rust provides a type that is especially suited for a single write or multiple read accesses in parallel, called RwLock.

So for your simple example, this would propably look something like this

use std::{sync::{Arc, RwLock}, thread};

struct BigStruct { 
    data: Vec<usize>
    // Lots more
}
pub fn main() {
    let arc_bigstruct = Arc::new(RwLock::new(BigStruct { data: Vec::new() }));
    for i in 0..3 {
        arc_bigstruct.write().unwrap().data.push(i);    // Phase where main thread has write access
        
        run_threads(&arc_bigstruct);    // Phase where worker threads have read-only access
    }
}

fn run_threads(ref_bigstruct: &Arc<RwLock<BigStruct>>) {
    {
        let arc_clone_for_worker = ref_bigstruct.clone();

        //MULTI-THREADED 
        let handle = thread::spawn(move || { worker_thread(&arc_clone_for_worker); } );
         handle.join().unwrap();
    }
    assert!(Arc::strong_count(&ref_bigstruct) == 1);
}

fn worker_thread(my_struct: &Arc<RwLock<BigStruct>>) {
    println!("   worker says len()={}", my_struct.read().unwrap().data.len()); 
}

Which outputs

worker says len()=1

worker says len()=2

worker says len()=3

As for your question, the borrow checker does not know when an Arc is released, as far as I know. The references are counted at runtime.