Aller au contenu principal

IPC & synchronisation

Progression

#IPC & synchronisation

À quoi ça sert ?

À quoi ça sert: faire communiquer des processus et coordonner l’accès à des ressources partagées sans corruption ni blocages. Comment: messages (pipes, sockets, files), mémoire partagée, et primitives (mutex, sémaphores, condvars) pour l’ordre.

#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)

bg-[rgba(var(--code-inline-bg),0.5)] text-[rgb(var(--fg))] px-1 roundedbg-[rgba(var(--code-inline-bg),0.5)] text-[rgb(var(--fg))] px-1 rounded
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).