Sub-interpreters inside rust side ( interpreter per runtime worker )

[codingmstr]

I created subinterpreters, one for each operator, but I'm having trouble using REST classes within these subinterpreteres. I always get the error: munmap_chunk(): invalid pointer
Aborted (core dumped) or the error: segment fault ,

code :
lib.rs ->
use pyo3::prelude::*;
pub mod core;

#[pymodule]
fn turbox( py: Python, m: &Bound<'_, PyModule> ) -> PyResult<()> {

crate::core::worker::build_module(py, m)

}

workers. ->
use pyo3::prelude::*;
use pyo3::ffi;
use std::ptr;
use std::cell::RefCell;

use crate::core::route::Route;
use crate::core::server::Server;

thread_local! {
pub static WORKER_INTERPRETER_STATE: RefCell<*mut ffi::PyThreadState> = RefCell::new(ptr::null_mut());
}

pub fn build_module( py: Python<'>, m: &Bound<'_, PyModule> ) -> PyResult<()> {

m.add_class::<Route>()?;
m.add_class::<Server>()?;
Ok(())

}
pub fn ensure_sub_interpreter_initialized() {

WORKER_INTERPRETER_STATE.with(|cell| {

    if cell.borrow().is_null() {

        unsafe {

            let gstate = ffi::PyGILState_Ensure();

            let config = ffi::PyInterpreterConfig {
                use_main_obmalloc: 0,
                allow_fork: 0,
                allow_exec: 0,
                allow_threads: 1,
                allow_daemon_threads: 0,
                check_multi_interp_extensions: 1,
                gil: ffi::PyInterpreterConfig_OWN_GIL,
            };

            let mut new_interp: *mut ffi::PyThreadState = ptr::null_mut();
            let status = ffi::Py_NewInterpreterFromConfig(&mut new_interp, &config);

            if ffi::PyStatus_Exception(status) != 0 {
                ffi::PyGILState_Release(gstate);
                panic!("Failed to create sub-interpreter");
            }

            let py = Python::assume_attached();

            if let Ok(sys) = py.import("sys") {

                if let Ok(path) = sys.getattr("path") {
                    if let Ok(cwd) = std::env::current_dir() {
                        let _ = path.call_method1("insert", (0, cwd.to_string_lossy()));
                    }
                }
                if let Ok(modules) = sys.getattr("modules") {
                    let module = PyModule::new(py, "turbox").expect("Failed to create module");
                    if let Err(e) = build_module(py, &module) {
                        e.print(py);
                        panic!("Failed to build module");
                    }
                    let _ = modules.set_item("turbox", module);
                }

            }

            let suspended = ffi::PyEval_SaveThread();
            *cell.borrow_mut() = suspended;

        }

    }

});

}

I would appreciate it if you could tell me the correct way to do this successfully.

[davidhewitt]

You should read #3451. The short answer is that PyO3 does not yet support subinterpreters well.