Memoria compartida entre procesos de python

Estoy tratando de encontrar una manera de compartir la memoria entre los procesos de python. Básicamente, existen objetos que múltiples procesos de Python necesitan poder LEER (solo leer) y usar (sin mutación). En este momento, esto se implementa usando redis + strings + cPickle, pero cPickle requiere un tiempo precioso de CPU, por lo que me gustaría no tener que usarlo. La mayoría de las implementaciones de memoria compartida de Python que he visto en Internet parecen requerir archivos y encurtidos, que es básicamente lo que ya estoy haciendo y exactamente lo que estoy tratando de evitar.

Lo que me pregunto es si habría una manera de escribir un me gusta… básicamente una base de datos/servidor de objetos python en memoria y un módulo C correspondiente para interactuar con la base de datos.

Básicamente, el módulo C le pediría al servidor una dirección para escribir un objeto, el servidor respondería con una dirección, luego el módulo escribiría el objeto y notificaría al servidor que un objeto con una clave dada fue escrito en el disco en el momento ubicación especificada. Luego, cuando cualquiera de los procesos quisiera recuperar un objeto con una clave dada, simplemente le pediría a la base de datos la ubicación de memoria para la clave dada, el servidor respondería con la ubicación y el módulo sabría cómo cargar ese espacio en la memoria y transfiera el objeto python de vuelta al proceso python.

¿Es eso totalmente irrazonable o simplemente muy difícil de implementar? ¿Estoy persiguiendo algo que es imposible? Cualquier sugerencia será bienvenida. gracias internet

Desde Python 3.8 y en adelante puedes usar multiprocesamiento.memoria_compartida.MemoriaCompartida

No irrazonable.

IPC se puede hacer con un archivo mapeado en memoria. Python tiene una funcionalidad integrada:

http://docs.python.org/library/mmap.html

Simplemente mmap el archivo en ambos procesos y listo, tiene un archivo compartido. Por supuesto, tendrá que sondearlo en ambos procesos para ver qué cambios. Y tendrás que cooperar escribe entre ambos. Y decida en qué formato quiere poner sus datos. Pero es una solución común a su problema.

Si no quieres encurtir, multiprocessing.sharedctypes podría encajar Sin embargo, es un poco de bajo nivel; obtiene valores individuales o matrices de tipos específicos.

Otra forma de distribuir datos a procesos secundarios (una forma) es multiprocessing.Pipe. Eso puede manejar objetos de Python y está implementado en C, por lo que no puedo decirle si usa decapado o no.

Python NO admite memoria compartida entre procesos independientes. Puede implementar el suyo propio en lenguaje C, o usar SharedArray
si está trabajando con libsvm, numpy.ndarray, scipy.sparse.

pip install SharedArray

def test ():
    def generateArray ():
        print('generating')
        from time import sleep
        sleep(3)
        return np.ones(1000)
    a = Sarr('test/1', generateArray)

    # use same memory as a, also work in a new process
    b = Sarr('test/1', generateArray) 
    c = Sarr('test/1', generateArray)

import re
import SharedArray
import numpy as np

class Sarr (np.ndarray):
    def __new__ (self, name, getData):
        if not callable(getData) and getData is None:
            return None
        self.orig_name = name
        shm_name="shm://" + re.sub(r'[./]', '_', name)
        try:
            shm = SharedArray.attach(shm_name)
            print('[done] reuse shared memory:', name)
            return shm
        except Exception as err:
            self._unlink(shm_name)
            data = getData() if callable(getData) else getData
            shm = SharedArray.create(shm_name, data.size)
            shm[:] = data[:]
            print('[done] loaded data to shared memory:', name)
            return shm

    def _unlink (name):
        try:
            SharedArray.delete(name[len('shm://'):])
            print('deleted shared memory:', name)
        except:
            pass


if __name__ == '__main__':
    test()