How to avoid deadlock when acquiring the GIL inside a multithreaded tokio::spawn

[jonmmease]

First off, thanks for PyO3. It works amazingly well, and I love having the ability to write Python libraries (like VegaFusion) in Rust!

Now for the question. I've run into a deadlock that I don't think is the same kind of situation as https://pyo3.rs/v0.15.1/faq.html#im-experiencing-deadlocks-using-pyo3-with-lazy_static-or-once_cell. The deadlock happens when attempting to acquire the GIL from inside a tokio::spawn async block, and only when tokio is running in multi-threaded mode.

Here's a repro:

cargo.toml

[package]
name = "pyo3_async"
version = "0.1.0"
edition = "2021"

[lib]
name = "pyo3_async"

[dependencies.tokio]
version = "1.18.1"
features = ["rt-multi-thread"]

[dependencies.pyo3]
version = "0.18.1"
features = [ "extension-module",]

lib.rs

use std::sync::Arc;
use pyo3::prelude::*;

fn get_gil() {
    println!("Try to acquire GIL");
    Python::with_gil(|_py| {
        println!("GIL acquired");
    });
}

pub async fn spawn_get_gil() {
    tokio::spawn(async {
        get_gil()
    }).await.unwrap();
}

#[derive(Clone)]
#[pyclass]
pub struct Foo {
    runtime: Arc<tokio::runtime::Runtime>
}

#[pymethods]
impl Foo {
    #[new]
    pub fn new(multi_thread: bool) -> PyResult<Self> {
        let runtime = if multi_thread {
            tokio::runtime::Builder::new_multi_thread()
                .enable_all()
                .build()
                .unwrap()
        } else {
            tokio::runtime::Builder::new_current_thread()
                .enable_all()
                .build()
                .unwrap()
        };
        Ok(Self {
            runtime: Arc::new(runtime)
        })
    }

    pub fn get_gil(&self) {
        self.runtime.block_on(spawn_get_gil());
    }
}

#[pymodule]
fn pyo3_async(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
    m.add_class::<Foo>()?;
    Ok(())
}

try_it.py

from pyo3_async import Foo
foo = Foo(multi_thread=False)
foo.get_gil()

Try to acquire GIL
GIL acquired

foo = Foo(multi_thread=True)
foo.get_gil()

(Deadlock)

So, everything works fine for the current thread tokio runtime, but the deadlock happens for the mult-threaded case.

I can use the single threaded runtime for now, and I realize that using the multi-threaded runtime won't speed up the Python code due to the GIL. But, I'd like to use the multi-threaded runtime because, in VegaFusion, I have other tasks that don't require the GIL that I'd like to be able to parallelize.

I'd appreciate any tips or ideas folks have. Thanks!

[mejrs]

You are already holding the gil because it is called from python. You can acquire the gil on the current thread again, because it is re-entrant, but not on another thread, where it will block (and deadlock, in this case). You can get around this with https://docs.rs/pyo3/latest/pyo3/marker/struct.Python.html#method.allow_threads

I have other tasks that don't require the GIL that I'd like to be able to parallelize.

Are you sure you actually want to use tokio? You haven't gone into depth on what you are doing but based on this it does not seem appropriate for your tasks.

[jonmmease]

Thanks @mejrs, that's helpful framing.

As for the use of tokio, we're building on DataFusion, which uses tokio for task parallelization. See https://thenewstack.io/using-rustlangs-async-tokio-runtime-for-cpu-bound-tasks/ for the rationale of using tokio this way.