Strömmande pipelines och namngivna pipes för genomströmning

Ett namngivet rör (FIFO — First In, First Out) skapas med mkfifo. Det visas i filsystemet som en vanlig fil, men data som skrivs till det lagras aldrig på disken — den flödar direkt till processen som läser.

Viktiga beteenden att komma ihåg:

• En skrivning till en FIFO blockeras tills en läsare öppnar den, och omvänt.
• FIFO-posten finns kvar i filsystemet; ni måste ta bort den med rm när ni är klara.
• Flera skrivare är tillåtna, men ordningen mellan dem kan inte garanteras.

Nedan komprimerar en producent data till en FIFO medan en konsument laddar upp den till S3 samtidigt — ingen temporär fil behövs.

Processubstitution använder syntaxen <(command) eller >(command). Bash skapar i bakgrunden en FIFO (eller en fildeskriptor för /dev/fd/N) och skickar sökvägen till det yttre kommandot.

Detta är kraftfullt när ett verktyg förväntar sig ett argument med ett filnamn i stället för stdin. Utan processubstitution skulle ni behöva en temporär fil; med processubstitution strömmar ni data direkt.

• <(cmd) — det yttre kommandot läser från cmd:s utdata.
• >(cmd) — det yttre kommandot skriver till cmd:s indata.

tee läser från stdin och skriver till både stdout och en eller flera filer. Tillsammans med processubstitution kan ni förgrena en enda ström till flera bearbetningspipeline:er samtidigt — helt utan att använda disken.

Detta mönster är användbart när ni till exempel vill logga rådata och bearbeta den samtidigt.

När en enda datakälla ska mata flera oberoende konsumenter kombinerar ni tee med flera processubstitutioner av typen >(). Varje konsument får hela strömmen och körs samtidigt.

Detta gör att källfilen inte behöver läsas flera gånger. För en fil på 10 GB är skillnaden enorm — en diskläsning i stället för N läsningar.

Motsatsen till förgrening är sammanföring: flera oberoende källor strömmar data till en enda konsument. Namngivna FIFO:er gör detta enkelt.

Ett vanligt användningsfall är att slå samman loggströmmar från flera servrar i realtid eller att samla delresultat från parallella arbetare.

Observera att konsumenten ser sammanflätad utdata när det finns flera skrivare — det fungerar bra för radorienterade data där varje rad är självständig, men om ordningen är viktig måste ni hantera den själva.

Ett av de mest praktiska användningsområdena för FIFO:er är parallell komprimering. Verktyg som pigz (parallell gzip) eller pbzip2 läser en ström; ni kan skicka rådata direkt genom en pipeline utan att först skapa en okomprimerad fil.

Mönstret nedan arkiverar en katalog, komprimerar den med alla CPU-kärnor och strömmar resultatet till en fjärrvärd — allt samtidigt:

Rör har en buffert i kärnan (vanligen 64 KB). När bufferten är full blockeras skrivaren; när den är tom blockeras läsaren. Detta är vanligtvis vad ni vill, men i vissa fall kan blockeringen orsaka ett dödläge.

Risk för dödläge: om process A skriver till FIFO1 och läser från FIFO2, medan process B skriver till FIFO2 och läser från FIFO1, kan båda blockeras i väntan på att den andra ska läsa först.

Lösningar:

• Kör minst den ena sidan i bakgrunden (&) så att den inte blockerar skalet.
• Använd mbuffer eller pv för att lägga till en större buffert i minnet mellan stegen.
• Använd pv -q -B 128m för att lägga in en buffert på 128 MB och jämna ut tillfälliga genomströmningsökningar.

Här är ett komplett och realistiskt mönster: följ flera loggfiler, slå samman strömmarna genom ett namngivet rör, filtrera efter fel och skriv en sammanfattning i realtid — allt utan mellanliggande filer och med alla steg körande parallellt.

Detta är den typ av pipeline som skulle köras som ett övervakningsskript i bakgrunden på en produktionsserver.

Ni kan mäta den faktiska skillnaden i genomströmning mellan metoderna med strömning och temporära filer med time. Pipeline-metoden vinner på stora datamängder eftersom:

• Stegen körs samtidigt — CPU och I/O överlappar.
• Ingen disk-I/O behövs för mellanliggande data — endast det slutliga resultatet skrivs till disken.
• Minnesåtgången förblir konstant oavsett indatafilens storlek (data strömmas i stället för att buffras).

En enkel benchmark för att jämföra de båda metoderna:

I den här lektionen har Ni utforskat hur data kan flyttas effektivt mellan processer utan mellanliggande filer:

• Anonyma pipes (|) kopplar samman intilliggande kommandon och kör alla steg samtidigt med automatisk backpressure.
• Namngivna pipes (mkfifo) skapar en FIFO-post i filsystemet som låter orelaterade processer eller bakgrundsprocesser strömma data till varandra — skrivningar blockeras tills en läsare finns.
• Processubstitution (<(cmd), >(cmd)) gör att kommandon som förväntar sig filnamn transparent kan läsa från eller producera strömmar.
• tee + >() förgrenar en ström till flera samtidiga konsumenter utan att källan behöver läsas igen.
• Fan-in sammanfogar flera producenter till en konsument via en gemensam FIFO.
• Backpressure och blockering är funktioner, inte buggar — men kör alltid minst ena sidan av ett FIFO-par i bakgrunden för att undvika dödläge.
• Använd pv eller mbuffer för att lägga till större buffertar och övervaka genomströmningen när stegen arbetar i ryck.

Dessa tekniker utgör grunden för Bash-baserad datahantering med hög genomströmning: bearbeta data i GB-skala med konstant minnesanvändning och maximal parallellitet för CPU och I/O.