Discussion :

[slim]

Bonjour tout le monde,

je savais pas ou mettre ce post, j'hesitais entre "windows : systeme et logiciels" et celui-là...

bon voila mon probleme :

j'ai un algo a ecrire sur les sémaphores (c'est un exercice que j'ai a faire dans une matiere, et je cherche pas la solution complete )

en fait j'ai deux processus : un ecrivain, qui ecrit dans une case memoire et un autre lecteur qui lit la case memoire
je peux avoir qu'un preocess ecrivain alors pour les lecteurs, je peux en avoir plusieurs à un moment donné. Donc, le processus ecrivain est en exclusion mutuelle...

en fait, il faut combiner les semaphores, les processus (routines) producteur et consommateur (Wakeup et sleep) dans l'algo des processus ecrivain et lecteurs.

j'ai pensé à ca :

j'ai mis un sémaphore binaire pour le processus ecrivain et un semaphore "normal" pour le processus lecteur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
processus producteur 
début
   Répéter indéfiniment
        produire(Ecrivain) ;
        PB(vides) ;
        P(mutex) ;
        déposer(Ecrivain) ;
        V(mutex) ;
        VB(pleines) ;
   FinRépéter
fin
 processus consommateur 
début
   Répéter indéfiniment
       PB(pleines) ;
       P(mutex) ;
       retirer(Ecrivain) ;
       V(mutex) ;
       VB(vides) ;
       consommer(Ecrivain) ;
   FinRépéter
fin

Ca c'est l'algo pour le processus Ecrivain. Mais pour le processus Lecteur, je crois qu'il suffit d'enlever l'exclusion mutuelle.
Je crois meme que je me trompe sur toute la ligne. je crois qu'il faudrait combiner les deux processus producteurs ensemble et les deux consommateurs ensemble. Autrement dit, il faut mettre un processus producteur pour les processus Ecrivain et Lecteurs et un processus Consommateur pour les processus Ecrivain et Lecteurs

Merci beaucoup à celle ou celui qui veut bien m'aider

[m@]

bonjour,

si tu n'as qu'une case mémoire, pourquoi comptes-tu les vides et les pleines ?
comme ton problème est décrit, j'ai l'impression que tu n'as besoin que de deux sémaphore binaires : peutEcrire et peutLire... mais je dois me tromper !

[slim]

Oui, tu as raison matteus, mais seulement pour le processus ecrivain parce qu'il peut y avoir plusieurs processus lecteur dans leur section critique et en meme temps (ou successivement ! ? )

j'oubliais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
Processus P : 
 
P(S)  //où S est le sémaphore
 début
    S = S - 1;
    Si S < 0 alors
       Bloquer le processus;
    Fin Si
 Fin
 
V(S) 
  début
    S = S + 1;
    Si S =< 0 alors
      réveiller le processus de la file d'attente;
    Fin Si
  Fin
 
--------------
 
PB(S) // où S est binaire
 debut
   Si S = 1 alors
     S = 0;
   Sinon
     Bloquer le processus;
   Fin Si
 Fin
 
VB(S)
  debut
    Si la file d'attente est libre alors
      S = 1;
    sinon
      réveiller un processus de la file;
    Fin Si
  Fin

Merci

[m@]

si tu peux définir librement les sémaphores, tu peux les inverser :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
le proc écrivain : bloque si enTrainDeLire > 0
   place enTrainDEcrire
       ecrit
    lève enTrainDecrire
 
les procs lecteurs : bloquent si enTrainDecrire
    incremente enTrainDeLire
        lit
    decremente enTrainDeLire

es-tu d'accord ou suis-je tjrs à côté de la plaque ?

[slim]

Petite précision :

Plusieurs processus peuvent avoir accès au contenu de la case mémoire en lecture.

Un seul processus peut, à un moment donné, avoir accès en écriture à la case mémoire.

remarque : il n'y a pas qu'un seul processus Ecrivain !

[m@]

dans ce cas tu peux prendre un sémaphore enTrainDEcrire du même type que enTrainDeLire
et écrivain bloque aussi si enTrainDEcrire > 0

[thebubble]

L'alog complete, doit normalement spécifier qui est prioritère entre les lecteurs et les redacteurs.

Dans l'alog exposé ici, si il y a beaucoup de lecteurs on pourra jamais écrire.

[slim]

salut,

Non, on tient pas compte de la priorité. On suppose qu'ils ont tous la meme priorité. Le probleme est quels semaphores mettre dans l'algo de chaque processus ? Faut il mettre aussi les producteurs et les consommateurs en plus des "P" et "V" qui sont (sleep et wakeup, comme en java) ?

merci pour les reponses.

[Metal Tom]

T'aurais pas envie d'utiliser les variables conditionnelles ? Ca simplifierait un peu la tâche.

[slim]

salut,

j'ai pensé à ces algorithmes... :
3 sémaphores :
cl : compteur de lecteurs
bd : ressource
et mutex : exclusion mutuelle
(Les fonctions P et V sont decrites dans 1 post plus haut)
processus lecteur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
processus lecteur 
début
   Répéter indéfiniment
      P(mutex) ;
      cl = cl +1;
      Si cl = 1 alors 
          P(bd) ;
          V(mutex) ;
          lire_données() ;
          P(mutex) ;
          cl = cl -1;
          Si cl = 0 alors 
             V(bd) ;
             V(mutex) ;
             utiliser_données() ;
          FinSi
       FinSi
   FinRépéter
fin

processus ecrivain :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
processus écrivain :
début    
   Répéter indéfiniment
        fabriquer_données() ;
        P(bd) ;
        ecrire_données() ;
        V(bd) ;
   FinRépéter
fin