1

Introduction au systèmes
d’exploitation

2
 Ordinateur: matériel +logiciel.

3
 Logiciel:

Les couches d’un système informatique

4
 Système d’exploitation: ensemble de programmes
qui agissent comme un intermédiaire entre
l’utilisateur et l’ordinateur.
 l’utilisateur a une vue simplifiée de l’ordinateur lui
permettant de l’utiliser plus facilement.

 But :
Développer des applications sans se soucier des
détails de fonctionnement et de gestion du
matériel.

5
 Processus : Programme en cours d’exécution

6
 Gestion du processeur et des processus

 Gestion de la mémoire

 Gestion des périphériques

 Gestion des fichiers

 Protection et sécurité

7
 Machines portes ouvertes (nues) : 1945-1955
 machines énormes, couteuses, très peu fiables et peu
rapides.
 Pas de système d’exploitation: le programmeur
s’occupe de la programmation, du chargement et du
lancement des programmes.
 Programmation en langage machine.
 Mode d’exploitation : Monoprogrammation
 Début des année 50 : Introduction des cartes perforées

8
 Traitement par lots : 1955-1965
Lot: ensembles de programmes écrits dans un même
langage et font appel au même compilateur.

9
 Traitement par lots : 1955-1965

Pgs. en
Bande
assembleur ou en
magnétique
Fortran

10
 Traitement par lots : 1955-1965
 Mode d’exploitation: Monoprogrammation (un
seul programme en mémoire à la fois)
 Inconvénient: Processeur inutilisé pendant les E/S

2 4 6 10 12 11
 Multiprogrammation et traitement par lots : 1965-1980
 SPOOLING (Simultaneous Peripheral Operation On Line)
-Simultanéité de transferts de programmes dans le disque et
transfert de fichiers vers les périphériques.
Disque Pg2
Pg1

pg1 pg2 pg3 pg4

SPOOL
Périphérique

12
 Spooling:
-Multiprogrammation: Plusieurs P.gs en mémoire.
-Simultanéité calcul et E/S.

13
 Multiprogrammation sans interruption de programme :

• Le processeur est accordé au programme

prioritaire qui le garde jusqu’{ ce qu’il se termine
ou fasse une E/S.
• Pendant qu’un processus est en attente ou s’il s’est
terminé, le contrôle est repris par le SE qui accorde
le processeur au programme le plus prioritaire qui
demande à faire du calcul.

14
 Multiprogrammation avec interruption de programme:

 Lorsqu’une opération d’E/S est terminée le SE

reprend la main et donne l’UC au programme le
plus prioritaire qui la demande.

 A tout moment le déroulement d’un programme

peut être interrompu au profit d’un autre plus
prioritaire: Une interruption est alors produite.

15
 Exemple : Priorité croissante (C,B,A)

1 3 4 5 7 8 9 11

16
 Temps partagé: plusieurs utilisateurs peuvent se
connecter { la machine par l’intermédiaire de leurs
terminaux et travailler en même temps.
 Le processeur est alloué, à tour de rôle, pendant un
certain temps à chacun des travaux en attente
d’exécution.
 ce mode d’exploitation donne l’impression que les
programmes s’exécutent en parallèle.

17
 Exemple: temps partagé ordre ABC

1 2 3 4 5 6 7 8 10
18
 Le temps réel: Bien que le temps partagé ait permis un
temps de réponse approprié aux utilisateurs, il existe
des domaines (industriel, médical, militaire) dans
lesquels, l’ordinateur doit réagir immédiatement { un
changement des données d’entrée.
 Quand un dispositif d’entrée veut envoyer une
donnée, il active sa ligne d’interruption qui
sera détectée par le processeur. Le processeur
interrompt son travail et exécute un programme
particulier associé à cette interruption.
19
 (1980-1990)L’informatique personnelle – Les systèmes
distribués
 Informatique personnelle:
Micro-ordinateurs (PC) ont connu un
développement. Le premier PC, conçu par IBM a
été équipé du système MS-DOS de Microsoft. Ce
système est l’ancêtre de l’actuel Windows. D’autres
constructeurs ont développé d’autres architectures
et l’ont équipé de variétés de SEs comme
Motorola, Apple ou Digital Research.

20
 Système d’exploitation réseau
 Un système distribué est un ensemble de machines
autonomes connectées par un réseau, et équipées d’un
logiciel dédié à la coordination des activités du système
ainsi qu’au partage de ses ressources
 Un système distribué est un système qui s’exécute sur un
ensemble de machines sans mémoire partagée, mais que
pourtant l’utilisateur voit comme une seule et unique
machine

21
 La miniaturisation – Les systèmes embarqués:1990 à
nos jours: Téléphones portables, Téléviseurs, machines à
laver, équipement médical, etc .
-Équipements électroniques autonomes conçus pour une
tâche bien précise doté d’un SE et de processeurs.

Exemple: Un système à domicile peut contrôler la

température, l’éclairage, l’alarme et même la machine {
café. Bientôt, le réfrigérateur pourra commander du lait
par internet quand il s’aperçoit qu’il n’en reste plus assez.

22
23
 Chaque composant (processeurs, mémoires et périphériques) de
l’ordinateur a son propre code qui assure son fonctionnement et
les interactions avec les autres.
 Le système d’exploitation gère et coordonne l’ensemble de ces
composants au moyen de signaux (interruptions).
 Les interruptions permettent au SE de reprendre le contrôle:
– Interruptions matérielles :
•Horloges (pour gérer l’allocation des processeurs)
•Périphériques
– Interruptions logicielles :
•Erreurs arithmétiques (division par zéro)
•Données non disponibles en mémoire (défaut de page)
•Appels système (invocation du système d’exploitation).
24
25
 les processeurs ont deux modes de fonctionnement:
– Le mode superviseur (noyau, privilégié ou maître): pour le
système d’exploitation, où toutes les instructions sont autorisées.
– Le mode utilisateur (esclave): pour les programmes des
utilisateurs et les utilitaires, où certaines instructions ne sont pas
permises.

 Un appel système consiste en une interruption logicielle qui a

pour rôle d’activer le système d’exploitation. Il a pour but de
changer de mode d’exécution pour passer du mode utilisateur au
mode maître.

26
 Les processeurs sont dotés d’un bit de mode: Ce mode de
fonctionnement assurent la protection du système
d’exploitation contre les intrusions et les erreurs.

27
28
29
 Les appels systèmes permettent:

- la création,
- la synchronisation
- l’arrêt des processus
- la communication interprocessus
- gestion de fichiers et répertoires

30
 Un processus peut créer un ou plusieurs
processus fils qui, à leur tour, peuvent créer des
processus fils (structure arborescente): commande
Fork()

 Un processus peut être partitionné en plusieurs

threads concurrents partageant un même environnement
d’exécution. Les threads sont un moyen de raffiner et de
diviser le travail normalement associé à un processus.
31
32
 - Segments de données partagés;
- Fichiers;
- Signaux;
- Messages -> Tubes de communication (pipe)

33
 Éviter l’accès simultané lecture/écriture ou
écriture/écriture à une même donnée.

34
 Partage de ressources:

35
 Un fichier est un ensemble de blocs sur le disque

36
 Les appels systèmes permettent de créer des fichiers, de les
supprimer, de les ouvrir, de les lire, de les modifier et de récupérer
leurs attributs…

37
 Les fichiers sont regroupés dans des répertoires.
Un répertoire peut contenir soit des fichiers, soit
d’autres répertoires (structure arborescente).
• L’accès au fichier se fait en spécifiant le chemin
d’accès (la liste des répertoires { traverser).
• Un chemin d’accès est absolu si le point de départ
est le répertoire racine.
• Un chemin d’accès est relatif si le point de départ
est le répertoire courant.

38
A

39
40
 A chaque fichier ou répertoire sont associés des droits
d'accès: autorisation ou inhibition de la lecture noté r,
de l'écriture noté w, de l'exécution noté x.
rwx rwx rwx
Autre s
Propriétaire groupe
utilisateurs
 exemple:
droits = 1101010002 = 6508
affiché sous la forme : rw-r-x---
droits du propriétaire : Lire, Ecrire
droits des membres du groupe : Lire, Exécuter
droits des autres : aucun
41
 Structure monolithique: ensemble de procédures
de même niveau: une procédure principale qui
appelle la procédure de service requise qui fait
appel à son tour à des procédures utilitaires qui
assistent les procédures de service (ex: la recherche
de données des programmes utilisateur)

42
43
 Micro noyau: Architecture plus moderne que la structure
monolithique.
 Différence entre les deux architectures se situe dans
l’implantation de leurs architectures respectives en mode
superviseur (kernel mode) et en mode usager (user mode).
 L’architecture monolitique met en œuvre tous les services
du SE dans le domaine du mode superviseur.
 l’architecture micro-kernel fait une division entre les
services du SE: services «haut-niveau» implantés dans le
domaine de l’utilisateur et «bas-niveau» implantés dans
l’espace du mode superviseur.

44
messages

45
1
Cycle de vie de programmes
en mémoire et lancement
de processus

2
 Un programme (écrit par l’utilisateur en langage
évolué) ne peut pas s’exécuter directement sur un
processeur cible. Il doit passer par plusieurs étapes
pour qu’il puisse s’exécuter.

3
4
 La traduction est le processus de transformation du
programme écrit (avec un éditeur de texte ou un
environnement de développement) en langage source vers
un programme en langage machine.
 Si le programme source est écrit en langage évolué (C, C++,
Pascal, etc.), la traduction nécessite un compilateur. Le
compilateur utilise des techniques d’analyse lexicale et
syntaxique pour générer le code objet.
 Si le programme source est écrit en langage assembleur, la
traduction nécessite un programme dit assembleur. La
traduction consiste en gros à déterminer l’adresse de chaque
symbole (variable ou étiquette) et à remplacer chaque
instruction mnémonique en son équivalent machine.
5
 Que se soit compilation ou assemblage, le résultat
obtenu est dit module objet qui ne peux pas être
exécuté par la machine pour deux raisons:
 Les instructions et les données seront localisées à
des adresses relatives qui ne sont pas forcément
des adresses permises à l’exécution.
 Le programme source peut faire appel à des
procédures qui se trouvent dans d’autres fichiers
sources ou objets.

6
 Remarques
 Certains langages (comme les scripts PHP, HTML, etc)
ne sont pas compilés mais lus et exécutés
directement. On dit qu’ils sont interprétés.
 Certains compilateurs traduisent d’abord le source en
langage assembleur pour qu’on puisse porter des
modifications au niveau bas et le réassembler ensuite.
 Le programme objet peut être absolu (les adresses des
instructions et des données ont des adresses fixes)
comme il peut être relogeable (les instructions et les
données peuvent être relogées dans un endroit
quelconque en mémoire)
7
 Code Opération
étiquette (Mnémonique) Opérandes
Ex:
….
Boucle Add A Dix Littéraux :valeurs Symboles
dans différente correspondant à
Dix DC 10 bases(binaire, des adresses en
hex, décimal...) mémoire
…..
 Chaque octet de l’instruction peut être adressé
individuellement.
8
TTL ‘Titre du programme’
Vecteur DS 50 ¢ Définition de la variable vecteur
et réservation de 50 mot
Zero DC 0 ¢ Définition de la constante zero
qui a la valeur 0.
PLEN 50 ¢ 50 lignes par page
FIN

9
 le programme source est lu à 2 reprises (2 passes).
 première passe (préparation)
 Initialise le compteur d’emplacement pour trouver
l’adresse de chaque instruction et donnée.
 Crée et remplit une table des symboles contenant
tous les symboles rencontrés et les adresses
associées.
 Crée et remplit la table des codes opération.
 Réserve des espaces mémoire pour les constantes
et les variables (en associant le nombre d’octets
approprié à chaque type)
10
 La table des symboles contient tous les
symboles(étiquettes) du programme. Pour chaque
symbole, l’assembleur lui associe son adresse. Si
l’adresse est connue (définition du symbole),
l’assembleur l’enregistre avec le symbole. Si l’adresse
est inconnue (référence en avant), l’assembleur
enregistre uniquement le symbole. L‘assembleur
parcourt le programme et quand il arrive à l’endroit ou
est définit ce symbole, il mettra à jour la table avec la
valeur de ce symbole.
 La table des codes opération est une table contenant
le code opération de chaque instruction et sa longueur
en octets. Cette table permet de connaitre la taille de
l’espace occupé par chaque instruction. 11
Deuxième passe (traduction proprement dite)
Dans cette passe, le code source est relu une
nouvelle fois et le code objet est généré au fur et à
mesure.

12
 Champ adresse
Tab DS 2 adresse :0000 sur 2 octets table des symboles
Dix DC 10 adresse: 0002
JUMP Boucle adresse: 0004 Symbole Valeur Type
……………………. Tab 0000 Mot
………………
Boucle MOVE Dix A1 adresse: 001A Dix 0002 Mot
MOVE A1 Tab adresse: 001F Boucle 001A Label
A1 DS 2 adresse: 0024
A1 0024 Mot
On suppose qu’un CO est sur 1 octet
Et un symbole sur 2 octets. table des code opération
Mnémonique Code opération(Hex)
Code opération JUMP 05
sur 1 octets
MOVE 07
13
Tab DS 2

Dix DC 10 00 0A
JUMP Boucle 05 00 1A
…………………….
………………
Boucle MOVE Dix A1 07 00 02 00 24
MOVE A1 Tab 07 00 24 00 00
A1 DS 2

14
 une seule lecture du programme source est effectuée. Le
code objet est généré en mémoire au fur et à mesure que les
instructions sont lues.
 Quand l’assembleur rencontre une instruction qui fait
référence à une étiquette non résolue, il garde un pointeur
vers cette instruction en attendant que cette étiquette soit
rencontrée. Une fois l’étiquette trouvée, l’assembleur revient
aux instructions l’ayant référencée et les met à jour. A la fin
de la lecture, l’assembleur crée un fichier objet et met le
contenu mémoire assemblé dans ce fichier.
 Cette technique est plus rapide que la précédente mais
consomme beaucoup de mémoire du au fait que tout le code
objet doit être construit en mémoire avant de le mettre dans
un fichier objet. 15
1.Tab DS 2 @ 00 00
2.Dix DC 10 @ 00 02 table des symboles
3. JUMP Boucle @ 00 04 Symbol Valeur Type Bit File d’attente
……………………. e indicateur
10.Boucle MOVE Dix A1@ 00 1A Tab 0000 Mot 0
11. MOVE A1 Tab@ 00 1F
Dix 0002 Mot 0
12. A1 DS 2 @ 00 24
Boucle -------- ------- 1 0004

table des instructions assemblées

table des instructions non assemblées
Ligne Instruction Adresse Ligne Instruction Adresse
1 ---- ---- 0000 3 ….. 0004
2 000A 0002
16
1.Tab DS 2 @ 00 00
2.Dix DC 10 @ 00 02 table des symboles
3. JUMP Boucle @ 00 04 Symbol Valeur Type Bit File d’attente
……………………. e indicateur
10.Boucle MOVE Dix A1@ 00 1A Tab 0000 Mot 0
11. MOVE A1 Tab@ 00 1F
Dix 0002 Mot 0
12. A1 DS 2 @ 00 24
Boucle 001A Label 0 0004
A1 ------- Mot 1 001F,001A
table des instructions assemblées
table des instructions non assemblées
Ligne Instruction Adresse Ligne Instruction Adresse
1 ---- ---- 0000 3 05 00 1A 0004
2 000A 0002 10 …… 001A
11 …… 001F 17
1.Tab DS 2 @ 00 00 table des symboles
2.Dix DC 10 @ 00 02
Symbol Valeur Type Bit File d’attente
3. JUMP Boucle @ 00 04 e indicateur
…………………….
Tab 0000 Mot 0
10.Boucle MOVE Dix A1@ 00 1A
11. MOVE A1 Tab@ 00 1F Dix 0002 Mot 0
12. A1 DS 2 @ 00 24
Boucle 001A Label 0 0004
A1 0024 Mot 0 001F,001A
table des instructions assemblées table des instructions non assemblées

Ligne Instruction Adresse Ligne Instruction Adresse

3 05 00 1A 0004
1 ---- ---- 0000
10 07 0002 0024 001A
2 000A 0002
12 ---- ---- 0024 11 07 0024 0000 001F 18
 La production d’un programme exécutable nécessite
la combinaison de différents modules. Cette opération
est dite édition de liens. Elle consiste à effectuer les
tâches suivantes :
 Rechercher dans les librairies de programmes les
routines utilisées et les insérer dans le programme.
 Résoudre les adresses de tous les modules:
établissement d’une table des modules.
 Ajuster les références externes au sein de chaque
module: translation d’adresse.
 Produire le programme exécutable regroupant tous
les modules. Ce fichier a le même format qu’un fichier
objet sauf qu’il n’a pas de références non résolues.
19
20
 Proc. Prog. Proc. Proc.
Source1 Principal Source2 Source n

Traduction
0 0 0
Proc. Prog. Proc. Proc.
N1-1 Source1 N2-1 Principal Source2 Source n
N3-1

Edition de liens
0
Prog.principal
N2-1
N2 -Aller à5 aller à N2+5
Module objet 1
N2+N1-1 -Call MO2 Call N2+N1
N2+N1 (consulter la table des
modules)
Module objet 2
N2+N1+N3-1

Module objet n
21
 Table des modules :
Module Adresse longueur Adresse fin
début
Prog.principal 0 N2 N2-1

Module Objet1 N2 N1 N2+N1-1

ModuleObjet2 N2+N1 N3 N2+N1+N3-1

22
 le chargeur est exécuté en mode noyau et a pour tâches les
éléments suivants:
 Lire l’entête du fichier exécutable pour déterminer la taille du
code (programme) et des données
 Créer un espace mémoire suffisant pour le code, les données et
la pile.
 Copier les instructions et les données dans cet espace en
effectuant les translations nécessaires pour les adresses
absolues.
 Initialiser les registres du processeur (en général, les remettre
tous à zéro).
 Sauter à la routine de démarrage (start-up) qui fait passer le
processeur en mode utilisateur et donne la main à son tour à la
routine 'main' du programme (module principal du
programme).
23
 Deux types de chargeur :
 Chargeur absolu: Opère dans les systèmes mono
programmés. Un espace mémoire est réservé une
fois pour toute pour le module. La translation
d’adresses se fait en fonction de cet emplacement.
 Chargeur relogeable: Opère dans les systèmes
multiprogrammés. Le module peut être utilisé par
plusieurs programmes et donc chargé plusieurs fois
en mémoire. Un registre de base est alors utilisé
pour translater automatiquement les adresses des
instructions.
24
Processus

25
 Un processus est un programme en cours d’exécution
caractérisé par :
– Un numéro d’identification unique (PID);
– Un espace d’adressage (code, données, piles d’exécution);
– Un état principal (prêt, élu, bloqué, …);
– Les valeurs des registres lors de la dernière suspension (CO,
PSW, …);
– Une priorité;
– Les ressources allouées (fichiers ouverts, mémoires,
périphériques …);
– Les signaux à capturer, à masquer ou à ignorer.
– Identifiant du père, des fils, groupe, variables
d’environnement, statistiques et limites d’utilisation des
ressources…. 26
27
28
29
30
31
 Un démons est un processus qui s’exécute en
arrière-plan. Ceci implique que son père n’attend
pas la fin de son exécution. Les démons ne sont
associés à aucun terminal ou processus utilisateur.
Ils sont toujours à l’écoute et attendent qu’un
évènement se produise. Ils réalisent des tâches de
manière périodique.

32
 Le SE fournit un ensemble d’appels système qui permettent la création, la
destruction, la communication et la synchronisation des processus.
 Un processus peut créer un ou plusieurs processus qui, à leur tour, peuvent
en créer d’autres.
 Dans certains systèmes (MS-DOS), lorsqu’un processus crée un processus,
l’exécution du processus créateur est suspendue jusqu’à la terminaison du
processus créé (exécution séquentielle).
 Dans Windows, les processus créateurs et créés s’exécutent en
concurrence et sont de même niveau (exécution asynchrone mais pas de
relation hiérarchique explicite gérée par le SE).
 Un processus se termine par une demande d’arrêt volontaire (appel
système exit()) ou par un arrêt forcé provoqué par un autre processus
(appel système kill()). 33
34
 Le programme amorce charge une partie du
système d’exploitation à partir du disque pour lui
donner le contrôle. Cette partie détermine les
caractéristiques du matériel, effectue un certain
nombre d’initialisations et crée le processus 0.
• Le processus 0 réalise d’autres initialisations (ex.
le système de fichier) puis crée deux processus: init
de PID 1 et démon des pages de PID 2.
• Ensuite, d’autres processus sont crées à partir du
processus init.

35
 Chaque processus a un numéro d’identification unique (PID). L’appel system getpid()
permet de récupérer le PID du processus: int getpid();
 Chaque processus a un père, à l’exception du premier processus créé (structure
arborescente). S’il perd son père, il est tout de suite adopté par le processus init de PID 1.
L’appel système getppid() permet de récupérer le PID de son processus père.
 Un processus père s’exécute en concurrence avec ses fils (exécution asynchrone).
 Un processus fils peut partager certaines ressources (mémoire, fichiers) avec son processus
père ou avoir ses propres ressources. Le processus père peut contrôler l’usage des
ressources partagées.
 Le processus père peut avoir une certaine autorité sur ses processus fils. Il peut les
suspendre, les détruire (appel système kill), attendre leur terminaison (appel système wait)
mais ne peut pas les renier.
 La création de processus est réalisée par duplication de l’espace d’adressage et de certaines
tables du processus créateur (l’appel système fork). La duplication facilite la création et le
partage de ressources. Le fils hérite des résultats déjà calculés par le père.
 Un processus peut remplacer son code exécutable par un autre (appel système exec). 36
 La norme Posix définit des appels système pour la gestion de processus:

pid_t fork(): Création de processus fils.

int execl(), int execlp(), int execvp(), int execle(),
int execv(): Les services exec() permettent à un processus
d’exécuter un code différent.
pid_t wait(): Attendre la terminaison d’un processus.
void exit() : Finir l’exécution d’un processus.
pid_t getpid(): Retourne l’identifiant du processus.
pid_t getppid(): Retourne l’identifiant du processus père.
type pid_t: long int.

37
38
39
 L’appel système fork :
– associe un numéro d’identification (le PID du processus);
– ajoute puis initialise une entrée dans la PCB. Certaines entités comme les
descripteurs de fichiers ouverts, le répertoire de travail courant, les limites des
ressources sont copiées du processus parent;
– duplique l’espace d’adressage du processus effectuant l’appel à fork
(pile+données);

 La valeur de retour est:

– 0 pour le processus créé (fils).
– le PID du processus fils pour le processus créateur (père).
– négative si la création de processus a échoué (manque d’espace mémoire ou le
nombre maximal de créations autorisées est atteint).
 Au retour de la fonction fork, l’exécution des processus père et fils se poursuit, en
concurrence, à partir de l’instruction qui suit fork.
 Le père et le fils ont chacun leur propre image mémoire mais ils partagent
certaines ressources telles que les fichiers ouverts par le père avant le fork. 40
 i

(40) (27) 41
42
43
44
45
Exécution

46
 Exécution
sans
l’instruction
sleep

47
 Les appels système wait( ) et waitpid( ) permettent à un processus
père d’attendre ou de vérifier la terminaison d’un de ses fils:
#include <sys/wait.h>
int wait (int *status);
int waitpid(int pid, int *status, int options);
void exit(int return_code);
wait et waitpid retournent :
– le PID du fils qui vient de se terminer,
– -1 en cas d’erreur (le processus n’a pas de fils).
– des informations concernant la terminaison du fils, dans le paramètre
status.
Ces informations peuvent être récupérées au moyen de macros telles que :
• WIFEXITED(status) : fin normale avec exit
• WIFSIGNALED(status) : tué par un signal
• WIFSTOPPED(status) : stoppé temporairement
• WEXITSTATUS(status) : valeur de retour du processus fils ( exit(valeur))

48
 Status: Permet de savoir comment s’est terminé un processus:
 Si le fils est stoppé, les 8 bits de poids fort contiennent le numéro
du signal qui a arrêté le processus et les 8 bits de poids faible ont la
valeur octale 177.
 Si le fils s’est terminé avec un exit(), les 8 bits de poids faible de
status sont nuls et les 8 bits de poids fort contiennent les 8 bits de
poids faible du paramètre utilisé par le processus fils lors de l’appel
de exit().
 Exemple de macro:

WEXITSTATUS(status)
La définition de ce macro se trouve dans <sys/wait.h> :
#define WEXITSTATUS(s) (((s)>>8) &0xFF)
49
 Options:
WNOHANG: revenir immédiatement si aucun fils n'est achevé.
WUNTRACED: revenir si un fils est bloqué.
WCONTINUED: revenir si un fils bloqué a été relancé par la délivrance
du signal SIGCONT.
-wait(status) et waitpid(-1,status,0) bloquent le processus appelant
jusqu’à ce que l’un quelconque des fils du processus se termine.
-waitpid(pid, status,0) avec pid>0, bloque le processus appelant
jusqu’à ce que son fils pid se termine.
-waitpid(pid, status, WNOHANG) vérifie seulement la terminaison,
retourne 0 en cas de non terminaison (pas d’attente).

50
51
52
53
54
55
 Un processus fils devient un processus zombie
lorsque son père ne l’attend pas.

56
 Le processus init adopte le processus B si son père
meurt avant lui.

57
58
 #include <unistd.h>
int execl(const char *path, const char *argv, ...);
int execv(const char *path, const char *argv[]);
int execle(const char *path, const char *argv, const char *envp[]);
int execlp(const char *file, const char *argv, ...);
int execvp(const char *file, const char *argv[]); 59
 Ces appels permettent d’exécuter de nouveaux
programmes.
 Le processus conserve, notamment, son PID,
l’espace mémoire alloué, sa table de descripteurs
de fichiers et ses liens parentaux (processus fils et
père).
 En cas de succès de l’appel système exec,
l’exécution de l’ancien code est abandonnée au
profit du nouveau.
 En cas d’échec, le processus poursuit l’exécution de
son code à partir de l’instruction qui suit l’appel (il
n’y a pas de remplacement de code) 60
61
62
 On suppose que le fichier a.out est fils.cpp

63
64
1
Ordonnancement de
processus

2
 Les programmes lancés sont d’abord admis par le système
qui se charge d’en créer les processus nécessaires.
 Dans un système multiprogrammé, plusieurs processus
peuvent être présents en mémoire centrale.
 Le système d’exploitation décide de l’ordre et du moment
de l’admission des programmes en attente (ordonnanceur
de haut niveau).
 Il gère également l’allocation du processeur aux différents
processus à exécuter (ordonnanceur de bas niveau).
 L’exécution d’un processus est une séquence alternée de
calculs CPU (rafales) et d’attentes d’événements (E/S).
 Lorsque le processus en cours se bloque, le processeur est
alloué à un autre => L’ordonnanceur de bas niveau se
charge des changements de contexte.
3
4
5
 L’ordonnanceur de haut niveau décide du degré de la
multiprogrammation (nombre maximal de processus
dans le système).
 L’ordonnanceur de niveau intermédiaire gère le
déplacement des processus d’une file d’attente à une
autre.
 Dans la majorité des systèmes actuels, les niveaux
intermédiaire et haut sont combinés -> haut niveau.
 L’ordonnanceur de bas niveau (dispatcher) est sollicité
plusieurs fois par seconde et doit constamment résider
en mémoire.
 L’ordonnancement doit se faire selon une politique
bien réfléchie visant à répondre à des objectifs de
performance. 6
1. Maximiser le nombre de processus exécutés par unité
de temps.
2. Minimiser le temps d’attente de chaque processus.
3. Maximiser les temps d’utilisation des processeurs et
autres ressources.
4. Respecter les échéanciers (terminer l’exécution avant
leurs deadlines).
5. Éviter le problème de famine (attente infinie).
6. Favoriser les processus les plus prioritaires (éviter le
problème d’inversion des priorités).
7. Minimiser le nombre et la durée des changements de
contexte.
7
 Temps de séjour d’un processus (temps de rotation
ou de virement): temps entre l’admission du
processus et sa sortie.
 Temps d'attente d’un processus: somme des
périodes que le processus passe à l'état prêt (temps
de séjour-temps d’exécution).
 Capacité de traitement: nombre de processus
traités par unité de temps.
 Taux d’utilisation d’un processeur.

8
 Choix du processus à exécuter
– Premier arrivé, premier servi.
– Plus prioritaire (priorités statiques ou dynamiques).
– Plus court temps ….
 Le temps d’allocation du processeur au processus choisi:
– Allocation jusqu’à terminaison ou libération volontaire
(ordonnanceur non préemptifs –sans interruption-).
– Temps d’allocation limité, fixe ou variable (ordonnanceur
préemptifs –avec interruption-).
 Quand appeler l’ordonnanceur ?
– Le processus en cours se termine, se bloque ou cède le
processeur,
– Le temps alloué a expiré.
– L’arrivée d’un processus plus prioritaire… 9
 Le système d’exploitation choisit le prochain
processus à exécuter:
– Premier arrivé, Premier servi (FCFS, First-Come
First-Served ou FIFO, first in first out)
– Plus court d’abord (SPF, Shortest Process First ou SJF
Shortest Job First).
– Plus prioritaire d’abord (priorité = (temps d’attente +
temps d’exécution) / temps d’exécution).
 Il lui alloue le processeur jusqu’à ce qu’il se termine, se
bloque (attente d’un événement) ou cède le
processeur.

10
 s

11
12
13
 Pour s’assurer qu’aucun processus ne s’exécute pendant trop de
temps, les ordinateurs ont une horloge électronique qui génère
périodiquement une interruption.
 A chaque interruption d’horloge, le système d’exploitation reprend
la main et décide si le processus courant doit:
– poursuivre son exécution ou
– être suspendu pour laisser place à un autre.
 S’il décide de suspendre l’exécution au profit d’un autre, il doit
d’abord sauvegarder l’état des registres du processeur avant de
charger dans les registres les données du processus à lancer
(commutation de contexte). Cette sauvegarde est nécessaire pour
pouvoir poursuivre ultérieurement l’exécution du processus
suspendu.
14
 Le processeur passe donc d’un processus à un autre en
exécutant chaque processus pendant quelques
dizaines ou centaines de millisecondes.
 La commutation entre processus doit être rapide
(temps nettement inférieur au quantum).
 Le processeur, à un instant donné, n’exécute
réellement qu’un seul processus.
 Pendant une seconde, le processeur peut exécuter
plusieurs processus et donne ainsi l’impression de
parallélisme (pseudo-parallélisme).

15
 Lorsqu’un processus arrive, l’ordonnanceur compare le temps
estimé de son exécution avec celle du processus actuellement en
exécution (version préemptive du SPF). Si ce temps est plus petit,
on exécute immédiatement le nouveau processus.

16
17
 Algorithme équitable mais sensible au choix du
quantum.
 Un quantum trop petit provoque trop de
commutations de processus et abaisse l’efficacité
du processeur
 Un quantum trop élevé augmente le temps
d’attente des courtes commandes en mode
interactif.
 Il était de 1 seconde dans les premières versions d’UNIX.
 Il varie entre 20 et 120 ms.

18
19
20
21
12
22
23
 Problèmes
• Équité: L’exécution des processus moins
prioritaires peuvent être constamment retardée
par l’arrivée de processus plus prioritaires.

• Inversion des priorités: Un processus moins

prioritaire détient une ressource nécessaire à
l’exécution d’un processus plus prioritaire.

24
 Pour empêcher les processus de priorité élevée de s’exécuter indéfiniment,
l’ordonnanceur diminue régulièrement la priorité du processus en cours
d’exécution (priorité dynamique) et augmente progressivement celles des
processus en attente.
 La priorité du processus en cours est comparée régulièrement à celle du
processus prêt le plus prioritaire (en tête de file). Lorsqu’elle devient
inférieure, la commutation a lieu; Dans ce cas, le processus suspendu est
inséré en queue de file correspondant à sa nouvelle priorité.
 Pour favoriser les processus qui font beaucoup d’E/S, ils doivent acquérir le
processeur dès qu’ils le demandent, afin de leur permettre de lancer leurs
requêtes suivantes d’E/S.
 Pour éviter qu’il y ait beaucoup de commutations pour les processus
consommateurs de temps CPU, il est préférable d’allouer un plus grand
quantum à ces processus (quantum variable).

25
 C’est un ordonnanceur à deux niveaux. L’ordonnanceur de bas
niveau se charge d’élire un processus parmi ceux qui résident
en mémoire.
 L’ordonnanceur de haut niveau se charge des transferts de
processus entre la mémoire centrale et le disque.
 L’ordonnanceur de bas niveau utilise plusieurs files, une priorité
est associée à chaque file (plusieurs niveaux de priorité).
 Les processus prêts qui sont en mémoire, sont répartis dans les
files selon leur priorité.
 Les priorités des processus s’exécutant en mode utilisateur
sont positives ou nulles, alors que celles des processus
s’exécutant en mode noyau sont négatives.
 Les priorités négatives sont les plus élevées. 26
27
 L’ordonnanceur de bas niveau choisit le processus le
plus prioritaire qui se trouve en tête de file.
 Le processus élu est alors exécuté pendant au
maximum un quantum (100 ms). S’il ne se termine pas
ou ne se bloque pas au bout de ce quantum, il est
suspendu.
 Le processus suspendu est inséré en queue de sa file.
 La priorité initiale d’un processus utilisateur est en
général égale à 0. La commande nice permet
d’attribuer une priorité plus basse à un processus (>0).
 Les priorités des processus prêts en mémoire sont
recalculées périodiquement toutes les secondes. 28
 L’ordonnanceur de Linux est un ordonnanceur préemptifs
et à priorité.
 Il distingue trois classes de tâches (processus) qu’il
ordonnance différemment:
-temps réel avec priorité (SCHED_FIFO).
-Tourniquet temps réel (SCHED_RR ).
-Temps partagé de la classe OTHER: Ils s’exécutent
uniquement si aucun processus des autres classes n’est prêt.

 Chaque processus créé fait partie d’une des trois classes et

a une priorité comprise entre 1 et 40 (20 par défaut).
 Les valeurs élevées correspondent à des priorités élevées.

29
 Garantit au processus une utilisation illimitée du processeur. Il
ne sera interrompu que dans une des circonstances suivantes:
– Le processus bloque sur un appel système ou se termine.
– Un autre processus de la classe SCHED_FIFO de priorité plus
élevée est prêt. Dans ce cas le processus actuel est remplacé
par celui-ci.
– Le processus libère lui-même le processeur, en exécutant
l’appel système sched_yield().

 Rien n’est plus prioritaire qu’un processus de la classe

SCHED_FIFO, à l’exception d’un autre processus de la même
classe qui possède une valeur de priorité supérieure.
30
 Stratégie préemptive. Chaque processus de cette classe se voit
attribuer un quantum. Lorsque ce quantum sera écoulé, le
contrôle sera donné à un autre processus de même priorité de la
classe SCHED_RR en appliquant l’algorithme du tourniquet.
 le tourniquet ne se fait qu’avec des processus de même priorité.
 Si deux processus de la classe SCHED_RR avec une priorité de
20 s’exécutent, ils alterneront dans le processeur. Si entretemps
apparaît un processus de la même classe, mais de priorité 25,
c’est ce dernier qui prend le contrôle du processeur et ne le
redonnera que lorsqu’il se terminera. À moins, que n’apparaisse
un autre processus SCHED_RR de priorité supérieure ou égale, ou
encore un processus SCHED_FIFO.

31
 Les processus de cette classe se partagent le processeur
de manière inégale, selon leur priorité et leur usage du
processeur.
 chaque processus possède une valeur de priorité qui lui est
attribuée au moment de sa création: priorité statique.
 Le Quantum du processus initial est égale à la priorité et
diminue de 1 unité à chaque consommation de 10 ms de
temps CPU.
 Les quanta sont réajustés lorsque tous les processus sont
bloqués ou leurs quanta sont nuls: Quantum:= Quantum/2
+ priorité
32
 Le processus élu est celui qui a une plus forte note.
 Allouer le processeur à celui qui a la plus grande note
(temps d’allocation maximum est 10 fois son quantum)
33
34
35