TÉLÉCOM & Management SudParis
TÉLÉCOM SudParis 2^ème année

TP Noté CSC4508/M2 du 21/06/10

(2è session)

Modalités

cd votreRepertoireDeTravailPourCSC4508M2
tar cvfz $USER.tgz TPNote2010Session2

Préparation

cd votreRepertoireDeTravailPourCSC4509M2
cp ~simatic/Cours/CSC4508/tPNote2010Session2.tgz .
tar xvfz tPNote2010Session2.tgz
cd TPNote2010Session2

Question 1 : Parallélisation d'un algorithme (10 points)

Question 1.1 (3 points)

Question 1.2 (3 points)

Question 1.3 (4 points)

1. g(données,i) (i allant de 0 à 9) doit absolument être traité par le thread T_fi
2. On rappelle que si 2 threads T₁ et T₂ exécutent l'algorithme suivant :
      tant que VRAI
        P(sem)
        traitement()
     fin tant que
   et qu'ils sont tous les deux bloqués à un instant donné sur l'instruction P(sem), alors si un thread T₀ fait deux fois V(sem), on peut avoir l'une des exécutions suivantes :
• T₁, puis T₂
• T₂, puis T₁
• T₁, puis T₁
• T₂, puis T₂
• T₁ en parallèle de T₂ (cas d'un processeur double-cœur, par exemple)
  

Question 2 : Implémentation de l'outil de synchronisation Loquet (10 points)

• Un Loquet est un outil de synchronisation permettant de retarder l'exécution de threads tant que le Loquet n'est pas dans son état terminal. Un Loquet agit comme une porte : tant qu'il n'est pas dans son état terminal, la porte est fermée et aucun thread ne peut passer. Dans son état terminal, la porte s'ouvre et tous les threads peuvent entrer. Quand un Loquet est dans son état terminal, il ne peut changer d'état et reste ouvert à jamais.
  Le Loquet permet donc qu'un ou plusieurs threads attendent qu'un ensemble d'événements se produisent. L'état du Loquet est formé d'un compteur initialisé (au moment de la création du Loquet avec la fonction nouveauLoquet()) avec un nombre positif qui représente le nombre d'événements à attendre. La fonction decrementLoquet() décrémente ce compteur pour indiquer qu'un événement est survenu. La fonction attenteLoquet() attend que le compteur passe à zéro, ce qui signifie que tous les événements se sont passés. Si le compteur est non nul lorsqu'elle est appelée, attenteLoquet() se bloque jusqu'à ce qu'il atteigne zéro. Si le compteur est nul, attenteLoquet() retourne immédiatement.
• Le corrigé des algorithmes était le suivant :
  
  Variables liées à un loquet
  ===========================
  int compteur = 0
  int nbAttenteLoquetOuvert = 0
  Semaphore mutex initialisé à 1
  Sémaphore attenteLoquetOuvert initialisé à 0
  
  Algorithme de nouveauLoquet(int valeurCompteur)
  ===============================================
  compteur = valeurCompteur
  
  Algorithme de decrementLoquet()
  ===============================
  P(mutex)
  compteur -= 1
  Si compteur == 0 alors
    Répéter nbAttenteLoquetOuvert fois
        V(attenteLoquetOuvert)
    FinRépéter
  FinSi
  V(mutex)
  
  Algorithme de attenteLoquet()
  =============================
  P(mutex)
  Si compteur > 0 alors
     nbAttenteLoquetOuvert += 1
     V(mutex)
     P(attenteLoquetOuvert)
  Sinon
     V(mutex)
  FinSi