Introduction Générale aux

Systèmes d’Exploitation
 Plan

1. Définition
2. Les différents types de système d’exploitation.
3. Rôles du système d’exploitation
4. Historique
5. Structure des systèmes d’exploitation

2
 Système d’exploitation
Déftnition
Un système d’exploitation (SE) en anglais (operating system) est un
ensemble de programmes responsables de la liaison entre les ressources
matérielles d’un ordinateur et les applications informatiques de l’utilisateur

L’utilisateur travaille avec ses

logiciels.
Les logiciels communiquent avec
l’OS.
L’OS échange avec l’ordinateur.
 Les différents types de système d’exploitation
Multi utilisateurs
Un système d’exploitation qui peut supporter plusieurs sessions en même temps.
Multi tâches
Un système d'exploitation est multitâche s’il permet d’exécuter, de façon
apparemment simultanée, plusieurs programmes informatiques. On parle
également de multiprogrammation.

Multi tâches « coopératif »

Le passage de l’exécution d’un processus à un autre est appelé commutation de
contexte. Ces commutations sont initiées par les processus eux-mêmes
Inconvénients :

• Processus en cours bloqué = système bloqué

• Le partage des ressources (temps CPU, mémoire, accès disque, etc.)
peut être inefficace.
Windows 3.x
Multi tâches « préemptif »
le processeur signale au système d’exploitation que le processus en cours d’exécution
doit être mis en pause pour permettre l’exécution d’un autre processus.
• Sauvegarde de l’état
• File d’attente
• Restauration du contexte d’exécution

Multi processeurs
Système avec plusieurs processeurs en parallèle.
vrai multitâches ( Exécution de plusieurs processus en même temps).
Puissance de calcul plus importante.
Disponibilité du système (en cas de panne d'un processeur)
Systèmes temps réel
prévus pour traiter des informations de manière fiable dans un temps donnés :
• Applications industrielles,
• Robotique,
• Transports, …

Systèmes embarqués
prévus pour fonctionner sur :
• des machines de petite taille ( , téléphone, …)
• des appareils électroniques autonomes (sondes spatiales, robot,
ordinateur de bord de véhicule, …)
Autonomie réduite = gestion avancée de l'énergie
 Rôles du système d’exploitation
La gestion du processeur: le système d’exploitation est chargé de gérer l’allocation du
processeur entre les différents programmes grâce à un algorithme d’ordonnancement .
Gestion de la mémoire : le système d’exploitation est chargé de gérer l’espace mémoire
alloué à chaque application.
Gestion des entrées/sorties: le système d’exploitation permet de contrôler l’accès des
programmes aux ressources matérielle par l’intermédiaire des pilotes.
Gestion des fichiers : le système d’exploitation gère la lecture et l’écriture dan le système
de fichier et des droits d’accès aux fichiers par les utilisateurs et les applications.
 Historique

. Première génération (1945-

1955).

Deuxième génération (1955-1965)

Troisième génération (1965-1980)

La quatrième génération (après les

années 1980)

8
 Historique: La première génération (1945-1955).

• Moteurs de calcul utilisant des relais

mécaniques (temps de cycles en secondes)
remplacés ensuite par des tubes à vide
• Ni langage ni système d'exploitation.
• 1950 : Première amélioration : les cartes
perforées = « écriture de programmes »

9
Historique: La quatrième génération (après les années 1980)

• Ordinateurs personnels
• Circuits intégrés à haute densité (Puces
contenant des milliers de transistors sur
1mm2 de silicium).
• Micro-ordinateurs, très peu onéreux comparés
aux mini-ordinateurs de type PDP-11
• Systèmes d’Exploitation CP/M, MS-DOS, MAC
OS X, Windows, UNIX, Linux…

10
Structure des systèmes d’exploitation

Les systèmes monolithiques:

C’est-à-dire que l’ensemble des fonctions du système et des pilotes sont regroupés
dans un seul bloc de code et un seul bloc binaire généré à la compilation.(MS DOS,
Les premières version d’UNIX).

L’évolution du code s’est faite en parallèle à l’évolution du matériel, et des problèmes

de portage ont alors été mis en évidence sur les noyaux monolithiques.
11
Structure des systèmes d’exploitation
Un système d’exploitation est un logiciel complexe qui joue le rôle d’interface
entre le matériel est les logiciels d’application.

Le logiciel SE peut être organisé de diverses manières

Les systèmes monolithiques modulaire:

• les parties fondamentales du système sont

regroupées dans un bloc de code unique .
• Les pilotes matériels, sont regroupées en
différents modules .

12
Les machines virtuelles

13
Les systèmes en couches:

14
L’architecture client/serveur

• La plupart des fonctionnalités d'un SE sont reportées dans des processus utilisateurs.
• Pour demander un service comme la lecture d'un bloc de fichier, le processus client
envoie une requête à un processus serveur qui effectue le travail et envoie une
réponse.

• la seule fonction du noyau est la mise en communication du client avec le serveur.

15
Chapitre1:La gestion des processus

SYSTÈMES D’EXPLOITATION
AVANCÉES

16
 Plan

1. Définition
a. Processus
2. Le modèle des processus
a. L’arborescence
b. Le PCB
c. Les états d’un processus
d. Commutation de contexte
3. Ordonnancement des processus

17
 Définition : processus

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.

18
 Définition : processus

• Caractéristiques statiques, c’est-à-dire ne variant pas au cours de sa vie, sont:

• Un numéro unique: PID (Process IDentifier),
• Un propriétaire déterminant les droits d’accès du processus aux ressources : ouverture de
fichiers...
• Un processus parent dont il hérite la plupart des caractéristiques,
• Un terminal d’attache pour les entrées/sorties.
• Caractéristiques dynamiques sont:
• Priorité, environnement d’exécution...
• Quantité de ressources consommées (temps unité centrale utilisé...)

19
 Programme vs processus
Programme
Base de comparaison Processus

Le programme est un Lorsqu'un programme est en

De base
ensemble d'instructions. cour d’exécution , il est
appelé processus.

La nature
statique Dynamique

Durée de vie
Plus long Limité

Le programme est stocké sur Processus utilise les

Ressources requises le disque dans certains ressources telles que le
fichiers et ne nécessite processeur, la mémoire, le
aucune autre ressource. disque, les E / S, etc.

20
 Image mémoire d’un processus

L’espace mémoire alloué à un processus, dit image

mémoire (Memory Map) du processus,il est divisé en un Pile
ensemble de parties :
1. Segment de code (Text section) : Copie du segment de
code du fichier exécutable
2. Segment de données (Data section ) : qui contient
l’ensemble des constantes et variables déclarées. Tas
3. Pile (Stack) : qui permet de stocker :
• les valeurs des registres. Segment de données
• les variables locales et paramètres de fonctions.
• les adresses de retour des fonctions. Segment de code

4. Tas (Heap) :
zone de la mémoire allouée dynamiquement.
21
 Bloc de contrôle de processus
Chaque processus est représenté dans le système d’exploitation par une structure de
données contenant toute les informations décrivant le contexte d’un processus appelé
bloc de contrôle (Process Control Bloc: PCB).

PCB: contient plusieurs informations concernant un

processus spécifique : PCB
 L’état du processus: nouveau, prêt, en exécution, en Pointeur État du processus
attente, arrêté… Numéro du processus
 PID, UID,GID, PPID Compteur d’instructions
 Compteur d’instructions: : indique l’adresse de
Registres
 la prochaine instruction à exécutée par ce processus.
 Informations sur l’ordonnancement de la Limite de la mémoire
CPU:information concernant la priorité du processus. Liste des fichiers ouverts
 Informations sur la gestion de la mémoire
...
 Informations sur l’état des E/S: liste des
périphériques E/S allouées à ce processus, une liste
des fichiers ouverts, etc. 22
 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é de :
− Mot d’état (Program Status Word PSW),
− registres généraux.
– compteur ordinal (Program Counter PC). Contient l’adresse mémoire de la
prochaine instruction à exécuter.
– registre d’instruction (Instruction Register IR). Contient l’instruction en cours
de traitement.
– registre d’état (FLAGS register). Ensemble de bits représentant des drapeaux.
– pointeurs de pile (Stack Pointer SP). Contient l’adresse du sommet de la pile.
– mode d’exécution (MODE). En mode esclave, les instructions privilégiées
sont interdites, et en mode maître les restrictions disparaissent.
– masque d’interruptions (Interrupt Mask IM). Indique le niveau de priorité du
processus courant, qui est utilisée pour savoir si une interruption doit être prise
en compte immédiatement, ou alors être retardée (masque).

23 8
 Arborescence des processus

 Les processus sont organisés sous forme d’une arborescence ou chaque

processus a un seul père et peut avoir plusieurs fils.
 Un processus est identifié par un PID (Process IDentifier) et un PPID
(Parent Process IDentifier).
 Exemple: L’arborescence des processus sous Linux

init

Login:
Mot de passe:
Login:
Mot de passe:
… Login:
Mot de passe:

shell

ls

24 9
 Arborescence des processus unix

25
 états d’un processus

Lorsqu’un processus s’exécute; il change d’état. Il peut se trouver dans

l’un des trois états principaux suivants:

Prêt (Ready) : le processus attend

son tour pour s’exécuter Nouveau Terminé

 

Élu (Running) : les instructions sont Prêt Élu
encours d’exécution. 
 
Bloqué
Bloqué (Sleep) : le processus bloqué
en attente d’événement: signal, E/S,
… Graphe des états d’un processus

26
 Transitions

1. Création du processus
2. Allocation du processeur Nouveau Terminé
3. Fin du temps alloué sur le  

processeur, l’exécution du Prêt Élu
processus n’est pas terminée

4. Opération E/S  
Bloqué
5. Fin opération E/S
6. Exécution terminée Graphe des états d’un
processus

27
 Commutation de contexte

 Sur un système P0 P1
multiprogrammé, le SE doit
redonner le contrôle du Élu
Inactif
processeur d’un processus à
un autre en effectuant des Sauvegarde PCB0

commutations de contexte. Recharge PCB1

 La commutation de contexte
consiste à mémoriser le PCB Inactif Élu
du processus courant et
charger le PCB du processus
Sauvegarde PCB1
à élire.
Recharge PCB0
Inactif
Élu

28
 Commutation de contexte

Le basculement d'un processus à l'autre est géré par le noyau.

• Suspendre le processus P0
• Mettre à jour le PCB de P0
• Restaurer le PCB de P1
P0 P1
• Reconfigurer l'espace mémoire
Élu
Inactif
• Démarrer P1
Sauvegarde PCB0

Recharge PCB1

Inactif Élu

Sauvegarde PCB1

Recharge PCB0
Inactif
Élu
29
 table de processus :

30
 Ordonnancement

Lorsqu’un ordinateur est multiprogrammé, il possède fréquemment plusieurs

processus en concurrence pour l’obtention de temps processeur.

A qui allouer?
P3 P2 P1 CPU

File d’attente CPU

→ S’il n’y a qu’un seul processeur, un choix de processus à exécuter

doit être fait .

La partie du système d’exploitation qui effectue ce choix se nomme

l’ordonnanceur (scheduler) et l’algorithme qu’il emploie s’appel
algorithme d’ordonnancement .

31
 Ordonnancement des processus

Les algorithmes d’ordonnancement:

• FCFS: First Come First Served

• SJF: Shortest Job First

• RR: Round-Robin

• Ordonnancement par priorité

32
Les entités responsables de l’ordonnancement

Preemption
Scheduler
(Ordonnanceur)
CPU1
File des
Processeurs
Election de
Sortie du Dispatcher Process prêts
système CPU2 (répartiteur)

Election de
PCB PCB PCB PCB

processus
CPU4
File des
bloques
Blocage PCB PCB Réveil

Nadia Bel Hadj Aissa 33

Critères d’Ordonnancement

• Utilisation du CPU
• Débit (Throughput): le nombre moyen de processus traités par unité de temps.

• Temps de rotation (Turnaround time)

• Temps d’attente

• Temps de réponse
Critères d’optimisation: max/min
• Les critères d’ordonnancement peuvent être ramenés à des
problèmes d’optimisation. Chaque critère devra être maximisé
ou minimisé.
• Utilisation du CPU

même temps??
Peuvent-ils tous être optimisés en
– Maximiser
• Débit (Throughput)
– Maximiser
• Temps de rotation (Turnaround time)
– Minimiser
• Temps d’attente
– Minimiser
• Temps de réponse
– Minimiser

35
Avec/Sans réquisition
• Ordonnancement sans réquisition (non préemptif):
– Une fois que le CPU a été allouée à un processus, ce dernier le
garde jusqu'à ce qu’il le libère, soit parce qu’il a terminé, soit
parce qu’il commute à l’état en attente.
– Algorithmes simples et faciles à mettre en œuvre mais pas
adaptés pour le temps partagé et seulement pour les système
de traitement par lots.
• Ordonnancement avec réquisition (préemptif):
– Un processus peut être suspendu à n’importe quel instant,
sans avoir été prévenu, pour laisser la place à un autre
processus.
– Implémentation plus couteuse à cause de la commutation de
processus, utilisée dans les systèmes à temps partagé et
systèmes temps-réels.
– Nécessité d’un mécanisme de synchronisation.

36
1 Cas : FCFS (Premier arrivé, premier servi )
l'unité centrale est allouée selon l'ordre de soumission des processus.

On suppose que les processus arrivent en meme temps à l’instant 0 et admis dans
l’ordre : P1 , P3 , P2 , P4
On considère l’ensemble des processus
suivants :

Processus Temps d’exécution Temps d’attente

P1 3 P1 = 0
P2 9 P2 = 8
P3 5
P3 = 3
P4 7
P4 = 17
Le diagramme de Gantt pour l’ordonnancement FCFS de cet ensemble est :

P1 P3 P2 P4
0 3 8 17 24
Temps d’attente moyen = (0 + 8 + 3 + 17) / 4 = 7 37
2èmeCas : FCFS (Premier arrivé, premier servi )
On considère l’ensemble de processus suivant :

Temps Temps Temps d’attente : début d’exécution– temps d’arrivée

Processus
d’exécution d’arrivée
P1 = 0 – 0 = 0
P1 20 0 P2 = 24 – 3 = 21
P2 12 3 P3 = 20 – 2 = 18
P3 4 2 P4 = 36 – 5 = 31
P4 9 5

Le diagramme de Gantt pour l’ordonnancement FCFS est :

P1 P3 P2 P4
0 20 24 36 45

Temps d’attente moyen = (0 + 21 + 18 + 31) / 4 = 70 / 4=17,5

38
 3èmeCas : FCFS (Premier arrivé, premier
servi )
Process Arrival 1st exec 1st I/O 2nd exec 2nd I/O 3rd exec
time
A 0 4 4 4 4 4
B 2 8 1 8 - -
C 3 2 1 2 - -
D 7 1 1 1 1 1

T=0 T=2 T=3 T=4 T=7 T=8 T=12 T=1 T= T=1 T=1 T=1 T=2 T=2 T=3
3 14 5 6 9 3 9 0
A B B B C C C D D A B B C D A
c c D D D A A B C C D A
A A B B C D D A
39
3èmeCas : FCFS (Premier arrivé, premier servi )

• Turn around time (temps de traitement):

tatA = 34 – 0 = 34
tatB = 27 – 2 = 25
tatC = 29 – 3 = 26
tatD = 35 – 7 = 28

tatAVG = (34 + 25 + 26 + 28) / 4 = 28.25

40
3èmeCas : FCFS (Premier arrivé, premier servi )

• Waiting time (temps d’attente):

wtA = (0 – 0) + (15 – 8) + (30 – 23) = 14
wtB = (4 – 2) + (19 – 13) = 8
wtC = (12 – 3) + (27 – 15) = 21
wtD = (14 – 7) + (29 – 16) + (34 – 31) = 23

wtAVG = (14 + 12 + 21 + 23) / 4 = 16.5

41
 3èmeCas : FCFS (Premier arrivé, premier
servi )

• Response time:
rtA = 0 – 0 = 0
rtB = 4 – 2 = 2
rtC = 12 – 3 = 9
rtD = 14 – 7 = 7

rtAVG = (0 + 2 + 9 + 7) / 4 = 4.5

42
Inconvénients FIFO

• Dans cette politique, des processus de faible temps

d'exécution peuvent être pénalisés parce qu'un processus de
longue durée les précède dans la file .
• Le temps d’attente n’est pas proportionnel au temps
d’utilisation
⇒ pas équitable,
⇒ temps moyen de traitement élevé

43
SJF (Travail le plus court d’abord ) non-Préemptif
Le plus court d’abord: On exécute le processus le plus court d’abord.
On considère l’ensemble de processus suivant :
Temps Temps Temps d’attente : début d’exécution– temps d’arrivée
Processus
d’éxécution d’arrivée P1 = 30 – 10 = 20
P2 12 0 P2 = 0 – 0 = 0
P3 8 3 P3 = 22 – 3 = 19
P4 4 5 P4 = 12 – 5 = 7
P5 = 16 – 12 = 4
P1 10 10
P5 6 12
Le diagramme de Gantt avec SJF est :

P2 P4 P5 P3 P1
0 12 16 22 30 40

Temps d’attente moyen = (20 + 0 + 19 + 7 + 4) / 5 = 50 / 5 = 10

44
SRTF (temps restant le plus court d'abord) préemptif
On considère l’ensemble de processus suivant :

Processu Temps Temps Temps d’attente : début d’exécution– temps d’arrivée

s d‘exécution d’arrivée P1 = 30 – 10 = 20
P2 = (0 – 0) + (21 - 3) = 18
P2 12 9 0
P3 = (3 – 3) + (9 - 5) = 4
P3 8 65 3
P4 = (5 – 5) = 0
P4 4 5 P5 = 15 – 12 = 3
P1 10 10
P5 6 12

Le diagramme de Gantt avec SJF préemptif est comme suit :

P2 P3 P4 P3 P5 P2 P1
0 3 5 9 15 21 30 40

Temps moyen d’attente = (20 + 18 + 4 + 0 + 3) / 5 = 45 / 5 = 9

45
 SRTF (temps restant le plus court d'abord)
Process Arrival 1st exec 1st I/O 2nd exec 2nd I/O 3rd exec
time
A 0 4 4 4 4 4
B 2 8 1 8 - -
C 3 2 1 2 - -
D 7 1 1 1 1 1

T= T=2 T=3 T=4 T=6 T=7 T=8 T=9 T= T= T= T T= T= T= T= T=2

0 11 12 13 14 16 20 23 24 7

A A 2 A1 B8 B8 B7 B7 B7 B7 B7 B7 B7 B7 B3 A4 A3 B8

B 8 B8 C2 D1 A4 A3 A3 A3 A2 A2 A4 B8

C2 C2 D1 D1
46
 SRTF (temps restant le plus court d'abord)

p p p

• Processor utilization(occupation de
processus) = (35 / 35) * 100 = 100 %
• Throughput(débit) = 4 / 35 = 0.11

47
 SRTF (temps restant le plus court d'abord)

p p p

• Turn around time:

tatA = 27 – 0 =27
tatB = 35 – 2 = 33
tatC = 11 – 3 =8
tatD = 14 – 7 = 7

tatAVG = (27 + 33 + 8 + 7) / 4 = 18.75

48
 SRTF (temps restant le plus court d'abord)

p p p

• Waiting time:
wtA = (0 – 0) + (8 – 8) + (12 - 9) + (14 – 13) + (23 - 20) = 7
wtB = (6 – 2) + (16 – 7) + (27-24) = 16
wtC = (4 – 3) + (9 – 9) = 1
wtD = (7 – 7) + (11 – 10) + (13 – 13) = 1

wtAVG = (7 + 16 + 1 + 1) / 4 = 6.25

49
 SRTF (temps restant le plus court d'abord)

p p p

• Response time:
rtA = 0 – 0 =0
rtB = 6 – 2 =4
rtC = 4 – 3 =1
rtD = 7 – 7 =0

rtAVG = (0 + 4 + 1 + 0) / 4 = 1.25

50
Algorithme du Tourniquet (Round Robin)
• Algorithme conçu spécialement pour le temps
partagé
• Les processus accèdent au processeur, chacun à
leur tour, pour un temps maximal déterminé à
l’avance (le quantum noté q= en général 10-100
millisecondes),
• Lorsqu’il a épuisé ce temps, ou qu’il se bloque : le
processus suivant est élu et le remplace.
• Le processus suspendu est mis en queue du
tourniquet (file FIFO circulaire).

51
Algorithme du Tourniquet (Round Robin)
Le tourniquet (round-robin): On exécute les processus à tour de rôle.
On considère l’ensemble des processus suivant avec un Quantum de temps = 5 UT
Processus Temps
d‘exécution Temps d’attente :
P1 12 7 2 P1 = 0 + (24 - 5) + (37 - 29) = 27
P2 = 5 + (29 - 10) = 24
P2 8 3
P3 = 10
P3 4
P4 = 14 + (32 - 19) = 27
P4 10 5 P5 = 19
P5 5

Le diagramme de Gantt pour l’ordonnancement RR avec q = 5 est comme suit :

P1 P2 P3 P4 P5 P1 P2 P4 P1
0 5 10 14 19 24 29 32 37 39
Temps d’attente moyen = (27 + 24 + 10 + 27 + 19) / 5 = 107 / 5 = 21.4
52
Algorithme du Tourniquet (Round Robin)
Process Arrival 1st exec 1st I/O 2nd exec 2nd I/O 3rd exec
time
A 0 4 4 4 4 4
B 2 8 1 8 - -
C 3 2 1 2 - -
D 7 1 1 1 1 1

T= T=2 T=3 T=6 T=8 T=9 T=1 T=1 T=1 T=1 T=1 T=2 T=2 T=2 T=2 T=2
0 2 3 5 7 8 0 1 2 4 5
A B B C A B D C B A D D B A A D
C A B D C B A D B B A D D B
A B D C B A D A B
53
 Algorithme du Tourniquet (Round Robin)

 Si plus d’un processus essayent d’entrer en même temps à la file

d’attente des processus prêts, la priorité est donnée comme suit:
 1: processus qui viennent d’être soumis
 2: processus qui ont fini une opération d’E/s
 3: Les processus qui ont été préemptés par le CPU
preeemption
3
1
START READY RUNNING HALTED

I/O 2 I/O
completed requested
WAITING
54
Algorithme du Tourniquet (Round Robin)

p p p p p p p

• Processor utilization = (35 / 35) * 100 = 100 %

• Throughput = 4 / 35

55
Algorithme du Tourniquet (Round Robin)

p p p p p p p

• Turn around time:

tatA = 35 – 0 = 35
tatB = 34 – 2 = 32
tatC = 15 – 3 =12
tatD = 26 – 7 = 19

tatAVG = (35 + 32 + 12 + 19) / 4 = 24.

56
 Algorithme du Tourniquet (Round Robin)

p p p p p p p

• Waiting time:
wtA = (0 – 0)+(8 – 3)+(17 – 13)+(24 – 20)+(29 – 29)+(34 – 32)=15
wtB = (3 – 2)+(9 – 6)+ (15 -12)+(21 – 18)+(26 – 24)+(32 – 29) =15
wtC = (6 – 3) + (13 – 9) = 7
wtD = (12 – 7) + (20 – 14) + (25 – 22) = 14

wtAVG = (15 + 12 + 7 + 11) / 4 = 11.25

57
Algorithme du Tourniquet (Round Robin)

p p p p p p p

• Response time:
rtA = 0 – 0 = 0
rtB = 3 – 2 = 1
rtC = 6 – 3 = 3
rtD = 12 – 7 = 5

rtAVG = (0 + 1 + 3 + 5) / 4 = 2.25

58
 Ordonnancement avec priorité
• Le système d’exploitation ordonne les processus prêts selon l’ordre décroissant de
leurs priorités et le processus à élire est celui avec la plus haute priorité

• Un processus ne peut s'exécuter que si aucun processus de priorité supérieure n'est

dans l'état ready.

• Tous les processus ont la même priorité c'est la politique FIFO qui est appliquée.

• Ordonnancement
– non-préemptif ou préemptif

59 43
Ordonancement avec priorité non-préemptif
Priorité: On exécute les processus selon leur priorité.
On considère l’ensemble de processus suivant :
Temps Temps Temps d’attente :
Processus Priorité
d’exécution d’arrivée début d’exécution– temps d’arrivée
P1 10 3 Tous les P1 = 6
P2 1 1 Processus
Arrivent
P2 = 0
P3 2 4 au meme P3 = 16
P4 1 5 temps
P4 = 18
P5 5 2
P5 = 1
Le diagramme de Gantt avec un ordonnancement avec priorité est comme suit :

P2 P5 P1 P3 P4
0 1 6 16 18 19

Temps d’attente moyen = (6 + 0 + 16 + 18 + 1) / 5 = 41 / 5 = 8.2

60
Ordonancement avec priorité préemptif
On considère l’ensemble de processus suivant :

Temps Temps Temps d’attente :

Processus Priorité
d’exécution d’arrivée début d’exécution– temps d’arrivée
P1 10 9 7 3 0.0
P1 = (0 - 0)+(2 - 1)+(9 - 4) = 6
P2 1 1 1.0 P2 = 1 – 1 = 0
P3 2 4 2.0 P3 = 16 – 2 = 14
P4 1 5 3.0 P4 = 18 – 3 = 15
P5 5 2 4.0
P5 = 4 – 4 = 0

Le diagramme de Gantt avec un ordonnancement avec priorité préemptif est comme suit :

P1 P2 P1 P5 P1 P3 P4
0 1 2 4 9 16 18 19

Temps d’attente moyen= (6 + 0 + 14 + 15 + 0) / 5 = 35 / 5 = 7

61
Tableau récapitulatif

FCFS SJF PSJF Tourniquet

tatavg 28.25 23.50 18.75 24.50
wtavg 16.50 10.50 6.25 12.25
rtavg 4.50 3.00 1.25 2.25
Facile à Impossible de Impossible de Implémentable,
implémenter connaitre le connaitre le rtmax est
prochain temps prochain important pour
de travail du temps de les systèmes
CPU travail du CPU interactifs
exacement. exacement.

62
 Chapitre 2
Communication Interprocessus
Les processus
Différence entre programme et processus
Image
 Image
•La mémoire d’un programme est divisée en les parties suivantes :
- Segment de données (données + BSS + tas binaire (heap en
anglais)) ;
- Pile d'exécution, souvent abrégée en la pile (stack en anglais) ;
- Segment de code.
Le segment de données contient les variables globales et statiques
utilisées par le programme et qui sont initialisées.
Le segment BSS aussi connu comme zone de données non initialisées commence
à la fin du segment de données et contient toutes les variables globales et toutes
les variables statiques qui sont initialisées à zéro ou n’ont pas d’initialisation
explicite dans le code source. Par exemple, une variable déclarée static int i; sera
« contenue » dans le segment BSS. le segment bss se résume alors aux variables
locales de la fonction main().
tas : allocation dynamique (malloc, calloc, realloc)
Processus en mémoire
Processus en mémoire
Les processus
Propriétaire d’un processus
Etats d’un processus
Création de processus
Création de processus
Clonage
 Création de processus

• Un signal pendant est un signal qui a été envoyé un processus mais qui n'a pas encore été
pris en compte
• En informatique, la réentrance est la propriété pour une fonction d'être
utilisable simultanément par plusieurs tâches utilisatrices. La réentrance permet d'éviter la
duplication en mémoire vive d'un programme utilisé simultanément par plusieurs
utilisateurs.
Création de processus Déroulement de
l’exécution
Création de processus
Arborescence
Création de processus
Différence fils-pére
Indéterminisme du déroulement
 Terminaison de processus
● Un processus se termine par une demande d’arrêt volontaire (exit) ou par un
arrêt forcé provoqué par un autre processus (appel système kill) ou une erreur.
void exit(int vstatus);
• Lorsqu’un processus fils se termine :
– son état de terminaison est enregistré dans son PCB,

– la plupart des autres ressources allouées au processus sont libérées,

– le processus passe à l’état zombie (<defunct>).
• Son PCB et son PID sont conservés jusqu’à ce que son processus père ait
récupéré cet état de terminaison. Il est alors détruit.
• Les appels système wait(&status) et waitpid(pid, &status, option) permettent au
processus père de récupérer, dans status, cet état de terminaison.
Synchronisation
Appels système wait et exit
Appels système wait et exit
Création de processus et
synchronisation
Recouvrement d’un processus
Recouvrement d’un processus
Recouvrement d’un processus
Recouvrement d’un processus :
remplacement du code
Création puis Recouvrement et
synchronisation
Conclusion
Communication interprocessus

Partie 2
Les entrées-sorties
Descripteurs
Descripteurs
Les tubes anonymes
Les tubes anonymes
Les tubes anonymes
Les tubes anonymes
Les tubes anonymes
Les tubes anonymes
Les tubes anonymes
Les tubes anonymes
 Exemple 1
#include <stdio.h>
$ ./tube_exo1
#include <unistd.h>
$ bonjour bien reçu
int tube[2];
$
char buf[20];
main() {
pipe(tube);
if (fork()==0) { /* fils */
close(tube[0]);
write(tube[1], "bonjour", 8);
}
else { /* pere */
wait(NULL);
close(tube[1]);
read(tube[0], buf, 8);
printf("%s bien reçu\n", buf);
}
}
 Exemple 2
#include<sys/types.h>
#include<sys/wait.h>
#include<unistd.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define R 0
#define W 1
int main()
{
int pid;
int fd[2];
char message[100];
int Nboctects;
char* phrase="VOICI MON MESSAGE POUR TOI PERE";
system("clear");
 Exemple 2
printf("_____________________________________________\n");
printf("\t\tProcessus Courant:: %d\n",(int)getpid());
printf("_____________________________________________\n");
if (pipe(fd) == -1)
{
perror ("Creation du pipe a échoué ");
exit(1);
}
pid=fork();
if(!pid)
{
close(fd[R]);//fermeture du fichier de lecture par le fils
printf("\t\t\t\t\t\t+++++++++++++++++++++++++++++++++++++++\e[m\n");
printf("\t\t\t\t\t\t\t Processus FILS:: %d\n",(int)getpid());
printf("\t\t\t\t\t\t+++++++++++++++++++++++++++++++++++++++\n");
printf("\t\t\t\t\t\t FILS::PERE JE T'ENVOIE UN MESSAGE\n");
 Exemple 2
if (write(fd[W],phrase,strlen(phrase)+1)== -1)
{
perror("write : Ecriture dans le pipe à échoué ");
exit(4);
}
close(fd[W]);//fermeture du fichier d'écriture par le fils
//sleep(2);
exit(3);
}
printf("J'attends la terminaison du fils");
wait(NULL);
close(fd[W]);//fermeture du descripteur d’écriture par le père
 Exemple 2

if (( Nboctects = read (fd[0],message, 100)) == -1)

{
perror ("read : Lecture échoué ");
exit(5);
}
message[Nboctects]='\0';
Printf ("MESSAGE RECU :: nboctets = %d Message= %s,Nboctects,message );
close(fd[R]);//fermeture du descripteur de lecture par le père
return 0;
}
 Exemple 3
#include<sys/types.h>
#include<sys/wait.h>
if(pipe(tube)==-1)
#include<unistd.h>
{
#include<stdio.h>
perror("Création pipe : ");
#include<string.h>
exit(EXIT_FAILURE);
#include<stdlib.h>
}
#include<assert.h>
system("clear");
#define R 0
printf("_______________________________\n");
#define W 1
printf("\t\tProcessus Courant:: %d\n",(int)getpid());
int main(int argc,char* argv[])
printf("_______________________________\n");
{
int tube[2];
int pid;
char buf;
assert(argc==2);
 Exemple 3
pid=fork();
if(pid==-1)
{
perror("Fork echec"); //PERE
exit(EXIT_FAILURE); close(tube[R]);
} write(tube[W],argv[1],strlen(argv[1])+1);
if(!pid)//FILS close(tube[W]);
{ printf("J'attends la terminaison du fil\n");
close(tube[W]); wait(NULL);
while(read(tube[R],&buf,1) > 0) printf("BYE \n");
{ return 0;
sleep(1); }
write(STDOUT_FILENO,&buf,1);
}
write(STDOUT_FILENO,"\n",1);
close(tube[R]);
exit(EXIT_SUCCESS);
}
 Les tubes anonymes :
Redirection de stdin et stdout
 Exemple 4

int main(int argc,char* argv[])

#include<sys/types.h>
{int pid;
#include<sys/wait.h>
int fd[2];
#include<unistd.h>
assert(argc==3);
#include<stdio.h>
system("clear");
#include<assert.h>
pipe(fd);
#include<string.h>
pid=fork();
#include<stdlib.h>
if(!pid) {
#define R 0
close(fd[W]);
#define W 1
dup2(fd[R],0);
close(fd[R]);
execlp(argv[2],argv[2],NULL);
}
else
{
close(fd[R]);
dup2(fd[W],1);
close(fd[W]);
if(execlp(argv[1],argv[1],NULL)==-1)
perror("execlp");
}
return 0;
}
 Exercice

Écrire un programme C qui réalise la commande ls -al | wc -l en

créant deux processus qui communiquent à travers un tube.
Le fils écrit dans le tube en ayant au préalable redirigé sa sortie
standard à travers un tube ; quant au père il lit dans le tube en ayant
au préalable redirigé son entrée standard vers le tube.
Pour la redirection de la sortie et de l'entrée standard, utiliser la
fonction dup.
Utiliser la primitive de recouvrement execlp pour faire exécuter au
fils et au père les commandes ls et wc.
 Exercice
Donner l’organisation d’une application de transmission
bidirectionnelle d’informations entre un processus père et un de
ses fils via des tubes : le père envoie 5 entiers au fils qui les affiche
et renvoie ces entiers multipliés par 2. Le père affiche ces doubles.
Écrire le programme C correspondant.
Dans ce problème, on crée deux tubes p1 et p2 pour faire
communiquer les deux processus :
– le père a accès en écriture sur p1 et en lecture sur p2,
– le fils a accès en écriture sur p2 et en lecture sur p1.