Intérprete global Bloqueo y acceso a datos (por ejemplo, para matrices NumPy)

Question

Estoy escribiendo una extensión C para Python, que debería liberar el bloqueo de Intérprete global mientras opera en datos. Creo que he entendido bastante bien el mecanismo del GIL, pero queda una pregunta: ¿puedo acceder a los datos en un objeto de Python mientras el hilo no posee el GIL? Por ejemplo, quiero leer datos de una matriz (grande) de NumPy en la función C, mientras que aún quiero permitir que otros hilos hagan otras cosas en los otros núcleos de la CPU. La función C debe

• liberación del GIL con Py_BEGIN_ALLOW_THREADS
• lectura y el trabajo en los datos sin necesidad de utilizar las funciones de Python
• incluso escribir datos en matrices NumPy previamente construidos
• readquirir la GIL con Py_END_ALLOW_THREADS

¿Esto es seguro? Por supuesto, se supone que otros hilos no cambian las variables que utiliza la función C. Pero tal vez haya una fuente oculta de errores: ¿podría el intérprete de Python mover un objeto, por ej. por algún tipo de recolección de basura, mientras que la función C funciona en un hilo separado?

Para ilustrar la pregunta con un ejemplo mínimo, considere el código (mínimo pero completo) a continuación. Compilarlo (en Linux) con

gcc -pthread -fno-strict-aliasing -DNDEBUG -g -fwrapv -fPIC -I/usr/lib/pymodules/python2.7/numpy/core/include -I/usr/include/python2.7 -c gilexample.c -o gilexample.o 
gcc -pthread -shared gilexample.o -o gilexample.so 

y probarlo en Python con

import gilexample 
gilexample.sum([1,2,3]) 

Es el código entre Py_BEGIN_ALLOW_THREADS y Py_END_ALLOW_THREADS seguro? Accede al contenido de un objeto de Python, y no quiero duplicar la matriz (posiblemente grande) en la memoria.

#include <Python.h> 
#include <numpy/arrayobject.h> 

// The relevant function 
static PyObject * sum(PyObject * const self, PyObject * const args) { 
    PyObject * X; 
    PyArg_ParseTuple(args, "O", &X); 
    PyObject const * const X_double = PyArray_FROM_OTF(X, NPY_DOUBLE, NPY_ALIGNED); 
    npy_intp const size = PyArray_SIZE(X_double); 
    double * const data = (double *) PyArray_DATA(X_double); 
    double sum = 0; 

    Py_BEGIN_ALLOW_THREADS // IS THIS SAFE? 

    npy_intp i; 
    for (i=0; i<size; i++) 
    sum += data[i]; 

    Py_END_ALLOW_THREADS 

    Py_DECREF(X_double); 
    return PyFloat_FromDouble(sum); 
} 

// Python interface code 
// List the C methods that this extension provides. 
static PyMethodDef gilexampleMethods[] = { 
    {"sum", sum, METH_VARARGS}, 
    {NULL, NULL, 0, NULL}  /* Sentinel - marks the end of this structure */ 
}; 

// Tell Python about these methods. 
PyMODINIT_FUNC initgilexample(void) { 
    (void) Py_InitModule("gilexample", gilexampleMethods); 
    import_array(); // Must be present for NumPy. 
} 

Answer 1

¿Puedo acceder a los datos en un objeto de Python, mientras que el hilo no es dueño del GIL?

No, no puedes.

Answer 2

¿Es esto seguro?

Estrictamente, no. Creo que debería mover las llamadas al PyArray_SIZE y PyArray_DATA fuera del bloque GIL-less; si haces eso, estarás operando solo en C datos. También es posible que desee aumentar el recuento de referencias en el objeto antes de entrar en el bloque sin GIL y disminuirlo después.

Después de sus ediciones, debería ser seguro. No olvide disminuir el conteo de referencia después.