Se 2020-2021VF PDF

Université Mohammed V
École Mohammadia d'Ingénieurs

Département Génie Informatique
Systèmes d'exploitation II
Mme Z.Bakkoury (bakkoury@emi.ac.ma)

Mr N. EL Faddouli (faddouli@emi.ac.ma)
2020-2021
Plan du cours
 Introduction et Rappels
 Gestion des processus: Synchronisation
– Définitions et rappels
– Algorithmes avec attente active
 Gestion des processus: Synchronisation sans attente active
– Les sémaphores
– Les moniteurs
– L'interblocage
 Gestion de la mémoire
– Définitions et rappels
– La mémoire virtuelle
 Les entrées/Sorties
EMI / Département Génie Informatique/ Système d’exploitation II 2
Qu’est-ce qu’un SE ?
 Une couche logicielle, dont le rôle est de:
– Gérer les ressources de la machine.
Ressource : tout ce qui est nécessaire à l’avancement d’un
processus (processeur, mémoire, disques, périphériques,
message d’un autre processus, réseau, etc …)
Exemples:
• Savoir quelles sont les ressources disponibles
• Savoir qui utilise quoi, quand, combien, etc.
• Allouer/Libérer les ressources efficacement.
– Fournir aux programmes d’application une interface
simplifiée avec les ressources
(base pour le développement et l’exécution des
programmes d’application.)

Problématique
 Afin que les programmes puissent s’exécuter de
façon portable et efficace, il faut pouvoir gérer
simultanément:
- La multiplicité des différentes ressources.
- La complexité des composants de chacune d’elles,

ce qui requiert la prise en compte de nombreux
détails fastidieux, sources d'erreurs.

Exemple: Partage d’imprimante
Pour assurer un service d’impression sur une machine

multi-utilisateurs, il faut:
-Verrouiller l’accès à l’imprimante afin que les flots de

caractères à imprimer envoyés par les programmes ne
s’entrelacent pas sur le papier.
-Gérer les tampons d’impression afin que les programmes

puissent reprendre leur travail sans devoir attendre la fin de
l’impression.

Buts d’un SE
Le problème : gérer l’accès à des ressources

coûteuses.
À tout instant, il faut:
 Connaître l’utilisateur d’une ressource donnée;

 Gérer l’accès concurrent à cette ressource;
Pouvoir accorder l’usage (exclusif) à cette
ressource;
Éviterles conflits entre les programmes ou entre les
usagers.
Buts d’un SE
Un SE a pour but de:

 Fournir un environnement où l’utilisateur
peut exécuter des programmes;
 Utiliser le matériel de façon efficace
 Protéger le système et ses usagers de
fausses manipulations

Fonctionnalités d’un SE
Le SE fournit à l’utilisateur:
 Une vue uniforme des entrées/sorties;
 Une mémoire partageable;
 La gestion de fichiers et répertoires;
 La gestion des droits d’accès, sécurité, et du
traitement des erreurs;
 La gestion des processus;
 La gestion des communications inter-processus.

Fonctionnalités d’un SE (suite)
En tant que gestionnaire de ressources, le SE doit

permettre:
D’assurer le bon fonctionnement des ressources;
L’identification de l’usager d’une ressource;
Le contrôle des accès;
L’interruption d’une utilisation de ressource;
La gestion des erreurs, …

Caractéristiques d’un SE
 Temps de réponse
 Fiabilité
 Sécurité

Gestion des processus
Synchronisation avec attente active

Définitions
 Processus: c’est un programme en exécution
(ou ensemble d’instructions réalisant une fonction donnée).
 Ordonnanceur (scheduleur): se charge de l’ordonnancement

des processus.
 Section critique: une partie du code qui utilise une ou
plusieurs ressources partagées.
 Exclusion mutuelle: si une ressource est en cours
d’utilisation par un processus, les autres processus ne
peuvent pas y accéder, càd un seul processus à la fois est
autorisé à utiliser la ressource partagée.
 Blocage mutuel (Interblocage ou Deadlock): c’est la
situation dans laquelle aucun processus ne peut exécuter la
section critique: chaque processus attend indéfiniment que la
section critique soit libérée.

Processus
 “Un programme qui s’exécute”
 Plusieurs processus peuvent être exécutés
simultanément (pseudo parallélisme)
A
A B C A
B B
C
C
Temps
Monoprogrammation Multiprogrammation

Exemple
Problème de Lecteur - Rédacteur
(Producteur - Consommateur)
Écrire   lire
Etats d’un processus:
Elu : En cours d’exécution (Actif)

Bloqué: Attend un événement (libération d’une
ressource) pour pouvoir continuer
Prêt : Suspendu provisoirement pour permettre
l’exécution d’un autre processus

Etats des processus
 Changement d’état basé sur des événements
– Système réactif
Terminaison
Nouveau
Elu
élu Attente ressource ou évenement
Interruption
Prêt Bloqué
Ressource disponible

Synchronisation des processus
Lorsque des processus s’exécutent (en même temps),

ils peuvent:
-Entrer en conflit pour accéder à une ressource
 Assurer l’exclusion mutuelle

-Échanger des informations, coopérer selon un certain
protocole (Exemple: producteur-consommateur) par
l’intermédiaire de ressources partagées
 Assurer la communication inter-processus

 Nécessité de développer des mécanismes de
communication et de synchronisation

Problème de Synchronisation
 n processus {P0, P1, …,Pn} en concurrence pour utiliser des
ressources (données, …) partagées.
 Section critique: Segment de code dans lequel le processus
peut accéder aux données partagées. Elle doit être exécutée de
façon atomique.
 Problème: Assurer que, quand un processus exécute sa
section critique, aucun autre processus n’est autorisé à
exécuter la sienne.
Exemples:
1) Plusieurs processus réalisant, en parallèle, l’impression d’un texte sur
une imprimante qui constitue une ressource critique à utiliser par un
seul des processus  Allocation
2) Mise à jour d’un compte à l’aide de deux classes de processus:
- Processus créditeurs
- Processus débiteurs
Exemple: Mise à jour d’un compte bancaire
Processus créditeur Processus débiteur
... …
(1) S =Lecture_Solde(); (1) M=Lecture_Solde();
(2) S = S+ 100 (2) M= M- 50
(3) Ecriture_Solde(S); (3) Ecriture_Solde(M);
… …
solde du compte = 1000 En séquentiel: Solde valide=1050
Processus créditeur 1 Processus débiteur 1

(1)
(2)
(1)  Solde invalide = 1100
(2)
(3)
(3)

Exemple: Mise à jour d’un compte bancaire(Suite)
Exécution de deux processus débiteurs
solde du compte = 1000 En séquentiel: Solde valide=900
Processus débiteur1 Processus débiteur 2

(1)
(2)
(1) Solde invalide=950
(2)
(3)
(3)
 Si l’accès est concurrent, l’exécution n’est pas cohérente et

les données (solde) sont invalides.
 Adopter une solution pour assurer l’exclusion mutuelle

Conditions pour avoir une bonne solution
 Exclusion mutuelle:
Si un processus exécute sa section critique, aucun autre
processus ne peut exécuter la sienne.
 Interblocage:
Un processus qui n’est pas dans sa section critique ne peut
pas bloquer les autres pour y accéder
 Famine:
Aucun processus ne doit attendre trop longtemps
(indéfiniment) pour entrer en section critique.
 Aucune hypothèse n’est faite sur les vitesses relatives des
processus, ni sur le nombre de processus.
Solutions:
1. Logicielles
2. Matérielles

Section critique- Exclusion mutuelle
On Considère deux processus comportant une section critique.

L’exécution de la section critique doit suivre le protocole suivant.
Processus P1; Processus P2;
{ {
… …
{entrée_section;} {entrée_section;}
SC; SC;
{sortie_section;} {sortie_section;}
… …
} }

Solutions Logicielles
Utilisation d’une variable verrou
verrou: Boolean
Verrou = 0
(1) While (verrou == 1); // Attente

{entrée_section;}:
(2) verrou = 1; // Verrouillage
{sortie_section;}: verrou = 0; // Déverrouillage
Solution Fausse: la séquence (1)P1; (1)P2;(2)P1;(2)P2 autorise

l’entrée simultanée contrairement au but recherché.

Solutions Logicielles (Suite)
Utilisation d’une variable verrou (suite)
Amélioration:
(1) While (verrou != 0); // Attente
(2) verrou = pid; // Verrouillage
(3) if (verrou == pid)
Section critique
verrou=0;
La séquence précédente deviendra:

(1)P1 ; (1)P2 ;(2)P1 ; (3)P1 ;(2)P2 ;(3)P2
Inconvénients: Attente active , problème (conflit) d’accès à la

variable partagée.
Solution matérielle Test and Set (TAS)
 L'instruction TAS:
Function TAS(b boolean): Boolean
Begin
TAS := b;
b := TRUE;
End
C’est une opération indivisible (atomique) dont l’argument est

une variable qui sera mémorisée dans un registre.
 Utiliser TAS pour entrer en SC: Initialisation verrou= FALSE

While TAS(&verrou); //Attente
Section_Critique();
verrou :=FALSE; // Sortie de la section critique
 Problème: attente active

Alternance
Tour= 1; // C’est le rédacteur qui commencera en premier
Processus 1 /*Lecteur*/
While (True)
{ While (Tour==1) ; // Attente
SC_Lecteur(); // SC exécutée si Tour=0. Exemple: Lire(B) où B est un objet à lire
Tour=1; // sortie de la SC, c’est le tour du rédacteur

Section_Non_Critique(); // Exemple: Traitement de l’objet B }
Processus 2 /*Rédacteur*/
While (True)
{ While (Tour==0) ; // Attente
SC_Redacteur(); // SC exécutée si Tour=1. Exemple: Ecrire(B)
Tour=0; // sortie de la SC, c’est le tour du lecteur
Section_Non_Critique();}

Algorithme de Dekker (1965)
Utilisation de 2 variables partagées: tour, demande
Type identité = (P1, P2);
Var tour: identité INIT(P1); // tour initialisée à P1  P1 peut entrer en SC
//Le tableau demande initialisé à Flase  Les deux processus ne veulent pas entrer en SC
demande: Array[P1..P2] of Boolean INIT(2:FALSE);
Procédure Entrer_SC (A_Moi, A_Lui: identité)

Begin (1) demande[A_Moi] := TRUE; // je veux entrer
(2) WHILE demande[A_Lui] DO Begin // tant que l’autre le veut aussi…
(3) IF tour != A_Moi THEN Begin // si ce n’est pas mon tour…
(4) demande[A_Moi] := FALSE; // je renonce …
(5) WHILE tour!=A_Moi DO NOP;// jusqu’à ce que ce soit mon

tour
(6) demande[A_Moi] := TRUE; // …puis je réaffirme ma demande
END {if}
END {while}
End;
Algorithme de Dekker (suite)

Procédure Sortir_SC (A_Moi, A_Lui: identité)
Begin
demande[A_Moi] := FALSE; // je ne veut pas entrer
tour := A_Lui; // C’est le tour de l’autre processus
End;
P1 exécute: Entrer_SC(P1,P2);
SC
Sortir_SC(P1,P2);
P2 exécute: Entrer_SC(P2,P1);
SC
Sortir_SC(P2,P1);

Algorithme de Peterson (1981)

Exclusion mutuelle entre deux processus numérotés 0 et 1
Var Tour: 0..1; // variable de tour
Intéressé: ARRAY[0..1] Boolean; // intention d’entrer dans la SC
Initialisation: Interéssé[0] = Interéssé[1] = FALSE
Processus i: // i= 0 ou 1
(1) Intéressé[i]:=TRUE; //veut entrer
(2) Tour:=i; // est passé en dernier
(3) while (Tour!=i AND Intéressé[(i+1) mod 2]=TRUE );//Attendre son tour
(4) Section_Critique();
(5) Intéressé[i]:=FALSE;
Exercices
Les primitives Sleep & Wakeup
 Au lieu de l'attente active (= consommation de la CPU)
le processus s'endort : primitive sleep
 Un processus peut réveiller un autre processus :
primitive wakeup.
Exemple: Le problème de producteur-consommateur à n cases

 Le producteur :
– peut remplir une case libre s'il y en a.

sinon il s'endort en attente d’être réveillé par le consommateur.
– après avoir produit, il réveille le consommateur si une seule case
est pleine.
 Le consommateur :
– peut vider une case pleine s'il y en a, sinon il s'endort en attente

d’être réveillé par le producteur.
– après avoir consommé, il réveille le producteur si une seule case
est vide.
Les primitives Sleep & Wakeup
/* Un tampon de N cases est partagé entre les deux processus */
#define N 100
int compteur = 0; /* Nombre courant d’objets */
Producteur () Consommateur ()
{ objet a; { objet a;
while (1){ while (1){
if( compteur ==0) sleep ();
Produire_Objet(&a);
Retirer_Objet(&a);
if( compteur == N) sleep (); compteur --;
Stocker_Objet(a); if( compteur == N -1)
compteur ++; wakeup ( producteur );
if( compteur == 1) Consommer_Objet(a);
}
wakeup ( consommateur );
}
}
} Pas d’attente active.
Problème si perte du signal wakeup.
Gestion des processus
Synchronisation sans attente active

Les Sémaphores
 Introduit par Dijkstra en 1965 pour résoudre le
problème d’exclusion mutuelle.
 Permettent l’utilisation de m ressources identiques par
n processus.
 Un sémaphore possède une valeur entière et une file
de processus en attente de la ressource.
 Un sémaphore S est une variable globale protégée,
accessible au moyen de deux opérations atomiques:
- P(S) ou Down(S): décrémente la valeur de S de 1,
si sa valeur est <0 le processus appelant est bloqué.
- V(S) ou UP(S): incrémente S. Si la valeur de S
est ≤0, elle réveille un processus bloqué dans la file
associée au sémaphore.
Les Sémaphores (suite)
 Un sémaphore binaire (booléen ou d’exclusion mutuelle)

est un sémaphore dont la valeur ne peut prendre que deux
valeurs positives possibles : 1 et 0.
P(S): if (S==1) S=0;

else Bloquer le processus appelant dans la file d’attente de S
S = 1;
V(S):
Réveiller un processus en attente dans la file de S
Remarque: S=1  accès à la SC
S=0  pas d’accès à la SC

 Exemple
Pour le problème de Lecteur-Rédacteur avec une seule case:
on utilise deux sémaphores R et W
Initialisation: W=1 et R=0 // le rédacteur commence en premier
P1: (Rédacteur) P2: (Lecteur)

While (True) Do While (True) Do
B=Créer_Msg() P(R);
P(W); Read(B);
Write(B); V(W);
V(R); Utiliser_Msg(B)
End End Exercices
 Un sémaphore de comptage (ou entier) est un

sémaphore dont la valeur peut prendre plus de deux
valeurs positives possibles.
– Il est utile pour allouer une ressource parmi
plusieurs exemplaires identiques : la valeur du
sémaphore est initialisée avec le nombre de
ressources.
– Il est associé à une ressource accessible par

plusieurs processus.

Soit Q le nombre de détenteurs potentiels.
Initialisation: S=Q
P(S):
S  S-1
Si(S<0) Alors Bloquer le processus appelant dans la file
d’attente de S
V(S):
S  S+1
Si(S<=0) Alors Réveiller un processus en attente dans la file
de S
Remarque: Si S<0 alors |S| = nombre de processus dans la

file d’attente de S
Exercices
 Un sémaphore multiple est un sémaphore permettant l’accès

en exclusion mutuelle à un ensemble de N ressources. Ce
Sémaphore est représenté par un vecteur de N bits: Etat
P(S):
Si Etat[i]=1 pour 1 ≤ i ≤ N
Etat[i]  0 pour 1 ≤ i ≤ N
Sinon
Bloquer le processus appelant dans la file d’attente de S
V(S):
Etat[i]  1 pour 1 ≤ i ≤ N
Réveiller un processus en attente dans la file de S
Exercices
Les Moniteurs (Monitor)
Hoare (1974) / Hansen (1975)
 Un moniteur est un module de programme constitué:
– d'un ensemble de variables partagées (variables d'état),
– d'un ensemble de procédures (méthodes) permettant
d’accéder à ces variables.
– D’un corps comportant l’initialisation des variables.
 Seules certaines procédures, appelées entrées (entry)

du moniteur sont visibles: seules ces procédures
peuvent être appelées de l'extérieur.
 Les procédures du moniteur sont exécutées en
exclusion mutuelle : Un seul processus peut être
actif dans le moniteur à un instant donné.

Les Moniteurs (suite)
 Un moniteur est une primitive de haut niveau : c'est

au compilateur d’assurer l’exclusion mutuelle
pour l’accès au procédures du moniteur.
 Une variable de type condition a un rôle particulier
dans un moniteur: Elle est représentée par une file
d’attente C sur laquelle on peut agir à l’aide de deux
primitives spéciales:
– wait : suspend le processus appelant et le met en attente
dans C.
– signal: permet à un processus bloqué dans C de

reprendre son exécution.
Si aucun processus n’est suspendu, la primitive signal n’a pas
d’effet (l’état de la variable condition ne change pas).
Exemple 1: acquisition d’une ressource unique
allocateur: Moniteur;
Var Occupé: Booléen;
Libre: Condition;
PROCEDURE Acquisition()
Begin
If Occupé Then Libre.wait;
Occupé := True;
End;

PROCEDURE Libération()
Begin
Occupé=Faux;
Libre.signal;
End;
Begin // corps d’initialisation des variables
Occupé :=Faux;
End;
Utilisation du moniteur par un processus:
allocateur.Acquisition(); // acquérir la ressource via le moniteur
Utiliser_Ressource_Dans_SC(); // peut faire partie du moniteur.
allocateur.Libération(); // Libérer la ressource

Exemple 2: Producteur-Consommateur
Prod_Cons: Moniteur
Var Buffer: Array[0..N-1] of message;
read, write: Condition;
compteur , indiceP, indiceC : Integer ;
PROCEDURE Ecrire(A: message)
Begin
If compteur = N Then write.wait;
Buffer[indiceP] :=A; indice P:=(indiceP+1) Mod N;

compteur := compteur + 1;
If compteur = 1 Then read.signal;
End;
PROCEDURE Lire( X:message)
Begin
If compteur = 0 Then read.wait;

X := Buffer[indiceC];
indiceC := (indiceC + 1) Mod N

compteur := compteur -1;
If compteur = N-1 Then write.signal;
End;
Begin
compteur:=0; indiceP := 0; indiceC := 0;
Fin; // fin du moniteur

Avantages des moniteurs

 Les sections critiques sont transformées en fonctions dans un
moniteur  regrouper les sections critiques du programme
 La gestion des sections critiques n’est plus à la charge du
programmeur. Elle est réalisée par l’implantation du
moniteur (supporté par le compilateur).
 Le moniteur tout entier est implémenté comme une section
critique dont l’accès est assuré par le compilateur.
 Quand un processus P appelle une procédure d’un moniteur
qui n’est pas disponible (le moniteur est utilisé par un autre
processus), le PCB du processus P est placé dans une file
d’attente associée au moniteur. Dès que ce dernier est libéré,
un processus est choisi de la file et la procédure appelée est
exécutée.
Exemple: Producteur-Consommateur en Java
public class ProdCons

{ private Object buffer[]; /* Memoire partagee */
private int N; /* Capacite de la zone */
private int count, in, out; /* nb d’éléments, indices */
private Waitqueue vide, plein; /* files d'attente */
public ProdCons(int tailleZone)

{ N = tailleZone; /* création d'un tampon de taille tailleZone*/
buffer = new Object[N];
count = 0; in = 0; out = 0;
vide= new Waitqueue();
plein= new Waitqueue();
}
public synchronized void append(Object data)

{ if (count == N) plein.qWait();
buffer[in] = data;
in = (in + 1) % N; count++;
vide.qSignal();
}
public synchronized Object take()
{
Object data;
if (count == 0) vide.qWait();
data = buffer[out];
out = (out + 1) % N;
count--; plein.qSignal(); return data;
}}
Interblocage
Un ensemble de processus est en interblocage si chaque

processus est bloqué en attente d’un événement (une libération
de ressource: un signal, un message, un sémaphore, …) qui ne
peut être causé que par un autre processus de l’ensemble.
Proc 1 Proc 2
Alloué
Demande
R1 R2

Interblocage: Exemple
Utilisation de deux sémaphores, chacun pour obtenir une

ressource.
Prog1 Prog2
down(mutex1)
accès à ressource 1 ------->
down(mutex2)
<---------- accès à ressource 2
down(mutex2)
down(mutex1)
accès à ressource 2 accès à ressource 1
up(mutex2) up(mutex1)
up(mutex1) up(mutex2)

Interblocage (suite)
Conditions provoquant un interblocage:

• L’exclusion mutuelle pour la prise d’une ressource: Chaque
ressource est soit disponible, soit attribuée à un seul
processus.
• La détention et l’attente: les processus ayant déjà obtenu
des ressources peuvent en demander des nouvelles.
• Pas de réquisition: les ressources doivent être libérées par
le processus qui les détient. Ces ressources ne peuvent pas
être retirées de force.
• L’attente circulaire: Deux ou plusieurs processus, chacun
d’eux attendant une ressource détenue par un autre.
Interblocage (suite)
Stratégies de lutte contre les blocages mutuels
1- Évitement de l’interblocage
2- Prévention de l’interblocage
3- Détection et résolution de l’interblocage
4- La politique de l’autruche

Interblocage: Évitement de l’interblocage
 Ce mécanisme contrôle pas à pas la progression d’un

système de tâches d’une façon à garantir qu’aucun blocage
ne se produira.
 État sûr : s'il n’est pas en interblocage et qu’il existe un
ordre d’ordonnancement dans lequel chaque processus peut
être exécuté jusqu’à la fin, même si tous les processus
demanderaient immédiatement toutes les ressources dont ils
ont besoin pour finir leurs travaux.
 État risqué : à partir duquel l’interblocage est inéluctable
 État d’interblocage.

Interblocage: La politique de L’autruche
 L’approche la plus simple
 Ignorer le problème (Ignorer les possibilités d’interblocage)
 Stratégie de la plupart des systèmes courants
•UNIX et Windows utilisent cette approche
•Raisonnable si:
– les interblocages se produisent rarement
– le coût de la prévention est élevé

Interblocage: Évitement de l’interblocage (suite)
Principe : Si un processus présente au système une demande

d’allocation de ressource, le système doit vérifier si
le nouvel état obtenu serait un état "risqué".
 Pour éviter les interblocages, il est important de ne

pas s’avancer vers un état non sûr (risqué).
 Éviter dynamiquement les interblocages en allouant

les ressources avec précaution.
Algorithme de banquier: Proposé par dijkstra en 1965 en se

basant sur l’utilisation des matrices d’allocation des
ressources.
Interblocage: Évitement de l’interblocage (suite)
Exemple: Si tous les processus demandent leurs

maximum de ressources, est-ce que l’état de départ est
sécuritaire?
Exécution de tous les processus jusqu’à la fin

 l’état initial était sûr
Interblocage: Prévention de l’interblocage
 Éviter les interblocages est pratiquement

impossible
 Les prévenir en empêchant l’apparition des

4 conditions de leur existence.

Condition de détention et d’attente
 Obliger un processus à demander toutes les

ressources d’un coup, en début d’exécution.
• Difficile de prévoir ces ressources.
• Les processus qui demandent beaucoup de ressources

risquent d'attendre trop longtemps (famine)
 À chaque fois qu’un processus doit faire la demande

de nouvelles ressources, le forcer à relâcher au
préalable celles détenues.

Condition d’attente circulaire
Idée : Définir une relation d’ordre pour les

ressources du systèmes.
Principe : un processus ne peut demander que les

ressources dont le numéro est supérieur
au numéro de toutes les ressources déjà
détenues

Condition de non réquisition
 définir un ordre de priorité entre les processus
 Retirer les ressources au processus les plus

(moins) prioritaires
 La prévention de l’interblocage dégrade la

performance du système

Interblocage: Détection et résolution
 Le système doit vérifier s’il y a des processus en

interblocage.
 Il construit dynamiquement le graphe d'allocation des
ressources qui indique les attributions et les demandes
des ressources
Exemple: graphe d'allocation pour 3 ressources R, S et T
Le processus A demande R
A B C
Le processus B demande S
Le processus C demande T
Le processus A demande S R S T
Le processus B demande T
Le processus C demande R
Interblocage: Détection et résolution (suite)
Le système vérifie s'il y a des interblocages:

 À chaque modification du graphe suite à une demande
d'une ressource (coûteuse en terme de temps CPU).
 À un intervalle régulier de temps
 Lorsqu'un indicateur d’interblocage est activé, par

exemple le taux d’utilisation du CPU devient inférieur à
un certain seuil (la détection peut être tardive)

Interblocage: Détection et résolution (suite)
Résolution:
 Tuer des processus
 Résoudre par la réquisition de ressource: Retirer

temporairement une ressource à un processus pour
l’attribuer à un autre
 Résoudre par rollback: Restaurer un état antérieur et

éviter de retomber dans la même situation
 La reprise (résolution) n’est pas évidente.

Interblocage: La politique de L’autruche
 L’approche la plus simple
 Ignorer le problème (Ignorer les possibilités d’interblocage)
 Stratégie de la plupart des systèmes courants
•UNIX et Windows utilisent cette approche
•Raisonnable si:
– les interblocages se produisent rarement
– le coût de la prévention est élevé

Famine
 Un processus peut ne jamais avoir une ressource

tout en n’étant pas en interblocage
 La famine peut être évitée en utilisant une

politique d’allocation des ressources

Exercices:Synchronisation des processus
 Exercice1: Problème des philosophes
1
Chaque philosophe répète:
1 2
- Penser
- Prendre les fourchettes 5
2
- Manger
5 3
- Poser les fourchettes
4 4 3

(suite)
Problème des philosophes (suite)
Solution 1: Prévoir un sémaphore d'exclusion mutuelle pour

chaque fourchette.
Solution 2:
- Quel est le problème de la solution 1?
- Utiliser un sémaphore entier initialisé avec une valeur
pouvant éviter l'attente circulaire.
Indication: C'est le nombre maximal de philosophes pouvant

prendre des fourchettes simultanément sans provoquer un
interblocage.
(suite)
Problème des philosophes (suite)
Solution 3:
Utiliser un tableau de sémaphores binaire pour les philosophes

ainsi qu'un tableau qui représente l'état des philosophes
(pense, mange et affamé).

Gestion de la mémoire

Gestionnaire de la mémoire
La mémoire est une ressource gérée par le Gestionnaire de la Mémoire

qui permet de:
Connaître les parties libres
Connaître les parties occupées
Allouer de la mémoire aux processus qui en ont besoin
Récupérer la mémoire utilisée par un processus qui s’est terminé
Gérer le va et vient (swapping) entre la mémoire secondaire et la
mémoire principale, …
Deux modes principaux de gestion de la mémoire:

Les systèmes à mémoire réelle
Les systèmes à mémoire virtuelle
Systèmes à mémoire réelle
1) Système mono-programmé
Partition
Utilisateur Utilisation d’un registre limite pour protéger
la partition système
Partition système
 Mauvaise utilisation de la mémoire (un seul processus) et

du processeur (attente des E/S)
 Les possibilités du système sont limitées: les programmes
sont limités à la mémoire existante
Systèmes à mémoire réelle (suite)
2) Multiprogrammation avec des partitions fixes

100 K
200 K
50 K
Système
 La mémoire est découpée en plusieurs partitions de taille

différentes mais invariantes
 Des registres limites peuvent être utilisés pour encadrer
chaque partition
 Allocation: utilisation de files multiples ou une file unique
 Problème: Gaspillage de mémoire si la taille demandée est
beaucoup plus petite que celle des partitions.
3) Multiprogrammation avec des partitions variables

 Le nombre, la position et la taille des partitions varient
dynamiquement.
 Allocation et libération plus complexes
 Problème de fragmentation non résolu
 Tassement (compactage):
Le compactage consiste à déplacer les programmes en

mémoire centrale de manière à ne créer qu'une seule et
unique zone libre.
 Problème: Blocage de l’activité système pendant cette

opération
Allocation d’espace contigu

 Représentation des zones libres avec une liste chaînée
 Choix d’une zone libre
 Libération d’une zone occupée
 Traitement des cas où il n’ y a pas de zone libre de taille
suffisante

Choix d’une zone libre (Allocation)

 Trois stratégies pour allouer n octets:
 First-Fit
 Best- Fit
 Worst-Fit
 Libération d’une zone
Pour limiter la fragmentation, on fusionne la zone libérée avec

la ou les zone(s) adjacentes libres (si elles existent)

Inconvénients de l’allocation contiguë

 Perte d’espace due à la fragmentation de la mémoire
 Perte de temps due au compactage
 Nécessité d’une stratégie d’allocation
 Représentation complexe de la mémoire

Mécanisme de pagination
Allocation d’espaces en blocs

 La mémoire est divisée en blocs de tailles identiques appelés
pages
 Une page est le plus petit espace allouable
- Eviter le compactage: Les pages allouées à un processus

ne sont pas forcément contiguës
- Simplifier la représentation: la mémoire peut être

représentée par un vecteur de bits où chaque bit correspond
à une page et indique si cette page est libre ou occupée.

Mécanisme de pagination (Suite)
- Pour libérer une zone occupée par un programme, il suffit

de marquer les pages correspondantes comme libres.
- Pour allouer une zone de n pages, il suffit de marquer n

pages, comme occupées dans la mémoire. Ces pages
peuvent ne pas être contiguës.

Limitations des systèmes à mémoire réelle
- L’espace d’exécution d’un processus doit être
entièrement chargé en mémoire centrale
- La capacité de la mémoire réelle limitera la taille

des programmes utilisateurs
 Systèmes à mémoire virtuelle

Systèmes à mémoire virtuelle
 Lorsqu’un processus s’exécute, seuls certains

blocs de son espace d’exécution peuvent être
présents en mémoire réelle, les autres seront en
mémoire secondaire
 L'espace d’adressage virtuel est divisé en
pages. Les unités correspondantes dans la
mémoire physique sont appelées cadres de
pages (page frame).

Systèmes à mémoire virtuelle (Suite)
 La gestion de la mémoire virtuelle doit

comprendre des:
– Mécanismes de chargement en mémoire réelle
– Une politique de remplacement pour la gestion des

transferts entre mémoire centrale et mémoire
secondaire.

Politique de chargement
Un programme ne peut exécuter une instruction

que si la page qui contient l’instruction, comme
celle contenant chaque donnée repérée sont
présentes dans la mémoire physique.
Nécessité de mise en œuvre d’une technique de

chargement par le système
Chargement par anticipation

Chargement à la demande
Chargement par anticipation
Consiste à amener une page virtuelle en mémoire
avant qu’elle ne soit référencée
Théorie de la localité: les programmes restent

dans les mêmes pages pendant un certain temps.
Technique intéressante dans le cas où les

programmes ont un comportement
raisonnablement séquentiel
Difficile de prédire l’avenir

Chargement à la demande
 Une page est chargée en mémoire à la demande

càd quand elle est référencée.
 Technique utilisée par la presque totalité des

systèmes actuels.
 Quand un programme, durant son exécution,
référence une page qui n’existe pas en M.C, une
interruption de faute de page est déclenchée.
 Le processus correspondant est bloqué en
attente du chargement de la page.
Politique de remplacement
Au bout d’un certain temps, la mémoire centrale est

saturée.
Pour charger une nouvelle page, il va falloir

transférer une autre page vers la mémoire
secondaire.
Problème: Quelle page chasser de la mémoire

principale?
Objectif: diminuer le trafic total de pages entre la

M.C et la M.S
Algorithme de Belady: OPT Algorithme
- Il remplace la page qui sera utilisée le plus tardivement

– Étiqueter chaque page avec le nombre d’instructions qui seront
exécutées avant que cette page ne soit référencée
 Enlever la page dont l’étiquette est la plus grande
(on repousse ainsi le défaut de page aussi tard que possible)
- Algorithme optimal, mais impossible à mettre en œuvre
- Modèle théorique pour mesurer la performance des autres

systèmes

Algorithme de Belady: OPT Algorithme (Suite)
Remplacer la page qui ne sera pas utilisée pendant la plus

longue durée
Exemple:
4 frames (nombre de page en MC)

Demandes de pages: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4,
5
1 1 1 1 1 1 1 1 1 1 4 4
2 2 2 2 2 2 2 2 2 2 2
3 3 3 3 3 3 3 3 3 3
4 4 4 5 5 5 5 5 5
6 fautes de pages
Algorithme Aléatoire: Random Algorithm
La page qui sera remplacée est choisie de façon aléatoire

Algorithme FIFO
- La page la plus ancienne en M.C est remplacée
- Algorithme le plus simple
Problèmes:
- Cet algorithme peut virer des pages importantes. En effet, la

page la plus ancienne peut être la page la plus utilisée.
- Cet algorithme souffre de l'anomalie de Belady.

Algorithme FIFO (Suite)
Exemple: Anomalie de Belady
3 frames (nombre de page en MC)

Demandes de pages: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5
1 1 1 4 4 4 5 5 5 5 5 5
2 2 2 1 1 1 1 1 3 3 3
3 3 3 2 2 2 2 2 4 4
 9 fautes de page.
 En général, plus il y a plus de frames, moins il y aura de

fautes de pages.
Algorithme FIFO (suite)
 Revoir l'exemple avec 4 frames au lieu de 3.
1 1 1 1 1 1 5 5 5 5 4 4
2 2 2 2 2 2 1 1 1 1 5
3 3 3 3 3 3 2 2 2 2
4 4 4 4 4 4 3 3 3
 10 fautes de page.

Algorithme LRU: Least Recently Used
 La page remplacée est la moins récemment utilisée
Un défaut de page remplace la page qui n'a pas été utilisée depuis
le plus longtemps
(Approximation de l'algorithme optimal)
 Associer à chaque page son dernier instant d'utilisation.
 Deux méthodes d'implémentation:

– Avec un compteur
– Avec une pile
 Peut être implémenté au moyen d'un matériel spécialisé

Algorithme LRU: Least Recently Used (Suite)
 Implémentation avec un compteur :

– Chaque page à un compteur. Chaque fois qu'une page est
référencée, l'horloge est copiée dans le compteur.
– Quand une page doit être changée, prendre celle avec le plus
vieux compteur.
Exemple: 4 frames
1 1 1 1 1 1 1 1 1 1 1 5
2 2 2 2 2 2 2 2 2 2 2
3 3 3 3 5 5 5 5 4 4
4 4 4 4 4 4 3 3 3
 8 fautes de pages

Algorithme LFU: Least Frequently Used
 La page remplacée est la moins fréquemment utilisée.

Utilisation d’un compteur incrémenté à chaque fois que la page est
référencée.
Exemple: 4 frames
1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2 2
3 3 3 3 5 5 5 3 3 5
4 4 4 4 4 4 4 4 4
 7 fautes de page

Algorithme NUR: Not Used Recently
 On remplace les pages non utilisées récemment

 Pour les déterminer, on utilise deux indicateurs d’utilisation:
deux bits R et M.
Principe
 chaque fois que la page est lue ou écrite (référencée): R 1
 chaque fois que la page est modifiée: M 1
 A chaque interruption d'horloge: R  0
(afin de distinguer les pages récemment référencées)

Algorithme NUR: Not Used Recently (Suite)
 À un instant donnée, les pages sont organisées par classes:

 Classe 0: non référencée, non modifiée (R= 0 et
M=0)
 Classe 1: non référencée, modifiée (R=0 et M=1)
 Classe 2: référencée, non modifiée (R=1 et M=0)
 Classe 3: référencée, modifiée (R=1 et M=1)
 Comment déterminer la page à virer?

L’algorithme NRU vire une page au hasard dans la plus
basse classe non vide.
Si le bit M=1 de la page à virer, elle doit être copiée sur le
disque. Génie Informatique/ Système d’exploitation II
EMI / Département 94
Limitations
Problème d’écroulement: Thrashing

 Niveau de multiprogrammation élevé
 Quand le nombre de processus augmente, le
nombre de pages présentes pour chacun diminue
 de plus en plus de fautes de pages et attente
de pages
 Le système passe son temps à remplacer des
pages de certains processus pour les donner aux
autres.

Limitations (Suite)
Comment minimiser le thrashing ?

 Algorithme de remplacement local : un processus qui fait du
trashing ne peut pas prendre de frames aux autres
processus.
 Fournir à un processus autant de frames qu'il en a besoin.
Utiliser par exemple le Working Set Model.
– Working Set (Ensemble de Travail): c’est l’ensemble des pages
du processus qui doivent être chargées à un instant donné pour
que le processus s'exécute efficacement
– Si l'ensemble de travail est entièrement en mémoire, le

processus ne fera pas de faute.
– Le système de pagination doit s'assurer que l'ensemble de

travail est en mémoire avant que le processus ne puisse avoir
accès au processeur. 
Gestion des Entrées/Sorties
Les périphériques
1- Moyens de communications entre la machine et l’utilisateur

(écrans, imprimantes…).
2- Moyens de stockage: unités de disques
3- Transfert d’informations depuis ou vers la MC

 Périphériques:
 Entrée (clavier, …), Sortie (Ecran, …), Entrée/Sortie (disque, …)
 Caractère : accès séquentiel, un octet à la fois (imprimante,
clavier, …)
 Bloc: lecture-écriture aléatoire d'un bloc d'octets à la fois
(disques, carte vidéo, ….)

Les contrôleurs de périphériques (Suite)
Disque Imprimante
Contrôleur Contrôleur …….

CPU Mémoire disque Imprimante
Bus
 Contrôleur = Carte électronique possédant un connecteur

pour relier le périphérique
 Un contrôleur peut accepter plusieurs périphériques
 Le système d’exploitation communique avec le contrôleur et
non le périphérique
Les contrôleurs de périphériques
- Le contrôleur: transformer les signaux électriques "compris"
par le périphérique en signaux compris par l’unité centrale
ou la mémoire (et vice versa).
- Un contrôleur possède des registres spécifiques:
 registre(s) d'état
 registre(s) de commande
 registre(s) de données
Exemple: Ecrire un caractère sur un terminal.

- l'UC vérifie si le contrôleur est libre
- Copie le caractère de dans le registre de données
- Indique le sens de transfert (Ecriture)
- l'UC ne peut pas envoyer un 2ème caractère avant le
traitement du premier
 pour exécuter une E/S: UC + Contrôleur + Périphérique

Fonctions d’un système de gestion d’E/S
Il doit permettre au système d’exploitation d’assumer plusieurs tâches:
Indépendance vis-à-vis du matériel par des programmes

gestionnaires de périphériques (device drivers)
Traitement des demandes d’E/S à destination des unités
Prise en compte et analyse de l’interruption renvoyée par le
matériel quand l’E/S est terminée: les données ont été
acheminées en mémoire (entrée) ou transmises à l’unité
périphérique (sortie).
Gestion des erreurs
Partage de périphériques

Lien UC-Contrôleurs
La gestion des transactions entre les périphériques, le
processeur et la mémoire principale peut être implémentée de
plusieurs façons:
Par interrogation: le processeur doit gérer les périphériques

explicitement. Il doit les consulter périodiquement pour réaliser
une E/S.
 Attente active: Le processeur passe son temps à faire de la
scrutation (Polling)
Par interruption: Si le périphérique sollicité est occupé, le

processeur doit faire autre chose (passer à un autre
processus). Quand le périphérique est libre, il envoie un signal
au processeur qui peut alors déclencher la procédure
appropriée.
 Les données passent par le processeur
Accès direct à la mémoire: DMA
Permet d’effectuer des transferts directs entre mémoire et
périphériques sans que les données transférées ne transitent
par l’UC.
UC Mémoire
Bus
Registres
Périphériques
DMA

DMA
Les registres DMA contiennent:

- l’adresse du début de la zone mémoire à transférer
- La longueur de la zone
- Le sens de l'opération
- Adresse du périphérique concerné
Avantages:
Mécanisme d'interruption + DMA: Décharger l'UC de toute la

réalisation des E/S.
 L'UC initialise l'opération: initialisation des registres du DMA.
 Le DMA effectue l'opération d'E/S: lire ou écrire en mémoire
centrale les données transférées par l'unité périphérique.
 Lorsque l'opération d'E/S est terminée, le DMA émet une
interruption pour le signaler au processeur.
Partage de périphérique
 Associer à chaque processus d’E/S une file
d’attente gérée par un sémaphore, car elle peut
être accessible par le processus d’E/S et les
processus demandeurs.
 Utilisation d’un autre sémaphore pour la
synchronisation entre processus demandeur et
processus d’E/S. Le processus d’E/S (s’il n’y a pas
de demande) reste bloqué
 Protection des périphériques d’E/S par la définition

des droits d’accès

Autres fonctions du système d’E/S
 Choix du chemin d’accès aux unités (quand il y a plusieurs
voies physiques possibles)
 Classement des demandes d’E/S (par priorités ou par
ordre d’arrivée)
Dans certains cas d’E/S sur disque, l’ordre des requêtes

peut être adapté de manière à minimiser les déplacements
du bras de lecture.
 Utilisation de SPOOL (Simultaneous Peripheral Operation
Online) pour les imprimantes.
Le spool est un fichier sur disque

 Remédier à la lenteur des matériels d’impression

Se 2020-2021VF PDF

Transféré par

Droits d'auteur :

Formats disponibles

Se 2020-2021VF PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Se 2020-2021VF PDF

Transféré par

Droits d'auteur :

Formats disponibles

Université Mohammed V

École Mohammadia d'Ingénieurs

Mme Z.Bakkoury (bakkoury@emi.ac.ma)

EMI / Département Génie Informatique/ Système d’exploitation II 3

- La multiplicité des différentes ressources.

- La complexité des composants de chacune d’elles,

EMI / Département Génie Informatique/ Système d’exploitation II 4

Pour assurer un service d’impression sur une machine

-Verrouiller l’accès à l’imprimante afin que les flots de

-Gérer les tampons d’impression afin que les programmes

EMI / Département Génie Informatique/ Système d’exploitation II 5

Le problème : gérer l’accès à des ressources

 Connaître l’utilisateur d’une ressource donnée;

Un SE a pour but de:

EMI / Département Génie Informatique/ Système d’exploitation II 7

EMI / Département Génie Informatique/ Système d’exploitation II 8

En tant que gestionnaire de ressources, le SE doit

EMI / Département Génie Informatique/ Système d’exploitation II 9

EMI / Département Génie Informatique/ Système d’exploitation II 10

EMI / Département Génie Informatique/ Système d’exploitation II 11

 Ordonnanceur (scheduleur): se charge de l’ordonnancement

EMI / Département Génie Informatique/ Système d’exploitation II 12

EMI / Département Génie Informatique/ Système d’exploitation II 13

Etats d’un processus:

Elu : En cours d’exécution (Actif)

EMI / Département Génie Informatique/ Système d’exploitation II 14

EMI / Département Génie Informatique/ Système d’exploitation II 15

Lorsque des processus s’exécutent (en même temps),

 Assurer l’exclusion mutuelle

 Assurer la communication inter-processus

EMI / Département Génie Informatique/ Système d’exploitation II 16

Processus créditeur 1 Processus débiteur 1

EMI / Département Génie Informatique/ Système d’exploitation II 18

Exécution de deux processus débiteurs

solde du compte = 1000 En séquentiel: Solde valide=900

Processus débiteur1 Processus débiteur 2

 Si l’accès est concurrent, l’exécution n’est pas cohérente et

 Adopter une solution pour assurer l’exclusion mutuelle

EMI / Département Génie Informatique/ Système d’exploitation II 19

EMI / Département Génie Informatique/ Système d’exploitation II 20

On Considère deux processus comportant une section critique.

Processus P1; Processus P2;

EMI / Département Génie Informatique/ Système d’exploitation II 21

(1) While (verrou == 1); // Attente

{sortie_section;}: verrou = 0; // Déverrouillage

Solution Fausse: la séquence (1)P1; (1)P2;(2)P1;(2)P2 autorise

EMI / Département Génie Informatique/ Système d’exploitation II 22

Utilisation d’une variable verrou (suite)

(2) verrou = pid; // Verrouillage

(3) if (verrou == pid)

La séquence précédente deviendra:

Inconvénients: Attente active , problème (conflit) d’accès à la

C’est une opération indivisible (atomique) dont l’argument est

 Utiliser TAS pour entrer en SC: Initialisation verrou= FALSE

 Problème: attente active

Tour=1; // sortie de la SC, c’est le tour du rédacteur

EMI / Département Génie Informatique/ Système d’exploitation II 25

Procédure Entrer_SC (A_Moi, A_Lui: identité)

(5) WHILE tour!=A_Moi DO NOP;// jusqu’à ce que ce soit mon