Python utilizzo della memoria multiprocessing

Question

ho writen un programma che può essere riassunta come segue:

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() 

Il vero codice (soprattutto'writeOutput() ') è molto più complicato. 'writeOutput() 'utilizza solo questi valori che assume come argomenti (ovvero non fa riferimento a hadata')

In pratica carica un enorme set di dati in memoria e lo elabora. La scrittura dell'output è delegata a un processo secondario (scrive in più file in realtà e ciò richiede molto tempo). Quindi, ogni volta che viene elaborato un elemento di dati, viene inviato al processo secondario tramite res_queue che a sua volta scrive il risultato in file, se necessario.

Il processo secondario non ha bisogno di accedere, leggere o modificare i dati caricati da "loadHugeData()" in alcun modo. Il processo secondario deve solo utilizzare ciò che il processo principale invia tramite'res_queue'. E questo mi porta al mio problema e alla mia domanda.

Mi sembra che il processo secondario ottenga la copia dell'enorme set di dati (quando si controlla l'utilizzo della memoria con'top'). È vero? E se è così allora come posso evitare id (usando essenzialmente la doppia memoria)?

Sto usando Python 2.6 e il programma è in esecuzione su linux.

Answer 1

Il modulo multiprocessing si basa in modo efficace sulla chiamata di sistema fork che crea una copia del processo corrente. Poiché si caricano i dati enormi prima di fork (o si crea lo multiprocessing.Process), il processo figlio eredita una copia dei dati.

Tuttavia, se il sistema operativo in esecuzione su implementa COW (copy-on-write), ci sarà solo una copia dei dati nella memoria fisica a meno che non si modifichino i dati nel processo padre o figlio (sia genitore che figlio saranno condividere le stesse pagine di memoria fisica, anche se in spazi di indirizzi virtuali diversi); e anche in questo caso, la memoria aggiuntiva verrà assegnata solo per le modifiche (negli incrementi pagesize).

È possibile evitare questa situazione chiamando multiprocessing.Process prima di caricare i dati enormi. Quindi le allocazioni di memoria aggiuntive non si rifletteranno nel processo figlio quando si caricano i dati nel genitore.