Tube (informatique)
Cet article ne cite pas suffisamment ses sources ().
Si vous disposez d'ouvrages ou d'articles de référence ou si vous connaissez des sites web de qualité traitant du thème abordé ici, merci de compléter l'article en donnant les références utiles à sa vérifiabilité et en les liant à la section « Notes et références ».
En pratique : Quelles sources sont attendues ? Comment ajouter mes sources ?
Pour les articles homonymes, voir Tube.
En génie logiciel, un tube ou une pipeline est un mécanisme de communication inter-processus sous la forme d'une série de données, octets ou bits, accessibles en FIFO. Le patron de conception qui correspond à ce mécanisme s'appelle le filtre. Les tubes des shell, inventés pour UNIX, permettent de lier la sortie d'un programme à l'entrée du suivant dans les shell et permet, tel quel, de créer des filtres. Ces tubes sont réalisés par l'intermédiaire de mécanisme sous-jacent appelé tubes anonymes. Ces tubes sont détruits lorsque le processus qui les a créés disparait, les tubes nommés sont en revanche liés au système d'exploitation et ils doivent être explicitement détruits. Ce type de mécanisme se retrouve bien sûr dans tous les systèmes d'exploitation de type Unix mais aussi dans les systèmes d'exploitation de Microsoft cependant leur sémantique est sensiblement différente. Les tubes sont considérés comme la plus ancienne implémentation non triviale de la programmation modulaire au niveau de l'architecture d'un projet informatique.
Mise en œuvre
[modifier | modifier le code]Les tubes sont particulièrement efficaces dans les systèmes d'exploitation multitâches, puisque tous les processus chainés sont lancés simultanément. L'acquisition des données est immédiatement traitée par tous les processus successifs sans qu'il soit nécessaire d'accumuler une grande quantité de données. Cela permet aussi de facto de maximiser l'activité des unités de calcul.
Habituellement un mécanisme de synchronisation inter-processus est mis en place, les opérations de lecture ou d'écriture sont bloquantes. Ceci signifie que d'une part l'exécution du processus d'acquisition des données est suspendu jusqu'à ce que toutes les données puissent être écrites dans le processus de destination qui le suit et d'autre part l'exécution du processus de destination est suspendue tant que toutes les données provenant de la source ne sont pas disponibles. Un interblocage peut alors se produire, chacun des processus pouvant attendre l'autre indéfiniment.
Pour des raisons de performance car les processus sont le plus souvent non-synchrones, les interfaces de programmation qui implémentent ces mécanismes utilisent des tampons FIFO plus ou moins gros. La taille est paramétrable sous UNIX. Ce phénomène se rencontre par exemple au cours d'une compression en format MP3 sur disque dur d'un fichier musical lu sur un CD. Le mécanisme de lecture se fait par bloc et plus rapide que le mécanisme de compression, de ce fait cela permettra, si le tampon est suffisant, de retirer le CD du lecteur avant que la compression soit finie.
Implémentation sous Unix
[modifier | modifier le code]Sous Unix, le tube est implémenté grâce aux appels systèmes pipe(), fork() et exec(). Comme un processus peut envoyer des informations plus rapidement que le suivant ne peut les lire, il existe un buffer géré par le noyau et associé au tube. Lorsque le buffer est plein, le processus qui invoque l'appel write() est bloqué jusqu'à ce qu'un processus lise le contenu du buffer. Sous Linux la taille du buffer est 65 536 octets.
Les tubes de Hartman
[modifier | modifier le code]Les tubes de Hartmann sont un port de ce concept pour les systèmes d'exploitation VM, Unix et MVS. Ces tubes sont plus complexes que les traditionnels tubes des shell UNIX, ils permettent la manipulation de tubes ayant plusieurs entrées et plusieurs sorties. La syntaxe liée à leur usage est assez complexe et les risques d'inter-blocages sont plus grands. Ces mises en œuvre sont très rarement utilisés dans les applications UNIX même si les noyaux le supporte. Certains shell UNIX les supportent via des descripteurs de fichier arbitraire. Leur usage est plus simple sur les systèmes d'exploitation d'IBM.
