python - ¿Una forma más segura de exponer un búfer de memoria asignado por C usando numpy/ctypes?

dangling-pointer

Question

Estoy escribiendo enlaces de Python para una biblioteca de C que utiliza buffers de memoria compartida para almacenar su estado interno. La asignación y liberación de estos buffers se realiza fuera de Python por la propia biblioteca, pero puedo controlar indirectamente cuando esto sucede llamando a funciones de constructor / destructor envueltas desde Python. Me gustaría exponer algunos de los buffers a Python para poder leerlos y, en algunos casos, enviarles valores. El rendimiento y el uso de la memoria son preocupaciones importantes, por lo que me gustaría evitar copiar datos siempre que sea posible.

Mi enfoque actual es crear una matriz numpy que proporcione una vista directa sobre un puntero de 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)

Además de evitar copias, esto también significa que puedo usar la sintaxis de asignación e indexación de numpy y pasarla directamente a otras funciones 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]

Sin embargo, también es inherentemente peligroso:

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

Para hacer esto más seguro, necesito poder verificar si el puntero C subyacente se ha liberado antes de intentar leer / escribir en el contenido de la matriz. Tengo algunos pensamientos sobre cómo hacer esto:

• Una forma sería generar una subclase de np.ndarray que contenga una referencia al atributo _cbuf de MyWrapper , verifique si es None antes de realizar cualquier lectura / escritura en su memoria subyacente, y genera una excepción si este es el caso.
• Podría generar fácilmente múltiples vistas en el mismo búfer, por ejemplo, mediante la conversión o el corte de .view , por lo que cada uno de estos tendría que heredar la referencia a _cbuf y el método que realiza la comprobación. Sospecho que esto podría lograrse anulando __array_finalize__ , pero no estoy seguro de cómo.
• El método de "comprobación de puntero" también debería llamarse antes de cualquier operación que lea y / o escriba en el contenido de la matriz. No sé lo suficiente sobre los aspectos internos de numpy para tener una lista exhaustiva de métodos para anular.

¿Cómo podría implementar una subclase de np.ndarray que realice esta comprobación? ¿Alguien puede sugerir un mejor enfoque?

Actualización: esta clase hace la mayor parte de lo que quiero:

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)

Por ejemplo:

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!

Estoy seguro de que hay otros casos de borde que he perdido.

Actualización 2: He tenido una weakref.proxy jugar con weakref.proxy , como sugiere @ivan_pozdeev . Es una buena idea, pero desafortunadamente no puedo ver cómo funcionaría con matrices numpy. Podría intentar crear una debilidad en la matriz numpy devuelta por .buffer :

wrap = MyWrapper()
wr = weakref.proxy(wrap.buffer)
print(wr)
# ReferenceError: weakly-referenced object no longer exists
# <weakproxy at 0x7f6fe715efc8 to NoneType at 0x91a870>

Creo que el problema aquí es que la instancia np.ndarray devuelta por wrap.buffer inmediatamente queda fuera del alcance. Una solución alternativa sería que la clase ejemplificara la matriz en la inicialización, mantuviera una fuerte referencia a ella y que el .buffer() devuelva un weakref.proxy a la matriz:

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)

Sin embargo, esto se interrumpe si creo una segunda vista en la misma matriz mientras el búfer aún está asignado:

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]

Esto se ha roto seriamente : después de llamar wrap2.__del__() no solo puedo leer y escribir en buf2 que era una vista de matriz wrap2._cbuf en wrap2._cbuf , sino que incluso puedo leer y escribir en buf , lo cual no debería ser posible dado que wrap2.__del__() establece wrap2._buffer en None .

Answer 1

Es una biblioteca propietaria escrita por un tercero y distribuida como un binario. Podría llamar a las mismas funciones de la biblioteca desde C en lugar de Python, pero eso no ayudaría mucho ya que todavía no tengo acceso al código que realmente asigna y libera los buffers. No puedo, por ejemplo, asignar yo mismo los buffers y luego pasarlos a la biblioteca como indicadores.

Sin embargo, podría envolver el búfer en un tipo de extensión de Python. De esa manera, puede exponer solo la interfaz que desea que esté disponible y dejar que el tipo de extensión maneje automáticamente la liberación del búfer. De esa forma no es posible que la API de Python realice una lectura / escritura de memoria libre.

mybuffer.c

#include <python3.3/Python.h>
// Hardcoded values
// N.B. Most of these are only needed for defining the view in the Python
// buffer protocol
static long external_buffer_size = 32; // Size of buffer in bytes
static long external_buffer_shape[] = { 32 }; // Number of items for each dimension
static long external_buffer_strides[] = { 1 }; // Size of item for each dimension
//----------------------------------------------------------------------------
// Code to simulate the third-party library
//----------------------------------------------------------------------------
// Allocate a new buffer
static void* external_buffer_allocate()
{
// Allocate the memory
void* ptr = malloc(external_buffer_size);
// Debug
printf("external_buffer_allocate() = 0x%lx/n", (long) ptr);
// Fill buffer with a recognizable pattern
int i;
for (i = 0; i < external_buffer_size; ++i)
{
*((char*) ptr + i) = i;
}
// Done
return ptr;
}
// Free an existing buffer
static void external_buffer_free(void* ptr)
{
// Debug
printf("external_buffer_free(0x%lx)/n", (long) ptr);
// Release the memory
free(ptr);
}
//----------------------------------------------------------------------------
// Define a new Python instance object for the external buffer
// See: https://docs.python.org/3/extending/newtypes.html
//----------------------------------------------------------------------------
typedef struct
{
// Python macro to include standard members, like reference count
PyObject_HEAD
// Base address of allocated memory
void* ptr;
} BufferObject;
//----------------------------------------------------------------------------
// Define the instance methods for the new object
//----------------------------------------------------------------------------
// Called when there are no more references to the object
static void BufferObject_dealloc(BufferObject* self)
{
external_buffer_free(self->ptr);
}
// Called when we want a new view of the buffer, using the buffer protocol
// See: https://docs.python.org/3/c-api/buffer.html
static int BufferObject_getbuffer(BufferObject *self, Py_buffer *view, int flags)
{
// Set the view info
view->obj = (PyObject*) self;
view->buf = self->ptr; // Base pointer
view->len = external_buffer_size; // Length
view->readonly = 0;
view->itemsize = 1;
view->format = "B"; // unsigned byte
view->ndim = 1;
view->shape = external_buffer_shape;
view->strides = external_buffer_strides;
view->suboffsets = NULL;
view->internal = NULL;
// We need to increase the reference count of our buffer object here, but
// Python will automatically decrease it when the view goes out of scope
Py_INCREF(self);
// Done
return 0;
}
//----------------------------------------------------------------------------
// Define the struct required to implement the buffer protocol
//----------------------------------------------------------------------------
static PyBufferProcs BufferObject_as_buffer =
{
// Create new view
(getbufferproc) BufferObject_getbuffer,
// Release an existing view
(releasebufferproc) 0,
};
//----------------------------------------------------------------------------
// Define a new Python type object for the external buffer
//----------------------------------------------------------------------------
static PyTypeObject BufferType =
{
PyVarObject_HEAD_INIT(NULL, 0)
"external buffer", /* tp_name */
sizeof(BufferObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) BufferObject_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
&BufferObject_as_buffer, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
"External buffer", /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc) 0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
};
//----------------------------------------------------------------------------
// Define a Python function to put in the module which creates a new buffer
//----------------------------------------------------------------------------
static PyObject* mybuffer_create(PyObject *self, PyObject *args)
{
BufferObject* buf = (BufferObject*)(&BufferType)->tp_alloc(&BufferType, 0);
buf->ptr = external_buffer_allocate();
return (PyObject*) buf;
}
//----------------------------------------------------------------------------
// Define the set of all methods which will be exposed in the module
//----------------------------------------------------------------------------
static PyMethodDef mybufferMethods[] =
{
{"create", mybuffer_create, METH_VARARGS, "Create a buffer"},
{NULL, NULL, 0, NULL} /* Sentinel */
};
//----------------------------------------------------------------------------
// Define the module
//----------------------------------------------------------------------------
static PyModuleDef mybuffermodule = {
PyModuleDef_HEAD_INIT,
"mybuffer",
"Example module that creates an extension type.",
-1,
mybufferMethods
//NULL, NULL, NULL, NULL, NULL
};
//----------------------------------------------------------------------------
// Define the module''s entry point
//----------------------------------------------------------------------------
PyMODINIT_FUNC PyInit_mybuffer(void)
{
PyObject* m;
if (PyType_Ready(&BufferType) < 0)
return NULL;
m = PyModule_Create(&mybuffermodule);
if (m == NULL)
return NULL;
return m;
}

test.py

#!/usr/bin/env python3
import numpy as np
import mybuffer
def test():
print(''Create buffer'')
b = mybuffer.create()
print(''Print buffer'')
print(b)
print(''Create memoryview'')
m = memoryview(b)
print(''Print memoryview shape'')
print(m.shape)
print(''Print memoryview format'')
print(m.format)
print(''Create numpy array'')
a = np.asarray(b)
print(''Print numpy array'')
print(repr(a))
print(''Change every other byte in numpy'')
a[::2] += 10
print(''Print numpy array'')
print(repr(a))
print(''Change first byte in memory view'')
m[0] = 42
print(''Print numpy array'')
print(repr(a))
print(''Delete buffer'')
del b
print(''Delete memoryview'')
del m
print(''Delete numpy array - this is the last ref, so should free memory'')
del a
print(''Memory should be free before this line'')
if __name__ == ''__main__'':
test()

Ejemplo

$ gcc -fPIC -shared -o mybuffer.so mybuffer.c -lpython3.3m
$ ./test.py
Create buffer
external_buffer_allocate() = 0x290fae0
Print buffer
<external buffer object at 0x7f7231a2cc60>
Create memoryview
Print memoryview shape
(32,)
Print memoryview format
B
Create numpy array
Print numpy array
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31], dtype=uint8)
Change every other byte in numpy
Print numpy array
array([10, 1, 12, 3, 14, 5, 16, 7, 18, 9, 20, 11, 22, 13, 24, 15, 26,
17, 28, 19, 30, 21, 32, 23, 34, 25, 36, 27, 38, 29, 40, 31], dtype=uint8)
Change first byte in memory view
Print numpy array
array([42, 1, 12, 3, 14, 5, 16, 7, 18, 9, 20, 11, 22, 13, 24, 15, 26,
17, 28, 19, 30, 21, 32, 23, 34, 25, 36, 27, 38, 29, 40, 31], dtype=uint8)
Delete buffer
Delete memoryview
Delete numpy array - this is the last ref, so should free memory
external_buffer_free(0x290fae0)
Memory should be free before this line

Answer 2

Debe mantener una referencia a su Wrapper mientras exista cualquier matriz numpy. La forma más sencilla de lograr esto, es guardar esta referencia en un atributo del ctype-buffer:

class MyWrapper(object):
def __init__(self, n=10):
# buffer allocated by external library
self.size = n
self.addr = libc.malloc(C.sizeof(C.c_int) * n)
def __del__(self):
# buffer freed by external library
libc.free(self.addr)
@property
def buffer(self):
buf = (C.c_int * self.size).from_address(self.addr)
buf._wrapper = self
return np.ctypeslib.as_array(buf)

De esta manera, su envoltorio se libera automáticamente, cuando la última referencia, por ejemplo, la última matriz numpy, se recolecta como basura.

Answer 3

Me gustó el enfoque de @Vikas, pero cuando lo probé, solo conseguí una matriz de objetos Numpy de un solo objeto FreeOnDel . Lo siguiente es mucho más simple y funciona:

class FreeOnDel(object):
def __init__(self, data, shape, dtype, readonly=False):
self.__array_interface__ = {"version": 3,
"typestr": numpy.dtype(dtype).str,
"data": (data, readonly),
"shape": shape}
def __del__(self):
data = self.__array_interface__["data"][0] # integer ptr
print("do what you want with the data at {}".format(data))
view = numpy.array(FreeOnDel(ptr, shape, dtype), copy=False)

donde ptr es un puntero a los datos como un entero (por ejemplo, ctypesptr.addressof(...) ).

Este atributo __array_interface__ es suficiente para decirle a Numpy cómo crear una región de memoria como una matriz, y luego el objeto FreeOnDel convierte en la base esa matriz. Cuando se elimina la matriz, la eliminación se propaga al objeto FreeOnDel , donde puede llamar a libc.free .

Incluso podría llamar a esta clase de FreeOnDel " BufferOwner ", porque ese es su rol: hacer un seguimiento de la propiedad.

Answer 4

Si puede controlar completamente la vida útil del búfer de C desde Python, lo que esencialmente tiene es un objeto "búfer" de Python que debe utilizar un ndarray .

Así,

• Hay 2 formas fundamentales de conectarlos:
  • búfer -> ndarray
  • ndarray -> buffer
• También hay una pregunta sobre cómo implementar el búfer en sí.

búfer -> ndarray

No es seguro: no hay nada que ndarray automáticamente una referencia al buffer durante el tiempo de vida de ndarray . La introducción de un tercer objeto para contener referencias a ambos no es mejor: entonces solo hay que hacer un seguimiento del tercer objeto en lugar del buffer .

ndarray -> buffer

"¡Ahora estas hablando!" ¿Ya que la tarea en cuestión es "buffer que debe usar un ndarray "? Esta es la forma natural de ir.

De hecho, numpy tiene un mecanismo incorporado: cualquier ndarray que no sea propietaria de su memoria contiene una referencia al objeto que tiene en su atributo base (lo que evita que este último se recoja). Para las vistas, el atributo se asigna automáticamente en consecuencia (al objeto principal si su base es None o a la base ).

El problema es que no puedes colocar ningún objeto viejo allí. En su lugar, el atributo es llenado por un constructor y el objeto sugerido se pone primero a través de su escrutinio.

Entonces, si solo pudiéramos construir algún objeto personalizado que numpy.array acepte y considere elegible para la reutilización de la memoria ( numpy.ctypeslib.as_array es en realidad una envoltura para numpy.array(copy=False) con algunas comprobaciones de numpy.array(copy=False) ) ...

<...>

Answer 5

Solo necesita un contenedor con la función __del__ adicional antes de pasarlo al método numpy.ctypeslib.as_array .

class FreeOnDel(object):
def __init__(self, ctypes_ptr):
# This is not needed if you are dealing with ctypes.POINTER() objects
# Start of hack for ctypes ARRAY type;
if not hasattr(ctypes_ptr, ''contents''):
# For static ctypes arrays, the length and type are stored
# in the type() rather than object. numpy queries these
# properties to find out the shape and type, hence needs to be
# copied. I wish type() properties could be automated by
# __getattr__ too
type(self)._length_ = type(ctypes_ptr)._length_
type(self)._type_ = type(ctypes_ptr)._type_
# End of hack for ctypes ARRAY type;
# cannot call self._ctypes_ptr = ctypes_ptr because of recursion
super(FreeOnDel, self).__setattr__(''_ctypes_ptr'', ctypes_ptr)
# numpy.ctypeslib.as_array function sets the __array_interface__
# on type(ctypes_ptr) which is not called by __getattr__ wrapper
# Hence this additional wrapper.
@property
def __array_interface__(self):
return self._ctypes_ptr.__array_interface__
@__array_interface__.setter
def __array_interface__(self, value):
self._ctypes_ptr.__array_interface__ = value
# This is the onlly additional function we need rest all is overhead
def __del__(self):
addr = ctypes.addressof(self._ctypes_ptr)
print("freeing address %x" % addr)
libc.free(addr)
# Need to be called on all object members
# object.__del__(self) does not work
del self._ctypes_ptr
def __getattr__(self, attr):
return getattr(self._ctypes_ptr, attr)
def __setattr__(self, attr, val):
setattr(self._ctypes_ptr, attr, val)

Probar

In [32]: import ctypes as C
In [33]: n = 10
In [34]: libc = C.CDLL("libc.so.6")
In [35]: addr = libc.malloc(C.sizeof(C.c_int) * n)
In [36]: cbuf = (C.c_int * n).from_address(addr)
In [37]: wrap = FreeOnDel(cbuf)
In [38]: sb = np.ctypeslib.as_array(wrap, (10,))
In [39]: sb[:] = np.arange(10)
In [40]: print(repr(sb))
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)
In [41]: print(repr(sb[::2]))
array([0, 2, 4, 6, 8], dtype=int32)
In [42]: sbv = sb.view(np.double)
In [43]: print(repr(sbv))
array([ 2.12199579e-314, 6.36598737e-314, 1.06099790e-313,
1.48539705e-313, 1.90979621e-313])
In [45]: buf2 = sb[:8]
In [46]: sb[::2] += 10
In [47]: del cbuf # Memory not freed because this does not have __del__
In [48]: del wrap # Memory not freed because sb, sbv, buf2 have references
In [49]: del sb # Memory not freed because sbv, buf have references
In [50]: del buf2 # Memory not freed because sbv has reference
In [51]: del sbv # Memory freed because no more references
freeing address 2bc6bc0

De hecho, una solución más fácil es sobrescribir la función __del__

In [7]: olddel = getattr(cbuf, ''__del__'', lambda: 0)
In [8]: cbuf.__del__ = lambda self : libc.free(C.addressof(self)), olddel
In [10]: import numpy as np
In [12]: sb = np.ctypeslib.as_array(cbuf, (10,))
In [13]: sb[:] = np.arange(10)
In [14]: print(repr(sb))
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)
In [15]: print(repr(sb))
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)
In [16]: print(repr(sb[::2]))
array([0, 2, 4, 6, 8], dtype=int32)
In [17]: sbv = sb.view(np.double)
In [18]: print(repr(sbv))
array([ 2.12199579e-314, 6.36598737e-314, 1.06099790e-313,
1.48539705e-313, 1.90979621e-313])
In [19]: buf2 = sb[:8]
In [20]: sb[::2] += 10
In [22]: del cbuf # Memory not freed
In [23]: del sb # Memory not freed because sbv, buf have references
In [24]: del buf2 # Memory not freed because sbv has reference
In [25]: del sbv # Memory freed because no more references

Answer 6

weakref es un mecanismo incorporado para la funcionalidad que está proponiendo. Específicamente, weakref.proxy es un objeto con la misma interfaz que el referido. Después de la eliminación del objeto al que se hace referencia, cualquier operación en el proxy genera un valor weakref.ReferenceError . Ni siquiera necesitas numpy :

In [2]: buffer=(c.c_int*100)() #acts as an example for an externally allocated buffer
In [3]: voidp=c.addressof(buffer)
In [10]: a=(c.c_int*100).from_address(voidp) # python object accessing the buffer.
# Here it''s created from raw address value. It''s better to use function
# prototypes instead for some type safety.
In [14]: ra=weakref.proxy(a)
In [15]: a[1]=1
In [16]: ra[1]
Out[16]: 1
In [17]: del a
In [18]: ra[1]
ReferenceError: weakly-referenced object no longer exists
In [20]: buffer[1]
Out[20]: 1

Como puede ver, en cualquier caso, necesita un objeto de Python normal sobre el búfer de C. Si una biblioteca externa posee la memoria, el objeto debe eliminarse antes de que el búfer se libere en el nivel C. Si usted es dueño de la memoria, simplemente crea un objeto ctypes la manera normal, luego se liberará cuando se elimine.

Por lo tanto, si su biblioteca externa posee la memoria y puede liberarse en cualquier momento (su especificación es vaga al respecto), debe indicarle de alguna manera que está a punto de hacerlo; de lo contrario, no tiene forma de saberlo para tomar las medidas necesarias.