2017-06-20 21:10:12 +00:00
|
|
|
// Copyright (c) 2017-present PyO3 Project and Contributors
|
2015-04-19 03:22:03 +00:00
|
|
|
//
|
2017-06-20 21:10:12 +00:00
|
|
|
// based on Daniel Grunwald's https://github.com/dgrunwald/rust-cpython
|
2015-04-19 03:22:03 +00:00
|
|
|
|
2017-06-21 06:26:28 +00:00
|
|
|
use std::{sync, rc, marker, mem};
|
2015-01-04 23:07:31 +00:00
|
|
|
use ffi;
|
2017-06-21 06:26:28 +00:00
|
|
|
use python::{Python, ToPyPointer};
|
2017-06-22 08:16:22 +00:00
|
|
|
use pointer::PyObjectPtr;
|
2017-06-21 06:26:28 +00:00
|
|
|
use objects::PyObject;
|
2015-01-05 16:05:53 +00:00
|
|
|
|
2016-03-05 23:22:16 +00:00
|
|
|
static START: sync::Once = sync::ONCE_INIT;
|
2015-01-05 16:05:53 +00:00
|
|
|
|
2015-06-27 20:45:35 +00:00
|
|
|
/// Prepares the use of Python in a free-threaded context.
|
2015-04-18 20:20:19 +00:00
|
|
|
///
|
2015-06-27 20:45:35 +00:00
|
|
|
/// If the Python interpreter is not already initialized, this function
|
2015-04-18 20:20:19 +00:00
|
|
|
/// will initialize it with disabled signal handling
|
2015-06-27 20:45:35 +00:00
|
|
|
/// (Python will not raise the `KeyboardInterrupt` exception).
|
2015-04-18 20:20:19 +00:00
|
|
|
/// Python signal handling depends on the notion of a 'main thread', which must be
|
2015-06-27 20:45:35 +00:00
|
|
|
/// the thread that initializes the Python interpreter.
|
|
|
|
///
|
|
|
|
/// If both the Python interpreter and Python threading are already initialized,
|
|
|
|
/// this function has no effect.
|
|
|
|
///
|
|
|
|
/// # Panic
|
|
|
|
/// If the Python interpreter is initialized but Python threading is not,
|
|
|
|
/// a panic occurs.
|
|
|
|
/// It is not possible to safely access the Python runtime unless the main
|
|
|
|
/// thread (the thread which originally initialized Python) also initializes
|
|
|
|
/// threading.
|
|
|
|
///
|
|
|
|
/// When writing an extension module, the `py_module_initializer!` macro
|
|
|
|
/// will ensure that Python threading is initialized.
|
|
|
|
///
|
2015-01-04 04:50:28 +00:00
|
|
|
pub fn prepare_freethreaded_python() {
|
2015-06-27 20:45:35 +00:00
|
|
|
// Protect against race conditions when Python is not yet initialized
|
2015-01-04 19:11:18 +00:00
|
|
|
// and multiple threads concurrently call 'prepare_freethreaded_python()'.
|
2015-06-27 20:45:35 +00:00
|
|
|
// Note that we do not protect against concurrent initialization of the Python runtime
|
|
|
|
// by other users of the Python C API.
|
2015-01-04 04:50:28 +00:00
|
|
|
START.call_once(|| unsafe {
|
2015-01-04 19:11:18 +00:00
|
|
|
if ffi::Py_IsInitialized() != 0 {
|
2015-06-27 20:45:35 +00:00
|
|
|
// If Python is already initialized, we expect Python threading to also be initialized,
|
|
|
|
// as we can't make the existing Python main thread acquire the GIL.
|
2015-01-04 19:11:18 +00:00
|
|
|
assert!(ffi::PyEval_ThreadsInitialized() != 0);
|
|
|
|
} else {
|
2015-06-27 20:45:35 +00:00
|
|
|
// If Python isn't initialized yet, we expect that Python threading isn't initialized either.
|
2015-01-04 19:11:18 +00:00
|
|
|
assert!(ffi::PyEval_ThreadsInitialized() == 0);
|
2015-06-27 20:45:35 +00:00
|
|
|
// Initialize Python.
|
2015-01-04 19:11:18 +00:00
|
|
|
// We use Py_InitializeEx() with initsigs=0 to disable Python signal handling.
|
|
|
|
// Signal handling depends on the notion of a 'main thread', which doesn't exist in this case.
|
2015-06-27 20:45:35 +00:00
|
|
|
// Note that the 'main thread' notion in Python isn't documented properly;
|
|
|
|
// and running Python without one is not officially supported.
|
2015-01-04 19:11:18 +00:00
|
|
|
ffi::Py_InitializeEx(0);
|
|
|
|
ffi::PyEval_InitThreads();
|
|
|
|
// PyEval_InitThreads() will acquire the GIL,
|
|
|
|
// but we don't want to hold it at this point
|
2015-01-04 04:50:28 +00:00
|
|
|
// (it's not acquired in the other code paths)
|
2015-01-04 19:11:18 +00:00
|
|
|
// So immediately release the GIL:
|
|
|
|
let _thread_state = ffi::PyEval_SaveThread();
|
2015-06-27 20:45:35 +00:00
|
|
|
// Note that the PyThreadState returned by PyEval_SaveThread is also held in TLS by the Python runtime,
|
2015-01-04 19:11:18 +00:00
|
|
|
// and will be restored by PyGILState_Ensure.
|
2015-01-04 04:50:28 +00:00
|
|
|
}
|
2017-06-21 06:26:28 +00:00
|
|
|
|
|
|
|
// initialize release pool
|
|
|
|
POOL = Box::into_raw(Box::new(Vec::with_capacity(250)));
|
2015-01-04 04:50:28 +00:00
|
|
|
});
|
2015-01-05 16:05:53 +00:00
|
|
|
}
|
|
|
|
|
2016-03-05 16:41:04 +00:00
|
|
|
/// RAII type that represents the Global Interpreter Lock acquisition.
|
2015-06-27 20:45:35 +00:00
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
/// ```
|
2017-05-13 05:43:17 +00:00
|
|
|
/// use pyo3::Python;
|
2015-06-27 20:45:35 +00:00
|
|
|
///
|
|
|
|
/// {
|
|
|
|
/// let gil_guard = Python::acquire_gil();
|
|
|
|
/// let py = gil_guard.python();
|
|
|
|
/// } // GIL is released when gil_guard is dropped
|
|
|
|
/// ```
|
2015-01-04 23:07:31 +00:00
|
|
|
#[must_use]
|
|
|
|
pub struct GILGuard {
|
2017-06-21 06:26:28 +00:00
|
|
|
pos: usize,
|
2016-03-05 23:22:16 +00:00
|
|
|
gstate: ffi::PyGILState_STATE,
|
|
|
|
// hack to opt out of Send on stable rust, which doesn't
|
|
|
|
// have negative impls
|
|
|
|
no_send: marker::PhantomData<rc::Rc<()>>
|
2015-01-04 23:07:31 +00:00
|
|
|
}
|
|
|
|
|
2017-06-11 15:46:23 +00:00
|
|
|
/// The Drop implementation for `GILGuard` will release the GIL.
|
2015-01-04 23:07:31 +00:00
|
|
|
impl Drop for GILGuard {
|
|
|
|
fn drop(&mut self) {
|
2017-06-21 06:26:28 +00:00
|
|
|
unsafe {
|
2017-06-22 17:26:07 +00:00
|
|
|
drain(self.pos);
|
2017-06-21 06:26:28 +00:00
|
|
|
|
|
|
|
ffi::PyGILState_Release(self.gstate);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-22 08:04:37 +00:00
|
|
|
static mut POOL: *mut Vec<PyObjectPtr> = 0 as *mut _;
|
2017-06-21 06:26:28 +00:00
|
|
|
|
2017-06-22 17:26:07 +00:00
|
|
|
pub struct Pool {
|
|
|
|
pos: usize,
|
|
|
|
no_send: marker::PhantomData<rc::Rc<()>>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Pool {
|
2017-06-22 19:32:01 +00:00
|
|
|
#[inline]
|
2017-06-22 17:26:07 +00:00
|
|
|
pub unsafe fn new() -> Pool {
|
|
|
|
let pool: &'static mut Vec<PyObject> = mem::transmute(POOL);
|
|
|
|
Pool{ pos: pool.len(), no_send: marker::PhantomData }
|
|
|
|
}
|
2017-06-22 19:32:01 +00:00
|
|
|
// /// Retrieves the marker type that proves that the GIL was acquired.
|
|
|
|
// #[inline]
|
|
|
|
// pub fn python<'p>(&'p self) -> Python<'p> {
|
|
|
|
// unsafe { Python::assume_gil_acquired() }
|
|
|
|
//}
|
2017-06-22 17:26:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Drop for Pool {
|
|
|
|
fn drop(&mut self) {
|
|
|
|
unsafe {
|
|
|
|
drain(self.pos);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub unsafe fn register<'p>(_py: Python<'p>, obj: PyObjectPtr) -> &'p PyObject {
|
|
|
|
let pool: &'static mut Vec<PyObjectPtr> = mem::transmute(POOL);
|
|
|
|
pool.push(obj);
|
|
|
|
mem::transmute(&pool[pool.len()-1])
|
|
|
|
}
|
|
|
|
|
|
|
|
pub unsafe fn drain(pos: usize) {
|
|
|
|
let pool: &'static mut Vec<PyObjectPtr> = mem::transmute(POOL);
|
|
|
|
|
|
|
|
let len = pool.len();
|
|
|
|
if pos < len {
|
|
|
|
for ob in &mut pool[pos..len] {
|
|
|
|
ffi::Py_DECREF(ob.as_ptr());
|
|
|
|
}
|
|
|
|
pool.set_len(pos);
|
2015-01-04 23:07:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-21 06:26:28 +00:00
|
|
|
|
2015-01-04 23:07:31 +00:00
|
|
|
impl GILGuard {
|
|
|
|
/// Acquires the global interpreter lock, which allows access to the Python runtime.
|
2015-06-27 20:45:35 +00:00
|
|
|
///
|
|
|
|
/// If the Python runtime is not already initialized, this function will initialize it.
|
|
|
|
/// See [prepare_freethreaded_python()](fn.prepare_freethreaded_python.html) for details.
|
2015-01-04 23:07:31 +00:00
|
|
|
pub fn acquire() -> GILGuard {
|
|
|
|
::pythonrun::prepare_freethreaded_python();
|
2017-06-21 06:26:28 +00:00
|
|
|
|
|
|
|
unsafe {
|
|
|
|
let gstate = ffi::PyGILState_Ensure(); // acquire GIL
|
|
|
|
let pool: &'static mut Vec<PyObject> = mem::transmute(POOL);
|
|
|
|
|
|
|
|
GILGuard { pos: pool.len(), gstate: gstate, no_send: marker::PhantomData }
|
|
|
|
}
|
2015-01-04 23:07:31 +00:00
|
|
|
}
|
2015-04-18 20:20:19 +00:00
|
|
|
|
|
|
|
/// Retrieves the marker type that proves that the GIL was acquired.
|
2015-06-21 22:35:01 +00:00
|
|
|
#[inline]
|
2015-01-04 23:07:31 +00:00
|
|
|
pub fn python<'p>(&'p self) -> Python<'p> {
|
|
|
|
unsafe { Python::assume_gil_acquired() }
|
|
|
|
}
|
|
|
|
}
|