Vous êtes sur la page 1sur 24

OPERATING SYSTEMS

1OSS – LABS – CORRECTION


Systèmes d’exploitation

Le fonctionnement des systèmes d’exploitation

Le blocage
L’inter blocage
L’ordonnancement
Avec ou sans priorité
Processus – Processus Léger

Version 1.0
Last update: 13/08/2018
Use: internal
Author: Cyril Alexandre Pachon
1OSS – LABS – CORRECTION
Systèmes d’exploitation

SOMMAIRE

1 TP1 – ELEMENT DE BASE DU SYSTEME ............................................................................................................... 3


1.1 TP1-1 – GENERALITE .................................................................................................................................................... 3
1.2 TP1-2 – LES MECANISMES D’INTERRUPTION ...................................................................................................................... 4
1.3 TP1-3 – EXPLIQUEZ CETTE REPRESENTATION D’UN SYSTEME PREEMPTIF .................................................................................. 6
2 TP2 – ORDONNANCEMENT ................................................................................................................................ 7
2.1 TP2-1 – POLITIQUES D’ORDONNANCEMENT ...................................................................................................................... 7
2.2 TP2-2 – POLITIQUES D’ORDONNANCEMENT AVEC PRIORITE................................................................................................ 10
2.3 TP2-3 – POLITIQUES D’ORDONNANCEMENT AVEC LES ENTREES/SORTIES ............................................................................... 12
3 TP3 – COMMUNICATION INTER PROCESSUS .................................................................................................... 15
3.1 TP3-1 – GENERALITE .................................................................................................................................................. 15
3.2 TP3-2 – UN ALGORITHME ............................................................................................................................................ 16
3.3 TP3-3 – L’EXCLUSION MUTUELLE ................................................................................................................................... 18
3.4 TP3-4 – COMMENT EVITER LES PRIVATIONS ET LES BLOCAGES.............................................................................................. 18
3.5 TP3-5 – LES MONITEURS – LE RENDEZ-VOUS ................................................................................................................... 20
3.6 TP3-6 – LES MONITEURS – PRODUCTEUR/CONSOMMATEUR............................................................................................... 20
4 TP4 – ARCHITECTURE ....................................................................................................................................... 21
4.1 TP4-1 – GENERALITES ................................................................................................................................................. 21
4.2 TP4-2 – EVOLUTION DE LA MEMOIRE CENTRALE ............................................................................................................... 21
4.3 TP4-3 – UNE MEMOIRE SEGMENTEE PAGINEE .................................................................................................................. 23

Page 2 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

1 TP1 – ELEMENT DE BASE DU SYSTEME


1.1 TP1-1 – GENERALITE
1. Définissez et dissociez les notions suivantes :
a. Appel système.
b. Commutation de contexte.
c. Programme.
d. Processus.
e. Processus léger (Thread).

SOLUTION
Appel système : Une fonction fournie par un noyau système. Le système contrôle de façon sécurisée les applications.
Le rôle du noyau est de gérer les ressources et de donner aux programmes une interface uniforme pour l'accès à ces
ressources. Des appels systèmes :
1. open, read, write et close manipulations sur les systèmes de fichiers,
2. alloc, free pour allouer et désallouer de la mémoire.
Commutation de contexte : consiste à sauvegarder l'état d'un processus ou d'un processus léger et à restaurer l'état
d'un autre processus (léger).
Programme : Ensemble d’instruction permettant une réalisation
Processus : Système organisé qui utilise des ressources (machines, informations) pour exécuter une tâche.
Thread ou processus léger, est similaire à un processus, ne contenant que des informations propre au thread

2. Quelles sont les fonctions principales d’un système d’exploitation ?

SOLUTION
Un système d’exploitation doit proposer une machine virtuelle aux utilisateurs. Il doit également gérer les
périphériques d’E/S et les autres ressources systèmes.

3. Parmi ces instructions, lesquelles ne devraient être autorisées qu’en mode noyau ?
a. Désarmer toutes les interruptions.
b. Lire l’horloge donnant la date.
c. Ecrire l’horloge donnant la date.
d. Changer la carte de l’espace d’adressage

SOLUTION
Les choix a, c, d doivent être limités au mode noyau.

4. Avec le schéma et les éléments suivants, reconstruisez un système d‘exploitation :


a. Mode utilisateur
b. Mode Noyau
c. Services exécutifs
d. Gestionnaire de Mémoire
e. Gestionnaire d’entrées/sorties
f. Gestionnaire de processus
g. Pilote de périphériques
h. Matériel

Page 3 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

Schéma à compléter avec les éléments de l’énoncé

SOLUTION
Mode utilisateur

Mode Noyau

Services exécutifs
Noyau Gestionnaire Gestionnaire Gestionnaire
d’entrées/sorties de mémoire de
processus

Pilote de périphériques

Matériel

5. Dans un système quel est le rôle du noyau ?

SOLUTION
Noyau : Ensemble de routines (fonctions fondamentales) gérant le microprocesseur. Il coordonne le travail des
modules de l’exécutif. Avec le noyau, les entrées/sorties sont prises en charges par le processeur. Le noyau permet
alternance des processus = ordonnanceur chapitre suivant.

1.2 TP1-2 – LES MECANISMES D’INTERRUPTION


1. Pourquoi les interruptions ont-elles été définies ?

SOLUTION
Les interruptions sont définies pour les situations ou un programme est en cours de traitement, et qu’une demande
extérieure au programme, nécessite un traitement urgent.

2. Définissez et listez des interruptions internes et des interruptions externes ?

SOLUTION
Interruption : aléas survenant au cours d'une exécution dans un microprocesseur,

Page 4 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

Les interruptions externes sont liées aux périphériques pour contrôler leur comportement par le processeur : Les
interruptions (IT) peuvent résulter d'une demande d'E/S, de la présence de données (un caractère due à une touche du
clavier), l'ouverture d’un lecteur de disque (qui provoque l'arrêt de l'unité).

Les interruptions internes sont faites par le fonctionnement de la machine, elles permettent la diffusion
d'information entre deux composants différents, ou d'activer un composant.
 L’IT Horloge : laisse exécuter un programme normalement jusqu'à expiration d'un délai préfixé.
 L’IT de débordements (Overflow) pour limiter les valeurs des entiers, des réels, des mantisses, des
exposants,...
 L’IT de protection de la mémoire pour limiter les adressages hors zones métriques définies (zones
interdites), …
 L’IT de code d’opération inconnu pour stopper l’exécution d’une instruction dont le code n'existe pas
(c'est souvent une donnée...). (Pour cette architecture se sont les Traps)
 L’IT des pannes matérielles comme la coupure de courant impliquant la sauvegarde immédiate des
données importantes sur disque en utilisant les condensateurs qui assurent une autonomie de quelques
secondes.

3. Dans quelles situations les interruptions vont-elles être efficaces et rendre services à l’utilisateur ?

SOLUTION
 Un programme boucle indéfiniment, l’intervention extérieure (par exemple Cltr C) est une interruption pour le
système pour stopper le processus sur le processeur.
 Erreur d’algorithme dans le processus en (par exemple une division par 0). Le processus doit être détruit, car son
exécution est anormale. Dans les langages de programmation, cette erreur peut être traitée par le programmeur,
avec un traitement sécurisé.
 Lors d’un problème sur un périphérique. Par exemple, s’il manque du papier pour une impression (le processus
en cours est soit une routine interne d’impression, soit une demande d’impression d’un utilisateur), il faut une
interruption pour faire une demande de recharge de papier.
 Certains processus évoluent en temps-réel. Il faut donc des systèmes d’interruption pour contrôler et maitriser
les erreurs.

4. Donnez les caractéristiques des programmes avec interruptions et sans interruptions ?

SOLUTION
 sans interruptions (activation explicite) : le programme comporte des instructions de test pour éviter les erreurs
relatives à des interruptions.
 avec interruptions (activation matériel) : Les programmes peuvent avoir des modules différents, imbriqués ou
liés sans tenir comptes des erreurs. La protection se fait par les routines d’interruption qui protègent la machine.

5. Un programme s’exécute correctement sur le processeur, lorsqu’une interruption de type 3


(déclenchée par une unité périphérique) survient. 1002 est l’adresse de la prochaine instruction du
programme lambda qui devait s’exécuter dans le processeur. 0017 est l’adresse de la routine
associée à l’interruption de type n°3.
a. Décrivez la table des vecteurs d’interruption.
b. Décrivez le mécanisme d’interruption ci-dessus, n’oubliez pas le retour d’interruption. Vous
pouvez argumenter votre scénario d’interruption par un schéma. N’oubliez pas de décrire les
mécanismes au niveau du Compteur Ordinal.

Page 5 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

SOLUTION

1 - Le processeur exécute le programme.


2 - L'interruption n°3 survient, déclenchée par une unité périphérique.
3 - Le processeur arrête alors l'exécution du programme.
4 - Le processeur sauvegarde le contexte du processeur en mémorisant notamment l'adresse de la prochaine
instruction à exécuter dans le programme (ici 1002).
5 - Puis le processeur détermine grâce à une table appelée la table des vecteurs d'interruptions, l'adresse de la
routine associée à l'interruption n°3. : ici 0017.
6 – Le processeur charge alors le CO (Compteur Ordinal) avec cette adresse, exécute la routine d'interruption
7 – La routine se termine par l'instruction machine RTI (return Interrupt). Cette instruction restaure le contexte
sauvegardé lors de la prise en compte de l'interruption : le CO est chargé avec l'adresse 1002
8 - le programme reprend son exécution là où il avait été interrompu.

1.3 TP1-3 – EXPLIQUEZ CETTE REPRESENTATION D’UN SYSTEME PREEMPTIF

Page 6 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

SOLUTION
Ce schéma illustre le déroulement des opérations d'ordonnancement avec deux processus P0 et P1.
1 - Initialement le processus P0 est élu et s'exécute.
2- Le processus P1 est dans l'état prêt.
3 - Le processus P0 fait un appel système : il y a commutation de contexte avec changement de protection pour aller
exécuter le code de l'appel système (passage en mode superviseur) au cours duquel le processus P0 se bloque.
4 - Il y a une opération d'élection et le processus P1 est élu : le contexte processeur associé au processus P0 est
sauvegardé dans le PCB du processus P0 (PCB0) et le processeur est chargé avec le PCB du processus 1 (PCB1).
5 - Le processus P1 commence alors son exécution.
6 - Au cours de cette exécution, le processus P0 obtient la ressource demandée au cours de son appel système et
dont l'indisponibilité l'avait bloqué, et donc repasse dans l'état prêt.
7 - Une interruption survient : il y a commutation de contexte avec changement de protection pour aller exécuter le
code de l'interruption (passage en mode superviseur).
8 - A la fin du traitement de l'interruption, une opération d'ordonnancement est lancée : le processus P0 est de
nouveau élu : le contexte processeur associé au processus P1 est sauvegardé dans le PCB du processus P1 (PCB1) et le
processeur est chargé avec le PCB du processus 0 (PCB0).

2 TP2 – ORDONNANCEMENT
2.1 TP2-1 – POLITIQUES D’ORDONNANCEMENT
1. Nous considérons 5 processus numérotés de P1 à P5 dont les caractéristiques sont résumées dans le
tableau suivant :
Processus Date d’arrivée Temps d’exécution
P1 0 5
P2 0 5
P3 0 9
P4 0 14
P5 0 1

Exécutez les politiques d’ordonnancement :


 FCFS (First come First served) ou FIFO (First in First out)
1 Exprimez le temps de séjour de chaque processus
2 Exprimez le temps d’attente de chaque processus
3 Exprimez le temps moyen de séjour
4 Exprimez le temps moyen d’attente
5 Exprimez par un diagramme de Gantt (un tableau d’ordonnancement)
6 Calculez le taux d’utilisation

 Plus court d’abord


1 Exprimez le temps de séjour de chaque processus
2 Exprimez le temps d’attente de chaque processus
3 Exprimez le temps moyen de séjour
4 Exprimez le temps moyen d’attente
5 Exprimez par un diagramme de Gantt (un tableau d’ordonnancement)
6 Calculez le taux d’utilisation

 Tourniquet avec un quantum de temps égal à 2 unités


1 Exprimez le temps de séjour de chaque processus
2 Exprimez le temps d’attente de chaque processus
3 Exprimez le temps moyen de séjour
4 Exprimez le temps moyen d’attente

Page 7 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

5 Exprimez par un diagramme de Gantt (un tableau d’ordonnancement)


6 Calculez le taux d’utilisation

SOLUTION
-POLITIQUE : Premier arrivé, premier servi
: ORDE : P1, P2, P3, P4, P5
: Temps d’attente P1=0, P2=5, P3=10, P4= 19, P5=33
: Temps de séjour P1=5, P2=10, P3=19, P4=33, P5=34
: Temps moyen de séjour (5+10+19+33+34)/5 = 20,2
: Temps moyen d’attente (0+5+10+19+33)/5 = 13,4
: Tableau de Gantt :

Temps T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 T16 T17


Processus 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 3 3 3

Temps T18 T19 T20 T21 T22 T23 T24 T25 T26 T27 T28 T29 T30 T31 T32 T33
Processus 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5
: Taux : 100%

-POLITIQUE : Par plus petit temps de séjour non préemptif


: ORDE : P5, P1, P2, P3, P4
: Temps d’attente P1=1, P2=6, P3=11, P4= 20, P5=0
: Temps de séjour P1=6, P2=11, P3=20, P4=34, P5=1
: Temps moyen de séjour (6+11+20+34+1)/5 = 14,4
: Temps moyen d’attente (1+6+11+20+0)/5 = 7,6
: Tableau de Gantt :

Temps T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 T16 T17


Processus 5 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 3 3

Temps T18 T19 T20 T21 T22 T23 T24 T25 T26 T27 T28 T29 T30 T31 T32 T33
Processus 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4
: Taux : 100%

-POLITIQUE : Tourniquet avec un quantum de temps égal à 2 unités


: ORDE : P1, P2, P3, P4, P5, P1, P2, P3, P4, P5,
: Temps d’attente P1=13, P2=14, P3=19, P4= 20, P5=8
: Temps de séjour P1=18, P2=19, P3=28, P4=34, P5=9
: Temps moyen de séjour (18+19+28+34+9)/5 = 21,6
: Temps moyen d’attente (13+14+19+20+8)/5 = 14,8
: Tableau de Gantt :

Temps T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 T16 T17


Processus 1 1 2 2 3 3 4 4 5 1 1 2 2 3 3 4 4 1

Temps T18 T19 T20 T21 T22 T23 T24 T25 T26 T27 T28 T29 T30 T31 T32 T33
Processus 2 3 3 4 4 3 3 4 4 3 4 4 4 4 4 4
: Taux : 100%

-POLITIQUE : Tourniquet avec un quantum de temps égal à 3 unités


: ORDE : P1, P2, P3, P4, P5, P1, P2, P3, P4, P5,
: Temps d’attente P1=10, P2=12, P3=17, P4= 20, P5=12
: Temps de séjour P1=15, P2=17, P3=26, P4=34, P5=13
: Temps moyen de séjour (15+17+26+34+13)/5 = 21,0

Page 8 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

: Temps moyen d’attente (10+12+17+20+12)/5 = 14,2


: Tableau de Gantt :

Temps T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 T16 T17


Processus 1 1 1 2 2 2 3 3 3 4 4 4 5 1 1 2 2 3

Temps T18 T19 T20 T21 T22 T23 T24 T25 T26 T27 T28 T29 T30 T31 T32 T33
Processus 3 3 4 4 4 3 3 3 4 4 4 4 4 4 4 4
: Taux : 100%

2.Nous considérons 5 processus numérotés de P1 à P5 dont les caractéristiques sont résumées dans le
tableau suivant :
Processus Date d’arrivée Temps d’exécution
P1 0 2
P2 0 6
P3 0 10
P4 0 4
P5 0 12
Exécutez les politiques d’ordonnancement :
 FCFS (First come First served) ou FIFO (First in First out)
1 Exprimez le temps de séjour de chaque processus
2 Exprimez le temps d’attente de chaque processus
3 Exprimez le temps moyen de séjour
4 Exprimez le temps moyen d’attente
5 Exprimez par un diagramme de Gantt (un tableau d’ordonnancement)
6 Combien de changement de contexte

 Plus court d’abord


1 Exprimez le temps de séjour de chaque processus
2 Exprimez le temps d’attente de chaque processus
3 Exprimez le temps moyen de séjour
4 Exprimez le temps moyen d’attente
5 Exprimez par un diagramme de Gantt (un tableau d’ordonnancement)
6 Combien de changement de contexte

SOLUTION
-POLITIQUE : Premier arrivé, premier servi
: ORDE : P1, P2, P3, P4, P5
: Temps d’attente P1=0, P2=2, P3=8, P4= 18, P5=22
: Temps de séjour P1=2, P2=8, P3=18, P4=22, P5=34, (8 = 2 + 6, 18 = 8 + 10, …)
: Temps moyen de séjour (2+8+18+22+34)/5 = 16,8
: Temps moyen d’attente (0+2+8+18+22)/5 = 10

Temps T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 T16 T17


Processus 1 1 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3

Temps T18 T19 T20 T21 T22 T23 T24 T25 T26 T27 T28 T29 T30 T31 T32 T33
Processus 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5
5 changements de contextes. Nous supposons initialement que le processeur n’était pas en train de traiter le
processus P1. Donc Init  P1  P2  P3  P4  P5.

-POLITIQUE : Plus court d’abord


: ORDE : P1, P4, P2, P3, P5
: Temps d’attente P1=0, P2=6, P3=12, P4= 2, P5=22

Page 9 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

: Temps de séjour P1=2, P2=12, P3=22, P4=6, P5=34,


: Temps moyen de séjour (2+6+12+22+34)/5 = 15.2
: Temps moyen d’attente (0+6+12+2+22)/5 = 8.4

Temps T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 T16 T17


Processus 1 1 4 4 4 4 2 2 2 2 2 2 3 3 3 3 3 3

Temps T18 T19 T20 T21 T22 T23 T24 T25 T26 T27 T28 T29 T30 T31 T32 T33
Processus 3 3 3 3 5 5 5 5 5 5 5 5 5 5 5 5
5 changements de contextes. Nous supposons initialement que le processeur n’était pas en train de traiter le
processus P1. Donc Init  P1  P2  P3  P4  P5.

2.2 TP2-2 – POLITIQUES D’ORDONNANCEMENT AVEC PRIORITE


1. Nous considérons 5 processus numérotés de P1 à P5 dont les caractéristiques sont résumées dans le
tableau suivant :
Processus Date d’arrivée Temps d’exécution Priorité
P1 0 2 2
P2 0 6 4
P3 0 10 3
P4 0 4 5
P5 0 12 1
Le 5 est la priorité la plus forte et le 1 la plus faible

 Par priorité constante


1 Exprimez le temps de séjour de chaque processus
2 Exprimez le temps d’attente de chaque processus
3 Exprimez le temps moyen de séjour
4 Exprimez le temps moyen d’attente
5 Exprimez par un diagramme de Gantt (un tableau d’ordonnancement)
6 Combien de changement de contexte

 Tourniquet avec un quantum de temps égal à 2 unités


1 Exprimez le temps de séjour de chaque processus
2 Exprimez le temps d’attente de chaque processus
3 Exprimez le temps moyen de séjour
4 Exprimez le temps moyen d’attente
5 Exprimez par un diagramme de Gantt (un tableau d’ordonnancement)
6 Combien de changement de contexte

SOLUTION
-POLITIQUE : Par priorité
: ORDE : P4, P2, P3, P1, P5
: Temps d’attente P1=20, P2=4, P3=10, P4= 0, P5=22
: Temps de séjour P1=22, P2=10, P3=20, P4=4, P5=34,
: Temps moyen de séjour (22+10+20+4+34)/5 = 18
: Temps moyen d’attente (20+4+10+0+22)/5 = 11.2
Temps T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 T16 T17
Processus 4 4 4 4 2 2 2 2 2 2 3 3 3 3 3 3 3 3

Temps T18 T19 T20 T21 T22 T23 T24 T25 T26 T27 T28 T29 T30 T31 T32 T33
Processus 3 3 1 1 5 5 5 5 5 5 5 5 5 5 5 5
5 changements de contextes. Nous supposons initialement que le processeur n’était pas en train de traiter le
processus P4. Donc Init  P4  P2  P3  P1  P5.

Page 10 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

-POLITIQUE : Par quantum de temps =2


: ORDE : P1, P2, P3, P4, P5, P2, P3, P4, P5, P2, P3,P5,P3,P5,P3, P5,P5
: Temps d’attente P1=0, P2=14, P3=20, P4= 12, P5=22
: Temps de séjour P1=2, P2=20, P3=30, P4=16, P5=34, (20 = 2+2+2+2+2+2+2+2+2+2, 16 = 2+2+2+2+2+2+2+2 …. )
: Temps moyen de séjour (2+20+30+16+34)/5 = 20.4
: Temps moyen d’attente (0+14+20+12+22)/5 = 13.6
Temps T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 T16 T17
Processus 1 1 2 2 3 3 4 4 5 5 2 2 3 3 4 4 5 5

Temps T18 T19 T20 T21 T22 T23 T24 T25 T26 T27 T28 T29 T30 T31 T32 T33
Processus 2 2 3 3 5 5 3 3 5 5 3 3 5 5 5 5
16 changements de contextes Nous supposons initialement que le processeur n’était pas en train de traiter le
processus P1. Donc Init  P1  P2  P3  P4  P5  P2  P3  P4  P5  P2  P3  P5  P3  P5  P3  P5.
En respectant un ordre différent pour les processus :
Temps de séjour moyen = 20.8
Temps moyen d’attente = 14

2. Nous considérons 5 processus numérotés de P1 à P5 dont les caractéristiques sont résumées dans le
tableau suivant :
Processus Date d’arrivée Temps d’exécution Priorité
P1 2 2 1
P2 4 6 4
P3 5 3 2
P4 0 4 5
P5 0 7 3
Le 1 est la priorité la plus forte et le 5 la plus faible
Donnez l’ordre de service des processus et le temps de réponse moyen obtenu dans le cas :
1. D’un ordonnancement par priorité non préemptif
2. D’un ordonnancement par priorité préemptif
3. D’un ordonnancement par tourniquet avec un quantum de temps égal à 2 unités

SOLUTION
 D’un ordonnancement par priorité non préemptif
P5 (7) P1(2) P3(3) P2(6) P4(4)
Temps moyen d’attente : (5 + 0 + 4 + 18 + 8)/5
(P5(0) + P1(5) +P3(4) + P2(8) + P4(18)) / 5 = 7 UT
Temps de séjour
7 + 9 +12 + 18 + 22 / 5 = 13,6 UT

 D’un ordonnancement par priorité préemptif


P5 (2) P1(2) P5(1) P3(3) P5(4) P2(6) P4(4)
Temps moyen d’attente (0 + 8 + 0 + 18 + 5) / 5 = 6,2 UT
Temps de séjour
(2+14+4+18+12)/5 = 10 UT

 D’un ordonnancement par tourniquet


P4,P5,P1,P2,P3,P4,P5,P2,P3,P5,P2,P5
T=((0-0)+(2-0) +(4-2) +(6-4) +(8-5) +(10-4) +(12-2) +(14-8) +(16-10) +(17-14) + (19 - 16) +(21-19))/5
T=9 UT
Temps de séjour
P1 (4) P2(17) P3(12) P4(12) P5(22)
T= (4+17+12+12+22)/5
T= 13,4 UT

Page 11 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

2.3 TP2-3 – POLITIQUES D’ORDONNANCEMENT AVEC LES ENTREES/SORTIES


Nous disposons d’un ordinateur avec un seul processeur. Pendant leur exécution, les processus partagent un même
disque et suivent un mécanisme de répartition. Le disque est utilisé de façon exclusive et non partageable. La gestion du
disque est faite selon un cycle d’entrées / sorties. Les cycles d’utilisation du processeur sont indépendantes des cycles des
entrées / sorties disque. Les processus se mettent en attente d’entrées / sorties, si l’accès au disque est déjà occupé par
un autre processus, sinon il prend l’accès de cette entrée / sortie. L’accès à l’entrée / sortie est donc faite selon
l’ancienneté de l’attente du processus.
Dans la gestion de l’ordonnancement, nous avons donc les états suivants pour les processus :
1. Elu
2. En attente du processeur
3. En cycle d’entrée / sortie disque
4. En attente d’entrée / sortie disque
Votre système fonctionne avec 4 processus nommés P1, P2, P3, P4 et les cycles d‘utilisation du processeur se font de
la façon suivante :
Les processus P1 et P2 suivent un fonctionnement de premier arrivé premier servi préemptif. En cas de conflits de
date entre les processus, le processus le plus prioritaire est Elu.
Les caractéristiques de P1 et P2 sont les suivantes :

Processus Date arrivée Priorité Comportement


P1 0 1 Calcul sur processeur : 3 UT
Entrée / sortie disque : 5 UT
Calcul sur processeur : 4 UT
Entrée / sortie disque : 4 UT
Calcul sur processeur : 1 UT

P2 0 2 Calcul sur processeur : 3 UT


Entrée / sortie disque : 5 UT
Calcul sur processeur : 7 UT
Entrée / sortie disque : 5 UT
Calcul sur processeur : 1 UT

La plus petite valeur correspond à la priorité la plus forte.

Les processus P3 et P4 suivent un fonctionnement de tourniquet. Le processeur est donné au processus pour un
quantum de temps égal à 1 UT.
Les caractéristiques de P3 et P4 sont les suivantes :

Processus Date arrivée Priorité Comportement


P3 2 2 Calcul sur processeur : 1 UT
Entrée / sortie disque : 4 UT
Calcul sur processeur : 5 UT

P4 5 2 Calcul sur processeur : 10 UT

La plus petite valeur correspond à la priorité la plus forte.


Les processus P1, P2 sont plus prioritaires que les processus P3, P4 pour obtenir le processeur.

1. Donnez quelles sont toutes les ressources partagées par les processus ?
SOLUTION
Deux ressources : Un disque et un processeur.

Page 12 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

2. Expliquez dans le détail les deux systèmes de fonctionnement de P1, P2 d’une part de P3, P4 d’autre
part.
SOLUTION
P1 et P2 : Pour la ressource processeur, Les processus peuvent être interrompus par un autre processus du même
système premier arrivé premier servi ayant une priorité supérieure. Ils ne sont pas interrompus par d’autre catégorie de
processus. Pour la ressource disque nous n’avons pas de priorité et tous les processus sont dans la même file d’attente.
P3 et P4 : Pour la ressource processeur, les processus fonctionnent en tourniquet donc celui qui attend la ressource
en premier aura son quantum de 1UT. Si celui qui attend en premier n’a toujours pas eu son quantum au moment ou un
autre arrive dans la file d’attente, il reste prioritaire. Le plus ancien est toujours prioritaire. Pour la ressource disque nous
n’avons pas de priorité tous les processus sont dans la même file d’attente.

3. Donnez le temps total de gestion du processus P1 à savoir son temps de calcul + son temps d’entrées /
sorties + ses temps d’attentes. Détaillez.

SOLUTION
Le plus simple est de faire les diagrammes de Gantt de chaque processus. Nous sommes dans un mécanisme de
répartition Elu, Prêt, En attente (avec En attente = attente d’E/S puis cycle d’E/S sur le disque pour retourner dans
l’état Prêt). Donc, au début de l’ordonnancement, soit le processus est Elu, soit il est dans la file des Prêt. Dès que le
processus a fini sa phase de calcul, il passe dans l’état En attente (pour effectuer sa phase d’E/S). Le processus le plus
prioritaire est P1 qui prend directement le processeur, car il arrive en date 0 en même temps que P2 qui se place dans
la file des Prêt. Puis tous les autres processus (P3, P4) se placent dans la file des Prêt en arrivant à des dates décalées
et que le processeur est utilisé par P2. Puis les cycles fonctionnement commencent :

P1 Elu
Prêt
E/S D
Attente E/S D

P2 Elu
Prêt
E/S D
Attente E/S D

P3 Elu
Prêt
E/S D
Attente E/S D

P4 Elu
Prêt
E/S D
Attente E/S D
Le diagramme est numéroté de T0 T1 T2 … T34

Ne pas oublier que la gestion du disque se fait sur l’ancienneté et non pas sur la priorité, c’est pour cela qu’à T13, P3
passe avant P1 pour l’E/S du disque lorsque P2 quitte le disque (à ce moment P1 se met dans la file de En attente d’E/S du
disque).

Pour la gestion du tourniquet, pas de priorité entre les deux processus, ils ont donc tous les deux un quantum de 1UT.
Au Temps T20, P4 passe avant P3, car c’est l’ancienneté d’attente dans la file des Prêt qui prime et comme P4 attend
depuis plus longtemps que P3 (il en tête dans la file), il passe Elu.

Temps Elu : 3 + 4 + 1 = 8 UT
Temps d’E/S D : 5 + 4 = 9 UT

Page 13 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

Temps d’attente E/S : 5 UT


Total : 8 + 9 + 5 = 22 UT

4. Donnez le temps total de gestion du processus P2 à savoir son temps de calcul + son temps d’entrées /
sorties + ses temps d’attentes. Détaillez.

SOLUTION
Temps de calcul : 3 + 7 + 1 = 11 UT
Temps d’E/S D : 5 + 5 = 10 UT
Temps d’attente Prêt + E/S : 3 + (2 + 1) = 6 UT
Total : 11 + 10 + 6 = 27 UT

5. Donnez le temps total de gestion du processus P3 à savoir son temps de calcul + son temps d’entrées /
sorties + ses temps d’attentes. Détaillez.

SOLUTION
Temps de calcul : 1 + 1 + 1 + 1 + 1 + 1 = 6 UT
Temps d’E/S : 4 UT
Temps d’attente Prêt + E/S + Prêt : (4) + (6) + (5 + 1 + 2 + 1 + 1) = 20 UT
Total : 6 + 4 + 20 = 30 UT

6. Donnez le temps total de gestion du processus P4 à savoir son temps de calcul + ses temps d’attentes.
Détaillez.

SOLUTION
Temps de calcul : 1 + 1 + 1 + 1 + 1 + 1 + 1 + 3 = 10 UT
Temps d’attente Prêt : 2 + 4 + 7 + 2 + 1 + 2 + 1 + 1 = 20 UT
Total : 10 + 20 = 30 UT
Nous n’avons pas de Temps d’E/S à calculer car il n’en comporte pas dans le comportement deP4, donc pas de point
à attribuer.

7. Donnez le temps moyen d’attente pour les entrées / sorties disque, justifiez votre résultat.

SOLUTION
5 + (2 + 1) + 6 + 0 = 14 UT
Temps moyen pour 4 processus = 14/4 UT ou 3.5 UT

8. Donnez le temps moyen d’attente pour le processeur, justifiez votre résultat.

SOLUTION
0 + 3 + (4 + 5 + 1 + 2 + 1 + 1) + (2 + 4 + 7 + 2 + 1 + 2 + 1 + 1) = 37 UT
Temps moyen pour 4 processus = 37/4 UT ou 9.25 UT

9. Donnez le taux d’occupation du processeur, justifiez votre résultat.

SOLUTION
100% :
8 + 11 + 6 + 10 = 35 UT comme nous sommes numérotés de T0 à T34 nous avons bien 35UT  100%

Page 14 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

3 TP3 – COMMUNICATION INTER PROCESSUS


3.1 TP3-1 – GENERALITE
1. Qu’est-ce que la monoprogrammation ?

SOLUTION
La monoprogrammation met en mémoire qu'un seul programme. Ce programme a toute la mémoire (même s'il ne
l'utilise pas entièrement). L’ordonnancement est :
a. Chargement du programme,
b. Lancement de l’exécution,
c. attendre la fin de l’exécution,
d. Libération.

2. Qu’est-ce que la multiprogrammation ?

SOLUTION
La multiprogrammation est l’échange rapide du processeur entre plusieurs processus en mémoire. Elle sert
essentiellement à occuper le processeur pendant qu’un ou plusieurs processus exploitent l’E/S. La multiprogrammation
nécessite un mécanisme de protection pour lutter contre les erreurs. Le mécanisme doit protéger les utilisateurs et le
système contre les utilisateurs eux-mêmes, mais non perturber le système. Le système est réputé fiable.

3. Pourquoi une table de processus est-elle nécessaire dans un système à temps partagé ?

SOLUTION
La table de processus sert à stocker l’état du processus suspendu, qu’il soit prêt ou bloqué.

4. Une table de processus, est-elle également requise dans un système personnel où un seul processus existe,
avec accès à toute la machine durant son exécution ?

SOLUTION
Elle n’est pas nécessaire dans un système à processus unique, puisque celui-ci n’est jamais suspendu.

Page 15 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

3.2 TP3-2 – UN ALGORITHME

1. Donnez l’algorithme du graphe précédent ? Il s’agit de deux algorithmes (2 processus).


2. Etudiez le fonctionnement de cet algorithme et détectez si :
a. Nous avons des erreurs de blocages, d’inter blocages, de famines, d’attentes infinies ?
b. Nous avons de l’exclusion mutuelle ?
c. Nous avons de la dépendance entre les processus ?
3. Donnez l’arbre des appels de votre algorithme?

SOLUTION
trn  1; C1, C2 : ENTIER
P1 P2
NC1: a2 (action quelconque 2) NC2: b2 (action quelconque 2)
C1  0; C2  0;
L1: a3 (action quelconque 3) L2: b3 (action quelconque 3)
si (C2 = 0) alors si (C1 = 0) alors
a4 (action quelconque 4) b4 (action quelconque 4)
si (trn = 1) alors si (trn = 2) alors
aller à L1; aller à L2;
sinon sinon
a6 (action quelconque 6) b6 (action quelconque 6)
C1  1; C2  1;
a8 (action quelconque 8) b8 (action quelconque 8)
ATT1 : tant que (trn = 2) faire; ATT2 : tant que (trn = 1) faire;
aller à NC1; aller à NC2;
fin si; fin si;

Page 16 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

sinon sinon
a5 (action quelconque 5) b5 (action quelconque 5)
crit1 ; crit2 ;
a7 (action quelconque 7) b7 (action quelconque 7)
trn  2 ; trn  1 ;
C1 1 ; C2 1 ;
aller à NC1; aller à NC2;
fin si ; fin si ;
C’est l’algorithme de Dekker

Si pas de conflit P1 entre alors directement en section critique.


En cas de conflit d'accès, NC1L1 et NC2L2 sont entrelacées, et ne modifient pas Trn. Notez que les deux processus
exécutent des boucles d'attente mais différentes.
Si Trn = 1, P2 se met en attente en ATT2, C2 a été remis à 1. Donc P1 sort de la boucle L1 et entre en section critique.
 L'attente infinie est évitée,
 L'exclusion mutuelle est garantie,
 L'indépendance est aussi assurée, car si P2 n'entre plus en section critique, C2 est à 1, et les instructions en L1 ne
seront pas exécutées.
L'entier trn ne sert à départager arbitrairement les deux processus en cas de conflit d'accès : en donnant la priorité à
l'un d'eux, il évite le blocage.

L’arbre des appels est le suivant en fonction des actions des C1, C2 et trn :

Page 17 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

3.3 TP3-3 – L’EXCLUSION MUTUELLE


Soit l’algorithme suivant :
LIBRE, OCCUPE : BOOLEEN ;

PROCEDURE EntrerDansSection ( BOOLEEN verrou )


DEBUT
Tantque (verrou = OCCUPE )
Faire
attendre();
verrou  OCCUPE ;
Fin Tantque
Fin PROCEDURE

PROCEDURE SortirDeSection (BOOLEEN verrou )


DEBUT
verrou  LIBRE ;
Fin PROCEDURE

PROCEDURE attendre()
DEBUT
VAR compteur  0 ;
Tantque (compteur /= 1000)
FAIRE
compteur  compteur +1
Fin Tantque
Fin PROCDURE

Dans le code précédent verrou est l’adresse d’une variable partagée entre plusieurs processus. Expliquez si les
sections critiques des processus élus seront protégées ? Donnez un exemple d’exécution à l’aide de deux processus
nommés P1 et P2 pour affirmer vos explications ?

SOLUTION
Comme il est noté dans la question verrou est une variable partagée car nous faisons référence à son adresse.
Il ne s’agit pas de copie mais de la même variable.
Le problème est que le test de la variable verrou et de son affectation à la valeur OCCUPE s’entrelace avec l’exécution
d’autres processus (ce n’est pas atomique) donc pas de protection efficace des sections critiques.
Soit P1 et P2 utilisant EntrerDansSection, SortirDeSection. Nous pouvons faire le déroulement suivant :

P1 | P2
SI (verrou = LIBRE) |
| SI (verrou = LIBRE)
verrou  OCCUPE |

Les processus P1 et P2 exécuteront leurs sections critiques sans exclusion. Donc ce programme ne garantit pas
l’exclusion mutuelle.

3.4 TP3-4 – COMMENT EVITER LES PRIVATIONS ET LES BLOCAGES


Le problème des philosophes : 5 philosophes sont réunis autour d'une table pour manger des spaghettis. Chaque
philosophe doit utiliser 2 fourchettes pour manger. Et si il ne peut pas manger il pense. 2 Philosophes peuvent manger en
même temps et 3 philosophes pensent. Il faut éviter les famines (c'est-à-dire chaque philosophe doit manger à tour de
rôle). Les fonctions que vous avez et que vous devez décrire sont Penser() et Manger().

Page 18 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

Donnez un algorithme pour cette réflexion dégustative ?


SOLUTION
SOLUTION FAUSSE :
Function Philosophe i
Penser();
P(fourchette i);
P(fourchette (i+1) mod 5;
manger();
V(fourchette i);
V(fourchette (i+1) mod 5;

Si tous les philosophes prennent en même temps leur fourchette i, il y a inter blocage.
SOLUTION
Semaphore mutex  sem(1)
Fonction Philosophe i
Penser();
prendre_fourchette(i);
manger();
poser_fourchette(i);

Fonction Prendre_fourchette(i)
P(mutex);
état[i]FAIM;
test(i);
V(mutex);
P(s[i]); /* philosophe bloqué */

Fonction Poser_fourchette(i)
P(mutex);
état[i]PENSE;
test(GAUCHE);
test(DROITE);
V(mutex);

/* Faire une fonction test qui réveille un philosophe qui a faim */


Fonction test(i)
si (état[i]=FAIM&&état[GAUCHE] != MANGE&& état[DROITE] != MANGE)
Alors
état[i]MANGE;
FinSI
V(s[i]); /* libération du philosophe de son attente */

Page 19 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

3.5 TP3-5 – LES MONITEURS – LE RENDEZ-VOUS


Ecrire un moniteur pour effectuer le rendez-vous de N Processus ? Le but de ce moniteur est de permettre
l’attente de N processus suivant la condition du nombre de processus à attendre et des processus présents.
SOLUTION
Moniteur de rendez-vous
N  10: constante

Var
n : entier;
tous_présent : condition;

Procédure arriver;

Début
nn+1;

si n<N alors tous_présent.attendre;

tous_présent.signaler;
fin;

Début
n0;
fin

3.6 TP3-6 – LES MONITEURS – PRODUCTEUR/CONSOMMATEUR


Résoudre le problème du Producteur/Consommateur avec les moniteurs utilisant une seule case.

SOLUTION
Moniteur Producteur/Consommateur
Var
Plein : booléen ;
Buffer : Caractère ;
Pr, Co : Condition

Procédure Produire (C : caractère)


Début
Si Plein alors Pr.attendre;

Buffer  C,
Plein  Vrai;
Co.Signaler ;
Fin

Procédure Consommer (C : caractère)


Debut
Si Non Plein alors Co.attendre;

C  Buffer;

Page 20 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

Plein  Faux ;
Pr.Signaler
Fin

Début /* Initialisation */
Plein  Faux
Fin

Processus Producteur
Début
Répéter
Construire(Message) ; /* instance de Producteur(C : caractère) */
Produire(Message) ;
Fin

Processus Consommateur
Début
Répéter
Consommer(Message) ; /* instance de Consommer(C : caractère) */
Afficher(Message) ;
Fin

4 TP4 – ARCHITECTURE
4.1 TP4-1 – GENERALITES
Que fait le système d’exploitation lors d’une pagination ?

SOLUTION
1. Le SE maintient une liste de toutes les cases disponibles.
2. La taille des programmes s’exprime en termes de case. Pour un programme de n cases le SE doit trouver n
cases disponibles.
3. La translation des adresses se fait par l’intermédiaire d’une translation maintenue par le SE
4. Par contre la fragmentation interne n’est pas résolue.

4.2 TP4-2 – EVOLUTION DE LA MEMOIRE CENTRALE


1. Soit la liste des pages virtuelles référencées aux instants t=1,2,…,11 :4 6 7 9 4 10 7 12 4 7 11. La
mémoire centrale est composée initialement de 4 cases. Représentez l’évolution de la mémoire centrale au
fur et à mesure des accès pour chacune des deux politiques de remplacement de pages FIFO et LRU. Indiquez
les défauts de pages éventuelles.

SOLUTION
FIFO :
T 1 2 3 4 5 6 7 8 9 10 11
bloc 4 6 7 9 4 10 7 12 4 7 11
Case :
1 4 4 4 4 4 10 10 10 10 10 11
2 6 6 6 6 6 6 12 12 12 12
3 7 7 7 7 7 7 4 4 4
4 9 9 9 9 9 9 7 7
Défaut de pages D D D D D D D D D

Page 21 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

LRU :
T 1 2 3 4 5 6 7 8 9 10 11
bloc 4 6 7 9 4 10 7 12 4 7 11
Case :
1 4 4 4 4 4 4 4 4 4 4 4
2 6 6 6 6 10 10 10 10 10 11
3 7 7 7 7 7 7 7 7 7
4 9 9 9 9 12 12 12 12
Défaut de pages D D D D D D D

2. Soit la liste des pages virtuelles référencées aux instants t=1,2,…,11 : 3 5 6 8 3 9 6 12 3 6 10


La mémoire centrale est initialement composée de 3 cases. Représentez l’évolution de la mémoire
centrale au fur et à mesure des accès pour chacune des deux politiques de remplacement de pages
FIFO et LRU. Indiquez quand il y a défaut de page.
SOLUTION
FIFO :
t 1 2 3 4 5 6 7 8 9 10 11
bloc 3 5 6 8 3 9 6 12 3 6 10
Case :
1 3 3 3 8 8 8 6 6 6 6 10
2 5 5 5 3 3 3 12 12 12 12
3 6 6 6 9 9 9 3 3 3
Défaut de pages D D D D D D D D D D

LRU :
t 1 2 3 4 5 6 7 8 9 10 11
bloc 3 5 6 8 3 9 6 12 3 6 10
Case :
1 3 3 3 8 8 8 6 6 6 6 6
2 5 5 5 3 3 3 12 12 12 10
3 6 6 6 9 9 9 3 3 3
Défaut de pages D D D D D D D D D D

Pour 4 cases :
FIFO :
t 1 2 3 4 5 6 7 8 9 10 11
bloc 3 5 6 8 3 9 6 12 3 6 10
Case :
1 3 3 3 3 3 9 9 9 9 9 10
2 5 5 5 5 5 5 12 12 12 12
3 6 6 6 6 6 6 3 3 3
4 8 8 8 8 8 8 6 6
Défaut de pages D D D D D D D D D

LRU :
t 1 2 3 4 5 6 7 8 9 10 11
bloc 3 5 6 8 3 9 6 12 3 6 10
Case :
1 3 3 3 3 3 3 3 3 3 3 3
2 5 5 5 5 9 9 9 9 9 10
3 6 6 6 6 6 6 6 6 6
4 8 8 8 8 12 12 12 12
Défaut de pages D D D D D D D

Page 22 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

4.3 TP4-3 – UNE MEMOIRE SEGMENTEE PAGINEE


Nous considérons une mémoire segmentée paginée pour laquelle les cases en mémoire centrale sont de 4
ko. La mémoire centrale compte au total 15 cases numérotées de 1 à 15. Dans ce contexte, nous considérons
deux processus A et B. Le processus A a un espace d’adressage composé de trois segments S1A, S2A, S3A qui sont
respectivement de 8ko, 12ko, 4ko. Le processus B a un espace d’adressage composé de deux segments S1B, S2B
qui sont respectivement de 16ko, 8ko. Pour le processus A, seules les pages 1 et 2 du segment S1A, la page 2 du
segment S2A et la page 1 du segment S3A sont chargées en mémoire centrale respectivement dans les cases
4,5,10,6.Pour le processus B, seules les pages 2 et 3 du segment S1B et la page 1 du segment S2B sont chargées
en mémoire centrale respectivement dans les cases 11, 2 et 15.

1. Représentez sur un dessin les structures allouées (table des segments, tables des pages) et la mémoire
centrale correspondant à l’allocation décrite.

SOLUTION
Mémoire centrale :
1
2 Page 3 S1B
3
4 Page 1 S1A
5 Page 2 S1A
6 Page 1 S3A
7
8
9
10 Page 2 S2A
11 Page 2 S1B
12
13
14
15 Page 1 S2B

Table des segments du processeur A


Table des pages des segments
Taille Table de pages vNuméro de case
8 1 4
12 1 5
4
0
1 10
0
1 6

Page 23 sur 24
© SUPINFO International University – http://www.supinfo.com
1OSS – LABS – CORRECTION
Systèmes d’exploitation

Table des segments du processeur B


Table des pages des segments

vNuméro de case
Taille Table de pages 0
16 1 11
8 1 2
0

1 15
0

2. Soit l’adresse logique <S1A,page 1,12> . Quelle adresse réelle lui correspond-elle ?
SOLUTION
Adresse logique < S1A, page 1, 12> = adresse réelle < 16Ko, 12> = 4 * 4 Ko + 12 = 16396, car Page 1 en case 4 de la
Mémoire Centrale.

3. Soit l’adresse logique <S2B,page 2,10> . Quelle adresse réelle lui correspond-elle ?
SOLUTION
Adresse logique <S2B, page 2, 10>. La page 2 du segment 2 du processus B n’est pas en mémoire centrale. Il se
produit un défaut de page. Nous pouvons supposer que la page manquante est chargée dans la première case libre, c'est-
à-dire la case 1. Il s’ensuit alors que l’adresse physique correspondante est 10.

4. Dans ce même contexte, donnez pour chacune des adresses linéaires suivantes, son équivalent en adresse
virtuelle, puis son adresse physique correspondante :
a. 4 098 pour le processus A
b. 8 212 pour le processus B
SOLUTION
Processus A : La mémoire est segmentée paginée et la taille des pages du processus A est égale à 4 Ko (même taille
que la mémoire centrale), soit 2 pages pour le segment S1A (8Ko = 2 * 4Ko), 3 pages pour le segment S2A (12Ko = 3 * 4Ko)
et 1 page pour le segment S3A (4Ko).

Pour l’adresse linéaire 4098 de A, nous avons : 4098 div 4096 + 1 = 2


D'après la table des segments, la page 2 se trouve dans le segment S1A et correspond à la page 2. Le déplacement est
de : 4098 mod 4096 = 2
Nous avons donc l'adresse virtuelle suivante : <segment S1A, page 2, déplacement 2>
La page est valide et correspond à la case 5. L'adresse réelle est : <case 5, déplacement 2 >

4098 pour le processus A : adresse virtuelle <S1, page 2, déplacement 2> = adresse réelle <case 5, déplacement 2> = =
5 * 4Ko + 2 = 5 * 4096 + 2 = 16386 octets

Processus B : La mémoire est segmentée paginée et la taille des pages du processus B est égale à 4 Ko (même taille
que la mémoire centrale), soit 4 pages pour le segment S1B (16ko = 4 * 4Ko) et 2 pages pour le segment S2B (8Ko = 2 * 4
Ko).
Pour l’adresse linéaire 8212 de B, nous avons : 8212 div 4096 + 1 = 3
Dans la table des segments, la page 3 se trouve dans le segment S1B et correspond à la page 3.
Le déplacement est de : 8212 mod 4096 = 20. Nous avons donc l'adresse virtuelle suivante : <segment S1B, page 3,
déplacement 20>
D'après la table des segments, la page est valide et correspond à la case 2. L'adresse réelle est donc : <case 2,
déplacement 20>

8212 pour le processeur B : adresse virtuelle <S1, page 3, déplacement 20> = adresse réelle <case 2, déplacement
20> = 2 * 4Ko + 20 = 2 * 4096 + 20 = 8212 octets

Page 24 sur 24
© SUPINFO International University – http://www.supinfo.com