Cours #2 Synchronisation dans un OS multitâches

ELE- Ordinateurs et programmation système Cours #2 Synchronisation dans un OS multitâches Bruno De Kelper Site internet : http://www.ele.etsmtl.ca/academique/ele/ Cours # 2 ELE - Ordinateurs et programmation système 1 Plan d aujourd hui 1. Introduction - synchronisation du noyau 1. Notions de base 1. Concurrence, conditions de course et synchronisation 2. Région critique et opérations atomiques. Verrou et contention. Inter-blocage et auto-blocage 2. Protection des ressources 1. Quand le faire? 2. Quoi protéger?. Catégorie de protection 2. 1. Opérations atomiques 2. Verrou tournant et sémaphore. Variables de terminaison. Désactivation de la préemption du noyau 5. Séquence d exécution et barrières 6. Verrou tournant et sémaphore «lecteur / écrivain». Verrous séquentiels Cours # 2 ELE - Ordinateurs et programmation système 2 Cours # 2 ELE - Ordinateurs et programmation système 1

Introduction - synchronisation du noyau 1.1 - Notions de base Protéger l accès concurrent aux ressources partagées est particulièrement important dans les systèmes multiprocesseurs 1.1.1 - Concurrence, conditions de course et synchronisation Concurrence : Même processeur Pseudo-concurrence - Dans un système multitâches préemptif, une tâche peut être préemptée par une autre tâche plus prioritaire. - Une tâche peut être interrompue par une interruption asynchrone. ISR interruption préemption Plusieurs processeurs Vrai-concurrence - Plusieurs tâches, placées sur différents processeurs, peuvent vouloir accéder à la même ressource. accès Ressource Ressource accès CPU-B Cours # 2 ELE - Ordinateurs et programmation système Introduction - synchronisation du noyau 1.1.1 - Concurrence, conditions de course et synchronisation Concurrence : La concurrence dans le noyau - Les interruptions se produisent de façon asynchrone. ISR - Un Softirq ou un Tasklet peut être démarré ou cédulé n importe quand. Softirq Tasklet - Une tâche-noyau peut préempter une autre tâche-noyau moins prioritaire. - Une tâche-noyau peut s endormir (se placer en attente d un événement). - Plusieurs processeurs peuvent exécuter des tâches-noyau en même temps. Zzzz Ressource CPU-B Cours # 2 ELE - Ordinateurs et programmation système Cours # 2 ELE - Ordinateurs et programmation système 2

Introduction - synchronisation du noyau 1.1.1 - Concurrence, conditions de course et synchronisation Ressources : - Processeur : Temps d exécution - Mémoire : Données (variable simple, structures, tableaux, ) - Périphériques : Disque (fichiers, matériel), Entrées/Sorties (écran, clavier, canaux de communication, ), Matériel (contrôleur d interruptions, compteurs, horloge, ) Conditions de course : - Lorsque plus qu un morceau de code, une tâche, veut utiliser la même ressource. - Seulement une tâche peut utiliser la ressource à un instant donné. - La première arrivée? Ressource Cours # 2 ELE - Ordinateurs et programmation système 5 Introduction - synchronisation du noyau 1.1.1 - Concurrence, conditions de course et synchronisation Collision : Par exemple : Lit X ++ Écrit X Lorsque plus d un tâche accède à une ressource en même temps. Supposons qu on veux compter le nombre de fois total que 2 tâches s exécutent, à l aide d un compteur X. Ce qu on voudrait qu il arrive Mémoire X 9 9 9 CPU-B Lit X ++ Écrit X Lit X ++ Écrit X Ce qu il arrive en fait Mémoire X CPU-B Lit X ++ Écrit X Et cela peut arriver aussi avec des tâches sur un même processeur Cours # 2 ELE - Ordinateurs et programmation système 6 Cours # 2 ELE - Ordinateurs et programmation système

Introduction - synchronisation du noyau 1.1.1 - Concurrence, conditions de course et synchronisation Synchronisation : - Il s agit de s assurer que l accès aux ressources est contrôlé. - Les tâches peuvent utiliser la ressource à tour de rôle. - La synchronisation est une stratégie pour permettre l accès à une ressource : - Premier arrivé? - Plus rapide d exécution? - Plus prioritaire? - Besoin de plusieurs ressources? Pour l accès au processeur, c est l ordonnanceur qui s en occupe Priorité Appelsystème Tranche de temps Attente sur un verrou CPU Tâche 5 Ordonnanceur Cours # 2 ELE - Ordinateurs et programmation système Introduction - synchronisation du noyau 1.1.2 - Région critique et opérations atomiques Synchronisation : Pour le reste, il faut prévoir des mécanismes d accès Mutex Sémaphore Lecteur / écrivain Variable de terminaison Sémaphore Désactivation de la préemption Ressource Spin lock Verrou séquentiel Opération atomique Spin lock Lecteur / écrivain Cours # 2 ELE - Ordinateurs et programmation système Cours # 2 ELE - Ordinateurs et programmation système

Introduction - synchronisation du noyau 1.1.2 - Région critique et opérations atomiques Région critique : - Morceau de code qui accède à une ressource partagée. Région critique Lit X ++ Écrit X Mémoire X Code ou opération atomique : - Morceau de code qui s exécute en une seule fois, sans aucune interruption. Opération atomique X++ Mémoire X Les opérations sont faites en une fois comme si s était une seule opération Cours # 2 ELE - Ordinateurs et programmation système 9 Introduction - synchronisation du noyau 1.1. Verrou et Contention Verrou : - C est un mécanisme qui permet de capturer une ressource afin d être seul à pouvoir l utiliser. Contention : - Lorsqu un verrou appartient à une tâche et que d autres tâches essayent de le capturer. Demande Utilise Ressource A (Disponible) Ressource A (Verrouillée) - On parle de contention élevée lorsque : - Un verrou est capturer fréquemment. - Un verrou est tenu pendant longtemps. - Une contention élevée devient un goulot d étranglement pour le système. Libère Ressource A (Disponible) Défaut de programmation Cours # 2 ELE - Ordinateurs et programmation système 10 Cours # 2 ELE - Ordinateurs et programmation système 5

Introduction - synchronisation du noyau 1.1. Verrou et Contention Tâche-usager : - Une tâche-usager qui tient un verrou peut être préemptée ou interrompue. ISR Tâche-noyau : - Une tâche-noyau qui tient un verrou ne peut pas être préemptée. - Une tâche-noyau peut être interrompue ISR X Cours # 2 ELE - Ordinateurs et programmation système 11 Introduction - synchronisation du noyau 1.1. - Inter-blocage et auto-blocage Inter-blocage : - Deux tâches ou plus qui tiennent une ressource et qui veulent capturer la ressource de l autre. possède requête Ressource A Inter-blocage Ressource B requête possède Auto-blocage : - Une tâche qui tente de capturer une ressource qu elle tient déjà. possède requête Ressource A Auto-blocage Défaut de synchronisation Défaut de programmation Cours # 2 ELE - Ordinateurs et programmation système 12 Cours # 2 ELE - Ordinateurs et programmation système 6

Introduction - synchronisation du noyau 1.2 Protection des ressources 1.2.1 Quand le faire? Toujours prévoir la protection des ressources dés le début de la conception du code et non lorsqu il devient absolument nécessaire. 1.2.2 Quoi protéger? Besoin de protection Pas besoin de protection - Toute donnée qui est globale a probablement besoin de protection. - Toute donnée qui est partagée entre le contexte-processus et le contexte-interruption. - Toute donnée partagée entre des routines d interruptions. - La question à se poser est : Est-ce que la donnée peut être accédée par d autres? - Une donnée qui est locale à une tâche. - Toute donnée qui est créée dynamiquement par une tâche n existe que sur la pile de la tâche. Cours # 2 ELE - Ordinateurs et programmation système 1 Introduction - synchronisation du noyau 1.2 Protection des ressources 1.2. Catégorie de protection Préemption-sûr : Est protégé des accès concurrents avec la préemption du noyau. Interruption-sûr : Est protégé des accès concurrents de routines d interruptions. SMP-sûr : Est protégé des accès concurrents dans un système multiprocesseurs symétrique. Cours # 2 ELE - Ordinateurs et programmation système 1 Cours # 2 ELE - Ordinateurs et programmation système

2.1 Opérations atomiques Le noyau de Linux fournit 2 ensembles d opérations atomiques : Opérations entières atomiques : Type de donnée spéciale atomic_t - Ces variables ne peuvent être utilisées qu au travers d instructions spéciales. - Ces opérations sont exécutées sans aucune interruption. Création d une variable atomique : atomic_t v; atomic_t u = ATOMIC_INIT(); Variable pré-initialisée Utilisation d une variable atomique : équivalent à atomic_set (&v, ); v = ; atomic_add (2, &u); u = u + ; atomic_inc (&v); v = v + 1; int x = atomic_read(&v); x = v; Il y en a plusieurs autres atomic_dec_and_test (&u); u = u 1; et retourne Vrai si u = 0 après. Cours # 2 ELE - Ordinateurs et programmation système 15 2.1 Opérations atomiques Opérations binaires atomiques : - Ces opérations peuvent agir sur les bits de n importe quel type de données. - Elles doivent recevoir un pointeur vers la variable à traiter. - Ces opérations sont exécutées sans aucune interruption. - Les opérations non-atomiques équivalentes portent le même nom mais sont précédées d un double sous-ligné. Opérations : Atomique set_bit (, &y); clear_bit (2, &y); change_bit (, &y); test_bit (21, &y); test_and_set_bit (15, &y); test_and_clear_bit (, &y); test_and_change_bit (, &y); Non-atomique set_bit (, &y); clear_bit (2, &y); change_bit (, &y); test_bit (21, &y); test_and_set_bit (15, &y); test_and_clear_bit (, &y); test_and_change_bit (, &y); Cours # 2 ELE - Ordinateurs et programmation système 16 Cours # 2 ELE - Ordinateurs et programmation système

2.2 Verrou tournant et sémaphore Les verrous tournants et les sémaphores sont les principaux mécanismes de protection (région critique) et de synchronisation du noyau. Verrou tournant (Spin lock) : - Seule une tâche à la fois peut posséder le verrou tournant. - Il sert à créer un morceau de code atomique. - Lorsque le verrou n est pas disponible, la tâche qui désire le capturer se place en attente active (ne dort pas) jusqu à ce qu il redevienne disponible. Tourne dans une boucle inutile et consomme du temps de processeur. Exemple de code d un verrou tournant : void Verrou_capture (int *verrou) { while (! test_and_set_bit (0, verrou)); } Opération atomique pour changer l état du verrou void Verrou_libère (int *verrou) { clear_bit (0, verrou); } Cours # 2 ELE - Ordinateurs et programmation système 1 2.2 Verrou tournant et sémaphore Verrou tournant (Spin lock) : - À cause de l attente active, ce verrou ne doit pas être retenu trop longtemps. - Lorsque le verrou est capturé, la préemption du noyau est désactivée. Multiprocesseur Désactive la préemption seulement sur le processeur de la tâche qui possède le verrou. Monoprocesseur Désactive la préemption sur le processeur. - Mais les interruptions ne sont pas nécessairement désactivées. - Puisque qu il ne dort pas, il peut être utilisé dans les routines d interruptions. - ATTENTION : Ce verrou peut auto-bloquer!!! Exemple : spinlock_t my_lock = SPIN_LOCK_UNLOCKED; Déclaration Code atomique spin_lock (&my_lock); spin_unlock (&my_lock); Utilisation Région critique Cours # 2 ELE - Ordinateurs et programmation système 1 Cours # 2 ELE - Ordinateurs et programmation système 9

2.2 Verrou tournant et sémaphore Sémaphore : - Le sémaphore est un verrou dormant, s il n est pas disponible, la tâche qui le demande est placée dans une fil d attente (waiting queue). - À cause de ça, le sémaphore est utilisé seulement en contexte processus. - De plus, une tâche qui possède un verrou tournant ne peut pas tenter de capturer un sémaphore car elle pourrait dormir. - Contrairement aux verrous tournants, le sémaphore ne désactive pas la préemption du noyau et la tâche qui le tient peut être préemptée. Exemple de code d un sémaphore : void Capture_sem (atomic_t *sem) { if (atomic_add_negative (-1, sem)) { atomic_set (0, sem); sleep (current, sem); } } void Libère_sem (atomic_t *sem) { atomic_inc (sem); } La capture et la libération doit être faite de façon atomique. Cours # 2 ELE - Ordinateurs et programmation système 19 2.2 Verrou tournant et sémaphore Sémaphore : - Dépendamment de son initialisation, un sémaphore peut être tenu par une seule ou par plusieurs tâches : Valeurs possibles 0 ou 1 Sémaphore binaire, aussi appelé Mutex. Sert habituellement pour créer un morceau de code atomique dans le but de protéger l accès à une ressource. 0 ou > 0 Sémaphore compteur. Sert habituellement pour la synchronisation ou pour protéger l accès à une ressource ayant plusieurs points d accès ou instances. - De façon générale, on peut faire l une de choses avec un sémaphore : Initialiser Capturer Libérer Appelé down() Appelé up() Cours # 2 ELE - Ordinateurs et programmation système 20 Cours # 2 ELE - Ordinateurs et programmation système 10

2.2 Verrou tournant et sémaphore Création d un sémaphore : manière statique manière dynamique static DECLARE_SEMAPHORE_GENERIC (my_sem, ); static DECLARE_MUTEX (my_sem); struct semaphore my_sem; sema_init (&my_sem, ); init_mutex (&my_sem); équivalent si égal à 1 équivalent si égal à 1 0 init_mutex_locked (&my_sem); Utilisation d un sémaphore : down (&my_sem); Capture ou dort en état TASK_UNINTERRUPTIBLE. down_interruptible (&my_sem); Capture ou dort en état TASK_INTERRUPTIBLE. down_trylock (&my_sem); Tente de capturer (si oui, retourne 0), mais ne dort pas. up (&my_sem); Libère le sémaphore ou le Mutex. Cours # 2 ELE - Ordinateurs et programmation système 21 2. Variable de terminaison - Similaire aux sémaphores, elle permet à une tâche de signaler qu elle à fini à une autre tâche qui attends. - Utilisé principalement pour la synchronisation, c est-à-dire pour permettre à une tâche de dire à une autre quand faire son travail. Création d une variable de terminaison : manière statique manière dynamique DECLARE_COMPLETION (ma_var); struct completion ma_var; init_completion (&ma_var); Utilisation d un sémaphore : C est un mécanisme simple et léger de synchronisation de deux tâches wait_for_completion (&ma_var); Attend le signal de fin d utilisation. complete (&ma_var); Envoi le signal de fin d utilisation. Cours # 2 ELE - Ordinateurs et programmation système 22 Cours # 2 ELE - Ordinateurs et programmation système 11

2. Désactivation de la préemption du noyau - Comme il a été mentionné, lorsqu un verrou tournant est capturé, la préemption du noyau est désactivée. - Mais il arrive qu il soit nécessaire de désactiver la préemption du noyau sans avoir recours à un verrou tournant. - Par exemple, pour créer un morceau de code atomique de très courte durée. - La désactivation du noyau est récursive, c est-à-dire qu elle peut être faite plusieurs fois de suite et elle devra être réactivée autant fois pour être de nouveau active. Utilisation de la désactivation de la préemption du noyau : preempt_disable ( ); preempt_enable ( ); preempt_count ( ); Désactive la préemption du noyau et compte. Décompte et réactive la préemption du noyau lorsque le compte est à zéro. Retourne le compte actuel. Cours # 2 ELE - Ordinateurs et programmation système 2 2.5 Séquence d exécution et barrières Séquence d exécution : - Pour des raisons d optimisation, il arrive que les compilateurs changent l ordre d une séquence de lecture et d écriture de données au moment de la compilation. - Aussi, certains processeurs effectuent des écritures out-of-order automatiquement et qui change l ordre de séquences d écritures. - Par exemple, la séquence suivante : a = 1; est exécutée b = 2; b = 2; dans l ordre a = 1; - Du autre côté, il est parfois nécessaire de s assurer que la séquence d exécution est respectée, surtout lors d accès au matériel. - Pour forcer le respect de l ordre d une séquence, Linux fournit la notion de barrière et les fonctions qui vont avec. Cours # 2 ELE - Ordinateurs et programmation système 2 Cours # 2 ELE - Ordinateurs et programmation système 12

2.5 Séquence d exécution et barrières Barrière : - La barrière fournit un mécanisme de sérialisation, c est-à-dire d empêcher qu un réarrangement de l exécution se fasse au travers de la barrière. - Les lectures ou écritures de données se trouvant avant la barrière seront complétées obligatoirement avant. Tandis que les lectures ou écritures se trouvant après la barrière ne pourront pas être effectuées avant. Utilisation de barrières : rmb ( ); umb ( ); mb ( ); Barrière de lecture. Barrière d écriture. Barrière de lecture et d écriture. read_barrier_depends ( ); Cas particulier d une barrière d écriture où seuls les écritures dépendantes de part et d autre de la barrière sont affectées. Cours # 2 ELE - Ordinateurs et programmation système 25 2.5 Séquence d exécution et barrières Exemple de Barrière : Soit 2 tâches parfaitement synchronisées qui exécutent le code suivant : Sans la barrière Avec la barrière A = ; B = ; B A Mémoire A 1 1 1 1 B 2 2 CPU-B 1 A 1 C = B; D = A; D B C A = ; mb(); B = ; A B Mémoire A 1 1 B 2 2 2 2 CPU-B 2 B 2 C = B; rmb(); D = A; C A D Et cela peut arriver aussi avec des tâches sur un même processeur Cours # 2 ELE - Ordinateurs et programmation système 26 Cours # 2 ELE - Ordinateurs et programmation système 1

2.6 Verrou tournant et sémaphore «lecteur / écrivain» Principe du «lecteur / écrivain» : - Il n est pas nécessaire de protéger l accès à une donnée lorsqu il s agit uniquement de la lire, du moment qu elle ne change pas en cours de route. - Donc on peut permettre autant de «lecteurs» simultanés que l on veut. - Par contre, dés qu un «écrivain» accède à la donnée pour la changer, alors il doit être seul, sinon il y a un risque de collision. - Donc, les verrous «lecteur / écrivain» permettent à tous les lecteurs de capturer le verrou, du moment qu il n est pas en la possession d un écrivain. - Si un écrivain a capturé le verrou, alors aucun lecteur ne peut le prendre. Verrou tournant «lecteur / écrivain» : rwlock_t my_rwlock = RW_LOCK_UNLOCKED; read_lock (&my_rwlock); Région critique : Lecteur read_unlock (&my_rwlock); Déclaration write_lock (&my_rwlock); Région critique : Écrivain write_unlock (&my_rwlock); Cours # 2 ELE - Ordinateurs et programmation système 2 2.6 Verrou tournant et sémaphore «lecteur / écrivain» Sémaphore «lecteur / écrivain» : - Tous les sémaphores «lecteur / écrivain» sont des Mutex (0, 1). - Les sémaphores «lecteur / écrivain» placent les tâches en attente dans l état TASK_UNINTERRUPTIBLE. Déclaration manière static DECLARE_RWSEM (rw_sem); statique Utilisation manière dynamique struct rw_semaphore rw_sem; init_rwsem (&rw_sem); down_read (&rw_sem); Région critique : Lecteur down_write (& rw_sem); Région critique : Écrivain up_read (&rw_sem); up_write (& rw_sem); Aussi down_read_trylock (&rw_sem); down_write_trylock (& rw_sem); downgrade_writer (&rw_sem); Cours # 2 ELE - Ordinateurs et programmation système 2 Cours # 2 ELE - Ordinateurs et programmation système 1

2. Verrous séquentiels - Le but du verrou séquentiel est sensiblement le même que celui des verrous «lecteur / écrivain». - C est un mécanisme simple qui permet à tous les lecteurs d accéder à la donnée protégée, même si un écrivain est en action sur la donnée. - Par contre, à la fin de la lecture, le lecteur doit vérifier si la donnée a changée en cours de route et si oui, il reprend sa lecture. - L écrivain doit capturer le verrou pour accéder à la donnée. Ce faisant, il incrémente un «numéro de séquence» (devient impair). - Lorsque l écrivain libère le verrou, il incrémente de nouveau le «numéro de séquence» (devient pair). - Avant d accéder à la donnée, le lecteur prend une copie de ce «numéro de séquence». Et après avoir lut la donnée, il compare sa copie à la valeur actuelle du «numéro de séquence». S il a changé, alors un écrivain a changé la donnée. - De plus, si le «numéro de séquence» est impair, un écrivain est en train de changer la donnée, sinon il a terminé. Cours # 2 ELE - Ordinateurs et programmation système 29 2. Verrous séquentiels Déclaration Utilisation Côté lecteur : Boucle tant qu il change. Côté écrivain : seqlock_t mon_seq = SEQLOCK_UNLOCKED; unsigned long seq; do { seq = read_seqbegin (&mon_seq); Région critique : Lecteur } while (read_seqretry(&mon_seq, seq)); write_seqlock (&mon_seq); Région critique : Écrivain write_sequnlock (&mon_seq); Nécessaire pour recevoir la copie du numéro de séquence (unsigned long). Prend la copie du numéro de séquence. Compare la copie du numéro de séquence. Capture le verrou et incrémente le numéro de séquence. Libère le verrou et incrémente le numéro de séquence. Cours # 2 ELE - Ordinateurs et programmation système 0 Cours # 2 ELE - Ordinateurs et programmation système 15