【发布时间】：2016-10-25 14:58:58
【问题描述】：
我正在为 C 库编写 Python 绑定，该库使用共享内存缓冲区来存储其内部状态。这些缓冲区的分配和释放是由库本身在 Python 之外完成的，但我可以通过从 Python 中调用包装的构造函数/析构函数来间接控制何时发生这种情况。我想向 Python 公开一些缓冲区，以便我可以从中读取，并在某些情况下将值推送给它们。性能和内存使用是重要的问题，因此我希望尽可能避免复制数据。
我目前的方法是创建一个 numpy 数组，它可以直接查看 ctypes 指针：
import numpy as np
import ctypes as C
libc = C.CDLL('libc.so.6')
class MyWrapper(object):
def __init__(self, n=10):
# buffer allocated by external library
addr = libc.malloc(C.sizeof(C.c_int) * n)
self._cbuf = (C.c_int * n).from_address(addr)
def __del__(self):
# buffer freed by external library
libc.free(C.addressof(self._cbuf))
self._cbuf = None
@property
def buffer(self):
return np.ctypeslib.as_array(self._cbuf)
除了避免复制之外，这还意味着我可以使用 numpy 的索引和赋值语法，并将其直接传递给其他 numpy 函数：
wrap = MyWrapper()
buf = wrap.buffer # buf is now a writeable view of a C-allocated buffer
buf[:] = np.arange(10) # this is pretty cool!
buf[::2] += 10
print(wrap.buffer)
# [10 1 12 3 14 5 16 7 18 9]
然而，它本身也很危险：
del wrap # free the pointer
print(buf) # this is bad!
# [1852404336 1969367156 538978662 538976288 538976288 538976288
# 1752440867 1763734377 1633820787 8548]
# buf[0] = 99 # uncomment this line if you <3 segfaults
为了更安全，我需要能够在尝试读取/写入数组内容之前检查底层 C 指针是否已被释放。我对如何做到这一点有一些想法：
- 一种方法是生成
np.ndarray的子类，该子类包含对MyWrapper的_cbuf属性的引用，在对其底层内存进行任何读/写之前检查它是否为None，并引发如果是这种情况，则例外。 - 我可以轻松地在同一个缓冲区上生成多个视图，例如通过
.view转换或切片，因此每个都需要继承对_cbuf的引用和执行检查的方法。我怀疑这可以通过覆盖__array_finalize__来实现，但我不确定具体如何。 - 还需要在读取和/或写入数组内容的任何操作之前调用“指针检查”方法。我对 numpy 的内部结构知之甚少，无法提供详尽的覆盖方法列表。
如何实现np.ndarray 的子类来执行此检查？任何人都可以提出更好的方法吗？
更新：这个类做了我想要的大部分：
class SafeBufferView(np.ndarray):
def __new__(cls, get_buffer, shape=None, dtype=None):
obj = np.ctypeslib.as_array(get_buffer(), shape).view(cls)
if dtype is not None:
obj.dtype = dtype
obj._get_buffer = get_buffer
return obj
def __array_finalize__(self, obj):
if obj is None: return
self._get_buffer = getattr(obj, "_get_buffer", None)
def __array_prepare__(self, out_arr, context=None):
if not self._get_buffer(): raise Exception("Dangling pointer!")
return out_arr
# this seems very heavy-handed - surely there must be a better way?
def __getattribute__(self, name):
if name not in ["__new__", "__array_finalize__", "__array_prepare__",
"__getattribute__", "_get_buffer"]:
if not self._get_buffer(): raise Exception("Dangling pointer!")
return super(np.ndarray, self).__getattribute__(name)
例如：
wrap = MyWrapper()
sb = SafeBufferView(lambda: wrap._cbuf)
sb[:] = np.arange(10)
print(repr(sb))
# SafeBufferView([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)
print(repr(sb[::2]))
# SafeBufferView([0, 2, 4, 6, 8], dtype=int32)
sbv = sb.view(np.double)
print(repr(sbv))
# SafeBufferView([ 2.12199579e-314, 6.36598737e-314, 1.06099790e-313,
# 1.48539705e-313, 1.90979621e-313])
# we have to call the destructor method of `wrap` explicitly - `del wrap` won't
# do anything because `sb` and `sbv` both hold references to `wrap`
wrap.__del__()
print(sb) # Exception: Dangling pointer!
print(sb + 1) # Exception: Dangling pointer!
print(sbv) # Exception: Dangling pointer!
print(np.sum(sb)) # Exception: Dangling pointer!
print(sb.dot(sb)) # Exception: Dangling pointer!
print(np.dot(sb, sb)) # oops...
# -70104698
print(np.extract(np.ones(10), sb))
# array([251019024, 32522, 498870232, 32522, 4, 5,
# 6, 7, 48, 0], dtype=int32)
# np.copyto(sb, np.ones(10, np.int32)) # don't try this at home, kids!
我确定我还漏掉了其他边缘情况。
更新 2： 根据 @ivan_pozdeev 的建议，我玩过 weakref.proxy。这是一个好主意，但不幸的是我看不出它如何与 numpy 数组一起工作。我可以尝试为 .buffer 返回的 numpy 数组创建一个弱引用：
wrap = MyWrapper()
wr = weakref.proxy(wrap.buffer)
print(wr)
# ReferenceError: weakly-referenced object no longer exists
# <weakproxy at 0x7f6fe715efc8 to NoneType at 0x91a870>
我认为这里的问题是wrap.buffer 返回的np.ndarray 实例立即超出范围。一种解决方法是让类在初始化时实例化数组，持有对它的强引用，并让 .buffer() getter 将 weakref.proxy 返回到数组：
class MyWrapper2(object):
def __init__(self, n=10):
# buffer allocated by external library
addr = libc.malloc(C.sizeof(C.c_int) * n)
self._cbuf = (C.c_int * n).from_address(addr)
self._buffer = np.ctypeslib.as_array(self._cbuf)
def __del__(self):
# buffer freed by external library
libc.free(C.addressof(self._cbuf))
self._cbuf = None
self._buffer = None
@property
def buffer(self):
return weakref.proxy(self._buffer)
但是，如果我在同一个数组上创建第二个视图，而缓冲区仍处于分配状态，则会中断：
wrap2 = MyWrapper2()
buf = wrap2.buffer
buf[:] = np.arange(10)
buf2 = buf[:] # create a second view onto the contents of buf
print(repr(buf))
# <weakproxy at 0x7fec3e709b50 to numpy.ndarray at 0x210ac80>
print(repr(buf2))
# array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)
wrap2.__del__()
print(buf2[:]) # this is bad
# [1291716568 32748 1291716568 32748 0 0 0
# 0 48 0]
print(buf[:]) # WTF?!
# [34525664 0 0 0 0 0 0 0
# 0 0]
这严重坏了 - 在调用 wrap2.__del__() 之后，我不仅可以读取和写入 buf2，这是 wrap2._cbuf 上的一个 numpy 数组视图，而且我什至可以读取和写入buf，鉴于wrap2.__del__() 将wrap2._buffer 设置为None，这应该是不可能的。
【问题讨论】：
-
您是否考虑过使用 Cython 编写包装器？它有一个更简洁（并且可能更安全）的界面，用于通过“类型化的内存视图”获取内存缓冲区的视图
-
@JoshAdel 在这种情况下，键入的内存视图真的有帮助吗？最终的问题是，这些缓冲区的分配和释放是由我无法直接控制的外部库在 Python 之外完成的。我能做的最好的事情就是根据我迄今为止调用的任何库函数来跟踪它们是否应该仍然被分配。我想我可以用 Cython 而不是 Python 来记账，但我还没有看到切换到 Cython 的显着优势（还有其他一些原因导致在这个阶段这会很痛苦）。
-
如果您保留对某些将为您调用删除器的对象的强引用（例如
cffi（您应该始终使用而不是ctypes）内置支持使用gc方法的删除器），那么您不必担心无效的弱引用。 -
@o11c
gc在这里无关紧要，因为缓冲区是由我包装的外部库在 Python 之外分配和释放的。 -
@ali_m：分配
_buffer = None不会释放_buffer，因为另一个数组仍然有对它的引用。如果您在指针准备好被释放之前手动调用释放指针的函数，那么东西就会中断。
标签： python c numpy ctypes dangling-pointer