Effet de l ordonnancement Licence miage Université Lille 1 Pour toutes remarques : Alexandre.Sedoglavic@univ-lille1.fr Semestre 6 2012-2013 Le segment de code d un est constitué de plusieurs instructions. Par exemple, on peut considérer un A dont les instructions constituant le code seraient : IA1 IA2 IA3 IA4 IA5 IA6 IA7... et un B avec comme code les instructions : IB1 IB2 IB3 IB4 IB5 IB6 IB7... Du fait d interruption et d attente d entrée-sortie, le processeur exécute les instructions par intermittence : IB1 IA1 IA2 IB2 IB3 IB4 IA3... -2 (24-02-2012) V75 (24-02-2012) Problème de concurrence Considérons une ressource ici une variable int cpt=2000 que l on désire mettre à 1000 en utilisant 2 (qui sont supposés se partager la ressource) : EA1 EA2 EA3 EA4 A charger(vara2,1000) charger(vara1,cpt) resa=add(vara1,vara2) ranger(resa,cpt) EB1 EB2 EB3 EB4 Supposons que l on ait la succession d actions : EB1, EB2, EA1, EA2, EA3, EA4, EB3, EB4, le résultat de cette séquence est cpt=0. Supposons que l on ait la succession d actions : EB1, EA1, EA2, EB2, EA3, EB3, EB4, EA4, cette fois le résultat de cette séquence est cpt=3000. B charger(varb2,2000) charger(varb1,cpt) resb=sub(varb1,varb2) ranger(resb,cpt) Notion de section critique : définition La mise-à-jour de cpt doit s effectuer à l exclusion de toute autre action : il s agit d une section critique. Un seul à la fois peut modifier cpt ; l autre doit attendre que le en cours ait fini. De plus, ces opérations ne peuvent se faire dans n importe quel ordre. Peut importe l ordre dans lequel se font les instructions EA1 et EB1 ; ces instructions ne font pas partie de la section critique. SCA = EA2, EA3, EA4 forment la section critique du A. SCB = EB2, EB3, EB4 forment la section critique du B. Problème : comment coordonner ces sections critiques? Solution : exclusion mutuelle. Il nous suffit d exclure l exécution d une section critique par un pendant qu un autre peut effectuer cette exécution. 75 (24-02-2012) V75 (24-02-2012) Solution logiciel (fausse puis vrai) : utilisation d un verrou On peut mettre un verrou sur la ressource. Il s agit d une variable partagée par tous les. Un doit tester ce verrou avant d entrer en section critique : si le verrou est à 0, le le met à 1 et entre dans la section critique ; Si le verrou est à 1, le attend qu il soit à 0 pour s emparer de la ressource. Problème : si un voit le verrou à 0 et s endort avant de le mettre à 1, un autre peut se mettre sur les rangs et lui ravir la ressource. Lors du réveil du premier, celui-ci croit la ressource à sa disposition et entre en section critique alors que le second y est déjà. Le verrou constitue une ressource partagée. Illustration Considérons l utilisation d un seul booléen initialisé à vrai (C := vrai) qui est une ressource partagée par deux : EA1 EA11 EA12 SCA EA5 A charger(vara2,1000) tant que non C attendre C := faux Section Critique C := vrai EB1 EB11 EB12 SCB EB5 B charger(varb2,2000) tant que non C attendre C := faux Section Critique C := vrai 75 (24-02-2012) V75 (24-02-2012)
Solution logiciel correcte : algorithme de Deckker On peut assurer l alternance grâce à une variable tour commune à tous les et initialisée à 0. Si tour est égal à i alors le i est autorisé à exécuter sa section critique. Les autres font une boucle basée sur un test sur tour et attendent que leur tour arrive. Pour le i, on a donc while(1) while(tour!=i) ; /* attendre */ section_critique() ; tour = i + 1 ; section_non_critique() ; Combinaison du verrou et du tour : on peut combiner ces deux approches. Comme précédemment, les A et B doivent partager des variables qu il faut initialiser comme suit : int c[2]; int tour; c[0] = FALSE; c[1] = FALSE; tour = 0; On considère que i est associé au courant et j à l autre c[i] = TRUE; tour = j; while ((c[j]) && (tour == j)) ; c[i] = FALSE; Inconvénient : même si le ne fait rien, il monopolise le processeur. On peut aussi empêcher les interruptions afin de monopoliser le processeur physiquement. 75 (24-02-2012) V75 (24-02-2012) Description du problème : cinq philosophes chinois sont assis autour d une table ronde. Chacun d eux a devant lui un plat. Une baguette sépare deux assiettes mitoyennes. Un philosophe partage son temps entre deux actions : manger et penser. Lorsqu un philosophe a faim, il tente de s emparer de deux baguettes ; s il les obtient il mange un certain temps avant de reposer ces baguettes et de se remettre à penser. Conséquence de la loi de Murphy : un philosophe peut ne jamais avoir deux baguettes ; chaque philosophe peut en avoir une. Objectif : organiser le comportement de chaque philosophe pour éviter les privations et les blocages. Dans ce problème, il existe des produits et des cases. Chaques cases pouvant contenir un produit. De plus, un producteur dispose de deux primitives : produire(produit) et deposer(case,produit). Il ne peut déposer son produit que si la case correspondante n est pas pleine ; un dispose de deux primitives : consommer(produit) et retirer(case,produit). Le ne peut consommer que si la case est pleine. Les deux ne doivent pas accéder en même temps au tampon. Conséquences de la loi de Murphy : le producteur peut déposer un produit alors que le n a pas retiré le précédent ou retirer un produit alors que le producteur n a rien déposé. Objectif : organiser les comportements des deux partenaires. 75 (24-02-2012) V75 (24-02-2012) Définition et utilisation des Ce problème modélise les accès à une base de données : un ensemble de tente constamment d accéder à la base de données soit pour écrire, soit pour lire des informations. Afin d assurer une certaine cohérence des données de la base, il faut interdire l accès (en lecture et en écriture) à l ensemble des, si un est en train de modifier la base (accède à la base en mode écriture). Par contre, plusieurs peuvent accéder à la base, en même temps, en mode lecture. Dans ce cadre : les rédacteurs représentent les qui demandent des accès en écriture à la base de données ; les lecteurs représentent les qui demandent des accès en lecture à la base de données. En 1965, Dijkstra introduit la notion de ; cette structure de donnée est composée : d un compteur pouvant prendre des valeurs entières (négatives, positives ou nulles) ; d une liste de en attente ; deux primitives atomiques manipulant le : wait décrémente le compteur associé au. Si sa valeur est négative, le se bloque dans la file d attente ; signal incrémente le compteur associé au. Si le compteur est négatif ou nul, un est choisi dans la file d attente est devient actif. Plusieurs terminologies sont utilisées : wait down P signal up V Ces opérations sont ininterruptibles et ont lieu séquentiellement. 75 (24-02-2012) V75 (24-02-2012)
Exclusion mutuelle Synchronisation l accès à une ressource unique (fichier, variable, imprimante, etc). Le s est initialisé à 1. Utilisation : Chaque a une section critique où il utilise la ressource. Dans ce cas, chacun peut utiliser le comme suit : Dans ce cas, un doit en attendre un autre pour continuer (ou commencer) son exécution. Le s est initialisé à 0. Utilisation : dans le cas de deux, le est manipulé comme suit : wait(s) signal(s) Processus 1 Processus 2 wait(s) // attente 1 signal(s) // réveil 2 75 (24-02-2012) V75 (24-02-2012) Les rendez-vous Le rendez-vous est une généralisation de la synchronisation. Un RDV doit attendre que n autres soient parvenus à un endroit précis pour poursuivre son exécution. Ceci fait, les autres poursuivent eux aussi leurs exécutions. On utilise : un Ssync initialisé à 0 un mutex initialisé à 1 un Sattend initialisé à 0 un entier nb initialisé à 0 (une ressource partagée). Il ne reste plus qu à programmer les : Processus i Processus RdV...... P(mutex) ;... nb = nb + 1 ; P(Ssync) ; si nb = n alors V(Ssync) ; nb = 0 ; V(Sattend, n) ; V(mutex) ;... P(Sattend) ;......... 75 (24-02-2012) V75 (24-02-2012) Le problème d interblocage Supposons que SemA et SemB soient deux d exclusion mutuelle initialisés à 1 et que l on dispose d au moins deux : Processus i Processus j P(semA) ; P(semB) ; P(semB) ; P(semA) ; V(semB) ; V(semA) ; V(semA) ; V(semB) ; Il y a interblocage en programmant le problème des philosophes par : penser(); P(fourchette i); P(fourchette (i+1) mod 5); manger(); V(fourchette i); V(fourchette (i+1) mod 5); Il existe deux remèdes différents pour s affranchir des interblocages : 1. Prévention : exécuter les P() toujours dans le même ordre ; déclarer quelles sont les ressources que l on va utiliser et utiliser un algorithme qui en tient compte. 2. Détection Guérison : 2.1 construire le graphe des conflits (périodiquement) ; 2.2 si un circuit est trouvé alors il y a interblocage ; 2.3 tuer un puis effectuer les V() manquants. #define N 100 /* nombre de places dans le tampon */ semaphore_t mutex=sema_init(1); /* contr\^ole d acc\ es au tampon */ semaphore_t vide =sema_init(n); /* nb de places libres */ semaphore_t plein=sema_init(0); /* nb de places occup\ ees */ void producteur (void) objet_t objet ; while (TRUE) produire_objet (&objet) ; /* produire l objet suivant */ down (&vide) ; /* d\ ec. nb places libres */ down (&mutex) ; /* entr\ ee en section critique */ mettre_objet (objet) ; /* mettre l objet dans le tampon */ up (&mutex) ; /* sortie de section critique */ up (&plein) ; /* inc. nb places occup\ ees */ 75 (24-02-2012) V75 (24-02-2012)
void (void) objet_t objet ; while (TRUE) down (&plein) ; /* d\ ec. nb emplacements occup\ es */ down (&mutex) ; /* entr\ ee section critique */ retirer_objet (&objet) ; /* retire un objet du tampon */ up (&mutex) ; /* sortie de la section critique */ up (&vide) ; /* inc. nb emplacements libres */ utiliser_objet (objet) ; /* utiliser l objet */ Pour contrôler les accès à la base, on doit connaître le nombre nbl de lecteur en train de lire. unsigned int nbl = 0 ; /* c est une ressource partag\ ee */ semaphore_t mutex=sema_init(1);/* contr\^ole d acc\ es \ a la base */ semaphore_t redac=sema_init(1);/* contr\^ole d acc\ es \ ecrivain */ void lecteur (void) do down(mutex) ; if(!nbl) down(redac);/* le premier lecteur emp\^eche l \ ecriture * nbl++ ; up(mutex) ; LectureDeLaBase() ; down(mutex) ; nbl-- ; if(!nbl) up(redac);/* le dernier lecteur autorise l \ ecriture */ up(mutex) ; while(1) ; void redacteur(void) dodown(redac); ModificationDeLaBase(); up(redac); while(1); 75 (24-02-2012) V75 (24-02-2012) #define N 5 /* nombre de philosophes */ #define GAUCHE(i-1)%N /* on construit un tore */ #define DROITE(i+1)%N #define penser 0 /* les actions du philosophe */ #define faim 1 #define manger 2 typedef int semaphore ; int etat[n] ; /* on suppose ce tableau initialis\ e */ semaphore mutex = 1 ; /* s\ emaphore d exclusion mutelle */ semaphore s[n] ; /* un s\ emaphore est attach\ e \ a chaque philosope, il est initialis\ e \ a 0 */ void philosophe(int i) while(1) penser() ; prendre_baguettes(i) ; manger(); poser_baguettes(i) ; void test(int i) if ( etat[i] == faim && etat[gauche(i)]!= manger && etat[droite(i)]!= manger ) etat[i] = manger ; up(s[i]) ; void prendre_baguettes(int i) void poser_baguettes(int i) down (&mutex) ; down(&mutex) ; etat[i] = faim ; etat[i] = penser ; test(i) ; test(gauche(i)) ; up(&mutex) ; test(droite(i)) ; down(s[i]); up(&mutex) ; 75 (24-02-2012) V75 (24-02-2012) Primitive de manipulation des (System V) Un est implanté dans linux par la structure de donnée ci-contre. Un tableau de valeurs est associé au ainsi qu une file d attente sem queue. sem undo permet de rétablir le au cas ou le le manipulant est corrompu. La primitive semget d obtention de #include <sys/types.h> #include <sys/ipc.h> key_t ftok(const char *pathname, int proj_id); #include <sys/sem.h> int semget(key_t key, int nsems, int semflg); La fonction ftok retourne une clef supposée unique construite à partir d un chemin d accès et d un entier. Cette clef est associée à une ressource et permet de la désigner. La fonction semget retourne l identificateur d un tableau de nsems valeurs associées au lui même associé à la clef key. Une structure de données associée à un est créée si le drapeau semflg est IPC CREAT et qu aucun n est associé à la clef key. 75 (24-02-2012) V75 (24-02-2012)
La primitive semctl de contrôle de #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> int semctl(int semid, int semnum, int cmd, union semun arg); union semun int val; unsigned short *array ; struct semid_ds *buf; struct seminfo * buf; ; L entier cmd détermine l action de la fonction semctl suivant les valeurs : IPC STAT copie les informations du semaphore dans arg.buf ; IPC SET affecte les informations du semaphore à partir de arg.buf ; IPC RMID détruit le. La primitive semop de manipulation de #include<sys/types.h> /* semid~: identificateur du s\ emaphore */ #include<sys/ipc.h> /* nsops~: nb d \ el\ ements du tableau de s\ #include<sys/sem.h> int semop(int semid, struct sembuf *sops, unsigned nsops); struct sembuf unsigned short int sem_num; /* semaphore number */ short int sem_op; /* semaphore operation */ short int sem_flg; /* operation flag */ ; L action de l appel semop dépend du champs sem op. S il est : strictement positif : une opération up est exécutée sur le ; strictement négatif : une opération down est exécutée sur le ; nul : une opération d attente est exécutée et se termine quand l ensemble des désignés par dipc sont nul. 75 (24-02-2012) V75 (24-02-2012) s de léger ( POSIX) La gestion des conformémant à la norme POSIX se fait par l intermédiaire des appels : #include <semaphore.h> int sem_init(sem_t *sem, int pshared, unsigned int value); int sem_wait(sem_t * sem); int sem_trywait(sem_t * sem); int sem_post(sem_t * sem); int sem_getvalue(sem_t * sem, int * sval); int sem_destroy(sem_t * sem); Ces appels ne s appliquent qu aux légers () et ne peuvent donc pas servir à la communication de lourd. Autres méthodes de synchronisation que les : moniteurs et compteurs Au lieu de se servir de, on peut regrouper l ensemble des sections critiques d un Problème dans un module nommé moniteur. Ce moniteur est un ensemble de fonctions, de variables et de structures de données qui permettent de manipuler une ressource. Les peuvent appeler les fonctions du moniteur mais ne peuvent accéder à sa structure interne. Pour assurer l exclusion mutuelle, il suffit qu à tout moment, il n y ait qu un actif utilisant le moniteur. Pour ce faire, si un actif utilise le moniteur, un appelant le moniteur est bloqué. Lorsque le actif quitte le moniteur, il le libère. Les moniteurs existent dans les langages orientés objet (JAVA, C++). 75 (24-02-2012) V75 (24-02-2012) Compteurs d événements Un compteur peut être associé à un événement et indiqué le nombre d occurrences de cet événement. Ce compteur peut servir à synchroniser des : un attend jusqu à ce qu une valeur du compteur soit atteinte. Trois opérations doivent être définies pour chaque compteur : eval(cpt) donne la valeur du compteur cpt ; inc(int *cpt) incrémente la valeur de cpt. Attention, l exécution de cette fonction ne doit pas être interrompue ; wait(cpt,val) attend que cpt dépasse la valeur val. Un compteur d événement peut être utilisé dans le problème du producteur. 75 (24-02-2012) V75 (24-02-2012) Une solution du problème des producteurs et s par compteur d événement #define N 100 /* taille du tampon i.e. nb de cases */ int in = 0 ; /* incr\ ement\ e par le producteur */ int out = 0 ; /* incr\ ement\ e par le */ void producteur (void) void (void) int objet, sequence=0, pos=0 ; int objet, sequence=0, pos=0 ; while(1) while(1) objet++ ; sequence++ ; sequence++ ; /* attendre que le tampon /* attendre que le tampon devienne non vide */ devienne non plein */ wait(in,sequence) ; wait(out, sequence-n) ; objet = tampon[pos] tampon[pos] = objet ; /* incr\ ementer le compteur pos = (pos+1)%n ; de retraits */ /* incr\ ementer le nombre inc(&out) ; de d\ ep\^ots */ printf("objet consomm\\ e [%d]: inc(&int) ; pos, objet) ; pos = (pos+1)%n ;