Multi-threading. Mécanismes de Synchronisation

Transcription

1 Multi-threading Mécanismes de Synchronisation 1

2 Exclusion Mutuelle - Mutex Producteurs / Consommateur - Sémaphores 2

3 Accès en Exclusion Mutuelle Exemple d'une liste d'objects partagée: Gérée en LIFO (Last In, First Out) Dernier inséré = Premier retiré 1) liste vide 3) après insertion de obj2 NULL 2) après insertion de obj1 obj2 NULL obj1 NULL obj1 4) après retrait du premier élément NULL obj1 3

4 Listes LIFO - API(1) typedef struct { void* next; /* address of next item */ } item_t; typedef struct { item_t* last; /* address of last item */ } lifo_t; 4

5 Listes LIFO - API(2) #define LIFO_INIT(lifo) \ (lifo)->last = (s_link_t*)(null) #define LIFO_IS_EMPTY(lifo) \ ((lifo)->last == (s_link_t*)null) #define LIFO_INSERT(lifo, item) \ ((s_link_t*)(item))->next = (lifo)->last, \ (lifo)->last = (s_link_t*)(item) #define LIFO_REMOVE(lifo, ItemType) \ (ItemType*) (lifo)->last; \ (lifo)->last = (s_link_t*)(lifo)->last->next 5

6 Thread_1: LIFO_INSERT(lifo, obj_1); Thread_2: LIFO_INSERT(lifo, obj_2); A l'exécution, avec préemption de Thread_1 par Thread_2: Thread_1: Thread_2: Accès Concurrents obj_1 >next = lifo >last, /* NULL */ obj_2 >next = lifo >last, /* NULL */ lifo >last = (s_link_t*)(obj_2); Thread_1: lifo >last = (s_link_t*)(obj_1); 6

7 Accès Concurrents État initial de la liste NULL Thread_1 en cours d'exécution obj_1 >next = lifo >last, NULL obj1 Thread_2 préempte Thread_1 obj_2 >next = lifo >last, lifo >last = obj2;... Thread_2 se bloque Thread_1 reprend son exécution obj2 NULL lifo >last = obj_1; obj1 NULL 7

8 Outil de Synchronisation : Garantir accès exclusif aux objects partagés entre plusieurs threads concurrentes Objet composé Etat : libre / occupé Mutex Liste des threads en attente du mutex Modèle de Programmation mutex_acquire(&mutex); // if owned, block thread /* access shared object */ mutex_release(&mutex); // release ownership 8

9 void lifo_insert_obj(obj_t *obj) { mutex_acquire(&lifo_mutex); LIFO_INSERT(&the_lifo, obj); mutex_release(&lifo_mutex); } obj_t* lifo_remove_obj() { obj_t *obj = NULL; } Mutex Programming: exemple mutex_acquire(&lifo_mutex); if (! LIFO_IS_EMPTY(&the_lifo)) { obj = LIFO_REMOVE(&the_lifo, obj_t); } mutex_release(&lifo_mutex); return obj; 9

10 Mutex (2) Support de la récursivité La même thread peut-elle acquérir le même mutex plusieurs fois? doit mémoriser la thread propriétaire du mutex et compter le nombre d'acquisitions Ordonnancement des threads en attente FIFO (First In, First Out) En fonction de leur priorité plus complexe & coûteux à réaliser risque de privation 10

11 Mutex (3) Lorsque des threads sont en attente quand le mutex est relâché Mettre le mutex dans l'état libre Réveiller première thread en attente Thread + prioritaire peut [re]prendre le mutex entre-temps Solution Laisser le mutex dans l'état occupé Réveiller première thread en attente 11

12 Mutex (4) Situations d'inter-blocages (deadlock) 1) Thread_1 acquiert mutex_1 2) Thread_2 acquiert mutex_2 3) Thread_2 veut acquérir mutex_1 => bloquée 4) Thread_1 veut acquérie mutex_2 => bloquée Détection coûteuse à mettre en oeuvre Pas de correction possible à l'exécution Remède pire que le mal! 12

13 Problème de l'inversion de Priorités Priorité(T1) < Priorité(T2) < Priorité(T3) T1 acquiert mutex M1 T1 préemptée par T3 T3 blocquée en voulant acquérir mutex M1 T1 préemptée par T2 Inverse l'ordre d'exécution de T2 et T3 13

14 Mutex et Inversion de Priorités Mémorise thread propriétaire du mutex Attribue temporairement à la thread propriétaire la priorité de la thread en attente ayant la plus haute priorité Quand thread propriétaire libére le mutex transmet la propriété du mutex à la première thread en attente du mutex Si sa priorité a été changée, reprend sa priorité initiale 14

15 Exclusion Mutuelle - Mutex Producteurs / Consommateurs - Sémaphores 15

16 Producteurs / Consommateurs état d'un capteur Lu périodiquement par 1 thread représenté par une structure de données Inséré dans une liste (FIFO) évènement notifié à thread de traitement Modèle producteur/consommateur 1 thread produit les états du capteur 1 thread moins prioritaire traite les états du capteur 16

17 Modélisation des Echanges Liste (FIFO) des états du capteur Thread productrice insère nouveaux états dans FIFO Thread de traitement retire les états de la FIFO Tant que la FIFO est vide, doit être mise en attente Doit être réveillée lorsqu'un état est inséré dans la FIFO 17

18 Sémaphores à Compteur (1) Sémaphore comprend Un compteur (entier signé) Une liste (FIFO) de threads en attente Valeur du compteur >= 0 : nombre d'objets produits < 0 : nombre de threads en attente Opérations sur sémaphore sema_init(&sema, counter_init_value) sema_put(&sema) sema_get(&sema) 18

19 Semaphore Programming void capteur_state_provide(state_t *st) { mutex_acquire(&capteur_fifo_mutex); FIFO_INSERT(&capteur_state_fifo, st); mutex_release(&capteur_fifo_mutex); sema_put(&capteur_sema); } state_t* capteur_state_consume() { state_t *st; } sema_get(&capteur_sema); mutex_acquire(&capteur_fifo_mutex); st = FIFO_REMOVE(&capteur_fifo, state_t); mutex_release(&capteur_fifo_mutex); return st; 19

20 Sémaphores à Compteur (2) sema_put(sema_t *sema) compteur--; si (compteur < 0) - insérer thread courante dans FIFO d'attente - bloquer thread courante sema_put(sema_t *sema) compteur++; si (compteur <= 0) - retirer première thread de la FIFO d'attente - réveiller cette thread 20

21 Sémaphores à Compteur (3) Opérations sema_put() et sema_get() exécutées par threads concurrentes => accès en exclusion mutuelle à l'état du sémaphore (compteur, FIFO) Utilisent mécanismes de synchronisation de plus bas niveau dans le système 21