Page 1 sur 270

AVANT PROPOS

Ce syllabus a été conçu pour les étudiants du niveau MASTER de la faculté des
Sciences Informatiques de l’Université Catholique du Congo (UCC).

L'esprit de ce cours présente une indépendance aux implémentations tant hardware

que software des systèmes existants dans l’environnement professionnel. Nous ne
cherchons pas à apprendre aux apprenants à utiliser les systemes d’exploitation,
mais les amèner à être capable d’abord de comprendre les fonctions de base d’un
système d’explotation quelle que soit son domaine d’application (bureautique,
industriel,…) :

- Gestion de processus;
- Gestion de la mémoire ;
- Gestion du système de fichiers ;
- Gestion des entrées/sorties .
Afin que l’apprenant ne puisse pas nager dans l’abstraction, dans le cadre des
travaux pratiques, nous avions choisi de travailler avec un système d’exploitation du
monde des logiciels ouverts, LINUX, qui va aussi permettre à l’apprenant de vérifier,
de vivre les fonctions de base susmentionnées. Contrairement à des systèmes
d’explotation très vendus comme Windows, dont les composants architecturaux sont
des boîtes noires, pour les utilisateurs, avec LINUX, les apprenants sont capables
d’obtenir le code source de différents composants, de les modifier, voire de les
enrichir. C’est vraiment un système qui peut aider à comprendre non seulement le
«comment «, mais aussi le «pourquoi«. Il est par excellence un Système
d’explotation du milieu academique.

A la fin de ce cours l’apprenant aura :

© Kasengedia motumbe pierre 1

 Page 2 sur 270

- beaucoup de facilité pour aborder, exploiter n’importe quel système

d’exploitation ;
- de facilité pour ecrire des scrits, s’initier à programmation systèmes sous
LINUX (la majorité de serveurs fonctionnant sur Internet sont de la famille
POSIX, UNIX, LINUX,.. ) ;
- Pourrait être facilement initiè pour concevoir, des modules à integrer dans
un système d’exploitation.
Enfin c’est un cours pilier de la formation d’un informaticien, qui va lui permettre de
comprendre d’autres domaines tels que la programmation parallèle, l’informatique
temps réel,…

Je tiens à remercier tous ceux qui ont apporter leur pierre pour l’élaboration de ce
syllabus, particulièrement mes eminents Assistants de la mention Math – Statistiques
– Informatique, de la faculté des Sciences et Technologies de l’UNIKIN : Doctorand
Kaningine Neto Junior, Doctorand Amisi Fataki Clement , Master CMayombo
Jacques.

Ce syllabus est une version draft d’un livre que je suis en train d’écrire sur «les
bases conceptuelles d’un système d’exploitatiion d’ordinateurs ». Je vous serais très
reconnaissant pour toute critique, remarque, obsevation que vous pourriez formuler
pour l’enrichir.

Pour rappel : Ce support de cours a pour seule vocation d’être utilisé par les
étudiants dans le cadre de leurs cursus au sein de l’UCC. Aucun autre usage ni
diffusion ne pourrait être faits, sans l’autorisation de l’auteur.

© Kasengedia motumbe pierre 2

 Page 3 sur 270

TABLE DES MATIÈRES

AVANT PROPOS......................................................................................................... i
PREMIÈRE PARTIE : LES CONCEPTS
FONDAMENTAUX ......................................vi

CHAP.1. CONCEPTS GENERAUX ............................................................................1

1.1 DEFINITION ...................................................................................................... 1
1.2 STRUCTURE INTERNE D‟UN ORDINATEUR ................................................. 1
1.2.1. Introduction................................................................................................. 1
1.2.2. Histoire de l‟ordinateur et du système
d‟exploitation...................................1
1.2.3. Système à microprocesseur ......................................................................
2
1.2.3.1. Microprocesseurs .................................................................................
2 1.2.3.2. Les opérations d‟entrée
/sorties ..............................................................5
1.3. ORGANISATION EN COUCHES ET SYSTEMES D‟EXPLOITATION ............10
1.4. FONCTIONS DE BASE D‟UN SYSTEME D‟EXPLOITATION ......................... 11
I. 4.1. Définition formelle .....................................................................................
10
1.4.2. Types de système d‟exploitation ..............................................................
11
1.4.2. 1. Systèmes d‟exploitation temps réels ...................................................
11
1.4.2. 2. Traitement par lot ..................................................................................
15
1.4.2. 3. Système monolithique ..........................................................................
16

© Kasengedia motumbe pierre 3

 Page 4 sur 270

I. 5. 3 Systèmes en multi programmation............................................................

17
1.4.2. 4. Systèmes temps partagés (time sharing systems) ...............................
17
1.4.2. 5. Système multi utilisateurs „time – sharing‟ ...........................................
18
1.4.2. 6. Le modèle client-serveur ..................................................................... 19

CHAP.2. GESTION DE PROCESSUS .....................................................................

20
2.1. INTRODUCTION l’ORDONNANCEMENT DES PROCESSUS…………………20
2.1.1. Le concept de processus .......................................................................... 20
2.1.2. Hiérarchie de processus ........................................................................... 20
2.1.3. Etats de processus ................................................................................... 21
2.1.4. Ordonnancement des processus ............................................................. 22
2.1.4. 1. Introduction .......................................................................................... 22
2.1.4. 2. Critères de qualité d‟un algorithme d‟ordonnancement.........................
23
2.1.4. 3. Stratégie d‟ordonnancement sans recyclage des travaux ....................
23 a. File d‟attente simple
(FIFO) ........................................................................... 23
b. File d‟attente ordonnée suivant le temps estimé d‟exécution..........................
24
Conclusion : ....................................................................................................... 24
2.1.4. 4. Stratégie d‟ordonnancement avec recyclage des travaux ....................
25
Choix du quantum : ............................................................................................
25
Ordonnancement par priorité.............................................................................. 27
Réalisation d‟un ordonnancement à priorité ......................................................
28

© Kasengedia motumbe pierre 4

 Page 5 sur 270

2. 1. 3. 5 Ordonnancement par priorité avec files multiples ................................

28
Principes : .......................................................................................................... 28
2.2. EXCLUSION MUTUELLE ................................................................................. 30
2.2.1. Analyse approfondie du problème ………………........................................ 30
2.2.2. Attente active ........................................................................................ 34
2.2.3. Attente active par masquage des interruptions ...............................................36

2.2.4.Les verrous................................................................. 36
2.2.5. Les sémaphores .......................................................................................
37
2.2.5.1. Définition de sémaphores ......................................................................
37 2.2.5.2. Propretés de sémaphores .....................................................................
39 2.2.5.4. Sémaphores d‟exclusion mutuelle ........................................................
40
2.3. RESEAU DE PETRI (MODELISATION DES PROCESSUS)……………… .......
41
2.3.1. Introduction ...........................................................................................41
2.3.2. Discussion informelle .......................................................................... 41
2.3.3. Définition formelle ............................................................................... 44
2.4. MECANISME DE SYNCHRONISATION ........……………............................. 45
2.4.1. Introduction .......................................................................................... 45
2.4. 2. Mécanisme d‟action directe ...................................................................
45
2.4. 3. Mécanisme d‟action indirecte ................................................................
46
2.4.3.1. Synchronisation par évènements .....................................................
46 a) Evènement mémorisé ........................................................................................
46

© Kasengedia motumbe pierre 5

 Page 6 sur 270

b) Evènement non mémorisé ............................................................................ 47

c) Extension de la notion d‟événement ............................................................ 47
2.4.3.2. Synchronisation par sémaphores ................................................... 47
2.4.3.3. Modélisation de synchronisation et de la communication entre
processus par réseau de Pétri ............................................................................
48
2.4.3.4. Programmation de la synchronisation et communication entre
processus (source) et processus destination. ................................................... 51
2.5. COMMUNICATION ENTRE PROCESSUS ...................................................... 52
2.5.1 Introduction ............................................................................................... 52
2.5.2. Quelques types de communication entre processus par variable
commune .......... 54
2.5.2.1. Communication entre processus par variables communes ................
54
2.5.2.2. Le modèle du producteur et du consommateur ..................................
54
2.5.2.3. Communication par boite aux lettres...................................................
56 2.5.2.4. Différence entre communication par boîte aux lettres et
celle basée sur la
communication directe entre les processus ...................................................... 58

CHAP. 3. GESTION DE LA MEMOIRE .....................................................................

59
3.1. INTRODUCTION ...........................................................................................
59
3.2. LA GESTION DE LA MÉMOIRE SANS VA-ET-VIENT NI PAGINATION ......59
3.2.1. Monoprogrammation sans avec et vient ni pagination ……......................
59
3.2.2. Multiprogrammation et utilisation de la mémoire ..................................... 61
3.2.3. Multiprogrammation avec partition fixes ................................................. 63
3.3. GESTION DE LA MÉMOIRE AVEC VA-ET-VIENT ........................................64

© Kasengedia motumbe pierre 6

 Page 7 sur 270

3.3.1. Introduction ........................................................................................... 64

3.3.2. Multiprogrammation avec partitions variables .......................................
64
3.3.3. Gestion de la mémoire par table de bits ..................................................... 66
3.3.4. Gestion de la mémoire par liste chaînée .....................................................
67
L‟algorithme de la zone libre suivante (next fit) : ............................................... 68
L‟algorithme du meilleur ajustement ..................................................................
68
L‟algorithme du plus grand résidu (worst fit) : .....................................................
68 3.4. La mémoire virtuelle ....................................................................................
69 3.4.1.
Introduction ............................................................................................. 69
3.4.2. La pagination ........................................................................................... 69
Fonctionnement interne de l‟unité de gestion de la mémoire MMU (Memory
Management Unit) ............................................................................................ 70
Les algorithmes de remplacement de page....................................................... 72
Le remplacement de page optimal .................................................................... 72
Remplacement de page premier entré premier entré, première sortie, FIFO ....
72
Remplacement de la page la moins récemment utilisée ................................... 72

CHAP.4. GESTION DE SYSTEMES DE FICHIERS .................................................

73
4.1. DISQUE MAGNÉTIQUE ............................................................................... 73
4.1.1. Description d‟un disque magnétique ........................................................ 73
4.1.2. Noms de fichiers............................................................................. 75
partienom.extension ................................................................................ 75
Fichier de sauvegarde .............................................................................. 76
Fichier.html ............................................................................................... 76

© Kasengedia motumbe pierre 7

 Page 8 sur 270

Fichier contenant page web ............................................................................. 76

Fichier.pdf .......................................................................................................... 76
4.2. STRUCTURE DE FICHIERS ........................................................................ 77
Suite d‟octets sans structure .....................................................................................
77
Suite d‟enregistrements de longueur fixe ……….......................................................
77
Fichier en arbre d‟enregistrements .......................................................................... 78
4.3. CLASSIFICATION DE FICHIERS……………………………… .................... 78
4.3.1. Les fichiers ordinaires (« regular files ») ..........................................................78
Fichiers ASCII .................................................................................................... 79
Fichiers binaires ................................................................................................ 79
4.3.2. Les répertoires (« directories »)....................................................................... 80
Chemin d‟accès absolu ......................................................................................... 82
Chemin d‟accès relatif .......................................................................................... 83
Les opérations sur les répertoires ..........................................................................
83
4.3.3. Les fichiers spéciaux caractère (« character special files ») ...........................
84
4.3.4. Les fichiers spéciaux bloc (« block spécial files ») ...........................................
84
4.4. ACCES ET ORGANISATION BASIQUE DES SYSTEMES DE FICHIERS .......
84
Fichier à accès séquentiel ..................................................................................
84
Fichier indexé………………………………………………………………………… 85
Fichier séquentiel indexé ................................................................................... 85
Fichier à accès direct (fichier hashé) ................................................................. 87
Analyse comparative de différentes organisations des fichiers...........................
88

© Kasengedia motumbe pierre 8

 Page 9 sur 270

CHAP 5. LES OPÉRATION D‟ENTRÉES SORTIES ................................................

89
5.1. GESTION DES PÉRIPHÉRIQUES .................................................................
89
5.1.1. Comment le système d‟exploitation interagit avec les périphériques ........
89
5.1.2. Principe pour connecter un périphérique à un système à
microprocesseur.. ………89
5.1.3. Interfaces standard .................................................................................. 90
5.1.4. Contrôleur de périphérique....................................................................... 92
5.1.5. Registre de modules, contrôleurs de périphériques d‟Entrée/sortie .........
92
5.2. TYPES DE TRANSMISSION ......................................................................... 93
5.2.1. Introduction .............................................................................................. 93
5.2.2. Transmission parallèle .............................................................................
94 5.2.3. Transmission sérielle ...............................................................................
94 5.2.4. Transmission asynchrone ........................................................................
95 5.2.5. Transmission
synchrone ...........................................................................96
5.2.6. Mode de transmission physique (simplex, half-duplex, full-duplex) ........
96
5.3. Opérations d‟Entrées/Sorties de base ............................................................
97
5.3.1. Entrées-Sorties spéciales contre entrées-sorties projetées/mappées sur la
mémoire………………....................................................................................... 97

5.3.2. Interfaces standards ............................................................................... 99

5.3.2.2.2. I8251 (un USART standard ..............................................................
102

© Kasengedia motumbe pierre 9

 Page 10 sur 270

5.3.3. Méthodes de contrôle des opérations d‟entrées-

sorties .........................105 5.3.4. Opération d‟Entrée-sortie par
interruption ............................................. 107
5.3.5. Opération d‟Entrée/Sortie par DMA (Direct Memory
Access) .............112
5.3.6. Canaux d‟Echange de données .........................................................115
5.4. Organisation des dispositifs d‟Entrées/sorties ............................................116
5.5. Organisation logicielle des Entrées/Sorties ..................................................118
5.5.1. Considérations préliminaires ...........................................................118
5.5.2. Objectifs des logiciels d‟Entrée/Sortie. .............................................
119
5.5.3. Structure en couches des logiciels d‟Entrée/Sortie ..........................121
IIème PARTIE : TRAVAUX PRATIQUES……………………………………………..
125
BIBLIOGRAPHIE ....................................................................................................166

© Kasengedia motumbe pierre 10

 Page 11 sur 270

PREMIÈRE PARTIE

LES CONCEPTS FONDAMENTAUX

D’UN SYSTEME D’EXPLOITATION D’ORDINATEURS

© Kasengedia motumbe pierre 11

 Page 12 sur 270

CHAP.1. CONCEPTS GENERAUX

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 utilisés actuellement et nous appuyer
d‟un système à 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 à l‟évolution technologique et

celle du système d‟exploitation est liée à celle de l‟ordinateur. C‟est ainsi
que nous pouvons relever les époques suivantes :
- Machine à calculer à engrenages mécaniques ;
- Machine à tube à vide ;
- Machine à circuits intégrés ;
- Machine à circuits intégrés à échelle très large.

• Machine à calculer à engrenages mécanique a été inventée par Blaise

Pascal (16231662) et pouvait réaliser des opérations arithmétiques

© Kasengedia motumbe pierre 12

 Page 13 sur 270

(addition, multiplication, soustraction) et était une machine mécanique à

base d‟engrenage.
• Machine à tube à vides
Pendant la seconde guerre mondiale, fut construit un ordinateur
(COLOSSUS) à tube à vide par le mathématicien Anglais ALAIN TURING.
Cet ordinateur a pu décoder des messages cryptés envoyés par amirauté
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 à tube (ENIAC (Electronic numerical integration
and computeur)) à vide ayant les caractéristiques : -18000 tubes ;
-1500 relais ;
-10 registres ;
-10 chiffres décimaux ;
-pesait 30 tonnes 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 convenir de tous ce qu‟il a vu et entendu
A émis l‟idée de base (modèle) VON NEUMAN, modèle qui est à la base de la
plupart d‟ordinateur standards actuels. Sur la Fig.1.1. ci-dessous présente le modèle
VON NEUMAN.
• Machine à circuits intégrés
• Machine à circuits très intégrés

© Kasengedia motumbe pierre 13

 Page 14 sur 270

MODELE VON NEUMAN

E S
N O
T R
R MEMOIRE T
E I
E E

Unité de ALU
commande
ACCU

Fig.1.1. Modèle VON NEUMAN

Unité de commande + ALU + registres = processeur

Proce
sseur
intégr
é

1.2.3. Système à microprocesseur

Un système à microprocesseur peut être aussi développé comme un ordinateur

qu‟on peut facilement transporter, dédicacer à :
- contrôler les paramètres fonctionnels d‟une voiture ;
- Un pilote automatique (ordinateur embarqué) d‟un avion ;
- Un central téléphonique, etc…

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

© Kasengedia motumbe pierre 14

 Page 15 sur 270

à 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 illustré le principe d‟interconnexion d‟un
microprocesseur aux différents équipements d‟entrée/sortie.

CU : commande unit

(ALU)
Unité arthritique et
logique

REGISTRE

DISQUE IMPRIMA
CO RI NTE
Mémoire
principale
AC
…. Contrôleur Contrôleur
HDD imprimante

© Kasengedia motumbe pierre 15

 Page 16 sur 270

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

d‟entrée/sortie.

Structure interne d‟un microprocesseur hypothétique

Sur le schema de la Fig.1.3. ci-dessous est présenté la 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.1.3. Structure interne d‟un microprocesseur hypothétique

RI (IR) : REGISTRE 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

© Kasengedia motumbe pierre 16

 Page 17 sur 270

Décode
Exécution
L‟unité de commande peut être un séquenceur : câblé ou micro-
programmée. Il importe que vous sachiez qu‟il existe toujours une
équivalence entre la logique câblée et celle microprogrammée

Fig.1.4. Equivalence entre la logique câblée et celle micro-

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 à la mémoire d‟adresse ayant
comme entrée les valeurs ABC sur contenu (M) aura le résultat de la

© Kasengedia motumbe pierre 17

 Page 18 sur 270

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 Step 2 (CA C+D)

D2

Step 4

D4

D3

Fig.1.5. Equivalence entre la logique

câblée et celle programmée

D1

Step 0
Step1

0. LOAD B ( A B)
1. Test (A0, A0) / ( 2, 3 )
2. C C+D
GOTO 4

© Kasengedia motumbe pierre 18

 Page 19 sur 270

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 :
- méthode Interrogative (polling) ;
- Par interruption ;
- Par DMA (direct memory Access);
- Canaux d‟ entrées /sorties.

Méthode interrogative Polling (Fig.1.6)

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

interroge périodiquement le slave (périphérique), un à un, pour
demander à 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.

© Kasengedia motumbe pierre 19

 Page 20 sur 270

P1
(master)

CPU P2

Polling slave
P3

P4

Fig.1.6. Méthode interrogative (polling)

Méthode 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 à 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)

© Kasengedia motumbe pierre 20

 Page 21 sur 270

P1
IREQ1
INT
CPU
INTA PIC IREQ2
P2
IREQ n

P3

data

adress

Fig.1.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 utilisés :
- adresse bloc de données du départ ;
- adresse bloc arrivé ;
- nombre mots à transférer.

Sur la Fig.8. Est illustré un système à microprocesseur utilisant le DMA

© Kasengedia motumbe pierre 21

 Page 22 sur 270

² Control
Fig.1.8. Système à microprocesseur utilisant le DMA

BUSREQ BUSG
P1 P2 Pj
MEMOIRE DMA

DATA

Logique
MICRO- décodage
PROCESSEUR
ADDRESS

BUSREQ bus contrôle

BUSGR

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

- gros ordinateurs (MAINFRAME)
- interruption et DMA traditionnel inefficaces - canaux de données ou
canaux d‟entrée / 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, à telle enseigne qu‟ils sont obligés d‟utiliser de
véritables processeurs spécialisés pour les opérations d‟entrée/sortie.

© Kasengedia motumbe pierre 22

 Page 23 sur 270

- canaux multiplexés : peut gérer plusieurs échanges 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.1.9. Canaux d‟entrées /sorties, processeur spécialises pour les entrées/sorties.

© Kasengedia motumbe pierre 23

 Page 24 sur 270

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 organisé en couche, de

la même manière que celle du modèle OSI. Cette organisation s‟inspire
de l‟approche oignons, qui consiste à décomposer un problème complexe
en module moins complexe, qu‟on peut mieux maîtriser. Ainsi l‟ordinateur
(ses modules hardware et software) peut être perçu comme une
superposition de machines virtuelles.

© Kasengedia motumbe pierre 24

 Page 25 sur 270

.
.
Fig.1.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.

© Kasengedia motumbe pierre 25

 Page 26 sur 270

Fig.1.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 :

- Gestion de processus;
- Gestion de la mémoire ;

© Kasengedia motumbe pierre 26

 Page 27 sur 270

- Gestion du système de fichiers ;

- Gestion des entrées / sorties .
1.4.1. Définition formelle

Un système d‟exploitation est un ensemble de programmes qui constituent 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
lieu 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)

© Kasengedia motumbe pierre 27

 Page 28 sur 270

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
Comptes
Rendus Actions
PROCESSUS

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

robot Industriel est un système mécatronique, ayant un certain nombre de grade de
libertés.

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

Sur le schema de la Fig.1.12. est présenté un robot didactique

ayant quatre grades de liberté.

© Kasengedia motumbe pierre 28

 Page 29 sur 270

Fig.1.12. Un robot didactique ayant quatre grades de liberté(le

quatrième est celui du préhenseur).

Le système de commande du robot sysmentionné peut fonctionner de la manière

suivate :
- une tache peut être affectée à la gestion d‟un grade de liberté
- une tache à la gestion de l‟apprehendeur

© Kasengedia motumbe pierre 29

 Page 30 sur 270

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

Carte contrôleur robot

Calculateur
Amplificateur
puissance

Robot

Fig.1.13. Un robot industriel contrôlé par un calculateur.

Une tache est un programme ou une partie 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.1.12, Fig.1.13. Est présenté un robot à 4 grades de libertés,

respectivement un robot didactique contrôlé 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.

© Kasengedia motumbe pierre 30

 Page 31 sur 270

TACHE A TACHE B TACHE C

IPA CODE IPC
IPB CODE CODE

DONNEES DONNEES DONNEES

SPA SPB SPC

Figure.1.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 PILE SPC PILE SPB

© Kasengedia motumbe pierre 31

 Page 32 sur 270

Fig.1.14.(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.1.15. Gestion quasi parallèle d’un système à 3 taches, dans un monoprocesseur.

© Kasengedia motumbe pierre 32

 Page 33 sur 270

Mesure de température dans une usine d’industrie chimique

Monitoring

Imprimante

Niveau supervision ORDINATEUR

CENTRAL

Niveau opérationnel

MICRO- MICRO- MICRO-

PROCESSE PROCESSE PROCESSE
UR UR UR

Sensers (sonde) Sensers

Sensers

Système distribué hiérarchisé temps réel

Fig.1.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.

© Kasengedia motumbe pierre 33

 Page 34 sur 270

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 de navigation aerienne 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 ;

© Kasengedia motumbe pierre 34

 Page 35 sur 270

Imprima
. . . . . nte

IBM 1401 IBM 7094 IBM 1401

- 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 . . . . .

Fig.1.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.

© Kasengedia motumbe pierre 35

 Page 36 sur 270

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

2 3

© Kasengedia motumbe pierre 36

 Page 37 sur 270

Fig.1.18. Système d‟exploitation monolithique

1.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.1.19. Ci-dessous schématise la multiprogrammation.

Ordinateur

n programmes à la fois

E/S

Programme sur carte lecteur cartes imprimante

Fig.1.19. Système multiprogrammation

© Kasengedia motumbe pierre 37

 Page 38 sur 270

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.1.20, Fig.1.21, sont représentés les principes d‟un système
multiutilisateur (temps partage), respectivement la répartition du temps CPU entre
les utilisateurs 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.

© Kasengedia motumbe pierre 38

 Page 39 sur 270

Ordinateur

n programmes à la fois

E/S

Imprimante
Fig.1.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)

© Kasengedia motumbe pierre 39

 Page 40 sur 270

Fig.1.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)

© Kasengedia motumbe pierre 40

 Page 41 sur 270

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.1.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 qu‟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.1.23.

© Kasengedia motumbe pierre 41

 Page 42 sur 270

Un client qui envoie des messages à un serveur, n‟a pas besoin de savoir s‟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 recevoir une réponse.

Client Serveur de Serveur des Serveur des

fichier processus terminaux

Noyau Noyau Noyau Noyau

Fig.1.23. Modèle client-serveur dans un système distribué.

© Kasengedia motumbe pierre 42

 Page 43 sur 270

CHAP.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‟exploitation 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éés 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

© Kasengedia motumbe pierre 43

 Page 44 sur 270

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 nous pouvons 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.2.1. Etats d‟un processus

© Kasengedia motumbe pierre 44

 Page 45 sur 270

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.

© Kasengedia motumbe pierre 45

 Page 46 sur 270

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
qu‟il gère.

Processus

1 ………… N-2 N-1

ORDONANCEUR (scheduler)

Fig.2.2. L‟ordonnanceur 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.

© Kasengedia motumbe pierre 46

 Page 47 sur 270

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 : o l‟ordonnancement circulaire (tourniquet, round-
robin) ; o l‟ordonnancement par priorité ; o
l‟ordonnancement par priorité avec files multiples.
o 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éalisé 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, quel que 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.

© Kasengedia motumbe pierre 47

 Page 48 sur 270

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 où 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

© Kasengedia motumbe pierre 48

 Page 49 sur 270

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.2.3. 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 les 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

© Kasengedia motumbe pierre 49

 Page 50 sur 270

T5 T4 T3 T2 T1 PROCES
SEUR

3 Tache insérée selon le temps estimé d’exécution

Fig.2.4. 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énient 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. Stratégie d’ordonnancement 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.

© Kasengedia motumbe pierre 50

 Page 51 sur 270

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écrite 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
éligibles. 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 où il serait bloqué, il rejoindrait
la file de processus bloqués)

Fig.2.5 : 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.

© Kasengedia motumbe pierre 51

 Page 52 sur 270

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.2.6. 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

© Kasengedia motumbe pierre 52

 Page 53 sur 270

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 multiutilisateur.
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 nœud comporte un numéro 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.2.7. Programmation d‟une file suivant une liste circulaire.

Ordonnancement par priorité

© Kasengedia motumbe pierre 53

 Page 54 sur 270

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âche par niveau de priorité.
Sur la Fig.2.8. est présenté l‟algorithme de l‟ordonnancement des tâches
par priorité. Processus termine ou bloqué

Fig.2.8. 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

© Kasengedia motumbe pierre 54

 Page 55 sur 270

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 statiques 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 majeure 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.

© Kasengedia motumbe pierre 55

 Page 56 sur 270

Fig.2.9.(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.

Fig.2.10. 2) insertion d‟une nouvelle tâche dans la file de taches organisées par

priorité.

2.1.3. 5. Ordonnancement par priorité avec files multiples

© Kasengedia motumbe pierre 56

 Page 57 sur 270

Principes :

Ce type d‟ordonnancement est une variante de l‟ordonnancement par priorité.

Comme nous pouvons le constater sur Fig.2.11; 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 (Round-robin, tourniquet). S‟il n‟y a pas
qu‟une seule tâche par niveau de priorité le modèle est celui de l‟ordonnancement
par priorité .Entre ces deux modèles une multitude 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.2.11.. Ordonnancement par priorité avec files multiples

© Kasengedia motumbe pierre 57

 Page 58 sur 270

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 finale du compte est n-n2 au lieu de n-n1-n2.c‟est une
anomalie.

© Kasengedia motumbe pierre 58

 Page 59 sur 270

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 exemples illustrent la notion 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).

© Kasengedia motumbe pierre 59

 Page 60 sur 270

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, c‟est à 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

© Kasengedia motumbe pierre 60

 Page 61 sur 270

2. Une seule variable commune fonctionnant en bascule :

Contexte commun : entier t;

t :=i
Processus pi : début i (1,2)
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.

© Kasengedia motumbe pierre 61

 Page 62 sur 270

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;
Processus pi : début i (1,2)

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[j] et trouve faux ;
2. pj consulte c[i] et trouve faux ;
3. pi fait c[i] :=vrai et entre dans sa section critique ;
4. pj fait c[j] :=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 ;

© Kasengedia motumbe pierre 62

 Page 63 sur 270

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 pi pour laisser passer pj : Ai : c[i] :=vrai ;
Si c[j] alors C[i] := faux
Aller à Ai

© Kasengedia motumbe pierre 63

 Page 64 sur 270

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 aux conditions requises, comme nous allons le voir dans ce qui suit :

© Kasengedia motumbe pierre 64

 Page 65 sur 270

- il n‟y a pas conflit d‟accès à la section critique, c'est-à-dire que

l‟un 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 Ai, 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

© Kasengedia motumbe pierre 65

 Page 66 sur 270

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 de m ;
si m=0 alors
début
m:=1;
section critique sur ressource ;
m:=0;
fin
sinon
Libérer accès cellule mémoire m ;
Fin

En considérant les aspects suivants :

- p : variable à tester
- R : ressources critique

© Kasengedia motumbe pierre 66

 Page 67 sur 270

L‟instruction TAS peut être utilisée de la manière

suivante :
Debut
p :=0
E : TAS (p)
Aller à E
Fin

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 : Tas (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

© Kasengedia motumbe pierre 67

 Page 68 sur 270

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 : Debut
Ne peut bloquer m car cellule m déjà bloquée 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

© Kasengedia motumbe pierre 68

 Page 69 sur 270

critique est occupée. Sur la Fig.2.12a ci-dessous est présenté le cas de l‟utilisation
de TAS, dans un environnement multiprocesseur.

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

Fig.2.12a. 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
BTS pour Intel 80386

NB : Intel est le numéro un mondial de la fabrication des microprocesseurs. Les

fameux PC pentium sont équipés de ses microprocesseurs.

© Kasengedia motumbe pierre 69

 Page 70 sur 270

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 sûr qu‟aucun autre pro
cessus 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‟attente f (p). Si un processus ne peut entrer en section critique,
dans la file d‟attente ; lorsqu‟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

© Kasengedia motumbe pierre 70

 Page 71 sur 270

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
ressource critique ; ce sont des procédures du système, car elle manipule des files
de processus ; nous les appellerons primitives parce qu‟au niveau des processus
appelants elle se comporte comme des instructions. Comme toute 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

© Kasengedia motumbe pierre 71

 Page 72 sur 270

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, atomique. 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) ;

© Kasengedia motumbe pierre 72

 Page 73 sur 270

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
si e(s) < 0 alors e(s):= e(s) – 1 sinon
debut
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
si f(s)=vide alors
e(s)=e(s)+1 sinon

Début
Sortir un processus de la file f(s) ;
Commentaire : soit q le processus de la file f(s) ;
État (q) : actif ;
Fin

© Kasengedia motumbe pierre 73

 Page 74 sur 270

Fin

2.2.5.2. Propriétés de sémaphores

La définition des primitives P, et V a les conséquences suivantes :

1) la variable e(s) du sémaphore ne peut être initialisée à 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)

© Kasengedia motumbe pierre 74

 Page 75 sur 270

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(s), V(s) 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

© Kasengedia motumbe pierre 75

 Page 76 sur 270

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 en particulier de :

- modéliser les processus concurrents, parallèles ;

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

2.3.2. Discussion informelle

Un réseau de PETRI est composé de types d‟éléments suivants :

© Kasengedia motumbe pierre 76

 Page 77 sur 270

- 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 la 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

© Kasengedia motumbe pierre 77

 Page 78 sur 270

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. 2.13.(a). et Fig. 2.13.(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

Jeton
Transition

Fig. 2.13.(a). Condition avant franchissement

© Kasengedia motumbe pierre 78

 Page 79 sur 270

Fig. 2.13.(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é les frais d‟études (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 Fig. 2.14. (c).Après élection

(Mira élue, après
C3 franchissement)

Fig. 2.14. (a). Avant élection

Election -OK

© Kasengedia motumbe pierre 79

 Page 80 sur 270

Fig. 2.14. (b).Après élection (Mira

élue, avant franchissement)

Fig. 2.14. (d).

Après élection
(Mira, non élue)
Fig. 2.14. (a)., Fig. 2.14. (b). , Fig. 2.14. (c). modélise l‟évolution de Mira. , Fig. 2.14. (d) :
modélisent la situation de l‟échec de Mira a l‟élection.

Si on analyse, les choses avec la minutie 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.2.15. Attribution d‟une ressource

© Kasengedia motumbe pierre 80

 Page 81 sur 270

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‟un 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

t2 t1

d e

© Kasengedia motumbe pierre 81

 Page 82 sur 270

Fig.2.16. 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 ne pas être utilisés par le processus agissant :

© Kasengedia motumbe pierre 82

 Page 83 sur 270

2.4. 2. Mécanisme d’action directe

Les processus qui évoluent dans un système ne se comportent pas généralement

tous convenablement, à telle enseigne que certain processus peuvent par exemple
boucler 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 n’est 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 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 bloqué ; 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 bloqué (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é

© Kasengedia motumbe pierre 83

 Page 84 sur 270

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énement 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é.

© Kasengedia motumbe pierre 84

 Page 85 sur 270

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 event
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‟un pseudo
variable de type complétion :
Completion (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. Completion (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

© Kasengedia motumbe pierre 85

 Page 86 sur 270

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(s) ; il est attendu par une primitive P(s).
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

© Kasengedia motumbe pierre 86

 Page 87 sur 270

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.

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 et de la communication 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
cidessus et sur Fig38b est présenté la modélisation de leur synchronisation et
communication en utilisant le réseau de PETRI.

© Kasengedia motumbe pierre 87

 Page 88 sur 270

La Fig.2.17a. 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‟à 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.

© Kasengedia motumbe pierre 88

 Page 89 sur 270

© Kasengedia motumbe pierre 89

 Page 90 sur 270

Fig.2.
17b. Réseau de PETRI modélisant la synchronisation et communication entre processus
(source) et processus destination.

© Kasengedia motumbe pierre 90

 Page 91 sur 270

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 à envoyer le request-to-send.

Lorsque le jeton arrive à f, suite à la réception du ready-to-receive, le franchissement

de la transition 6 est possible et le jeton passe en g ce qui indique que la source est
prête à envoyer les données. On notera le franchissement de la transition 7 conduit à
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ères
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êt à envoyer
data-sent. L‟arrivée 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 de la transition.

Certaines opérations évoquees dans la modélisation peuvent requérir un certain

temps d‟exécution mais un modèle étant une abstraction de la réalité ne doit pas
nécessairement être à même dans d‟en représenter tous 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

© Kasengedia motumbe pierre 91

 Page 92 sur 270

des états. Un jeton en a indiqué la source est prête à prendre en charge une
demande d‟envoi des données provenant du processus A. La transition 2 marque la
prise en charge de la demande, les jetons en c indique que la source à préparer les
données, un jeton en d
Indique que le message request-to-sent est prêt à être envoie tandis que le jeton en
e indique que la source est en attente de la réponse de la destination c‟est à dire
l‟arrivée de ready-toreceive 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 à titre d‟exercice en mentionnant toute fois
le jeton 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 à la préparation des ressources nécessaire pour recevoir des
données. Des autres places et transitions sont relatives à des mécanismes déjà
évoques.

Si l‟on désire 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ées, en utilisant les
sémaphores, en langage Pascal concurrent, comme dans le programme ci-dessous.

P(s): debut
si e(s)=1
alors

© Kasengedia motumbe pierre 92

 Page 93 sur 270

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

© Kasengedia motumbe pierre 93

 Page 94 sur 270

Begin request-to-send :=0 ;

Ready-to-receive :=0 ;
Data-sent :=0 ;
Data-consumed :=0 ;

Cobegin

Processus 1
L1 : get-data-ready ;
V(request-to-ready) ;
P(ready-to-receive) ;
Send -data ;
V(data-send) ;
P(data-consumed) ;
Go-to-L1 ;

Processus 2
L2 : P(request-to-send ;
Get-ready ;
V(ready-to-receive) ;
P(data-send) ;
Consume-data ;
V(data-consumed) ;
P(data-consumed) ;
Go-to-L2 ;
Coend
end

© Kasengedia motumbe pierre 94

 Page 95 sur 270

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 à la réalisation de certaines tâches
auxquelles les processus sont impliqués. 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

© Kasengedia motumbe pierre 95

 Page 96 sur 270

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‟à 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 informations 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 établit une connexion avec l‟objet de destination. Tout
processus peut être autorise à 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-là, il n‟est pas
nécessaire d‟établir une quelconque connexion

© Kasengedia motumbe pierre 96

 Page 97 sur 270

• 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 à é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 à un accès en lecture ou à un accès en écriture,
mais pas aux deux. L‟accès bidirectionnel peut être autorise, permettant aux
processus de lire et d‟écrire à la fois dans un objet.
• A combien des objets 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 imposer 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.

© Kasengedia motumbe pierre 97

 Page 98 sur 270

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 à 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 à tous les
processus. Toutefois l‟accès simultané de plusieurs processus a des telles variables
pose des problèmes de cohérence soulevée à 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 à inclure tout accès à
des données, a une section critique ; toutefois, des considérations d‟efficacité amène
à réaliser des sections critiques brèves que possible, et en particulier à éviter les
blocages des processus à 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 :

© Kasengedia motumbe pierre 98

 Page 99 sur 270

 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 à 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‟information 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
signale pas sa réception a p. l‟arrivée d‟un message impliquant
l‟arrivée 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 abordés :
- 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 :

© Kasengedia motumbe pierre 99

 Page 100 sur 270

-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 à 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 dès
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) :

© Kasengedia motumbe pierre 100

 Page 101 sur 270

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 :

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@à

PRODUCTEUR CONSOMMATEUR
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 ;

© Kasengedia motumbe pierre 101

 Page 102 sur 270

nplein=nplein+1 si nvide :=nvide+1 ;

s consommateur en producteur en attente
attente alors réveiller producteur
reveiller consommateur réveiller producteur
aller a PROD ; Consommer le message ;
aller a CONS ;

© Kasengedia motumbe pierre 102

 Page 103 sur 270

Les parties notées entre accolade doivent se dérouler de façon indivisible (elles sont
atomiques). Elles doivent se dérouler ainsi puisqu‟elles comprennent le test et la
modification de variables critiques. Considérons à 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 fait, on compare nplein a 0 puisqu‟on fait
nplein :=nplein+1).

Le test et la modification de cette condition se fait comme suit :

PRODUCTEUR CONSOMMATEUR
. .
. .
. .
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

© Kasengedia motumbe pierre 103

 Page 104 sur 270

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.

© Kasengedia motumbe pierre 104

 Page 105 sur 270

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

© Kasengedia motumbe pierre 105

 Page 106 sur 270

Fig.2.18. 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

© Kasengedia motumbe pierre 106

 Page 107 sur 270

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.

© Kasengedia motumbe pierre 107

 Page 108 sur 270

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.

CHAP. 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.

© Kasengedia motumbe pierre 108

 Page 109 sur 270

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 à 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 autorisé.
La gestion de la mémoire est du ressort du gestionnaire de la mémoire. Il 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.
Les systèmes de gestion de la mémoire se répartissent 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.

3.2. La gestion de la mémoire sans va-et-vient ni pagination

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;
- multiprogrammation avec des partitions variables;

© Kasengedia motumbe pierre 109

 Page 110 sur 270

3.2.1. Monoprogrammation sans avec – et – vient ni pagination

La gestion de la mémoire la plus simple consiste à avoir un seul processus en

mémoire à 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é 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 situé 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
situé 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
MSDOS, 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 à microprocesseur Intel 8086/88.

Système Pilotes de
D‟exploitation périphérique
ROM en Rom

© Kasengedia motumbe pierre 110

 Page 111 sur 270

Programme
Utilisateur Programme
Utilisateur

Système Système
D‟exploitation D‟exploitation
en RAM en RAM

Fig.3.1(a) Fig.3.1 (b) Fig.3.1 (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

ko Video

960Adaptater
ko
Pilotes
mémoire réservée
Video Ram

800

Utilisateur
+
768 ko Pilote
Dos

© Kasengedia motumbe pierre 111

 Page 112 sur 270

640 ko Processus

Mémoire conventionnelle

Fig.3.2. 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 organisé

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) ;

© Kasengedia motumbe pierre 112

 Page 113 sur 270

- 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.

© Kasengedia motumbe pierre 113

 Page 114 sur 270

un seul compteur de commutation 4

compteurs de processus ordinal
ordinaux

A A B C D

C Fig.3.3.(b)

Fig.3.3.(a)

Processus

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é.

© Kasengedia motumbe pierre 114

 Page 115 sur 270

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éalisé 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).

© Kasengedia motumbe pierre 115

 Page 116 sur 270

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

Fig.3.4.(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

© Kasengedia motumbe pierre 116

 Page 117 sur 270

désavantage les taches de petites tailles alors qu‟il faudrait théoriquement les traiter
en priorité.
Ce système, à partitions fixes déterminées par l‟opérateur au démarrage a été utilisé
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 à 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 tous les utilisateurs,
il faut placer quelques processus sur le disque, qu‟il faudrait bien sûr, 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 sont pas très intéressantes lorsque la mémoire est
très limitée, car on perd beaucoup de place à cause des programmes qui sont plus
petits les partitions. Il faut utiliser une autre méthode : les partitions variables.

© Kasengedia motumbe pierre 117

 Page 118 sur 270

Avec les partitions variables, le nombre et la taille des processus en mémoire varient au
cours du temps. La Fig.3.5. illustre le fonctionnement des partitions variables.
Au départ, un seul processus A, se trouve en mémoire (Fig.3.5a). Les processus B et
C sont créés ou charge à partir disque. A la Fig.3.5d, A se termine ou est déplacé sur
le disque. Puis d‟arriver et B s‟en va. Enfin E est charge en mémoire (Fig.3.5g).
La différence fondamentales entre la position et les partitions fixes (Fig.3.4) et les
partitions variables (Fig.3.5) est que le nombre, la taille de ces dernières varie
dynamiquement au fur et à mesure que les processus entrent ou sortent sont de la
mémoire. On n‟est plus limité par un nombre fixe de partition ou 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

© Kasengedia motumbe pierre 118

 Page 119 sur 270

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.3.5. 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

© Kasengedia motumbe pierre 119

 Page 120 sur 270

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 tous 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 requiert 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 à 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
11111000

11111111

11111111 © Kasengedia motumbe pierre 120

110000
 Page 121 sur 270

(a)

(b)

P 0 5 H 5 3 P 8 6 P 14 3

P 17 6 P 23 3 H 26 4

Zone debout longueur Processus Hachuree

Libre
(on trou) 18
(C)

Fig.3.6 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 à 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

© Kasengedia motumbe pierre 121

 Page 122 sur 270

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.

© Kasengedia motumbe pierre 122

 Page 123 sur 270

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ésidu avant la fin X.

devient A B
a) A X
B

b) A X devient A

c) X B devient B

d) X devient

Fig.3.7 quatre combinaisons des voisins possibles d‟un processus qui se termine.

L’algorithme de la première zone libre (first fit) :

© Kasengedia motumbe pierre 123

 Page 124 sur 270

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 à partir de cette position et non à partir du début.

L’algorithme du meilleur ajustement

Il consiste à 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 à 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

© Kasengedia motumbe pierre 124

 Page 125 sur 270

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

© Kasengedia motumbe pierre 125

 Page 126 sur 270

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 à la page 0 (adresse 0 à 4095) qui
appartient à la case 2(8192 à 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 à 12387.
De même, l‟instruction MOVE REG, 8192 est transformée en MOVE REG 24576
Parce que l‟autre adresse virtuelle 8192 est situé dans la page virtuelle 2 et que cette
page est mappée a la a la case physique 6 adresses physiques 42576 à 28671).
L‟adresse virtuelle 21500 est située 20 octets après le début de la page virtuelle 5
(adresses virtuelles 20480 à
24575) et correspond à 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 signalés 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.

© Kasengedia motumbe pierre 126

 Page 127 sur 270

Fig.3.8. La relation entre les adresses virtuelles est les adresses de la mémoire
physique est indiquée dans la table des pages. Chaque page comme à un multiple
de 4 096 et fini 4095 adresses plus haut. 4k-8k signifient donc 4096 à 8 191 et 8k-
12k signifie 8 192 à 12 287.

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 à 12 octets après le début de la page 8 qui commence à
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érée, modifie la mappée, et ré-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 à 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 ré-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 à présent le fonctionnement
interne du MMU et la raison pour laquelle nous avons choisi des tailles de pages qui
sont puissances de 2.

© Kasengedia motumbe pierre 127

 Page 128 sur 270

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. Ce registre de sortie (qui contient l‟adresse physique) est ensuite le placer
sur le bus de la mémoire.

© Kasengedia motumbe pierre 128

 Page 129 sur 270

Fig.3.9 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 supprimée.

© Kasengedia motumbe pierre 129

 Page 130 sur 270

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

© Kasengedia motumbe pierre 130

 Page 131 sur 270

probablement utilisées pendant un certain temps. l‟algorithme consiste à

supprimer et à 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).

© Kasengedia motumbe pierre 131

 Page 132 sur 270

CHAP.4. GESTION DE SYSTEMES DE FICHIERS

La gestion de fichiers est justifiée par le fait qu‟il se pose le besoin d‟enregistrer, de
stocker à long terme, les informations et de les retrouver.
Trois conditions essentielles sont exigées pour le stockage à long terme de
l‟information: - Pouvoir enregistrer une très grande quantité d‟informations;
- Les informations doivent être conservées, après la fin du processus qui les
utilise; - Plusieurs processus doivent pouvoir accéder simultanément à une
même information (exemple : plusieurs processus veulent accéder à un seul
répertoire téléphonique). Les supports utilisés pour le stockage à long terme
sont :

- Les disques magnétiques ;

- Les Bandes magnétiques ; - Disques optiques numériques.

4.1. DISQUE MAGNÉTIQUE

4.1.1. Description d’un disque magnétique

Grâce au système d‟exploitation, au système de fichiers, un disque dur, entité

physique, peut être considérée comme une entité logique, une suite séquentielle
de blocs de taille fixe, qui supporte deux opérations :

- Lire le bloc k ;
- Ecrire le bloc k .

Sur Fig.4.1 sont détaillés les composants physiques d‟un disque dur pour ordinateur
fixe1, ainsi qu‟à la Fig.4.2.

Les composants logiques d‟un disque dur :

- Cylindre ; - Piste ; - Secteur.

1
www.culture-informatique.net

© Kasengedia motumbe pierre 132

 Page 133 sur 270

Fig.4.1. Eléments composants d‟un disque dur pour ordinateur fixe2

2
www.culture-informatique.net

© Kasengedia motumbe pierre 133

 Page 134 sur 270

Fig.4.2. les composants logiques d‟un disque dur : - cylindre ; piste ; secteur

4.1.2. Noms de fichiers

Le fichier est un mécanisme d‟abstraction qui permet d‟écrire des informations

sur un disque, et en lire plus tard, de façon à ce que l‟utilisateur ne soit pas
préoccupé par le fonctionnement, les caractéristiques techniques du disque.
Quand un processus crée un fichier, il lui donne un
nom. Le nom peut avoir les caractéristiques
suivantes :

- Chaîne de caractères ;
- Chiffre ;

- Chiffre et caractère ;

- Sensible à la lettre majuscule.

Certains systèmes de fichiers utilisent de noms sensibles à la majuscule, par exemple
UNIX :
jean ≠ Jean ≠ JEAN, alors que d‟autres ne sont pas sensibles à la majuscule, tel que
DOS : jean = Jean = JEAN.

© Kasengedia motumbe pierre 134

 Page 135 sur 270

Les fichiers se trouvant dans un support de stockage de masse (HDD, Bande

magnétique,…) sont gérés par une partie du système d‟exploitation appelée
système de fichiers. Sur le tableau de la Fig.4.3. sont présentés les systèmes de
fichiers généralement utilisés Fig.4.3. Systèmes de fichiers généralement utilisés

SYSTEMES FICHIERS SYSTEMES

D’EXPLOITATION

FAT 16 MS-DOS, mais aussi

WINDOWS 95,
WINDOW 98

FAT 32 (extension de FAT 16) WINDOW 98, Windows NT

NTFS Système de fichiers natif de 4 versions

de Windows NT

Windows NT, Windows 2000, Windows XP, Windows Vista reconnaissent FAT 16, FAT
32.

De nombreux systèmes de fichiers gèrent des noms

de fichiers en deux parties : indique le type de
partienom.extension
fichier

nom d‟un fichier

MS DOS : nom de 1 à 8 caractères, extension de 1 à 3 caractères ; UNIX : la taille

de l‟extension, si elle existe, dépend de l‟utilisateur. Un fichier peut avoir deux
extensions ou plus.

Exemple : homepage.html.zip (fichier homepage.html a été compressé grâce au

programme gzip)

© Kasengedia motumbe pierre 135

 Page 136 sur 270

Sur le tableau de la Fig.4.4. sont présentés quelques exemples de fichiers et leurs

extensions.

Fig.4.4. Quelques exemples de fichiers et leurs extensions.

FICHIER ET SIGNIFICATION
EXTENSION
Fichier.bak Fichier de sauvegarde

Fichier.c Programme source

en C

Fichier.gif fichier image en

format GIF

Fichier.hlp fichier d‟aide

Fichier.jpg fichier image en format

JPEG

Fichier.mp3 fichier de musique

codé en MPEG

Fichier.o fichier objet (source

compilée, non
encore liée)

Fichier.ps Fichier documente

en format

© Kasengedia motumbe pierre 136

 Page 137 sur 270

Post Script

Fichier.tex fichier
documenté
en format
TEX
Fichier.txt fichier
doc
ument en
format
TEXTE
Fichier.zip fichier
docume
nt archive
compressé
Fichier.html Fichier contenant page
web

Fichier
Fichier.pdf contenant
document PDF

4.2. STRUCTURE DE FICHIERS

Les fichiers peuvent être structurés de différentes façons :

- Une suite d‟octets sans structure ;

- Une suite d‟enregistrements de longueur fixe ;
- Un arbre d‟enregistrements.

© Kasengedia motumbe pierre 137

 Page 138 sur 270

- Sur la Fig.4.5. sont présentées deux Structures des fichiers (Une suite d‟octets

sans structure, Une suite d‟enregistrements de longueur fixe).

Fig.4.5. Structures des fichiers

Suite d’octets sans structure

Le système d‟exploitation ne s‟occupe pas du contenu de ce fichier, il ne voit que des

octets. Toute signification doit être apportée par les programmes des utilisateurs.

Suite d’enregistrements de longueur fixe

Dans ce modèle, un fichier est une suite d‟enregistrements de longueur fixe, qui ont
chacun une structure interne. Ainsi, une opération de lecture renvoie un
enregistrement, une opération d‟écriture ajoute un enregistrement.

© Kasengedia motumbe pierre 138

 Page 139 sur 270

Fichier en arbre d’enregistrements

Un fichier est un arbre d‟enregistrements, qui ne sont pas nécessairement tous de

même longueur et dont chacun contient une clé dont la position est fixe dans
l‟enregistrement. L‟arbre est trié en fonction de la clé, ce qui permet de rechercher
rapidement une clé donnée. Sur la Fig.4.6. est décrit le fichier d‟enregistrement d‟un
zoo.

Fig.4.6. Fichier en arbre d‟enregistrements

L‟opération fondamentale ne consiste pas à obtenir l‟enregistrement prochain, mais à

obtenir un enregistrement avec une clé donnée.

Ce type de fichier est vraiment très différent des suites d‟octets exploitées dans
Windows, Unix, mais largement utilisé dans les gros systèmes (main frame), qui
exploitent certaines applications de traitement de données commerciales.

4.3. CLASSIFICATION DE FICHIERS(ORDINAIRES ET AUTRES)

D‟un certain point de vue, les fichiers peuvent être classifiés en fichiers ordinaires et
autres :

- Les fichiers ordinaires (« regular files »)

- Les répertoires (« directories »)
- Les fichiers spéciaux caractère (« character special files »)

© Kasengedia motumbe pierre 139

 Page 140 sur 270

- Les fichiers spéciaux bloc (« block spécial files »)

4.3.1. Les fichiers ordinaires (« regular files »)

Les fichiers ordinaires sont ceux qui contiennent les données, informations des utilisateurs.
Ils peuvent être, tels qu‟expliqués à la section précédente :

- Une suite d‟octets sans structure ;

- Une suite d‟enregistrement de longueur fixe ; - Un arbre d‟enregistrements.

La plupart des systèmes d‟exploitation, notamment Windows, Unix, supportent ce type de

fichiers.

Les fichiers ordinaires peuvent être classifiés en :

- Fichiers ASCII
- Fichiers binaires.
Fichiers ASCII
Les fichiers ASCII se composent de lignes de texte. Selon le système d‟exploitation
auquel on a affaire, une ligne peut se terminer par le caractère ASCII ″CR″ (Carriage
Return), ou le caractère ASCII ″LF″ (Line Feed – saut de ligne). MS-DOS utilise les
deux manières de terminer la ligne.

Le grand avantage du fichier ASCII, couramment appelé fichier texte est qu‟on peut
l‟éditer avec n‟importe quel éditeur de texte, l‟afficher, l‟imprimer, tels quels. De
nombreux programmes peuvent, moyennant des tubes (pipes), relier la sortie d‟un
fichier ASCII à l‟entrée d‟un autre, comme le ferait l‟interpréteur de commandes
SHELL.

Fichiers binaires
Les fichiers binaires sont différents des fichiers ASCII, dans ce sens que si on les
imprime, cela donnerait des feuilles complètement incompréhensibles. Ils possèdent
une structure interne pour des programmes qui les exploitent.
Sur le fichier de la Fig.4.7, ci-dessous est illustrée la structure interne d‟un simple
fichier exécutable d‟une ancienne version d‟UNIX. Bien que, techniquement, le

© Kasengedia motumbe pierre 140

 Page 141 sur 270

fichier soit juste une suite d‟objets, le système d‟exploitation l‟exécutera s‟il
respecte un certain format. Ce format comprend cinq parties :

- L‟en-tête (header) ;
- Le code
- Les données

- Les bits de translation (relocation) ; - La table de symboles.

En-tête: au début de l‟en-tête est inscrit un nombre magique (magic number), une
valeur identifiant le fichier et qui permet d‟éviter une exécution accidentelle. Il
contient aussi les tailles des parties maniables du fichier, l‟adresse à laquelle son
exécution démarre et autres indications.
Code et données: le code et les données du programme qui suivent l‟en-tête sont chargés
en mémoire et déplacés à l‟aide des bits de translation.
Table des symboles: la table des symboles est utilisée pour déboguer (dépanner) le
programme. Fichier d’archive
Dans le contexte d‟UNIX, est aussi utilisé une variante de fichier binaire, appelé
fichier d’archive. Il consiste en un rassemblement de modules de bibliothèques
compilés mais pas encore liés par un éditeur de liens (Link Editor). Chacun d‟eux
est composé d‟un en-tête et du module objet (objet module). L‟en-tête est composé
de : - Nom du module ;

- Date de création ;

- Nom du propriétaire ;

- Protection (droits, permissions) ; - Taille.

Sur Fig.4.8, ci-dessous est présenté un exemple du fichier binaire, fichier exécutable.

© Kasengedia motumbe pierre 141

 Page 142 sur 270

Fig.4.8. Structure interne d‟un simple fichier exécutable d‟une ancienne version d‟UNIX

4.3.2. Les répertoires (« directories »)

Les répertoires sont des fichiers système qui conservent la structure du système
de fichiers, laquelle a comme rôle de conserver la trace des fichiers concernant
des répertoires. Dans ce qui suit, nous allons aborder : Les systèmes à un seul
niveau de répertoire ;

- Les systèmes à répertoire hiérarchique ;

- Les chemins d‟accès ;
- Les opérations sur les répertoires.
Systèmes à un seul niveau de répertoire
Le répertoire le plus basique est celui qui contient tous les fichiers. Il est aussi
appelé répertoire racine (« root directory »). Mais comme il est unique, son nom
n‟a pas beaucoup d‟importance. Un exemple de système avec un répertoire
unique est illustré sur le schéma de Fig.4.9, ci-dessous. Les avantages de ce
schéma sont sa simplicité et l‟aptitude à retrouver rapidement un fichier.
Le système à un niveau de répertoire est exploité dans :

© Kasengedia motumbe pierre 142

 Page 143 sur 270

- CDC 6600, le premier super-ordinateur au monde ;

- Appareils intégrés simples, comme un téléphone, appareil photo digital, baladeur,…

Fig.4.9. Système de répertoire à un seul niveau contenant quatre fichiers

Les systèmes à répertoire hiérarchique

Le répertoire unique est acceptable pour de petites applications dédiées (il était
même utilisé dans les premiers ordinateurs personnels), mais pour des
utilisateurs actuels, qui possèdent des milliers de fichiers, il est très difficile de
retrouver quoi que ce soit avec un répertoire unique. Ainsi une structure
hiérarchique (arbre de répertoires) est nécessaire. Elle permet à chaque
utilisateur d‟avoir autant de répertoires qu‟il le souhaite afin de regrouper ses
fichiers de manière logique.

Sur le schéma de Fig.4.10, ci-dessous est décrit un système à répertoire

hiérarchique, où les répertoires A, B, C situés à la racine appartiennent à des
utilisateurs différents, deux d‟entre eux ayant créé.

© Kasengedia motumbe pierre 143

 Page 144 sur 270

Fig.4.10. Système à répertoire hiérarchique

Les systèmes de fichiers actuels sont organisés en répertoire hiérarchique, car la

possibilité de créer un nombre élevé de sous-répertoires offre aux utilisateurs un
puissant outil d‟organisation pour leur travail.
Les chemins d’accès
Quand le système de fichiers est organisé en arbre de répertoires, il faut trouver un
moyen pour spécifier les noms de fichiers. Pour ce faire, il existe deux méthodes :

- Chemin d‟accès absolu (absoute path name)

- Chemin d‟accès relatif (relative path name)

© Kasengedia motumbe pierre 144

 Page 145 sur 270

Chemin d’accès absolu

Le chemin d‟accès absolu consiste à montrer le chemin, de la racine jusqu‟au fichier.
Dans les systèmes d‟exploitation Windows, UNIX, MULTICS, on peut indiquer le
chemin |usr|ast|courrier de la manière suivante :
Windows \usr\ast\courrier Unix
/usr/ast/courrier MULTICS
>usr>ast>courrier .

Il est important de noter que quel que soit le système d‟exploitation utilisé, si le premier
caractère du chemin d‟accès est le séparateur, c‟est qu‟on a affaire au chemin absolu.
Chemin d’accès relatif
Le chemin d‟accès relatif (relative path name) fonctionne
conjointement avec le répertoire de travail (working directory), aussi appelé répertoire
courant (current directory). Si un utilisateur désigne un répertoire comme un
répertoire de travail, tous les chemins d‟accès qui ne commencent pas à la racine
sont alors relatifs au répertoire courant.
En considérant le chemin absolu /usr/ast/courrier, si le répertoire courant est /usr/ast,
alors pour évoquer le fichier « courrier », on indique seulement courrier.
En d‟autres termes, dans le contexte du système d‟exploitation UNIX, les commandes
cidessous, utilisant le chemin d‟accès absolu et le chemin d‟accès relatif sont
équivalentes :

cp /usr/ast/courrier /usr/ast/courier.bak
et cp courrier courrier.bak.
Naturellement si le répertoire de travail est /usr/ast
Il est bien évident que le chemin d‟accès absolu fonctionnera toujours quel que soit le
chemin d‟accès relatif.

Les opérations sur les répertoires

En nous basant sur UNIX, il y a lieu de relever les opérations suivantes :

1. create

© Kasengedia motumbe pierre 145

 Page 146 sur 270

2. delete
3. opendir
4. closedir
5. readdir
6. rename
7. link
8. unlink

create : pour créer un répertoire, qui sera au début vide et contiendra « . » et « .. », qui
sont placés automatiquement pour le système.
delete : permet de supprimer un répertoire. Seuls les répertoires vides peuvent être
supprimés.
opendir : contient un programme de listage qui ouvre le répertoire afin d‟extraire les
noms de tous les fichiers qu‟il contient.
closedir : après avoir lu un répertoire, il est impératif de le fermer avant de libérer
l‟espace dans les tables internes.
readdir : cet appel renvoie la prochaine entrée d‟un répertoire ouvert.
rename : permet de renommer les répertoires, de la même manière que les
fichiers.
link : le lien, permet à un fichier d‟apparaître dans plus d‟un répertoire. Il consiste à
associer à un fichier existant, un chemin d‟accès.
unlink : sert à supprimer le lien qui a été établi par ″link ″. Si le fichier qui est délié
est uniquement présent dans un répertoire (cas normal), il est effacé du système de
fichiers ; s‟il est présent dans plusieurs répertoires, seul le nom du chemin d‟accès
spécifié est effacé, les autres vont continuer à demeurer. Dans UNIX, unlink est
l‟appel système qui sert à effacer des fichiers.

© Kasengedia motumbe pierre 146

 Page 147 sur 270

4.3.3. Les fichiers spéciaux caractère (« character special files »)

( A compléter pendant le cours)

4.3.4. Les fichiers spéciaux bloc (« block spécial files »)

( A compléter pendant le cours)

4.4. ACCES ET ORGANISATION BASIQUE DES SYSTEMES DE FICHIERS

Un système de fichier qui stocke une grande quantité de données, doit répondre à un
certain nombre de critères parmi lesquels il y a lieu d‟abord de citer :

- L‟accès rapide pour lire; - Mise à jour convenable; - Economie de stockage.

Par après, nous pouvons aussi prendre en considération d‟autres critères tels que :

- Fiabilité ;

- Maintenance de l‟intégrité.
Dans ce qui suit, nous allons aborder, les différentes méthodes d‟accès et organisation de
fichiers:

- Fichier à accès séquentiel

- Fichier à accès séquentiel-indexé ;

- Fichier à accès indexé ;

- Fichier à accès direct (fichier hashé).

Beaucoup de structures de fichiers rencontrées dans la pratique, peuvent se retrouver

dans les catégories susmentionnées, provenir de leur combinaison.

Fichier à accès séquentiel

Pour un fichier à accès séquentiel, l‟organisation de fichiers est telle que les
enregistrements sont structurés en séquence, selon une clé primaire afin de
localiser un enregistrement le programme doit parcourir le fichier du début

© Kasengedia motumbe pierre 147

 Page 148 sur 270

jusqu‟atteindre l‟enregistrement désiré. Un exemple éloquent du fichier séquentiel

est la liste alphabétique de numéro téléphonique dans un répertoire téléphonique
(en ignorant bien sûr, tout index qui pourrait être inclus dans ce répertoire).
A cause de leur inflexibilité, les fichiers séquentiels ne peuvent pas être utilisés pour
une base de données exploitable, mais pour le « backup », par conséquent ne
peuvent pas être stockés dans un disque dur, mais plutôt dans une bande
magnétique. Sur la Fig.4.11 est représenté le fichier séquentiel.

Fig.4.11. Fichier séquentiel

Fichier indexé
Dans une organisation de fichiers indexés les enregistrements sont stockés
séquentiellement ou non séquentiellement. L‟index va permettre au programme de
localiser les enregistrements individuels. Comme un catalogue, dans une librairie, un
index et une taille utilisée pour déterminer l‟emplacement de la rangée où se trouverait
le livre.

© Kasengedia motumbe pierre 148

 Page 149 sur 270

Fig.4.12. Organisation du fichier indexé

Fichier séquentiel indexé

Le fichier séquentiel indexé a été conçu pour surmonter la limitation liée au
problème du temps d‟accès inhérent à l‟organisation séquentielle de fichiers. C‟est
ainsi qu‟on introduit l‟index qui permet un accès aléatoire, avant de procéder à un
parcours séquentiel.

Fig.4.13. Fichier séquentiel indexé

Sur le schéma ci-dessus est décrit le principe d‟un fichier séquentiel indexé.

© Kasengedia motumbe pierre 149

 Page 150 sur 270

L‟organisation de fichiers séquentiels-indexés peuvent être bien supplémentée dans

un disque dur (HDD), comme nous pouvons le constater sur la Fig.4.14. ci-dessous.
Nous pouvons constater que l‟accès indexé du maitre index au cylindre, se fait
d‟une manière aléatoire, au niveau d‟un cylindre, on peut précéder un accès
séquentiel.

Fig.4.14. Fichiers séquentiels indexés implémentés sur un disque dur

Un fichier à accès direct (fichier hashé)

Dans un fichier à accès direct (hashed file, fichier hashé), l‟adresse de chaque
enregistrement est déterminée par la fonction Hash, l‟algorithme « Hashing », tel
que nous pouvons le constater sur la figure ci-dessous.

© Kasengedia motumbe pierre 150

 Page 151 sur 270

Fig.4.15. Fichier à accès direct (fichier hashé)

Analyse comparative de différentes organisations des fichiers

Organisation de fichiers

Critères Séquentiel Indexé Hashé

Espace de Pas de gaspillage Pas gaspillage pour Pour permettre

stockage data, mais extra l‟addition,
pour index l‟effacement des
enregistrements
après chargement
initiale ensemble
d‟enregistrements

Retrait séquentiel Très rapide Modérément Impraticable à moins

sur clé primaire rapide d‟utiliser « hash index
»

Retrait aléatoire Impraticable Modérément Très rapide

sur clé primaire rapide

© Kasengedia motumbe pierre 151

 Page 152 sur 270

Retrait sur Possible, exige de Très rapide avec Pas possible au lieu
multiples clés parcourir tout multiples indexes d‟utiliser « hash
le fichier index »

Effacement Peut créer Facile si espace Très facile

enregistrement espace gaspillé peut être
on exige dynamiquement
réorganisation alloue, mais exige
maintenance des
indexes

Ajout nouvel Exige réécriture Idem Très facile, mais

enregistrement du… multiple clés

Travail
supplémentaire

Modifier Généralement, Facile, mais

enregistrement exige réécriture exige la
du fichier maintenance des
indexes

Fig.4.15. Analyse comparative organisation fichiers

Dans le schéma de la fig. ci-dessus est ressentie une analyse comparative des
organisations de fichiers séquentiels, indexés et hashé. L‟organisation de fichiers
séquentiels indexés combine les avantages des fichiers séquentiels et indexés.

© Kasengedia motumbe pierre 152

 Page 153 sur 270

CHAP 5. LES OPÉRATION D’ENTRÉES SORTIES

5.1. GESTION DES PÉRIPHÉRIQUES

5.1.1. Comment le système d’exploitation interagit avec les périphériques La gestion

des périphériques représente peut-être le défi le plus important d‟un système
d‟exploitation. Ce dernier doit contrôler tout un ensemble de périphériques avec les
différences multidimensionnelles telles que :
- La rapidité du périphérique ;
- Volume d‟informations ;
- Service proposé ;
- Direction du flux d‟informations; - Protocoles de communication.

Le système d‟exploitation doit pouvoir traiter un grand nombre de périphériques. Sur

certains systèmes de centaines de périphériques différents peuvent potentiellement
être connectés à la machine, chacun nécessitant une prise en charge propre par le
système d‟exploitation. L‟ensemble de cette gestion doit par ailleurs se dérouler
dans un environnement parallélisé. Les périphériques agissent, en général,
indépendamment de l‟unité centrale en fonction de leur propre synchronisation. Le
système d‟exploitation, qui la plupart de temps, s‟exécute sur une seule unité
centrale, doit donc gérer des requêtes simultanées en provenance d‟un grand
nombre de périphériques.
Bien qu‟elle doit traiter des ensembles divers de périphériques, l‟abstraction
présentée aux applications doit être la plus indépendante possible de ces
périphériques. Les caractéristiques physiques d‟un disque dur(HDD), CD-ROM,
imprimantes, etc… peuvent varier longuement, mais les applications doivent être
capables de lire ces périphériques ou d‟y écrire, comme s‟ils étaient tous identiques.

© Kasengedia motumbe pierre 153

 Page 154 sur 270

5.1.2. Principe pour connecter un périphérique à un système à microprocesseur

Les périphériques utilisés dans un système à microprocesseurs, peuvent être
classifiés en : - Périphériques de stockage (HDD, CD-ROM, bande
magnétique)
- Périphériques conversationnels (clavier + écran, terminal vidéo ou écran tactile,
…) ;
- Périphérique temps réel (utilisé par les systèmes à microprocesseurs pour la
commande de processus industriel, CAN(Convertisseur Analogique Numérique),
CNA(Convertisseur Numérique Analogique), moteur,…).
-
- Sur la Fig.5.1, est décrite la structure de principe pour connecter un périphérique
(un processus industriel à un système à microprocesseurs.

© Kasengedia motumbe pierre 154

 Page 155 sur 270

Interface

Contrôleur (unité Périphérique

de commande) (processus
industriel)

Bus système (Data, address, control)

Afin d‟être un plus pragmatique, considérons que le périphérique (ou processus) à

commander Fig. 5.1. Structure de principe pour connecter un périphérique à un est une
imprimante, laquelle est divisée en deux partiessystème à microprocesseur :
- Partie mécanique ;
- Partie électronique.

Afin de commander les moteurs appartenant à la partie mécanique ; la partie

électronique, constituée de circuits électroniques de commande, aussi appelée
contrôleur, doit par exemple être capable de mener les actions ci-après :
- Déterminer le moment quand on doit imprimer un caractère ;
- Déterminer la correctitude du caractère reçu (gestion d‟erreur de transmission) ;
- Déplacement de la tête d‟impression, après que chaque caractère ait été
imprimé ; - Vérifier si une feuille de papier est présente.
- Placer la tête au début d‟une ligne,…

La connexion du contrôleur au système à microprocesseur s‟effectue par l‟intermédiaire

d‟un ensemble de signaux appelés interface.

© Kasengedia motumbe pierre 155

 Page 156 sur 270

L‟interface peut être standardisée ou non standardisée.

5.1.3. Interfaces standard

Les interfaces standard peuvent être classifiées, en fonction de modalités

d‟information vers ou du périphérique. Ainsi, on peut parler d‟interface sérielle,
parallèle,… elles sont programmables, c‟est-à-dire leurs fonctionnalités sont fixées
par un programme.
Dans la catégorie des Interfaces standard, nous pouvons citer:
- PIO (Parallèle Input Output) ;
- PIA(Programmable Interface Adapter) ;
- PPI (Programmable Peripheral Interface) ;
- UART (Universal Asynchronous Receiver Transmitter);
- USART (Universal Synchronous Asynchronous Receiver Transmitter);
- ACIA (Asynchronous Communications Interface Adaptater);
TD : pour les interfaces susmentionnées, veuillez préciser
- L‟organisme de standardisation ou la société à la base du standard ;
- Son historique;
- Les produits technologiques ayant été vendus sur le marché ; - Compatibilité aux
microprocesseurs connus; - Les applications.

Sur la Fig.5.2., est décrite la structure de principe pour une interface en général,
l‟interface d‟un périphérique a besoin de plusieurs ports, par conséquent de plusieurs
adresses :
- Une adresse ou deux pour le port d‟entrée, sortie de data (données) selon que
la liaison est bidirectionnelle ou de deux ports unidirectionnels.
- Une adresse pour un port de sortie qui va contenir un mot de commande pour le
périphérique.

Puisque l‟état d‟un périphérique peut être exprimé par un ou deux indicateurs on
peut procéder à la réunification des indicateurs de plusieurs périphériques pour
former un registre, ayant un port commun avec une seule adresse. De la même
manière les signaux de commande pour plusieurs périphériques, peuvent relever

© Kasengedia motumbe pierre 156

 Page 157 sur 270

d‟un seul port pour un système avec un nombre réduit de ports, où nous avons un
mot d‟adressage A7, A6, …, A2 pour la sélection linéaire de
6 interfaces ;
A1A0 pour identifier 4 ports de chaque interface
Sur le tableau de la Fig.5.3 est présentée la sélection linéaire de 6 interfaces et 4 ports /
interface.

BUS DE DATA

Logique de
sélection

Buffer d‟entrée Buffer de

sortie

PE
BUS ADRESSE RI

}
PH
BUS CONTROL ER
IQ
UE

Fig 5.2. Structure de Principe d‟une interface

Fig.5.3. Sélection linéaire de 6 interfaces et 4 Ports/interface

A7A6 A5 A4 A3 A2 A1 A0 Ressource adressée

© Kasengedia motumbe pierre 157

 Page 158 sur 270

0 0 0 0 0 1 0 0 Interface 1 et 4 Ports différents

0 0 0 0 0 1 0 1
0 0 0 0 0 1 1 0
0 0 0 0 0 1 1 1
0 0 0 0 1 0 0 0 Interface 2 et 4 Ports différents
0 0 0 0 1 0 0 1
0 0 0 0 1 0 1 0
0 0 0 0 1 0 1 1
0 0 0 1 0 0 0 0 Interface 3 et 4 Ports différents
0 0 0 1 0 0 0 1
0 0 0 1 0 0 1 0
0 0 0 1 0 0 1 1

1 0 0 0 0 0 0 0 Interface 6 et 4 Ports différents

1 0 0 0 0 0 0 1
1 0 0 0 0 0 1 0
1 0 0 0 0 0 1 1

5.1.4. Contrôleur de périphériques

Dans le modèle le plus simple le contrôle des Entré/Sortie, l‟unité centrale de traitement
(CPU) communique directement avec les périphériques d‟entrée/sortie. Le CPU
prend en charge le contrôle de moindres détails de l‟opération périphérique. Ce type
de communication est de plus en plus rare ; on la trouve peut-être encore dans les
systèmes embarqués, contrôlés par microprocesseur et extrêmement spécialisés.
Dans un PC, le CPU Communique avec un contrôleur de périphériques. Une
commande classique du CPU ou contrôleur, peut être le lancement d‟une opération
de lecture pour un octet d‟informations depuis un appareil ou celle d‟un secteur

© Kasengedia motumbe pierre 158

 Page 159 sur 270

d‟informations depuis un disque. Le contrôleur de périphériques transmet au

périphérique les commandes plus détaillées, nécessaires à la réalisation de
l‟opération rapide. En déchargeant cette responsabilité d‟E/S sur le contrôleur, le
CPU est libre d‟accomplir simultanément d‟autres taches de traitement. Chaque
contrôleur d‟entrées/sorties est spécifiquement conçu pour gérer un type particulier
de dispositif. Ses capacités sont limitées et intégrées au contrôleur. La plupart de
contrôleurs peuvent servir plusieurs périphériques.

5.1.5. Registre de modules, contrôleurs de périphériques d’Entrée/sortie

Le nombre et la fonction des registres des modules dépendent des modules

d‟Entrée/Sortie impliqués. Le module d‟un dispositif simple d‟Entrée/Sortie peut disposer
de deux registres :
• Registre de données ;
• Registre de contrôle ;

Registre de données
Le registre de données est utilisé comme mémoire tampon, qui stocke la donnée à
échanger entre le CPU et le module d‟Entrée/Sortie.
Registre de contrôle
Le registre de contrôle contient les bits utilisés par le processeur central pour commander
le module d‟Entrée/Sortie.
Parmi les fonctions des bits du registre de contrôle, il y‟ a lieu de citer :
 Activer, réinitialiser l‟appareil ;
 Lancer une opération de lecture ;
 Communiquer le statut du périphérique au CPU ;
 Signaler la finie d‟une opération ;
 Indiquer différents types de conditions d‟erreurs.

© Kasengedia motumbe pierre 159

 Page 160 sur 270

Les modules contrôlant des dispositifs plus complexes, peuvent comporter un nombre de
registres supérieur à deux.

5.2. TYPES DE TRANSMISSION

5.2.1. Introduction
IL existe plusieurs critères pour classifier les types de transmission entre la carte de
communication d‟un ordinateur, émetteur et l‟extérieur. Parmi les types les plus
connus, il y‟a lieu de citer :
- Transmission parallèle ;
- Transmission série ;
- Transmission asynchrone ;
- Transmission synchrone ;
- Mode de transmission physique (simplex, half-duplex, full-duplex).
Dans ce qui suit nous allons expliquer les modes de transmission susmentionnés.

5.2.2. Transmission parallèle

Elle consiste à l‟envoi de 8 bits de données en parallèle, en utilisant un fil séparé

pour chaque bit. Ce mode de transmission est avantageux car on gagne en vitesse,
mais ne permet pas une transmission à longue distance. Elle peut être utilisée, par
exemple, entre un ordinateur et une imprimante. Sur le schéma de la Fig.5.4, est
illustré le principe de la Transmission
parallèle. 1
0 0
1 1
1
0
2 2
0
3 3
4 0
4
5 1 5
6 6

© Kasengedia motumbe pierre 160

 Page 161 sur 270

N.B. : 1≈5v
0 ≈ 0.2v

Unité source Unité destination

Fig.5.4. Transmission parallèle

5.2.3. Transmission sérielle

Si la distance entre les équipements s'agrandit, à cause du coût et de la
variation du délai de propagation du signal sur chaque câble (fil) individuel, on fait
appel à la transmission sérielle. En transmission sérielle, les données sont
transmises bit par bit dans un seul câble, de DTE source vers DTE destination. Mais
on utilise une paire de câbles, le deuxième étant utilisé comme niveau de référence
(Fig.5.5.a). Avant le transfert de données par le port série, elles subissent au niveau
de DTE source une conversion parallèle-série et au DTE destination, une conversion
série-parallèle, comme illustré à la Fig.5.5.b.

0 00 10 1 1 0

Source DTE
Destination

Signal de

Fig.5.5.a Transmission sérielle

© Kasengedia motumbe pierre 161

 Page 162 sur 270

Fig.5.5.b. Conversion parallèle-série, à la source, série- parallèle, à la destination

5.2.4. Transmission asynchrone

La transmission asynchrone est un mode de transmission utilisé pour envoyer une

information caractère par caractère, d'une manière aléatoire. Par exemple, un
utilisateur actionnant sur les tastes d'un "clavier", envoie les caractères en
intervalles aléatoires de temps. Chaque caractère transmis est en capsulé entre un
bit start et un ou plusieurs 'stop bit'. Sur la Fig.5.6., est décrit le caractère utilisé pour
la transmission asynchrone.

© Kasengedia motumbe pierre 162

 Page 163 sur 270

Stop bit
Start bit Start bit

Fig.5.6. Caractère utilisé pour la transmission asynchrone

Exemple
Considérons une situation où on a 1 bit start, 7 bits données, 1 bit parité, 2 bits stop;
supposons que nous envoyons 1100 bits dans un canal de communication. Quel
sera le taux d'utilisation du canal?

Solution

La situation évoquée ci-dessus nous donne un total de 11bits (= 1 +7+ 1 +2), dont 7
bits de données. Le taux d'utilisation utile est le rapport entre le nombre de bits de
données et le nombre total de bits: 7/11 = 0,63 = 63 %

5.2.5. Transmission synchrone

L'exercice de la section 1.7.3, démontre combien la transmission asynchrone n'est

pas efficiente du point de vue de l'utilisation de la capacité de la transmission,
surtout lorsqu'on veut transmettre un message contenant de vastes blocs des
caractères. La transmission synchrone est utilisée pour dépasser ce handicap.
Au lieu de fonctionner avec des caractères, elle utilise un bloc de données appelé
trame, dans laquelle on intègre des caractères dépourvues de bits start et stop. De
cette manière, les données envoyées sous forme de trames, utiliseront mieux la

© Kasengedia motumbe pierre 163

 Page 164 sur 270

capacité du canal de transmission. Sur la Fig.5.7, est présenté un format d'une

trame de données.

GESTION
SYN ENTETE STX X CARACTERES ETX D‟ERREURS SYN

Fig.5.7. Format général d'une

trame

5.2.6. Mode de transmission physique (simplex, half-duplex, full-duplex)

Les Mode de transmission physique peuvent être classifiés en trois modes de

communication:
Simplex ;
half-duplex ; full-duplex.

1) Mode simplex (unidirectionnel)

L'information est envoyée dans un seul sens. C'est ainsi que pour ce mode de
transmission décrit a la Fig.5.8., on peut utiliser le code correcteur d'erreurs au niveau du
récepteur.

POSTE POSTE
EMETTEUR RECEPTEUR

Fig.5.8. Mode de transmission simplex

2) Mode half duplex ou semi-duplex (bi directictionnel alterné)

Fig.5.9. présente le Mode de transmission half duplex ou semi-duplex ou bidirectionnell
alterné. Les deux postes se comportent différemment:
si le poste A est émetteur, le poste B sera récepteur;

© Kasengedia motumbe pierre 164

 Page 165 sur 270

si le poste B est émetteur, le poste A sera récepteur.

EMETTEUR RECEPTEUR
OU
RECEPTEUR EMETTEUR

Fig.5.9. Mode half duplex ou semi-duplex (bidirectionnel alterné)

3) Mode full duplex (bidirectionnel simultané)

Le full duplex est le duplex intégral. Quand l‟émetteur est en train d'émettre, il pourra
aussi recevoir.
Sur la Fig.5.10. est décrit le Mode de transmission full duplex (bidirectionnel simultané).

EMETTEUR RECEPTEUR
ET
RECEPTEUR EMETTEUR

Fig.5.10. Mode de transmission full duplex (bidirectionnel simultané)

5.3. Opérations d’Entrées/Sorties de base

Dans un ordinateur un système à microprocesseur, le CPU est obligé d‟échanger des

informations avec le monde extérieur, et les traiter.
Une fois les informations traitées, elles peuvent être affichées ou acheminées pour
commander différents appareils. Dans ce qui suit nous allons présenter différentes
techniques algorithmes, boitiers pour réaliser des opérations des Entré/Sorties

© Kasengedia motumbe pierre 165

 Page 166 sur 270

5.3.1. Entrées-Sorties spéciales contre entrées-sorties projetées/mappées sur la mémoire.

Selon la manière dont le CPU adresse un périphérique d‟Entrées/Sorties, on peut

distinguer deux cas :
- Entrée /Sorties projetées/mappées en mémoire
- Entrées/Sorties spécialisées

5.3.1.1. Entrées/Sorties projetées en mémoire

Dans ce cas d‟espèce l‟équipement d‟Entrée/Sortie est perçu comme une adresse de
mémoire. Un port d‟entrée sortie est considéré comme une adresse mémoire.
Généralement on réserve les dernières adresses de l‟espace mémoire pour adresser de
l‟espace mémoire pour adresses les ports d‟Entrées/sorties.
Les signaux MEMR, MEMW utilisés habituellement pour lire le contenu de la
mémoire, ou écrire dans une case mémoire seront utilisés pour agir sur les ports
d‟Entrées sorties, lire ou écrire une donnée. Sur le schéma de la Fig.5.11, est illustré
le principe des entrées-Sorties projetées en mémoire. Il convient de noter que bit
d‟adresse A15 est utilisé pour produire les signaux I/OR (Input output/Read), I/OW
(Input output/Write) destinés à la lecture, respectivement l‟écriture d‟un mot du port
d‟Entrée/Sortie.

© Kasengedia motumbe pierre 166

 Page 167 sur 270

Vers
mémoire

I/OR Vers
E/S

I/OW

A15
Fig.5.11. Entrées/Sorties projetées en mémoire

Il convient de noter que si A15 est égal à « 1 » toutes les adresses sur les bits A0 à
A14, spécifieraient un périphérique, mais si A15 =0, A0-A14 sélectionnent une position/
case mémoire.

5.3.1.2. Entrées-Sorties spécialisées

Dans le cas d‟instructions d‟entrées sorties spécialisées ; le processeur central

envoie des signaux de contrôle qui indiquent que le cycle en cours concerne les
entrées sorties et non la mémoire. C‟est ainsi qu‟au lieu que le CPU, utilise les
signaux MEMR, et MEMW, pour commander une unité d‟entrée-sortie, il va utiliser
des signaux spécialisés, notamment : - IOR (Input Output Read) : pour lire un mot
d‟un port d‟entrée-sortie ;
- IOW (Input Output Write) : pour écrire un mot dans un port d‟entrées/sortie.

Sur le schéma de la Fig.5.12., est décrit le principe d‟Entrées-sorties spécialisées.

© Kasengedia motumbe pierre 167

 Page 168 sur 270

Le bus adresse sélectionnera un registre, un emplacement dans le périphérique. Le

bus de contrôle va spécifier quelle est l‟opération qui doit être effectuée. Ceci est la
conception standard dans la plupart des systèmes à microprocesseur.

VERS
MEMOIRE

VERS
E/S

Fig.5.12. Entrées-sorties spécialisées

5.3.2. Interfaces standards

5.3.2.1. PIO (Programmable Input Output) Intel 8255

PIO I8255 est un composant de catégorie de circuits intégrés LSI (voir Fig.5.13). Il
comprend 24 lignes d‟Entrée/Sortie, pouvant s‟interfacer directement avec tout
circuit compatible TTL. Le microprocesseur peut écrire „‟0‟‟ ou „‟1‟‟ sur n‟importe
quelle ligne série ou, lire l‟état de n‟importe quelle ligne d‟entrée. Préalablement à
son utilisation, le microprocesseur doit configurer le 8255A, en écrivant dans un ou
plusieurs registres internes programmables. Les 2 lignes d‟adresses assurent la
sélection d‟un de 4 registres interne (A, B, C et un registre de commande
(programme)). Ce dernier dernier détermine les ports qui seront utilisés entrées et
ceux qui feront office des sorties.

© Kasengedia motumbe pierre 168

 Page 169 sur 270

8
CS
Port A
A0-A1
8
PIO
WR Port B
8255A
RD
8
RESET Port C

D0-D7

Fig.5.13. PIO 8255A d‟Intel

Le composant circuit LSI, PIO exécute les fonctions suivantes :

- Décodage d‟adresse
- Mémorisation et multiplexage de données en entrée et en sortie « prise de contact
»
- Sur le schéma de la Fig.5.14.. Est présentée la structure de I8255

Fig.5.14. Structure interne de I8255

© Kasengedia motumbe pierre 169

 Page 170 sur 270

Chacun de principaux constructeurs de microprocesseurs a sa propre version d‟interface

parallèle programmable (« PIO »). Tous ont des fonctions similaires.

Il convient de signaler que ce circuit peut être utilisé pour la commande de processus
industriels, notamment celle d‟un robot industriel. Sur la Fig.5.16a est décrit le
principe de l‟utilisation d‟une interface de commande par programme d‟un petit
robot dont les degrés de liberté sont commandés par de moteurs pas a pas.

Comme vous pouvez le constater sur la figure, un amplificateur de puissance amplifie le

courant faible venant du I8255 pour obtenir un courant suffisant pour les moteurs pas a pas.

Il convient de nous rappeler que le moteur pas à pas est commande par une suite
d‟impulsions qui détermine son mouvement dans un sens, ou dans un autre. Enfin,
sur la Fig.5.16b est expose un tableau décrivant la séquence d‟impulsions qui doit
être envoyée pour faire tourner un moteur dans le sens horaire et anti-horaire. Φ1, Φ2,
Φ3, Φ4 représentent les quatre bobines du moteur pas à pas du robot. Le
traducteur X/Tension permet de réguler le mouvement de
ROBOT
Micro Interface AMPLIFICATEUR avec
ordinateur avec DE PUISSANCE moteur pas
I8255I à pas

TRADUCTEUR
CAN
X / TENSION

Fig.5.16a. Interface entre un micro-ordinateur et un robot (avec moteur pas à pas)

différents moteurs, traduisant les déplacements en tension, avant qu‟un CAN

(Convertisseur Analogique Numérique) puisse convertir la tension en donnée
numérique exprimant le déplacement du moteur.
Sens anti-
Sens horaire
horaire

Φ1 Φ2 Φ3 Φ4 Φ1 Φ2 Φ3 Φ4

1 0 0 1 1 0 0 1

© Kasengedia motumbe pierre 170

 Page 171 sur 270

1 1 0 0 0 0 1 1

0 1 1 0 0 1 1 0

0 0 1 1 1 1 0 0

Fig.5.16b. Séquence d‟impulsions pour faire tourner le moteur pas à pas dans le sens
horaire, anti-horaire.

5.3.2.2. UART (Universal Asynchronous Receiver transmitter), USART (Universal

Asynchronoums synchronous Receiver Transmitter)

5.3.2.2.1. Principe de fonctionnement d’un UART et USART

Plusieurs périphériques exigent des communications sérielles : clavier ; disque ;

bandes magnétiques ; carte réseau, etc… Alors que dans l‟ordinateur, les données
sont transmisses entre le CPU et les différents modules d‟Entrées/Sorties en mode
parallèle. En vue de réaliser ce desideratum, on fait appel aux UART (Universal
Asynchronous Receiver Transmitter) et USART (Universal Synchronous
Asynchronous Receiver Transmitter), qui ont comme fonctions essentielles la
conversion:

- série–

parallèle ; -

parallèle–série.

D‟une manière plus explicite, il s‟agit de :

1) prendre une série de bits, venant de l‟extérieur, via liaison serielle, et la co

vertir en données parallèles, qui seront injectées dans le bus data de l‟ordinateur.
Cette fonctionnalité est appelée SIPO (Serial In Paralel Out)

2) accepter les données en parallèle, provenant du bus data de l‟ordinateur et les

convertir en une série de bits comportant éventuellement : un bits start, un bit de

© Kasengedia motumbe pierre 171

 Page 172 sur 270

parité et des bits de stop, pour les envoyer sur une liaison sérielle, attachée a
l‟extérieur. Cette fonctionnalité est appelée PISO (Paralel In Serial Out)

UART et USART fonctionnent de la même manière, à la seule différence, que USART

peut aussi réaliser de la transmission synchrone.

Sur la Fig.5.17. est exposée la structure d‟un UART

Il convient de noter que les fonctionnalités USART sont incluses dans de cartes de

Entrée série
Horloge Récepteur Sortie parallèle

Entrees/Sorti Emetteur Sortie série

es parallèles

Contrôle Signaux d‟état

Fonctions de
commandes

Fig.5.17. Structure d‟un UART

communication comme : carte Ethernet, carte HDLC,….

Comme Exemples UART, il y‟a lieu de citer :

- ACIA (adaptateur interface pour communications asynchrones)

- ML6850 (de Motorola)

Comme USART le circuit d‟Intel : I8251

5.3.2.2.2. I8251 (un USART standard

Sur la Fig.5.18a., sont présentés la structure et les signaux du circuit intégré I8251,
proposé par la société INTEL.

© Kasengedia motumbe pierre 172

 Page 173 sur 270

Le circuit USART I8251 permet l‟émission et la réception synchrone des données en

plus de la transmission asynchrone.

Ainsi, Il est important de noter que USART = UART + USRT.

USART I8251 a cinq registres internes :

-données reçues ;

-données à émettre ;

-mode

-état

-commande

Au démarrage, le premier octet de commande envoyé au 8251 va établir le mode

(synchrone ou asynchrone). L‟octet de commande suivant va être mémorisé comme
commande. La commande spécifie la longueur de mots et d‟autres paramètres. Le
tableau de la Fig.5.18b, fournit la table de vérité des signaux de commande du bus
du 8251.

Intérieur Micro-ordinateur

EMMETEUR TxD

RxD
RECEPTEUR

D0-D7 TAMPON BUS

DONNEES
RESET
CLK
C/

© Kasengedia motumbe pierre 173

 Page 174 sur 270

Fig.5.18a. La structure et les signaux du circuit intégré I8251

C/D RD WR CS OPERATION

0 0 1 0 8251 TO DATA BUS (READ)

0 1 0 0 DATA BUS TO 8251 (WRITE)

1 0 1 0 STATUS TO DATA BUS

1 1 0 0 DATA BUS TO CONTROL

- - - 1 DATA BUS TO 3 – STAT

Fig.5.18b. table de vérité des signaux de commande du bus de I8251.

Sur la Fig.5.19, est proposé une manière d‟interconnecter le circuit I8251 avec par
exemple le microprocesseur I8080. Comme vous pouvez le constater, on a montré
essentiellement la connexion aux trois principaux bus (DATA, ADDRESS,
CONTROL)

© Kasengedia motumbe pierre 174

 Page 175 sur 270

CONTROL BUS

ADDRESS BUS

DATA BUS

8251

TxD CRT
CRT
Terminal
RxD controller Keyboard

RxC BAUD RATE

TxC GENERATOR

Fig.5.19. Interface I8251 au Microprocesseur I8080

5.3.3. Méthodes de contrôle des opérations d’entrées-sorties

5.3.3.1. Polling, Entrée/sortie programmée, par sondage (« scrutation »)

Pour ce type de transfert, le CPU commence par interroger si une unité d‟E/S est
prête pour une opération d‟entrée/sortie. Le transfert de données de CPU vers l‟unité
E/S ou de l‟unité E/S vers le CPU s‟effectuera suivant la logique de Fig.5.20. a, b. Le
transfert, implanté en software, est totalement contrôlé par le CPU, car les données
passent par le CPU du système
(généralement via l‟accumulateur) .Un désavantage majeur de cette méthode est que le
transfert est relativement lent est mobilisé entièrement le CPU.

Le transfert de données par CPU est aussi appelée polling, methode interrogative, ou
entréesortie programmée.

© Kasengedia motumbe pierre 175

 Page 176 sur 270

P1

P2

CPU

Fig.5.20.a. Méthode d‟Entrée/Sortie Polling.

Pn
MEMOIRE

CPU

P1E/S P2E/S P3 E/S

Fig.5.20.b Méthode d‟Entrée/Sortie Polling.

En entrées-sorties programmées, tous les transferts vers les périphériques, en

venant d‟eux, sont effectives par le programme. Le processeur envoie et demande
les données, toute l‟opération d‟entrée-sortie est sous le contrôle du programme qui
s‟exécute.
La méthode de base pour déterminer si une opération est nécessaire, ou possible
est d‟avoir recours aux indicateurs « flags » un indicateur est un bit qui lorsqu‟il est à
un signifie qu‟une condition qui nécessite l‟attention s‟est présentée. Par exemple :
- Pour un périphérique d‟entrée, l‟indicateur, peut indiquer que « le tampon est
plein » donc le périphérique est prêt ;
- Pour un périphérique de sortie, l‟indicateur peut montrer que le tampon est
vide », donc le périphérique est prêt

© Kasengedia motumbe pierre 176

 Page 177 sur 270

L‟indicateur est continuellement examiné par le programme : c‟est le « sondage ».

La caractéristique de cette approche est d‟utiliser un minimum de hardware au prix
d‟une forte surcharge software. Sur la Fig.5.20c. sont présentés les Indicateurs «
flags » utilisés dans le Polling

EP1 CPU

EP2

EP3

EP4

EP5

EP6

EP7

EP8

Fig.5.20c. Indicateurs « flags » utilisés dans le Polling

Un port est utilisé pour indiquer l‟état prêt des périphériques.

La méthode simple de lecture des indicateurs consiste à porter sur le bus de données
les états « prêt » de huit périphériques lorsqu‟on exécute l‟instruction « lecture des
états ».

© Kasengedia motumbe pierre 177

 Page 178 sur 270

Le port ou on lit les états peut être n‟importe quelle adresse convenablement
décodée. Quand le registre a été lu le programme examine chaque bit, et se branche
sur la routine de service convenable, si c‟est nécessaire.
L‟ordinogramme d‟une boucle d‟interrogation apparait sur la Fig.5.21. , le
programme boucle continuellement à travers une série de tests pour déterminer si
une série de tests pour déterminer si une entrée-sortie peut, on doit être effectuée.
Quand un périphérique ayant besoin qu‟on s‟occupe de lui est trouvé la routine de
service adéquate est activée, les sondages recommencent lorsqu‟elle est activée.

P1 OUI
Demande
service
NON Routine service
O U I

OUI
P2
Demande
service
NON
Routine service
. O U I

OUI
P3
Demande
service
NON Routine service
O U I

Fig.5.21. Ordinogramme de la boucle d‟interrogation

© Kasengedia motumbe pierre 178

 Page 179 sur 270

5.3.4. Opération d’Entrée-sortie par interruption

5.3.4.1. Principe d’Opération d’Entrée-sortie par interruption

La Méthode d‟Entrée-sortie programmée a deux limitations :

1. Elle fait perdre du temps au processeur puisqu‟il examine chaque fois l‟état de tous
les périphériques le plus souvent inutilement.
2. Elle est lente par essence puisqu‟on vérifie l‟état de tous les périphériques avant de
revenir à l‟un d‟entre-eux.
Cela peut être implémentable dans certains systèmes « temps réel », ou un
périphérique exige d‟être servi dans un temps donné. En particulier quand un
système inclut des périphériques rapides, des entrées-sorties programmées peuvent
n‟être pas assez rapides. Des périphériques rapides comme les disques HDD ou les
écrans exigent un temps de réponse presque instantané pour transférer des
données sans perte d‟information.
Le sondage est un mécanisme synchrone, alors que l‟interruption est un mécanisme
asynchrone. Le principe de l‟opération d‟Entrée-sortie par interruption est illustré à la
Fig.5.22. Le contrôleur de chaque périphérique est relié à une ligne d‟interruption
par la quelle, il transmet une demande d‟interruption ou microprocesseur, en
générant une impulsion, s‟il a besoin d‟être servi.

© Kasengedia motumbe pierre 179

 Page 180 sur 270

MEMOIREMEMO
IRE

CPUCPU

P1E/SP P2E/SP P3
1E/S 2E/S E/SP3

Fig.5.22. Principe d‟une opération d‟entrée-sortie par Interruption

Le microprocesseur examine s‟il y‟a des interruptions à la fin de chaque instruction.

S‟il y‟a une interruption, il va la traiter sinon va chercher l‟instruction suivante ceci
est illustré sur la Fig.5.23.

© Kasengedia motumbe pierre 180

 Page 181 sur 270

CPU EXECUTE
INSTRUCTION

REQUET OUI INTERR NO

E UPTION N
INTERR MASQUE
UPTION E

NO
N
PROCHAINE Traitement
INSTRUCTION Interruption

Fig.5.23. Comment CPU vérifie une requête d‟interruption

Afin de résoudre problème de niveaux de priorités entre différents périphériques a

été introduit le PIC (Programmable Interrupt Controller) (Contrôleur d‟interruption
programmable) , auquel tous les périphériques devront envoyer leur requête
d‟interruption.

Après que ce dernier ait été saisi de la demande d‟un périphérique, il transmet une
interruption au CPU, via par exemple le signal INT (INTerrupt request) . Si celui-ci est
d‟accord, il lui envoie une reconnaissance de l‟interruption INTA (INTerrupt
Acknowledge). Le microprocesseur arrêtera le programme principal pour exécuter le
sous-programme, la sous-routine, attachés au périphérique demandeur.

Avant de lancer ce sous–programme, il commence d‟abord à sauver le contexte de

son programme principal. Une fois terminée l‟exécution du sous-programme
d‟interruption, il va restaurer le contexte sauvegardé, dans le but de reprendre le
programme principal au niveau auquel il a été interrompu, dans le même contexte
connu avant son interruption.

© Kasengedia motumbe pierre 181

 Page 182 sur 270

Il convient de noter que sauver le contexte, consiste à sauver généralement dans une
pile, certaines données importantes du programme, se trouvant dans les composants ci-
après du microprocesseur :
- CO (compteur Ordinal), qui garde en permanence l‟adresse de l‟instruction suivante
à exécuter ;
- Registre AC (Accumulateur) ;
- RI (Registre d‟instruction) ;
- PSW (Programme status) ; - De différents registres généraux.

Dans l‟hypothèse où, on n‟ait pas besoin de beaucoup de niveaux d‟interruption, un

périphérique peut envoyer directement un signal d‟interruption au CPU, sans passer
par un circuit de type PIC, tel que nous l‟avions évoqué précédemment.

Fig.5.24. présente un schéma simplifié d‟un système utilisant un contrôleur

d‟interruption (PIC). Il convient de noter que le PIC résout aussi le problème de
conflits entre différents périphériques qui initient l‟interruption en même temps

P1

INT IREQ1

CPU PIC IREQ2

INTA P2
IREQn

Pn

DONNEES

ADRESSE

Fig.5.24. Méthode d‟Interruption via PIC.

Si un système utilise plus de 8 périphériques, les circuits PIC peuvent être mis en cascade,
comme nous pouvons le constater sur la Fig.5.25.

© Kasengedia motumbe pierre 182

 Page 183 sur 270

© Kasengedia motumbe pierre 183

 Page 184 sur 270

INT Cascade (I8259

IRQ0
PIC
IRQ1
IRQ
IRQ0 2
IRQ3
IRQ4
IRQ5
IRQ6

IRQ0
PIC
IRQ1
IRQ
IRQ0 2
IRQ3
IRQ4
IRQ5
IRQ6

IRQ0
PIC
IRQ1
IRQ
IRQ0 2
IRQ3
IRQ4
IRQ5
IRQ6

Fig.5.25. Pour un système avec plus de 8 périphériques, les circuits PIC sont mis en
cascade

5.3.4.2. PIC (Programmable Interrupt Controller) I8259, contrôleur d’interruption

proposé par INTEL

© Kasengedia motumbe pierre 184

 Page 185 sur 270

Horloge
IR0
INT Clavier
IR1
INTA IR2

MICRO
RD 8259A IR3
CONTROLER
PROCESSEUR
WR D‟INTERRUPTION IR4

A0 IR5

CS IR6 Disque

D0-D7 +5V IR7 Imprimante

Fig.5.26. Utilisation de 8259A d‟Intel comme contrôleur d‟interruptions

Le principe du „‟transfert par interruption‟‟ a été déjà expliqué. Le circuit Intel I8259A
présenté à la Fig.5.26. ci–après est utilisé sur le micro-ordinateur IBM PC, PC /AT,
PS/2 et divers systèmes compatibles. Plusieurs dispositifs de niveaux de priorité
différents peuvent être connectés au I8259A, ainsi le 8259A pourra arbitrer en cas
d‟une demande concurrente d‟interruption. D‟une manière générale l‟équipement
attaché au niveau IRO est plus prioritaire et le IR7 est moins prioritaire.

5.3.5. Opération d’Entrée/Sortie par DMA (Direct Memory Access)

5.3.5.1. Principe du DMA

Le DMA est souvent utilisé, lorsqu‟on veut réaliser une opération E/S avec un
périphérique rapide. Le transfert s‟effectuera directement entre le périphérique et la
mémoire sous la forme de blocs de données, sous le contrôle d‟un circuit spécialisé
DMA (Direct Memory Access), sans que le CPU puisse intervenir.

L‟armement du contrôleur DMA (programmation) consiste à la détermination de :

- Adresse bloc de départ ;

- Adresse bloc d‟arrivée;
- Nombre octets à transférer; - Direction de transfert;

© Kasengedia motumbe pierre 185

 Page 186 sur 270

- Adresse du périphérique.

Les DMAC peuvent être classifiés selon leur accès aux bus (data, address, control) :
- DMAC peut suspendre le CPU ;
- DMAC peut voler les cycles mémoires au CPU ; - DMAC peut rallonges les cycles
d‟horloges.

Lorsque le contrôleur désire acquérir le bus de données de manière à effectuer un

transfert, il en informe le CPU en activant une ligne que nous appellerons HOLD. Ce
dernier se déconnecte du bus (physiquement, il met ses lignes (BUS) en état de très
haute impédance (appelée aussi impédance infinie)) et en avertit le DMA en activant
une ligne HOLDA.

A partir de ce moment, le DMA a accès au bus et peut transférer les données. Le

contrôleur DMA libérera le bus en désactivant sa sortie HOLD, ce qui forcera le
processeur à désactiver sa sortie HOLDA et il aura de nouveau accès au bus. La
firme INTEL est parmi les premières à avoir lancé sur la marche ce genre de
contrôleurs sous forme de circuits intégrés. Il y‟a lieu de citer : I8257A ; I8237A.

5.3.5.2. Fonctionnement du DMA (Direct Memory Access)

Le Fonctionnement du DMA peut etre articulé en étapes ci-

après: - contrôleur DMA active HOLD pour informer

CPU

- CPU met lignes bus en impédance infinie, s‟il est d‟accord - CPU active HOLDA

- Le Transfert s‟effectue entre la mémoire et le périphérique, via DMA qui prend la

place du CPU

- Le DMA désactive HOLD, cela force le CPU à désactiver HOLDA

Sur le schéma des Fig.5.27.a, Fig.5.27b, Fig.5.27c, sont décrites les différentes étapes du
fonctionnement de DMA.

© Kasengedia motumbe pierre 186

 Page 187 sur 270

16
CPU MEMOIRE
ADDRESS

DATA

Fig.5.27a. CPU a accès à la Mémoire

© Kasengedia motumbe pierre 187

 Page 188 sur 270

CPU MEMOIRE

HOL

DMAC
INT
Fig.5.27.b. DMA interrompt CPU Contrôleur périphérique

MEMOIRE
CPU

HOLDA DONNEE
S MEMW
DMAC
ACK Contrôleur périphérique

Fig.5.27c. DMA prend la place du CPU, le transfert s‟effectue directement entre la

mémoire et le périphérique

Par ailleurs, Il y‟a lieu de relever, comme vous pouvez le constater sur la Fig. 5.28,
le fait que le circuit DMA comprend au moins quatre registres accessibles en
lecture/écriture par le processeur central: - Pointeur (500);

- Compteur (64);

- Adresse Equipement E/S (4); - Sens du transfert (1).

© Kasengedia motumbe pierre 188

 Page 189 sur 270

Compteur
Adresse

CPU DMA Mémoire

500
64 Contrôleur
500
7 série V24
1

Adresse
équipement Sens du
E/S transfert

«1»

Fig.5.28. Système équipé d’un circuit DMA

5.3.6. Canaux d’Echange de données

Dans le cas des gros ordinateurs (main frames), la méthode employée pour les
opérations d‟entrées-sorties est quelque peu différente. Ces ordinateurs ont en effet
à effectuer tellement d‟échanges avec des périphériques rapides que le DMA et
Interruption traditionnels deviennent inefficaces, à telle enseigne qu‟on fait appel à
de véritables processeurs d‟E/S appelés canaux de données ou canaux d‟E/S.

Les canaux d‟Entrée/sortie sont plus sophistiqués que les contrôleurs d‟Entrée/sortie
et peuvent même contenir leur propre CPU. Ils exécutent des programmes de canal
pouvant être changés dans la mémoire principale ou dans la propre mémoire du
canal

Comme nous pouvons le constater sur l‟illustration de Fig.5.29, on distingue deux catégories :

- Canaux spécialisés commandant les périphériques de même type, à haute vitesse de

transfert (disques) ;

© Kasengedia motumbe pierre 189

 Page 190 sur 270

- Canal multiplexé pouvant gérer plusieurs échanges simultanés avec de types de

périphériques différents à faible vitesse de transfert (exemple : terminaux, imprimantes)

Bus mémoire
Mémoire
principale

Processeur Bus d‟E/S

Processeur d‟E/S Processeur d‟E/S

(canal) (canal)

Contrôleur des Imprimante Disque Disque Disque

terminaux

Fig.5.29. Canaux d‟Echange de données d‟un ordinateur de grande puissance

5.4. Organisation des dispositifs d’Entrées/sorties

Bien que différents dans le détail, les ordinateurs sont conçus à partir des
architectures relativement similaires. Les dispositifs d‟Entrée/sortie, la mémoire et le
CPU (processeur centrale) communiquent entre eux par l‟intermédiaire d‟un ou
plusieurs bus de communication. Les machines les plus simples sont équipés d‟un
seul bus (de données), auquel sont reliés tous les périphériques d‟Entrée /sortie, la
mémoire, le processeur central comme illustre la Fig.5.30., ci-dessous.
Les communications ne peuvent avoir lieu qu‟entre deux éléments à la fois, un type
particulier de protocole est nécessaire pour contrôler le périphérique pouvant

© Kasengedia motumbe pierre 190

 Page 191 sur 270

communiquer sur le bus à un instant donné. Il s‟agit d‟arbitre du bus, dont son rôle
est de déterminer l‟entité pouvant utiliser le bus.

Fig.5.30. Architecture à Bus (de donnée) unique

Le matériel sélectionné peut communiquer avec n‟importe quel autre de son

choix, à condition que ce dernier soit relié au bus. Un mécanisme d‟adressage
identifie le dispositif de destination.
Il y‟a lieu aussi de signaler qu‟on peut trouver des bus multiples sur des
machines pour des raisons des performances. Les bus multiples permettent à
plusieurs communications de se dérouler simultanément. Le processeur central peut
par exemple communiquer avec un port série sur un bus, alors qu‟un disque
communique avec la mémoire sur un autre bus.
Cependant, l‟avantage des bus multiples est assez limité. La plupart des
communications impliquent soit la mémoire, soit le processeur central. Sans matériel
multi-accès particulier, ils ne peuvent communiquer qu‟avec un seul dispositif à la
fois.
Les architectures PC les plus récentes, outre le bus du processeur central, elles ont souvent
recours à trois types des bus suivants:
- Bus mémoire;
- Bus PCI (Péripheral component interconnect); - Bus ISA
(Industry Standard Architecture).

© Kasengedia motumbe pierre 191

 Page 192 sur 270

Bus mémoire
Le bus mémoire est un bus spécial permettant d‟optimiser les communications entre le
CPU et la mémoire.
Bus PCI
Le bus PCI est le bus standard pour connecter les périphériques.
Bus ISA
Le Bus ISA est relié au bus PCI pour offrir une compatibilité descendante avec les anciens
périphériques ISA.
Il sied aussi de rappeler qu‟il existe une version améliorée d‟ISA appelée EISA
(Extended ISA), qui a la particularité d‟intégrer aussi les fonctions d‟un bus, qui a été
introduit dans les fameux ordinateurs d‟IBM, PS/2, en 1987 appelé MCA (Micro
Channel Architecture). Sur le schéma de la Fig.5.31., ci-dessous est présentée une
architecture basée sur PCI utilisant les bus mémoire et ISA.

© Kasengedia motumbe pierre 192

 Page 193 sur 270

Bus mémoire
UC
Passerelle Mémoire
Mémoire PCI principale
cache

Moniteur Réseau

CD- Disque Contrôle Contrôleu Contrôleu

ROM SCSI ur SCSI r vidéo r réseau
SCSI

Bus PCI

Imprimante Com1 Haut-parleurs

Contrôleur Contrôleur Passerelle Carte

port port série ISA Son
parallèle

Bus ISA

Fig.5.31. Architecture basée sur le bus PCI avec bus mémoire, et ISA

5.5. ORGANISATION LOGICIELLE DES ENTRÉES/SORTIES

5.5.1. Considérations préliminaires

Le système d‟exploitation met en œuvre des primitives systèmes qui permettent aux
processeurs de requérir des services d‟Entrée/Sorties. Pour aller dans le sens de la
généralisation, le même ensemble élémentaire de primitives peut se trouver à la
disposition de toutes les entités. Dans certains cas, les primitives sont les même que
celles d‟un fichier d‟Entrée/Sortie. Compte tenu des caractéristiques uniques de
certains dispositifs, certaines fonctionnalités d‟Entrée/Sortie dépendantes du matériel
peuvent aussi être proposées.

© Kasengedia motumbe pierre 193

 Page 194 sur 270

Sous UNIX, l‟appel au superviseur remplit diverses fonctions, selon le dispositif auquel il
s‟applique et selon les arguments spécifiés, par exemple :
• Il est utilisé pour définir le débit en bauds, sur une ligne série ;
• Dans le cas d‟un lecteur d‟un CD-ROM, pour l‟effectuer un certain nombre
d‟actions ; Périphériques unidirectionnels.

Vitesse de l’appareil

Les périphériques d‟Entrée/Sortie peuvent être relativement lents.

Certains systèmes d‟exploitation proposent l‟option d‟émettre des opérations
d‟Entrée/Sortie non bloquantes. Ces opérations d‟Entrée non bloquantes peuvent
être gérées de deux manières :

• En utilisant des données d‟entrée et mises en tampon, avant l‟appel système ;

• Le processus peut recevoir une notification à l‟achèvement des opérations d‟entrées.

Pour les opérations de sortie non bloquantes, la notification peut également être utilisée.

Exclusion mutuelle

La plupart des périphériques ne pouvant pas être partagés, leur utilisation par différents
processus, exigent l‟exclusion mutuelle.
Quel type de protection, le système d‟exploitation va-t-il offrir aux utilisateurs de ces
périphériques ?
Il y‟a lieu de retenir plusieurs options :

• Autoriser seulement un processus à la fois d‟avoir le périphérique ouvert ;

• Attribuer la propriété du périphérique à l‟utilisateur qui l‟a ouvert et refusé l‟accès aux
autres utilisateurs. Cette solution permet au propriétaire de substituer l‟accès par
défaut et d‟accorder l‟accès s‟il le dérive ;

• Traiter le problème au niveau de l‟application en mettant en œuvre une gestion

temporisée (spool) ou une autre solution comparable ;
• Ne rien faire. Laisser le problème entre les mains des utilisateurs.

© Kasengedia motumbe pierre 194

 Page 195 sur 270

Périphériques unidirectionnels

Certains périphériques traitent uniquement des entrées ou uniquement des sorties.

Le système d‟exploitation doit prendre soin, afin de gérer les requêtes qui ne
peuvent pas être réalisées par le périphérique.
Généralement, les périphériques doivent être ouverts avant que les Entrée/Sorties
puissent être réalisées. La procédure d‟ouverture peut inclure un paramètre qui
indique le type d‟accès souhaité. La tentative d‟ouverture d‟un périphérique pour le
mauvais type d‟Entrée/Sortie conduira surement à un échec.

5.5.2. Objectifs des logiciels d’Entrée/Sortie.

Les objectifs principaux des logiciels d‟Entrée/Sortie peuvent être articulés de la manière
suivante :
• Indépendance par rapport au matériel (device indépendance);
• Désignation universelle (uniform naming);
• Gestion des erreurs (error handling)
• Transferts synchrone (bloquant) et les transferts asynchrones
• La mise en mémoire tampon (buffering)

Indépendance par rapport au matériel

L‟indépendance par rapport au matériel est incontestablement un des concepts clés
des logiciels d‟Entrée/Sortie. Ce concept stipule qu‟il doit être possible d‟écrire des
programmes qui accèdent à n‟importe quel périphérique d‟Entrée/Sortie, sans qu‟il
soit nécessaire de préciser le matériel à l‟avance.
Par exemple, un programme qui lit un fichier en entrée doit être capable de lire un
fichier qui se trouve sur un disque dur, un CD-ROM, un DVD, ou une clé USB, sans
qu‟il faille modifier le programme en fonction du périphérique. En outre, on doit
pouvoir taper une commande comme
# Sort <input> <output>
Et qu‟elle puisse fonctionner pour n‟importe quel périphérique que la sortie aille sur le
disque ou sur l‟écran.

© Kasengedia motumbe pierre 195

 Page 196 sur 270

Il appartient au système d‟exploitation de régler les problèmes dus aux différences

entre les périphériques et au fait qu‟ils nécessitent des séquences de commande
différentes pour lire ou écrire.

Désignation universelle

Le principe de la désignation universelle est étroitement lié à l‟indépendance par

rapport au matériel. Le nom d‟un fichier ou d‟un périphérique doit être une chaine de
caractères ou un entier et ne doit dépendre en aucune manière du périphérique.
Sous UNIX, tous les disques peuvent être intégrés dans la hiérarchie du système de
fichiers d‟une manière arbitraire. Ainsi, l‟utilisateur n‟a pas besoin de connaitre le
nom qui correspond à un périphérique donné. Ainsi tous les fichiers et périphériques
sont adressés de la même manière, par leur chemin d‟accès. Par exemple, une clé
USB peut être montée (mounted), au point de montage /Usr/ast/backup, de manière
à ce que le fait de copier un fichier dans /Usr/ast/backup/, copie le fichier sur la clé
USB.

Gestion des erreurs

La gestion des erreurs est un autre point clé lié aux logiciels d‟Entrée/Sortie. En
général les erreurs sont gérées aussi près du matériel que possible. Si le contrôleur
découvre une erreur de lecture, il essaie de la corriger. S‟il ne le peut pas, c‟est le
pilote du périphérique qui la gère, en essayant par exemple de relire le bloc. De
nombreuses erreurs, telles les erreurs de lecture sont passagères : elles
disparaissent si l‟on répète l‟opération.
C‟est uniquement, lorsque les couches inférieures n‟arrivent pas à résoudre le
problème, que les couches supérieures en sont informées. Les erreurs sont souvent
récupérées de manière transparente au bas niveau, sans que les niveaux supérieurs
en aient connaissance.

© Kasengedia motumbe pierre 196

 Page 197 sur 270

Les transferts synchrones (bloquants) et les transferts asynchrones (pilotés par les
interruptions)

Les transferts synchrones et asynchrones sont également importants. La plupart des

opérations d‟Entrée/Sortie sont asynchrones : le processeur central commence le
transfert et passe à autre chose en attendant l‟interruption.
Mais, les programmes utilisateurs sont plus simples à écrire, si les opérations
d‟Entrée/Sortie sont bloquantes : après l‟appel système read, le programme est
automatiquement suspendu, jusqu‟à ce que les données soient disponibles dans la
mémoire tampon. C‟est au système d‟exploitation de faire en sorte que les
opérations pilotées par les interruptions aient l‟air bloquant pour les programmes
utilisateurs.

La mise en mémoire tampon

La mise en mémoire tampon est un autre principe important des logiciels d‟Entrée/Sortie. Il
arrive souvent que les données qui provenaient d‟un périphérique ne puissent pas être
stockées directement dans leur emplacement final. Par exemple, lorsqu‟un paquet se
présente en provenance du réseau, le système d‟exploitation ne saura pas où le placer,
avant de l‟avoir rangé, c‟est ainsi qu‟on le place provisoirement dans la zone tampon.

5.5.3. Structure en couches des logiciels d’Entrée/Sortie

Les logiciels d‟Entrée/Sortie s‟organisent typiquement en quatre couches placées

sur le matériel, comme nous pouvons le constater sur la Fig.5.32., ci-dessous.
Comme les fonctionnalités en couches et les interfaces peuvent différents d‟un
système à l‟autre, cette structure n‟est pas spécifique à un ordinateur.

Logiciel d‟Entrée/sortie (Niveau utilisateur)

Logiciel d‟indépendance du matériel (niveau

système d‟exploitation)

© Kasengedia motumbe pierre 197

 Page 198 sur 270

Pilotes de périphériques

Gestionnaires d‟interruptions

Matériel

Fig.5.32. Structure en couches des logiciels d‟Entrée/ Sortie.

5.5.3.1. Gestionnaires d’interruptions

La complexité du fonctionnement des interruptions au niveau le plus bas sont telles

qu‟elles deviennent une réalité, déplaisante qui ne peut être évitée. C‟est ainsi qu‟il
faut, les cacher, les enfermer dans les entrailles du système d‟exploitation, de façon
à ce que la partie du système d‟exploitation qui en connait l‟existence, soit aussi
réduite que possible. Le pilote du périphérique peut se bloquer en effectuant
certaines commandes :
 Un sémaphore ;
 Variable conditionnelle ;
 Liée à la messagerie de processus.

Lorsqu‟une interruption se produit, c‟est la procédure d‟interruption qui la gère et qui

sait ce qu‟elle doit faire. Elle peut alors décalquer le pilote qui l‟a invitée. Selon les
circonstances :
 Elle exécute simplement un V(s), P(s) sur un sémaphore ; Elle émet un signal sur
une variable conditionnelle ; Elle envoie un message au pilote bloqué.

Dans tous les cas, l‟interruption fera que tout pilote précédemment bloqué puisse de
nouveau s‟exécuter. Ce modèle fonctionne même si les pilotes sont structurés sous
forme de processus de noyau, possédant leurs propres états, piles et compteur
ordinal.
5.5.3.2. Les pilotes de périphériques

© Kasengedia motumbe pierre 198

 Page 199 sur 270

Il a été évoqué précédemment que chaque contrôleur possède des registres de

contrôle qui servent à lui adresser les commandes, à lire son état ou les deux. Le
nombre de registre de contrôle et la nature de commandes varient radicalement d‟un
périphérique à l‟autre. Par exemple, un pilote de souris, doit accepter les
informations provenant de la souris et qui lui indiquer la distance à parcourir, ainsi
que le bouton sur lequel on a appuyé. Par contre, un pilote de disque doit connaitre
les secteurs, pistes, cylindres, têtes, mouvements du bras, mouvement du moteur,
temps d‟établissement de la tête et tout autre mécanisme permettant au disque de
fonctionner correctement. Ces pilotes sont par conséquent, très différents.
Par conséquent, chaque périphérique d‟Entrée/Sortie connecté à un ordinateur doit
disposer d‟un programme spécifique au périphérique pour le contrôler. Ce
programme appelé pilote de périphérique (device driver), est généralement écrit par
le fabricant du périphérique et livré avec.
Dans la mesure où chaque système d‟exploitation a besoin de ses propres pilotes,
les fabricants de périphériques fournissent généralement les pilotes pour plusieurs
systèmes d‟exploitation.
Pour accéder au périphérique, autrement dit aux registres de commande, le pilote de
périphérique doit faire partie du noyau du système d‟exploitation, tout au moins dans
les architectures actuelles. Il est effectivement possible de construire des pilotes qui
s‟exécutent dans l‟espace utilisateur, en réalisant des appels systèmes pour lire et
écrire les registres des périphériques. Cela permet d‟éliminer la principale source de
pannes systèmes due aux pilotes logués qui interfèrent avec le noyau d‟une façon
ou d‟une autre.
Il sied de signaler que MINIX 3 est un exemple de système d‟exploitation dont les pilotes de
périphériques s‟exécutent en tant que processus utilisateur.
Les pilotes de périphériques interviennent normalement dans une couche située sous le
reste du système d‟exploitation, comme le montre la Fig.5.33., ci-dessus.

© Kasengedia motumbe pierre 199

 Page 200 sur 270

Fig.5.33. Place du pilote de périphérique dans l‟architecture.

En réalité toutes les communications entre les pilotes et les contrôleurs de périphériques
passent par les bus.
Les systèmes d‟exploitation classifient généralement les pilotes par catégories :
Périphériques d‟Entrée/Sortie par
blocs ; Périphériques d‟Entrée/sortie
de caractères.

Périphériques d’Entrée/Sortie par blocs

Par exemple les périphériques qui contiennent plusieurs blocs de données qu‟on peut
adresser séparément.
Périphériques d’Entrée/Sortie de caractères
Par exemple, le clavier, l‟imprimante, qui génèrent ou acceptent des flots de caractères.

5.5.3.3. Logiciel d’indépendance par rapport au matériel

© Kasengedia motumbe pierre 200

 Page 201 sur 270

La fonction de base de logiciel d‟indépendance par rapport au matériel consiste à

assurer des fonctions d‟Entrée/Sortie communes à tous les périphériques et fournir
une interface uniforme au logiciel utilisateur.
Parmi les fonctions du logiciel d‟indépendance au matériel, il y‟ a lieu citer :
 Interface uniforme pour les pilotes de périphériques;
 Gestion des erreurs;
 Allocation et libération des périphériques dédiés;
 Fournir une taille de bloc indépendante du périphérique.

5.5.3.4. Mise en mémoire tampon

La mise en mémoire tampon (buffering) est un autre aspect important, tant pour les
périphériques d‟Entrée/Sortie par bloc, que pour les périphériques d‟Entrée/Sortie
par caractères.
Prenons l‟exemple d‟un processus qui veut lire les données d‟un modem. Pour
traiter les caractères entrants, le processus utilisateur peut émettre un appel read et
se bloquer dans l‟attente d‟un caractère. La procédure de service de l‟interruption
remet le caractère au processus utilisateur et se bloque une fois le caractère placé à
un emplacement défini, le processus lit un autre caractère et se bloque à nouveau.
Ce modèle est illustré à la Fig.5.34.

Processus utilisateur

Espace
Utilisateu
r
2 2
Espace
Noyau

1 1 3

Modem Modem Modem Modem

(a)
(b) (c) (d)

© Kasengedia motumbe pierre 201

 Page 202 sur 270

Fig.5.3. (a) Entrée caractère sans mémoire tampon

(b)
mise en mémoire tampon dans l‟espace utilisateur
(c)
mise en mémoire tampon dans le noyau, suivi d‟une copie dans
l‟espace utilisateur
(d) double mémoire tampon dans le noyau
Le problème que pose cette méthode est que le processus utilisateur doit être exécuté à
chaque caractère entrant.
En vue d‟améliorer l‟efficacité, dans Fig.5.31.(b), (c), (d), sont proposés :
 Mise en mémoire tampon dans l‟espace utilisateur ;
 Mise en mémoire tampon dans le noyau, suivie d‟une copie dans l‟espace
utilisateur ; Double mémoire tampon dans le noyau.

5.5.3.5. Gestion des erreurs

Les erreurs sont bien plus courantes dans le contexte des Entrées/Sorties que dans
d‟autres contextes. Lorsqu‟elles se produisent, le système d‟exploitation doit les
gérer de la bonne manière possible. De nombreuses erreurs sont spécifiques au
périphérique et doivent être gérées par le pilote approprié, mais la structure de la
gestion des erreurs est indépendante du périphérique.
Les erreurs de programmation, par exemple sont un type d‟erreur d‟Entrée/Sortie.
Elles peuvent se produire dans les cas ci-dessous, quand un processus demande
une opération impossible :
 Ecrire dans un périphérique d‟entrée (clavier, souris, scanner, ….)
 Lire, à partir d‟un périphérique de sortie (imprimante, écran, table traçante,….).

On trouve, également des erreurs telles que :

 Une adresse de mémoire tampon incorrecte ;
 Un périphérique non valide, inexistant (par exemple, se référer au disque 3, alors
que le système ne contient que deux disques.

Pour prendre ces erreurs en charge, il suffit de retourner au processus appelant, le code
d‟erreur.

© Kasengedia motumbe pierre 202

 Page 203 sur 270

Les erreurs d‟Entrée/Sortie sont un autre type d‟erreurs.il convient de signaler les scenarios
suivants :
 On tente d‟écrire dans un bloc de disque endommagé ;
 On tente de lire les données provenant d‟un caméscope éteint.

Dans de tels cas, il appartient au pilote de déterminer, ce qu‟il convient de faire. S‟il ne le
sait pas, il retourne le problème au logiciel d‟indépendance du matériel.
L‟action entreprise par ce logiciel dépend alors de l‟environnement et de la nature de
l‟erreur. S‟il s‟agit d‟une simple erreur de lecture et qu‟il existe un utilisateur en
mode interactif, le logiciel peut afficher une boite de dialogue qui demande à
l‟utilisateur ce qu‟il veut faire:
 Recommencer un certain nombre de fois;
 Ignorer l‟erreur;
 Arrêter le processus appelant.

S‟il n‟y a pas d‟utilisateur, la seule option réellement disponible, est l‟échec de l‟appel
système ; avec un vide d‟erreur.
Certaines erreurs ne peuvent pas être traitées de cette manière. Par exemple une
structure de donnée importante, comme le répertoire racine, ou une liste de blocs
libres, peut avoir été détruite. Dans ce cas, le système doit afficher un message et
s‟arrêter.

© Kasengedia motumbe pierre 203

 Page 204 sur 270

IIème PARTIE

TRAVAUX PRATIQUES

SOUS L’ENVIRONNEMENT LINUX

© Kasengedia motumbe pierre 204

 Page 205 sur 270

I. INTRODUCTION : LES NOTION FONDAMENTALES

1. Quelles sont les deux principales fonctions d‟un système d‟exploitation ?

2. Que fait l‟UC quand il n‟y a aucun programme à exécuter ?
3. Quelle est la caractéristique commune aux déroutements, aux interruptions, aux
appels au superviseur et aux appels aux sous programmes.
4. Qu‟est-ce qui différencient les déroutements, les interruptions et les appels aux sous
programmes ?
5. Quel est le rôle d‟un système d‟exploitation ? Les interpréteurs de commandes et les
compilateurs font-ils parties du système d‟exploitation ?
6. Qu‟est-ce qu‟un système multiprogrammé ? Un système de traitement par lots ? Un
système en temps partagé ?
7. Parmi les instructions suivantes, lesquelles doivent être privilégié (à savoir, lesquelles
ne peuvent être exécutés qu‟en mode superviseur ?
a) Changement des registres de gestion des mémoires
b) Ecriture du compteur de programme
c) Lecture de l‟horloge
d) Réglage de l‟horloge
e) Changement de la priorité du processeur.
8. Un S.E. peut mettre en œuvre un périphérique d‟E/S de mémoire. Les opérations
d‟E/S du périphérique provoquent la lecture ou l‟écriture de l‟emplacement de la
mémoire correspondante. Quel est l‟inconvénient de ce type de périphérique ? doit-il
être accessible aux utilisateurs ou simplement aux administrateurs systèmes ?
9. Les applications suivantes, sont-elles des applications par lots ou interactives ?
a) Traitement de texte
b) Production de relevés bancaires mensuels
c) Calcul du nombre pi jusqu‟à un million de chiffres après la virgule
10. Pourquoi un ordinateur doit-il démarrer en mode superviseur lors de sa première mise
sous tension ?

© Kasengedia motumbe pierre 205

 Page 206 sur 270

11. Quelle est la taille maximale d‟un programme d‟initialisation du niveau 1 au début du
disque dur, sachant que le profil binaire valide est de 2 octets et la taille du secteur du
512 octets.
12. Enumérer les caractéristiques matérielles conçues pour assister de manière explicite
le système d‟exploitation ?
13. Qu‟est-ce qui différencie le déroutement, les appels aux superviseurs et les appels
aux sous programmes des interruptions ?
14. Qu‟est-ce qui différencie les appels aux sous programmes et les appels aux
superviseurs du déroutement et des interruptions ?
15. Pourquoi les programmes utilisateurs n‟ont-ils pas l‟autorisation d‟écrire dans des
emplacements de mémoires contenant un vecteur d‟interruption ?
16. Quelles sont les instructions suivantes qui doivent être privilégiées (à savoir lesquelles
ne peuvent être exécuté qu‟en mode superviseur ? a) Réglage du mode en mode
superviseur
b) Réamorçage
c) Lecture du registre d‟état
d) Désactivation de l‟interruption
e) Ecriture dans le registre d‟instruction

17. Les applications suivantes sont-elles les applications par lots ou des applications
interactives ?
a) Génération d‟un formulaire de déclaration de revenu
b) Génération d‟un formulaire de déclaration de TVA dans une entreprise
c) Simulateur des vols
18. Le S.E. et le programme d‟amorçage qui copie le système d‟exploitation dans la
mémoire doivent-ils être situés sur le même disque ? pourquoi ?
19. Quelles sont les caractéristiques communes aux déroutements, aux interruptions, aux
appels au superviseur et aux appels procéduraux ?
20. Qu‟est-ce qui différencie les déroutements, les interruptions, et les appels au
superviseur des appels procéduraux ?

© Kasengedia motumbe pierre 206

 Page 207 sur 270

21. Qu‟est-ce qui différencie les déroutements, les, appels procéduraux et les appels au
superviseur des interruptions?
22. Détailler ce qu‟est une interruption et le mécanisme de sa prise en compte.
23. Répondre à la question précédente en considérant le cas d‟un déroutement (trappe).
24. Préciser les différences entre interruption et déroutement.
25. Etablir les correspondances entre les termes :
(1) Multiprogrammation
(2) Système d'exploitation
(3) Machine virtuelle
(4) Temps partagé
(5) BIOS
(6) Système réparti

et les définitions :

A- gère les composants de l'ordinateur

B- permet d'augmenter le rendement du processeur
C- teste les composants de l'ordinateur
D- le processeur est équitablement partagé entre les utilisateurs
E- permet de partager des ressources sur un réseau
F- permet de masquer la complexité du matériel

26. Un système d'exploitation est un logiciel qui regroupe un certain nombre de services
nécessaires à l'exécution des programmes qu'un utilisateur peut ordonner. C'est à
travers sa composante logiciels de base (ou noyau système) qu'il gère toutes les
opérations destinées à contrôler et à commander de l'ordinateur et ses divers
périphériques. Sa seconde composante est formée quant à elle d'un ensemble
d'utilitaires qui ne sont vraisemblablement pas nécessaires pour démarrer à froid
l'ordinateur. Dans ce qui suit, on s'intéresse à classer divers services système selon
leur appartenance. Pour cela on vous demande de remplir le tableau suivant en
mettant une croix dans la case qui convient.

© Kasengedia motumbe pierre 207

 Page 208 sur 270

1) GESTION DE PROCESSUS

1. Que fait chacun des programmes

suivants : 1) int main( ) { int p=1 ;
while(p>0) p=fork() ; execlp(“prog”,
“prog”, NULL) ;
return 0 ;
} 2) int
i=2 ; int
main ( )
{ j=10;
int p ;
while(i-- && p = fork())
if(p<0) exit(1) ; j += 2;

© Kasengedia motumbe pierre 208

 Page 209 sur 270

if (p == 0) { i *= 3; j *=
3; }
else { i *= 2; j *= 2; }
printf(« i=%d, j=%d »,
i,j) ; return 0 ; }
3)
#include
<stdio.h>
#include
<unistd.h> int
main ( ) { int fd[2],
i=2; char ch[100];
while ( i)
{ pipe(fd);
if( fork())
{ close(fd[0]);
dup2(fd[1],1);
close(fd[1]);
break; } else
{ close(fd[1]);
dup2(fd[0],0);
close(fd[0]); }
i--; } scanf("%s",
ch);
printf("%s\n",ch)
; exit(0); } 4) int
i=4, j=10; int
main ( ) { int p ;
p = fork(); if(p<0)
exit(1) ; j += 2;
if (p == 0) { i *=
3; j *= 3; }

© Kasengedia motumbe pierre 209

 Page 210 sur 270

else { i *= 2; j *= 2; }
printf(“i=%d, j=%d”, i,j) ;
return 0 ;
} 5) int main ( ) { int p=1 ; for(int i=0 ;
i<=4 ; i++) if (p>0) p=fork( ) ; if(p !=-1)
execlp(“prog”, “prog”, NULL) ; else
exit(1) ; while( wait(NULL) !=-1) ;
return 0 ;
}

2. ORDONNANCEMENT DES PROCESSUS

Considérons n processus P1, P2, …, Pn, arrivés en même temps et insérés

dans cet ordre dans la file des processus prêts. Ces processus ne font pas
d‟E/S et leurs temps d‟exécution sont respectivement c1,… et cn. Le temps
de commutation est supposé nul.

a) Quel est le temps d‟attente moyen des n processus dans chacun des cas

suivants : - D‟un ordonnanceur circulaire avec un quantum qt.

- D‟un ordonnanceur sans préemption fonctionnant selon la discipline

premier arrivé, premier servi.

Dans quel cas, obtient-on un meilleur temps d‟attente moyen ?

b) Supposons que le nombre de processus est 5 et que leurs temps

d‟exécution sont égaux à : 2*qt + r avec r<qt.
 Montrez comment les processus vont utiliser le processeur dans le cas d‟un
ordonnanceur circulaire avec un quantum qt. Calculer le temps moyen de
séjour des processus.
 Quel serait le temps moyen de séjour des 5 processus dans le cas d‟un
ordonnanceur sans préemption fonctionnant selon la discipline premier arrivé,
premier servi. Dans quel cas, obtient-on un meilleur temps de séjour moyen ?

© Kasengedia motumbe pierre 210

 Page 211 sur 270

3. On considère 4 processus, A, B, C, D. On suppose que l‟exécution des

processus nécessite :
• Pour A : 7 unités de temps CPU, 3 unités de temps d'E/S et 5 unités de temps CPU.

• Pour B : 6 unités de temps CPU, 4 unités de temps d‟E/S, 4 unités de temps CPU.
Pour C : 5 unités de temps CPU.

• Pour D : 1 unité de temps CPU, 4 unités de temps d‟E/S et 2 unités de temps CPU.
On suppose que

• A se présente en premier, à l‟instant 0,

• B se présente à l‟instant 1,

• C se présente à l‟instant 9,

• D se présente à l‟instant 12.

Montrez comment les 4 processus vont utiliser le processeur dans chacun des
cas suivants :

 Chaque processus a son propre périphérique d‟E/S et l‟ordonnanceur

fonctionne selon Premier Arrivée Premier Servi PAPS (sans préemption).
Chaque processus a son propre périphérique d‟E/S et l‟ordonnanceur utilise
l'algorithme du tourniquet, avec un quantum de 5. Le temps de commutation
est égal à 0. Donnez, dans ce cas, les temps de séjour des processus A, B, C
et D.
 Les trois processus utilisent le même périphérique d'E/S dont la file d'attente
est gérée premier arrivée premier servi. L‟ordonnanceur du processeur utilise
l'algorithme du tourniquet, avec un quantum de 5.
Le temps de commutation est supposé égal à 0.

4. Les processus suivants sont soumis à l‟ordonnanceur aux temps indiques avec
la durée et le niveau de priorité associés (5 la plus faible priorité). Ils sont listés
dans le format (arrivée : durée : priorité): P1(0:10:3), P2(2:6:4), P3(4:8:2),
P4(6:12:1), P5(8:4:5), P6(8:3:5). A chaque unité de temps, l‟ordonnancement
peut changer en fonction des nouvelles taches arrivées. Donnez le diagramme
de GANNT, le temps de séjour, le rendement et le temps d‟attente pour chacun
des algorithmes d‟ordonnancement suivants:

© Kasengedia motumbe pierre 211

 Page 212 sur 270

 tourniquet avec un quantum de 3 où une tâche nouvellement arrivée est placée

en début de tourniquet et obtient immédiatement la main lorsqu‟un quantum vient
de se terminer,
 selon les priorités,

 La tâche avec le temps d‟exécution le plus court (SJF), la tâche avec le plus
court temps restant en premier (SRT),

 Selon l‟ordre d‟arriver (FCFS).

5. Soient trois processus concurrents P1, P2 et P3 qui partagent les

variables n et out. Pour contrôler les accès aux variables
partagées, un programmeur propose les codes suivants :
Semaphore mutex1 = 1 ;
Semaphore mutex2 = 1 ;
Code du processus p1 :
P(mutex1) ;
P(mutex2) ;
out=out+1 ;
n=n-1 ;
V(mutex2) ;
V(mutex1) ;
Code du processus
p2 : P(mutex2) ;
out=out-1 ;
V(mutex2) ;
Code du processus
p3 : P(mutex1) ;
n=n+1 ; V(mutex1) ;
Cette proposition est-elle correcte ? Sinon, indiquer parmi les 4 conditions requises
pour réaliser une exclusion mutuelle correcte, celles qui ne sont pas satisfaites ?
Proposer une solution correcte.

© Kasengedia motumbe pierre 212

 Page 213 sur 270

6. On veut effectuer en parallèle le produit de deux matrices A et B d‟ordre n

(nxn). Pour se faire, on crée m (m<n) processus légers (threads). Chaque
processus léger se charge de calculer quelques lignes de la matrice résultat
R: Pour j = 0 à n-1 R[i,j] = ¦ k=0,n-1 A[i,k]*B[k,j] ;
Donner sous forme de commentaires (en utilisant les sémaphores et les
opérations P et V), le code des processus légers : CalculLignes ( ).
Préciser les sémaphores utilisés et les variables partagées.
7. Deux villes A et B sont reliés par une seule voie de chemin de fer. Les trains
peuvent circuler dans le même sens de A vers B ou de B vers A. Mais, ils ne
peuvent pas circuler dans les sens opposés. On considère deux classes de
processus : les trains allant de A vers B (Train Avers B) et les trains allant de
B vers A (Train B vers A).
Ces processus se décrivent comme suit :
Train Avers B :
Demande d‟accès à la voie par A ;
Circulation sur la voie de A vers
B; Sortie de la voie par B; Train
B vers A :
Demande d‟accès à la voie par B ;
Circulation sur la voie de B vers A;
Sortie de la voie par A;
1) Parmi les modèles étudiés en classe (producteur/consommateur,
lecteur/rédacteur), ce problème correspond à quel modèle ?
2) Ecrire sous forme de commentaires en utilisant les sémaphores, les opérations P
et V, les codes de demandes d‟accès et de sorties, de façon à ce que les
processus respectent les règles de circulation sur la voie unique.

8. Considérons le problème producteur/consommateur, vu en classe. Adaptez la solution

suivante :
a) cas de n producteurs, n consommateurs et un seul tampon de taille (Max, il
peut contenir au plus Max messages). Les producteurs produisent des

© Kasengedia motumbe pierre 213

 Page 214 sur 270

messages et les déposent dans le tampon. Chaque message déposé dans le

tampon est récupéré (consommé) par un seul consommateur.

b) Au cas d‟un seul producteur, n consommateurs et n tampons de même taille

(Max). Chaque message produit par le producteur est déposé dans tous les
tampons en commençant par le premier. Le consommateur i récupère
(consomme) les messages déposés dans le tampon i.
Semaphore Mutex =1, Vide=Max, Plein=0 ;
Message tampon [Max] ;
Producteur ( )
{ int ip =0 ;
Message m ;
Repeter
{ m = creermessage() ;
P(Vide) ;
P(Mutex) ;
Tampon[ip]=
m; V(Mutex) ;
ip++ ;
V(Plein) ;
}tant que vrai ;
}
Consommateur( )
{ int ic =0 ;
Message m ;
Repeter
{
P(Plein) ;
P(Mutex) ; m =
Tampon[ic];
V(Mutex) ;
ic++ ; V(Vide) ;

© Kasengedia motumbe pierre 214

 Page 215 sur 270

}tant que vrai ; }

9. En utilisant le modèle de Réseau de Petri, modélisez le déterminisme du match de

football de FC RENAISSANCE & AS. VITA CLUB

10. On considère un ensemble de six tâches séquentielles {A, B, C, D, E ,F}. La tâche

A doit précéder les tâches B, C, D. Les tâches B et C doivent précéder la tâche E.
Les tâches D et E doivent précéder la tâche F. Réaliser la synchronisation de ces
tâches en utilisant les sémaphores

11. Etablir la matrice d‟incidence avant (Pre), la matrice d‟incidence arrière (Post) et
la matrice d‟incidence W du réseau ci-dessous :

© Kasengedia motumbe pierre 215

 Page 216 sur 270

T1

T5
P1

T2

P2 P5 P6
P4

T3

P3 T6

T4

12. Etablir la matrice d‟incidence avant (Pre), la matrice d‟incidence arrière (Post) et la
matrice d‟incidence W du réseau ci-dessous :

© Kasengedia motumbe pierre 216

 Page 217 sur 270

13. Déterminer la matrice d‟incidence ainsi que sa transposée associée au réseau de

Pétri de la Figure ci-dessus :

14. Sur un système doté de n U.C, quel est le nombre maximum de processus pouvant
se trouver dans les états prêt, exécution et bloqué ?
15. Sur un système doté de n U.C. quel est le nombre minimum de processus pouvant
se trouver dans l‟état prêt, exécution et bloqué ?
16. Quel est le principal avantage de la multiprogrammation ?
17. Quel est le principal inconvénient qui découle d‟un abus de multiprogrammation ?
18. Le pourcentage d‟attente des E/S, ω, d‟un processus est le pourcentage de temps
pendant lequel ce processus attend l‟achèvement des E/S, lors de l‟exécution dans
un environnement de monoprogrammation. Sur un système qui a recours à
l‟ordonnancement de tourniquet avec n processus, tous ayant le même
pourcentage d‟attente des E/S, quel est le pourcentage de temps d‟inactivité de
l‟UC en termes de ω.
19. Pour chacune de transition suivante entre les états d‟un processus, indiquez si la
transition est possible. Si c‟est possible, donnez un exemple d‟un élément qui peut
en être à l‟origine.
a) En exécution – prêt
b) En exécution – bloqué

© Kasengedia motumbe pierre 217

 Page 218 sur 270

c) En exécution – permuté – bloqué

d) Bloqué – en exécution
e) En exécution – terminé
20. Soit un système avec n processus, combien existe – t – il des manières
d‟ordonnancer ces processus ?
21. Sur un système recourant à l‟ordonnancement à tourniquet, quelle serait la
conséquence de l‟introduction d‟un meme processus à deux reprises dans la liste
des processus ?
22. Avec les processus répertoriers dans le tableau ci-après dessiner un schéma
illustrant leur exécution à l‟aide de : a) L‟algorithme FCFS
b) L‟algorithme SJF
c) L‟algorithme SRT
d) L‟algorithme à tourniquet (quantum = 2)
e) L‟algorithme à tourniquet (quantum = 1)
Processus Temps d‟arriver Temps de traitement

A 0,000 3

B 1,001 6

C 4,001 4

D 6,001 2

23. Pour les processus du tableau précédent, quel est le temps moyen de rotation
(arrondi au centième) si l‟on utilise. a) L‟algorithme FCFS
b) L‟algorithme SJF
c) L‟algorithme SRT
d) L‟algorithme à tourniquet (quantum = 2)
e) L‟algorithme à tourniquet (quantum = 1)

24. Pour les processus du tableau précédent, quel est le temps d‟attente de chaque
processus (arrondi au centième) si l‟on utilise.

© Kasengedia motumbe pierre 218

 Page 219 sur 270

1) L‟algorithme FCFS
2) L‟algorithme SJF
3) L‟algorithme SRT
4) L‟algorithme à tourniquet (quantum = 2)
5) L‟algorithme à tourniquet (quantum = 1)

25. Pour le processus du tableau précédent, quel est débit si l‟on utilise.
a. L‟algorithme FCFS
b. L‟algorithme SJF
c. L‟algorithme SRT
d. L‟algorithme à tourniquet (quantum = 2)
e. L‟algorithme à tourniquet (quantum = 1)

26. Pour les processus de tableau ci-après, dessiner un schéma illustrant leur
exécution en utilisant l‟ordonnancement de priorité. Un nombre de priorité
élevé correspond à une priorité plus importante.
a) Préemptif
b) Non préemptif
Processus Date d‟arrivée Cycle priorité
A 0,0000 4 3
B 1,0001 3 4
C 2,0001 3 6
D 3,0001 5 5

27. Pour le processus du tableau du numéro 13, quel est le temps de rotation (arrondi
au centième de chaque chiffre ? a) Préemptif
b) Non préemptif
28. Pour les processus du tableau précédent, quel est le débit moyen ?
29. Sur un système utilisant un les files multi niveaux à retour, un processus
entièrement tributaires de l‟UC a besoin de 14 secondes pour s‟exécuter. Si la

© Kasengedia motumbe pierre 219

 Page 220 sur 270

première file utilise un quantum de temps est 2 et qu‟à chaque niveau, le quantum
de temps augmente de 5 unités de temps. Combien de fois sera interrompu le
travail et dans quelle file se trouvera – t – il lorsqu‟il s‟achèvera ?
30. Sur un système Unix, un appel système permet d‟augmenter ou de réduire la
valeur de la priorité associée à un processus. Après l‟augmentation de la valeur de
la priorité de processus, on observe que le système semble s‟exécuter plus
lentement. Pourquoi ?
31. Le choix d‟un algorithme d‟ordonnancement non – préemptif est – il un choix
judicieux pour un système interactif. expliquer brièvement pourquoi.
32. Un système fait appel à un algorithme d‟ordonnancement avec priorité préemptif
(les processus au numéro de priorité élevé ont une priorité plus importante). Les
processus ont introduits dans le système avec une priorité de 0. Lors de l‟attente
dans la file des processus prêts, la priorité d‟un processus change au rythme α.
Lors de l‟exécution du processus, sa priorité est modifiée au rythme β. a) Quel
algorithme résulte de β ˃ α ˃ 0 ?

b) Quel algorithme résulte de β ˂ α ˂ 0 ?

33. Si un système utilise l‟algorithme du travail le plus court d‟abord pour

l‟ordonnancement à court terme et une moyenne exponentielle de α = 0,5, quel est
le prochain cycle processeur estimé pour un processus aux cycles processeur de
5, 8, 3 et 5 et une valeur initiale de 10 pour e1 .
34. Dans quelle mesure peut-on affirmer que l‟ordonnancement du travail le plus court
d‟abord est une forme particulière de l‟ordonnancement des priorités ?
35. Sur un système utilisant l‟ordonnancement à tourniquet, s représente le temps
nécessaire pour réaliser une commutation de processus, q, le quantum de temps à
tourniquet et r, le temps moyen d‟exécution d‟un processus avant de bloquer les
E/S. donner une formule pour l‟efficacité de l‟UC en fonction de ce qui suit : a) q =
∞

b) q ˃ r

c) s ˂ q ˂ r

d) s = q ˂ r
e) q proche de 0

© Kasengedia motumbe pierre 220

 Page 221 sur 270

36. A quel degré les algorithmes suivants favorisent-ils les processus tributaires de
l‟UC ?
a) FSFC
b) SJF
c) SRT
d) RR
e) MFQ

37. Donnez un exemple de situation dans laquelle il peut être utile d‟avoir un
programme qui est exécuté par l‟utilisateur effectif de son propriétaire plutôt que
d‟avoir un utilisateur réel qui exécute le programme.
38. Répondre par OUI ou NON et par d‟éventuels commentaires.
1. Un processus est une entité produite après compilation
2. Un processus est une entité produite après chargement d‟un binaire en mémoire
3. Le pseudo-parallélisme impose aux processus de se connaître mutuellement
4. Le quasi-parallélisme impose la connaissance mutuelle des identités des
processus
39. Pourquoi fait-on la distinction entre le concept programme et celui de processus ?
40. Quelle différence y a-t-il entre un appel d‟une procédure et un appel au
superviseur (ou appel d‟une primitive du noyau système) ?
41. Existe-t-il une grande différence dans le traitement d‟un appel au superviseur et
celui d‟un traitant d‟interruption (handler interrupt) ? Pourquoi ?
42. Qu'est-ce qu'un code réentrant ? De quelle manière peut-on transformer un code
nonréentrant en code réentrant ? Est-ce toujours facile ? Pourquoi ?
43. Schématiser un diagramme d‟états/transitions pour les cas suivants :
a) Système de monoprogrammation
b) Système de multiprogrammation
c) Système à temps partagé.
44. a) Expliquez la différence entre les systèmes multitâches non préemptifs et
préemptifs.
b) Indiquez quels sont les avantages des seconds par rapport aux premiers.

© Kasengedia motumbe pierre 221

 Page 222 sur 270

Hypothèse : un ordinateur avec un unique processeur central.

45. Répondez aux questions suivantes :

a) Qu‟est-ce qu‟un commutateur ?
b) Quand est-ce qu‟il peut être activé ? et par qui ?
c) Quel est son principe de fonctionnement ?
46. Le parallélisme regroupe un certain nombre de concepts relatifs à l‟exécution en
parallèle de plusieurs processus. Rappeler donc les caractéristiques inhérentes
au :
- vrai parallélisme,
- quasi- parallélisme,
- pseudo- parallélisme
47. Préciser quelles sont les propriétés d‟une exclusion mutuelle ?
48. Qu‟est-ce qu‟un sémaphore et pour quelles raisons ses primitives sont-elles
considérées être des opérations atomiques (indivisibles) ?
49. Quelles différences existe-t-il entre un sémaphore binaire, un sémaphore à
compteur et un sémaphore privé ?
50. Répondre par OUI ou NON et par d‟éventuels commentaires.
a) La synchronisation est un mécanisme dû à l‟existence de relations de
coopération inter-processus
b) La compétition des processus pour l‟acquisition d‟une ressource partagée
impose une synchronisation de leur activité
c) la propriété de l‟exclusion mutuelle décrite par une utilisation correcte d‟un
sémaphore d‟exclusion mutuelle mutex implique que : nf(mutex) = nv(mutex)
+ 1 où nf et nv sont des fonctions donnant respectivement le nombre de
franchissement et le nombre d‟opérations V sur le sémaphore mutex
initialisé à 1.
d) La propriété de l‟exclusion mutuelle décrite par uneutilisation correcte d‟un
sémaphore d‟exclusion mutuelle mutex implique que : nf(mutex) = np(mutex)
+ 1 où nf et np sont des fonctions donnant respectivement le nombre de

© Kasengedia motumbe pierre 222

 Page 223 sur 270

franchissement et le nombre d‟opérations P sur le sémaphore mutex

initialisé à 1.
51. Ecrire un programme qui réalise, à l‟aide des sémaphores, l‟exécution des actions
P0 à P7 données par la figure ci-dessous décrivant leur précédence.

52. Le problème à traiter concerne la mise au point d‟un rendez-vous de travail entre
N personnes. Chaque personne doit se rendre au lieu du rendez-vous et attendre
le début de travaux qui ne peut commencer que lorsque tout le monde est présent.
Le dernier arrivé donc débloquera la situation et les travaux de l‟assemblée
peuvent démarrer. Résoudre ce problème en utilisant des sémaphores et
considérant que les personnes sont des processus citoyens.

53. Soit un fichier partagé par N processus ayant chacun une clé d‟accès de 0 à k.
Ces processus sont autorisés à accéder simultanément au fichier à condition que
la somme des clés en cours d‟accès soit inférieure ou égale à M. Donner une
solution à ce problème en utilisant des sémaphores.

54. Pour chacun des algorithmes d‟ordonnancement suivants, indiquer s‟il nécessite
ou pas une réquisition, expliciter son fonctionnement et donner ses
avantages/inconvénients.
a) Premier arrivé premier servi
b) Plus court d‟abord
c) Tourniquet
d) Plus court en temps restant
e) Selon priorité
55. On suppose, qu‟à la date t=0, le CPU est libre et que la liste des processus à
l‟état prêt sont ceux listés dans le tableau suivant.

© Kasengedia motumbe pierre 223

 Page 224 sur 270

Processus Date d‟arrivée Temps de traitement

A 0 3

B 1 6

C 4 4

D 6 2

On s‟intéresse à l‟ordonnancement de ces processus lorsque l‟algorithme mis

en œuvre est FCFS, SJF, SRTF, RR (q=2). En prenant en considération que
le temps nécessaire pour la commutation est nul, calculé pour chacun de ces
algorithmes : a) le temps moyen de rotation
b) le temps d‟attente de chaque processus
c) le débit
56. Supposons un système d‟exploitation monoprocesseur, un temps de
commutation nul et une liste de processus à l‟état prêt décrite par le tableau
suivant :

Processus Date d‟arrivée (a) Durée d‟exécution (e)

A 0 3

B 1 5

C 3 2

D 9 5

E 12 5

En supposant que l‟ordonnancement des processus se fait selon la stratégie

tourniquet
(Round Robin), calculer pour chaque processus selon la valeur du quantum Q
 la date de début de l‟exécution : d
 la date d‟achèvement de l‟exécution : f
 le temps de réponse T= f –a

© Kasengedia motumbe pierre 224

 Page 225 sur 270

 le temps d‟inactivité M= T-e

 le ratio de pénalité P= T/a
 le ratio de réponse R= 1/P
On prendra pour Q les valeurs 1 puis 4.
57. On considère un système monoprocesseur avec une seule unité de disque. On
suppose qu‟à la date t=0 la liste des processus à l‟état prêt renferme 4
processus A, B, C et D. Ceux-ci ont été soumis au système dans cet ordre et
effectuent du calcul et des entrées/sorties avec le disque selon les temps
donnés ci-dessous :

Représentez sur un graphe le chronogramme d'exécution de ces 4 processus et

donnez le temps de réponse moyen obtenu lorsque :
a) l'ordonnancement sur le processeur se fait selon une politique FCFS et que
l'ordre de services des requêtes d'E/S pour le disque se fait également en
FIFO.
b) l'ordonnancement sur le processeur se fait selon une politique en tourniquet
avec un quantum égal à 1 (RR, Q=1) et que l'ordre de services des requêtes
d'E/S pour le disque se fait également en FIFO.
Hypothèses : A la date t=0, le processeur est libre et le disque dur est disponible,
La durée d‟une commutation de contexte est nulle,

58. A l‟état initial, le système considéré dispose de l‟ensemble de ressources qui

suit :

© Kasengedia motumbe pierre 225

 Page 226 sur 270

Plus tard la configuration du système indique un état sein définit pr les structures des
données suivantes :

Donner l‟algorithme du banquier pour savoir si un interblocage peut se produire.

Indiquez si non la suite fiable des demandes à honorer.

59. La situation illustrée par le graphe d'allocation de ressources ci-après, peut-elle

causer un interblocage. Justifier.

Sur ce graphe les processus sont représentés par des ronds, les ressources
par des rectangles contenant des points explicitant le nombre d‟exemplaires
d‟une ressource, les flèches qui partent des rectangles vers les ronds
désignent ce qui a déjà été octroyé à un processus, et les flèches dans l‟autre
sens ce qui lui manque.

60. Indiquez comment l‟exclusion mutuelle peut être mise en œuvre au moyen des
boites aux lettres, avec une primitive non bloquante send_mailbox et une

© Kasengedia motumbe pierre 226

 Page 227 sur 270

primitive bloquante receive_mailbox. Partez du principe que les primitives sont

exécutées comme des opérations élémentaires indivisibles.
61. L‟embouteillage (gridlock) est un problème de circulation dans lequel aucun
mouvement n‟est possible dans le trafic. Démontrer que les quatre conditions
d‟interblocage s‟appliquent.
62. Compte tenu de l‟utilisation et de la disponibilité des ressources décrites dans le
tableau ci-après, dessinez le graphe d‟allocation des ressources.

63. Compte tenu de l‟utilisation et de la disponibilité des ressources des processus

décrites dans le tableau du numéro précédent, dessinez le graphe réduit
d‟allocation des ressources.

3) GESTION DE MEMOIRE

1. Pour chacun des schémas de gestion de la mémoire, décrivez brièvement les

fonctions réalisées par le logiciel de système d‟exploitation. a) Partition
contigüe (avec les registres base)
b) Multiprogrammation à partitions variables
c) Système des zones siamoises
d) Pagination simple
2. Pour chacun des schémas de gestion de la mémoire, décrivez brièvement les
fonctions réalisées par le matériel de gestion de la mémoire.
 Partition contigüe (avec les registres base)
 Multiprogrammation à partitions variables
 Système des zones siamoises

© Kasengedia motumbe pierre 227

 Page 228 sur 270

 Pagination simple

3. Un programme contenant du code translatable a été créé, en partant du

principe qu‟il serait chargé dans l‟adresse 0. Dans son code, le programme

fait référence aux adresses suivantes 50, 78, 150, 152, 154. Si le programme

est chargé en mémoire en commençant à l‟emplacement 250, comment

doivent être adressées ces adresses ?

4. Dans quelle mesure un schéma de partition absolue qui utilise du code

translatable estil comparable à un schéma de partition translatable ? dans
quelle mesure sont-ils différents ?

5. Sur un système doté de 224 octets de mémoires et de partitions fixes, toutes

d‟une taille de 65536 octets, quel est le nombre minimum de bits nécessaires
dans une entrée de la table de processus pour enregistrer la partition à
laquelle a été louée un processus ?

6. Sur un système doté de 224 octets de mémoires et de partitions fixes, toutes

d‟une taille de 65536 octets, combien de bits doit avoir le registre limite ?
7. Sur un système qui utilise les partitions fixes de taille 216, 223 et 232, combien

de bits doit avoir le registre limite ?

8. Sur un système qui utilise l‟allocation de la première zone libre, supposons

que la mémoire est allouée comme spécifiée dans la figure ci-après, avant
que d‟autres requêtes de 20, 10 et 5 Ko (dans cet ordre ci) soient reçues. A
quelle adresse de départ vont être allouées chacune des autres requêtes ?

9. Sur un système qui utilise l‟allocation du meilleur ajustement, supposons que

la mémoire est allouée comme spécifiée dans la figure du numéro 8, avant

© Kasengedia motumbe pierre 228

 Page 229 sur 270

que d‟autres requêtes de 20, 10 et 5 Ko (dans cet ordre ci) soient reçues. A
quelle adresse de départ vont être allouées chacune des autres requêtes ?

10. Sur un système qui utilise l‟allocation du pire ajustement, supposons que la
mémoire est allouée comme spécifiée dans la figure du numéro 8, avant que
d‟autres requêtes de 20, 10 et 5 Ko (dans cet ordre ci) soient reçues A quelle
adresse de départ vont être allouées chacune des autres requêtes ?

11. Sur un système qui utilise l‟allocation de la zone libre suivante, supposons
que la mémoire est allouée comme spécifiée dans la figure du numéro 8,
avant que d‟autres requêtes de 20, 10 et 5 Ko (dans cet ordre ci) soient
reçues A quelle adresse de départ vont être allouées chacune des autres
requêtes ?
12. Sur un système doté de 1 Mo de mémoire et qui utilise des zones siamoises,
dessiner un schéma qui illustre l‟allocation de la mémoire après chacun des
événements suivants :
a) Processus A, requête 50 Ko
b) Processus B, requête 150 Ko
c) Processus C, requête 60 Ko
d) Processus D, requête 60 Ko
e) Processus E, requête 60 Ko
f) Processus D, sortie
g) Processus C, sortie
h) Processus E, sortie
i) Processus A, sortie
j) Processus F, requête 150 Ko
k) Processus G, requête 150 Ko
l) Processus F, sortie
m) Processus G, sortie
n) Processus B, sortie

© Kasengedia motumbe pierre 229

 Page 230 sur 270

13. Sur un système doté de 1 Mo de mémoire et qui utilise des zones siamoises,
quelle est la première requête à échouer dans la chaine suivante de requêtes,
en raison d‟un manque de mémoire disponible ?
Requêtes : 50 Ko, 150 Ko, 90 Ko, 130 Ko, 70 Ko, 80 Ko, 120 Ko, 180 Ko, 60 Ko,

14. Dans le problème de l‟exercice précédent, au moment de l‟échec de la

requête, combien de mémoire est gaspillée en raison de la fragmentation
interne et combien l‟est en raison de la fragmentation externe ?
15. Pourquoi la taille de la page est toujours une puissance de 2 ?
16. Dans la pagination (en partant du principe que la taille de la page est une
puissance de

2), pourquoi n‟est-il pas nécessaire d‟ajouter l‟offset de la page à l‟adresse du

départ du cadre de page pour générer une adresse physique ?
17. Sur un système de pagination simple de 224 octets de mémoire physique, 256

pages d‟espace d‟adressage logique et une taille de page de 210 octets,

combien de bits se trouvent dans une adresse logique ?

18. Sur un système de pagination simple de 224 octets de mémoire physique, 256

pages d‟espace d‟adressage logique et une taille de page de 210 octets,

combien de bits de l‟adresse physique spécifient le cadre de page ?

19. Sur un système de pagination simple de 224 octets de mémoire physique, 256
pages d‟espace d‟adressage logique et une taille de page de 210 octets,
combien de bits sont nécessaires pour stocker une entrée dans la table de
pages (de quelle largeur est la table de pages) partons du principe que
chaque entrée de table d‟adressage contient un bit valide / invalide en plus du
numéro de cadre de page.
20. Sur un système de pagination simple avec une table de pages contenant 64
entrées de 11 bits (bit valide et invalide y compris) chacune et une taille de
page de 512 octets, combien de bit dans l‟adresse logique spécifient l‟offset à
l‟intérieur d‟une page ?

© Kasengedia motumbe pierre 230

 Page 231 sur 270

21. Sur un système de pagination simple avec une table de pages contenant 64
entrées de 11 bits (bit valide et invalide y compris) chacune et une taille de
page de 512 octets, quelle est la taille de l‟espace d‟adressage logique.
22. Sur un système de pagination simple avec une table de pages contenant 64
entrées de 11 bits (bit valide et invalide y compris) chacune et une taille de
page de 512 octets, combien de bit dans l‟adresse physique spécifient l‟offset
au sein d‟un cadre de page ?
23. Sur un système de pagination simple avec une table de pages contenant 64
entrées de 11 bits (bit valide et invalide y compris) chacune et une taille de
page de 512 octets, quelle est la taille de l‟espace d‟adressage physique ?

24. Sur un système de pagination simple, l‟espace d‟adressage logique peut-il

être plus grand que l‟espace d‟adressage physique ? peut-il être plus petit ?

25. Un ordinateur possède un espace d‟adressage virtuel de 32 bits et des pages

de 1024 octets. Une entrée de table de pages prend 4 octets. Une table de
page de plusieurs niveaux est utilisée car chaque table doit être contenue
avec une page. Combien faut-il de niveaux ?
26. Sur un système paginé simple, des registres associatifs contiennent des
entrées de pages les plus actives et la table de pages entière est stockée
dans la mémoire principale. Si les références satisfaites par les registres
associatifs prennent 90 ns, et que les références à travers les tables de pages
de la mémoire principale prennent 220 ns, quel est le temps d‟accès effectif si
60% de toutes les références de la mémoire trouvent leur entrée dans les
registres associatifs.
27. Quel avantage offre la segmentation par rapport à la multiprogrammation à
partition variables ?

28. Sur un système utilisant la pagination et la segmentation, l‟espace

d‟adressage virtuel se compose au maximum de 8 segments, chacun d‟entre
eux pouvant avoir une longueur qui atteint 229. Le matériel pagine chaque
segment en page de 256 octets.

Combien de bits de l‟adresse virtuelle spécifient ?

29. Pourquoi la pagination est-elle plus rapide que la segmentation ?

© Kasengedia motumbe pierre 231

 Page 232 sur 270

30. Quelles sont les deux principales différences entre la segmentation et la

pagination ?
31. Dans ce problème, utilisez des valeurs décimales, une taille de page de 2000
octets et la table de pages suivante :

Int /out cadre

In 20

Out 22

In 200

In 150

Out 30

Out 50

In 120

In 101

Parmi les adresses virtuelles suivantes, laquelle génère un défaut de page ?

Pour celles qui ne génèrent pas de défauts de page, quelle est leur adresse
physique après translation ?
a) 10451
b) 5421
c) 14123
d) 9156

32. Donnez un exemple d‟accès à des variables à l‟intérieur d‟un programme

conduisant à une localité temporelle.

33. Donnez un exemple d‟accès à des variables à l‟intérieur d‟un programme

conduisant à une localité spatiale.

34. Soit un système d‟exploitation, qui utilise l‟allocation contiguë par partition
variable. On considère à l‟instant T l‟état suivant de la mémoire centrale (les
zones hachurées sont libres):

© Kasengedia motumbe pierre 232

 Page 233 sur 270

A B C D E F
(210Ko) (280Ko) (490Ko) (560Ko) (280Ko) (140Ko)
140Ko 350Ko 630Ko 700Ko 840Ko

A) Représenter l‟évolution de la mémoire centrale, en fonction de l‟arrivée des

processus K, L, M et O, selon cet ordre: K (280 Ko), L (630 Ko), M (350 Ko) et O (70
Ko) :
1) en utilisant la stratégie d‟allocation First Fit

2) en utilisant la stratégie d‟allocation Best Fit

3) en utilisant la stratégie d‟allocation Worst Fit

B) Nous désirons choisir un moyen de mémorisation des parties libres et parties
occupées de la mémoire, ainsi qu‟elle était représentée avant l‟arrivée des nouveaux
processus.
1) Donner la table de bits correspondant à la répartition précédente, en supposant
que l‟unité d‟allocation est le 70Ko.

2) Soit une représentation des parties libres/occupées sous la forme d‟une liste
chaînée, dont chaque nœud contient un bit d‟état (L/O), la taille de la partition, et
un pointeur sur la prochaine partition. Représenter la liste chaînée correspondant
à la répartition précédente (unité d‟allocation : 70Ko).

35. Soit une mémoire centrale utilisant la technique d‟allocation contiguë par
partitionnement fixe. Cette mémoire est composée de 5 partitions P1, P2, P3,
P4 et P5. Ces partitions ont pour tailles respectives 100, 500, 200, 300 et 600
KO. Soient 4 processus A, B, C et D de tailles respectives 212, 417, 112 et
426 KO. Donner les différents états de la mémoire centrale pour charger les 4
processus A, B, C et D (dans l‟ordre) en utilisant les algorithmes d‟allocation
suivants :
a- FIRST-FIT
b- BEST-FIT
c- WORST-FIT
d- NEXT-FIT

© Kasengedia motumbe pierre 233

 Page 234 sur 270

36. On dispose d‟un espace adressable virtuel 4 Go (adressable sur 32 bits), et

d‟un espace physique 32 Mo (adressable sur 25 bits). Une page occupe 1 Ko
(déplacement sur 10 bits). Quelle est la taille de la table des pages (en octet),
sachant qu‟une case de la table de page comporte 1 bit de présence et un n°
physique de la page ?

37. Considérons une architecture caractérisée par les hypothèses suivantes :

 Une table de page de taille 128Ko ;
 Chaque entrée de la table contient une référence vers un cadre de page et un bit de
présence/absence ;

 La taille d‟une page est de 64ko ;

 La taille de la mémoire physique est de 2Go ;
 Une adresse virtuelle indexe un octet ;
Répondez aux questions suivantes en justifiant toujours votre réponse :
1. Combien de cadre de page contient la mémoire physique ?
2. Quelle est la taille en bit d‟une entrée de la table de pages ? 3. Quel est le nombre
d‟entrées dans la table de pages ?
4. Quelle est la taille de la mémoire virtuelle de cette
architecture ? 5. Quelle est la taille en bit du bus d‟adresse de
cette architecture ?

38. On considère un système utilisant la technique de pagination et ayant les

caractéristiques suivantes :
 Une table de page ayant 216 entrées ;
 Chaque entrée de la table de pages est codée sur 16 bits. Une entrée contient un
numéro de cadre de page et un bit de présence/absence.
 Le déplacement (offset) est codé sur 16 bits
 Une adresse virtuelle indexe 1 octet

1. Quelle est la taille d‟une page ?

© Kasengedia motumbe pierre 234

 Page 235 sur 270

2. Quelle est la taille de la mémoire physique ?

3. Quelle est la taille de la mémoire virtuelle ?
4. Quelle est la taille (en bit) du bus d‟adresse de ce système ?

39. Soit la suite des pages suivantes {1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5}. Donner

l‟évolution de la mémoire centrale en utilisant les algorithmes de
remplacement de page suivants et en donnant le nombre de défauts de page:
 Pour l'algorithme FIFO avec nombre de case mémoire=3, puis avec nombre de case
mémoire =4. Que constatez-vous ? Expliquez.
 Pour l'algorithme optimal avec nombre de case mémoire=4.

4) GESTION DE SYSTEME DES FICHIERS

1. Dans quelle mesure un fichier avec deux noms est-il différent des deux copies d‟un
même fichier
2. Sur un système qui monte les systèmes de fichiers sur des dispositifs individuels
dans un seul système de fichier, une disquette a été montée au point /usr/mount. Si
le système de fichiers de la disquette contient un fichier de nom de /data/jan, quel
sera le nom de ce fichier dans le système de fichiers global ?
3. Donnez un avantage d‟avoir la partition spécifiée comme faisant partie du nom de

fichier (comme c‟est le cas dans DOS)

4. Donnez un avantage de permettre aux partitions d‟être montées sur un espace de

nommage unifié.

5. Quel avantage présente l‟autorisation des objets qui ne sont pas des fichiers dans
une structure de système des fichiers ?

6. Pourquoi l‟ajout d‟une opération copy (copie) n‟accroit pas les fonctionnalités ?
7. Il est possible de renommer un fichier en copiant ce dernier, puis en supprimant
l‟original. L‟existence d‟une opération de renommage offre-t-elle des nouvelles
fonctionnalités ?

© Kasengedia motumbe pierre 235

 Page 236 sur 270

8. Dans quelle mesure le fait d‟avoir un fichier avec plusieurs noms complique-t-il

l‟opération de suppression dans un système de fichiers ?

9. Est-il possible de simuler dans un logiciel une structure de répertoire multiniveaux

sur un système qui ne prend en charge qu‟une arborescence à un niveau ?

10. Le système DOS considère chaque fichier comme étant simplement une séquence
d‟octets de 8 bits. Quelle structure d‟enregistrement un tel système peut-il utilisé ?
11. Un fichier à accès séquentiel possède des enregistrements d‟une taille fixe de
15 octets. Si l‟on part du principe que le premier enregistrement est l‟enregistrement
1. A quel emplacement logique se trouve le premier octet de l‟enregistrement 5 ?

12. Un fichier à accès direct possède des enregistrements d‟une taille fixe de 15
octets. Si l‟on part du principe que le premier enregistrement est
l‟enregistrement 1. A quel emplacement logique se trouve le premier octet de
l‟enregistrement 5 ?

13. Un fichier à accès séquentiel ou direct possède des enregistrements d‟une

taille fixe de S octets. A quel emplacement logique possède commence le
premier octet de l‟enregistrement N ?

14. Un programme vient de lire le premier enregistrement d‟un fichier à accès

direct. Il veut ensuite lire le dixième enregistrement. Combien
d‟enregistrement doit lire le programme avant d‟entrer dans le dixième ?

15. Sur un système qui a recours à l‟accès indexé, que ce passe-t-il si aucun
enregistrement ne correspond à la valeur d‟index sur une requête de lecture ?

16. Sur un système basé sur la capacité, chaque fichier est associé à une valeur
unique de 16 bits. Pour chaque fichier, chaque utilisateur peut avoir la
capacité d‟écriture ou celle de lecture. Combien d‟octets sont nécessaires
pour stocker chaque donnée d‟accès de l‟utilisateur ?

17. Sur un système qui a recours à l‟attribution fixe de blocs avec des

enregistrements de 20 octets et des blocs de 50 octets, combien d‟espace est

gaspillé dans chaque bloc ?

© Kasengedia motumbe pierre 236

 Page 237 sur 270

18. Sur un système qui utilise l‟attribution non étendue de blocs et de blocs de
100 octets, un fichier contient des enregistrements de 20, 50, 35, 70, 40, 20.
Quel pourcentage d‟espace est gaspillé dans les blocs alloués au fichier ?
19. Sur un système qui utilise l‟allocation contiguë, calculer le numéro du bloc
physique correspondant au bloc logique, sachant que le fichier est stocké en
commençant au bloc physique indiqué (en partant du principe que le numéro
de blocs commence par
1).
a) Bloc physique de départ : 1000 ; bloc logique : 12
b) Bloc physique de départ : 75 ; bloc logique : 2000
c) Bloc physique de départ : 150 ; bloc logique : 25

20. Prenons un système dans lequel une entrée de répertoire peut stocker jusqu‟à
16 adresse de blocs de disque. Pour les fichiers qui ne dépassent pas 16
blocs, les 16 adresses servent de table d‟index du fichier. Pour les fichiers
supérieurs à 16 blocs, les adresses pointes vers les blocs indirects qui à leur
tour pointent vers des 256 blocs de fichiers. Un bloc se compose de 1024
octets. Quelle taille peut avoir le plus gros fichier ?

5) GESTION DES ENTREES ET SORTIES

1. sur un système avec un bus unique de 32 bits et 100 MHz (cycle de 10 ns), le
contrôleur du disque utilise l‟accès direct à la mémoire pour transférer des
données depuis et vers la mémoire, à un débit de 40 Mo/s. supposons que
l‟ordinateur récupère et exécute une instruction de 32 bits par cycles,
lorsqu‟aucun cycle n‟a été volé. A quel pourcentage le contrôleur de disque
va-t-il ralentir l‟exécution des instructions ?

2. un S.E qui a recours aux E/S mappées en mémoire possède un espace

d‟adressage de 16 bits. Les adresses comportant des uns dans les deux bits

© Kasengedia motumbe pierre 237

 Page 238 sur 270

les plus significatifs font références aux périphériques. Quel est le volume
maximal de mémoire pouvant être référencé dans un tel système ?
3. sur un système de mémoire virtuelle, donnez une fonction pouvant être
proposée aux utilisateurs d‟un système mappé en mémoire et qui ne peut être
offert sur un système à ports d‟E/S ?
4. l‟attente active d‟E/S est-elle appropriée pour le type suivant des systèmes ?

 un système dédié au contrôle d‟un seul périphérique d‟E/S

 un ordinateur personnel exécutant un système d‟exploitation mono tâche

 un poste de travail s‟exécutant comme un serveur web de manière intensive.

5. Un fichier disque contient des enregistrements de taille fixe de 32 octets. Les
E/S physiques sont des blocs de 512 octets stockés dans un tampon du S.E.
si un processus lit les enregistrements du fichier de manière séquentielle, quel
pourcentage des requêtes lues finira en opération d‟E/S ?

6. Les E/S bloquantes empêchent un processus de poursuivre son exécution

jusqu‟à la réalisation de l‟E/S. comment les processus peuvent-ils atteindre
cette fonctionnalité sur des systèmes avec des E/S non bloquantes ? cette
implémentation présente-t-elle des inconvénients ?
7. Où sont implémentées les tâches suivantes, dans l couche des E/S logiques
dans les pilotes des périphériques ou dans les deux ? a) Vérification des
autorisations d‟accès

b) Ordonnancement des opérations d‟E/S

c) Vérification pour savoir si les informations requises se trouvent dans les caches

d) Traitement d‟une interruption d‟un périphérique.

8. Sur un système qui utilise un cache de disque, le temps d‟accès moyen est

fonction du temps d‟accès moyen du cache, du temps d‟accès moyen au

disque et du taux de réussite. Quel est le temps d‟accès moyen d‟après les

paramètres suivants :

a) Cache : 1 ms disque : 100 ms taux de réussite : 25%

b) Cache : 1 ms disque : 100 ms taux de réussite : 50%

© Kasengedia motumbe pierre 238

 Page 239 sur 270

9. Citez un périphérique sur un ordinateur personnel ordinaire pour lequel la mise

en cache par écriture différée est une politique souhaitable ? trouvez un autre
périphérique pour lequel la mise en cache par écriture immédiate serait un choix
plus judicieux.

10. Si la mémoire vidéo commence à l‟adresse A0000000 (hex) pour un moniteur

couleur de 16 bits et une résolution de 1024 x 768, où se termine-t-elle ?
11. Expliquez brièvement l'interaction entre le pilote de périphériques, le contrôleur
et le périphérique lui-même.

© Kasengedia motumbe pierre 239

 Page 240 sur 270

ETUDE DE CAS : LE SYSTEME D’EXPLOITATION LINUX

PRESENTATION DE LINUX

Unix est né, en 1969, dans les Bell Laboratoires (AT&T) sous l‟impulsion de deux
hommes, Ken Thompson et Dennis Ritchie. Il était destiné à fournir aux
programmeurs maison un environnement de développement auquel ils avaient goûté
avec Multics (MULTiplexed Information and Computing Service). Suite au
développement par Dennis Ritchie du langage C, adapté à ce type de
programmation, une nouvelle version d‟Unix est réécrite, en grande partie en C, en
1973. Pour la première fois, un système d‟exploitation est écrit en langage non
assembleur, et devient donc portable, du moins en principe.

En 1974, la version 4 d‟Unix est « donnée » à l‟université de Berkeley, Californie, qui

commence alors son propre développement du système. C‟est le début d‟une
divergence entre les deux versions d‟Unix : AT&T et BSD (Berkeley Software
Distribution). Le succès d‟Unix devient alors considérable dans les universités
américaines : seul système d‟exploitation disponible en source, sur mini–ordinateur
(PDP11), il est adopté par les départements de « computer science » des universités
pour la formation des étudiants en informatique système. Le nombre d‟experts Unix
croît à une vitesse considérable. De 1977 à 1979, Ken Thompson et Dennis Ritchie

© Kasengedia motumbe pierre 240

 Page 241 sur 270

réécrivent Unix pour le rendre réellement portable. Et en 1980 les premières licences
de distribution d‟Unix System V d‟AT&T sont délivrées aux constructeurs.

L‟année 1984 voit la création du groupe X/Open, composé de constructeurs

informatiques ayant adopté Unix et se donnant pour but de normaliser les différentes
versions d‟Unix. Cette même année est créée par le MIT la norme X Window :
système de multifenêtrage graphique, indépendant d‟Unix, mais qui contribuera au
succès de ce système.
En 1987, AT&T, propriétaire d‟Unix, et Sun, un des leaders du marché des stations
de travail et utilisant la version BSD, concluent une alliance visant à une
convergence entre les deux systèmes.
En 1988 sont créés deux consortiums :
 OSF (Open Software Fondation), (DEC, HP, IBM, …) travaillant à la
normalisation d‟un nouvel Unix baptisé OSF1 ;
 Unix International (AT&T, Sun, …) cherchant à imposer Unix System V. En
1992, Digital Equipment propose DEC/OSF1, première version
commercialement disponible d‟OSF1, et Sun propose la première version
commerciale résultant de la convergence entre System V et BSD. Il y a
encore plusieurs Unix, mais les différences ne représentent plus une difficulté
pour l‟utilisateur.

Le succès d‟Unix tient à plusieurs facteurs :

 Le plus important, à l‟origine, est son adoption par les universités américaines
pour la formation des étudiants, ce qui a sans aucun doute permis de former
plus d‟experts sur ce système que sur aucun autre.
 Un autre facteur déterminant est le besoin de standard exprimé par les
utilisateurs, qu‟ils soient sociétés de développement de logiciel ou utilisateurs
finals. Dans un monde où le changement de fournisseur avait toujours été
catastrophique pour l‟utilisateur, les systèmes ouverts offrent des
perspectives d‟évolution en douceur tout en maintenant une concurrence
entre fournisseurs. Cette pression des utilisateurs est un fait nouveau dans

© Kasengedia motumbe pierre 241

 Page 242 sur 270

l‟histoire de l‟informatique. La participation de groupes d‟utilisateurs et

d‟éditeurs de logiciels aux consortiums dirigeant l‟évolution d‟Unix n‟a de réel
équivalent pour aucun autre système d‟exploitation.

© Kasengedia motumbe pierre 242

 Page 243 sur 270


Unix est le seul système d‟exploitation multi–utilisateur disponible à faible coût
pour une société développant un système à base de processeur standard.

Linux

Unix est l‟un des systèmes d‟exploitation le plus populaire au monde, en raison du
grand nombre d‟architectures qu‟il supporte. Il existe des versions d‟Unix pour tous
les types d‟ordinateurs, y compris les ordinateurs personnels.
SCO Unix est le système le plus ancien sur cette plateforme. Le premier package
Unix, de nom SCO Xenix System pour Intel 8086 et 8088, date de 1983. La société
SCO est maintenant propriétaire de la marque Unix, qu‟elle a achetée à la société
Novell, qui l‟avait elle–même achetée à une filiale d‟ATT (Unix System Labs).
SCO Unix existe toujours. Unix est maintenant une marque déposée de
l‟OpenGroup.
L‟idée d‟un système d‟exploitation libre est né en 1984 avec la Free Software
Foundation (FSF). Les bases de l‟environnement ont été définies. Puis des outils,
tels des éditeurs, des compilateurs, des shells ... ont été développés. Linux, système
Unix libre sur plate–forme PC, était au départ un projet de loisirs de Linus Torvalds,
étudiant finlandais. Linux fut inspiré de Minix, un petit système Unix développé par
Andrew Tanenbaum. Les premières discussions autour de Linux se passèrent sur le
forum comp.os.minix. Ses débuts furent la maîtrise de la commutation de tâches du
mode protégé du processeur 80386, tout fut écrit en assembleur. Le 5 octobre 1991,
Linus Torvalds annonça la première version « officielle » de Linux, la version 0.02.
Après la version 0.03, Linus passa directement en version 0.10.

Linux a continué à évoluer grâce à Linus Torvalds et aussi aux efforts de nombreux
volontaires répartis aux 4 coins du monde, reliés entre eux par le réseau Internet.
Sous la pression de ces co–développeurs, Linus Torvalds a accepté que tout le code
soit sous licence GPL (General Public Licence), créant ainsi un noyau Unix
totalement libre. Grâce à ce réseau, toute personne intéressée par le
développement de ce système peut aider : porter des programmes, écrire de la

© Kasengedia motumbe pierre 243

 Page 244 sur 270

documentation, corriger des bogues… On compte actuellement plus de 18 millions

d‟utilisateurs de Linux, et nombreux sont ceux qui contribuent d‟une façon ou d‟une
autre au développement de ce système et de son environnement.

À ce jour, Linux est un vrai système 32 bits, multitâches, multi-utilisateurs, réseau et

complet.
Il s‟installe sur la plupart des PC (avec ou sans autre système d‟exploitation). Il
supporte une large gamme de programmes tels que X Window, TCP/IP, C/C ++GNU
et d‟autres outils GNU, le courrier électronique, les news, des outils dérivés de
LateX (LyX), ou des outils de bureautique. Une machine sous Linux est modulaire et
paramétrable à souhait. Elle peut donc servir de station personnelle ou de serveur
(Web, ftp…).
Linux est une libre implémentation des spécifications POSIX, avec des extensions
System V et Berkeley. Ceci accélère la propagation de Linux au sein de
l‟administration, qui exige la conformité POSIX de la plupart des systèmes qu‟elle
utilise. Linux est un phénomène très important et peut devenir une alternative au
système Microsoft Windows, grâce notamment aux outils bureautiques…
Linux est le plus souvent diffusé sous forme d‟une distribution, un ensemble de
programmes (noyau, sources des utilitaires, commandes, applications) formant
après installation un système complet. Par conséquent, il est de plus en plus utilisé
dans les sociétés commerciales comme station de travail et serveur.

Le succès de Linux tient à plusieurs facteurs :

 Le code source du système, ainsi que le noyau, les programmes utilisateurs,
les outils
de développement sont librement distribuables (licence GPL, ou GNU),
 Linux est compatible avec un certain nombre de standards Unix au niveau du
code source, incluant les spécifications POSIX, system V et BSD,
 Un très grand nombre d‟applications Unix gratuites disponibles sur Internet se
compilent sous Linux sans aucune modification,

© Kasengedia motumbe pierre 244

 Page 245 sur 270



 Le système Linux a été développé pour les processeurs Intel et utilise toutes
les fonctionnalités de ce processeur.

LES DISTRIBUTIONS DE LINUX

DEBIAN : Debian a longtemps été la seule distribution entièrement et

uniquement composée de logiciels libres et open source ce qui lui vaut
toujours le nom officiel de Debian GNU/Linux.

 un nombre gigantesque de packages qui se chiffre en milliers, un logiciel

d‟installation appelé APT très pratique et performant,
 une distribution 100 % open source,
 une stabilité à toute épreuve pour un environnement de production, de
nombreux dépôts de logiciels.

Ces avantages entraînent aussi quelques inconvénients :

 des packages souvent anciens dans les dépôts stables,

 des mises à jour de la distribution irrégulières et trop espacées,
 des risques liés à la multiplication des paquets et des dépendances,
 une installation et une configuration parfois compliquées pour le débutant.

UBUNTU : Le mot Ubuntu est un mot du langage africain bantou signifiant «

humanité aux autres » ou encore « je suis ce que je suis grâce à ce que nous
sommes tous ». Cette définition reflète ce qu‟est la distribution : un dérivé de
Debian dont le but est de fournir des logiciels plus récents et très fortement
axés sur la convivialité et l‟ergonomie à l‟aide du support du plus grand
nombre :

© Kasengedia motumbe pierre 245

 Page 246 sur 270

 une distribution issue de Debian,

 une compatibilité avec les packages de Debian,
 un système d‟installation très simple,
 une sortie tous les 6 mois,
 un environnement graphique agréable.

RED HAT, FEDORA ET CENTOS : Les distributions Red Hat ont très
fortement marqué les esprits car elles sont restées la référence pendant
presque vingt ans.
Chaque version était innovante tant dans l‟intégration des logiciels que dans
son installateur (appelé Anaconda) et ses outils de configuration.
En 2003 la version 9.0 est la dernière destinée officiellement au grand public.
Les versions suivantes ont été confiées au projet communautaire Fedora qui
continue tous les six mois à sortir une nouvelle version. Red Hat se concentre
maintenant sur le monde de l‟entreprise avec des distributions commerciales
appelées RHEL (Red Hat Enterprise Linux).

 des versions professionnelles destinées aux entreprises,

 des solutions du poste de travail au plus gros serveur,
 des architectures matérielles nombreuses,
 un support commercial,
des mises à jour assurées pendant sept ans, voire plus avec un support
étendu, 100 % libre.
Red Hat est l‟une des distributions préférées des entreprises et ceci pour de
nombreuses raisons :
 c‟est une distribution historique ayant acquis le support d‟un grand nombre
d‟éditeurs, Red Hat propose un support de très haut niveau,

© Kasengedia motumbe pierre 246

 Page 247 sur 270



 Red Hat ne propose pas qu‟un système d‟exploitation, mais tout un
écosystème (Cloud, Virtualisation, Serveurs applicatifs, stockage,
automatisation)

 OpenSUSE : Se prononçant opensousse, OpenSUSE est une distribution

d‟origine allemande datant de 1992. Le nom de l‟entreprise luimême était un
hommage au célèbre Konrad Zuse l‟inventeur des ordinateurs modernes.

La distribution est originellement basée sur la distribution Slackware. En 1996

SuSE se rapproche d‟une distribution française appelée Jurix créée par
Florian La Roche qui est utilisée comme base à la place de Slackware. Cette
même année le développement de l‟outil YaST est démarré et la version 4.2,
en fait totalement nouvelle, sort. Au même moment SuSE utilise le nouveau
gestionnaire de packages de Red Hat appelé RPM.
 Etc.

Installation

L‟installation de Linux sur une machine est une opération assez simple car
interactive dans chaque distribution. Toutefois, le meilleur conseil que nous
pourrions donner est de choisir une distribution accompagnée d‟une documentation
papier d‟installation complète. Il est également possible (et recommandé pour un
débutant) d‟acheter une nouvelle machine avec Linux déjà installé. Si vous voulez
installer Linux sur une machine existante, avant de commencer, vous devriez savoir
répondre aux quelques questions suivantes :

 Quel est le débit de ma connexion à l‟Internet ? Si l‟accès à l‟Internet se fait

par un modem, même à 56K, une distribution gratuite téléchargée coûtera
beaucoup plus cher qu‟un jeu de CD avec la documentation !

© Kasengedia motumbe pierre 247

 Page 248 sur 270

 Mes sauvegardes me permettront-elles de remettre mon système dans son

état actuel en cas de problème ? Si la réponse est oui, je peux passer à la
suite.
 Mon système dispose-t-il d‟un espace disque disponible d‟au moins 1 Go ? Si
ce n‟est pas le cas, il est inutile d‟aller plus loin. Si cet espace disque
disponible se trouve dans des partitions déjà formatées et utilisées par ailleurs,
il faudra libérer cet espace en réduisant la taille des partitions (et ceci nous
ramène à la question précédente sur les sauvegardes). Linux aura besoin de
ses propres partitions.
 Ce système Linux sera-t-il autonome ou intégré à un réseau local ? Dans le
premier cas, préférer une installation de type « station de travail » alors que
dans le deuxième, une installation de type « serveur » sera peut-être plus
adaptée. Dans ce dernier cas, vous devrez toutefois acquérir des
connaissances d‟administration Unix et réseau.
 de choisir une installation de type workstation ;
 si votre poste est à votre domicile et que vous utilisez une connexion ADSL,
mettre en place une protection dite « firewall moyen ».
Une fois l‟installation terminée, il est important de créer un deuxième utilisateur. Ce
compte sera en fait votre compte de travail. Vous ne vous connecterez en tant
qu‟administrateur système (root) que pour lancer des commandes purement
système.

Il sied de préciser que les informations présentées sur cette partie ne donnent que
les outils de bases permettant aux étudiants d'utiliser Unix/Linux. Nous
recommandons aux étudiants d‟exploiter d'autres documentations sur internet et
dans la bibliothèque centrale de l'université mais aussi les différentes présentations
complémentaires lors de travaux pratiques pendant les séances de Laboratoires.

A la fin de ces travaux Pratiques, l'étudiant doit être capable de :

© Kasengedia motumbe pierre 248

 Page 249 sur 270



 Pratiquer les concepts théoriques (processus, gestion de mémoire,
communication entre processus) appris lors du cours magistral dans un
système Unix/Linux.
 Travailler d'une manière autonome dans un système d'exploitation Unix/Linux.
 Maîtriser les commandes des bases pour administrer un système
d'exploitation Unix/Linux
 Automatiser les taches d'administration moyennant des programmes écrits en
scripts Shell
 Maîtriser les concepts et philosophies des logiciels libres
Les notions apprises lors de travaux pratiques pourront aider l'étudiant à se préparer
pour un examen international de certification Linux Junior mais aussi viser le métier
d'administrateur système Unix/Linux plus-tard.

Unix en tant que système d'Exploitation

Unix est un système d‟exploitation, constitué du noyau Unix, d‟un interpréteur de

commandes et d‟un grand nombre d’utilitaires.
Le noyau assure la gestion des ressources physiques (processeur, mémoires,
périphériques) et logicielles (processus, fichiers…). L‟interface entre les
programmes des utilisateurs et le noyau est définie par un ensemble de procédures
et de fonctions, soit directement au niveau du noyau, soit par l‟intermédiaire de
bibliothèques. Pour ce qui concerne l‟architecture du noyau proprement dit, les
éléments caractéristiques sont les suivants :
 Le noyau est constitué d‟un ensemble de procédures et de fonctions écrites
pour l‟essentiel en langage C
 La structure du noyau est monolithique et la notion de couche, contrairement
à d‟autres systèmes, n‟existe pas.
Comme c‟est le cas avec tout système d‟exploitation, l‟utilisateur d‟Unix n‟accède
pas directement au noyau mais à un interpréteur de commandes : le shell (le choix

© Kasengedia motumbe pierre 249

 Page 250 sur 270

de ce terme indique qu‟Unix est « caché » à l‟intérieur de cette coquille qui en est la
seule partie visible par l‟utilisateur).
Une différence importante entre Unix et les autres systèmes d‟exploitation est qu‟il
existe plusieurs shells différents : richesse incomparable, mais source de confusion.

L‟interface utilisateur d‟Unix est donc constituée :

 D‟un ensemble de programmes exécutables : les commandes.
 Du shell lui–même, interpréteur de commandes mais aussi, plus que dans
n‟importe quel autre système d‟exploitation, langage de commandes
permettant d‟écrire des programmes d‟une grande complexité. Ces
programmes de commandes, appelés scripts, seront développés à la partie
appropriée.

Parmi les utilitaires, on trouve :

 différents langages de programmation : C++, Fortran , Java, Perl, TCL/TK,
GTK;
 des utilitaires de développement et maintenance de logiciels : make,
assembleur, éditeurs de lien ;
des outils de bureautique : messagerie, traitement de
textes ; des outils de mise au point de programmes ;
 des éditeurs de textes (sed, vi et vim, emacs, gnotepad) ;
 des formateurs de textes ;
 un système de messagerie complet (courrier, conversation en temps réel…) ;
 un analyseur syntaxique yacc, un générateur d‟analyseur lexical lex ;
 un environnement graphique distribué : X11 ;
 les outils pour le Web (Apache, Netscape…)

VUE GÉNÉRALE D’UNIX

Unix est un système multi–utilisateur « temps partagé », c‟est–à–dire qu‟il est

possible de connecter sous Unix plusieurs utilisateurs simultanément. Chacun a à sa

© Kasengedia motumbe pierre 250

 Page 251 sur 270



disposition l‟ensemble des ressources du système, le partage étant effectué par
découpage du temps et récupération des temps morts d‟entrée–sortie. Comme tout
système multi–utilisateur, Unix comporte des mécanismes d‟identification et de
protection permettant d‟éviter toute interférence (accidentelle ou malveillante) entre
utilisateurs.

Unix est un système multitâche, c‟est–à–dire qu‟un utilisateur peut lancer plusieurs
tâches simultanément. Un processus (ou tâche) correspond à l‟exécution d‟un
programme à un instant donné, le programme étant en lui–même quelque chose
d‟inerte rangé sur disque sous la forme d‟un fichier ordinaire exécutable.
Le système de fichiers est un système hiérarchisé arborescent. Il se retrouve sur
beaucoup d‟autres systèmes d‟exploitation (GCOS, DOS, VMS…). Les entrées–
sorties sont généralisées. Les périphériques sont considérés, du point de vue de
l‟utilisateur, comme des fichiers.
Le système est écrit à 99 % en C, ce qui facilite l‟appel au noyau par des
applications écrites en langage C. Ce système a été écrit de façon à être réellement
portable.

CONNEXION D’UN UTILISATEUR

L'utilisateur
Pour permettre à de nombreux utilisateurs de travailler sur la même machine, Linux
met en oeuvre des mécanismes d‟identification des utilisateurs, de protection et de
confidentialité de l‟information, tout en permettant le partage contrôlé nécessaire au
travail en groupe. Tout utilisateur est identifié par un nom (login name) et ne peut
utiliser le système que si son nom a préalablement été défini par l‟administrateur du
système (ou super–utilisateur), dont le nom est généralement root. Ce dernier a tous
les droits et aucune restriction d‟accès ne lui est applicable.

Connexion

Lors du démarrage d‟une machine, plusieurs étapes se succèdent :

© Kasengedia motumbe pierre 251

 Page 252 sur 270

 mise sous tension de la machine et de ses périphériques,

 bootstrap du système (charger le noyau Linux),
 montage des disques,
 vérification des systèmes de fichiers (fsck), passage en multi–utilisateur,
lancement des services.

On obtient alors, affichée à l‟écran, l‟invite “ login : ”

Le système Linux étant un système multi–utilisateur et multitâche, plusieurs
personnes sont connectées simultanément et peuvent travailler sans interférer les
unes avec les autres. Cela nécessite un système de protection des fichiers propre à
chaque utilisateur, système que nous développerons à la partie concernant la
gestion des droits et protection des utilisateurs. Ainsi pour qu‟un utilisateur puisse
travailler avec le système Linux, il doit établir une connexion (on dit aussi ouvrir une
session).

Il est à signaler que le système d'exploitation Linux offre deux types de connexions à
savoir :
a) connexion en mode graphique : vous utilisez l'outil graphique pour ouvrir une
session.
b) connexion en mode texte : vous utilisez la Console pour ouvrir une session.
Tout au long de nos travaux pratiques, c'est le mode texte qui sera utilisé.

Remarques
 En cas d‟erreur lors de la saisie du nom ou du mot de passe, le système
donne à l‟utilisateur la possibilité de recommencer.
 Une erreur lors de la saisie du nom peut être annulée par la combinaison de
touches <ctrl–u>.

Mot de passe

© Kasengedia motumbe pierre 252

 Page 253 sur 270



Lors d‟une première connexion, il est fortement conseillé à l‟utilisateur de s‟attribuer
un mot de passe. Ce mot de passe sera chiffré (le chiffrage est purement logiciel et
non inversible). Il sera impossible de le retrouver à partir du mot chiffré, même pour
le super–utilisateur
(l‟administrateur de la machine). Si l‟utilisateur oublie son mot de passe,
l‟administrateur ne peut que le détruire pour lui permettre d‟en définir un nouveau.
Un utilisateur peut à tout moment changer son mot de passe, ou s‟en attribuer un
par la commande passwd. Lors du changement, il faut fournir l‟ancien mot de passe.

Si vous avez réalisé vous-même l‟installation, une fois cette dernière terminée,
connectezvous au système en tant qu‟administrateur (répondre root au login :). Il
faut immédiatement définir un mot de passe pour cet utilisateur root aussi appelé
super-utilisateur. Ce mot de passe doit contenir plus de six caractères. Il vous
permettra de vous connecter en tant qu‟utilisateur root et ainsi d‟avoir tous les droits
sur le système.
Mais attention il ne faut jamais l‟utiliser comme un compte personnel. Il doit être
utilisé pour réaliser des modifications dans votre système. C‟est pourquoi la
première action d‟un administrateur est de créer un compte personnel. Pour ceci, il
suffit d‟utiliser la commande useradd.

Fichiers /etc/passwd et /etc/group

La liste des utilisateurs du système est généralement dans le fichier /etc/passwd. Ce

fichier est accessible en lecture à tous les utilisateurs et contient, pour chaque
utilisateur, les champs suivants :
 nom de connexion (login) de l‟utilisateur,
 un caractère x
 le numéro de l‟utilisateur (UID = user identifier),
 le numéro de groupe (GID = group identifier),
 [ commentaire ],

© Kasengedia motumbe pierre 253

 Page 254 sur 270

le répertoire
d‟accueil,
[ programme à
lancer ].

NB : Les points cités entre crochets ne sont pas obligatoires.

Exemple : voici un extrait du fichier /etc/passwd et /etc/group

Un groupe d’utilisateurs rassemble un certain nombre d‟utilisateurs pouvant

facilement partager des fichiers. Ce groupe est répertorié dans un fichier (/etc/group)
qui est constitué par
:
 nom du groupe,
 un champ vide ou contenent un caractère x ou * numéro du groupe (GID =
group identifier), [ liste des utilisateurs membres du groupe ].

Les notions d‟UID et de GID sont importantes pour la protection des fichiers (il ne
faut pas les changer inconsidérément). Un utilisateur a un groupe principal de
rattachement et peut appartenir à plusieurs autres groupes.

Déconnexion
Elle peut se réaliser de deux manières à savoir :
En mode texte
Pour sortir de session, vous pouvez utiliser la commande exit. La déconnexion est
effective lorsqu‟apparaît l‟invite login :.

En mode graphique
Pour sortir de session, il faut sélectionner avec le bouton gauche de la souris le
menu démarrer puis choisir la commande log out. La déconnexion est effective
lorsqu‟apparaîtra l‟invite graphique login.

© Kasengedia motumbe pierre 254

 Page 255 sur 270



LES SHELLS

Après toute entrée en session (login), le système positionne l‟utilisateur dans son
répertoire privé (home directory ou répertoire d’accueil), qui a été créé par
l‟administrateur du système au moment de l‟ouverture de son compte et qui devient
son répertoire de travail courant (current working directory). Puis le système active
l‟interpréteur de commandes désigné dans le dernier champ du fichier /etc/passwd.
Il existe plusieurs interpréteurs de commandes : le Bash, le TC–shell, et d‟autres.
Historiquement, le Bourne–shell fut le premier et a donc fait partie de la première
version d‟Unix. Il a été maintenu dans la version System V d‟AT&T ainsi que dans la
version Berkeley (BSD).

Autres shells
 TC–shell (Tenex C–shell) de souche Berkeley
 le Z–shell totalement libre
 le Bash, shell standard sous Linux

Le TC–shell est un descendant très amélioré du C–shell d‟origine Berkeley. Le shell

standard de Linux est le Bash, descendant très amélioré du Bourne–shell. Cet
interpréteur de commandes est présenté plus en détail un peu plus loin.
(a) TC–shell
Le TC–shell doit son nom au fait que sa syntaxe est inspirée du langage C. Il
possède des fonctionnalités supérieures à celles du Bourne–shell, entre autres :
un mécanisme d‟historique avec rappel et édition des commandes ;
 la possibilité de création d‟alias ;
 des possibilités accrues pour le contrôle de processus.
Il exécute deux fichiers d‟initialisation, qui sont les deux fichiers de commandes
(scripts) du répertoire privé de l‟utilisateur : .cshrc et .login. Puis l‟interpréteur se met
en attente d‟une commande de l‟utilisateur.

© Kasengedia motumbe pierre 255

 Page 256 sur 270

Le fichier d‟initialisation .cshrc est exécuté lors de chaque appel au TC–shell. Il est
destiné à positionner des variables du TC–shell, à affecter pour certaines
commandes des arguments implicites et à définir d‟autres commandes (alias). Il
affecte une valeur :
 à la variable prompt qui définit l‟invite,
 à la variable path qui contient les répertoires de recherche des commandes,
 aux variables nécessaires à la gestion de l‟historique des commandes, etc.
Le fichier .login, qui est exécuté après le fichier .cshrc, une seule fois lors de la
connexion, est destiné à positionner des variables d‟environnement de la session. Il
contient lesn initialisations standard, principalement les caractéristiques du terminal
utilisé.

Les principales variables du TC–shell sont :

1. prompt : valeur du prompt.
2. path : précise le chemin d‟accès aux répertoires contenant les principaux
programmes.
3. home : indique le répertoire d‟accueil de l‟utilisateur.
En sortie de session, à l‟aide de la commande exit, le fichier de commandes .logout
est exécuté.

(b) Bash
Après une entrée en session (login) sur un système Linux, vous êtes pris en charge
par un interpréteur de commandes (shell) qui est le Bash (bash). A la connexion,
avant l‟interprétation des commandes, c‟est à dire apparition du prompt, le Bash
exécute les fichiers d‟initialisation : /etc/profile et .bash profile.
Le fichier /etc/profile est généralement géré par l‟administrateur système alors que le
fichier .bash profile, se trouvant dans le répertoire d‟accueil (Home Directory), est à
la disposition de l‟utilisateur. L‟existence (ou non), l‟accès en lecture d‟un de ces
fichiers, peut changer l‟ordre d‟accès à ces fichiers ou à d‟autres fichiers, .bash
login par exemple.

© Kasengedia motumbe pierre 256

 Page 257 sur 270



Ces fichiers permettent de modifier ou de créer des variables internes au shell, ou
des variables d‟environnement, de créer des fonctions, etc.

Les principales variables du Bash sont :

PS1 : valeur du prompt.
 PATH : précise le chemin d‟accès aux répertoires contenant les principaux
programmes.
 HOME : indique le répertoire d‟accueil de l‟utilisateur.
En sortie de session, à l‟aide de la commande exit, le fichier de commandes .bash
logout est exécuté s‟il existe.

© Kasengedia motumbe pierre 257

 Page 258 sur 270

COMMANDES LINUX

Il existe sous Linux de nombreuses commandes dont on trouvera les plus courantes
en annexe et que nous présenterons dans cette partie qui est totalement dédiées
aux travaux pratiques sous Linux.
Une commande est composée en premier d‟un code mnémonique (son nom
proprement dit), suivi parfois d‟options et/ou de paramètres. Une option dans une
ligne de commandes Unix est une lettre. Elle commence par un tiret "–". Sous Linux,
les options peuvent être de la forme :
-c c = caractère
--mot mot = un mot explicite l‟espace est le caractère séparateur des différents
éléments d‟une commande. Cette dernière est prise en compte et n‟est interprétée
que lorsque l‟utilisateur a tapé la touche <return>.

Remarque
Pour obtenir la totalité des options d‟une commande, il faut faire appel à
l‟option help. Exemple : root@junior-kaningini-laptop:/home/juni-kaningini# ls
–i<return> root@junior-kaningini-laptop:/home/juni-kaningini# ls inode<return>

Il est possible, à tout moment avant la saisie de <return>, de modifier ou d‟effacer

une commande saisie au clavier et affichée à l‟écran. La touche <backspace> (sur
le clavier 102 touches, la touche situé au-dessus du <return>) ou la combinaison
de touches <ctrl–h> permet d‟annuler le dernier caractère saisi et ainsi de modifier la
commande. La combinaison
<ctrl–u> permet d‟effacer tous les caractères situés à gauche du curseur.
Exemple
root@junior-kaningini-laptop:/home/juni-kaningini# ls –lz § erreur de frappe : z en
trop § la touche <backspace> permet
§ d’annuler le dernier caractère root@junior-kaningini-
laptop:/home/juni-kaningini# ls –l

© Kasengedia motumbe pierre 258

 Page 259 sur 270

L‟interpréteur Bash permet de modifier des commandes déjà exécutées et de les

relancer. Linux autorise la frappe anticipée des caractères, c‟est–à–dire qu‟il est
possible de saisir une réponse à une question sans que cette dernière soit apparue
à l‟écran (à n‟utiliser que lorsque l‟on a une parfaite maîtrise du système).
L‟exécution d‟une commande peut être interrompue à l‟aide de la combinaison
<ctrl–c>. Si vous avez saisi une commande inconnue du système, ce dernier vous
l‟indiquera par un message d‟erreur.

Exemple
root@junior-kaningini-laptop:/home/juni-kaningini# date
Tue May 9 10:50:24 CEST 2000 root@junior-kaningini-
laptop:/home/juni-kaningini# dte bash: dte: Command
not found.
root@junior-kaningini-laptop:/home/juni-kaningini#

Si la commande existe, elle est exécutée et affiche à l‟écran le résultat. En cas

d‟une erreur d‟option, le programme indique l‟erreur à l‟écran et parfois affiche la
liste des options disponibles.

Exemple
root@junior-kaningini-laptop:/home/juni-kaningini# who
root@junior-kaningini-laptop:/home/juni-kaningini# pts/1 May 9
10:49 root@junior-kaningini-laptop:/home/juni-kaningini# pts/0
May 9 09:27 root@junior-kaningini-laptop:/home/juni-kaningini#
who c who: invalid option c
Try `who help' for more information.
root@junior-kaningini-laptop:/home/juni-kaningini#

Remarque
Pour les utilisateurs de machines Linux, il est formellement déconseillé de
redémarrer la machine (couper le secteur, reset). En effet, un arrêt brutal de Linux a

© Kasengedia motumbe pierre 259

 Page 260 sur 270

pour conséquence de rendre le système de fichiers incohérent. Ainsi, si vous êtes «

planté », c‟est–à–dire si l‟une de vos applications bloque l‟écran, que la combinaison
de touches <ctrl–c> ne permet pas de détruire le programme, contrairement à ce
que vous feriez avec le DOS, surtout n’éteignez pas l’ordinateur. Une solution existe :
lancer un écran virtuel par la combinaison de touches <alt–ctrl–F2>. Dans cet écran,
vous pourrez lancer des commandes de destruction de programmes et vous pourrez
ainsi récupérer la main.

LE TERMINAL

Il est possible sous Linux d‟activer simultanément plusieurs consoles de connexion.

En mode texte, le basculement entre les consoles est obtenu par la combinaison de
touches <alt–ctrl– Fx>, où Fx représente les touches de fonction F1 à F8 situées sur
le haut de votre clavier.

Remarque

Pour les utilisateurs de machines Linux, il est formellement déconseillé de

redémarrer la machine (couper le secteur, reset). En effet, un arrêt brutal de Linux a
pour conséquence de rendre le système de fichiers incohérent. Ainsi, si vous êtes «
planté », c‟est-à-dire si l‟une de vos applications bloque l‟écran, que la combinaison
de touches <ctrl–c> ne permet pas de détruire le programme, contrairement àce que
vous feriez avec le DOS, surtout n‟éteignez pas l‟ordinateur. Une solution existe :
lancez un écran virtuel par la combinaison de touches <alt–ctrl–F2>. Dans cet écran,
vous pourrez lancer des commandes de destruction de programmes et vous pourrez
ainsi récupérer la main. Si vous êtes en mode graphique et que vous ne pouvez plus
déplacer la souris, la combinaison de touches <alt–ctrl–backspace> permet de
revenir à un mode texte. Le mode graphique est relancé à partir du mode texte par
la commande startx.

© Kasengedia motumbe pierre 260

 Page 261 sur 270

EXERCICES LINUX

1) Dans le système UNIX, les véritables appels système sont effectués à partir :

 d‟un programme utilisateur ;

 d‟une commande shell ;
 d‟une procédure de la bibliothèque standard

Sont-ils exécutés en mode superviseur ou en mode utilisateur ?

2) Comment sont organisés les fichiers dans le système UNIX ? Un utilisateur peut-il
accéder à un fichier d‟un autre utilisateur ? Si oui, comment ?

3) Dans le système UNIX, est-ce que tout processus a un père ? Que se passe-t-il
lorsqu‟un processus devient orphelin (mort de son père) ? Quand est-ce un
processus passe à l‟état Zombie ?

4) Pour lancer en parallèle plusieurs traitements d‟une même application, vous avez
le choix entre les appels système fork( ) et pthread_create( ). Laquelle des deux
possibilités choisir ? Pourquoi ?

5) Citez quatre événements qui provoquent l‟interruption de l‟exécution d‟un

processus en cours, dans le système UNIX.

© Kasengedia motumbe pierre 261

 Page 262 sur 270

6) Quel est le rôle de l‟ordonnanceur ? Décrire brièvement l‟ordonnanceur du

système UNIX
? Favorise-t-il les processus interactifs ? 7) Pourquoi le partage de
données pose des problèmes dans un système multiprogrammé en temps partagé ?
Le système UNIX permet-il de contrôler les accès aux données partagées ? Qu‟est-
ce qu‟une section critique ?

8) Les commandes linux

1. Que réalise la commande : chmod 751 ~/*.pl?
2. Que réalise la ligne de commandes : ls -l | grep '^[^09]+$'
3. Quelle est la commande qui permet de changer de répertoire ? (proposez un
exemple).
4. Afficher par ordre alphabétique les utilisateurs définis dans le fichier /etc/passwd.
5. Rechercher tous les fichiers du répertoire /etc contenant la chaîne de caractères
"root".
6. Créer un répertoire "Old".
7. Déplacer tous les fichiers avec l'extension old vers le répertoire "Old".
8. Sous votre répertoire de départ, créez un lien matériel "Mon_lien" équivalent à
"Mon_fichier_2".
9. Quelle est la taille totale des fichiers contenue dans votre répertoire?
9) Exercice
1. Créez deux groupes "Group1" et "Group2".
2. Créez quatre utilisateurs "user1, user2, user3 et user4" ?
3. Rendez les utilisateurs dans les groupes :
• Les premiers et deuxièmes utilisateurs sont membres du premier groupe.
• Les troisièmes et quatrièmes utilisateurs sont membres du second groupe.

10) Exercice
Lister tous les fichiers qui :
• se terminent par 5.

© Kasengedia motumbe pierre 262

 Page 263 sur 270

• commencent par annee4.

• commencent par annee4 et de 7 lettres en maximum.
• commencent par année avec aucun chiffre numérique.
• contiennent la chaîne "reda".
• commence par r ou R.
11) Exercice
Si on applique la commande Umask 024. Quels sont les droits qui seront appliqués
aux fichiers et aux dossiers au moment de leur création?
12) Exercice
Pour exécuter la commande : cp rep1/file1 rep2/rep3
Quels droits d'accès devez-vous avoir sur rep1, rep2, rep3 et file1?
13) Exercice
Créer un script permettant d'afficher la liste des fichiers du répertoire /etc accessible
en exécution?
14) Exercice
Créer un script qui permet d'afficher le mois correspond à un chiffre de 1 à 12.
15) Exercice
Créez un fichier premiertexte contenant une ou deux phrases.
16) Exercice
Visualisez le contenu de premiertexte sans l'éditer
17) Exercice
Quelle est la taille de premiertexte ?
18) Exercice
Éditez PREMIERTEXTE. Que constatez-vous ?
Utilisez les commandes cp, ls, mv
19) Exercice
a) Faites une copie de premiertexte appelée double
b) Comparez leurs tailles
c) Renommez double en introduction
d) Quelle différence y a-t-il entre mv double introduction et cp double
introduction ? Utilisez les commandes mkdir, cd, cp, ls, mv

© Kasengedia motumbe pierre 263

 Page 264 sur 270

20) Eexercice

a) Créez un répertoire essai/

b) Déplacez double dans essai/
c) Faites une copie de premiertexte appelée copie, et placez-la également dans
essai
d) Affichez une liste de ce que contient essai/

Utilisez les commandes rmdir, cd, rm

21) Exercice
a) Essayez de détruire essai/. Que se passe-t-il ? Que faut-il faire pour détruire
un répertoire ?
b) Détruisez tout ce que contient essai/
c) Détruisez essai/

CRITERES POUR LES NOMS DE FICHIER

Exercice 1:
Dans votre répertoire courant, créez en une commande les fichiers suivants: annee1
Annee2 annee4 annee45 annee41 annee510 annee_saucisse banane

Exercice 2:
Créer le répertoire Year dans votre répertoire courant, en une commande déplacez
les fichiers précédemment créés dans le répertoire Year.

Exercice 3:
Lister tous les fichiers : se terminant par 5 commençant par annee4
commençant par annee4 et de 7 lettres
maximum commençant par annee avec aucun
chiffre numérique

© Kasengedia motumbe pierre 264

 Page 265 sur 270

contenant la chaîne ana

commençant par a ou A

Copier les fichiers dont l'avant dernier caractère est un 4 ou 1 dans le répertoire /tmp
en une seule commande.

Exercice 4:
Dans votre répertoire courant, créez un répertoire courant essai_droit, par défaut ce
répertoire est à 755 (rwxr-xr-x), quelles sont les commandes (en notation symbolique
et en base 8) pour

propriétaire groupe les autres

droit en droit en droit droit en droit en droit droit en droit en droit

lecture écriture d'accès lecture écriture d'accès lecture écriture d'accès

commande
oui oui oui oui non oui non non oui
1

commande
oui non oui non oui non non non oui
2

commande
non oui non non non oui oui non non
3

commande
non non oui oui non oui non non non
4

lui donner les droits suivant (on suppose qu'après chaque commande on remet le
répertoire à 755:

Exercice 5:
Créez un fichier droit dans le répertoire essai_droit, par défaut ce fichier est à 644
(rw-r--r--). En partant du répertoire courant, pour chaque commande de l'exercice
précédent, essayez d'accèder au répertoire essai_droit (commande cd), de faire un
ls dans essai_droit et de modifier le fichier avec un éditeur quelconque (vi par
exemple).

© Kasengedia motumbe pierre 265

 Page 266 sur 270

Exercice 6:
Tapez la commande umask, de manière à ce que les fichiers lors de leur création
aient par défaut les droits 640 (rw-r-----), et les répertoires 750 (rwxr-x---).

GREP

Exercice 7:
Créer un répertoire essai-grep dans votre home directory. Dans ce répertoire créer
les fichiers suivants:
Tomate poire pomme cerise Fraise fraise courgette POMME3 afraise
Editez les fichiers (sortie de la commande ls redirigée vers grep) avec les critères sur
leur nom suivant:

Critère Le nom doit être Fraise ou fraise

1

Critère se est en fin de nom

2

Critère ai est présent dans le nom

3

Critère Nom contenant un chiffre

4 numérique

Critère Nom contenant la chaîne mm ou

5 MM

Exercice 8
Copiez le fichier /etc/passwd dans votre home directory. Editez la ligne commençant
par votre nom de login.

© Kasengedia motumbe pierre 266

 Page 267 sur 270

Exercice 9
Dans le fichier passwd qui est dans votre home directory, éditez les lignes
commençant par des noms de login ne contenant pas de chiffre.

Exercice 10
Editez les lignes du fichier passwd commençant par des noms de login de 3 ou 4
caractères.

LES FILTRES

Exercice 11
Copiez le fichier /etc/passwd dans votre home directory. Editez uniquement les
champs contenant le login et la home directory.

Exercice 12

Triez passwd sur le nom

Exercice 13

Extraire les noms de login et UID puis triez suivant les UID, le tout en une seule
commande, vous redirigerez le tout vers un fichier

Exercice 14

Dans le fichier de résultat précédent remplacer les ":" par des " " (espace).

Exercice 15

Editez les cinq dernières lignes du fichier.

© Kasengedia motumbe pierre 267

 Page 268 sur 270

Exercice 16
Editez les cinq premiers caractères du fichier.
Find

Exercice 17
Cherchez dans toute l'arborescence les fichiers dont le nom se termine par .c,
redirigez les erreurs vers le fichier poubelle /dev/null Commençant par X ou x.
Dont les noms ne contiennent pas de chiffre.
Exercice 18
Chercher dans /usr les fichiers dont la taille dépasse 1Mo (2000 blocs de 500Ko) et
dont les droits sont fixés à 755 (-rwxr-xr-x).

Exercice 19
Combien il y a de fichiers dans toute l'arborescence vous appartenant et ayant les
droits fixés à 666 (-rw-rw-rw-).
Exercice 20
Trouver tous les fichiers core dans l'arborescence et supprimez-les après
confirmation.

© Kasengedia motumbe pierre 268

 Page 269 sur 270

BIBLIOGRAPHIE

1. Crocus. Système d'exploitation des ordinateurs.DUNOD. BORDAS 1975

2. Daniel Tshirrhart. Commande en temps réels. Dunod 1991
3. KASENGEDIA MOTUMBE Pierre. Concepts fondamentaux d'un système à
microprocesseurs. Syllabus.Fac.Sciencess UNIKIN 1999.
4. Harold Lorin Harvey, M. Dertel. Operating systms. ADDISON-WESLEY.
Publishing company. 1981
5. Paolo Zanella. Architecture et technologies des ordinateurs. DUNOD 1999
6. Frederic j .Hill. Digital Systems: hardware organisation and design. John
Willey & Sons .New york 1978
7. ANDREW S. TANENBAUM. Systemes d'exploitation. Université Libre
D'Amsterdam Intereditions. 1991

© Kasengedia motumbe pierre 269

 Page 270 sur 270

8. ANDREW S. TANENBAUM. Systèmes d‟exploitation, Edition Pearson 3ème,

2008
9. ANDREW S. TANENBAUM. Architecture d'ordinateur. Université Libre
D'Amsterdam. Intereditions. 1991
10. Ellis horonsitz, Sartaj sahm : Fundamentals of computer algorithms computer
Science pression
11. virga, Jean-Pierre Lovinosse. Organiser la memoire de notre ordinateur.
Marabont. Alleur(Belgique).1993
12. J. Archet Harri. Systemes d'exploitation. SCHAUM'S. Ediscience Dunod. Paris
2002.
13. Jean-Paul, Armspach, Pierre Colin, Frédérique Ostré Waerzeggers. LINUX :
Initiation et utilisation, 2e édition, Dunod, Paris, 2000, 2004 ISBN 2 10 007654
X
14. Saria HATOUM, note de TPs Systèmes d‟exploitation Séance 2 : Les
Processus fork et wait, Université de Namur, 2015-2016
15. Divers URL Internet

© Kasengedia motumbe pierre 270