Я пишу привязки Python для библиотеки C, которая использует буферы разделяемой памяти для хранения своего внутреннего состояния. Выделение и освобождение этих буферов осуществляется за пределами 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, который содержит ссылку на атрибут_cbufMyWrapper, проверяет, является ли этоNone, прежде чем делать чтение/запись в свою базовую память и повышает исключение, если это так. - Я мог бы легко создать несколько представлений в одном и том же буфере, например. путем
.viewлитья или нарезки, поэтому каждому из них нужно будет наследовать ссылку на_cbufи метод, который выполняет проверку. Я подозреваю, что это может быть достигнуто путем переопределения__array_finalize__, но я точно не знаю, как именно. - Метод "проверки указателя" также должен быть вызван перед любой операцией, которая будет читать и/или записывать содержимое массива. Я не знаю достаточно о numpy internals, чтобы иметь исчерпывающий список методов для переопределения.
Как я могу реализовать подкласс 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: У меня была игра с weakref.proxy, как было предложено @ivan_pozdeev. Это хорошая идея, но, к сожалению, я не вижу, как она будет работать с массивами numpy. Я мог бы попытаться создать weakref для массива numpy, возвращаемого .buffer:
wrap = MyWrapper()
wr = weakref.proxy(wrap.buffer)
print(wr)
# ReferenceError: weakly-referenced object no longer exists
# <weakproxy at 0x7f6fe715efc8 to NoneType at 0x91a870>
Я думаю, проблема здесь в том, что экземпляр np.ndarray, возвращенный wrap.buffer, сразу выходит из области видимости. Обходной путь будет заключаться в том, чтобы класс создавал экземпляр массива при инициализации, держал на нем сильную ссылку и возвращал .buffer() getter a 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, который представлял собой вид массива numpy на wrap2._cbuf, но я даже могу читать и писать на buf, что не должно возможно, что wrap2.__del__() устанавливает wrap2._buffer в None.
