See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/332864969

Polycopié Systèmes d'Exploitation 1 Partie 1 (Cours)

Book · April 2019

CITATIONS READS

0 4,410

1 author:

Youssef Elmir
École supérieure en Sciences et Technologies de l'Informatique et du Numérique - ESTIN
28 PUBLICATIONS   122 CITATIONS   

SEE PROFILE

Some of the authors of this publication are also working on these related projects:

https://www.youtube.com/watch?v=V9ISVClmJTE View project

biometry View project

All content following this page was uploaded by Youssef Elmir on 04 May 2019.

The user has requested enhancement of the downloaded file.

 REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE
Ministère de l’Enseignement Supérieur et de la Recherche Scientifique
Université TAHRI Mohammed Béchar
Faculté des Sciences Exactes
Département des Mathématiques et Informatique

N° d’ordre : UTMB/FSE/PI /2019

Filière : Informatique
Spécialité : Systèmes Informatiques

Polycopié
Module : Système d’Exploitation 1

Systèmes d'Exploitation 1
Partie 1 (Cours)
2ème Année Licence en Informatique
Elmir Youssef

Année Universitaire :2018/2019

 Avant-propos
L'objectif de ce polycopié "Systèmes d'Exploitation 1, Partie 1 (Cours)" est
d'établir un support de cours pour guider les étudiants en deuxième année en
licence Informatique dans l'apprentissage de la première partie de matière
"Systèmes d'Exploitation". Le contenu de ce polycopié est adapté avec le
programme du canevas du socle commun pour présenter les principes de
fonctionnement des systèmes d'exploitation. Il est aussi important que l'étudiant
comprenne les concepts fondamentaux comme la gestion des fichiers, gestion de
la mémoire, gestion du processeur et gestion des entrées-sorties.

Ce document s’adresse aux étudiants et aux enseignants chargés du cours,

travaux dirigés ou travaux pratiques.

Cette première partie est organisée sous forme des chapitres du contenu
théorique.

Une deuxième partie sera préparée et organisée sous forme d’un tutoriel
contenant des fiches de travaux dirigés (exercices avec solutions) ainsi que des
fiches de travaux pratiques.

La bibliographie est rédigée soigneusement avec l’outil de gestion des sources

bibliographiques de Microsoft Word en utilisant le style de bibliographie de la
norme "GOST–Tri par ordre alphabétique des noms d’auteurs".

En fin, j’espère que ce polycopié pourra apporter un plus et une assistance

pédagogique aux enseignants chargés de cours, TD ou TP, ainsi qu’aux étudiants
dans leur formation en informatique.

Page | 2
Table des matières
Avant-propos ...................................................................................................................................... 2
Table des matières ........................................................................................................................ 3
I. Introduction aux systèmes d'exploitation ................................................................................... 6
I.1. Définition d'un système d'exploitation ................................................................................ 6
I.1.1. Rappels sur l'architecture des ordinateurs ......................................................................... 6
I.1.2. Définition du système d'exploitation ................................................................................. 9
I.2. Fonctions d'un système d'exploitation ................................................................................ 9
I.2.1. La machine virtuelle .......................................................................................................... 9
I.2.2. La gestion et le partage des ressources ............................................................................. 9
I.2.3. Les outils d'exploitation..................................................................................................... 9
I.3. Organisation en couches d'un système d'exploitation ........................................................ 10
I.4. Virtualisation de la machine.............................................................................................. 10
I.5. Evolution des systèmes informatiques .............................................................................. 11
I.5.1. Un rapide historique ....................................................................................................... 11
I.5.2. Les entrées-sorties .......................................................................................................... 11
I.5.3. Multiprogrammation....................................................................................................... 11
I.5.4. Les compilateurs ............................................................................................................. 12
I.5.5. Mémoire virtuelle ........................................................................................................... 12
I.5.6. Les communications ........................................................................................................ 13
I.6. Exemples de systèmes d'exploitation ................................................................................ 13
II. Mécanismes de base d’exécution des programmes .................................................................. 16
II.1. Structure matérielle d'une machine de Von Neumann ...................................................... 16
II.2. Cheminement d'un programme dans un système ............................................................. 16
II.2.1. Editeur de texte (Text Editor) ......................................................................................... 17
II.2.2. Compilateur (Compiler) .................................................................................................. 17
II.2.3. Editeur de liens (Linker) .................................................................................................. 18
II.2.4. Le chargeur (Loader) ...................................................................................................... 19
II.3. Concepts de processus et multiprogrammation ................................................................ 19
II.3.1. Définition ....................................................................................................................... 19
II.3.2. Contexte d’un processus ................................................................................................ 19
II.3.3. Image mémoire d’un processus ...................................................................................... 20
II.3.4. Descripteur de Processus (PCB) ...................................................................................... 20
II.3.5. Etat d’un processus ........................................................................................................ 22

Page | 3
 II.3.6. Multiprogrammation...................................................................................................... 22
II.3.7. Mécanisme de commutation de contexte ...................................................................... 22
II.4. Les systèmes d'interruption ............................................................................................. 23
II.4.1. Définition et organigramme général d'une interruption. ................................................ 23
II.4.2. Mécanismes de gestion des interruptions ...................................................................... 24
II.4.3. Systèmes d'interruption sur les PCs. ............................................................................... 25
III. Gestion des Entrées / Sorties physiques .................................................................................. 26
III.1. Définition d'une E/S ........................................................................................................ 26
III.2. Types d'E/S ..................................................................................................................... 26
III.3. Organisation des transferts ............................................................................................. 26
III.3.1. Instructions d'E/S .......................................................................................................... 26
III.3.2. Découpage fonctionnel matériel/logiciel d'une E/S........................................................ 27
III.4. Modes de pilotage d'une E/S : ......................................................................................... 27
III.4.1. Pilotage synchrone ........................................................................................................ 27
III.4.2. Pilotage asynchrone ...................................................................................................... 28
III.5. Gestion d’E/S simultanées .............................................................................................. 28
IV. Gestion du processeur central ................................................................................................ 30
IV.1. Définition ....................................................................................................................... 30
IV.2. Objectifs de scheduling. .................................................................................................. 30
IV.3. Critères de scheduling. ................................................................................................... 30
IV.4. Niveaux de scheduling .................................................................................................... 30
IV.5. Politiques de scheduling. ................................................................................................ 31
IV.5.1. First in first out FIFO (first come first served FCFS) ........................................................ 31
IV.5.2. Short job first SJF .......................................................................................................... 31
IV.5.3. Avec priorité ................................................................................................................. 32
IV.5.4. Tourniquet .................................................................................................................... 32
IV.6. Contrôle de processus .................................................................................................... 33
IV.6.1. Etats d'un processus ..................................................................................................... 33
IV.6.2. Bloc de contrôle de processus PCB ................................................................................ 33
IV.6.3. Création de processus ................................................................................................... 34
IV.6.4. Destruction d'un processus ........................................................................................... 35
V. Gestion de la mémoire centrale............................................................................................... 36
V.1. Objectifs d'un gestionnaire de la mémoire. ...................................................................... 36
V.1.1. Rôle ............................................................................................................................... 36

Page | 4
 V.1.2. Exigence ........................................................................................................................ 37
V.2. Fonctions. ...................................................................................................................... 37
V.3. Modes de partage de la mémoire. ................................................................................... 38
V.3.1. Système mono-programmé............................................................................................ 38
V.3.2. Système multiprogrammé .............................................................................................. 38
V.4. Protection de la mémoire. .............................................................................................. 40
V.4.1. Système mono-programmé............................................................................................ 40
V.4.2. Système multiprogrammé .............................................................................................. 41
V.5. Partage de code. ............................................................................................................. 42
V.5.1. Code partagé ................................................................................................................. 42
VI. Gestion des périphériques ...................................................................................................... 43
VI.1. Les périphériques ........................................................................................................... 43
VI.1.1. Les périphériques graphiques........................................................................................ 43
VI.1.2. Les disques de stockage ................................................................................................ 43
VI.1.3. Ordonnancement du disque dur ................................................................................... 44
VII. Gestion des fichiers ............................................................................................................... 45
VII.1. Définition ...................................................................................................................... 45
VII.2. Le support physique ...................................................................................................... 45
VII.2.1. Formatage physique .................................................................................................... 45
VII.2.2. La taille du disque ........................................................................................................ 46
VII.2.3. Adresses sur le disque .................................................................................................. 46
VII.2.4. Les temps d'accès ........................................................................................................ 48
VII.2.5. Formatage logique ....................................................................................................... 49
VII.3. Organisation de l'espace disque ..................................................................................... 49
VII.4. Gestion des blocs libres ................................................................................................. 49
VIII. Conclusion ........................................................................................................................... 51
IX. Bibliographie ......................................................................................................................... 52

Page | 5
I. Introduction aux systèmes d'exploitation

I.1. Définition d'un système d'exploitation

I.1.1. Rappels sur l'architecture des ordinateurs

Les trois éléments essentiels d'un ordinateur sont, du moins pour ce qui nous concerne, le
processeur, la mémoire et le dispositif de gestion des entrées-sorties. Ils communiquent entre
eux par l'intermédiaire du bus. Schématiquement un ordinateur peut être symbolisé comme
suit :

Figure 1. Schéma de principe d'un ordinateur.

Le bus est le circuit d'échange des informations. Son débit ou bande passante est
un paramètre important pour définir la rapidité d'une machine. Souvent, dans les micro-
ordinateurs, elle est trop faible par rapport à la rapidité du processeur. Celui-ci attend
fréquemment les informations en provenance de la mémoire ou des contrôleurs d'entrées-
sorties. Dans le schéma ci-dessus on ne les a pas distingués mais un écran et un disque ne
sont pas branchés sur le même contrôleur. Par exemple on trouve les mêmes processeurs
PowerPC dans les Macintoshs et certaines machines SP (Scalable POWERparallel) d'IBM
(International Business Machines Corporation). La rapidité du bus et sa bande passante ne
sont pourtant pas les mêmes, ce qui est une explique des différences de performances comme
de prix. Les ordinateurs les plus performants possèdent un bus qui permet de transférer en
parallèle 256 bits ou plus, les moins performants 32 bits seulement. Il faut donc plus de
cycles pour transférer une information de même longueur (c'est à dire contenant le même
nombre de bits) de la mémoire vers le processeur et la rapidité effective de la machine n'a
rien à voir avec celle du processeur. Un processeur moderne peut contenir plusieurs unités de
calcul, additionneur, multiplicateur entier ou flottant. Certains peuvent effectuer des
opérations plus complexes comme plusieurs additions et multiplications flottantes
simultanément. Le processeur peut donc réaliser plusieurs instructions élémentaires
parallèlement. Les plus puissants possèdent une structure, appelée pipe-line qui permet
d'enchaîner, dans certains cas, une opération à chaque cycle d'horloge alors que la précédente
n'est pas terminée. Ceci accélère considérablement le débit de calcul. Cette complexité
explique que la cadence de l'horloge ne permette pas de comparer des processeurs
d'architecture différente. Deux directions se font jour pour augmenter les performances:
compliquer l'architecture interne du processeur mais conserver un cycle relativement lent
(IBM Power par exemple) ou diminuer le temps de cycle (Intel par exemple) mais avec une
architecture plus simple. Il n'existe pas de meilleur choix: suivant les programmes l'une ou
l'autre architecture se révèle la meilleure. Les unités de commande travaillent selon les
processeurs sur des mots de 32 bits (Intel Pentium IV) ou, de plus en plus aujourd'hui, sur 64

Page | 6
bits (AMD (Advanced Micro Devices) Athlon, IBM Power...). Le jeu d'instructions varie
fortement d'une réalisation à l'autre : instructions courtes RISC (reduced instruction set
computer) (Power IBM, Sparc Sun, Intel Itanium par exemple) ou longues (Intel Pentium,
AMD Athlon). Le code d'un langage évolué correspond donc à un nombre plus ou moins
grand d'instructions machine et la comparaison des performances est beaucoup plus
compliquée que la simple mesure des cycles d'horloge.

Les processeurs modernes intègrent dans leur puce une mémoire cache accessible très
rapidement pour accélérer les opérations. On ajoute également un deuxième niveau de
mémoire, placée juste à côté du processeur sur la carte mère, connue sous le nom de cache
niveau 2 ou L2. Les communications avec le processeur sont plus rapides que celles avec la
mémoire car elles ne passent pas par le bus dont la bande passante est bien inférieure au débit
que peut accepter le processeur. Lorsqu'une instruction ou une donnée est contenue dans un
cache son fonctionnement est accéléré car il n'attend plus un transfert. Le processeur
demande simultanément l'information voulue à la mémoire et aux caches. Lorsqu'elle est
disponible dans celles-ci la réponse arrive très rapidement et la requête est abandonnée. On a
donc intérêt à posséder des caches de grande dimension car, statistiquement, la chance d'y
retrouver une information est plus grande. Idéalement toute la mémoire devrait être un
immense cache accessible très rapidement mais cela exploserait le prix des machines. C'est le
cas des superordinateurs comme les Cray qui ne possèdent pas de caches. La mémoire est
construite avec les dispositifs les plus rapides, identiques à ceux utilisés dans les caches des
machines ordinaires. Les performances sont optimales mais le coût est absolument prohibitif!

La mémoire est organisée, dans tous les ordinateurs, en groupes de 8 bits appelés octets ou
bytes en anglais. Chaque octet possède une adresse numérique. Cependant le quantum
manipulé par le processeur est le mot qui regroupe de quatre à huit octets selon le processeur.
Le mot est de deux octets dans les micro-ordinateurs anciens. Les ordinateurs personnels et
les stations de travail utilisent des mots de quatre ou huit octets. Les superordinateurs Cray
possèdent des mots de huit octets. L'accès à la mémoire se fait de façon matricielle, selon des
lignes et des colonnes. Comme une ligne ou une colonne qui vient d'être lue ou écrite est
inhibée pendant un certain temps appelé temps de latence, la mémoire est divisée en bancs.
Deux octets dont les adresses sont consécutives sont placés dans des bancs différents ainsi
plusieurs bancs peuvent être accédé simultanément, ce qui améliore les échanges avec le
processeur. Il ne faut pas oublier que le temps d'accès à la mémoire est bien plus long que le
temps de cycle du processeur, de l'ordre de quatre fois au minimum. Multiplier les bancs
permet d'échanger plus rapidement plusieurs informations entre le processeur et la mémoire.
Un PC comporte habituellement quatre bancs, une grosse machine seize ou plus. Chaque
octet est accompagné d'un certain nombre de bits qui servent au contrôle d'erreurs et à leur
correction lors des échanges. Ce nombre peut atteindre 8 sur les gros ordinateurs, il est limité
à un seul sur les micro-ordinateurs. La fiabilité, les capacités de fonctionner en
environnement dégradé, sont liées à ce nombre. On comprend donc pourquoi,
indépendamment de sa rapidité, le prix de la mémoire varie avec les modèles de machines.

Il faut distinguer le rôle des différentes mémoires qui existent dans la machine. Les disques
servent à stocker l'information de façon permanente. Leur contenu se conserve même lorsque
l'ordinateur n'est plus sous tension. Cependant comme les transferts entre ces périphériques et
le processeur sont lents, celui-ci ne travaille jamais directement avec ces supports. Le
processeur échange ses informations avec la mémoire et la mémoire dialogue avec les
disques. Pour exécuter un programme il faut donc d'abord le déplacer du support permanent
(le disque) vers la mémoire. Puis, au cours de l'exécution les données lues dans les fichiers

Page | 7
sont déplacées par morceaux des disques vers la mémoire pour être employées par le
processeur. Il en est de même, en sens inverse, pour les écritures. Il existe un mécanisme
caché en deux étapes qui fait obligatoirement transiter les échanges par la mémoire. Cette
hiérarchie se retrouve également dans les échanges entre la mémoire et le processeur avec les
caches. Le processeur recherche ses informations d'abord dans ceux-ci. Ceci met en œuvre
des algorithmes complexes car il faut savoir gérer les cas où les données recherchées ne s'y
trouvent pas. Enfin il faut également considérer le rôle des registres, véritable mémoire
interne du processeur. L'utilisateur n'y accède pas directement mais un compilateur bien écrit
sait en tenir compte.

Il convient de ne pas confondre la taille de la mémoire qui définit les possibilités logicielles
de la machine et la taille des disques qui indique sa capacité à stocker des informations
permanentes. Le couple longueur du mot, longueur du registre d'adresse (ou compteur
ordinal) est la première notion de l'architecture physique visible de l'extérieur. En particulier
il permet de définir les tailles maximum des programmes et des tableaux : tous les adressages
nécessaires pour accéder aux informations que ce soit dans la mémoire ou sur disque se font
au moyen de nombres entiers. Une architecture à mot de 32 bits permet donc d'adresser un
peu plus de quatre Giga-octets et il devient impossible d'adresser directement un système de
fichiers ou une mémoire plus grande. Il faut se déplacer par indirection au moyen
d'informations relais jamais séparées par une distance supérieure à cette valeur fatidique, ce
qui diminue fortement l'efficacité de l'ordinateur. On comprend donc pourquoi aujourd'hui on
développe des processeurs à mot de 64 bits : l'ordre de grandeur du plus grand entier est 1,8
1019, ce qui laisse une marge certaine pour les disques et les mémoires que l'on sait fabriquer
aujourd'hui !

Le troisième paramètre important pour l'utilisateur est la largeur du bus qui définit combien
de bits peuvent être transférés en parallèle. La rapidité de travail effectif d'une machine y est
très sensible. Les contrôleurs sont construits pour assurer les communications avec les
périphériques. Ils sont spécialisés dans leur usage et possèdent leur propre mémoire. Un
contrôleur d'écran stocke ainsi une partie des informations qu'il présente à l'utilisateur. Un ou
des processeurs auxiliaires présents sur la carte assurent le fonctionnement de base. Le
problème fondamental est de réussir à faire fonctionner cet ensemble, à assurer les échanges
d'information entre les différents éléments qui constituent la machine et surtout, du point de
vue de l'utilisateur, à dialoguer avec lui. C'est le rôle du système d'exploitation. A titre
d'exemple, voici quelques performances mesurées entre deux machines qui diffèrent
essentiellement par leur processeur. La première est équipée d'un Pentium MMX, la seconde
d'un Pentium II, tous les deux à 233 MHz. Les disques sont les mêmes ainsi que la mémoire.
Le programme de mesure est Wintune 95 et le système d'exploitation Windows 95. Certes ces
données sont anciennes mais elles permettent de comprendre l'influence de l'architecture et le
peu d'intérêt qu'il faut porter à la vitesse d'horloge, sauf lorsqu'il s'agit de processeurs de la
même famille qui ne différent que par leur cadence d'horloge. Le résultat est intéressant
quoiqu'il faille toujours considérer des tests avec la plus extrême prudence.

Tableau 1. Résultats de tests des processeurs

Test Pentium MMX Pentium II (PII)

Lecture d'un bloc de 32 Koctets 225 Mb/s 419 Mb/s
Ecriture d'un bloc de 32 Koctets 85 Mb/s 209 Mb/s
Lecture d'un bloc de 4 Kb 1173 Mb/s 873 Mb/s
Ecriture d'un bloc de 4 Kb 85 Mb/s 1107 Kb/s

Page | 8
Que signifie ce test ? Comme l'architecture interne des deux processeurs n'est pas la même
ces différences peuvent provenir de la taille des caches (plus grands pour le PII) comme de
l'efficacité des instructions. On a cependant le sentiment que le PII ne prend toute son
efficacité que lorsque la taille des blocs échangés est suffisamment grande. Et ceci dépend
beaucoup des codes des programmes mais aussi de celui du système d'exploitation. Les gains
peuvent donc être fort décevants lorsqu'on change de processeur sans se préoccuper des
programmes.

I.1.2. Définition du système d'exploitation

Il existe plusieurs définitions possibles des systèmes d’exploitation.

Un système d'exploitation peut être vu comme un programme agissant en tant

qu’intermédiaire entre l’utilisateur et le matériel de l’ordinateur. Le but principal d’un
système d’exploitation est de fournir un environnement qui permet à un utilisateur d’exécuter
des programmes.

Un système informatique doit savoir répondre aux demandes suivantes:

 gestion de l'information: stockage, désignation, recherche, communications... Le

stockage comprend la gestion des périphériques.
 désignation et recherche sont liées notamment à l'architecture du système de fichier.
 préparation et mise au point des programmes
 exploitation des programmes.

I.2. Fonctions d'un système d'exploitation

Les principales fonctions du système d'exploitation peuvent être classées en trois rubriques:

I.2.1. La machine virtuelle

 fonctions de gestion de l'information: structuration, conservation, désignation

(mémoire virtuelle, fichiers...). Ceci concerne aussi bien l'information stockée sur les
mémoires périphériques que dans celle de l'ordinateur.
 transferts entre les différents éléments de la machine. Ceci concerne les échanges
entre les différentes parties: mémoire, processeur, périphériques... Voir la figure 1.
 fonctions d'exécution: exécution des programmes en parallèle, en séquence.

I.2.2. La gestion et le partage des ressources

 gestion des ressources physiques: allocation de la mémoire principale et de la

mémoire secondaire (fichiers), gestion des organes d'entrées-sorties.
 partage et échange de l'information entre utilisateurs
 protection mutuelle entre utilisateurs, sécurité.

I.2.3. Les outils d'exploitation

 compilateurs, aide à la mise au point de programmes.

 outils de sauvegarde, d'archivage, traitement des défaillances.

Page | 9
  éditeurs, outils divers...

La plupart des utilisateurs ne connaissent que ce troisième niveau. Sa richesse, sa facilité

d'emploi, sa souplesse définissent la qualité d'un système d'exploitation du moins pour le non-
spécialiste.

I.3. Organisation en couches d'un système d'exploitation

Conceptuellement si on représente l'ensemble des fonctions d'un système d'exploitation sous

forme de couches, on pourrait les décrire comme suit :

Figure 2. Couches du système d'exploitation.

Le logiciel d'application, celui développé par l'utilisateur ou installé à la demande, comme un

traitement de texte, par exemple, utilise des fonctions intrinsèques au système d'exploitation.
L'utilisateur y a également accès soit directement soit par l'intermédiaire d'utilitaires livrés
avec le système. La machine physique n'est accessible qu'au travers du logiciel de base. Ce
schéma n'est pas tout à fait rigoureux. Il est délicat de tracer la limite entre logiciels
applicatifs et de base. Un système sophistiqué d'utilitaires de gestion des fichiers comme
PCTools pour micro-ordinateurs "IBM compatibles" est un applicatif car il est ajouté par
l'utilisateur. Compris dans la livraison initiale il serait considéré comme logiciel de base !

A l'intérieur même du logiciel de base, on peut distinguer deux couches:

 Les outils, les services, les compilateurs, éditeurs, communications ...

 Le système d'exploitation

Là encore la distinction n'est pas nette entre certains outils et le système d'exploitation. Les
communications peuvent également être considérées comme partie du système.

I.4. Virtualisation de la machine

Une des premiers systèmes d'exploitation à gérer le concept de machine virtuelle (l'adaptation
du temps partagé) a été l'OS/360 d'IBM, proposé vers 1968 sous le nom de CP/CMS (Control
Program/Cambridge Monitor System), puis sous le nom de VM/370 (Virtual Machine
Facility) en 1979.

Le cœur du système d'exploitation, appelé moniteur de machine virtuelle ou VM/370,

s'exécute sur le même matériel et fournit à la couche supérieure plusieurs machines virtuelles.
Ces machines virtuelles sont des copies conformes de la machine réelle avec ses
interruptions, ses modes noyau/utilisateur,… etc.

Chaque machine virtuelle peut exécuter son propre système d'exploitation. Lorsqu'une
machine virtuelle exécute en mode interactif un appel système, l'appel est analysé par le

Page | 10
moniteur temps partagé de cette machine, CMS. Toute instruction d'entrées/sorties (E/S),
toute instruction d'accès mémoire est convertie par VM/370 qui l’exécute dans sa simulation
du matériel. La séparation complète de la multiprogrammation et de la machine étendue rend
les éléments du système d'exploitation plus simples et plus souples. VM/370 a gagné de la
simplicité en déplaçant une grande partie du code d'un système d'exploitation dans le
moniteur CMS.

I.5. Evolution des systèmes informatiques

I.5.1. Un rapide historique

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 étaient é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 nait 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

I.5.2. Les entrées-sorties

Les échanges entre la mémoire et le processeur sont très rapides. Le débit des périphériques
est beaucoup plus lent, surtout lorsqu'il met en œuvre des éléments mécaniques. D'où l'idée
de tampons (ou buffers), zones spéciales de la mémoire réservées au stockage de
l'information en attente de transfert. Dans les machines les plus performantes les contrôleurs
d'E/S sont de véritables ordinateurs affectés uniquement à cette tâche.

I.5.3. Multiprogrammation

La multiprogrammation ne doit pas être confondue avec le temps partagé qui apparaitra plus
tard. L'idée part du constat que le processeur est mal employé à chaque fois qu'un programme
est interrompu par l'attente d'une communication avec un périphérique : plutôt que de le

Page | 11
mettre en sommeil pourquoi ne pas l'affecter à une autre tâche ? Un ensemble de programmes
est donc chargé simultanément en mémoire, leur exécution est chainée, c'est à dire que le
processeur exécute successivement des séquences d'instructions pour chacun. Le passage de
l'un à l'autre est optimisé de façon à occuper au mieux la partie la plus précieuse de la
machine: le processeur. L'unité centrale est affectée à une nouvelle tâche chaque fois qu'un
programme est en attente d'échanges, c'est à dire effectue des entrées-sorties. La commutation
des tâches doit être très rapide. Il faut aussi que le débit des échanges entre la mémoire et le
processeur soit suffisant pour que ceci ne soit pas le facteur de blocage. La bande passante du
bus doit donc être grande. Un système multitâche est complexe car il faut sauvegarder le
contexte de travail de chaque programme lorsque son exécution est interrompue. De plus il
n'est pas aisé de se prémunir contre des blocages possibles lorsque toutes les tâches se
mettent en attente d'une ressource déjà réservée.

I.5.4. Les compilateurs

L'emploi des premiers ordinateurs était une affaire d'hyper-spécialistes puisqu'on doit coder
directement en langage machine voire en binaire ! Dès le milieu des années 50 des
théoriciens se demandent s'il est possible d'imaginer un langage proche de l'expression
humaine et un outil capable de le traduire en code binaire tout en optimisant le code réalisé.
Un compilateur traduit un programme écrit dans un langage aussi naturel que possible en un
code binaire compréhensible par l'ordinateur. Il peut éventuellement optimiser son
déroulement. Par exemple, tous les compilateurs savent détecter dans les boucles les
instructions qui ne dépendent pas de celles-ci et sont donc répétées inutilement. Ils les
déplacent automatiquement. De même ils savent utiliser les jeux de registres du processeur
pour minimiser les transferts de et vers la mémoire. Le premier compilateur est apparu en
1961. Il s'agit de Fortran, langage orienté vers le calcul scientifique (FORmulae
TRANslation), développé à l'époque dans l'unique but de vérifier s'il était possible d'écrire un
tel outil. Il ne faut pas confondre un compilateur avec un interpréteur - Basic fut le premier -
qui lit puis décode chaque instruction successivement au moment de son exécution. Depuis
bien d'autres langages ont été inventé. Mentionnons le langage C, inventé pour développer
plus rapidement qu'en langage assembleur un nouveau système d'exploitation : il s'agissait
d'Unix.

I.5.5. Mémoire virtuelle

Pendant longtemps le coût des dispositifs électroniques et leur manque de compacité ne

permettait de construire que des mémoires de petite taille. Dans les années 60, par exemple,
les super-ordinateurs possédaient une mémoire partie sous forme de micro-bobines
électromagnétiques, partie sous forme de transistors et leur dimension n'excédait pas
quelques centaines de Koctets ! Le souci était donc également d'optimiser son usage.

Très schématiquement il s'agit d'un dispositif qui permet de simuler la mémoire de

l'ordinateur sur un disque (zone de swap). Seules les informations nécessaires à l'activité
immédiate résident, à un instant donné, dans la vraie mémoire. Ceci permet d'exécuter des
programmes dont la taille est supérieure à la mémoire réelle de la machine. Le mauvais côté
de cette invention est qu'il faut multiplier les échanges entre le disque et la mémoire pour la
mettre à jour. Il faut donc disposer de périphériques et de contrôleurs d'entrées-sorties
rapides.

Page | 12
I.5.6. Les communications

Les années 80 ont été marquées par le développement des échanges d'informations entre
ordinateurs. Les systèmes se sophistiquent jusqu'à faire éclater l'organisation en étoile qui
prévalait jusqu'alors: tous les terminaux, tous les périphériques étaient alors reliés à une
machine unique qui centralisait toutes les fonctions. Les réseaux, en conjonction avec
l'effondrement du prix des mémoires et des processeurs et l'augmentation vertigineuse de leur
rapidité, vont amener à la notion d'informatique distribuée. Les machines sont déplacées près
des hommes. Il apparaît la notion de serveur, machine virtuelle répartie éventuellement sur
plusieurs machines physiques, répondant aux requêtes d'utilisateurs distribués
géographiquement sur un grand territoire: serveur de fichiers, serveur de calcul, de
messagerie... Le réseau devient le bus d'une espèce de machine virtuelle à l'échelle d'un
campus ou d'une entreprise. La demande croissante de puissance fait apparaître les machines
multiprocesseurs et les ordinateurs massivement parallèles. Dans tous les cas ceci revient à
faire travailler ensemble plusieurs processeurs (de quelques-uns à quelques milliers) pour
exécuter une ou plusieurs tâches. Le gros problème, loin d'être résolu aujourd'hui, est de faire
coopérer cet ensemble. Les machines multiprocesseurs sont limitées par les conflits dans
l'accès à une mémoire commune. On montre qu'il est inutile de dépasser quelques dizaines de
processeurs dans le meilleur des cas car le gain devient de plus en plus faible et se révèle trop
onéreux. Les ordinateurs parallèles sont des machines où chaque processeur dispose de sa
propre mémoire. Le point critique est l'échange des informations entre ces processeurs qui
doivent coopérer. Il n'existe pas de compilateur capable de générer automatiquement le code
parallèle et leur programmation demande de grands efforts. Ils sont encore largement
expérimentaux même si tous les grands constructeurs commencent à en produire.

I.6. Exemples de systèmes d'exploitation

Comme son nom l'indique l'ordinateur individuel n'est employé que par une seule personne à
la fois. Celle-ci dispose de moyens de communication: écran, clavier, souris, une imprimante
et éventuellement d'une tablette graphique. Des mémoires secondaires appelées aussi unités
de stockage: disque, disquette ou bande magnétique permettent de conserver l'information de
façon permanente. La taille de la mémoire principale est un paramètre important pour définir
quels programmes peuvent être employés. Le système d'exploitation gère cet ensemble de
façon plus ou moins transparente pour l'utilisateur. Il permet de donner des ordres à la
machine et d'en recevoir en retour des informations qui sont le résultat du traitement
demandé. Les ressources de l'ordinateur ne sont employées que par l'unique usager de la
machine. Quelques fonctions peuvent s'exécuter simultanément. Par exemple il est possible
d'afficher une horloge tout en utilisant un traitement de textes ou graver un CD (Compact
disc) mais la simultanéité n'est pas le point de force de cette machine. Ce parallélisme qui
n'est qu'apparent s'améliore dans les dernières versions des systèmes d'exploitation et parce
que la puissance des processeurs ne cesse de croître. Les mécanismes de sécurité nécessaires
pour préserver la confidentialité des informations sont peu ou mal employés lorsqu'ils
existent.

Un ordinateur qui contrôle un procédé industriel doit veiller sur un ensemble de paramètres
physiques et engager des actions en fonction de leurs valeurs. Les délais de réponse peuvent
être très courts et doivent être toujours garantis. Ceci est particulièrement vrai en ce qui
concerne la sécurité: au cas où certains paramètres sortiraient de leur plage de valeurs
normales il est indispensable de réagir de façon appropriée en un temps défini. Un système

Page | 13
d'exploitation orienté temps réel doit donc pouvoir garantir une réponse avec une contrainte
dans le temps.

Ceci introduit deux contraintes importantes :

 Les informations doivent être acquises sur les différents dispositifs d'entrés
périodiquement. Cette période doit être respectée précisément ainsi qu'il a été
défini dans le cahier des charges. Le traitement de ces informations est effectué en un
temps maximum T. Ce temps peut être défini soit port d'entrée par port d'entrée soit
pour l'ensemble des mesures à acquérir mais il est évident que le système ne pourra
fonctionner correctement que si, dans tous les cas, T est plus petit, voire beaucoup
plus petit que .
 Les fonctions de sécurité sont prioritaires, certaines le sont plus que d'autres. Il faut
donc disposer des moyens matériels et logiciels pour gérer ces priorités et pouvoir, le
cas échéant, interrompre toute activité moins prioritaire.
 Il doit également présenter la souplesse nécessaire pour que l'on puisse aisément
piloter des dispositifs au travers de cartes électroniques standards du marché.

De tels systèmes sont appelés systèmes temps réel. Certains systèmes d'exploitation peuvent
s'en rapprocher, notamment parce que la puissance des processeurs aujourd'hui permet à un
système de répondre relativement rapidement, mais sans disposer de toutes les fonctions qui
pourraient permettre de garantir les délais de traitement. Enfin n'oublions pas que les
commandes de processus industriel doivent être particulièrement fiables, en relation avec le
niveau de sécurité exigé, ce qui peut nécessiter des dispositifs électroniques et logiques
supplémentaires. Dans certains cas plusieurs ordinateurs effectuent le même travail,
comparent en permanence leurs résultats et prennent une décision ... à la majorité!

Le cas des systèmes embarqués est particulier : outre les contraintes des systèmes temps réel
il est impossible pour des raisons diverses; (environnement, volume, poids..) d'employer les
composants que l'on retrouve dans la plupart des ordinateurs. Il faut alors employer des
systèmes d'exploitation spécifiques, le plus souvent allégés et ne comportant que les fonctions
utiles. Ne parlons pas des systèmes militaires et spatiaux !

La caractéristique fondamentale d'un système transactionnel est de gérer un ensemble

d'informations structurées de grande dimension, de l'ordre de plusieurs giga-octets, appelé
base de données. Ces informations sont consultées, modifiées simultanément à partir d'un
grand nombre de points d'accès, terminaux ou micro-ordinateurs. Les contraintes d'intégrité
sont énormes. L'exécution d'un ordre ou transaction doit préserver la cohérence de la base.
Par exemple il est nécessaire d'afficher l'état exact des places disponibles dans un train tout en
évitant qu'un siège puisse être réservé plusieurs fois au même moment à partir de deux
terminaux différents. Ces systèmes doivent être très fiables puisque leur arrêt, même très
court bloquerait un nombre important de personnes. En cas d'interruption du service il faut
pouvoir redémarrer les nombreuses activités parallèles de façon cohérente sans perte
d'information, dans l'état exact où était le système avant cette interruption. On mesure les
performances en nombre de transactions par secondes (TPS).

L'invention du temps partagé est le fruit d'une simple constatation: l'homme est beaucoup
plus lent que la machine et prend un temps non négligeable pour élaborer une requête ou
analyser les réponses de l'ordinateur. Dans toute phase d'interaction la machine attend. La
fonction d'un système temps partagé est donc de donner à tous ces acteurs humains

Page | 14
l'impression qu'ils sont chacun seul en face de la machine. Chacun doit avoir le sentiment que
l'ordinateur est à sa disposition; la qualité du service sera appréciée en termes de temps de
réponse. Il faut donc ajouter les services adéquats pour tenir compte du fait que l'ordinateur
est utilisé simultanément par un grand nombre de personnes. On combine donc dans un tel
système les aspects évoqués pour les ordinateurs individuels et transactionnels. Il faut ajouter
un programme gestionnaire qui partage le temps disponible entre les différents utilisateurs.
Par exemple, si on estime que 90% du temps passé devant un terminal est un temps de
réflexion indispensable entre requêtes successives, 10% des utilisateurs seulement sont
réellement actifs à un moment donné. Si le programme gestionnaire alloue des tranches de
temps de 50 ms à chacun, le temps d'attente moyen est donc de 0,5s environ pour ces dix
utilisateurs (ce ne sont jamais les mêmes). La machine peut être utilisée en fait par cent
personnes.

De tels systèmes ne sont pas adaptés aux travaux qui nécessitent peu de dialogues. On
remplace alors le terminal par un ensemble de fichiers utilisés soit en lecture soit en écriture.
Ces programmes sont exécutés en traitement par lot ou batch. Leur déroulement est
volontairement ralenti par rapport aux tâches qui dialoguent avec les hommes. On diminue
donc la priorité - déjà évoquée pour les systèmes temps réel - de ces calculs. Les systèmes en
temps partagé sont souvent employés pour le temps réel et le transactionnel, en leur ajoutant
le cas échéant les quelques fonctionnalités qui leur manquent.

Aujourd'hui deux systèmes prédominent : Windows, dans toutes ses variations, sur les postes
personnels, Unix et de plus en plus sa version Linux, sur les serveurs et les gros ordinateurs
(Windows est réservé aux processeurs Intel). La puissance des processeurs permet
d'employer l'un ou l'autre système pour couvrir la plupart des gammes d'application, au
moyen de modules spécifiques éventuellement. Windows ne dispose pas des éléments
nécessaires au temps partagé mais parvient à servir plusieurs utilisateurs simultanés, s'ils sont
physiquement connectés à un autre poste relié par le réseau, en employant une technologie
client-serveur.

Page | 15
II. Mécanismes de base d’exécution des programmes
II.1. Structure matérielle d'une machine de Von Neumann

Cette architecture est appelée ainsi en référence au mathématicien John Von Neumann qui a
élaboré la première description d’un ordinateur dont le programme est stocké dans sa
mémoire. L’architecture dite architecture de Von Neumann est un modèle pour un ordinateur
qui utilise une structure de stockage unique pour conserver à la fois les instructions et les
données demandées ou produites par le calcul. De telles machines sont aussi connues sous le
nom d’ordinateur à programme enregistré. La séparation entre le stockage et le processeur est
implicite dans ce modèle.

Figure 3. Schématisation de l'architecture de Von Neumann.

L’architecture de Von Neumann décompose l’ordinateur en 4 parties distinctes :

1. L’unité arithmétique et logique (UAL) ou unité de traitement : son rôle est d’effectuer
les opérations de base ;
2. L’unité de contrôle, chargée du « séquençage » des opérations ;
3. la mémoire qui contient à la fois les données et le programme qui indiquera à l’unité
de contrôle quels sont les calculs à faire sur ces données. La mémoire se divise entre
mémoire volatile (programmes et données en cours de fonctionnement) et mémoire
permanente (programmes et données de base de la machine) ;
4. les dispositifs d’entrée-sortie, qui permettent de communiquer avec le monde
extérieur.

II.2. Cheminement d'un programme dans un système

Le passage d’un programme de la forme externe à la forme interne se fait en plusieurs étapes.
Un programme est généralement écrit dans un langage évolué (Pascal, C, VB, Java, etc.).
Pour faire exécuter un programme par une machine, on passe généralement par les étapes
suivantes:

Page | 16
 Figure 4. Cheminement d’un programme dans un système

II.2.1. Editeur de texte (Text Editor)

C’est un logiciel interactif qui permet de saisir du texte à partir d’un clavier, et de
l’enregistrer dans un fichier.

Exemple : Bloc-Notes, vi, vim, emacs, …etc.

II.2.2. Compilateur (Compiler)

Un compilateur est un programme qui traduit des programmes écrits dans des langages
évolués (Pascal, C, Ada, Java, …etc.) en programmes binaires ou en langage machine,
appelés aussi objets.

Le langage machine est un ensemble de codes binaires directement décodables et

exécutables par la machine.

Page | 17
II.2.3. Editeur de liens (Linker)

Un programme source peut être constitué :

1. des instructions,
2. des données localement définies,
3. des données externes, et
4. des procédures ou sous-programmes externes (bibliothèques de fonctions).

Avant d’exécuter le programme objet, il est nécessaire de rassembler les parties non locales et
les procédures externes avec le programme.

L’éditeur de liens est donc un logiciel permettant de combiner plusieurs programmes objets
en un seul programme.

Figure 5. Principe d’édition de liens

Pour pouvoir développer de gros programmes, on structure ceux-ci en modules que l’on
traduit indépendamment. Ainsi, un programme peut être constitué de plusieurs fichiers dont
l’un est le programme principal. Ce dernier fait appel aux sous-programmes, ce qui donne
lieu à des références extérieures.

Lors de la compilation, le compilateur ne peut pas remplacer les références extérieures par les
adresses correspondantes puisqu’il ne les connaît pas. Le programme objet généré contient

Page | 18
donc le code machine des instructions et la liste des références extérieures, ainsi que la liste
des adresses potentiellement référençables depuis l’extérieur du module. Après la
compilation, chaque sous-programme commence à l’adresse logique 0.

L’éditeur de liens ordonne les sous-programmes et le programme appelant, modifie les

adresses de chacun d’eux et produit un programme final dont l’origine est à l’adresse 0.

II.2.4. Le chargeur (Loader)

Après l’édition de liens, le programme exécutable doit se trouver en mémoire centrale pour
être exécuté. Le chargeur est un programme qui installe ou charge un exécutable en mémoire
centrale à partir d’une adresse déterminée par le système d’exploitation.

Figure 6. Chargement d'un programme exécutable.

II.3. Concepts de processus et multiprogrammation

II.3.1. Définition

Un processus (Process en anglais) est un programme en cours d’exécution. Tout processus

possède des caractéristiques propres (Ex. un numéro d’identification), des ressources qu’il
utilise (comme des fichiers ouverts) et se trouve à tout moment dans un état (en exécution ou
en attente …).

Un processus est constitué d’ :

− Un code exécutable du programme en exécution.

− Un contexte qui est une image décrivant l’environnement du processus.

II.3.2. Contexte d’un processus

Le contexte d’un processus est l’ensemble des données qui permettent de reprendre
l’exécution d’un processus qui a été interrompu. Il est formé des contenus de :

− compteur ordinal (CO),

− Mot d’état (Program Status Word PSW),
− registres généraux,
− pile.

Le CO et le PSW représentent le petit contexte, et les registres généraux et la pile

représentent le grand contexte.

Page | 19
II.3.3. Image mémoire d’un processus

L’espace mémoire alloué à un processus, dit image mémoire (Memory Map) du processus,
est divisé en un ensemble de parties :

1. Code (Text) : qui correspond au code des instructions du programme à exécuter.

L’accès à cette zone se fait en lecture seulement (Read-Only).
2. Données (Data) : qui contient l’ensemble des constantes et variables déclarées.
3. Pile (Stack) : qui permet de stocker :

• les valeurs des registres,

• les variables locales et paramètres de fonctions,
• les adresses de retour des fonctions.

4. Tas (Heap) : une zone à partir de laquelle l’espace peut être alloué dynamiquement en
cours d’exécution (Runtime), en utilisant par exemple les fonctions new et malloc.

II.3.4. Descripteur de Processus (PCB)

Chaque processus est représenté dans le système d’exploitation par un bloc de contrôle de
processus (Process Control Bloc, PCB). Le contenu du PCB varie d’un système à un autre
suivant sa complexité. Il peut contenir :

1. Identité du processus : chaque processus possède deux noms pour son identification :

− Un nom externe sous forme de chaîne de caractères fourni par l’usager (c’est le
nom du fichier exécutable).
− Un nom interne sous forme d’un entier fourni par le système. Toute référence au
processus à l’intérieur du système se fait par le nom interne pour des raisons de
facilité de manipulation.

2. Etat du processus : l’état peut être nouveau, prêt, en exécution, en attente, arrêté,
…etc.
3. Contexte du processus : compteur ordinal, mot d’état, registres ;
4. Informations sur le scheduling de l’unité centrale : ces informations comprennent la
priorité du processus, des pointeurs sur les files d’attente de scheduling, …etc.
5. Informations sur la gestion mémoire : ces informations peuvent inclure les valeurs des
registres base et limite, les tables de pages ou les tables de segments.
6. Information sur l’état des E/S : l’information englobe la liste de périphériques d’E/S
alloués à ce processus, une liste de fichiers ouverts, etc.
7. Informations de Comptabilisation : ces informations concernent l’utilisation des
ressources par le processus pour facturation du travail effectué par la machine (chaque
chose a un coût).

Page | 20
 Figure 7. Bloc de contrôle de processus (PCB).

Le système d’exploitation maintient dans une table appelée «table des processus» les
informations sur tous les processus créés (une entrée par processus : Bloc de Contrôle de
Processus PCB). Cette table permet au SE de localiser et gérer tous les processus.

Donc, un processus en cours d’exécution peut être schématisé comme suit :

Figure 8. Schéma général d’un processus en cours exécution.

Page | 21
II.3.5. Etat d’un processus

Un processus prend un certain nombre d’états durant son exécution, déterminant sa situation
dans le système vis-à-vis de ses ressources. Les trois principaux états d’un processus sont :

− Prêt (Ready) : le processus attend la libération du processeur pour s’exécuter.

− Actif (Running) : le processus est en exécution.
− Bloqué (Waiting) : le processus attend une ressource physique ou logique autre
que le processeur pour s’exécuter (mémoire, fin d’E/S, …etc.).

Figure 9. Diagramme de transition des états d’un processus.

II.3.6. Multiprogrammation

Dans un système multiprogrammé, le processeur assure l’exécution de plusieurs processus en

parallèle (pseudo-parallélisme).

Le passage dans l’exécution d’un processus à un autre nécessite une opération de sauvegarde
du contexte du processus arrêté, et le chargement de celui du nouveau processus. Ceci
s’appelle la commutation du contexte (Context Switch).

II.3.7. Mécanisme de commutation de contexte

La commutation de contexte consiste à changer les contenus des registres du processeur

central par les informations de contexte du nouveau processus à exécuter.

Page | 22
 Figure 10. Mécanisme de commutation de contexte.

La commutation du contexte se fait en deux phases:

− La première phase consiste à commuter le petit contexte (CO, PSW) par une
instruction indivisible.
− La deuxième phase consiste quant à elle à commuter le grand contexte par celui du
nouveau processus.

Figure 11. Les phases d’une commutation de contexte.

II.4. Les systèmes d'interruption

II.4.1. Définition et organigramme général d'une interruption.

II.4.1.1. Définition

Une interruption est une réponse à un événement qui interrompt l’exécution du programme
en cours à un point observable (interruptible) du processeur central. Physiquement,
l’interruption se traduit par un signal envoyé au processeur. Elle permet de forcer le

Page | 23
processeur à suspendre l’exécution du programme en cours, et à déclencher l’exécution d’un
programme prédéfini, spécifique à l’événement, appelé routine d’interruption (Rit).

II.4.1.2. Organigramme général

Figure 12. Traitement d'une interruption.

Le programme repris après le traitement de l’interruption peut être le programme interrompu

ou autre.

II.4.2. Mécanismes de gestion des interruptions

Lorsqu'une interruption survient, le processeur achève l'exécution de l'instruction en cours

pour les interruptions externes, puis il se produit :

1. Sauvegarde du contexte dans une pile :

- adresse de la prochaine instruction à exécuter dans le programme interrompu,
- contenu des registres qui seront modifiés par le programme d'interruption,
- contenu du mot d'état (registre de drapeaux) rassemblant les indicateurs

(Tout cela forme le contexte sauvegardé)

2. Chargement du contexte du programme d'interruption (contexte actif) et passage en

mode système (ou superviseur)
3. Exécution du programme d'interruption
4. Retour au programme interrompu en restaurant le contexte (commande Assembleur
IRET) et en repassant en mode utilisateur.

Page | 24
II.4.3. Systèmes d'interruption sur les PCs.

Les interruptions ne jouent pas seulement un rôle important dans le domaine logiciel, mais
aussi pour l'exploitation de l'électronique.

On distingue donc :

• interruptions internes : protection du système et des processus, appelées par

une instruction à l'intérieur d'un programme (overflow, erreur d'adressage,
code opération inexistant, problème de parité…) (hardware internes)
• interruptions logiques : permet à un processus utilisateur de faire un appel au
système (software),
• interruptions matérielles déclenchées par une unité électronique (lecteur,
clavier, canal, contrôleur de périphérique, panne de courant,....) ou par
l'horloge (hardware externes).

Page | 25
III. Gestion des Entrées / Sorties physiques

L'une des principales fonctions d'un système d'exploitation consiste à contrôler tous les
périphériques d'entrée/sortie (E/S) de l'ordinateur. Il doit émettre des commandes vers les
périphériques, intercepter les interruptions et gérer les erreurs. Il fournit également une
interface simple entre les périphériques et le reste du système. Dans la mesure du possible,
l'interface doit être la même pour tous les périphériques (indépendance des périphériques).

III.1. Définition d'une E/S

Dans un système d'exploitation :

Les entrées sont les données envoyées par un périphérique (disque, réseau, clavier…) à
destination de l'unité centrale.

Les sorties sont les données émises par l'unité centrale à destination
d'un périphérique (disque, réseau, écran…).

III.2. Types d'E/S

Les principes de base sont employés pour réaliser les entrées-sorties entre la mémoire et un
périphérique.

On peut imaginer, toujours dans le cas du système d'exploitation le plus rudimentaire, que le
processeur pilote lui-même le dispositif de lecture ou d'écriture. Il gère directement le disque
choisissant l'emplacement où écrire et enchaîne une à une toutes les opérations nécessaires.
Ceci est un gaspillage car le processeur devra consacrer le plus clair de son temps à cette
gestion, travaillant fort peu pour l'usager. On a donc depuis longtemps introduit une certaine
intelligence dans les dispositifs de gestion des entrées-sorties. On distingue:

 Les coupleurs: processeurs simples qui disposent d'un peu de mémoire et d'un jeu
d'instructions limité. Ils peuvent gérer les adresses sur le disque et les déplacements
des têtes d'écriture.
 Les canaux et dispositifs d'accès direct à la mémoire (DMA ou direct memory access)
qui sont de véritables processeurs, parfois non interruptibles, qui peuvent interrompre
le processeur. Ils peuvent activer en parallèle plusieurs disques ou coupleurs,
possèdent une mémoire qui leur permet de stocker l'information et de réordonner les
accès pour accélérer les échanges.

III.3. Organisation des transferts

III.3.1. Instructions d'E/S

Les instructions d'entrée-sortie sont privilégiées, c'est-à-dire qu'elles ne peuvent figurer que
dans des programmes exécutés en mode système. En mode utilisateur, un programme
demande au système d'opérer l'entrée-sortie dont il a besoin. La seule façon pour exécuter une
opération d’entrée-sortie par un programme est de faire un appel à une fonction du système
judicieusement choisie par le programmeur. Cette fonction, une fois appelée, va s'exécuter en

Page | 26
mode système et aura donc de ce fait accès aux instructions d'entrée/sortie. La forme de cet
appel au système est celle d'un appel de procédure.

III.3.2. Découpage fonctionnel matériel/logiciel d'une E/S

Chaque périphérique est connecté à l'ordinateur par l'intermédiaire d'une carte électronique
spéciale appelée contrôleur de périphérique.

Figure 13. Rôle du contrôleur.

Un contrôleur possède en général :

− une zone tampon (buffer),

− des bits de contrôle : bit d'état (prête, occupée), et bit de commande (lecture, écriture).

III.4. Modes de pilotage d'une E/S :

III.4.1. Pilotage synchrone

Lors d'entrées-sorties synchrones, le processeur est immobilisé pendant toute la durée du

transfert. Le coupleur contient un mot d'état qui indique entre autre :

− s'il est prêt lorsque le périphérique est apte à fonctionner

− fini lorsque le transfert est terminé et qu'il est prêt pour un nouvel échange. Le
processeur peut alors reprendre son activité
− erreur lorsqu'une erreur est détectée au cours du transfert. La nature de celle-ci est
indiquée par un code qui fait partie du mot d'état. La qualité du diagnostic dépend de
l'électronique, nombre de bits de contrôle par octet) et des possibilités de traitement
du système d'exploitation.

Figure 14. Couplage synchrone.

Les entrées-sorties synchrones ne présentent d'intérêt que pour des processeurs rudimentaires
lorsqu'il n'y a pas de raison de vouloir mieux employer les temps d'attente. C'est le cas, par
exemple, du microprocesseur affecté au clavier d'un ordinateur. Leur programmation est
simple puisque l'état de l'activité, en chaque point interruptible, est toujours parfaitement
Page | 27
déterminé. Les coupleurs synchrones ne se rencontrent que dans des dispositifs spécialisés
dont l'état est parfaitement prévisible à tout instant. Leur programmation est facile donc
efficace et ne demande que peu de mémoire pour stocker le programme.

III.4.2. Pilotage asynchrone

Figure 15. Couplage asynchrone synchrone.

Le pilotage des entrées-sorties asynchrones est plus complexe. On ne peut pas prévoir à
l'avance l'état des différents processus qui devront communiquer entre eux. Leur
programmation nécessite le recours à des interruptions car le processeur et le coupleur
travaillent simultanément à la différence du pilotage synchrone où ils travaillent en
alternance. Chacun doit pouvoir être interrompu à des moments imprévisibles entre deux
instructions. Ce mode de fonctionnement est évidemment plus performant puisque le
processeur n'est pas immobilisé inutilement : lorsqu'il attend que le coupleur ait effectué une
opération d'écriture pour un processus il peut retourner à d'autres activités. Cependant ceci
est la source de nombreuses possibilités d'erreurs. Il faut veiller à synchroniser correctement
le périphérique et le processeur. Les données doivent être prêtes au moment voulu. Une
mauvaise synchronisation est la source de nombreuses erreurs souvent difficiles à détecter et
à corriger. Les canaux et dispositifs DMA fonctionnent généralement dans ce mode. Le
processeur peut consulter leur mot d'état pour connaître leur activité. Dans le dispositif DMA
le plus simple il se réduit à un registre qui contient l'adresse en mémoire des données à
transférer, le nombre d'octets et le sens du transfert. Le processeur connaît l'état d'avancement
du travail grâce à cette information.

III.5. Gestion d’E/S simultanées

Lorsqu’une requête d’E/S arrive en mode synchrone, une requête est en cours d’exécution à
la fois, puisque le CPU attend la fin d’E/S.

Néanmoins, en mode asynchrone et mode DMA, l’E/S demandée est lancée. Puis, le contrôle
est rendu immédiatement à un programme utilisateur, qui peut formuler de nouvelles requêtes
d’E/S.

A cet effet, le système s’exploitation maintient une table contenant une entrée pour chaque
périphérique d’E/S ; c’est la table d’état des périphériques (Device-Status Table).

Page | 28
 Figure 16. Table d’état des périphériques.

Chaque entrée de la table indique le type du périphérique, son adresse et son état (inactif ou
occupé), ainsi qu’une liste des requêtes formulées d’E/S. Cette liste contient, pour chaque
requête, le type d’opération, l’adresse de données et la longueur des données, …etc.

Page | 29
IV. Gestion du processeur central

Dans un système multitâche, la ressource la plus importante d’une machine est le processeur.
Cette ressource est allouée à un et un processus sélectionné parmi un ensemble des processus
éligibles. Par conséquent, il convient à bien gérer ce dernier afin de le rendre plus productif.
En effet, un système d’exploitation dispose d’un module qui s’occupe de l’allocation du
processeur en l’occurrence le Dispatcheur. Ce module est exécuté chaque fois qu’un
processus se termine ou se bloque dans le but de réquisitionner le processeur pour un autre
processus. En plus de ce Dispatcheur, un système d’exploitation dispose d’un autre module
permettant ainsi la mise en ordre des processus qui demandent le processeur.

IV.1. Définition

L'ordonnanceur (scheduler) est un programme du système d’exploitation qui s’occupe de

choisir, selon une politique de scheduling donnée, un processus parmi les processus prêts
pour lui affecter le processeur.

IV.2. Objectifs de scheduling.

L'ordonnancement est la partie du système d'exploitation qui détermine dans quel ordre les
processus prêts à s'exécuter (présents dans la file des prêts) seront élus. Ses objectifs sont :

1. faible temps de réponse des processus,

2. bon fonctionnement des processus en tâches de fond,
3. éviter absolument la famine.

IV.3. Critères de scheduling.

1. Utilisation de la CPU – utiliser la CPU le maximum possible

2. Débit (Throughput) – # de processus qui terminent leur exécution par unité de temps
3. Temps de rotation (Turnaround time) – le temps depuis le lancement du processus
jusqu’à sa terminaison (les attentes incluses)
4. Temps d’attente – temps d’un processus dans la file d’attente des processus prêts
5. Temps de réponse – temps mis entre une requête émise et la première réponse, pas la
sortie (pour les environnements à temps partagé)

IV.4. Niveaux de scheduling

Il existe trois niveaux de Scheduling :

1. Le scheduling de haut niveau (Long-Term scheduling) qui décide du degré de la

multiprogrammation (nombre maximal de processus dans le système).
2. Le scheduling de niveau intermédiaire (Medium-Term scheduling) gère le
déplacement des processus d’une file d’attente à une autre. Dans la majorité des
systèmes actuels, les niveaux intermédiaires et haut sont combinés -> haut niveau.
3. Le scheduling de bas niveau (Short-Term scheduling) (dispatcher ou répartiteur) est
sollicité plusieurs fois par seconde et doit constamment résider en mémoire. Il permet
de déterminer le processus prêt à utiliser le processeur central.

Page | 30
IV.5. Politiques de scheduling.

Les algorithmes d’ordonnancement se distinguent les uns des autres du fait que certains
autorisent la réquisition de l’unité centrale alors que d’autres l’interdisent. La réquisition est
la possibilité de retirer à n’importe quel instant le processeur à un processus même si ce
dernier est en cours d’exécution.

Nous distinguons plusieurs algorithmes d’ordonnancement, les plus répandus sont :

IV.5.1. First in first out FIFO (first come first served FCFS)

Dans cet algorithme ; connu sous le nom FIFO (First In, First Out) ; les processus sont rangés
dans la file d’attente des processus prêts selon leur ordre d’arriver. Les règles régissant cet
ordonnancement sont :

1. Quand un processus est prêt à s’exécuter, il est mis en queue de la file d’attente des
processus prêts.
2. Quand le processeur devient libre, il est alloué au processus se trouvant en tête de file
d’attente des processus prêts.
3. Le processus élu relâche le processeur s’il se termine ou s’il demande une entrée
sortie.

Cet algorithme est sans réquisition et non adapté à un système temps partagé car dans un
système pareil, chaque utilisateur obtient le processeur à des intervalles réguliers.

IV.5.2. Short job first SJF

SJF choisit de façon prioritaire les processus ayant le plus court temps d’exécution sans
réellement tenir compte de leur date d’arrivée. Dans cet algorithme les différents processus
sont rangés dans la file d'attente des processus prêts selon un ordre croissant de leur temps
d'exécution (cycle de calcul). Les règles régissant cet ordonnancement sont :

1. Quand un processus est prêt à s’exécuter, il est inséré dans la file d’attente des
processus prêts à sa position approprie.
2. Quand le processeur devient libre, il est assigné au processus se trouvant en tête de la
file d’attente des processus prêts (ce processus possède le plus petit cycle processeur).
Si deux processus ont la même longueur de cycle, on applique dans ce cas
l’algorithme FCFS.
3. Si le système ne met pas en œuvre la réquisition, le processus élu relâche le
processeur s’il se termine ou s’il demande une entrée sortie. Dans le cas contraire, le
processus élu perd le processeur également. Quand un processus ayant un cycle
d’exécution inférieur au temps processeur restant du processus élu, vient d’entrer dans
la file d’attente des prêts. Le processus élu dans ce cas sera mis dans la file d’attente
des éligibles, et le processeur est alloué au processus qui vient d’entrer.

Cet algorithme peut être avec ou sans réquisition et son implémentation est difficile, car il
n’existe aucune manière pour connaître le cycle suivant du processeur.

Page | 31
IV.5.3. Avec priorité

Dans cet algorithme, les processus sont rangés dans la file d’attente des processus prêt par
ordre décroissant de priorité. L’ordonnancement dans ce cas est régit par les règles suivantes :

1. Quand un processus est admis par le système, il est inséré dans la file d’attente des
processus prêts à sa position approprie (dépend de la valeur de priorité).
2. Quand le processeur devient libre, il est alloué au processus qui se trouve en tête de
file d’attente des processus prêts (le plus prioritaire).
3. Un processus élu relâche le processeur s’il se termine ou se bloque (E/S ou autre).

Si le système met en œuvre la réquisition, quand un processus de priorité supérieure à celle

du processus élu entre dans l’état prêt ; le processus élu sera mis dans la file d’attente des
éligibles à la position approprie, et le processeur est alloué au processus qui vient d’entrer.

Cet algorithme peut être avec ou sans réquisition. Un processus de priorité basse risque de ne
pas être servi (problème de famine) d’où la nécessité d’ajuster périodiquement les priorités
des processus prêts. L’ajustement consiste à incrémenter graduellement la priorité des
processus de la file d’attente des éligibles (par exemple à chaque 15 mn on incrémente d’une
unité la priorité des processus prêts).

IV.5.4. Tourniquet

Dans cet algorithme les processus sont rangés dans une file d'attente des éligibles, le
processeur est alloué successivement aux différents processus pour une tranche de temps fixe
Q appelé Quantum. Cet Ordonnancement est régit par les règles suivantes :

1. Un processus qui rentre dans l’état éligible est mis en queue de la file d'attente des
prêts.
2. Si un processus élu se termine ou se bloque avant de consommer son quantum de
temps, le processeur est immédiatement alloué au prochain processus se trouvant en
tête de la file d'attente des prêts.
3. Si le processus élu continue de s'exécuter au bout de son quantum, dans ce cas le
processus sera interrompu et mis en queue de la file d'attente des prêts et le processeur
est réquisitionné pour être réalloué au prochain processus en tête de cette même file
d’attente.

Cet algorithme est avec réquisition, il est adapté aux systèmes temps partagé. La stratégie du
tourniquet garantit que tout processus est servi au bout d’un temps fini. Son avantage est
d’éviter la famine. On dit qu'un processus est en famine lorsqu'il est prêt à être exécuté et se
voit refuser l'accès à une ressource (ici le processeur) pendant un temps indéterminé.
L’efficacité de cet ordonnanceur dépend principalement de la valeur du quantum Q:

− Le choix d'un Q assez petit augmente le nombre de commutation.

− Le choix d'un Q assez grand augmente le temps de réponse du système

Page | 32
IV.6. Contrôle de processus

Un processus est une entité dynamique qui matérialise un programme en cours d'exécution
avec ses propres ressources physiques (mémoire, processeur, entrée/sortie, …) et logiques
(données, variables,…). Contrairement à un programme (texte exécutable) qui a une
existence statique.

Le système d’exploitation manipule deux types de processus :

− Processus système : processus lancé par le système (Init processus père des tous les
processus du système)
− Processus utilisateur : processus lancée par l’utilisateur (commande utilisateur)

Dès sa création, un processus reçoit les paramètres suivants :

− PID : identificateur du processus (numéro unique)

− PPID : identificateur du processus père
− UID : identificateur de l’utilisateur qui a lancé le processus
− GID : identificateur du groupe de l’utilisateur qui a lancé le processus

IV.6.1. Etats d'un processus

Dans les systèmes mono programmés, un programme ne quitte pas l’unité centrale avant de
terminer son exécution. Pendant cette période, il dispose de toutes les ressources de la
machine. Par contre, ce n’est pas le cas dans les systèmes multiprogrammés et temps-partagé,
un processus peut se trouver dans l’un des états suivants :

1. Elu : (en cours d’exécution) : si le processus est en cours d'exécution

2. Bloqué : attente qu’un événement se produit ou bien ressource pour pouvoir continuer
3. Prêt : si le processus dispose de toutes les ressources nécessaires à son exécution à
l'exception du processeur.

Figure 17. Diagramme de transition d’un processus

IV.6.2. Bloc de contrôle de processus PCB

Lorsqu’un processus est temporairement suspendu, il faut qu’il puisse retrouver l’état où il se
trouvait au moment de suspension, il faut que toutes les informations dont il a besoin soient
sauvegardées pendant sa mise en attente.

Page | 33
Notons que le contexte d’un processus dépend du système, mais dans tous les cas c’est un
bloc de contrôle de processus (BCP) qui contient toute information nécessaire à la reprise
d’un processus interrompu : Etat du processus (prêt, suspendu, ..), quantité de mémoire,
temps CPU (utilisé, restant), priorité, etc.

Les BCP sont rangés dans une table (table des processus) qui se trouve dans l’espace
mémoire du système (figure 18).

Figure 18. Bloc de contrôle de processus (PCB)

IV.6.3. Création de processus

Il existe des appels système permettant de créer un processus, charger son contexte et lancer
son exécution (fork, exec sous Unix). Un processus (père) peut créer d’autres processus (fils)
qui hérite les descripteurs de son père. Ce dernier à son tour crée d’autres processus. Un
processus a un seul père mais peut avoir plusieurs fils.

Figure 19. Création de processus.

Page | 34
IV.6.4. Destruction d'un processus

Les processus peuvent se terminer ou ils peuvent être éliminés par d’autres processus (la
primitive kill). A la destruction d’un processus, on libère toutes les ressources qu’il avait.

Dans certains cas, la destruction d’un processus entraîne l’élimination de ces descendants;
cette opération n’affecte pas les processus qui peuvent continuer indépendamment de leur
père (processus orphelins).

Page | 35
V. Gestion de la mémoire centrale

Pour pouvoir utiliser un ordinateur en multiprogrammation, système d’exploitation charge

plusieurs processus en mémoire centrale (MC). La façon la plus simple consiste à affecter à
chaque processus un ensemble d'adresses contiguës.

Quand le nombre de tâches devient élevé, pour satisfaire au principe d'équitabilité et pour
minimiser le temps de réponse des processus, il faut pouvoir simuler la présence simultanée
en MC de tous les processus. D'où la technique de "va et vient" ou recouvrement (swapping),
qui consiste à stocker temporairement sur disque l'image d'un processus, afin de libérer de la
place en MC pour d'autres processus.

D'autre part, la taille d'un processus doit pouvoir dépasser la taille de la mémoire disponible,
même si l'on enlève tous les autres processus. L'utilisation de pages (mécanisme de
pagination) ou de segments (mécanisme de segmentation) permet au système de conserver en
MC les parties utilisées des processus et de stocker, si nécessaire, le reste sur disque.

Le rôle du gestionnaire de la mémoire est de connaître les parties libres et occupées, d'allouer
de la mémoire aux processus qui en ont besoin, de récupérer de la mémoire à la fin de
l'exécution d'un processus et de traiter le recouvrement entre le disque et la mémoire
centrale, lorsqu'elle ne peut pas contenir tous les processus actifs.

Modules Traducteur Modules

sources objets

Editeur
Bibliothèque
de liens
statique

Module
executable

Chargeur

Bibliothèque Liaison et chargement

dynamique dynamiques Image
mémoire

Figure 20. Phases de génération de l’espace d’adressage.

L’espace d’adressage d’un processus est généré par le compilateur et l’éditeur de liens.

V.1. Objectifs d'un gestionnaire de la mémoire.

V.1.1. Rôle

Toute instruction ou donnée de l’espace d’adressage doit être chargée en mémoire centrale
(principale, physique) avant d’être traitée par un processeur.

Page | 36
Le gestionnaire de la mémoire est le composant du système d’exploitation qui se charge de
gérer l’allocation d’espace mémoire aux processus à exécuter :

– Comment organiser la mémoire ? (une ou plusieurs partitions, le nombre et la

taille des partitions fixes ou variables au cours du temps).
– Faut-il allouer une zone contiguë à chaque processus à charger en mémoire ?
Faut-il allouer tout l’espace nécessaire à l’exécution du processus entier ?
(politique d’allocation).
– Comment mémoriser l’état de la mémoire? Parmi les parties libres en
mémoire, lesquelles allouées au processus? (politique de placement)
– S’il n’y a pas assez d’espace en mémoire, doit-on libérer de l’espace en
retirant des parties ou des processus entiers? Si oui lesquels ? (politique de
remplacement).
– Les adresses figurant dans les instructions sont-elles relatives? Si oui,
comment les convertir en adresses physiques.
– Si plusieurs processus peuvent être résident en mémoire, comment assurer la
protection des processus (éviter qu’un processus soit altéré par un autre?

V.1.2. Exigence

− Efficacité : la mémoire doit être allouée équitablement et à moindre coût tout en

assurant une meilleure utilisation des ressources (mémoire, processeurs et disque).
− Protection : Les processus ne peuvent pas se corrompre.
− Transparence : Chacun des processus doit ignorer l’existence des autres en mémoire.
− Relocation : la possibilité de déplacer un processus en mémoire (lui changer de place).

V.2. Fonctions.

Le compactage de la mémoire permet de regrouper les espaces inutilisés. Très coûteuse en

temps l’unité centrale, cette opération est effectuée le moins souvent possible.

S'il y a une requête d'allocation dynamique de mémoire pour un processus, on lui alloue de la
place dans le tas (Thermal-assisted switching) (heap : des parties d'un grand pool de
mémoire) si le système d’exploitation le permet, ou bien de la mémoire supplémentaire
contiguë à la partition du processus (agrandissement de celle-ci). Quand il n'y a plus de place,
on déplace un ou plusieurs processus :

− soit pour récupérer par ce moyen des espaces inutilisés,

− soit en allant jusqu'au recouvrement.

A chaque retour de recouvrement (swap), on réserve au processus une partition un peu plus
grande que nécessaire, utilisable pour l'extension de la partition du processus venant d'être
chargé ou du processus voisin.

Il existe trois façons de mémoriser l'occupation de la mémoire : les tables de bits (bits maps),
les listes chaînées et les subdivisions (buddy).

Page | 37
V.3. Modes de partage de la mémoire.
V.3.1. Système mono-programmé

Système Pilotes des

d’exploitation périphériques
dans la ROM dans la ROM

Programme
utilisateur Programme
utilisateur

Programme
utilisateur
Système Système
d’exploitation d’exploitation
dans la RAM dans la RAM

Figure 21. Exemples de système mono-programmé.

− Cas (a): un seul processus en mémoire RAM :Random Access Memory.

− Cas (b): ordinateurs de poche ou systèmes embarqués avec ROM : Read Only
Memory.
− Cas (c): MS-DOS: Microsoft Disc Operating System.

V.3.2. Système multiprogrammé

La mémoire est partagée entre le système d' exploitation et plusieurs processus.

Optimisation du taux d'utilisation du processeur en réduisant notamment les attentes sur des
entrées-sorties.

Deux préoccupations:

– Comment permettre efficacement la cohabitation de plusieurs processus ?

– Comment assurer leur protection ?

V.3.2.1. Partitions fixes

– La mémoire réservée aux utilisateurs est divisée en un ensemble de partitions.

– Le nombre et la taille des partitions sont fixés à l' avance (lors du chargement
du système).
– Les partitions peuvent être égales ou non.
– Le choix du nombre et de la taille des partitions dépend du niveau de
multiprogrammation voulu.
– On peut avoir une file par partition ou une file globale.
– L’unité d’allocation est une partition.

Page | 38
 Files d'attente
multiples

File d'attente
unique

Système Système
d’exploitation d’exploitation

Figure 22. Partitions fixes.

V.3.2.2. Partitions variables

Initialement, l’espace mémoire réservée aux utilisateurs constitue une seule partition.

Quand un nouveau processus doit être chargé, on lui alloue une zone contiguë de taille
suffisamment grande pour le contenir.

Le nombre et les tailles des partitions varient au cours du temps.

Cette forme d’allocation conduit éventuellement à l’apparition de trous trop petits pour les
allouer à d’autres processus : c’est la fragmentation externe.

Solutions:

– Compactage (coûteux et exige que les processus soient relocalisables)

– Allocation discontinue.

Page | 39
 Figure 23. Partitions variables.

V.4. Protection de la mémoire.

V.4.1. Système mono-programmé

Pour protéger le code et les données du système d’exploitation des programmes des
utilisateurs, on utilise un registre limite qui indique la limite de la zone réservée aux
utilisateurs.

Chaque adresse référencée par un processus est comparée avec le registre limite.

Page | 40
 Figure 24. Protection de la mémoire dans un système mono-programmé.

V.4.2. Système multiprogrammé

Comme on ne peut prévoir dans quelle partition sera chargé un processus, les adresses
attribuées par le compilateur et l’éditeur de liens aux instructions et aux données d’un
programme doivent être relatives à une adresse 0.

Ces adresses relatives seront ensuite translatées en adresses physiques.

La translation peut se faire lors du chargement du processus (utilisée dans OS/360 d’IBM.
Les adresses relatives sont remplacées par des adresses absolues (en ajoutant à chaque fois
l’adresse de début de la partition).

Cette solution n’est pas intéressante car en remplaçant les adresses relatives en adresses
absolues, il ne sera plus possible de déplacer le processus.

Pour éviter la translation d’adresse au cours du chargement d’un processus, une autre solution
consiste à doter la machine de 2 registres spéciaux :

– Le registre de base ;
– Le registre limite.

Quand un processus est élu (par l’ordonnanceur), système d’exploitation charge dans le
registre de base l’adresse absolue du début de sa partition et dans le registre limite la longueur
de la partition.

Durant l’exécution d’une instruction, chaque adresse relative référencée par l’instruction est
vérifiée en la comparant avec le contenu du registre limite, afin d’interdire tout accès en
dehors de la partition courante.

Les adresses physiques sont obtenues en ajoutant le contenu du registre de base aux adresses
relatives.

Avantage : le processus peut être déplacé en mémoire.

Page | 41
 Figure 25. Protection de la mémoire dans un système multiprogrammé.

Cette translation doit être rapide.

V.5. Partage de code.

Un des avantages est le partage de code commun. Particulièrement important pour les
systèmes à temps partagé où plusieurs utilisateurs partagent un programme (éditeur de texte,
base de données, etc.)

V.5.1. Code partagé

Une copie en lecture seule (code réentrant) est partagée entre plusieurs utilisateurs. Seule la
position dans le code change selon les utilisateurs.

Le code partagé doit apparaître au même endroit dans l'espace logique de tous les processus.

Editeur

limite
Editeur

Table des segments

Processus 1
Mémoire logique
Processus 1

Editeur

limite
Mémoire physique

Table des segments

Mémoire logique Processus 2
Processus 2

Figure 26. Une bibliothèque de liens dynamiques (Dynamic Link Library: DLL) utilisée par plusieurs utilisateurs.

Page | 42
VI. Gestion des périphériques

La gestion des périphériques représente peut-être le défi le plus considérable d’un système
d’exploitation. Ce dernier doit contrôler tout un ensemble de périphériques avec des
différences multidimensionnelles. Rapidité du périphérique, volume des informations, service
proposé, direction du flux d’informations et protocoles de communication sont autant de
grandeurs aux éventails très larges. Outre cette diversité, le système d’exploitation doit
pouvoir traiter un grand nombre de périphériques, ce traitement doit se dérouler dans un
environnement parallélisé. Les périphériques agissent en général indépendamment de l’unité
centrale, en fonction de leur propre fréquence et synchronisation. Le système d’exploitation,
qui la plupart du temps s’exécute sur une seule unité centrale, doit donc gérer des requêtes
simultanées en provenance d’un grand nombre de périphériques.

VI.1. Les périphériques

VI.1.1. Les périphériques graphiques

L’un des plus grands problèmes est le volume d’informations qui doit être transmis pour
décrire l’affichage sur les moniteurs. L’image sur les moniteurs est affichée sous formes de
points nommés pixels. Les moniteurs diffèrent selon le nombre de pixels et les couleurs qu’ils
peuvent adopter. Les premiers moniteurs étaient composés de 200 lignes de 320 pixels noir et
blanc. De nos jours, les résolutions de 800×600, 1024×768 et 1280×960 sont les plus
répondues. L’illumination de chaque pixel est contrôlée par des valeurs stockées en mémoire
vidéo :

− Les affichages monochromes de base n’ont besoin que d’un bit par pixel.
− Les affichages par niveaux de gris (255 niveaux) ont besoin de 8 bits.

Les affichages couleurs réelles ont besoin de 24 bits : chaque pixels est généré par la
combinaison des trois couleurs primaires (rouge, vert et bleu : RVB) ; 8 bits pour chacune de
ces couleurs. Avec un affichage couleurs réelles et pour un moniteur vidéo 1024×768, il nous
faut 2,3 Mo pour stocker une valeur de 24 bits pour chaque pixel. Pour modifier une image à
l’écran, de nouvelles données doivent être écrites en mémoire vidéo.
Compte tenu du grand volume de données multimédia cela peut représenter une charge
importante sur le système. Par exemple, une animation vidéo qui nécessite 25 image/seconde
et 2,3 Mo par image réécrit 25 fois dans la mémoire vidéo par seconde donc un total de 58
Mo/seconde. Cette exigence de transfert a poussé l’évolution des conceptions matérielles.

− Bus PCI (Peripheral Component Interconnect) : capacités de transfert de 132 Mo/S,

− Le nouveau bus graphique AGP (Accelerated graphics Port) possède un taux de
transfert de 528 Mo/S.

VI.1.2. Les disques de stockage

Le disque peut être considéré comme le seul périphérique d’E/S commun à tous les
ordinateurs. Même les moniteurs et les claviers ne sont pas indispensables sur des systèmes
tels que les serveurs. Il existe de nombreuses tailles et vitesses de disques et l’information
peut être stockée de manière optique ou magnétique. L’unité élémentaire de stockage
d’informations est le secteur.

Page | 43
 − Les DVD (Digital Versatile Disc) et CD-ROM : les secteurs forment une longue
spirale qui s’éloigne en tournant du centre du disque.
− Sur les disquettes et disques dans le support tourne à vitesse constante. Les secteurs
sont organisés en pistes. Les pistes sont des cercles concentriques autour du centre.
− Certains disques stockent le même nombre de secteurs pour chaque piste. D’autres
disques placent plus de secteurs sur des pistes externes.
− Les disques contiennent un ou plusieurs plateaux de support. Certain proposent
d’utiliser les deux faces du plateau et propose deux têtes de lecture/écriture par
plateau.

VI.1.3. Ordonnancement du disque dur

Si un disque est appelé à répondre à plusieurs E/S, il doit ordonnancer ces requêtes suivant
certains algorithmes d’ordonnancement. La performance de ces algorithmes se mesure par le
total des mouvements par tête.

− FIFO : premier entré premier servi.

− Priorité : la requête venant du processus ayant la priorité la plus élevée est servi la
première.
− SSTF (Shortest Seek Time First) : traduit par plus court positionnement d’abord,
répond à la requête dont la position de la piste est la plus proche de celle en cours.
− SCAN : avance et recule la tête de Lecture/écriture entre la piste la plus interne et la
plus externe et satisfait en route toutes les requêtes de la piste en suspens.
− LOOK : le même que SCAN, mais s’il n’y a pas de requêtes dans un sens la tête ne
fait pas le déplacement de façon inutile.
− C-SCAN et C-LOOK : une fois la dernière piste est atteinte, les algorithmes
retournent sur la piste de départ.
− N-step SCAN : file de requête divisée en sous files de longueur N. Ces files sont
ordonnancées en FIFO. Au sein des files les requêtes sont ordonnancées en SCAN.
− FSCAN : tel que le précédent, mais seulement deux sous files illimitées : Une en
cours de traitement et l’autre pour les nouvelles requêtes (celles qui viennent lors du
traitement).

Page | 44
VII. Gestion des fichiers
VII.1. Définition

Un fichier est vu comme une suite d'articles ou d'enregistrements logiques d'un type donné
qui ne peuvent être manipulés qu'à travers des opérations spécifiques. L'utilisateur n'est pas
concerné par l'implantation des enregistrements, ni par la façon dont sont réalisées les
opérations. Généralement, elles sont traduites par système d’exploitation en opérations
élémentaires sur les mémoires.

On dispose généralement des opérations suivantes :

− fichiers : créer, ouvrir, fermer, détruire, pointer au début, renommer, copier dans un
autre fichier, éditer le contenu,
− articles : lire, écrire, modifier, insérer, détruire, retrouver.

Un système de fichiers (SGF) est l'entité regroupant les fichiers mémorisés sur disque. Il
contient les données des fichiers et un ensemble d'informations techniques.

VII.2. Le support physique

A l'écriture, la tête magnétise le support. C'est le défilement des points magnétisés qui permet
de lire. Le courant d'air créé par le plateau en mouvement fait flotter la tête.

Figure 27. Tête et plateau.

Le disque tourne dans arrêt à vitesse constante. Un grain de poussière entre le disque et
la tête les détruit tous les deux. (Ex : un fragment de cendre de cigarette).

On empile plusieurs plateaux les uns au-dessus des autres. Les plateaux tournent à la même
vitesse. Les têtes sont solidaires (une tête par face).

Figure 28. Pile de plusieurs plateaux.

VII.2.1. Formatage physique

Sur chaque face, on écrit sur des pistes concentriques. Les pistes au-dessus les unes des autres
sont accessibles sans bouger les têtes de lecture. Elles forment un cylindre.

Page | 45
 Figure 29. Le disque après formatage.

Les pistes sont divisées en secteurs. Le secteur est l'unité de lecture-écriture. Le formatage
physique marque les positions des pistes et des secteurs.

VII.2.2. La taille du disque

Il suffit de connaître :

− La taille du secteur.
− Le nombre de secteurs par piste.
− Le nombre de pistes par cylindre.
− Le nombre de cylindres.

Taille d'une piste = taille d'un secteur x nombre de secteurs (clusters, blocs) par piste

Taille d'un cylindre = taille d'une piste x nombre de faces par cylindre

Taille d'un plateau = taille d'une piste x nombre de pistes / plateau

Taille du disque = taille d'1 cyl. x nbre de cyl = taille d'1 plat. x nbre de plat.

VII.2.3. Adresses sur le disque

Chaque secteur est repéré par ses coordonnées : (n° de cylindre, n° de face, n° de secteur).

La carte d'interface reçoit de l'ordinateur une commande (lire, ou écrire + données) et une
adresse de secteur, et exécute l'opération sur un secteur entier.

Page | 46
 Figure 30. Les numéros de secteurs.

Figure 31. Les numéros de faces.

Figure 32. Les numéros de cylindres.

Alors physiquement, un fichier est une suite de secteurs dont l'ordre est essentiel !

Figure 33. Exemple de répartition d’un fichier dans un disque.

Page | 47
VII.2.4. Les temps d'accès
Quand on demande à lire un secteur, la carte d'interface va

1. Placer les têtes de lecture sur le bon cylindre.

2. Attendre que le secteur cherché arrive sous la tête.
3. Copier le secteur sur la carte d'interface.
4. Envoyer les données de la carte à l'ordinateur.

VII.2.4.1. Temps de lecture d'un secteur

(Durée de 1 tour) / (Nombre de secteurs par piste).

Durée constante (ex : 0,5 ms)

Débit = le nombre d'octets lus par seconde

Si on lisait sans arrêt = le nombre d'octets qui passent sous la tête en 1 seconde.

Exemple:

Secteurs de 512 octets, 32 secteurs / piste, 7200 tours / mn

⇒ 16 Ko par piste, 120 tours / s

Débit = 1920 Ko/s = 1,875 Mo par seconde

Lecture d'un secteur = 1 / (120 x 32) = 2,5x10-4 s

VII.2.4.2. Attendre un secteur

Au mieux : attente nulle

Au pire : un tour

Temps de latence = durée moyenne d'attente = demi durée d'un tour

Ex : 4 ms

VII.2.4.3. Changer de piste

Au plus près : la piste voisine ⇒ temps de déplacement minimal

Au plus loin : du cylindre intérieur au cylindre extérieur ⇒ temps de déplacement maximal

En général, entre les deux ⇒ temps de déplacement moyen

Ex : 9,5 ms

Page | 48
Alors, pour lire un fichier dans l'ordre et si les secteurs sont n'importe comment sur le disque,
à chaque secteur il faut :

1. Placer les têtes (durée = temps de déplacement moyen)

2. Attendre le secteur (durée = temps de latence)
3. Lire (durée fixe)

VII.2.5. Formatage logique

On divise le disque en partitions formées de cylindres consécutifs

Chaque partition est utilisée par le système comme un disque

− Un peu moins de déplacement de têtes.

− On peut mettre un système par partition (double boot).

VII.3. Organisation de l'espace disque

Il existe deux stratégies pour stocker un fichier de n octets sur disque :

1. allouer des secteurs contigus totalisant une capacité d'au-moins n octets. Avec deux
inconvénients:
o le dernier secteur a toutes chances d'être sous-utilisé et ainsi, on gaspille de la
place. Le pourcentage de place perdue est d'autant plus grand que la taille
moyenne des fichiers est faible, ce qui est la réalité
o si le fichier est agrandi, il faudra déplacer le fichier pour trouver un nouvel
ensemble de secteurs consécutifs de taille suffisante
2. diviser le fichier en blocs de taille fixe, insécables, que système d’exploitation alloue
de façon non nécessairement contigüe à des secteurs.

Un bloc est défini comme une zone de mémoire secondaire contenant la quantité
d'information qui peut être lue ou écrite par un périphérique en une seule opération. La taille
d'un bloc est donc attachée à un périphérique d'E/S et fixée par le matériel. Cependant, si
système d’exploitation n'a pas le choix de la taille d'un bloc, il peut grouper plusieurs article
dans un même bloc (packing).

Pour des blocs de taille 1 Ko, le taux de remplissage du disque est excellent, mais la vitesse
de transfert des données est modeste (délai de rotation du disque et de recherche importants
par rapport au temps de transfert lui-même). Au-delà de 1 Ko, le taux de remplissage se
dégrade, mais la vitesse de transfert s'améliore.

VII.4. Gestion des blocs libres

Dès qu'on a choisi une taille de blocs (souvent 1/2 Ko à 2 Ko), on doit trouver un moyen de
mémoriser les blocs libres. Les deux techniques les plus répandues sont les suivantes :

− table de bits : on gère une table comportant autant de bits que de blocs sur le disque.
A chaque bloc du disque, correspond un bit dans la table, positionné à 1 si le bloc est
occupé, à 0 si le bloc est libre (ou vice versa). Par exemple, un disque de 300 Mo,

Page | 49
 organisé en blocs de 1 Ko, sera géré par une table de 300 Kbits qui occupera 38 des
307.200 blocs
− liste chaînée de n° des blocs : par exemple, un disque de 300 Mo, organisé en blocs de
1 Ko : supposons que chaque bloc soit adressé par 4 octets. Chaque bloc de la liste
pourra contenir 255 adresses de blocs libres. La liste comprendra donc au plus
307.200/255 = 1205 blocs. Cette solution mobilise beaucoup plus de place que la
précédente.

Figure 34. Liste chaînée de n° des blocs.

On peut imaginer deux variantes de cette dernière solution :

− une liste chaînée de blocs : chaque bloc libre pointe sur le bloc libre suivant,
− une liste chaînée de zones libres : chaque bloc de début d'une série de blocs libres
(zone libre) contient la taille de la zone et pointe sur le premier bloc de la zone libre
suivante.

Page | 50
VIII. Conclusion
Dans ce polycopié, la première partie de matière "Systèmes d'Exploitation" est
présentée au profit des étudiants en deuxième année en licence Informatique.

Les concepts fondamentaux sont bien présentés ; comme la gestion des fichiers, gestion
de la mémoire, gestion du processeur et gestion des entrées-sorties.

Comme il est mentionné dans l’introduction de ce polycopié, une deuxième partie sera
préparée et organisée sous forme d’un tutoriel contenant des fiches de travaux dirigés
(exercices avec solutions) ainsi que des fiches de travaux pratiques.

En fin, j’espère que le contenu de ce polycopié a bien aidé et assisté le lecteur dans cette
formation en licence Informatique.

Page | 51
 IX. Bibliographie
Challal Y., Bettahar H. et Vayssade M. Systèmes d’exploitation: des concepts a la programmation -
Gestion des entrées / sorties [En ligne] // ESI Ecole nationale Supérieure d'Informatique. - 04 Mai
2016. - 05 Mars 2018. - http://y_challal.esi.dz/wp-content/uploads/2016/05/CH3-ES.pdf.

Epelboin Yves Systèmes d'exploitation des ordinateurs [En ligne]. - Université Pierre et Marie Curie -
UPMC, 25 Février 2007. - 05 Mars 2018.

GUILLIER François Histoire de l'Informatique [En ligne] // Histoire de l'Informatique. - 1996. - 05

Mars 2018.

Heudin J.C. et Panetto C. Les architectures RISC [Ouvrage]. - [s.l.] : Dunod, 1990.

LOUKAM Mourad Systèmes d'exploitation 1, Licence 2 [En ligne]. - 05 Mars 2018. -

http://www.loukam.net/index_Courses.html.

Montagnon J. A. et Pichat E. Architecture des ordinateurs. Tome 1: le sous système central

[Ouvrage]. - [s.l.] : Elsevier-Masson, 1986.

Moreau ené Ainsi naquit l'informatique: Histoire des hommes et des techniques [Ouvrage]. - [s.l.] :
Dunod, 1987.

Rossi Serge l'Histoire de l'Informatique [En ligne]. - 20 Novembre 2004. - 05 Mars 2018.

Sghaier Imene Systèmes d’exploitation – Gestion des périphériques [En ligne] // Technologue pro,
cours électricité électronique informatique. - 28 Octobre 2012. - 05 Mars 2018. -
http://www.technologuepro.com/Systemes-Exploitation/Gestion-des-peripheriques.html.

Weygand D. Les processeurs RISC [Ouvrage]. - [s.l.] : Eyrolles , 1991.

Zanella P. et Ligier Y. Architecture et technologie des ordinateurs [Ouvrage]. - [s.l.] : Dunod, 1989.

Page | 52

View publication stats