Merge pull request #245 from PyO3/backport-fixes-for-0.15.1

Backport fixes for 0.15.1

Author: kngwyu

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+- v0.15.1
+  - Make arrays produced via `IntoPyArray`, i.e. those owning Rust data, writeable ([#235](https://github.com/PyO3/rust-numpy/pull/235))
+  - Fix thread-safety in internal API globals ([#222](https://github.com/PyO3/rust-numpy/pull/222))
+
 - v0.15.0
   - [Remove resolver from Cargo.toml](https://github.com/PyO3/rust-numpy/pull/202)
   - [Bump PyO3 to 0.15](https://github.com/PyO3/rust-numpy/pull/212)

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "numpy"
-version = "0.15.0"
+version = "0.15.1"
 authors = [
     "Toshiki Teramura <[email protected]>",
     "Yuji Kanagawa <[email protected]>",

src/array.rs

@@ -406,7 +406,7 @@ impl<T: Element, D: Dimension> PyArray<T, D> {
             ptr::null_mut(),   // data
             0,                 // itemsize
             flag,              // flag
-            ptr::null_mut(),   //obj
+            ptr::null_mut(),   // obj
         );
         Self::from_owned_ptr(py, ptr)
     }
@@ -432,11 +432,11 @@ impl<T: Element, D: Dimension> PyArray<T, D> {
             dims.ndim_cint(),
             dims.as_dims_ptr(),
             T::npy_type() as i32,
-            strides as *mut _,          // strides
-            data_ptr as _,              // data
-            mem::size_of::<T>() as i32, // itemsize
-            0,                          // flag
-            ptr::null_mut(),            //obj
+            strides as *mut _,           // strides
+            data_ptr as _,               // data
+            mem::size_of::<T>() as i32,  // itemsize
+            npyffi::NPY_ARRAY_WRITEABLE, // flag
+            ptr::null_mut(),             // obj
         );
         PY_ARRAY_API.PyArray_SetBaseObject(ptr as *mut npyffi::PyArrayObject, cell as _);
         Self::from_owned_ptr(py, ptr)

src/npyffi/array.rs

@@ -2,7 +2,8 @@
 use libc::FILE;
 use pyo3::ffi::{self, PyObject, PyTypeObject};
 use std::os::raw::*;
-use std::{cell::Cell, ptr};
+use std::ptr::null_mut;
+use std::sync::atomic::{AtomicPtr, Ordering};
 
 use crate::npyffi::*;
 
@@ -12,7 +13,7 @@ const CAPSULE_NAME: &str = "_ARRAY_API";
 /// A global variable which stores a ['capsule'](https://docs.python.org/3/c-api/capsule.html)
 /// pointer to [Numpy Array API](https://numpy.org/doc/stable/reference/c-api/array.html).
 ///
-/// You can acceess raw c APIs via this variable and its Deref implementation.
+/// You can acceess raw C APIs via this variable.
 ///
 /// See [PyArrayAPI](struct.PyArrayAPI.html) for what methods you can use via this variable.
 ///
@@ -31,28 +32,35 @@ pub static PY_ARRAY_API: PyArrayAPI = PyArrayAPI::new();
 
 /// See [PY_ARRAY_API] for more.
 pub struct PyArrayAPI {
-    api: Cell<*const *const c_void>,
+    api: AtomicPtr<*const c_void>,
 }
 
 impl PyArrayAPI {
     const fn new() -> Self {
         Self {
-            api: Cell::new(ptr::null_mut()),
+            api: AtomicPtr::new(null_mut()),
         }
     }
-    fn get(&self, offset: isize) -> *const *const c_void {
-        if self.api.get().is_null() {
-            Python::with_gil(|py| {
-                let api = get_numpy_api(py, MOD_NAME, CAPSULE_NAME);
-                self.api.set(api);
-            });
+    #[cold]
+    fn init(&self) -> *const *const c_void {
+        Python::with_gil(|py| {
+            let mut api = self.api.load(Ordering::Relaxed) as *const *const c_void;
+            if api.is_null() {
+                api = get_numpy_api(py, MOD_NAME, CAPSULE_NAME);
+                self.api.store(api as *mut _, Ordering::Release);
+            }
+            api
+        })
+    }
+    unsafe fn get(&self, offset: isize) -> *const *const c_void {
+        let mut api = self.api.load(Ordering::Acquire) as *const *const c_void;
+        if api.is_null() {
+            api = self.init();
         }
-        unsafe { self.api.get().offset(offset) }
+        api.offset(offset)
     }
 }
 
-unsafe impl Sync for PyArrayAPI {}
-
 impl PyArrayAPI {
     impl_api![0; PyArray_GetNDArrayCVersion() -> c_uint];
     impl_api![40; PyArray_SetNumericOps(dict: *mut PyObject) -> c_int];

src/npyffi/ufunc.rs

@@ -1,7 +1,8 @@
 //! Low-Level binding for [UFunc API](https://numpy.org/doc/stable/reference/c-api/ufunc.html)
 
 use std::os::raw::*;
-use std::{cell::Cell, ptr};
+use std::ptr::null_mut;
+use std::sync::atomic::{AtomicPtr, Ordering};
 
 use pyo3::ffi::PyObject;
 use pyo3::Python;
@@ -18,28 +19,35 @@ const CAPSULE_NAME: &str = "_UFUNC_API";
 pub static PY_UFUNC_API: PyUFuncAPI = PyUFuncAPI::new();
 
 pub struct PyUFuncAPI {
-    api: Cell<*const *const c_void>,
+    api: AtomicPtr<*const c_void>,
 }
 
 impl PyUFuncAPI {
     const fn new() -> Self {
         Self {
-            api: Cell::new(ptr::null_mut()),
+            api: AtomicPtr::new(null_mut()),
         }
     }
-    fn get(&self, offset: isize) -> *const *const c_void {
-        if self.api.get().is_null() {
-            Python::with_gil(|py| {
-                let api = get_numpy_api(py, MOD_NAME, CAPSULE_NAME);
-                self.api.set(api);
-            });
+    #[cold]
+    fn init(&self) -> *const *const c_void {
+        Python::with_gil(|py| {
+            let mut api = self.api.load(Ordering::Relaxed) as *const *const c_void;
+            if api.is_null() {
+                api = get_numpy_api(py, MOD_NAME, CAPSULE_NAME);
+                self.api.store(api as *mut _, Ordering::Release);
+            }
+            api
+        })
+    }
+    unsafe fn get(&self, offset: isize) -> *const *const c_void {
+        let mut api = self.api.load(Ordering::Acquire) as *const *const c_void;
+        if api.is_null() {
+            api = self.init();
         }
-        unsafe { self.api.get().offset(offset) }
+        api.offset(offset)
     }
 }
 
-unsafe impl Sync for PyUFuncAPI {}
-
 impl PyUFuncAPI {
     impl_api![1; PyUFunc_FromFuncAndData(func: *mut PyUFuncGenericFunction, data: *mut *mut c_void, types: *mut c_char, ntypes: c_int, nin: c_int, nout: c_int, identity: c_int, name: *const c_char, doc: *const c_char, unused: c_int) -> *mut PyObject];
     impl_api![2; PyUFunc_RegisterLoopForType(ufunc: *mut PyUFuncObject, usertype: c_int, function: PyUFuncGenericFunction, arg_types: *mut c_int, data: *mut c_void) -> c_int];

tests/to_py.rs

@@ -115,6 +115,16 @@ fn into_pyarray_cant_resize() {
     })
 }
 
+#[test]
+fn into_pyarray_can_write() {
+    let a = vec![1, 2, 3];
+    pyo3::Python::with_gil(|py| {
+        let arr = a.into_pyarray(py);
+        pyo3::py_run!(py, arr, "assert arr.flags['WRITEABLE']");
+        pyo3::py_run!(py, arr, "arr[1] = 4");
+    })
+}
+
 /// Check that into_pyarray works for ndarray of which the pointer of the first element is
 /// not at the start. See https://github.com/PyO3/rust-numpy/issues/182 for more
 #[test]