La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

7a.1 URDL22005 Systèmes dexploitation Synchronisation Classique Contexte Le problème de la section critique Matériel pour la synchronisation Sémaphores.

Présentations similaires


Présentation au sujet: "7a.1 URDL22005 Systèmes dexploitation Synchronisation Classique Contexte Le problème de la section critique Matériel pour la synchronisation Sémaphores."— Transcription de la présentation:

1 7a.1 URDL22005 Systèmes dexploitation Synchronisation Classique Contexte Le problème de la section critique Matériel pour la synchronisation Sémaphores Problèmes classiques de synchronisation

2 7a.2 URDL22005 Systèmes dexploitation Contexte Accès concurrent à une mémoire partagée peut produire des incohérences Maintenir la cohérence des données requière des mécanismes pour assurer une exécution correcte des processus coopérants Une solution mémoire partagée au problème de tampon borné (bounded buffer) contient un problème de race condition (condition de concurrence) sur la variable donnée count.

3 7a.3 URDL22005 Systèmes dexploitation Race Condition Le Producteur appelle while (1) { while (count == BUFFER_SIZE) ; // operation nulle // ajouter un element au tampon count++; buffer[in] = item; in = (in + 1) % BUFFER_SIZE; }

4 7a.4 URDL22005 Systèmes dexploitation Race Condition Le Consommateur appelle while (1) { while (count == 0) ; // operation nulle // retirer un element du tampon count--; item = buffer[out]; out = (out + 1) % BUFFER_SIZE; }

5 7a.5 URDL22005 Systèmes dexploitation Race Condition count++ peut être implémenté de la façon suivante register1 = count register1 = register1 + 1 count = register1 count– peut être implémenté de la façon suivante register2 = count register2 = register2 - 1 count = register2 Considérez cette exécution: S0: producteur exécute register1 = count {register1 = 5} S1: producteur exécute register1 = register1 + 1 {register1 = 6} S2: consommateur exécute register2 = count {register2 = 5} S3: consommateur exécute register2 = register2 - 1 {register2 = 4} S4: producteur exécute count = register1 {count = 6 } S5: consommateur exécute count = register2 {count = 4}

6 7a.6 URDL22005 Systèmes dexploitation Solution au Problème de Section Critique 1. Exclusion Mutuelle – Si le processus P i est dans sa section critique, alors aucun autre processus ne peut exécuter sa section critique 2.Progression – Sil ny a aucun processus dans la section critique et que des processus veulent entrer dans leur section critique, alors la sélection des processus pour entrer en section critique ne peut pas être retardée indéfininement 3.Attente Bornée - Une borne doit exister sur le nombre de fois que les autres processus sont permis dentrer dans leur section critique après quun processus ait fait une requête dadmission en section critique et avant que cette demande ne soit accordée Supposer que chaque processus exécute à une vitesse différente de 0 Pas dhypothèses concernant les vitesses dexécution relatives des processus

7 7a.7 URDL22005 Systèmes dexploitation Solution pour 2 Tâches 2 Tâches, T 0 et T 1 (T i et T j ) 3 solutions présentées. Toutes implémentent linterface suivante: const int TURN0 = 0; const int TURN1 = 1; void enteringCriticalSection(int turn); void leavingCriticalSection(int turn);

8 7a.8 URDL22005 Systèmes dexploitation Thread Travailleur while (true) { // initialisation des variables partagées …. // demande dentrée en section critique enteringCriticalSection(id); // section critique... // modification des varaibles partagées... // sortie de section critique leavingCriticalSection(id); // section NON critique }

9 7a.9 URDL22005 Systèmes dexploitation Algorithme 1 Les threads partagent un entier turn Si turn==i, thread i rentre dans sa section critique Ne réspecte pas la règle de progession Pourquoi?

10 7a.10 URDL22005 Systèmes dexploitation Algorithme 1 // Thread 0 turn = TURN0; void enteringCriticalSection(int t) { while (turn != t) laisser_la_main(); } void leavingCriticalSection(int t) { turn = 1 - t; }

11 7a.11 URDL22005 Systèmes dexploitation Algorithme 2 Ajouter plus dinformations sur létat Drapeau boléen pour indiquer lintérêt du thread pour entrer dans la section critique Règle de progression toujours pas respectée Pourquoi?

12 7a.12 URDL22005 Systèmes dexploitation Algorithme 2 void enteringCriticalSection(int t) { { flag0 = true; while(flag1 == true) laisser_la_main(); } void leavingCriticalSection(int t) { flag0 = false; }

13 7a.13 URDL22005 Systèmes dexploitation Algorithme 3 Combine les 2 idées précédentes Règles respectées?

14 7a.14 URDL22005 Systèmes dexploitation Algorithme 3 // Thread 0 void enteringCriticalSection(int t) { int other = 1 - t; turn = other; if (t == 0) { flag0 = true; while(flag1 == true && turn == other) laisser_la_main(); } void leavingCriticalSection(int t) { flag0 = false; }

15 7a.15 URDL22005 Systèmes dexploitation Matériel de Synchronisation Plusieurs systèmes fournissent un support matériel pour gérer des sections critiques Uniprocesseurs – bloquer les interruptions Le code en exécution sexécute sans préemption Générallement pas efficace sur des multiprocesseurs OSs utilisant cette technique ne passent pas à léchelle Machines modernes fournissent des instructions spécifiques Atomiques = non-préemptables Soit tester un mot mémoire et le modifier Ou échanger le contenu de deux mots mémoire

16 7a.16 URDL22005 Systèmes dexploitation Structures de Données pour Solutions Matérielles typedef struct { boolean data; } HardwareData; boolean get(HardwareData *var) { return var->data; } void set(HardwareData *var, boolean data) { var->data = data; }

17 7a.17 URDL22005 Systèmes dexploitation Structure de Données pour Solutions Matérielles - cont boolean TestAndSet(HardwareData *var) { boolean oldValue = get(var); set(var, true); return oldValue; } void swap(HardwareData *this, HardwareData *other) { boolean temp = get(this); set(this, get(other)); set(other, temp); }

18 7a.18 URDL22005 Systèmes dexploitation Thread Utilisant TestAndSet Verrou // Verrou partagé par tous les threads HardwareData verrou = { false }; while (true) { while (TestAndSet(verrou)) laisser_la_main(); sectionCritique(); set(verrou, false); sectionNonCritique(); }

19 7a.19 URDL22005 Systèmes dexploitation Thread Utilisant Instruction swap // verrou partagé par tous les threads HardwareData verrou = {false}; // chaque thread a une copie locale de clef HardwareData clef = {true}; while (true) { set(clef, true); do { swap(verrou, clef); } while (get(clef) == true); sectionCritique(); set(verrou, false); sectionNonCritique(); }

20 7a.20 URDL22005 Systèmes dexploitation Sémaphore Outil de synchronisation ne provoquant pas du busy waiting (attente active) (spin lock) Semaphore S – entier Deux opérations standards modifient S: acquire() and release() A lorigine (Hollandaise) appelées P() and V() Moins compliqué Peut être accédé via deux opérations indivisibles (atomiques) acquire(S) { while S <= 0 ; // no-op S--; } release(S) { S++; }

21 7a.21 URDL22005 Systèmes dexploitation Sémaphore comme Outil de Synchronisation Général Sémaphore de Comptage – valeur entière sur un domaine non restreint Sémaphore Binaire – valeur entière 0 ou 1; plus simple à implémenter Connu aussi sous le nom de as verrou dexclusion Peut implémenter un sémaphore de comptage S avec des sémaphores binaires Fournit lexclusion mutuelle

22 7a.22 URDL22005 Systèmes dexploitation Synchronisation avec Sémaphores Semaphore sem; // initialisé à 1 while (true) { acquire(sem); // section critique release(sem); // section non critique }

23 7a.23 URDL22005 Systèmes dexploitation Implémentation Sémaphores acquire(S){ valeur--; if (valeur < 0) { ajouter processus à liste bloquer; } release(S){ valeur++; if (valeur <= 0) { supprimer un processus P de liste réveiller P; }

24 7a.24 URDL22005 Systèmes dexploitation Implémentation Sémaphores Doit garantir que deux processus ne puissent pas exécuter acquire() et release() simultanément sur un même sémaphore Ainsi limplémentation devient le problème de la section critique Peut maintenant avoir de lattente active dans limplémentation de la section critique Mais le code de limplémentation est court Très peu dattente active si la section critique est très peu occupée Les applications peuvent rester longtemps dans une section critique Problèmes de performance discutés dans cette conférence

25 7a.25 URDL22005 Systèmes dexploitation Deadlock et Famine Deadlock – deux ou plusieurs processus en attente infinie pour un évènement qui ne peut être provoqué que par un processus en attente Soient S et Q deux sémaphores initialisés à 1 P 0 P 1 acquire(S); acquire(Q); acquire(Q); acquire(S);. release(S); release(Q); release(Q); release(S); Famine – blocage infini. Un processus peut ne jamais être repêché de liste des processus bloqués du sémaphore.

26 7a.26 URDL22005 Systèmes dexploitation Problèmes Classiques de Synchronisation Problème du Tampon Borné (Bounded Buffer) Problème des Lecteurs/Ecrivains Problème des Philosophes

27 7a.27 URDL22005 Systèmes dexploitation Problème du Tampon Borné const int BUFFER_SIZE = 5; Objet *buffer[BUFFER_SIZE]; int in, out; // initialisé à 0 Semaphore mutex; // initalisé à 1 Semaphore empty; // initialisé à BUFFER_SIZE Semaphore full; // initialisé à 0

28 7a.28 URDL22005 Systèmes dexploitation Problème du Tampon Borné:Méthode insert() void insert(Objet *item) { acquire(empty); acquire(mutex); // ajouter un item au tampon buffer[in] = item; in = (in + 1) % BUFFER_SIZE; release(mutex); release(full); }

29 7a.29 URDL22005 Systèmes dexploitation Problème du Tampon Borné:remove() Objet *remove() { acquire(full); acquire(mutex); // supprimer un item du tampon Objet *item = buffer[out]; out = (out + 1) % BUFFER SIZE; release(mutex); release(empty); return item; }

30 7a.30 URDL22005 Systèmes dexploitation Problème du Tampon Borné:Producteur Objet *message; while (true) { // des instructions diverses … // produire litem & insérer dans le tampon message = produireMessage(); insert(message); }

31 7a.31 URDL22005 Systèmes dexploitation Problème du Tampon Borné:Consommateur Objet *message; while (true) { // instructions diverses … // consommer un item du tampon message = remove(); }

32 7a.32 URDL22005 Systèmes dexploitation Problème Lecteurs-Ecrivains: Lecteur RWLock db; while (true) { // instructions diverses... acquireReadLock(db); // on a maintenant un accès lecture à la base de données // lire de la base de données // relâcher le verrou releaseReadLock(db); }

33 7a.33 URDL22005 Systèmes dexploitation Problème Lecteurs-Ecrivains: Ecrivain RWLock db; while (true) { acquireWriteLock(db); // on a un accès en écriture // écrire releaseWriteLock(db); }

34 7a.34 URDL22005 Systèmes dexploitation Lecteurs-Ecrivains: Base de Données typedef struct { int readerCount; // initialisé à 0 Semaphore mutex; // initialisé à 1 Semaphore db; // initialisé à 1 } RWLock;

35 7a.35 URDL22005 Systèmes dexploitation Lecteurs-Ecrivains: Méthodes Lecteur void acquireReadLock(RWLock verrou) { acquire(&verrou.mutex); ++readerCount; // si je suis le 1 er à lire, dire aux autres // que la base de données est en train dêtre lue if (readerCount == 1) acquire(&verrou.db); release(&verrou.mutex); } void releaseReadLock(RWLock verrou) { acquire(&verrou.mutex); --readerCount; // si je suis le dernier à lire, dire aux autres // que la base de données nest plus lue if (readerCount == 0) release(&verrou.db); release(&verrou.mutex); }

36 7a.36 URDL22005 Systèmes dexploitation Lecteurs-Ecrivains: Méthodes Ecrivain void acquireWriteLock() { acquire(&verrou.db); } void releaseWriteLock() { release(&verrou.db); }

37 7a.37 URDL22005 Systèmes dexploitation Problème des Philosophes Données partagées Semaphore *baguettes[5];

38 7a.38 URDL22005 Systèmes dexploitation Problème des Philosophes (Cont.) Philosophe i: while (true) { // prendre baguette de gauche acquire(baguette[i]); // prendre baguette de droite acquire(baguette[(i+1)%5]); manger(); // rendre baguette de gauche release(baguette[i]); // rendre baguette de droite release(baguette[(i+1)%5]); penser(); }

39 7a.39 URDL22005 Systèmes dexploitation Problème des Philosophes (Cont.) Début P(mutex) Si les deux voisins immédiats ne mangent pas Alors V(sémaphore privé) Etat = mange Sinon Etat = veut manger FSi V(mutex) P(sémaphore privé) mange... Fin


Télécharger ppt "7a.1 URDL22005 Systèmes dexploitation Synchronisation Classique Contexte Le problème de la section critique Matériel pour la synchronisation Sémaphores."

Présentations similaires


Annonces Google