强制 NumPy ndarray 在 Cython 中获取其内存的所有权

Question

在this answer to "Can I force a numpy ndarray to take ownership of its memory?" 之后，我尝试通过 Cython 的 NumPy 包装器使用 Python C API 函数 PyArray_ENABLEFLAGS，发现它没有暴露。

以下尝试手动公开它（这只是重现失败的最小示例）

from libc.stdlib cimport malloc
import numpy as np
cimport numpy as np

np.import_array()

ctypedef np.int32_t DTYPE_t

cdef extern from "numpy/ndarraytypes.h":
    void PyArray_ENABLEFLAGS(np.PyArrayObject *arr, int flags)

def test():
    cdef int N = 1000

    cdef DTYPE_t *data = <DTYPE_t *>malloc(N * sizeof(DTYPE_t))
    cdef np.ndarray[DTYPE_t, ndim=1] arr = np.PyArray_SimpleNewFromData(1, &N, np.NPY_INT32, data)
    PyArray_ENABLEFLAGS(arr, np.NPY_ARRAY_OWNDATA)

因编译错误而失败：

Error compiling Cython file:
------------------------------------------------------------
...
def test():
    cdef int N = 1000

    cdef DTYPE_t *data = <DTYPE_t *>malloc(N * sizeof(DTYPE_t))
    cdef np.ndarray[DTYPE_t, ndim=1] arr = np.PyArray_SimpleNewFromData(1, &N, np.NPY_INT32, data)
    PyArray_ENABLEFLAGS(arr, np.NPY_ARRAY_OWNDATA)
                          ^
------------------------------------------------------------

/tmp/test.pyx:19:27: Cannot convert Python object to 'PyArrayObject *'

我的问题：这是在这种情况下采取的正确方法吗？如果是这样，我做错了什么？如果没有，我如何强制 NumPy 获得 Cython 的所有权，而不需要深入到 C 扩展模块？

Answer 1

你只是在接口定义中有一些小错误。以下对我有用：

from libc.stdlib cimport malloc
import numpy as np
cimport numpy as np

np.import_array()

ctypedef np.int32_t DTYPE_t

cdef extern from "numpy/arrayobject.h":
    void PyArray_ENABLEFLAGS(np.ndarray arr, int flags)

cdef data_to_numpy_array_with_spec(void * ptr, np.npy_intp N, int t):
    cdef np.ndarray[DTYPE_t, ndim=1] arr = np.PyArray_SimpleNewFromData(1, &N, t, ptr)
    PyArray_ENABLEFLAGS(arr, np.NPY_OWNDATA)
    return arr

def test():
    N = 1000

    cdef DTYPE_t *data = <DTYPE_t *>malloc(N * sizeof(DTYPE_t))
    arr = data_to_numpy_array_with_spec(data, N, np.NPY_INT32)
    return arr

这是我的setup.py 文件：

from distutils.core import setup, Extension
from Cython.Distutils import build_ext
ext_modules = [Extension("_owndata", ["owndata.pyx"])]
setup(cmdclass={'build_ext': build_ext}, ext_modules=ext_modules)

使用python setup.py build_ext --inplace 构建。然后验证数据是否真正拥有：

import _owndata
arr = _owndata.test()
print arr.flags

除其他外，您应该看到OWNDATA : True。

是的，这绝对是解决这个问题的正确方法，因为numpy.pxd 将所有其他功能导出到 Cython 的做法完全相同。

Answer 2

@Stefan's solution 适用于大多数情况，但有些脆弱。 Numpy 使用PyDataMem_NEW/PyDataMem_FREE 进行内存管理，这是一个实现细节，这些调用被映射到通常的malloc/free + 一些内存跟踪（我不知道 Stefan 的解决方案对内存跟踪有什么影响，至少它似乎没有崩溃）。

还有更多深奥的情况，其中来自 numpy-library 的 free 不使用与 cython 代码中的 malloc 相同的内存分配器（例如链接到不同的运行时，例如在这个 @ 987654324@ 或这个SO-post)。

传递/管理数据所有权的正确工具是PyArray_SetBaseObject。

首先我们需要一个python-object，它负责释放内存。我在这里使用自制的 cdef 类（主要是因为日志记录/演示），但显然还有其他可能性：

%%cython
from libc.stdlib cimport free

cdef class MemoryNanny:
    cdef void* ptr # set to NULL by "constructor"
    def __dealloc__(self):
        print("freeing ptr=", <unsigned long long>(self.ptr)) #just for debugging
        free(self.ptr)
        
    @staticmethod
    cdef create(void* ptr):
        cdef MemoryNanny result = MemoryNanny()
        result.ptr = ptr
        print("nanny for ptr=", <unsigned long long>(result.ptr)) #just for debugging
        return result

 ...

现在，我们使用MemoryNanny-object 作为内存的标记，一旦 parent-numpy-array 被销毁，它就会被释放。代码有点尴尬，因为PyArray_SetBaseObject 窃取了引用，Cython 不会自动处理：

%%cython
...
from cpython.object cimport PyObject
from cpython.ref cimport Py_INCREF

cimport numpy as np

#needed to initialize PyArray_API in order to be able to use it
np.import_array()


cdef extern from "numpy/arrayobject.h":
    # a little bit awkward: the reference to obj will be stolen
    # using PyObject*  to signal that Cython cannot handle it automatically
    int PyArray_SetBaseObject(np.ndarray arr, PyObject *obj) except -1 # -1 means there was an error
          
cdef array_from_ptr(void * ptr, np.npy_intp N, int np_type):
    cdef np.ndarray arr = np.PyArray_SimpleNewFromData(1, &N, np_type, ptr)
    nanny = MemoryNanny.create(ptr)
    Py_INCREF(nanny) # a reference will get stolen, so prepare nanny
    PyArray_SetBaseObject(arr, <PyObject*>nanny) 
    return arr
...

下面是一个例子，如何调用这个功能：

%%cython
...
from libc.stdlib cimport malloc
def create():
    cdef double *ptr=<double*>malloc(sizeof(double)*8);
    ptr[0]=42.0
    return array_from_ptr(ptr, 8, np.NPY_FLOAT64)

可以这样使用：

>>> m =  create()
nanny for ptr= 94339864945184
>>> m.flags
...
OWNDATA : False
...
>>> m[0]
42.0
>>> del m
freeing ptr= 94339864945184

结果/输出符合预期。

注意：结果数组并不真正拥有数据（即标志返回OWNDATA : False），因为内存归内存保姆所有，但结果是相同的：一旦数组被删除，内存就会被释放（因为没有人再持有对保姆的引用）。

---

MemoryNanny 不必保护原始 C 指针。它可以是其他任何东西，例如也可以是std::vector：

%%cython -+
from libcpp.vector cimport vector
cdef class VectorNanny:
    #automatically default initialized/destructed by Cython:
    cdef vector[double] vec 
    @staticmethod
    cdef create(vector[double]& vec):
        cdef VectorNanny result = VectorNanny()
        result.vec.swap(vec) # swap and not copy
        return result
   
# for testing:
def create_vector(int N):
    cdef vector[double] vec;
    vec.resize(N, 2.0)
    return VectorNanny.create(vec)

以下测试表明，保姆工作：

nanny=create_vector(10**8) # top shows additional 800MB memory are used
del nanny                  # top shows, this additional memory is no longer used.

Answer 3

最新的 Cython 版本允许您使用最少的语法，尽管开销比建议的低级解决方案略高。

numpy_array = np.asarray(<np.int32_t[:10, :10]> my_pointer)

https://cython.readthedocs.io/en/latest/src/userguide/memoryviews.html#coercion-to-numpy

仅此一项并不能传递所有权。

值得注意的是，此调用通过array_cwrapper 生成一个 Cython 数组。

这会生成一个cython.array，而不分配内存。 cython.array 默认使用 stdlib.h malloc 和 free，因此您也应该使用默认的 malloc，而不是任何特殊的 CPython/Numpy 分配器。

free 仅在为此cython.array 设置所有权时才调用，默认情况下仅在分配数据时才调用。对于我们的案例，我们可以通过以下方式手动设置：

my_cyarr.free_data = True

---

所以要返回一个一维数组，就这么简单：

from cython.view cimport array as cvarray

# ...
    cdef cvarray cvarr = <np.int32_t[:N]> data
    cvarr.free_data = True
    return np.asarray(cvarr)