« INFO622 : Systèmes de synchronisation et Processus » : différence entre les versions
Aller à la navigation
Aller à la recherche
Aucun résumé des modifications |
Aucun résumé des modifications |
||
| Ligne 22 : | Ligne 22 : | ||
== Systèmes de synchronisation et processus == |
== 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...) |
|||
<br/> |
|||
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. |
|||
Version du 21 février 2014 à 15:34
- 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
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