Linux - Le PIPE
Table of Contents
1. Funzionamento
La pipe (o tubo, in italiano) è un meccanismo fisico/logico nei sistemi Unix-like (come Linux e macOS) che permette la comunicazione unidirezionale tra due processi. Ecco come è implementata a livello di sistema operativo:
1.1. Fisicamente: è un buffer in memoria
- Non esiste come un oggetto hardware, ma è una struttura dati gestita dal kernel del sistema operativo.
- È un buffer circolare (una zona di memoria riservata) che memorizza temporaneamente i dati scritti da un processo prima che vengano letti dall’altro processo.
- Ha una capacità limitata (di solito 64 KB su Linux, ma dipende dal sistema). Se il buffer è pieno, il processo scrittore viene bloccato finché lo spazio non si libera.
1.2. Come funziona a basso livello
Quando esegui:
comando1 | comando2
il sistema operativo:
- Crea una pipe (buffer + due file descriptor: uno per la lettura, uno per la scrittura).
- Esegue i processi in parallelo:
- Il processo di `comando1` scrive il suo output nel file descriptor di scrittura della pipe.
- Il processo di `comando2` legge dall’altro lato (file descriptor di lettura).
- Sincronizzazione: Se `comando2` è più lento, il kernel sospende `comando1` finché la pipe non ha spazio libero (e viceversa).
1.3. Dettagli tecnici
- File descriptor: La pipe è identificata da due "punti di accesso" (file descriptor):
- `fd[0]` (lato di lettura).
- `fd[1]` (lato di scrittura).
- Comunicazione unidirezionale: I dati fluiscono solo in una direzione (da `comando1` a `comando2`).
- Blocco dei processi: Se la pipe è vuota, `comando2` si blocca in attesa di dati; se è piena, `comando1` si blocca finché `comando2` non legge.
1.4. Esempio con codice C (per capire l’implementazione) Ecco come il kernel crea una pipe a livello di sistema:
#include <unistd.h> int fd[2]; pipe(fd); // Crea la pipe
- Dopo `pipe(fd)`, `fd[0]` è il lato di lettura, `fd[1]` è il lato di scrittura.
- In una shell, questi file descriptor vengono automaticamente collegati a `stdout` del primo processo e `stdin` del secondo.
1.5. Analogia con il mondo reale
Immagina un tubo che collega due secchi:
- Il primo processo (`comando1`) versa acqua nel tubo (scrive dati).
- Il secondo processo (`comando2`) prende l’acqua dall’altro lato (legge dati).
- Se il tubo è pieno, chi versa deve aspettare; se è vuoto, chi prende deve aspettare.
1.6. Limitazioni
- Dati volatili: Se i dati nella pipe non vengono letti, vengono persi quando i processi terminano.
- Unidirezionale: Per comunicazione bidirezionale servono due pipe (o strumenti più avanzati come socket).
1.7. Curiosità
- La pipe è stata introdotta da Douglas McIlroy nei primi anni ’70 ed è una delle feature chiave di Unix.
- È alla base della filosofia Unix: "Fai una cosa e falla bene. Usa pipe per collegare programmi semplici".