Support OS L2-Tous 2

Contenu |1
Ecole Supérieure d’Informatique Salama

République Démocratique du Congo
Lubumbashi, Haut-Katanga
Système d’exploitation
L2_Tous/ESIS
User
Contenu |2
Contenu
Contenu ............................................................................................................................................... 2
Objectifs ............................................................................................................................................... 5
Fiche de la matière.................................................................................Erreur ! Signet non défini.
Prérequis ............................................................................................................................................... 5
Discipline à respecter .............................................................................Erreur ! Signet non défini.
Principes à respecter ..............................................................................Erreur ! Signet non défini.
Evaluations................................................................................................Erreur ! Signet non défini.
Introduction ......................................................................................................................................... 6
0.1. Définition des concepts..................................................................................................... 6
0.1.1. Informations ...................................................................................................................... 6
0.1.2. Messages .......................................................................................................................... 6
0.1.3. Donnée : ........................................................................................................................... 6
0.1.4. Informatique ou information automatique ............................................................... 6
0.1.5. Ordinateur ........................................................................................................................ 6
0.1.6. Programme....................................................................................................................... 7
0.2. Système informatique ........................................................................................................ 7
0.3. Système d’information ....................................................................................................... 8
0.4. Ordinateur et changements technologique ................................................................ 9
0.4.1. Ordinateur ........................................................................................................................ 9
0.4.2. Structure d’un ordinateur .............................................................................................. 9
0.4.3. Changement technologique .....................................................................................12
1.1.1. Première génération: Tubes électroniques ou lampe à vide (1945 - 1955) ..12
1.1.2. Deuxième génération: Transistors et systèmes par lots (1955 - 1965) .............12
1.1.3. Troisième génération: circuits intégrés (1965 - 1980)..........................................13
1.1.4. Quatrième génération: microprocesseurs (1980 – à nos jours) .......................14
1.1.5. Cinquième génération: intelligence artificielle (Actuellement en cours) .....15
0.5. Machine de Von Neumann............................................................................................16
0.6. Schéma général d’un ordinateur..................................................................................17
Chapitre.1 Généralités sur le système d’exploitation ...............................................................19
User
Contenu |3
1.2. Qu’est-ce qu’un Système d’exploitation .....................................................................19

1.2.1. Le système d'exploitation ........................................................................................19
1.2.2. L'interface utilisateur .................................................................................................19
1.2.3. L'apport du système d'exploitation aux applications ........................................19
1.2.4. La tâche du système d'exploitation vis- à-vis des ressources système ..........20
1.3. Terminologie :.....................................................................................................................20
1.3.1. Multitâche ...................................................................................................................21
1.3.2. Multithreading ............................................................................................................21
1.4. Fonction d’un système d’exploitation ..........................................................................22
Chapitre.2 Gestion des processus ................................................................................................23
2.1. Processus.............................................................................................................................23
2.2. Les niveaux d'ordonnancement des processus .........................................................23
2.3. Les états d'un processus ..................................................................................................24
2.4. L'ordonnancement des processus ................................................................................26
2.4.1. Critères d'ordonnancement des processus.........................................................27
2.4.2. Algorithmes d'ordonnancement " scheduling algorithms " ..............................27
Chapitre.3 Synchronisation des processus..................................................................................34
3.1. Communication inter-processus ....................................................................................34
3.2. Partage d'informations ....................................................................................................34
3.3. Partage des ressources d'un système informatique ..................................................34
3.3.1. Exemple de conflit d'accès ....................................................................................35
3.4. La synchronisation des processus ..................................................................................36
3.4.1. Section critique ..........................................................................................................36
3.4.2. Blocage .......................................................................................................................40
3.4.3. Famine .........................................................................................................................41
3.5. Mécanismes d'exclusion mutuelle.................................................................................41
3.5.1. Désactiver les interruptions......................................................................................41
3.5.2. Les sémaphores .........................................................................................................41
Chapitre.4 Gestion de la mémoire...............................................................................................43
4.1. Rôle de la mémoire ..........................................................................................................43
4.2. Gestion de la mémoire pour systèmes monotâches ................................................44
User
Contenu |4
4.3. Gestion de la mémoire pour systèmes multitâches ..................................................44

4.3.1. Partition de la mémoire............................................................................................45
4.4. La pagination.....................................................................................................................46
4.4.1. Fonctionnement des tables de pages .................................................................47
4.5. La segmentation ...............................................................................................................49
4.6. Segmentation avec pagination ....................................................................................49
Bibliographie .....................................................................................................................................51
User
Objectifs |5
Objectifs
A l'issue de ce cours l'étudiant(e) sera capable de :
▪ Maitriser le fonctionnement d’un ordinateur abstrait autrement dit connaître

l’importance d’un système d’exploitation sur un ordinateur physique
▪ Installer normalement un système d’exploitation + les applications sur un

ordinateur
▪ Comprendre la gestion des processus, des mémoires et des fichiers
Prérequis
• Architecture des ordinateurs
• Logiques
• Algorithme
• Connaissance nécessaire à la compréhension abstraite des
ordinateurs
User
Introduction |6
Introduction
Aujourd’hui, la technologie évolue et les ordinateurs aussi en s’adaptant aux
besoins de l’utilisation de l’homme dans différent secteur de travail.
Ce cours se propose donc d’introduction aux concepts de base des systèmes
informatiques ainsi que leur fonctionnement, leur utilisation, ainsi que leur
installation.
0.1. Définition des concepts

0.1.1. Informations
Élément de connaissance susceptible d'être représenté à l'aide de
conventions pour être conservé, traité ou communiqué
0.1.2. Messages
Ensemble de données destinées à être transmises par un système informatique
0.1.3. Donnée :
Représentation conventionnelle d'une information en vue de son
traitement informatique.
0.1.4. Informatique ou information automatique

Information automatique ; désigne la science du traitement automatique
de l'information par une machine capable de traiter ou de manipuler les
informations ou les données sous forme numérique ou binaire c'est la notion
de l'ordinateur (Matériel + logiciel).
Le traitement de l'information c'est :
▪ Le calcul arithmétique et logique

▪ La gestion et l'enregistrement des informations
▪ La communication et l'échange des données
0.1.5. Ordinateur
Un ordinateur est défini comme une machine à calculer appeler autre fois
calculateur ou de nos jours comme un dispositif électronique programmable de
traitement automatique de l’information qui est dotée de mémoires, de moyens
de traitement des informations qui est capable de résoudre des problèmes grâce
à l’exploitation automatique de programme enregistres. Il renferme également
de circuits électroniques qui lui permettent de manipuler les données sous forme
binaires.
User
Introduction |7
0.1.6. Programme
Un programme informatique est une liste d'ordres indiquant à un ordinateur ce
qu'il doit faire. Il se présente sous la forme d'une ou plusieurs séquences
d'instructions, comportant souvent des données de base, devant être exécutées
dans un certain ordre par un processeur ou par processus informatique.
Nous avons souvent improprement utilisé le terme « programme informatique »

comme synonyme de « logiciel » ; Pour le logiciel actuellement est composes de
plusieurs programmes qui permet à un ordinateur ou un système informatique
d’assurer correctement tache ou une fonction précise et particulier.
Le terme logiciel est employé souvent pour désigner un programme

informatique, et de manière inverse, bien que nous sachions qu’un logiciel est
composé d’un seul ou d’une suite de programmes.
▪ Exemple de logiciel :
o Logiciel de Gestion de relation client (CRM)
o Logiciel de comptabilité
o Navigateur web (Mozilla, Google chrome, Internet Explorer)
o Etc.
L’exemple ci-dessus représente des logiciels plutôt que des programmes, car ils
sont le fruit de la concaténation de multiple programme exécutant différents
actions et fonctions.
0.2. Système informatique

Un système informatique est un ensemble de dispositifs (matériels et logiciels)
associés, sur lesquels repose un système d'information. Il est constitué
généralement des serveurs, routeurs, pare-feu, commutateurs, imprimantes,
médias (câbles, wifi, etc.), stations de travail, systèmes d'exploitation,
applications, bases de données, etc.
▪ Côté matériel, un ordinateur est composé de :

o L’Unité Centrale (UC) pour les traitements
o La Mémoire Centrale (MC) pour le stockage
o Les Périphériques : disque dur, clavier, souris, carte réseau...
accessibles via des pilotes de périphériques
▪ Côté logiciel, un système informatique est composé de deux niveaux bien
distincts : le système d’exploitation et les applications.
User
Introduction |8
o L’objectif du logiciel est d’offrir aux utilisateurs des fonctionnalités

adaptées à leurs besoins.
o Le principe est de masquer les caractéristiques physiques du
matériel.
o La solution consiste à structurer en couches le logiciel, chacune
offrant des services de plus en plus évolués au niveau supérieur.
▪ Cette abstraction logicielle du matériel s’appelle machine
virtuelle.
Figure 1 Représentation d’un système informatique
0.3. Système d’information

Un système d'information est un ensemble de moyens organisés permettant
d'élaborer, de traiter, de stocker et/ou de diffuser de l'information grâce aux
processus ou services.
Parties d'un système d’information :
▪ Hommes : Si vous y réfléchissez, la seule raison d'être des ordinateurs est

d'aider les hommes à atteindre leurs objectifs. Par conséquent, lors de
la planification d'un système d'information, il est essentiel de
comprendre ce que les hommes espèrent en tirer. Ont-ils besoin de
certaines informations ? Ont-ils besoin de l'ordinateur pour activer un
périphérique qui effectue une tâche ? Veulent-ils être divertis ou
éduqués ? La première étape de la planification d'un système
d'information consiste à analyser les besoins des personnes.
▪ Matériel : Quand la plupart des gens pensent aux ordinateurs, ils
pensent immédiatement au matériel, aux parties physiques du système
informatique. Le matériel comprend des circuits imprimés avec des
User
Introduction |9
puces de silicium et des transistors montés sur eux, des dispositifs d'entrée
comme le clavier et la souris, et des dispositifs de sortie tels que des
imprimantes et des moniteurs.
▪ Logiciel : Le matériel informatique ne fonctionne que s'il n'y a pas de
logiciel, c'est-à-dire un programme qui indique au matériel quoi faire. Il
existe différents niveaux de logiciels, y compris le système d'exploitation
(comme Windows ou Mac OS) et les applications (comme un
traitement de texte ou un programme de comptabilité).
▪ Procédures : Le logiciel ne s'exécute pas lui-même (généralement). Les

gens doivent interagir avec l'ordinateur pour lui dire quel logiciel
exécuter. Par exemple, avant de pouvoir créer des chèques avec votre
logiciel de comptabilité, vous devez démarrer le logiciel, ouvrir le fichier
qui stocke les données pour l'entreprise et émettre la commande qui
ouvre le registre de compte de contrôle. Vous pouvez apprendre des
procédures à partir du système d'aide en ligne de l'application, à partir
d'un manuel d'utilisateur imprimé, d'un cours de formation ou par essais
et erreurs.
▪ Données : Les programmes informatiques fonctionnent sur les données
qu'ils reçoivent. Par exemple, dans votre logiciel de comptabilité, vous
saisissez des données sur les chèques que vous écrivez- la date, le
montant, le destinataire - et le programme stocke ces données afin que
vous puissiez les rappeler plus tard.
0.4. Ordinateur et changements technologique

0.4.1. Ordinateur
Il est décomposé essentiellement en deux parties
a. Le matériel ou physique (Hardware) : c'est l'ensemble des

composantes électroniques modulaire c'est à dire qu’on peut
remplacer une composante par une autre afin d'améliorer les
performances de l'ordinateur
b. Le logiciel (Software) : c'est un ensemble de programme assurant la
gestion et la commande de la partie matériel de l'ordinateur. C'est le
système d'exploitation et les applications spécifiées
0.4.2. Structure d’un ordinateur

La structure de base d’un ordinateur comprend les éléments
fondamentaux suivant :
User
I n t r o d u c t i o n | 10
▪ Une unité centrale de traitement (Microprocesseur) : Unité

centrale de traitement en anglais CPU (Central Prossecing Unit)
est le central de calcul et de contrôle d’un ordinateur, elle
constitue le cerveau de l’ordinateur. Il est caractérisé par sa
marque (Intel, AMD ou Cyrix) et par sa fréquence d’horloge (1 KHz
= 210 Hz, …, 1 GHz = 230 Hz).
Et se compose de 2 parties essentielles :
▪ L’unité arithmétique et logique (UAL ou ALU en anglais) : Est
l’organe qui permet d’effectuer des opérations
arithmétiques (addition, soustraction, multiplication,
division), des opérations logiques (ET, OU, NON, …).
▪ L’unité de contrôle ou l’unité de commande : Gère le
déroulement des instructions en décodant et en exécutant
les instructions demandées et réalisées par le processeur.
▪ Une unité de mémoire, appelée mémoire centrale : Est l’organe

de l’ordinateur permettant d’enregistrer, de stocker et de restituer
les informations. Elle se présente sous la forme de petites barrettes
que l’on peut enficher dans des supports, appelés Slots.
La mémoire centrale d’un ordinateur est séparée en deux
sections : la mémoire vive et la mémoire morte.
▪ Des unités de stockage : Sont les organes de l’ordinateur qui
permettent le stockage des informations.
▪ Disque dur : est un support de stockage de forme
cylindrique, composé d’un regroupement de disques
magnétiques rigide protégé par un boîtier, le disque dur est
le principal outil de stockage de données d’un ordinateur.
La capacité d’un disque dur est exprimée en giga-octets
(80, 120, 200, 500 Go).
▪ Disquette : est composé d’un plateau circulaire en matière
plastique qui tourne à l’intérieur d’un étui de protection
carré. La capacité d’une disquette est 1.44 Mo soit 1444
octets.
▪ Des unités d’entrée/sortie : Sont les organes de l’ordinateur qui
permettent la communiquer avec l’unité centrale et de stocker,
de collecter et de transmettre des données.
▪ Les périphériques d’entrée :
• Le clavier
User
• La souris
• Scanner
• Microphone
• Etc.
▪ Les périphériques de sortie :
• L’écran
• L’imprimante
• Les Enceintes
• Etc.
▪ Un système de bus permettant de véhiculer l’information entre
l’unité centrale et les autres unités : Est l’organe qui constitue le
schéma fonctionnel d’un ordinateur.
Figure 2. Architecture d’un système informatique (ordinateur)
User
Figure 3. Un ordinateur et ses différents périphériques.
0.4.3. Changement technologique

1.1.1. Première génération : Tubes électroniques ou lampe à vide (1945 - 1955)
A cette ère l’informatique était seulement consacrée pour
l’armée et la science et posé des problèmes de place et
consommation électrique.
Cette technologie utilisée des relais mécaniques (temps de

cycles en secondes) remplacés ensuite par des tubes à vide ce qui
donne des machines énormes que l'on programmait en basculant
des interrupteurs.
Il y’avais aucun langage ni système d’exploitation pour cela et

cet à partir de 1950 que la première amélioration fut apportée avec
les cartes perforées « écriture programmable.
1.1.2. Deuxième génération : Transistors et systèmes par lots (1955 - 1965)

A cette ère fut nait l’informatique de gestion, les ordinateurs
deviennent suffisamment fiables pour être commercialisés mais seule
pour les grandes entreprises et les nations riches.
L’apparition des langages FORTRAN qui un langage incontesté

et COBOL (orienté gestion) qui étais un concurrent ainsi que
l’assembleur.
User
Les machines devaient être installées dans des locaux climatisés,

programmées via des cartes perforées que les programmeurs
remettaient aux opérateurs. Les opérateurs chargeaient les
programmes dans l'ordinateur avec le compilateur si nécessaire. Les
résultats étaient imprimés puis remis aux programmeurs.
Figure 4. Exemple de traitement par lots.
Ces manipulations engendraient des pertes de temps trop

couteuses vu l’importance de l’investissement.
Une machine Une machine moins onéreuse (IBM 1401) lisait les
cartes (a) pour en recopier le code sur une bande magnétique (b).
Le gros calculateur lisait cette bande (c), exécutait les jobs (d) puis
transcrivait les résultats sur une autre bande (e) postposant ainsi
l'impression des résultats (impression off-line ensuite par un ordinateur
plus léger (f).
1.1.3. Troisième génération : circuits intégrés (1965 - 1980)

Cette ère marqua la naissance du circuit intègre qui était une
nouvelle technologie basée sur le transistor et le circuit imprimé.
Les ordinateurs ont commencé à occuper moins de volume,

moins consommer l’électricité et augmenter en rapidité. Ils étaient
utilisés le plus souvent pour des applications de gestion.
Au début des années 60, il y avait deux types d'ordinateurs :
▪ Ceux qui comme le 7094 étaient orientés vers des tâches de

calculs intensifs. L'unité de donnée y est le mot.
User
▪ Ceux à vocation plus commerciale dont l'unité de donnée sont le

caractère (IBM 1401) et qui étaient utilisés par de gros organismes
tels que les banques et les compagnies d'assurances pour la
gestion de bandes magnétiques et l'impression de données.
1.1.4. Quatrième génération : microprocesseurs (1980 – à nos jours)

Cette ère est marquée par la création des microprocesseurs qui
a permis la naissance de la micro-informatique (micro-ordinateur)
avec les circuits LSI Large Scale Integration ciruit contenant des
milliers de transistors/mm². Un individu peut actuellement acheter son
ordinateur personnel (PC).
L’évolution des ordinateur personnels ce présente comme suit :
▪ 1974 : le 8080, microprocesseur 8 bits généraliste fabriqué par

Intel.
Gary Kildall, l'un des consultants d'Intel, a écrit un contrôleur de
disquettes 8 pouces pour ce processeur puis un système
d'exploitation orienté disque appelé le CP/M (Control Program for
Microcomputer). Pensant que ce système avait peu d'avenir Intel
a cédé les droits sur le CP/M à Kildall qui fonda Digital Research
pour développer et commercialiser le CP/M.
▪ 1977 : Le CP/M est réécrit pour fonctionner sur de nombreuses
plates-formes.
▪ 1981 : IBM PC/XT - Processeur 8088 4,77 MHz - 640 Ko max
IBM contacte Bill Gates pour son interpréteur BASIC et Gary Kildall
pour son CP/M mais ce dernier refuse la proposition de IBM.
IBM se tourne vers Bill Gates pour l'OS que celui-ci rachète (le DOS)
à un petit constructeur pour 50 000$ dit-on. Il engage ensuite Tim
Paterson l'auteur du DOS pour y apporter quelques modifications
-> le MS-DOS 1.0 8 Ko de code
▪ 1983 : MS-DOS 2.0 Les 24 Ko de code contiennent maintenant
un interpréteur de commandes et des fonctions inspirées de UNIX
Steve Jobs Co-inventeur de l'Apple découvre l'interface
graphique lors d'une visite chez Xerox Parc. L'idée est exploitée
pour donner le Lisa (trop chère) puis le Macintosh d'Appel
(succès)
User
▪ 1985 : L'environnement d'exploitation Windows 1.0 est considéré

comme un gadget. C'est une surcouche de MS-DOS, un
interpréteur de commandes graphique
▪ 1986 : IBM PC/AT Processeur 80286 - 8 MHz - 16 M, Le MS-DOS 3.0
fait 36 Ko de code. Le CP/M tombe dans l'oubli.
▪ 1987 : Windows 2.0 ne fait toujours pas plus sérieux
▪ 1990 : Sortie du 80386 qui est un processeur 32 bits
1.1.5. Cinquième génération : intelligence artificielle (Actuellement en cours)

Définir les ordinateurs de la cinquième génération est plutôt
difficile, puisque nous sommes en train de les créer. En En utilisant les
dernières avancées technologiques, les ordinateurs pourraient
comprendre le langage naturel et imiter la pensée humaine.
La traduction simultanée des langues étrangères est aussi un but
majoritaire des ordinateurs de la cinquième génération. Cela
semblait être une tâche relativement facile au début, du moins
jusqu'à ce que les programmeurs réalisent que la compréhension
humaine repose plus sur le contexte et le sens que sur une simple
traduction mot à mot.
La construction des ordinateurs et la technologie en général ont

été faites. Un de ces progrès concerne le calcul parallèle, qui
remplace la simple unité de traitement décrite par von Neumann par
un ensemble de processeurs travaillant en parallèle sur les mêmes
problèmes. Un autre progrès est la technologie des
supraconducteurs, qui éliminent la résistance à la conductivité
électrique et permettent d'améliorer les vitesses de transmission de
l'information.
Les ordinateurs d'aujourd'hui présentent déjà quelques attributs des
ordinateurs de la cinquième génération.
▪ Exemple :
o Les systèmes experts aident les médecins à réaliser
des diagnostics en appliquant les prescriptions qu'un
médecin utiliserait pour répondre aux besoins d'un
patient.
User
0.5. Machine de Von Neumann

Von Neumann est un mathématicien et physicien américano-hongrois. Il a
apporté d'importantes contributions tant en mécanique
quantique qu'en analyse fonctionnelle, en théorie des ensembles,
en informatique, en sciences économiques ainsi que dans beaucoup d'autres
domaines des mathématiques et de la physique.
Il fait remarquer que puisque les instructions sont codées en binaire, elles
peuvent prendre place dans la mémoire de l'ordinateur au côté des données.
Ces instructions s'exécutent en suivant l'ordre dans lequel elles sont écrites mais il
est possible d'imaginer des instructions de sauts de programme qui ordonnent à
l'unité de commande de reprendre la lecture des instructions ailleurs en mémoire
autorisant de cette manière les ruptures de séquences automatiques, les sauts
conditionnels et les boucles de programmes. L'unité de contrôle peut dès lors
reprendre une séquence d'instructions et « prendre des décisions » sans l'aide
d'un opérateur humain.
La machine de Von Neumann est conçue à partir de composants

électroniques numérique et binaire.
Elle est constituée de cinq sous-ensembles qui permettent la mise n’œuvre des
fonctions de base d’un ordinateur :
▪ Une unité de commande

▪ Une unité de traitement (arithmétique et logique)
▪ La mémoire centrale qui contient donc les données et le programme
▪ Une unité d'entrée des données
▪ Une unité de sortie des résultats
Qui peut être définis encore comme suit :
▪ Le stockage de données,
▪ Le traitement des données,
▪ Le mouvement des données et
▪ Le contrôle des périphériques.
User
Figure 5. Machine de Von Neumann.
0.6. Schéma général d’un ordinateur

Sur les illustrations ci-dessous nous pouvons voir le schéma général d’un
ordinateur que nous pouvons distinguer comme suit :
L'unité centrale (appelée aussi UC) des périphériques (ce qu'il y a autour de
l'ordinateur). Les périphériques permettent de fournir à l'ordinateur les données à
traiter et de les récupérer.
Figure 6. Schéma illustratif d'un ordinateur.
Dans l'unité centrale (appelé aussi microprocesseur)
User
Nous distinguons trois parties principales :
▪ La mémoire
▪ L'unité de traitement
▪ L'unité arithmétique
Qui permet de stocker momentanément les données à traiter, et dans cette

mémoire nous devons distinguer deux formes de données : la liste des données à
traiter, et bien sur le logiciel (appelé aussi programme) qui est la liste des
instructions que devra exécuter l'ordinateur. Chargée d'interpréter et d'exécuter
le logiciel qui est en mémoire, et de commander les différents périphériques. (Ou
unité de calcul) qui effectue tous les calculs.
Figure 7. Schéma illustratif d'un ordinateur.
User
C h a p i t r e . 1 G é n é r a l i t é s s u r l e s y s t è m e d ’ e x p l o i t a t i o n | 19
Chapitre.1 Généralités sur le système d’exploitation
➢ Comprendre la structure du système d’exploitation

➢ Apprendre à propos de son évolution
1.2. Qu’est-ce qu’un Système d’exploitation
Les utilisateurs de l'informatique attendent des ordinateurs qu'ils soient toujours

plus performants, simples d'utilisation, mais capables d'accueillir des applications
de plus en plus sophistiquées et des données toujours plus volumineuses.
Le hardware de plus en plus complexe ne peut à lui seul répondre à ces
exigences Il faut donc un système capable d'orchestrer les fonctions du hardware
et des applications et de donner aux utilisateurs l'impression que l'ensemble est
convivial et simple [1].
1.2.1. Le système d'exploitation
Il s'agit du système d'exploitation automatique des ressources de
l'ordinateur communément appelé "système d'exploitation" ou Operating System
O.S. et parfois "système opératoire". On le représente généralement comme une
couche logicielle placée au-dessus du hardware.
1.2.2. L'interface utilisateur
Au système d'exploitation est associée une interface utilisateur (texte ou
graphique) capable d'interpréter une série de commandes de base. Cette
interface ne fait (théoriquement) pas partie du système d'exploitation mais l'étude
des commandes donne un bon aperçu des fonctions qu'il procure.
La convivialité du système dépend de la richesse et de la simplicité de l'interface
homme/machine.
1.2.3. L'apport du système d'exploitation aux applications
Le système d'exploitation constitue une machine virtuelle qui, pour les
applications, substitue des composants logiciels aux composants matériels. Il est
la plateforme pour laquelle sont construites les applications.
Pour ce qui est du développement des applications : l'OS propose une interface
de programmation appelée API (Application Program Interface), une sorte de
boîte à outils à laquelle les développeurs recourent pour construire leurs
applications. Ces API procurent une vue uniforme et simplifiée des ressources de
la machine. Cela permet aux applications de faire abstraction des particularités
du matériel en dissimulant la diversité et la complexité du hardware.
User
1.2.4. La tâche du système d'exploitation vis- à-vis des ressources système

Le S.E. reçoit des demandes des programmes d'application et des utilisateurs. Il y
donne suite en leur allouant les ressources du système :
1. Le CPU
2. La mémoire
3. Les périphériques
4. Le système de fichier (y compris parfois, le réseau)
L'allocation des ressources système est une tâche complexe :
• Répartir les temps d'utilisation du CPU entre chaque application, tenir
compte des priorités, des applications en attente etc.
• Partager la mémoire entre les différentes applications (mémoire
physique ou virtuelle)
• Donner accès aux périphériques : disques, carte graphique, ports
(série, parallèle, USB ...), clavier, souris etc.
• Donner le moyen d'enregistrer des données sur les disques : le file
system
• Rediriger certaines commandes du système de fichier vers le réseau
• Identifier les utilisateurs et gérer les droits d'accès aux fichiers et aux
périphériques
• Gérer les erreurs
1.3. Terminologie :
Un programme est une suite statique d'instructions
Un processeur est l'agent qui exécute les instructions d'un programme
Un processus est un programme en cours d'exécution.
Un programme peut avoir plusieurs exécutions simultanées. Pour faire tourner
un processus il faut donc, non seulement chercher le code et les données mais il
User
faut aussi lui réserver un espace mémoire, le gérer les accès aux ressources, la
sécurité etc. C'est un des rôles de l'OS.
- Au temps du DOS déjà, le rôle du système d'exploitation était de charger
les programmes d'application en mémoire avant de leur passer la main.
- - Actuellement les systèmes d'exploitation sont multitâches. Le temps
processeur est partagé par plusieurs processus qui semblent tourner
simultanément.
1.3.1. Multitâche
Le S.E. est multitâche s'il permet à l'ordinateur de faire tourner simultanément
plusieurs processus. Il s'arrange pour que chaque processus ait à tour de rôle un
court laps de temps pour s'exécuter partiellement. Cette méthode, aussi
appelée multiprogrammation, donne l'impression que tous ces programmes
s'exécutent simultanément et surtout, maximise l'occupation du processeur. Dès
qu'un programme s'interrompt pour attendre la réalisation d'une fonction plus
lente, telle qu'une opération d'entrées/sortie, le processeur passe sans plus
attendre à l'exécution d'un autre processus.
Multitâche coopératif
Chaque processus dispose des ressources du système puis les libère pour
permettre au processus qui suit dans une file d'attente d'en disposer à son tour
=> Chaque tâche dépend des autres. Une tâche programmée de manière peu
rigoureuse va compromettre la bonne marche de l'ensemble.
Multitâche préemptif
Chaque processus dispose du processeur pendant un laps de temps déterminé à
l'avance ou jusqu'à ce qu'un autre ait une priorité supérieure à celle du processus
en cours.
L'ordonnancement, (l'attribution du temps processeur aux processus) est fait par
l'OS sans que les applications soient consultées.
=> Si une application "se plante", elle est mise de côté sans bloquer le système.
1.3.2. Multithreading
Une application multithread est un logiciel qui dès sa conception a été partagé
en différentes unités d'exécutions ou threads dont la gestion est confiée au
système d'exploitation. Exemple : la correction orthographique dans WORD.
Nous avions vu dans le cadre du multitâche que chaque processus dispose d'une
partie distincte de la mémoire pour s'exécuter indépendamment des autres.
Dans le cas du multithreading au contraire, le même espace d'adressage est mis
en commun par tous les threads d'une application.
User
1.4. Fonction d’un système d’exploitation

Un système d’exploitation permet de répondre à deux besoins qui ne sont pas
forcément liés :
1. Le système d’exploitation en tant que machine étendue (ou « machine

virtuelle »),
2. Le système d’exploitation en tant que gestionnaire de ressources.
Exemple de systèmes d’exploitation :
1. Linux, Mac OS, Windows, MS-DOS, MINIX, etc.
User
C h a p i t r e . 2 G e s t i o n d e s p r o c e s s u s | 23
Chapitre.2 Gestion des processus
➢ Comprendre la gestion des processus

➢ Comprendre les algorithmes et leurs utilités
2.1. Processus
Un processus est un programme en cours d'exécution.
• Un programme est une suite d'instructions ; c'est du texte, un code statique.
• Le processus est un concept dynamique, il représente le déroulement d'une
tâche faisant partie d'une application ou un programme système
quelconque.
La notion de processus est essentielle pour décrire le fonctionnement des
systèmes multiprogrammés aussi appelés multitâches ou plus simplement
multiprocessus.
Parmi les avantages de la multiprogrammation, citons :
• Le fractionnement des applications qui peut en simplifier le développement,
• L’avantage pour l'utilisateur de savoir faire tourner plusieurs applications
simultanément
• Et surtout l'optimalisation de l'utilisation du (ou des) processeurs(s)
Un processeur n'est capable de traiter qu'un seul processus à la fois. Un sous-ensemble
du système d'exploitation, appelé ordonnanceur, organise les tâches et les fait
commuter tout à tour pour donner l'impression qu'elles s'exécutent toutes
simultanément.
Le système d'exploitation conserve des informations sur chaque processus pour
pouvoir les interrompre et les relancer selon ce que décide l'ordonnanceur. Ces
informations regroupent entre autres :
• Un numéro d'identification du processus (PID)
• L’état du processus, son compteur ordinal et les autres registres
• L’emplacement mémoire du code, des données et de la pile
• Des pointeurs vers les ressources utilisées, fichiers, E/S, ...
• Et une quantité innombrable d'informations : pointeur vers le processus
parent, priorité, compteur de threads, durée d'exécutions, informations
d'attentes etc.
Toutes ces informations peuvent être regardées comme les composants
d'un processeur virtuel agent d'exécution du processus.
2.2. Les niveaux d'ordonnancement des processus

L'ordonnancement est à envisager à trois niveaux : à court, à moyen et à long terme.
1. L'ordonnancement à long terme "job schedulling" (ordonnancement des travaux)
décide des processus que le système peut mener en parallèle. Ils doivent être
assez nombreux pour que le processeur soit inactif le plus rarement possible
User
(quand tous les processus attendent des E/S) sans pour autant être trop
abondants et saturer la mémoire principale du système.
- Dans un traitement par lots, les processus attendent sur le disque dans une file
d'attente jusqu'à ce que le scheduler ou ordonnanceur d'admission décide de
les prendre en charge.
- Dans un système interactif à temps partagé, le système accepte en principe
toutes les requêtes de processus que les utilisateurs provoquent en lançant leurs
applications
Une fois le processus admis dans le système, il n'en sort que lorsqu'il est terminé ou s'il
est détruit par le système d'exploitation suite à une erreur grave ou à la demande de
l'utilisateur (commande kill sous Unix ou via le gestionnaire des tâches sous Windows)
2. L'ordonnancement à moyen terme est assuré par l'ordonnanceur de
mémoire aussi appelé permutateur ou swapper. Son rôle est de permuter les
processus placés en mémoire et ceux qui, faute de place, ont été
temporairement entreposés sur le disque.
Ces permutations ne peuvent toutefois pas être trop fréquentes pour ne pas gaspiller
la bande passante des disques.
3. L'ordonnanceur à court terme aussi appelé dispatcher, répartiteur
ou ordonnanceur du processeur choisit à quel processus sera alloué le processeur
et pour quel laps de temps.
Ces commutations des processus sont très fréquentes.
2.3. Les états d'un processus
Les processus, puisqu'ils sont concurrents et doivent se partager le processeur,
ne peuvent être continuellement actifs. Ils ont donc, si on ne considère pour
commencer que l'ordonnancement à court terme, trois niveaux fondamentaux
et quatre transitions possibles.
Elu signifie en cours d'exécution. L'exécution n'est interrompue que par les conditions
suivantes :
Transition 1 : Le processus se bloque, faute de données pour l'alimenter
ou en attendant une opération d'entrée/sortie.
User
Transition 2 : Le processus est interrompu soit parce que la tranche de

temps qui lui est impartie est achevée soit parce qu'un
processus de plus haute priorité réquisitionne le processeur.
L'état Prêt est un état provisoire pour permettre aux autres processus de s'exécuter
quasi simultanément.
L'état Bloqué est un état d'attente d'un événement extérieur, tel qu'une
entrée/sortie, nécessaire à la poursuite de l'exécution du processus.
Ajoutons deux états qui correspondent à l'ordonnancement à long terme : les états
" Nouveau " et " Terminé ".
Nouveau : le processus vient d'être créé mais n'existe pas encore qu'à l'état de
requête de processus en attendant d'être admis par le scheduler en tant que
processus activable.
Terminé : le processus est désormais inactif car il a achevé sa tâche. Il sera détruit
prochainement par le système d'exploitation pour libérer de la place en mémoire. Il
est parfois conservé pendant un temps à l'état terminé en attendant qu'une
entrée/sortie s'achève ou que les données de ce processus soient exploitées par un
autre. On parle alors de processus " zombie".
Pour être complet il faut aussi envisager les états permutés qui résultent de
l'ordonnancement à moyen terme. Le swapper range les processus prêts ou bloqués
sur le disque ou en mémoire.
User
Permuté-Prêt : le processus est pour l'instant transcrit en mémoire auxiliaire (sur

disque). Il serait prêt à être activé par l'ordonnanceur à court terme s'il était en
mémoire principale. La permutation de mémoire dépend de l'ordonnanceur à
moyen terme.
Permuté-Bloqué : c'est l'état d'un processus qui étant bloqué en attendant un
événement externe a été transféré sur disque pour faire de la place en mémoire
principale.
2.4. L'ordonnancement des processus

Les processus concurrents doivent se partager le processeur, la mémoire et les
entrées/sorties.
- Dans les systèmes anciens, les systèmes de traitement par lots mais aussi les
systèmes d'exploitation pas vraiment multitâches tels que Windows 9x,
l'ordonnancement était de type coopératif. L'ordonnanceur n'intervenait
que lorsque le processus en cours se terminait où se bloquait. Ce système
assez sommaire convenait aux traitements par lots quand le temps de
réponse n'avait que peu d'importance.
- Actuellement, sur les systèmes interactifs multitâches, parfois même multi
utilisateurs et multi processeurs, l'ordonnancement doit être préemptif.
L'ordonnanceur ne peut laisser un processus monopoliser les ressources du
système et réquisitionne régulièrement le processeur pour en répartir la
disponibilité entre les processus qui simultanément sont prêts à être
exécutés. La politique suivie pour déterminer la manière d'ordonnancer les
processus est fonction de nombreux critères parfois contradictoires. Le fait
de favoriser certaines catégories de tâches peut en léser d'autres.
User
2.4.1. Critères d'ordonnancement des processus

- L'utilisation intensive du processeur
Le système perd son efficacité si le processeur passe trop de temps à attendre des
E/S .
- L'équité
Tous les processus doivent avoir la possibilité d'utiliser le processeur. Nonobstant les
priorités parfois indispensables, des processus comparables doivent être traités avec
les mêmes égards.
- Utilisation répartie de l'ensemble des ressources
En ne tenant compte que de l'utilisation optimale du CPU, on risque de sous-utiliser
momentanément d'autres ressources que les processus devront se disputer ensuite.
Une bonne stratégie consiste donc à évaluer et à bien répartir l'emploi de l'ensemble
des ressources.
Certains critères s'appliquent plus particulièrement aux systèmes de traitement par lots :
- Le nombre de processus par unité de temps

Ce critère dépend cependant de la longueur des processus.
- La durée de rotation
C'est le délai moyen entre l'admission du processus et la fin de son exécution.
- Le temps d'attente
C'est le temps moyen qu'un processus passe à attendre. Il s'obtient en soustrayant la
durée d'exécution du processus de sa durée de rotation. Cette durée est
indépendante de la durée d'exécution du processus lui-même.
D'autres critères qui ne s'appliquent qu'aux systèmes interactifs :
- Le temps de réponse
C'est la vitesse de réaction aux interventions extérieures. Les programmes d'avant-
plan doivent pour cela avoir priorité sur les tâches de fond.
- La prévisibilité
Un système qui d'habitude réagit rapidement aux commandes mais qui parois prend un temps beaucoup plus long
sera perçu comme moins stable que s'il répondait à chaque fois dans un temps
comparable même s'il est globalement plus lent.
Le système semblera aussi plus convivial s'il respecte l'idée parfois fausse que les
utilisateurs se font de la complexité des tâches.
2.4.2. Algorithmes d'ordonnancement " scheduling algorithms "
a. FCFS - Fist-come First-served = Premier arrivé / Premier servi
Les jobs attendent dans une file. Le premier arrivé est admis
immédiatement et s'exécute tant qu'il n'est pas bloqué ou terminé. Lorsqu'il
se bloque, le processus suivant commence à s'exécuter et le processus
bloqué va se mettre au bout de la file d'attente.
User
C'est typiquement un algorithme non préemptif.

Avantages : l'algorithme est simple (c'est une simple liste chaînée),
l'ordonnancement est équitable.
Inconvénient : Le processus qui utilise davantage de temps est favorisé par
rapport à ceux qui font beaucoup d'appels aux entrées/sorties.
Exemple :
Processus Temps de cycle

P1 24
P2 3
P3 3
Si les processus arrivent au temps 0 dans l’ordre : P1, P2, P3
Le diagramme de Gantt est :
P P2 P
1 3
0 2 2 3
Temps d’attente pour P1= 0 ; P2= 24; P3= 27 4 7 0
Temps attente moyen : (0 + 24 + 27) /3 = 17
Si les mêmes processus arrivent à 0 mais dans l’ordre : P2 , P3 , P1 .
Le diagramme de Gantt est :
P P P
2 3 1
0 3 6 30
Temps d’attente pour P1 = 6 P2 = 0 P3 = 3
Temps moyen d’attente : (6 + 0 + 3) /3 = 3
Beaucoup mieux
Donc pour cette technique, le temps d’attente moyen peut varier
grandement
b. SJF - Shorted Job First = le job le plus court d'abord

Sera élu, le processus dont on suppose que le traitement sera le plus court.
Si quatre jobs ont des durées d'exécution a, b, c et d ; le premier se termine
User
à l'instant a, le second à l'instant a+b et ainsi de suite. La durée de rotation

moyenne est de
(4a + 3b + 2c + d) /4
Le premier job exécuté contribue donc beaucoup plus que les autres à la
durée moyenne. Il est donc normal d'exécuter le plus court en premier lieu.
(C'est ce qui se passe quant à la caisse d'une grande surface les clients
laissent passer devant quelqu'un qui n'a qu'un article)
- Avec préemption : si un processus qui dure moins que le restant

du processus courant se présente plus tard, l’UCT est donnée à
ce nouveau processus
o SRTF : shortest remaining-time first
- Sans préemption : on permet au processus courant de terminer
son cycle
o Observation : SRTF est plus logique car de toute façon le
processus exécutant sera interrompu par l’arrivée du
nouveau processus
o Il est retourné à l’état prêt
Exemple de SJF sans préemption :
Processus Arrivée Cycle
P1 0 7
P2 2 4
P3 4 1
P4 5 4
SJF (sans préemption)
Temps d’attente moyen = (0 + 6 + 3 + 7) /4 = 4
User
Inconvénient : les jobs les plus courts sont favorisés. Si des processus courts
arrivent sans cesse, les processus plus longs n'auront jamais le temps de
s'exécuter
c. SRT - Shorted Remaining Time = l'algorithme du temps restant le plus court
C'est la version préemptive de l'algorithme précédent.
Exemple de SJF sans préemption :

Processus Arrivée Cycle
P1 0 7
P2 2 4
P3 4 1
P4 5 4
SJF (préemptive)
Temps moyen dàttente = (9 + 1 + 0 +2) /4 = 3
◦ P1 attend de 2 à 11, P2 de 4 à 5, P4 de 5 à 7
d. RR - Round Robin = L'algorithme du tourniquet

Chaque processus reçoit tour à tour un intervalle de temps
appelé quantum. Au terme de ce quantum ou, si le processus s'achève ou
se bloque avant cet instant, l'ordonnanceur attribue directement le
processeur au processus suivant. L'algorithme est simple et équitable. C'est
généralement cet ordonnancement circulaire qui est utilisé dans les
systèmes à temps partagé. La valeur du quantum est couramment fixée
aux alentours de 20 à 50 ms.
Des quanta plus courts provoqueraient trop de commutations de processus
et la proportion du temps consacré à ces changements de contexte
deviendrait trop importante.
Si par contre, on optait pour des quanta plus longs, ce seraient les temps
de réponse aux processus interactifs qui en pâtiraient.
User
Exemple : Tourniquet Quantum = 20
Processus Cycle
P1 53
P2 17
P3 68
P4 24
Normalement,
◦ Temps de rotation (turnaround) plus élévé que SJF
◦ Mais temps attente moyen meilleur
Le choix du quantum pour le tourniquet :

Doit être beaucoup plus grand que le temps requis pour exécuter le
changement de contexte
Doit être un peu plus grand que le cycle typique (pour donner le temps à la
plupart des processus de terminer leur cycle, mais pas trop pour éviter de
pénaliser les processus courts)
e. L'ordonnancement avec priorité = Algorithme : Priorité

Une valeur de priorité est assignée à chaque processus.
La priorité peut être fonction d'un ordre de préséance entre utilisateurs ou
fonction des caractéristiques des processus. Un processus temps réel sera
par exemple prioritaire par rapport à une tâche de fond.
La priorité peut varier dynamiquement. Exemple : pour ne pas encombrer
la mémoire avec des processus qui passent le plus clair de leur temps à
attendre des entrées/sorties, on leur accorde une priorité d'autant plus
grande qu'ils ne consomment qu'une petite fraction de leur quantum.
Exemple de la priorité :
Supposons que la valeur du quantum est fixée à 50 ms. Un processus
qui n'utilise que 1 ms avant d'être bloqué aurait droit à une priorité
User
de 50 ms/ 1 ms = 50 tandis qu'un processus qui se bloque au bout de

25 ms a droit à une priorité de 50/25=2 et les processus qui
consomment tout le quantum ont une priorité de 1.
Inconvénients :
- Famine : les processus moins prioritaires n’arrivent jamais à exécuter

- Solution :
o Modifier la priorité d’un processus en fonction de son âge et
de son historique d’exécution
o Le processus change de file dàttente
- Plus en général, la modification dynamique des priorités est une
politique souvent utilisée
f. Algorithme : Files multiples (quantum variable)

Pour éviter qu’il y ait be
g. Algorithme : Files multiples et à retour

Un processus peut passer d ’une file à l ’autre, p.ex. quand il a passé trop
de temps dans une file
À déterminer :
- Nombre de files
- Algorithmes d ’ordonnancement pour chaque file
- Algorithmes pour décider quand un processus doit passer d ’une file
à làutre
- Algorithme pour déterminer, pour un proc qui devient prêt, sur quelle
file il doit être mis
User
PRIO = 0
PRIO = 1
PRIO = 2
Exemple de la priorité :
Trois files :
◦ Q0: tourniquet, quantum 8 msecs
◦ Q1: tourniquet, quantum 16 msecs
◦ Q2: FCFS
Ordonnancement :
◦ Un nouveau processus entre dans Q0, il reçoit 8 msecs d ’UCT
◦ S ’il ne finit pas dans les 8 msecs, il est mis dans Q1, il reçoit 16
msecs additionnels
◦ S ’il ne finit pas encore, il est interrompu et mis dans Q2
◦ Si plus tard il commence à demander des quantums plus petits,
il pourrait retourner à Q0 ou Q1
En pratique :
Les méthodes que nous avons vues sont toutes utilisées en pratique (sauf plus
court servi pur qui est impossible)
Les SE sophistiqués fournissent au gérant du système une librairie de méthodes,

qu’il peut choisir et combiner au besoin après avoir observé le comportement
du système
Pour chaque méthode, plusieurs paramètres sont disponibles : p.ex. durée du

quantum, coefficients, etc.
User
C h a p i t r e . 3 S y n c h r o n i s a t i o n d e s p r o c e s s u s | 34
Chapitre.3 Synchronisation des processus
➢ Comprendre la synchronisation des processus

➢ Comprendre les conflits de ressources
3.1. Communication inter-processus

Les processus, même quand ils sont indépendants sont rarement isolés et doivent
pouvoir coopérer pour les raisons suivantes :
- Se synchroniser
- Échanger de données
- Partager des données sans provoquer d'incohérences
- Partager des ressources sans provoquer d'interblocages
Les processus doivent donc pouvoir communiquer. Les systèmes d'exploitation
prenant en charge le multitâche fournissent pour cela des primitives de
communication et de synchronisation des processus
3.2. Partage d'informations

Les processus peuvent partager des informations de diverses manières, voici
quelques techniques envisageables :
- L'échange d'informations via des fichiers.
Les informations écrites par un processus peuvent être lues par un autre.
Le principe est valable même pour des processus qui ne s'exécutent pas
simultanément.
- Le partage d'emplacements mémoire.
C'est essentiellement de cette manière que communiquent les threads
qui rappelons-le, sont des processus qui partagent un même espace
d'adressage.
- Les pipes, les redirections d'E/S ou un système de messagerie pour
processus prévu par le système d'exploitation
3.3. Partage des ressources d'un système informatique

Les processus même s'ils sont apparemment indépendants, cohabitent dans
l'ordinateur. Ils doivent partager certaines ressources et risquent d'entrer en conflit.
Voyons d'abord dans quelles conditions les ressources sont partageables ou non.
Sont partageables :
Les ressources qui peuvent être utilisées par plusieurs processus sans provoquer
d'interférences : le processeur, les fichiers en lecture seule et les zones de mémoire
qui ne contiennent que des procédures ou des données protégées contre toute
modification.
User
Ne sont pas partageables :

Les ressources qui ne peuvent être utilisées que par un seul processus à la fois ;
soit parce qu'il est matériellement impossible de partager cette ressource,
soit parce qu'elle contient des données susceptibles d'être modifiées. Si un
processus lit une donnée pendant qu'un autre la modifie, le résultat sera
imprévisible.
3.3.1. Exemple de conflit d'accès
Prenons l'exemple de l'enregistrement de travaux d'impression dans un
spooler. ( Exemple emprunté au cours "Système d'exploitation" de Andrew
Tanenbaum)
L'imprimante est une ressource qui ne peut pas être utilisée simultanément par
plusieurs processus. Les travaux d'impression doivent donc être enregistrés dans un
répertoire de spool en attendant d'être imprimés.
Les processus qui veulent imprimer ont accès à
deux variables partagées In et Out associées au
spooler :
In le numéro à attribuer au prochain fichier qui
entre dans le spooler
Out le numéro du prochain fichier à imprimer.
Si au même moment deux processus A et B décident de placer un fichier dans le

répertoire de spool, ils doivent lire la variable In, se servir de cette valeur pour inscrire
à l'endroit voulu le fichier à imprimer puis modifier la variable In pour qu'elle indique
l'emplacement libre suivant.
i = In;
InscrireFichier(i);
In = i + 1;
Si le processus A est interrompu pendant l'exécution de ces instructions et qu'entre
temps l'ordonnanceur passe la main au processus B, la variable In sera lue et réutilisée
une deuxième fois consécutivement sans avoir été incrémentée. Les deux processus
vont donc inscrire le fichier à imprimer au même emplacement du spooler et, bien
que l'état du répertoire de spooler semble cohérent, un des deux fichiers ne sera
jamais imprimé.
Pour éviter ces conflits d'accès, il faut empêcher la lecture ou l'écriture de données
partagées à plus d'un processus à la fois. La solution est l'exclusion mutuelle pour
les accès concurrents.
User
3.4. La synchronisation des processus

La synchronisation des processus concerne les processus parallèles qui utilisent des
ressources ou des données non partageables. Il existe un certain nombre
d'algorithmes pour y parvenir. Ils sont généralement assez courts mais la
compréhension de leur comportement est rendue difficile parce qu'ils s'exécutent en
parallèle dans chaque processus. Il faut être sûr, non seulement que les interférences
soient évitées, mais aussi qu'ils ne provoquent pas de blocages et qu'ils soient
équitables pour chaque processus. (Interblocage et famine)
Les systèmes d’exploitation multitâches fournissent de tels mécanismes.
3.4.1. Section critique
L'exemple du répertoire de spool nous montre que les deux processus A et B ne sont
pas totalement indépendants. Les variables (In et Out) susceptibles d'être modifiées
sont des ressources critiques. La partie de programme où se produit le conflit est
appelée section critique. Il faut donc contrôler les accès aux variables partagées. Le
problème est résolu si on peut être sûr que deux processus ne sont jamais en section
critique en même temps.
Cette première condition permet d'éviter les conflits d'accès mais il y a d'autres types
d'interférences à éviter. En dehors des sections critiques aucun processus ne peut
bloquer les autres et aucun processus ne doit attendre trop longtemps avant d'entrer
en section critique.
Les mécanismes qui mettent en œuvre l'exclusion mutuelle doivent satisfaire les
quatre conditions suivantes :
1. Deux processus ne peuvent se trouver simultanément dans la même
section critique.
2. Aucune hypothèse ne peut être faite ni sur les vitesses relatives des
processus ni sur le nombre de processeurs.
3. Aucun processus hors d'une section critique ne peut bloquer les autres.
4. Aucun processus ne doit attendre trop longtemps avant d'entrer en
section critique.
3.4.1.1. Le problème de la section critique
Lorsqu’un processus manipule une donnée (ou ressource) partagée, nous disons
qu’il se trouve dans une section critique.
Le problème de la section critique est de trouver un algorithme dèxclusion
mutuelle de processus dans lèxécution de leur SCs afin que le résultat de leurs
actions ne dépende pas de l’ordre d’entrelacement de leur exécution.
L’exécution des sections critiques doit être mutuellement exclusive: à tout instant,
un seul processus peut exécuter une SC pour une var donnée (même lorsqu’il y a
plusieurs processeurs)
3.4.1.2. Structure du programme
- Chaque processus doit donc demander une permission avant d’entrer
dans une section critique (SC)
User
- La section de code qui effectue cette requête est la section d’entrée

- La section critique est normalement suivie d’une section de sortie
- Le code qui reste est la section restante (SR): non-critique
repeat
section d’entrée
section critique
section de sortie
section restante
forever
3.4.1.3. Critères nécessaires pour solutions valides

- Exclusion Mutuelle
• À tout instant, au plus un processus peut être dans une section critique
(SC) pour une variable donnée
- Non interférence:
• Si un processus s’arrête dans sa section restante, ceci ne devrait pas
affecter les autres processus
- Mais on fait l’hypothèse qu’un processus qui entre dans une section critique,
en sortira
3.4.1.4. Types de solutions
- Solutions par logiciel: des algorithmes dont la validité ne s’appuie pas sur
l’existence dìnstruction spéciale
- Solutions fournies par le matériel: s’appuient sur l’existence de certaines
instructions (du processeur) spéciales
- Solutions fournies pas le SE: procure certains appels du système au
programmeur
- Toutes les solutions se basent sur l’atomicité de l’accès à la mémoire centrale:
une adresse de mémoire ne peut être affectée que par une instruction à la
fois, donc par un processus à la fois.
- Plus en général, toutes les solutions se basent sur l ’existence d’instructions
atomiques, qui fonctionnent comme SCs de base
a. Solutions par logiciel
- Nous considérons d’abord 2 processus
o Algorithmes 1 et 2 ne sont pas valides
▪ Montrent la difficulté du problème
o Algorithme 3 est valide (algorithme de Peterson)
- Notation
User
o Débutons avec 2 processus : T0 et T1

o Lorsque nous discutons de la tâche Ti, Tj dénotera toujours l’autre
tâche (i ! = j)
Exemples :
- Algorithme 1: processus se donnent mutuellement le tour
La variable partagée turn est initialisée à 0 ou 1 processus Ti:
repeat
La SC de Ti est exécutée ssi turn = i
while(turn!=i){};
Ti est occupé à attendre si Tj est dans SC.
SC
Fonctionne pour l’exclusion mutuelle!
turn = j;
Mais critère du progrès n’est pas satisfait car
l’exécution des SCs doit strictement alterner SR
forever
Initialisation de turn a 0 ou 1 :
processus T0: processus T1:
repeat repeat
while(turn!=0){}; while(turn!=1){};
SC SC
turn = 1; turn = 0;
SR
SR
forever
forever
- Algorithme 2: Excès de courtoisie processus Ti:

Une variable Booléenne par processus: flag[0] et
flag[1] repeat
Ti signale qu’il désire exécuter sa SC par: flag[i] =vrai flag[i] = vrai;
Mais il n’entre pas si l’autre est aussi intéressé!
Exclusion mutuelle ok while(flag[j]==vrai){};
Progrès pas satisfait:
SC
Considérez la séquence:
T0: flag[0] = vrai flag[i] = faux;
T1: flag[1] = vrai
Chaque processus attendra indéfiniment pour SR
exécuter sa SC: on a un interblocage
forever
User
- Algorithme 3 (dit de Peterson): Bon processus Ti:

Combine les deux idées: flag[i]=intention
repeat
d’entrer; turn=à qui le tour
Initialisation: flag[i] = vrai;
flag[0] = flag[1] = faux
// je veux entrer
turn = i ou j
Désire d’exécuter SC est indiqué par turn = j;
flag[i] = vrai // je donne une chance à l’autre
flag[i] = faux à la section de sortie
do while
(flag[j]==vrai && turn==j){};
SC
flag[i] = faux;
SR
forever
Extension à > 2 processus

- L ’algorithme de Peterson peut être généralisé au cas de >2 processus
- Cependant, dans ce cas il y a des algorithmes plus élégants, comme l’algorithme du
boulanger, basée sur l’idée de ‘prendre un numéro’...
- À fin que des processus avec des variables partagées puissent réussir, il est nécessaire
que tous les processus impliqués utilisent le même algorithme de coordination
a.1. Critique des solutions par logiciel
- Difficiles à programmer et à comprendre
o Les solutions que nous verrons dorénavant sont toutes basées sur
l’existence d’instructions spécialisées, qui facilitent le travail.
- Les processus qui requièrent l’entrée dans leur SC sont occupés à attendre
(busy waiting); consommant ainsi du temps de processeur
o Pour de longues sections critiques, il serait préférable de bloquer les
processus qui doivent attendre...
b. Solution par matériel : désactivation des interruptions

Sur un uniprocesseur: exclusion mutuelle est préservée mais Process Pi:
l’efficacité se détériore: lorsque dans SC il est impossible
d’entrelacer l’exécution avec d’autres processus dans une SR repeat
Perte d’interruptions inhiber interrupt
Sur un multiprocesseur: exclusion mutuelle n’est pas préservée section critique
Une solution qui n’est généralement pas acceptable rétablir interrupt
section restante
forever
User
c. Solutions matérielles: instructions machine spécialisées

- Normal: pendant qu’un processus ou processus fait accès à une adresse de
mémoire, aucun autre ne peut faire accès à la même adresse en même
temps
- Extension: instructions machine exécutant plusieurs actions (ex: lecture et
écriture) sur la même case de mémoire de manière atomique (indivisible)
- Une instruction atomique ne peut être exécutée que par un processus à la fois
(même en présence de plusieurs processeurs)
L’instruction test-and-set
Une version C++ de test-and-set: Un algorithme utilisant testset pour Exclusion

Mutuelle:
bool testset(int& i)
{ Variable partagée b est initialisée à 0
if (i==0) { C’est le 1er Pi qui met b à 1 qui entre dans

SC
i=1;
Tâche Pi:
return true;
while testset(b)==false{};
} else {
SC //entre quand vrai
return false;
b=0;
}
SR
}
Instruction atomique!
d. Solutions basées sur des instructions fournies par le SE (appels du système)

- Les solutions vues jusqu’à présent sont difficiles à programmer et conduisent à
du mauvais code.
- On voudrait aussi quìl soit plus facile d’éviter des erreurs communes, comme
interblocages, famine, etc.
o Besoin d’instruction à plus haut niveau
- Les méthodes que nous verrons dorénavant utilisent des instructions
puissantes, qui sont implantées par des appels au SE (system calls)
3.4.2. Blocage
Le blocage ou interblocage (deadlock) peut se produire quand les ressources
requises pour certains processus sont utilisées par d'autres qui en revanche attendent
eux aussi des ressources utilisées par les premiers.
Le système d'exploitation doit être capable de prévenir ou d'atténuer l'effet des
blocages
User
3.4.3. Famine
La famine (starvation) est la situation d'un processus qui reste indéfiniment bloqué
dans l'attente d'une ressource sans pour autant être en situation d'interblocage.
Cette situation dépend des autres processus alors que dans le cas de l'interblocage
il faut que le système d'exploitation intervienne d'autorité en retirant une ressource à
l'un des processus.
3.5. Mécanismes d'exclusion mutuelle
3.5.1. Désactiver les interruptions
Nous savons que dans un système monoprocesseur c'est un ordonnanceur qui
tour à tour passe la main à chaque processus pour donner une impression de
parallélisme. Il est possible d'éviter l'intervention de l'ordonnanceur dans une
section critique en s'interdisant d'exécuter des instructions susceptibles de
provoquer le déroutement et en désactivant momentanément les interruptions.
DisableInterrupt()
. // Section critique
EnableInterrupt()
Le processus qui entre dans la section critique monopolise ainsi le processeur en
excluant tout autre processus.
Inconvénients de ce mécanisme :
- Il ne convient pas s'il y a plusieurs processeurs
- Certaines interruptions risquent d'être perdues si elles ne sont pas traitées à
temps
- Les processus qui attendent risquent la famine
3.5.2. Les sémaphores

Le sémaphore est un mécanisme proposé par le mathématicien et informaticien
néerlandais Dijkstra en 1965.
Le sémaphore est une généralisation du verrou pour des ressources pouvant être
utilisées non pas par un seul processus mais par n processus à la fois.
Le sémaphore est en quelque sorte un distributeur de jetons. Le nombre de jetons est
fixe. Il est initialisé lors de la création du sémaphore. Chaque processus pour avoir le
droit d'accéder à la ressource doit demander un jeton qu'il rend après utilisation.
Le sémaphore est donc une variable entière dont la valeur positive est fixée lors de
sa création et qui n'admet par la suite que deux opérations P(s) et V(s) du
néerlandais "Proberen" = essayer et "Verhogen" = incrémenter.
Synonymes de P/ V: Down / Up Wait / Signal
Les sémaphores sont facilement mis en oeuvre par les systèmes d'exploitation.
Le sémaphore est alors un objet système qui encapsule la variable entière (niveau du
sémaphore) et une file d'attente de processus.
User
L'opérations P(s) décrémente la valeur du niveau de sémaphore si elle est supérieure

à 0. Si la décrémentation est impossible le processus est bloqué et enregistré dans la
file d'attente. Il y attend que la décrémentation soit possible, autrement dit, qu'un
autre processus rende un jeton et le signale par l'opération V(s) qui incrémente le
niveau de sémaphore.
L'intérêt de ces opérations P(s) et V(s) réalisés par des fonctions du système
d'exploitation est que ce sont des opérations indivisibles, elles ne peuvent être
interrompues. On dit encore qu'elles sont exécutées de façon atomique.
On désigne par le nom de mutex ou par l'expression sémaphore binaire, les
sémaphores qui n'admettent que deux valeurs 0 et 1 (Verrouillé et déverrouillé)
User
C h a p i t r e . 4 G e s t i o n d e l a m é m o i r e | 43
Chapitre.4 Gestion de la mémoire
➢ Optimisation de l’utilisation de la mémoire principale = RAM
4.1. Rôle de la mémoire

Le gestionnaire de mémoire est un sous-ensemble du système d'exploitation. Son rôle
est de partager la mémoire entre l'OS et les diverses applications. Le terme "mémoire"
fait surtout référence la mémoire principale, c'est à dire à la RAM, mais la gestion de
celle-ci demande la contribution de la mémoire auxiliaire (mémoire de masse,
spacieuse mais lente) et à la mémoire cache (rapide mais de taille restreinte).
Voici quatre fonctions qu'on attend du gestionnaire de mémoire :
• L'allocation de la mémoire aux processus
- Répertorier les emplacements libres de la mémoire

- Allouer la mémoire nécessaire aux nouveaux processus
- Récupérer la mémoire des processus qui s'achèvent
Cette récupération peut nécessiter une réallocation des processus en cours
pour optimiser l'emploi de la mémoire. La zone mémoire attribuée à un
processus peut donc changer au cours de son exécution.
• La protection
Il faut s'assurer que les adresses générées par chaque processus ne concernent
que la zone mémoire qui lui est impartie, sans quoi, l'intégrité du système
d'exploitation et des autres processus n'est pas garantie.
Certaines zones mémoire doivent pourtant servir simultanément à plusieurs
processus : le code de fonctions servant à plusieurs applications qui tournent en
parallèle ou les données utilisées simultanément par divers processus
• La segmentation de l'espace d'adressage
Les programmes sont subdivisés en segments : le code, les données modifiables,

celles qui ne le sont pas, la pile. On attend donc du gestionnaire de mémoire
qu'il permette la segmentation de l'espace d'adressage des programmes pour
les raisons suivantes :
- Pouvoir coder les segments séparément et les paramétrer en fonction de

l'application
- Permettre des degrés de protection différents selon les segments (lecture
seule, exécution...)
- Accepter le partage de certains segments.
• La mémoire virtuelle
User
Elle offre aux applications une mémoire de taille supérieure à celle de la

mémoire principale.
L'espace d'adressage qu'offre la mémoire centrale est parfois insuffisant. Les

disques suppléent à cette insuffisance en fournissant une mémoire auxiliaire plus
vaste mais plus lente et qui n'est pas directement accessible au processeur.
4.2. Gestion de la mémoire pour systèmes monotâches

Dans le cas des systèmes monotâche, la gestion de la
mémoire est assez simple. Il suffit de réserver une partie
de la mémoire au système d'exploitation. L'application
est ensuite casée dans l'espace restant qui est libéré
sitôt que l'application est terminée.
Cela se complique un peu si l'application nécessite
plus d'espace que ce que peut fournir la mémoire vive.
On segmente alors l'application en segments de
recouvrements ou "Overlays". Cette technique n'a plus
cours maintenant. Elle était utilisée à l'époque du DOS
pour des applications volumineuses. Le programmeur
devait prévoir le découpage de son application en
imaginant comment ces overlays serait chargés en
mémoire les uns à la suite des autres pour qu'au cours
de son exécution l'application puisse atteindre toutes
les fonctions nécessaires.
C'était en quelque sorte comme cela qu'on concevait
la mémoire virtuelle à l'époque des systèmes
d'exploitation monotâche. Notez que la zone mémoire
occupée par le système d'exploitation n'était pas
protégée par ce type de gestion de mémoire.
4.3. Gestion de la mémoire pour systèmes multitâches
Plusieurs processus doivent se partager la mémoire sans empiéter sur l'espace réservé
au système d'exploitation ni aux autres processus. Quand un processus se termine, le
S.E. doit libérer l'espace mémoire qui lui était alloué pour pouvoir y placer de
nouveaux processus.
User
4.3.1. Partition de la mémoire

4.3.1.1. Partitions fixes
Le plus simple est de diviser la mémoire en
partitions fixes dès le démarrage du système. Les
partitions sont de différentes tailles pour éviter
que de grandes partitions ne soient occupées
que par de petits processus. Le gestionnaire de
mémoire, en fonction de la taille des processus,
décide quelle partition lui allouer pour ne pas
gaspiller trop de mémoire.
Une file d'attente est associée à chaque
partition. Quand vient une nouvelle tâche, le
gestionnaire détermine quelle est la plus petite
partition qui peut la contenir puis place cette
tâche dans la file correspondante.
Le fait d'éviter d'allouer une partition trop grande
à un petit processus conduit parfois à des
aberrations. Il arrive que des partitions plus
grandes restent inutilisées alors que se forment
ailleurs des files interminables de petits processus.
La mémoire est donc mal utilisée.
Une autre solution est de créer une file unique. Lorsqu'une partition se libère, on
consulte la file pour trouver la tâche qui l'occuperait de manière optimale.
Le risque est que les petites tâches soient pénalisées. Une parade est de conserver
une petite partition au moins qui ne sera accessible qu'aux petites tâches. Une autre
solution, serait de dire qu'un processus ne peut être ignorer qu'au maximum un certain
nombre de fois. Après n refus, il prendra place dans une partition même si la partition
est bien plus grande qu'il ne faut.
4.3.1.2. Partitions variables
Une autre manière d'éviter les emplacements mémoires inoccupés en fin de
partitions est d'allouer aux processus des espaces qui correspondent exactement à
l'espace qui leur est utile.
Au fur et à mesure que les processus se créent et se terminent, des partitions s'allouent
et se libèrent laissant des zones mémoires morcelées et inutilisables.
La mémoire se fragmente et est de plus en plus mal employée. Il faudrait la
compacter en déplaçant régulièrement les processus mais cette tâche
supplémentaire ralentit le système.
4.3.1.3. Conclusion :
Le partitionnement de la mémoire que ce soit avec des partitions de tailles fixes ou
de tailles variables, ne permet pas d'utiliser la mémoire au mieux.
User
4.4. La pagination
Les processus requièrent des espaces d'adresses continus. On a vu que cela est
difficilement réalisable en découpant la mémoire en partions dont les tailles
correspondent à celles des processus. La pagination est une technique d'allocation
de la mémoire bien plus efficace. Elle fournit aux processus des espaces
d'adresses séquentiels à partir d'espaces mémoire discontinus.
La pagination consiste à diviser la mémoire et les processus en blocs de mêmes tailles
appelés pages. Les pages mémoire sont souvent
appelées "frames" ou "cadres" tandis que les pages de processus sont simplement
appelées "pages".
Les pages (de processus) ne sont pas toutes simultanément actives ; elles ne sont
donc pas nécessairement toutes présentes simultanément dans la mémoire
principale. Les pages inactives attendent sur le disque. L'espace d'adressage est
donc virtuel sa taille peut être supérieure à celle de la mémoire réelle.
Les processeurs disposent actuellement d'un dispositif, le MMU "Memory Manager
Unit" qui permet de placer des processus en mémoire sans nécessairement placer les
pages de processus dans des cadres de pages contigus. On distingue les adresses
logiques qui se réfèrent aux pages de processus des adresses physiques qui se
réfèrent aux cadres de pages.
Voyons à présent comment l'unité de gestion mémoire (MMU) met en correspondance

les adresses physiques et logiques. Elle contient pour ce faire une table de pages où
sont inscrits les numéros des cadres de pages.
User
4.4.1. Fonctionnement des tables de pages

L'adressage se fait au moyen de numéros de pages et d'offsets. L'offset
(= déplacement ou décalage) est la position relative au début de la page.
L'adresse logique est composée du numéro de page de processus et d'un offset.
L'adresse physique correspondante est formée à partir du numéro du cadre de
page où est chargé la page de
processus et du même offset que
celui de l'adresse logique.
Le numéro du cadre de page est
consigné dans une table des pages
associée au processus. On y
retrouve le numéro du cadre de
page en se servant du numéro de
page de processus comme d'un
index.
Figure 8 : Pagination simple
User
Le nombre de pages étant souvent très grand les tables des pages deviennent
volumineuses et peuvent même occuper ... plusieurs pages. On les fractionne donc
en plusieurs niveaux : une table de page de niveau supérieur dont chaque élément
pointe vers une table de niveau inférieur. L'adresse logique contient dès lors deux
nombres pour aboutir au numéro de page. Le premier sert d'index dans la table de
niveau supérieur, le second sert d'index dans la table du niveau suivant.
Figure 9: Tables de pages multiniveaux
Ces accès multiples à différentes pages pour aboutir à l'adresse finale ralentissent
fortement l'adressage. On évite de répéter ces recherches en notant les
correspondances trouvées entre les adresses logiques et les adresses physiques dans
une mémoire associative. Ce qui permet ensuite de retrouver presque
immédiatement les correspondances les plus récentes
User
NB. L'espace d'adressage est perçu par le programmeur comme une suite continue
d'octets. La subdivision de l'adresse en numéros de page et d'offset est transparente.
Elle est prise en charge par le matériel.
4.5. La segmentation
Chaque processus est constitué d'un ensemble de segments. Chaque segment est
un espace linéaire.
Les segments sont des espaces d'adressages indépendants de différentes longueurs
et qui peuvent même varier en cours d'utilisation. Ils correspondent à des subdivisions
logiques déterminées par le programmeur ou par le compilateur.
Les segments contiennent des informations de même nature : le code, les données,
la pile, des tables, etc. Il est dès lors possible d'attribuer des protections adaptées à
chaque type de segment : un segment de code peut être déclaré en exécution
seule, une table de constantes en lecture seule mais pas en écriture ni en exécution.
Certaines zones de code en exécution seule peuvent être partagées par plusieurs
processus ; cela se fait par exemple pour des bibliothèques de sous-programmes.
L'accès aux segments se fait via une table de segments.
Chaque entrée de la table comporte l'adresse de départ du segment et sa taille.
L'adresse logique est constituée du numéro de segment et d'un offset. Contrairement
aux pages dont le fonctionnement est transparent pour le programmeur, les
segments sont des entités logiques qu'il connaît et manipule. Il distingue les deux
informations contenues dans l'adresse : le numéro du segment et l'offset.
Le numéro de segment sert d'index pour retrouver l'adresse du début du segment
dans la table de segment. Cet offset doit être inférieur à la taille du segment
consignée elle aussi dans la table de segment. Si ce n'est pas le cas, une erreur est
générée qui provoque l'abandon du programme. L'offset est ensuite ajouté à
l'adresse de début de segment pour former l'adresse physique.
4.6. Segmentation avec pagination

La segmentation et la pagination concernent des problèmes différents. Ce sont deux
techniques qui peuvent se combiner :
- La segmentation découpe les processus en zones linaires pouvant être gérées
différemment selon que ces segments sont propres au processus, qu'ils sont
partagés, lus, écrits ou exécutées et de manière à protéger les processus entre
eux.
- La pagination découpe la mémoire en pages non contiguës mais de même taille.
Elle procure aux processus des espaces d'adresse continus (nécessaires aux
segments). Les pages mémoires peuvent n'être allouées que lorsqu'un processus
en a besoin. On obtient de la sorte une mémoire virtuelle de taille supérieure à la
mémoire réelle.
Les systèmes d'exploitation qui gèrent ces deux techniques simultanément
administrent une table de segments et plusieurs tables de pages.
User
Un segment peut contenir plusieurs pages mais toutes ne doivent pas nécessairement
être présentes en mémoire à tout moment. On ne garde en mémoire que celles qui
sont réellement utilisées. Chaque segment a sa propre table de pages.
User
B i b l i o g r a p h i e | 51
Bibliographie
[1] A. Tanenbaum, Systèmes d'exploitation, Paris: Pearson, 2008.
[2] D. E. Cecile Germain, «Architecture des Ordinateurs,» Licence d’Informatique - IUP

Miage - FIIFO.
[3] Larousse, «Larousse langue française,» [En ligne]. Available:

https://www.larousse.fr/dictionnaires/francais.
[4] D. C. CURT FRANKLIN, «Comment fonctionnent les systèmes d'exploitation,» [En

ligne]. Available: https://computer.howstuffworks.com/operating-system.htm.
[5] M. Rouse, «Operating system (OS),» [En ligne]. Available:

https://whatis.techtarget.com/definition/operating-system-OS.
User

Support OS L2-Tous 2

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Support OS L2-Tous 2

Transféré par

Droits d'auteur :

Formats disponibles

Contenu |1

Ecole Supérieure d’Informatique Salama

1.2. Qu’est-ce qu’un Système d’exploitation .....................................................................19

4.3. Gestion de la mémoire pour systèmes multitâches ..................................................44

A l'issue de ce cours l'étudiant(e) sera capable de :

▪ Maitriser le fonctionnement d’un ordinateur abstrait autrement dit connaître

▪ Installer normalement un système d’exploitation + les applications sur un

▪ Comprendre la gestion des processus, des mémoires et des fichiers

0.1. Définition des concepts

0.1.4. Informatique ou information automatique

Le traitement de l'information c'est :

▪ Le calcul arithmétique et logique

Nous avons souvent improprement utilisé le terme « programme informatique »

Le terme logiciel est employé souvent pour désigner un programme

0.2. Système informatique

▪ Côté matériel, un ordinateur est composé de :

o L’objectif du logiciel est d’offrir aux utilisateurs des fonctionnalités

Figure 1 Représentation d’un système informatique

0.3. Système d’information

Parties d'un système d’information :

▪ Hommes : Si vous y réfléchissez, la seule raison d'être des ordinateurs est

▪ Procédures : Le logiciel ne s'exécute pas lui-même (généralement). Les

0.4. Ordinateur et changements technologique

a. Le matériel ou physique (Hardware) : c'est l'ensemble des

0.4.2. Structure d’un ordinateur

▪ Une unité centrale de traitement (Microprocesseur) : Unité

▪ Une unité de mémoire, appelée mémoire centrale : Est l’organe

Figure 2. Architecture d’un système informatique (ordinateur)

Figure 3. Un ordinateur et ses différents périphériques.

0.4.3. Changement technologique

Cette technologie utilisée des relais mécaniques (temps de

Il y’avais aucun langage ni système d’exploitation pour cela et

1.1.2. Deuxième génération : Transistors et systèmes par lots (1955 - 1965)

L’apparition des langages FORTRAN qui un langage incontesté

Les machines devaient être installées dans des locaux climatisés,

Figure 4. Exemple de traitement par lots.

Ces manipulations engendraient des pertes de temps trop

1.1.3. Troisième génération : circuits intégrés (1965 - 1980)

Les ordinateurs ont commencé à occuper moins de volume,

Au début des années 60, il y avait deux types d'ordinateurs :

▪ Ceux qui comme le 7094 étaient orientés vers des tâches de

▪ Ceux à vocation plus commerciale dont l'unité de donnée sont le

1.1.4. Quatrième génération : microprocesseurs (1980 – à nos jours)

L’évolution des ordinateur personnels ce présente comme suit :

▪ 1974 : le 8080, microprocesseur 8 bits généraliste fabriqué par

▪ 1985 : L'environnement d'exploitation Windows 1.0 est considéré

1.1.5. Cinquième génération : intelligence artificielle (Actuellement en cours)

La construction des ordinateurs et la technologie en général ont

0.5. Machine de Von Neumann

La machine de Von Neumann est conçue à partir de composants

▪ Une unité de commande

Qui peut être définis encore comme suit :

Figure 5. Machine de Von Neumann.

0.6. Schéma général d’un ordinateur

Figure 6. Schéma illustratif d'un ordinateur.

Dans l'unité centrale (appelé aussi microprocesseur)

Nous distinguons trois parties principales :

Qui permet de stocker momentanément les données à traiter, et dans cette

Figure 7. Schéma illustratif d'un ordinateur.

Chapitre.1 Généralités sur le système d’exploitation

➢ Comprendre la structure du système d’exploitation

1.2. Qu’est-ce qu’un Système d’exploitation

Les utilisateurs de l'informatique attendent des ordinateurs qu'ils soient toujours