Communication inter-processus

Les fichiers peuvent être utilisés pour échanger des données entre plusieurs processus concurrents. Les processus voulant envoyer des données écrivent dans un ou plusieurs fichiers à certaines positions ; les processus souhaitant recevoir ces données se positionnent à ces positions dans le (ou les) fichier(s) et les lisent. Ce type d'échange est possible entre des processus concurrents locaux en utilisant le système de fichiers local, ou des processus concurrents distants en utilisant un système de fichiers distribué, tel que NFS.

La mémoire principale d'un ordinateur peut aussi être utilisée pour échanger des données entre plusieurs processus concurrents. Suivant le type de processus, les mécanismes utilisés ne sont pas les mêmes :

• dans le cas de processus lourds (process en anglais), les espaces mémoires des processus ne sont pas partagés. On utilise alors un mécanisme de partage de mémoire, tel que les segments de mémoire partagée dans Unix ;
• dans le cas de processus légers (thread en anglais), l'espace mémoire des processus est partagé, la mémoire peut donc être utilisée directement.

Dans les deux cas, les échanges sont réalisés en plaçant les données en mémoire dans des variables partagées par les processus.

Quelle que soit la méthode utilisée pour échanger les données (fichiers ou mémoire principale), ce type de communication pose le problème des sections critiques : le moment où les processus accèdent aux données partagées. En effet, si deux processus accèdent en même temps à une donnée commune, il peut se produire différents résultats :

• les données ne sont plus cohérentes ;
• un ou plusieurs des processus concernés « plantent » ;
• un ou plusieurs des processus est interrompu : il(s) doit (ou doivent) attendre que la donnée commune soit libérée.

En utilisant des fichiers, on tombe généralement sur le deuxième ou le troisième cas. Si on le prévoit, le processus peut attendre (10 millisecondes, 1 seconde, etc.) et reprendre plus tard l'accès aux données. Cela dit, cette solution n'est pas toujours possible en réseau, car les fichiers ne sont pas toujours libérés correctement.

En utilisant la mémoire principale, on tombe plutôt sur le premier cas. Si on le prévoit, le processus peut effectuer des synchronisations par lectures/écritures exclusives. Dans tous les cas, le partage de données en mémoire n'est possible que sur un seul et même ordinateur.

Les mécanismes de synchronisation sont utilisés pour résoudre les problèmes de sections critiques et plus généralement pour bloquer et débloquer des processus suivant certaines conditions.

Les verrous permettent de bloquer tout ou une partie d'un fichier. Ces blocages peuvent être réalisés soit pour les opérations de lecture, soit d'écriture, soit pour les deux.

Les sémaphores sont un mécanisme plus général, ils ne sont pas associés à un type particulier de ressource et permettent de limiter l'accès concurrent à une section critique à un certain nombre de processus. Pour ce faire les sémaphores utilisent deux fonctions : P et V, et un compteur. La fonction P décrémente le compteur, si le compteur est nul le processus est bloqué. La fonction V incrémente le compteur et débloque l'un des processus bloqués.

Les signaux sont à l'origine destinés à tuer (terminer) un processus dans certaines conditions, par exemple le signal SIGSEGV tue un processus qui effectue un accès à une zone de mémoire qu'il n'a pas allouée. Les signaux peuvent cependant être déroutés vers d'autres fonctions. Le blocage d'un processus se fait alors en demandant l'attente de l'arrivée d'un signal et le déblocage consiste à envoyer un message au processus.

Le problème des mécanismes de synchronisation est que les processus ne sont bloqués que s'ils les utilisent. De plus, leur utilisation est difficile et entraine des problèmes d'interblocage (tous les processus sont bloqués).

Il existe des situations usuelles de synchronisation lors de coopération inter-processus :

• exclusion mutuelle : ressource accessible par un seul processus à la fois. Exemple : carte bancaire, carte son.
• cohorte : ressource accessible par N processus à la fois. Exemple : parking pouvant accueillir 500 voitures.
• rendez-vous : ressource accessible après l'attente de plusieurs processus. Exemple : Roméo & Juliette, processus devant échanger des informations entre les étapes de l'algorithme.
• producteurs–consommateurs : ressource accessible après la fin d'un autre processus. Exemple : Formule 1 qui ne repart que lorsque les mécaniciens ont terminé, réception de données sur le réseau puis traitement.
• lecteurs–rédacteurs : ressource accessible par une seule catégorie de processus à la fois. Exemple : fichier pouvant être lu par plusieurs personnes si personne ne le modifie.

Ces mécanismes regroupent les possibilités des deux catégories précédentes et sont plus simples d'utilisation.

L'idée de ce type de mécanisme est de communiquer en utilisant le principe des files, les processus voulant envoyer des informations les placent dans la file ; ceux voulant les recevoir les récupèrent dans cette même file. Les opérations d'écriture et de lecture dans la file sont bloquantes et permettent donc la synchronisation.

Ce principe est utilisé par les files d'attente de message (message queue en anglais) sous Unix, par les sockets Unix ou Internet, par les tubes, nommés ou non, et par la transmission de messages (message passing en anglais).