Il modo più veloce per scrivere dati durante la produzione

Question

Nel mio programma sto simulando un sistema N-body per un gran numero di iterazioni. Per ogni iterazione produco un insieme di coordinate 6N che devo aggiungere a un file e quindi utilizzare per eseguire l'iterazione successiva. Il codice è scritto in C++ e attualmente utilizza il metodo write() per scrivere i dati in formato binario ad ogni iterazione.

Non sono un esperto in questo campo, ma mi piacerebbe migliorare questa parte del programma, poiché sono in procinto di ottimizzare l'intero codice. Sento che la latenza associata alla scrittura del risultato del calcolo ad ogni ciclo rallenta significativamente le prestazioni del software.

Sono confuso perché non ho esperienza di programmazione parallela e I/O di file di basso livello. Ho pensato di alcune tecniche astratte che ho immaginato avrei potuto realizzare, dal momento che sono la programmazione per la moderna (possibilmente multi-core) macchine con sistemi operativi Unix:

• Scrittura dei dati nel file in blocchi di n iterazioni (sembra ci essere modi migliori per procedere ...)
• parallelizzare il codice con OpenMP (come implementare effettivamente un buffer in modo che i fili sono sincronizzati in modo appropriato, e non si sovrappongono?)
• Uso mmap (la dimensione del file potrebbe essere enorme, nell'ordine dei GB, questo approccio è abbastanza robusto?)

Tuttavia, non so come implementarli al meglio e combinarli in modo appropriato.

Answer 1

Naturalmente scrivere in un file ad ogni iterazione è inefficiente e molto probabilmente rallenterà il tuo computer. (come regola generale, dipende dal caso actuel)

È necessario utilizzare un modello di progettazione producer ->consumer. Saranno collegati da una coda, come un nastro trasportatore.

• Il produttore cercherà di produrre il più velocemente possibile, rallentando solo se il consumatore non può gestirlo.
• Il consumatore proverà a "consumare" il più velocemente possibile.

Dividendo i due, è possibile aumentare le prestazioni più facilmente perché ogni processo è più semplice e ha meno interferenze dall'altro.

• Se il produttore è più veloce, è necessario migliorare il consumatore, nel tuo caso, scrivendo in un file in modo più efficiente, blocco per blocco molto probabilmente (come hai detto)
• Se il consumatore è più veloce , è necessario migliorare il produttore, molto probabilmente parallelizzando come hai detto tu.

C'è non è necessario per ottimizzare entrambi. Ottimizza solo il più lento (il collo di bottiglia).

In pratica, si utilizzano thread e una coda sincronizzata tra di loro. Per suggerimenti sull'implementazione, date un'occhiata allo here, in particolare al § 18.12 "The Producer-Consumer Pattern".

Per quanto riguarda la gestione del flusso, è necessario aggiungere un po 'più di complessità selezionando una "dimensione massima della coda" e facendo attendere il produttore (i) se la coda non ha spazio sufficiente. Attenzione ai deadlock, quindi, codificalo attentamente. (vedi il collegamento wikipedia che ho dato a riguardo)

Nota: è consigliabile utilizzare i thread di boost perché i thread non sono molto portabili. (beh, lo sono dal C++ 0x ma la disponibilità di C++ 0x non è ancora buona)

Answer 2

È meglio suddividere l'operazione in due processi indipendenti: data-producing e file-writing. Data-producing userebbe un po 'di buffer per il passaggio dei dati in iterazione, e file-writing userebbe una coda per memorizzare le richieste di scrittura. Quindi, data-producing pubblicherebbe solo una richiesta di scrittura e proseguirà, mentre file-writing farebbe fronte alla scrittura in background.

In sostanza, se i dati vengono generati molto più rapidamente di quanto possa essere memorizzato, si finisce rapidamente a conservare la maggior parte nel buffer. In tal caso il tuo approccio attuale sembra abbastanza ragionevole, dal momento che si può fare poco a livello programmatico per migliorare la situazione.

Answer 3

"Uso mmap (la dimensione del file potrebbe essere enorme, dell'ordine di GB, è questo approccio robusto abbastanza?)"

mmap è il metodo di caricamento dei programmi, librerie condivise e del sistema operativo il file page/swap: è robusto come qualsiasi altro I/O di file e generalmente offre prestazioni più elevate.

MA nella maggior parte dei sistemi operativi è difficile/difficile/impossibile espandere la dimensione di un file mappato mentre è in uso. Quindi, se conosci la dimensione dei dati, o stai solo leggendo, è fantastico. Per un log/dump che si aggiungono continuamente è meno affidabile, a meno che non si conoscano delle dimensioni massime.

Answer 4

Se non vuoi giocare con roba in un thread diverso, puoi provare a usare aio_write(), che consente l'asincrono scrive. Fondamentalmente si fornisce al sistema operativo il buffer da scrivere, e la funzione ritorna immediatamente e termina la scrittura mentre il programma continua, è possibile controllare in seguito per vedere se la scrittura è stata completata.

Questa soluzione continua a soffrire del problema produttore/consumatore menzionato in altre risposte, se l'algoritmo sta producendo dati più velocemente di quanto possa essere scritto, alla fine si esaurirà la memoria per memorizzare i risultati tra l'algoritmo e la scrittura , quindi dovresti provarlo e vedere come funziona.