2023/2024

Systèmes d’exploitation

MAHSEUR MOHAMMED
Deuxième Année Licence
Informatique
2023/2024
I. Chapitre 1 : Introduction
1. Notion de système d’exploitation
 Un système d’exploitation est une couche de logiciels, sa fonction est de
masquer la complexité du matériel et de proposer des instructions plus simples
pour l’utilisateur.
 Un système d’exploitation est un gestionnaire de ressources.
 Un système d’exploitation est un ensemble de programmes qui réalisent
l’interface entre le matériel de l’ordinateur et les utilisateurs, afin de construire
une machine virtuelle plus facile d’emploi et plus conviviale (facile pour un
utilisateur non professionnel).

2. Fonctions et rôles
 Offrir une interface agréable et simple aux utilisateurs
 Offrir une interface indépendante de l’architecture de l’ordinateur
 Contrôler l’intégrité et la confidentialité des informations de ses utilisateurs
 Assurer une gestion optimale des ressources :
 Gestion du processeur
 Gestion des fichiers
 Gestion des entrées/sorties
 Gestion de la mémoire
 Gestion de la concurrence
 Gestion de la protection
 Gestion des accès au réseau

3. Exemples de système d’exploitation

 MS-DOS : c’est un système mono-tache mono-utilisateur avec interface textuel,
il est le plus connu parmi les premiers systèmes pour PC.
 Mac OS : c’est un système d’exploitation des ordinateurs d’Apple, parmi les
premiers systèmes qui ont utilisé la souris et l’interface graphique.
 Linux : c’est un système multiutilisateurs, multitâches stable et gratuit
 Windows : c’est un système multitâche multifenêtres multiutilisateurs
 Android : c’est un système fondé sur Linux, conçu pour les Smartphones,
tablettes tactiles, télévisions, …

[1]
 4. Position du système d’exploitation dans un système
informatique
Un système informatique peut être vu comme un ensemble de couches :

 La couche 0 : qui représente tous ce qui est matériel

 La couche 1 : qui représente tous ce qui est logiciel, cette couche comporte
deux grandes catégories :
 Les programmes systèmes : qui assurent le fonctionnement de la machine,
dans cette catégorie on trouve le système d’exploitation et les utilitaires
systèmes
 Les programmes d’application qui répond aux besoins des utilisateurs

Figure 1: La couche système d'exploitation

5. Les différentes classes des systèmes d’exploitation

Le développement rapide qui a eu lieu dans le monde des ordinateurs s'est
accompagné d'un développement remarquable dans les systèmes d'exploitation,
nous distinguons six classes de systèmes d’exploitation :

a. Les systèmes à traitement par Lot

Le principe du traitement par lots s’appuie sur la composition de lots de travaux
ayant des caractéristiques ou des besoins communs, la formation de ces lots visant
à réduire les temps d’attente du processeur en faisant exécuter les uns à la suite
des autres ou ensemble, des travaux nécessitant les mêmes ressources.

b. Les systèmes multiprogrammation

Le principe de base de ces systèmes consiste à charger plusieurs processus (jobs)
en mémoire, ensuite le système contrôle l’usage du processeur. Le contrôle dans
[2]
ce cas, consiste à commuter le processeur entre les différents processus présents
en mémoire. La commutation est déclenchée chaque fois que le processus en
cours d’exécution se termine ou demande une opération d’entrée sortie. Ceci
permet de faire travailler le processeur même pendant la période de l’opération
d’entrée sortie.

c. Les systèmes temps partagé

Ce sont des systèmes multiprogrammation dans lesquels chaque processus occupe
le processeur pendant une durée fixée Q (appelée quantum) d’une manière
périodique.

d. Les systèmes temps réel

C’est une classe des systèmes utilisée pour satisfaire des commandes des
dispositifs non informatiques connectés à l’ordinateur. Le système d’exploitation
dans ce cas, doit garantir que tout traitement finira à temps c’est à dire dans un
délai préalablement connu.

e. Les systèmes multitraitement

C’est une classe utilisée sur des ordinateurs ayant plusieurs processeurs, ce qui
permet l’exécution en parallèle de plusieurs travaux

f. Les systèmes répartis

C’est une classe utilisée sur un ensemble de processeurs tels que chaque
processeur possède son propre horloge et mémoire locale, et il peut être situé
dans un site éloigné. Le rôle d’un système réparti est de faire la communication et
la coordination entre processeurs.

[3]
II. Chapitre 2 : La gestion du processeur
Les premiers systèmes d’exploitation ne permettaient d'exécuter qu'un seul
programme à la fois. Ce programme avait l’accès à toutes les ressources du
système. En revanche, les systèmes informatiques actuels permettent à plusieurs
programmes d'être chargés en mémoire et exécutés simultanément. Cette
évolution a nécessité un contrôle plus ferme et un plus grand cloisonnement des
différents programmes ; et ces besoins ont abouti à la notion de processus

1. Définitions
a. Notion de programme
C’est une entité passive, comme un fichier contenant une liste d'instructions
stockées sur disque (souvent appelé fichier exécutable). Un programme devient un
processus lorsqu'un fichier exécutable est chargé en mémoire.

b. Notion de processus
C’est un programme en cours d'exécution, c’est plus que le code du programme. Il
comprend également l'activité en cours, représentée par la valeur du compteur de
programme et le contenu des registres du processeur. Un processus comprend
généralement la pile de processus, qui contient des données temporaires (telles
que des paramètres de fonctions, des adresses de retour et des variables locales),
et une section de données, qui contient des variables globales. Un processus peut
également inclure un tas, qui est une partie mémoire allouée dynamiquement
pendant l'exécution du processus. La structure d'un processus en mémoire est
illustrée dans la figure suivante :

Figure 2: Structure d'un processus en mémoire

[4]
Remarque : on peut trouver plusieurs processus associés au même programme, ils
sont néanmoins considérés comme deux séquences d'exécution distinctes. Par
exemple, un utilisateur peut lancer plusieurs copies du programme de navigateur
Web. Chacun de ces éléments est un processus distinct ; et bien que les sections de
texte soient équivalentes, les sections de données, de tas et de pile varient.

c. Types de processus

a) Processus système
Processus lancé par le système (init processus père de tous les processus système
sous Unix)

b) Processus utilisateur
Processus lancé par l’utilisateur (commande utilisateur)
d. Création/Terminaison de processus sous Unix
 La création de processus se fait par l’appel système Fork
 La terminaison se fait par l’appel système Kill
Lors de sa création, un processus reçoit les paramètres suivants :
 PID : identificateur de processus (numéro entier 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
e. Bloc de contrôle de processus
Chaque processus est représenté dans le système d'exploitation par un bloc de
contrôle de processus. Il contient de nombreuses informations associées à un
processus spécifique, notamment :
 État du processus : l'état peut être nouveau, prêt à fonctionner, en attente,
arrêté, etc.
 Compteur de programme : Le compteur indique l'adresse de la prochaine
instruction à exécuter pour ce processus.
 Registres du processeur : les registres varient en nombre et en type, en
fonction de l'architecture de l'ordinateur. Ils comprennent des
accumulateurs, des registres d'index, des pointeurs de pile et des registres à
usage général, ainsi que toutes les informations de condition de code. Avec
le compteur de programme, ces informations d'état doivent être

[5]
 sauvegardées lorsqu'une interruption se produit, pour permettre au
processus de se poursuivre correctement par la suite.
 Informations de planification de l’UC : ces informations incluent une priorité
de processus, des pointeurs vers les files d'attente de planification et tout
autre paramètre de planification.
 Informations de gestion de la mémoire : ces informations peuvent inclure
des informations telles que la valeur des registres de base et de limite, les
tables de pages, ou les tables de segments, en fonction du système de
mémoire utilisé par le système d'exploitation.
 Informations comptables : ces informations comprennent le temps réel
utilisé, les limites de temps, les numéros de compte, les numéros de tâche
ou de processus, etc.
 Informations sur l'état des E/S : ces informations incluent la liste des
périphériques d'E/S alloués au processus, une liste des fichiers ouverts, etc.
En bref, le BCP sert simplement de référentiel pour toute information pouvant
varier d'un processus à autre. Voir la figure suivante :

Figure 3: Bloc de Contrôle de processus

[6]
 f. Commutation des processus

g. Notion de Thread
Dans les systèmes d'exploitation traditionnels, chaque processus dispose d'un
espace d'adressage et d'un seul fil de contrôle. En fait, c'est presque la définition
d'un processus. Néanmoins, dans de nombreuses situations, il est souhaitable
d'avoir plusieurs mini-processus (appelés Threads) dans un processus.
La principale raison d'avoir des threads est que dans de nombreuses applications,
plusieurs activités se déroulent à la fois. Certains d'entre eux peuvent se bloquer
de temps à autre. En décomposant une telle application en plusieurs threads
séquentiels qui s'exécutent en quasi-parallèle, le modèle de programmation
devient plus simple.

2. Différents états d’un processus

L'état d'un processus est défini par l'activité actuelle de ce processus. Chaque
processus peut être dans l'un des états suivants:

 Nouveau : Le processus est en cours de création.

[7]
 En cours (élu) : Les instructions sont en cours d'exécution.
 En attente : Le processus attend qu'un événement se produise (tel qu'un
achèvement d'E/S ou la réception d'un signal).
 Prêt : Le processus attend d'être affecté à un processeur.
 Terminé : Le processus a terminé son exécution.
Le diagramme d'états correspondant à ces états est présenté dans la figure
suivante :

Figure 4: Diagramme d'état d'un processus

3. Hiérarchies de processus
Dans certains systèmes, un processus peut créer un autre processus, on parle dans
ce cas de processus parent et de processus enfant. Le processus enfant peut lui-
même créer plus de processus, formant une hiérarchie de processus. Notez qu’un
processus n'a qu'un seul parent, mais zéro, un, deux ou plusieurs enfants.

4. Ordonnancement des processus

a. Critères de planification
L’évaluation d’une telle méthode de planification est basée sur un ensemble de
critères (métriques) à respecter et optimiser :
 Utilisation du processeur : L’objectif est de garder le processeur aussi
occupé que possible. Conceptuellement, l'utilisation du processeur peut
varier de 0 à 100%. Dans un système réel, il devrait aller de 40 % (pour un
système peu chargé) à 90 % (pour un système très utilisé).

[8]
 Débit : C’est le nombre de processus terminés par unité de temps. Pour les
processus longs, ce taux peut être un processus par heure; pour les
transactions courtes, il peut s'agir de dix processus par seconde. C’est un
critère à maximiser.
 Délai d'exécution : C'est l'intervalle de temps entre la soumission d'un
processus et son achèvement. C’est la somme des périodes passées à
attendre pour entrer en mémoire, à attendre dans la file d'attente prête, à
s'exécuter sur le CPU et à effectuer des E/S. C’est un critère à minimiser.
C'est une mesure appropriée pour un travail par lots.
 Temps d'attente : C’est la quantité de temps qu'un processus passe à
attendre dans la file d'attente prête, elle égale à la somme des périodes
d'attente dans la file d'attente prête, ce critère dépend de la l’algorithme de
planification du processeur adoptée. C’est un critère à minimiser.
 Temps de réponse : Dans un système interactif, le délai d'exécution n'est
peut-être pas le meilleur critère. Souvent, un processus peut produire une
sortie assez tôt et peut continuer à calculer de nouveaux résultats pendant
que les résultats précédents sont envoyés à l'utilisateur. Donc le Temps de
réponse est le temps écoulé entre la soumission d'une demande et la
production de la première réponse, c’est le temps nécessaire pour
commencer à répondre, et non le temps nécessaire pour sortir la réponse.
 Prévisibilité : Un travail donné doit s'exécuter dans à peu près le même laps
de temps et à peu près au même coût quelle que soit la charge sur le
système. Une grande variation du temps de réponse ou du temps de
traitement distrait les utilisateurs. Cela peut signaler une grande variation
des charges de travail du système ou la nécessité d'un réglage du système
pour remédier aux instabilités.
 Équité : En l'absence de directives de l'utilisateur ou d'autres directives
fournies par le système, les processus devraient être traités de la même
manière.
 Application des priorités : Lorsque des priorités sont assignées aux
processus, la politique d'ordonnancement devrait favoriser les processus de
priorité plus élevée.
 Équilibrage des ressources : La politique de planification doit maintenir les
ressources du système occupées. Les processus qui utiliseront les ressources
rarement sollicitées doivent être favorisés.

[9]
 b. Algorithmes d’ordonnancement (planification)
L'ordonnancement du CPU traite le problème de la décision à lequel des processus
de la file d'attente prête doit se voir allouer le CPU. Il existe de nombreux
algorithmes de planification CPU différents :
 Planification premier arrivé, premier servi FCFS (First-Come, First-Served) :
Le processus qui demande le CPU en premier se voit attribuer le CPU en
premier. La mise en œuvre de la politique FCFS est facilement gérée avec une
file d'attente FIFO. Lorsqu'un processus entre dans la file d'attente prête, son
BCP est lié à la queue de la file d'attente. Lorsque la CPU est libre, elle est
allouée au processus en tête de file d'attente. Le processus en cours est ensuite
supprimé de la file d'attente. Le code de planification FCFS est simple à écrire
et à comprendre. Du côté négatif, le temps d'attente moyen dans le cadre de la
politique FCFS est souvent assez long.
Exemple : Considérez l'ensemble suivant de processus qui arrivent à l'instant 0,
Processus Période d’utilisation CPU
24 ms
P1
3 ms
P2
3 ms
P3

Si les processus sont dans l'ordre P1, P2, P3 et sont servis dans l'ordre FCFS,
nous obtenons le résultat affiché dans le diagramme de Gantt suivant, qui est
un diagramme à barres qui illustre un calendrier particulier, y compris les
heures de début et de fin de chacun des processus participants :

P1 P2 P3
0 24 27 30

Le temps d'attente est de 0 ms pour P1, 24 ms pour P2 et 27 ms pourP3. Ainsi,

le temps d'attente moyen est de (0+24+27)/3=17ms.
Si les processus arrivent dans l'ordre P2, P3, P1, cependant, les résultats seront
comme indiqué dans le diagramme de Gantt suivant :

P2 P3 P1
0 3 6 30

Le temps d'attente moyen est maintenant (6+0+3)/3=3 ms. Cette réduction est
importante. Ainsi, le temps d'attente moyen dans le cadre d'une politique FCFS

[10]
n'est généralement pas minimal et peut varier considérablement si les temps
d’exécution CPU des processus varient considérablement.
Notez que l'algorithme de planification FCFS n'est pas préventif. Une fois que le
CPU a été allouée à un processus, ce processus conserve le CPU jusqu'à ce qu'il
libère le CPU, soit en arrêtant, soit en demandant une E/S. L'algorithme FCFS
est donc particulièrement gênant pour les systèmes à temps partagé, où il est
important que chaque utilisateur reçoive une part du CPU à intervalles
réguliers. Il serait désastreux de permettre à un processus de conserver le
processeur pendant une période prolongée.
 Planification du travail le plus court d'abord SJF (Shortest-Job-First):
Cet algorithme associe à chaque processus la longueur de la prochaine
utilisation du CPU. Lorsque le CPU est disponible, il est affecté au processus qui
a la plus petite période d’utilisation du CPU. Si les périodes d’utilisation de deux
processus sont identiques, la planification FCFS est utilisée.
Exemple : considérons l'ensemble de processus suivant :
Période d’utilisation CPU
Processus
6 ms
P1
8 ms
P2
7 ms
P3
3
P4
En utilisant la planification SJF, nous planifierions ces processus selon le
diagramme de Gantt suivant:

P4 P1 P3 P2
0 3 9 16 24
Le temps d'attente est de 3 ms pour P1, 16 ms pour P2, 9 ms pourP3 et 0 ms
pour P4. Ainsi, le temps d'attente moyen est de (3+16+9+0)/4= 7 ms.

Par comparaison, si nous utilisions le schéma d'ordonnancement FCFS, le

temps d'attente moyen serait de 10,25 ms.

L'algorithme d'ordonnancement SJF est prouvé optimal, en ce qu'il donne le

temps d'attente moyen minimum pour un ensemble donné de processus.
Déplacer un processus court avant un processus long réduit davantage le
temps d'attente du processus court qu'il augmente le temps d'attente du

[11]
 processus long. Par conséquent, le temps d'attente moyen diminue. La vraie
difficulté avec l'algorithme SJF est de connaître la longueur de la prochaine
requête CPU. On distingue deux types d’algorithmes SJF : SJF préemptif et SJF
non préemptif. Le choix se pose lorsqu'un nouveau processus arrive dans la file
d'attente prête alors qu'un processus précédent est toujours en cours
d'exécution. La prochaine période d’utilisation de CPU du nouveau processus
arrivé peut-être plus courte que ce qui reste du processus en cours d'exécution.

Un algorithme SJF préemptif préemptera le processus en cours d'exécution,

tandis qu'un algorithme SJF non préemptif permettra au processus en cours
d'exécution de terminer sa période d’exécution CPU. La planification SJF
préemptive est parfois appelée planification du temps le plus court restant en
premier SRT (shortest-remaining-time-first). À titre d'exemple, considérons les
quatre processus suivants, avec la longueur de la période d’exécution CPU
donnée en millisecondes :

Temps d’arrivé Période d’utilisation CPU

Processus
0 8
P1
1 4
P2
2 9
P3
3 5
P4
Le programme SJF non préemptif résultant est illustré dans le diagramme de
Gantt suivant : (les cases barrées représentent la période d’attente et les cases
verts représentent la période d’exécution CPU)
P4

P3

P2

P1

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

Le temps d’attente moyen= (0+7+15+9)/4=7,75ms

[12]
 Le programme SJF préemptif (SRT) résultant est illustré dans le diagramme de
Gantt suivant :
P4

P3

P2

P1

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

Le temps d’attente moyen= (9+0+15+2)/4=6,5ms

 Planification du travail le plus prioritaire

Une priorité est associée à chaque processus et le CPU est allouée au processus
avec la priorité la plus élevée. Les processus de priorités égales sont planifiés dans
l'ordre FCFS. Un algorithme SJF est simplement un algorithme de priorité où la
priorité (p) représente la durée de la période d’exécution CPU. Plus cette durée est
grande, plus la priorité est faible et vice versa. Les priorités sont généralement
indiquées par une plage fixe de nombres, par exemple de 0 à 7. Cependant, il n'y a
pas un accord général sur la question de savoir si 0 est la priorité la plus élevée ou
la plus basse. Certains systèmes utilisent des nombres faibles pour représenter une
faible priorité ; d'autres utilisent des nombres faibles pour une priorité élevée.
Exemple : considérons l'ensemble de processus suivant, supposé être arrivé au
temps 0 dans l'ordre P1, P2, · · ·, P5. Dans cet exemple, nous supposons que les
nombres faibles représentent une priorité élevée.

Période d’exécution CPU (ms) Priorité

Processus
10 3
P1
1 1
P2
2 4
P3
1 5
P4
5 2
P5

[13]
En utilisant la planification prioritaire, nous planifierions ces processus selon le
diagramme de Gantt suivant :
P5

P4

P3

P2

P1

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

Le temps d’attente moyen= (6+0+16+18+1)/5=8,2ms.

La planification prioritaire peut être préemptive. Lorsqu'un processus arrive dans la

file d'attente, sa priorité est comparée à la priorité du processus en cours
d'exécution, l’algorithme de planification de priorité préemptive préemptera le
CPU si la priorité du processus nouvellement arrivé est supérieure à la priorité du
processus en cours d'exécution. Par contre, un algorithme de planification de
priorité non préemptive mettra simplement le nouveau processus en tête de la file
d'attente. Un algorithme de planification prioritaire peut laisser certains processus
à faible priorité en attente pour une longue durée. La solution de ce problème est
d’introduire la notion de vieillissement qui consiste à augmenter progressivement
la priorité des processus qui attendent longtemps dans le système. Par exemple, si
les priorités vont de 127 (faible) à 0 (élevée), il possible d’augmenter la priorité
d'un processus d'attente avec la soustraction de 1 toutes les 15 minutes.
Finalement, même un processus avec une priorité initiale de 127 aurait la priorité
la plus élevée dans le système et serait exécuté. En fait, il ne faudrait pas plus de 32
heures pour qu'un processus de priorité 127 devienne un processus de priorité 0.

[14]
  Planification circulaire RR (Round-Robin)
L'algorithme de planification circulaire (RR) est spécialement conçu pour les
systèmes de temps partagé. Il est similaire à la planification FCFS, mais la
préemption est ajoutée pour permettre au système de basculer entre les
processus. Une petite unité de temps, appelée quantum de temps ou tranche de
temps, est définie. Un quantum de temps dure généralement de 10 à 100
millisecondes. La file d'attente prête est traitée comme une file d'attente circulaire.
L'ordonnanceur du processeur fait le tour de la file d'attente, allouant le
processeur à chaque processus pendant un intervalle de temps fixé. Pour
implémenter la planification RR, la file d’attente est implémentée selon le principe
FIFO. Les nouveaux processus sont ajoutés à la queue de la file d'attente.
L'ordonnanceur du processeur sélectionne le premier processus dans la file
d'attente prête, définit un minuteur pour qu'il s'interrompe après 1 temps
quantique et distribue le processus. Une des deux choses se produira alors. Le
processus peut avoir une durée d’utilisation CPU inférieure à 1 quantum de temps.
Dans ce cas, le processus lui-même libérera le CPU volontairement. Le planificateur
passera ensuite au processus suivant dans la file d'attente. Si la durée d’exécution
CPU du processus en cours d'exécution est supérieure à 1 quantum de temps, la
minuterie s'éteindra et provoquera une interruption du système d'exploitation. Un
changement de contexte sera exécuté et le processus sera placé à la fin de la file
d'attente prête. Le planificateur du processeur sélectionnera alors le processus
suivant dans la file d'attente. Le temps d'attente moyen dans le cadre de la
politique RR est souvent long. Les performances de l'algorithme RR dépendent
fortement de la taille du quantum de temps.Si le quantum tend vers une grande
valeur, le RR devient similaire à FCFS. En revanche, si le quantum de temps est
extrêmement petit (par exemple, 1 ms), l'approche RR peut entraîner un grand
nombre de changements de contexte.

Exemple : Considérez l'ensemble suivant de processus qui arrivent à l'instant 0,

avec la longueur de la durée d’exécution CPU donnée en millisecondes :

Période d’exécution CPU (ms)

Processus
13
P1
3
P2
6
P3

[15]
Si nous utilisons un quantum de temps de 4 millisecondes, alors le calendrier RR
résultant est le suivant :
P3

P2

P1

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

Le temps d’attente moyen= (9+4+11)/3=8ms.

 Planification de file d'attente à plusieurs niveaux

Une autre classe d'algorithmes d'ordonnancement a été créée pour les situations
dans lesquelles les processus sont facilement classés en différents groupes. Par
exemple, une division commune est faite entre les processus de premier plan
(interactifs) et les processus d'arrière-plan (par lots). Ces deux types de processus
ont des exigences de temps de réponse différentes et peuvent donc avoir des
besoins de planification différents. De plus, les processus de premier plan peuvent
avoir la priorité (définie de manière externe) sur les processus d'arrière-plan. Un
algorithme de planification de file d'attente à plusieurs niveaux partitionne la file
d'attente prête en plusieurs files d'attente distinctes (voir la figure). Les processus
sont affectés en permanence à une file d'attente, généralement en fonction de
certaines propriétés du processus, telles que la taille de la mémoire, la priorité du
processus ou le type de processus. Chaque file d'attente a son propre algorithme
de planification. Par exemple, des files d'attente séparées peuvent être utilisées
pour les processus de premier plan et d'arrière-plan. La file d'attente de premier
plan peut être planifiée par un algorithme RR, tandis que la file d'attente d'arrière-
plan est planifiée par un algorithme FCFS. De plus, il doit y avoir une planification
parmi les files d'attente, qui est généralement implémentée comme une
planification préemptive à priorité fixe. Par exemple, la file d'attente de premier
plan peut avoir la priorité absolue sur la file d'attente d'arrière-plan. Examinons un
exemple d'algorithme de planification de files d'attente à plusieurs niveaux avec
cinq files d'attente, répertoriées ci-dessous par ordre de priorité :

[16]
1. Processus système
2. Processus interactifs
3. Processus d'édition interactifs
4. Processus par lots
5. Processus des étudiants

 Planification avec retour à plusieurs niveaux (feedback)

Normalement, lorsque l'algorithme de planification de file d'attente à plusieurs
niveaux est utilisé, les processus sont affectés en permanence à une file d'attente
lorsqu'ils entrent dans le système. S'il existe des files d'attente distinctes pour les
processus de premier plan et de fond, par exemple, les processus ne passent pas
d'une file d'attente à l'autre, car les processus ne modifient pas leur nature de
premier plan ou de fond. Cette configuration a l'avantage d'une baisse des frais
généraux, mais elle est inflexible. L'algorithme de planification de rétroaction à
plusieurs niveaux, en revanche, permet à un processus de se déplacer entre les
files d'attente. L'idée est de séparer les processus en fonction des caractéristiques
de leurs utilisations de processeur. Si le temps d’exécution d’un processus est trop
élevé, sera déplacé vers une file d'attente de priorité inférieure. Ce schéma laisse
des processus liés aux E/S et interactifs dans les files d'attente de priorité
supérieure. De plus, un processus qui attend trop longtemps dans une file
d'attente de priorité inférieure peut être déplacé vers une file d'attente de priorité
plus élevée. Cette forme de vieillissement empêche le temps d’attente d’aller vers
l’infini. Par exemple, considérez un ordonnanceur à plusieurs niveaux avec trois

[17]
files d'attente, numérotés de 0 à 2 (voir la figure suivante). L’ordonnanceur
exécute d'abord tous les processus dans la file d'attente 0. Ce n'est que lorsque la
file d'attente 0 est vide, il exécutera les processus dans la file d'attente 1. De
même, les processus dans la file d'attente 2 ne seront exécutés que si les files
d'attente 0 et 1 sont vides. Un processus entrant dans la file d'attente est mis dans
la file d'attente 0. Un processus dans la file d'attente 0 reçoit un quantum de temps
de 8 millisecondes. S'il ne se termine pas dans ce délai, il est déplacé vers la queue
de la file d'attente 1. Si la file d'attente 0 est vide, le processus à la tête de la file
d'attente 1 reçoit un quantum de 16 millisecondes. S'il ne se termine pas, il est
préempté et est mis dans la file d'attente 2. Les processus dans la file d'attente 2
sont exécutés sur une base FCFS mais sont exécutés uniquement lorsque les files
d'attente 0 et 1 sont vides. Cet algorithme de planification donne la plus haute
priorité à tout processus avec une utilisation de CPU de 8 millisecondes ou moins.
Un tel processus obtiendra rapidement le processeur et terminera sa tâche. Les
processus qui ont besoin de plus de 8 mais moins de 24 millisecondes sont
également servis rapidement, bien qu'avec une priorité plus faible que les
processus plus courts. Les processus longs s'enfoncent automatiquement dans la
file d'attente 2 et sont servis dans la technique FCFS.

 Gestion des taches d’E/S dans un mode multiprogrammé

[18]
Ce mode de planification est basé sur le principe suivant :Si un programme
demande une ressource, et si cette dernière est libre alors le système lui alloue la
ressource. Ainsi que si un programme demande une opération d’E/S, alors le CPU
est allouer au prochain processus placé dans la file d’attente des processus prêts.
L’ordonnancement est géré à l’aide d’un ensemble de taches de contrôles
(interruptions).
Exemple : algorithme FCFS en mode multiprogrammé
On s’intéresse à l’exécution de trois programmes A, B, et C sur une configuration
monoprocesseur (CPU, MC, périphérique d’E/S). Le séquencement des actions des
programmes A, B,et C est donné ci-après :

A B C

2 unités de temps CPU 3 unités de temps CPU 2 unités de temps CPU

4 unités de temps E/S 2 unités de temps E/S 2 unités de temps E/S

1 unité de temps CPU 2 unités de temps CPU 1 unité de temps CPU

On supposera que les programmes sont pris en charge dans l’ordre A, B, C.

1. Donner les synoptiques d’exécution des programmes dans lemode
d’exploitation multiprogrammé.
2. Calculer le temps de séjour et le temps d’attente individuels et moyens.

TA de A=1(l’instant 6) ; TA de B=2 (l’instant 0 et 1) ; TA de C=5(l’instant 0 ;1 ;2 ;3 ;4)

[19]
III. Chapitre 3 : Les interruptions (Cas Intel 8086)
1. Introduction
La plupart des processeurs modernes permettent d'être interrompus par des
périphériques externes. Cela évite au processeur de vérifier périodiquement de
tels appareils pour voir s'ils ont besoin d'une attention particulière.
Par exemple, au lieu de demander à un processeur de vérifier fréquemment dans
un clavier si une touche a été enfoncée et d'obtenir des réponses négatives la
plupart du temps, il serait plus efficace pour le processeur d'ignorer le clavier mais
de permettre au clavier d'attirer l'attention du processeur lorsqu’une touche est
enfoncée.
La première méthode est appelée interrogation, la seconde est appelée
interruption.

2. Définition
Une interruption est une procédure qui interrompe tout programme en cours
d'exécution. Elle peut être déclenchée par des périphériques externes du CPU ; en
outre, elle peut également être déclenchée par des instructions d'interruptions
logicielles et, dans certaines conditions, par le CPU lui-même.
Le 8086 peut gérer jusqu'à 256 types d'interruptions différents. Chaque
interruption est identifiée par un numéro entre 0 et 255.
Une fois l’interruption est traitée par le CPU, le programme interrompu reprend
son exécution.
Les interruptions permettent au processeur de communiquer avec les
périphériques d’entrées sorties (I/O) et vice-versa.

[20]
3. Présentation de l’Intel 8086
a. Vue externe

Figure 5: Vue externe d'un Intel 8086

 La ligne NMI (Non-MaskableInterrupt) : Cette ligne est utilisée pour signaler au

CPU un événement « catastrophique », tel qu'une perte d'alimentation
imminente, une détection d'erreur de mémoire ou une erreur de parité de bus.
 La ligne RESET : Cette ligne est utilisée pour redémarrer l’ordinateur.
 La ligne INTR (InterruptRequest) : Cette ligne est utilisée pour demander
l’exécution d’une interruption masquable.
 La ligne 𝐈𝐍𝐓𝐀(InterruptAcknowledge) : Cette ligne est utilisée pour répondre
aux demandes d’interruptions INTR, elle égale à zéro dans le cas favorable.

[21]
 b. Vue interne :

Figure 6: Vue interne d'un Intel 8086

 CS (Code Segment) : c’est un registre contenant l’adresse de base (début) du

segment de Code.
 IP (Instruction Pointer) : c’est un registre contenant le déplacement dans le
segment de code de l’instruction suivante, il est appelé aussi le compteur
ordinal (CO).
 Avec le couple (CS : IP) on peut déterminer l’adresse physique d’une
instruction.
 PSW (Program Statut Word) : c’est un registre d’état contenant des
informations sur l’état du processus et la dernière opération exécutée, parmi
ses bits on trouve :
 IF (Interrupt-enable Flag) : permet au CPU de reconnaître les demandes
d'interruption externes (masquables). La mise à zéro de IF désactive ces
interruptions. IF n'a aucun effet sur les interruptions externes non masquables
(NMI), ou générées en interne.
 TF (Trap Flag) : met le processeur en mode à étape unique (exécution pas à
pas) pour le débogage. Dans ce mode, le CPU génère automatiquement une

[22]
 interruption interne après chaque instruction, permettant à un programme
d'être inspecté lors de l'exécution instruction par instruction.

4. Types d’interruptions
a. Les interruptions externes
Ce sont des interruptions provenant de l’extérieur du CPU, on distingue :

 L’interruption NMI
C’est une interruption non masquable déclenchée par la ligne NMI. Les demandes
d'interruption arrivant sur NMI ne peuvent pas être désactivées. Ce type
d’interruptions porte le numéro 2.

 L’interruption Reset
C’est une interruption non masquable déclenchée par la ligne Reset, utilisée pour
redémarrer le microprocesseur. Lorsque le processeur détecte le front montant
d'une impulsion lors de la réinitialisation, il met fin à toutes les activités jusqu'à ce
que le signal passe au niveau bas, moment auquel il initialise le système comme
indiqué dans le Tableau 1.
Composants CPU Contenu
PSW Effacé
IP 0000H
CS FFFFH
DS 0000H
ES 0000H
File d’attente Vide
Tableau 1: État du processeur après la réinitialisation

 Les interruptions signalées par INTR

Pour les interruptions externes masquables, le CPU reçoit une demande
d’interruption par le signal INTR, le CPU doit réagir selon la valeur du drapeau IF, si
IF =0 (ce qui signifie que les interruptions signalées sur INTR sont masquées ou
désactivées), le CPU ignore la demande d'interruption et traite l'instruction
suivante de son programme en cours d’exécution. Sinon (IF=1) le CPU reconnaît la
demande d'interruption et la traite. Pour cela il doit envoyer un signal
d’acquittement de l’interruption 𝐼𝑁𝑇𝐴 = 0, ensuite le périphérique demandeur

[23]
envoi le numéro de l’interruption (via le bus de données) pour que le CPU puisse la
traiter.

b. Les interruptions internes

Ce sont des interruptions non masquables générées à l’intérieur du CPU, elles
partagent les caractéristiques suivantes :
1. Le code du type d'interruption est soit contenu dans l'instruction ou il est
prédéfini.
2. Aucun cycle de bus 𝐼𝑁𝑇𝐴n'est exécuté.
3. Les interruptions internes ne peuvent pas être désactivées, sauf pour
l’interruption d’exécution pas à pas (TF=1 pour les activer et TF=0 pour les
désactiver).
4. Toute interruption interne (sauf exécution pas à pas) a une priorité plus élevée
que toute interruption externe (voir le Tableau 2). Si des demandes
d'interruption arrivent sur NMI et / ou INTR pendant l'exécution d'une
instruction qui provoque une interruption interne (par exemple, une erreur de
division), l'interruption interne est traitée en premier.
5. Toutes les procédures d'interruption doivent être terminées par une
instruction IRET (retour d'interruption). L'instruction IRET suppose que la pile
est dans le même état que lors de l’appel de l’interruption. Elle dépile les trois
premiers mots de la pile dans IP, CS et PSW, retournant ainsi à l'instruction qui
était sur le point d'être exécutée lorsque la procédure d'interruption a été
activée.

Interruption Priorité

Interruption interne Élevée

NMI
INTR
Exécution pas à pas Faible
Tableau 2: Priorités des interruptions

Les interruptions internes regroupent les interruptions processeur et les

interruptions logicielles

 Les interruptions processeur

[24]
Ce sont des interruptions générées par le processeur dans un cas d’erreur (division
par zéro, …), ou bien dans l’exécution pas à pas (si TF est activé).

 Les interruptions logicielles

Ce sont des interruptions appelées dans le code source du programme en utilisant
l’instruction INT <Numéro du type d’interruption>, le Numéro du type
d’interruption est nécessaire pour appeler la procédure de traitement de
l'interruption (Routine d’interruption).

5. Table des vecteurs d’interruptions

La table des vecteurs d'interruptions (Figure 7) est le lien entre le code de type
d'interruption et la routine d’interruption (la procédure). La table des vecteurs
d'interruptions occupe le premier kilo octets de la mémoire (adresses faibles). Il
peut y avoir jusqu'à 256 entrées dans la table, une pour chaque type
d'interruption. Chaque entrée du tableau est un pointeur à double mot (4 octets)
contenant l'adresse de la procédure qui doit traiter les interruptions de ce type. Le
mot de plus haut niveau du pointeur contient l'adresse de base du segment (CS)
contenant la procédure. Le mot le plus bas contient le décalage (IP) de la
procédure depuis le début du segment. Étant donné que chaque entrée a une
longueur de quatre octets, le CPU peut calculer l'emplacement de l'entrée correcte
pour un type d'interruption donné en multipliant simplement (N° type * 4).

6. Trace d’exécution d’une interruption logicielle

a. Appel de l’interruption : INT N
1) Empiler le PSW
2) IF0 ; TF0
3) Empiler le CS
4) CS[N*4+2]
5) Empiler le IP
6) IP[N*4]
7) Sauter vers le nouvel emplacement adressé par CS :IP .

b. Retour de l’interruption : IRET

1) Dépiler le IP
2) Dépiler le CS
3) Dépiler le PSW
[25]
Figure 7: Table des vecteurs d'interruptions

[26]
IV. Chapitre 4 : Gestion de la mémoire
1. Introduction
La mémoire principale est une ressource importante qui doit être gérée très
soigneusement, malgré des capacités de plus en plus grandes, elle n’est jamais
suffisante à cause des tailles des programmes qui ne cessent pas de croitre.
Le système d’exploitation comporte un module chargé de la gestion rationnelle de
la mémoire appelé Gestionnaire de mémoire, son travail consiste à gérer
efficacement la mémoire : garder une trace des parties de la mémoire utilisées,
allouer de la mémoire aux processus lorsqu'ils en ont besoin et la libérer lorsqu'ils
ont terminé.

2. Adresse physique et adresse logique

a. Adresse physique
Chaque octet de la mémoire centrale est référencé d’une manière unique par une
suite fixe de bits appelée adresse physique. Donc l’accès aux données d’un
programme se fait par ces derniers.
L’utilisation des adresses physiques dans le code objet d’un programme pose un
problème de relocalisation, parce que les programmes sont chargés à chaque fois à
des positions différentes dans la mémoire centrale, donc il faut trouver une
abstraction des adresses, c’est la notion de l’adresse logique.

b. Adresse logique
Lors de l’exécution d’un programme, le système d’exploitation lui réserve un
espace mémoire appelé Mémoire logique, où les octets sont numérotés d’une
manière virtuelle à partir de zéro, ces numéros sont appelés déplacements.
Une donnée est référencée par le couple formé de l’adresse de début de la
mémoire logique et son déplacement.

[27]
Exemple :

Figure 8: Adresse physique et adresse logique

La transformation des adresses logiques vers des adresses physiques est effectuée
par un périphérique matériel appelé l'unité de gestion de la mémoire MMU
(Memory-management Unit). La figure suivante illustre un exemple de MMU :

Figure 9: MMU

[28]
 3. Allocation contiguë de la mémoire
L’allocation contiguë consiste à charger le processus en un seul morceau, cela
nécessite l’utilisation d’un registre de base (translation) et d’un registre de borne
(limite), son utilisation est montrée dans la figure suivante :

Figure 10: Gestion des adresses avec le registre de base et le registre limite

Cette allocation souffre de deux problèmes : fragmentation interne et

fragmentation externe
 Fragmentation interne : c’est un espace mémoire inutile dans une partition
occupé par un processus, sa taille =taille partition-taille processus
 Fragmentation externe : c’est un espace mémoire inutile entre deux
partitions occupées.

a. Allocation contiguë avec des partitions fixes

La mémoire centrale est subdivisée en régions distinctes appelées partitions, ces
partitions sont soit de même taille soit de tailles différentes.
La figure suivante illustre une partition fixe d’une mémoire de 64Mo, avec les deux
méthodes : tailles égales et tailles inégales.
Dans cette allocation, n’importe quel programme peut être affecté à n’importe
quelle partition, l’essentiel qu’elle soit suffisamment grande.

[29]
 Figure 11: Exemple d'une partition fixe

Algorithmes de placement pour les partitions fixes de tailles inégales

 Utilisation de plusieurs queues : cette méthode consiste à utiliser une file
d’attente par taille de partition et assigner chaque nouveau processus à la
partition possédant la taille suffisante la plus petite afin de minimiser la
fragmentation interne. L’inconvénient de cet algorithme est la possibilité
d’avoir des files trop chargées et des files vides en même temps.
 Utilisation d’une seule queue : cette méthode consiste à utiliser une seule
file d’attente pour toutes les catégories de partitions et affecter chaque
nouveau processus à la plus petite partition libre et suffisante.
L’inconvénient de cet algorithme est la possibilité d’augmenter la
fragmentation interne.

[30]
 b. Allocation contiguë avec des partitions dynamiques
Cette approche a été développée pour surmonter certaines des difficultés du
partitionnement fixe, avec le partitionnement dynamique, les partitions sont de
longueur et de nombre variables. Lorsqu'un processus est introduit dans la
mémoire principale, il se voit allouer exactement autant de mémoire qu'il en a
besoin et pas plus.
Un exemple, utilisant 64 Mo de mémoire principale, est illustré dans la figure
suivante :

[31]
 Figure 12: L'effet du partitionnement dynamique

Initialement, la mémoire principale est vide, sauf pour le système d'exploitation

(a). Les trois premiers processus sont chargés, en commençant là où le système
d'exploitation se termine et en occupant juste assez d'espace pour chaque
processus (b, c, d). Cela laisse un "trou" à la fin de la mémoire qui est trop petit
pour un quatrième processus. À un moment donné, aucun des processus en
mémoire n'est prêt. Le système d'exploitation remplace le processus 2 (c), ce qui
laisse suffisamment de place pour charger un nouveau processus, le processus 4
(f). Comme le processus 4 est plus petit que le processus 2, un autre petit trou est
créé. Plus tard, un point est atteint auquel aucun des processus dans la mémoire
principale n'est prêt, mais le processus 2, dans l'état Prêt-Suspendu, est disponible.
Comme il n'y a pas suffisamment d'espace mémoire pour le processus 2, le
système d'exploitation échange le processus 1 en sortie (g) et le processus 2 en
retour (h). Comme le montre cet exemple, cette méthode démarre bien, mais elle
aboutit finalement à une situation dans laquelle il y a beaucoup de petits trous
dans la mémoire. Au fil du temps, la mémoire devient de plus en plus fragmentée
et l'utilisation de la mémoire diminue.

[32]
Gestion de la mémoire libre
Lorsque la mémoire est affectée dynamiquement, le système d'exploitation doit la
gérer. Il existe deux manières de suivre l'utilisation de la mémoire : les bitmaps et
les listes chaînées.
 Gestion de la mémoire avec Bitmaps :
Avec un bitmap, la mémoire est divisée en petites unités d'allocation. À chaque
unité d'allocation correspond un bit dans le bitmap, qui vaut 0 si l'unité est libre et
1 si elle est occupée (ou vice-versa). La taille de l'unité d'allocation est un problème
de conception important. Plus l'unité d'allocation est petite, plus le bitmap est
grandet vice-versa. La figure suivante montre une partie de la mémoire et le
bitmap correspondant.

Figure 13: Gestion de la MC avec Bitmap

 Gestion de la mémoire avec liste chaînée

Une autre façon de garder une trace de la mémoire consiste à maintenir une liste
chaînée de segments de mémoire alloués et libres, où un segment contient un
processus ou un trou vide entre deux processus. Chaque entrée de la liste spécifie
un trou (H) ou un processus (P), l'adresse à laquelle il commence, la longueur et un
pointeur vers l'élément suivant. Dans l’exemple suivant, la liste des segments est
conservée triée par adresse.

[33]
 Figure 14: Gestion de ma MC avec liste chaînée

Le tri de cette manière présente l'avantage que lorsqu'un processus se termine ou

est échangé, la mise à jour de la liste est simple.
Un processus de terminaison a normalement deux voisins (sauf lorsqu'il se trouve
tout en haut ou en bas de la mémoire).
Ceux-ci peuvent être des processus ou des trous, conduisant aux quatre
combinaisons illustrées à la figure suivante :

Figure 15: Quatre combinaisons de voisins pour le processus de terminaison de X

Algorithmes de placement pour le partitionnement dynamique

L’objectif de ces algorithmes est de décider comment affecter les processus à la
mémoire afin de boucher et minimiser les trous, pour cela, trois algorithmes de
placement qui pourraient être considérés :
 Best-fit : Meilleur ajustement : Attribuez le plus petit trou suffisamment
grand. Nous devons rechercher dans toute la liste, à moins que la liste ne
soit classée par taille. Cette stratégie produit le plus petit trou restant.
[34]
  First-fit : Premier ajustement : attribuez le premier trou suffisamment grand.
La recherche peut commencer soit au début de l'ensemble de trous, soit à
l'endroit où la recherche de premier ajustement précédente s'est terminée.
Nous pouvons arrêter la recherche dès que nous trouvons un trou libre
suffisamment grand.
 Worst-fit : Pire ajustement : Attribuez le plus grand trou. Encore une fois,
nous devons rechercher toute la liste, à moins qu'elle ne soit triée par taille.
Cette stratégie produit le plus grand trou restant, ce qui peut être plus utile
que le plus petit trou restant d'une approche de meilleur ajustement.
Exemple :
On considère un système disposant de 32 Mo de mémoire principale. La partie
résidente du système est sur 8 Mo.
L’ordonnancement des processus est réalisé avec l’algorithme FIFO.
Les processus arrivent dans le système dans l’ordre suivant :

Processus Temps d’arrivé Taille Durée

A 0
B 3
C 5
D 10
E 20
F 25
G 26
10 5
8 16
6 19
4 8
10 10
4 5
2 4

Donnez les états d’occupation de la mémoire aux différentes étapes de traitement

de ces processus, en utilisant l’algorithme : First-Fit.

[35]
Solution
Algorithme first-fit
 Diagramme de Gantt
32
31
30
29
28
27
26
25

B
24
23

E
22
21
20
19
18
17
16 D
G
15
14
13
A
12
11
10
9
C F
8
7

SE
6
5
4

2
1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

[36]
Les différents états d’occupation de la mémoire :

32

31

30

29

28

27

26

25

24

23
B B B B
22

21

20
E E E E
19

18

17
D
16

15

14
A A G
13

12
C C c C C
11
F F
10

9
8
7
6
5
SE

SE

SE

SE

SE

SE

SE

SE

SE

SE
SE

4
3
2
1
10-17

20-23

26-29

30…..
0-2

3-4

5-9

18

19

24

25

[37]
Sommaire
I. Chapitre 1 : Introduction ....................................................................................... 1
1. Notion de système d’exploitation..................................................................... 1
2. Fonctions et rôles ............................................................................................. 1
3. Exemples de système d’exploitation ................................................................ 1
4. Position du système d’exploitation dans un système informatique .................. 2
5. Les différentes classes des systèmes d’exploitation ......................................... 2
II. Chapitre 2 : La gestion du processeur ................................................................... 4
1. Définitions ........................................................................................................ 4
2. Différents états d’un processus ........................................................................ 7
3. Hiérarchies de processus .................................................................................. 8
4. Ordonnancement des processus ...................................................................... 8
III. Chapitre 3 : Les interruptions (Cas Intel 8086)................................................... 20
1. Introduction ................................................................................................... 20
2. Définition ....................................................................................................... 20
3. Présentation de l’Intel 8086 ........................................................................... 21
4. Types d’interruptions ..................................................................................... 23
5. Table des vecteurs d’interruptions ................................................................. 25
6. Trace d’exécution d’une interruption logicielle .............................................. 25
IV. Chapitre 4 : Gestion de la mémoire ................................................................... 27
1. Introduction ................................................................................................... 27
2. Adresse physique et adresse logique.............................................................. 27
3. Allocation contiguë de la mémoire ................................................................. 29

[38]
Bibliographies
Silberschatz, Abraham, Galvin, Peter Baer et Gagne, Greg. 2009.Operating System
Concepts. USA : John Wiley, 2009.
Stallings, William and Paul, Goutam Kumar. 2012.Operating systems: internals
and design principles. s.l. : Pearson New York, 2012. Vol. 9.
Tanenbaum, Andrew S et Bos, Herbert. 2015.Modern operating systems. USA :
Pearson, 2015.

[39]