Processus. 1- Notion de processus 1.1- Rappel sur la chaîne de production d'un programme exécutable.

Processus Nous commençons à présent l'étude du fonctionnement d'un système multiprogrammé. Dans ce cours, nous nous intéressons à la fonction d'exécution : elle recouvre principalement deux notions : celle de processus,qui correspond à l'image d'un programme qui s'exécute et celle d'ordonnancement qui correspond au problème de l'allocation du processeur et donc du partage du processeur entre différents processus. 1- Notion de processus 1.1- Rappel sur la chaîne de production d'un programme exécutable. La chaîne de production de programme (figure 1) transforme un programme écrit dans un langage de haut niveau en un programme dit exécutable, écrit en langage machine. Cette transformation s'effectue à l'aide de plusieurs étapes : L'utilisateur saisit son programme à l'aide de l'éditeur de texte qui crée un fichier sur le disque que l'on appelle le fichier source. Ce fichier source est ensuite compilé à l'aide d'un compilateur dépendant du langage de programmation utilisé et dont le rôle est de vérifier que la syntaxe du langage est respectée et de générer alors l'équivalent du programme source en langage machine : on obtient alors sur disque le fichier objet. Ce fichier objet est ensuite soumis à l'éditeur de liens dont le rôle est de résoudre les références externes, c'est-à-dire par exemple, d'associer les appels système inclus dans le programme à leur adresse dans le système. L'éditeur de liens produit sur disque le fichier exécutable. Lorsque l'utilisateur demande l'exécution de son programme, le fichier exécutable est alors monté en mémoire centrale : c'est l'étape de chargement. Le système alloue de la place mémoire pour placer le code et les données du programme. Du programme au processus Editeur de texte prog.c source Compilateur cc -c prog.c prog.o objet Editeur de liens ld -o prog.o prog.exe Bibliothèques prog.exe exécutable en mémoire processus Chargeur prog.exe : programme exécutable sur disque

Fig 1 : Chaîne de production de programme Exemple sur Unix : Pour le système d'exploitation Unix, les étapes suivantes permettent de passer d'un fichier source à un processus saisie du fichier source avec un éditeur tel que vi : programme.c compilation et production du fichier programme.o : cc -c programme.c <return> édition des liens et production du fichier exécutable programme : ld -o programme programme.o <return> chargement et création du processus : programme <return> 2- L'exécution d'un programme La figure 2 représente l'exécution du programme à un niveau qui est celui de l'architecture matérielle de la machine. Le programme à exécuter est placé en mémoire centrale à partir de l'emplacement d'adresse 102. Le processeur a commencé l'exécution du programme : la première instruction de celui-ci a été chargée dans le registre instruction (RI) et le Compteur Ordinal (CO) contient l'adresse de la prochaine instruction à exécuter soit 103. Lorsque l'instruction courante aura été exécutée, le processeur chargera dans la registre RI l'instruction pointée par le CO, soit add Imm R1 5 et le compteur ordinal prendra la valeur 104. L'exécution de l'instruction add Imm R1 5 va modifier le contenu du registre PSW puisque c'est une instruction arithmétique : les flags de signe, de nullité etc sont mis à jour. On voit donc qu'à chaque étape d'exécution du programme, le contenu des registres du compteur ordinal évolue. De même le contenu de la mémoire centrale peut être modifié : écriture, lecture dans la pile (Push, Pop), modification des données par une instruction Store. On appelle processus l'image de l'état du processeur et de la mémoire au cours de l'exécution d'un programme. Le programme est statique et le processus représente la dynamique de son exécution. Lors de l'étape de chargement, le système alloue de la place mémoire pour placer le code et les données du programme et crée la pile d'exécution de ce qui est en train de devenir un processus. Il alloue alors une structure de donnée descriptive du processus destinée à regrouper toutes les informations du contexte du processus : le bloc de contrôle du processus. Le processus est alors créé. Il est prêt à s'exécuter.

Notion de processus CO RI 103 load imm R1 20 Ri UAL 100 101 102 103 104 105 load imm R1 20 add imm R1 5 store dir R1 15 Psw Rsp Mémoire UE CPU Bus externe Fig 2 : Exécution d'un programme 3- Le processus 3.1- Définition Processus Un processus est un programme en cours d exécution auquel est associé un environnement processeur (CO, PSW, RSP, registres généraux) et un environnement mémoire appelés contexte du processus. Un processus est l instance dynamique d un programme et incarne le fil d exécution de celui-ci dans un espace d'adressage protégé (objets propres : ensemble des instructions et données accessibles) Un programme réentrant est un programme pour lequel il peut exister plusieurs processus en même temps 3.2- Les états du processus Lors de son exécution, un processus est caractérisé par un état : - lorsque le processus obtient le processeur et s'exécute, il est dans l'état élu. L'état élu est l'état d'exécution du processus. - lors de cette exécution, le processus peut demander à accéder à une ressource (réalisation d'une entrée/sortie, accès à une variable protégée) qui n'est pas immédiatement disponible : le processus ne peut pas poursuivre son exécution tant qu'il n'a pas obtenu la ressource (par exemple, le processus doit attendre la fin de l'entrée/sortie qui lui délivre les données sur lesquelles il réalise les calculs suivants dans son code) : le processus quitte alors le processeur et passe dans l'état bloqué. L'état bloqué est l'état d'attente d'une ressource autre que le processeur.

- lorsque le processus a enfin obtenu la ressource qu'il attendait, celui-ci peut potentiellement reprendre son exécution. Cependant, nous nous sommes placés dans le cadre de systèmes multiprogrammés, c'est-à-dire qu'il y a plusieurs programmes en mémoire centrale et donc plusieurs processus.. Lorsque le processus est passé dans l'état bloqué, le processeur a été alloué à un autre processus. Le processeur n'est donc pas forcément libre. Le processus passe alors dans l'état prêt. L'état Prêt est l'état d'attente du processeur. - Le passage de l'état prêt vers l'état élu constitue l'opération d'élection. Le passage de l'état élu vers l'état bloqué est l'opération de blocage. Le passage de l'état bloqué vers l'état prêt est l'opération de déblocage. Un processus est toujours crée dans l'état prêt. Un processus se termine toujours à partir de l'état élu (sauf anomalie). Système multiprocessus Etats des processus Fin Réveil Prêt Election Elu En exécution En attente du processeur Blocage Déblocage Bloqué En attente de ressources Fig 3 : Etats d'un processus Exemple sous Unix La figure ci-dessous présente le graphe d'états simplifié pour un processus Unix. Un processus évolue entre trois modes au cours de son exécution : le mode utilisateur qui est le mode normal d'exécution, le mode noyau en mémoire qui est le mode dans lequel se trouve un processus prêt ou bloqué (endormi) et le mode swappé qui est le mode dans lequel se trouve un processus bloqué (endormi) déchargé de la mémoire centrale. En effet, le système Unix décharge de la mémoire centrale les processus endormis depuis trop longtemps (ils sont alors dans l'état Endormi swappé). Ces processus réintègrent la mémoire centrale lorsqu'ils redeviennent prêts (transition de l'état prêt swappé vers l'état prêt). Un processus qui se termine passe dans un état dit zombi. Il y reste tant que son PCB n'est pas entièrement démantelé par le système.

Processus Unix Rappels : Etats des processus (simplifie) Actif Utilisateur Mode Utilisateur Nouveau Prêt Actif Noyau Zombi Endormi Mode Noyau en mémoire Prêt swappe Endormi swappe Mode Swappe Etats d'un processus Unix (graphe simplifié) 3.3- Le bloc de contrôle du processus (PCB) Le bloc de contrôle d'un processus (PCB) contient les informations suivantes : - un identificateur unique du processus (un entier) : le PID - l'état courant du processus (élu, prêt, bloqué) - le contexte processeur du processus : la valeur du CO, la valeur des autres registres du processeur - le contexte mémoire : ce sont des informations mémoire qui permettent de trouver le code et les données du processus en mémoire centrale - des informations diverses de comptabilisation pour les statistiques sur les performances système - des informations liées à l'ordonnancement du processus. Le PCB permet la sauvegarde et la restauration du contexte mémoire et du contexte processeur lors des opérations de commutations de contexte.

bloc de contrôle de processus PCB identificateur processus état du processus compteur instructions contexte pour reprise (registres et pointeurs, piles,..) pointeurs sur file d' attente et priorité(ordonnancement) Bloc de contrôle de processus ou PCB informations mémoire (limites et tables pages/segments informations de comptabilisation et sur les E/S, périphériques alloués, fichiers ouverts,.. Fig 4 : Bloc de contrôle d'un processus Exemple sous Unix Nous prenons en exemple la structure du bloc de contrôle de processus dans le système d'exploitation Unix. Le bloc de contrôle du processus est divisé en deux parties : - chaque processus dispose d'une entrée dans une table générale du système, la table des processus. Cette entrée contient les informations sur le processus qui sont toujours utiles au système quel que soit l'état du processus : l'identificateur du processus (pid), l'état du processus, les informations d'ordonnancement, les informations mémoire, c'est-à-dire l'adresse des régions mémoire allouées au processus. - chaque processus dispose également d'une autre structure, la Zone U. Cette Zone U contient d'autres informations concernant le processus, mais ce sont des informations qui peuvent être temporairement "swappées" sur le disque.

Processus Unix Zone U Table des régions Table des régions par processus Mémoire principale Table des processus (pid, état, informations ordonnancement, informations mémoire) Bloc de contrôle d'un processus Unix 4- Processus Unix : création, vie et mort 4.1- Création d'un processus Unix La primitive FORK permet la création dynamique d'un nouveau processus qui s'exécute de manière concurrente avec le processus qui l'a créé. Tout processus Unix hormis le processus 0 est crée à l'aide de cette primitive. Le processus créateur (le père) par un appel à la primitive FORK crée un processus fils qui est une copie exacte de lui-même (code est données). Primitive FORK pid_t fork (void) : permet la création d'un processus Unix par duplication complète du créateur. Lors de l'exécution de l'appel système Fork, si les ressources noyaux sont disponibles, le système effectue les opérations suivantes : - le système alloue une entrée à la table des processus pour le nouveau processus - le système alloue un PID unique au nouveau processus - le système duplique le contexte du processus parent : le code, les données, et la pile - le système retourne au processus père le PID du processus crée et au nouveau processus (le fils) la valeur 0. Lors de cette création le processus fils hérite de tous les attributs de son père sauf : - l'identificateur de son père

- son propre identificateur - les temps d'exécution du nouveau processus sont à nuls. Notamment, le fils hérite de tous les descripteurs de fichiers ouverts par son père et partage donc ces fichiers avec lui. A l'issue de l'exécution de la primitive Fork, chaque processus, le père et le fils, reprend son exécution après le Fork. Le code et les données étant strictement identiques, il est nécessaire de disposer d'un mécanisme pour différencier le comportement des deux processus après le Fork. On utilise pour cela le code retour du Fork qui est différent chez le fils (toujours 0) et le père (PID du fils créé). Dans l'exemple de la figure ci-dessous, le processus n 12222 est le processus père. Le processus 12224 est le processus fils crée par le processus de 12222 à l'issue de l'appel à la primitive Fork. Une fois la primitive Fork exécutée par le père, les deux processus (le père et le fils) reprennent leur exécution de manière concurrente. Le processus fils a pour retour de la primitive Fork la valeur 0. Il va donc exécuter la partie de l'alternative pour laquelle (if pid = = 0) est vrai. Le processus père au contraire a pour retour de la primitive Fork la valeur du PID du processus créé c'est-à-dire une valeur positive. Il va donc exécuter l'autre partie de l'alternative. Dans cet exemple, la primitive GETPID retourne à un processus la valeur de son PID.. La primitive GETPPID retourne au processus le PID de son père. Exemple de création d'un processus avec la primitive Fork Primitive de création de processus PROCESSUS PID 12222 PROCESSUS PID 12224 Main () pid_t pid ; int i, j; for(i=0; i<8; i++) i = i + j; pid= fork(); if (pid == 0) printf(" je suis le fils ") else printf ("je suis le père"); printf ("pid de mon fils, %d", pid) Pid du fils : 12224 getpid : 12222 getppid :shell Main () pid_t pid ; int i, j; for(i=0; i<8; i++) i = i + j; pid= fork(); if (pid == 0) printf(" je suis le fils ") else printf ("je suis le père"); printf ("pid de mon fils, %d", pid) getpid : 12224 getppid :12222 4.2- Terminaison d'un processus Unix

Un appel à la primitive EXIT provoque la terminaison du processus effectuant l'appel avec un code retour valeur. Un processus qui se termine passe dans l'état zombi et reste dans cet état tant que son père n'a pas pris en compte sa terminaison. Primitive EXIT void exit (int valeur) : provoque la terminaison du processus appelant Lorsqu'un processus se termine, le système démantèle tout son contexte, sauf l'entrée de la table des processus le concernant. Le processus père, par un appel à la primitive WAIT, récupère la mort de son fils, cumule les statistiques de celui-ci avec les siennes et détruit l'entrée de la table des processus concernant son fils défunt. Le processus fils disparaît complètement. La communication entre le fils zombi et le père s'effectue par le biais d'un signal transmis du fils vers le père (signal SIGCHLD ou mort du fils). Si le père n'attend pas la mort de son fils par un appel à la primitive WAIT alors la table des processus n'est pas libérée et il y a risque de saturation de cette table. Primitive WAIT pid_t wait (int *status) : attente de la mort du fils Exemple d une synchronisation père fils assurant une bonne libération des ressources du système à la mort du fils. Primitive de création de processus PROCESSUS PID 12222 Main () pid_t pid ; int i, j; for(i=0; i<8; i++) i = i + j; pid= fork(); if (pid == 0) printf(" je suis le fils "); exit(); else printf ("je suis le père"); printf ("pid de mon fils, %d", pid) wait(); PROCESSUS PID 12224 Main () pid_t pid ; int i, j; for(i=0; i<8; i++) i = i + j; pid= fork(); if (pid == 0) printf(" je suis le fils "); exit; else printf ("je suis le père"); printf ("pid de mon fils, %d", pid); wait(); Un processus fils défunt reste zombi jusqu'à ce que son père ait pris connaissance de sa mort.

Un processus fils orphelin, suite au décès de son père (le processus père s'est terminé avant son fils) est toujours adopté par le processus numéro 1 (INIT) et non par son grand-père. 4.3- Les primitives de recouvrement Il s'agit d'un ensemble de primitives (famille EXEC) permettant à un processus de charger en mémoire, un nouveau code exécutable. L'exécution d'une de ces primitives EXEC entraîne l'écrasement du code hérité au moment de la création (primitive Fork) par le code exécutable spécifié en paramètre de la primitive. Des données peuvent être passées au nouveau code exécutable via les arguments de la primitive EXEC. Primitives EXEC Ensemble de primitives (famille EXEC) permettant à un processus de charger en mémoire, un nouveau code exécutable : - int execl (const char *ref, const char *arg,, NULL) : ref est le chemin d'un exécutable à partir du répertoire courant, const char *arg,, NULL est la liste des arguments. - int execlp (const char *ref, const char arg,, NULL) : ref est le chemin d'un exécutable à partir de la variable d'environnement PATH, const char *arg,, NULL est la liste des arguments. - int execv (const char *ref, const char *arg[]) : ref est le chemin d'un exécutable à partir du répertoire courant, const char *arg [] est un tableau contenant les arguments. - int execvp (const char *ref, const char *arg[]) : ref est le chemin d'un exécutable à partir de la variable d'environnement PATH, const char *arg [] est un tableau contenant les arguments. L'interface du programme principal d'un exécutable (le main) se présente toujours de la manière suivante : int main (int argc, char *argv[], char *arge[]); - argc est le nombre de composants de la commande - argv est un tableau de pointeurs de caractères donnant accès aux différentes composantes de la commande - arge est un tableau de pointeurs de caractères donnant accès à l'environnement du processus. Exemple : calcul 3 4 Exprime la commande Unix du lancement de l exécution du programme calcul à qui on passé les arguments 3 et 4. On a alors argc = 3, argv[0]="calcul",argv[1]="3" et argv[2] = "4" Le source de ce programme est : Calcul.c

main(argc,argv) int somme; if (argc <> 3) printf("erreur"); exit(); somme = atoi(argv[1]) + atoi(argv[2]); -- atoi : conversion caractère entier exit(); La figure ci-dessous donne un exemple de l'utilisation d'une des primitives EXEC : la primitive EXECL. Dans l'exemple ci-dessous, le processus fils résultant de l'exécution du Fork va exécuter la partie de l'alternative pour laquelle PID == 0 est vrai. Dans cette alternative, le processus fils fait appel à la primitive EXECL en demandant l'exécution d'un programme exécutable qui a pour nom calcul et qui admet pour paramètre argv[0] = "calcul", argv [1] = "3" et argv[2] = "2". Il faut noter que les arguments sont transmis comme des chaînes de caractères. C'est pourquoi une conversion de caractère vers entier est nécessaire. Dans l'exemple donné, cette conversion est réalisée à l'aide de la primitive atoi. Exemple de programmation avec une primitive de la famille Exec.. Primitives de recouvrement (execl) #include <sys/types.h> #include <sys/wait.h> int execl(const char *ref, const char *arg,, NULL) Chemin absolu du code exécutable arguments Création d'un processus fils par duplication du code et données du père Le processus fils recouvre le code et les données hérités du père par ceux du programme calcul. Le père transmet des données de son environnement vers son fils par les paramètres de l'exec Le père attend son fils Main () pid_t pid ; int i, j; PROCESSUS for(i=0; i<8; i++) i = i + j; pid= fork(); if (pid == 0) printf(" je suis le fils "); execl("/home/calcul","calcul","3","4", NULL); else executable paramètres printf ("je suis le père"); printf ("pid de mon fils, %d", pid); wait(); 5- Architecture du système Unix Tout le système UNIX repose sur ce concept arborescent de processus père et de processus fils créé par duplication du processus père puis par recouvrement par un code exécutable spécifique du code hérité du processus père. Le seul processus Unix qui n'est pas crée par un

appel à la primitive Fork puis par un appel à une des primitives Exec est le premier processus de la machine c'est-à-dire le processus 0. Une fois créé, le processus 0 crée un deuxième processus, le processus 1 appelé également processus INIT. Le processus 0 devient alors le processus Swapper c'est-à-dire le processus responsable de swapper hors de la mémoire centrale les processus utilisateurs endormis depuis trop longtemps. Le processus INIT va créer à son tour un certain nombre de processus : d'une part les processus DEMONS responsable de fonctions système telles que la surveillance du réseau (inetd), la gestion de l'imprimante (lpd), d'autre part des processus GETTY chargés de la surveillance des terminaux. Le processus INIT trouve l'ensemble des processus à créer dans un fichier qui est fichier /etc/inittab. Lorsqu'un utilisateur vient pour utiliser la machine, il se logue sur un terminal. Le processus GETTY crée alors un nouveau processus, le processus LOGIN chargé de lire le login de l'utilisateur, son mot de passe et de vérifier dans le fichier /etc/passwd que l'utilisateur est autorisé à se connecter à la machine. Si l'utilisateur est autorisé à se connecter à la machine, alors le processus LOGIN va créer à son tour un nouveau processus le processus SHELL c'est-à-dire l'interpréteur de commande pour le nouvel utilisateur. Cet interpréteur de commandes va prendre en charge les commandes tapées par l'utilisateur et pour chacune d'elles il va crée un nouveau processus chargé d'exécuter la commande. Ce processus existera le temps de l'exécution du programme ou de la commande. L'arborescence de processus Unix : Processus Unix Tout le système Unix repose sur ce concept arborescent Processus 0 Processus Swapper Processus daemon Création : fork et exec (/etc/init) Processus 1 : init Fichier /etc/inittab création création Création : fork et exec de chaque exécutable spécifié dans /etc/inittab Processus getty Processus getty Inetd Crond Création lpd... Processus login Fichier /etc/passwd Création : fork et exec du shell spécifié dans /etc/passwd Processus shell Création : fork et exec de la commande /bin/ls, paramètre -l Prog.exe ls -l 6- Processus léger 6.1- Définition

Le processus léger constitue une extension du modèle traditionnel de processus. Un processus classique est constitué d'un espace d'adressage avec un seul fil d'exécution, ce fil d'exécution étant représenté par une valeur de compteur ordinal et une pile d'exécution. Un processus léger est un espace d'adressage dans lequel plusieurs fils d'exécution peuvent évoluer en parallèle. Ces fils d'exécution sont chacun caractérisés par une valeur de compteur ordinal propre et une pile d'exécution privée. Un processus léger est un espace d'adressage dans lequel plusieurs fils d'exécution peuvent évoluer en parallèle. Ces fils d'exécution sont chacun caractérisés par une valeur de compteur ordinal propre et une pile d'exécution privée. Le gros avantage lié à la notion de processus léger est un allègement des opérations de commutations de contexte : en effet lorsque le processeur commute d'un fil d'exécution à un autre fil et que ces deux fils appartiennent au même espace d'adressage, alors la commutation est très allégée puisqu'elle consiste seulement à changer de pile et de valeur de compteur ordinal, le contexte mémoire restant le même. Un inconvénient majeur est que l'espace d'adressage est complètement partagé entre tous les fils d'exécution qui évoluent au sein de celui-ci et donc les opérations de synchronisation sont plus souvent requises.. 6.2- Primitives associées aux processus léger - int pthread_create (pthread_t *thread, const pthread_attr_t *attr, void * (*start_routine)(void *), void *arg) : Création d'un processus léger : un processus léger identifié par l'identificateur *thread est crée et attaché à l'exécution de la routine (*start_routine)(void *), void *arg). - nt pthread_join ( pthread_t thread, void **value_ptr) : synchronisation entre processus légers : permet au processus léger principal d'attendre la terminaison de ses fils. - int pthread_exit (void **value_ptr) : terminaison de processus léger La figure ci-dessous donne un exemple d'un programme dans lequel un processus léger principal (le main) crée 4 autres processus légers qui sont chacun rattachés à la fonction void t_pthread(int i). Chaque processus léger affiche le pid du processus auquel il appartient (l'espace d'adressage) par l'appel à la fonction getpid, puis son propre identifiant par l'appel à la fonction pthread_self(). Exemple de programmation avec les processus légers :

Notion de processus léger #include <stdio.h> #include <pthread.h> pthread_t pthread_id[3]; void f_thread(int i) printf ("je suis la %d-eme pthread d'identite %d.%d\n", i, getpid(), pthread_self()); main() int i; for (i=0; i<3; i++) if (pthread_create(pthread_id + i, pthread_attr_default, f_thread, i) == -1) fprintf(stderr, "erreur de creation pthread numero %d\n", i); printf ("je suis la thread initiale %d.%d\n", getpid(), pthread_self()); pthread_join(); main f_thread