INFO622 : Systèmes de synchronisation et Processus

• Responsable pour 2012--2013: Xavier Provençal
• Xavier Provençal (CM/TD/TP)

Ouvrage de référence

1. Andrew Tanenbaum, Systèmes d'exploitation

Documentation remise en classes

- Entêtes de fonctions POSIX (I) :
   fonctions_POSIX_1.pdf.
- Entêtes de fonctions POSIX (II) :
   fonctions_POSIX_2.pdf.
- Entêtes de fonctions POSIX (III) :
   fonctions_POSIX_3.pdf.
- Entêtes de fonctions POSIX (IV) :
   fonctions_POSIX_4.pdf.

Systèmes de synchronisation et processus

Multiprogrammation :

Exécuter plusieurs programmes simultanément sur le même CPU.

On divise l’écriture des programmes dans 3 espace mémoires différents donc cela permet de faire

marcher le CPU en non-stop les programme sont exécuter en simultané avec le CPU.

Processus :

Un programme en cours d’exécution. Deux composantes d’un processus :

• Espace d’adressage. (mémoire) (code, donnée, piles des appels, etc...)
• Des registres.

Préemption :

Action d’interrompre un processus avec l’intention d’un reprendre l’exécution plus tard.

Note : la coopération du processus n’est pas requise.

Principales causes de préemption :

• A la demande du processus. (ex : sleep)
• Lors d’un appel système bloquant. (ex : utilisation d’un périphérique)
• Déclenchement d’une interruption. (signal envoyé au CPU ex : horloge, périph, etc...)

Observation :

Solde = solde + 1000 ; Solde = solde + (Solde * 0.01/365.0) ;

1. Copie Solde dans R2
2. « Arithmétique » sur des registres
3. Copier R2 dans Solde

Les deux processus partage une variable, si il se mette pas d’accord le solde est peut-être pas mis a

jours au bon moment.

On passe d’un solde de 2000 à un solde à 1000.90 ...

Condition de concurrence :

Situation ou au moins deux processus écrivent des données partagées et où le résultat final dépend

de l’ordre d’exécution.

Ex : spool d’impression :

Prochain_libre = 10

1. Lire prochain_libre
2. Ecrire le doc dans la case « prochain_libre »
3. Incrémenter prochain_libre

Section critique :

Partie du code dans laquelle on doit jamais avoir 2 processus en même temps.

Deux objectifs :

• Identifier les sections critiques
• Assurer l’exclusion mutuelle

Les quatre règles d’or de la gestion des sert critiques :

1. Deux processus ne doivent jamais se trouver simultanément en section critique.
2. On ne peut faire aucune supposition quant à la vitesse ou au nombre de processus en œuvre.
3. Aucun processus s’exécutant hors de sa section critique ne doit bloquer un autre processus.
4. Aucun processus ne doit attendre indéfiniment longtemps avant d’entrer en section critique.

TP

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

Déroulement (2013-2014)

CM1 : Introduction à la multiprogrammation, condition de concurrence et section critique.

- Banque virtuelle : exemple de condition de concurrence.
   programme ``banqueVirtuelle.c``.

TD1 :

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

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 )
   Utilisez la commande "time" pour observer un gain de vitesse sur une machine à plusieurs coeurs. 
   Pour cela il vous faudra de grands nombres premiers. En voici un : 1000000000000039723

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``.
- Exemple erroné d'utilisation d'un sémaphore non nommé par des processus apparenté ( fork() ) (compiler avec l'option -lpthread) :
   programme ``semFork-bug.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

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

CM5 : Variables de condision 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