Gestion de Processus

Ce laboratoire porte sur la gestion des processus en programmation système sous Unix/Linux. Il permet de comprendre le fonctionnement de l'appel système fork(), la création de processus fils, la gestion des identifiants de processus (pid), ainsi que la synchronisation entre processus parent et fils via wait(). Les exercices couvrent l'analyse de programmes simples, la génération de suites numériques dans un processus fils, la compréhension des arborescences de processus, et la prévention des processus orphelins ou zombies. Pour réaliser ce TP, il est nécessaire d'avoir un environnement de développement C avec un compilateur compatible POSIX et un système supportant les appels fork() et wait().

Objectifs

• Comprendre le comportement de l'appel système fork() et ses retours dans le processus parent et fils.
• Identifier les valeurs des pid dans différents contextes d'exécution.
• Écrire un programme utilisant fork() pour générer la suite de Fibonacci dans un processus fils.
• Analyser et représenter l'arborescence des processus créés par des appels fork() imbriqués.
• Reconnaître et éviter la création de processus orphelins et zombies.
• Interpréter les différentes sorties possibles d'un programme concurrent avec plusieurs forks.

Prérequis et installation

• Connaissances de base en programmation C.
• Compréhension des concepts de processus, pid, et appels système fork() et wait().
• Environnement Unix/Linux avec un compilateur gcc ou équivalent.
• Accès à un terminal pour compiler et exécuter les programmes.

Exercice 1 : Identification des pid dans un programme avec fork()

Ce premier exercice consiste à analyser un programme C simple qui crée un processus fils avec fork(). L'objectif est d'identifier les valeurs des pid affichées aux lignes marquées A, B, C, et D, en supposant que le pid du parent est 2600 et celui du fils 2603.

Programme :

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>

int main()
{
    pid_t pid, pid1;

    /* fork a child process */
    pid = fork();

    if (pid < 0) { /* error occurred */
        fprintf(stderr, "Fork Failed");
        return 1;
    }
    else if (pid == 0) { /* Child Process */
        pid1 = getpid();
        printf("child: pid = %d", pid); /* A */
        printf("child: pid1 = %d", pid1); /* B */
    }
    else { /* parent process */
        pid1 = getpid();
        printf("parent: pid = %d", pid); /* C */
        printf("parent: pid1 = %d", pid1); /* D */
        wait(NULL);
    }
    return 0;
}

Ce qu'il faut faire :

• Compiler et exécuter le programme.
• Observer les valeurs affichées aux lignes A, B, C, et D.
• Comparer avec les valeurs supposées : parent pid = 2600, fils pid = 2603.

Pourquoi cette étape : Elle permet de comprendre comment fork() retourne différentes valeurs dans le processus parent (pid du fils) et dans le processus fils (0), et comment obtenir le pid courant avec getpid().

Résultat attendu :

• Ligne A (dans le fils) : pid = 0
• Ligne B (dans le fils) : pid1 = 2603 (pid du fils)
• Ligne C (dans le parent) : pid = 2603 (pid du fils)
• Ligne D (dans le parent) : pid1 = 2600 (pid du parent)

Exercice 2 : Génération de la suite de Fibonacci dans un processus fils

Dans cet exercice, vous devez écrire un programme C qui utilise fork() pour créer un processus fils qui calcule et affiche la suite de Fibonacci jusqu'à un nombre donné en argument de la ligne de commande.

Instructions :

• Le processus fils calcule la suite de Fibonacci et affiche les n premiers nombres.
• Le processus parent attend la fin du fils avec wait() avant de terminer.
• Contrôlez que le nombre passé en argument est un entier non négatif.

Pourquoi cette étape : Elle permet de pratiquer la création de processus, la gestion des arguments en ligne de commande, et la synchronisation entre processus.

Exemple d'exécution :

./fibonacci 5
0 1 1 2 3

Ce qu'il faut faire :

• Écrire le programme en C selon les consignes.
• Compiler et exécuter avec différents arguments.
• Vérifier que la sortie correspond bien à la suite de Fibonacci.

Exercice 3 : Analyse du nombre de processus créés et de leur arborescence

Le programme suivant crée plusieurs processus via des appels fork() imbriqués :

#include <unistd.h>

int main(void)
{
    fork() && (fork() || fork());
    sleep(2);
    return 0;
}

Ce qu'il faut faire :

• Déterminer combien de processus sont créés à l'exécution.
• Représenter l'arborescence des processus engendrés.

Pourquoi cette étape : Elle permet de comprendre les effets combinés de plusieurs appels fork() et les opérateurs logiques sur la création de processus.

Conseil : Analyser chaque appel fork() et son retour dans chaque processus pour déduire le nombre total de processus.

Exercice 4 : Analyse et modification d'un programme avec boucle fork()

Le programme suivant crée des processus dans une boucle while avec fork() :

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

int main()
{
    int i = 0;
    while (fork() != 0 && i < 2)
        i = i + 1;
    printf("Processus %d termine avec i=%d\n", getpid(), i);
    return 0;
}

Questions à traiter :

1. Donner l'arborescence des processus engendrés par ce programme.
2. Donner la valeur de i affichée par chacun des processus.
3. Identifier si des processus orphelins ou zombies peuvent apparaître, justifier et expliquer comment vérifier leur présence.
4. Modifier le code pour :
• Éviter la présence éventuelle d’orphelins et zombies.
• Créer une arborescence spécifique où PP est le processus principal (schéma fourni dans le document source, non reproduit ici).

Pourquoi cette étape : Elle permet de comprendre les conséquences des forks dans une boucle, la gestion des processus zombies et orphelins, et les techniques pour les éviter.

Exercice 5 : Analyse des sorties possibles d'un programme concurrent

Deux programmes C sont présentés (images non reproduites ici). On suppose que tous les appels printf() sont immédiatement flushés vers stdout et que les fonctions ne retournent pas d'erreur.

Partie I : Pour plusieurs combinaisons d'ordres d'affichage (exemple : 513242, 324251, etc.), il faut indiquer si elles sont possibles en sortie du programme.

Partie II : Il faut énumérer toutes les sorties possibles du second programme.

Ce qu'il faut faire :

• Analyser la logique des appels fork() et printf() dans chaque programme.
• Déduire les ordres possibles d'exécution et d'affichage.
• Répondre aux questions en cochant Oui ou Non pour chaque combinaison.

Résultats attendus

• Exercice 1 : Compréhension claire des valeurs retournées par fork() et des pid affichés.
• Exercice 2 : Programme fonctionnel affichant la suite de Fibonacci correcte dans le processus fils.
• Exercice 3 : Nombre exact de processus créés et arborescence correcte.
• Exercice 4 : Arborescence des processus, valeurs de i correctes, et code modifié évitant orphelins et zombies.
• Exercice 5 : Réponses précises sur la possibilité des différentes sorties et énumération complète des sorties possibles.

Pièges courants

• Confondre la valeur retournée par fork() dans le parent (pid du fils) et dans le fils (0).
• Ne pas utiliser wait() dans le parent, ce qui peut entraîner des processus zombies.
• Passer un argument négatif ou non numérique à l'exercice Fibonacci sans contrôle d'erreur.
• Mal interpréter les opérateurs logiques dans l'exercice 3, ce qui fausse le calcul du nombre de processus.
• Oublier d'incrémenter la variable i dans la boucle fork() de l'exercice 4, ou ne pas gérer la terminaison des processus.
• Ignorer le flush automatique de printf(), ce qui peut fausser l'ordre d'affichage dans l'exercice 5.