3 Protocoles de synchronisation

Transcription

1 CNAM de Lorraine Applications concurrentes : conception et outils 3 Stéphane Vialle Stephane.Vialle@supelec.fr 3. Les Règles d utilisation des sémaphores Principe d utilisation des sémaphores : On implante un «protocole de synchronisation applicatif» Ce protocole doit être : - générique : ne pas faire d hypothèse sur le scheduler, - portable : fonctionner avec tous systèmes de sémaphores Règles de bonne utilisation des sémaphores : N utiliser que les 4 opérations de base : création-init, wait, signal, destruction Les autres opérations son non-portables et mènent à des protocoles erronées!! Ex. : «lire la valeur d un sémaphore». NON!!!! Règles d utilisation des sémaphores Opéations wait et signal «étendues» : Souvent disponibles : wait(sem,n) et signal(sem,n) Similaire mais différent de : for(i = 0; i < n; i++) wait(sem); for(i = 0; i < n; i++) signal(sem); limitera la portabilité (parfois non disponibles) peut fonctionner différemment d une boucle sur wait(sem) ou signal(sem) à utiliser «en toute conscience». Implantation d exclusion mutuelle 3. Les Principe : un processus au plus exécute une section critique à un instant donné 1 - Création d un sémaphore binaire : sémaphore initialisé à 1 valeurs possibles : 0 ou 1 «lock» dans certains systèmes /* Processus père ou thread principal */ Creation-Init(sem,1); Create-Thread(); 2 - Encadrement des sections critiques dans chaque processsus : /* Processus A : */ wait(sem); /* section critique */ signal(sem); Protocole simple mais très séquentialisant! «ne pas abuser» 1

2 Implantation d une cohorte Principe : coopération d'un groupe de taille maximale donnée (P tâches au plus exécutent certaines actions à t donné) 1 - Création d un sémaphore (générique) : sémaphore initialisé à K valeurs possibles : 0 à K /* Processus père ou thread principal */ Creation-Init(sem,K); 2 - Encadrement des sections à accès limité dans chaque process /* Processus A : */ wait(sem); /* section à accès limité */ signal(sem); /* Processus B : */ wait(sem); /* section */ /* à accés */ /* limité */ signal(sem); 3. Les 1 - Principe du protocole : P processus «P i» produisent des données. C processus «C i» les consomment. Les données sont stockées en mémoire partagée circulaire. Une donnée doit être consommée une fois et une seule. Les producteurs doivent agir en parallèle des consommateurs sans exclusion mutuelle. 2a - Implant du protocole «1 producteur 1 consommateur» Pas d attente active et pas de mutex globale sur la mémoire partagée! 1 tableau partagé : mémoire circulaire. 2 indices : FuturDepot (0), FuturRetrait (0) 2 sémaphores compteurs : NbCaseVide (N), NbCasePleine (0) P1 P2 P3 P4 Processus producteurs C1 P1 Mémoire partagée circulaire NbCaseVide NbCasePleine C1 C2 C3 Processus consommateurs Quand il n y a plus de place : les producteurs sont suspendus Quand il n y a plus de données : les consommateurs sont suspendus FuturRetrait FuturDepot 2b - Code source du «producteur consommateur» /* Le producteur */ While (!fin) Tab[FuturDep] = msg; signal(nbcasepleine); /* Le Consommateur */ While (!fin) wait(nbcasepleine); msg = Tab[FuturRet]; 3a - Implant du protocole «P prods. C consos.» Pas d attente active et pas de mutex globale sur la mémoire partagée! 1 tableau partagé : mémoire circulaire 2 indices partagés : FuturDepot (0), FuturRetrait (0) 2 sémaphores compteurs : NbCaseVide (N), NbCasePleine (0) 2 sémaphores de mutex : MutexProd (1), MutexCons (1) C1 C1 C1 NbCaseVide P1P2P3 NbCasePleine Utilisation «croisée» des 2 sémaphores compteurs Pas d exclusions mutuelles MutexCons FuturRetrait FuturDepot MutexProd 2

3 3b - Code source des «P producteurs C consommateurs» /* Un producteur */ /* Un Consommateur */ While (!fin) wait(mutexprod); Tab[FuturDep] = msg; signal(mutexprod); signal(nbcasepleine); While (!fin) wait(nbcasepleine); wait(mutexcons); msg = Tab[FuturRet]; signal(mutexcons); Utilisation «croisée» des 2 sémaphores compteurs Exclusions mutuelles réduites en participants : - entre consommateurs le temps d un retrait - entre producteurs le temps d un dépôt 3c - Code source des «P prod. C conso.» optimisé /* --- Un producteur --- */ /* --- Un Consommateur -- */ int locfd; int locfr; While (!fin) wait(mutexprod); locfd = FuturDep; signal(mutexprod); Tab[locFD] = msg; signal(nbcasepleine); While (!fin) wait(nbcasepleine); wait(mutexcons); locfr = FuturRet; signal(mutexcons); msg = Tab[locFR]; Utilisation «croisée» des 2 sémaphores compteurs Exclusions mutuelles réduites en taille et en participants : - entre consommateurs le temps de cibler le retrait - entre producteurs le temps de cibler le dépôt 4a - Implant du protocole «1 prod. 1 conso. non bloqué» Principe : le consommateur effectue une tâche de fond quand il n y a pas de tâche à retirer de la mémoire partagée. Et toujours pas d attente active et pas de mutex globale sur la mémoire partagée! 4b - Implant du protocole «1 prod. 1 conso. non bloqué» 1 tableau partagé : mémoire circulaire. 2 indices : FuturDepot (0), FuturRetrait (0) 1 sémaphore compteur : NbCaseVide (N), 1 variable partagée : NbCasePleine (0), + 1 sémaphore binaire i : MutexNbCasePleine (1) Pour éviter de bloquer le consommateur : on remplace le sémaphore compteur de cases pleines par une variable partagée protégée par une mutex. C1 NbCaseVide FuturRetrait P1 MutexNbCaseVide FuturDepot NbCasePleine 4c - Code source du «prod. conso. non bloqué» /* Le producteur */ /* Le Consommateur */ While (!fin) Tab[FuturDep] = msg; wait(mutexnbcasepleine); NbCasePleine++; signal(mutexnbcasepleine); While (!fin) wait(mutexnbcasepleine); NbCasePleine++; signal(mutexnbcasepleine); msg = Tab[FuturRet]; Utilisation «croisée» du sémaphore compteur et du compteur (associé à son sémaphore de mutex) Exclusions mutuelles minimales (maj d un compteur) 3. Les 3

4 1 - Principe du protocole : Les données sont lues sans être détruites. Lectures concurrentes (sans exclusion mutuelle entre lecteurs). Ecriture exclusive. 2 - Stratégies de ré-allocation des rsrcs du Hyp : lecture en cours et écriture en attente, puis nouvelle requête de lecture : lecteur lecteur lecteur lecteur lecteur lecteur attente??? lecteur Solution immédiate : démarrage d une nouvelle lecture. parallélisme élevé mais risque de famine du!! Pas d attente active et pas de mutex systématique sur le fichier! Définition de stratégies possibles : Priorité aux lecteurs (famine s??) Priorité aux s (famine lecteurs??) FIFO (pas de famine mais parallélisme non optimal) 3a Implant. avec priorité aux lecteurs : /* Un redacteur */ /* Writing file */ 1 compteur partagé (NbLecteur), 1 sémaphore d exclusion mutuelle entre lecteurs sur leur compteur partagé (MutexNbLecteur), 1 sémaphore d exclusion mutuelle globale sur le fichier, entre un et tout autre processus (MutexAcces). /* Un lecteur */ wait(mutexnblecteur); NbLecteur++; if (NbLecteur == 1) signal(mutexnblecteur); /* Reading file */ wait(mutexnblecteur); NbLecteur--; if (NbLecteur == 0) signal(mutexnblecteur); 3b Implant. avec priorité aux lecteurs : Remarques : Ce protocole applicatif de synchronisation repose sur deux éléments : Un compteur de lectures en cours (NbLecteur),( ) partagé et protégé par une mutex (MutexNbLecteur), Un sémaphore d exclusion mutuelle entre chaque et les lecteurs (MutexAcces). Une subtilité de ce protocole est d utiliser le sémaphore MutexNbLecteur à la fois pour protéger les accès au compteur partagé NbLecteur et pour bloquer les lecteurs suivants lorsqu un premier lecteur est lui-même bloqué par un (bloqué sur wait(mutexacces)). 4a Implant. avec priorité aux s: Objectif : rendre exclusif un avec tout lecteur ou tout autre (comme précédemment), autoriser un seul lecteur à la fois, en l absence de s, toujours laisser passer un quand le fichier redevient libre et que des s et des lecteurs sont en attentes. il y a risque de famine des lecteurs Cette configuration correspond à des applications où l on fait attendre les lecteurs plutôt que de leur donner accès à des informations périmées. Attente 1 Attente 2 lecteur lecteur 4b Implant. avec priorité aux s: Ressources utilisées : Initialisation : 1 sémaphore d exclusion mutuelle entre lecteurs 1 (MutexLecteurs) 1 sémaphore binaire indiquant l absence de s 1 actif ou en attente (PasDeRedacteur) 1 compteur partagé NbRedacPresents, des s en 0 attente ou actif 1 sémaphore d exclusion mutuelle entre s sur 1 leur compteur partagé (MutexNbRedacPresents) 1 sémaphore d exclusion mutuelle globale sur la réservation 1 du fichier (MutexAcces). 4

5 4c Implant. avec priorité aux s: /* Un redacteur */ /* Un lecteur */ wait(mutexnbredacpresents); NbRedacPresents++; if (NbRedacPresents == 1) wait(pasderedacteur); signal(mutexnbredacpresents); /* Ecriture */ wait(mutexnbredacpresents); NbRedacPresents--; if (NbRedacPresents == 0) signal(pasderedacteur); signal(mutexnbredacpresents); wait(mutexlecteurs); wait(pasderedacteur); signal(pasderedacteur); /* Lecture */ signal(mutexlecteurs); 3. Les Programmation «SPMD» 1 Définition du «SPMD» SPMD : Simple Program and Multiple Data Le même programme est exécuté sur chaque processeur ou dans chaque processus. Chaque processus possède un numéro différent. Selon son n un processus exécute un code un peu différent des autres, ou travaille sur des données différentes. if (me == 0) print(«debut des calculs»); cacul(tab[me]); barrier(); print(«fin des calculs»); else calcul(tab[me]); barrier(); 2a - Méthode de programmation SPMD : le processus principal installe le système multiprocessus tous les processus exécutent les mêmes routines de calcul les processus se synchronisent sur des s de synchro le processus principal termine le programme init Crée process fin Données Simple et parallèle, mais réservé à des problèmes «réguliers» 2b Implantation en sémaphore d une «unique» : 1 sémaphore générique 1 sémaphore binaire 1 compteur partagé Processus : en nombre connu (P) int LocCount; if (P > 1) wait(semmut) ShCount++; LocCount = ShCount; signal(semmut); if (LocCount == P) /*ShCount = 0;*/ signal(semx,p-1); else wait(semx,1); Sem SemMut 1; Sem SemX 0; int ShCount 0; Nombre d opérations sur sémaphores : NbOp = 3.P Principal inconvénient : une mutex, source de congestion et de ralentissement de la. mais utilisable une seule fois (pas d enchaînement)! 2c Implant. en sémaphores d une «réutilisable» : 2 sémaphores génériques 1 sémaphore binaire 1 compteur partagé 1 index partagé int LocCount; int i = ShIndex; if (P > 1) wait(semmut) ShCount++; LocCount = ShCount; signal(semmut); if (LocCount == P) ShCount = 0; ShIndex = 1 ShIndex; signal(semx[i],p-1); else wait(semx[i],1); Nbr de processus connu (P) Sem SemMut 1; Sem SemX[2] 0; int ShCount 0; int ShIndex 0; Nombre d opérations sur sémaphores : NbOp = 3.P Principal inconvénient : une mutex, source de congestion et de ralentissement de la. 5

6 2d Implantation en sémaphore d une «unique» : 2 sémaphores Processus : nombre et numéros connus NbOp = 2.P et pas de mutex Sem Sem0 0; Sem SemAll 0; if (P > 1) // Si il y a bien plusieurs processus : if (Me == 0) // - Processus 0 (existe toujours!) wait(sem0,p-1); signal(semall,p-1); else // - Autres processus signal(sem0,1); wait(semall,1); mais utilisable une seule fois (pas d enchaînement)! 2e Implant. en sémaphores d une «réutilisable» Barrière réutilisable, 3 sémaphores, et 1 index partagé Processus : nombre et numéros connus int index; Sem Sem0 0; Sem SemAll[2] 0,0; int ShIndex 0; if (P > 1) // Si il y a bien plusieurs processus : index = ShIndex; // - Copie locale de l index des Sem. if (Me == 0) // - Processus 0 (existe toujours!) wait(sem0,p-1); ShIndex = 1-ShIndex; signal(semall[index],p-1); else // - Autres processus signal(sem0,1); wait(semall[index],1); NbOp = 2.P et pas de mutex Plusieurs s peuvent se suivre. SPMD & Ecluse de synchronisation 3a - Méthode de programmation SPMD «relaxée» : toujours les principes du SPMD un processus ne peut sortir d une portion de code (l écluse) que lorsque tous y sont entrés. init Crée process Entrée écluse Sortie écluse fin Données Entrée écluse Sortie écluse Entrée écluse Sortie écluse Rmq : une écluse peut facilement être implantée en sémaphores 3b Implantation en sémaphore d une écluse «unique» : 1 sémaphore, 1 sémaphore binaire, 1 compteur partagé Processus : nombre connu void EntreeEcluse(void) Sem MutexShCounter 1; wait(mutexshcounter); Sem SemEcluse 0; if (ShCounter < P-1) int ShCounter 0; ShCounter++; else signal(semecluse,p); ShCounter = 0; void SortieEcluse(void) signal(mutexshcounter); wait(semecluse,1); mais écluse utilisable une seule fois (pas d enchaînement, pas d emboitement)! 3c Implantation en sémaphore d une écluse nommée : n sémaphores, n sémaphores binaires, n compteurs partagés Processus : nombre connu void EntreeEcluse(int index) Sem MutexShCnt[n] 1,,1; Sem SemEcluse[n] 0,,0; assert(index < IndexMax); wait(mutexshcnt[index]); if (ShCt[index] < P-1) ShCnt[index]++; else int ShCnt[n] 0,,0; signal(semecluse[index],p); ShCnt[index] = 0; signal(mutexshcnt[index]); void SortieEcluse(int index) assert(index < IndexMax); wait(semecluse[index],1); Des écluses différentes peuvent s emboîter ou se suivre. 3d Implantation en sémaphore d une écluse enchaînable : 2 sémaphores, 2 sémaphores binaires, 2 compteurs partagés Un tableau de P indexes Processus : nombre et n connus void EntreeEcluse(void) Sem MutexShCnt[2] 1,1; Sem SemEcluse[2] 0,0; Idx = TabIdx[Me]; int ShCnt[2] 0,0; wait(mutexshcnt[idx]); if (ShCt[Idx] < P-1) ShCnt[Idx]++; else signal(semecluse[idx],p); ShCnt[Idx] = 0; signal(mutexshcnt[idx]); int TabIdx[P] 0,,0; void SortieEcluse() Idx = TabIdx[Me]; wait(semecluse[idx],1); TabIdx[Me] = 1-Idx; Des écluses peuvent se suivre (mais pas s emboiter). 6

7 3. Les 3. Les FIN 7