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 à l'examen

- Entêtes de fonctions POSIX -- Aide pour l'examen.

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).

TP

• TP0 : Écrire un programme qui répond à la question : quel est le comportement par défaut de la mémoire partagée (obtenue par : shm_open + ftruncate + mmap) lors que le processus effectue un fork ? Est-elle copiée ou est-elle partagée entre les processus père et fils ? Inscrivez votre réponse à la question en commentaire au début du fichier.

- TP1 : Parallélisation du tri rapide
  - Un peu de documentation sur le tri rapide : 
    - Wikipedia : https://fr.wikipedia.org/wiki/Tri_rapide
    - OpenClassRooms : https://openclassrooms.com/courses/le-tri-rapide-qsort
    - Un petit vidéo : https://www.youtube.com/watch?v=xcyDSLSkb0k

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

- TP2 : 
   Fichiers sources, les exercices sont en commentaire dans le fichier tp2.c

- TP3 : 
   Énoncé du TP.
   Fichiers sources du simulateur.

Déroulement (2016-2017)

- CM1 : Multiprogrammation ( Présentation d'introduction (pdf)  )
   - 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 : Processus et threads
   - Commandes : fork, waitpid, wait.
   - Threads, définition, principe, fonctionnement, librairie pthread.
   - Méthodes d'exclusion mutuelle (partie 1).

- 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 (principe)
     - Sémaphores POSIX anonymes. 
     - Programme verrou.c
     - Programme mutex.c
     - Programme ParleurCC.c (avec condition de concurrence)
     - Programme ParleurSem.c (sans condition de concurrence)

- TD3 :
   - Énoncé du TD3.

- CM4 : 
   - Mécanismes d'exclusion mutuelle (deuxième partie)
     - Sémaphore POSIX nommés.
     - Programme createur.c
     - Programme gestionnaire.c
     - Programme parleur.c
     - Programme destructeur.c
   - Mémoire partagée
     - Principes de base : shm_open, ftrunctate, mmap.
     - Fichier entête mp_maStruct.h
     - Programme mp_lecture.c
     - Programme mp_affichage.c

- TD4 :
   - Énoncé du TD4.
      - Solution de l'exo 3.

- CM5 : 
   - Barrières de synchronisation
     - Programme barriere.c
   - Communication inter-processus
     - Retour sur le problème ``producteur/consommateur`` : prodCons_naif.c    prodCons_sem.c  
   - Communication inter-processus
     - Schémas de base
     - Descripteurs de fichier
     - Appels systèmes : read et write
     - Tubes UNIX (première partie)
       - Principes de bases

- TD5 : 
   - Énoncé du TD5.

- CM6 : 
   - Tubes UNIX (suite et fin)
      - Tubes nommés et non-nommés
        - Programme tubeFork.c
        - Programme fifoLecture.c
        - Programme fifoEcriture.c
   - Fonction select
        - Programme fifoLectureMultiple.c

- TD6 : 
   - Énoncé du TD6.
     - Solution de la question 1 (compiler avec option -lpthread)
     - Solution alternative de la question 1 (compiler avec option -lrt)
     - Solution de la question 2

- CM7
   - Interblocages
     - banqueVirtuelle2.c
   - Trace 2D

- TD7
  - Énoncé du TD7.

Archives

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.

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

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

- 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
     - tubeFork.c
     - fifoEcriture.c
     - fifoLecture.c
     - ficoLectureMultiple.c (utilisation de la fonction select)

- TD6
  - Énoncé du TD5.

- CM7
   - Tubes Unix (suite et fin)
   - Interblocages
     - banqueVirtuelle2.c