Systemexpolt 23decok PDF

1.
CONSIDERATIONS PRELIMINAIRES
1.1 DEFINITION
Un système d‟exploitation est un ensemble de programmes qui joue le rôle de l‟interface entre
utilisateur et ordinateur et Il s‟occupe de la gestion rationnelle de ressources tant hardware
que software de l‟ordinateur.
1.2 STRUCTURE INTERNE D’UN ORDINATEUR
1.2.1. Introduction
Un ordinateur est une machine capable de résoudre un problème en suivant les instructions
d‟un programme. Nous allons décrire un modèle assez représentatif des ordinateurs utilises
actuellement et nous appuyer d‟un système a microprocesseur pour faire un survol sur ce
fonctionnement de l‟ordinateur
1.2.2.Histoire de l’ordinateur et du système d’exploitation
L‟histoire de l‟ordinateur est fortement liée a l‟évolution technologique et celle du système du

système d‟exploitation est liée a celle de l‟ordinateur. C‟est ainsi que nous pouvons relever les
époques suivantes :
-Machine a calculer a engrenages mécaniques ;

-Machine a tube a vide
-Machine a circuits intègres.
-Machine a circuits intègres a échelle très large.
 Machine a calculer a engrenages mécanique a été inventée par Blaise Pascal (1623-
1662) et pouvait réaliser des opérations arithmétiques (addition, multiplication,
soustraction et était une machine mécanique a base „engrenage.
 Machine a tube a vides
Pendant la seconde guerre mondiale, fut construit un ordinateur (COLOSSUS) a tube a vide
par le mathématicien Anglais ALAIN TURING. Cet ordinateur a pu décoder des messages
cryptés envoyés par amiraute allemande, par onde radio, au sous marin allemands.
En 1943 MANCHEY aidé par un de ses étudiants en thèse a conçu et construit un ordinateur
a tube (ENIAC (Electronic numerical integration and computeur)) a vide ayant les
caractéristiques :
-18000 tubes
-1500 relais
-10 registres
-10 chiffres décimaux
-pesait 30tonnes et consommait 140 kW
On la programmait en langage machine, en manipulant quelques 6000 commutateurs
interconnectés par un foret de câble.
Un des participant VON NEUMAN génie au même titre que Léonard de Vinci :
Parlait plusieurs langues couramment
Expert en sciences physiques et mathématiques
Pouvait se souvenir de tous ce qu‟il a vu et entendu
@ kasengedia motumbe pierre 1

A émis l‟idée de base (modèle) VON NEUMAN, modèle qui e a la base de la plupart
d‟ordinateur standards actuels. Sur la Fig1 ci dessous présente le modèle VON NEUMAN.
 Machine a circuits integres
 Machine a circuits très integres
MODELE VON NEUMAN
E S
N O
T R
R MEMOIRE T
E I
E E
Unité ALU
de
comma ACC
nde U
Fig1. Modèle VON NEUMAN
Unité de commande + ALU + registres = processeur

Processeur intégré
1.2.3. Système a microprocesseur
Un système a microprocesseur peut être aussi développe comme un ordinateur qu‟on peut
facilement transporte, dédicacer a :
- contrôler les paramètres fonctionnels d‟une voiture
- Un pilote automatique (ordinateur embarqué) d‟un avion
- Un central téléphonique
1.2.3.1. Microprocesseurs
Un microprocesseur est une unité centrale de traitement (CPU), il est le moteur du traitement
de l‟information dans un microordinateur, système a microprocesseur.
Relier directement ou indirectement à tous les composants du système ou PC
CPU : central processing unit est l‟élément moteur de l‟ordinateur qu‟il interprète et exécute
les instructions du programme
CPU = CU + ALU + Registres
CU : command unit
ALU : Arithmétic Logic unit
On relie le microprocesseur aux différents équipements d‟entrée-sortie (Keyboard, écran,

disque dur, imprimante) moyennant des contrôleurs (entrée/sortie) sur la Fig.2 est illustre.

Unité de commande
CU : commande unit
(ALU)
Unité arthritique et
logique
REGISTRE
DISQUE IMPRIMA
CO RI NTE
Mémoire
principale
AC
…. Contrôleur Contrôleur
HDD imprimante
Fig.2. Principe d‟interconnexion d‟un microprocesseur aux différents équipements

d‟entrée/sortie.
Structure interne d‟un microprocesseur hypothétique
RA MEMOIRE RM
AC
CO RI
Décodeur
2
3
Horloge Séquenceur
Mémoires, entrées/entrées
Fig.3. Structure interne d‟un microprocesseur hypothétique

RI (IR) : REISTRE D‟INSTRUCTION (IR :Instruction Registre)
AC : Accumulateur
CO: computer ordinal (PC : Programm counter)
UAL, ALU: Unité arithmétique Logique (ALU : Arihmetic Logic Unit)
Le microprocesseur exécute trois opérations de base pour traiter l‟information.
Fetch
Décode
Exécution
L‟unité de commande peut être un séquenceur : câblé ou microprogrammée. Il importe que
vous sachiez qu‟il existe toujours une équivalence entre la logique câblée et celle
microprogrammée
A+B
A (A+B) .C
+ C = ( A + B ) + C =( A . B ) + C
B
(a)
Fig.4. Equivalence entre la logique câble et celle microprogrammée

A B C M
0 0 0 1
0 0 1 1
0 1 0 1
0 1 1 0
1 0 0 1
1 0 1 0
1 1 0 1
1 1 1 0
Adresse (b)
A B C M
Pour réaliser le tableau de microprogrammation du circuit logique Fig.4.(a), On assembles les

valeurs d‟entrée ABC, et le résultat M dans un tableau Fig.4(b). Si on veut obtenir le résultat
de la logique câblée en microprogrammation, il suffit d‟accéder a la mémoire d‟adresse ayant
comme entrée le valeurs ABC sur contenu (M) aura le résultat de la fonction logique. On
stocke la valeur de l‟opération logique. Microprogrammation (firmeware)
Le principe de la microprogrammation a été introduit pour la première fois par Maurice
Wilkes. Il a appelé ce principe : « La mémoire de commande ».

B A Step 2(C C+D)
D2
Step 4
D4
C C+E
(Step 3)
D3
Fig.5. Equivalence entre la logique câblee

et celle de la programmation.
D1
Step 0
Step 1
0. LOAD B ( A B)
1. Test (A0, A) / ( 2, 3 )
2. C C+D
GOTO 4
3. C C+E
4. STOP
1. 2. 3.2. Les opérations d’entrée /sorties
Opérations permettant au processeur central de communiquer avec l‟extérieur, avec les

périphériques. Parmi les opérations d‟entrée/sortie les plus connues, nous pouvons citer :
a) polling
- Interrogative par méthode (polling ;

- Par interruption
- Par DMA (direct memory Access)
- Canaux d‟ entrées /sorties.
Méthode interrogative Polling (Fig.6)
Le polling est une méthode par laquelle le master (microprocesseur) interroge

périodiquement le slave (périphérique), un a un, pour demander a chacun, s‟il veut

effectuer une opération d‟entrée/sortie. Dans l‟affirmation il effectue l‟opération
d‟entrée/sortie dans le cas contraire, il passe au prochain périphérique.
P1
(master)
CPU P2
Polling slave
P3
P4
Fig.6. Méthode interrogative (polling)
Methode par interruption (Fig.7)
Le polling a un inconvénient majeur dans le sens qu‟il mobilise beaucoup de temps du

CPU, qui passe son temps a interroger les périphériques. C‟est pourquoi, on introduit la
méthode par interruption par laquelle lorsque le périphérique veut effectuer une opération
d‟entrée/sortie, il envoie un signal d‟interruption au microprocesseur. En vue de gérer les
interruptions provenant de plusieurs périphériques, on a introduit le PIC (programmable
interrupt controller)
P1
IREQ1
INT
CPU
INTA PIC IREQ2
P2
IREQ n
P3
data
adress
Fig.7. Opération entrée/sortie moyennant un PIC (programmable interrupt controller)

DMA (Direct memory access)
Pour bien réaliser les opérations entrée /sortie avec un périphérique rapide,
On utilise le transfert direct entre le périphérique et la mémoire sous contrôle DMA
En vue d‟effectuer les opérations d‟entrée/sortie, par DMA, les paramètres suivants sont
utilises.
- adresse bloc de données du départ ;
- adresse bloc arrivé ;
- nombre mots à transférer.
Sur la Fig.8. est illustre un système a microprocesseur utilisant le DMA
BUSREQ BUSG P1 P2 Pj
MEMOIRE DMA
DATA
Logique
MICRO- décodage
PROCESSEUR
ADDRESS
Control
Fig.8. Système a microprocesseur utilisant opération entrée/sortie
BUSREQ bus contrôle

BUSGR
b) Canaux d’entrée/sortie (Fig.9)

- gros ordinateurs (MAINFRAME)
- interruption et DMA traditionnel inefficaces
- canaux de données ou canaux d‟entré / sortie
-canaux spécialisés : commandent les périphériques à haute vitesse de transfert

Certains gros ordinateurs ont un volume important d‟opération d‟entrée/sortie, a telle
enseigne qu‟ils sont obliges d‟utiliser de véritables processeur spécialises pour les
opérations d‟entrée/sortie.
-canaux multiplexés : peut gérer plusieurs échange avec des périphériques à faible
vitesse de transfert (ex : terminaux)
MEMOIRE
PRINCIPALE
PROCESSEUR
Canal E/S Canal E/S

multiplexe Spécialisé
Contrôleur des
terminaux imprimante disque disque disque
Fig.9. Canaux d‟entrées /sorties, processeur spécialises pour les entrées/sorties.

1.3. ORGANISATION EN COUCHES ET SYSTEMES D’EXPLOITATION
Exemple d‟organisation en couches le modèle OSI :

-stratégie, approche oignons
-décomposition d‟un problème en modules (qu‟on peut mieux maîtriser)
-gestion de la complexité
L‟ordinateur peut être perçu comme un système organise en couche, de la même manière
que celle du modèle OSI. Cette organisation s‟inspire de l‟approche oignons, qui
consiste a décomposer un problème complexe en module moins complexe, qu‟on peu
mieux maîtriser. Ainsi l‟ordinateur (ses modules hardware et software) peut être perçu
comme une superposition de machines virtuelles.
Machine virtuelle. Mn Programme en langage Ln traduits

Niveau n
Langaga machine Ln plus interprètes dans un langage de
bas niveau par un interpréteur
machine bas niveau
.
.
.
Niveau 4 Machine virtuelle. M4
Langaga machine L4
Programme L3traduit et interprété

Machine virtuelle. M3 en LL ou L1 par un interpréteur
Niveau 3 Langaga machine L3 tournant sous M2 ou M1
Machine virtuelle. M2 Programme L2 traduits et

Niveau 2 Langaga machine L2 interprété par un interpréteur
tournant sur M1
Machine réelle M1 Les programmes en L1sont

Langage machine L1 exécutés directement par
Niveau 1 l‟électronique (figure)
Fig.10.(a) ; Organisation en couche d‟un ordinateur
Sur les Fig.10.(a). et Fig.10.(b) est illustrée l‟organisation en couches d‟un ordinateur.

PASCAL, C, LIPS, SHEME
Couche de COBOL
Niveau 6 langage d‟application
Traduction(compilateur)
Couche de
langage d‟assemblage
Niveau 5
Traduction(assembleur)
Couche système
. d‟exploitation
.
Niveau 4 interprétations SE
Couche traductionnelle
Niveau 3
Interprétations (microprogramme)
Couche microprogrammée
Niveau 2
Couche physique
Niveau 1 Circuit electronique
(poste logique)
Fig.10.(b). Organisation en couches d‟un ordinateur
1.4. FONCTIONS DE BASE D’UN SYSTEME D’EXPLOITATION
les fonctions de base d‟un système d‟exploitation sont, la gestion :
Gestion de :
- de processus (de processeur)
- des entrées / sorties
- de la mémoire
- du système de fichiers
I. 4. 1 Définition formelle
Un système d‟exploitation est un ensemble de programmes qui constitue une machine

virtuelle épargnant l‟utilisateur, de gérer la complexité de la programmation du bas niveau.
Il joue aussi le rôle d‟interface entre utilisateur et l‟ordinateur et assure la gestion rationnelle
tant de ressources hardware que software de l‟utilisateur.
1.4.2. Types de système d’exploitation
Les systèmes d‟exploitation peuvent se différencier fondamentalement selon :

- le hardware sur lesquels, ils sont battit ;

- l‟environnement d‟utilisation.
Ainsi en nous basant sur l‟environnement d‟utilisation et la structure interne il y a lien de les
classifier de la manière suivante :
- système d‟exploitation temps réels
- système d‟exploitation traitements par lots (batch processing)
- système d‟exploitation monolithiques
- système d‟exploitation modèle client – serveur
- système d‟exploitation multiprogrammation
- système d‟exploitation time sharing (temps reparti)
- système d‟exploitation (multipurpose) à plusieurs objectifs
1.4.2. 1. Systèmes d’exploitation temps réels
Généralement utilisée dans la commande de processus industriels (robot industriel)

Un système automatisé peut se décomposer en 2 parties qui coopèrent
- la partie opératrice appelée également processus
- la partie commande ou automatisme.
La communication avec l‟opérateur fait partie intégrante de cette structure.
Le temps réel est lié à la notion de pilotage d‟un système soumis à des contraintes de temps.
L‟environnement temps réel est aussi caractérisé par l‟activité liée à des environnements
externes.
PARTIE COMMANDE
PARTIE CONTROLE
TACHE 1 TACHE 2 . .
TACHE ………
3 TACHE n
Feedback
Compltes
Rendus Actions
PROCESSUS
Fig.11 .Décomposition structure simplifiée par exemple un robot industriel. Un robot

Industriel est un système mécanique, ayant un certain nombre de grade de liberté.
Processus : dans le cas d‟espèce ne doit pas être considère comme un programme exécute
dans l‟ordinateur. Ici, il a plutôt le sens du processus industriel

Figure 13
Fig.12.
Un robot avec minimum 3 grades de libertés

- une tache peut être affectée à la gestion d‟un grade de liberté
- une tache à la gestion de l‟apprehendeur
Modèle des taches dans un système multitâches monoprocesseurs
Carte contrôleur robot
calculeur
Amplificateur
puissance
Robot
Fig.13. Un robot industriel contrôle par un calculateur.
Une tache est un programme ou une parie de programme en exécution conceptuellement,

chaque tache possède un processeur virtuel comprenant :

- son pointeur d‟instruction (IP) ;
- sa zone de donnée ;
- son pointeur de pile (SP)
Sur le Fig.12, Fig.13. sont pressentes un robot industriel a 3 grades de libertés, respectivement
un robot industriel contrôle par un calculateur.
En réalité le processeur physique commute des taches sous le contrôle d‟un module particulier
au système d‟exploitation, appelé Ordonnanceur.
TACHE A TACHE B TACHE C

IPA CODE IPC
IPB CODE CODE
DONNEES DONNEES DONNEES
SPA SPB SPC
A
Figure.14.(a) Modèle d‟un système d‟exploitation comportant les taches A,B,C
TACHE A TACHE B TACHE C
CODE CODE CODE
IP à instant t IP à t +δt IP à t +2δt
DONNEES DONNEES DONNEES
SPA PILE SPB PILE SPC PILE
Fig.15.(b). Modèle réel d‟un système comportant trois tâches A, B, C
Sur les Fig.14(a) et Fig.14.(b) sont présentes :

- un modèle conceptuel d‟un système d‟exploitation gérant les taches ABC
- un modèle réel gérant les taches ABC
Figure 16
Tache C
Tache B
Tache A
t t + δt t +2δt t +3δt temps
Fig.15. Gestion quasi parallèle d‟un système a3 taches, dans un monoprocesseur.
Mesure de température dans une usine d’industrie chimique
Monitoring
imprimante
Niveau supervision ORDINATEUR

CENTRAL
Niveau operationnel
MICRO- MICRO- MICRO-

PROCESSE PROCESSE PROCESSE
UR UR UR
Sensers (sonde) Sensers

Sensers
Système distribué hiérarchisé temps réel
Fig.16. Pour la mesure de température dans une usine d‟industrie chimique, on peut
utiliser un système multi-calculateur / microprocesseur à deux niveaux :
- niveau de supervision
- niveau opérationnel
Ce genre de contrôle implique un polling périodique de sous système microprocesseur par le
niveau de supervision, qui se comporte un peu comme le maître (master).

Si un événement exceptionnel apparaît le « slave » (esclave) peut en informer au maître.
Dans cette architecture master – slave le slave a aussi une certaine capacité de traitement de
contrôle, de stockage.
Ce genre de systèmes multiprocesseur peut être utilisé dans :

- le monitoring de lignes de production
- le contrôle de processus continus (pipe –line) ;
- le monitoring et contrôle du système de « feu rouge « dans une ville ;
- monitoring de l‟état des avions militaires
1.4.2. 2. Traitement par lot
Ce genre de système est apparu vers la fin des années 50 et le début des années 60. Pour
lancer un travail (job), un programme ou ensemble de programmes) le programmeur devrait
commencer à écrire le programme (en FORTRAN ou assembleur) puis devrait le mettre sur
des cartes perforées. Il amenait ses cartes à la salle de soumissions des travaux et les donnait
à l‟un des opérateurs. Lorsque l‟ordinateur terminait un travail, un opérateur retirait les
résultats de l‟imprimante et les portait à la salle de retrait des travaux pour que le
programmeur puisse venir les prendre.
L‟idée directrice du traitement par lots était de collecter un ensemble des travaux codifiés
dans des cartes perforées, les soumettre au lecteur de cartes, avant qu‟ils puissent être
transférés dans les bandes magnétiques, en utilisant par exemples un petit ordinateur peu
onéreux (IBM 1401), qui était excellent pour lire les cartes, copier les bandes et imprimer les
résultats mais très mauvais pour les calculs numériques.
D‟autres machines, bien, plus chères, comme IBM 7094, étaient utilisées pour les calculs.
Sur la Fig.17.suivante est illustré un de premiers systèmes du traitement par lot.
Les opérations puissent être résumées de la manière suivante :
- les programmeurs portent les cartes IBM 1401, qui transcrit les travaux ;
- l‟opérateur porte la bande de données à l‟IBM 7094, qui va effectuer les calculs ;
- l‟opérateur fournit la bande des résultats à l‟IBM 1401, qui va s‟occuper de
l‟impression
Dérouleur bande bande bande

Lecteur bande entrée système sortie
Carte . . . . .
Imprima
. . . . . nte
IBM 1401 IBM 7094 IBM 1401
Fig.17. : un des premiers systèmes de traitement par lot

1.4.2. 3. Système monolithique
Il s‟agit d‟une organisation assez répandue .Cette approche pourrait être surnommée « le
grand désordre ». La situation est qu‟il n‟ y a pas de structure.
Le système d‟exploitation est une collection de procédure, chacune pouvant appeler à
n‟importe quel moment n‟importe quelle autre .Chaque procédure du système doit de ce fait,
avoir une interface bien définie au niveau de ses paramètres et des résultats qu‟elle retourne et
peut appeler toute autre procédure qui lui est utile.
Pour construire le code objet du système d‟exploitation, il faut compiler toutes les procédures,
ou les fichiers qui les contiennent puis, les réunir au moyen d‟un éditeur de liens.
Même dans les systèmes monolithiques, il est possible d‟avoir une structure minimale .Les
services offerts par le système d‟exploitation sont adressés en mettant des paramètres dans des
endroits biens définis, (registres, piles,…) et en exécutant ensuite une instruction spéciale
nommée « appel au noyau, appel au superviseur. Cette instruction commute le mode
utilisateur au mode noyau (superviseur).
En nous appuyant sur la Fig.18 ci –dessous nous pouvons expliquer le fonctionnement :
- un programme utilisateur s‟exécute en mode utilisateur ;

- lorsqu‟on lance une commande du système d‟exploitation on passe du mode
utilisateur au mode superviseur (étape 1)
- le système d‟exploitation examine les paramètres de l‟appel 2 pour déterminer
l‟appel système à exécuter.
- le système cherche dans une table indexée la position k qui contient un pointeur sur
l‟appel système k
- cette opération 3 identifie le service qui est ensuite appelé (exécuté)
- l‟appel système se termine et le contrôle est rendu au programme appelant.
Programmeur utilisateur Programme utilisateur

s‟exécute en mode
Programme utilisateur. Appel au noyau utilisateur
4 Procédure
Service S.E
1 S‟exécute en mode
noyau
2 3
Fig.18. Système d‟exploitation monolithique
I. 5. 3 Systèmes en multi programmation
On dit d‟une machine qu‟elle est multiprogrammée si plusieurs programmes sont chargés en
même temps , en mémoire dans le but de partager le CPU . La multiprogrammation est donc
une technique qui vise l‟élimination du temps d‟attente du CPU pendant les opérations

d‟entrée sortie. La différence entre les systèmes mono et multiprogramme réside dans le
nombre de programmes chargés en mémoire et prêts à utiliser le CPU.
La Fig.19.Ci-dessous schématise la multiprogrammation.
Ordinateur
n programmes à la fois
E/S
Programme sur carte lecteur cartes imprimante
Fig.19. Système multiprogramme
La multiprogrammation pose un certain nombre de problèmes, notamment :

- Comment partager l‟unité de traitement (CPU) entre plusieurs programmes et
sauvegarder le contexte.
- Comment gérer la mémoire centrale (MC) en permettant le chargement d‟un nombre
élevé de programmes dans un espace mémoire limité.
- Comment gérer les entrées-sorties de différents programmes, en assurant un trafic
ordonné de données entre la mémoire centrale et les unités périphériques et en
empêchant le système de mélanger les informations appartenant aux différents
programmes.
- Comment protéger les programmes et les données stockées dans la mémoire centrale
et sur disque, des erreurs éventuelles de programmes utilisateurs système de la
machine.
1.4.2. 4. Systèmes temps partagés (time sharing systems)
Le „time sharing‟ se réfère au système dont la préoccupation majeure est de distribuer la

puissance de calcul (traitement) à un ensemble d‟utilisateurs connectés à l‟ordinateur, à
partir d‟un terminal, de façon à ce que chaque utilisateur ait l‟illusion d‟un ordinateur qui
lui est totalement dédicacé. Le système „time sharing‟ à temps partagé dit aussi multi
accès, multi utilisateurs est une variante de système multiprogrammés ou le temps CPU
est distribué par petite tranches égales à un grand nombre d‟utilisateur par l‟intermédiaire
de leur terminal. Sur les Fig.20, Fig.21, sont représentes les principes d‟un système
multiutilisateur (temps partage), respectivement la répartition du temps CPU entre les

utilisateur dans un système. Il y a lieu de constater que le parallélisme du traitement de
l‟information n‟est en réalité qu‟un pseudo parallélisme.
Ordinateur
n programmes à la fois
E/S
Iimprimante
Fig.20. Principe d‟un système multiutilisateur (temps partage)
1.4.2. 5. Système multi utilisateurs ‘time – sharing’
Dans la figure ci dessous est décrite la répartition du temps CPU entre utilisateur dans un
système multi utilisateur (time sharing)
USERS
USER4
USER3
USER2
USER1
0 t1 t2 t3 t4 t5 t6 t7 t8
Fig.21. Répartition du temps CPU entre utilisateur dans un système multi utilisateur (temps
parage).

1.4.2. 6. Le modèle client-serveur
Dans certains systèmes, on a eu l‟idée de déplacer une grande partie du code du système
d‟exploitation dans une couche plus élevée. Ainsi selon cette idée, la tendance des systèmes
d‟exploitation modernes tente de réduire le système d‟exploitation à un noyau minimal. Donc,
on a reporté la plupart des fonctions du système d‟exploitation dans un processus utilisateur.
Pour demander un service comme la lecture d‟un bloc d‟un fichier, un processus utilisateur
(aussi appelé client) envoie une requête à un processus serveur qui effectue le travail et lui
envoie la réponse sur la Fig.22.
Dans le modèle illustré sur la Fig.22 le noyau ne gère que la communication entre les
processus clients et serveurs.
Processus Processus serveur Mode

Client client des serveur serveur utilisateur
Processus ……. des imprimant
fichiers
mode
NOYAU noyau
Le mode noyau requiert un service

en envoyant un message
au processus serveur
Fig.22. Modèle client serveur dans un système non distribué
La décomposition du système d‟exploitation en petites parties qui ont chacune une fonction
particulière, telle que la gestion des fichiers, processus, des terminaux, ou de la mémoire, rend
ces parties plus faciles à modifier. De plus, les serveurs s‟exécutent comme des processus en
mode utilisateur, et non en mode noyau, ne peuvent pas accéder directement au matériel. Une
conséquence notable est q‟un bogue dans le serveur de fichiers par exemple, n‟affectera pas
en général l‟ensemble de la machine. Le modèle client-serveur se prête par ailleurs très bien
à une utilisation dans les systèmes distribués tel qu‟on peut le constater sur la Fig.23.
Un client qui envoie des messages à un serveur, n‟a pas besoin de savoir si il est traité sur sa
propre machine ou s‟il est transmis au serveur d‟une machine au travers d‟un réseau. Du point
de vue de client la même chose se produit dans les deux cas : il va envoyer et puis, il va
reçevoir une réponse.

Client Serveur de Serveur des Serveur des
fichier processus terminaux
Noyau Noyau Noyau Noyau
Fig.23. Modèle client serveur dans un système distribué.
2. GESTION DE PROCESSUS
2.1. INTRODUCTION AUX PROCESSUS ET ORDONNANCEMENT DES TACHES
2.1.1. Le concept de processus
Le concept de processus est un des plus importants dans le système d‟exploitation.
Il est l‟abstraction d‟un programme en cours d‟exécution. Un programme étant une suite
d‟instructions contenue dans un fichier. Tous les ordinateurs peuvent effectuer plusieurs
taches à la fois. Un ordinateur peut, pendant qu‟il exécute le programme d‟un utilisateur, lire
les données d‟un disque ou afficher les résultats sur écran ou une imprimante. Dans un
système multiprogrammé, le processus peut aussi commuté d‟un programme à un autre en
exécutant chaque programme pendant quelques dizaines ou centaines de millisecondes. Mais,
le processeur, à un instant donné, n‟exécute réellement qu‟un seul programme. Pendant une
seconde, le processeur peut exécuter plusieurs programmes et donne ainsi aux utilisateurs une
impression de parallélisme. Certains qualifient de pseudo parallélisme une commutation
instantanée du processeur d‟un processus à un autre,la différencier du vrai parallélisme qui se
produit au niveau du matériel lorsque le processeur travaille en même temps que certains
périphériques d‟entrée/sorties.
2.1.2. Hiérarchie de processus
Les systèmes d‟exploitations qui font appel au concept de processus doivent permettre de
créer le processus requis. Dans la plupart des systèmes il faut pouvoir créer et détruire
dynamiquement les processus. Les processus dans MINIX, sont crées par l‟appel système
FORK( ) qui crée une copie conforme du processus appelant. Le processus fils peut aussi
effectuer un FORK( ), ce qui conduit rapidement à une arborescence de processus. D‟autres
systèmes d‟exploitation ont des appels système pour créer un processus, changer son état
concept et lancer son exécution. Quelle que soit la nature de l‟appel système, les processus
doivent pouvoir créer d‟autres processus. Notez qu‟un processus n‟a qu‟un père et peut avoir
plusieurs fils.

2.1.3. Etats de processus
Les processus bien qu‟étant des entités indépendantes, doivent parfois interagir avec d‟autres
processus. Les résultats d‟un processus peuvent, par exemple,être les données d‟un autre,
comme ous pouvos le constater dans la commande shell.
Cat fichier1 fichier2 fichier3 /grep etudiant
Le processus qui exécute cat, concatène les trois fichiers (fichier1, fichier2, fichier3) et envoie
le résultat sur la sortie standard. Le deuxième processus qui exécute grep, recherche lignes qui
contiennent le mot étudiant.
Si grep est prêt à s‟exécuter et ne peut pas lire faute de données .Il doit se bloquer en
attendant les données, un processus peut être dans les états suivants :
- bloqué
- Elu
- Prêt
tel que nous pouvons aussi le constater sur la Fig.24. ci-dessous
ELU
1
2
3
BLOQUE
PRET
4 4
Fig.24. Etats d‟un processus
Etat bloqué : état d‟un processus qui a été exécuté (donc élu), mais ne peut pas poursuivre
son exécution suite à une raison logique, par exemple, lorsqu‟il attend des données qui ne sont
pas disponibles.
Etat Elu : un processus est élu, lorsqu‟il est en cours d‟exécution ,il peut être arrêté même s‟il
peut poursuivre son exécution ,si le système d‟exploitation décide d‟allouer le processeur à un
autre processus.
Etat prêt : il s‟agit de l‟état d‟un processus qui a été suspendu provisoirement par le système
d‟exécution afin de permettre l‟exécution d‟un autre processus ou un processus qui attendait
les données et vient de les recevoir, mais constate que le processeur est toujours occupé par un
autre processus.
Quand et comment fonctionne les transitions 1, 2, 3, 4 de la Fig.24.
Transition 1 :
- processus exécuté (élu) qui manque une donnée pour continuer logiquement son
exécution.
Transition 4 :

- le processus attendait une donnée pour continuer son exécution et vient de la recevoir,
main constate que le processeur est toujours occupé.
Transition 2 :
- l‟ordonnanceur retire le processeur au processus et choisit un autre processus.
Transition 3 :
- l‟ordonnanceur choisit un processus en lui allouant le processeur.
Le modèle des processus permet de mieux comprendre ce qui se passe à l‟intérieur du

système. Une partie des processus exécute les programmes qui traitent les commandes tapées
par les utilisateurs, les autres processus du système gèrent les tâches telles que les requêtes au
gestionnaire de fichiers ou les opérations sur les disques ou les bandes magnétiques.
Le modèle des processus s‟appuie sur l‟ordonnanceur qui se charge de l‟ordonnancement de
l‟exécution de différents processus.
Sur la Fig.25. ci-dessous est présenté l‟ordonnanceur (scheduler) et les processus q‟il gère.
Processus
0 1 ………… N-2 N-1
ORDONANCEUR (scheduler)
Fig.25. L‟ordonnenceur et les processus qu‟il gère la couche la plus basse d‟un système
d‟exploitation structuré en processus se charge des interruptions et effectue
l‟ordonnancement.
2.1.4. Ordonnancement des processus
2.1.4. 1 . Introduction
L‟ordonnancement est le mécanisme par lequel un ordonnanceur, ou un noyau système

d‟exploitation, choisit le processus auquel on doit attribuer un processeur.
Parmi les techniques d‟ordonnancement les plus courantes, il y a lieu de citer :
- l‟ordonnancement circulaire (tourniquet, round-robin) ;
- l‟ordonnancement par priorité ;
- l‟ordonnancement par priorité avec files multiples.
- Autres techniques

2.1.4. 2. Critères de qualité d’un algorithme d’ordonnancement.
Plusieurs processus peuvent être en concurrence pour accéder au processeur. Potentiellement,

tous les processus sont candidats à l‟élection par le processeur. Le choix du processus à
exécuter est réalise par l‟ordonnancement. Ce choix appelé algorithme d‟ordonnancement est
fonction de la finalité du système.
Les critères d‟attribution du processeur sont très différents selon qu‟il s‟agit de gérer un
grand nombre de terminaux connectés à un ordinateur de temps partagé (time sharing) ou
qu‟il s‟agit de gérer un processus industriel en temps réel.
Un algorithme d‟ordonnancement, quelque soit le système auquel il s‟adresse doit avoir les
qualités suivantes :
- Efficacité ;
-Temps de réponse ;
-Impartialité ;
-Débit
-Temps de réponse aux interruptions
Efficacité : le processeur doit consacrer le maximum de temps à une application c‟est à dire
doit éviter du temps mort.
Temps de réponse : le temps de réponse doit être faible de façon à réagir rapidement à un
événement externe. En fonction de l‟application d‟autres critères peuvent être appliqués.
Impartialité : l‟Ordonnanceur doit effectuer un partage équitable du processeur. Chaque

processus reçoit son temps processus.
Débit : l‟Ordonnanceur doit effectuer le plus de tâches possibles dans un intervalle de temps
donné.
Temps de réponse aux interruptions : le temps de réponse aux interruptions est un critère
important pour les noyaux temps réel. Ce temps doit être spécifié, car il fixe le délai maximal
au bout duquel une tâche matérielle peut être lancée. Il dépend de la durée pendant laquelle
les interruptions sont masquées dans les sections critiques du noyau. Durant
l‟ordonnancement des processus et l‟exécution de la plupart des primitives, le système
d‟exploitation est masqué (partiellement ou totalement) retardant l‟instant ou une interruption
peut être prise en compte.
Les critères énoncés, ci-dessus, sont parfois contradictoires. Un débit élevé n‟est pas
conciliable avec une bonne efficacité. Si le processeur commute les processus à intervalle de
trop rapprochés le temps passé dans la gestion de l‟ordonnancement peut devenir
prépondérant par rapport au temps consacré aux processus.
2.1.4. 3. Stratégie d’ordonnancement sans recyclage des travaux
a. File d’attente simple (FIFO)
Le schéma de la Fig.32. ci-dessous montre la stratégie la plus simple d‟une file d‟attente
simple ou FIFO (first in first out) ou premier arrivé, premier servi. Cette stratégie ne tient
compte des temps d‟exécution. Elle est utilisée dans le système de traitement par lot.
Mais, il présente un inconvénient majeur, les travaux courts ont un temps de réponse élevé,
s‟ils arrivent après des travaux longs.

Entrée sortie
T5 T4 T3 T2 T1 PROCES
SEUR
Ti : tache i
Fig.32. ordonnancement file d‟attente simple (FIFO)
Pour pallier au désagrément que peut subir les petits travaux, lorsqu‟ils arrivent après de long
travaux, on a mis au point la méthode de file temps estimé d‟exécution .C‟est d‟ailleurs l‟objet
de la section suivante.
b. File d’attente ordonnée suivant le temps estimé d’exécution
Quand un nouveau processus arrive, il est placé dans la file à l‟endroit correspondant à son
temps estimé d‟exécution,la file est ordonnée suivant les temps d‟exécution croissants :
l‟estimation est faite a priori et aucune correction n‟est tentée en cours d‟exécution. Le temps
de réponse de travaux courts est ainsi diminué, mais le travaux longs sont retardés (voir même
retardés indéfiniment si le débit d‟arrivé des travaux courts est assez grand)
Sur la figure ci-dessous est présente un schéma décrivant cet algorithme
T5 T4 T3 T2 T1 PROCES
SEUR
Tache insérée selon le temps estimé d’exécution

3
Fig.33. File d‟attente ordonnée suivant le temps estimé d‟exécution
Conclusion :
Quand bien même cette méthode permet d‟abaisser le temps de réponse de travaux courts, elle
ne permet pas d‟apporter une solution fiable pour le temps réponse de travaux longs et
présente l‟inconvénients de se fier uniquement à un temps d‟exécution estimé, qui peut être
incorrect ou falsifié par des usagers de mauvaise foi.
Compte tenu de tout ce qui a été dit, nous allons faire appel à d‟autres méthodes notamment
celles qui appel au recyclage de travaux.

2.1.4. 4. Strategie d’ordonnacement avec recyclage des travaux
Ordonnancement circulaire (tourniquet, round-robin)
L‟algorithme de l‟ordonnancement le plus ancien, le plus simple et le plus fiable est

l‟ordonnancement circulaire, aussi appelé :
- balayage cyclique simple ;
- tourniquet ;
- round-robin.
Dans un noyau avec réquisition du processeur, chaque processus possède une quantité de
temps ou quantum, pendant lequel il est autorisé à occuper le processus. Lorsque son quantum
est écoulé, le processeur est réquisitionné et alloué au processus suivant de la file de processus
prêts.
Sur la Fig.26 ci-dessous est décrit une instance donnée. Le processus p5 est élu (en
exécution), c‟est à dire il utilise le processeur physique.
Les processeurs p2, p4, p3, p1 sont dans la file d‟attente de processus prêts, donc elligibles.
Si le processus élu p5 épuise son quantum du temps sur le CPU, il rejoint la queue de file de
processus prêts.
Le processus p6 est terminé ou bloqué (dans le cas ou il serait bloqué, il rejoindrait la file de
processus bloqués)
p6 p5 p2 p4 p3 p1 p7
CPU File processus prêts

Processus arrivée processus
terminé prêts
ou bloqué
Processus élu
Fig.26 : Gestion des processus par file circulaire
Choix du quantum :
Le choix du quantum est l‟affaire de compromis. Un quantum de courte durée augment le

nombre de processus commuté dans un laps de temps donné, mais diminue l‟efficacité du
noyau.
Pour un système avec réquisition du noyau, on définit l‟efficacité de l‟Ordonnanceur par le
rapport E :
E = (T-t)/T=1-t/T (1) avec T : durée du quantum
t : temps de commutation
En analysant l‟équation, pour que E soit le plus proche possible de 1, c‟est à dire une
efficacité 100%, on ne peut qu‟agir que T, étant donné que t fixé par la conception de
l‟Ordonnanceur et la vitesse du processeur.
Sur la Fig.27. est présentée l‟utilisation du processeur durant un quantum

Commutation Temps consacré à un processus Commutation
Fig.27. Utilisation du processus durant un quantum.
Supposons que t (commutation du processus, aussi appelé commutation du contexte) dure

5ms et que le quantum fixé à 25 ms. Le processeur travaille alors pendant 20ms sur des tâches
utiles, puis passe 5ms sur la commutation de processus, donc 20% du temps processeur sont
perdus pour la gestion du système (overhead). Pour améliorer l‟efficacité, on peut par
exemple fixer la valeur du quantum à 500ms. La perte en temps est alors égale à 1%, mais
cela risque de pénaliser l‟interactivité dans un système multi-utilisateurs.
En général, un quantum de 100ms est un compromis raisonnable. Les systèmes temps réels
utilisent des quantum de faible durée (généralement 5ms au moins). Ainsi, pour conserver une
bonne efficacité, le temps de commutation doit être court, ce qui nécessite d‟écrire
l‟Ordonnanceur en langage d‟assemblage.
Conclusion : un quantum trop petit provoque trop de commutation de processus et abaisse
l‟efficacité du processus, alors qu‟un quantum trop élevés augmente le temps de réponse des
courtes commandes en mode interactif. Un quantum de 100ms est un compromis raisonnable.
Sur la Fig.28. Est décrit comment on peut programmer une file suivant une liste circulaire. La
file est réalisée en utilisant une liste chaînée simple. Chaque noeud comporte un numero de
tâche (processus) et un pointeur vers le nœud suivant. Ce type de chaînage nécessite de
mémoriser le nœud précédant lors du parcours de la liste.
O
Tête de la
file p
Fig.28. Programmation d‟une file suivant une liste circulaire.
Ordonnancement par priorité
Souvent l‟ordonnancement par file circulaire suppose que tous les processus (tâches) ont la
même priorité. Cette situation ne correspond pas à la réalité tant dans un milieu bureautique
universitaire que dans un milieu industriel de commande en temps réel :

- milieu universitaire : dans un centre de calcul d‟une université la hiérarchie peut être
fixée de la manière suivante : les doyens en premier, les professeurs, CT, assistant,
secrétaires et enfin les étudiants ;
- dans le système de processus industriel, on est souvent amené à ranger les processus
par priorité, ou classe de priorités (tâches de commande, de contrôle, de dialogue,
tâche de sécurité, …)
Dans ce qui suit, nous allons envisager un ordonnancement par priorité, avec une seule tâches
par niveau de priorité.
Sur la Fig.29. est présenté l‟algorithme de l‟ordonnancement des tâches par priorité.
Processus
termine
ou bloqué
Niveau priorité n
p6 Niveau priorité n – 1
p5
Processus P p1 Niveau priorité n – 2

élu R plus prioritaire
O
C
E p3 Niveau priorité n – 3
S
S
E
U p7 Niveau priorité n – 4
R moins prioritaire
Processus prêts
Fig.29. Ordonnancement des tâches par priorité.
Le principe de l‟ordonnancement des tâches par priorité est très simple. Chaque tâche reçoit
lors de sa création un niveau de priorité. L‟Ordonnanceur lance la tâche prête prioritaire.
Pour empêcher le processus de priorité élevée de s‟exécuter indéfiniment, l‟Ordonnanceur
diminue la priorité du processus à chaque impulsion de l‟horloge. Si cette priorité devient
inférieure à celle du deuxième processus de plus haute priorité, la commutation à lieu. Les
priorités peuvent être statique ou dynamiques.
Dans le cas de priorité dynamique, il y a lieu d‟envisager le cas suivant : certains processus
font beaucoup d‟entrée/sortie et attendent ainsi la majeur partie du temps la fin d‟une
opération d‟entrée/sortie. Il faut donc leur allouer le processus dès qu‟ils en demandent, pour
leur permettre d‟effectuer leur requête suivante d‟entrée/sortie. Cette opération d‟entrée/sortie
pourra s‟exécuter en même temps qu‟un autre processus qui fait des calculs. Si les processus
qui font beaucoup d‟opération d‟entrée/sortie n‟obtiennent pas rapidement le processeur, ils
occuperont la mémoire inutilement pendant leur attente. Un bon algorithme consiste à donner
à ces processus la priorité 1/f, où f la fraction du quantum que le processus a utilisé à sa
dernière activation (élection). Un processus qui n‟a utilisé que 2ms de son quantum de 100ms

aura une priorité 50, alors qu‟un autre qui sera exécuté pendant 50ms avant de se bloquer aura
une priorité de 2. La priorité d‟un processus qui a utilisé tout son quantum sera de 1.
Réalisation d’un ordonnancement à priorité
La Fig.30.(1) présente une file chaînée simple dont chaque nœud comporte le numéro de la
tâche (x, y, z, w), et la valeur de la priorité (p, q, r, s) accordée à celle-ci. La file doit être triée
par priorités décroissantes pour éviter son parcours lors de la recherche de la tâche prioritaire.
De cette façon la tâche prioritaire est retirée en tête de file. L‟ajout d‟une tâche dans la file
d‟effectue en comparant, à partir de la tête, les priorités de chaque nœud avec celle de la tâche
à insérer.
p y
q z
r w
s
Tête de la file
Fig.30.(1). Ordonnancement par priorité en utilisant une liste chaînée

La Fig.(30).1 ci-dessous présente l‟insertion d‟une tâche i de priorité b entre les tâches y et z.
x
p y
q z
r w
s
i
b
Fig.30.(2) insertion d‟une nouvelle tache dans la file de taches organisées par priorité.
2. 1. 3. 5 Ordonnancement par priorité avec files multiples
Principes :
Ce type d‟ordonnancement est une variante de l‟ordonnancement par priorité. Comme nous
pouvons le constater sur Fig.31; le principe utilisé consiste à combiner l‟ordonnancement
Circulaire et l‟ordonnancement par priorité .Dans le modèle ci-dessous plusieurs taches
coexister au même niveau de priorité .Si plusieurs taches sont présentes dans la file de plus
forte priorité, ces taches seront exécutées, en utilisant le modèle circulaire (rund robin,
tourniquet) .S‟il n‟y a pas qu‟une seule tache par niveau de priorité le modèle est celui de
l‟ordonnancement par priorité .Entre ces deux modèles une multitudes de combinaisons sont
possibles.

Recyclage des taches prioritaires non terminées arrivées
P2 P4 P3 P1
P1 P5 P7
File prioritaire 0 (priorité supérieure)
P
R P9 P15
File prioritaire 1
O
C
E P11 P13 P6
S
File prioritaire 2
S
U
P8
S File prioritaire 3
Fig.31. Ordonnancement par priorité avec files multiples
Le processus p1 vient de se terminer ou de se bloquer .Le processus p5 est en exécution .Les

processus p2, p4, p3 et p1 sont dans la file d‟attente de priorité et sont en attente d‟exécution.
Lorsque le processus p7 de priorité 0 est activé il est placé en queue de file .ces processus est
exécuté avant ceux présents dans les files de priorité inférieure. Lorsque le niveau de priorité
0est vide, les processus 9 et 15 sont exécutés jusqu‟à l‟accomplissement ou blocage, à moins
qu‟un processus de priorité supérieure ne soit activé. Enfin de compte viendront les processus
p11, p13, p6 puis p8.
Ce type d‟ordonnancement est bien adapté aux applications temps réel, et la plupart des
exécutifs l‟utilisent. Il est également utilisé dans certaines versions d‟UNIX (version 7)
2.2. EXCLUSION MUTUELLE
2.2.1. Analyse approfondie du problème
1. Exemple 1
Mr et Mme Matumata ont un compte bancaire commun. Emettons l‟hypothèse selon laquelle
Mr et Mme Matumata se décident séparément à partir de deux guichets bancaires éloignés de
retrancher un montant de leur compte, en même temps. Si un système efficace de transactions
bancaires n‟est pas implémenté dans la base de données, on pourrait avoir la situation
suivante :
Le compte n est lu par Mr ;
Le compte n est lu par Mme ;

Le compte est modifié par monsieur et devient n-n1
Le compte est modifié par madame et devient n-n2

La valeur fin ale du compte est n-n2 au lieu de n-n1-n2.c‟est une anomalie.
2. Exemple 2
Soit deux processus p et q qui produisent de données devant être imprimées par une
imprimante unique .L‟emploi de cette imprimante par p exclut son emploi pour q tant que
l‟impression n‟est pas terminée.
3 Exemple
En dehors de l‟informatique, le même problème deux trains ayant à circuler dans les deux
sens sur un tronçon de voie unique.
Ces trois exemple illustrent la notion de d‟exclusion mutuelle :le compte du client doit être
considéré comme une ressource à un seul point d‟accès,de même que l‟imprimante ou la voie
ferroviaire unique.
Considérons la programmation au niveau de processus, de l‟exclusion mutuelle pour une

ressource C donnée, et appelons section critique d‟un processus, pour cette ressource une
phase du processus pendant laquelle la ressource C est utilisée par le processus, et donc
inaccessible aux autres processus.
Par hypothèse, les vitesses relatives des processus sont quelconques et inconnues ; nous
supposons unique que tout processus soit de section critique au bout d‟un temps fini.
Nous exigeons de la solution un certain nombre de propriétés :
a) A tout instant, un processus au plus peut se trouver en section critique (par définition de
la section critique).
b) Si plusieurs processus sont bloqués en attente de la ressource critique ,alors qu‟aucun
processus ne se trouve en section critique,l‟un d‟eux doit pouvoir y entrer au bout d‟un
temps fini(il faut éviter qu‟un blocage mutuel des processus puisse durer indéfiniment.
c) Si un processus est bloqué hors de la section critique, ce blocage ne doit pas empêcher
l‟entrée d‟un autre processus en sa section critique.
d) La solution doit être la même pour tous les processus, cest à dire qu‟aucun processus ne
doit jouer le rôle de privilégié.
Examinons quelques maniérer de réaliser l’exclusion mutuelle moyenne moyennant des

variables communes.
1. Une variable booléenne commune :
Cherchons à réaliser l‟exclusion mutuelle entre deux processus pi et pj qui veulent accéder à
une ressource critique en utilisant une seule variable booléenne commune.
Pour l‟écriture du programme de pi, on de signe « l‟autre processus »
Par pj ; c’est-à-dire : j=1 si i=2et j=2 si i=1(j=3-i)

Contexte commun : booléen C ;
C :=faux ;

Processus pi : début i (1,2)
Ai : si C alors aller à Ai ;
c :=vrai ;
section critique i ;
c :=faux ;
reste du programme i ;
Aller à Ai ;
Fin ;
Cet algorithme a une limitation : supposons que C=faux. Si chaque processus teste C avant
que l‟autre ne lui ait affecté la valeur vraie. Les deux processus s‟engagent dans leur section
critique. L‟exclusion mutuelle n‟est donc pas assurée.
2. Une seule variable commune fonctionnant en bascule :
Contexte commun : entier t;

t :=1 ;
Ai : si t=j alors aller à Ai ;

section critique i ;
t :=j ;
reste du programme i ;
Aller à Ai ;
Fin ;
Le processus pi ne peut entrer dans sa section critique que si t=i ;
L‟exclusion mutuelle est donc garantie par l‟indivisibilité de l‟opération de l‟accès à t.
Toutefois, la modification de t à chaque fin de section critique impose un fonctionnement en
bascule de deux processus, incompatibles avec la propriété d‟indépendance (condition c) de
l‟exclusion mutuelle. En particulier, l‟arrêt de pi dans la partie reste du programme i empêche
pj d‟exécuter plus d‟une fois sa section critique.
3. Deux variables communes :
On pose encore j=3-i. Une solution conforme aux conventions de l‟énoncé peut s‟écrire :
Contexte commun : booléen tableau C[1][2];

C [1] :=C [2] :=faux;
Ai : si C[j] alors aller à Ai ;

C[i] :=vrai ;
Section critique i ;
C[i] :=faux;
Reste du programme i ;
Aller à Ai ;

Fin ;
On a traduit ici le fait qu‟un processus pi ne peut entrer en section critique que si c[j]:= faux.
Considérons toute fois la séquence suivante :
1. pi consulte c[i]et trouve faux ;
2. pj consulte c[j]et trouve faux ;
3. pi fait c[j] :=vrai et entre dans sa section critique ;
4. pj fait c[i] :=vrai et entre dans sa section critique ;
L‟exclusion mutuelle n‟est donc pas garantie, et la solution est inacceptable. On peut songer à
modifier le programme de façon à faire l‟affectation de c[i] avant le test de c[j], remplaçant
les deux instructions suivant Ai par
Ai : c[i] :=vrai ;
Si c[j] alors aller à Ai ;
L‟exclusion mutuelle est cette fois garantie : en effet, si pi trouve c[j]=faux, pj ne se trouve
pas en section critique p j et p j ne peut y entrer puisque c[i]=vrai au moment du test de c[j].
Mais la condition b) de l‟exclusion mutuelle n‟est maintenant plus vérifiée.
Soit en effet la séquence suivante :

1. pi exécute l‟instruction étiquetée Ai :=c[i] := vrai ;
2. pj exécute l‟instruction étiquetée Aj :=c[j] := vrai ;
3. pj consulte c[i], trouve vrai et n‟exécute Aj ;
4. pi consulte c[j], trouve vrai et n‟exécute Ai ;
Les deux processus sont désormais engagés dans une boucle infinie t donc ne respectent pas
la condition b) de l‟exclusion mutuelle. On pourrait encore songer à améliorer la dernière
solution en remettant temporairement c[i], à faux à l‟intérieure la boucle d‟attente de p i pour
laisser passer pj :
Ai : c[i] :=vrai ;
Si c[j] alors
Début
C[i] := faux ;
Aller à Ai
Fin
4. trois variables communes
On pose toujours j=3-i
Contexte commun : entier t ;

Booléen tableau c [1 :2] ;
t :=1 ; c[1] :=c[2] := faux ;
Processus pi : début
Ai : c[i] := vrai ;
li : si c[j] alors

Début
si t=i alors aller à li ;
C[i] := faux ;
Bi : si t=j alors
aller à Ai
Fin
Section critique i ;
t:=j ;c[i] :=faux ;
Reste du programme i
Aller à Ai
Fin ;
Cette solution est due à la Dekker, et a été développé dans le livre de Dijkstra (cooperating
sequential processes, in programming languages. Press 1967).
Elle satisfait au conditions requises, comme nous allons le voir dans ce qui suit :
- il n‟y a pas conflit d‟accès à la section critique, c'est-à-dire que l‟une

des processus (soit pi) exécute li alors que c[j]=faux ; pi entre alors en
section critique ; comme c[i] a alors la valeur vraie et la gardera tant
que pi sera en section critique, pj ne pourra entrer en section critique
avant que pi en soit sorti.
- L‟exécution des instructions Ai, Li dans le processus pi est entrelacé
avec celle de Aj, Lj dans le processus pj.
On utilise alors le fait que la variable t ne pas modifier par l‟exécution des instructions A i, Li.
Si t = i alors pj entrera dans la boucle étiqueté Bj après avoir remis c[j] à faux : cela permet
donc l‟entrée en section critique de pj, qui était engagé dans la boucle Li. A la fin de sa section
critique, pi remet à la valeur j, ce qui libère pj, de la boucle Bj, lui permettant de tenter à
nouveau l‟entrée en section critique par Aj. Ainsi, on pourra éviter l‟attente infinie que
l‟entrée simultanée puisque le processus pi et lui seul entre en section critique en cas de
conflit.
En analysant les quatre exemples présentés, nous pouvons dire que le problème de l‟exclusion
mutuelle pourrait être résolu si on disposait d‟une instruction adéquate, le problème de
l‟exclusion mutuelle se résoudrait par :
Exclusion mutuelle (section critique) où section critique désigne une suite
d‟instructions utilisant la ressource critique.
Les propriétés a) , b), c), d) sont supposées vérifiées par l‟instruction appelée ici exclusion
mutuelle. Cette instruction se décompose en trois étapes suivantes :
Exclusion mutuelle (section critique) :
Début
Entrée;
Section critique ;
Sortie
Fin

Pour vaincre les problèmes causés par l‟utilisation de la variable booléenne en vue de
l‟exclusion mutuelle, explorons diverses façons de réaliser les instructions de l‟exclusion
mutuelle.
2.2.2. Attente active
Une solution simple peut être obtenue en utilisant l‟attente active. Pour ce faire, nous faisons
appelle à une instruction spéciale TAS (Test And Set) qui existe sur certaines
machines ;cette instruction agissant sur une variable m, peut se décrire ainsi :
Instruction TAS (m)
Début
bloquer l’accès à la cellule de mémoire m ;
Lire le contenu ;
si m=0 alors
début
m:=1 ;
section critique sur ressource ;
fin
sinon
Libérer accès cellule mémoire m ;
Fin
En considérant les aspects suivants :

- p : variable à tester
- R : ressources critique
L‟instruction TAS peut être utilisé de la manière suivante :
- au début p :=0
- E : TAS (p)
Aller à E
La validité cette solution tient à ce que le teste et la mise à 1 de p ne peuvent être faits que par
une seule instruction TAS (p) à la fois. Le bouclage de l‟accès à la cellule de mémoire p
assure par câblage, l‟exclusion mutuelle à la ressource R critique.
Dans cette section un processus bloqué sur p boucle sur l‟instruction et monopolise un
processeur, d‟où le nom d‟attente active. Cela est acceptable si l‟exclusion mutuelle survient
rarement et dure peu.
Pourquoi l’instruction TAS change la valeur de la variable booléenne commune, après

qu’elle Bloquée la cellule mémoire ?
* Comment fonctionne A instruction.

* considérons qu‟un processus p lance la suite d‟instruction:
A1 : Ta (m)
Aller à A1
En commençant par exécuter TAS (m)
Q : bloque l‟accès de la cellule m ;
Lit le contenu du m ;

Si m = 0 alors
Début
M := 1
Section critique sur ressource ;
Fin
Sinon
Libérer accès cellule m
Fin.
Lorsqu‟il trouve m = 0, (c'est-à-dire) que le processus n‟est pas occupé, pourquoi après avoir
bloqué m doit-il encore faire m = 1 ?
De toute façon, si un autre processus q tentait de lire la valeur de m, il n‟y arriverait pas, car la
cellule m est déjà bloquée par p, ainsi le comportement du processus q ressemblerait à ce qui
suit :
q : début
Ne peut bloquer m car cellule m déjà bloqué par p
Passe en attente ;
Bloqué accès cellule m ; le processus p vient de débloque m
Lire contenue m ;
Si m = 0 alors
Début
M:=1;
Section critique ressource ;
Fin
Sinon
Libérer accès m
Fin
En analysant les explications ci-dessous, on peut constater que dans le contexte d‟un
environnement monoprocesseur il n‟est pas important de changer la valeur de m, lorsqu‟un
processeur y accède en vue d‟occuper la ressource critique. Par contre dans le contexte d‟un
environnement multiprocesseur, en attribuant la valeur „1‟, lorsqu‟un processus qui est
exécuté dans un processeur autre que celui dont le processus occupe la ressource critique, il
constatera que m = 1, donc la ressource critique est occupée. Sur la Fig.33a. . ci-dessous est
présenté le cas de l‟utilisation de TAS, dans un environnement multiprocesseur
m=1
Proces- Proces- Proces

seur1 seur 2 seur 3
p11 p21 p31

p12 p22 p32
pij : jième processus exécuté par le processeur „ i‟

Fig.33a. en exécutant TAS (m), lorsqu‟on accède a la ressource critique en faisant m = 1, cela
empêcherait un processus d‟un autre processeur de tenter l‟accès à la ressource critique.

Sur notre exemple si p11 occupe la ressource critique, p12 ne pourra jamais accéder à m, car
il le trouvera. Mais, par exemple, p21 pourra accéder à m, par contre il trouvera m =1, donc la
bloqué ressource critique est occupée.
Il convient de signaler que certains microprocesseurs possèdent une instruction de type Test
and Set Lock (TSL) ;il s‟agit de :
TAS pour le Motorola 68000
BTSpour Intel 80386
NB : Intel est le numéro mondial de la fabrication des microprocesseurs. Les fameux PC

pentium sont équipés de ses microprocesseurs.
Motorola est aussi un des grands dans le domaine de la production de microprocesseurs. Ses
microprocesseurs sont souvent utilisés dans les implémentations de systèmes industriels.
2.2.3. Attente active par masquage des interruptions
Un autre moyen simple de réaliser l‟attente active est que chaque processus masque les
interruptions avant d‟entrer dans une section critique et le restaure à la fin de la section
critique. L‟interruption horloge ne peut avoir lieu lorsque les interruptions sont masquées. Le
processeur ne pourra donc plus être alloué à un autre processus, puisque ce sont les
interruptions qui provoquent le changement d‟allocation.
Dès qu‟un processus a masqué les interruptions, il peut accéder à la ressource critique car il
est sur qu‟aucun autre processus ne pourra l‟interrompre.
Cette approche a un inconvénient majeur car elle permet aux processus utilisateurs de
masquer les interruptions. Supposer qu‟un de ces processus oublie de les restaurer. Ce serait
la fin du système.
De plus, si le système possède plus d‟un processeur, le masquage des interruptions n‟aura lieu
que sur le processus pour lequel le masquage a été défini.
2.2.4. Les verrous
Appelons verrou la variable p (qui a été utilisé dans l‟attente active), et nous y associons une
file d‟entente f (p). Si un processus ne peut entrer en section critique, dans la file d‟attente ;
lorsque un processus sort de la section critique, un des processus de la file d‟attente est activé
(élu), si bien sur la file d‟attente n‟est pas vide.
La valeur initiale de p est 0.
Nous pouvons alors définir les opérations suivantes :
Verrouiller (p) :
Si p=0 alors p :=1
Sinon
Mettre le processus dans la file f(p) ;
(Il passera à état prêt, non élu)
Déverrouiller (p) :
Si f (p) n’est pas vide
Alors
Sortir un processus de f (p)
(Ce qui le rend actif, élu)
Sinon
P :=0 ;

Le verrou p et sa file f (p) sont évidemment des ressources critiques qu‟il faut protéger. Il est
plus commode de considérer les deux procédures comme une seule ressources critique ; ce
sont des procédures du système,car elle manipule des files de processus ;nous les appellerons
primitives parce qu‟aucun niveau des processus appelants elle se comporte comme des
instructions. Comme tout instruction, une primitive est indivisible pour l‟observateur. Elle est
perçue comme une entité atomique.
Comment résoudre l‟exclusion mutuelle pour l‟exécution des primitives ?
Les solutions sont différentes, selon que le système possède un seul ou plusieurs processeurs :
- dans un système monoprocesseur, il suffit de rendre les procédures
ininterruption ; on utilise le processeur comme ressource critique ;
- dans un système multiprocesseur, cette condition ne suffit pas car elle
n‟empêche pas deux processus de consulter et de modifier
simultanément p et f (p) ; on introduit donc une variable d‟exclusion
mutuelle dans les procédures, variable qui sera consulté par
l‟instruction de type TAS (Test And Set)
2.2.5. Les sémaphores
Les sémaphores sont la généralisation de concepts de verrouiller et de déverrouiller pour

lesquels la variable p peut prendre des valeurs entières quelconques.
Les concepts du sémaphore ont été introduits pour la première fois en 1965 par Dijkestra.
2.2.5.1. Définition de sémaphores
Un sémaphore S est constitué d‟une variable entière e(s) et d‟une file d‟attente f(s) .La
variable e(s) peut prendre des valeurs entières positives, négatives ou nulles ; cette variable
sera appelée valeur du sémaphore .La politique de la gestion de la file d‟attente est laissée en
guise du concepteur du système.
Un sémaphore s est créé par une déclaration qui doit spécifier la valeur initiale eo(s) de
e(s).Cette valeur initiale est nécessairement un entier non négatif. A la création d‟un
sémaphore, sa file d‟attente est toujours initialement vide.
Toute opération sur un sémaphore, est une opération indivisible. On peut agir sur un
sémaphore s, seulement par les primitives suivantes :
P(s) et V(s)
Cette terminologie provient de la langue nationale de Dijkstra, le néerlandais :

P : Phoberen, qui veut dire « tester»
V : Verhogen, qui veut dire « incrémenter».
Les opérations sémaphore sont parfois également connues sous le nom de :

Up (haut) ;
Down (bas) ;
Où
Wait( ) ;
Signal( ).

Il existe deux approches pour définir le sémaphore :
- approche généralisante ;
- approche moins généralisante :
Approche généralisante :
Le sémaphore peut prendre les valeurs entières positives, négatives ou nulles,ainsi les
primitives seront :
P(s) : début
e(s):= e(s) – 1
si e(s) < 0 alors
début
Commentaire : on suppose que cette primitive est exécutée
Par le processeur r ;
État(r) :=bloqué ;
Mettre le processus r dans la file f(s)
fin
V(s) : début
e(s): e(s) +1
si e(s) ≤ 0 alors
Début
Sortir un processus de la file f(s) ;
Commentaire : soit q le processus de la file f(s) ;
État (q) : actif
fin
fin
Approche moins généralisante :
Le sémaphore peut prendre les valeurs positives ou nulles
P(s): debut
Si e(s) = 0
Alors
e(s):=e(s)-1
Autrement
début
Commentaire : on suppose que cette primitive est exécutée par le processus r ;
État = bloqué ;
Mettre le processus r dans la file f(s)
fin
fin
V(s) : début
si file f(s) vide alors
e(s) := e(s) +1
Autrement

début
Sortir un processus de la file f(s) ;
Commentaire : soit q le processus sorti ;
état (q) := actif
fin
fin
Il est bien évident que lorsque vous choisissez une approche, il faut pousser le raisonnement
en restant dans l‟approche choisie.
2.2.5.2. Propretés de sémaphores
La définition des primitives P, et V a les conséquences suivantes :
1) un sémaphore ne peut être initialisé à une valeur négative, mais il peut devenir négatif
après un certain nombre d‟opération P(s)
2) Soit np(s) le nombre d‟instructions P exécutées sur le sémaphore s,
nv(s) le nombre d‟instructions V exécutées sur le sémaphore s
eo(s) la valeur initiale du sémaphores
Il résulte de la définition de P et V que e(s)=eo(s)-np(s)+nv(s)
3) soit nf(s) le nombre de processus qui ont franchis la primitive P(s), c'est-à-dire qui, ou
bien n‟ont pas été bloqués par celle-ci, ou bien ont été bloqué, mais débloqués depuis ;
à tout instant on a
nf(s) ≤ np(s)
Il a été démontré [CROCUS] que l‟exécution des primitives P et V laisse invariante la

relation :
nf(s) = min (np(s), eo(s) + nv(s))
4) si e(s) est négative, sa valeur absolue égale le nombre de processus bloqués dans la file
d‟attente f(s)
e(s) =eo(s)-np(s)+nv(s)
e(s) < 0 ona eo(s)+nv(s) < np(s)
En nous basant sur la propriété 3
nf(s) = eo(s) + nv(s)

e(s) = -np(s) + nf(s)
-e(s) = np(s)-nf(s)
5) Si e(s) est positive ou nulle, sa valeur donne le nombre de processus pouvant franchir le
sémaphore s sans se bloquer.
Ainsi, en initialisant la valeur initiale du sémaphore à n,P et V peuvent être utilisés jusqu‟à
autoriser n processus dans leurs sections critiques.
2.2.5.3. Sémaphore binaire
Un sémaphore binaire est un sémaphore dont e(s) ne peut prendre que les valeurs 1 ou 0.

Les primitives P,V exécutées sur le sémaphore binaire,peuvent être décrites de la manière
suivante :
P(s): debut
si e(s)=1 alors
e(s) := e(s)-1
Autrement
début
État (p)= bloqué
Mettre le processus p dans la file f(s)
fin
fin
V(s) : début
si file f(s) vide
alors
e(s) :=1
Autrement
début
Sortir un processus de la file f(s)
état(q) := actif
fin
fin
2.2.5.4. Sémaphores d’exclusion mutuelle
L‟exclusion mutuelle est résolue de la manière suivante : résout comme suit :

On introduit un sémaphore mutex initialisé à 1 et chaque processus s‟exécute selon le
programme
début
P (mutex) ;
Section critique ;
V (mutex) ;
Suite d’instructions ;
Fin
2.3. RESEAU DE PETRI (MODELISATION DES PROCESSUS CONCURRENTS)
2.3.1. Introduction
Les réseaux de PETRI ont été introduits au début des années 1960 par C.A. PETRI, puis
développés au MIT (Massachusetts Institute of Technology) autour de 1972.
Ils permettent zen particulier de :
- modéliser les processus concurrents parallèles ;

- modéliser les protocoles de communication ;
- analyser le système d‟information ( Ainsi, ils sont utilise dans la méthode MERISE)

2.3.2. Discussion informelle
Un réseau de PETRI est composé de types d‟éléments suivants :
- des places (liées à des conditions) ;

- des transitions (liées à des évènements) ;
- des arcs orientés reliant places et transitions ;
- des jetons.
Les places situées en amont d‟une transition sont appelées places d‟entrée de cette transition
(input places). Celles en aval d‟une transition portent le nom de places de sortie de cette
transition. Une place peut posséder 0,1 ou plusieurs jetons. La présence d‟un jeton (token)
dans une place indique que la condition associée à la place est remplie.
Une transition est régie par l‟ensemble des règles suivantes :
- une transition est franchissable (enabled ou firable) si chacune de ses places d‟entrées
contient au moins un jeton ;
- le franchissement d‟une transition consiste à prélever un jeton dans chaque place
d‟entrée et d‟en déposer un dans chaque place de sortie ;
- une transition peut ne pas être franchie immédiatement après la réalisation de ses
conditions de franchissement ;
- le franchissement d‟une transition, lorsqu‟il se produit ne prend aucun temps.
Au lieu du franchissement d‟une transition on parle parfois du tir d‟une transition (firing).
Dans description de processus concurrents et protocoles de communication, il est impératif

d‟utiliser une description formelle, car elle élimine les ambiguïtés inhérentes au langage
naturel de l‟être humain. Une autre technique de description formelle utilisée dans la
modélisation de processus concurrents et protocoles de communication sont :
- la machine d‟états finis ; pourrait utiliser plusieurs types de représentation :

 le diagramme d‟états (state transition diagram) ;
 l‟algèbre vectorielle
 les tables de décision
Il y a lieu de citer comme techniques utilisées dans la modélisation de processus, protocoles :

- le langage Estelle, qui est fondée sur le concept de machine d‟états finis étendue ;
- le langage LOTOS, développé par le sous-groupe C de ISO (ISO/SC21/WG16-
1/FDT), entre 1981-1984 et s‟appuie sur l‟ordonnancement temporel.
Sur les Fig.34.(a) et Fig.34.(b) ci-dessous est représenté le comportement d‟une condition du
réseau de PETRI avant franchissement respectivement après franchissement.
Places d‟entrée Places de sortie
Fig. 34.(a). Condition avant franchissement

Jeton
Transition
Fig. 34.(b). Condition RdP avant franchissement
Prenons d‟une manière informelle un exemple qui n‟a rien à avoir avec la gestion de
processus :
On définit les conditions pour devenir CP, L1 – Informatique :
- être de sexe féminin (C1) ;

- avoir payé le minerval (C2) ;
- être élu avec plus de 50% de voix (C3).
Modélisons la situation pour que Mlle Bolingo Mira puisse devenir CP
C1 Elu
C2
C3
Fig. 35.(a). avant élection Fig. 35.(b).Après élection(Mira élue, avant

franchissement)
Election -OK
Les Fig.35.(a), Fig.35.(b), Fig.35.(c) modélise l‟évolution de Mira.
Fig. 34.(c).Après élection Fig. 34.(b).

(Mira élue, après Après élection
franchissement) (Mira, non élue)
Les Fig.35.(a), Fig.35.(b) : modélisent la situation de l‟échec de Mira a l‟élection.
Si on analyse, les choses avec la minute d‟un clinicien, force est de constater que les places
permettent de représenter les états du système ; l „ensemble des transitions représente alors
l‟ensemble des évènements dont l‟occurrence provoque la modification de l‟état du système.
La Fig.36. Ci-dessous représente « attribution d‟une ressource ». Les deux places d‟entrée
correspondent aux préconditions « ressource libre » et « demande d‟attribution ». La présence
d‟un jeton indique que la ressource a été attribuée.
Ressource libre Demande d‟attribution
Attribution d‟une ressource
Ressource attribuée
Fig.36. Attribution d‟une ressource
2.3.3. Définition formelle
D‟une manière formelle, le réseau de PETRI peut être défini comme un quadruplet (P,T,I,O),
avec,
P = p1, p2, …, pk l‟ensemble des places (conditions) ;
T = t1, t2, …, tn l‟ensemble des transitions (évents) ;
I = la fonction d‟entrée telle que I(ti) = pi, pk, …
O = la fonction de sortie telle que O(tj) = p1, pm, …
Les fonctions I et O définissent la topologie du réseau de PETRI. La fonction I permet la

vérification des conditions de franchissement c‟est-à-dire la présence de jetons dans les places
d‟entrée de la transition considérée. Les fonctions I et O permettent de calculer la situation
des jetons après le franchissement d‟une transition.
L‟une des intérêts des réseaux de PETRI réside dans la possibilité de représenter le non
déterminisme. Sur la Fig.37. Ci-dessous, est représenté un non déterminisme pur, les
transitions t1 et t2 peuvent toutes deux être franchies, mais si une l‟est, l‟autre ne peut plus
l‟être.
a b c
t1 t2
d e
Fig.37. Réseau de PETRI modélisant le non déterminisme.

2.4. MECANISME DE SYNCHRONISATION
2.4. 1. Introduction
Les divers processus d‟un système n‟évoluent généralement pas indépendamment : il existe
entre eux des relations qui dépendent de la logique de la tâche à accomplir et qui fixent leur
déroulement dans le temps. L’ensemble de ces relations est la synchronisation, bien
qu‟elles ne fassent pas intervenir le temps comme mesure de durée, mais seulement comme
moyen d‟introduire une relation d‟ordre entre des instructions exécutées par les processus.
Le problème de la synchronisation consiste donc à construire un mécanisme indépendant des
vitesses permettant à un processus actif (soit p) :
- d‟en bloquer un autre ou de se bloquer lui-même en attendant un signal d‟un autre
processus ;
- d‟activer un autre processus en lui transmettant éventuellement de l‟information.
Remarquons que, dans ce dernier cas, le processus q auquel est destiné le signal d‟activation
peut déjà se trouver à l‟état actif ; il faut donc définir de façon plus précise l‟effet de
l‟opération d‟activation lorsqu‟on se trouve dans cette circonstance. Deux possibilités se
présentent :
a) Le signal d‟activation n‟est pas mémorisé, et par conséquent il est perdu si le
processus q ne l‟attend pas.
b) Le signal est mémorisé et le processus q ne se bloquera pas lors de la prochaine
opération de blocage concernant ce processus.
Deux techniques sont concevables pour réaliser des opérations de synchronisation, appelées
primitives :
a) Action directe : un processus agit directement sur un autre processus.
b) Action indirecte : un processus actionne sur un mécanisme qui agit sur d‟autres
processus.
Autrement dit, dans le cas de l‟action directe, l‟identité du processus doit être un paramètre
d‟activation (ou de blocage) alors que dans le second cas, le nom et l‟identité des processus
visés peuvent être inconnue du processus agissant :
2.4. 2. Mécanisme d’action directe
Les processus qui évoluent dans un système ne sont pas généralement tous a telle enseigne
que certain processus peuvent par exemple bouclé indéfiniment : il est alors indispensable de
pouvoir les suspendre en les faisant passer à l‟état bloqué.
Dans ce cas, l‟identité du processus que l‟on désire suspendre doit être un paramètre de la
primitive de blocage.
L‟instant où intervient cette action dans le cycle du processus à suspendre ne pas toujours
indifférent. En effet, pour assurer l‟homogénéité des variables, certaines opérations exécutées
par le processus à suspendre doivent être rendues logiquement in interruptibles, par exemple
lorsqu‟il accède à sa section critique.
Le mécanisme de synchronisation par action directe, peut être réalisé par des primitives :
- Bloquer ()
- éveiller ()
en outre à chaque processus q est associé un indicateur booléen noté état(q) qui indique l‟état
actif ou bloqué du processus q.
la primitive bloquer (q) force le passage du processus q à l‟état loqué ; l‟évolution du
processus reprendra, lorsque son état aura repris la valeur « actif » la primitive éveiller (q) a
pour effet de rendre actif le processus q, s‟il était bloqué, si la primitive éveiller (q) est

exécutée par un processus p alors que q est encore actif, le signal d‟activation émis à
l‟intention du processus q, alors que celui-ci se trouve à l‟état actif, on doit associer à chaque
processus un indicateur booléen supplémentaire noté témoin (témoin d‟éveil). Son effet sera
de maintenir à l‟état actif le processus q, lors de la prochaine primitive bloquer (q).
Dans ces conditions, bloquer (q) provoquera le passage à l‟état bloqué du processus q ssi le
témoin (q) = faux.
Par contre, si témoin (q) = vrai, il est remis à faux, l‟effet de la primitive s‟arrête là.
L‟algorithme de cette opération s‟exprime de la manière suivante :
Bloquer (q) : si témoin (q) = faux alors

État (q) = bloqué
Sinon
Témoin (q) := faux
La primitive éveiller (q) active le processus q, s‟il est bloqué. Par contre si le processus est
encore actif lorsque la primitive est exécutée, témoin (q) est mis à vrai et l‟activation est ainsi
mémorisée.
L‟algorithme est le suivant :
Éveiller (q) : si état (q) = bloqué alors
État (q) : = actif
Sinon témoin (q) : = vrai
Le témoin d‟éveil d‟un processus peut mémoriser une et une seule activation éventuelle : c‟est
là une limitation de ce mécanisme.
2.4. 3. Mécanisme d’action indirecte
Dans un mécanisme d‟action indirecte la synchronisation met en jeu non plus le nom du
processus mais un ou plusieurs objets intermédiaires connus des processus coopérants, et
manipulables par eux uniquement à travers des opérations indivisibles spécifiques. Selon la
nature des opérations qui permettent de les manipuler, ces objets portent les noms :
- d‟évènements ;
- de sémaphores.
2.4. 3. 1. Synchronisation par évènements

Un événement ne peut être manipulé que par certaines opérations particulières : un
évènements peut être attendu par le (les) processus qui y ont accès, ou bien il peut être
déclenché. En outre, un événement peut être mémorisé ou non mémorisé.
a) Evènement mémorisé
Un événement mémorisé est représenté par une variable booléenne ; à un instant donné la
valeur 1 ou 0, de cette variable traduit le fait que l‟événement est ou n‟est pas arrivé. Un
processus se bloque si et seulement si l‟événement qu‟il attend n‟est pas arrivé ; selon le
système, le déclenchement d‟un événement débloque un processus ou tous les processus qui
l‟attendent. Par exemple, en PL/1, il est possible, en utilisant l‟option task, d‟initialiser des
processus parallèles. Un évènement est représenté par un symbole déclaré explicitement par
l‟attribut évent ou implicitement lors de la création d‟un processus (option task).
L‟affectation d‟une valeur booléenne à un événement se fait au moyen d‟une pseudo variable
de type complétion :
Complétion (evt) = ‘0’B ; indique que l‟événement noté « evt » n‟est pas arrivé, ce qui
équivaut à une « remise à zéro » de l‟événement.

Complétion (evt) = ‘1’B ; déclenche l‟événement noté « evt ».
Un processus qui exécute l‟instruction wait (evt) se bloque si et seulement si l‟événement
n‟est pas arrivé, autrement dit si complétion (evt) = ‘0’B
b) Evènement non mémorisé
Lorsqu‟il n‟y a pas mémorisation, un événement émis alors qu‟aucun processus ne l‟attend est
perdu. Par contre, si un ou plusieurs processus sont bloqués dans l‟attente de cet événement au
moment où il se produit, ces processus deviendront actifs.
La notion d‟événement non mémorisé est très délicate à manipuler, car elle met en jeu la
vitesse des processus.
On retrouve souvent l‟événement non mémorisé dans les langages spécialement conçus pour
la commande de processus industriels.
c) Extension de la notion d’événement
On peut très bien imaginer le fait que l‟activation d‟un processus soit associée à des entités
plus complexes qu‟un simple événement, par exemple l‟occurrence conjointe de deux
évènements ou à l‟occurrence de l‟un ou l‟autre de deux évènements et plus généralement à
une expression booléenne d‟évènements.
Cette idée est illustrée dans le programme PL1 ci-dessous :
p1: procedure:
Call p2 event (e2) ;
Call p3 event (e3) ;
Wait (e2, e3) (i);
...;
end pl.
Dans ce programme, deux tâches parallèles sont initialisées au moyen d‟instruction call, avant
d‟exécuter une instruction wait l‟événement e2 déclaré explicitement par l‟attribut évent à la
création de la tâche p2, sera déclenché par la fin de l‟exécution de cette tâche ; il en est de
même de e3. Il en résulte que :
Si i = 2 la tâche pl reste bloquée sur l‟instruction wait jusqu'à l‟arrivée des deux événements
e2 et e3.
Si i = 1 l‟arrivée d‟un seul de deux événements suffit à débloquer la tâche pl.
Si i ≤ 0 l‟instruction wait est sans effet et la tâche pl ne se bloque pas.
2.4. 3. 2. Synchronisation par sémaphores
Nous avons déjà rencontré le mécanisme des sémaphores pour résoudre le problème
d‟exclusion d‟accès à une ressource critique. On peut utiliser le sémaphore pour résoudre des
problèmes généraux de synchronisation : un signal d‟activation est envoyé par une primitive
v ; il est attendu par une primitive p.
Ainsi, un processus dont l‟évolution est subordonné à l‟émission d‟un signal par un autre
processus bloqué, au moyen d‟une primitive p, derrière son sémaphore initialisé à zéro, le
signal de réveil de ce processus bloqué est obtenu en faisant exécuter par un autre processus
une opération V sur le même sémaphore.

Exemple : L‟activation d‟un processus p dont l‟évolution est subordonnée a l‟émission d‟un
signal par un processus q se programme comme suit en introduisant le sémaphore signal
initialisé à 0.
Sémaphore signal : (valeur initiale)
Processus p : début processus q : début

A1 :… ; Ai B1 : … ; Bj,
p (signal) ; V (signal) ;
…; …;
fin ; fin ;
Deux cas peuvent être envisagés :
- le processus p est déjà bloqué sur la primitive p (signal) lorsque le processus q exécute
la primitive V (signal), alors le processus p va se réveiller.
- le processus p est actif lorsque le signal est émis (il exécute par exemple l‟instruction
Ai) et tout se passe comme si le signal était mémorisé ; en effet la valeur du
sémaphore signal est passé à 1 et lorsque le processus p exécutera la primitive p, il ne
se bloquera pas
2.4. 3. 3. Modélisation de synchronisation entre processus par réseau de Pétri
Nous allons voir en utilisant un outil de modélisation puissant comment on peut modéliser la
synchronisation et la communication entre deux processus. Soient deux processus : A et B.
1. A prépare les données ;
2. A transmet a B le message « request-to-send »;
3. A attend de B le message “ready-to-receive”;
4. A Envoi de données;
5. A signal a B par “data-sent”, la fin de l‟envoi;
6. A attend de B le message « data-consumed ».
Sur la Fig38a est illustre les processus A et B qui communiquent selon la description ci-
dessus et sur Fig38b est présenté la modélisation de leur synchronisation et communication
en utilisant le réseau de PETRI.
A r_t_s B
(source) r_t_r (destination)
d_s
d_c
La Fig38a. Processus A et B en synchronisation et communication

r_t_s : request_to_send
r_t_r: ready_to_receive
d_s: data send
d_c: data consumed
La Fig38b. fait apparaître les modèles des deux parties, source et destination avec transition 1
et 12 comme interface de la source avec le reste du processus A et les transitions 17 et 18 a
l‟interface entre la destination et le reste du processus B, lui-même modélise en grise de la
manière la plus simple possible qui marque cependant les caractère «esclave de ce processus.

On notera l‟interface entre la source et la destination est représentée par les transitions 4, 5, 9
et 10 et ce pour le deux parties du modèle. A chacune de ces transitions est associé le passage
d‟un message. Le fait de choisir la même transition entre la source et la destination indique
qu‟a ce stade nous considérons que le milieu de transition se comporte de manière idéale
c'est-à-dire sans perte et sans délai.
1 b 2
get_data_ready
C Request_to_send
a 3 n m
d 4 4
13
15
p
f ready_to_receive
e 15
6
g 5 5 q
send_data
r
data_sent
9 9
i 16 s
8
k t
10 10 x
j w v
12
11 data_consmed 18
19
Source Destination
Fig.38b. Réseau de PETRI modélisant la synchronisation et communication entre processus

(source) et processus destination.

Voyons maintenant le modèle de la source. On note tout d‟abord qu‟au départ on a place un
jeton en a pour marquer l‟état opérationnel de la source.
La présence de ce jeton permet, si un jeton apparaît en b, de franchir la transition 2 qui
modélise la prise en charge des données pour en préparer la transmission et permettre le
franchissement de la transition 3 dont le résultat est de placer un jeton en d et en e. Le jeton en
d indique que l‟on est prêt a envoyer le request-to-send.
Lorsque le jeton arrive a f, suite a la réception du ready-to-receive, le franchissement de la

transition 6 est possible et le jeton passe ne g ce qui indique que la source est prête a envoyer
les données. On notera le franchissement de la transition 7 conduit a placer un jeton dans la
placée d‟entrée grisée de la transition 16. En réalité dans la modélisation du protocole on
aurait pu ne pas faire apparaître la partie en grisée et se limiter aux
Interactions entre source et destination via les quatre messages. Il importe de rappeler que tout
modèle est une abstraction de la réalité et en reflète que les aspects considèrent comme les
plus fondamentaux.
Les jeton h marque la fin de la transmission des données et le franchissement de la transition

place un jeton en j et un jeton en I indiquant que l‟on est près a envoyer data-sent. L‟arriver
de data-consumed représente par un jeton en k permet le franchissement de la transition 11
qui remet un jeton en a ainsi qu‟un jeton en 1 ce qui permet le franchissement de la transition
12 d‟informer le processus A de l‟exécution du transition.
Certaines opérations évoque dans la modélisation peuvent requérir un certain temps

d‟exécution mais un modèle étant une abstraction de a réalité ne doit pas nécessairement être
a même dans d‟en représenter tout les aspects.
En particulier les réseaux de pétri que nous venons de voir ne permettent pas la modélisation
du temps. Ils permettent par contre la modélisation des événements et des états. Un jeton en a
indique la source et prête a prendre en charge une demande d‟envoi des données provenant du
processus A. La transition 2marque la prise en charge de la demande, les jetons en c indique
que la source a préparer les données, un jeton en d
Indique que le message request-to-sent est prêt a être envoie tandis que le jeton en e indique
que la source est en attente de la réponse de la destination c‟est a dire l‟arriver de ready-to-
receive via le jeton en f.
On pourrait aussi analyser de manière détaillée le modèle du processus destination de la Fig.

2.5. Nous laisserons ce travail a titre d‟exercice en mentionnant toute fois les jetons initiale
en m qui indique la destination et en attente d‟un message venant de la source, la transition 13
qui indique la prise en charge du request-to-send, la transition 14 relative a la préparation des
ressources nécessaire pour recevoir des données. Des autres places et transitions sont relatives
a des mécanismes déjà évoques.
Si l‟on désir abstraire le modèle du tout détail non directement en rapport avec le protocole de
communication, il est possible de simplifier la Fig. 2.5 en éliminant tout ce qui modélise des
états et événement strictement interne aux processus source et destination et en ne conservant
que ceux lies aux interactions entre source et destination ainsi qu‟avec les parties externes de
processus A et B.

2.4. 3. 4. Programmation de la synchronisation et communication entre processus
(source) et processus destination.
La communication et synchronisation entre les processus Source et destination présentées

dans la section précédente peuvent être programmée , en utilisant les sémaphores, en langage
Pascal concurrent, comme dans le programme ci-dessous.
begin requet-to-send :=0 ;

ready-to-receive :=0 ; get-data-ready Get-ready
pata-sent:=0;
data-consumed:=0; r-t-s
A a
cobegin
r-t-r
process 1 b
L1: get-data-ready; source
Signal (reqest-to-send); d-s Detin.
Wait (ready-to-receive); c d-c
Send-data; d
Signal (data-sent);
Wait (data-consumed);
Go-to-L1; source destinaton
process 2
L2: wait (request-to-send);

Get-ready;
Signal (ready-to-receive);
Wait (data-sent);
Consume-data;
Signal (data-consumed);
Go-to-L2;
coend
end
2.4. COMMUNICATION ENTRE PROCESSUS
2.4.1 Introduction
La coopération des plusieurs processus a l‟exécution d‟une tache commune nécessite une
communication d‟information entre ces processus. Les primitives de synchronisation étudiées
précédemment réalise un mode de communication ou l‟information transmise est réduite a la
forme élémentaire d‟une autorisation ou d‟une interdiction de continuer l‟exécution au de la
d‟un certain point prédétermine. Le message se réduit donc dans ce cas a un potentiel
d‟activation. Ce mode de communication ne communication ne suffit pas a tous le besoins.
Ainsi lorsque les actions exécutées par un processus après son activation dépendent de
l‟identité du processeur activateur, cette identité doit pouvoir être transmise au processus
actif.

Donc la communication entre processus est le fait que les processus peuvent se communiquer
des messages, d‟information, au de la d‟une simple activation. Les messages qu‟ils se
communiquent contribuent a la réalisation de certaines taches auxquelles les processus sont
impliques. Les fichiers par exemples constituent le mécanisme le plus fréquemment utilise
pour le partage d‟information. Les informations écrites dans un fichier par un processus
peuvent être lues par un autre processus. Le volume d‟information pouvant être partage et
uniquement limite par la capacité de taille de fichier du système.
Sous le système prenant en charge les threads (sous-taches s‟exécutant d‟une manière
parallèle), la mémoire fait partie intégrante du concept de threads. Dans certain système
d‟exploitation le disque virtuel est utilisé comme mécanisme d‟échange entre processus. Le
système de fichier permet la création de ce disque virtuel qui est en réalité une zone de
l‟espace de mémoire interne. Donc les fichiers stocké sur le disque virtuel sont en réalité
enregistre en mémoire. Les primitives de signalisations dans certains systèmes d‟exploitations
peuvent être utilisés pour l‟envoie des messages :
send-signal (pid, signal-id) : envoi un numéro de signal, signal-ID au processus avec le

numéro d‟identification pid.
React-signal (function, signal Id) : configure le processus pour qu‟a la réception d‟un numéro
de signal Id, celui réponde en passant en fonction « function ».
En associant une signification a différent numéros de signaux, les processus peuvent se

communiques des information entres eux. Nombreux des systèmes d‟exploitation prennent en
charge un système de messagerie applicative pour l‟envoi des messages entre processus. Voici
certains facteurs qui entre en compte lors de la conception d‟un tel système :
 A quel genre d‟objet est envoyé le message ?
 Il peut s‟agir d‟un processus, d‟une boite aux lettres, d‟un tampon de communication ;
l‟objet peut être identifié par un nom ou un numéro d‟identification.
 Comment les processus sont-ils associés aux objets du message ?
 Le système d‟exploitation peut exiger par exemple que toute communication soit
précédée d‟une primitive qui établi une connexion avec l‟objet de destination. Tout
processus peut être autorise a communiquer avec l‟objet destination, mais il est
possible de mettre en place certaines restrictions si l‟objet de destination est une boite
aux lettres ou tampon de communication, en ce moment la, il n‟est pas nécessaire
d‟établir une quelconque connexion
 Combien des processus peuvent partager un même objet de messagerie ?

Le nombre de processus en mesure en mesure de lire et d‟écrire dans l‟objet du
message peut faire l‟objet de diverses restrictions. Ainsi,un certain nombre de
processus peuvent être autorisés a écrire dans l‟objet,avec un seul pouvant lire les
messages depuis l‟objet.
 L‟objet de messagerie est-il bidirectionnel ou unidirectionnel ?

Un processus peut être limite a un accès en lecture ou a un accès en écriture, mais pas
aux deux. L‟accès bidirectionnel peut être autorise, permettant aux processus de lire et
d‟écrire a la fois dans un objet.
 A combien des objet de messagerie un processus peut-il accéder ?

Le système d‟exploitation peut imposer des limites a l‟échelle du système ou
restreindre le nombre d‟objet pouvant être utilise entre les deux processus.
 Les messages sont-ils de tailles fixe ou variable ?
Les messages peuvent être de taille fixe, mais s‟ils sont d‟une taille variable, le
système d‟exploitation peut impose une taille maximale.
 Combien des messages peuvent être stocké dans un objet de messages ?
La mise en mémoire tampon peut être :
 Inexistante ;
 Bornée ;
 Non borne ;
 Baser sur un mécanisme d‟accuser réception
Mise en tampon inexistant :

Dans ce cas l‟opération d‟envoie bloque le processus d‟envoie jusqu'à la
Consommation du message car le récepteur. Ce type d‟opération est appelé
Rendez-vous.
Mise en tampon borné :

Elle bloque l‟opération d‟envoie si la mémoire tampon est plein.
Mise en tampon non bornée :

L‟émetteur n‟est jamais bloqué lorsqu‟il essaie d‟envoyer un message .
Mise en tampon borné sur mécanisme d’accuser réception :

Bloquer l‟expéditeur jusqu'à ce que le récepteur renvoie un type spécial d‟accuser
réception.
 Les messages sont-ils envoyés par valeur ou par référence ?

Le message envoyé par référence nécessite moins des surcharges, mais ils peuvent être
modifie après leurs envoies, et il enfreint le principe selon lequel chaque processus
doit recevoir un processus d‟adressage indépendant.
 Que se passe-t-il si un processus se termine alors qu‟un autre processus est bloqué
dans l‟attente d‟une action du processus qui vient de s‟adresser ?
Généralement la primitive a l‟origine du blocage renvoie un statut d‟erreur en
indiquant un échec ou bien le processus bloqué se termine également.
2.4.2. Quelques types de communication entre processus par variable commune
2.4.2.1. Communication entre processus par variables communes
Les problèmes les plus généraux de communication entre processus peuvent être résolus en
rendant un ensemble des variables communes accessible a tous les processus. Toutefois
l‟accès simultané de plusieurs processus a des telles variables pose des problèmes de
cohérence soulevée a propos de l‟exclusion mutuelle. Les processus doivent donc s‟imposer

une règle du jeu plus ou moins élaboré suivant la nature de la communication. Cette règle
simple consisterait a inclure tout accès a des données, a une section critique ; toute fois, des
considérations d‟efficacité amène a réaliser des sections critiques brèves que possible, et en
particulier a éviter les blocages des processus a l‟intérieur d‟une telle section. On peut faire
deux remarques sur ce modèle de communication générale par accès a des variables
communes :
 Les règles de communication que doivent observes les processus ne peuvent leur
imposées car on a aucune garantie contre le non respect de ces règles par un
processus défectueux ;
 La communication par consultation et modification des variables communes se
prêtent assez mal a une interprétation du type „envoie des messages‟ un tel mode
d‟interaction entre processus p et q, serai par exemple :
 p envoie un message a q (c'est-à-dire fournir de l‟informations et prévient

qui que cette information est disponible) puis peut attendre ou n‟est pas
attendre un accuse de réception de q pour continuer ;
 q, qui attendait un message, reçoit le message p et signal, ou ne signal pas
sa réception a p. l‟arriver d‟un message impliquant l‟arriver d‟un message
le réveil du destinateur en attente, ou voit qu‟un dispositif de
synchronisation doit être incorpore dans le protocole de communication.
dans la catégorie de la communication entre processus par variable
commune seront abordes :
- le modèle du producteur et du consommateur ;
- la communication par boite aux lettres.
2.4.2.2. Le modèle du producteur et du consommateur
Le schéma connus sous le nom de « modèle du producteur et du consommateur » permet de

présenter les principaux problèmes de la communication entre processus en utilisant des
variables communes avec synchronisation. On considère deux processus…….producteur et
consommateur, qui se communiquent de l‟information a travers une zone de mémoire, dans
les conditions suivantes :
-l‟information est constituée par des messages de taille constante ;

-aucune hypothèse n‟est faite sur la vitesse relative de deux processus.
La zone de mémoire commune, ou tampon, a une capacité fixe de n message (n>0).l‟activité

de deux processus se déroule schématiquement suivant le cycle ci-après :
PRODUCTEUR CONSOMMATEUR
PROD : produire un message ; CONS : prélever un message

Déposer un message dans le tampon ;
Dans le tampon ; consommer le message ;
aller a PROD ; aller a CONS ;
On souhaite que la communication se déroule suivant la règle ci-après :

-exclusion mutuelle au niveau du message. Le consommateur ne peut prélever un message
que le producteur et entrain de ranger ;

-le producteur ne peut placer un message dans le tampon ci celui est plein (on s‟interdit de
placer des messages par surimpression) ;le producteur‟ doit alors attendre ;
-le consommateur doit prélever tout message une fois et une seule ;
-si le producteur est en attente parce que le tampon est plein,il doit être prévenu des que cette
condition cesse d‟être vraie ;il en est de même pour le consommateur et la condition « tampon
vide ».
Pour représenter de façon plus précise l‟état du système,introduisant deux variables
caractérisant l‟état du tampon en dehors des phases de communication proprement dite(les
deux processus se trouvent donc…..leur phase de production ou consommation) :
nplein :nombre de messages attendant d‟être prélevé,

nvide :nombre d‟emplacement disponible dans le tampon.
Initialement,nous avons :
nplein=0, nvide=n
L‟algorithme des deux processus peut alors s‟écrire de la manière suivante :
Entier nplein=0, nvide=n
PROD : produire un message ; CONS : nplein :=nplein-1 ;
nvide :=nvide-1 ; si nplein=-1 alors
si nvide=-1 alors
attendre ; attendre ;
deposer le message ; prelever un message ;
nplein=nplein+1 nvide :=nvide+1 ;

si consommateur en si producteur en attente alors
attente alors réveiller producteur
reveiller consommateur réveiller producteur
aller a PROD ; Consommer le message ;
aller a CONS ;
Les parties notées entre accolade doivent se dérouler de façon indivisible (elle sont
atomiques). Elles doivent se dérouler ainsi puisqu‟elles comprennent le test et la
modification de variables critiques. Considérons a présent le test sur la
condition « consommateur en attente »dans le processus producteur. On peut remarquer
qu‟en raison du caractère indivisible de la séquence de débit du consommateur ou pour
remplacer la condition « consommateur en attente » par la condition nplein=-1 qui lui est
équivalente (en faite, on compare nplein a 0 puisqu‟on fait nplein :=nplein+1).
Le test et la modification de cette condition se fait comme suit :

. .
. .
. .
nplein : = n plein+1 ; nplein : = n plein -1
si nplein = 0 alors si nplein = -1 alors
réveiller le consommateur attendre ;

. .
. .
. .
Remarquons enfin que les conditions nplein = 0 et nplein = -1 entraînent respectivement
n plein ≤ 0 et npelin < 0. On voit que nplein fonctionne en fait comme un sémaphore avec la
restriction, due à l‟unicité du consommateur, qu‟un processus au plus peut se trouver bloqué
dans sa file. On fait la même remarque que pour le compteur nvide et le producteur. En
utilisant les primitives P(s) et V(s) l‟algorithme des deux processus peut maintenant s‟écrire :
Sémaphore nplein = 0, nvide = 0 ;
PROD : Produit un message ; CONS : P (nplein) ;

P (nvide) ; Prélever un message ;
Déposer le message V (nvide) ;
V (nplein) ; Consommer le message ;
aller à PROD aller à CONS ;
2.4.2.3. Communication par boite aux lettres
La communication ente processus suivant la méthode de la boite aux lettres est une
application directe du modèle du producteur et du consommateur. Nous pouvons remarquer
que, lors du dépôt d‟un message par un producteur, un consommateur quelconque peut se
trouver activer, et pas nécessairement le destinataire prévu ; on voit donc que le dispositif
n‟est efficace que si tous les destinataires sont équivalent (c'est-à-dire s‟il est indifférent pour
accomplir la tâche demandée, d‟activer l‟un quelconque de ces processus). Sinon l‟identité du
destinataire doit faire partie du message ce qui implique un tri à la réception.
La solution généralement retenue consiste donc à prévoir une boite aux lettres par classe de
processus équivalents, évitant ainsi tout tri à la réception.
Prenons comme exemple un système d‟entré/sortie gérant un lecteur de cartes perforées et

deux imprimantes pouvant fonctionner en parallèle. Les opérations possibles sont :
- imprimer le contenu d‟un fichier
- lire des cartes et placer leur contenu dans un fichier.
L‟impression d‟un fichier peut être demandée par un processus quelconque (correspondant à
l‟exécution d‟un programme utilisateur). La lecture de cartes ne peut être demandée que par
une commande introduite à la console de l‟opérateur. Si on veut exploiter complètement le
parallélisme, on prévoira trois processus consommateurs :
- un processus lecteur de cartes
- deux processus chargés de l‟impression (les deux sont équivalents), dans ce sens qu‟il
est indifférent qu‟un fichier soit imprimé sur l‟une ou l‟autre imprimante.
Les demandes d‟entrée/sortie utilisent deux boîtes aux lettres suivant le schéma de la Fig.39.
Ci-dessous.
Les messages transmis dans les boîtes aux lettres contiennent l‟identité du fichier concerné
par l‟entrée/sortie

PRODUCTEURS CONSOMMATEURS
Processus
Imprimante 1
Processus
demandeurs boite aux lettres
d‟impression « impressions »
Processus
Imprimante 2
Boite aux lettres

« lectures »
Processus
Opérateur lectures cartes
Fig.39. Boite aux lettres utilisées pour la lecture de cartes et impression.
Le fonctionnement d‟une boîte aux lettres étant ainsi défini dans son principe, il reste à
examiner les modalités de son implémentation :
- l‟allocation d‟espace pour la (ou les) boîte(s) aux lettres.
- Accès à la boîte aux lettres : celle-ci doit être adressable par tous les processus qui
l‟utilisent.
Cette contrainte est à la source des principaux problèmes d‟implémentation d‟un système de
communication par boîte aux lettres en particulier dans le cas où chaque processus dispose
d‟un espace adressable distant.
2.4.2.4. Différence entre communication par boîte aux lettres et celle basée sur la
communication directe entre les processus
Pour que nous puissions bien saisir cette différence, analysons comment les deux concepts
sont implémentés dans certains systèmes.
Exemple pour la communication directe
Int send_process ( 765, Bonjour) : le processus qui exécute cette primitive envoie le message
« bonjour » au processus ayant pid (numéro d‟identification du processus) égal à 756. Le

message sera copié dans la file de message du récepteur. Tout processus quel qu‟il soit, peut
envoyer un message à tout autre processus. Normalement cette primitive ne se bloque jamais,
car un nombre illimité de messages peut résider dans la file du récepteur. Cette primitive
échoue si le processus de destination n‟existe pas.
Int receive_process (765, mareception) : le processus qui exécute cette primitive reçoit le
message dont le pid (processus d‟identification du processus) est 765 et le placera dans sa file,
mareception. Si au lieu de 765, on aurait mis 0, il recevrait un message de n‟importe quel
processus (on part du principe qu‟aucun processus ne peut avoir le numéro d‟identification 0).
Cette primitive échoue si un processus émetteur est spécifié et n‟existe pas.
Exemple pour la communication du message réalise indirectement par le biais d’une

boîte aux lettres
Int_create_mailbox (boitelettre) : crée une boîte aux lettres appelée boite lettre. Cette
primitive échoue si la boîte aux lettres existe déjà.
Int delete_mailbox (boitelettre) : supprime une boîte aux lettres appelée boite lettre. Cette
primitive échoue si le processus qui émet la primitive n‟est pas propriétaire de la boîte aux
lettres ou si l boîte aux lettres n‟existe pas.
Int_send_mailbox (boitelettre, bonjour) : elle envoie le message « bonjour » dans la boîte aux
lettres dont le nom d‟identification est « boite lettre ». Le message est copié dans la boîte aux
lettres. Tout processus peut envoyer un message à n‟importe quelle boîte aux lettres.
L‟émetteur est bloqué jusqu'à réception du message. Cette primitive va échouer si la boîte aux
lettres n‟existe pas.
Int receive_mailbox (boitelettre.mareception) : reçoit le message en provenance de la boîte

aux lettres dont le nom d‟identification est boite lettre et place ce message dans mareception.
Les messages sont reçus dans l‟ordre de leur envoi. S‟il n‟y a aucun message dans la file, il
restera bloqué jusqu‟à ce qu‟un message soit envoyé. Cette primitive échoue si le processus
qui exécute la primitive n‟a pas de droit sur la boîte aux lettres ou si cette dernière n‟existe
pas.
En analysant les primitives utilisées pour la communication directe entre les processus et
celles utilisées dans la communication via la boîte aux lettres, force est de constater que dans
la communication directe le message qu‟un processus émetteur envoie à un processus
récepteur sera copié dans la file du processus récepteur, alors que celui envoyé via la boîte
aux lettres, sera d‟abord copié dans la boîte aux lettres, avant que le processus réception
puisse en prendre possession.
3 GESTION DE LA MEMOIRE
3.1. Introduction
La mémoire est une ressource importante qui doit être gérée avec prudence. Le moindre
ordinateur domestique a, de nos jours dix fois plus de mémoire que l‟IBM 7094, l‟ordinateur
le plus puissant du début des années soixante. Mais, la nature ayant honneur du vide, la taille
des programmes augmente tout aussi que celle des mémoires.

Le système d‟exploitation doit cohabiter dans la mémoire principale avec un ou plusieurs
processus. La gestion de a mémoire prend en charge l‟allocation de la mémoire aux
processus. Elle doit également protéger la mémoire allouée a chaque processus contre un
accès indésirable d‟autre processus, ainsi que la mémoire allouée au système d‟exploitation
contre des accès non autorises.
La gestion de la mémoire es du ressort du gestionnaire de la mémoire. Ils doit connaître les

parties libres et occupées de la mémoire, allouer de la mémoire processus qui en ont besoin,
récupérer la mémoire par un processus lorsque celui-ci se termine est traiter le va et vient (
swapping) entre le disque et la mémoire principale lorsque cette dernière ne peut pas contenir
les processus.
3.2. La gestion de la mémoire sans va-et-vient ni pagination
Les systèmes de gestion de la mémoire se repartissent en deux grandes catégories :
-les systèmes qui déplacent les processus entre la mémoire et le disque ;

(swapping et pagination)
-les systèmes qui ne déplacent pas les processus entre la mémoire et le disque.
Cette section s‟occupe seulement de ceux qui ne font pas le swapping, ni la pagination. C‟est
ainsi que dans les sous sections qui suivent nous aborderons :
-la monoprogrammation sans va-et-vient ni pagination ;

-la multiprogrammation et l‟utilisation de la mémoire
-multiprogrammation avec des partitions fixes.
3.2.1. Monoprogrammation sans avec – et – vient ni pagination
La gestion de la mémoire la plus simple consiste a avoir un seul processus en mémoire a un

instant donne et lui permettre toute la mémoire disponible. Cette approche ;cette
approche ;courante avant 1960, n‟est plus utilisée de nos jours, parce qu‟elle implique que
chaque processus contiennent les pilotes des périphériques d‟E/S qu‟il utilise. La technique
que l‟on utilise généralement sur les micro-ordinateurs (PC, Personal computer) est donne a la
Fig.40. Ci-dessous, la mémoire est partagée entre le système d‟exploitation et un unique de
processus utilisateur. Nous pouvons avoir les cas des figures suivantes.
-le système d‟exploitation est située au bas de la mémoire vive

(RAM,Random Access Memory)
(être situe en bas, veut dire occuper les adresses les plus basses), cette situation est illustrée
dans la Fig.40.(a) ;
-le système d‟exploitation est situe en motte, au dessous de la mémoire vive, comme le
montre la Fig.40.(b) ;
-le système d‟exploitation au bas de la RAM, les pilotes en ROM (Read Only Memory)dans
la partie haute de la mémoire. Cela est illustre sur la Fig.40.(c). les pilotes étant situe dans un
bloc de 8Ko de l‟espace d‟adressage de 1 Mo. Les programmes en ROM, sont appelés le
BIOS (Basic Input Output système). Cette approche est celle du système d‟exploitation MS-
DOS, qui est un système : mono programme, mono utilisateur.

Sur la Fig.41. Ci-dessous, est illustrée l‟organisation de la mémoire de 1Mo sous MS-DOS,
dans un micro-ordinateur a microprocesseur Intel 8086/88.
Système Pilotes de
D‟exploitation périphérique
ROM en Rom
Programme
Utilisateur Programme
Utilisateur
Système Système
D‟exploitation D‟exploitation
en RAM en RAM
Fig.40(a) Fig.40 (b) Fig.40 (c)
Fig.40. Trois organisations possibles de la mémoire s‟il n‟y a que le système d‟exploitation et
un seul processus utilisateur.
1024 ko Rom Bios
960 ko Pilotes
mémoire réservée
800 ko Video Adaptater
768 ko Pilote
Video Ram
640 ko Processus
Utilisateur
+ Mémoire conventionnelle
Dos
Fig.41. Organisation de la mémoire sous MS-DOS, dans un micro-ordinateur à

microprocesseur I8088/86
Lorsque la mémoire est organisée de cette manière, il ne peut y avoir qu‟un seul processus qui
s‟exécute a une instante donne. L‟utilisateur tape une commande sur son terminale et le
système d‟exploitation change le programme demande en mémoire, puis l‟exécute. Lorsque le
processus se termine, le système d‟exploitation affiche une invite (prompt) sur le terminal et
attend et attend la commande suivante pour changer un nouveau processus qui remplace le
précèdent.

3.2.2. Multiprogrammation et utilisation de la mémoire
Dans un environnement multiprogrammation, le logiciel d‟un ordinateur est organise en un

certain nombre de processus, un processus étant un programme qui s‟exécute qui possède son
compteur ordinal (CO, PC : Program counter), ses registres et ses variables. Conceptuellement
chaque processus a son propre processus virtuel. En réalité, le vrai processus commute entre
plusieurs processus. Mais, pour comprendre le système, il est préférable de penser à un
ensemble de processus qui s‟exécutent en (pseudo) parallélisme plutôt qu‟à allocation du
processeur entre différents processus. Cette commutation rapide est appelée
multiprogrammation, comme nous l‟avions fait dit au début du cours.
Dans ce qui suit, il est présenté :

- la multiprogrammation de quatre programmes dans un ordinateur ; (Fig.42.(a))
- une abstraction de cas précédent où les quatre programmes indépendants qui ont
chacun leur propre contrôle de flux (c'est-à-dire leur compteur ordinal) (Fig. b) ;
- A la Fig.42.(d), on peut constater que sur un intervalle de temps assez grand, tous les
processus ont progressé mais qu‟a un instant donné, il n‟y a qu‟un seul processus actif.
La multiprogrammation sans une gestion de la mémoire sans va-et-vient ni pagination est
utilisée de temps en temps sur des petits ordinateurs, mais plus rarement sur des grands
ordinateurs à plusieurs utilisateurs.
Plusieurs arguments militent en faveur de l‟utilisation de la multiprogrammation :
- facilité le développement du programme en permettant de le diviser en plusieurs
processus.

un seul compteur de commutation 4 compteurs
de processus ordinal ordinaux
A A B C D
C Fig.42.(b)
Fig.42.(a)
Processus
B
A
Temps
(c)
(a) Multiprogrammation de 4 programma
(b) Modèle conceptuel de 4 processus séquentiels indépendants.
(c) un seul programme est actif à un instant donné.
Une de formules fondamentales du génie logiciel (software en informatique engineering)

dit :
C(P) > C(SP1) + C(SP2) + … + C(SPi) + … + C(SPn)
Le coût d‟un programme non modulaire (n‟ayant pas de sous-programmes) est supérieur au
coût du même programme réaliser d‟une manière modulaire.
où,
P : programme réalisé d‟une manière non modulaire
SPi : le ième sous-programme du programme P.
- la multiprogrammation se justifie aussi dans un environnement multi-utilisateur,
« time sharing ».
c‟est ainsi qu‟il faut avoir plus d‟un processus en mémoire à la fois.

Beaucoup de processus passent la plus grande partie de leurs temps à attendre des E/S sur
disque. En effet, il arrive fréquemment qu‟un effectue une boucle pour lire les donnes d‟un
fichier qu‟il traite ensuite. Dans un système mono programmé, si la lecture des données des
E/S (Entrée/Sortie) requis 40 ms et le traitement 10 ms le processeur resterait libre pendant
80% du temps. C‟est pourquoi, en introduisant la multiprogrammation, on éviterait à ce que le
processeur reste en « chômage » pendant ce 80% du temps. Donc, la multiprogrammation
permet d‟améliorer le taux d‟utilisation du processeur.
3.2.3. Multiprogrammation avec partition fixes
La méthode la plus simple de la multiprogrammation est de réaliser la

multiprogrammation « sans va-et-vient ni pagination » en utilisant des partitions fixes. Elle
consiste à diviser la mémoire en n partitions (éventuellement de tailles inégales). Ce
partitionnement peut, par exemple, être fait par l‟opérateur au démarrage du système.
Chaque nouvelle tâche est placée dans la file d‟attente de la plus petite partition qui peut la
contenir. La Fig43.(a) ci-dessous présente ce système à partitions fixes et à files multiple
Partition 4 Partition 4
700 k
File d‟entrée
400 k unique
125 k
100 k
Système Système
D‟exploitation d‟exploitation
o
(a) (b)
Fig.43.(a) Des partitions mémoires de taille fixe à files multiples

(b) Des partitions mémoires de taille fixe à une seule file
Trier les tâches en fonction de leurs tailles dans des files multiples présente un inconvénient
majeur, lorsque la file des grandes partitions est vide et celle des petites pleine, comme c‟est
le cas dans la Fig.43. Une alternative consiste a utiliser ne fie comme celle de la Fig(b). Des
qu‟une partition se libère, on y place la première une seule file d‟attente qui peut y tenir et on
exécute. Comme il n‟est pas intéressant d‟allouer une grande partition a une petite tache, on
peut aussi parcourir la file d‟attente et choisir la plus grande tache que peut contenir la
partition. Cette stratégie désavantage les taches de petites tailles alors qu‟il faudrait
théoriquement les traiter en priorité.

Ce système, a partitions fixes déterminées par l‟opérateur au démarrage a été utilise par le
OS/360 des grands ordinateurs IBM pendant de nombreuses années. Il s‟appelait MFT
(Multiprogramming with a Fixed number of tasks)ou OS/MFT.
3.3. Gestion de la mémoire avec va-et-vient
3.3. 1. Introduction
L‟organisation de la mémoire en partition fines est une méthode adoptée avec systèmes a
traitement par lots. Avec le système en temps partages, la situation est différente : la mémoire
ne pouvant pas contenir les processus de tout les utilisateur, il faut placer quelques processus
sur le disque, qu‟il faudrait bien sur, ramener en mémoire principale avant de les exécuter.
Les mouvements de processus entre la mémoire principale et le disque est appeler va-et-vient
(swapping)
Ainsi, dans ce qui suit nous allons voir quelques méthodes de gestion de mémoire avec les
quatre swapping :
-multiprogrammation avec partitions variables ;
-gestion de la mémoire par tables de bits ;
3.3. 2. Multiprogrammation avec partitions variables

En principe, on peut utiliser des partitions fixes pour les va-et-vient lorsqu‟un processus se
bloque, on le déplace sur le disque et on le remplace par une autre. En pratique, les partitions
fixes ne ont pas très intéressantes lorsque la mémoire est très limitée, car on perd beaucoup de
place a cause des programmes qui sont plus petits les partitions. Il faut utiliser une autre
méthode : les partitions variables.
Avec les partitions variables, le nombre et la taille des processus en mémoire varient au cours
du temps. La Fig.44. illustre le fonctionnement des partitions variables.
Au départ, un seul processus A, se trouve en mémoire (Fig.44a). Les processus B et C sont
crées ou charge à partir disque. A la Fig.44d, A se termine ou est déplace sur le disque. Puis
d‟arriver et B s‟en va. Enfin E est charge en mémoire (Fig.44g).
La différence fondamentales entre la position et les partitions fixes (Fig.43) et les partition
variables (Fig.44) est que le nombre, la taille de ces dernières varie dynamiquement au fur et
a mesure que les processus entrent ou sortent sont de la mémoire. On n‟est plus limite par un
nombre fixe de partition ou par le ait que les partitions sont très grandes ou trop petites. Cette
souplesse accrue améliore l‟usage de la mémoire mais complique son allocation et sa
libération

C C
B B B
A A A
Système Système Système Système

Exploitation Exploitation Exploitation Exploitation
(a) (b) (c) (d)
C C C
B
E
D D D
Système Système Système

Exploitation Exploitation Exploitation
(e) (f) (g)
Fig.44. l‟allocation de la mémoire varie en fonction de l‟arrivée et du départ des processus de

la mémoire principale les régions grisées représentent des espaces mémoire inutilisés.
Une fois les processus crées et détermines, l‟utilisation de la mémoire évolue et devient une
alternance de sections d‟espace alloues et non alloues, tel un damier, tel que vous pouvez le
constater sur la Fig.….ci-dessous. Par conséquent bien qu‟il ait peut être plus des mémoires
non allouée que la taille d‟un processus en attente, la mémoire n‟est peut être utilisée pour ce
processus, car elle est dispensée dans un grand nombre de trois zones de mémoire, libre
(memory holes) cet espace qui n‟est pas alloue a aucune partition est appelée fragmentation
externe.
Pour gagner l‟espace inutilisé, on peut réunir les espaces inutilisés en une partition de grande
de grande taille en déplaçant tout les processus vers le bas de la mémoire. Il s‟agit du
compactage de la mémoire. Cette technique n‟est généralement pas utilisée, car elle requiet
beaucoup de temps processeur. Par exemple il faut une seconde pour compacter la mémoire
d‟un micro-ordinateur de 1 Mo qui peut copier un octet par micro seconde (1 Megaoctet/s).

cette technique est en revanche, utilisée sur les grands ordinateur CDC cyber car ils possèdent
des circuits spécialises qui compactent la mémoire a la vitesse de 40 Megaoctet/s.
3.3. 3. Gestion de la mémoire par table de bits

La mémoire est divisée en unité d‟allocation dont la taille peut varier de quelques mot a
plusieurs kilooctets.
A chaque unité, on fait correspondre un bit dans la table de bits qui est :
-„0‟, si l‟unité est libre ;

-„1‟si elle est occupée
( ou vice versa, selon ; la convention adoptée)
Sur Fig45…ci-dessous est présente une partie de la mémoire et la table de bits

correspondantes
A B C D E
8 17 24
(a)
11111000
11111111
11001111
11110000
(b)
P 0 5 H 5 3 P 8 6 P 14 3
4 17 6 P 23 3 H 26 4
Zone debout longueur Processus Hachuree

Libre
(on trou) 18
(C)
Fig.45 une partie e la mémoire occupée par cinq processus et rois zones libres les tirets
matérialisent l‟unité d‟allocation de la mémoire. Les régions hachurées (0 dans la table de
bit) seront libres représentent les zones libres

b) sur a Fig. 45b est illustrée la table de bits indiquant les zones occupées et non occupes de la
mémoire.
Quant a la Fig.44(c) ,elle montre la manière de représenter la même information en liste
chaînée.
H : zone hachurée, non utilisée par un processus
P : zone utilisée par le processus
Il convient de noter que la taille de l‟unité d‟allocation joue un rôle important. Néanmoins,
même si elle ne fait que n octets, il faut 1 bit de la taille de bits pour représenter 32 bits de la
mémoire. Une mémoire de 32 n bits va nécessiter une table de bits de n bits. Donc dans ce cas
la table de bits occupe 3% de la mémoire.
La table de bits permet donc de mémoriser l‟occupation de la mémoire dans un espace
mémoire de taille fixe car la taille „une table de bits ne dépend que de la taille de l‟unité
d‟allocation. Le seul problème survient lorsqu‟on doit ramener en mémoire un processus de k
unités. Le gestionnaire de mémoire doit alors parcourir la table de bits à la recherche de k
zéros consécutifs. Cette recherche est lente ce qui fait qu‟en pratique on utilise rarement les
tâches de bits.
3.3. 4. Gestion de la mémoire par liste chaînée

Une autre méthode pour mémoriser l‟occupation de la mémoire consiste à gérer une liste
chaînée des segments libres et occupés, un segment étant un processus ou un espace libre
entre deux processus. La Fig.45(c) présente la mémoire de Fig. 44a sous forme d‟une liste
chaînée à chaque entrée de la liste spécialisé : une zone libre (H ou hole en anglais) ou un
processus (P), son adresse de départ, sa longueur et un pointeur sur l‟entrée suivante.
liste Dans cet exemple, la liste des segments est triée sur les adresses. Ce tri permet de mettre
la à jour facilement lorsqu‟un processus se termine ou est déplacé sur le disque. Un processus
normalement deux voisins (sauf s‟il se trouve en haut ou bas de la mémoire). Ces derniers
sont des processus soit des zones libres, ce qui donne les combinaisons de la Fig.46 :
- A la Fig.46 (a), il suffit de remplacer P par H ;
- Au Fig.46 (b), Fig.46 (c) ; il faut réunir deux entrées en une seule de plus grande taille,
ce qui réduit la liste d‟une entrée ;
- A la Fig.46 (d), les trois entrées ne forment plus qu‟une.
Quand on mémorise les processus et les zones libres dans une liste triée en fonction des
adresse, on peut utiliser plusieurs algorithmes pour allouer de la mémoire aux nombreux
processus où aux processus ramener en mémoire principale.
On suppose que la gestionnaire de la mémoire connaît la taille de la mémoire à allouer.
Les algorithmes qui peuvent être utilisés sont :
- l‟algorithme de la première zone libre (first fit) ;
- l‟algorithme de la zone libre suivante ;
- l‟algorithme du plus grand résidus avant la fin X.

a) A X B devient A B
b) A X devient A
c) X B devient B
d) X devient
Fig.46 quatre combinaisons des voisins possibles d‟un processus qui se termine.
L’algorithme de la première zone libre (first fit) :
Le gestionnaire de la mémoire parcours la liste chaînée de segments à la recherche de la

première zone libre qui peut contenir le processus. Cette zone est alors scinde en deux
parties :
La première partie contient le processus, et la deuxième, l‟espace mémoire inutilisé (sauf si le
processus a exactement la même taille que la zone). Cet algorithme est rapide puisqu‟il y a
très peu de recherche.
L’algorithme de la zone libre suivante (next fit) :
Cet algorithme est une légère variante de l‟algorithme précédent. Sa stratégie est identique au
précédent mais il mémorise en plus la position de l‟espace libre trouvé. La recherche
commencera a partir de cette position et non a partir du début.
L’algorithme du meilleur ajustement
Il consiste a rechercher dans la liste la plus petite zone libre qui convient. On évite ainsi de
fractionner une grande zone dont on pourrait avoir besoin ultérieurement.
L’algorithme du plus grand résidu (worst fit) :
Il consiste a toujours prendre la plus grande zone libre disponible pour que la zone libre
restante soit la plus grande possible. La simulation a montré que cette stratégie ne donne pas
des bons résultats.

3.4. La mémoire virtuelle
3.4.1. Introduction
L‟idée de base de la mémoire virtuelle est que la taille du programme, des données et de la
pile peut dépasser la mémoire interne disponible. Le système d‟exploitation garde en mémoire
les parties du programme qui sont utilisées et stocke le reste sur le disque. Par exemple, on
peut exécuter un programme de 1M sur une machines de 256 koctets en choisissant
judicieusement les 256 koctets du programme à mettre en mémoire principale à tout instant.
Les autre parties vont faire des vas – et – vient entre le disque et la mémoire.
La mémoire virtuelle peut aussi être utilisée sur un système multiprogrammé. On peut, par
exemple, allouer des partitions de 256 Ko à 8 programmes de 1M sur un système qui a 2M de
mémoire. Chaque programme se déroule comme s‟il avait sa propre machine de 256 ko. La
mémoire virtuelle et la multiprogrammation se complètent très bien.
Dans l‟explication ci-dessus, la capacité de la mémoire se référer à la partie de la mémoire
utilisée par le programme/application utilisateur ; on a fait fi de celle occupée par le système
d‟exploitation.
3.4.2. La pagination
La plupart des systèmes à mémoire virtuelle ont recours à la pagination. Sur tout ordinateur,
les programmes peuvent générer un certain nombre d‟adresses. Quand un programme effectue
une instruction comme MOVE REG, 1000, il copie le registre REG. Ces adresses manipulées
par les programmes sont appelées des adresses virtuelles et constituent l‟espace d‟adressage
virtuel. Sur les ordinateurs sans mémoire virtuelle, les adresses sont directement placées sur le
bus le bus d‟adresse de la mémoire et provoque la lecture ou l‟écriture du mot à l‟adresse
spécifiée. Lorsque l‟adresse mémoire virtuelle est utilisée, les adresses virtuelles ne sont pas
directement placées sur le bus d‟adresse de la mémoire. Elles sont envoyées à l‟unité de
gestion de la mémoire ou MMU (Memory Management Unit), composant qui traduit les
adresses virtuelles en adresses physiques, comme le montre la Fig.47
La fig. donne un exemple de cette conversion. L‟ordinateur de cet exemple peut générer des
adresses sur 16 bits de 0 à 64 koctets, mais on ne peut pas les changer entièrement en
mémoire. Une image mémoire de tout le programme (donc de moins de 64 koctets) doit alors
être stockée sur disque de telle sorte qu‟on puisse en placer, au besoin, différentes parties dans
la mémoire principal. L‟espace d‟adressage virtuel est divisée en petites unités appelées des
pages. Les unités correspondantes de la mémoire physique sont les cases mémoires (pages
frames). Les pages et les cases sont toujours de la même taille. Dans notre exemple, elles font
4 koctets mais on rencontre fréquemment des tailles de 512 octets,et 2 octets. Avec 64 koctets
de mémoire virtuelle 32 koctets de mémoire physique, on a 16 pages virtuelles et 8 cases. Le
transfert entre la mémoire et le disque se fait toujours par pages entières. Quand un
programme essaie de lire l‟adresse O, par exemple au moyen de l‟instruction MOV REG, O,
l‟adresse virtuelle O est envoyée au MMU. Ce dernier constate que cette adresse virtuelle se
situe a la page 0 (adresse 0 a 4095) qui appartient a la case 2(8192 a 12384). Elle reçoit tout
simplement une demande de lecture de l‟adresse 8192. Le MM a donc nappe les adresses
virtuelles comprises entre 0 et 4096 sur les adresses physiques 8192 a 12387.
De même, l‟instruction MOVE REG, 8192 est transformée en MOVE REG 24576
Parce que l‟autre adresse virtuelle 8192 est situe dans la page virtuelle 2 et que cette page est
mappée a la a la case physique 6 adresses physiques 42576 a 28671). L‟adresse virtuelle

21500 est située 20 octets après le début de la page virtuelle 5 (adresses virtuelles 20480 a
24575) et correspond a l‟adresse physique 12288+20= 12308.
Ce passage au moyen du MMU des 16 pages virtuelles sur n‟importe laquelle de 8 cases ne
résout pas le problème soulevé par le fait que l‟espace de l‟adresse virtuelle est plus grande
que la mémoire que la mémoire physique. Comme on a 8 cases physiques de la fig.47
Les autres pages signaler par « X » sur la figure, ne sont pas mappées. Le matériel mémorise
dans un bit de présence si une page est mappée ou non.
Espace des
adresses
virtuelles Adresse
mémoire
0-4K 2
physique
4K-8K 1
0-4K
6
8K-12K 4K-8K
12K-16K 0
4 8K-12K
16K-20K 12K-16K
3
16K-20K
20K-24K x
24K-28K
20K-24K
28K-32K x
x 24K-28K
32K-36K 28-K-32K
5
36K-40K
x
40K-44K 7
44K-48K
48K-52K x
Case physique
x
52K-56K
56K-60K
x
56K-64K x
Page virtuelle
Fig.47. table des pages faisant la relation entre les adresses virtuelles et celles physique.
Que se passe-t-il si le programme tente d‟utiliser une page non mappée, par exemple en
effectuant MOV REG, 32780 ?
(cette adresse se situe a 12 octets après le début de la page 8 qui commence a l‟adresse
32768. le MMU constate que cette page n‟est pas mappée et provoque un déroulement (trap) :
le processeur est restituer au système d‟exploitation.
Ce déroulement est appelé un défaut de page(page fault).

Le système d‟exploitation repère une case peu utilise et recopie son contenu sur le disque.
Il place ensuite la case qui vient d‟être libère, modifie la mappée, et re-exécute l‟instruction
déroulée. Si le système d‟exploitation choisit de déplacer la case1, il charge la page virtuelle a
8 a l‟adresse physique 4K et effectue deux changements dans la mappe du MMU. Il
commence par indiquer que la page virtuelle 1 n‟est pas mappée afin de pouvoir dérouter les

prochains accès aux adresses comprises entre 4 K et 8 K. puisqu‟il remplace le « X » de la
page virtuelle 8 par 1 pour mapper l‟adresse virtuelle 32780 sur l‟adresse physique 4108,
lorsque l‟instruction déroutée sera re-exécutée
Fonctionnement interne de l’unité de gestion de la mémoire MMU (Memory

Management Unit)
Le rôle d‟un MMU est de mapper une adresse virtuelle en adresse physique, grâce à la table
de pages. Examinons a présent le fonctionnement interne du MMU et la raison pour laquelle
nous avons choisit des tailles de pages qui sont puissances de 2.
La figure…donne une adresse virtuelle 8196 (0010000000000100 en binaire), qui est mappée
grâce à la table des pages de la Fig.48.
L‟adresse reçue de 16 bits est subdivisée en deux parties :
- un numéro de page de 4 bis ;
- un déplacement dans cette page de 12 bits.
Les 4 bits du numéro de page permettent d‟avoir 16 pages et les 12 bits du déplacement
permettent d‟adresser 4096 octets d‟une page
Le numéro de page sert d‟index dans la table des pages et donne la case qui correspond à cette
page virtuelle. Si le bit de présence est à 0, il se produit un déroutement s‟il est à 1, on copie
le de la case dans les 3 bits du poids fort du registre de sortie. On copie aussi les 12 bits du
déplacement fournis par l‟adresse virtuelle. se registre de sortie (qui contient l‟adresse
physique) est ensuite le placer sur le bus de la mémoire.
0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 adresse
Virtuelle
En entrée
La page virtuelle 2 (8 196)
sert d‟index dans la table
des pages.
0 010 1 Bit de référence

1 001 1
2 110 1 110
3 000 1
4 100 1
5 011 1
6 000 0 Déplacement de 12 bits
Table 7 000 0 recopié directement
En 8 000 0 de l‟entrée à la sortie
Pages 9 101 1
10 000 0
11 111 1
12 000 0
13 000 0
14 000 0
15 000 0
16 000 0
Adresse
Physique
1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 en sortie
Fig.48 le fonctionnement interne d‟un MMU qui a 16 pages de 4 koctets.

Les algorithmes de remplacement de page
A la suite d‟un défaut de page (on se réfère à une page ne se trouvant pas dans la mémoire
physique), le système d‟exploitation doit retirer une page de la mémoire pour libérer de la
place pour la page manquante. Si la page à retirer a été modifiée depuis son changement en
mémoire, il faut la récrire sur le disque. Sinon le disque est déjà à jour. La page lue remplace
simplement la page supprimer.
Si on choisit de retirer la page peu utilisée, cela peut sensiblement améliorer les performances
du système.
Dans ce qui, sont présentés les algorithmes suivants de remplacement de page :
- le remplacement de page optimal.
- Remplacement de la page premier entré, première sortie FIFO
- Remplacement de la page la moins utilisée.
Le remplacement de page optimal
Cet algorithme est facile à décrire, mais presque impossible à mettre en œuvre. Au moment du
défaut de page, il existe en mémoire un certain nombre de pages. Une de ces pages risque
d‟être référence très vite, d‟autres ne seront référencées que dans 10, 100 ou 1000
instructions. On peut numéroter chaque page avec le nombre d‟instructions qui seront
exécutées avant qu‟elle ne soit référencée.
L‟algorithme de copie de page optimal consiste à retirer la page qui porte le plus haut
numéro. Si une page n‟est adresse qui dans 8 millions d‟instructions, et une autre dans 6
milliards d‟instructions il vaut mieux retirer la première car on repousse ainsi le défaut de
page suivant le plus tard possible.
Malheureusement cet algorithme est irréalisable, car le système d‟exploitation ne peut pas
connaître d‟avance le moment où les différents pages seront référencés.
Remplacement de page premier entré premier entré, première sortie, FIFO
Le système d‟exploitation mémorise une liste de toutes les pages en mémoire, la première
page de cette liste, la plus ancienne et la dernière la plus récente. Lorsqu‟il se produit un
défaut de page, on retire la première page de la liste et on place la nouvelle page à la fin de
cette liste.
Remplacement de la page la moins récemment utilisée
Une bonne approximation de l‟algorithme optimal se fonde sur l‟observation suivante :

- les pages les plus référencées au cours des derniers instants seront probablement
utilisées au cours des prochaines instructions. De même, les pages qui n‟ont pas été
référencées pendant un long moment ne seront probablement utilisées pendant un
certain temps. l‟algorithme consiste a supprimer et a favoriser celles qui ont été
références au cours de derniers instants
Ainsi, la page qui est resté inutilisé pendant longtemps. Cette stratégie est celle de la page la
moins récemment utilisée (LRU : Least Recently Used)


Systemexpolt 23decok PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Systemexpolt 23decok PDF

Transféré par

Droits d'auteur :

Formats disponibles

1.

1.2 STRUCTURE INTERNE D’UN ORDINATEUR

1.2.2.Histoire de l’ordinateur et du système d’exploitation

L‟histoire de l‟ordinateur est fortement liée a l‟évolution technologique et celle du système du

-Machine a calculer a engrenages mécaniques ;

@ kasengedia motumbe pierre 1

MODELE VON NEUMAN

Fig1. Modèle VON NEUMAN

Unité de commande + ALU + registres = processeur

1.2.3. Système a microprocesseur

On relie le microprocesseur aux différents équipements d‟entrée-sortie (Keyboard, écran,

@ kasengedia motumbe pierre 2

Fig.2. Principe d‟interconnexion d‟un microprocesseur aux différents équipements

Structure interne d‟un microprocesseur hypothétique

@ kasengedia motumbe pierre 3

Fig.4. Equivalence entre la logique câble et celle microprogrammée

Pour réaliser le tableau de microprogrammation du circuit logique Fig.4.(a), On assembles les

@ kasengedia motumbe pierre 4

Fig.5. Equivalence entre la logique câblee

1. 2. 3.2. Les opérations d’entrée /sorties

Opérations permettant au processeur central de communiquer avec l‟extérieur, avec les

- Interrogative par méthode (polling ;

Méthode interrogative Polling (Fig.6)

Le polling est une méthode par laquelle le master (microprocesseur) interroge

@ kasengedia motumbe pierre 5

Fig.6. Méthode interrogative (polling)

Methode par interruption (Fig.7)

Le polling a un inconvénient majeur dans le sens qu‟il mobilise beaucoup de temps du

Fig.7. Opération entrée/sortie moyennant un PIC (programmable interrupt controller)

@ kasengedia motumbe pierre 6

Sur la Fig.8. est illustre un système a microprocesseur utilisant le DMA

BUSREQ bus contrôle

b) Canaux d’entrée/sortie (Fig.9)

@ kasengedia motumbe pierre 7

Canal E/S Canal E/S

Fig.9. Canaux d‟entrées /sorties, processeur spécialises pour les entrées/sorties.

@ kasengedia motumbe pierre 8

Exemple d‟organisation en couches le modèle OSI :

Machine virtuelle. Mn Programme en langage Ln traduits

Programme L3traduit et interprété

Machine virtuelle. M2 Programme L2 traduits et

Machine réelle M1 Les programmes en L1sont

Fig.10.(a) ; Organisation en couche d‟un ordinateur

@ kasengedia motumbe pierre 9

Fig.10.(b). Organisation en couches d‟un ordinateur

1.4. FONCTIONS DE BASE D’UN SYSTEME D’EXPLOITATION

les fonctions de base d‟un système d‟exploitation sont, la gestion :

Un système d‟exploitation est un ensemble de programmes qui constitue une machine

1.4.2. Types de système d’exploitation

Les systèmes d‟exploitation peuvent se différencier fondamentalement selon :

@ kasengedia motumbe pierre 10

1.4.2. 1. Systèmes d’exploitation temps réels

Généralement utilisée dans la commande de processus industriels (robot industriel)

Fig.11 .Décomposition structure simplifiée par exemple un robot industriel. Un robot

@ kasengedia motumbe pierre 11

Un robot avec minimum 3 grades de libertés

Modèle des taches dans un système multitâches monoprocesseurs

Carte contrôleur robot

Fig.13. Un robot industriel contrôle par un calculateur.

Une tache est un programme ou une parie de programme en exécution conceptuellement,

@ kasengedia motumbe pierre 12

TACHE A TACHE B TACHE C

DONNEES DONNEES DONNEES