Can we read python class attribute without gil in Rust?

[noonchen]

Greetings,

I'd like to stop a Rust loop from python side.

Say we have a python class Flag:

class Flag:
    stop = False

f = Flag()

In Rust we have a function that will be running for a long time. I wish that once I set f.stop = True by clicking a GUI button on python side that will stop rust loop. Is it possible to obtain the reference of f.stop so that we don't have to acquire gil every iteration?

fn func_take_long_time(py: Python, object: &PyAny) {
    let stop_flag: &bool =     // can we get the reference of `f.stop` as `&bool`?

    while true {
    if *stop_flag { break; }

    // .. do some time critical work
    }
}

[birkenfeld]

No, this is not possible. Among other things, there is no &bool that would change, since Python bool objects are immmutable. Reassigning f.stop = True sets the "stop" entry in f.__dict__ to the True object instead of the False object.

However, what you may be able to do is to move setting the stop flag to Rust, by providing a method/function set_stop_flag() implemented in Rust. Then, you can set an actual Rust bool flag (well, probably AtomicBool) and check it cheaply from Rust code.

[mejrs]

That'd probably need to be an Arc<AtomicBool>, which can be shared between your pyclass and some other rust code.

[noonchen]

Thanks for the answer and suggestion. I just have another idea but I don't know if it's possible:

fn func_take_long_time(py: Python, object: &PyAny) {
    let stop_flag = Arc::new(AtomicBool::new(false));
    // start a new thread, acquire gil and store python `f.stop` result to rust bool
    let stop_clone = stop_flag.clone();
    thread::spawn(move || { stop_clone.store(/* acquire gil here and get `f.stop` */, Ordering::Relaxed) })

    while true {
    if stop_flag.load(Ordering::Relaxed) { break; }

    // .. do some time critical work
    }

    // clean up ....
}

Can this work as expected?

[adamreichold]

Can this work as expected?

I think it can work, but you have to decouple object: &PyAny from the GIL first, i.e.

let stop_clone = stop_flag.clone();
let object: Py<PyAny> = object.into();
thread::spawn(move || { stop_clone.store(Python::with_gil(|py| object.getattr(py, "stop").extract::<bool>().unwrap()), Ordering::Relaxed) });

But I think this is a bit round-about and would suggest you use a custom #[pyclass] as a handle type, e.g.

#[pyclass]
pub struct TakeLongTimeHandle {
  stop_flag: Arc<AtomicBool>,
  join_handle: Option<JoinHandle<()>>,
}

#[pymethods]
impl TakeLongTimeHandle {
  #[new]
  pub fn new() -> Self {
    let stop_flag = Arc::new(AtomicBool::new(false));

    let join_handle = {
      let stop_clone = stop_flag.clone();

      thread::spawn(move || {
        while !stop_flag.load(Ordering::Relaxed) {
          // .. do some time critical work
        }
      });
    }

    Self { stop_flag, join_handle: Some(join_handle) }
  }

  pub fn stop(&mut self) {
    if let Some(join_handle) = self.join_handle.take() {
      stop.store(true, Ordering::Relaxed);
      join_handle.join().unwrap();
    }
  }
}

(I have not actually tried to compile these examples. Sorry if they still contain errors.)

[noonchen]

Thanks, it's really helpful!