+ Répondre à la discussion
Affichage des résultats 1 à 10 sur 10
  1. #1
    Invité régulier
    Étudiant
    Inscrit en
    janvier 2007
    Messages
    31
    Détails du profil
    Informations personnelles :
    Âge : 28

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2007
    Messages : 31
    Points : 6
    Points
    6

    Par défaut Sémaphore du lecteur/rédacteur

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

  2. #2
    Modérateur
    Avatar de gangsoleil
    Profil pro
    R&D en systemes informatiques bas niveau Unix/Linux
    Inscrit en
    mai 2004
    Messages
    8 702
    Détails du profil
    Informations personnelles :
    Âge : 34
    Localisation : France, Isère (Rhône Alpes)

    Informations professionnelles :
    Activité : R&D en systemes informatiques bas niveau Unix/Linux

    Informations forums :
    Inscription : mai 2004
    Messages : 8 702
    Points : 24 337
    Points
    24 337

    Par défaut

    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,
    Modérateur "C", "Informatique Générale & Hardware" et "Unix"
    Les règles du forum

  3. #3
    Invité régulier
    Étudiant
    Inscrit en
    janvier 2007
    Messages
    31
    Détails du profil
    Informations personnelles :
    Âge : 28

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2007
    Messages : 31
    Points : 6
    Points
    6

    Par défaut

    VOILA j'ai ecris l'algorithme

  4. #4
    Modérateur
    Avatar de gangsoleil
    Profil pro
    R&D en systemes informatiques bas niveau Unix/Linux
    Inscrit en
    mai 2004
    Messages
    8 702
    Détails du profil
    Informations personnelles :
    Âge : 34
    Localisation : France, Isère (Rhône Alpes)

    Informations professionnelles :
    Activité : R&D en systemes informatiques bas niveau Unix/Linux

    Informations forums :
    Inscription : mai 2004
    Messages : 8 702
    Points : 24 337
    Points
    24 337

    Par défaut

    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.
    Modérateur "C", "Informatique Générale & Hardware" et "Unix"
    Les règles du forum

  5. #5
    Invité régulier
    Étudiant
    Inscrit en
    janvier 2007
    Messages
    31
    Détails du profil
    Informations personnelles :
    Âge : 28

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2007
    Messages : 31
    Points : 6
    Points
    6

    Par défaut

    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!

  6. #6
    Invité régulier
    Étudiant
    Inscrit en
    janvier 2007
    Messages
    31
    Détails du profil
    Informations personnelles :
    Âge : 28

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2007
    Messages : 31
    Points : 6
    Points
    6

    Par défaut

    voici ce que j'ai trouvé de mieux je crois pou l'algorithme
    Code :
    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 :
    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;

  7. #7
    Modérateur
    Avatar de gangsoleil
    Profil pro
    R&D en systemes informatiques bas niveau Unix/Linux
    Inscrit en
    mai 2004
    Messages
    8 702
    Détails du profil
    Informations personnelles :
    Âge : 34
    Localisation : France, Isère (Rhône Alpes)

    Informations professionnelles :
    Activité : R&D en systemes informatiques bas niveau Unix/Linux

    Informations forums :
    Inscription : mai 2004
    Messages : 8 702
    Points : 24 337
    Points
    24 337

    Par défaut

    Citation Envoyé par chelsea23
    voici ce que j'ai trouvé de mieux je crois pou l'algorithme
    Code :
    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 ;-)

    Citation Envoyé par chelsea23
    Code :
    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.


    Citation Envoyé par chelsea23
    pour le lecteur j'ai pas pu implémenté le sémaphore
    Code :
    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
    Modérateur "C", "Informatique Générale & Hardware" et "Unix"
    Les règles du forum

  8. #8
    Invité régulier
    Étudiant
    Inscrit en
    janvier 2007
    Messages
    31
    Détails du profil
    Informations personnelles :
    Âge : 28

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2007
    Messages : 31
    Points : 6
    Points
    6

    Par défaut

    voila en sémaphore et j'espére que c'est mieux
    Code :
    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 .

  9. #9
    Modérateur
    Avatar de gangsoleil
    Profil pro
    R&D en systemes informatiques bas niveau Unix/Linux
    Inscrit en
    mai 2004
    Messages
    8 702
    Détails du profil
    Informations personnelles :
    Âge : 34
    Localisation : France, Isère (Rhône Alpes)

    Informations professionnelles :
    Activité : R&D en systemes informatiques bas niveau Unix/Linux

    Informations forums :
    Inscription : mai 2004
    Messages : 8 702
    Points : 24 337
    Points
    24 337

    Par défaut

    Bonjour

    Citation Envoyé par chelsea23
    Code :
    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.
    Modérateur "C", "Informatique Générale & Hardware" et "Unix"
    Les règles du forum

  10. #10
    Invité régulier
    Étudiant
    Inscrit en
    janvier 2007
    Messages
    31
    Détails du profil
    Informations personnelles :
    Âge : 28

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2007
    Messages : 31
    Points : 6
    Points
    6

    Par défaut

    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.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •