M4104C-TP-Boost-Exercice1

Groupe de threads et functor

Dans cet exercice, le vector de pointeurs de threads n’est nécessaire que pour permettre au main-thread d’attendre qu’ils soient tous terminés avant de passer à la suite.

Il devient complètement inutile dès lors que les threads créés appartiennent au même groupe. Le main-thread peut alors se contenter d’attendre la fin de tous les threads du groupe.

La plupart des constructeurs de threads ont un paramètre de type Callable, c’est-à-dire pouvant être appelé au moyen de l’opérateur-fonction (). On peut donc utiliser un functor comme paramètre.

Travail à effectuer

Créer le projet GrpThreadsEtFctor. Vous pouvez vous servir de QT comme d’un éditeur de texte intelligent et réaliser les compilations et éditions de liens dans un terminal gnome ou faire tout avec QT. Cependant sachez que QT traite déjà ses propres threads qui seront en concurrence avec les vôtres.
Sachez également que lorsque vous importerez, dans QT, des fichiers dont les noms contiennent des majuscules, QT transformera ces majuscules en minuscules.

Télécharger le fichier Concurrence.cpp qui est le corrigé de l’exercice précédent. Le renommer en GrpThreadsEtFctor.cpp.

Modifier les propriétés du projet (ajout de la ligne
LIBS = /usr/lib/x86_64-linux-gnu/libboost_thread.so.1.62.0 /usr/lib/x86_64-linux-gnu/libboost_system.so.1.62.0
dans le fichier .pro du projet).

Remplacer les fonctions Incr() et Decr() par les functors correspondants.

Supprimer tout ce qui concerne la classe vector, créer un groupe de threads et y ajouter dynamiquement tous les threads.

Compiler et tester.

M4104C-boost-Exo1-Corrigé

/**
 * @file   Concurrence.cxx
 *
 * @author D. Mathieu
 *         M. Laporte
 *
 * @date   17/02/2010
 *
 * @brief  Concurrence
 *
 * Acces protege par une section critique implementee par un lock_guard
 *
 */
#include <iostream>
#include <sstream>
#include <vector>

#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/locks.hpp>

using namespace std;
using namespace boost;

enum { KErrArg  = 253 };    // Erreur d'arguments de main()

typedef unsigned long long ULL_t;
typedef          long long  LL_t;

namespace
{
    volatile LL_t  a (0);
    ULL_t NbBoucles;
    mutex Mtx;

    class Incr
    {
      public :
        void operator () (void)
        {
            for (ULL_t i = 0; i < NbBoucles; ++i)
            {
                lock_guard <mutex> Lock (Mtx);
                ++a;
            }
        } // operator()()

    }; // Incr

    class Decr
    {
      public :
        void operator () (void)
        {
            for (ULL_t i = 0; i < NbBoucles; ++i)
            {
                lock_guard <mutex> Lock (Mtx);
                --a;
            }
        } // operator()()

    }; // Decr

} // namespace anonyme

int main (int argc, char * argv [])
{
    if (argc != 3)
    {
         cerr << "Usage : Concurrence <NbThreads> <NbBoucles>\n";
         return KErrArg;
    }
    unsigned NbThreads;
    {
         istringstream is (argv [1]);
         is >> NbThreads;
    }
    {
         istringstream is (argv [2]);
         is >> NbBoucles;
    }
    cout <<   "Nbre de threads : " << NbThreads
         << "\nNbre de boucles : " << NbBoucles << '\n';

    // vector <thread *> VThreads;
    thread_group threadGroup;

    for (unsigned i = NbThreads; i--; )
    {
        // VThreads.push_back (new thread (Incr));
        threadGroup.add_thread (new thread (Incr ()));
        // VThreads.push_back (new thread (Decr));
        threadGroup.add_thread (new thread (Decr ()));

    }
    // for (unsigned i = NbThreads * 2; i--; ) VThreads[i]->join ();
    threadGroup.join_all ();

    cout << "a = " << a << '\n';

    return 0;

} // main()





M4104C-TP-Boost-Exercice2

Dans ce qui suit, il s’agit d’établir un point de synchronisation entre N threads, simulant des activités que nous appellerons des passants.

L’activité de chaque passant (thread) est composée de trois parties :

  1. le traitement T1() à exécuter avant d’atteindre le point de synchronisation,

  2. l’arrivée au point de synchronisation, et l’attente que les N thread aient atteint ce point,

  3. le traitement T2() à exécuter après avoir quitté le point de synchronisation.

Les traitements T1() et T2() seront simplement simulés par des attentes (appels de sleep()).

Travail à effectuer

Créer le projet RDV_NThreadsBoost.

Télécharger les fichiers SleepChronogram.h et SleepChronogram.cpp.

Version a

Dans l’espace de noms anonyme du fichier RDV_NThreadsBoost.cpp, écrire la fonction RendezVous(), de profil

void RendezVous ();

qui est appelée par chaque thread lorsqu’il arrive au point de rendez-vous.

Cette fonction doit utiliser :

  • un compteur de threads encore attendus (variable globale initialisée au nombre total de threads et décrémentée chaque fois qu’un thread arrive au RDV),

  • une variable-condition qui bloque les threads tant que le compteur n’est pas nul et qui libère ensuite tous les threads bloqués (broadcast).

Dans l’espace de noms anonyme du fichier RDV_NThreadsBoost.cpp, écrire la classe (ou la struct) CPassant, qui contient :

  • un identifiant (entier naturel) qui s’incrémente automatiquement à chaque création d’un CPassant (utiliser une variable statique),

  • les caractéristiques de fonctionnement d’un thread : le temps qu’il met à arriver au point de rendez-vous, et le temps qu’il met à se terminer après être reparti du point de rendez-vous.

  • l’operator() qui représente le comportement de chaque passant.

    Le corps de cette fonction est composé de trois parties :

    1. l’arrivée au point de rendez-vous (sleep()),

    2. le blocage au point de rendez-vous (RendezVous()),

    3. le départ du point de rendez-vous(sleep()).

Ajouter un vector de CPassants.

Dans la fonction main(), lire au clavier le nombre de threads à lancer puis, pour chacun, les délais d’arrivée et de départ (on entrera ces données dans un fichier texte qui sera redirigé sur l’entrée standard du programme).

Ces délais sont placés dans une instance de CPassant, qui est ensuite rangée dans le vector.

Affichage : afin de suivre le chronogramme du déroulement des opérations, nous vous proposons ici d’utiliser une visualisation plus agréable que de faire afficher des tops d’horloge : à chaque seconde, chaque thread affiche son état (une lettre par exemple) sur une ligne qui lui est propre : le thread 1 progresse sur la ligne 1, le thread 2 progresse sur la ligne 2, etc.

Il n’affiche rien lorsqu’il est bloqué (sur un sémaphore, dans une variable condition, etc.)

En utilisant le fichier de données
StdIn
suivant qui contient :

3
3 5
4 6
5 2

redirigé sur l’entrée standard de l’exécutable RDV_NThreadsBoost qui est mis à votre
disposition et que vous devez
télécharger
(mais cela ne fonctionne pas), vous obtiendrez les chronogrammes suivants (à deux instants différents) :

AAA
AAAA
AAAA

Trois passants (threads) ont été lancés en même temps.

Le symbole 'A' est affiché à chaque seconde pendant que le thread Arrive vers le point de rendez-vous.

On voit que le thread 1 est bloqué alors que les deux autres ont continué à progresser pendant 1 seconde.

AAADDDDD
AAAADDDDD
AAAAADDX

On voit sur ce chronogramme que les trois threads sont repartis lorsque le troisième est arrivé au rendez-vous (au bout de 5 secondes).

Chacun a alors repris son exécution normale (Départ).

Le troisième s’est terminé au bout de 2 secondes (X), les autres continuent depuis 4 secondes.

Pour obtenir ces affichages, vous devez utiliser la NTCTS clrscr, la classe gotoxy et la fonction SleepChronogram(), toutes trois décrites dans le fichier SleepChronogram.h.

Version b

Modifier la fonction RendezVous() pour effectuer un réveil en cascade.

Version c

La bibliothèque Boost offre la fonction barrier qui permet de réaliser très simplement un rendez-vous de N threads !

La mettre en oeuvre.

M4104C-boost-Exo2-Corrigé

/**
 *
 * @file    SleepChronogram.h
 *
 * @author  M. Laporte, D. Mathieu
 *
 * @date    05/01/2007
 *
 * @version 2.0
 *
 * @brief   SleepChronogr() affiche periodiquement un caractere
 **/
#if !defined __SLEEP_CHRONOGR_H__
#define      __SLEEP_CHRONOGR_H__

#include <iostream>             // ios_base::failure
#include <string>

#include <boost/thread/thread.hpp>
#include <boost/thread/locks.hpp>

namespace nsUtil
{
    // L'injection de la NTCTS
    //
    //=========================//
    //                         //
    extern std::string clrscr; //
    //                         //
    //=========================//
    //
    // vide l'ecran et positionne le curseur en haut a gauche

    // La
    //
    //============//
    //            //
    class gotoxy; //
    //            //
    //============//
    //
    // est un injecteur qui positionne le curseur a l'ecran
    // en position x et y :
    //
    // cout << gotoxy (10, 20) << ...

    class gotoxy
    {
      public :
        gotoxy (int x, int y);
        friend std::ostream &amp; operator << (std::ostream &amp; os,
                                           const gotoxy &amp; m);
      private :
        int m_x, m_y;

    }; // gotoxy()

    std::ostream &amp; operator << (std::ostream &amp; os, const gotoxy &amp; m);

    // La fonction
    //
    //===============================================//
    //                                               //
    void SleepChronogram (                           //
                          unsigned Num,              //
                          unsigned &amp; Col,            //
                          char Status,               //
                          unsigned Duree,            //
                          boost::mutex &amp; Mutex,      //
                          unsigned Decal   = 10u,    //
                          unsigned Periode = 1u      //
                         )                           //
        throw (std::ios_base::failure);              //
    //                                               //
    //===============================================//
    //
    // fait dormir le thread qui l'appelle pendant Duree secondes au
    // moyen de la fonction ::sleep().
    //
    // Elle est destinee a tracer des chronogrammes de threads pendant
    // leur periode de sommeil, chronogrammes qui apparaissent comme
    // dans l'exemple ci-dessous :
    //
    // ------------ Haut de l'ecran ----------------------
    //                                  ^
    //                                  |
    //                                  |
    //                                Decal
    //                                  |
    //                                  |
    //                                  v
    // AAADDDDD
    // AAAADDDDD
    // AAAAADDX
    //
    //------------- Bas de l'ecran -----------------------
    //
    // Status  : caractere affiche en exclusion mutuelle.
    //           Il est sense representer l'etat courant du thread
    // Mutex   : mutex POSIX utilise pour l'affichage
    // Periode : periodicite de l'affichage (en secondes)
    // Duree   : duree totale de l'affichage (= du sommeil du thread)
    // Decal   : nombre de lignes vierges en haut de l'ecran
    // Num     : numero de la ligne d'affichage sur laquelle est affiche
    //           le caractere Status.
    //           Le curseur apparait donc a la ligne (Decal + Num).
    //           Num est en general le numero du thread (e partir de 0).
    // Col     : en entree : colonne du premier affichage du caractere
    //           Status
    //         : en sortie : position du curseur en fin d'affichage
    //
    // La fonction Sleep () est susceptible de lever deux exceptions
    // - std::ios_base::failure lors de l'injection du caractere
    // - nsUtil::CExcFct lors du (de)-verrouillage du mutex
    //   (voir CException.h)

} // namespace nsUtil

#endif /* __SLEEP_CHRONOGR_H__ */
/**
 *
 * @file    SleepChronogram.cpp
 *
 * @author  M. Laporte, D. Mathieu
 *
 * @date    05/01/2007
 *
 * @version 2.0
 *
 * @brief   SleepChronogr() affiche periodiquement un caractere
 **/
#include <iostream>

#include <unistd.h>             // sleep()

//#include "SleepChronogram.h"

using namespace std;
using namespace boost;
using namespace boost::posix_time;

string nsUtil::clrscr ("\033[2J");    //    Clear screen

#define GOTOXY nsUtil::gotoxy

GOTOXY::gotoxy (int x, int y) : m_x (x), m_y (y) {}

ostream &amp; nsUtil::operator << (ostream &amp; os, const gotoxy &amp; m)
{
    return os << "\033[" << m.m_y << ';' << m.m_x << 'H';
}

#undef GOTOXY

void nsUtil::SleepChronogram (unsigned Num,
                              unsigned &amp; Col,
                              char Status,
                              unsigned Duree,
                              boost::mutex &amp; ioMutex,
                              unsigned Decal   /* = 10u */,
                              unsigned Periode /* = 1u  */)
    throw (std::ios_base::failure)
{
    for (unsigned i = Duree; i--; )
    {
        {
            lock_guard <mutex> Lock (ioMutex);
            cout << gotoxy (Col++, Num + Decal) << Status << flush;
        }
        this_thread::sleep (seconds (Periode));
    }

} // SleepChronogr()

/**
 * @file   RDV_NThreadsBoost_c.cpp
 *
 * @author D. Mathieu
 *         M. Laporte
 *
 * @date   08/10/2008
 *
 * @brief  Rendez-vous de N threads par la fonction barrier()
 *
 * Rendez-vous de N threads par la fonction barrier()
 *
 */
#include <iostream>
#include <sstream>
#include <vector>

#include <boost/thread/thread.hpp>
#include <boost/thread/locks.hpp>
#include <boost/thread/barrier.hpp>

//#include "SleepChronogram.h"

using namespace std;
using namespace boost;
using namespace nsUtil;

namespace
{
    enum { KExcArg  = 253 };    // Erreur d'arguments de main()

    mutex io_Mtx;
    barrier * pBarriere;

    void RendezVous ()
    {
        pBarriere->wait();

    } // RendezVous()

    class CPassant
    {
        static unsigned s_ID;

        unsigned  m_ID;
        unsigned  m_DelaiAvant;
        unsigned  m_DelaiApres;

      public :
        CPassant (const CPassant &amp; P)
        :   m_ID (P.m_ID),
            m_DelaiAvant (P.m_DelaiAvant),
            m_DelaiApres (P.m_DelaiApres) {}

        CPassant (unsigned DelaiAvant, unsigned DelaiApres)
            : m_ID (++s_ID),
              m_DelaiAvant (DelaiAvant), m_DelaiApres (DelaiApres) {}

        void operator () ()
        {
            unsigned Col (1);

            SleepChronogram (m_ID, Col, 'A', m_DelaiAvant, io_Mtx);

            RendezVous();

            SleepChronogram (m_ID, Col, 'D', m_DelaiApres, io_Mtx);
            SleepChronogram (m_ID, Col, 'X', 1,            io_Mtx);

        } // operator()

    }; // CPassant

} // namespace

unsigned CPassant::s_ID (0);

int main (int argc, char * argv [])
{
    if (argc != 1)
    {
         cerr << "Usage : RDV_NThreadsBoost\n";
         return KExcArg;
    }
    unsigned NbThreads;
    cin >> NbThreads;
    pBarriere = new barrier (NbThreads);

    vector <CPassant> VPassants;
    VPassants.reserve (NbThreads);

    for (unsigned DelaiAvant, DelaiApres, i (0); i < NbThreads; ++i)
    {
        cin >> DelaiAvant >> DelaiApres;
        VPassants.push_back (CPassant (DelaiAvant, DelaiApres));
    }
    thread_group GrpThreads;
    cout << clrscr << flush;

    for (unsigned i = NbThreads; i--; )
        GrpThreads.create_thread (VPassants [i]);

    GrpThreads.join_all ();

    cout << gotoxy (0, NbThreads + 12);

    return 0;

} // main()

M4104C-TP-Boost-Exercice3

Il s’agit de simuler par des threads des activités parallèles, que nous appellerons des baigneurs.

L’activité de chaque baigneur (thread) est constituée de différentes phases :

  1. le traitement initial effectué avant l’arrivée à la piscine, qui sera symbolisé par la lettre A (Arriver),

  2. le déshabillage, qui sera symbolisé par la lettre D,

  3. la baignade, qui sera symbolisé par la lettre B,

  4. le rhabillage, qui sera symbolisé par la lettre R,

  5. le traitement final effectué après le départ de la piscine, qui sera symbolisé par la lettre Q, (Quitter).

Chacun de ces cinq traitements sera simulé par un appel à la fonction sleep(), d’une durée différente pour chaque baigneur.

Ressources critiques : certaines phases de ces activités mettent en jeu des ressources critiques, pour lesquelles les threads entrent en compétitions :

  • la piscine dispose d’un certain nombre NbPaniers de paniers dans lesquels les baigneurs laissent leurs habits pendant le temps de la baignade,

  • chaque baigneur se déshabille et se rhabille dans une cabine individuelle.

    La piscine dispose d’un nombre NbCabines de cabines.

Les phases de déshabillage et de rhabillage ne peuvent commencer que si certaines conditions sont réalisées :

  • chaque baigneur doit disposer d’un panier et d’une cabine pour commencer à se déshabiller,

  • chaque baigneur ne doit disposer que d’une cabine pour commencer à se rhabiller.

Ces deux conditions sont donc éventuellement bloquantes.

Les fins des phases de déshabillage et de rhabillage ne sont pas bloquantes mais correspondent à la libération de ressources critiques :

  • chaque baigneur rend sa cabine quand il a fini de se déshabiller,

  • chaque baigneur rend sa cabine et son panier quand il a fini de se rhabiller.

Ces ressources critiques seront gérées au moyen de variable(s)-condition.

Travail à effectuer

Créer le projet PiscineThreadsBoost.

Télécharger les fichiers /tpAA-COO/usingthreads/usingthreads/RDV_NThreadsBoost/SleepChronogram.cpp”>SleepChronogram.cpp.

Dans l’espace de noms anonyme du fichier PiscineThreads.cpp, écrire les quatre fonctions de synchronisation DebutDeshabiller(), FinDeshabiller(), DebutRhabiller(), FinRhabiller(), de profils :

void DebutDeshabiller (void);
void FinDeshabiller   (void);
void DebutRhabiller   (void);
void FinRhabiller     (void);

Ces fonctions doivent utiliser :

  • deux compteurs NbPaniers et NbCabines, variables globales initialisées en début de programme et indiquant à l’instant t le nombre de ressources correspondantes encore disponibles,

  • une variable-condition qui bloque le thread si la ou les ressources dont il a besoin ne sont pas disponibles, et qui réveille les threads bloqués s’il rend une ou plusieurs ressources.

Dans l’espace de noms anonyme, écrire la classe (ou la struct) CBaigneur qui contient :

  • un identifiant (entier naturel) qui s’incrémente automatiquement à chaque création d’un CBaigneur (utiliser une variable statique),

  • les caractéristiques de fonctionnement d’un thread : le temps qu’il met à arriver à la piscine, le temps du déshabillage, le temps de la baignade, le temps du rhabillage, le temps qu’il met à se terminer après être reparti de la piscine,

  • l’operator() qui représente le comportement de chaque baigneur.

    Le corps de cette fonction est composé de cinq parties :

    1. l’arrivée à la piscine (sleep()),

    2. le déshabillage

      DebutDeshabiller()

      sleep()

      FinDeshabiller()

    3. la baignade (sleep()),

    4. le rhabillage,

      DebutRhabiller()

      sleep()

      FinRhabiller()

    5. le départ de la piscine (sleep()),

Ajouter un vector de CBaigneurs.

Dans la fonction main(), lire au clavier :

  • le nombre NbPaniers de paniers disponibles,

  • le nombre NbCabines de cabines disponibles (NbCabines < NbPaniers),

  • le nombre de baigneurs (threads) à lancer,

  • pour chaque baigneur, les 5 délais de son activité (on entrera ces données dans un fichier texte qui sera redirigé sur l’entrée standard du programme).

    Ces délais sont placés dans une instance de CBaigneur, qui est ensuite rangée dans le vector.

Comme dans l’exercice “Rendez-vous entre N threads“, l’affichage pourra être réalisé de façon agréable au moyen des outils mis à votre disposition dans les fichiers SleepChronogram.h et SleepChronogram.cpp.

Vous pouvez de nouveau /tpAA-COO/usingthreads/usingthreads/PiscineThreadsBoost/PiscineThreadsBoost.a”>-->télécharger et tester l’exécutable PiscineThreadsBoost qui est mis à votre disposition (mais qui ne se télécharge pas.

M4104C-boost-Exo3-Corrigé

/**
 *
 * @file    sleepChronogram.h
 *
 * @author  M. Laporte, D. Mathieu
 *
 * @date    05/01/2007
 *
 * @version 2.0
 *
 * @brief   SleepChronogr() affiche periodiquement un caractere
 **/
#if !defined __SLEEP_CHRONOGR_H__
#define      __SLEEP_CHRONOGR_H__

#include <iostream>             // ios_base::failure
#include <string>

#include <boost/thread/thread.hpp>
#include <boost/thread/locks.hpp>

namespace nsUtil
{
    // L'injection de la NTCTS
    //
    //=========================//
    //                         //
    extern std::string clrscr; //
    //                         //
    //=========================//
    //
    // vide l'ecran et positionne le curseur en haut a gauche

    // La
    //
    //============//
    //            //
    class gotoxy; //
    //            //
    //============//
    //
    // est un injecteur qui positionne le curseur a l'ecran
    // en position x et y :
    //
    // cout << gotoxy (10, 20) << ...

    class gotoxy
    {
      public :
        gotoxy (int x, int y);
        friend std::ostream &amp; operator << (std::ostream &amp; os,
                                           const gotoxy &amp; m);
      private :
        int myx, myy;

    }; // gotoxy()

    std::ostream &amp; operator << (std::ostream &amp; os, const gotoxy &amp; m);

    // La fonction
    //
    //===============================================//
    //                                               //
    void sleepChronogram (                           //
                          unsigned num,              //
                          unsigned &amp; column,            //
                          char status,               //
                          unsigned oneDuration,            //
                          boost::mutex &amp; oneMutex,      //
                          unsigned decal   = 10u,    //
                          unsigned period = 1u      //
                         )                           //
        throw (std::ios_base::failure);              //
    //                                               //
    //===============================================//
    //
    // fait dormir le thread qui l'appelle pendant oneDuration secondes au
    // moyen de la fonction ::sleep().
    //
    // Elle est destinee a tracer des chronogrammes de threads pendant
    // leur periode de sommeil, chronogrammes qui apparaissent comme
    // dans l'exemple ci-dessous :
    //
    // ------------ Haut de l'ecran ----------------------
    //                                  ^
    //                                  |
    //                                  |
    //                                decal
    //                                  |
    //                                  |
    //                                  v
    // AAADDDDD
    // AAAADDDDD
    // AAAAADDX
    //
    //------------- Bas de l'ecran -----------------------
    //
    // status  : caractere affiche en exclusion mutuelle.
    //           Il est sense representer l'etat courant du thread
    // oneMutex   : mutex POSIX utilise pour l'affichage
    // period : periodicite de l'affichage (en secondes)
    // oneDuration   : duree totale de l'affichage (= du sommeil du thread)
    // decal   : nombre de lignes vierges en haut de l'ecran
    // num     : numero de la ligne d'affichage sur laquelle est affiche
    //           le caractere status.
    //           Le curseur apparait donc a la ligne (decal + num).
    //           num est en general le numero du thread (e partir de 0).
    // column     : en entree : colonne du premier affichage du caractere
    //           status
    //         : en sortie : position du curseur en fin d'affichage
    //
    // La fonction Sleep () est susceptible de lever deux exceptions
    // - std::ios_base::failure lors de l'injection du caractere
    // - nsUtil::CExcFct lors du (de)-verrouillage du mutex
    //   (voir CException.h)

} // namespace nsUtil

#endif /* __SLEEP_CHRONOGR_H__ */
/**
 *
 * @file    sleepChronogram.cpp
 *
 * @author  M. Laporte, D. Mathieu
 *
 * @date    05/01/2007
 *
 * @version 2.0
 *
 * @brief   SleepChronogr() affiche periodiquement un caractere
 **/
#include <iostream>

#include <unistd.h>             // sleep()

//#include "sleepChronogram.h"

using namespace std;
using namespace boost;
using namespace boost::posix_time;

string nsUtil::clrscr ("\033[2J");    //    Clear screen

#define GOTOXY nsUtil::gotoxy

GOTOXY::gotoxy (int x, int y) : myx (x), myy (y) {}

ostream &amp; nsUtil::operator << (ostream &amp; os, const gotoxy &amp; m)
{
    return os << "\033[" << m.myy << ';' << m.myx << 'H';
}

#undef GOTOXY

void nsUtil::sleepChronogram (unsigned num,
                              unsigned &amp; column,
                              char status,
                              unsigned oneDuration,
                              boost::mutex &amp; ioMutex,
                              unsigned decal   /* = 10u */,
                              unsigned period /* = 1u  */)
    throw (std::ios_base::failure)
{
    for (unsigned i = oneDuration; i--; )
    {
        {
            lock_guard <mutex> oneLock (ioMutex);
            cout << gotoxy (column++, num + decal) << status << flush;
        }
        this_thread::sleep (seconds (period));
    }

} // SleepChronogram()

/**
 * @file   PoscineThreadsBoost.cpp
 *
 * @author D. Mathieu
 *         M. Laporte
 *
 * @date   23/09/2008
 *
 * @brief  Simulation du fonctionnement d'une piscine
 *
 *  Simulation du fonctionnement d'une piscine
 *  Gestion de plusieurs ressources de natures differentes
 */
#include <iostream>
#include <vector>

#include <boost/thread/thread.hpp>
#include <boost/thread/locks.hpp>
#include <boost/thread/condition.hpp>

//#include "CstCodErr.h"
//#include "SleepChronogram.h"

using namespace std;
using namespace boost;

using namespace nsUtil;             // KExcArg

namespace
{
    enum { KExcArg  = 253 };    // Erreur d'arguments de main()
    mutex io_Mtx;
    mutex mtxCond;
    condition_variable condition;

    unsigned nbBaskets;
    unsigned nbCubicles;

    void beginUndressing (void)
    {
        unique_lock <mutex> oneLock (mtxCond);
        while (nbCubicles == 0 || nbBaskets == 0) condition.wait (oneLock);

        --nbBaskets;
        --nbCubicles;

    } // beginUndressing()

    void endUndressing   (void)
    {
        unique_lock <mutex> oneLock (mtxCond);
        ++nbCubicles;

        condition.notify_all ();

    } // endUndressing()

    void beginDressingAgain   (void)
    {
        unique_lock <mutex> oneLock (mtxCond);
        while (nbCubicles == 0) condition.wait (oneLock);

        --nbCubicles;

    } // beginDressingAgain()

    void endDressingAgain     (void)
    {
        unique_lock <mutex> oneLock (mtxCond);
        ++nbCubicles;
        ++nbBaskets;

        condition.notify_all ();

    } // endDressingAgain()

    class Bather
    {
        static unsigned s_ID;

        unsigned myID;
        unsigned myArrivalDuration;
        unsigned myUndressingDuration;
        unsigned myBathDuration;
        unsigned myDressingAgainDuration;
        unsigned myEndingDuration;

      public :
        Bather  (unsigned arrivalDuration,
                 unsigned undressingDuration,
                 unsigned bathDuration,
                 unsigned dressingAgainDuration,
                 unsigned endingDuration)
            : myID (++s_ID),
              myArrivalDuration       (arrivalDuration),
              myUndressingDuration    (undressingDuration),
              myBathDuration          (bathDuration),
              myDressingAgainDuration (dressingAgainDuration),
              myEndingDuration        (endingDuration)          {}

        void operator ()()
        {
                unsigned Col (1);
            sleepChronogram (myID, Col, 'A', myArrivalDuration,
                         io_Mtx);

            beginUndressing();

            sleepChronogram (myID, Col, 'D', myDressingAgainDuration, io_Mtx);

            endUndressing ();

            sleepChronogram (myID, Col, 'B', myBathDuration,       io_Mtx);

            beginDressingAgain ();

            sleepChronogram (myID, Col, 'R', myDressingAgainDuration,   io_Mtx);

            endDressingAgain ();

            sleepChronogram (myID, Col, 'Q', myEndingDuration,          io_Mtx);

            sleepChronogram (myID, Col, 'X', 1,                   io_Mtx);

        } // operator()

   }; // Bather

} // namespace

unsigned Bather::s_ID (0);

int main (int argc, char * argv [])
{
    if (argc != 1)
    {
         cerr << "Usage : PiscineThreadsBoost\n";
         return KExcArg;
    }
    unsigned nbThreads;

    cin >> nbBaskets >> nbCubicles >> nbThreads;

    cout << clrscr << flush;
    vector <Bather> vBathers;
    vBathers.reserve (nbThreads);
    for (unsigned arrivalDuration, undressingDuration, bathDuration,
                  dressingAgainDuration, endingDuration, i (0); i < nbThreads; ++i)
    {
        cin >> arrivalDuration    >> undressingDuration >> bathDuration
            >> dressingAgainDuration >>  endingDuration;

        vBathers.push_back (
              Bather (arrivalDuration, undressingDuration,
                         bathDuration,  dressingAgainDuration, endingDuration));
    }
    thread_group grpThreads;
        cout << clrscr << flush;

    for (unsigned i = nbThreads; i--; )
        grpThreads.create_thread (vBathers [i]);

    grpThreads.join_all ();

    cout << gotoxy (0, nbThreads + 12);

    return 0;

} // main()

M4104C-TP-Boost-Exercice4

L’intérêt du parallélisme est double :

  • profiter de la puissance de traitement des machines multi-processeurs,

  • confier à chaque thread une activité spécifique beaucoup plus facile à concevoir et maintenir qu’au sein d’un gros programme.

Rappel : le nombre de combinaisons de N objets (N > 0) pris p à p (p <= N), noté C (N, p), est défini par :

C (N, p) = N si p = 1
C (N, p) = 1 si p = N

C (N, p) = C (N-1, p-1) + C (N-1, p) dans les autres cas

Il peut être calculé récursivement par :

unsigned CNp (unsigned N, unsigned p)
{
    return (N == p) ? 1 : (p == 1) ? N : CNp (N-1, p-1) + CNp (N-1, p);

} // CNp() 

// programme appelant :
...
Result = CNp (NbTot, Nb);
...

Il vous est demandé de remplacer chaque appel de la fonction récursive CNp() par la création d’un thread qui calcule la valeur correspondante.

A son tour, chaque thread lance 2 threads dont il attend le résultat (ou aucun) avant de se terminer lui-même.

Le main_thread lance un thread avec les valeurs initiales N et p et attend sa fin.

Travail à effectuer

Créer le projet CNpThreadsBoostV1.

Dans l’espace de noms anonyme du fichier CNpThreadsBoostV1.cpp, écrire la fonction thread CNp() qui effectue le calcul C(N, p), selon cette méthode.

N et p lui sont passés en paramètre(s).

En principe, elle devrait renvoyer le résultat, mais une fonction-thread ne renvoie pas de résultat (void).

Il ne reste plus qu’à en faire une procédure (utiliser un paramètre-résultat supplémentaire !).

Attention et rappel : les paramètres d’une fonction-thread sont toujours passés par valeur …

Pour créer un thread on utilisera la fonction bind(), de la bibliothèque functional,
qui renvoie un callable, qui lie son premier paramètre (une fonction), avec tous les autres paramètres de
bind() qui sont, dans l’ordre, les paramètres de la fonction premier paramètre de bind.

Exemple :

void f (int P1, char P2, int * P3);
int Val;
bind (f, 12, 'c', & Val) // est un callable

Ecrire la fonction main() qui amorce le calcul réparti, en utilisant les valeurs N et p passées en arguments de la commande (à vérifier), et qui affiche le résultat.

M4104C-boost-Exo4-Corrigé

/**
 *
 *  @file    CNpThreadsBoostV1.cpp
 *
 *  @author  D. Mathieu, M. Laporte
 *
 *  @date    23/09/2008
 *
 *  @version 2.0
 *
 *  @brief   Calcul parallele de CNp
 *
 **/
#include <iostream>
#include <vector>
#include <sstream>

#include <boost/thread/thread.hpp>
#include <boost/tr1/functional.hpp>  // ou <functional>

//#include "CstCodErr.h"

using namespace std;
using namespace boost;

//using namespace nsUtil;             // KExcArg

namespace
{
    enum { KExcArg  = 253 };    // Erreur d'arguments de main()
    void CNp (unsigned N, unsigned p, unsigned * pRes)
    {
        if  (N == p)
        {
            *pRes = 1;
            return;
        }
        if (p == 1)
        {
            *pRes = N;
            return;
        }

        unsigned r1;
        unsigned r2;

        thread_group groupThreads;
        groupThreads.create_thread (bind (CNp, N - 1, p - 1, &amp; r1));
        groupThreads.create_thread (bind (CNp, N - 1, p    , &amp; r2));

        groupThreads.join_all ();
        *pRes = r1 + r2;

    } // CNp()

} // namespace

int main (int argc, char * argv [])
{
    if (argc != 3)
    {
         cerr << "Usage : " << argv [0] << " <N> <p>\n";
         return KExcArg;
    }
    unsigned N;
    {
        istringstream is (argv [1]);
        is >> N;
    }
    unsigned p;
    {
        istringstream is (argv [2]);
        is >> p;
    }
    cout << "C (" << N << ", " << p << ") = " << flush;

    unsigned result;
    thread thr (bind (CNp, N, p, &amp; result));

    thr.join ();

    cout << result << '\n';

    return 0;

} // main()

M4104C-TP-Boost-Exercice5

Remarque préliminaire : cet exercice ne peut être effectué qu’après l’exercice Application répartie entre threads – Partie I.

La solution de l’exercice ci-dessus présente deux inconvénients majeurs liés :

  1. l’arborescence des appels de CNp() présente de très nombreux noeuds identiques, comme le montre l’exemple C(5,3) ci-dessous :




    Figure 1

  2. puisque chaque noeud correspond à la création d’un thread, et puisque leur nombre est limité, il est probable que le nombre maximal soit très vite atteint.

L’exercice proposé ici consiste à ne lancer un thread que si la combinaison correspondante n’a pas été déja calculée, ou si elle n’est pas en cours de calcul.

Cette technique est connue en informatique sous le nom de .

Pour cela, on utilise une matrice à deux dimensions, Combin qui mémorise les valeurs de C(i, j) avec 1 <= i <= N, et 1 <= j <= p.

Celle-ci est supposée déclarée au début de l’espace de noms, à des dimensions suffisantes.

Conventionnellement, on utilisera les valeurs suivantes :

Combin [i][j] = -1        : C(i, j) non calculée
Combin [i][j] =  0        : C(i, j) en cours de calcul
Combin [i][j] =  x > 0    : C(i, j) déjà calculée

Pour simplifier le traitement, Combin[i][j] correspond à C(i, j).

Pour cela, une ligne correspondant à i = 0 et une colonne correspondant à j = 0 ont été ajoutées au tableau.

Avant le début du calcul, la matrice Combin doit être initialisée.

Pour N = 5 et p = 3 par exemple, elle prend les valeurs suivantes :


Vous remarquez que certaines valeurs initiales découlent immédiatement de la définition et n’ont pas besoin d’être calculées pour être connues : les C(i, i) et C(N, 1).

Elles ont donc été directement placées dans la matrice.

La figure suivante représente le contenu de la matrice Combin après la fin du calcul de C(5, 3).


Travail à effectuer

Créer le projet CNpThreadsBoostV2.

Télécharger le fichier

M4104C-boost-Exo5-Corrigé

/**
 *
 *  @file    CNpThreadsBoostV2.cpp
 *
 *  @author  D. Mathieu, M. Laporte
 *
 *  @date    09/03/2011
 *
 *  @version 2.0
 *
 *  @brief   Calcul parallele de CNp avec "memoisation"
 *
 **/
#include <iostream>
#include <vector>
#include <sstream>

#include <boost/thread/thread.hpp>
#include <boost/tr1/functional.hpp>  // ou <functional> : bind()
#include <boost/thread/locks.hpp>
#include <boost/thread/condition.hpp>

//#include "CstCodErr.h"

using namespace std;
using namespace boost;

//using namespace nsUtil;             // KExcArg

namespace
{
    enum { KExcArg  = 253 };    // Erreur d'arguments de main()
    int combin [100][100];
    mutex mtx;
    condition_variable condition;

    void CNp (unsigned N, unsigned p, unsigned * pRes)
    {
        int result;
        {
            unique_lock <mutex> oneLock (mtx);
            if ((result = combin [N][p]) > 0)
            {
                *pRes = result;
                return;
            }
            if (result == 0)
            {
                while (combin [N][p] == 0) condition.wait (oneLock);

                *pRes = combin [N][p];
                return;
            }
            combin [N][p] = 0;

        } // Liberation du lock

        unsigned r1;
        unsigned r2;

        thread_group groupThreads;
        groupThreads.create_thread (bind (CNp, N - 1, p - 1, &amp; r1));
        groupThreads.create_thread (bind (CNp, N - 1, p    , &amp; r2));

        groupThreads.join_all ();
        *pRes = r1 + r2;
        {
            lock_guard <mutex> oneLock (mtx);
            combin [N][p] = *pRes;
        }
         condition.notify_all ();

    } // CNp()

} // namespace

int main (int argc, char * argv [])
{
    if (argc != 3)
    {
         cerr << "Usage : " << argv [0] << " <N> <p>\n";
         return KExcArg;
    }
    unsigned N;
    {
        istringstream is (argv [1]);
        is >> N;
    }
    unsigned p;
    {
        istringstream is (argv [2]);
        is >> p;
    }
    cout << "C (" << N << ", " << p << ") = " << flush;

    for (unsigned i = 1; i <= N; ++i)
    {
        combin [i][1] = i;
        for (unsigned j = 2; j <= p; ++j) combin [i][j] = -1;
    }
    for (unsigned j = 1; j <= p; ++j) combin [j][j] = 1;

    unsigned result;
    thread Thr (bind (CNp, N, p, &amp; result));

    Thr.join ();

    cout << result << '\n';

    return 0;

} // main()