He escrito un programa que puede resumirse de la siguiente manera:

def loadHugeData():
    #load it
    return data

def processHugeData(data, res_queue):
    for item in data:
        #process it
        res_queue.put(result)
    res_queue.put("END")

def writeOutput(outFile, res_queue):
    with open(outFile, 'w') as f
        res=res_queue.get()
        while res!='END':
            f.write(res)
            res=res_queue.get()

res_queue = multiprocessing.Queue()

if __name__ == '__main__':
    data=loadHugeData()
    p = multiprocessing.Process(target=writeOutput, args=(outFile, res_queue))
    p.start()
    processHugeData(data, res_queue)
    p.join()

El código real (especialmentewriteOutput()) es mucho más complicado.writeOutput() solo utiliza estos valores que toma como sus argumentos (lo que significa que no hace referencia adata)

Básicamente carga un enorme conjunto de datos en la memoria y lo procesa. La escritura de la salida se delega a un subproceso (en realidad se escribe en varios archivos y esto lleva mucho tiempo). Por lo tanto, cada vez que se procesa un elemento de datos, se envía al subproceso a través de res_queue, que a su vez escribe el resultado en archivos según sea necesario.

El subproceso no necesita acceder, leer o modificar los datos cargados porloadHugeData() de cualquier manera. El subproceso solo necesita usar lo que el proceso principal lo envía a través deres_queue. Y esto me lleva a mi problema y pregunta.

Me parece que el subproceso se obtiene en la copia del enorme conjunto de datos (al verificar el uso de la memoria contop). ¿Es esto cierto? Y si es así, ¿cómo puedo evitar la identificación (esencialmente con memoria doble)?

Estoy usando Python 2.6 y el programa se está ejecutando en Linux.