Discussion :

[chelsea23]

dans le probléme de redacteur/lecteurs,les lecteurs sont prioritaires,de ce fait il existe un risque de famine.prposer une solution qui qui élimine la famine et qui rend les rédacteurs prioritaires sur les lecteurs.en d'autres terme,dés qu'un redacteur réclame l'accés à un fichier(ressource),il doit l'obtenir le plus tot possible.donc tout lecteur arrivé aprés la demande du rédacteur doit attendre,méme si des lecteurs utilsent encore le fichier:
solution:je n'ai utlisé que deux sémaphores mutex(pour proteger une variable comp_redacteur qui va étre consulté par les lecteurs et redacteurs)et redact(y'a pas une simultaniéte entre les redacteurs)
on va proceder par l'algorithme

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
 process redacteur;
begin
    Si un redacteur est en exécution 
        alors se bloquer;{un seul redacteur accéde a la ressource}
    Sinon 
                    compteur_redacteur:=compteur_redacteur+1;
                    ecrire(mettre à jour);
                    compteur_redacteur:=compteu_redacteur-1;
   Si compteur_redacteur<>0
   alors reveiller un redacteur{qui etait dans la fille d'attente}
end ;


 process lecteur;
begin
Sicompteur_redacteur<>0
Alors ___;{mis dans la file d'attente}
Sinon lire(consulter);
      reveiller un lecteur{un lecteur qui etait dans la file}
end ;

NB:LES PROCESSUS S'EXéCUTENT EN PARALLéLE.
ma question
doit on declarer un sémaphore pour le lecteur je me pose cette question car quand un rédacteur arrive il doit absolument utiliser la ressource(prioritaire) méme si un redacteur arrive au méme temps que lui et méme si si y'a des lecteurs qui utilisent cette ressource(car plusieurs lecteurs accédent à la ressource simultanément) donc on doit mettre le lecteur dans une file d'attente mais dans quelle fille????? ça peut pas étre celle des redacteurs!! dans mutex???? mais c juste pour proteger la variable compteur_redacteur.
ALORS voila j'espére que cette fois c'est un peu plus lisible

[gangsoleil]

Bonjour,

Bon, j'ai eu beau mettre les balises code, le code n'est pas indenté et reste assez illisible... Pourrais-tu essayer de faire quelque chose ?

Ensuite, avant d'écrire el code, il est fortement conseillé d'écrire l'algorithme à implémenter. Or j'ai beau lire le code, je ne comprends pas ton algorithme... Est-ce que tu pourrais essayer de nous remémorer exactement le problème (qui réveille qui, quand un rédacteur arrive, que veut dire qu'il est prioritaire (fin du travail du lecteur ou pause), ....)

Cordialement,

[chelsea23]

VOILA j'ai ecris l'algorithme

[gangsoleil]

Merci bien pour les modifications, c'est beaucoup mieux

Donc en fait, si je me souviens bien, il faut deux files d'attentes : une pour les rédacteurs et une pour les lecteurs.

Lorsqu'un lecteur arrive, il doit vérifier que la file d'attente des rédacteurs est vide. Si tel est le cas, alors il lit, puis appelle un autre lecteur quant il a finit (qui vérifie pour sa part s'il y a un rédacteur en attente ou non).

Seul soucis que je vois : si les rédacteurs arrivent en continue, il y a famine du point de vue des lecteurs, et allongement infini du nombre de lecteur. Mais il ne peut pas y avoir famine du point de vue des rédacteurs.

[chelsea23]

avant cet algorithme y'avait le probléme de famine pour les REDACTEURS car on autorisé l'accés a plusieurs lecteurs et simultanément.
Maintenen on veut y remedier en rendant les redacteurs prioritaires donc y'aura un autre probléme de famine aussi apparament,mais moi la question qui me derrange est ou allons nous mettre les lecteurs qui arrivent aprés les redacteurs??? sacahnt que je n'ai pas utilsé de sémaphore pour les lecteurs car je vois pas l'interet de l'utiliser vu que j'ai plusieurs lecteurs qui consultent le fichier SIMULTANEMENT biensure sans qu'il y'ai de redacteur!!
peut étre que ma façon de raisonner est fausse je sais pas!!!! essayez de dire ce que vous avez compris s'i vous plait!

[chelsea23]

voici ce que j'ai trouvé de mieux je crois pou l'algorithme

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 processus redacteur;                               
 SI y'a un redacteur alors attente;
  sinon 
compteur-redacteur:=compteur-redacteur+1;{entrée}
     (mise à jour);
compteur:=compteur-1;
    reveiller un LECTEUR;{sortie}
 
                                                process lecteur;
                                                  SI compteur-recateur=1 alors attente;
                                                SINON  (consulter);
                                                   reveiller un redacteur;{sortie}

voici avec les semaphores mais je suis pas sure

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
REDACT;
  begin
                  p(redact);{si <0 alors attente}
                  p(mutex);
                 compteur-redacteur:=compteur-redacteur+1;
                 (mise à jour);
                 v(mutex);
                 p(mutex);{pour consulter la variable partageable}
                 compteur-redacteur:=compteur-redacteur-1;{reveiller 1 lecteur}
                v(mutex)
 end;

pour le lecteur j'ai pas pu implémenté le sémaphore
LECTEUR;
begin
  SI compteur-redacteur=1 alors attente;
sinon(lire,consulter);
   V(redact){reveiller un redacteur si y'en a dans la file
end;

[gangsoleil]

voici ce que j'ai trouvé de mieux je crois pou l'algorithme

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 processus redacteur;                               
 SI y'a un redacteur alors attente;
  sinon 
compteur-redacteur:=compteur-redacteur+1;{entrée}
     (mise à jour);
compteur:=compteur-1;
    reveiller un LECTEUR;{sortie}
 
process lecteur;
   SI compteur-recateur=1 alors attente;
   SINON  (consulter);
   reveiller un redacteur;{sortie}

Ca semble correct comme idée ;-)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
REDACT;
  begin
                  p(redact);{si <0 alors attente}
                  p(mutex);
                 compteur-redacteur:=compteur-redacteur+1;
                 (mise à jour);
                 v(mutex);
                 p(mutex);{pour consulter la variable partageable}
                 compteur-redacteur:=compteur-redacteur-1;{reveiller 1 lecteur}
                v(mutex)
 end;

Il y a à mon avis un problème avec le code en rouge : il est à mon avis inutile

redact est initialisé à 1, c'est à dire qu'un unique rédacteur peut se trouver dans cette section, donc le fait de relacher le mutex pour le redemander de-suite après ne sert à rien.

pour le lecteur j'ai pas pu implémenté le sémaphore

Code :

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

1
2
3
4
5
6
7
LECTEUR;
begin
  SI compteur-redacteur=1 alors attente;
sinon(lire,consulter);
   V(redact){reveiller un redacteur si y'en a dans la file}
end;

Je pense que tu as des problèmes avec le concept de mutex : ta variable compteur-redacteur ne sert à rien, puisqu'il existe un mutex qui te renseigne là dessus.

Je pense que tu devrais poser encore un peu l'algorithme avant de chercher à l'écrire : qui est prioritaire, comment ca va se traduire, qui donne des ressources à qui, ...

Exemple : si un rédacteur arrive, il doit bloquer tous les lecteurs déjà dans la file d'attente. Tu peux donc penser (à juste titre a priori) qu'il faut un sémaphore ici, qui serapris uniquement par les rédacteurs.
Du côté des lecteurs, il faut qu'ils vérifient l'état du mutex des rédacteurs, pour ne pas lire quand quelqu'un est en train d'écrire.
...

Bon courage, et n'hésite pas à poser des questions

[chelsea23]

voila en sémaphore et j'espére que c'est mieux

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
process redact;
  p(redact);
  p(mutex);
  cosulter(mettre a jour);
  v(mutex);
 
 
                                   process lecteur;
                                      p(mutex);
                                        lire(consulter);
                                       v(redact);

y'a plus de variable compteur_redact .

[gangsoleil]

Bonjour

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
process redact;
  p(redact);
  p(mutex);
  consulter(mettre a jour);
  v(mutex);
 

                                   process lecteur;
                                      p(mutex);
                                        lire(consulter);
                                       v(mutex);
                                       v(redact);

Tout d'abord, petit détail : il manque le v(mutex) pour les lecteurs.


Ensuite, essaye de voir ce qui se passe dans le cas suivant :

• Le premier arrivant est un rédacteur.
• Il prend le sémaphore "redact"
• Son quatum de temps est épuisé, il passe donc le main (le process est donc arrété entre p(redact) et p(mutex)
• Un lecteur arrive
• Il essaye de prendre le mutex
• Il y arrive puisque personne n'est encore dans la section d'exclusion mutuelle
• Il se met donc à consulter
• Le rédacteur reprend la main : il essaye p(mutex), et se fait jeter puisque quelqu'un est en train de lire (attenion, il est normal qu'il se fasse jeter)
• Il repasse donc la main au lecteur
• le lecteur finit de lire, libère le mutex, et exécutes le code v(redac)
• Un autre rédacteur arrive : il essaye p(redact), qui lui répond qu'il peut passer
• Nous avons alors deux rédacteurs en concurrence (même s'il est vrai qu'ils ne peuvent écrire en même temps)
• L'un des deux rédacteurs (peu importe lequel) prend le mutex, et se met à écrire, puis relache le mutex
• A ce moment là, un lecteur arrive, et essaye de prendre le mutex. Il réussit, puisque personne n'est en train de lire ni d'écrire
• Problème : un lecteur est passé avant un rédacteur, qui était pourtant là avant lui

Ta solution est donc sur la bonne voie, mais pas encore totalement finalisée, puisque les rédacteurs ne sont pas totalement prioritaires sur les lecteurs.

[chelsea23]

bonjour!
peut étre que cette précision nous mettera sur la méme longueur d'onde!
voila en gros ce qu'on m'a demandé de faire
c'est Priorité aux lecteurs,sans famine des redacteurs,si il existe des lecteurs sur le fichier ,toute nouvelle demande de lecture est accéptée sauf s'il y'a un redacteur en attente.
leV(mutex)que vaous aviez rajouté ne sert qu'a remettre la valeur du mutex a 1

l'exécution c'est genre lecteur,redacteur,lecteur,redacteur....etc!!

j'éspére qu'il réponds à notre demande!!
SINON je vais étre obligée de le refaire.