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
- 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) ;
- Copie Solde dans R2
- « Arithmétique » sur des registres
- 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
- Lire prochain_libre
- Ecrire le doc dans la case « prochain_libre »
- 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 :
- Deux processus ne doivent jamais se trouver simultanément en section critique.
- On ne peut faire aucune supposition quant à la vitesse ou au nombre de processus en œuvre.
- Aucun processus s’exécutant hors de sa section critique ne doit bloquer un autre processus.
- 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