panic_fuse does not terminate when one thread panics

[scullionw]

use rayon::prelude::*;
use std::{thread, time::Duration};

fn run_workers(n: usize) {
    (0..n)
        .into_par_iter()
        .panic_fuse() // <- stop others ASAP if any worker panics
        .for_each(|i| {
            loop {
                println!("hi from thread: {i}");

                thread::sleep(Duration::from_secs(1));

                if i == 0 {
                    thread::sleep(Duration::from_secs(2));
                    panic!("oh no");
                }
            }
        });
}

fn main() {
    run_workers(10);

    println!("cya")
}

from the docs i would expect this to terminate?

(im trying to have a worker system where we let the system crash when there is a panic, like single threaded rust)

[adamreichold]

(im trying to have a worker system where we let the system crash when there is a panic, like single threaded rust)

A bit off-topic, but did you consider using panic = "abort" as a simpler/global way to achieve that or do you still require unwinding for internal clean-up?

[cuviper]

The for_each closure is opaque to us, and there's no means to interrupt a thread in progress like your loop. All panic_fuse() does (or can do) is avoid starting any new items after seeing a panic. Maybe we should expand on this in the docs, explaining what "stopping" really means.

panic = "abort" is definitely a stronger way to "stop now", if that works for you!

[scullionw]

i understand you cant preempt the user provided closure, but you could panic at a "supervisor" level no?

if you spawn N handles, you can theoretically monitor your handles for a panic and then panic yourself, propagating that to the caller immediately?

ie you cant stop the work, but you should be able to immediately propagate a panic? (with that information the caller could (using flags or message passing) tell the active work to stop (assuming the panic didnt propagate all the way to main)?

[scullionw]

anyways i understand its probably not what rayon wants to do -- i guess i was a bit too excited upon reading the panic_fuse docs

ill probably just handle it myself using some sort of flag set on Drop

thank you!

[cuviper]

ie you cant stop the work, but you should be able to immediately propagate a panic?

No, we definitely cannot do this, because that other work may be operating on borrowed data that would be invalidated on unwind. Your example closure is 'static, with no captures at all, but imagine if it captured a reference to a local String to include in its print statements -- then that reference would be left dangling if we panic and unwind-drop the local.

Even simpler, the closure itself is a shared &Fn to each thread, regardless of what it borrows.

[teor2345]

(im trying to have a worker system where we let the system crash when there is a panic, like single threaded rust)

A bit off-topic, but did you consider using panic = "abort" as a simpler/global way to achieve that or do you still require unwinding for internal clean-up?

Another aside:
We're required to unwind by some dependencies, so we exit in our Rayon panic handler. That might work for your use case?

Specifically for a Rayon thread pool:
https://github.com/autonomys/subspace/blob/b59b800bcb82917c40ff293ffb2d9b15efd47796/crates/subspace-farmer/src/plotter/gpu/cuda.rs#L100-L108

As a function for the default panic handler:
https://github.com/autonomys/subspace/blob/b59b800bcb82917c40ff293ffb2d9b15efd47796/shared/subspace-process/src/lib.rs#L244-L250