Communication Interprocessus (IPC)

Notion de Parallélisme et d'Exécution Concurrente

  • Capacités des systèmes d'exploitation modernes :

    • La majorité des systèmes d'exploitation actuels intègrent des mécanismes évolués permettant d'assurer le parallélisme matériel et logiciel.

    • Plusieurs tâches sont créées et chargées simultanément en mémoire centrale pour être exécutées en même temps.

  • Distinction entre parallélisme réel et pseudo-parallélisme :

    • Parallélisme réel : survient lorsque la machine dispose de plusieurs cœurs de calcul (Cores). Dans cette configuration matérielle, chaque tâche distincte est allouée et exécutée simultanément sur un cœur physique dédié.

    • Pseudo-parallélisme (concurrence) : survient lorsque la machine ne dispose que d'un unique cœur de processeur. Les tâches ne tournent pas de manière physiquement simultanée ; elles sont exécutées en concurrence via des mécanismes de commutation de contexte (context switching) et d'ordonnancement temporel, créant l'illusion d'une simultanéité.

  • Terminologie associée au parallélisme :

    • Multiprogrammation : gestion de plusieurs programmes résidant en mémoire centrale pour maximiser l'utilisation du processeur.

    • Multitâche : capacité du système d'exploitation à exécuter ou basculer rapidement entre plusieurs processus applicatifs.

    • Multithreading : décomposition d'un même processus en plusieurs flux d'exécution légers (threads ou fils d'exécution) partageant le même espace mémoire.

  • Interdépendance et coopération des processus :

    • Dans la majorité des cas, les processus en cours d'exécution ne sont pas totalement isolés ou indépendants.

    • Ils doivent collaborer activement en établissant des canaux de communication, en partageant des données et en coordonnant leur progression via des mécanismes de synchronisation.

    • Exemple de dépendance : un processus donné peut être contraint d'attendre la terminaison complète ou la fourniture de données d'un autre processus avant de pouvoir démarrer ou poursuivre sa propre séquence d'exécution.

Fondements de la Communication Interprocessus (IPC)

  • Typologie des processus au sein d'un environnement multitâche :

    • Processus indépendants :

    • L'exécution d'un processus n'exerce aucune influence directe ou indirecte sur l'exécution des autres processus du système.

    • Absence totale d'interaction, de partage d'état ou de transfert de données entre ces entités.

    • Processus coopérants :

    • L'exécution d'un processus affecte directement ou se trouve affectée par l'exécution d'autres processus.

    • Les objectifs fondamentaux de la coopération interprocessus résident dans l'accélération de la vitesse globale de calcul (parallélisation de sous-tâches) et l'amélioration de la modularité logicielle (découpage en composants spécialisés).

  • Définition et rôle des mécanismes IPC (InterProcess Communication) :

    • Les systèmes d'exploitation multitâches fournissent un ensemble standardisé d'outils et d'abstractions de bas niveau assurant la communication et la synchronisation sécurisées entre processus.

    • Cet ensemble d'interfaces de programmation et de structures système est regroupé sous l'acronyme IPC.

  • Panorama des principaux mécanismes d'IPC :

    • Les Tubes (Pipes) : permettent l'établissement d'une communication unidirectionnelle en flux continu entre deux processus.

    • Le Passage de messages (Message Queues) : offre un canal où deux ou plusieurs processus échangent des messages discrets et structurés déposés dans une file d'attente système.

    • Les Signaux : fournissent un moyen d'envoyer des notifications asynchrones d'événements entre plusieurs processus.

    • La Mémoire partagée (Shared Memory) : consiste à réserver une zone d'adressage mémoire spécifique accessible simultanément en lecture et en écriture par plusieurs processus distincts.

    • Les Sockets : constituent un mécanisme de communication universel, indispensable et prédominant pour les échanges locaux et réseaux distribués.

Les Tubes Anonymes (Pipes)

  • Concept et caractéristiques intrinsèques :

    • Un pipe (ou tube anonyme) est un canal de communication logique se comportant comme un tuyau permettant à deux processus présentant un lien de parenté (typiquement un processus père et son fils) d'échanger des données.

    • La transmission des informations au sein d'un tube est strictement unidirectionnelle (semi-duplex).

    • Au niveau du noyau, le tube est matérialisé sous la forme d'un fichier temporaire partagé en mémoire, dépourvu de nom sur le système de fichiers classique, manipulable à l'aide de deux descripteurs de fichiers :

    • Un premier descripteur dédié exclusivement à la lecture des données (pour le processus récepteur).

    • Un second descripteur dédié exclusivement à l'écriture des données (pour le processus émetteur).

    • L'un des processus adopte le rôle d'écrivain (ou rédacteur) et injecte le flux d'octets dans le tube, tandis que l'autre joue le rôle de lecteur et consomme ce flux.

Schéma de fonctionnement d'un tube anonyme (pipe) entre processus
  • Primitives et prototypes système en langage C (<unistd.h>) :

    • Création d'un tube :

    • int pipe(int fds[2]);

    • L'argument fds est un tableau de deux entiers alloué par l'utilisateur pour recevoir les descripteurs générés par le noyau :

      • fds[0] est assigné aux opérations de lecture.

      • fds[1] est assigné aux opérations d'écriture.

    • La fonction retourne la valeur 00 en cas de succès et −1-1 en cas d'erreur de création.

    • Lecture dans le tube :

    • int read(int fds[0], void *buf, int nb_car);

    • Paramètres :

      • fds[0] : descripteur d'ouverture en lecture.

      • buf : pointeur vers le tampon mémoire (buffer) destiné à accueillir les données lues.

      • nb_car : nombre maximal d'octets ou de caractères à extraire.

    • Valeur de retour : entier indiquant le nombre réel de caractères ou octets effectivement lus.

    • Écriture dans le tube :

    • int write(int fds[1], void *buf, int nb_car);

    • Paramètres :

      • fds[1] : descripteur d'ouverture en écriture.

      • buf : pointeur vers le tampon mémoire contenant les données à transmettre.

      • nb_car : nombre d'octets ou de caractères à transférer.

    • Valeur de retour : entier représentant le nombre de caractères ou octets effectivement écrits.

    • Fermeture des descripteurs :

    • int close(int fds[0]); (fermeture de l'extrémité de lecture).

    • int close(int fds[1]); (fermeture de l'extrémité d'écriture).

  • Règles impératives de manipulation des descripteurs :

    • Principe directeur : toujours fermer les extrémités inutilisées du tube avant de procéder à une opération de lecture ou d'écriture, puis fermer l'extrémité utilisée immédiatement après la fin du transfert.

    • Règle du lecteur :

    • Avant de lire dans le tube, le processus doit fermer son descripteur d'écriture (fds[1]).

    • Après avoir achevé la lecture des données, il doit impérativement fermer son descripteur de lecture (fds[0]).

    • Règle du rédacteur (écrivain) :

    • Avant d'écrire dans le tube, le processus doit fermer son descripteur de lecture (fds[0]).

    • Après avoir achevé l'écriture de ses informations, il doit fermer son descripteur d'écriture (fds[1]).

  • Mise en pratique : Échange de données entre père et fils :

    • Objectif de l'exercice : concevoir un programme en C créant deux processus (père et enfant) via fork(). Le premier saisit une valeur entière au clavier, la transmet à travers un tube, et le second lit cette valeur pour calculer et afficher son carré.

    • Implémentation complète :

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main() {
    int desc[2];
    int nombre = 0;
    char buff[3];
    pid_t pid;

    if (pipe(desc) == -1) {
        printf("Erreur de creation de pipe
");
        exit(1);
    } else {
        pid = fork();
        if (pid < 0) {
            printf("erreur de fork
");
            exit(1);
        } else {
            if (pid == 0) {
                // Code exécuté par le processus fils
                printf("Donnez un nombre : ");
                scanf("%d", &nombre);
                close(desc[0]); // Fermeture de l'extrémité de lecture
                printf("le nombre est %d
", nombre);
                write(desc[1], &nombre, sizeof(nombre)); // Écriture dans le tube
                close(desc[1]); // Fermeture après écriture
            } else {
                // Code exécuté par le processus père
                close(desc[1]); // Fermeture de l'extrémité d'écriture
                read(desc[0], &nombre, sizeof(nombre)); // Lecture bloquante
                close(desc[0]); // Fermeture après lecture
                printf("le carre du nombre est %d
", nombre * nombre);
            }
        }
    }
    return 0;
}

Files de Messages (Message Queues)

  • Principes généraux et avantages structurels :

    • Les files de messages permettent à plusieurs processus de s'échanger des paquets de données sous la forme de messages formellement structurés.

    • Contrairement aux tubes anonymes qui imposent généralement un lien de filiation direct (père/fils), les files de messages permettent la communication entre des processus totalement indépendants et arbitraires.

    • Communication asynchrone : les processus émetteurs et récepteurs n'ont pas l'obligation d'être synchronisés temporellement. Un processus émetteur peut déposer un message et poursuivre son exécution sans attendre que le récepteur ne le consomme.

    • Chaque message est organisé selon un type de données défini et stocké dans une file gérée au niveau de l'espace noyau.

Architecture d'une file de messages (Message Queue) entre deux processus
  • Protocole méthodologique d'utilisation des files de messages :

    1. Définir la structure de données formelle décrivant le message.

    2. Générer une clé IPC unique servant d'identifiant système global.

    3. Créer ou ouvrir la file de messages via l'API système.

    4. Manipuler la file (opérations d'émission msgsnd et de réception msgrcv).

    5. Détruire explicitement la file de messages pour libérer l'espace mémoire alloué par le noyau.

  • Étape 1 : Définition de la structure de message en C :

    • Tout message échangé doit obligatoirement commencer par un champ de type entier long positif (long msg_type) représentant le type ou la catégorie du message.

    • Ce champ est directement interprété par le système pour effectuer le tri, le filtrage et la sélection des messages (commandes, réponses, alertes, etc.).

    • Modèle structurel standard :

typedef struct {
    long msg_type; // Type obligatoire identifiant la catégorie du message
    // ... champs de données utilisateur additionnels (entiers, chaînes, etc.)
} Message;
  • Étape 2 : Génération de l'identificateur unique (Clé IPC) :

    • Chaque file est identifiée de manière univoque par une clé de type key_t.

    • Génération déterministe et unique : la fonction ftok() dérive une clé à partir des métadonnées (inode, périphérique) d'un fichier existant sur le disque et d'un nombre entier arbitraire :

    • key_t ftok(const char *ref, int numero);

    • ref : chemin d'accès pointant vers un fichier réel existant sur le disque.

    • numero : entier arbitraire (code projet sur un octet).

    • Exemple d'initialisation :

#include <sys/msg.h>
#include <stdio.h>

FILE *f = fopen("monFichier", "w"); // S'assurer de l'existence du fichier
fclose(f);
key_t cle = ftok("monFichier", 100);
  • Attribution manuelle directe : il est techniquement possible d'assigner une valeur brute arbitraire (key_t cle = 1234;), mais cette pratique n'apporte aucune garantie d'unicité au sein du système d'exploitation et peut induire des collisions.

    • Étape 3 : Création et ouverture de la file (msgget) :

  • L'initialisation ou la récupération de la file s'effectue via l'appel système :

    • int msgget(key_t cle, int options);

  • Paramètres :

    • cle : clé IPC générée au préalable.

    • options : masques de création et droits d'accès UNIX (typiquement 0666 | IPC_CREAT).

      • IPC_CREAT : ordonne la création de la file si elle n'existe pas encore.

      • 0666 : octroie les permissions de lecture et d'écriture à tous les utilisateurs.

  • Comportement et valeur de retour :

    • Le premier processus à invoquer l'instruction crée la ressource dans le noyau.

    • Les processus ultérieurs invoquant la même clé récupèrent l'identifiant numérique interne (msgid) de cette file existante.

    • Retourne l'identifiant msgid en cas de succès, ou −1-1 en cas d'échec.

    • Étape 4 : Utilisation de la file (Émission et Réception) :

  • 4.1. Envoi d'un message (msgsnd) :

    • Prototype : int msgsnd(int msgid, const void *p, int taille, int options);

    • msgid : identifiant de file obtenu via msgget().

    • p : pointeur vers la structure du message à expédier.

    • taille : taille en octets du contenu utile des données, excluant impérativement la taille du champ initial msg_type (soit sizeof(struct) - sizeof(long)).

    • options : drapeau de contrôle. Positionné à 00, l'appel bloque le processus émetteur si la file est saturée. L'utilisation du drapeau IPC_NOWAIT rend l'appel non bloquant.

    • Exemple d'envoi textuel :

struct message {
    long type;        // Type du message (obligatoire)
    char texte[100];  // Contenu textuel
} msg;

msg.type = 1;
strcpy(msg.texte, "Bonjour");
msgsnd(msgid, &msg, sizeof(msg.texte), 0); // Émission bloquante si file pleine
  • 4.2. Réception d'un message (msgrcv) :

    • Prototype : int msgrcv(int msgid, void *p, int taille, long type, int options);

    • msgid : identifiant de la file concernée.

    • p : pointeur vers la zone mémoire devant accueillir la structure du message lu.

    • taille : taille maximale des données attendues (hors champ type).

    • type : valeur du type de message recherché :

    • Si type == 0 : le premier message disponible dans la file est extrait (comportement FIFO pur).

    • Si type > 0 : le premier message possédant exactement cette valeur de type est extrait.

    • options : drapeau fixé à 00 pour rendre l'appel bloquant tant qu'aucun message correspondant n'est présent.

    • Exemple de réception :

struct message recu;
msgrcv(msgid, &recu, sizeof(recu.texte), 1, 0); // Récupère un message de type 1
printf("Message reçu : %s
", recu.texte);
  • Étape 5 : Destruction de la file (msgctl) :

    • Prototype : int msgctl(int msgid, int cmd, struct msqid_ds *buf);

    • Commande de suppression : msgctl(msgid, IPC_RMID, NULL); (ou msgctl(msgid, IPC_RMID, 0);).

    • Persistance du noyau : si la file n'est pas expressément détruite par l'un des processus, elle reste résidente dans la mémoire du noyau Linux même après la terminaison complète des programmes applicatifs.

  • Mise en pratique : Architecture Client / Serveur avec arrêt sur zéros :

    • Cahier des charges : le client lit deux entiers saisis au clavier et les envoie au serveur via une file de messages. Le serveur calcule leur somme et l'affiche à l'écran. L'ensemble s'interrompt lorsque les deux nombres saisis sont nuls (x=0x = 0 et y=0y = 0).

    • Code source du Client :

#include <stdio.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <stdlib.h>

typedef struct {
    long msg_type;
    int x;
    int y;
} requette;

int main() {
    int x, y;
    key_t cle;
    requette req;
    int msgid;

    cle = ftok("monFichier", 100);
    msgid = msgget(cle, 0666 | IPC_CREAT);

    while (1) {
        printf("Donnez deux nombres : ");
        scanf("%d %d", &x, &y);
        req.x = x;
        req.y = y;
        req.msg_type = 1;
        // Envoi en excluant les 4 octets du type long (sizeof(req) - 4)
        msgsnd(msgid, (requette *)&req, sizeof(req) - 4, 0);
        if ((x == 0) && (y == 0)) {
            break;
        }
    }
    msgctl(msgid, IPC_RMID, 0); // Demande de destruction de la file
    return 0;
}
  • Code source du Serveur :

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
#include <unistd.h>

typedef struct {
    long msg_type;
    int x;
    int y;
} requette;

int main() {
    int x, y, z;
    key_t cle;
    requette req;
    int msgid;

    cle = ftok("monFichier", 100);
    msgid = msgget(cle, 0666 | IPC_CREAT);

    while (1) {
        msgid = msgget(cle, 0666 | IPC_CREAT);
        msgrcv(msgid, (requette *)&req, sizeof(requette), 1, 0);
        x = req.x;
        y = req.y;
        z = x + y;
        printf("%d
", z);
        if (z == 0) {
            break;
        }
        sleep(1);
    }
    msgctl(msgid, IPC_RMID, 0); // Destruction finale de la file
    return 0;
}

La Mémoire Partagée (Shared Memory)

  • Principes de fonctionnement et protection mémoire :

    • Dans l'architecture standard des systèmes d'exploitation, l'espace d'adressage virtuel de chaque processus est strictement isolé et protégé des autres.

    • Si un processus tente d'accéder sans droit à la mémoire d'un autre processus, le contrôleur matériel et le système déclenchent une violation de protection mémoire (segmentation fault), provoquant l'arrêt brutal immédiat du processus fautif.

    • La mémoire partagée contourne cette barrière en permettant à deux ou plusieurs processus de mapper une même zone de mémoire physique directement dans leurs espaces virtuels respectifs.

    • Il s'agit du mécanisme d'IPC le plus rapide car l'échange de données ne requiert aucune copie intermédiaire vers l'espace noyau.

Organisation des espaces d'adressage virtuels et mapping d'un segment de mémoire partagée
  • Cycle de vie d'un segment de mémoire partagée :

    1. Générer une clé d'identification unique pour le segment via ftok() ou valeur entière.

    2. Allouer et créer le segment de mémoire partagée dans le système via shmget().

    3. Attacher le segment créé à l'espace d'adressage local du processus appelant via shmat().

    4. Manipuler la mémoire partagée via un pointeur natif en C (comme une variable standard).

    5. Détacher le segment de l'espace d'adressage virtuel après utilisation via shmdt().

    6. Supprimer définitivement le segment de la table mémoire du noyau via shmctl().

  • Détail des primitives C (<sys/ipc.h>, <sys/shm.h>, <sys/types.h>) :

    • 1. Génération de l'identificateur :

    • Utilisation analogue aux files de messages :

      • key_t token = ftok("fichierQuelconque", 100);

      • Ou assignation directe : key_t token = 4321;

    • 2. Création du segment (shmget) :

    • int shmget(key_t cle, int taille, int options);

    • Paramètres :

      • cle : clé IPC obtenue à l'étape préalable.

      • taille : dimension en octets du segment à allouer en mémoire.

      • options : drapeaux d'accès (ex. 0666 | IPC_CREAT).

    • Valeur de retour : identifiant numérique du segment (segid ou shmid), ou −1-1 en cas d'erreur.

    • 3. Attachement au processus (shmat) :

    • void *shmat(int shmid, const void *adr, int options);

    • Paramètres :

      • shmid : identifiant retourné par shmget().

      • adr : adresse virtuelle souhaitée pour attacher le segment. La valeur 00 (ou NULL) est transmise afin de laisser le système d'exploitation déterminer automatiquement l'adresse optimale.

      • options : permissions d'accès au segment (la valeur 00 configure l'accès en lecture et écriture r/w).

    • Valeur de retour : pointeur générique void* vers la zone mémoire partagée, à transtyper selon la structure des données.

    • 4. Détachement du segment (shmdt) :

    • int shmdt(void *shmadr);

    • Paramètre : shmadr correspond à l'adresse de base du pointeur retourné antérieurement par shmat().

    • 5. Destruction du segment (shmctl) :

    • int shmctl(int shmid, int cmd, struct shmid_ds *p);

    • Paramètres pour la destruction :

      • shmid : identifiant du segment.

      • cmd : opération à effectuer, positionnée à IPC_RMID.

      • p : structure de configuration, fixée à NULL pour une libération standard.

  • Mise en pratique : Incrémentation concurrente d'une variable partagée :

    • Cahier des charges : deux processus concurrents collaborent pour incrémenter une variable entière partagée initialisée à 00 jusqu'à ce qu'elle dépasse le seuil de 100100 :

    • Process_1 incrémente la variable de +1+1 toutes les secondes (1 s1\,\text{s}).

    • Process_2 incrémente la variable de +10+10 toutes les cinq secondes (5 s5\,\text{s}).

    • Code source de Process_1 :

#include <stdio.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>

int main() {
    key_t cle;
    int *nombre;
    int segid;

    cle = ftok("monSegment", 100);
    segid = shmget(cle, 16, 0666 | IPC_CREAT);
    nombre = (int *)shmat(segid, 0, 0);

    *nombre = 0; // Initialisation du compteur partagé

    while (1) {
        *nombre = *nombre + 1;
        printf("%d
", *nombre);
        if (*nombre > 100) {
            break;
        }
        sleep(1);
    }

    shmdt(nombre); // Détachement du segment mémoire
    shmctl(segid, IPC_RMID, NULL); // Libération du segment
    return 0;
}
  • Code source de Process_2 :

#include <stdio.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>

int main() {
    key_t cle;
    int *nombre;
    int segid;

    cle = ftok("monSegment", 100);
    segid = shmget(cle, 16, 0666 | IPC_CREAT);
    nombre = (int *)shmat(segid, 0, 0);

    *nombre = 0; // Réinitialisation / synchronisation de la variable

    while (1) {
        *nombre = *nombre + 10;
        printf("%d
", *nombre);
        if (*nombre > 100) {
            break;
        }
        sleep(5);
    }

    shmdt(nombre); // Détachement de l'espace d'adressage
    shmctl(segid, IPC_RMID, NULL); // Destruction du segment mémoire
    return 0;
}