Communication interprocessus

Les systèmes d'exploitation UNIX permettent de manipuler aisément les communications interprocessus dans les lignes de commandes :

int fork()

fork() est une fonction très utile qui permet, à partir d’un processus (père), de créer un deuxième processus identique (fils).

• En cas de succès, fork() va renvoyer 0 au processus fils et le pid du processus fils au père.
• En cas d’erreur, aucun fils n’est créé et fork() renvoie -1.

#include <stdio.h>
#include <unistd.h>
int main(void)
{
	int pid ;
	printf("Création d'un processus fils\n") ;
	pid = fork() ; // Création de la copie du processus courant(fils)
	if (pid < 0) 
	{ // Si fork() a échoué
		printf("Erreur : fork() !\n") ;
		return -1 ;
	}
	if (pid == 0) 
	{ // Si on est dans le processus fils ...
		printf("Je suis le fils\n");
	}
	else
	{ // Si on est dans le père
		printf("Je suis le père\n");
	}
	return 0 ;
}

Autres exemples de communications interprocessus, l'utilisation du pipe :

$ ps -ef | grep rlogin | awk '{ printf ("%-8s  %s\n", $1, $2) }' | sort

$ cat file1 file2 file3 | sort > /dev/lp &

Les fichiers file1, file2, et file3 sont passés en argument à la commande cat. Le résultat de cette concaténation est envoyé via un pipe ( l'opérateur | ) à la commande sort qui trie selon l'ordre alphabétique les lignes du texte concaténé. L'opérateur de redirection renvoit le résultat dans un fichier lp. Sous UNIX, tout est fichier, et lp représente l'imprimante, /dev étan le répertoire par défaut des fichiers spéciaux figurant des périphériques.

Le fait de faire suivre la commande par l'opérateur & permet de signaler au shell qu'il ne doit pas attendre la fin du traitement pour rendre la main au prompt. Le job est alors effectué en arrière plan, permettant à l'utilisateur de continuer son travail.

Les deux processus (cat et grep) utilisent comme moyen de communication le pipe qui simule un fichier dans lequel un process peut écrire et l'autre peut lire. Les processus partagent donc des données d'entrées/sorties (IO pour Input/Output), dont il faudra gérer les accès.

Les situations où plusieurs processus accèdent en lecture/écriture à des données partagées en fonction de l'ordre des processus se nomment les accès concurents, ou race conditions.

Parallélisme

La programmation parallèle permet l'exécution simultanée de plusieurs programmes qui coopèrent pour réaliser une tàche commune, ou qui entrent en compétition pour la possession de ressources.

Nous pouvons considérer le parallélisme sous trois aspects :

• une machine partage son temps processeur entre chaque programme, ce qui donne l'impression à l'utilisateur qu'il s'agit de parallélisme (en réalité, le processeur ne sait effectuer qu'une et une seule tàche en même temps, mais nous avons bien une rotation entre les temps CPU pour les différents programmes).
• une machine multiprocesseurs. La situation optimale suggérant que chaque processeur traite un programme, mais la réalité imposant que chaque processeur s'occupe d'un pool de processus.
• plusieurs machines interconnectées en réseau. Chaque machine possédant un ou plusieurs processeurs, appliquant les principes ci dessus.

Coopération et concurrence

Pour notre exemple, nous pouvons imaginer la situation suivante :

Sur un chantier, des manœuvres travaillent dans un même but : transporter du sable d'un endroit vers un autre.

Ils collaborent, ou coopèrent pour cette tàche.

Un d'eux se chargera de pelleter le sable dans la brouette, nous l'appellerons le chargeur de brouette.
Un second se chargera de transporter la brouette, nous lui donnons son permis de chauffeur de brouette.

Remarques :

Si nous détachons un autre manœuvre avec sa brouette, ils entreront en concurrence pour la possession d'une ressource : le sable.

Nous pouvons remarquer certaines instructions d'attente qui permettent de synchroniser les processus.
Par exemple, le chargeur de brouette doit attendre que la ressource brouette soit disponible pour effectuer son travail de chargement.

Exclusions mutuelles

Dans le cadre de la communication interprocessus,

• Une ressource est soit locale (un processus est le seul à l'utiliser), ou commune (elle ne peut donc être locale à aucun processus).
• Une ressource commune est partageable pour un nombre de points d'entrées n >= 1 si elle peut être attribuée simultanément à n processus.
• Une ressource commune partageable pour un seul point d'entrée est dite d'exclusion mutuelle, ou ressource critique.

La plupart du temps les processus effectuent des traitements qui ne mènent pas à des situations suceptibles de générer des conflits d'accès. Seules certaines portions de notre code feront appel à des ressources partagées. Une séquence d'instructions qui utilise des ressources en exclusion mutuelle est une section critique. Nous devrons donc traiter les cas pour lesquels plus d'un processus devrait entrer dans la section critique en même temps.

Conditions d'exclusion mutuelle

• Exclusion : un processus maximum peut se trouver en section critique en un moment t.
• Accès : Si des processus entre en concurrence pour une section critique et que cette dernière est libre, un de ceux qui demandent l'accès doit entrer dans cette section au bout d'un certain laps de temps qui ne doit pas être trop élevé.
• Indépendance : le blocage d'une section critique ne doit pas entraîner le blocage des autres sections critiques. En général, les sections critiques seront dépendantes chacune d'une ressource : un processus bloqué en attente de l'imprimante ne doit pas bloquer un processus qui demande à écrire sur la disquette.

Voyons maintenant comment résoudre les problèmes liés à l'exclusion mutuelle...

Structure du document