Cours 02 – Synchronisation Linux

ELE-784 Ordinateurs et programmation système

Cours #2 Synchronisation dans un OS multitâches Bruno De Kelper Site internet : http://www.ele.etsmtl.ca/academique/ele784/ Cours # 2

ELE784 - 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 3. Verrou et contention 4. Inter-blocage et auto-blocage 2. Protection des ressources 1. Quand le faire ? 2. Quoi protéger ? 3. Catégorie de protection 2. Méthodes de synchronisation du noyau 1. Opérations atomiques 2. Verrou tournant et sémaphore 3. Variables de terminaison 4. 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 » 7. Verrous séquentiels Cours # 2

Cours # 2



2

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

-

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.

Pseudo-concurrence ISR

Tâche 1

Ressource

Plusieurs processeurs

-

Vrai-concurrence

Plusieurs tâches, placées sur différents processeurs, peuvent vouloir accéder à la même ressource.

CPU-A Tâche 1 Cours # 2

Tâche 2

préemption

interruption

CPU-B

Ressource

accès

Tâche 2

accès


3

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

-

Tâche 1

Un Softirq ou un Tasklet peut être démarré ou cédulé n’importe quand. Tâche 1

Softirq

-

Une tâche-noyau peut préempter une autre tâche-noyau moins prioritaire. Tâche 1

-

Tâche 1

Tâche 2

Plusieurs processeurs peuvent exécuter des tâches-noyau en même temps. CPU-A Tâche 1 Cours # 2

Cours # 2

Tâche 2

Une tâche-noyau peut s’endormir (se placer en attente d’un événement). zz Zz

-

Tasklet

Ressource

CPU-B Tâche 2



4

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 ? Tâche 1 Ressource Tâche 2

Cours # 2


5

Introduction - synchronisation du noyau 1.1.1 - Concurrence, conditions de course et synchronisation Lorsque plus d’un tâche accède à une ressource en même temps.

Collision :

Par exemple :

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

Ce qu’il arrive en fait

Mémoire

Mémoire

CPU-A Tâche 1 Reg

Lit X Reg++ Écrit X

7

CPU-A

X 7

8 8

8 8

CPU-B Reg Tâche 2

8 9

9 Cours # 2

Cours # 2

CPU-B

Tâche 1 Reg

9



7

X 7

8 8

Reg Tâche 2

7 8

8

8


Et cela peut arriver aussi avec des tâches sur un même processeur



6

3

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

Appelsystème

Priorité

Tranche de temps

Attente sur un verrou

Tâche 1

CPU Tâche 5

Tâche 2 Ordonnanceur Cours # 2


7

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

Mu tex

e de iabl on r a V inais term

re apho Sém écrivain ur / Lecte

Cours # 2

Cours # 2

é Verrou s

quentiel

n r a tio Opé ique a to m

ore aph

Désa de la ctivation préem ption

Tâche 2

Ressource

Tâche 1 Sp i n lo ck

Sém

Lec

Spin teur lock / éc riva in



8

4

Introduction - synchronisation du noyau 1.1.2 - Région critique et opérations atomiques Région critique :

Code ou opération atomique : - Morceau de code qui s’exécute en une seule fois, sans aucune interruption.

- Morceau de code qui accède à une ressource partagée. Mémoire

Mémoire

CPU-A

CPU-A

Tâche 1 Reg


Région critique

7

X 7

8 8

8

Tâche 1 Reg

Opération atomique

7 X++

X 7

8 8

8

Les 3 opérations sont faites en une fois comme si s’était une seule opération

Cours # 2


9

Introduction - synchronisation du noyau 1.1.3 – Verrou et Contention Verrou :

Contention :

- C’est un mécanisme qui permet de capturer une ressource afin d’être seul à pouvoir l’utiliser. Tâche 1

Tâche 1

Tâche 1

Demande

Ressource A (Disponible) Utilise

Libère

Cours # 2

Cours # 2

Ressource A (Verrouillée)

Ressource A (Disponible)

- Lorsqu’un verrou appartient à une tâche et que d’autres tâches essayent de le capturer. - 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. Défaut de programmation



10

5

Introduction - synchronisation du noyau 1.1.3 – Verrou et Contention Tâche-usager : - Une tâche-usager qui tient un verrou peut être préemptée ou interrompue. Tâche 1

ISR

Tâche 2

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 Tâche 1

ISR

Cours # 2

X

Tâche 2


11

Introduction - synchronisation du noyau 1.1.4 - Inter-blocage et auto-blocage Inter-blocage :

Auto-blocage :

- Deux tâches ou plus qui tiennent une ressource et qui veulent capturer la ressource de l’autre. possède

Ressource A

- Une tâche qui tente de capturer une ressource qu’elle tient déjà.

possède requête

Tâche 1 I

e nt

r-b

l

e ag c o

Ressource A Tâche 2

Tâche 1

requête Auto-blocage

requête Ressource B

possède

Défaut de synchronisation Cours # 2

Cours # 2

Défaut de programmation



12

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


13

Introduction - synchronisation du noyau 1.2 – Protection des ressources 1.2.3 – 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 :

Cours # 2

Cours # 2

Est protégé des accès concurrents dans un système multiprocesseurs symétrique.



14

7

Méthodes de synchronisation du noyau 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(3); Utilisation d’une variable atomique : atomic_set (&v, 4); atomic_add (2, &u); atomic_inc (&v); int x = atomic_read(&v); atomic_dec_and_test (&u); Cours # 2

Variable pré-initialisée

équivalent à v = 4; u = u + 4; v = v + 1;

Il y en a plusieurs autres

x = v; u = u – 1; et retourne Vrai si u = 0 après.


15

Méthodes de synchronisation du noyau 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

Non-atomique

set_bit (4, &y); clear_bit (2, &y); change_bit (8, &y); test_bit (21, &y); test_and_set_bit (15, &y); test_and_clear_bit (3, &y); test_and_change_bit (7, &y); Cours # 2

Cours # 2

__set_bit (4, &y); __clear_bit (2, &y); __change_bit (8, &y); __test_bit (21, &y); __test_and_set_bit (15, &y); __test_and_clear_bit (3, &y); __test_and_change_bit (7, &y);



16

8

Méthodes de synchronisation du noyau 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_libère (int *verrou) { clear_bit (0, verrou); }

void Verrou_capture (int *verrou) { while (! test_and_set_bit (0, verrou)); }

Cours # 2

Opération atomique pour changer l’état du verrou


17

Méthodes de synchronisation du noyau 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. -

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 : Code atomique Cours # 2

Cours # 2

Monoprocesseur Désactive la préemption sur le processeur.

spinlock_t my_lock = SPIN_LOCK_UNLOCKED; spin_lock (&my_lock); spin_unlock (&my_lock);

Déclaration

Utilisation Région critique



18

9

Méthodes de synchronisation du noyau 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); } } Cours # 2

void Libère_sem (atomic_t *sem) { atomic_inc (sem); } La capture et la libération doit être faite de façon atomique.


19

Méthodes de synchronisation du noyau 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 3 choses avec un sémaphore : Initialiser

Capturer

Libérer

Appelé down() Cours # 2

Cours # 2

Appelé up()



20

10

Méthodes de synchronisation du noyau 2.2 – Verrou tournant et sémaphore Création d’un sémaphore : manière statique

static DECLARE_SEMAPHORE_GENERIC (my_sem, 3); static DECLARE_MUTEX (my_sem);

équivalent si égal à 1

struct semaphore my_sem; manière dynamique

sema_init (&my_sem, 3); init_MUTEX (&my_sem);

équivalent si égal à 0 1 init_MUTEX_LOCKED (&my_sem);

Utilisation d’un sémaphore : Capture ou dort en état TASK_UNINTERRUPTIBLE.

down (&my_sem); down_interruptible (&my_sem); down_trylock (&my_sem); up (&my_sem); Cours # 2

Capture ou dort en état TASK_INTERRUPTIBLE.

Tente de capturer (si oui, retourne 0), mais ne dort pas. Libère le sémaphore ou le Mutex.


21

Méthodes de synchronisation du noyau 2.3 – 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 DECLARE_COMPLETION (ma_var); statique manière dynamique

struct completion ma_var; init_completion (&ma_var);

C’est un mécanisme simple et léger de synchronisation de deux tâches

Utilisation d’un sémaphore : wait_for_completion (&ma_var); complete (&ma_var); Cours # 2

Cours # 2

Attend le signal de fin d’utilisation.

Envoi le signal de fin d’utilisation.



22

11

Méthodes de synchronisation du noyau 2.4 – 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 ( );

Désactive la préemption du noyau et compte.

preempt_enable ( );

Décompte et réactive la préemption du noyau lorsque le compte est à zéro.

preempt_count ( );

Retourne le compte actuel.

Cours # 2


23

Méthodes de synchronisation du noyau 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; b = 2;

b = 2; 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

Cours # 2

est exécutée dans l’ordre



24

12

Méthodes de synchronisation du noyau 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 ( );

Barrière de lecture.

umb ( );

Barrière d’écriture.

mb ( );

Barrière de lecture et d’écriture.

read_barrier_depends ( );

Cours # 2

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.


25

Méthodes de synchronisation du noyau 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 : Avec la barrière Sans la barrière A = 3; B = 4;

C = B; D = A;

Mémoire CPU-A Tâche 1

4

C = B;

mb();

CPU-B

CPU-A

B 2

1

2

1

Reg → A 3 Reg ← 4 4

Reg → C

Reg → B 4

3

Tâche 2

Tâche 1

Reg ← A

Reg ← 3

Reg

1

4

1

4

1 Reg → D 4 Reg ← B

Reg → A 3

3

4

4

3

D = A; CPU-B

A 1

B 2

1

2

2

3

2

3

2

2 Reg → C 3 Reg ← A

4

3

Reg

Reg → B 4 Reg ← 3 3

rmb();

Mémoire

B = 4;

A 1 Reg

Reg ← 4

A = 3;

Tâche 2 Reg

Reg ← B

Reg → D

Et cela peut arriver aussi avec des tâches sur un même processeur Cours # 2

Cours # 2



26

13

Méthodes de synchronisation du noyau 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;

Déclaration

read_lock (&my_rwlock);

write_lock (&my_rwlock);

Région critique : Lecteur

Région critique : Écrivain

read_unlock (&my_rwlock);

write_unlock (&my_rwlock);

Cours # 2


27

Méthodes de synchronisation du noyau 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 struct rw_semaphore rw_sem;

manière dynamique

init_rwsem (&rw_sem);

Utilisation

Aussi

down_read (&rw_sem);

down_write (& rw_sem);

Région critique : Lecteur

Région critique : Écrivain

up_read (&rw_sem);

up_write (& rw_sem);

down_read_trylock (&rw_sem);

down_write_trylock (& rw_sem);

downgrade_writer (&rw_sem); Cours # 2

Cours # 2



28

14

Méthodes de synchronisation du noyau 2.7 – 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


29

Méthodes de synchronisation du noyau 2.7 – Verrous séquentiels Déclaration

seqlock_t mon_seq = SEQLOCK_UNLOCKED;

Utilisation Côté lecteur : unsigned long seq; Boucle tant qu’il change.

Nécessaire pour recevoir la copie du numéro de séquence (unsigned long).

do { seq = read_seqbegin (&mon_seq);

Région critique : Lecteur } while (read_seqretry(&mon_seq, seq));

Prend la copie du numéro de séquence. Compare la copie du numéro de séquence.

Côté écrivain : write_seqlock (&mon_seq);

Région critique : Écrivain write_sequnlock (&mon_seq); Cours # 2

Cours # 2

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.



30

15

Cours 02 – Synchronisation Linux

Cours 02 – Synchronisation Linux

Suggest Documents

Cours Linux - Free

Cours de S.E. – Coopération, exclusion mutuelle, synchronisation ...

Support de cours - linux | EPFL

Cours : les Concepts de la Synchronisation - Cedric - Cnam

Cours 3: Synchronisation entre processus : suite de l'étude des ...

Calcul Parall`ele Cours 4 - JAVA/CUDA et synchronisation Eric ...

Partiel 2004-2005 1 Questions de cours 2 Synchronisation de ...

Synchronisation

Instructeur PAC - Cours de rafraÃ®chissment 02-15f.pdf - Google Drive

Cours

Cours

Synchronisation Licence Fact Sheet

Synchronisation par tubes

Cours

Cours

Aspects of Synchronisation

La synchronisation - EMC

Synchronisation getrennter Ethernets

Yeast colony synchronisation - CiteSeerX

Aspects of Synchronisation

Time reversal time-domain synchronisation

One node driving synchronisation - arXiv

Workload measurements and synchronisation - CiteSeerX

Data synchronisation layer Authors - MODAClouds