Aller au contenu principal
Valrose.tech

Systèmes d'exploitation · L3 · Section 4/6

IPC & synchronisation

Progression

Points d’expérience : —XPSérie de jours consécutifs : —· —Progression du module : — / —compris

#IPC & synchronisation

#Panorama

  • Pipes/queues: passage de messages; découplent producteur/consommateur et lissent les pics.
  • Shared memory: très rapide (zéro‑copie) mais exige une stricte synchronisation.
  • Verrous/sémaphores/moniteurs: exclusion mutuelle, signaux, attente conditionnelle.

#Exemple producteur‑consommateur (pseudo‑code)

code

1buffer = Queue(max=10)2 3producer:4  loop:5    x = make_item()6    buffer.put(x)   # bloque si plein7 8consumer:9  loop:10    x = buffer.take()  # bloque si vide11    process(x)

#Diagramme: mutex + condition

Producteur
Buffer
Consommateur
1. lock → push(x) → signal
2. wait(cond) → lock → pop() → unlock

#Problèmes classiques

  • Deadlock (interblocage), livelock, famine; conditions de Coffman et évitement.

#Barrières mémoire et atomiques (pourquoi/comment)

Les architectures réordonnent les accès mémoire; des variables atomiques et fences établissent des relations happens‑before pour que les threads voient les mises à jour dans le bon ordre.

cc

1#include <stdatomic.h>2 3atomic_int x = 0, y = 0;4 5// Thread 16void t1() {7  atomic_store_explicit(&x, 1, memory_order_release);8}9 10// Thread 211void t2() {12  if (atomic_load_explicit(&x, memory_order_acquire) == 1) {13    // voit l'effet de t114  }

#Problème ABA (aperçu)

Les opérations atomiques (CAS) peuvent être trompées: une variable passe de A à B puis revient à A; un thread qui compare à A croit que rien n’a changé. Solutions: étiqueter (version/tag) avec le pointeur/valeur ou utiliser des primitives qui évitent l’ABA (DCAS, hazard pointers selon le cas).

#Animation: happens‑before

Release
Publier: rend visibles les écritures précédentes
Acquire
Voit les écritures publiées (HB établi)
Seq‑cst
Ordre total global plus fort si requis

#Animation: sémaphore (producteur/consommateur)

1
Init
plein=0, vide=N ; mutex pour le buffer
2
Produit
wait(vide) → lock → push(x) → unlock → signal(plein)
3
Consomme
wait(plein) → lock → pop() → unlock → signal(vide)

#Exemple Python (threads): deadlock et correction

pythonpython

1import threading, time2 3lock_a = threading.Lock()4lock_b = threading.Lock()5 6def t1():7    with lock_a:8        time.sleep(0.01)9        with lock_b:10            print('t1 ok')11 12def t2():13    with lock_b:14        time.sleep(0.01)

#Quiz

Quel mécanisme est adapté pour « au plus un producteur dans la section critique » ?

  • Sémaphore binaire (mutex)
  • File de messages
  • Horloge monotone

Réponse: Sémaphore binaire (mutex).