• Section critique et exclusion mutuelle
• Module Mutex
• Attente et synchronisation
• Module Condition

Synchronisation des processus

Section critique et exclusion mutuelle

Module Mutex

# Mutex.create ;;
- : unit -> Mutex.t = <fun>
# Mutex.lock ;;
- : Mutex.t -> unit = <fun>
# Mutex.unlock ;;
- : Mutex.t -> unit = <fun>

# Mutex.try_lock;;
- : Mutex.t -> bool = <fun>

Les philosophes orientaux

---

Figure 4.1 : La table des philosophes orientaux

---

# let b =
  let b0 = Array.create 5 (Mutex.create()) in
   for i=1 to 4 do b0.(i) <- Mutex.create() done;
   b0 ;;
val b : Mutex.t array = [|<abstr>; <abstr>; <abstr>; <abstr>; <abstr>|]
# =======
 Comme on le voit sur la figure \ref{fig-philosophes}, un philosophe
 qui prend les deux baguettes autour de son bol empêche ses voisins
 imm\'ediats d'en faire autant. Dès qu'il dépose l'une de ses
 baguettes, son voisin, affamé, peut s'en emparer. Le cas échéant, ce
 dernier devra attendre que l'autre baguette soit disponible.
 
 %Pour simplifier les choses, on supposera que chaque philosophe a des habitudes
 %et vient toujours à la même place. 
 On modélise les philosophes par cinq processus et les cinq baguettes
 par autant de verrous. Un philosophe qui s'empare d'une baguette est
 un processus qui prend un verrou. Ainsi, un seul philosophe à la fois
 peut détenir une baguette donner. La méditation et la mastication sont
 simulées par une suspension d'un processus. On introduit un petit
 delai entre la prise et le dép\^ot d'une baguette. 
 \begin{caml}
 let b = let b0 = Array.create 5 (Mutex.create()) 
         in Array.map (fun _ ->  Mutex.create ()) b0 ; b0 ;;
Characters 0-7:
Syntax error
# >>>>>>> 1.23
 let mediter t = Thread.delay (Random.float t)
 let manger = mediter ;;
Characters 0-7:
Syntax error

# let philosophe i =
   let ii = (i+1) mod 5
   in while true do
        mediter 3. ;
        Mutex.lock b.(i);
        Printf.printf "Le philosophe (%d) prend sa baguette gauche" i ;
        Printf.printf " et médite encore un peu\n";
        mediter 0.2;
        Mutex.lock b.(ii);
        Printf.printf "Le philosophe (%d) prend sa baguette droite\n" i;
        manger 0.5;
        Mutex.unlock b.(i);
        Printf.printf "Le philosophe (%d) repose sa baguette gauche" i;
        Printf.printf " et commence déjà à méditer\n";
        mediter 0.15;
        Mutex.unlock b.(ii);
        Printf.printf "Le philosophe (%d) repose sa baguette droite\n" i
      done ;;
Characters 69-76:
Unbound value mediter

for i=0 to 4 do ignore (Thread.create philosophe i) done ;
while true do Thread.delay 5. done ;;

Problèmes de la solution naïve

Producteurs et consommateurs I

# let f = Queue.create ()  and  m = Mutex.create () ;;
val f : '_a Queue.t = <abstr>
val m : Mutex.t = <abstr>

# let produire i p d = 
   incr p ;
   Thread.delay d ;
   Printf.printf "Le producteur (%d) a produit %d\n" i !p ;
   flush stdout ;;
val produire : int -> int ref -> float -> unit = <fun>

# let stocker i p =
   Mutex.lock m ;
   Queue.add (i,!p) f ;
   Printf.printf "Le producteur (%d) a ajouté son %d-ieme produit\n" i !p ;
   flush stdout ;
   Mutex.unlock m ;;
val stocker : int -> int ref -> unit = <fun>

# let producteur i =
   let p = ref 0 and d = Random.float 2. 
   in while true do
        produire i p d ;
        stocker i p ;
        Thread.delay (Random.float 2.5)
      done ;;
val producteur : int -> unit = <fun>

# let consommateur i =
   while true do
     Mutex.lock m ;
     ( try 
         let ip, p = Queue.take f 
         in Printf.printf "Le consommateur(%d) " i ;
            Printf.printf "a retiré le produit (%d,%d)\n" ip p ;
            flush stdout ;
       with
          Queue.Empty ->
            Printf.printf "Le consommateur(%d) " i ;
            print_string "est reparti les mains  vides\n" ) ;
     Mutex.unlock m ;
     Thread.delay (Random.float 2.5)
   done ;;
val consommateur : int -> unit = <fun>

for i = 0 to 3 do
 ignore (Thread.create producteur i);
 ignore (Thread.create consommateur i)
done ;
while true do Thread.delay 5. done ;;

Attente et synchronisation

Sémaphores

• wait(s) : si s > 0 alors s := s -1, sinon l'exécution du processus ayant appelé wait(s) est suspendue.
• signal(s) : si un processus a été suspendu lors d'une exécution antérieure d'un wait(s) alors le réveiller, sinon s := s + 1.

Module Condition

create

: unit -> Condition.t qui crée un nouveau signal.

signal

: Condition.t -> unit qui réveille l'un des processus en attente du signal.

broadcast

: Condition.t -> unit qui réveille l'ensemble des processus en attente du signal.

wait

: Condition.t -> Mutex.t -> unit qui suspend le processus appelant sur le signal passé en premier argument. Le second argument est un verrou utilisé pour protéger la manipulation du signal. Il est libéré, puis repositionné à chaque exécution de la fonction.

Producteurs et consommateurs (2)

# let c = Condition.create () ;;
val c : Condition.t = <abstr>
# let stocker2 i p =
   Mutex.lock m ;
   Queue.add (i,!p) f ;
   Printf.printf "Le producteur (%d) a ajoute son %d-ème produit\n" i !p ;
   flush stdout ;
   Condition.signal c ;
   Mutex.unlock m ;; 
val stocker2 : int -> int ref -> unit = <fun>
# let producteur2 i =
   let p = ref 0 in
   let d = Random.float 2. 
   in while true do
        produire i p d;
        stocker2 i p;
        Thread.delay (Random.float 2.5)
      done ;;
val producteur2 : int -> unit = <fun>

# let attendre2 i =
   Mutex.lock m ;
   while Queue.length f = 0 do
     Printf.printf "Le consommateur (%d) attend\n" i ;
     Condition.wait c m
   done ;;
val attendre2 : int -> unit = <fun>
# let emporter2 i =
   let ip, p = Queue.take f in
     Printf.printf "Le consommateur (%d) " i ;
     Printf.printf "emporte le produit (%d, %d)\n" ip p ;
     flush stdout ;
     Mutex.unlock m ;;
val emporter2 : int -> unit = <fun>
# let consommateur2 i =
   while true do
     attendre2 i;
     emporter2 i;
     Thread.delay (Random.float 2.5)
  done ;;
val consommateur2 : int -> unit = <fun>

Lecteurs et écrivain

# let data = ref 0 ;;
val data : int ref = {contents=0}
# let n = ref 0 ;;
val n : int ref = {contents=0}
# let m = Mutex.create () ;;
val m : Mutex.t = <abstr>
# let c = Condition.create () ;;
val c : Condition.t = <abstr>

# let cpt_incr () = Mutex.lock m ; incr n ; Mutex.unlock m ;;
val cpt_incr : unit -> unit = <fun>
# let cpt_decr () = Mutex.lock m ; decr n ; Mutex.unlock m ;;
val cpt_decr : unit -> unit = <fun>
# let cpt_signal () = Mutex.lock m ; 
                     if !n=0 then Condition.signal c ;
                     Mutex.unlock m ;;
val cpt_signal : unit -> unit = <fun>

# let lire i = 
   cpt_incr () ;
   Printf.printf "Le lecteur (%d) lit (donnée=%d)\n" i !data ;
   Thread.delay (Random.float 1.5) ;
   Printf.printf "Le lecteur (%d) a fini sa lecture\n" i ;
   cpt_decr () ;
   cpt_signal () ;;
val lire : int -> unit = <fun>

# let lecteur i = while true do lire i ; Thread.delay (Random.float 1.5) done ;;
val lecteur : int -> unit = <fun>

# let ecrire () = 
   Mutex.lock m ;
   while !n<>0 do Condition.wait c m done ;
   print_string  "L'écrivain écrit\n" ; flush stdout ;
   data := 1 ; Thread.delay (Random.float 1.) ; data := 0 ;
   Mutex.unlock mn ;;
Characters 206-208:
Unbound value mn

# let ecrivain () = 
   while true do ecrire () ; Thread.delay (Random.float 1.5) done ;;
Characters 36-42:
Unbound value ecrire

ignore (Thread.create ecrivain ());
for i=0 to 5 do ignore(Thread.create lecteur i) done;
while true do Thread.delay 5. done ;;