INFO622 : Systèmes de synchronisation et Processus

• Responsable pour 2015--2016: Xavier Provençal
• Intervenants : Xavier Provençal (CM/TD/TP), Rodolphe Lepigre (TD/TP)

Ouvrage de référence

1. Andrew Tanenbaum, Systèmes d'exploitation. Principalement les chapitres 2 et 6.

Documentation remise en classes

- Entêtes de fonctions POSIX (I).
- Entêtes de fonctions POSIX (II).
- Entêtes de fonctions POSIX (III).
- Entêtes de fonctions POSIX (IV).
- Entêtes de fonctions POSIX (V).

TP

- TP1 : 
   Énoncé du TP.
   code fourni.

Déroulement (2015-2016)

- CM1 : 
   - Introduction à la multiprogrammation
   - Condition de concurrence
   - Section critique.
   - Banque virtuelle : exemple de condition de concurrence 
     - programme ``banqueVirtuelle.c``.
  

- TD1 : 
   - Énoncé du TD1 (en salle machine).
      - Solution question 1a)
      - Solution question 2a)
      - Solution question 2c)
      - Solution question 2e)
      - Solution question 3a)
      - Solution question 3d)
      - Solution question 3e)

- CM2 : 
   - Threads et processus. 
   - Ressources physiques et espace d'adressage. 
   - Commandes fork, wait, pthread_create, pthread_join.
     - programme ``zombies.c``. 
   - Mécanismes d'exclusion mutuelle (première partie).

- TD2 : 
   - Énoncé du TD2.
      - Code question 4, version séquentielle
      - Code question 4, version parallèle boguée
      - Solution de 4b)
      - Solution de 4c)
      - Solution de 4f)

- CM3 : 
   - Mécanismes d'exclusion mutuelle (deuxième partie)
     - Mutex et sémaphores
     - Programme verrou.c
     - Programme mutex.c
     - Programme ParleurCC.c (avec condition de concurrence)
     - Programme ParleurSem.c (sans condition de concurrence)
   - Communication interprocessus
     - Problème "producteurs/consommateurs"

- TD3 :
   - Énoncé du TD3.
     - Solution de la question q1 (fichier source).
     - Implémentation du problème ``producteurs/consommateurs`` (avec attente active et conditions de concurrence).
     - Solution au problème ``producteurs/consommateurs`` (avec n producteur et m consommataeurs, sans conditions de concurrence).

- CM4 :
   - Sémaphores nommés vs non-nommés
     - Implémentation du duo "Parleur/gestionnaire" avec un sémaphore non-nommé.
       - Parleur/gestionnaire avec threads et sémaphore non-nommé.
       - Parleur/gestionnaire avec fork et sémpaphore non-nommé (non-fonctionnel).
     - Implémentation du duo "Parleur/gestionnaire" avec un sémphore nommé.
       - createur.c (crée un sémaphore nommé).
       - gestionnaire.c (fait des POST sur un sémaphore nommé).
       - parleur.c (fait des WAIT sur un sémaphore nommé).
       - destructeur.c (détruit un sémaphore nommé).
   - Mémoire partagée
     - Exemple simplissime d'utilisation de mémoire partagée.
       - mp_1.c (à compiler avec l'option -lrt).
       - mp_2.c (à compiler avec l'option -lrt).

- TD4 :
   - Énoncé du TD4.
     - Solution de la question 1 (fichier source).
     - Solution de la question 2 (fichier source).
     - Solution de la question 3 (fichier source).

- CM5
   - Mémoire partagée (suite et fin)
     - Solution du devoir sur le comportement par défaut de la mémoire partagée lors d'un fork.
       - sol_devoir.c
     - Exemple un peu plus évolué d'utilisation de mémoire partagée.
       - mp_maStruct.h.
       - mp_affichage.c (à compiler avec l'option -lrt).
       - mp_lecture.c (à compiler avec l'option -lrt).
   - Variable de condition
     - Programme ``decrémenteur`` avec une variable de condition.
     - Implémentation de ``Producteur/consommateur`` avec des variables de condition.
   - Barrière de synchronisation
     - Exemple simplissime d'utilisation d'une barrière de synchronisation.

- TD5
   - Énoncé du TD5.
   

- CM6
   - Tubes Unix

- TD6
  - Énoncé du TD5.
   
   

Archives

Déroulement (2014-2015)

- CM1 : Introduction à la multiprogrammation, condition de concurrence et section critique.
   - Banque virtuelle : exemple de condition de concurrence.
      programme ``banqueVirtuelle.c``.
  
      
  
  
- TD1 : 
   - Énoncé du TD1 (en salle machine).
  
- CM2 : 
  - Processus et threads
  - Utilisation des fonctions : fork, wait, waitpid, pthread_create, pthread_exit, pthread_join. 
  - Méthodes d'exclusion mutuelle : désactivation des interruptions et attente active.
  
- TD2 : 
   - Énoncé du TD2.
      - Implémentation du code de la question 6. (à compiler avec l'option -lm )
      - Implémentation de la solution de la question 6. (à compiler avec les options -lm -lpthread )
  
- CM3 : Producteur/Consommateur et Sémaphores
   - Exemple d'utilisation d'un sémaphore non nommé par des threads (compiler avec l'option -lpthread) :
      programme ``semThread.c``.
  
  
- TD3 : 
   - Énoncé du TD3.
      - Implémentation du code de la question 2. (à compiler avec les options -lpthread -lcurses )
      - Implémentation de la solution de la question 2. (à compiler avec les options -lpthread -lcurses )
  
  
- CM4 : Sémaphores nommés et mémoire partagée
   - Exemple erroné d'utilisation d'un sémaphore non nommé par des processus apparenté ( fork() ) (compiler avec l'option -lpthread) :
      programme ``semFork-bug.c``.
   - Sémaphores nommés avec processus distincs (compiler avec l'option -lpthread) :
      programme ``createur.c``.
      programme ``destructeur.c``.
      programme ``gestionnaire.c``.
      programme ``parleur.c``.
   - Exemple simplissime de manipulation d'un entier situé en mémoire partagée (compiler avec l'option -lrt) :
      programme ``mp_1.c``.
      programme ``mp_2.c``.
   - Exemple d'utilisation d'un sémaphore non-nommé situé en mémoire partagée (compiler avec l'option -lrt) :
      fichier entête ``mp_maStruct.h``.
      programme ``mp_lecture.c``.
      programme ``mp_affichage.c``.
  
  
- TD4 : 
   - Énoncé du TD4.
   - Programme ``collatz.c`` à compléter (compilez avec les options : -lpthread -lrt.
  
- CM5 : Variables de condition et implémentation du problème "producteurs/consommateurs".
   - Solution au devoir :
      Programme qui teste le comportement par défaut le la mémoire partagée lors d'un fork. 
   - Exemple d'utilisation d'une variable de condition.
      Implémentation naïve (non-fonctionnelles) 
      Implémentation avec des sémaphores 
      Implémentation avec des variables de conditions 
   - Barrières de synchronisation (début)
  
  
- CM6 : 
   - Barrières de synchronisation (suite et fin)
      Programme ``barriere.c``.
   - Tubes (début)
  
  
- TD5 : 
   - Énoncé du TD5.
  
  
- CM7 : 
   - Tubes (suite et fin)
   - Exemple d'utilisation d'un tube non-nommé entre processus père et fils.
      Programme ``tubeFork.c``.
   - Exemnple d'utilisation d'un fifo entre deux processus non-apparentés.
      Programme ``fifoEcriture.c``.
      Programme ``fifoLecture.c``.
  Interblocages et famine
   - Exemple de programme créant un interblocage.
      Programme ``banqueVirtuelle2.c``.
  
- TD6 : 
   - TD6.
   
- TD7 :
   - TD7.
     Solution des question 1), 2a) et 2b).