Pipeline di streaming e named pipe per le prestazioni

Quando concatena comandi come sort file.txt > tmp.txt && uniq tmp.txt > result.txt, paga un costo nascosto: scritture su disco, letture da disco e una pipeline che si arresta finché il primo passaggio non è completato del tutto prima di avviare il successivo.

Le pipeline in streaming eliminano questo costo. I dati passano direttamente dal produttore al consumatore in memoria, fase dopo fase, in modo concorrente. Questa è l’idea alla base delle pipe Unix; le pipe con nome, ovvero le FIFO, la estendono ulteriormente.

• Pipe anonima (|): collega due comandi adiacenti nella stessa riga della shell.
• Pipe con nome (FIFO): un file speciale nel filesystem che consente a processi non correlati di trasmettere dati tra loro.
• Sostituzione di processo: consente a un comando di trattare l’output di un altro comando come se fosse un file.

Questa lezione mostra come applicare tutti e tre i meccanismi per massimizzare il throughput nei flussi di lavoro Bash reali.

Una pipe anonima collega lo stdout di un processo allo stdin del processo successivo. Il kernel mantiene entrambi i processi in esecuzione simultaneamente, utilizzando un buffer in memoria di dimensione fissa, in genere di 64 KB su Linux.

L’idea fondamentale è che la pipeline è veloce quanto la sua fase più lenta. Se il produttore è più veloce, si blocca quando il buffer è pieno. Se il consumatore è più veloce, si blocca quando il buffer è vuoto. Questa contropressione è un controllo automatico del flusso, disponibile senza costi aggiuntivi.

L’esempio seguente conta gli indirizzi IP univoci in un grande log degli accessi senza mai scrivere un file temporaneo. Ogni fase viene eseguita contemporaneamente:

Una pipe con nome (FIFO — First In, First Out) viene creata con mkfifo. Compare nel filesystem come un normale file, ma i dati scritti al suo interno non vengono mai memorizzati su disco: fluiscono direttamente verso il processo in lettura.

Comportamenti fondamentali da ricordare:

• Una scrittura su una FIFO si blocca finché un lettore non la apre, e viceversa.
• La voce della FIFO rimane nel filesystem; al termine è necessario eliminarla con rm.
• Sono consentiti più scrittori, ma l’ordine tra loro non è garantito.

Di seguito, un produttore comprime i dati in una FIFO mentre un consumatore li carica contemporaneamente su S3, senza bisogno di un file temporaneo.

La sostituzione di processo utilizza la sintassi <(command) o >(command). Bash crea una FIFO o un descrittore di file /dev/fd/N dietro le quinte e passa il percorso al comando esterno.

È particolarmente utile quando uno strumento si aspetta un argomento filename anziché stdin. Senza la sostituzione di processo sarebbe necessario un file temporaneo; con essa, i dati vengono trasmessi direttamente.

• <(cmd) — il comando esterno legge l’output di cmd.
• >(cmd) — il comando esterno scrive nell’input di cmd.

tee legge stdin e scrive i dati sia su stdout sia su uno o più file. In combinazione con la sostituzione di processo, consente di distribuire un singolo flusso verso più pipeline di elaborazione simultaneamente, senza mai accedere al disco.

Questo schema è utile, ad esempio, quando si desidera registrare i dati grezzi ed elaborarli contemporaneamente.

Quando una singola origine dati deve alimentare più consumatori indipendenti, si può combinare tee con più sostituzioni di processo >(). Ogni consumatore riceve l’intero flusso e viene eseguito contemporaneamente.

In questo modo si evita di leggere più volte il file sorgente. Per un file da 10 GB la differenza è enorme: una sola lettura dal disco invece di N letture.

L’opposto del fan-out è il fan-in: più origini indipendenti trasmettono dati a un singolo consumatore. Le FIFO consentono di realizzare questo schema in modo semplice.

Un caso d’uso comune consiste nell’unire in tempo reale i flussi di log di diversi server o nell’aggregare risultati parziali provenienti da worker paralleli.

Con più scrittori, il consumatore riceve un output intercalato: questo va bene per dati orientati alle righe, in cui ogni riga è autonoma, ma se la sequenza è importante sarà necessario gestire personalmente l’ordinamento.

Uno degli impieghi più pratici delle FIFO è la compressione parallela. Strumenti come pigz (gzip parallelo) o pbzip2 leggono un flusso; è possibile convogliare direttamente i dati grezzi senza creare prima un file non compresso.

Lo schema seguente archivia una directory, la comprime usando tutti i core della CPU e trasmette il risultato a un host remoto, tutto contemporaneamente:

Le pipe hanno un buffer del kernel, generalmente di 64 KB. Quando il buffer è pieno, lo scrittore si blocca; quando è vuoto, si blocca il lettore. Di solito è il comportamento desiderato, ma in alcuni casi il blocco può causare un deadlock.

Rischio di deadlock: se il processo A scrive nella FIFO1 e legge dalla FIFO2, mentre il processo B scrive nella FIFO2 e legge dalla FIFO1, entrambi possono bloccarsi aspettando che l’altro consumi per primo i dati.

Soluzioni:

• Eseguire almeno una delle due parti in background (&), così non blocca la shell.
• Usare mbuffer o pv per aggiungere un buffer in memoria più grande tra le fasi.
• Usare pv -q -B 128m per inserire un buffer da 128 MB e rendere più regolare il throughput.

Ecco uno schema completo e realistico: seguire più file di log, unire i flussi tramite una pipe con nome, filtrare gli errori e scrivere un riepilogo aggiornato in tempo reale, senza file intermedi e con tutte le fasi eseguite in parallelo.

Questo è il tipo di pipeline che verrebbe eseguita come script di monitoraggio in background su un server di produzione.

È possibile misurare la differenza effettiva di throughput tra l’approccio in streaming e quello basato su file temporanei usando time. L’approccio con pipeline è più efficiente sui grandi insiemi di dati perché:

• Le fasi vengono eseguite contemporaneamente: CPU e I/O si sovrappongono.
• Non è necessario alcun I/O su disco per i dati intermedi: solo l’output finale viene scritto su disco.
• L’uso della memoria rimane costante indipendentemente dalle dimensioni dell’input, perché i dati vengono trasmessi in streaming e non memorizzati in un buffer.

Un semplice benchmark per confrontare i due approcci:

Consideri il seguente script:

mkfifo /tmp/mypipe
echo 'hello' > /tmp/mypipe
echo 'done'

Che cosa accade quando lo script viene eseguito senza processi in background né lettori?

In questa lezione ha esplorato come spostare i dati in modo efficiente tra processi senza utilizzare file intermedi:

• Pipe anonime (|) collegano comandi adiacenti ed eseguono contemporaneamente tutte le fasi, applicando automaticamente il back-pressure.
• Named pipe (mkfifo) creano una voce FIFO nel file system che consente a processi non correlati o in background di trasmettere dati tra loro: le scritture si bloccano finché non è presente un lettore.
• Sostituzione di processo (<(cmd), >(cmd)) consente ai comandi che si aspettano nomi di file di consumare o produrre flussi in modo trasparente.
• tee + >() distribuiscono un flusso a più consumer concorrenti senza rileggere la sorgente.
• Fan-in combina più produttori in un unico consumer tramite una FIFO condivisa.
• Back-pressure e blocchi sono funzionalità, non bug; tuttavia, esegua sempre almeno un lato di una coppia FIFO in background per evitare deadlock.
• Utilizzi pv o mbuffer per aggiungere buffer più grandi e monitorare il throughput quando le fasi generano raffiche di dati.

Queste tecniche sono alla base della gestione dei dati ad alto throughput con Bash: consentono di elaborare dati su scala di GB usando memoria costante e il massimo parallelismo di CPU/I/O.