CSI 3201 - FRIntroduction Aux Systèmes D - Exploitation - Edited

INFORMATIQUE APPLIQUÉE: CSI 3201
INTRODUCTION AUX
SYSTÈMES
D’EXPLOITATION
Diomède Nzisabira
Introduction aux systèmes d’exploitation
Avant-propos
L’Université virtuelle africaine (UVA) est fière de participer à l’accès croissant à l’éducation dans
les pays africains grâce à la production de matériaux d’apprentissage de qualité. Nous sommes
également fiers de contribuer à la connaissance globale car nos ressources éducatives ouvertes
sont principalement accessibles depuis le continent africain.
Ce module a été développé dans le cadre d’un programme de diplôme et d’études en

informatique appliquée, en collaboration avec 18 institutions partenaires africaines de 16 pays.
Au total, 156 modules ont été développés ou traduits pour assurer la disponibilité en anglais,
en français et en portugais. Ces modules ont également été mis à disposition en tant que
ressources éducatives ouvertes (OER) sur oer.avu.org.
Au nom de l’Université virtuelle africaine et de notre patron, nos institutions partenaires, la

Banque africaine de développement, je vous invite à utiliser ce module dans votre institution,
pour votre propre éducation, à le partager aussi largement que possible et à participer
activement à l’AVU Communautés de pratique de votre intérêt. Nous nous sommes engagés à
être en première ligne de développement et de partage de ressources éducatives ouvertes.
L’université virtuelle africaine (UVA) est une organisation intergouvernementale panafricain

créée par une charte qui a pour mandat d’augmenter considérablement l’accès à une
éducation et à une formation supérieures de qualité grâce à l’utilisation innovante des
technologies de communication d’information. Une charte établissant l’UVA en tant
qu’organisation intergouvernementale a été signée à ce jour par dix-neuf (19) gouvernements
africains - Kenya, Sénégal, Mauritanie, Mali, Côte d’Ivoire, Tanzanie, Mozambique, République
démocratique du Congo, Bénin, Ghana, République de Guinée, Burkina Faso, Niger, Soudan
du Sud, Soudan, Gambie, Guinée-Bissau, Éthiopie et Cap-Vert.
Les institutions suivantes ont participé au Programme des sciences informatiques appliquées:
(1) Université d’Abomey Calavi au Bénin; (2) Université de Ougagadougou au Burkina Faso;
(3) Université Lumière de Bujumbura au Burundi; (4) Université de Douala au Cameroun; (5)
Université de Nouakchott en Mauritanie; (6) Université Gaston Berger au Sénégal; (7) Université
des Sciences, Techniques et Technologies de Bamako au Mali (8) Institut de gestion et
d’administration publique du Ghana; (9) Université Kwame Nkrumah de Science et Technologie
au Ghana; (10) L’Université Kenyatta au Kenya; (11) Egerton University au Kenya; (12) Université
d’Addis-Abeba en Ethiopie (13) Université du Rwanda; (14) Université de Dar es-Salaam en
Tanzanie; (15) Université Abdou Moumouni de Niamey au Niger; (16) Université Cheikh Anta
Diop au Sénégal; (17) Université Pedagógica au Mozambique; Et (18) L’Université de Gambie
en Gambie.
Bakary Diallo
Le Recteur
Université virtuelle africaine
2
Crédits de production
Auteur
Diomede Nzisabira
Pair Réviseur
Sagbo Romaric
UVA – Coordination Académique
Dr. Marilena Cabral
Coordinateur global Sciences Informatiques Apliquées
Prof Tim Mwololo Waema
Coordinateur du module
Victor Odumuyiwa
Concepteurs pédagogiques
Elizabeth Mbasu
Benta Ochola
Diana Tuel
Equipe Média
Sidney McGregor Michal Abigael Koyier
Barry Savala Mercy Tabi Ojwang
Edwin Kiprono Josiah Mutsogu
Kelvin Muriithi Kefa Murimi
Victor Oluoch Otieno Gerisson Mulongo
3
Droits d’auteur
Ce document est publié dans les conditions de la Creative Commons
Http://fr.wikipedia.org/wiki/Creative_Commons
Attribution http://creativecommons.org/licenses/by/2.5/
Le gabarit est copyright African Virtual University sous licence Creative Commons Attribution-
ShareAlike 4.0 International License. CC-BY, SA
Supporté par
Projet Multinational II de l’UVA financé par la Banque africaine de développement.
4
Table des matières
Avant-propos 2
Crédits de production 3
Droits d’auteur 4
Supporté par 4
Aperçu sur du cours 10
Bienvenu dans le module d’introduction au système d’exploitation. . . . . . . . 10
Prérequis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Matériels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Objectifs du module. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Unités 11
Unité 1: Principes des SE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Unité 2: Gestion des processus . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Unité 3: Gestion de la mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . .11
Unité 4 : Gestion des périphériques et systèmes de fichiers . . . . . . . . . . . . 11
Unité 5: La Sécurité et la protection. . . . . . . . . . . . . . . . . . . . . . . . .11
Unité 6: Thèmes spéciaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11
Calendrier 11
Évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Ressources documentaires 13
Les ressources documentaires à consulter sont:. . . . . . . . . . . . . . . . . . 13
Unité 0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Unité 1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Unité 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Unité 3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Unité 4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Unité 5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Unité 6. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
5
Unité 0. Aperçu sur les systèmes d’exploitation 15
Qu’est-ce qu’un système informatique?. . . . . . . . . . . . . . . . . . . . . . 15
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Objectif de l’unité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Mots-clés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Activité 1. structure d’un système informatique. . . . . . . . . . . . . . . . . . 16
Introduction 16
1 Structure d’un ordinateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2 Unité centrale de traitement . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Résumé de l’unité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3 Mémoire centrale : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4 Les périphériques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Ressources documentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Évaluation de l’unité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Unité 1. Principes des Systèmes d’Exploitation 20
Quels sont les objectifs d’un système d’exploitation? . . . . . . . . . . . . . . . 20
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Objectifs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Mots-clés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Activité1. SE comme gestionnaire de ressources . . . . . . . . . . . . . . . . . . 21
Introduction 21
Activité 2. Evolution des SE . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Introduction 22
Activité 3. Structure d’un SE. . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Introduction 23
Évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Résumé de l’unité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Lectures et autres ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
6
Évaluation de l’unité d’apprentissage . . . . . . . . . . . . . . . . . . . . . . 26
Unité 2. Gestion de processus 27
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27
Objectifs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27
Mots-clés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Activité 1. Processus et threads . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Introduction 28
Processus et Programme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Activité 2. Communication interprocessus . . . . . . . . . . . . . . . . . . . . . 38
Introduction 38
Évaluation de l’activité :. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Activité 2.3: Ordonnancement de processus . . . . . . . . . . . . . . . . . . . . 43
Introduction 43
Activité 2.4 : Interblocages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Introduction 52
Résumé de l’unité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61
Évaluation de l’activité :. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61
Unité 3. Gestion de la mémoire 63
Comment se fait la gestion de la mémoire par le SE?. . . . . . . . . . . . . . . 63
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Objectifs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Mots-clés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Activité 1. Mémoire sans va-et-vient. . . . . . . . . . . . . . . . . . . . . . . . 64
Introduction 64
Activité 3.2 : Le va-et-vient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
7
Introduction 68
Activité 3.La mémoire virtuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Introduction 72
Évaluation de l’unité : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
Résumé de l’unité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Unité 4. Gestion des périphérique et système de fichiers 83
Introduction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Objectifs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Mots-clés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Activité 1. Gestion des périphériques . . . . . . . . . . . . . . . . . . . . . . . 84
Introduction 84
Activité 2. Le Système de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . 89
Introduction 89
Évaluation de l’activité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Activité 3.Organisation de l’espace des ressources et des fichiers . . . . . . . . . 94
Introduction 94
Résumé de l’unité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Unité 5. Sécurité et protection 104
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Objectifs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Mots-clés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Activité 1. Aperçu général sur la sécurité. . . . . . . . . . . . . . . . . . . . . 105
Introduction 105
8
Activité 2. Les attaques du système. . . . . . . . . . . . . . . . . . . . . . . . 106
Introduction 106
Évaluation de l’unité: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Activité 3. Les mécanismes de protection . . . . . . . . . . . . . . . . . . . . . 108
Introduction 108
Résumé de l’unité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Évaluation de l’unité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Unité 6. Thèmes spéciaux 111
Activité 1. Configuration et maintenance des SE . . . . . . . . . . . . . . . . . 111
Introduction 111
Activité 6.2 : Système temps réel . . . . . . . . . . . . . . . . . . . . . . . . . 118
Introduction 118
Activité 3. Virtualisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Introduction 120
Résumé de l’unité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
9
Aperçu sur du cours

Bienvenu dans le module d’introduction au système
d’exploitation
Un système d’exploitation (SE) est le centre névralgique de toute activité de traitement
d’information sur un ordinateur. Un système d’exploitation est un programme qui fait
fonctionner les autres programmes ainsi que la partie matérielle de l’ordinateur. Il agit
comme un intermédiaire entre l’utilisateur, les logiciels d’application et la partie matérielle
de la machine. Ce cours introduit les principes fondamentaux des systèmes d’exploitation,
de sa structure et de son fonctionnement. Il traite l’ensemble des techniques matérielles et
logicielles utilisées pour construire un SE et permet également d’acquérir des connaissances
en rapport avec l’installation et la maintenance des SE.
Prérequis
Pour mieux aborder ce cours, il est préférable que l’apprenant ait des connaissances en
architecture des ordinateurs, en structure de données.
Matériels
Le matériel nécessaire pour accomplir ce cours est:
• Un ordinateur ;
• Des SE (Windows et Linux) ;
• Une connexion Internet ;
• Un navigateur.
Objectifs du module
A la fin de ce module, l’apprenant devra être capable de:
• Définir un Système d’Exploitation;

• Expliquer la structure de base et le fonctionnement des systèmes d’exploitation;
• Fixer les problèmes en rapport avec la gestion des processus, la synchronisation,
et proposer des solutions appropriées;
• Expliquer les bases de la gestion de la mémoire, l’utilisation de la mémoire
virtuelle, et la structure des fichiers systèmes;
• Décrire les menaces et les mécanismes de protection des systèmes
d’exploitation;
• Virtualiser les Système d’Exploitations et les applications.
10
Unités
Unités
Unité 1: Principes des SE
Cette unité passe en revue les principes fondamentaux des SE. Elle présente le SE comme une
machine virtuelle évolutive et comme un gestionnaire d’événements et des tâches.
Unité 2: Gestion des processus

Cette unité expose les notions de processus, types de processus, des états d’un processus, de
la gestion des threads, de l’ordonnancement, de la Communication interprocessus.
Unité 3: Gestion de la mémoire

Cette unité présente les différents types de mémoire ainsi que les mécanismes de leur gestion.
Unité 4 : Gestion des périphériques et systèmes de fichiers

Cette unité porte sur la notion de périphériques et de système de fichiers. Elle présente la
structure des fichiers, les types de fichiers, les différents accès aux fichiers, l’implantation d’un
système de fichiers ainsi que leur gestion.
Unité 5: La Sécurité et la protection

Cette unité traite la notion de sécurité et protection. Elle présente les menaces pour la sécurité,
les problèmes de sécurité et la manière d’y faire face.
Unité 6: Thèmes spéciaux

Cette unité concerne les préalables lors de l’installation des SE (Windows et Linux),
l’introduction aux systèmes embarqués et temps réel ainsi que la notion de virtualisation.
Calendrier
Unité Activités Période
Principes des Activité 1:SE comme gestionnaire de ressources 1H

Systèmes
Activité 2:SE comme machine virtuelle
d’Exploitation
Activité 3: SE comme logiciel évolutif
Gestion de Activité 2.1 : Processus et threads 6H

processus
Activité 2.2 : Communication interprocessus 6H
Activité 2.3 : Ordonnancement de processus 6H
Activité 2.4 : Interblocages 6H
11
Gestion de la Activité 3.1 : Mémoire sans va-et-vient 5H

mémoire
Activité 3.2 : Le va-et-vient 5H
Activité 3.3 : La mémoire virtuelle 6H
Gestion et Activité 4.1 : Gestion des périphériques 3H

périphérique
Activité 4.2 : Le Système de fichiers 3H
et système de
fichiers Activité 4.3 : Organisation de l’espace des ressources et 3H
des fichiers
Sécurité et Activité 5.1 : Les bases de sécurité 3H

protection
Activité 5.2 : Les attaques du système 3H
Activité 5.3 : Les mécanismes de protection 4H
Thèmes Activité 6.1 : Configuration et maintenance des SE 5H

spéciaux
Activité 6.2 : Les systèmes embarqués 5H
Activité 6.3 : Les systèmes temps réels 5H
Activité 6.4 : La virtualisation 5H
Évaluation
1 Evaluation pondération
continue (%)
1.1 Test I 10
1.2 Test II 15
1.3 Travail à 10
domicile
1.4 Projet 25
2 Examen final 40
Total 100
12
Ressources documentaires
Les ressources documentaires à consulter sont:
Unité 0
https://www-gtr.iutv.univ-paris13.fr/Cours/Mat/Architecture/
http://dept-info.labri.fr/ENSEIGNEMENT/archi/cours/archi.pdf
Unité 1
http://www-int.impmc.upmc.fr/impmc/Enseignement/ye/informatique/systemes/chap1/13.html
Andrew Tanenbaum, Systèmes d’exploitation 2ème édition, chapitre 1
Unité 2
Dijkstra, E.W., 1965. Solution of a Problem in Concurrent Programming Control.
Habermann, A.N. Prevention of System Deadlocks. CACM, Vol. 12, No. 7, July 1969, pp.
373-385.
Andrew Tanenbaum, Systèmes d’exploitation (2ème édition) page 169-195
http://www.groupes.polymtl.ca/inf3600/TransparentsAut2006/Ch1INF3600.pdf
Unité 3
373-385.
Unité 4
Andrew Tanenbaum, Systèmes d’exploitation, 2eme édition, chapitre 6
13
Unité 5
https://www.google.com/search?q=Alexandre+viardin&ie=utf-8&oe=utf-8
ftp://ftp.pgpi.org/pub/pgp/6.5/docs/french/IntroToCrypto.pdf
Andew Tanenbaum, Systèmes d’exploitation 2ème édition, chapitre 9
https://www.irit.fr/~Zoubir.Mammeri/Cours/M1ASTRE/Chapitre1.pdf
http://lanteri.isabelle.perso.sfr.fr/files/noyau1.pdf
Unité 6
http://sist.sysu.edu.cn/~isscwli/OSRef/Abraham%20Silberschatz-Operating%20System%20
Concepts%20%289th,2012.12%29.pdf
http://perso-etis.ensea.fr/miramond/Enseignement/M1/IE/Cours/CoursAndry_TR.pdf
14
Unité 0. Aperçu sur les systèmes d’exploitation
Unité 0. Aperçu sur les systèmes

d’exploitation
Qu’est-ce qu’un système informatique?
Introduction
Un système est un ensemble d’éléments interagissant entre eux selon certains principes ou
règles. Un système est déterminé par :
• la nature de ses éléments constitutifs ;

• es interactions entre ces derniers ;
• sa frontière, c’est-à-dire le critère d’appartenance au système (déterminant si une
entité appartient au système ou fait au contraire partie de son environnement) ;
• ses interactions avec son environnement.
Avec cette définition générique on peut alors se demander ce que c’est un système
informatique. Et qu’est-ce qu’un système informatique possède de spécifique par rapport aux
autres systèmes ?
Objectif de l’unité
A la fin de cette unité d’apprentissage, les apprenants devront être à mesure de :
• définir un système informatique ;

• identifier les composants d’un système informatique ;
• définir un système d’exploitation.
15
Mots-clés
Ordinateur: Un ordinateur est une machine électronique qui fonctionne
par la lecture séquentielle d’un ensemble d’instructions, organisées en
programmes, qui lui font exécuter des opérations logiques et arithmétiques
sur des chiffres binaire.
Informatique : L’informatique est le domaine d’activité scientifique,

technique et industriel concernant le traitement automatique de
l’information via l’exécution de programmes par ordinateur.
Système d’exploitation : Un logiciel système qui fait fonctionner les autres

programmes (application)
Système Informatique : Un ensemble d’équipements destiné au traitement

(enregistrement, modification, suppression, restitution) automatique de
l’information.
Activité 1. structure d’un système informatique
Introduction
Un système informatique peut être défini comme un ensemble de moyens matériels et

logiciels nécessaire pour satisfaire les besoins en traitement, conservation et restitution des
données des utilisateurs. Un ordinateur est une machine électronique ayant des composants
matériels et logiciels.
1 Structure d’un ordinateur

La structure de base d’un ordinateur comprend les éléments fondamentaux suivants :
• Une unité centrale de traitement (unité centrale).

• Une unité de mémoire, appelée mémoire centrale.
• Des unités de stockage.
• Des unités d’entrée/sortie.
• Un système de bus permettant de véhiculer l’information entre l’unité centrale et
les autres unités.
16
Figure 1: Architecture d’un système informatique
Les différents constituants de l’ordinateur sont composés de circuits électroniques ou

d’éléments magnétiques. Ils fonctionnent donc avec des impulsions électriques ou font
intervenir un champ magnétique, et donnent lieu à deux états (ouvert ou fermé) ou bien (nord
ou sud).
L’information élémentaire est le ‘Bit’ un bit ne peut prendre que deux valeurs notées : 0 et 1.
2 Unité centrale de traitement

L’unité centrale de traitement ou CPU (Central Processing Unit) est le centre de calcul et de
contrôle d’un ordinateur, elle constitue le « cerveau » de l’ordinateur.
L’unité centrale qui réalise toutes les opérations demandées, elle est matérialisée
physiquement par un circuit électronique appelé « microprocesseur ». Un microprocesseur est
caractérisé par :
• Sa marque (Intel ou cyrix).

• Sa fréquence d’horloge : le nombre d’opération que le microprocesseur peut
effectuer en seconde (la fréquence atteint actuellement quelques Gigahertz).
1 KHz = 210 Hz
1 MHz = 220 Hz
1 GHz = 230 Hz
17
L’unité centrale comporte les éléments suivants :
• Unité arithmétique et logique : L’UAL est l’organe qui permet d’effectuer des
opérations arithmétiques (addition, soustraction, multiplication, division), des
opérations logiques (par exemple des comparaisons).
• Unité de commande : L’unité de commande gère le déroulement des instructions.
Elle décode et exécute les instructions demandées.
3 Mémoire centrale :
La mémoire centrale est un organe de l’ordinateur permettant d’enregistrer, de stocker et de
restituer les informations. La mémoire centrale se présente sous la forme de petites barrettes
que l’on peut enficher dans des supports, appelés Slots. La mémoire centrale d’un ordinateur
est séparée en deux sections : la mémoire vive (mémoire volatile destinée à être lue et écrite)
et la mémoire morte (mémoire non volatile destinée à être lue).
4 Les périphériques
Les périphériques sont les organes de l’ordinateur qui permettent de communiquer avec
l’unité centrale et de stocker les informations d’une façon permanente. On en distingue trois
catégories à savoir : les périphériques d’entrée, les périphériques de sortie et les périphériques
d’entrée-sortie.
Résumé de l’unité
Un système d’exploitation est un logiciel fondamental pour la machine. C’est lui qui fait
fonctionner les éléments matériels et logiciels de l’ordinateur. Le système d’exploitation
fournit des services aux utilisateurs et aux programmes en cours d’exécution sur un système
informatique. Un système d’exploitation est conçu avec des compromis sur les performances,
la sécurité, la compatibilité et la maintenabilité.
18
Évaluation de l’unité
Cette évaluation est composée par une série de question de simple
compréhension
Question1 :
Qu’est-ce qu’un ordinateur ?
Question 2 :
Quels sont les principaux composants d’un ordinateur ?
Question 3 :
Qu’est-ce qu’un périphérique ? Donnez les trois grandes catégories de

périphériques
Question 4 :
Qu’est-ce qu’un système informatique ?
Question 5 :
A quoi sert un système d’exploitation
Système de notation :
• Pour toute réponse incorrecte (0 points)

• Pour une réponse incomplète (0,5 points)
• Pour toute réponse correcte (1 point)
Rappel
Un ordinateur est composé essentiellement de deux grandes parties à savoir la

partie matérielle et la partie logiciel.
Le système d’exploitation offre les services aux utilisateurs et aux autres

composants du système informatique.
19
Unité 1. Principes des Systèmes

d’Exploitation
Quels sont les objectifs d’un système d’exploitation?
Introduction
Les fondements d’un SE peuvent être vus sous deux grands axes: niveau utilisateur et niveau
système. De plus, de par sa nature logiciel et ses fonctionnalités, le système d’exploitation
est appelé à évoluer avec le temps en fonction de l’évolution du matériel et des besoins des
utilisateurs.
Ainsi, trois principaux vues caractérisent les SE:
1. point de vue gestionnaire de ressources;
2. point de vue machine virtuelles;
3. logiciel évolutif.
Objectifs
A la fin de cette unité d’apprentissage, l’apprenant devra être à mesure de:
• décrire les principes et les objectifs des SE;

• décrire les différentes vues des SE;
• identifier les éléments pouvant faire évoluer les SE.
Mots-clés
Machine virtuelle: C’est une machine, un système installé sur un autre
système donnant l’impression d’une machine réel
Système évolutif: Système/Logiciel capable d’évoluer
Ressources: Ce terme est utilisé pour désigner n’importe quel composant

(matériel et logiciel) de la machine interne à la machine ou connecté à
celle-ci.
20
Unité 1. Principes des Systèmes d’Exploitation
Activité1. SE comme gestionnaire de ressources
Introduction
Le SE étant la partie qui fait fonctionner les composant d’un ordinateur, nous allons dans cette
activité focaliser notre attention sur ce logiciel system. Qu’est-ce qu’un SE ?
Définition
Le système d’exploitation peut être défini comme programme système qui commande
l’exécution de programmes d’application. Il est responsable pour le chargement et l’exécution
de programmes d’application. Il doit veiller à la disponibilité des configurations matérielles et
logicielles requises avant d’exécuter le programme d’application
Rôle d’un SE
Dans un système informatique, le SE est le programme qui agit comme intermédiaire entre
l’utilisateur est la partie matérielle. Un système informatique possède un ensemble de
ressources pour la circulation, le traitement et le stockage de données.
Ainsi, du point de vue machine, un SE peut être considéré comme gestionnaire de ressources.
Un ensemble de demande d’accès aux ressources, pouvant même générés des conflits
sont gérés par le SE. C’est lui qui décide qui accède à telle ressource, pour telle durée en
garantissant un fonctionnement efficace du système. Le SE contrôle également les dispositifs
d’E/S et les logiciels d’application afin de garantir un bon fonctionnement du système.
Conclusion
Un SE est un logiciel indispensable pour le fonctionnement de l’ordinateur. Il joue le rôle

d’intermédiaire entre la partie matérielle et les utilisateurs.
Question 1 :
Distinguer les logiciels d’application des logiciels d’exploitation.
Question 2 :
Qu’est-ce qui garantit la bonne utilisation des ressources sur un ordinateur ?
Question 3 :
Existe-t-il un logiciel d’application indispensable au fonctionnement de

l’ordinateur ? Justifier votre réponse.
Rappel :
Un SE peut être défini comme logiciel système qui commande l’exécution de

programmes d’application. Il contrôle les ressources et dispositif d’entrée-sortie
afin de garantir le bon fonctionnement de tout le système.
21
Activité 2. Evolution des SE
Introduction
Les ordinateurs ont évolué dans le temps. Cette évolution a été largement influencée par
l’évolution des SE. Mais quelles sont les évolutions qu’a connues le système d’exploitation ?
Cette question sera répondue dans cette activité.
Evolution
Étudier l’évolution des systèmes d’exploitation est utilisé pour comprendre les exigences clés
d’un système d’exploitation. De plus, elle aide à comprendre la signification des principales
caractéristiques des systèmes d’exploitation modernes.
Les systèmes d’exploitation et l’architecture de l’ordinateur sont historiquement liés. La

combinaison de l’architecture de l’ordinateur avec un système d’exploitation est connue sous
le nom de plate-forme informatique. Ces changements architecturaux affectent la structure et
la performance des systèmes d’exploitation.
Les premiers ordinateurs ne possédaient pas vraiment de système d’exploitation. Le

moniteur était chargé avec l’unique programme à exécuter qui se greffait sur ce système
rudimentaire tout comme une fonction ou un sous-programme se greffe aujourd’hui sur le
programme principal. Les entrées-sorties étaient rudimentaires, réduites à un ruban perforé,
les programmes écrits en langage machine, c’est à dire directement codés en suite de chiffres,
exécutés pas à pas et modifiés directement en mémoire au moyen d’un jeu de clés !
Vers 1950 est apparu le moniteur d’enchaînement. Il permettait l’exécution d’une série de
travaux en séquence, c’est à dire l’un après l’autre. C’est l’ancêtre du traitement par lot. Il
possédait déjà des fonctions de protection: maximum de temps par travail, supervision des
périphériques, protection de la zone mémoire utilisée, gestion et abandon des travaux erronés.
Ces avancées étaient fondamentales car elles introduisaient un environnement autour du
programme à exécuter.
L’informatique moderne naît dans les années 1960. On peut résumer rapidement ses avancées
autour de l’invention des notions suivantes :
• Apparition des processeurs d’entrées-sorties

• Multiprogrammation, c’est à dire possibilité d’exécuter plusieurs programmes
simultanément.
• Compilateurs
• Temps partagé
• Mémoire paginée virtuelle. Elle permet de faire fonctionner un ensemble de
programmes dont la taille est supérieure à celle de la mémoire physique.
• Les communications
22
Les éléments ci-dessus sont en grande partie tirés de :
Pour d’autres détails reportez-vous à la référence ci-dessous :
Andew Tanenbaum, Systèmes d’exploitation 2ème édition, pages 8-34
Conclusion
L’évolution des systèmes d’exploitation au cours des dernières décennies le SE ont connu
plusieurs étapes de leurs évolution. Des machines sans SE on est arrivé actuellement aux
ordinateurs avec les systèmes distribués.
Évaluation
Question 1 :
Donner les grandes étapes de l’évolution des SE. Expliquer brièvement les
caractéristiques de chaque étape.
Question 2 :
Comment l’évolution des SE a-t-elle influencé celle des ordinateurs ?
Rappels :
Les SE d’exploitation ont passé par de grandes étapes. Des machines sans
systèmes d’exploitation aux systèmes distribués ces évolutions vont de paires
avec celles des ordinateurs.
Activité 3. Structure d’un SE
Introduction
Dans cette activité nous allons détailler la structure interne d’un système d’exploitation.
Plusieurs approches d’implémentation des SE existe, nous allons donner un aperçu sur
quelques-uns. Il s’agit notamment des systèmes monolithiques, des systèmes en couche,
des machines virtuelles, des exonoyaux et des systèmes client-serveur.Pour des détails sur
cette activité reportez-vous sur la documentation suivante :Andew Tanenbaum, Systèmes
d’exploitation 2ème édition, pages 59-66
Système monolithique
Le SE est une structure hiérarchique écrit comme un ensemble de procédures dont chacune
peut appeler n’importe quelle autre en cas de besoin. La structure de base suggérée par cette
organisation est la suivante :
• un programme principal qui invoque la procédure de service ;

• un ensemble de procédures de services qui gèrent les appels système ;
• un ensemble de procédures utilitaires auxiliaires des procédures.
23
Les systèmes en couche
L’organisation d’un système en une série de couches est une généralisation de la structure
précédente. Le système était composé par une série de couches hiérarchiques.
• La couche 0 fournissait le service de multiprogrammation CPU.

• La couche 1 était en charge de la gestion de la mémoire et des tampons
• La couche 2 se chargeait de la communication interprocessus et console
• La couche 3 était en charge des entrées sorties
• La couche 4 contenait les programmes utilisateurs
• La couche 5 était le processus opérateur.
Machines virtuelles
La plus part du temps, les utilisateurs des ordinateurs sont assis devant leur PC (unité centrale
+ les différents périphériques).Cependant, dans d’autres cas, les utilisateurs sont en face d’un
terminal connecté à un mainframe ou ordinateur connecté à d’autres ordinateurs en réseau.
Dans le premier cas, le système est conçu de telle sorte qu’un seul utilisateur monopolise
toutes les ressources. Ainsi l’objectif de tels systèmes est l’efficacité dans l’accomplissement
des tâches soumises par l’utilisateur. Ces systèmes sont donc conçus de telle sorte qu’elles
soient faciles à utiliser avec pour seule considération les performances du système, sans se
soucier de l’utilisation des ressources.Dans le second cas (utilisation d’un terminal), la même
ressource peut être demandée par plusieurs utilisateurs chacun assis devant son propre
terminal.
Dans de tels cas, la conception de ces SE met un accès particulier sur l’accès aux ressources. Ils
doivent garantir la disponibilité de ressources et un partage équitable entre les requérants.
En dernier lieu, on distingue de systèmes où l’utilisateur possède des ressources dédiées

(utilisation d’un ordinateur personnel) mais comportant des ressources partagées (serveur de
fichiers, serveur d’impression, etc.).
Dans ce cas, la conception de tels SE doit chercher un compromis entre la gestion des
ressources et l’utilisation individuelle de la machine.
L’ensemble de ces situations et différentes exigences des utilisateurs, nous montre qu’un SE
est un système conçu de telle sorte qu’il garantit une facilité d’utilisation, une disponibilité et
un partage des ressources dans un environnement où les utilisateurs ont besoins et exigences
différents.
Les exonoyaux
C’est un système qui donne à chaque utilisateur un clone de l’ordinateur réel mais seulement
pourvu d’un sous ensemble de ses ressources. L’exonoyau est la couche la plus basse ayant
pour rôle d’allouer des ressources pour les machines virtuelles et de vérifier les tentatives
d’accès à ces dernières.
24
Le modèle client-serveur
C’est la tendance actuelle des SE. Elle consiste à implémenter la plus grande partie du SE
sous forme de processus utilisateur. La demande d’un service passe par l’envoie du service
demandeur (le client) d’une requête au service pourvoyeur (serveur) qui rend le service et
renvoie le résultat.
Conclusion
Les différents modèles des SE reposent sur une architecture bien définie. La première
approche était la structure monolithique. Cette approche a été améliorée passant de la
structure en couche, a été considérablement améliorée pour arriver maintenant à la structure
actuelle qui est le système client-serveur.
Évaluation
Types de questions : simple question de compréhension
Question 1 : Indiquer les différents modèles des structures interne des SE
Question 2 : Pourquoi la structure monolithique était une sorte de gâchis ?
Question 3 : Quelles sont les spécificités du modèle client-serveur ?
Rappel :
La structure interne des SE repose sur une architecture bien précise. Il existe
plusieurs architectures permettant de distinguer les principaux systèmes suivants
: systèmes monolithiques, des systèmes en couche, des machines virtuelles, des
exonoyaux et des systèmes client-serveur. Chaque architecture possède des
spécificités particulières qui la distinguent des autres.
Les principes et objectifs des SE permet de considérer un SE sous trois angles:
1. une machine virtuelle:
• intermédiaire entre l’utilisateur et la partie matérielle (agit comme machine

virtuelle);
• cache à l’utilisateur les complexités matérielles;
• fournit à l’utilisateur une interface conviviale.
2. Un gestionnaire des ressources
• Assure une gestion des ressources en garantissant leur disponibilité et leur

partage;
• Améliore l’utilisation des ressources.
25
3. Logiciel évolutif
Evolue pour s’adapter aux changements:
• nouveaux matériels.
• besoin de nouveaux services;
• correction des erreurs latentes.
Évaluation de l’unité d’apprentissage

Donner les réponses aux questions suivantes:
1. Comment se présente la structure interne de l’ordinateur ?
2. Comment le modèle client-serveur peut être utilisé sur un seul ordinateur ?
3. Donner les avantages du SE comme machine virtuelle.
4. Quels sont les objectifs d’un SE ? Comment percevez-vous le SE comme

gestionnaire de ressource ?
Système de notation :
L’évaluation de cette unité compte pour 20% répartie comme suit :
• L’évaluation des activités d’apprentissage : 10%

• L’évaluation des unités : 10%
Rétroaction
Critères d’évaluation
• Questions/Evaluation non répondues ou mal répondues : Echec

• Questions/Evaluation répondues partiellement ou réponse partiellement
correcte : Moitié de point pour la question/évaluation correspondante
• Toutes les évaluations sont faites avec des réponses correctes : Totalité des
points
Lectures et autres ressources

26
Unité 2. Gestion de processus

Introduction
La conception d’un système d’exploitation est intimement liée à la notion de processus. Un
processus représente une abstraction d’un programme en cours d’exécution. L’exécution d’un
processus suppose l’utilisation de ressources machines. Ces dernières étant limitées, l’intention
d’y accéder à plusieurs crée la concurrence. Au cours de cette unité, nous allons présenter:
• la notion de processus;
• les états d’un processus;
• la gestion des threads;
• les communications inter-processus ; ainsi que
• l’interblocage (deadlock).
Objectifs
A la fin de ce chapitre, l’apprenant devra être à mesure de:
• Définir un processus et les threads;

• Décrire les différents états des processus;
• Différencier les processus et les threads;
• Démontrer une bonne connaissance de la gestion des processus et des threads;
• Démontrer une bonne connaissance des interblocages.
27
Mots-clés
Processus : Un processus est un programme en cours d’exécution auquel
est associé un environnement processeur (Compteur Ordinal, Registre
d’Etat, RSP , registres généraux) et un environnement mémoire appelés
contexte du processus
Ressource : Une désigne toute entité dont a besoin un processus pour

s’exécuter
M u l t i p ro g r a m m a t i o n : E n S y s t è m e d ’ E x p l o i t a t i o n ( S E ) , l a
multiprogrammation est la capacité d’un système d’exécuter à la suite
plusieurs activités sans l’intervention de l’utilisateur. C’est une des premières
capacités fournies par les SE dès la fin des années 1950.
Thread : Les threads sont des entités planifiées pour leur exécution par le
processeur. Les threads autorisent les exécutions multiples dans le même
environnement de processus avec une marge d’indépendance les uns par
rapport aux autres.
Programme : C’est une suite ordonnée d’instructions élémentaires en vue

d’accomplir une tâche donnée.
Concurrence : Les faits que deux ou plusieurs processus concourent à

l’accès à une même ressource.
Ordonnancement : L’Ordonnancement est le fait d’agencer les processus

par ordre de priorité.
Interblocage : C’est un état qui se produit lorsque deux processus

concurrentes s’attendent mutuellement (l’un détenant la ressource que
l’autre a besoin).
Activité 1. Processus et threads
Introduction
Tous les ordinateurs modernes sont capables de faire plusieurs tâches simultanément
(exécuter un programme utilisateur par exemple et afficher du texte ainsi qu’effectuer des
lectures sur disque, etc.). Dans un système multiprogrammé, le processeur bascule entre
programme pour les servir en raison de petit laps de temps (au tour des dizaines ou centaines
de millisecondes) ce qui fait que le processeur puisse intervenir pour plusieurs programmes
à raison d’une seconde simulant ainsi le parallélisme. Pour le vrai parallélisme on a des
systèmes multiprocesseurs se partageant la même mémoire physique. Le modèle conceptuel
des processus séquentiels permettant de gérer le parallélisme ainsi que certaines de ses
conséquences seront abordés dans cette activité.
28
Processus et Programme
Par définition, un processus est une abstraction d’un programme en cours d’exécution. Le
processus est représenté dans le système par un PCB (Process Control Block), possède un état,
peut communiquer des informations avec d’autres processus et peut concourir avec d’autres
processus pour l’obtention d’une ressources.
Conceptuellement, un processus modélise l’exécution d’un programme sur un processeur

virtuel disposant:
• d’un compteur ordinal;

• d’un jeu de registre;
• de mémoire;
• etc.
Le processeur physique commute entre les processus sous la direction d’un ordonnanceur.
Figure 2: Commutation entre processus
Dans le cas de systèmes à temps partagé, tous les processus progressent dans le temps, mais
un seul s’exécute à la fois.Lorsque le processeur passe d’un processus à un autre la vitesse
de traitement de processus n’est pas uniforme, ni même reproductible si le même processus
s’exécutait une autre fois.Mais Quelle est la différence entre un processus et un programme?
L’analogie ci-dessus peut aider à mieux les différencier. Prenons un informaticien en train de
confectionner un gâteau d’anniversaire de sa petite amie. Il dispose de:
• une cuisine équipée;

• la recette du gâteau;
• tous les ingrédients nécessaires: farine, œufs, etc.
Dans cette métaphore, la recette représente le programme, (algorithme exprimé dans

la notation appropriée), l’informaticien représente le processeur (l’unité centrale) et les
ingrédients sont des données d’entrée.Le processus est l’activité qui consiste à confectionner
le gâteau: lecture de la recette, mélange des ingrédients, cuisson.
29
Soupons que notre informaticien se mette à hurler car piqué d’une guêpe.Son cerveau
enregistre le point où il s’est arrêté dans la préparation du gâteau (l’état dans lequel le
processus en cours est enregistré). Il commence à suivre les instructions de premiers
secours. De ce fait, le processeur bascule du processus (confection gâteau) vers un autre
processus de priorité supérieure (administrer antidote). Chaque processus découle d’un
programme différent (recette et brochure sur les premiers soins). Une fois le problème de
piqure résolu, l’informaticien retourne au point où il avait laissé la préparation du gâteau.
En résumé un processus est une activité. Il inclut un programme, une entrée, une sortie et
un état.Un processeur peut être partagé par plusieurs processus à l’aide d’un algorithme
d’ordonnancement intervenant pour déterminer à quel moment arrêter de travailler sur un
processus pour en servir un autre.
Les SE ont besoin de savoir que tous les processus nécessaires existent bel et bien. Le SE doit
permettre l’exécution concurrentielle de processus, et a besoin d’une méthode pour créer, et
arrêter les processus au cours de leur activité.
Il existe essentiellement quatre événements provoquant la création d’un processus:
Initialisation du système
Lors de l’amorçage du SE, plusieurs processus sont créés. Certains sont des processus de
premiers plans (processus qui interagissent avec l’utilisateur et accomplissent des tâches pour
eux), d’autres sont des processus d’arrière-plan, non associés à une utilisation particulière de
l’ordinateur. Ex: les processus d’arrière-plan conçu pour accepter les courriers électroniques
entrant, ceux conçus pour accepter les requêtes entrantes de pages web hébergées sur
l’ordinateur; etc.
Exécution d’un appel système de création de processus par un processus en

cours d’exécution
Un processus en exécution peut émettre des appels systèmes pour créer un ou plusieurs
nouveaux processus. Cela est particulièrement utile lorsque la tâche à accomplir peut être
divisée en plusieurs processus qui interagissent entre eux tout en étant indépendants.
Requête utilisateur sollicitant la création d’un nouveau processus
Un nouveau processus peut également être créé à la demande d’un utilisateur. Cela passe par
la saisie d’une commande ou dans le mode graphique le clic sur une icône. Ces deux cas de
figures lancent un nouveau processus qui exécute le programme concerné.
initiation d’un travail en traitement par lots
Ce cas de figure concerne les gros mainframes. Les utilisateurs peuvent soumettre des
tâches de traitement par lots au système. Lorsque le SE constate qu’il dispose des ressources
nécessaires à l’exécution d’un job supplémentaire, il crée un nouveau processus et exécute le
job suivant de la file d’attente.
30
Une fois qu’un processus a été créé, il commence à s’exécuter quelle que soit sa tâche et il
finira à s’arrêter pour diverses raisons:
• Arrêt normal (fin de la tâche qui leur incombait);

• Arrêt pour erreur (demande d’exécution d’un programme qui n’existe pas);
• Arrêt pour erreur fatale (bogue du programme);
• Le processus est arrêté par un autre processus.
Types de processus
Les processus interactifs
Les processus interactifs sont démarrés par l’utilisateur connecté au système. Ils sont initialisés
et contrôlés via une session terminale. Ces processus peuvent s’exécuter en avant plan du
terminal qui a lancé le programme. Dans ce cas aucune autre application ne peut être lancée
aussi longtemps que le processus est en train de s’exécuter en avant plan.
Lorsque ces processus s’exécutent en arrière-plan, de nouvelles commandes peuvent être

acceptées par le terminal pendant l’exécution du programme. Lors de l’exécution des
programmes en arrière-plan, le système n’interdit pas l’utilisateur à faire autre chose sur le
terminal utilisé pour lancer le programme. Le job control du noyau du SE offre une gestion
aisée de plusieurs processus. Ce mécanisme fait passer les processus de l’avant plan à l’arrière-
plan. En utilisant ce système, des programmes peuvent également être lancés immédiatement
en arrière-plan.
Les processus automatiques
Les processus automatiques ou processus par lot sont des processus non connectés au
terminal. Ce sont plutôt de tâches mises dans une file d’attente pour être exécutées. Cette file
d’attente est gérée selon le mode du premier entré- premier sorti (First in, First out : FIFO). De
telles tâches sont exécutées selon les critères suivants:
• A une certaine période (date et heure): exécutée selon la commande at;

• Au moment où le système est suffisamment moins occupé pour accepter d’autres
travaux (jobs): exécutées en utilisant la commande par lot (batch command).
Par défaut les tâches sont mises dans une file dans laquelle elles vont attendre
l’exécution jusqu’au moment où le système de chargement est en-dessous de 0.8.
Dans les environnements plus larges, le traitement par lots peut être privilégié
lorsque de grandes quantités de données doivent être traitées ou lorsque des
tâches gourmandes en ressources sont en attente alors que le système est
suffisamment chargé. Le traitement par lots est aussi utilisé dans l’optimisation
des performances du système.
31
Les daemons
Les daemons sont des processus serveurs exécutés continuellement. La plus part de temps,
ils sont initialisés au démarrage du système et attendent en arrière-plan jusqu’à ce qu’une
demande de leur service soit faite. Un exemple est le daemon, xinetd, démarré dans presque
toutes les procédures de démarrage. Après le démarrage du système, ce daemon réseau
attend qu’un programme client, le client ftp par exemple, ait besoin de se connecter.
Les états d’un processus
Rappelons qu’un processus est une instance d’un programme en exécution mais pointant
le fait qu’un programme n’est pas à lui-même un processus, c’est une entité passive. Un
processus est une entité active (dynamique) dont on peut étudier l’état au cours du temps. Un
processus peut-être dans trois états différents : élu, prêt, bloqué.
• Un processus est dit élu s’il est en cours d’exécution sur le processeur. Dans le
cas d’une machine multiprocesseurs plusieurs processus peuvent être élus en
même temps. Notons cependant que le nombre de processus élu doit être égal
au nombre de processeurs. Lorsque le quantum de temps attribué au processus
élu est épuisé, l’ordonnanceur est appelé de façon asynchrone par interruption et
élit un autre processus parmi les processus prêt. Le processus qui était en cours
d’exécution passe de l’état élu à l’état prêt.
• Un processus est dit prêt s’il est suspendu en faveur d’un autre. Pour un
processus prêt, il ne lui manque que la source processeur pour s’exécuter.
• Lorsqu’un processus en exécution attend un événement externe (décompte
d’horloge, attente des données, etc.), il s’en dort et passe dans l’état bloqué.
L’ordonnanceur appelé de façon explicite par ledit processus, élit un autre
processus parmi les processus prêt. Lorsque l’événement externe attendu
se produit le système d’exploitation se charge de son traitement, puisque
le processus se trouve dans un état bloqué. Pour ce faire, le SE interrompt
temporairement le processus en exécution pour traiter les données reçues et faire
passer le processus bloqué à l’état prêt.
Le schéma ci-dessous matérialise les différentes transitions.
Figure 3: Les états d’un processus
32
Gestion des threads
Dans les SE traditionnels, chaque processus possède un espace d’adressage et un thread de

contrôle unique. Il arrive cependant qu’il soit souhaitable de disposer de plusieurs threads de
contrôle dans le même espace d’adressage, ceux-ci s’exécutant quasiment parallèle comme
s’il s’agissait de processus distincts. Cet état de fait sera abordé dans cette partie.
Le modèle de thread
Rappelons que le modèle de processus est fondé sur deux concepts: le regroupement de
ressources et l’exécution. Il est parfois nécessaire de les séparer et c’est là qu’intervient les
threads.
Un processus est un espace d’adressage contenant un programme et des données mais aussi
d’autres ressources (fichiers ouverts, les processus enfants, les alertes en attente, les handlers
de signal, les informations de décompte, etc.). En rassemblant ces ressources sous forme de
processus, on facilite leur gestion.
Sous un autre angle, les processus peuvent être vus en considérant leur thread d’exécution
(chemin d’exécution) que l’on se contente d’appeler thread.
Le thread inclut:
• un compteur ordinal qui effectue le suivi des instructions à exécuter;

• des registres qui détiennent ses variables de travail en cours; et
• une pile qui contient l’historique de l’exécution.
Bien qu’un thread s’exécute dans un processus, ce sont deux concepts distincts qui peuvent
être traités séparément. Les processus servent à regrouper les ressources et les threads sont
les entités planifiées pour leur exécution par le processeur.
Les threads autorisent les exécutions multiples dans le même environnement de processus
avec une marge d’indépendance les uns par rapport aux autres. Cela est comparable au fait
que plusieurs processus s’exécutent en parallèle sur un ordinateur.
Dans le premier cas, les threads partagent un espace d’adressage, les fichiers ouverts et les
autres ressources.
Dans le second cas, les processus partagent la même mémoire physique, les disques, les
imprimantes et les autres ressources.
Etant donné que les threads ont certaines propriétés des processus, on les qualifie de
processus léger. Le terme multithreading est également employé pour désigner la situation
dans laquelle plusieurs threads sont présents dans un processus.
33
Figure 4: Processus avec un espace d’adressage et un thread de contrôle unique
Comme le montre la figure ci-dessus il s’agit de trois processus traditionnels, chacun

possédant son propre espace d’adressage et un thread de contrôle unique.Ci-dessous, nous
présentons un cas de figure où on a un processus unique avec trois threads de contrôle.
Figure 5: Exemple d’un multithreading
Bien que dans les deux cas on est en présence de trois threads, les deux situations sont
différentes. Dans le premier cas, chaque thread fonctionne dans un espace d’adressage
différent, tandis que dans le second cas les trois threads se partagent le même espace
d’adressage (multithreading).Dans ce dernier cas, le processeur bascule rapidement entre les
threads donnant une illusion d’une exécution en parallèle de threads chacun sur son propre
processus. Etant donné que ces threads partage le même espace d’adressage, ils partagent
également les mêmes variables globales (en lecture/écriture) et aucune protection n’existe
entre les threads d’un même processus. Les threads exploitent également le même jeu de
fichiers ouverts, de processus enfant; d’alertes et de signaux, etc.
Généralement, chaque thread appelle des procédures différentes et donc un historique

d’exécution différent. C’est pour cela que chaque thread a besoin de sa propre pile. Celle-ci
contient un frame pour chaque procédure invoquée mais qui n’a encore rien retourné. Chaque
frame contient, les variables locales de la procédure et l’adresse de retour à employer une fois
l’appel de procédure exécuté. Le schéma ci-dessous présente un processus ayant trois threads.
34
Figure 6: Exemple d’un multithreading avec pile de thread
L’utilisation de thread
Dans de nombreuses applications plusieurs activités ont lieu simultanément. En décomposant

une application en plusieurs threads séquentiels, qui vont s’exécuter presque en parallèle, le
modèle de programmation devient plus simple (processus).
Avec les threads, un élément nouveau apparaît: “la capacité pour les entités parallèles à
partager un espace d’adressage et toutes ses données”.
De plus, étant donné qu’aucune ressource n’est associée aux threads, ils deviennent plus
faciles à créer et à détruire que les processus. Les threads peuvent également améliorer le
fonctionnement d’une application.
Notons enfin que les threads sont utiles sur les systèmes multiprocesseurs, sur lesquels un
véritable parallélisme est possible.
L’implémentation de threads dans l’espace utilisateur
L’implémentation de threads dans l’espace utilisateur consiste à placer le paquetage de

threads dans l’espace utilisateur. Cela reste transparent au noyau qui les prend en charge
comme des processus ordinaires monothreads. Cela est pratique pour les SE ne supportant
pas les threads.
Lorsque les threads sont gérés dans l’espace utilisateur, chaque processus a besoin de sa
propre table de threads privé pour le suivi des threads du processus. Les propriétés des
threads concernés par cette table sont: le compteur ordinal, le pointeur de pile, les registres,
l’état, etc. La table des threads est gérée par le système d’exécution (run time system).
Lorsqu’un thread passe à l’un des états prêt ou bloqué, les informations nécessaires à son
redémarrage sont stockées dans la table de threads de la même manière que le noyau stocke
les informations relatives aux processus dans la table des processus.
35
Lorsqu’un thread accompli une action susceptible de le bloquer localement, par exemple il
attend qu’un autre thread de son processus termine une tâche quelconque, il invoque une
procédure du système d’exécution. C’est cette dernière qui détermine si le thread doit être
placé en état bloqué. Dans ce cas, elle stocke les registres du thread dans la table des threads,
sonde la table à la recherche d’un thread prêt à s’exécuter et recharge le registre machine
avec les valeurs enregistrée du nouveau thread. Dès que le pointeur de la pile et le compteur
ordinal ont basculés, le nouveau thread recommence à s’exécuter automatiquement. Si la
machine possède une instruction pour stocker tous les registres et une autre pour les charger,
le basculement complet du thread peut s’accomplir en quelques instructions seulement. Ce
type de basculement est plus rapide que la rétention dans le noyau.
L’ordonnancement des threads est plus rapide par rapport à l’ordonnancement des processus :
• Utilisation des procédures locales;

• pas de nécessité d’interruption;
• pas de changement de contexte;
• pas de nécessité de vider la cache mémoire; etc.
L’implémentation de threads dans le noyau
Dans ce mode, le noyau a connaissance des threads et en assure la gestion. Ainsi, il n’est pas
nécessaire de disposer d’un système d’exécution pour chaque thread comme précédemment.
En outre, il n’y a pas de table de thread dans chaque processus. Cette table se retrouve dans
le noyau et est chargé du suivi de tous les threads du système. Un thread qui veut créer un
nouveau thread ou détruire un thread existant effectue un appel noyau qui prend en charge
la création ou la destruction en actualisant la table des threads du noyau. Cette table dispose
pour chaque thread de registre, de l’état et d’autres informations. Notons que ces informations
sont les mêmes que pour les threads utilisateurs la seule différence est qu’ils sont localisés
dans le noyau.A côté de cela, le noyau maintien également une table des processus traditions
pour assurer leur suivi.
Lorsqu’un thread se bloque, le noyau peut exécuter un autre prêt du même processus ou
d’un autre processus. Avec les threads utilisateurs, le système d’exécution continue d’exécuter
des threads de son propre processus jusqu’à ce que le noyau cesse de lui allouer du temps
processeur ou qu’il n’y ait plus de thread prêt. La création et la destruction des threads étant
lourd, certains systèmes recyclent leurs threads. Lorsqu’un thread est détruit, il est marqué
comme étant non exécutables mais ses structures de données noyaux n’en sont pas autrement
affectées. Lorsqu’un nouveau thread doit être crée, un ancien thread est réactivé, ce qui réduit
la surcharge. Le recyclage des threads est également envisageable pour les threads utilisateurs.
Si un thread d’un processus donné provoque un défaut de page, le noyau peut aisément
déterminer si le processus possède d’autres threads exécutables. Si tel est le cas, il peur en
exécuter un en attendant la récupération sur le disque de la page sollicitée. Le principal
inconvénient des threads noyaux est qu’un appel système est une démarche lourde. Ainsi,
si les opérations sur les threads (création, arrêt; etc.) sont nombreuses, la surcharge sera
importante.
36
Les implémentations hybrides
Plusieurs méthodes ont été testées pour tenter de combiner les avantages des threads
utilisateurs et noyau. L’une d’elle consiste à employer les threads noyaux puis à multiplexer les
threads utilisateurs sur un ou plusieurs threads noyaux.
Dans cette conception, le noyau ne connait que les threads noyaux et l’ordonnance. Certains
de ces threads peuvent disposer de threads utilisateurs multiplexés. Ceux-ci sont créés, détruit
et ordonnancés exactement comme les threads utilisateurs d’un processus qui s’exécute sur un
système d’exploitation dépourvu de fonctionnalités multithreading. Dans ce modèle, chaque
thread noyau possède un jeu donné de thread utilisateurs qu’il utilise tour à tour.
Une autre approche nommée activation de l’ordonnancement poursuit les objectifs qui
consistent à imiter la fonctionnalité des threads noyaux mais avec les performances
supérieures et la grande souplesse qu’offre les paquetages mis en œuvres dans l’espace
utilisateur.
Lorsqu’on emploi les activations de l’ordonnanceur, le noyau assigne un certain nombre de

processeurs virtuel à chaque processus et laisse le système d’exécution (espace utilisateur)
allouer des threads aux processeurs. Ce mécanisme peut également être exploité sur un multi
processeur dans lequel les processeurs virtuels peuvent être de véritables CPU. Le nombre
de processeurs virtuels alloués à un processus est initialement de 1 mais le processus peut
en solliciter d’autres. Notons qu’il peut également retourner les processeurs dont il n’a plus
besoin. Le noyau peut également récupérer des processeurs virtuels déjà alloué afin de les
assigner à d’autres processus prioritaires.
Conclusion
Pour pallier les effets d’interruption, les systèmes d’exploitation offrent un modèle conceptuel
de processus séquentiels s’exécutant en parallèle. Les peuvent être créés et arrêter
dynamiquement. Chaque processus possède son propre espace d’adressage. Dans certaines
applications, il est intéressant de disposer de plusieurs threads de contrôle au sein d’un même
processus. Les threads d’un processus sont ordonnancés indépendamment les uns des autres
et chacun possède sa propre pile mais partagent tous un espace d’adressage commun.
Cette activité d’apprentissage a montré de long en large, les processus et les threads ainsi que
les différentes implémentations des threads.
37
1. Quelle est la différence entre un processus et un programme ?
2. Quels sont les états possibles pour un processus ?
3. A la figure 2, trois états de processus apparaissent. En théorie avec trois

états on pourrait avoir six transitions (deux en sortie de chaque état). Cependant
on ne voit que quatre transitions commentez cet état de fait.
4. Supposons que vous devriez concevoir une architecture informatique

avancée qui effectuerait la commutation entre processus au niveau matériel au
lieu d’employer les interruptions. De quelle information le processeur aurait-il
besoin. Décrire comment cela pourrait fonctionner.
5. Lorsqu’une interruption ou un appel système transfère le contrôle au système

d’exploitation, on utilise généralement une zone de pile du noyau distincte de la
pile du processus interrompu. Expliquer pourquoi.
Rappel :
Les ordinateurs modernes sont conçus pour exécuter un à plusieurs programmes

utilisateurs. Pour ce faire, le processeur bascule entre programme pour les
servir en raison de petit laps de temps (au tour des dizaines ou centaines de
millisecondes) ce qui fait que le processeur simule le parallélisme. Pour qu’il y ait
un vrai parallélisme il faut des systèmes multiprocesseurs se partageant la même
mémoire physique. Toutes ces différentes notions sont essentiellement basées
sur le modèle de processus.
Activité 2. Communication interprocessus
Introduction
Il arrive que les processus aient besoin de communiquer entre eux par exemple dans pipeline
du shell, lorsque la sortie d’un processus doit être passée à un autre processus, etc. Il est donc
préférable que cette communication se fasse de manière structurée. Au cours de cette activité
nous allons aborder quelques-uns des problèmes liés à la communication interprocessus.
Les notions de base de communication interprocessus
Les processus d’un système ne s’exécutent pas tous de manière isolée. Certains se trouvent
en compétition pour une ressource donnée, d’autres ont besoin de coopérer et nécessitent
par conséquent des moyens de communication et de synchronisation. Ainsi, les principaux
problèmes liés à la communication interprocessus sont les suivants:
38
• Comment un processus fait-il pour passer des informations à un autre processus?

• Comment éviter que deux processus ou plus ne produisent pas de conflits
lorsqu’ils s’engagent dans des activités critiques (tentative de récupération du
dernier Mo de mémoire par deux processus?
• Comment faire le séquençage en présence de dépendances (un processus B qui
travaille sur des données produites par A, doit attendre que A ait terminé pour
pouvoir commencer)?
Pour étayer la communication interprocessus, prenons pour exemple le spouleur d’impression.

Les noms des fichiers à imprimer sont stockés dans un répertoire de spool et supprimés au fur
et à mesure de leur impression. Le répertoire de spool possède plusieurs entrées numérotées
de manière croissante et chaque entrée peut loger un nom de fichier. Pour gérer ce répertoire,
deux variables globales partagées (in et out) sont utilisées. La variable in pointe vers la
prochaine entrée libre du répertoire tandis que la variable out pointe vers le prochain fichier à
imprimer.Le processus qui veut lancer l’impression lit la valeur de la variable globale in, la met
dans sa variable locale suivant , puis place le nom de fichier dans l’entrée libre, du répertoire
de spool, désignée par le contenu de suivant puis met à jour la variable globale in en lui
affectant la valeur de suivant incrémentée de 1.
Le pseudo code correspondant à cette séquence est le suivant:
suivant=in;
MettreNomDeFichier (suivant);
in=suivant+1;
Admettons qu’à un instant t, in=7 et out =4 et que deux processus A et B désirent lancer
l’impression.
Figure 7: Intention d’accès simultanée de deux processus à la mémoire partagée
39
Dans ce cas, chaque processus doit exécuter la séquence d’actions d’ajout d’une tâche
d’impression (voir le pseudo-code ci-dessus indiqué). Supposons que le processus A s’exécute
et est interrompu par l’ordonnanceur avant de mettre à jour la variable globale in (c’est à dire
interrompu quelque part entre la 1ère et la 3ème instruction). L’ordonnanceur jugeant que
le processus A a eu suffisamment de temps bascule vers le processus B. Pour ce cas les deux
processus vont utiliser le même numéro, de l’entrée libre, pour placer la tâche d’impression et
l’une des tâches sera sans doute supprimée. Cependant au regard du contenu des variables in
et out, le répertoire va rester cohérent et aucune anomalie ne sera détectée par le CPU.
De tels cas de figure sont appelés de situations de concurrences (race conditions en anglais).
Face à une telle situation, il est donc indispensable que le système fournisse un moyen sûr
de communication interprocessus permettant la synchronisation et l’échange de données.
Sections critiques
Pour résoudre le cas des problèmes d’accès concurrents (voir exemple ci-dessus), il faut éviter
que plus d’un processus accèdent (en lecture/écriture) à une donnée partagée en même
temps. Cela consiste à mettre en place un processus d’exclusion mutuelle à la ressource
partagée aussi appelée section critique.
Quatre conditions sont à remplir pour résoudre ce problème:
1. deux processus ne doivent pas se trouver parallèlement dans leurs sections

critiques;
2. il ne faut pas faire de suppositions sur la vitesse ou le nombre de processeurs

mis en œuvre;
3. Aucun processus s’exécutant en dehors de la section critique ne doit bloquer

d’autres processus;
4. aucun processus ne dit attendre indéfiniment pour entrer dans sa section

critique.
5. Il existe plusieurs façons de mettre en œuvre l’exclusion mutuelle. Ci-dessous

nous allons détailler quelques-unes.
Masquage des interruptions
Le moyen le plus simple d’éviter les accès concurrents est de masquer les interruptions avant
d’entrer dans la section critique et de les restaurer à la sortie de celle-ci. Cela permettra
d’éviter la suspension du processus en section critique au profit d’un autre processus, puisque
l’inhibition des interruptions empêche l’ordonnanceur de s’exécuter. Les principaux problèmes
en rapport avec le masquage d’interruption sont les suivants:
• risque d’accaparer le processeur par un seul processus si celui-ci se maintient

longtemps en section critique;
• risque de blocage du système si le processus en section critique oublie de
restaurer les interruptions.
40
Malgré ces inconvénients, cette technique est souvent utilisée par le système d’exploitation
pour manipuler de façon sur ses structures internes.Notons que cette technique reste
inefficace pour les structures à multiprocesseurs, puisque les processus s’exécutant peuvent
toujours entrer en section critique.
Variables de verrouillage
Rappelons que pour le masquage des interruptions, si un processus entre en section critique,
le reste des processus sont bloqué et cela même si la section critique ne concerne qu’un
seul processus. Il serait mieux alors de définir autant de sections critiques indépendantes
que nécessaire.Pour ce faire, on déclare une variable par section critique pour jouer le rôle
de verrou. La variable sera mise à 1 par le processus entrant en section critique et remise à 0
par le même processus à la sortie de la section critique.Tout processus qui veut entrer dans
la section critique va tester le contenu de la variable verrou et n’entrer que s’il est égal à 0
(section critique libre). Le processus continuera à tester le contenu de cette variable aussi
longtemps qu’il est égal à 1. Cela est résumé dans le tableau ci-dessous.
Tableau 1: Exclusion mutuelle par variable de verrouillage
Cette solution présente le même inconvénient majeur que la précédente. En effet si un

processus lit le verrou et qu’il le trouve à 0, puis avant de le positionner à 1, un autre processus
planifié s’exécute et le fait à sa place. Au moment où le premier processus s’exécute de
nouveau, il va mettre encore le verrou à 1 et entre à son tour dans la section critique.
Les sémaphores
Le concept de sémaphore permet une solution élégante à la plupart des problèmes

d’exclusion. Ce concept nécessite la mise en œuvre d’une variable, le sémaphore, et de deux
opérations atomiques associées P et V. Soit SM la variable, elle caractérise les ressources et
permet de les gérer. Lorsqu’on désire effectuer une exclusion mutuelle entre tous les processus
par exemple, il n’y a virtuellement qu’une seule ressource et on donnera à SM la valeur initiale
de 1.
Lorsqu’un processus effectue l’opération P(SM) :
• Si la valeur de SM est supérieure à 0, il y a alors des ressources disponibles, (SM)

décrémente SM et le processus poursuit son exécution;
• Sinon ce processus sera mis dans une file d’attente jusqu’à la libération d’une
ressource.
41
Lorsqu’un processus effectue l’opération V(SM) :
• S’il n’y a pas de processus dans la file d’attente, V(SM) incrémente la valeur de
SM;
• Sinon un processus en attente est débloqué.
P(SM) correspond donc à une prise de ressource et V(SM) à une libération de ressource. Dans
la littérature, on trouve parfois d’autres terminologies, respectivement, wait(SM) et signal(SM)
ou get(SM) et release(SM).
Les mutex
Les mutex sont une version simplifiée des sémaphores. Un mutex est une variable qui peut
prendre deux états : déverrouillé ou verrouillé. Par conséquent un seul bit est nécessaire
pour le représenter même si dans la pratique en utilise un entier prenant la valeur 0 quand
c’est déverrouillé et une autre valeur sinon. Deux procédures (mutex_lock et mutex_unlock)
interviennent sur les mutex. Lorsqu’un processus (thread) a besoin d’accéder à une ressource,
il invoque la procédure mutex_lock. Si le mutex est déverrouillé alors l’appel réussit et le
processus (thread) est libre d’entrer dans la section critique.
Par contre, si le mutex est verrouillé, alors le thread appelant est bloqué, jusqu’à ce que le
processus en section critique appelle la procédure mutex_unlock. Si plusieurs threads sont
bloqués sur un mutex l’un d’eux est choisi aléatoirement pour prendre possession du verrou.
Conclusion
Les processus peuvent communiquer entre eux à l’aide de primitif de communication

interprocessus, comme les sémaphores, les moniteurs et les messages. Ces primitives
permettent d’empêcher que deux processus se trouvent dans la même section critique. Un
processus peut être dans un état prêt, en train de s’exécuter ou bloqué. Il peut changer
d’état de lui-même ou lorsque un autre primitif exécute l’un des messages de communication
interprocessus. Grâce à ces primitifs, la communication interprocessus est possible et
différentes situation de chaos peuvent être évitées.
Évaluation de l’activité :
1. Que faut-il comprendre par la communication interprocessus ?
2. Quelle est la différence entre les sémaphores et les moniteurs ?
3. Discuter du problème d’accès concurrents et la manière de le résoudre.
Rappel :
Tout au long de leur durée de vie les processus communiquent entre eux. Les
SE s’assure que cette communication se fasse de manière structurée. Des fois
les processus se trouvent en concurrence au tour d’une même ressource. Des
mécanismes ont été proposés pour résoudre ce genre de problème.
42
Activité 2.3: Ordonnancement de processus
Introduction
La fonction d’ordonnancement gère le partage du CPU entre les différents processus. En

effet, lorsque deux ou plusieurs processus sont dans un état prêt et qu’il n’y a qu’un seul
processeur, un choix doit être fait quant au prochain processus à exécuter. Cette tâche revient
à l’ordonnanceur. Pour ce faire il utilise un algorithme d’ordonnancement. On distingue deux
principales catégories d’ordonnancement : l’ordonnancement préemptif et l’ordonnancement
non-préemptif.
On peut dire que pour qu’il ait l’ordonnancement, il faut avoir un système multiprogrammé
c’est-à-dire plusieurs processus sont exécutés simultanément mais un seul processus à la fois a
accès au CPU.
Ordonnancement préemptif :
C’est la sélection d’un processus qui s’exécute pendant un délai déterminé.
Si le processus est toujours en cours d’exécution après ces délais, il est suspendu et un autre
processus est choisi. L’ordonnancement préemptif nécessite une interruption à la fin du délai
afin de donner le contrôle du processeur à l’ordonnanceur.
Ordonnancement non-préemptif :
Ici, on la sélection d’un processus qui s’exécute jusqu’à ce qu’il se bloque ou qu’il libère
volontairement le processeur. En effet aucune décision d’ordonnancement n’intervient pendant
les interruptions d’horloge. Une fois le traitement de l’interruption terminé, le processus qui
était en cours d’exécution avant l’interruption est toujours relancé.
Quelques algorithmes d’ordonnancement
Il existe un certain nombre d’algorithmes d’ordonnancement très utilisés dans la gestion des
processus. Comme par exemple FIFO (FCFS : First Come First Serve), Shortest Job First (SJF),
Round Robin (Tour niquet), File de priorité, etc.
Les deux principaux facteurs qui permettent d’évaluer un algorithme d’ordonnancement sont
en générale : Le temps moyen d’attente (moyenne de tous les temps d’attente) et le temps
moyen d’exécution (moyenne de tous les temps d’exécution).
A.FIFO (First In First Out) ou Premier arrivé, premier servi:
Il est sans doute le plus simple des algorithmes d’ordonnancement. Pour ce cas, les processus
se voient attribuer le temps processeur selon leur ordre d’arrivée. Il existe une seule file
d’attente des processus prêts. Le premier processus arrivé dans la file d’attente est exécuté
aussi longtemps qu’il le souhaite. Au fur et à mesure que les autres jobs arrivent, ils prennent
place dans la file d’attente. Lorsque le processus en cours d’exécution se bloque, le processus
suivant s’exécute. Quand il redevient prêt, il est placé à la queue de la file d’attente comme si
c’était un nouveau processus qui arrive.
43
La grande force de cet algorithme est sa simplicité de mise en œuvre. Malheureusement, le

mécanisme du premier arrivé, premier sorti (First In First Out) souffre d’un inconvénient majeur.
Prenons un cas de figure dans lequel un processus de traitement s’exécute à raison d’une
seconde à la fois, et où de nombreux processus d’Entrée-sortie (E/S) utilisent peu de temps
processus, mais doivent chacun effectuer 1.000 lectures disque pour se terminer. Le processus
de traitement s’exécute pendant une seconde, puis il lit un bloc de disque. Tous les processus
d’E/S s’exécutent alors et commencent à faire des lectures disque. Lorsque le processus de
traitement récupère son bloc de disque, il s’exécute encore une fois pendant une seconde,
suivi de tous les processus d’E/S en rapide succession.
Il en résulte que chaque processus d’E/S arrive à lire un bloc par seconde et prend 1 000
secondes pour se terminer. Avec un algorithme d’ordonnancement qui préempterait le
processus de traitement toutes les 10 millisecondes, les processus d’E/S se termineraient en 10
secondes au lieu de 1 000, et ce sans ralentir le processus de traitement de façon palpable.
Les schémas ci-dessous montrent les exemples de l’exécution des processus selon l’algorithme
FIFO.
Jobs Durée Temps de

soumission
1 3 0
2 2 2
3 4 1
4 3 3
Tableau 2: Durée des processus et leurs temps de soumission
Figure 8: Ordonnancement selon le FIFO
44
Jobs Temps d’attente Temps d’exécution
1 0 3
2 5 7
3 2 6
4 6 9
Moyenne 3,25 6,25
Tableau 3: FIFO (temps d’attente et d’exécution)
Exemple 2 : FIFO
Processus Arrivée Durée E/S Durée E/S
Processus 1 0 5 1 3
Processus 2 2 4
Processus 3 3 2
Processus 4 5 4
Tableau 4:FIFO (Arrivée, Durée d’exécution et d’Entrée/Sortie)
Figure 9: Exemple 2 d’ordonnancement avec FIFO
45
B.Exécution du job le plus court en premier (Shortest Job First: STF)
Ici, les processus les plus courants sont exécutés en premier. Pas de notion de priorité, c’est
un algorithme non-préemptif qui suppose que les délais d’exécution sont connus d’avance. Le
principe consiste à choisir le processus dans le prochain cycle d’horloge et le plus petit.
Remarque : Cet algorithme demande une connaissance à priori de la longueur du prochain

cycle d’horloge du CPU. Cet algorithme existe en version avec ou sans préemption.
Processus Arrivée Durée
Processus 1 0 5
Processus 2 0 4
Processus 3 4 2
Processus 4 3 4
Tableau 5: Arrivée et Durée des processus
Figure 10: Ordonnancement selon SJF (Shortest Job First)
C.Exécution du temps restant le plus court (Shortest Remaining First: SRF)
Ici, les processus dont le reste de temps d’exécution le plus court sont exécutés en premier.
Pas de file d’attente. C’est un algorithme préemptif qui nécessite de connaître la durée des
processus.Lorsqu’un nouveau job arrive, son temps total est comparé au temps restant pour
le processus en cours. Si le nouveau job a un temps d’exécution plus court que celui en cours
d’exécution, ce dernier est suspendu au profit du nouveau processus. Cela favorise les services
des jobs courts.
46
D.Ordonnancement de type tourniquet (Round Robin)
Le principe du Round Robin est que le CPU obtenu pour une durée limitée (un quantum
de temps prédéfinis). Un intervalle de temps d’exécution est accordé à chaque processus
(quantum). A la fin du quantum de temps, si le processus est en cours d’exécution le
processeur est préempté au profit d’un autre processus. Si le processus a bloqué ou terminé
avant la fin du quantum, le basculement du processeur se fait naturellement.
E.Ordonnancement par priorité
Le principe consiste à associer au processus une priorité et choisir le processus donc, la priorité
est la plus élevée.
Une priorité peut se définir en fonction de :
• L’espace mémoire utilisé ;

• L’importance relative au processus ;
• Ou l’instant du dernier accès au CPU.
L’algorithme d’ordonnancement avec priorité existe en version avec ou sans préemption.
Sans préemption
Processus Arrivée Durée Priorité
P1 0 5 7
P2 0 4 4
P3 3 3 2
P4 3 4 5
Tableau 6: Données des processus pour ordonnancement par priorité
Avec préemption
Processus Arrivée Durée Priorité
P1 0 5 7
P2 0 3 5
P3 3 3 8
P4 3 4 5
Tableau 7: Données des processus pour ordonnancement avec préemption
47
Figure 11: Schéma d’ordonnancement sans préemption
Processus Temps d’attente Temps d’exécution
P1 0 5
P2 10 14
P3 11 14
P4 2 7
Moyenne 5,75 10
Tableau 8: Données des processus à ordonnancer sans préemption
Figure 12: Schéma d’ordonnancement avec préemption
48
Processus Temps d’attente Temps d’exécution
P1 0 8
P2 8 11
P3 0 3
P4 8 12
Moyenne 4 8
Tableau 9: Ordonnancement avec préemption
Conclusion
Le partage du CPU entre les différents processus est une tâche qui doit être bien accomplie
pour éviter que certains processus monopolisent cette ressource partagée. Pour cela,
nous avons au cours de cette activité d’apprentissage vu les deux principales catégories
d’ordonnancement : l’ordonnancement préemptif et l’ordonnancement non-préemptif. Des
algorithmes d’ordonnancement ont été vus tant pour les systèmes de traitement par lots
(exemple : algorithme du job le plus court en premier), que pour les systèmes interactifs
(Round Robin, l’ordonnancement par priorité, ..).
Question 1 :
Considérez un système d’exploitation qui ordonnance les processus selon

l’algorithme du tourniquet. La file des processus prêts contient des pointeurs
vers les entrées de la table des processus (les descripteurs des processus).
Citez deux problèmes qui peuvent survenir si la file contient des éléments
identiques (deux ou plusieurs pointeurs égaux).
Supposez que le système d’exploitation est composé de deux unités de contrôle

(deux processeurs CPU1 et CPU2) et d’une unité d’E/S. Chaque processeur
exécute l’algorithme du tourniquet avec un quantum de trois unités de temps (qt
= 3). Tous les processus prêts sont dans une même file d’attente. La commutation
de contexte est supposée de durée nulle.
49
Considérez trois processus A, B et C décrits dans le tableau suivant :
Processus Instant d’arrivée Temps d’exécution
A 0 4 unités de CPU, 2 unités d’E/S, 2 unités de CPU
B 2 3 unités de CPU, 4 unités d’E/S, 2 unités de CPU
C 3.5 5 unités de CPU
La première ligne signifie que le processus A arrive dans le système à l’instant

0, son exécution nécessite dans l’ordre 4 unités de temps CPU, 2 unités de
temps d’E/S et 2 unités de temps CPU. Au départ le processus A est élu par le
processeur CPU1.
Si plusieurs événements surviennent en même temps, vous supposerez les

priorités suivantes :
• Le CPU1 a la priorité d’accès à la file des processus prêts par rapport au CPU2.
• A la fin d’un quantum, le processus non terminé en cours est suspendu
uniquement si la file des processus prêts n’est pas vide. Le traitement réalisé à la
fin d’un quantum est plus prioritaire que celui d’une fin d’E/S qui, à son tour, est
plus prioritaire que l’arrivée de nouveaux processus dans le système.
1. Donnez les diagrammes de Gantt montrant l’allocation des deux processeurs,

de l’unité d’E/S et l’évolution des états des files d’attente (celle des processus
prêts et celle des processus en attente de l’unité d’E/S).
2. Calculez le temps moyen de virement (temps moyen de séjour).
Question 2 :
1) Expliquez la différence entre les Ordonnanceurs d’exécution non préemptifs

(ex : ceux des premières versions de MacOS) et préemptifs (ex. ceux d’Unix, de
Windows2000…).
2) Supposez que plusieurs processus sont à l’état prêt et que le processus

élu exécute le programme suivant :
int main ( )
for ( int i=0; i<=100; i = min(100,i++)); return 0;
50
a)Que se passe-t-il pour les processus qui sont à l’état prêt, si l’Ordonnanceur
d’exécution est non préemptif?
b)Que se passe-t-il pour les processus qui sont à l’état prêt, si l’Ordonnanceur
d’exécution est préemptif?
3) A l’instant t, deux processus utilisateur P1 et P2 existent dans un système

monoprocesseur. Le processus P1 est composé de deux threads. Le processus
P2 est composé de trois threads. Les temps nécessaires à leurs exécutions sont
résumés dans le tableau suivant :
Proc. Threads Temps d’exécution
P1 T11 T12 1 unité de CPU 3 unités de CPU
P2 T21 T22 T23 3 unités de CPU 2 unités de CPU 1 unité de CPU
Supposez que le processeur est libre. Donnez les diagrammes de Gantt montrant
l’allocation du processeur, pour chacun des cas suivants :
a) Les threads sont supportés par le noyau (threads noyau). Le noyau

ordonnance l’exécution des threads selon l’algorithme du tourniquet (Round
Robin) avec un quantum de 2 unités.
La file d’attente des threads prêts, à l’instant t, est : →T23 T12 T22 T21 T11 →
T11 est en tête de file.
b) Les threads sont implémentés entièrement au niveau utilisateur. Le noyau

ordonnance l’exécution des processus selon l’algorithme du tourniquet avec un
quantum de 2 unités. Les threads sont ordonnancés au niveau utilisateur selon
l’algorithme du tourniquet avec un quantum de 1 unité.
Supposez que le processeur est libre et que les processus sont passés à l’état
prêt dans l’ordre suivant :
P1 puis P2
Dans P1 : T11 puis T12
Dans P2 : T21 puis T22 puis T23
Dans tous les cas, le temps de commutation est supposé nul.
c) Calculez, pour chaque cas, le temps de virement (temps de séjour), relatif à

l’instant t, de chaque processus. Comparez puis commentez les résultats.
51
Activité 2.4 : Interblocages
Introduction
Les ordinateurs disposent de nombreuses ressources (mémoire principale, disques, fichiers,

périphériques, etc.) mais elles ne peuvent qu’à un seul processus à la fois. L’attribution de ces
ressources à un processus revient au SE. Pour de nombreuses applications, les processus n’ont
pas besoin d’un accès à une seule ressource mais doivent pouvoir accéder à plusieurs.
Supposons que les processus P1 et P2 désirent enregistrer chacun un document numérisé

sur CD. Admettons que le processus P1 demande en premier lieu le scanner et que le
processus P2 demande l’accès au graveur CD. Ces deux premières demandent sont honorées.
Supposons maintenant que P1 sollicite le graveur et que la demande est refusée jusqu’à ce
que P2 libère la ressource. Au lieu de libérer la ressource supposons que P2 sollicite à son tour
le scanner. A ce stade, les deux processus sont bloqués et vont le rester indéfiniment. C’est
ce que l’on appelle l’interblocage ou deadlock en anglais.Dans des situations complexes, les
interblocages peuvent concerner plusieurs utilisateurs et plusieurs périphériques à la fois.
Notons que les interblocages ne concernent que les requêtes des périphériques d’E/S. Dans
un système de gestion de base de données par exemple, un programme peut verrouiller
plusieurs enregistrement qu’il utilise afin d’éviter qu’ils entrent en concurrence. Si un
processus P1 verrouille l’enregistrement E1 et qu’un processus P2 verrouille l’enregistrement
E2 et que l’un ou les deux tente(nt) de verrouiller un enregistrement déjà verrouillé par un
autre, on est dans une situation d’interblocage. Les interblocages peuvent donc se produire
tant sur les ressources matérielles que sur les ressources logicielles
Au cours de cette activité, nous allons examiner les situations d’interblocage, comment elles se
présentent et comment les éviter. Même si nous sommes dans un contexte de SE, notons que
les interblocages peuvent se produire dans des systèmes de base de données et dans d’autres
contexte de traitement de données. Ce qui fait que le contenu développé s’applique à un
large éventail de système multiprocesseurs.
Les ressources
L’exécution d’un processus nécessite un ensemble de ressources (mémoire principale, disques,

fichiers, périphériques, etc.) qui lui sont attribuées par le système d’exploitation. L’utilisation
d’une ressource se fait par l’intermédiaire des trois évènements suivants :
• La demande de la ressource: Si l’on ne peut pas satisfaire la demande celle-ci

sera mise dans une table d’attente des ressources ;
• L’utilisation de la ressource : le processus demandeur utilise la ressource. A cet
instant d’autres processus qui demandent la ressource doivent attendre ;
• La libération de la source : Le processus libère la ressource qu’il utilisait.
Par ressource, nous faisons référence à tout objet pouvant être alloué à un processus. Il peut
s’agir d’un périphérique physique, d’une information (enregistrement verrouillé dans une base
de données) bref tout ce qui peut être utilisé par un processus.
52
Les ressources peuvent être :
• réutilisables (existent après leur utilisation) : exemple les ressources

physiques (imprimante, graveur, etc.) ou logiques (fichiers, mutex, verrous, etc.) ;
• d’usage partagé : c’est la ressource qui peut être utilisée par plusieurs
processus en même temps ? Ce genre de ressources n’affecte pas les
interblocages.
• préemptible ou non préemptible : La différence principale entre ressources
préemptibles et non préemptibles est que les premières peuvent être retirées
sans risque au processus qui les détient, tandis que les deuxièmes ne peuvent
être retirées sans provoquer des problèmes. Comme exemples de ressources
preémptibles nous avons le processeur (où le changement de contexte
correspond à l’expropriation et l’état du processeur est copié à la Table de
Contrôle de Processus (BCP)) et la mémoire virtuelle (le remplacement est une
expropriation et le contenu de la page doit être copié au swap). Les imprimantes
et les scanners sont des exemples de ressources non preémptibles.
Pour étudier le problème des interblocages, nous allons considérer uniquement les ressources
non préemptibles.
Définition d’un interblocage
Des problèmes peuvent survenir, lorsque les processus obtiennent des accès exclusifs aux
ressources. Par exemple, un processus P1 détient une ressource R1 et attend une autre
ressource R2 qui est utilisée par un autre processus P2 et que le processus P2 attend à son
tour le processus R1 qui est détenu par P1. Cette situation est un interblocage ou deadlock (en
anglais).
De ce qui précède, nous constatons qu’un ensemble de processus est en interblocage si

chaque processus attend la libération d’une ressource qui est allouée à un autre processus de
l’ensemble. Comme tous les processus sont en attente, aucun ne pourra s’exécuter et donc
libérer les ressources demandées par les autres. Par conséquent ces processus attendront
indéfiniment.
Conditions d’un interblocage
Pour qu’une situation d’interblocage ait lieu, les quatre conditions suivantes doivent être
remplies (Conditions de Coffman) :
• L’exclusion mutuelle : A un instant précis, une ressource est allouée à un seul

processus ou est disponible.
• La détention et l’attente : Les processus qui détiennent des ressources
peuvent en demander de nouvelles.
• Pas de préemption (réquisition) : Les ressources allouées à un processus
sont libérées uniquement par le processus.
• L’attente circulaire : Il existe une chaîne d’au moins deux processus chacun
attendant une ressource détenue par un autre processus de la chaîne.
53
La modélisation des interblocages
Les quatre conditions précédentes peuvent être modélisées à l’aide d’un graphe orienté
(graphe d’allocation de ressources). Ce graphe est composé de deux types de nœuds et d’un
ensemble d’arcs :
• Les processus qui sont représentés par des cercles.

• Les ressources qui sont représentées par des rectangles. Chaque rectangle
contient autant de points qu’il y a d’exemplaires de la ressource représentée.
• Un arc orienté d’une ressource vers un processus signifie que la ressource est
allouée au processus.
• Un arc orienté d’un processus vers une ressource signifie que le processus est
bloqué en attente de la ressource.
Ce graphe indique pour chaque processus les ressources qu’il détient ainsi que celles qu’il
demande.
Exemple :
Soient trois processus A, B et C qui utilisent trois ressources R, S et T comme illustré ci-dessous:
A B C
Demande de R Demande de S Demande de T
Demande de S Demande de T Demande de R
Libère R Libère S Libère T
Libère S Libère T Libère R
Tableau 10: Tableau de synthèse des besoins de trois processus
Si ces trois processus sont exécutés de façon séquentielle : A suivi de B suivi C, il n’y pas
d’interblocage. Par contre, supposons que l’exécution des processus est gérée par un
ordonnanceur du type circulaire. Si les instructions sont exécutées dans l’ordre ci-dessous :
1. A demande R
2. B demande S
3. C demande T
4. A demande S
5. B demande T
6. C demande R
54
Cela constitue une situation d’interblocage.
On la schématiser comme suit :
Figure 13: Situation d’interblocage de trois processus
Un graphe réduit peut être utilisé pour déterminer s’il existe ou non un interblocage. Pour la
réduction d’un graphe d’allocation des ressources, les flèches associées à chaque processus et
à chaque ressource doivent être vérifiées.
• Si une ressource possède seulement des flèches qui sortent (il n’y a pas des
requêtes), on les efface.
• Si un processus possède seulement des flèches qui pointent vers lui, on les efface.
• Si une ressource a des flèches qui sortent, mais pour chaque flèche de requête il
y a une ressource disponible dans le bloc de ressources où la flèche pointe, il faut
les effacer.
Exemple :
Soient 4 processus P1, P2, P3, P4 utilisant les ressources R1, R2, et R3. Le tableau ci-dessous
montre l’allocation courante et le nombre maximaux d’unités de ressources nécessaires pour
l’exécution des processus. Le nombre de ressources disponibles est A=[0,0,0].
Processus R1 R2 R3 R1 R2 R3
P1 3 0 0 0 0 0
P2 1 1 0 1 0 0
P3 0 2 0 1 0 1
P4 1 0 1 0 2 0
Tableau 11: Synthèse des besoins de 4 processus
55
Le graphe d’allocation de ressources correspondant est le suivant :
Le graphe précédent peut être réduit comme suit :
P1 possède seulement des flèches qui pointent vers lui, alors on les efface.Les requêtes de R1
effectuées par P2 peuvent donc être allouées, et P2 aura seulement des flèches qui pointent
vers lui. Alors on les efface aussi. On efface la flèche de R1 vers P3 (qui a changé de direction)
car R1 n’a que des flèches sortantes. Ce qui nous donne le graphe final ci-dessous :
Traitement des interblocages
De ce qui précède, nous constatons que les situations d’interblocage peuvent se produire
dans un système. Face à cette situation, que faut-il faire ?
1.Faire semblant que le problème n’existe pas
La première solution et c’est la plus simple consiste à appliquer la politique de l’autruche.

C’est-à-dire, ignorer complètement le problème et faire semblant qu’il n’existe pas. Cette
stratégie est adoptée par la plus part des SE courants car le prix à payer pour les éviter est
élevé.
2.La détection et la reprise des interblocages
Une autre solution consiste à détecter et reprendre les interblocages. C’est-à-dire qu’on les
laisse se produire et on essaie d’y remédier à postériori.Pour détecter les interblocages, il
construit dynamiquement le graphe d’allocation des ressources du système qui indique les
attributions et les demandes de ressources. Dans le cas des ressources à exemplaire unique,
il existe un interblocage si le graphe contient au moins un cycle. Dans le cas des ressources à
exemplaires multiples, il existe un interblocage si le graphe contient au moins un cycle terminal
(aucun arc ne permet de le quitter).
Le système vérifie s’il y a des interblocages :
• A chaque modification du graphe suite à une demande d’une ressource

(coûteuse en termes de temps processeur).
• Périodiquement ou lorsque l’utilisation du processeur est inférieure à un certain
seuil (la détection peut être tardive).
Ci-dessous, nous présentons un exemple d’un algorithme de détection des interblocages :
Soient n le nombre de processus P[1], P[2],… , P[n] et m le nombre de type de ressources E[1],
E[2],…, E[m] qui existent dans un système.
L’algorithme de détection des interblocages utilise les matrices et vecteurs suivants :
• Matrice C des allocations courantes d’ordre (n x m). L’élément C[i,j] désigne le

nombre de ressources de type E[j] détenues par le processus P[i].
• Matrice R des demandes de ressources d’ordre n x m). L’élément R[i,j] est le
nombre de ressources de type E[j] qui manquent au processus P[i] pour pouvoir
poursuivre son exécution.
56
• Vecteur A d’ordre m. L’élément A[j] est le nombre de ressources de type E[j] &
_disponibles (non attribuées).
• Vecteur E d’ordre E d’ordre m. L’élément E[j] est le nombre total de ressources de
type j existantes dans le système.
1. Rechercher un processus P[i] non marqué dont la rangée R[i] est inférieure
à A.
2. Si le processus existe, ajouter la rangée C[i] à A, marquer le processus et

revenir à 1
3. Si le processus n’existe pas, les processus non marqué son en interblocage.

L’algorithme se termine.
Exemple :
Considérons un système où nous avons trois processus en cours et qui dispose de 4 types
de ressources : 4 dérouleurs de bandes, 2 scanners, 3 imprimantes et un lecteur de CD ROM.
Les ressources détenues et demandées par les processus sont indiquées par les matrices C et
R.E=[4,2,3,1] ; A= [2,1,0,0]
C=[0 0 1 2 0 0 0 1 2 0 1 0 ] ; R=[2 0 0 1 0 1 2 1 0 100]
Seul le processus P3 peut obtenir les ressources dont il a besoin. Il s’exécute jusqu’à la fin puis
libère ses ressources, ce qui donne : A=[2,2,2,0].
Ensuite P2 peut obtenir les ressources dont il a besoin. Il s’exécute jusqu’à la fin et libère ses
ressources, ce qui donne : A=[4,2,2,1] . Enfin, P1 peut obtenir les ressources dont il a besoin. Il
n’y a donc pas d’interblocage.
Lorsque le système détecte un interblocage, il doit le supprimer, ce qui se traduit

généralement par la réalisation de l’une des opérations suivantes :
• Retirer temporairement une ressource à un processus pour l’attribuer à un autre.

• Restaurer un état antérieur (retour en arrière) et éviter de retomber dans la même
situation.
• Supprimer un ou plusieurs processus.
L’évitement des interblocages
Dans ce cas, lorsqu’un processus demande une ressource, le système doit déterminer si
l’attribution de la ressource est sûre. Si c’est le cas, il lui attribue la ressource. Sinon, la
ressource n’est pas accordée. Un état est sûr si tous les processus peuvent terminer leur
exécution (il existe une séquence d’allocations de ressources qui permet à tous les processus
de se terminer).Un état est non sûr si on ne peut garantir que les processus pourraient terminer
leurs exécutions.
Mais comment déterminer si un état est sûr ou non sûr ? Dijkstra a proposé en 1965 un
algorithme d’ordonnancement, appelé l’Algorithme du banquier qui permet de répondre à
57
cette question. Cet algorithme, utilise les mêmes informations que celles de l’algorithme de
détection précédent : matrices A, E, C et R. Un état est caractérisé par ces quatre tableaux.
Cet algorithme consiste à examiner chaque nouvelle requête pour voir si elle conduit à un état
sûr. Si c’est le cas, la ressource est allouée, sinon la requête est mise en attente. L’algorithme
détermine donc si un état est ou non sûr :
1. Trouver un processus Pi non marqué dont la rangée i de R est inférieure à A
2. Si un tel processus n’existe pas alors l’état est non sûr (il y a interblocage).
L’algorithme se termine.
3. Si tous les processus sont marqués alors l’état est sûr et l’algorithme se
termine sinon aller à l’étape 1.
L’algorithme du banquier permet bien d’éviter les interblocages mais il est peu utilisé en
pratique car on ne connaît pas toujours à l’avance les besoins en ressources des processus.
58
La prévention des interblocages
Pour prévenir les interblocages, on doit éliminer une des quatre conditions nécessaires à leur
apparition.
• Pour éviter l’exclusion mutuelle, il est parfois possible de sérialiser les requêtes
portant sur une ressource. Par exemple, pour les imprimantes, les processus «
spoolent » leurs travaux dans un répertoire spécialisé et un démon d’impression
les traitera, en série, l’un après l’autre.
• Pour ce qui concerne la deuxième condition (la détention et l’attente), elle
pourrait être évitée si les processus demandaient leurs ressources à l’avance. Ceci
est en fait très difficile à réaliser dans la pratique car l’allocation est, en général,
dynamique. Empêcher cette condition serait donc particulièrement coûteux.
• La troisième condition (pas de préemption) n’est pas raisonnablement traitable
pour la plupart des ressources sans dégrader profondément le fonctionnement
du système. On peut cependant l’envisager pour certaines ressources dont le
contexte peut être sauvegardé et restauré.
• Le problème de l’attente circulaire, dernière condition, peut être résolu en
numérotant les ressources et en n’autorisant leur demande, par un processus,
que lorsqu’elles correspondent à des numéros croissants ou en accordant aux
processus une seule ressource à la fois (s’il a besoin d’une autre ressource, il doit
libérer la première). Par exemple :
F(CD-ROM)=1
F(imprimante)=2
F(plotter)=3
F(rubban)=4
Ainsi on garantit qu’il n’aura pas de cycles dans le graphe des ressources. On peut exiger
seulement qu’aucun processus ne demande une ressource dont le numéro est inférieur aux
ressources déjà allouées. Mais ceci n’est pas non plus la panacée, car, en général, le nombre
potentiel de ressources est si important qu’il est très difficile de trouver la bonne fonction F
pour les numéroter.
Source :
http://www.groupes.polymtl.ca/inf2610/documentation/notes/chap7.pdf
D’autres détails se trouvent dans : Andrew Tanenbaum, Systèmes d’exploitation (2ème édition)
page 169-195
59
Conclusion
L’interblocage est un problème lorsque des processus ont obtenu des accès exclusif à
certaines ressources et lorsque chacun de ces processus sollicite une ressource détenu par
un autre processus du groupe. Nous avons vu qu’il est possible d’éviter les interblocages
en réalisant un suivi des états (un état sûr présente une séquence d’évènements qui offre
la garantie que tous les processus peuvent se terminer et un état non sûr n’offre pas cette
garantie. On a vu également que l’on peut éviter l’interblocage en concevant un système qui
les empêche de se produire.
Question 1 :
1. Qu’est-ce qu’un interblocage ?
2. Expliquer comment la situation d’interblocage apparaît.
Question 2 :
Des étudiants qui travaillent sur des PC dans un laboratoire d’informatique envoient
leurs fichiers à imprimer par un serveur qui les spoulent sur son disque dur. Sous quelle
condition un interblocage peut-il se produire si l’espace de spoule de l’imprimante est
limité ? Comment éviter l’interblocage ?
Question 3 :
Pour traiter une image de taille T unités, un système composé de N processeurs à

mémoire partagée, crée N processus. Chaque processus s’exécute sur un processeur
et se charge de traiter une partie de l’image. Pour faire son traitement, un processus a
besoin d’une unité de mémoire par unité d’image qu’il a à traiter, mais demande de la
mémoire unité par unité au fur et à mesure de ses besoins. Si une demande ne peut être
satisfaite, le processus demandeur est mis en attente (attente active). La libération des
unités de mémoire allouées à un processus aura lieu lorsqu’il aura fini le traitement de
toute sa partie. La mémoire disponible pour répondre aux demandes d’allocation des
différents processus est de taille M unités.Pour éviter les interblocages, le système utilise
l’algorithme du banquier. Supposez que N =4, T = 16, M = 8 et qu’à l’état courant les
processus P1, P2, P3 et P4 ont respectivement traité 1 sur 3 unités, 1 sur 4 unités, 1 sur 4
unités et 3 sur 5 unités (par exemple, P1 : 1 sur 3 unités signifie que le processus P1 est
chargé de traiter 3 unités de l’image et a seulement traité 1 unité).
1) Est-il possible d’atteindre une situation d’interblocage, si T<=M ? Si T>M ? Justifiez

votre réponse.
2) Vérifiez, en utilisant l’algorithme du banquier, si l’état courant est certain (sûr ou

sauf).
3) Le processus P3 demande une unité de mémoire. Doit-on la lui accorder ? Attention,

vous devez répondre à cette question en utilisant l’algorithme du banquier.
60
Pour pallier aux effets d’interruption les SE offrent un modèle conceptuel de processus
s’exécutant en parallèle. Chaque processus possède son propre espace d’adressage. Dans
certains cas, il existe plusieurs threads de contrôle pour un même processus. Ces threads sont
ordonnancés indépendamment les uns et les autres et chacun possède sa propre pile. La
communication interprocessus passe par certaines primitives comme les sémaphores, les
moniteurs ou les messages. Grâce à ces primitives un ensemble de problèmes de
synchronisation mais il faut rester attentif aux erreurs et aux interblocages.
Question 1 :
Donner les réponses aux questions suivantes:
1. Décrire le modèle de processus.
2. Distinguer les processus des threads
3. Discutez des principaux problèmes de synchronisation interprocessus et comment ils

sont résolus.
Question 2 :
Dans un système électronique de transfert de fonds, il existe des centaines de processus

identiques qui fonctionnent comme suit : Chaque processus lit une ligne de données qui
spécifie la quantité d’argent, le numéro de compte à créditer et le numéro de compte
à débiter. Il verrouille ensuite l’un après l’autre les deux comptes, transfère l’argent puis
libère les verrous.
1. Peut-on avoir des situations d’interblocage ? Justifiez votre réponse
2. Si vous répondez oui à la question précédente, proposez une solution qui permet de
les éviter. Attention : ne pas libérer l’enregistrement d’un compte avant que le transfert
ne soit terminé.
3. Peut-on les prévenir ? Si oui, expliquez brièvement comment ?
Rétroaction

points
61
Quotation
• L’évaluation des activités compte pour 60% tandis que celle de l’unité
d’apprentissage compte pour 40%.
• L’unité d’apprentissage compte pour 30% du module

373-385.
http://www.groupes.polymtl.ca/inf3600/TransparentsAut2006/Ch1INF3600.pdf
62
Unité 3. Gestion de la mémoire

Comment se fait la gestion de la mémoire par le SE?
Introduction
La mémoire est une ressource importante qui doit être gérée avec attention. Le Système
d’Exploitation doit cohabiter dans la mémoire principale avec un ou plusieurs processus. La
gestion de la mémoire prend en charge l’allocation de la mémoire aux processus. Elle doit
également protéger la mémoire allouée au Système d’Exploitation contre des accès non
autorisé. Ainsi, un bon gestionnaire de mémoire doit être capable de:
• Connaître les parties libres de la mémoire physique;

• allouer la mémoire aux processeurs en évitant le gaspillage;
• récupérer la mémoire par la terminaison de processus;
• offrir aux processus des services de mémoire virtuelle plus grand que la mémoire
physique disponible, au moyen des techniques de va-et-vient et de pagination.
Objectifs
A la fin de cette unité, l’apprenant devra être à mesure de différencier les différents types de
mémoires, et d’expliquer les différentes techniques de gestion de la mémoire.
Mots-clés
Mémoire virtuelle : C’est la mémoire que l’on crée sur le disque dur. Cette
notion repose sur la traduction des adresses virtuelles en adresse physique
de mémoires vives
Mémoire vive : C’est une partie de la mémoire où on trouve les programmes

en cours d’exécution.
Mémoire morte: C’est une mémoire non volatile (c’est-à-dire le contenu

de ce type de mémoire ne s’efface pas à la coupure de l’alimentation) dont
le contenu était fixé lors de sa programmation. Au début ces mémoires
étaient en lecture seule mais avec l’évolution de la technologie, des
utilisateurs expérimentés peuvent les modifier.
Pagination : La pagination est une technique d’allocation de la mémoire

qui fournit au processus des espaces d’adresses séquentielles à partir
d’espaces mémoire discontinues.
63
Partition: C’est le fait de subdiviser la mémoire en partie de tailles fixes

ou variables afin de mieux l’utiliser
Monoprogrammation : Se dit pour les systèmes d’exploitation n’exécutant

qu’un seul programme à la fois (un seul processus possible dans la mémoire
physique).
Multiprogrammation : Se dit lorsque le nombre de processus présents

dans la mémoire d’un ordinateur à un instant donné dépasse 1.
Activité 1. Mémoire sans va-et-vient
Introduction
La gestion de la mémoire sans va-et-vient est le plus simple. Pour ce cas, on ne considère
que la mémoire physique effectivement disponible, que l’on accède directement au
moyen d’adresses physiques. Dans cette activité nous allons passer en revue les différents
modes de fonctionnement à savoir : la monoprogrammation, la multiprogrammation et la
multiprogrammation avec partitions fixes.
La Monoprogrammation
Dans ce cas un seul processus à un instant donné, peut occuper l’ensemble de la mémoire
physique disponible. En pratique une partie de l’espace mémoire est dédiée au système
d’exploitation qui se compose de fonction de démarrage et de gestion de bas niveau de la
machine, situées en ROM et le SE proprement dit sujet à modification et chargé en RAM à
partir du disque lors du démarrage.
À la fin de chaque programme, l’interpréteur de commandes, demande à l’utilisateur le

prochain programme à lancer.
Exemple : Structure des PC sous DOS
Figure 16: Schéma de la structure des PC sous DOS
64
Lorsque la taille du programme dépasse la taille de la mémoire physique on ajoute des

segments de recouvrements « Overlays ». Le programme est alors composé d’une zone
permanente, et d’un ensemble d’overlays interchangeables correspondant le plus souvent aux
grandes fonctionnalités du programme.
Figure 17: Structure du programme avec des overlays
Le changement d’overlay s’effectue en passant par la zone permanente, où le chargement

du nouvel overlay à partir du disque est réalisé. Afin de limiter les remplacements d’overlays,
il est possible de dupliquer un même module au sein de plusieurs overlays. Si les fonctions
à appeler sont présentes au sein de l’overlay, la copie locale est utilisée, sinon l’appel est
effectué dans la zone d’indirections, où une routine adaptée se charge du chargement de
l’overlay correspondant et de l’appel de la fonction nouvellement chargée.
Figure 18: Changement d’overlays
La résolution des adresses et l’appel aux routines locales sont effectué statiquement par
l’éditeur de liens. Il revient à l’utilisateur de définir la structure d’overlays en fonction du
comportement attendu de son programme.
65
La Multiprogrammation
La multiprogrammation est utilisée dans les systèmes dédiés au calcul intensif. Elle facilite le
développement des programmes en les fractionnant en processus indépendants. Elle permet
de maximiser l’utilisation de la ressource processeur: si le programme possède une partie
interactive, il est aberrant de monopoliser la machine en instance.Ceci reste vrai dans le cas de
processus non interactifs réalisant beaucoup d’entrées-sorties. Ci-dessous, nous présentons un
exemple de la modélisation de la multiprogrammation.
Soit p la fraction de temps passée par un processus en attente d’entrées-sorties. Si n processus

sont chargés en mémoire la probabilité que tout soit simultanément en attente est de pn, et
donc le taux d’utilisation du processeur est de 1- pn
Figure 19: Taux d’utilisation du CPU en fonction du nombre de processus en mémoire
A titre d’exemple, pour un taux d’attente de 80%, il faut plus de 10 processus simultanément
en mémoire pour tenter d’obtenir 90% d’utilisation du processeur.
Cette formule peut être utilisée pour déterminer la quantité de mémoire, pour atteindre un
taux d’efficacité donné, en fonction du type des processus.
Avec 1Mo de Mémoire et 200Ko SE, on peut loger quatre processus de 200Ko passant 80% de
leur temps en attente active avec un taux d’utilisation de 60%. À l’ajout d’un Mo on peut loger
neuf processus et avoir un taux d’utilisation de 87%.
Le modèle probabiliste n’est qu’une approximation car les processus en réalité ne sont pas
indépendants. Un modèle plus précis est fourni par les files d’attente.
La Multiprogrammation avec partitions fixes
Elle consiste à diviser la mémoire en partitions, de tailles inégales. Cela est réalisé par
l’opérateur lors du démarrage de la machine. Chaque nouvelle tâche est placée dans la file la
plus petite pouvant la contenir (l’espace restant étant perdu).
66
Figure 20: Partitions mémoire avec files d’attente
L’utilisation de files multiples pose problème lorsque les files de grandes partitions sont vides
et les autres sont pleines. Une alternative est d’utiliser une file unique, et quand une partition
se libère, la plus grande tâche qui peut y tenir est placée. Comme cette stratégie désavantage
les tâches de petites tailles, alors il faudrait théoriquement les traiter en priorité. On peut
imaginer d’autres algorithmes cherchant la première tâche pouvant tenir dans la partition et
pas dans les plus petites en relâchant cette dernière contrainte si aucune tâche n’est trouvée
lors de la première passe.
Translation et protection
La multiprogrammation soulève deux problèmes majeurs à savoir:
• La translation d’adresse: elle apparaît lorsqu’on ne connaît pas l’adresse du début

de programme lors de la phase d’édition des liens.
• La protection contre les tentatives d’accès de la part des autres processus.
La solution à la translation d’adresse consiste à conserver une table générée par l’éditeur de
liens conservant les positions de tous les mots mémoire qui sont des adresses. Lors de la prise
en charge d’un programme, l’adresse de base de la partition est ajoutée à toutes les adresses
déclarées.
Cependant cette solution ne résout pas le problème de protection. Une solution consiste à
subdiviser la mémoire en bloc, chacun affecté d’une clé de 4bits (PSW « Program Status Word
»). Ce mécanisme interdisait toute interaction entre processus différents.
Une solution générique aux deux problèmes consiste à doter le processeur de 2 registres
de base et de limite. Et quand on charge un processus en mémoire, le registre de base est
initialisé avec la limite inférieure de la partition et cette valeur est implicitement aux adresses
générées par le processeur, et comparée avec la limite supérieure et toute valeur hors
intervalle déclenche la levée d’exception.
67
Conclusion
Tout au long de cette activité, nous avons abordé la gestion de la mémoire sans va-et-vient.
Nous avons vu que cela est possible lorsque la mémoire physique est effectivement disponible.
Nous avons analysé cela dans le cas de la monoprogrammation, la multiprogrammation et la
multiprogrammation avec partitions fixes.
Exercice 1 :
Expliquer les différents cas de gestion de la mémoire sans va–et-vient.
Exercice 2 :
Un ordinateur possède suffisamment de mémoire pour contenir 4 programmes

en mémoire principale. Ces derniers sont bloqués en attente d’E/S la moitié du
temps. Quelle fraction du temps CPU est perdue ?
Exercice 3 :
Dans le système de partition mémoire avec file d’attente, nous avons vu comment
plusieurs processus peuvent s’exécuter en même temps et se terminer plus
rapidement que s’ils avaient été exécutés les uns après les autres. Supposons
que nous ayons deux tâches qui démarrent simultanément et qui requièrent
chacune 10 minutes de temps CPU. Combien de temps prendra la dernière pour
se terminer si elles sont exécutées l’une après l’autre ? Combien de temps si
elles sont exécutées en même temps. Faites l’hypothèse d’une attente d’entrée
sortie de 50%.
Rappel :
La mémoire d’un ordinateur est une ressource critique qui doit être gérée
avec grande attention. L’une de manière de gestion de la mémoire est le
cas qui ne permet pas l’échange de processus entre la mémoire et le disque
pendant l’exécution. Cela a été analysé pour la monoprogrammation et la
multiprogrammation.
Activité 3.2 : Le va-et-vient
Introduction
L’organisation de mémoire en partition fixe est efficace pour le traitement en lots, pourtant
dans les systèmes à temps partagé, la mémoire physique ne peut contenir tous les processus
des utilisateurs, il est donc nécessaire de placer sur le disque certains de ces processus, qu’il
faudra ramener en mémoire centrale afin de les exécuter. Le mouvement des processus entre
la mémoire centrale et le disque est appelé « swapping».
3.2.1 Multiprogrammation avec partitions variables
Le va-et-vient avec les partitions fixes conduit à un gaspillage de la mémoire. En effet la taille
68
des programmes peut être plus petite que celle des partitions qui les hébergent. D’où la
nécessité de la mise en œuvre d’un mécanisme de gestion de la mémoire avec les partitions
de taille variable. Avec un mécanisme de partitions à taille variable, le nombre, la position
et la taille des partitions varient au cours du temps, en fonction des processus présents à un
instant donné en mémoire centrale. Le schéma ci-dessus montre un exemple de la gestion
de la mémoire avec partition variables. L’allocation mémoire change au gré des processus
qui viennent en mémoire et qui la quittent. Les zones en jaunes indiquent que la mémoire est
inutilisée.
Figure 21: Gestion de la mémoire avec taille des partitions variables
On améliore ainsi l’utilisation de mémoire, cependant les mécanismes d’allocation et de

libération deviennent plus compliqués.
Un autre problème concerne la taille des partitions attribuées à chaque processus, car celle-ci
augmente avec le temps. Donc on alloue à chaque processus un espace légèrement plus
grand que sa taille actuelle, tant au chargement que lors des migrations à partir du disque.
Cela permet de réduire le temps système associé au processus déplacés ou chargés dont la
taille n’est pas appropriée à la mémoire qui lui est allouée. Cependant lorsque l’on transfère
des processus sur disque, seule la mémoire véritablement utilisée doit être recopiée. Il est
inutile de recopier aussi la mémoire supplémentaire. La figure ci-dessous présente une
configuration mémoire dans laquelle un espace destiné à l’accroissement a été attribué à deux
processus.
69
Figure 22: Processus avec un espace destiné à l’accroissement
On doit donc disposer d’un mécanisme spécifique pour mémoriser les zones mémoires libres
et occupées, minimiser l’espace perdu lors d’une allocation, et réduire autant que possible les
fragmentations. Ces mécanismes peuvent être de trois sortes:
• Gestion par table de bits;

• Gestion par listes chaînées;
• Gestion par subdivision.
Gestion de la mémoire par table de bits
La mémoire est subdivisée en unités d’allocation, dont la taille peut varier de quelques mots
à quelques kilo-octets. Chacune de ces unités est représentée par un bit dans une table
d’allocation possédée par le système, mémorisant l’occupation de la mémoire.
Figure 23: Mémoire avec 4 processus
La taille de l’unité d’allocation est un élément fondamental dans la configuration : plus l’unité
est petite, plus la table de bits est importante.
70
Cette approche présente deux inconvénients:
• Le choix de la taille de l’unité d’allocation: une taille trop petite imposera une
table plus grande, donc un temps d’opérations plus grands, alors qu’une taille
trop grande causera des pertes de place plus importantes dans la dernière unité
d’allocation « partiellement remplie ».
• La recherche de k bits libres dans la table, qui nécessite des manipulations
coûteuses sur des masques de bits.
Gestion de la mémoire par les listes chaînées
Cette technique consiste à gérer une liste chaînée de segments libres et occupés, dans
laquelle chaque segment est représenté par un bit d’état, son adresse de début, et
éventuellement sa taille, et qui est triée par adresses de début croissantes. La figure ci-contre
illustre la gestion de la mémoire par liste chainée.
Afin de conserver à la liste la plus courte taille possible, et de limiter la fragmentation, un

compactage est effectué à la libération de chaque segment: le nouveau bloc libre est fusionné
avec son prédécesseur et/ou son successeur si ceux-ci sont également libres. Il existe plusieurs
algorithmes réalisant l’allocation de segments :
• First fit (premier qui correspond) : Pour ce cas, la liste est parcourue jusqu’à ce
qu’on trouve un segment libre de taille suffisante pour contenir l’espace mémoire
demandé. S’il reste de l’espace libre dans le segment, la cellule correspondante
est scindée pour conserver la trace de cet espace.
• Best fit (qui correspond le mieux) : Pour cet algorithme, la liste est entièrement
parcourue, et on choisit le plus petit segment dont la taille est supérieure à celle
de la mémoire demandée. Ainsi on évite de fractionner une grande zone dont
on pourrait avoir besoin ultérieurement. Sa limite c’est qu’il fait perdre beaucoup
plus d’espace mémoire que le précédent en remplissant la mémoire avec de
petites zones libres.
• Worst fit (plus grand résidu) : cet algorithme est similaire au précédent, à la
différence qu’on cherche la plus grande zone possible, qui donnera le résidu le
plus utilisable possible. Cette stratégie risque de détruire les segments de taille
grande utilisables par des processus long.
• Quick fit : Pour accélérer les recherches, on peut scinder en deux les listes
de segments libres et occupés, et scinder la liste des segments libres afin de
disposer de listes séparés pour les tailles les plus courantes.
71
NB : Les algorithmes présentés mémorisent l’occupation de la mémoire centrale pour que le

système puisse trouver de la place. Et peuvent être utilisés par le système swap pour allouer la
place sur le disque.
Conclusion
Tous les processus ne pouvant être logés en mémoire, nous avons vu qu’il y a un moyen de
conserver certains processus sur disque et de les ramener en mémoire au moment voulu afin
de les exécuter. Ce mouvement des processus de la mémoire vers le disque et du disque vers
la mémoire est ce que nous avons appelé le va-et-vient. Cette gestion de la mémoire peut se
faire par partition, table de bits, liste chaînée
Exercice 1 :
Rappeler brièvement le principe du swapping.
Exercice 2 :
Expliquer les différents types de gestion de la mémoire dans le va-et-vient
Exercice 3 :
Caractériser les différents algorithmes d’allocation de segment.
Activité 3.La mémoire virtuelle
Introduction
Lorsque la taille d’un processus dépasse la taille de la mémoire physique disponible, on fait
recours au principe de la mémoire virtuelle. Le principe consiste à conserver en mémoire
centrale les parties utilisées des processus et stocker, si nécessaire, le reste sur disque.
La notion de mémoire virtuelle et de multiprogrammation se complètent: un processus en

attente d’une ressource n’est plus conservé en mémoire centrale, si cela s’avère nécessaire. La
Mémoire virtuelle fait appel à deux mécanismes à savoir : la pagination et segmentation.
La pagination
Pour ce cas, l’espace d’adressage d’un processus est divisé en petites unités de taille fixe
appelées pages. La Mémoire Centrale (MC) est elle aussi découpée en unités physique de
même taille appelées cadres. Les échanges entre MC et disques ne portes que sur des pages
entières. Ainsi l’espace d’adressage est illimité, et on parle d’adressage virtuel. Le schéma
ci-dessous illustre la traduction des adresses virtuelles manipulées par les processus en
adresses légales dans la mémoire physique en gérant les discontinuités.
72
Figure 24: schéma d’adressage virtuel
Le principal problème de la mémoire virtuelle est que les parties immédiatement utiles à
l’avancement d’un processus sont disjointes en MC (Mémoire Centrale). Un mécanisme
efficace de mémoire virtuelle doit donc pouvoir effectuer la traduction des adresses virtuelles
manipulées par le processus en adresses légales dans la mémoire physique.
Dans un SE sans mémoire virtuelle, la machine calcule les adresses physiques en ajoutant
le contenu d’un registre de base aux adresses relatives contenues dans les instructions du
processus. Dans un SE à pagination, un sous-ensemble inséré entre l’UC et la MC, la MMU
(Memory Management Unit ou unité de gestion de la mémoire) traduit les adresses virtuelles
en adresses physiques.
Figure 25: Unité de gestion de la mémoire
La MMU mémorise :
• les cadres physiques alloués à des processus (sous forme d’une table de bits de
présence)
• les cadres mémoire alloués à chaque page d’un processus (sous forme d’une
table des pages)
On dira qu’une page est mappée ou chargée si elle est physiquement présente en mémoire.
Une représentation de l’espace virtuel et de l’espace physique est présentée ci-dessous.
73
Figure 26: Espace virtuel et espace physique
L’adressage virtuel est divisé en pages de taille 2n octets, la MMU dispose d’une table
d’indirection pour convertir les adresses virtuelle en adresses physiques. Les pages non
mappées sont identifiées par un bit de présence. L’indexation de la table en décomposant
l’adresse virtuelle en un numéro de page « page index » et un déplacement « offset » dans
la page. L’index de page sert à adresse la table des pages, qui fournit le numéro de page
physique remplaçant l’index de page dans l’adresse physique, comme le montre l’exemple
ci-dessous.
Figure 27: Opérations du MMU
74
Dans cet exemple, les pages ont une taille de 4Ko. L’adresse virtuelle 12292= (1024*12)
+4. C’est-à-dire qu’elle correspond à un déplacement de 4octets dans la page virtuelle 3,
correspondant à son tour à la page physique 2. Donc l’adresse physique correspond à un
déplacement de 4 octets dans la page physique 2 soit: (8*1024) +4=8196.
La page virtuelle 2 n’est pas mappée. Donc toute adresse virtuelle comprise entre 8192 et
12287, donnera lieu à un défaut de page. L’accès à une adresse virtuelle correspondant à une
page non mappée donne lieu à un défaut de page.
En cas de défaut de page, un déroutement se produit «Trap », et le processeur est rendu au SE.
Le SE doit alors effectuer les opérations suivantes:
• Déterminer la page à charger;

• Déterminer la page à décharger sur le disque pour libérer un cadre;
• Lire sur le disque la page à charger;
• Modifier la table de bits et la table de pages.
Ainsi avec un espace d’adressage de 232 octets, et des pages de 212 octet (4kO), on doit avoir
220 entrées. C’est-à-dire que la table doit faire 1MO. Pour réduire la mémoire utilisée par la
table des pages, et éviter de coder des espaces vides, on lui applique son propre principe,
en créant une table à deux niveaux d’indirections : la partie haute de l’adresse permet de
déterminer la table des pages devant être utilisée, qui est elle-même accédée au moyen de la
partie médiane de l’adresse afin de déterminer le numéro de la page physique utilisée.
Figure 28: Espace d’adressage avec table à deux indirections
Ainsi avec un 1er niveau indexé sur 10bits, et un 2ème niveau également sur 10 bits on réduit
la mémoire occupée par la table des pages pour les petits programmes.Cette solution a pour
limite de générer un surcoût marginal pour les gros programmes.
75
La Segmentation
Pour ce cas, l’espace d’adressage d’un processus est divisé en segments, générés à la
compilation. Chaque segment est repéré par son numéro S et sa longueur variable L. Un
segment est un ensemble d’adresses virtuelles contiguës. Une adresse n’est plus donnée de
façon absolue, par rapport à l’adressage virtuel, l’adresse est représenté par le couple (S, d),
où S est le numéro de segment et d le déplacement dans le segment (d є [0, L [ ).
Comme le montre la figure-ci-dessous, on utilise une table de segments pour calculer l’adresse
physique.
Figure 29: Calcul de l’adresse physique via la table de segments
Avec :
B: adresse de base (adresse physique de début de segment);
L: longueur du segment limite
p: protection du segment
Algorithmes de remplacement des pages
A la suite d’un défaut de page, le système d’exploitation doit ramener en mémoire la page
manquante à partir du disque. S’il n’y a pas de cadres libres en mémoire, il doit retirer une
page de la mémoire pour la remplacer par celle demandée. Si la page à retirer a été modifiée
depuis son chargement en mémoire, il faut la réécrire sur le disque. Quelle est la page à retirer
de manière à minimiser le nombre de défauts de page ?
76
Le choix de la page à remplacer peut se limiter aux pages du processus qui ont provoqué le
défaut de page (allocation locale) ou à l’ensemble des pages en mémoire (allocation globale).
Les différentes méthodes à utiliser reposent sur 3 stratégies:
• Une stratégie de chargement;

• Une stratégie de placement;
• Une stratégie de remplacement destinés à libérer certains cadres;
Les stratégies de placement sont dépendantes des stratégies de remplacement : on charge

nécessairement une page dans le cadre qui vient d’être libéré.
On distingue deux catégories de méthodes:
• Pagination anticipée: on charge les pages à l’avance;

• Pagination à la demande: le chargement n’a lieu qu’en cas de défaut de page et
on ne charge que la page manquante.
On appelle suite de références w=p_1 p_2….p_n une suite de numéros de pages

correspondant à des accès à ces pages. On dira qu’un algorithme A de pagination sur m
cadres est stable si:
∀m,∀w,on a:Coût (A,M,W)≤Coût(A,m+1,w).
L’algorithme optimal de remplacement de pages
Avec le remplacement de pages optimal le SE indexe chaque page par le nombre

d’instructions qui seront exécutées avant qu’elles ne soient référencée.
Cet algorithme est trop difficile à appliquer. La grande difficulté est de savoir comment calculer
les indices des pages? Il reviendrait, chaque fois qu’une page est accédée, à la marquer avec
un compteur indiquant à quel moment cette page sera ré-accédée de nouveau.
L’algorithme de remplacement de la page non récemment utilisée (NRU : Not

Recently Used)
Le SE référence chaque page par deux bits R(le plus à gauche) et M initialisés à 0. A chaque
accès en lecture à une page R est mis à 1. Et à chaque accès en écriture, M est mis à 1, et à
chaque interruption d’horloge, le SE remet R à 0.
Les bits R-M forment le code index. En cas de défaut de page, on retire une page au hasard
dans la catégorie non vide de plus petit index.
Ainsi on retire préférentiellement une page modifiée non référencée (index 1) qu’une page très
utilisée en consultation (index 2).
77
Chaque page est caractérisé par les valeurs de bits R et M:
Index Etat de la page
0( Page non accédée et non modifiée
1( Page non accédée mais modifiée: se produit quand le bit R
2 (R déjà modifiée est remis à 0 par la routine d’interruption.
Page accédée mais non modifiée
3(RM) Page accédée et modifiée
Tableau 12: Différentes valeurs des bits R et M
L’algorithme de remplacement de la page premier entré premier servi (FIFO :

First In First Out)
Pour cet algorithme le SE indexe chaque page par sa date de chargement et constitue une
liste chaînée, la 1ère page de la liste étant la plus anciennement chargée, et la dernière la
plus récemment chargée.Cet algorithme n’est pas stable. En effet quand le nombre de cadres
augmente, le nombre de défauts de page ne diminue pas (anomalie de BELADY).
La première amélioration consiste à examiner les bits R et M (algorithme de NRU) de la

page la plus ancienne en MC (en tête de la liste). Si cette page est de catégorie 0, il l’ôte.
Sinon, il teste la page un peu moins ancienne, etc... S’il n’y a aucune page de catégorie 0, il
recommence avec la catégorie 1, puis éventuellement avec les catégories 2 et 3.Une autre
amélioration est l’algorithme de la seconde chance.
L’algorithme de remplacement de page de la seconde chance
Pour l’algorithme de la seconde chance, R et M sont gérés comme en NRU. Le SE examine le

bit R de la page la plus ancienne (tête de la liste). Si R = 0, la page est remplacée, sinon R est
mis à 0, la page est placée en fin de liste et on recommence avec la nouvelle page en tête. Si
toutes les pages ont été référencées depuis la dernière RAZ, on revient à FIFO, mais avec un
surcoût.
L’algorithme Least Recently Use (LRU)
Avec le LRU, le SE retire la page la moins récemment référencée. Pour cela, il indexe chaque
page par le temps écoulé depuis sa dernière référence et il constitue une liste chaînée des
pages par ordre décroissant de temps depuis la dernière référence. Cet algorithme est stable
mais nécessite une gestion coûteuse de la liste qui est modifiée à chaque accès à une page.
Conclusion
Même si l’espace mémoire centrale est aujourd’hui une ressource moins critique qu’il y a
quelques années, les mémoires virtuelles constituent à la fois une abstraction et un mécanisme
fondamental dans la gestion de la mémoire. Dans cette activité d’apprentissage, nous
avons fait un aperçu plus ou moins complet des problèmes de gestion de la mémoire et des
algorithmes les plus utilisés dans la gestion de la mémoire.
78
Évaluation de l’unité :
Exercice 1 :
• Parler de la pagination, de la permutation, du recouvrement.

• Illustrer la pagination par des schémas.
• Qu’est-ce qu’une mémoire paginée ?
Exercice 2 :
Etant donné un système disposant de 4 cadres de mémoire physique occupées à un

instant donné ayant des pages mémoires virtuelles.
Ci-dessous, le tableau ci-dessous récapitule pour chaque cadre le temps de chargement,

le temps (en top horloge) du dernier accès à la page ainsi que l’état des bits : Référence,
Modifié et Présence
Cadre Tc Tda R M P
0 126 270 0 0 1
1 230 255 1 0 1
2 110 260 1 1 1
3 180 275 1 1 1
1) En cas de défaut de page, quelle est celle qui sera remplacée en fonction de
l’algorithme suivant :
a. LRU
b. FIFO
c. FINUFO
d. NRU
79
2) Du système précèdent, mais avec pagination à la demande, soient les données

suivantes:
• Accès à une page chargée en mémoire : 100 ns

• Accès à une page non chargée : 10 ms (quand il y a l’existence d’une case libre
en mémoire physique, ou s’il y a une page à retirer afin de faire place à la page
manquante). Au cas où la page à retirer a été modifiée le temps d’accès est de
20ms.
• Taux de défaut de page : 35%.
NB : A 70% de cas la page à retirer a été modifiée.
Calculez le temps d’accès moyen à la mémoire.
Dans cette unité d’apprentissage, nous avons examiné la gestion de la mémoire. Les systèmes
les plus simples n’effectuent pas de va-et-vient ni de pagination. Certains systèmes supportent
la multiprogrammation d’autres non.
Avec le va-et-vient le système peut gérer plus de processus qu’il n’a pas de mémoire.
Les mémoires virtuelles constituent à la fois une abstraction et un mécanisme fondamental

dans la gestion de la mémoire. Au cours de cette unité d’apprentissage, nous avons fait
un aperçu plus ou moins complet des problèmes de gestion de la mémoire ainsi que des
algorithmes couramment utilisés.

1. Un défaut de page arrive si :
a. Il y a interblocage
b. Débute la segmentation
c. La page n’est pas trouvée en mémoire
d. Aucune réponse n’est vraie
2. Le va-et-vient est un système de gestion de la mémoire où :
a. Le processus chargé reste en mémoire aussi longtemps qu’il en a besoin
b. Le processus en mémoire est interrompu pour laisser la place à celui qui se

trouve en-tête de la file d’attente
c. Les processus ayant un temps d’exécution long sont arrêtés pour laisser la
place à ceux ayant un temps d’exécution court.
d. Toutes les réponses sont correctes
e. Aucune réponse n’est vraie
80
3. Amener un processus de la mémoire vers l’espace disque afin d’obtenir la

place pour les autres processus s’appelle :
a. Swapping
b. Pagination à la demande
c. Défaut de page
d. Aucune réponse n’est vraie
4. L’algorithme de remplacement optimal de la page consiste :
a. La page ayant étiquette est la plus grande est enlevée de la mémoire
b. Toutes les pages sont enlevées de la mémoire
c. La page la moins récemment utilisée est enlevée de la mémoire.
B. Question de résumé
Pourquoi faut-il effectuer la gestion de la mémoire ?
Quelle est le composant qui est chargé de la gestion de la mémoire
Expliquer brièvement son fonctionnement
Rétroaction

points
Quotation
• ’évaluation des activités compte pour 60% tandis que celle de l’unité
d’apprentissage compte pour 40%.
• L’unité d’apprentissage compte pour 20% du module
81

373-385.
http://www.groupes.polymtl.ca/inf2610/documentation/notes/chap10.pdf
http://stic-os.webs.com/Support_Cours/OS-Gestion-memoire.pdf
Understanding the Linux® Virtual Memory Manager
82
Unité 4. Gestion des périphérique et système de fichiers
Unité 4. Gestion des périphérique et

système de fichiers
Introduction
Un ordinateur est composé de deux grandes parties à savoir l’unité centrale et les
périphériques.
La gestion de ces périphériques est une tâche importante qui doit être bien faite afin de mieux
utiliser la machine. Il en va de soi que cette tâche incombe à la machine même.
Un fichier, quant à lui, est ensemble d’informations regroupées en vue de leur conservation
et de leur utilisation dans un Système informatique. Le stockage persistant des données,
l’accès rapide à ces dernières, est un des critères déterminant de l’efficacité d’un système
d’exploitation. Les fichiers résident en dehors de l’espace d’adressage des processus. Il
existe un logiciel de gestion de fichiers appelé gestionnaire de fichier. Celui-ci fournit une
interface graphique d’exploiter ces fichiers. Ses principales fonctionnalités sont: la création,
l’ouverture, la visualisation, l’impression, la lecture, le renommage, le déplacement, la copie, la
suppression, la consultation des propriétés des fichiers et la recherche de fichiers.
La partie du SE qui gère les fichiers est connue sous le nom de système de fichiers (file system).
Dans cette unité d’apprentissage, nous allons aborder la gestion des périphériques et
l’interface utilisateur des fichiers et des répertoires.
Objectifs
A la fin de cette unité l’apprenant devra être en mesure de:
• Démontrer une bonne connaissance du système de fichier;

• Expliquer l’organisation logique de fichiers;
• Distinguer les fichiers des répertoires;
• Expliquer la manière dont le système de fichier est implémenté
83
Mots-clés
Périphérique : Un périphérique est tout élément matériel connecté à
l’ordinateur
Fichier : Un fichier est un conteneur d’information
Extension : L’extension spécifie le type d’un fichier (ex : .doc pour un

fichier Word). Il est formé d’un point suivi de trois lettres
Accès : L’accès à un fichier spécifie l’accès à un fichier. Par exemple en

écriture seule, en lecture seul ou en lecture/écriture
Système de fichiers : C’est la partie du SE qui gère les fichiers
Activité 1. Gestion des périphériques
Introduction
Les périphériques désignent tout élément matériel connecté à un ordinateur. On distingue

les périphériques d’E/S. Ces périphériques peuvent être subdivisés en deux grandes
catégories du point de vues des informations manipulées : les périphériques par blocs et les
périphériques par caractères ou alphanumériques. Les périphériques présentent des vitesses
de fonctionnement et des débits de transfert de données différents, d’où une pression
considérable sur le logiciel qui doit gérer correctement une grande variété de périphériques.
La problématique de gestion de ces périphériques sera abordée dans cette activité
d’apprentissage.
Périphériques, Contrôleur et Pilotes

Les périphériques sont souvent complexes à utiliser (vitesse de rotation, position des
têtes, gestion de l’espacement entre secteurs, . . .). Les détails exacts sont en plus souvent
dépendant du modèle et du fabriquant.
Afin de pallier à ces problèmes, il y a en général trois niveaux pour la gestion d’un
périphérique :
• Le périphérique lui-même (par exemple, un disque dur), qui effectue son

traitement et reconnaît un protocole d’assez bas niveau (par exemple, mettre en
marche le moteur, déplacer la tête de trois pistes).
• Le contrôleur, souvent sous forme d’une carte d’extension, parfois intégré
directement dans le périphérique, qui reconnaît un protocole de niveau
légèrement plus élevé (par exemple, lire le secteur numéro 4 de la piste numéro
3).
• Le pilote de périphérique, dans le système d’exploitation, qui lui reconnaît un
protocole de niveau encore plus élevé (par exemple, lire le secteur numéro 124
, sans se soucier de la géométrie du disque, ni du fait qu’il s’agisse d’un disque
dur ou d’une clé USB).
84
Le découpage exact peut varier, et il y a parfois deux contrôleurs, un intégré au périphérique

et un externe (par exemple dans le cas des disques durs, il y a un contrôleur IDE/SATA/SCSI
dans la carte mère ou en carte d’extension, et un contrôleur à l’intérieur même du disque, les
deux étant de niveau différent).
Types de périphériques
L’interaction avec un périphérique (sauf exceptions) consiste à envoyer ou recevoir des
données, souvent accompagnées de métadonnées (position dans le disque, fréquence
d’échantillonnage, . . .).
Les périphériques sont en général classifiés en deux catégories, suivant le type d’accès à ces
données.
Les périphériques de flux
La première classe de périphériques fonctionne en mode d’un flux de données. Par exemple,
un clavier envoie des données à chaque touche enfoncée/relâchée. Une souris à chaque
mouvement ou clic. Une carte son va recevoir des données en mode flux pour jouer du son, et
émettre des données en mode flux lorsqu’on enregistre depuis un micro.
Les périphériques en mode flux sont souvent appelés des character device. Ils ne supportent
pas d’opérations de positionnement (on ne peut pas demander à un clavier la touche enfoncée
il y a 10 secondes).
Ces périphériques possèdent en général un tampon (interne, dans le contrôleur et/ou dans
le système d’exploitation) permettant de conserver une quantité limitée d’informations avant
qu’elle ne soit traitée.
Si le système d’exploitation n’arrive pas à traiter les données suffisamment rapidement, une
fois le tampon plein, des données peuvent être perdues si le périphérique est un périphérique
d’entrée, ou alors des conséquences néfastes pourront lieu (son saccadé, par exemple) si le
périphérique est un périphérique de sortie.
Les périphériques de stockage
La deuxième classe de périphérique fonctionne sous la forme d’une zone de données, divisée
en blocs, qui peuvent être accédés de manière arbitraire.
Ces périphériques reconnaissent eux des opérations de positionnement, soit relatives (par
exemple pour une bande magnétique, avancer ou reculer d’un certain nombre de blocs), soit
absolues (le plus fréquent).
L’existence d’un tampon n’est pas nécessaire pour ces périphériques là, mais reste fréquente
pour des raisons de performances.
85
Les autres périphériques
Certains périphériques ne rentrent pas totalement dans ces deux catégories (qui, comme toute
catégorisation, est imparfaite). Voici quelques exemples :
• Les horloges, dont le fonctionnement sera détaillé plus loin ;

• Les écrans, qui sont hybrides entre le mode bloc et le mode flux : une image est
gérée en mode bloc, mais une succession d’images constitue un flux ;
• Un graveur de CD/DVD, qui, lorsqu’il écrit, s’apparente plus au fonctionnement
en mode flux, alors qu’en lecture il fonctionne en mode bloc.
PIO, MMIO et DMA

La deuxième grande question sur la gestion des périphériques est la technique utilisée pour
transférer les données entre le périphérique et le reste du système. Trois modes sont utilisés.
Le mode PIO
Le mode le plus simple et le plus ancien est le mode PIO (Programmed IO). Ce mode consiste
à lire (ou écrire) les données mot par mot (un mot étant une quantité de données manipulable
en une seule opération, en général de 8 à 64 bits, donc de 1 à 8 octets), avec une instruction
assembleur spéciale.
Ce mode est le plus simple à gérer pour le matériel. Cependant, il est très peu flexible, pour
plusieurs raisons :
• Une instruction assembleur spécifique doit être utilisée, ce qui interdit l’écriture
du code dans un langage de plus haut niveau, et nuit à la portabilité ;
• Le transfert de données est intégralement géré par le CPU, ce qui pour des
débits importants peut coûter très cher ;
• La latence peut être importante, puisque si le CPU est occupé par un autre
processus, le transfert n’aura pas lieu.
• Le mode MMIO
Le mode MMIO (Memory Mapped IO) est une évolution du mode PIO. Il consiste à utiliser
une zone de mémoire spéciale pour effectuer la communication entre les applications (ou le
système d’exploitation) et les périphériques.
En général, seul le noyau accède à ces zones de mémoires spéciales, mais la présence de la
mémoire virtuelle permet d’attribuer sélectivement des droits sur ces zones de mémoires à des
applications si nécessaire.
Lorsqu’une lecture ou écriture est faite sur ces zones de mémoire spéciale, les instructions de
lecture/écriture ne sont pas envoyées sur le bus mémoire, mais sur le bus du périphérique. Ce
sont les bridges de la carte mère qui gèrent cette bascule.
86
L’avantage principal de ce mode de transfert est qu’il ne nécessite aucune instruction spéciale,
et permet d’utiliser toutes les fonctions des langages de plus haut niveau.Par contre, c’est
toujours le CPU qui effectue le transfert, mot par mot, avec un coût qui peut être important sur
un transfert avec un débit élevé. Le problème de latence n’est toujours pas résolu.
Le DMA
Enfin de palier au problème de coût CPU et de latence, une technique nommée DMA (Direct
Memory Acess) a été inventée. Lorsque l’on communique avec un périphérique via le DMA,
on réserve une zone de mémoire vive pour le transfert. On signale alors à une puce spéciale,
le contrôleur DMA, que l’on souhaite initier un transfert entre cette zone mémoire et un
périphérique, ainsi que le sens du transfert. C’est le contrôleur DMA qui va alors transférer
les données, à la vitesse requise pour le périphérique, et ceci sans intervention du CPU.Le
contrôleur DMA est capable de gérer plusieurs transferts en parallèle, un par canal DMA (16
par exemple). Par contre, un seul mot peut circuler sur le bus au même moment, bien sûr.
Afin d’éviter les problèmes de données non synchronisées, les cache L1 et L2 doivent être
désactivés sur les zones mémoires concernées (en général possible avec une granularité d’une
page, sur les MMUs modernes).Une variante du DMA, utilisée sur le bus PCI, se nomme le
bus master, et permet d’effectuer des transferts de type DMA sans contrôleur DMA. La carte
PCI demande le contrôle du bus, et peut alors envoyer des requêtes au pont sud qui va les
transférer à la mémoire centrale.
Les interruptions
Les boucles d’attente
Maintenant que nous savons transférer des données vers ou depuis un périphérique, il reste
un certain nombre de questions : comment savoir qu’un périphérique est prêt à recevoir
des données ? Qu’il y a des données disponibles pour la lecture ? Qu’un transfert DMA est
terminé?
Pour répondre à ces questions, la première solution est de faire une boucle d’attente : on teste
régulièrement si des données sont disponibles, si le périphérique est près, si le transfert DMA
est terminé. Si la condition n’est pas remplie, on réessaie plus tard, jusqu’à ce qu’elle le soit.
La fréquence des tests va bien sûr dépendre du type de périphérique (élevée pour une carte
réseau, faible pour un clavier, par exemple).Mais ces tests réguliers peuvent finir par coûter
cher en terme de CPU utilisé, surtout quand le nombre de périphériques à surveiller est élevé
(cartes réseaux, disques, périphériques multimédias, périphériques d’entrée,
. . .) et la fréquence de vérification élevée.
De plus, dans le cadre d’un système multiprogrammé, ce test n’est de plus possible que quand
le CPU est actuellement attribué à l’application qui utilise le périphérique, ou au noyau pour
un pilote présent dans le noyau, ce qui peut introduire des latences élevées.
87
Le principe des interruptions
Pour pallier à ces deux problèmes, le mécanisme d’interruptions a été inventé. Il permet
au matériel d’interrompre la tâche en cours d’exécution pour donner le CPU au pilote de
périphérique correspondant, lorsque l’une de ces conditions est remplie.Le principe théorique
a déjà été étudié dans le cadre des processus et des threads : il s’agit de sauvegarde la
valeur des registres spéciaux du processeur (comme le pointeur de l’instruction en cours),
puis d’effectuer un saut sur un point d’entrée du système d’exploitation (le noyau en général).
Celui-ci se charge de sauvegarder le reste des registres, et peut alors effectuer son traitement,
puis rendre la main au processus interrompu.
La configuration des points d’entrée (adresses à l’intérieur du système d’exploitation) des

différentes interruptions possibles se fait dans une table spécifique, présente en mémoire,
nommée l’IDT (Interrupt Descriptors Table), de manière analogue aux tables de segments ou
de pages (mais en général de petite taille).
IRQ, interruptions logicielles et NMI
Le premier type d’interruptions, dont nous avons déjà parlé rapidement, sont les interruptions
logicielles. Elles sont émises volontairement par le programme, par exemple pour faire un
appel système. Elles ne nous intéressent pas dans notre cas.Le deuxième type d’interruptions,
qui est le plus répandu dans la gestion des périphériques, est l’IRQ. Un contrôleur spécifique
est présent sur la carte mère, et peut recevoir de la part des périphériques une demande
d’interruption (Interrupt Request, IRQ en anglais), avec un numéro (de 0 à 15 par exemple). Le
contrôleur va alors mémoriser la demande, et la signaler au CPU, via une patte spécialement
dédiée.
Si le CPU est disponible, il va passer le contrôle au gestionnaire d’interruption préalablement

enregistré pour cette IRQ. S’il ne l’est pas, l’interruption est mémorisée par le contrôleur d’IRQ,
qui réessaiera régulièrement jusqu’à ce que le CPU soit disponible. Si plusieurs IRQ arrivent
alors que le CPU est occupé, le contrôleur les transmettra dans un ordre fixe, en général les
IRQs de numéro le plus bas sont prioritaires. En effet, le système d’exploitation peut désactiver
(temporairement) les IRQ, pour éviter qu’un traitement critique ne soit interrompu.
Le troisième type d’interruption est la NMI, pour Non Masquable Interrupt. Ce type
d’interruption, en général émis par le CPU lui-même ou des composants très proches (la MMU
par exemple) ne peut pas être désactivé. Il correspond le plus souvent à des erreurs, qui
doivent impérativement être traitées (erreurs de protection dans la mémoire virtuelle, division
par zéro, . . .).Une erreur survenant pendant le traitement d’une interruption est nommée
un double fault, et une erreur survenant durant le traitement de cette erreur-là, le triple
fault. Il provoque en général un arrêt ou un redémarrage de la machine. Ils sont cependant
extrêmement rares.
Conclusion
Les périphériques désignent tout élément matériel connecté à un ordinateur. On distingue les
périphériques d’E/S. Au cours de cette activité différentes catégories de périphériques ont été
abordés, ainsi que la technique utilisée pour transférer les données entre le périphérique et le
reste du système et la notion d’interruption.
88
Évaluation de l’activité
Question 1 :
Que comprenez-vous par le terme périphérique ?
Question 2 :
Combien de catégorie de périphérique existent ? Donner deux exemples pour

chaque catégorie.
Question 3 :
Peut-on désactiver un périphérique donné (par exemple une imprimante) ?
Question 4:
Décrire le rôle du gestionnaire de périphérique
Activité 2. Le Système de fichiers
Introduction
La notion de fichier est l’abstraction fondamentale introduite dans les systèmes d’exploitation
pour gérer les données des utilisateurs acquises ou produites via les divers périphériques
connectés : disques, écran/clavier, imprimantes, scanners, modems, etc.
La gestion de ces données comporte deux aspects complémentaires :
• un aspect communication : les données doivent être échangées entre la mémoire

centrale où réside le programme en cours d’exécution et les ressources externes
ou périphériques qui permettent d’obtenir ou de produire des données ;
• un aspect mémorisation, conservation : les données échangées « appartiennent
» à différents usagers qui souhaitent pouvoir retrouver leurs données dans le
temps. Cette permanence, rémanence des données par rapport à la durée
des traitements (c’est-à-dire des processus) et leur protection contre des accès
erronés accidentels ou/et malveillants constituent des éléments essentiels dans la
gestion des fichiers.
Tout au long de cette unité d’apprentissage, nous allons étudier, du point de vue d’un
utilisateur, l’utilisation et les propriétés des fichiers.
Les fichiers
Un fichier possède un nom qui permet de l’identifier de manière unique. C’est à dire que l’on
ne peut pas avoir deux fichiers de même nom dans un même emplacement. Le nom de fichier
est composé de deux parties (un nom et une extension).
89
Exemples:
nomfic.c: fichier source d’un programme en C
nomfic.xls: fichier excel
nomfic.html: fichier document en langage html (HyperText Markup Language) pour internet
Un fichier est rangé sur un support permanent (DD, CD ou DVD, clé USB, etc.). Selon les
systèmes, on distingue différentes organisations de données dans les fichiers:
• une suite d’octets: conceptuellement la plus simple, c’est l’organisation adoptée

par de nombreux systèmes;
• des suites d’enregistrements: les fichiers sont structurés en enregistrement
de taille fixe. Ceux-ci ne peuvent être lus ou écrits qu’en totalité avec aucune
possibilité d’insertion au milieu.
• un arbre d’enregistrement de taille variable: les fichiers sont organisés en
enregistrement de taille variable, indexés chacun par une clé et groupés par
blocs de façon hiérarchique.
Les types de fichiers
La plus part de SE supportent plusieurs types de fichiers. Par exemple Unix et Windows
ont des fichiers ordinaires (contiennent les informations des utilisateurs) et des répertoires
(fichiers systèmes qui conservent la structure du système de fichiers). Unix possède également
des fichiers spéciaux caractère et bloc. Les fichiers spéciaux caractère sont liés aux E/S et
permettent de modéliser les périphériques d’E/S série tels que les terminaux, les imprimantes
et les réseaux. Les fichiers spéciaux bloc quant à eux servent à modéliser les disques.
Les accès aux fichiers
Les premiers SE ne proposaient que l’accès séquentiel. Dans ces systèmes un processus
pouvait lire tous les octets ou tous les enregistrements du début à la fin. La lecture en désordre
était impossible. Pour ce type d’accès on utilisait les bandes magnétiques comme support de
stockage.Avec l’apparition de disque, il est devenu possible de lire les données des fichiers
dans n’importe quel ordre. Ce genre de fichiers s’appellent des fichiers à accès aléatoire et
sont nécessaires à de nombreuses applications. Ces fichiers sont indispensables aux bases de
données.
Exemple: La réservation d’une place sur un vol donné doit se faire sans parcourir des milliers
d’enregistrement contenant d’autres vols.
Deux méthodes sont employées pour spécifier le début de la lecture. Dans la première,
chaque lecture donne la position dans le fichier pour démarrer la lecture. Dans la seconde,
une opération particulière, seek, permet de se placer à un endroit donné. De là, le fichier peut
être lu de manière séquentielle.Dans certains anciens SE de grands ordinateur, les fichiers
sont classés en deux catégories (fichiers séquentiels ou fichiers à accès aléatoires) lors de leur
création. Cela permet aux SE de se servir de méthodes de stockages différentes pour les deux
catégories. Pour les SE modernes tous les fichiers sont automatiquement à accès aléatoire.
90
Les attributs des fichiers
Chaque fichier possède un nom et des données. A chaque fichier, les SE associent des
informations complémentaires comme l’heure, la date de création du fichier et sa taille. Ce
genre d’information est appelé attribut du fichier et leur liste varie d’un SE à un autre.
Ci-dessous, nous dressons un tableau récapitulatif des attributs d’un fichier.
Attributs Signification
Protection Qui peut accéder au fichier et de quelle manière
Mot de passe Mot de passe nécessaire pour accéder au fichier
Créateur Créateur du fichier
Propriétaire Propriétaire actuel du fichier
Indicateur 0 pour la Lecture/Ecriture, 1 pour la lecture seule

lecture seule
Indicateur fichier 0 pour un fichier normal, 1 pour un fichier caché

caché
Indicateur fichier 0 pour un fichier normal, 1 pour un fichier système

système
Indicateur fichier 0 pour si le fichier a été archivé, 1 s’il doit être archivé
d’archivage
Indicateur fichier 0 pour un fichier ASCII, 1 pour un fichier binaire

ASCII/binaire
Indicateur fichier 0 pour un accès séquentiel, 1 pour un accès aléatoire

accès aléatoire
Indicateur fichier 0 pour un fichier normal, 1 pour supprimer le fichier lorsque le

temporaire processus se termine
Indicateur de 0 pour un fichier non verrouillé, 1 pour un fichier verrouillé

verrouillage
Longueur Nombre d’octets dans l’enregistrement

d’enregistrement
Position de la Position de la clé dans chaque enregistrement

clé
Longueur de la Nombre d’octets du champ clé

clé
Date de création Date et heure de création du fichier
91
Date du dernier Date et heure du dernier accès au fichier

accès
Date de Date et heure de la dernière modification

modification
Taille courante Nombre d’octets du fichier
Taille maximale Taille maximale autorisé pour le fichier
Tableau 13: Quelques attributs des fichiers
Les opérations sur les fichiers
Les fichiers servent de stockage de données et à les retrouver plus tard. Les SE permettent
différentes opérations pour réaliser le stockage et la recherche. Ci-dessus nous présentons les
principaux appels système relatifs aux fichiers:
• Create: crée un fichier vide. Cet appel permet de créer un fichier et de fixer un
certain nombre de paramètres
• Delete: Permet de supprimer un fichier et de libérer l’espace disque
• open: Avant d’utiliser le fichier un processus doit l’ouvrir. Cet appel permet au
système de charger les attributs et la liste des adresses du fichier sur le disque
afin d’accélérer les accès ultérieurs
• Close: Quand tous les accès au fichier sont terminés, les attributs et les adresses
du fichier ne sont plus nécessaires. Le fichier peut alors être fermé pour libérer de
l’espace dans les tables internes.
• Read: Permet de lire les données à partir du fichier. Généralement, les octets
proviennent de la position courante. L’appelant doit préciser le nombre d’octets
demandés et prévoir une mémoire tampon de lecture.
• Write: Permet d’écrire les données dans un fichier à partir de la position courante.
Si cette dernière est la fin du fichier, la taille de celui-ci augmente. Par contre si la
position courante est le milieu du fichier, les données existantes sont remplacées
et perdues définitivement.
• Append: C’est un appel de write restreint. Il permet d’ajouter les données à la fin
du fichier.
• Seek: Il permet de positionner le pointeur de fichier à un endroit précis de
celui-ci. Il est utilisé dans les fichiers à accès aléatoire. Après l’exécution de cet
appel, les données sont lues ou écrites à partir de cette position.
• Get attributes: Les processus doivent souvent lire les attributs des fichiers pour
effectuer certaines opérations. Par exemple le programme make d’UNIX sert à
gérer des développements de logiciels informatiques constitués de plusieurs
fichiers sources. Quand le programme make est appelé, il examine les dates de
modification de tous les fichiers sources et de tous les fichiers objet, et il réalise
le minimum de compilation requise pour mettre à jour tous les fichiers. Pour
accomplir cette tâche, il doit garder les attributs des fichiers, plus précisément
leur date de modification.
92
• Set attributes: Cet appel permet de modifier les attributs des fichiers par les
utilisateurs
• Rename: Cet appel permet à un utilisateur de renommer un fichier
Les répertoires
Du point de vue du système de fichiers, un répertoire est traité comme un fichier dont le
contenu est la liste des fichiers référencés. Un répertoire a donc les mêmes types de propriétés
qu’un fichier comme le nom, la taille, la date, les droits d’accès et les divers autres attributs.
Chaque fichier ou répertoire est référencé par un autre répertoire, ce qui forme une hiérarchie
cohérente, appelée aussi arborescence, dont le point d’entrée est le répertoire racine. La
racine est unique sur un système de type UNIX, ou sur une partition Windows (par exemple C:).
Les conventions de nommage varient d’un système d’exploitation à l’autre. On utilise un

caractère spécifique pour séparer les répertoires. Néanmoins on distingue en pratique :
• les systèmes dérivés ou issus de MS-DOS (Windows, OS/2 et les systèmes DOS
alternatifs) qui utilisent l’antislash
• les systèmes dérivés de Unix (et Internet) qui utilisent le slash
On distingue principalement des systèmes à un seul niveau de répertoire, à deux niveaux de

répertoires, et des systèmes à répertoire hiérarchique.
Sous Windows
Par exemple, pour les systèmes Windows, ce caractère est une barre contre-oblique (ou
antislash ou backslash), \ :
Exemple : c:\windows\system32\avifile.dll
Le fichier avifile.dll se trouve donc dans le répertoire system32, qui lui-même se trouve dans
le répertoire windows, lui-même se trouvant à la racine du système de fichiers C:. On dit que
windows est le répertoire parent de system32.On dit de c:\windows\system32 que c’est un «
chemin absolu », car c’est une référence qui ne tient pas compte de la position précédente.
Par opposition, system32 est un « chemin relatif » : cette référence suppose que le répertoire
courant est c:\windows.
Sous UNIX
Sur les systèmes UNIX, le même principe est appliqué, mais le caractère de séparation est une
barre oblique (ou slash) /.
Exemple : /usr/bin/mozilla-firefox
93
Conclusion
La notion de fichier est l’abstraction fondamentale introduite dans les systèmes d’exploitation
pour gérer les données des utilisateurs. Les fichiers sont désignés par un nom et possède
une extension. Cette extension permet de désigner le type de fichier. Les structures de
fichiers peuvent être de séquences d’octets, une suite d’enregistrements ou sous forme
d’arborescence. Les programmes accèdent aux fichiers pour les modifier, les supprimer, les
renommer, les déplacer, etc.
Question 1 :
Qu’est-ce qu’un fichier?
Question 2 :
Distinguer les trois modes d’accès à un fichier
Question 3 :
Quel problème rencontrerait-on si les fichiers n’avaient pas d’extension?
Question 4:
Distinguer l’accès séquentiel de l’accès aléatoire
Activité 3.Organisation de l’espace des ressources et des

fichiers
Introduction
Dans cette activité, on aborde le problème de la gestion des ressources physiques qui
pourront être utilisées comme support de mémorisation des données des fichiers. Un principe
de conception essentiel consiste à banaliser le plus possible les ressources physiques en
masquant leurs caractéristiques en terme de capacité, de performance d’accès, de type
d’accès, etc.
La désignation des ressources matérielles ou périphériques

Une première idée et étape consiste à intégrer les ressources physiques dans l’espace logique
même des fichiers. Cette approche apporte deux avantages : d’une part, les ressources
matérielles peuvent être désignées selon les mêmes règles que les fichiers c’est-à-dire dans le
même espace de noms et, d’autre part, l’accès à une ressource pourra se faire en utilisant les
méthodes d’accès des fichiers à condition, toutefois, d’en avoir le droit : en effet, un usager ne
doit pas avoir la possibilité d’écrire un volume disque séquentiellement, secteur par secteur.
94
Exemple Unix : Les ressources matérielles ou périphériques sont localisées dans le répertoire /
dev. Les ressources sont identifiées par un nom de base précisant leur nature et fixant le type
de leur pilote, suivi d’un numéro. Par exemple, tty01 désigne un « terminal usager » connecté
à l’entrée standard (stdin) et à la sortie standard (stdout), c’est-à-dire la plupart du temps le
clavier et une fenêtre.Les unités de disque peuvent apparaître sous des noms divers associés
souvent à leur interface de connexion, scsi par exemple.
Remarque La ressource mémoire centrale elle-même est intégrée dans l’espace de noms des
fichiers : mem désigne la mémoire usager, kmem celle du noyau.
La connexion des périphériques

Les périphériques sont de plusieurs sortes. On peut les caractériser (les distinguer) par leur
: capacité, vitesse de transfert, support final de l’information, sens des échanges, mode de
transfert (par bloc ou par octets). Nous distinguons deux grandes familles de périphériques :
• les périphériques ne pouvant pas mémoriser les données : périphériques

d’entrées de données (clavier, scanner, carte réseau, etc) ou des puits de
sauvegarde, diffuser des données (imprimante, table graphique, carte réseau,
etc).
• les périphériques qui peuvent mémoriser les données afin d’y accéder plus tard
(mémoire de masse) : Disques, les lecteurs/graveurs de CD ou DVD, les clés USB,
etc. Cette dernière catégorie constitue le support de stockage de fichiers.
Notons que les périphériques peuvent être connectés de manière permanente ou temporaire
(courte durée : clés USB par exemple).
Historiquement, la connexion des périphériques était très statique. L’ajout/retrait d’une unité
nécessitait l’arrêt préalable du système, éventuellement sa reconfiguration (ajout éventuel
du pilote correspondant à la nouvelle unité) et un redémarrage. Aujourd’hui, avec les unités
amovibles de type clé USB, la connexion d’une nouvelle unité est une opération simple ne
nécessitant ni arrêt, ni reconfiguration. Seule la connexion d’une unité d’un type nouveau
dont le pilote n’est pas présent dans la configuration courante nécessite une installation et un
redémarrage (en général) du système.
La programmation des différents types de périphériques passe par des interfaces

standardisées caractérisées, en particulier, par leur vitesse de transfert, le protocole d’échange
synchrone ou asynchrone, leur type série ou parallèle. Pour les connexions d’unités de disques,
on utilise surtout les interfaces parallèles SCSI (avec ses nombreuses variantes Ultra-5 à 640
Mo/S, Ultra-4 à 320 Mo/s, Ultra-3 à 160 Mo/s, . . .) ou FireWire (norme IEEE1394 de 50 à
100Mo/s). L’interface USB de 12 et 60Mo/s est devenue très populaire pour la connexion de
nombreux types de périphériques (clavier, appareils photos numériques, clé du même nom, . .
.). Le protocole de transfert SCSI parallèle gère très bien les périphériques multiples : plusieurs
disques connectés en série.
95
Pour qu’un périphérique soit utilisable, il faut qu’il puisse être connecté via une des interfaces
disponibles de l’architecture matérielle et que le logiciel de programmation des échanges,
appelé pilote ou driver en anglais, soit disponible et installé dans le noyau. Un pilote implante
les opérations d’échange et de contrôle du périphérique. Il se décompose en deux parties:
• les opérations appelées via les programmes usagers : lorsqu’un programme

appelle la primitive read, celle-ci va finalement sous-traiter l’opération effective
au pilote qui contient la routine de lecture adaptée au périphérique adressé ;
• les routines de traitement d’interruption de fin d’entrées/sorties : l’échange
mémoire ↔ périphérique se faisant en parallèle avec l’exécution des processus
sur l’unité centrale (les unités centrales), la fin d’un échange doit être signalée
par le contrôleur du périphérique. Pour ce faire, on utilise les interruptions.
Lorsqu’un échange se termine, le contrôleur émet une interruption vers l’unité
centrale. Le pilote doit donc contenir les routines de traitement d’interruption
correspondantes.
Généralement, un pilote peut gérer un type de périphériques. Autrement dit, si plusieurs

périphériques de même type sont connectés, un seul pilote existe. Une adresse passée en
paramètre des opérations permet d’identifier l’unité concernée.
La notion de volume
La notion de volume est introduite pour masquer la grande diversité des supports utilisables
comme mémoires de masse des systèmes de fichiers. Un volume est une abstraction de la
notion de disque : il peut être vu comme un tableau de blocs ou fragments (paquets de blocs)
de taille fixée.
La représentation d’un volume pourra être une ressource donnée : disque, CD, DVD, clé USB,
ou seulement une partition d’une unité dans le cas des disques de grandes capacité. L’unité
physique est découpée en plusieurs partitions, zones, supports de différents volumes. Le
partitionnement d’un disque en plusieurs volumes est une opération de configuration qui doit
être réalisée préalablement à l’usage de l’espace disque.
La propriété fondamentale d’un volume est de pouvoir être le support d’un système de fichiers
: autrement dit, une sous-arborescence de fichiers pourra être déployée sur un volume. Pour
ce faire, une opération d’initialisation du système de fichiers sur le volume est nécessaire.
Cette opération définit le nom du système de fichiers, les restrictions d’accès, l’espace
libre disponible, la table des descripteurs de fichiers, des dates (de création, de dernière
modification). A titre d’exemple, la commande mkfs <nom de volume>, sous Unix, permet
d’initialiser un système de fichiers sur un volume.
96
La projection de l’espace des fichiers sur l’espace des

ressources
Nous nous intéressons ici à l’implantation d’un sous arbre de fichiers sur un volume. On parle
souvent dans ce cas d’un (sous-)système de fichiers ayant pour support l’espace disque offert
par le volume. Il s’agit donc de représenter l’ensemble des fichiers de l’arbre y compris les
répertoires.
Principes généraux de conception
Stuart E. Madnick a proposé en 1970 une structuration en couches pour l’implantation des
systèmes de fichiers. Le tableau ci-dessous présente cette structuration:
Abstraction Niveau Fonction
Répertoires 6 Désignation (chemins via les

répertoires)
5
Localisation des descripteurs
Fichiers 4 Contrôle d’accès (listes ou

capacités)
3
Accès au contenu (lire, écrire)
Blocs 2 Allocation et caches
1 Gestion des échanges
Tableau 14: Structuration de systèmes de fichiers
Le niveau répertoire : implantation de l’arborescence de fichiers
L’implantation de la structure d’arbre repose sur une idée simple : les nœuds, c’est-à-dire
les répertoires, sont représentés par des fichiers. Autrement dit, nœuds ou feuilles, tout est
fichier. Pour obtenir la structure d’arbre, le contenu d’un répertoire est donc tout simplement
un tableau de couples (nom, i) dans lequel le nom est une chaîne de caractères identifiant le
fichier et l’indice repère le descripteur de fichier associé.
Cette approche implique que l’espace des fichiers proprement dit est représenté sous la forme
d’un simple tableau (ou table) de descripteurs (appelés i-node pour « internal node » sous
Unix). Lorsqu’un chemin d’accès est fourni en paramètre de la primitive open, il faut donc
éventuellement accéder à plusieurs répertoires, donc fichiers jusqu’à obtenir le numéro de
descripteur final du fichier cible.
Le niveau fichier : implantation des fichiers
D’après ce qui précède, un volume n’est donc que le support de fichiers. Il contient donc
seulement une table de descripteurs de fichiers et il suffit de connaître le numéro de ce
descripteur pour pouvoir accéder au fichier.
97
Exemple de descripteur sous Unix : le i-node Lorsqu’un fichier est créé, il faut donc réserver un
descripteur libre. Au fur et à mesure que des données vont être écrites dans le fichier, il faudra
allouer de l’espace disque pour recevoir ces données. La solution retenue est une allocation
dynamique par blocs ou fragments de taille multiple d’un secteur puisque la taille d’un fichier
n’est pas initialement connue.
Ceci pose naturellement deux problèmes :
• les blocs étant alloués dynamiquement, ils ne sont pas contigus sur le disque. Par
conséquent, il faut gérer une carte donnant pour chaque numéro logique de bloc
de fichier, le bloc physique lui correspondant. La taille d’un fichier n’étant pas
connue, la taille d’une carte ne l’est pas non plus.
• Il est nécessaire de connaître les blocs libres. Il faut donc une structure de
données permettant de connaître les numéros de blocs libres.
• Selon les systèmes de fichiers, les solutions ne sont pas tout à fait les mêmes. A
titre d’exemple, nous présentons les solutions Windows et Unix.
L’implantation Windows :
L’idée de base consiste à utiliser un tableau unique pour toutes les cartes, ce tableau ayant un
nombre d’entrées égal au nombre de blocs disque utilisables.
Figure 30: Localisation du contenu d’un fichier: Notion de carte
Pour des raisons de robustesse, ce tableau est dupliqué. Ce tableau sert à implanter un
chaînage de type liste entre les blocs logiques successifs d’un fichier. En effet, le nombre
d’entrées étant égal au nombre de blocs physiques, l’indice d’une entrée peut être utilisé
comme numéro de bloc physique et, dans une entrée occupée i du tableau (associé au bloc
i), on trouve la localisation du bloc logique suivant de i. En connaissant le numéro du premier
bloc physique du fichier, il est donc possible de retrouver tous ses blocs. La figure ci-dessous
illustre cette représentation des cartes.
98
Figure 31: Approche Windows de localisation du contenu d’un fichier
Cette implantation présente l’avantage de mixer à la fois les cartes des fichiers et la carte des
blocs libres : en effet, tout bloc libre peut être repéré dans le tableau par une entrée ayant
une valeur codant l’état libre. Elle a le désavantage d’être en fait une structure de liste et donc
d’être peu performante vis-à-vis des méthodes d’accès direct : il faut parcourir la liste jusqu’au
bloc demandé.
L’implantation Unix
L’idée de base est de placer une carte de taille fixe dans chaque descripteur de fichier. Une
carte comporte 13 entrées : les 10 premières peuvent pointer les 10 premiers blocs du fichier
s’ils existent. Typiquement, tous les blocs d’un petit fichier (une dizaine de Ko) sont donc
directement accessibles. Ensuite, la 11-ième entrée pointe un bloc qui contiendra un nombre
fixe de pointeurs vers les blocs suivants du fichier : par exemple, si les blocs ont une taille de
4K octets, on pourra placer dans un tel bloc, les pointeurs vers les K blocs suivants du fichier.
La 12-ème entrée adopte le même schéma mais avec une double indirection. Finalement,
l’usage du 13-ième conduit à 3 indirections successives.
Figure 32: Approche UNIX de localisation du contenu d’un fichier
99
Bien que cette approche permette de représenter des fichiers de taille importante, une taille
maximale existe. Les concepteurs d’Unix avaient adopté cette approche compte-tenu du
fait que le système Unix était pour eux un support au développement de programmes. C’est
pourquoi, 90 % de leurs fichiers étaient de petite taille et n’impliquaient que rarement l’usage
des indirections.
Le niveau bloc : la gestion de l’allocation/libération d’espace aux fichiers
L’allocation dynamique des blocs impose, nous avons vu, de connaître la « cartographie » des
blocs libres sur un volume. Le système Windows, avec une table de taille égale au nombre de
blocs combine les cartes de chaque fichier ainsi que celle des blocs libres. En effet, lorsqu’un
bloc i est libre, l’entrée correspondante contient une balise spécifique indiquant que le bloc
est libre. Le système Unix ayant opté pour des cartes implantées dans chaque descripteur de
fichier, doit donc par ailleurs gérer une carte des blocs libres. Cette carte est localisée dans le
descripteur du volume appelé « super-bloc ».
La structure de donnée utilisée est une pile dont la représentation se répartit dynamiquement
dans les blocs libres eux-mêmes au fur et à mesure des allocations/libérations de blocs. Le
descripteur de volume contient en fait une fenêtre « sommet » visible de la pile. La taille de
cette fenêtre est exactement égale au nombre de numéros de blocs que l’on peut mémoriser
dans un bloc. En effet, des blocs libres interviennent dans la représentation de la pile pour
contenir des numéros de blocs libres. Ceux-ci sont chaînés dans une liste.
La figure ci-dessous illustre cette représentation éclatée de la pile des blocs libres.
Figure 33: Carte (pile) de blocs libres: Approche Unix
100
Seule une fenêtre de taille fixe localisée dans le super bloc contient une partie sommet visible
de la pile. Le premier élément (base) de cette fenêtre contient un numéro de bloc libre qui, lui-
même, ne contient que des numéros de blocs libres. Lorsque la fenêtre ne contient plus que
ce dernier numéro de bloc i et qu’une demande d’allocation d’un bloc arrive, la fenêtre est
remplie de nouveau avec le contenu du bloc i et ce bloc i est alloué pour satisfaire la requête.
L’état de la fenêtre est alors à nouveau « plein » et permettra de satisfaire d’autres requêtes
futures d’allocation. Si, par contre, lors d’une libération d’un bloc j, la fenêtre est trouvée
pleine, le bloc libéré j est rempli avec le contenu de la fenêtre (pleine) et la fenêtre ne contient
plus alors, qu’à sa base, le numéro du bloc libéré j. A partir de cet état, d’autres blocs libérés
peuvent donc être à nouveau empilés dans la fenêtre.
La destruction des fichiers
L’usage d’un fichier obéit à une sorte de protocole standard constitué d’une séquence
d’appels de primitives.
Notons qu’aucune opération de destruction n’apparaît. Au niveau du langage de commande,

la destruction d’un fichier est souvent assimilée à la commande rm ou delete. En fait, une
telle commande a pour fonction première d’extraire le nom du fichier fourni en paramètre du
répertoire où il se trouve. La destruction du fichier sera automatiquement assurée par le noyau
du système lorsque deux conditions seront satisfaites pour un fichier donné F :
• Aucune connexion de processus n’existe sur ce fichier F.

• Le fichier est devenu anonyme : autrement dit, aucun répertoire ne contient
d’entrée pointant le descripteur du fichier F ;
Si ces deux conditions sont satisfaites, le fichier n’est plus utilisé et plus utilisable
puisqu’anonyme. Par conséquent, le noyau peut récupérer (libérer) les éléments intervenant
dans la représentation du fichier, en l’occurrence, son descripteur et les blocs contenant les
données du fichier.Cette approche consistant à automatiser une opération en confiant cette
opération au noyau plutôt qu’à l’usager est un principe fondamental pour la gestion des objets
partagés rémanents. Rappelons que le même principe est adopté pour la destruction des
pipes par exemple.
La gestion des échanges
L’optimisation de la gestion des échanges mémoire centrale et périphériques est un point

crucial d’un système de gestion de fichiers. En effet, de tels échanges (classiquement appelés
entrées/sorties) peuvent se dérouler en parallèle avec les processus s’exécutant sur le ou
les processeurs. Il s’agit donc de maximiser le parallélisme possible en essayant d’optimiser
l’usage des canaux d’entrées/sorties.
Cette optimisation consiste, en entrée, à « prévoir » les données qui vont être lues par les
processus : de cette façon, lorsque le processus émet une demande de lecture, l’opération
peut être très rapide puisque réduite à une recopie en mémoire centrale d’une zone source
à une zone destination. Cette approche est réalisable dans tous les cas d’accès séquentiel à
l’information.
101
En sortie, lorsqu’un processus émet une requête d’écriture, celle-ci se traduit par l’écriture des
données dans un tampon (des tampons) mémoire(s) du noyau. Ainsi, le noyau pourra optimiser
l’exécution de ces requêtes d’écriture, notamment en les ordonnançant de manière la plus
efficace en terme de temps d’exécution.Dans les deux cas, le noyau utilise un espace mémoire
composé de blocs de taille adaptée aux caractéristiques physiques des disques. Cet espace,
appelé cache, est partagé entre les processus demandeurs et les processeurs d’entrées/sorties
qui exécutent les échanges.Ce type de gestion des échanges n’exclut pas l’usage de primitives
exécutant les accès de manière directe sans passer par des caches.
Conclusion
L’intégration des ressources physiques dans l’espace logique des fichiers présente deux
avantages : même règles de désignation des ressources matérielles et des fichiers, mêmes
règles d’accès accès aux ressources matérielle qu’aux fichiers.
Il existe une très grande diversité de périphériques. Il est possible de les caractériser
(mais aussi distinguer) par leurs propriétés : capacité, vitesse de transfert, support final
de l’information, sens des échanges, mode de transfert (par bloc ou par octets). On peut
considérer qu’il existe 2 classes de périphériques : les périphériques de stockage et ceux
d’entrée et de diffusion des données. Le volume, support de stockage de fichiers, contient
une table de descripteur de fichiers. Le numéro du descripteur permet d’accéder au fichier
concerné. Sous Windows, l’implantation utilise une table de carte tandis que sous Unix on a
une carte dans chaque descripteur de fichier.
Question 1 :
Donner les principales catégories de périphériques et parler de leurs principaux

caractéristiques.
Question 2 :
Décrire les principales étapes de connexion d’un nouveau périphérique

(distinguer le cas où le pilote est présent dans la configuration du cas où il n’est
pas présent).
Question 3 :
Comparer les interfaces SCSI des interfaces USB
102
On désigne par périphérique tout matériel connecté à l’ordinateur. Ils sont en grand nombre et
leur nombre ne cesse d’augmenter. Les périphériques peuvent être classés en plusieurs
catégories en fonction de leur nature, en tenant comptes des informations manipulées, de la
durée de connexion aux ordinateurs, etc. Les périphériques présentent des vitesses de
fonctionnement différentes. Les ordinateurs possèdent des interfaces permettant de gérer
l’ensemble de ces périphériques.Les utilisateurs communiquent avec la machine par
l’intermédiaire de ces périphériques. Ils stockent leurs données sur les fichiers et peuvent
exploiter les données stockées dans ces fichiers.
Le système de fichiers réside de façon permanente sur les dispositifs de stockage secondaires,
la plupart du temps sur des disques conçus pour contenir une grande quantité de données de
manière permanente. L’espace disque est alloué aux fichiers à travers différents mécanismes.
Les routines de gestion doivent tenir compte de l’efficacité, la performance et la fiabilité des
systèmes de

1. Quelles sont les deux méthodes d’accès de fichier?
2. Quels sont les problèmes de répartition de fichier contigu?
3. Discuter de l’implantation des fichiers sous Windows et sous Unix

Andrew Tanenbaum, Systèmes d’exploitation, 2eme édition, chapitre 6
103
Unité 5. Sécurité et protection

Introduction
Dans les entreprises, la sécurité des données est nécessaire pour qu’elles ne soient pas
dérobées. Dès lors que de plus en plus de données soient stockées dans des systèmes
informatiques, il est impératif qu’elles soient protégées. La protection des données contre
une utilisation non autorisée est donc devenu un impératif pour tous les SE. Dans cette
unité d’apprentissage, nous allons explorer les différentes attaques exercées sur la sécurité
du système ainsi que des principes de conception à prendre en considération, tout en
développant un système d’exploitation de sorte qu’un système peut avoir une résistance à ces
types d’attaque.
Objectifs
A la fin de cette unité l’apprenant devra être en mesure de:
• Démontrer une bonne connaissance des notions de sécurité et de protection des

données
• Décrire les menaces de sécurité
• Prendre des mesures de protection de données dans un système
Mots-clés
Sécurité informatique: La sécurité des systèmes d’information est
l’ensemble des moyens techniques, organisationnels, juridiques et
humains nécessaire et mis en place pour conserver, rétablir, et garantir la
sécurité du système d’information.
Menace informatique: Les menaces contre la sécurité informatique

regroupent les actions susceptibles de nuire et de porter atteinte,
partiellement ou totalement, à un système informatique. Dans ce
contexte, les menaces peuvent être soustraites du cadre purement
virtuel, propre au système numérique, et ainsi venir de l’extérieur ou de
l’intervention humaine
Attaque: Une attaque est une exploitation d’une faille d’un système
Authentification: L’authentification l’identification d’un utilisateur afin de

lui donner accès aux fonctionnalités d’un système.
Virus: Un virus informatique est un programme, généralement de

petite ou très petite taille, doté des propriétés suivantes : infection ;
multiplication ; possession d’une fonction nocive. C’est un programme
malveillant.
104
Antivirus: Logiciel conçu dans le but de protéger un ordinateur en luttant

contre les virus
Faille: Faiblesse d’un système informatique susceptible d’être exploitée

afin de porter atteinte à un système informatique
Hacking : Le hacking est un ensemble de techniques informatiques,

visant à attaquer un réseau, un site, etc.
Activité 1. Aperçu général sur la sécurité
Introduction
Les ordinateurs les plus sécurisés sont ceux qui ne sont pas connectés à l’Internet. Dès lors
que l’ordinateur est connecté sur Internet c’est une brèche à de nombreuses attaques. Alors
devrons-nous abandonner de connecter nos ordinateurs à l’Internet ? La réponse est certes
non. Alors comment peut-on travailler en mode connecté et garantir la sécurité des données
et des applications ? Quelles sont les principales attaques dont on est le plus souvent cibles ?
L’ensemble de ces question sont traités dans cette activité ?
Concepts de sécurité
Les principaux concepts auxquels s’appuie la sécurité des données sont :
L’authentification : Tout utilisateur devrait avoir des informations d’authentification qui

l’identifient de manière unique. Avec celles-ci le système devrait connaître son profil et
finalement déterminer à quoi il a droit.
La confidentialité : C’est garantir que l’accès aux données est fait par l’utilisateur concerné.
Une des techniques qui permettent de de garantir la confidentialité est la cryptographie.
Intégrité : C’est le fait de protéger les données contre des modifications malveillantes.
Disponibilité : C’est garantir le fonctionnement. Eviter un déni de service de toute sorte
Le mécanisme de protection à mettre en place doit tenir en compte des menaces qu’encoure
le système. Par menace on désigne tout évènement potentiel susceptible de provoquer un
effet indésirable sur le système. Pour les données ça concerne essentiellement la modification,
l’ajout, la suppression, la copie par des personnes/programmes qui ne le devraient pas.
L’intrusion : L’intrusion concerne l’usurpation d’identité afin d’accéder aux ressources

auxquelles on n’a pas le droit.
105
La perte accidentelle de données : Un autre challenge concerne la perte accidentelle

des données. Les conséquences de la perte accidentelle des données sont souvent
catastrophiques essentiellement pour les données sensibles. La perte accidentelle des
données est souvent due aux phénomènes naturels, les erreurs matérielles et systèmes ou les
erreurs humaines.Pour plus de détails et essentiellement de conduite à tenir consulter le guide
pratique sur le lien suivant :
https://www.google.com/search?q=Alexandre+viardin&ie=utf-8&oe=utf-8
Conclusion
La sécurité du système concerne les ressources qui composent le système. Les principes en
rapport avec les mécanismes de sécurité ont été exposés dans cette activité. Les différentes
attaques possibles passent par les failles des systèmes. Certaines attaques produisent
immédiatement des effets indésirables (exemple : suppression, des données, modifications de
données,..). Dans tous les cas des précautions doivent être prises pour les éviter.
Évaluation de l’unité:
1. Qu’est-ce qu’une menace ?
2. Pourquoi attaque-t-on un système ?
3. En vous appuyant sur les éléments présentés dans cette activité et sur le
guide de sécurité d’Alexandre Viardin (https://www.google.com/search?q=Alexa
ndre+viardin&ie=utf-8&oe=utf-8) discuter des conseils à tenir pour la sécurisation
de base.
Activité 2. Les attaques du système
Introduction
L’activité précédente a été une occasion de passer en revue les principales menaces et failles
d’un système. Dans cette activité, nous allons voir les principales attaques dont fait l’objet le
système.Un système peut être attaqué par des situations différentes agressions qui testent sa
vulnérabilité. Les attaques peuvent être d’ordre physique qui consiste à voler ou physiquement
les ressources du système d’endommager ou de logique qui consiste à utiliser les programmes
malveillants et les ressources des systèmes de dégâts. Les attaques peuvent venir de l’intérieur
comme de l’extérieur.
Les attaques internes

Ce genre d’attaques est effectué par une entité qui a un droit d’accès. L’attaquant peut voler
ou endommager physiquement les ressources ou après pénétration réussie à un système,
l’intrus peut effectuer son opération souhaitée et attaquer le système. Plusieurs attaques
logiques à l’intérieur peuvent être imposées sur les systèmes. Ci-dessous, nous présentons
quelques-unes d’entre elles:
106
• Les chevaux de Troie: C’est un programme apparemment innocent, mais avec

des codes à l’intérieur qui provoque un fonctionnement inattendu comme la
modification, la suppression ou même transférer les informations de l’utilisateur
sur l’emplacement de l’attaquant.
• Le spoofing: l’attaquant présente une interface de connexion de faux qui
ressemble exactement à la vraie interface de connexion. L’utilisateur donne
alors son / ses données d’authentification de l’interface de faux qui recueille et
transmet les informations à l’attaquant et les sorties. L’interface de connexion
d’origine est affiché alors et l’utilisateur croit de faire une erreur précédemment
sur l’information et pense que le système affiche l’interface pour la deuxième fois.
• Bombe logique: C’est un code embarqué dans un programme qui “explose”
lorsque certaines conditions sont remplies, par exemple une certaine date ou la
présence de certains fichiers ou des utilisateurs.
• Trappes: C’est un point d’entrée secrète dans un programme, souvent laissé par
les développeurs du programme, ou parfois livré via une mise à jour logicielle.
Ce sont des codes inclus dans un programme pour aider le contournement de
l’attaquant des contrôles normaux.
• Dépassement de mémoire tampon: C’est une attaque qui se passe sur un
système en exploitant des bugs dans un programme et l’utilisation de ces
bugs à endommager le système. Le bug peut être un simple cas de mauvaise
programmation, dans lequel le programmeur a négligé de codes associée
vérification
Les attaques externes

Ce sont des attaques provoquées par un attaquant de l’extérieur du système principalement
sur un réseau. Ces attaques utilisent des codes transmis à la machine ciblée sur un réseau
et provoque des dommages à la machines cible. Ces codes sont connus comme des codes
malveillants et peuvent être virus, un ver, codes mobiles ou des applets Java.
Le virus est un programme qui se réplique en se fixant avec un autre programme et causant
des lésions sur les ressources du système. L’attaquant distribue le virus en l’attachant à
un programme attrayant qui est plus susceptible d’être utilisé par les utilisateurs (jeux,
applications gratuites, etc.). Après avoir pénétré dans le système, le virus reste inactif jusqu’à
ce que le programme infecté soit lancé et quand il commence, il commence à affecter d’autres
programmes du système. Les virus sont de types différents en fonction de leurs propriétés et
des procédés d’activation. Prévenir un virus de pénétrer dans un système sur la première place
est une solution idéale pour protéger un système à partir d’une attaque de virus qui est très
difficile, voire impossible, de le faire à l’époque des systèmes en réseau. Donc, la meilleure
alternative à la protection de virus pourrait être la détection d’un virus, une fois détecté
identifier son type, et ensuite essayer de le retirer du système ou en cas d’impossibilité retirer
l’ensemble du programme concerné. Celles-ci sont réalisées par des programmes spéciaux
connus sous le nom antivirus. Les programmes antivirus sont utilisés pour protéger le système
d’être affectés par des virus. Un antivirus maintient définition de virus qui est le code pur
des virus. L’antivirus inspecte ensuite les fichiers exécutables du système pour vérifier s’il y a
un code correspondant à la définition de virus. Si oui, ils essaient de fixer le programme en
supprimant le code du virus.
107
Un worm est similaire à un virus, sauf qu’il a la capacité de se répliquer et n’a pas besoin de
se fixer sur d’autres programmes à se reproduire. C’est un programme indépendant qui se
propage via des connexions réseau.
Conclusion
Les attaques du système peuvent être soit internes (arrive après que l’utilisateur se connecte
avec succès) ou externe à partir d’un endroit éloigné en particulier dans les systèmes en réseau.
Le cheval de Troie, la bombe logique, l’usurpation d’identité, dépassement de mémoire
tampon sont quelques-unes des attaques de l’intérieur du système alors que les virus, les vers,
les codes mobiles sont des attaques provenant de l’extérieur du système.
Comment le débordement de tampon attaque-t-il un système?
Donner les solutions pour protéger le système contre les attaques de vers?
Quelle est la différence entre un virus et un ver ?
Qu’est-ce qu’un cheval de Troie et comment attaque-t-il le système ?
Quelle est la différence entre une attaque interne et une attaque externe ?
Activité 3. Les mécanismes de protection
Introduction
Un système d’exploitation a la responsabilité de faire respecter les mécanismes de protection

de sécurité pour éviter les menaces possibles de se produire et de protéger les différents
afin de protéger les différentes ressources du système. Chaque actif d’un système a un nom
et un ensemble bien défini d’opérations à travers laquelle l’accès est fait. Dans cette section,
nous abordons quelques contre-mesures fixées par un système informatique pour se protéger
contre les attaques de sécurité et les principes de conception qui doivent être suivies pour
renforcer la sécurité de système. Tel qu’un système d’exploitation est conçu, chaque objet
(utilisateur, processus) a un ensemble de privilèges qui doivent être garantie. Les mécanismes
de sécurités doivent être interne et garantir l’accès contrôlé pendant toutes les opérations.
Le système de sécurité doit être revu de manière continuelle.Ci-dessous, nous explorons les
principaux mécanismes de sécurité.
108
La cryptographie
Un message est significatif quand il est lisible (écrit dans des caractères que l’on comprend).
La cryptographie est un mécanisme qui consiste à transformé une donnée (un texte par
exemple) qui était alors claire (facile à déchiffrer) en une donnée (code) difficile à déchiffrer.
Cela suppose qu’à la réception du message, le destinataire doit être à mesure de décrypter le
message. La transformation des données à transmettre dans des codes indéchiffrables (pour
les non destinataires) est appelé le cryptage tandis que la transformation du code reçu en le
message d’origine s’appelle le décryptage.
Lire le document ci-dessous pour les détails sur la cryptographie :
Authentification des utilisateurs

Un autre mécanisme de sécurité est l’authentification. Pour le système chaque utilisateur
possède une identification unique. L’authentification des utilisateurs est un processus de
détermination de l’identité d’un utilisateur sur la base duquel son / ses activités autorisées
sont également identifiés. Il permet à une entité (un utilisateur ou un système) de prouver son
identité à une autre entité. Les éléments d’identifications d’un utilisateur peuvent être : Nom
utilisateur et mot e passe, données biométriques (empreintes digitales, l’iris, …..), etc.
Pour les données non biométriques en l’occurrence le nom utilisateur et le mot de passe, il
est conseillé de les changer régulièrement. Il est conseillé de créer des mots de passe long,
comprenant plusieurs types de caractères (lettes, chiffres, caractères spéciaux, majuscules
minuscules). Remarque : Pour un mot de passe compliqué, les utilisateurs ont tendance à les
écrire soit dans un carnet sur la table, les coller sur les murs etc. ; D’où ce qui était une force
devient une faiblesse. Les utilisateurs doivent être sensibilisés pour ce qui est de la sécurité du
système informatique de leur organisation.
Enfin notons également que le contrôle d’accès physique est un élément important des
mécanismes de sécurité du système informatique.
Conclusion
Un système informatique a besoin de se protéger contre les accès non autorisés et illégitime.
Pour ce faire, il définit divers mécanismes de protection du système dont la cryptographie,
l’authentification des utilisateurs et sans doute aussi le contrôle d’accès physique aux
équipements.
En quoi consiste la cryptographie?
Quelles sont les règles à tenir en compte dans le choix d’un mot de passe.
Donner l’inconvénient principal d’un mot de passe complexe ?
109
Les systèmes d’exploitation sont menacés de plusieurs manières (virus provenant de l’extérieur
et les crackers). L’autre menace des données d’une entreprise est son propre personnel. Nous
avons au cours de cette unité d’apprentissage abordé les principaux thèmes en rapport avec la
protection des données. Nous nous sommes rendu compte qu’il est possible de concevoir des
systèmes sécurisés mais à côté de cela une politique de sécurité doit être adoptée au sein de
chaque organisation afin de mieux protéger ses données. Les membres du personnel doivent
être sensibilisés afin que chacun comprenne les enjeux en rapport avec la sécurisation de leurs
données.
Parler de la menace et de la politique de sécurité.
A quoi sert la cryptographie ?
Après la lecture de la ressource suivante sur la cryptographie, indiquer comment

se pose le problème de la gestion de clés dans la cryptographie et comment il
est résolu ?
Ressource à lire: ftp://ftp.pgpi.org/pub/pgp/6.5/docs/french/IntroToCrypto.pdf

110
Unité 6. Thèmes spéciaux

Jusqu’à présent, nous avons vu de long en large le système d’exploitation du point de vue
structure et fonctionnement. Pour leur bonne exploitation des changements de configuration
et la maintenance des SE sont nécessaires.Dans des environnements complexes avec
plusieurs tâches simultanées et de forte exigence en temps de réponse, des systèmes
temps réels sont nécessaires. Au cours de cette unité d’apprentissage, nous allons passer
en revue la maintenance et la configuration ainsi que la notion de système temps réel et
systèmes embarqués.En outre la notion de virtualisation est un autre thème qui est en vogue
pour le moment dans le monde informatique. Une machine virtuelle est une réplique de la
machine réel et ayant le même comportement que la machine physique. Dans cette unité
d’apprentissage, nous allons aborder la notion de virtualisation et montrer comment on peut
créer un SE virtuel.
Activité 1. Configuration et maintenance des SE

Comment identifier les exigences d’un SE? Comment installer et configurer un SE ?
Introduction
Avant d’installer le SE il est indispensable de connaître ses exigences (mémoire RAM, taille du
disque dur, processeur, etc.). Au cours de cette activité, nous allons passer en revue tout ce
qu’il faut pour bien installer et configurer les SE. L’installation pourra se faire soit à partir d’une
clé USB, d’un CD ou DVD, raison pour laquelle nous allons commencer par la configuration du
bios afin que l’ordinateur puisse démarrer sur, une clé USB, le CD ou DVD d’installation.
Identification des exigences

Chaque SE présente ses propres exigences qu’il faut tenir en compte avant toute installation.
Ci-dessous, nous présentons les principales exigences des SE:
Processeur: On distingue les processeurs à 32 ou à 64 bits. De ce fait, on distingue un SE

32 ou 64 bits. Un SE 32 bits fonctionne sur un processeur 32bits de même, un SE 64 bits
fonctionne sur un processeur 64 bits. Par conséquent, il faut bien identifier le processeur et le
système qui vont de pair.
Mémoire RAM: Chaque SE a une exigence en matière de mémoire RAM minimale requise. Il
faut s’assurer que la mémoire RAM a une taille supérieure ou égale à celle requise.
Taille du disque dur: Chaque SE a une exigence en matière de la taille de disque minimale
requise. Il faut s’assurer que l’espace mémoire disque disponible est suffisant pour le SE à
installer.S’assurer que le matériel sur lequel vous voulez installer le SE possède des pilotes
compatibles avec le nouveau système que vous voulez installer. De préférence, visitez le site du
constructeur de votre matériel avant d’installer votre système. Utiliser l’adresse MAC de votre
système ou le numéro de sériel de votre matériel pour que vous puissiez avoir des précisions
sur le système à installer et la compatibilité du matériel avec celui-ci.
111
Réglage de la séquence de boot dans le bios

L’installation du système d’exploitation se fait à partir d’un CD ou d’un DVD dit “bootable”,
lequel permet donc de démarrer la machine même si aucun système d’exploitation n’est
présent sur le disque dur. Pour que la carte mère sache qu’elle doit chercher à démarrer depuis
le CD ou DVD et non depuis le disque dur, il nous faut configurer l’option appropriée dans
le bios.Pour l’essentiel la présentation (et la marque) des bios peuvent être de deux types
différents, les bios AMI et AWARD. Nous allons donc détailler la procédure pour ces deux
types de bios. Le principe reste dans tous les cas le même : une liste indiquant l’ordre que doit
respecter la carte mère pour essayer de “booter” sur les différents médias devra être modifiée
afin de faire figurer le lecteur/graveur CD/DVD avant le disque dur.Pour entrer dans le bios,
vous devez appuyer sur une touche peu de temps après l’allumage de votre ordinateur : très
généralement il s’agit de la touche “Suppr” (“Del”) mais dans tous les cas de figure cette
information sera affichée à l’écran.
Bios AMI :
En utilisant les touches de direction, choisir le menu Boot et indiquer la priorité du boot.
Figure 34: Paramètres du boot
Validez avec la touche “Entrée” (Return) : Cela donne la figure ci-contre :
Figure 35: Menu de priorité de démarrage
112
Afin de modifier le premier media de boot, validez de nouveau avec la touche “Entrée”
(Return) : vous accédez à cette zone. Utiliser les touches de direction afin de mettre en
surbrillance l’option souhaitée.
Figure 36: Modification de l’ordre de démarrage
Une fois le choix opéré, valider de nouveau avec la touche entrée. Le premier média de boot
devient alors celui que vous avez choisi (CDROM pour le cas ci-contre).
Figure 37: Modification de l’ordre de démarrage (suite)
Une fois toutes les modifications faites valider vos choix en appuyant sur la touche F10 afin de
sauvegarder les modifications faites. Une demande de confirmation va apparaître. Confirmer la
demande en appuyant sur la touche entrée.
113
Figure 38: Validation des options de démarrage
Bios AWARD :
Figure 39: Menu du Bios AWARD
Utiliser les touches de direction de votre clavier pour vous déplacer dans les menus. Choisir
BIOS FEATURES SETUP et appuyer sur la touche entrée. Les différentes options pour cette
catégorie de BIOS apparaissent.
114
Figure 40: Option du boot Bios AWARD
Pour ordonner les séquences de boot, sélectionner la ligne « Boot Sequence » et appuyer sur
le bouton “+” (extrémité droite de votre clavier) afin de faire apparaître l’option “CDROM, C, A
Figure 41: Choix de l’ordre de boot dans le bios AWARD
La présentation de ce menu peut varier : suivant les versions de bios AWARD, vous
rencontrerez trois lignes intitulées “First Boot Device”, “Second Boot Device” et “Third Boot
Device” au lieu d’une seule ligne “Boot Sequence”. Dans ce cas de figure, positionnez l’option
“CDROM” pour le “First Boot Device” et l’option “Hard Disk” pour le “Second Boot Device”
Une fois les modifications terminées, appuyer sur la touche « Echap »ou « Esc » en fonction du
clavier. La demande de sauvegarde des modifications faites apparaît.
115
Figure 42: Menu de sauvegarde des modifications
Appuyez sur “Y” puis validez avec la touche “Entrée” (Return)
Lancement de l’installation du système d’exploitation
Après que vous ayez quitté le bios en sauvant, la machine reboote et vous déclare quelque
chose dans ce style :
Placez alors le CD ou DVD d’installation du système d’exploitation dans le lecteur puis appuyez
sur le bouton reset en façade. Après quelques instants l’installation du système d’exploitation
se lance automatiquement. Si le message « Appuyez sur n’importe quelle touche pour
démarrer à partir du CD-ROM » apparaît, suivez cette instruction pour démarrer l’installation
de votre système d’exploitation et suivez les instructions montré sur l’écran au cours de
l’installation.
Chaque fois que le besoin se fait sentir on peut modifier les paramètres de l’ordinateur
(changement de résolution, personnaliser l’écran de verrouillage, gérer les périphériques, etc.).
Dans les systèmes Windows toutes ces tâches se font dans le panneau de configuration. Pour
trouver le panneau de configuration dans Windows 8 par exemple, mettre le pointeur de votre
souris dans le coin inférieur gauche de votre écran puis cliquer sur le bouton paramètre.
116
Figure 43: Le bouton paramètre sous Windows 8
Après un clic sur le bouton paramètre, sélectionner le panneau de configuration. Le système

vous affiche alors l’interface du panneau de configuration.
Figure 44: Panneau de configuration
De là vous pouvez modifier les configurations comme vous le voulez.
NB : un compte administrateur est requis pour modifier les configurations qui affectent le
système en entièreté.
Conclusion
Tout au long de cette activité d’apprentissage, nous avons passé en revue la manière d’installer
le SE. Pour cela, nous avons vu qu’il faut d’abord vérifier les exigences du SE. Par la suite le
choix des options de démarrage s’impose. Une fois le choix des options de démarrage fait, la
machine redémarre et l’installation commence. Il ne reste qu’à suivre l’assistant d’installation
pour installer le SE. Des modifications de configuration peuvent être faites en passant par le
panneau de configuration.
117
Exercice1 :
Comment procéder pour identifier les exigences d’un SE ?
Exercice2 :
Indiquer les étapes de choix des options de démarrage pour les deux catégories
de Bios vu dans le cours.
Exercice3 :
Installer un système d’exploitation à partir d’un CD et faire un résumé des étapes

suivies.
Activité 6.2 : Système temps réel
Introduction
Un système d’exploitation en temps réel est la catégorie d’un système d’exploitation qui est
utilisé pour gérer des applications en temps réel. C’est-à-dire que pour de tel système l’on a
besoin d’une réponse correcte et dans un temps très court. Ce genre de système possède des
spécificités autres que celles déjà vues dans les unités précédentes. Cette activité consiste en
un aperçu sur les systèmes temps réels.
Exigences des systèmes temps réels

Un système en temps réel est généralement un système à but spécifique, de petite taille, à
peu de frais produites en masse et avec les exigences de calendrier précis. Un système
temps réel est conçu pour un seul but et vous ne pouvez pas l’utiliser pour d’autres tâches
que celle spécifiée lors de sa conception. Les systèmes temps réels autonome, conçus pour
des problèmes spécifiques, pour lesquels le matériel et l’application sont intimement liés sont
appelés des systèmes embarqués.
La plupart des systèmes en temps réel sont utilisés dans des environnements exigus qui place
également une limitation de CPU et de mémoire pour ces systèmes. Comme ces systèmes
sont aussi le plus souvent utilisés avec les appareils ménagers et les appareils grand public qui
sont fabriqués en masse dans des environnements de coûts conscients, les processeurs de ces
systèmes doivent également être fabriqués par un coût moindre. Enfin, l’exigence de temps
une caractéristique qui définit un système en temps réel qui permet de réagir aux événements
en temps opportun. En général, un système en temps réel a trois exigences principales :
118
1. Prévisibilité: le comportement de synchronisation du système d’exploitation

doit être prévisible
2. Gestion: le système d’exploitation doit gérer le calendrier et la programmation

de car il a peut-être au courant des délais de tâches. En outre, le système
d’exploitation doit fournir des services de temps précis avec une résolution
élevée.
3. Vitesse: Le système d’exploitation doit être rapide dans toutes les réponses,
ce qui est important dans la pratique.
Les systèmes d’exploitation traditionnels ont la capacité de supporter plusieurs périphériques

comme entrée, sortie, etc., plusieurs utilisateurs, des mécanismes de protection contre toute
menace possible, et la virtualisation pour améliorer son espace mémoire où tous ces éléments
créent une certaine complexité sur le noyau du système. En revanche, les systèmes temps réel
sont conçus simplement avec un petit nombre de codes et ont aucune de ces fonctionnalités.
Les principales raisons pour lesquelles les systèmes en temps réel ne parviennent pas à le faire
sont les suivantes:
• La plupart des systèmes en temps réel sont système conçu pour servir une seule
tâche. De tel système ne connaissent pas la notion d’utilisateur. Le système prend
en charge tout simplement un petit nombre de tâches, qui obtient souvent son
entrée à partir de périphériques tels que des capteurs.
• Il est impossible de donner aux systèmes d’exploitation temps réels, les
fonctions prises en charge par les systèmes d’exploitation de bureau standard
sans processeurs rapides et des quantités abondantes de la mémoire qui sont
indisponibles dans les systèmes en temps réel.
• Le soutien des caractéristiques communes dans les systèmes de bureau standard
par les systèmes en temps réel les rendrait coûteux et économiquement
impraticable.
• Les domaines d’application des systèmes temps réels sont de plus en plus variés,
on en trouve dans : l’électroménager, transport, télécommunication, guichet
automatique, etc.
Pour plus de détails sur les systèmes temps réels, consulter les liens ci-dessous :
Conclusion
Les systèmes temps réels sont des systèmes à forte contrainte de temps et de réponse. Ils
sont généralement intégrés à des types particuliers de dispositifs mais ils peuvent également
être exécuté sur du matériel traditionnel. Les exigences des systèmes temps réels diffèrent de
celles des systèmes classiques. Les systèmes temps réels sont généralement conçus pour une
activité spécifique.
119
Définir un système un système temps réel.
Différencier un système temps réels d’un système classique
Quel est l’importance des systèmes temps réel.
Expliquer les trois exigences des systèmes temps réels.
Activité 3. Virtualisation
Comment exécuter plusieurs SE sur une même machine ? Comment les machines virtuelles
fonctionnent-elles ?
Introduction
La virtualisation permet de simuler l’existence d’une ressource matérielle ou logiciel donnant

ainsi l’image d’un travail (exploitation d’une ressource réel) sur une ressource réelle.
Au cours de cette activité d’apprentissage, nous allons passer en revue la notion de

virtualisation, comment mettre en place et gérer des ressources virtuelles.
Définition
Les termes de “virtualisation” et “virtualiser” sont des termes récents, vous ne les trouverez
pas dans des dictionnaires ayant quelques années d’existence. Tout ce que vous pourrez
trouver, c’est “virtuel” et “virtuellement”. Vous comprendrez aisément le sens de ces 2
nouveaux mots, il s’agit de rendre virtuel.
On peut virtualiser :
• Les serveurs,
• Les applications,
• Les postes de travail,
• Les réseaux (Vlan)
• Les bureaux,
• …
• VMWare annonce la virtualisation des “datacenter”.
Avec la virtualisation aisément que virtuel, veut dire que ce n’est pas réel. C’est facile à
comprendre, mais en le précisant, ça a le mérite de le remettre en mémoire. La grande
question qui se pose est de savoir comment on se sert de ces éléments virtuels. Sans doute
c’est de la même manière que les éléments physiques.
120
Comment se fait-il ?
On prend un serveur physique sur lequel on va installer un logiciel spécial.Les éditeurs les plus
connus étant : VMWare avec VSphere, VirtualBox et ses ESXi, et Microsoft avec son système
Hyper-V.
Comment ça marche ?
Ce logiciel va faire croire aux autres systèmes qu’ils fonctionnent sur des machines physiques,
en leur mettant à disposition :
• de la RAM,
• de la puissance CPU,
• de l’espace disque,
• une ou plusieurs cartes réseaux,
• …
Ainsi lors de l’installation, le SE ne verra pas s’il est installé en direct sur une machine physique
ou s’il est installé sur une machine virtuelle.
Figure 45: Représentation d’un serveur avant la virtualisation
Comme le montre la figure ci-dessous, sur cette machine physique (ordinateur) il est installé un
système d’exploitation (OS) sur lequel on installe un ou plusieurs logiciels qui ont chacun une
ou plusieurs fonctionnalités ou rôles qui rendent des services.
Ci-dessous, nous présentons un serveur contenant trois serveurs virtuels :
121
Figure 46: Hyperviseur contenant trois serveurs virtuels
Dans ce schéma, une couche OS (Operating System) est mise sur l’ordinateur physique.
Cette couche OS est parfois intégrée directement dans le logiciel d’hypervision tel qu’ESXi
de VMware.Dans ce schéma, il n’y a qu’un seul ordinateur physique, en réalité on va mettre
plusieurs ordinateurs physiques, car si l’un tombe en panne, les autres se distribueront le
travail qui lui était attribué. C’est un hyperviseur qui va faire fonctionner l’ensemble.
Un hyperviseur est la plateforme mettant à disposition des machines virtuelles (celles-ci peut
être constitué ou non d’ordinateur physiques mais constitué du matériel, de l’OS et du logiciel
d’hypervision).
Pourquoi virtualiser ?
En regardant bien le travail des serveurs, on se rend compte que la plupart du temps, ceux-ci
attendent de répondre à une demande. Ensuite, ils répondent à cette demande en peu de
temps, et retourne ensuite à l’état d’attente.En virtualisant, on va ainsi mutualiser ces temps
d’attente, et un serveur (physique) sera plus sollicité car il répondra à plus de requêtes en
même temps (requêtes traitées par les serveurs virtuels).
On pourrait se dire que le serveur (physique) ne pourra pas répondre à toutes les requêtes
en même temps. C’est partiellement vrai : C’est vrai, qu’il ne peut pas répondre à toutes les
requêtes en même temps, mais les serveurs récents étant constitués de plusieurs cœurs chacun
pouvant traiter ses propres opérations, il y répondra en même temps en attribuant le travail à
chacun de ses cœurs. Et pour celles qu’il ne peut pas traiter en même temps, il y répondra si
vite qu’on aura l’impression qu’il a répondu en même temps que les autres.
122
Sans la virtualisation, il faut installer un serveur physique pour chaque système ou type de
serveur. On se rend bien compte qu’entre le temps d’achat du serveur, de la livraison, de
l’installation : il peut s’écouler plusieurs jours. En virtualisant les serveurs, ils peuvent être
opérationnels en quelques minutes seulement.Un serveur physique est constitué de matériels
électriques et électroniques, nous savons tous que cela peut tomber en panne. Il faut donc
surveiller l’ensemble de ces systèmes. L’intérêt de la virtualisation est de s’appuyer sur
quelques machines physiques, cela en fait beaucoup moins à surveiller. De plus, les systèmes
hyperviseurs sont en général redondés, lorsqu’un serveur physique tombe en panne, c’est les
autres serveurs qui prennent le relais. De plus, la surveillance, l’administration et l’exploitation
sont centralisées.
Et enfin, en cette période, où nous devons faire des économies d’énergie pour protéger notre
planète, les infrastructures virtualisées sont beaucoup moins gourmandes en électricité et en
climatisation qu’un ensemble de serveurs physiques. (Un seul serveur physique consomme
moins que plusieurs).La virtualisation est très utilisée dans le cloud car elle permet de fournir
de la puissance de calcul et de stockage à la demande.
Exemple de virtualisation avec Virtualbox

Avant de lancer l’installation de n’importe quel système d’exploitation sur votre serveur, il vaut
mieux s’entrainer à l’utiliser. Pour cela il existe une solution qui se nomme la virtualisation.
C’est un procédé qui émule le hardware d’un ordinateur. Vous pouvez ainsi lancer l’installation
de n’importe quel système d’exploitation sur une machine virtuelle comme si elle était réelle.
Ce logiciel de virtualisation VirtualBox est disponible sur différentes plateformes: Windows,

GNU/Linux, Mac et OpenSolaris. Il est sous licence libre GNU General Public License et est
téléchargeable gratuitement sur le site officiel d’Oracle.
L’installation
VirtualBox est téléchargeable sur le site : http://www.virtualbox.org/.
L’installation se déroule sans difficulté, il suffit de laisser tous les paramètres par défaut. Cette
dernière terminé, lancez VirtualBox. Vous vous retrouvez face à la fenêtre principale du logiciel.
Elle est divisée en deux parties: la liste des machines virtuelles (vide pour le moment) et les
détails de la machine virtuelle sélectionnée à droite.
123
Figure 47: Option détail du formulaire de virtualisation
Création d’une machine virtuelle
Cliquez sur « Nouvelle » et sur la fenêtre qui s’ouvre, cliquez sur suivant.
Maintenant, nommez votre machine virtuelle et choisissez l’OS correspondant à celui que vous
installerai par la suite. Pour notre cas, se sera Linux – Debian.
Figure 48: Choix du système d’exploitation
124
Ensuite choisissez votre quantité de mémoire vive alloué à la machine virtuelle. Surtout, évitez
de prendre plus de la moitié de la quantité de mémoire vive réelle pour éviter une perte de
performance trop importante pour votre ordinateur.
Figure 49: Choix de la mémoire vive
Ceci fait, laissez « Créer un nouveau disque dur » coché puis cliquez sur suivant. Une nouvelle
fenêtre s’ouvre, c’est l’assistance de création de disque virtuel. Cliquez sur suivant. Vous avez
alors le choix entre « Image de taille variable » qui vous permet d’économiser de l’espace sur
votre disque en utilisant juste la quantité de mémoire utile au système virtuel ou « Image de
taille fixe » qui vous permet d’être sûr de ne pas manquer d’espace sur votre disque dur réel
pour le disque virtuel mais cette option est plus longue à la création. Je choisi la première
solution.
Figure 50: Création du disque virtuel
125
Choisissez ensuite le chemin de destination du disque virtuel ainsi que sa taille tout en ne
dépassant pas la quantité de mémoire disponible. Je prends 160Go, la taille du disque dur de
notre serveur réel qui accueillera le système.
Figure 51: Choix de l’emplacement et de la taille du disque virtuel
L’étape suivante est celle de la configuration de la machine virtuelle créée.
Configuration de la machine virtuelle

Sélectionnez la machine virtuelle dans la fenêtre principale de VirtualBox que vous venez de
créer puis cliquez sur « Configuration ». Dans la nouvelle fenêtre qui apparaît choisissez «
Réseau » dans le menu de gauche.
Figure 52: Formulaire de configuration de la machine virtuelle
126
Nous allons nous intéresser ici principalement à deux modes: le « NAT » et l’« accès par pont ».
Le mode « NAT »
C’est le mode que VirtualBox vous propose par défaut. C’est aussi le mode le plus simple à
utiliser car il ne demande aucune configuration de votre part et vous êtes sûr que ça marchera
du premier coup! Cependant ce mode ne vous permettra que d’accéder à internet et non au
réseau local.
Le mode « Accès par pont »
Ce mode permet de créer un pont entre votre connexion physique et votre machine virtuelle.
Vous obtenez ainsi une IP pour votre machine virtuelle différente de votre machine réelle. Vous
pourrez travailler sur votre serveur comme si c’était une véritable machine sur votre réseau.
Il est conseillé donc d’utiliser ce dernier mode plus utile pour notre serveur virtuelle que le
premier!
Premier lancement de votre machine virtuelle
Sélectionnez votre machine virtuelle et cliquez sur « Démarrer ».
Une assistance de premier lancement se lance. Cliquez sur suivant. Vous devez maintenant
choisir un média d’installation. Vous avez la possibilité de choisir un lecteur optique de
votreordinateur ou de lancer une image iso. Pour cette dernière solution, cliquez sur le petit
dossier avec une flèche verte dessus.
Figure 53: Choix du média concernant le logiciel d’installation
Cette action vous ouvrira le « Gestionnaire de médias virtuels ». Dans celui-ci, cliquez sur «
Ajouter » et recherchez l’image iso du CD d’installation du système que vous avez choisi.
127
Figure 54: Création de l’image du CD d’installation
Sélectionnez l’iso dans le gestionnaire et cliquez sur « Choisir ».
De retour dans l’assistance, cliquez sur Suivant puis Terminer. La machine virtuelle se lance
enfin et il ne reste plus qu’à suivre les étapes d’installation normales correspondant à
l’installation de votre système.
Note : Il y a d’autres logiciels de virtualisation tels que :
• VMware ;
• Hyper-V ;
• Paragon Virtualization Manager ;
• Parallels Virtuozzo Containers ;
• Parallels Server 4 Bare Metal ;
• Parallels Transporter ;
• Parallels Workstation Extreme ;
• Etc.
128
Conclusion
Au cours de cette unité d’apprentissage, nous avons passé de long en large la notion de
virtualisation, la manière dont fonctionnent les machines virtuelles ainsi que les différentes
étapes de virtualisation via un exemple avec le logiciel Virtual Box.Ainsi, nous remarquons que
la virtualisation permet d’optimiser et d’accroître considérablement le taux d’utilisation des
ressources serveurs et postes de travail nécessaires aux entreprises.
La gestion dynamique, et non plus statique, des ressources serveurs et applicatives permet
de répondre aux besoins de plus en plus élevés de qualité de service rendue aux utilisateurs.
La virtualisation permet la réduction des coûts de maintenance et des coûts globaux
d’exploitation et de possession pouvant allant de l’ordre de 40 à 70% par rapport aux
architectures dites standards. Signalons enfin que la virtualisation permet une amélioration de
la productivité et permet une réduction de l’impact environnemental.
Exercice 1 :
Dire en quoi consiste la virtualisation
Exercice 2 :
Par un exemple donné, montrer comment la virtualisation permet de :
1. Réduire les ressources ;
2. Réduire les coûts de maintenance et d’exploitation.
Exercice 3 :
En utilisant un logiciel de virtualisation (Virtual box par exemple), installer un

logiciel serveur (Windows server 2012 par exemple ou n’importe quel autre SE
serveur) et indiquer les différentes étapes suivies.
Dans cette unité, nous avons passé en revue l’installation et la configuration des SE.
Pour installer un SE certains paramétrages du bios sont souvent nécessaires. Un SE bien

configuré et maintenu est la base pour une meilleure gestion de fonctionnement. Avant
d’essayer d’installer un système d’exploitation, il faut comprendre les exigences imposées par
ce système d’exploitation particulier et de se conformer à ces exigences. Une fois, l’installation
du système d’exploitation est terminée, il est également possible de customiser ou
personnaliser diverses caractéristiques de l’OS grâce à des outils de gestion de configuration.
Dans cette unité, nous avons également donné un aperçu sur les systèmes temps réel et leurs
exigences.Le dernier sujet spécial abordé dans cette unité est celle de la virtualisation. Grâce
à la virtualisation, on peut accroître considérablement le taux d’utilisation des ressources
serveurs et postes de travail nécessaires aux entreprises.
129
1. Vous voulez installer un SI et vous trouvez que la machine ne parvient pas
à démarrer sur votre CD. D’après vous ce problème est du à quoi ? Indiquer les
différentes étapes pour le corriger.
2. Expliquer les principales propriétés d’un système temps réel.
3. Par des exemples concrets indiquer l’importance de la virtualisation.
Quotation
Cette unité d’apprentissage compte pour 10% répartis comme suit :
• Evaluation des activités: 5%

• Evaluation de l’Unité : 5 %
Rappel

points

http://sist.sysu.edu.cn/~isscwli/OSRef/Abraham%20Silberschatz-Operating%20System%20
Concepts%20%289th,2012.12%29.pdf
Evaluation Final du module
130
131
Siège de l’Université Virtuelle Africaine
The African Virtual University

Headquarters
Cape Office Park
Ring Road Kilimani
PO Box 25405-00603
Nairobi, Kenya
Tel: +254 20 25283333
contact@avu.org
oer@avu.org
Bureau Régional de l’Université

Virtuelle Africaine à Dakar
Université Virtuelle Africaine
Bureau Régional de l’Afrique de l’Ouest
Sicap Liberté VI Extension
Villa No.8 VDN
B.P. 50609 Dakar, Sénégal
Tel: +221 338670324
bureauregional@avu.org
2017 UVA

CSI 3201 - FRIntroduction Aux Systèmes D - Exploitation - Edited

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

CSI 3201 - FRIntroduction Aux Systèmes D - Exploitation - Edited

Transféré par

Droits d'auteur :

Formats disponibles

INFORMATIQUE APPLIQUÉE: CSI 3201

Ce module a été développé dans le cadre d’un programme de diplôme et d’études en

Au nom de l’Université virtuelle africaine et de notre patron, nos institutions partenaires, la

L’université virtuelle africaine (UVA) est une organisation intergouvernementale panafricain

Université virtuelle africaine

UVA – Coordination Académique

Dr. Marilena Cabral

Coordinateur global Sciences Informatiques Apliquées

Prof Tim Mwololo Waema

Barry Savala Mercy Tabi Ojwang

Edwin Kiprono Josiah Mutsogu

Kelvin Muriithi Kefa Murimi

Victor Oluoch Otieno Gerisson Mulongo

Projet Multinational II de l’UVA financé par la Banque africaine de développement.

Aperçu sur du cours 10

Bienvenu dans le module d’introduction au système d’exploitation. . . . . . . . 10

Unité 1: Principes des SE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Unité 2: Gestion des processus . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Unité 3: Gestion de la mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . .11

Unité 4 : Gestion des périphériques et systèmes de fichiers . . . . . . . . . . . . 11

Unité 5: La Sécurité et la protection. . . . . . . . . . . . . . . . . . . . . . . . .11

Unité 6: Thèmes spéciaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11

Les ressources documentaires à consulter sont:. . . . . . . . . . . . . . . . . . 13

Unité 0. Aperçu sur les systèmes d’exploitation 15

Qu’est-ce qu’un système informatique?. . . . . . . . . . . . . . . . . . . . . . 15

Activité 1. structure d’un système informatique. . . . . . . . . . . . . . . . . . 16

1 Structure d’un ordinateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2 Unité centrale de traitement . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

Unité 1. Principes des Systèmes d’Exploitation 20

Quels sont les objectifs d’un système d’exploitation? . . . . . . . . . . . . . . . 20

Activité1. SE comme gestionnaire de ressources . . . . . . . . . . . . . . . . . . 21

Activité 2. Evolution des SE . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

Activité 3. Structure d’un SE. . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

Lectures et autres ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Unité 2. Gestion de processus 27

Activité 1. Processus et threads . . . . . . . . . . . . . . . . . . . . . . . . . . 28

Activité 2. Communication interprocessus . . . . . . . . . . . . . . . . . . . . . 38

Activité 2.3: Ordonnancement de processus . . . . . . . . . . . . . . . . . . . . 43

Activité 2.4 : Interblocages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

Résumé de l’unité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61

Évaluation de l’activité :. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61

Lectures et autres ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

Unité 3. Gestion de la mémoire 63

Comment se fait la gestion de la mémoire par le SE?. . . . . . . . . . . . . . . 63

Activité 1. Mémoire sans va-et-vient. . . . . . . . . . . . . . . . . . . . . . . . 64

Activité 3.2 : Le va-et-vient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

Activité 3.La mémoire virtuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

Évaluation de l’unité d’apprentissage . . . . . . . . . . . . . . . . . . . . . . 80

Lectures et autres ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

Unité 4. Gestion des périphérique et système de fichiers 83

Activité 1. Gestion des périphériques . . . . . . . . . . . . . . . . . . . . . . . 84

Activité 2. Le Système de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . 89

Activité 3.Organisation de l’espace des ressources et des fichiers . . . . . . . . . 94

Évaluation de l’activité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

Lectures et autres ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

Résumé de l’unité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

Évaluation de l’unité d’apprentissage . . . . . . . . . . . . . . . . . . . . . . 103

Unité 5. Sécurité et protection 104

Activité 1. Aperçu général sur la sécurité. . . . . . . . . . . . . . . . . . . . . 105

Évaluation de l’unité: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

Activité 3. Les mécanismes de protection . . . . . . . . . . . . . . . . . . . . . 108

Évaluation de l’activité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

Évaluation de l’activité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109