Merge pull request #869 from kngwyu/unsafe-gilpool

Bound 'py lifetime by GILPool in the internal usecases

CHANGELOG.md

@@ -20,6 +20,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ### Fixed
 * `__radd__` and other `__r*__` methods now correctly work with operators. [#839](https://github.com/PyO3/pyo3/pull/839)
 * Garbage Collector causing random panics when traversing objects that were mutably borrowed. [#855](https://github.com/PyO3/pyo3/pull/855)
+* `&'static Py~` being allowed as arguments. [#869](https://github.com/PyO3/pyo3/pull/869)
 
 ## [0.9.2]
 

pyo3-derive-backend/src/module.rs

@@ -220,9 +220,9 @@ fn function_c_wrapper(name: &Ident, spec: &method::FnSpec<'_>) -> TokenStream {
         {
             const _LOCATION: &'static str = concat!(stringify!(#name), "()");
 
-            let _py = pyo3::Python::assume_gil_acquired();
+            let _pool = pyo3::GILPool::new();
+            let _py = _pool.python();
             pyo3::run_callback(_py, || {
-                let _pool = pyo3::GILPool::new(_py);
                 let _args = _py.from_borrowed_ptr::<pyo3::types::PyTuple>(_args);
                 let _kwargs: Option<&pyo3::types::PyDict> = _py.from_borrowed_ptr_or_opt(_kwargs);
 

pyo3-derive-backend/src/pymethod.rs

@@ -105,9 +105,9 @@ fn impl_wrap_common(
             {
                 const _LOCATION: &'static str = concat!(
                     stringify!(#cls), ".", stringify!(#python_name), "()");
-                let _py = pyo3::Python::assume_gil_acquired();
+                let _pool = pyo3::GILPool::new();
+                let _py = _pool.python();
                 pyo3::run_callback(_py, || {
-                    let _pool = pyo3::GILPool::new(_py);
                     #slf
                     pyo3::callback::convert(_py, #body)
                 })
@@ -124,9 +124,9 @@ fn impl_wrap_common(
             {
                 const _LOCATION: &'static str = concat!(
                     stringify!(#cls), ".", stringify!(#python_name), "()");
-                let _py = pyo3::Python::assume_gil_acquired();
+                let _pool = pyo3::GILPool::new();
+                let _py = _pool.python();
                 pyo3::run_callback(_py, || {
-                    let _pool = pyo3::GILPool::new(_py);
                     #slf
                     let _args = _py.from_borrowed_ptr::<pyo3::types::PyTuple>(_args);
                     let _kwargs: Option<&pyo3::types::PyDict> = _py.from_borrowed_ptr_or_opt(_kwargs);
@@ -155,9 +155,9 @@ pub fn impl_proto_wrap(cls: &syn::Type, spec: &FnSpec<'_>) -> TokenStream {
             _kwargs: *mut pyo3::ffi::PyObject) -> *mut pyo3::ffi::PyObject
         {
             const _LOCATION: &'static str = concat!(stringify!(#cls),".",stringify!(#python_name),"()");
-            let _py = pyo3::Python::assume_gil_acquired();
+            let _pool = pyo3::GILPool::new();
+            let _py = _pool.python();
             pyo3::run_callback(_py, || {
-                let _pool = pyo3::GILPool::new(_py);
                 let _slf = _py.from_borrowed_ptr::<pyo3::PyCell<#cls>>(_slf);
                 #borrow_self
                 let _args = _py.from_borrowed_ptr::<pyo3::types::PyTuple>(_args);
@@ -193,9 +193,9 @@ pub fn impl_wrap_new(cls: &syn::Type, spec: &FnSpec<'_>) -> TokenStream {
             use pyo3::type_object::PyTypeInfo;
 
             const _LOCATION: &'static str = concat!(stringify!(#cls),".",stringify!(#python_name),"()");
-            let _py = pyo3::Python::assume_gil_acquired();
+            let _pool = pyo3::GILPool::new();
+            let _py = _pool.python();
             pyo3::run_callback(_py, || {
-                let _pool = pyo3::GILPool::new(_py);
                 let _args = _py.from_borrowed_ptr::<pyo3::types::PyTuple>(_args);
                 let _kwargs: Option<&pyo3::types::PyDict> = _py.from_borrowed_ptr_or_opt(_kwargs);
 
@@ -225,9 +225,9 @@ pub fn impl_wrap_class(cls: &syn::Type, spec: &FnSpec<'_>) -> TokenStream {
             _kwargs: *mut pyo3::ffi::PyObject) -> *mut pyo3::ffi::PyObject
         {
             const _LOCATION: &'static str = concat!(stringify!(#cls),".",stringify!(#python_name),"()");
-            let _py = pyo3::Python::assume_gil_acquired();
+            let _pool = pyo3::GILPool::new();
+            let _py = _pool.python();
             pyo3::run_callback(_py, || {
-                let _pool = pyo3::GILPool::new(_py);
                 let _cls = pyo3::types::PyType::from_type_ptr(_py, _cls as *mut pyo3::ffi::PyTypeObject);
                 let _args = _py.from_borrowed_ptr::<pyo3::types::PyTuple>(_args);
                 let _kwargs: Option<&pyo3::types::PyDict> = _py.from_borrowed_ptr_or_opt(_kwargs);
@@ -257,9 +257,9 @@ pub fn impl_wrap_static(cls: &syn::Type, spec: &FnSpec<'_>) -> TokenStream {
             _kwargs: *mut pyo3::ffi::PyObject) -> *mut pyo3::ffi::PyObject
         {
             const _LOCATION: &'static str = concat!(stringify!(#cls),".",stringify!(#python_name),"()");
-            let _py = pyo3::Python::assume_gil_acquired();
+            let _pool = pyo3::GILPool::new();
+            let _py = _pool.python();
             pyo3::run_callback(_py, || {
-                let _pool = pyo3::GILPool::new(_py);
                 let _args = _py.from_borrowed_ptr::<pyo3::types::PyTuple>(_args);
                 let _kwargs: Option<&pyo3::types::PyDict> = _py.from_borrowed_ptr_or_opt(_kwargs);
 
@@ -315,9 +315,9 @@ pub(crate) fn impl_wrap_getter(
         {
             const _LOCATION: &'static str = concat!(stringify!(#cls),".",stringify!(#python_name),"()");
 
-            let _py = pyo3::Python::assume_gil_acquired();
+            let _pool = pyo3::GILPool::new();
+            let _py = _pool.python();
             pyo3::run_callback(_py, || {
-                let _pool = pyo3::GILPool::new(_py);
                 let _slf = _py.from_borrowed_ptr::<pyo3::PyCell<#cls>>(_slf);
                 #borrow_self
                 pyo3::callback::convert(_py, #getter_impl)
@@ -372,9 +372,9 @@ pub(crate) fn impl_wrap_setter(
             _value: *mut pyo3::ffi::PyObject, _: *mut ::std::os::raw::c_void) -> pyo3::libc::c_int
         {
             const _LOCATION: &'static str = concat!(stringify!(#cls),".",stringify!(#python_name),"()");
-            let _py = pyo3::Python::assume_gil_acquired();
+            let _pool = pyo3::GILPool::new();
+            let _py = _pool.python();
             pyo3::run_callback(_py, || {
-                let _pool = pyo3::GILPool::new(_py);
                 let _slf = _py.from_borrowed_ptr::<pyo3::PyCell<#cls>>(_slf);
                 #borrow_self
                 let _value = _py.from_borrowed_ptr::<pyo3::types::PyAny>(_value);

src/class/basic.rs

@@ -12,7 +12,7 @@ use crate::callback::HashCallbackOutput;
 use crate::class::methods::PyMethodDef;
 use crate::{
     callback, exceptions, ffi, run_callback, FromPyObject, GILPool, IntoPy, ObjectProtocol, PyAny,
-    PyCell, PyClass, PyErr, PyObject, PyResult, Python,
+    PyCell, PyClass, PyErr, PyObject, PyResult,
 };
 use std::os::raw::c_int;
 
@@ -218,10 +218,9 @@ where
         where
             T: for<'p> PyObjectGetAttrProtocol<'p>,
         {
-            let py = Python::assume_gil_acquired();
+            let pool = GILPool::new();
+            let py = pool.python();
             run_callback(py, || {
-                let _pool = GILPool::new(py);
-
                 // Behave like python's __getattr__ (as opposed to __getattribute__) and check
                 // for existing fields and methods first
                 let existing = ffi::PyObject_GenericGetAttr(slf, arg);
@@ -485,9 +484,9 @@ where
         where
             T: for<'p> PyObjectRichcmpProtocol<'p>,
         {
-            let py = Python::assume_gil_acquired();
+            let pool = GILPool::new();
+            let py = pool.python();
             run_callback(py, || {
-                let _pool = GILPool::new(py);
                 let slf = py.from_borrowed_ptr::<crate::PyCell<T>>(slf);
                 let arg = py.from_borrowed_ptr::<PyAny>(arg);
 

src/class/buffer.rs

@@ -6,7 +6,7 @@
 //! c-api
 use crate::err::PyResult;
 use crate::gil::GILPool;
-use crate::{callback, ffi, run_callback, PyCell, PyClass, PyRefMut, Python};
+use crate::{callback, ffi, run_callback, PyCell, PyClass, PyRefMut};
 use std::os::raw::c_int;
 
 /// Buffer protocol interface
@@ -91,9 +91,9 @@ where
         where
             T: for<'p> PyBufferGetBufferProtocol<'p>,
         {
-            let py = Python::assume_gil_acquired();
+            let pool = GILPool::new();
+            let py = pool.python();
             run_callback(py, || {
-                let _pool = GILPool::new(py);
                 let slf = py.from_borrowed_ptr::<PyCell<T>>(slf);
                 let result = T::bf_getbuffer(slf.try_borrow_mut()?, arg1, arg2).into();
                 callback::convert(py, result)
@@ -126,9 +126,9 @@ where
         where
             T: for<'p> PyBufferReleaseBufferProtocol<'p>,
         {
-            let py = Python::assume_gil_acquired();
+            let pool = GILPool::new();
+            let py = pool.python();
             run_callback(py, || {
-                let _pool = GILPool::new(py);
                 let slf = py.from_borrowed_ptr::<crate::PyCell<T>>(slf);
                 let result = T::bf_releasebuffer(slf.try_borrow_mut()?, arg1).into();
                 crate::callback::convert(py, result)

src/class/gc.rs

@@ -89,8 +89,8 @@ where
         where
             T: for<'p> PyGCTraverseProtocol<'p>,
         {
-            let py = Python::assume_gil_acquired();
+            let pool = crate::GILPool::new();
-            let _pool = crate::GILPool::new(py);
+            let py = pool.python();
             let slf = py.from_borrowed_ptr::<PyCell<T>>(slf);
 
             let visit = PyVisit {
@@ -98,8 +98,8 @@ where
                 arg,
                 _py: py,
             };
-
+            let borrow = slf.try_borrow();
-            if let Ok(borrow) = slf.try_borrow() {
+            if let Ok(borrow) = borrow {
                 match borrow.__traverse__(visit) {
                     Ok(()) => 0,
                     Err(PyTraverseError(code)) => code,
@@ -136,8 +136,8 @@ where
         where
             T: for<'p> PyGCClearProtocol<'p>,
         {
-            let py = Python::assume_gil_acquired();
+            let pool = crate::GILPool::new();
-            let _pool = crate::GILPool::new(py);
+            let py = pool.python();
             let slf = py.from_borrowed_ptr::<PyCell<T>>(slf);
 
             slf.borrow_mut().__clear__();

src/class/macros.rs

@@ -8,9 +8,9 @@ macro_rules! py_unary_func {
         where
             T: for<'p> $trait<'p>,
         {
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
                 let slf = py.from_borrowed_ptr::<$crate::PyCell<T>>(slf);
                 $crate::callback::convert(py, $call!(slf, $f)$(.map($conv))?)
             })
@@ -34,9 +34,9 @@ macro_rules! py_unary_refmut_func {
         where
             T: for<'p> $trait<'p>,
         {
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
                 let slf = py.from_borrowed_ptr::<$crate::PyCell<T>>(slf);
                 let res = $class::$f(slf.borrow_mut()).into();
                 $crate::callback::convert(py, res $(.map($conv))?)
@@ -69,9 +69,9 @@ macro_rules! py_binary_func {
             T: for<'p> $trait<'p>,
         {
             use $crate::ObjectProtocol;
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
                 let slf = py.from_borrowed_ptr::<$crate::PyCell<T>>(slf);
                 let arg = py.from_borrowed_ptr::<$crate::PyAny>(arg);
                 $crate::callback::convert(py, $call!(slf, $f, arg)$(.map($conv))?)
@@ -99,9 +99,9 @@ macro_rules! py_binary_num_func {
             T: for<'p> $trait<'p>,
         {
             use $crate::ObjectProtocol;
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
                 let lhs = py.from_borrowed_ptr::<$crate::PyAny>(lhs);
                 let rhs = py.from_borrowed_ptr::<$crate::PyAny>(rhs);
 
@@ -125,9 +125,9 @@ macro_rules! py_binary_reverse_num_func {
             T: for<'p> $trait<'p>,
         {
             use $crate::ObjectProtocol;
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
                 // Swap lhs <-> rhs
                 let slf = py.from_borrowed_ptr::<$crate::PyCell<T>>(rhs);
                 let arg = py.from_borrowed_ptr::<$crate::PyAny>(lhs);
@@ -155,9 +155,9 @@ macro_rules! py_binary_self_func {
         {
             use $crate::ObjectProtocol;
 
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
                 let slf_ = py.from_borrowed_ptr::<$crate::PyCell<T>>(slf);
                 let arg = py.from_borrowed_ptr::<$crate::PyAny>(arg);
                 call_mut!(slf_, $f, arg)?;
@@ -184,9 +184,9 @@ macro_rules! py_ssizearg_func {
         where
             T: for<'p> $trait<'p>,
         {
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
                 let slf = py.from_borrowed_ptr::<$crate::PyCell<T>>(slf);
                 $crate::callback::convert(py, $call!(slf, $f; arg.into()))
             })
@@ -209,9 +209,9 @@ macro_rules! py_ternary_func {
         {
             use $crate::ObjectProtocol;
 
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
                 let slf = py.from_borrowed_ptr::<$crate::PyCell<T>>(slf);
                 let arg1 = py
                     .from_borrowed_ptr::<$crate::types::PyAny>(arg1)
@@ -245,9 +245,9 @@ macro_rules! py_ternary_num_func {
         {
             use $crate::ObjectProtocol;
 
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
                 let arg1 = py
                     .from_borrowed_ptr::<$crate::types::PyAny>(arg1)
                     .extract()?;
@@ -280,9 +280,9 @@ macro_rules! py_ternary_reverse_num_func {
             T: for<'p> $trait<'p>,
         {
             use $crate::ObjectProtocol;
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
                 // Swap lhs <-> rhs
                 let slf = py.from_borrowed_ptr::<$crate::PyCell<T>>(arg2);
                 let slf = slf.try_borrow()?;
@@ -312,9 +312,9 @@ macro_rules! py_dummy_ternary_self_func {
         {
             use $crate::ObjectProtocol;
 
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
                 let slf_cell = py.from_borrowed_ptr::<$crate::PyCell<T>>(slf);
                 let arg1 = py.from_borrowed_ptr::<$crate::PyAny>(arg1);
                 call_mut!(slf_cell, $f, arg1)?;
@@ -338,9 +338,9 @@ macro_rules! py_func_set {
         {
             use $crate::ObjectProtocol;
 
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
                 let slf = py.from_borrowed_ptr::<$crate::PyCell<$generic>>(slf);
 
                 if value.is_null() {
@@ -374,10 +374,9 @@ macro_rules! py_func_del {
         {
             use $crate::ObjectProtocol;
 
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
-
                 if value.is_null() {
                     let slf = py.from_borrowed_ptr::<$crate::PyCell<U>>(slf);
                     let name = py
@@ -408,9 +407,9 @@ macro_rules! py_func_set_del {
         {
             use $crate::ObjectProtocol;
 
-            let py = $crate::Python::assume_gil_acquired();
+            let pool = $crate::GILPool::new();
+            let py = pool.python();
             $crate::run_callback(py, || {
-                let _pool = $crate::GILPool::new(py);
                 let slf = py.from_borrowed_ptr::<$crate::PyCell<$generic>>(slf);
                 let name = py.from_borrowed_ptr::<$crate::PyAny>(name);
 

src/class/sequence.rs

@@ -7,7 +7,7 @@ use crate::conversion::{FromPyObject, IntoPy};
 use crate::err::{PyErr, PyResult};
 use crate::gil::GILPool;
 use crate::objectprotocol::ObjectProtocol;
-use crate::{callback, exceptions, ffi, run_callback, PyAny, PyCell, PyClass, PyObject, Python};
+use crate::{callback, exceptions, ffi, run_callback, PyAny, PyCell, PyClass, PyObject};
 use std::os::raw::c_int;
 
 /// Sequence interface
@@ -256,9 +256,9 @@ mod sq_ass_item_impl {
             where
                 T: for<'p> PySequenceSetItemProtocol<'p>,
             {
-                let py = Python::assume_gil_acquired();
+                let pool = GILPool::new();
+                let py = pool.python();
                 run_callback(py, || {
-                    let _pool = GILPool::new(py);
                     let slf = py.from_borrowed_ptr::<PyCell<T>>(slf);
 
                     if value.is_null() {
@@ -305,9 +305,9 @@ mod sq_ass_item_impl {
             where
                 T: for<'p> PySequenceDelItemProtocol<'p>,
             {
-                let py = Python::assume_gil_acquired();
+                let pool = GILPool::new();
+                let py = pool.python();
                 run_callback(py, || {
-                    let _pool = GILPool::new(py);
                     let slf = py.from_borrowed_ptr::<PyCell<T>>(slf);
 
                     let result = if value.is_null() {
@@ -352,9 +352,9 @@ mod sq_ass_item_impl {
             where
                 T: for<'p> PySequenceSetItemProtocol<'p> + for<'p> PySequenceDelItemProtocol<'p>,
             {
-                let py = Python::assume_gil_acquired();
+                let pool = GILPool::new();
+                let py = pool.python();
                 run_callback(py, || {
-                    let _pool = GILPool::new(py);
                     let slf = py.from_borrowed_ptr::<PyCell<T>>(slf);
 
                     let result = if value.is_null() {

src/derive_utils.rs

@@ -6,7 +6,6 @@
 
 use crate::err::PyResult;
 use crate::exceptions::TypeError;
-use crate::init_once;
 use crate::instance::PyNativeType;
 use crate::pyclass::PyClass;
 use crate::pyclass_init::PyClassInitializer;
@@ -138,8 +137,6 @@ impl ModuleDef {
         doc: &str,
         initializer: impl Fn(Python, &PyModule) -> PyResult<()>,
     ) -> PyResult<*mut ffi::PyObject> {
-        init_once();
-
         #[cfg(py_sys_config = "WITH_THREAD")]
         // > Changed in version 3.7: This function is now called by Py_Initialize(), so you don’t have
         // > to call it yourself anymore.
@@ -147,11 +144,11 @@ impl ModuleDef {
         ffi::PyEval_InitThreads();
 
         let module = ffi::PyModule_Create(self.0.get());
-        let py = Python::assume_gil_acquired();
+        let pool = GILPool::new();
+        let py = pool.python();
         if module.is_null() {
             return Err(crate::PyErr::fetch(py));
         }
-        let _pool = GILPool::new(py);
         let module = py.from_owned_ptr_or_err::<PyModule>(module)?;
         module.add("__doc__", doc)?;
         initializer(py, module)?;

src/gil.rs

@@ -3,12 +3,10 @@
 //! Interaction with python's global interpreter lock
 
 use crate::{ffi, internal_tricks::Unsendable, PyAny, Python};
-use std::cell::Cell;
+use std::cell::{Cell, UnsafeCell};
-use std::ptr::NonNull;
+use std::{any, mem::ManuallyDrop, ptr::NonNull, sync};
-use std::{any, sync};
 
 static START: sync::Once = sync::Once::new();
-static START_PYO3: sync::Once = sync::Once::new();
 
 thread_local! {
     /// This is a internal counter in pyo3 monitoring whether this thread has the GIL.
@@ -90,16 +88,6 @@ pub fn prepare_freethreaded_python() {
             // Note that the PyThreadState returned by PyEval_SaveThread is also held in TLS by the Python runtime,
             // and will be restored by PyGILState_Ensure.
         }
-
-        init_once();
-    });
-}
-
-#[doc(hidden)]
-pub fn init_once() {
-    START_PYO3.call_once(|| unsafe {
-        // initialize release pool
-        POOL = Box::into_raw(Box::new(ReleasePool::new()));
     });
 }
 
@@ -116,28 +104,46 @@ pub fn init_once() {
 /// ```
 #[must_use]
 pub struct GILGuard {
-    owned: usize,
-    borrowed: usize,
     gstate: ffi::PyGILState_STATE,
-    // Stable solution for impl !Send
+    pool: ManuallyDrop<GILPool>,
-    no_send: Unsendable,
+}
+
+impl GILGuard {
+    /// Acquires the global interpreter lock, which allows access to the Python runtime.
+    ///
+    /// 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 {
+        prepare_freethreaded_python();
+
+        unsafe {
+            let gstate = ffi::PyGILState_Ensure(); // acquire GIL
+            GILGuard {
+                gstate,
+                pool: ManuallyDrop::new(GILPool::new()),
+            }
+        }
+    }
+
+    /// Retrieves the marker type that proves that the GIL was acquired.
+    #[inline]
+    pub fn python(&self) -> Python {
+        unsafe { Python::assume_gil_acquired() }
+    }
 }
 
 /// The Drop implementation for `GILGuard` will release the GIL.
 impl Drop for GILGuard {
     fn drop(&mut self) {
         unsafe {
-            let pool: &'static mut ReleasePool = &mut *POOL;
+            ManuallyDrop::drop(&mut self.pool);
-            pool.drain(self.python(), self.owned, self.borrowed);
             ffi::PyGILState_Release(self.gstate);
         }
-
-        decrement_gil_count();
     }
 }
 
-/// Release pool
+/// Implementation of release pool
-struct ReleasePool {
+struct ReleasePoolImpl {
     owned: ArrayList<NonNull<ffi::PyObject>>,
     borrowed: ArrayList<NonNull<ffi::PyObject>>,
     pointers: *mut Vec<NonNull<ffi::PyObject>>,
@@ -145,9 +151,9 @@ struct ReleasePool {
     p: parking_lot::Mutex<*mut Vec<NonNull<ffi::PyObject>>>,
 }
 
-impl ReleasePool {
+impl ReleasePoolImpl {
-    fn new() -> ReleasePool {
+    fn new() -> Self {
-        ReleasePool {
+        Self {
             owned: ArrayList::new(),
             borrowed: ArrayList::new(),
             pointers: Box::into_raw(Box::new(Vec::with_capacity(256))),
@@ -187,42 +193,69 @@ impl ReleasePool {
     }
 }
 
-static mut POOL: *mut ReleasePool = ::std::ptr::null_mut();
+/// Sync wrapper of ReleasePoolImpl
-
+struct ReleasePool {
-#[doc(hidden)]
+    value: UnsafeCell<Option<ReleasePoolImpl>>,
-pub struct GILPool<'p> {
-    py: Python<'p>,
-    owned: usize,
-    borrowed: usize,
-    no_send: Unsendable,
 }
 
-impl<'p> GILPool<'p> {
+impl ReleasePool {
-    #[inline]
+    const fn new() -> Self {
-    pub fn new(py: Python) -> GILPool {
+        Self {
-        increment_gil_count();
+            value: UnsafeCell::new(None),
-        let p: &'static mut ReleasePool = unsafe { &mut *POOL };
-        GILPool {
-            py,
-            owned: p.owned.len(),
-            borrowed: p.borrowed.len(),
-            no_send: Unsendable::default(),
         }
     }
+    /// # Safety
+    /// This function is not thread safe. Thus, the caller has to have GIL.
+    #[allow(clippy::mut_from_ref)]
+    unsafe fn get_or_init(&self) -> &mut ReleasePoolImpl {
+        (*self.value.get()).get_or_insert_with(ReleasePoolImpl::new)
+    }
 }
 
-impl<'p> Drop for GILPool<'p> {
+static POOL: ReleasePool = ReleasePool::new();
+
+unsafe impl Sync for ReleasePool {}
+
+#[doc(hidden)]
+pub struct GILPool {
+    owned: usize,
+    borrowed: usize,
+    // Stable solution for impl !Send
+    no_send: Unsendable,
+}
+
+impl GILPool {
+    /// # Safety
+    /// This function requires that GIL is already acquired.
+    #[inline]
+    pub unsafe fn new() -> GILPool {
+        increment_gil_count();
+        // Release objects that were dropped since last GIL acquisition
+        let pool = POOL.get_or_init();
+        pool.release_pointers();
+        GILPool {
+            owned: pool.owned.len(),
+            borrowed: pool.borrowed.len(),
+            no_send: Unsendable::default(),
+        }
+    }
+    pub unsafe fn python(&self) -> Python {
+        Python::assume_gil_acquired()
+    }
+}
+
+impl Drop for GILPool {
     fn drop(&mut self) {
         unsafe {
-            let pool: &'static mut ReleasePool = &mut *POOL;
+            let pool = POOL.get_or_init();
-            pool.drain(self.py, self.owned, self.borrowed);
+            pool.drain(self.python(), self.owned, self.borrowed);
         }
         decrement_gil_count();
     }
 }
 
 pub unsafe fn register_any<'p, T: 'static>(obj: T) -> &'p T {
-    let pool: &'static mut ReleasePool = &mut *POOL;
+    let pool = POOL.get_or_init();
 
     pool.obj.push(Box::new(obj));
     pool.obj
@@ -234,7 +267,7 @@ pub unsafe fn register_any<'p, T: 'static>(obj: T) -> &'p T {
 }
 
 pub unsafe fn register_pointer(obj: NonNull<ffi::PyObject>) {
-    let pool = &mut *POOL;
+    let pool = POOL.get_or_init();
     if gil_is_acquired() {
         ffi::Py_DECREF(obj.as_ptr())
     } else {
@@ -243,47 +276,15 @@ pub unsafe fn register_pointer(obj: NonNull<ffi::PyObject>) {
 }
 
 pub unsafe fn register_owned(_py: Python, obj: NonNull<ffi::PyObject>) -> &PyAny {
-    let pool = &mut *POOL;
+    let pool = POOL.get_or_init();
     &*(pool.owned.push_back(obj) as *const _ as *const PyAny)
 }
 
 pub unsafe fn register_borrowed(_py: Python, obj: NonNull<ffi::PyObject>) -> &PyAny {
-    let pool = &mut *POOL;
+    let pool = POOL.get_or_init();
     &*(pool.borrowed.push_back(obj) as *const _ as *const PyAny)
 }
 
-impl GILGuard {
-    /// Acquires the global interpreter lock, which allows access to the Python runtime.
-    ///
-    /// 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 {
-        prepare_freethreaded_python();
-
-        unsafe {
-            let gstate = ffi::PyGILState_Ensure(); // acquire GIL
-            increment_gil_count();
-
-            // Release objects that were dropped since last GIL acquisition
-            let pool: &'static mut ReleasePool = &mut *POOL;
-            pool.release_pointers();
-
-            GILGuard {
-                owned: pool.owned.len(),
-                borrowed: pool.borrowed.len(),
-                gstate,
-                no_send: Unsendable::default(),
-            }
-        }
-    }
-
-    /// Retrieves the marker type that proves that the GIL was acquired.
-    #[inline]
-    pub fn python(&self) -> Python {
-        unsafe { Python::assume_gil_acquired() }
-    }
-}
-
 /// Increment pyo3's internal GIL count - to be called whenever GILPool or GILGuard is created.
 #[inline(always)]
 fn increment_gil_count() {
@@ -361,7 +362,7 @@ mod array_list {
 
 #[cfg(test)]
 mod test {
-    use super::{GILPool, NonNull, ReleasePool, GIL_COUNT, POOL};
+    use super::{GILPool, NonNull, GIL_COUNT, POOL};
     use crate::object::PyObject;
     use crate::AsPyPointer;
     use crate::Python;
@@ -388,7 +389,7 @@ mod test {
         let _ref = obj.clone_ref(py);
 
         unsafe {
-            let p: &'static mut ReleasePool = &mut *POOL;
+            let p = POOL.get_or_init();
 
             {
                 let gil = Python::acquire_gil();
@@ -416,10 +417,10 @@ mod test {
         let obj_ptr = obj.as_ptr();
 
         unsafe {
-            let p: &'static mut ReleasePool = &mut *POOL;
+            let p = POOL.get_or_init();
 
             {
-                let _pool = GILPool::new(py);
+                let _pool = GILPool::new();
                 assert_eq!(p.owned.len(), 0);
 
                 let _ = gil::register_owned(py, obj.into_nonnull());
@@ -427,7 +428,7 @@ mod test {
                 assert_eq!(p.owned.len(), 1);
                 assert_eq!(ffi::Py_REFCNT(obj_ptr), 2);
                 {
-                    let _pool = GILPool::new(py);
+                    let _pool = GILPool::new();
                     let obj = get_object();
                     let _ = gil::register_owned(py, obj.into_nonnull());
                     assert_eq!(p.owned.len(), 2);
@@ -443,9 +444,8 @@ mod test {
 
     #[test]
     fn test_borrowed() {
-        gil::init_once();
         unsafe {
-            let p: &'static mut ReleasePool = &mut *POOL;
+            let p = POOL.get_or_init();
 
             let obj = get_object();
             let obj_ptr = obj.as_ptr();
@@ -469,9 +469,8 @@ mod test {
 
     #[test]
     fn test_borrowed_nested() {
-        gil::init_once();
         unsafe {
-            let p: &'static mut ReleasePool = &mut *POOL;
+            let p = POOL.get_or_init();
 
             let obj = get_object();
             let obj_ptr = obj.as_ptr();
@@ -486,7 +485,7 @@ mod test {
                 assert_eq!(ffi::Py_REFCNT(obj_ptr), 1);
 
                 {
-                    let _pool = GILPool::new(py);
+                    let _pool = GILPool::new();
                     assert_eq!(p.borrowed.len(), 1);
                     gil::register_borrowed(py, NonNull::new(obj_ptr).unwrap());
                     assert_eq!(p.borrowed.len(), 2);
@@ -513,7 +512,7 @@ mod test {
         let obj_ptr = obj.as_ptr();
 
         unsafe {
-            let p: &'static mut ReleasePool = &mut *POOL;
+            let p = POOL.get_or_init();
 
             {
                 assert_eq!(p.owned.len(), 0);
@@ -536,7 +535,7 @@ mod test {
         let obj_ptr = obj.as_ptr();
 
         unsafe {
-            let p: &'static mut ReleasePool = &mut *POOL;
+            let p = POOL.get_or_init();
 
             {
                 assert_eq!(p.owned.len(), 0);
@@ -565,13 +564,11 @@ mod test {
         let gil = Python::acquire_gil();
         assert_eq!(get_gil_count(), 1);
 
-        let py = gil.python();
-
         assert_eq!(get_gil_count(), 1);
-        let pool = GILPool::new(py);
+        let pool = unsafe { GILPool::new() };
         assert_eq!(get_gil_count(), 2);
 
-        let pool2 = GILPool::new(py);
+        let pool2 = unsafe { GILPool::new() };
         assert_eq!(get_gil_count(), 3);
 
         drop(pool);

src/lib.rs

@@ -140,7 +140,7 @@ pub use crate::conversion::{
     ToBorrowedObject, ToPyObject,
 };
 pub use crate::err::{PyDowncastError, PyErr, PyErrArguments, PyErrValue, PyResult};
-pub use crate::gil::{init_once, GILGuard, GILPool};
+pub use crate::gil::{GILGuard, GILPool};
 pub use crate::instance::{AsPyRef, ManagedPyRef, Py, PyNativeType};
 pub use crate::object::PyObject;
 pub use crate::objectprotocol::ObjectProtocol;

src/pyclass.rs

@@ -2,7 +2,7 @@
 use crate::class::methods::{PyMethodDefType, PyMethodsProtocol};
 use crate::pyclass_slots::{PyClassDict, PyClassWeakRef};
 use crate::type_object::{type_flags, PyLayout};
-use crate::{class, ffi, gil, PyCell, PyErr, PyNativeType, PyResult, PyTypeInfo, Python};
+use crate::{class, ffi, PyCell, PyErr, PyNativeType, PyResult, PyTypeInfo, Python};
 use std::ffi::CString;
 use std::os::raw::c_void;
 use std::ptr;
@@ -111,8 +111,8 @@ where
     where
         T: PyClassAlloc,
     {
-        let py = Python::assume_gil_acquired();
+        let pool = crate::GILPool::new();
-        let _pool = gil::GILPool::new(py);
+        let py = pool.python();
         <T as PyClassAlloc>::dealloc(py, (obj as *mut T::Layout) as _)
     }
     type_object.tp_dealloc = Some(tp_dealloc_callback::<T>);

src/python.rs

@@ -57,6 +57,10 @@ impl<'p> Python<'p> {
     /// Because the output lifetime `'p` is not connected to any input parameter,
     /// care must be taken that the compiler infers an appropriate lifetime for `'p`
     /// when calling this function.
+    ///
+    /// # Safety
+    /// The lifetime `'p` must be shorter than the period you *assume* that you have GIL.
+    /// I.e., `Python<'static>` is always *really* unsafe.
     #[inline]
     pub unsafe fn assume_gil_acquired() -> Python<'p> {
         Python(PhantomData)

src/types/dict.rs

@@ -472,7 +472,7 @@ mod test {
 
         let cnt;
         {
-            let _pool = crate::GILPool::new(py);
+            let _pool = unsafe { crate::GILPool::new() };
             let none = py.None();
             cnt = none.get_refcnt();
             let _dict = [(10, none)].into_py_dict(py);

src/types/iterator.rs

@@ -137,7 +137,7 @@ mod tests {
         let none;
         let count;
         {
-            let _pool = GILPool::new(py);
+            let _pool = unsafe { GILPool::new() };
             let l = PyList::empty(py);
             none = py.None();
             l.append(10).unwrap();
@@ -147,7 +147,7 @@ mod tests {
         }
 
         {
-            let _pool = GILPool::new(py);
+            let _pool = unsafe { GILPool::new() };
             let inst = obj.as_ref(py);
             let mut it = inst.iter().unwrap();
 

src/types/list.rs

@@ -296,7 +296,7 @@ mod test {
 
         let cnt;
         {
-            let _pool = crate::GILPool::new(py);
+            let _pool = unsafe { crate::GILPool::new() };
             let v = vec![2];
             let ob = v.to_object(py);
             let list = <PyList as PyTryFrom>::try_from(ob.as_ref(py)).unwrap();
@@ -331,7 +331,7 @@ mod test {
 
         let cnt;
         {
-            let _pool = crate::GILPool::new(py);
+            let _pool = unsafe { crate::GILPool::new() };
             let list = PyList::empty(py);
             let none = py.None();
             cnt = none.get_refcnt();
@@ -360,7 +360,7 @@ mod test {
 
         let cnt;
         {
-            let _pool = crate::GILPool::new(py);
+            let _pool = unsafe { crate::GILPool::new() };
             let list = PyList::empty(py);
             let none = py.None();
             cnt = none.get_refcnt();

tests/test_compile_error.rs

@@ -7,4 +7,10 @@ fn test_compile_errors() {
     t.compile_fail("tests/ui/invalid_pymethod_names.rs");
     t.compile_fail("tests/ui/missing_clone.rs");
     t.compile_fail("tests/ui/reject_generics.rs");
+    // Since the current minimum nightly(2020-01-20) has a different error message,
+    // we skip this test.
+    // TODO(kngwyu): Remove this `if` when we update minimum nightly.
+    if option_env!("TRAVIS_JOB_NAME") != Some("Minimum nightly") {
+        t.compile_fail("tests/ui/static_ref.rs");
+    }
 }

tests/ui/static_ref.rs

@@ -0,0 +1,17 @@
+use pyo3::prelude::*;
+use pyo3::types::PyList;
+
+#[pyclass]
+struct MyClass {
+    list: &'static PyList,
+}
+
+#[pymethods]
+impl MyClass {
+    #[new]
+    fn new(list: &'static PyList) -> Self {
+        Self { list }
+    }
+}
+
+fn main() {}

tests/ui/static_ref.stderr

@@ -0,0 +1,11 @@
+error[E0597]: `_pool` does not live long enough
+ --> $DIR/static_ref.rs:9:1
+  |
+9 | #[pymethods]
+  | ^^^^^^^^^^^-
+  | |          |
+  | |          `_pool` dropped here while still borrowed
+  | borrowed value does not live long enough
+  | cast requires that `_pool` is borrowed for `'static`
+  |
+  = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)