Processus et sémaphores

Version imprimable

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 :P )

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:

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

10/05/2004, 18h13
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 ! :oops:

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 ! ? :roll: )

j'oubliais

Code:

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

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

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 ?

10/05/2004, 19h32
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 !
11/05/2004, 17h58
m@

dans ce cas tu peux prendre un sémaphore enTrainDEcrire du même type que enTrainDeLire
et écrivain bloque aussi si enTrainDEcrire > 0
11/05/2004, 20h09
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.
11/05/2004, 20h25
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.
14/05/2004, 12h40
Metal Tom

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

salut,

j'ai pensé à ces algorithmes... : :roll:
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:

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:

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