Faculté des Sciences de Monastir Systèmes d’Exploitation II – LFSI 2
Département des Sciences de l’Informatique
TD n°4 : Sémaphores – suite
1. Rappel : les sémaphores Opération V(S)
Les sémaphores sont des outils généraux de synchronisation qui Lorsqu’un processus libère une ressource, les demandes des
servent, par exemple, à gérer l’accès en exclusion mutuelle à une processus bloqués sont réexaminées et certains sont débloqués.
ressource critique. Un sémaphore est représenté par une valeur entière
E et une file d’attente F. Prenons, par exemple, le cas d’une ressource 3. Programmation des sémaphores
critique partagée par plusieurs processus et dont la quantité est L’implémentation des sémaphores disponible sous GNU/Linux
limitée. La quantité de cette ressource disponible initialement sera propose les deux opérations P et V ainsi qu’une troisième notée Z. Un
donnée par la valeur du sémaphore. Si nous disposons de n unités de processus qui effectue une opération Z est suspendu jusqu’à ce que la
ressources initialement, alors, la valeur initiale du sémaphore sera n. valeur du sémaphore associé soit égale à Zéro.
2. Opérations sur les sémaphores Il est absolument fondamental de remarquer que toute
opération sur les sémaphores est atomique : en d’autres termes, une
fois que le processus entre dans une opération traitant des
Algorithme Signification
sémaphores, alors il ne peut pas être interrompu.
S.E = S.E-1 Prise de la ressource. Si la
3.1 Structure sembuf
P(S) si (S.E < 0) alors ressource n’est pas disponible, le
La structure struct sembuf permet de définir une opération sur
Bloquer le processus processus est bloqué.
dans S.F un sémaphore particulier de l’ensemble des sémaphores. Elle a la
définition suivante :
S.E = S.E+1 Libération de la ressource.
si (S.E <= 0) alors Certains processus bloqués struct sembuf
V(S) Débloquer un processus pourront reprendre si la {
de S.F ressource nécessaire est à short sem_num; /* Numéro du sémaphore */
nouveau disponible. short sem_op; /* Opération P, V ou Z */
short sem_flg; /* Options */
};
Opération P(S).
Lorsqu’un processus nécessite une ressource pour fonctionner, il
va tenter de puiser dans la quantité disponible. La quantité de sem_num : Numéro du sémaphore sur lequel va s’appliquer l’opération.
ressources va donc être décrémentée de 1. Si après cette opération la Dans un ensemble de sémaphores, les numéros commencent à 0.
quantité de ressources est négative, cela veut dire que le processus ne sem_op : C’est le champ qui détermine l’opération :
peut pas s’exécuter correctement : il est alors suspendu dans l’attente
• sem_op = 0 : Opération Z
d’une quantité suffisante de ressources.
1/3
Systèmes d’Exploitation II – LFSI 2 TD n°4 : Sémaphores
• sem_op = 1 : Opération V 4. Applications
• sem_op = -1 : Opération P Soit le programme suivant :
sem_flg : Options sur l’opération. Son étude est hors de ce TD. #include <stdio.h>
#include <sys/sem.h>
3.2. Création de sémaphores void P(int semid) {
La fonction, s’appelle semget, sa syntaxe est la suivante : struct sembuf op;
op.sem_num = 0; op.sem_op = -1; op.sem_flg = 0;
int semget(key_t clef, int nbrSem, int options) semop(semid, &op, 1) ;
}
Pour simplifier, une seule option spécifique est présentée : nbrSem qui
permet de spécifier combien de sémaphores doivent être crée. La void V(int semid) {
fonction retourne l’identifiant du sémaphore crée. struct sembuf op;
op.sem_num = 0; op.sem_op = 1; op.sem_flg = 0;
3.3 Initialisation de sémaphores semop(semid, &op, 1);
La fonction semctl permet de gérer les sémaphores. Syntaxe : }
int semctl(int idSEM, int numSem, int opr, int val, …) void Z(int semid) {
struct sembuf op;
Avec idSEM l’identifiant du sémaphore. numSem est le numéro du op.sem_num = 0; op.sem_op = 0; op.sem_flg = 0;
sémaphore (le numéro commence de zéro). La valeur de opr détermine
semop(semid, &op, 1);
}
l’opération a faire : SETVAL permet de donner une valeur, val, au
sémaphore. void init(int semid, int E) {
semctl(semid, 0, SETVAL, E);
3.4 Opérations sur les sémaphores }
La fonction semop permet de réaliser les opérations P, V et Z
sur les sémaphores. La syntaxe générale est la suivante : int main() {
int i, semid;
int semop(int idSEM, struct sembuf * ensOps, int nbOps) int val = 4;
semid = semget(42, 1, IPC_CREAT|0666);
Avec idSEM l’identifiant du sémaphore. ensOps est l’adresse de la init(semid, val);
structure sembuf et nbOps le nombre d’opérations à effectuer, for (i=1; i<10; i++) {
généralement 1. P(semid);
printf("Opération P\n");
Remarque : Toutes ces fonctions sont définies dans la bibliothèque sys/ }
sem.h return 0;
}
2/3
Systèmes d’Exploitation II – LFSI 2 TD n°4 : Sémaphores
1. Interpréter le résultat de l’exécution de ce programme. 4. Même question avec la fonction principale suivante :
2. Même question avec la fonction principale suivante :
int main() {
int main() { int pid,i,j,semid;
int i, semid; int max = 100;
int val = 4; int val = 2;
semid = semget(42, 1, IPC_CREAT|0666); semid = semget(42, 1, IPC_CREAT|0666);
init(semid, val); init(semid, val);
for(;;) { pid = fork();
P(semid); switch(pid) {
printf("opération P\n"); case -1: printf("Erreur dans fork()\n");
P(semid); return -1;
printf("opération P\n"); case 0: printf("Je suis le processus fils.\n");
V(semid); printf("Je boucle dans le vide...\n");
printf("opération V\n"); for(i=0; i<=max; i++)
} for(j=max; j>=0; j--);
return 0; printf("Fin de la boucle.\n");
} P(semid);
Z(semid);
printf("Fin du fils.\n");
3. Même question avec la fonction principale suivante : break;
default: printf("Je suis le processus père.\n");
printf("J’attends un caractère...\n");
int main() { getchar();
int semid; printf("Fin de l’attente.\n");
int val = 0; P(semid);
semid = semget(42, 1, IPC_CREAT|0666); Z(semid);
init(semid,val); printf("Fin du père.\n");
for (;;) { break;
getchar(); }
V(semid); return 0;
printf ("Opération V\n"); }
}
return 0; Indication : faire une exécution du programme avec max = 100 et
} une autre avec max = 100000.
3/3
