pyo3/src/pythonrun.rs

168 lines
5.7 KiB
Rust
Raw Normal View History

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};
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
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
/// ```
#[must_use]
pub struct GILGuard {
2017-06-21 06:26:28 +00:00
pos: usize,
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<()>>
}
2017-06-11 15:46:23 +00:00
/// The Drop implementation for `GILGuard` will release the GIL.
impl Drop for GILGuard {
fn drop(&mut self) {
2017-06-21 06:26:28 +00:00
unsafe {
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
pub struct Pool {
pos: usize,
no_send: marker::PhantomData<rc::Rc<()>>,
}
impl Pool {
#[inline]
pub unsafe fn new() -> Pool {
let pool: &'static mut Vec<PyObject> = mem::transmute(POOL);
Pool{ pos: pool.len(), no_send: marker::PhantomData }
}
// /// 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() }
//}
}
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);
}
}
2017-06-21 06:26:28 +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.
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-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]
pub fn python<'p>(&'p self) -> Python<'p> {
unsafe { Python::assume_gil_acquired() }
}
}