Я пишу привязки 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 который содержит ссылку на_cbuf атрибутMyWrapperпроверяет, есть ли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: Я поиграл сweakref.proxyв соответствии с предложением@ivan_pozdeev, Это хорошая идея, но, к сожалению, я не вижу, как она будет работать с массивами numpy. Я мог бы попытаться создать слабую ссылку на массив 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() геттер вернуть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, но я могу даже читать и писатьbufчто не должно быть возможно, учитывая, чтоwrap2.__del__() наборыwrap2._buffer вNone.