Mise en œuvre d'un sémaphore binaire de la classe en C++

Donc, je suis en train de travailler sur un planificateur dans une de mes classes. Fondamentalement, nous sommes en prétendant qu'un seul thread peut s'exécuter en un temps. Nous sommes censés utiliser un sémaphore de la classe pour permettre à ces fils de bloquer eux-mêmes pour simuler le fil d'attente pour le CPU.

Le problème est, les fils semblent bloquer au mauvais moment et de l'exécuter au mauvais moment. Je me demandais si je suis absent de certaines compréhension conceptuelle d'un sémaphore et comment la mettre en œuvre. Je me demandais si je pouvais obtenir quelques commentaires sur mon œuvre. L'instructeur a fourni ce fichier d'en-tête que je n'ai pas modifié en aucune façon:

class Semaphore {
private:
  int             value;
  pthread_mutex_t m;
  pthread_cond_t  c;

public:

  /* -- CONSTRUCTOR/DESTRUCTOR */

  Semaphore(int _val);

  //~Semaphore();

  /* -- SEMAPHORE OPERATIONS */

  int P();
  int V();
};

C'est ma mise en œuvre à l'aide de posix trucs:

Semaphore::Semaphore(int _val){
    value = _val;
    c = PTHREAD_COND_INITIALIZER;
    m = PTHREAD_MUTEX_INITIALIZER;
}

int Semaphore::P(){
    if(value <= 0){
        pthread_cond_wait(&c, &m);
    }
    value--;
}

int Semaphore::V(){
    value++;
    if(value > 0){
        pthread_cond_signal(&c);
    }
}
InformationsquelleAutor Ben Creighton | 2012-03-24
  1. 9

    Vous êtes en négligeant de les verrouiller le mutex.

    Deuxièmement, ce que vous avez ici est un comptage de sémaphore, pas un sémaphore binaire. Un sémaphore binaire n'a que deux états, et donc un bool variable:

    class Semaphore {
private:
  bool            signaled;   //<- changed
  pthread_mutex_t m;
  pthread_cond_t  c;

  void Lock() { pthread_mutex_lock(&m); }          //<- helper inlines added
  void Unlock() { pthread_mutex_unlock(&m); }
public:

  /* -- CONSTRUCTOR/DESTRUCTOR */

  Semaphore(bool);

  //~Semaphore();

  /* -- SEMAPHORE OPERATIONS */

  void P();   //changed to void: you don't return anything
  void V();
};

    Impl:

    //consider using C++ constructor initializer syntax.

Semaphore::Semaphore(bool s){        //don't use leading underscores on identifiers
    signaled = s;
    c = PTHREAD_COND_INITIALIZER;    //Not sure you can use the initializers this way!
    m = PTHREAD_MUTEX_INITIALIZER;   //they are for static objects.

    //pthread_mutex_init(&m); //look, this is shorter!
}

void Semaphore::P(){
    Lock();              //added
    while (!signaled){   //this must be a loop, not if!
        pthread_cond_wait(&c, &m);
    }
    signaled = false;
    Unlock();
}

void Semaphore::V(){
    bool previously_signaled;
    Lock();
    previusly_signaled = signaled; 
    signaled = true;
    Unlock();  //always release the mutex before signaling
    if (!previously_signaled)
      pthread_cond_signal(&c); //this may be an expensive kernel op, so don't hold mutex
}
    • "L'instructeur fourni ce fichier d'en-tête que je n'ai pas modifié en aucune façon".
    • Cela peut être vrai, mais il n'y a pas besoin de mod en bas de ma réponse, à cause de cela. Le fait est que vous ne disposez pas d'un sémaphore binaire ici et j'ai été correctement souligné. Peut-être la tâche est de mettre en œuvre comme un sémaphore binaire sans changer l'en-tête, qui peut être fait.
    • Ok ok là vous allez.
    • Merci!!!! Voir votre œuvre m'a donné un de ces "Ah Ah!" moments. Je pense que l'instructeur intentionnellement à gauche de l'interface ouverte pour que nous puissions décider de ce genre de sémaphore à utiliser. J'ai fini par mettre en place un comptage sémaphore de toute façon de faire de la modification du programme pour les différents algorithmes d'ordonnancement de plus facile.
    InformationsquelleAutor Kaz
  2. 3

    Votre comptage sémaphore algorithme manque une boucle while, et les signaux de la sémaphore inutilement.

    Logique originale, avec des écluses ajoutée (voir autre réponse):

    int Semaphore::P(){
    Lock();
    if(value <= 0){
        pthread_cond_wait(&c, &m);
    }
    value--;
    Unlock();
}

int Semaphore::V(){
    Lock();
    value++;
    if(value > 0){
       pthread_cond_signal(&c);
    }
    Unlock(); 
}

    La façon correcte:

    int Semaphore::P(){
    Lock();
    while (value <= 0){   //not if
        pthread_cond_wait(&c, &m);
    }
    //value is now > 0, guaranteed by while loop
    value--;
    //value is now >= 0
    Unlock();
}

int Semaphore::V(){
    Lock();
    int prior_value = value++;
    Unlock();

    //E.g. if prior_value is 50, should we signal? Why?

    if (prior_value == 0) //was not signaled previously, now is.
        pthread_cond_signal(&c);
}

    Pour plus d'efficacité, de recueillir des informations concernant le signal ou pas à l'intérieur du mutex, mais alors ne le signal à l'extérieur le mutex. Mutex doit être tenu plus que quelques instructions machine que possible, car ils ajoutent de la contention, la réduction de la concurrence. Le signal peut prendre des centaines de cycles (voyage au noyau de faire la file d'attente de manipulation).

    Vous devez utiliser une boucle lors de l'attente sur une variable de condition, car il peut les réveils intempestifs. Aussi, si vous signal à l'extérieur du mutex, l'état du signal ne permet pas toujours d'aller à la "destinée" de thread. Entre le unlock et la signal, un thread peut se faufiler dans et appel P et décrémenter le mutex. Alors, le seul qui se réveille sur la condition doit ré-évaluer le test, sinon il faudra procéder de manière incorrecte.

    InformationsquelleAutor Kaz