Module Systèmes d’exploitation avancés

Enseignant Hassen JEDIDI

Classes 4 Info B2, B3 & M3

TP2 : Gestion des processus

I. Utilisation des commandes du shell :

Les exercices suivants s'attachent à montrer les différences entre processus et

utilisateur et à mettre en évidence quelques points importants du système Unix.

1. Pour constater la différence utilisateur/processus, on essaiera la séquence de

commandes suivantes:

who (liste des utilisateurs connectés)

who am i (qui suis-je ...)
ps -l (liste des processus attachés au terminal)
ps -axl (liste des processus présents sur le système)

On remarquera les différents processus :

o init de pid 1 et le swapper-scheduler de pid 0.

o les démons (notés ?),
o ceux qui déroulent un shell (sh, csh ou ksh),

2. Pour exécuter une commande en arrière plan on ajoute l’option &.

La commande sleep n met le processus qui l'exécute en pause pendant n

secondes.
Envoyer la séquence suivante et observer la filiation des processus :

ps -l (liste des processus attachés au terminal courant)

sleep 20& (processus qui dort pendant 20s en arrière plan)
sleep 30& (processus qui dort pendant 30s en arrière plan)
ps -l (pour voir la nouvelle configuration de processus)

Que remarquez-vous ?
 II. Programmation C :

1. Création de processus (fonction fork)

On va tout d'abord utiliser les fonctions Unix suivantes :

• fork()
Cette fonction va créer un processus. La valeur de retour n de cette fonction
indique :
o n>0
On est dans le processus père
o n=0
On est dans le processus fils
o n = -1
fork a échoué, on n'a pas pu créer de processus
• getpid() :
Cette fonction retourne le numéro du processus courant.
• getppid() :
Cette fonction retourne le numéro du processus père.

Exercice 1:

Soit le programme exercice1.c suivant

1. Après compilation de « exercice1.c », on exécutera ce programme plusieurs fois.

Que se passe-t-il ? Pourquoi ?
2. Ajouter maintenant la ligne suivante derrière l'appel à fork :
if (valeur == 0) sleep (4);
Que se passe-t-il ? Pourquoi ?
 Exercice 2 :

Soit le programme fork

fork-mul.c suivant

1. Compiler le programme « fork-mul.c », puis l'exécuter.

2. Après exécution et à l'aide du schéma suivant, relever les numéros des
processus et numéroter l'ordre d'exécution des instructions printf de façon à
retrouver l'ordre d'exécution des processus.

Remarque:

Sii on relève un numéro de processus égal à 1, il s'agit du processus init, père de

tous les processus. Init adopte les processus orphelins, c'est à dire qu'un processus
dont le père s'est terminé devient fils de 1, et getppid() renvoie 1.
 II. Synchronisation de processus père et fils (mécanisme
wait/exit)
On va utiliser dans cette partie les fonctions suivantes

• exit( i )
termine un processus, i est un octet (donc valeurs possibles : 0 à 255) renvoyé
dans une variable du type int au processus père.
• wait( &Etat )
met le processus en attente de la fin de l'un de ses processus fils.

Quand un processus se termine, le signal SIGCHILD est envoyé à son père. La

réception de ce signal fait passer le processus père de l'état bloqué à l'état prêt. Le
processus père sort donc
nc de la fonction wait.

La valeur de retour de wait est le numéro du processus fils venant de se

terminer.
Lorsqu'il n'y a plus (ou pas) de processus fils dont il faut attendre la fin, la
fonction wait renvoie -1.
Chaque fois qu'un fils se termine le processus père sort de wait,
wait et il peut
consulter Etat pour obtenir des informations sur le fils qui vient de se terminer.

Etat est un pointeur sur un mot de deux octets :

• L'octet de poids fort contient la valeur renvoyée par le fils ( i de la fonction

exit( i )),
• L'octet de poids faible :

contient 0 dans le cas général,

En cas de terminaison anormale du processus fils, cet octet de poids
faible contient la valeur du signal reçu par le fils.
Cette valeur est augmentée de 80 en hexadécimal (128 décimal),
déci si ce
signal a entrainé la sauvegarde de l'image mémoire du processus dans un
fichier core.

Schéma résumant le contenu du mot pointé par Etat à la sortie de wait :

 II.1 Exercice 1

1- Compilez et exécutez le fork-sync.c

2- Expliquer par diagramme l’exécution de ce programme.

/**************************** fork-sync.c ******************************/

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

int main (void)

{
int valeur, ret_fils,etat ;
printf ("Je suis le processus pere de pid %d \n", (int)getpid());
valeur=fork();
switch (valeur)
{
case 0 :
printf("\t\t\t\t********\n\t\t\t\t* FILS * \n\t\t\t\t********\n");
printf ("\t\t\t\tProc fils de pid %d \n\t\t\t\tPere de pid %d \n",
(int) getpid(),(int) getppid() );
printf("\t\t\t\tJe vais dormir 30 secondes ...\n");
sleep (30);
printf("\t\t\t\tJe me reveille ,\n\t\t\t\tJe termine mon execution
par un EXIT(7)\n");
exit (7);
case -1:
printf ("Le fork a echoue");
exit(2);
default:
printf("********\n* PERE *\n********\n");
printf ("Proc pere de pid %d \nFils de pid %d \n",
(int) getpid(),valeur );
printf ("J'attends la fin de mon fils...\n");
ret_fils = wait (&etat);
printf("Mon fils de pid %d est termine,\nSon etat etait : %0x\n",
ret_fils,etat);
}
return 0;
}

/***********************************************************************/

II.1 Exercice 2 : course de processus

Ecrire un programme qui lance dix fils qui effectuent une « course ». A la fin du
programme, l’ordre des fils est affiché (chaque fils effectuera, par exemple une boucle
vide de N tours et N est une valeur aléatoire).
 III. Père et fils exécutent des programmes différents
V.1 Fonctions utilisées :

La fonction exec charge un fichier dans la zone de code du processus qui l'appelle,
remplaçant ainsi le code courant par ce fichier. Les primitives de exec sont :

int execv (const char * app, const char * argv[ ]);

app : chemin complet de l’application, le dernier élément est NULL

argv[ ] : paramètre à donner à l’application

int execl(const char * app, const char * arg, …);

app : chemin complet de l’application

arg : paramètre sous forme d’une liste d’argument, terminé par pointeur NULL

Ces primitives de recouvrement écrasent le code du processus courant par le code de la

commande passée en paramètre.

Ces primitives peuvent être suffixées par l’une des lettres suivantes :

 p : La commande est recherchée dans la variable PATH

 e : L’environnement est modifiable

On aura par exemple les primitives suivantes :

1. int execlp(const char *ref, const char *arg, …, NULL)

– ref est le chemin d'un exécutable à partir de la variable d'environnement

PATH.
– arg est la liste des arguments.

2. int execle(const char *ref, const char *arg, …,const char *env[])

– ref est le chemin d'un exécutable à partir du rép. courant.

– const char *arg, …, NULL : Liste des arguments
– env : Liste des variables d'environnement.
 Exemple

execl (fic, arg0, [arg1, ... argn,] (char *)0)

char * fic, arg0, arg1, ... argn;

Commentaires :

• fic est le nom du fichier exécutable qui sera chargé dans la zone de code du processus
qui appelle execl.
Si ce fichier n'est pas dans le répertoire courant, il faut donner son nom complet
(chemin absolu).
• Les paramètres suivants sont des pointeurs sur des chaines de caractères contenant les
arguments passés à ce programme (cf. argv en C).
La convention UNIX impose que la première soit le nom du fichier lui-même et que le
dernier soit un pointeur nul.
Par exemple, si on veut charger le fichier appelé prog qui se trouve dans le répertoire
courant et qui n'utilise auncun argument passé sur la ligne de commande :
 execl ("prog", "prog", (char *)0)

V.1 Fonctionnement de exec :

Compiler puis exécuter le fichier fexec.c.

/****************************** fexec.c *****************************/

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

int main (int argc, char *argv[])

{
int Pid;
int Fils,Etat;
/*
----------------------------------------------------------
On peut executer ce programme en lui passant diverses
commandes en argument, par exemple, si l'executable est fexec :
fexec /usr/bin/ps
----------------------------------------------------------
*/

if (argc != 2)
{printf(" Utilisation : %s fic. a executer ! \n", argv[0]);
exit(1);
}

printf (" Je suis le processus %d je vais faire fork\n",(int) getpid());

Pid=fork();
switch (Pid)
{
case 0 :
printf (" Coucou ! je suis le fils %d\n",(int) getpid());
printf (" %d : Code remplace par %s\n",(int) getpid(), argv[1]);
execl(argv[1], argv[1], NULL);
printf (" %d : Erreur lors du exec \n", (int) getpid());
exit (2);

case -1 :
printf (" Le fork n'a pas reussi ");
exit (3) ;

default :
/* le pere attend la fin du fils */
printf (" Pere numero %d attend\n ",(int) getpid());
Fils=wait (&Etat);
printf ( " Le fils etait : %d ", Fils);
printf (" ... son etat etait :%0x (hexa) \n",Etat);
exit(0);
}
return 0;
}

/***********************************************************************/
On pourra y faire exécuter par execl un fichier très simple, par exemple celui dont le source
est ci-dessous :

int main (void)

{
printf("Coucou, ici %d !\n", getpid() );
sleep (4);
return 6;
}

Expliquer l’exécution du programme précédent.

...........................................................................
...........................................................................
...........................................................................
...........................................................................
...........................................................................
...........................................................................
...........................................................................
...........................................................................
....

IV. Exercices :
D'après les exemples précédents, écrire un programme dont le fonctionnement est le suivant :

• il lit sur la ligne de commande (utiliser argc et argv) le nombre N de processus à

créer.
• il crée ces N processus en faisant N appels à fork (cf. plus loin la tâche assignée à ces
processus).

Récupérez un canevas du programme à écrire ainsi que des indications sur l'utilisation
de argc, argv et sur la création des N fils.

• il se met en attente (appel à Pid_Fils = wait(&Etat)) de ces N processus fils et

visualise leur identité (Pid_Fils et valeur de Etat) au fur et à mesure de leurs
terminaisons.
Pour attendre la fin de tous les fils, utiliser le fait que wait renvoie la valeur -1 quand
il n'y a plus de processus fils à attendre.
Ce que fait chacun des processus fils Pi:
o il visualise son pid (getpid) et celui de son père (getppid),
o il se met en attente pendant 2*i secondes (sleep (2*i)), visualise la fin de
l'attente,
o il se termine par exit (i).

Compiler en utilisant l'option -Wall de gcc, il ne doit pas y avoir de warnings après la
compilation.

/**************************** canevas du programme ************************/

/* ----------------------------------------
 * Dans main, on indique comment utiliser
* les parametres passes sur
* la ligne de commande
* ----------------------------------------
*/
int main (int argc, char *argv[])
{
int Nbre_de_Proc, i_fils, pid_fils;

if (argc != 2) /* On utilise un seul parametre */

{
printf(" Utilisation : %s nbre-de-processus ! \n", argv[0]);
exit(2);
}

Nbre_de_Proc = atoi (argv [1]); /* conversion ascii -> entier */

/* ----------------------------------------
* creation des processus fils
* ----------------------------------------
*/
for ( i_fils =1; i_fils <= Nbre_de_Proc ; i_fils++ )
{
pid_fils = fork();
switch (pid_fils)
{
case 0 :
fils(i_fils); /* il faut ecrire la fonction fils ... */
break;
case -1 :
perror("Le fork n'a pas reussi ");
exit(33); /* si erreur -> fin du pere ! */
}
}

/* --------------------------------------------
* Dans la fonction pere, on utilisera le
* fait que wait renvoie la valeur -1 quand
* il n'y a plus de processus fils a attendre.
* --------------------------------------------
*/
pere(); /* il faut aussi ecrire la fonction pere ... */

return 0;

/***********************************************************************/

Exercice à rendre : Simulation d’ordonnancement de processus :

N processus sont en attente d’exécution sur un processeur. Les processus sont numérotés de 1
à N dans la file d'attente et une durée d'exécution est associée à chacun.
On veut simuler l'exécution des processus en attente en utilisant le principe de Round Robin
qui est le suivant : on fixe un quantum de temps élémentaire Q et on exécute chaque processus
dans l'ordre de la file d’attente pendant Q unités de temps. Lorsqu'un processus est terminé, il
quitte la file d'attente ; sinon sa durée d'exécution est diminuée de Q.
Exemple : si on dispose de 4 processus avec les durées indiquées dans la table ci-dessous et si
la valeur du quantum de temps est 2, l’ordre d’achèvement des processus est : P3, P1, P4 et
P2.

P1 P2 P3 P4
3 5 2 3
Ecrire un programme qui
- lit le nombre de processus et la durée d'exécution de chacun d'eux,
- affiche les numéros des processus au fur et à mesure de leur achèvement pour
différentes valeurs de Q fournies par l'utilisateur.
On représentera les processus en cours d'exécution par une liste chaînée circulaire (le suivant
du dernier élément de la liste est le premier élément de cette liste).
En quoi cette représentation est-elle bien adaptée au problème ?