REPUBLIQUE DU BENIN

---------
MINISTERE DE L’ENSEIGNEMENT SUPERIEUR
ET DE LA RECHERCHE SCIENTIFIQUE
---------
HAUTE ECOLE DE COMMERCE ET DE MANAGEMENT (HECM)
-----------
ANNEE ACADEMIQUE 2023-2024
-----------

INTITULE DU COURS

ARCHITECTURE
DES SYSTEMES
INFORMATIQUES
Présenté par :

Dr NOUNAGNON M. Maximin

1
Contenu
Chapitre 1: LES SYSTÈMES INFORMATIQUES .................................................................................4
I.1 DÉFINITION ET CLASSIFICATION .................................................................................4
I.2 LES SYSTÈMES INFORMATIQUES PERSONNELS ......................................................5
1.3 LES SYSTÈMES INFORMATIQUES D’ORGANISATION ..............................................6
1.3.1 Les composants.................................................................................................................................6
1.3.2 Le système d’information englobant ................................................................................................6
1.3.3 Les systèmes distribués....................................................................................................................7
1.3.4 Le cloud ...........................................................................................................................................7
1.4 LES SYSTÈMES INFORMATIQUES DE CONTRÔLE ET COMMANDE .........................9
1.4.1 Les composants.................................................................................................................................9
1.4.2 Les systèmes temps réel..................................................................................................................10
1.4.3 Les systèmes embarqués ou enfouis ...............................................................................................11
1.4.4 Les robots .......................................................................................................................................11
1.4.5 L’Internet des objets .......................................................................................................................12
Chapitre 2: L’ARCHITECTURE D’UN SYSTÈME INFORMATIQUE ...........................................13
2.1 LES ARCHITECTURES EN COUCHES ................................................................................14
2.2 L’ARCHITECTURE DE RÉFÉRENCE ..................................................................................15
2.2.2 La couche système/réseau...............................................................................................................16
2.3.2 Les équipements mobiles sous Android ..................................................................................18
2.3.3 Les solutions de virtualisation .................................................................................................20
Chapitre 3 : LES UNITES ET SYSTEMES DE STOCKAGE .............................................................22
3.1 LES UNITÉS DE STOCKAGE ...........................................................................................23
3.1.1 La hiérarchie des mémoires .....................................................................................................23
3.1.2 Les registres.............................................................................................................................24
3.1.3 La mémoire centrale ................................................................................................................24
3.1.4 Les mémoires cache ................................................................................................................26
3.1.5 Les SSD ..........................................................................................................................................28
3.1.6 Les disques magnétiques .........................................................................................................28
3.1.7 Les supports de sauvegarde et d’archivage .............................................................................30
3.1.8 Les mémoires mortes...............................................................................................................30
3.2 LES SYSTÈMES DE STOCKAGE ...........................................................................................31
3.2.1 Les architectures RAID ...........................................................................................................31
3.2.3 Les SAN ..................................................................................................................................34
3.2.4 Le stockage en ligne sur le cloud ............................................................................................34
Chapitre 4 : LES UNITES ET SYSTEMES DE TRAITEMENT.........................................................35
4.1 L’UNITÉ CENTRALE DE TRAITEMENT ............................................................................36
4.1.1 Les composants de l’unité centrale de traitement ....................................................................36
4.1.2 Les bus ............................................................................................................................................37

2
4.1.4 Le langage machine .................................................................................................................39
4.2 LES SYSTÈMES DE TRAITEMENT ......................................................................................46
4.2.1 Généralités sur les systèmes parallèles ...........................................................................................46
4.2.2 Les CPU multicœurs ...............................................................................................................48
4.2.3 Clusters et grilles .....................................................................................................................49
4.2.4 Systèmes à haute disponibilité et à équilibrage de charge.......................................................50

3
 Chapitre 1: LES SYSTÈMES
INFORMATIQUES

I.1 DÉFINITION ET CLASSIFICATION

Un système informatique est un ensemble de moyens informatiques et de

télécommunications, matériels et logiciels, ayant pour finalité de collecter, traiter,
stocker, acheminer et présenter des données.
Les concepts de système informatique et d’ordinateur ne doivent pas être confondus.
L’ordinateur n’est que l’un des composants, certes central, des systèmes
informatiques. Il en existe beaucoup d’autres, parmi lesquels on peut citer les
matériels réseau, les capteurs et actionneurs, les machines spécialisées (appliances),
comme les guichets automatiques bancaires ou les boîtiers de stockage en réseau, les
robots, les smartphones, les cartes à puce (smartcards), etc.
Un ordinateur est une machine de traitement automatique des données selon un
programme enregistré en mémoire. Il comporte un ou des processeurs, une mémoire
et des périphériques d’entrée, de sortie et de stockage. Les programmes sont
nécessairement exprimés dans le langage machine propre au processeur qui les
exécute, en général suite à une traduction depuis un langage de programmation plus
pratique à utiliser. Le système d’exploitation est le logiciel qui facilite et optimise
l’utilisation du matériel ainsi que la mise en œuvre des programmes. Tous ces
éléments seront décrits en détail dans les chapitres qui suivent.
Il existe aujourd’hui une très grande diversité d’ordinateurs. Du plus petit, le
microcontrôleur, qui tient en totalité sur une puce électronique d’un centimètre
carré, jusqu’au plus puissant, le supercalculateur, dont certains comportent des
centaines de milliers de processeurs afin de traiter d’énormes volumes de données.
La figure 1.1 résume les relations entre processeur, ordinateur et système
informatique.

Processeur (s) A u tr e
... com p osan t ...
Or di nateu r
Système informatique

Figure 1: Processeur, ordinateur et système informatique

Le présent document est une introduction aux systèmes informatiques, à leur

architecture et leurs composants, à leur configuration et leur utilisation. La suite de
ce chapitre introductif montre que les systèmes informatiques prennent de nos jours

4
des formes extrêmement variées selon le contexte dans lequel ils s’insèrent. On peut
distinguer, en première approximation, les systèmes informatiques personnels, les
systèmes informatiques d’organisation et les systèmes informatiques de contrôle et
commande. Chacune de ces catégories principales est analysée et éventuellement
affinée dans les paragraphes qui suivent.

I.2 LES SYSTÈMES INFORMATIQUES PERSONNELS

Un système informatique personnel a pour but de rendre des services, utilitaires ou

ludiques, à son possesseur. Il peut comporter différents matériels, connectés de façon
permanente ou non, comme :
- des ordinateurs personnels, qui se déclinent en ordinateur de bureau (PC pour
Personal Computer), ordinateur portable, tablette, assistant personnel,
- des équipements périphériques (imprimante, scanner, etc.),
- des équipements de transmission de données (modem, switch, box Internet,
etc.),
- des matériels plus spécialisés, comme les consoles de jeu ou les équipements
de domotique (habitat intelligent),
- des équipements terminaux de systèmes externes, comme les smartphones en
téléphonie.
L’architecture des réseaux domestiques connectent les divers composants des
systèmes informatiques personnels. On peut souligner dès à présent que les systèmes
informatiques personnels sont le plus souvent connectés au réseau Internet via la box
que fournit le fournisseur d’accès Internet (FAI). Cette box est également l’élément
clé de la convergence informatique/téléphone/télévision.
Les systèmes informatiques personnels constituent bien entendu la partie la plus
visible et la mieux connue par le public non spécialiste des systèmes informatiques.
Parmi les nombreux services grand public qu’ils offrent, on peut citer :

- la navigation sur le web,

- les messageries et les réseaux sociaux,
- les jeux individuels ou en réseau,
- la bureautique, avec le calcul (par exemple, via un logiciel tableur), le
traitement de texte, la gestion des données personnelles, etc.,
- le multimédia, avec la retouche d’images, le traitement du son, le montage
vidéo, la réception et la diffusion de flux de vidéo ou de musique (streaming),
etc.
-

5
1.3 LES SYSTÈMES INFORMATIQUES D’ORGANISATION
1.3.1 Les composants
Les systèmes informatiques d’organisation sont hébergés au sein des organisations
de toute nature que sont les entreprises, les associations, les administrations, les
laboratoires de recherche, etc. Ils comprennent une grande diversité de composants :
- tout d’abord des ordinateurs, comme des postes de travail, des serveurs
d’applications, des serveurs de données, des grappes de machines (cluster), des
supercalculateurs, etc.,
- ensuite, beaucoup d’autres équipements de traitement et de transmission de
données, comme des capteurs et actionneurs, des concentrateurs,
commutateurs et routeurs, des robots, des machines dédiées, etc.,
- enfin des réseaux, soit locaux à l’échelle d’un bâtiment – LAN pour Local
Area Network –, soit métropolitains à l’échelle d’une ville – MAN pour
Metropolitan Area Network –, soit étendus jusqu’à l’échelle mondiale – WAN
pour Wide Area Network – à l’image d’Internet.
1.3.2 Le système d’information englobant
Le système informatique constitue l’infrastructure technique du système
d’information de l’organisation. Ce qu’on appelle système d’information de
l’organisation comporte, outre le système informatique, un ensemble organisé
d’autres ressources, humaines, organisationnelles et immatérielles, comme des
méthodes, des règles, des procédures, etc. Le système d’information est destiné à
faciliter le fonctionnement de l’organisation en lui fournissant les informations utiles
pour atteindre ses objectifs.
Dans ces définitions, les termes donnés, quand on parle du système informatique, et
information, quand on parle du système d’information, ne sont pas équivalentes.
Une donnée est la description d’un élément ponctuel de la réalité, comme une mesure
ou une observation. Par exemple, le chiffre des ventes d’un produit à une certaine
date est une donnée. Une donnée est représentée dans le système informatique sous
une forme binaire, c’est-à-dire à deux états, notés 0 et 1 par convention. Cette forme
binaire peut correspondre à une certaine représentation des nombres, adaptée au
calcul automatique, à une certaine codification des caractères, ou à une certaine
numérisation d’un objet (son, image, etc.).
Une information est l’interprétation humaine d’une donnée ou d’un ensemble de
données qui lui donne du sens. Par exemple, la forme de la courbe annuelle des
ventes d’un produit constitue une information significative pour un responsable

6
commercial. L’interprétation humaine des informations peut conduire à des
connaissances de plus haut niveau qui peuvent guider les actions. Par exemple, le fait
que certains produits soient saisonniers est une connaissance qui va influencer la
gestion des ventes.
Aujourd’hui, seule une faible partie des connaissances est représentée explicitement
dans les systèmes informatiques. L’essentiel des connaissances, dites connaissances
tacites, se situe dans les têtes des personnes. On peut dire schématiquement que les
données sont la matière première du système informatique alors que les informations
et les connaissances demeurent majoritairement la matière première de la
composante humaine du système d’information. La figure 1.2 ci-après résume les
relations entre tous ces concepts.

Système d’information
i n f ormat
Niveau des ions et d es conna
informations i
et des
connaissances
Syst èm e
i nf ormat i que
( niveau des donn é es )

Ordinateur s

Ressources matérielles ,
logicielles, données

Ressources humaines, organisationnelles,

immatérielles (méthodes, règles, etc. )

Figure 2: Les niveaux de systèmes et leurs ressources

1.3.3 Les systèmes distribués

Les systèmes informatiques d’organisation sont le plus souvent aujourd’hui des
systèmes informatiques distribués (répartis), c’est-à-dire constitués par un
assemblage d’éléments matériels et logiciels qui coopèrent pour réaliser un objectif
commun en utilisant un réseau comme moyen d’échange des données. Ce réseau peut
être un réseau local ou un réseau étendu, le plus souvent Internet.
C’est le cas par exemple des systèmes de contrôle du trafic aérien, des systèmes
bancaires, des systèmes pair à pair (P2P), des grilles de calcul, du web, etc.

1.3.4 Le cloud
L’informatique « en nuage » (cloud, en anglais) est une déclinaison récente des
systèmes distribués. Il s’agit de l’exploitation de serveurs distants par l’intermédiaire
d’un réseau, le plus souvent Internet. Ces serveurs sont loués à la demande à des
fournisseurs externes selon l’utilisation (pay per use) ou forfaitairement. Par leur

7
 intermédiaire, trois principaux types de services peuvent être fournis, schématisés par
la figure 1.3.

Utilisateurs Consommer
SAAS

Développeurs Construire
PAAS

Architectes Héberge r
IAAS

Figure 3: IAAS, PAAS et SAAS

a) Infrastructure en tant que service

Le premier type est appelé « infrastructure en tant que service » (IAAS pour
Infrastructure As A Service). Le fournisseur loue un parc informatique virtualisé créé
et géré par une couche logicielle de virtualisation sur les serveurs de son centre de
ressources.
Les architectes du système client définissent l’infrastructure virtuelle sur laquelle
sont hébergés à distance tous les composants logiciels souhaités. L’organisation
économise ainsi l’achat de la couche matérielle de tout ou partie de son système
informatique.

b) Plateforme en tant que service

Le deuxième type est appelé « plateforme en tant que service » (PAAS pour Platform
As A Service). Le fournisseur loue une plateforme d’exécution complète des
applications, comprenant un ensemble de machines virtuelles en réseau avec leurs
systèmes d’exploitation et des outils d’infrastructure pour la distribution des
applications, le stockage, la sauvegarde, l’archivage, la surveillance, la sécurité, etc.
Les développeurs du système client le construisent sur cette plateforme. Comme au
niveau IAAS, un tel service offre une grande « élasticité », c’est-à-dire une capacité
d’adaptation immédiate aux besoins (croissance ou diminution de la charge par
exemple) et une mutualisation des coûts. L’utilisateur économise l’achat d’une
infrastructure matérielle et logicielle propre pour tout ou partie de son système
informatique

8
c) Logiciel en tant que service

Le troisième type est appelé « logiciel en tant que service » (SAAS pour Software As
A Service). Le fournisseur loue des applications accessibles via un simple navigateur
web. Par exemple, les Google Apps for Work comprennent des services
professionnels de messagerie, de visioconférence, de stockage en ligne et d’autres
applications d’entreprise.
Toutes les couches matérielles et logicielles sous-jacentes aux applications sont
cachées à l’utilisateur du service et mises à disposition dans le cadre de la
consommation du logiciel.
Le développement conjoint des applications web et du SAAS ouvre la perspective de
systèmes d’information accessibles 7 jours sur 7, 24 heures sur 24, en tout lieu et sur
tout appareil connecté (ordinateur, tablette, smartphone, téléviseur connecté, etc.).
On parle de solution Any Time, Any Where, Any Device, Any Content.
Dès aujourd’hui, le stockage de données sur le cloud et les logiciels sur le cloud sont
de plus en plus utilisés, même par le grand public dans le contexte des systèmes
informatiques personnels.

1.4 LES SYSTÈMES INFORMATIQUES DE CONTRÔLE ET

COMMANDE
1.4.1 Les composants
Un système informatique de contrôle et commande reçoit des données relatives à
l’état d’un procédé extérieur via des capteurs, traite ces données et, en fonction du
résultat, agit sur ce procédé extérieur via des actionneurs, afin de le maintenir dans
l’état souhaité.
Comme le montre la figure 1.4, des opérateurs humains peuvent être amenés à
fournir des consignes et à effectuer un suivi, par exemple via des visualisations de
l’état du procédé.

Procédé
Mesures Commandes

Capteur Actionneur

Acquisition Analyse et Restitution

données traitement données
données

Consignes Visualisations
Opérateur

Figure 4: Système de contrôle et commande

9
Dans le cas de procédés complexes, incluant de multiples entités physiques,
l’opérateur fournit des objectifs à atteindre et suit le comportement global du
procédé. Cette fonction de supervision constitue une couche de niveau supérieur par
rapport à celle de conduite des entités du procédé

1.4.2 Les systèmes temps réel

Quand les contraintes de temps deviennent primordiales, on parle de système
informatique temps réel. On peut en distinguer deux sous catégories :
- Un système temps réel strict doit respecter les contraintes temporelles même dans
le pire des cas. Un résultat logiquement correct mais fourni hors délai devient ipso
facto un résultat incorrect. Une large partie des systèmes de supervision
industrielle (centrales nucléaires, usines chimiques, etc.), des systèmes de
supervision médicale, des systèmes d’assistance au pilotage ou à la conduite
entrent dans cette catégorie.
- Un système temps réel souple (soft) peut exceptionnellement ne pas respecter les
contraintes de temps. C’est le cas par exemple de la visioconférence ou des jeux
en réseau, où un dépassement occasionnel des contraintes nuit simplement à
l’agrément d’utilisation. Exemple

Opérateurs

Supervision

Commande-contrôle

Procédé complexe

Figure 5: Système de contrôle et commande

Dans une voiture, le correcteur électronique de trajectoire (ESP pour Electronic

Stability Program) est composé de capteurs de vitesse, de braquage, d’accélération
latérale et d’actionneurs sur les freins et sur le régime moteur. Le calculateur contrôle
les signaux transmis par les capteurs et vérifie 25 fois par seconde si les mouvements
de braquage du volant correspondent bien à la direction suivie par la voiture. Dans le
cas contraire, l’ESP réagit en quelques millisecondes, sans intervention du
conducteur. Il utilise essentiellement le système de freinage pour ramener la voiture
sur sa trajectoire. Par exemple, en cas de sous-virage, quand le train avant dérive et
que la voiture a tendance à aller tout droit au lieu de suivre la courbe voulue, l’ESP
freine la roue arrière intérieure. En cas de survirage, quand le train arrière dérive
10
davantage que le train avant avec un risque de tête-à-queue, l’ESP freine la roue
avant extérieure.

1.4.3 Les systèmes embarqués ou enfouis

Quand le système informatique est partie intégrante d’un système plus large qu’il
commande et contrôle, on parle de système informatique embarqué ou enfoui. On en
trouve par exemple dans les automobiles, les avions et certains équipements
médicaux, électroménagers ou de loisir (caméras, jouets, etc.).
Outre les contraintes possibles de temps, ces systèmes informatiques subissent le
plus souvent de fortes contraintes de poids, volume, consommation énergétique,
autonomie (alimentation par batterie), consommation mémoire, etc.
1.4.4 Les robots
Les robots constituent une famille particulière de systèmes, alliant mécanique,
électronique et informatique (« mécatronique »), qui visent à remplacer les êtres
humains pour des tâches répétitives, pénibles, dangereuses ou même impossibles à
réaliser par eux. Un robot possède tout ou partie des capacités suivantes :
- capacité d’acquisition de données via des capteurs, « proprioceptifs » quand ils
mesurent l’état du robot lui-même (sa position, sa vitesse, sa charge, etc.) et «
extéroceptifs » quand ils renseignent sur l’état de son environnement
(température, lumière, chaleur, etc.),
- capacité d’interprétation des données acquises permettant de produire des
connaissances,
- capacité de décision qui, partant des données ou des connaissances, détermine et
planifie des actions ; ces actions sont destinées à réaliser des objectifs fournis le
plus souvent par un être humain, mais qui peuvent aussi être déterminés par le
robot lui-même, éventuellement en réaction à des événements,
- capacité d’exécution automatique d’actions dans le monde physique
(déplacements, manipulations d’objets, etc.) à travers des actionneurs (ou
effecteurs), comme des roues, des bras, des jambes, des pinces, etc.
- capacité de communication et d’interaction avec des opérateurs ou des utilisateurs
humains, avec d’autres robots ou avec des ressources via un réseau, comme
Internet,
- capacité transversale d’apprentissage, qui permet au robot de modifier son
fonctionnement à partir de son expérience acquise.

11
Il existe une très grande variété de robots, qui se distinguent par leur degré
d’autonomie plus ou moins grand vis-à-vis des opérateurs, leur degré d’adaptabilité
aux évolutions de leur environnement, leur capacité d’apprentissage et de créativité,
c’est-à-dire d’invention de comportements ou d’objectifs non prévus par leurs
concepteurs. Ils peuvent également être classés en grandes catégories fonctionnelles :
- robots industriels, comme dans les chaînes de montage de voitures,
- robots explorateurs, pour la conquête spatiale, l’exploration de décombres,
l’exploration sous-marine, le déminage, etc.,
- robots de service, pour l’agriculture (traite, cueillette, etc.), les transports, les
tâches domestiques (robot-aspirateur, robot-tondeuse, etc.), l’aide aux personnes
âgées ou handicapées, l’assistance médicale et chirurgicale, etc.
- robots ludiques, comme les robots de compagnie,
- robots humanoïdes, dont l’apparence rappelle celle d’un corps humain, etc.
La robotique suscite depuis l’origine énormément d’interrogations et de controverses
liées aux questions de sécurité, de conséquences sociales, sur l’emploi en particulier,
et plus fondamentalement de cohabitation et de frontière entre robots et humains.

1.4.5 L’Internet des objets

Les systèmes informatiques de contrôle et commande constituent aujourd’hui en

nombre le parc le plus important, avec approximativement 90 % du total des
systèmes informatiques. Cette prédominance provient du nombre énorme de
systèmes informatiques enfouis dans les objets de la vie quotidienne.
Tous ces objets, rendus « intelligents » par le système informatique qu’ils
embarquent, seront amenés de plus en plus à communiquer via Internet, à la fois
entre eux et avec des personnes et des systèmes informatiques extérieurs. Il s’agit de
ce qu’on appelle couramment « l’Internet des objets » (ou « Internet des choses »).
C’est le cas, par exemple, de la voiture intelligente (smart car) capable de
communiquer avec les autres véhicules proches, la route, les panneaux de
signalisation, des bases de données sur la circulation, la cartographie, etc.
« L’Internet à venir sera de plus en plus un Internet entre machines, entre capteurs,
entre robots, qui généreront des gisements de données sans limites (...) Il est difficile
d’imaginer aujourd’hui les transformations radicales que vont subir nos
environnements domestiques, urbains, sociaux, laborieux, etc. (smart car, smart
home, smart city, smart grid, smart body, etc.). »

12
Chapitre 2: L’ARCHITECTURE D’UN
SYSTÈME INFORMATIQUE

13
2.1 LES ARCHITECTURES EN COUCHES
Une architecture de système se décrit traditionnellement comme un ensemble de
couches. Les couches basses d’un système sont proches du matériel alors que les
couches hautes sont proches des utilisateurs. Idéalement, comme le montre la
figure 2.1, chaque couche utilise uniquement les services offerts par la couche
immédiatement inférieure et offre ses services à la couche immédiatement
supérieure.
Utilisateurs
Couche n (la plus haute)
…..
Couche i+1
Utilise les Offre ses
services de services à
Couche i

…….
Couche 1(la plus basse)

Matériel

Figure 2.1 : les architectures en couches

2 • L’architecture d’un système informatique
Dans une architecture logicielle en couches proprement définie, chaque service
comporte une interface et une implantation, comme le montre la figure 2.2.
L’interface permet l’accès aux fonctionnalités sans se préoccuper de la manière
dont elles sont implantées. Il peut s’agir d’une interface de manipulation par les
utilisateurs ou d’une interface de programmation (API pour Application
Programming Interface') pour les accès aux services par les programmes de la
couche supérieure. À fonctionnalités constantes, on peut donc modifier
l’implantation du service sans avoir à modifier ses utilisations.
Utilisations du service

Interface du service
Service
Implantation du
service
Figure2.2 : interface et implantation d’un service

14
2.2 L’ARCHITECTURE DE RÉFÉRENCE
Ce paragraphe décrit une architecture de référence en couches des systèmes
informatiques, synthétisée par la figure 2.3. La description détaillée des divers
composants de cette architecture sera fournie tout au long de cet ouvrage.
5. Couche des
applications
Couches hautes
4. Couche distribution
3. Couche 3.2. Services additionnels Couche
système/réseau 3.1. Noyau Système/réseau
2. Couche du langage 2.2. Couche du langage machine
machine 2.1. Couche du microcode Couches basses
1. Couche du matériel
Figure2.3 : l’architecture de référence des systèmes informatique
2.2 L’architecture de référence
2.2.1 Les couches basses
La couche la plus basse, notée couche 1 dans la figure 2.3, est celle du matériel.
Elle comprend les processeurs, les mémoires, les équipements d’entrée/sortie,
les équipements réseau, etc. À ce niveau, les données en forme binaire sont
traitées, stockées et transférées.
Au-dessus du matériel, la couche logicielle la plus basse est celle du langage
machine (couche 2). C’est-à-dire du langage en forme binaire, « directement »
exécutable dans les circuits électroniques du processeur.
Le mot directement est mis entre guillemets car ce n’est pas toujours réellement
le cas. C’est vrai uniquement dans le cas des processeurs possédant une unité de
commande câblée (matérielle). L’unité de commande d’un processeur recherche
successivement chaque instruction qu’il doit exécuter, l’analyse et la met en
œuvre en donnant une suite d’ordres aux autres composants de la machine (c/
paragraphe 4.1.1). Dans une unité de commande câblée, ce processus de mise en
œuvre est figé dans les circuits électroniques. Dans le cas d’une unité de
commande microprogrammée (logicielle), à chaque instruction du langage
machine correspond un ensemble de micro-instructions qui décrivent son
processus de mise en œuvre. Ce microprogramme ou microcode, stocké en
mémoire en lecture seulement (ROM pour Read Only Memory), est exécuté pour
mettre en œuvre chaque instruction. Cette approche, fréquente aujourd’hui,
donne des possibilités d’évolution des instructions du processeur par simple
modification de leur microcode.

15
L’architecture de référence de la figure 2.3 fait donc apparaître une éventuelle
couche du microcode (couche 2.1) sous la couche du langage machine
proprement dite (couche 2.2).
Dans la suite de l’ouvrage, les deux premières couches, 1 et 2, sont parfois
regroupées sous le vocable « couches basses ».

2.2.2 La couche système/réseau

La couche 3 correspond pour l’essentiel au système d’exploitation, c’est-à-dire
au logiciel intermédiaire entre le matériel et les applications qui l’utilisent. Son
rôle est triple :
 Gérer les ressources matérielles et logicielles : mémoire, processeurs,
programmes, données, communications locales et via les réseaux. Cette gestion
comprend l’allocation, le partage et la protection des ressources.
 Fournir une interface de manipulation de la machine et de ses ressources
qui soit la plus fe simple possible pour ses utilisateurs.
 Fournir une interface de programmation (API) plus facile d’utilisation que
le langage machine et qui dissimule les détails de l’utilisation des ressources.
Toutes ces notions seront développées dans le chapitre 7, consacré aux systèmes
d’exploitation. On distingue souvent le noyau du système d’exploitation (couche
3.1) des services système ; additionnels (couche 3.2). Ces derniers comprennent
en particulier :
 les compilateurs, qui traduisent les langages évolués (C, C++, etc.) en
langage machine,
 les environnements de bureau, pour faciliter l’interaction homme-machine
(IHM),
 les langages de commande (shells), pour programmer des scripts qui
automatisent les lâches d’administration récurrentes,
 les bibliothèques, qui facilitent l’utilisation des services du noyau, etc.

2.2.3 La couche de distribution des applications

La couche 4 est propre aux systèmes distribués (répartis). On l’appelle aussi «
couche du milieu » ou couche des middlewares (intergiciels) car elle se situe
entre le système/réseau et les applications réparties.
On peut la voir comme une sorte de « système d’exploitation » de la «
supermachine » constituée par le système distribué. Elle a quatre fonctions
principales :

16
  fournir une interface de programmation (API) de « haut niveau » aux
applications distribuées, plus facile à utiliser et plus spécialisée que les API de «
bas niveau » de la couche système/réseau,
 masquer l’hétérogénéité des composants (systèmes d’exploitation,
matériels, réseaux),
 rendre la répartition des traitements et des données invisible
(transparente),
 fournir des services d’usage courant pour construire les applications
distribuées.
2.2.4 La couche des applications
Enfin la couche 5 est la couche des applications. On peut distinguer au sein des
applications :
 les applications distribuées, qui exploitent toutes les couches inférieures
(4 à 1),
 les applications locales, qui s’appuient directement sur la couche
système/réseau et les couches inférieures (3 à 1).
Dans la suite de l’ouvrage, les deux dernières couches, 4 et 5, sont parfois
regroupées sous le vocable « couches hautes ».

2.3 DES EXEMPLES D’ARCHITECTURES CONCRÈTES

Tous les systèmes informatiques n’implantent pas nécessairement l’ensemble
des couches de l’architecture de référence. contrario, une subdivision en
couches logicielles plus spécifiques est parfois utile à la description de certains
systèmes informatiques.
Les paragraphes qui suivent donnent quelques exemples d’architectures
concrètes.

2.3.1 Les systèmes enfouis élémentaires

On trouve ce type de système, par exemple, dans tous les appareils dotés d’une
interface digitale, comme les caméras, les montres digitales, les lave-vaisselle,
etc. Son architecture se réduit à trois couches, comme illustré par la figure 2.4.
Un système enfoui élémentaire utilise un microprocesseur (processeur sur une
puce) ou un microcontrôleur (ordinateur sur une puce). Un unique programme
en langage machine, souvent appelé firmware, est stocké en mémoire morte
(ROM). Le système d’exploitation n’est pas utile, car tout le comportement
requis, assez simple, peut être programmé dans le firmware

17
 Firmware
Langage machine
Microcontrôleur

FIGURE 2.4 L'architecture d’un système enfoui élémentaire

2.3.2 Les équipements mobiles sous Android

Android est un système d’exploitation libre pour smartphones et tablettes,
développé actuellement par Google. Il a pour objectifs de faciliter :
- l’exploitation des réseaux de communication : téléphonie 2G, 3G et 4G,
Bluetooth pour les communications très courtes distances, Wi-Fi pour les
réseaux locaux,
- la manipulation de médias : vidéos, sons, images,
- l’exploitation des composants matériels : capteur de mouvement, caméra,
récepteur GPS, écran tactile, etc.,
- le stockage de données en base de données : carnet de contacts, etc.,
- le rendu d’images en 2D ou 3D en utilisant un processeur graphique,
- l’affichage de pages web,
- l’envoi de messages SMS,
- l’exécution d’applications en multitâche, c’est-à-dire en simultanéité
apparente, etc.

L’architecture d’Android comporte un empilement spécifique de couches

logicielles au-dessus des couches basses du smartphone ou de la tablette
qu’illustre la figure 2.5.
Applications
Natives (téléphone, contacts, navigateur), tierces, spécifiques

Framework applicatif Couches

Gestion des fenêtres, des activités, des ressources, etc. Interface de programmation (API) hautes

Bibliothèques C, C++Graphisme, ART (Android RunTime)

base de données, médias, web, etc. Machine virtuelle Java, bibliothèques Java de base
Couche
Noyau Linux système/réseau
Gestion de la mémoire, des processus, des fichiers, de l'alimentation, des matériels (écran,
clavier, caméra, accéléromètre, GPS, etc.), des communications, etc.
Couches basses
FIGURE 2.5 L’architecture d’Android

18
a) La couche système/réseau
Le noyau du système d’exploitation Android est un noyau Linux modifié. Il
fournit les services classiques comme la gestion des processus, la gestion de la
mémoire, la gestion du matériel (mémoire flash, caméra, son, alimentation, etc.)
et la gestion des communications.
Ce noyau Linux n’est pas manipulable directement par les utilisateurs.
Cependant, avec des applications comme Android Terminal Emulator, il est
possible d’utiliser les commandes de base du système Linux dans un pseudo-
terminal.

b) Les couches hautes

Comme le montre la figure 2.5, les couches hautes s’organisent en trois sous-
couches et quatre composants.

> Les bibliothèques C, C++

Les bibliothèques C, C++ offrent des services de base, comme par exemple la
manipulation de différents types de données. On y trouve en particulier : le
moteur de base de données SQLite, le moteur de rendu de pages web WebKit,
les codecs de V Android Media Framework pour enregistrer et restituer
différents médias, la libc (bibliothèque C standard), Open GL ES (Open
Graphics Library for Embedded System) pour afficher des contenus 3D, Open
SSL pour la sécurité, le Surface Manager pour l’affichage des fenêtres, etc.

> L’Android runtime

L’Android RunTime (ART) comprend une machine virtuelle Java (ART JVM
successeur de Dalvik) pour exécuter les applications Java, et les bibliothèques
Java de base(Core Java Libraries) pour les développer.

> Le framework applicatif

Le framework applicatif procure des services de haut niveau aux applications
sous la forme de classes Java : Activity Manager (cycle de vie des applications),
Telephony Manager, Location Manager (GPS), Resource Manager, Content
Providers (partage de données entre applications), etc. Ces services exploitent
les bibliothèques C, C++ de la couche inférieure.

> Les applications

En complément des applications de base préinstallées (téléphone, SMS,
navigateur web, gestionnaire de contacts, etc.), les utilisateurs peuvent

19
télécharger ou développer, principalement en Java, toutes les applications qu’ils
souhaitent.

2.3.3 Les solutions de virtualisation

Les outils de virtualisation rencontrent une popularité croissante, autant dans le
cadre des systèmes informatiques internes aux organisations que dans le cadre
du cloud. H en existe différents types qui visent tous à faire fonctionner
plusieurs machines virtuelles avec leurs propres systèmes d’exploitation (OS)
sur une machine hôte.
Une première architecture possible utilise un logiciel d’émulation qui s’exécute
sur le système d’exploitation de la machine hôte. Cette application simule le
processeur, la mémoire et le stockage de chaque machine virtuelle. Une de ces
applications, parmi les plus connues, est Oracle VirtualBox. Cette architecture,
que montre la figure 2.6, comporte un empilement de six couches, dont deux
couches de systèmes d’exploitation complets. La lourdeur qui en résulte pénalise
les performances des machines virtuelles.
Machines virtuelles

Logiciel de Applications Couches

contrôle ….. hautes
OS invité
des
machines Drivers
virtuelles Logiciel d'émulation
OS hôte Couche
système
Couches basses

FIGURE 2.6 L’architecture de virtualisation avec émulateur

Une autre architecture possible consiste à installer un logiciel spécialisé,

dénommé hyperviseur, directement sur les couches basses. Il s’agit d’un noyau
système très simplifié et optimisé pour faciliter les accès des OS invités à
l’architecture matérielle sous-jacente. Les hyperviseurs les plus connus sont
Xen, KVM, VMWare vSphere, etc. Les systèmes d’exploitation invités peuvent
ou non être adaptés à la virtualisation. Symétriquement, les processeurs de la
couche matérielle peuvent ou non être adaptés à la virtualisation.
Comme le montre la figure 2.7, cette seconde architecture ne comporte plus que
cinq couches, dont un seul système d’exploitation complet. Les quatre couches

20
inférieures peuvent être optimisées. Ce type de solution est plus efficace mais
aussi plus complexe à mettre en œuvre
Machines virtuelles

Logiciel Applications Couche hautes

de
contrôle
OS invité OS invité
Drivers Drivers Couche
Hyperviseur système
Couches basses

FIGURE 2.7 L’architecture de virtualisation avec hyperviseur

21
Chapitre 3 : LES UNITES ET
SYSTEMES DE STOCKAGE

22
 3.1 LES UNITÉS DE STOCKAGE

3.1.1 La hiérarchie des mémoires

Les systèmes informatiques, et les ordinateurs en particulier, comportent
actuellement plusieurs mécanismes de stockage de données ou mémoires. Ces
mécanismes se différencient par :
- leur coût,

- leur vitesse, c’est-à-dire le temps moyen d’accès aux données, et leur débit,
c’est-à-dire le nombre de données lues ou écrites par seconde,
- leur mode d’accès aux données, c’est-à-dire dans l’ordre de leur rangement
pour l’accès séquentiel ou via une adresse pour l’accès direct,
- leur durabilité, c’est-à-dire leur caractère persistant ou volatil. Les
mémoires vives, volatiles, perdent leur contenu quand le système
informatique est privé d’alimentation électrique suite à un arrêt ou une
panne. Les mémoires persistantes, non volatiles, préservent au contraire
leur contenu même en l’absence d’alimentation électrique.
Avec les technologies actuelles, plus une mémoire est efficace, en termes de
vitesse d’accès cl de débit, plus elle est chère, ce qui tend à limiter sa capacité.
Les systèmes informatiques | exploitent en conséquence une « hiérarchie des
mémoires » allant de la mémoire la plus i efficace, la plus chère et de plus faible
capacité à la mémoire la moins efficace, la moins chère Cl de plus grande
capacité. Les capacités s’expriment en kilo-octet (210 = 1 024 ≈ 1 000),
mégaoctet (220 ≈ 1 000 000), gigaoctet (230 ≈ 1 000 000 000), téraoctet (240), etc.
La hiérarchie actuelle des mémoires comprend dans cet ordre :
- les registres (mémoires les plus petites, les plus efficaces et les plus
chères),
- les mémoires cache,
- la mémoire centrale,
- les SSD {Solid-State Drive),
- les disques magnétiques,
- les supports de sauvegarde et d’archivage (mémoire les plus grandes, les
moins efficaces et les moins chères).
Les trois premiers types sont volatils alors que les trois suivants sont persistants.
L’accès direct aux données est possible pour tous, sauf pour les supports de
sauvegarde et d’archivage du type cassette ou bande magnétique, qui sont
exclusivement à accès séquentiel. Toutes ces mémoires sont en lecture/écriture,

23
 contrairement aux mémoires mortes en lecture seulement (ROM pour Read-
),
Only Memory) qui constituent une catégorie un peu à part, étudiée au paragraphe
3.1.8.

3.1.2 Les registres

Un registre est un emplacement de mémoire, interne à un processeur, qui sert en
particulier au stockage des opérandes et résultats intermédiaires lors des calculs.
Il s’agit de l’élément de mémoire le plus rapide.
La capacité d’un registre de données correspond au mot mémoire du processeur,
c’est-à-dire à l’unité de donnée de base qu’il manipule. La taille du mot
s’exprime en nombre de chiffres binaires (bits) ou en octets (groupes de 8 bits).
Les processeurs peu puissants ont des mots de petite taille (processeurs 8 bits
par exemple) alors que les processeurs puissants ont des mots de grande taille
(processeurs 64 bits par exemple).
Selon les architectures des processeurs, il peut exister un nombre plus ou moins
grand de registres généraux interchangeables et de registres spécialisés dont les
principaux seront présentés aux paragraphes 3.1.3 pour ceux liés à la mémoire
centrale et 4.1.1 pour ceux liés à l’unité de contrôle.
Les registres généraux sont accessibles via les instructions du langage machine.
Par exemple, on peut demander le chargement d’un registre depuis la mémoire
centrale, le rangement d’un registre en mémoire centrale, la réalisation d’un
calcul utilisant un ou plusieurs registres. La majorité des registres spécialisés
sont gérés directement par le processeur. Le microcode, quand il existe, utilise
ses propres registres, appelés registres microarchitecturaux.

3.1.3 La mémoire centrale

a) La mémoire physique
La mémoire centrale contient les programmes et les données que ceux-ci
manipulent. Elle est plus lente que les registres et que les mémoires cache (cf.
paragraphe 3.1.4) mais de capacité beaucoup plus importante. Sa capacité
s’exprime le plus souvent en gigaoctets, c’est-à-dire en milliards d’octets. C’est
une mémoire vive, qui perd tout son contenu lorsque l’alimentation électrique
est coupée, contrairement aux mémoires externes, comme les disques, et aux
mémoires mortes.
La mémoire centrale peut être vue comme un ensemble de cellules mémoires
(mots) qui peuvent contenir chacune une donnée ou une instruction en binaire.
Chaque cellule est repérée par un numéro, ou adresse mémoire. Oh peut lire ou
écrire une cellule à une adresse donnée. Le temps d’accès est le même quel que

24
soit le mot concerné. D’où le qualificatif de « mémoire à accès aléatoire » ou
RAM pour Random Access Memory, également utilisé.
L’adresse à lire ou à écrire doit être placée dans un registre spécialisé, le registre
adresse mémoire (RAM *). Un dispositif, le décodeur, sélectionne la bonne
cellule. En cas d’écriture, commandée par une microcommande d’écriture, la
donnée à écrire doit être placée dans un autre registre spécialisé, le registre
donnée mémoire (RDM). En cas de lecture, commandée par une
microcommande de lecture, c’est la donnée lue qui est rangée dans le RDM. La
figure 3.1 schématise cette organisation. Les notions de microcommande et de
bus seront précisées au paragraphe 4.1.1

FIGURE 3.1 La mémoire centrale

Du point de vue technologique, on distingue deux types de RAM :

 Les RAM statiques, ou SRAM, qui utilisent des bascules pour mémoriser
les bits. Une bascule est un circuit logique capable de maintenir sa sortie
inchangée dans une certaine configuration de ses entrées et donc de réaliser une
mémoire de 1 bit. L’implantation d’une bascule requiert un ensemble de 4 à 6
transistors. Les SRAM sont très rapides, de prix élevé et donc principalement
utilisées dans les mémoires cache (cf paragraphe 3.1.4),
 les RAM dynamiques, ou DRAM, avec de nombreuses générations
successives nommées SDRAM, RDRAM, DR-SDRAM, DDR-SDRAM, DDR2,
DDR3 et DDR4 pour les dernières. Elles ne nécessitent qu’un seul transistor et
un condensateur. Leur implantation exige un rafraîchissement périodique des
données, toutes les quelques millisecondes, à cause du courant de fuite du
condensateur. Elles sont moins rapides, moins coûteuses et plus fortement

25
intégrées que les RAM statiques. Elles sont utilisées dans les mémoires
centrales.
La mémoire centrale peut être sujette à des erreurs soit permanentes (usure,
défaut de fabrication), soit intermittentes (alimentation électrique perturbée,
particules alpha, etc.). On stocke souvent chaque mot de M bits avec K bits
supplémentaires permettant de détecter et de corriger d’éventuelles erreurs. Ces
K bits de contrôle sont calculés avant écriture en mémoire, stockés en mémoire
et recalculés en lecture pour comparaison et éventuellement correction de la
donnée (cf. paragraphe 6.11).

b) La mémoire virtuelle

Une adresse sur N bits permet d’adresser 2yV cellules. Par exemple, avec des
adresses de 32 bits on peut adresser environ 4 millions de cellules, ce qui est
souvent très insuffisant. Les ordinateurs actuels utilisent donc fréquemment le
concept de mémoire virtuelle. Cette approche, qu’illustre la figure 3.2, repose
sur une traduction à la volée d’adresses virtuelles, appartenant à un espace
d’adressage virtuel beaucoup plus grand que l’espace d’adressage physique, en
adresses physiques en mémoire centrale. C’est la MMU (Memory Management
Unit) qui réalise cette traduction. La mémoire virtuelle utilise une partie de la
mémoire externe, disque en général, comme extension de la mémoire centrale,
avec un va-et-vient de zones de tailles fixes, appelées pages, entre les deux.
C’est le système d’exploitation qui transfère, selon les adresses demandées, les
pages utiles vers la mémoire physique et les pages inutiles vers la mémoire
externe. Ce point sera approfondi lors de l’étude des fonctions des systèmes
d’exploitation au chapitre 7.

Unité Mémoire
MMU
centrale Adresse Adresse centrale
mémoire
virtuelle

Exception MMU

Figure 3.2 La mémoire virtuelle

3.1.4Les mémoires cache

L’augmentation des performances des processeurs surpasse celle des

26
 mémoires centrales des ordinateurs, même si les deux progressent très
rapidement. Il faut actuellement de l’ordre de 300 cycles processeur pour
accéder à un mot en mémoire centrale. Les mémoires cache cherchent à
masquer en partie ces différences, en accélérant l’accès aux données les plus
utilisées.

Un cache est une mémoire rapide qui enregistre temporairement des copies
de données provenant de la mémoire centrale (ou plus généralement d’une
certaine source), afin de diminuer le temps d’une nouvelle lecture de ces
données. Les architectures actuelles comprennent des caches d’instructions,
des caches de données et des caches mixtes instructions/données. Les
processeurs utilisent souvent plusieurs niveaux de caches : les plus proches
étant plus rapides mais aussi plus petits que ceux plus éloignés du processeur.
Le cas le plus classique est celui d’un processeur ayant deux niveaux de
cache embarqués dans le processeur (caches L1 et L2) et souvent un
troisième niveau de cache (L3) situé en dehors du processeur.
Le mode de fonctionnement est le suivant, si on suppose l’existence d’un seul
niveau de cache. Le processeur demande une donnée, c’est-à-dire un mot
mémoire. Le cache vérifie s’il possède cette donnée. S’il la possède, on parle
de « succès du cache », il la fournit au processeur. S’il ne la possède pas, on
parle de « défaut du cache », il la demande à la mémoire centrale, la transmet
au processeur et la stocke pour d’éventuelles utilisations ultérieures.
Deux « principes » expliquent l’accroissement notable des performances
résultant de l’utilisation d’un cache :
- Le principe de localité spatiale indique que l’accès à une donnée située à
une adresse A va probablement être suivi d’un accès à une zone très proche
de A. Cela résulte de l’accès principalement séquentiel aux instructions et
des accès fréquents à des ensembles consécutifs de données. Il est donc
intéressant de transférer dans le cache non pas la seule donnée demandée
mais un bloc de plusieurs mots autour de cette donnée.
- Le principe de localité temporelle indique que l’accès à une zone mémoire
à un instant t a de fortes chances de se reproduire rapidement après en t +
n. Cela résulte de l’existence fréquente de traitements répétitifs. C’est
pourquoi la donnée est conservée le plus longtemps possible dans le cache.
En conséquence de ces principes, le cache contient des blocs de cellules
mémoires contiguës, appelés lignes. Comme illustré par la figure 3.3, les
transferts avec le processeur se font par mots alors que les transferts avec la
mémoire se font par blocs. La politique de remplacement des blocs dans le cache

27
doit permettre de conserver le plus longtemps possible les données ayant fait
l’objet d’un accès. Pour charger un nouveau bloc, on peut supprimer par
exemple le plus ancien dans le cache (politique FIFO pour First in First Out) ou
le plus anciennement 'jj utilisé (politique LRU pour Last Recently Used).

Unité Mémoire
centrale Mot Cache Bloc centrale

FIGURE 3.3 Les mémoire cache

3.1.5 Les SSD

Un SSD, pour Solid State Drive est un dispositif utilisant une large quantité de
mémoire flash pour concurrencer les disques magnétiques.
La mémoire flash est une mémoire à semi-conducteurs réinscriptible, c’est-à-
dire une mémoire possédant les caractéristiques d’une mémoire vive persistante.
On la trouve également, à plus petite échelle, dans les clés USB et les caries
mémoires des appareils photo numériques ou des téléphones portables.
Dans les SSD, cette mémoire flash est répartie en plusieurs modules. Elle est
pilotée par un contrôleur qui organise le stockage et la répartition des données
sur l’ensemble des modules. Les données échangées entre le système
d’exploitation et le SSD transitent par une mémoire tampon (buffer). Les SSD
utilisent les interfaces Serial ATA (SATA), comme les disques, ou PCI-Express,
comme la carte graphique.
Un SSD est plus solide qu’un disque magnétique et possède une meilleure
résistance aux chocs et aux vibrations. Les SSD surpassent aussi les disques en
performances (temps d’accès, débit, consommation) mais leur prix au gigaoctet
reste plus élevé, même si la différence diminue régulièrement.

3.1.6 Les disques magnétiques

Un disque magnétique, appelé aussi « disque dur », comporte un axe central
autour duquel un empilement de plateaux en aluminium, verre ou céramique,
tourne à une vitesse de rotation rapide et constante, en général de 5 à 15 000
tours/minute (cf figure 3.4).

28
 Sens de rotation

Figure 3.4 : le disque magnétique

Les surfaces des plateaux sont recouvertes d’une fine couche d’un substrat
magnétisable, sur laquelle les données sont enregistrées. Les données sont
écrites grâce à une tête de lecture/écriture qui survole la surface du disque.
Suivant le courant électrique qui la t raverse, la tête modifie le champ
magnétique local pour écrire soit 0, soit 1. En lecture, le mouvement du champ
magnétique local engendre aux bornes de la tête un potentiel électrique qui
dépend de la valeur enregistrée (0 ou 1). Toutes les têtes de lecture/écriture sont
reliées à une armature qui se déplace entre les plateaux avec une tête par face du
plateau. L’armature déplace les têtes radialement au-dessus des plateaux pendant
qu’ils tournent, ce qui permet d’accéder à la totalité de leur surface.
La surface de chaque plateau est divisée en pistes concentriques séparées par un
petit espace. Toutes les pistes situées à une même distance de l’axe forment un
cylindre. Chaque piste est divisée en secteurs contenant les données. Il faut donc
trois éléments d’adresse pour accéder à un bloc : .
- un numéro de piste, qui détermine la position du bras qui porte les têtes,
- un numéro de tête, qui détermine le choix d’une surface,
- un numéro de secteur sur cette piste, qui détermine à partir de quel endroit
commencer à lire ou écrire les données pendant une rotation.

Il existe plusieurs types d’interfaces pour connecter les disques, comme ATA
(Advanced Technology Attachment), Serial-ATA (SATA) et SCSI (Small
Computer System Interface).

29
3.1.7 Les supports de sauvegarde et d’archivage
La sauvegarde (backup) correspond à la création d’une copie de sécurité sur un
support de mémorisation différent de l’original.
On peut procéder à une sauvegarde complète du support ou à des sauvegardes
partielles. Parmi ces dernières, on distingue :
- Les sauvegardes incrémentales, qui ne contiennent que les éléments
modifiés depuis la précédente sauvegarde. Pour reconstituer le support complet,
il faut remonter à la dernière sauvegarde complète et appliquer toutes les
sauvegardes incrémentales suivantes.
- Les sauvegardes différentielles, qui contiennent tous les éléments
modifiés depuis la p, dernière sauvegarde complète.
Ces trois modes, sauvegarde totale/incrémentale/différentielle, ont chacun leurs
avantages et b leurs inconvénients en termes de durée et d’espace de stockage
occupé. Le choix du mode et g de la fréquence de sauvegarde dépend de
l’importance des données et de leur fréquence de modification.
L’archivage correspond à une conservation à long terme de contenus a priori
figés pour des raisons légales ou d’information. La sauvegarde et l’archivage
s’accompagnent souvent de la compression des données.
Les disques magnétiques, les supports portables (clé USB, DVD-ROM, etc.) et
les supports g à accès séquentiel (bandes et cassettes magnétiques) sont utilisés à
la fois pour la sauvegarde IL.' cl pour l’archivage.
3.1.8 Les mémoires mortes
À l’origine, les mémoires mortes étaient des mémoires électroniques persistantes
en lecture seulement, c’est-à-dire dont le contenu était figé à la fabrication
{Read-Only Memory ou ROM). Avec l’évolution des technologies, le terme
mémoire morte inclut maintenant toutes les mémoires persistantes dont le
contenu est fixé initialement, essentiellement pour des lectures, mais qui peut
aussi, plus ou moins facilement, être modifié.
Plusieurs générations se sont succédé, nommées PROM {Programmable Read
Only Memory) constituées de « fusibles » pouvant être grillés (0) ou non (1),
EPROM {Erasable Programmable Read Only Memory) effaçables par des
ultraviolets, EEPROM {Electrically Erasable Read Only Memory) effaçables
électriquement. Les mémoires flash sont une variété de mémoire EEPROM
rapide et dense, effaçable par plage de données et non par mot mémoire isolé.
Les mémoires mortes sont utilisées à diverses fins, pour le stockage :
- des éléments nécessaires au démarrage des ordinateurs (BIOS),

30
- du microcode des instructions, dans le cas des séquenceurs microprogrammés,
- du firmware de certains systèmes embarqués et équipements, tels les disques
durs, les routeurs, les appareils photo numériques, etc.

3.2 LES SYSTÈMES DE STOCKAGE

Il s’agit de systèmes plus complexes que le simple attachement direct d’un
support de stockage à une machine, nommé DAS pour Direct Attached Storage.
Bien entendu, ces systèmes complexes mettent en jeu des composants logiciels
qui ne relèvent pas exclusivement des couches basses.

3.2.1 Les architectures RAID

Le mot RAID {Redundant Array of bide pend ent Disks) désigne des techniques
permettant de répartir les données sur plusieurs disques afin d’améliorer selon
les cas les performances ou la sécurité (tolérance aux pannes).
Les architectures RAID peuvent être gérées par une couche logicielle au sein du
système d’exploitation ou par un contrôleur matériel qui décharge le système
d’exploitation et lui rend les choses transparentes.
On distingue de multiples variantes d’architecture RAID. Les trois plus
importantes sont présentées dans les paragraphes qui suivent.

> Le RAID 0
Le RAID 0 ou « entrelacement de disques » {stripping) est une architecture de
répartition des données sur deux disques (ou plus), qui améliore les
performances grâce à la possibilité de lectures/écritures parallèles. Dans cette
approche, les blocs de données {stripes) sont répartis en « lignes » successives
sur les différents disques.
Dans la configuration à deux disques de la figure 3.5, on peut lire ou écrire en
parallèle Al et A2 par exemple.

FIGURE 3.5 L’architecture RAID 0

31
Le RAID 1
Le RAID 1 ou mirroring, décrit par la figure 3.6, est une architecture
redondante, avec deux disques (ou plus) qui contiennent à tout moment
exactement les mêmes blocs de données. On parle aussi de disques « miroirs ».
Le RAID 1 confère au stockage des données une certaine tolérance aux pannes
matérielles

FIGURE 3.6 L’architecture RAID

> Le RAID 5
Le RAID 5 est une architecture qui unifie les deux précédentes, avec une
efficacité légèrement plus faible. Cette approche combine la répartition par
bandes du RAID 0 à une parité répartie.
Il faut N + 1 disques pour disposer de la capacité utile de N disques. Par
exemple, quatre disques pour trois utiles pour la configuration de la figure 3.7.
En effet, à chaque « ligne » de N blocs de données (Al à AN) est associé un bloc
de parité (Ap). Les blocs de parité sont répartis sur les différents disques. En cas
de défaillance d’un disque, pour chaque « ligne » il manque soit un bloc de
données, soit le bloc de parité. Si c’est le bloc de parité, ce n’est pas grave, car
aucune donnée ne

Figure 3.7 : l’architecture RAID5

manque. Si c’est un bloc de données, on peut calculer son contenu à partir des

32
N-1 blocs de données restants et du bloc de parité. En effet, le ième bit du bloc de
parité Ap(i) est le résultat d’un « ou exclusif » (xor) entre les i èmes bits des blocs
de sa « ligne » :
Ap(i)=Al(i) xor A2(i) xor A3(î) xor ... xor AN(i)=Al(i).
L’opération xor a la propriété suivante :
Ap(i) xorA2(«) xor A3(i)xor...xor AN(i) =Al(i),
Al(i) xorAp(i) xor A3(i)xor ...xor AN(i) =A2(i),
Al (i) xorA2(i) xor Ap(i)xor...xor AN(i) = A3(i), etc.
C’est-à-dire que n’importe quel bloc de données Ak défaillant peut-être récupéré
grâce au bloc de parité Ap et les N -1 autres blocs.
Quand la défaillance se limite à un seul disque, le système reste en état de
fonctionner et il est possible de reconstruire le disque défaillant à partir des
données et des blocs de parité présents sur les autres disques.
3.2.2 Les NAS
Un serveur de stockage en réseau, ou NAS (Network Attached Storage), est un
système autonome dédié (appliance), relié à un réseau local, qui joue le rôle de
serveur de fichiers centralisé et optimisé pour un ensemble de clients, comme le
montre la figure 3.8.

Figure3.8 : un NAS
Le serveur NAS fournit ses services via les protocoles classiques de partage de
fichiers comme NFS {Network File System), CIFS {Common Internet File
System) ou AFP {Apple Filing Protocol), qui seront étudiés au chapitre 17. Les
données apparaissent aux clients comme des fichiers dans des volumes (disques
logiques) partagés sur le réseau.
Il existe des systèmes d’exploitation spécialisés pour transformer des ordinateurs
classiques en NAS, comme par exemple FreeNAS, qui dérive de FreeBSD, ou
OpenMediaVault, basé sur Debian.
Une telle gestion centralisée des fichiers présente de nombreux avantages :
partager efficacement les données stockées sur le serveur de stockage, diminuer

33
le nombre total de disques et centraliser une éventuelle architecture RAID,
centraliser la gestion des sauvegardes et simplifier l’administration des clients et
des autres serveurs qui ne sont plus concernés par la fonction de stockage.

3.2.3 Les SAN

Un réseau de stockage, ou SAN {Storage Area Network), est un réseau
spécialisé permettant de partager des baies de stockage, comme montré par la
figure 3.9. Les baies de stockage sont des équipements dédiés comprenant un
ensemble de disques et un ou plusieurs contrôleurs pour les connecter au réseau
de stockage (ou éventuellement à un NAS).

Figure3.9 : un SAN
Dans un SAN, les baies de stockage n’apparaissent pas comme des volumes
partagés sur le réseau. Elles sont accessibles en mode bloc comme les
périphériques locaux. Chaque client | voit l'espace disque d’une baie SAN
auquel il a accès par un réseau de stockage comme ses propres disques durs.
Les protocoles utilisés sont FibreChannel pour des débits élevés sur des fibres
optiques, iSCSI (internet SCSI) ou FCoE (Fibre Channel over Ethernet) pour
des accès via un réseau IP.
3.2.4 Le stockage en ligne sur le cloud
Le stockage en ligne est un service sur le cloud qui permet de sauvegarder,
partager et accéder à des fichiers depuis n’importe quel appareil connecté à
Internet.
Outre la capacité et le coût, les points importants à considérer dans ce type de
solution sont la sécurité (redondance du stockage, certification du fournisseur,
etc.) et la confidentialité des données. Le cryptage est essentiel et peut concerner
seulement le transfert, via le protocole de sécurisation des échanges sur Internet
SSL (cf. paragraphe 16.4), ou le transport et le stockage, quand le cryptage est
sous le contrôle du client.

34
 Chapitre 4 : LES UNITES ET
SYSTEMES DE TRAITEMENT

35
 4.1 L’UNITÉ CENTRALE DE TRAITEMENT
L’unité centrale de traitement (CPU pour Central Processing Unit), ou
processeur, comporte plusieurs composants qui communiquent entre eux et
avec des composants externes tels que la mémoire centrale et les unités
d’entrée/sortie, comme montré par la figure de l’introduction de la partie 1,
page 20.

4.1.1 Les composants de l’unité centrale de traitement

 Les unités de calcul
L'unité essentielle est l’unité arithmétique et logique (UAL ou ALU en anglais),
chargée F- comme son nom l’indique d’effectuer les opérations de calcul
arithmétique (+, -, x, etc.) et de calcul logique (>, <, =, ET, OU, etc.).
Elle peut être complétée par d’autres unités de calcul spécialisées. C’est le cas
des unités de calcul en virgule flottante (FPU pour Floating Point Units), qui
effectuent des calculs sur des réels en virgule flottante (cf. paragraphe 6.6) ou
des unités de calcul vectoriel, qui appliquent r un même calcul simultanément
sur toutes les valeurs d’un vecteur de données.
Le schéma simplifié de la figure 4.1 montre uniquement l’UAL, sans autre unité
de calcul spécialisée. L’UAL reçoit en entrée les données du calcul arithmétique
et logique rangées dans des registres généraux et la microcommande indiquant
le calcul à effectuer. Elle produit à en sortie le résultat du calcul, rangé dans un
registre général, et des bits de contrôle, indiquant I pur exemple un débordement
du résultat de l’opération, dans le registre spécialisé appelé registre d’état (ou
PSW pour Program Status Word).

Figure 4.1 : l’unité centrale et sa relation à la mémoire centrale

36
  Limité de commande

L’unité de commande, ou unité de contrôle, cherche, décode et met en œuvre les

instructions du programme en langage machine stocké en mémoire centrale.
L’exécution d’une instruction nécessite une suite particulière de
microcommandes de déplacement des données entre les registres, la mémoire
centrale, les unités de calcul et les unités d’entrée/sortie, ainsi que l’activation
des lectures/écritures en mémoire et l’activation des circuits de calcul de l’UAL.
Comme cela a déjà été décrit au paragraphe 2.2.1, soit cette mise en œuvre des
instructions est figée dans les circuits des séquenceurs câblés, soit elle résulte de
l’exécution d’un microcode dans le cas des séquenceurs microprogrammés.
L’horloge interne et le séquenceur de commandes permettent de générer ces
microcommandes suivant un cadencement précis et rapide. La fréquence de
l’horloge, exprimée en général en gigahertz, c’est-à-dire en milliard de
battements par seconde, peut donner une certaine indication de la puissance
d’une machine.
L’unité de commande comporte deux registres spécialisés. Le premier est le
compteur ordinal (CO ou PC pour program counter), qui contient à tout instant
l’adresse de la prochaine instruction à exécuter. Il est incrémenté de 1 en 1 lors
d’une phase d’exécution séquentielle du programme (si on suppose que les
instructions tiennent toutes sur un mot) et modifié ponctuellement lors d’un saut
à l’intérieur du programme. Le second registre spécialisé est le registre
instruction, qui contient l’instruction à décoder et dont l’exécution doit être
contrôlée. Une instruction contient toujours un code opération, suivi le plus
souvent d’un ou plusieurs noms de registres ou adresses en mémoire
correspondant aux opérandes de l’opération.
Le paragraphe 4.1.3 explicite plus en détail comment s’exécute un programme.
4.1.2 Les bus
Les bus transportent les données, instructions, adresses, signaux d’horloge,
microcommandes entre les composants de l’unité centrale et depuis ou vers les
composants externes (mémoire centrale, unités d’entrée/sortie, etc.). La figure
4.1 fait apparaître de manière très schématique un bus de données, un bus
d’adresses et quelques microcommandes.
Un bus est caractérisé par sa largeur, c’est-à-dire le nombre de bits qu’il peut
transmettre simultanément, sa fréquence, c’est-à-dire le nombre de paquets de
bits transmis par seconde (en Hz), et son débit, qui est le produit de la largeur
par la fréquence.

37
Des composants appelés ponts (bridge') aiguillent les communications vers les
différents bus. Le plus souvent, le pont nord (north bridge), ou contrôleur
mémoire, gère les communications entre le processeur et les bus et dispositifs
rapides : mémoire centrale, carte graphique, pont sud. Le pont sud (south
bridge), ou contrôleur d’entrée/sortie, gère les communications entre le pont
nord et tous les autres bus et dispositifs lents. La figure 4.2 représente cette
organisation physique caractéristique des PC actuels.

Figure4.2 : les ponts et les principaux bus

4.1.3 L’exécution d’un programme
a) le cycle « chercher, décoder, exécuter
Le principe général d’exécution d’un programme consiste en la répétition,
jusqu’à la rencontre d’une instruction d’arrêt du programme, du même cycle
d’actions « chercher, décoder, exécuter ». Ce cycle est décrit par le pseudo-code
suivant.
Répéter
 Chercher en mémoire l'instruction dont l'adresse est dans le compteur
ordinal CO et la ranger dans le registre instruction RI;
 incrémenter le compteur ordinal CO (de n si l'instruction tient sur n mots
mémoires);
 décoder le contenu de RI;
 s'il y en a, chercher en mémoire le ou les opérandes indiqués dans
l'instruction pour les ranger dans des registres;
 exécuter l'opération correspondant au code opération;
 s'il s'agit d'un calcul, le résultat est calculé à partir des opérandes rangés
dans des registres puis rangé dans un registre;
 s'il s'agit d'un branchement, le compteur ordinal CO prend comme valeur

38
 l'adresse à laquelle le branchement doit se faire.
fin répéter
b) Les interruptions
Une interruption est un arrêt temporaire de l’exécution normale d’un programme
par le processeur pour exécuter un autre programme plus prioritaire. Avant
chaque cycle « chercher, décoder, exécuter », le processeur teste l’arrivée d’une
interruption.
Les interruptions matérielles (ou IRQ pour Interrupt ReQuest) sont provoquées
par des causes externes au programme qui s’exécute, comme le signalement de
la fin d’un transfert de données. On y inclut souvent les exceptions, ou trappes,
qui correspondent à une condition exceptionnelle dans le programme, comme
une division par zéro, un accès mémoire illégal ou un appel système (cf.
paragraphe 7.3.4). Les interruptions logicielles (soft IRQ) sont généralement
déclenchées par une instruction spéciale du processeur.
Lors d’une interruption, le processeur sauvegarde tout ou partie de son état
interne, généralement dans la pile mémoire, et exécute ensuite un programme
associé à l’interruption appelé « traitant d’interruption ». Le vecteur
d’interruption donne pour chaque type d’interruption, codé par un entier, le
traitant à exécuter. Une fois le traitant terminé, l’état du programme interrompu
est en général restauré et ce dernier reprend la suite de son exécution.
Lors du fonctionnement de certaines parties du système d’exploitation, il peut
être nécessaire de bloquer (masquer) les interruptions, par exemple parce que
des structures de données sont en cours de modification. Les interruptions
bloquées sont le plus souvent exécutées dès que cela redevient possible. Il peut
exister des interruptions non masquables, car associées à des erreurs
catastrophiques pour le système. Les interruptions peuvent par ailleurs être
hiérarchisées suivant des priorités. Une interruption de priorité supérieure est
prise en compte lors du traitement d’une autre interruption, alors qu’une
interruption de priorité inférieure est mise en attente.
Les interruptions sont utilisées principalement pour permettre des
communications non bloquantes avec des périphériques plus lents que le
processeur (cf paragraphe 5.1.2) et dans le cadre de la commutation entre
processus par l’ordonnanceur (cf paragraphe 8.1.3).

4.1.4 Le langage machine

Chaque type de processeur est capable d’exécuter un certain ensemble
d’instructions, son « jeu d’instructions ». Cet ensemble définit le langage

39
compréhensible par le processeur, ou langage machine. Selon les processeurs,
les instructions sont plus ou moins nombreuses, avec des longueurs fixes ou
variables.
a) Les instructions
Chaque instruction machine contient tout d’abord un code opération, qui indique
l’opération à exécuter. Il existe trois catégories principales d’opérations :
- Les opérations de transfert : mémoire vers registre ou registre vers mémoire,
empilage ou dépilage. On rappelle que la pile est une zone de mémoire dans
laquelle on peut stocker temporairement des données en les empilant, telle une
pile d’assiettes, puis en les dépilant, du haut vers le bas, pour les utiliser.
- Les opérations de calcul arithmétique et logique : addition, division,
incrémentation de 1, comparaison, etc.
- Les opérations de branchement, inconditionnel ou conditionnel, comme par
exemple « sauter à une certaine adresse si le résultat de l’opération précédente
était négatif ».

b) Les modes d’adressage

Les autres champs de l’instruction décrivent les éventuels opérandes. L’accès à
un opérande peut s’effectuer de nombreuses manières, nommées modes
d’adressage :
- accès à l’opérande par sa valeur, appelé adressage immédiat,
- accès à l’opérande par son adresse mémoire, appelé adressage direct,

- accès à l’opérande par l’identification du registre qui le contient, appelé

adressage par registre,
- accès à l’opérande par l’identification d’un mot mémoire qui contient
l’adresse de l’opérande, appelé adressage indirect,
- accès à l’opérande par l’identification du registre qui contient son adresse
mémoire, appelé adressage indirect à registre,
- accès à l’opérande par l’identification du registre qui contient son adresse
mémoire plus un décalage de n mots donné comme une constante, appelé
adressage basé,
- accès à l’opérande par l’identification du registre qui contient son adresse
mémoire plus un décalage de n mots donné dans un deuxième registre, appelé
adressage indexé,
- sans indication particulière, car l’accès se fait implicitement à une localisation
donnée, comme le sommet de la pile ou un registre particulier, appelé

40
 adressage implicite.
Certains de ces modes, en apparence compliqués, sont destinés à faciliter les
accès à des ensembles de données consécutives en mémoire.

c) Le langage d’assemblage
Le langage d’assemblage (ou langage assembleur) est une forme lisible par les
humains du langage machine binaire. Un petit programme de traduction, appelé
assembleur, permet de passer du programme en langage d’assemblage au
programme en langage machine avant son exécution. Le langage d’assemblage
possède les caractéristiques suivantes :
- Le jeu d’instructions est identique à celui du langage machine.

- Les codes opération sont exprimés par des mnémoniques comme add, mul,
mov, etc.
- Les valeurs constantes sont exprimables en décimal, hexadécimal, octal, etc.

- Les registres sont dotés de noms comme ax. dx, ah, etc.

- Les branchements se font via des étiquettes. Par exemple, jmp _labas décrit
un saut inconditionnel vers l’instruction ayant étiquette _labas.
- Des directives à l’assembleur permettent de définir les identificateurs associés
aux constantes et aux variables, les étiquettes dans le programme, des blocs de
données ou de code, etc.
Voici un exemple de programme en langage d’assemblage qui affiche « bonjour
le monde ! ! », avec le jeu d’instructions Intel x86 et l’assembleur Microsoft
Macro Assembler (MASM) :

org 0x0100 ; directive qui fixe l'adresse du programme en hexadécimal ;

un texte qui suit un point virgule est un commentaire
mov dx, texte ; ; charge dans le registre dx l'adresse du texte à afficher

mov ah, 0x09 : charge dans le registre ah la constante hexadécimale 09

; : qui correspond à un affichage
int 0x21 ; ; interruption hexadécimale 21 qui provoque l'affichage écran
ret fin du programme

texte: db Bonjour le monde !!', 10, 13, '$'

; directive de définition d'une suite d'octets
; les codes 10 et 13 forcent le passage à la ligne
4.1.5 L’implantation de l’unité centrale de traitement

41
On peut, en théorie du moins, décrire l’implantation d’une unité centrale de
traitement à plusieurs niveaux de granularité, en termes de composants
électroniques, de portes logiques et de circuits logiques.

a) Les composants électroniques

Une description au niveau des composants électroniques, en particulier des
transistors qui sont les composants actifs essentiels de l’électronique, est
impossible en pratique à cause de leur nombre. Par exemple, le processeur Intel
Core i7, apparu en 2010, en contient près de deux milliards. La loi de Moore,
énoncée en 1975, postule que le nombre de transistors des microprocesseurs
double tous les deux ans. Elle a été vérifiée jusqu’à présent mais risque de ne
plus pouvoir l’être à l’avenir à cause des limites physiques qui existent au
processus de miniaturisation.

b) Les portes logiques

Une description complète en termes de portes logiques ET (AND), OU (OR),
NON (NOT), OU exclusif (XOR), NON-ET (NAND), NON-OU (NOR),
réalisables chacune avec un petit nombre de transistors, serait encore
gigantesque.
Les tables de vérité qui définissent les portes logiques sont rappelées ici

a b a ET b a OU b a OU-EXCL b NON a a NON-ET b a NON-OU b

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

c) Les circuits logiques

Une manière de procéder plus réaliste consiste à décrire l’unité centrale de
traitement comme une combinaison de circuits logiques. Un circuit logique est
un assemblage de portes logiques réalisant une fonction logique significative.
On distingue habituellement deux types de circuits logiques : les circuits
combinatoires et les circuits séquentiels.

> Les circuits combinatoires

Les circuits combinatoires, ou circuits de calcul, produisent leurs sorties
exclusivement à
partir de leurs entrées. Tout calcul peut s’implanter en combinant des portes ET,
OU et NON. La théorie mathématique utile pour concevoir les circuits de calcul
est l’algèbre de Boole.

42
Les additionneurs, décodeurs, multiplexeurs sont des exemples de circuits
combinatoires utiles dans les systèmes informatiques.

Exemple
Soit un additionneur de deux bits (a et 6) et d’une retenue d’entrée (Rentres)- La
somme se lit sur S et la retenue de sortie sur Rsortie- On pourra vérifier que :
 la table de vérité à gauche de la figure 4.3 correspond bien à une addition
des trois bits d’entrée,
 le circuit à droite de la figure implante bien la table de vérité en prenant
des exemples de valeurs en entrée et en calculant les sorties.

a b Rentrée s Rsortie
0 0 0 0 0
0 1 0 1 0
1 0 0 1 0
1 1 0 0 1
0 0 1 1 0
0 1 1 0 1
1 0 1 0 1
1 1 1 1 1

Figure4.3 : un additionneur de deux bits

> Les circuits séquentiels

Les circuits séquentiels, ou circuits de mémoire, produisent leurs sorties en
fonction non seulement de leurs entrées mais aussi de leurs précédentes sorties.
Cela permet de réaliser
« l’effet mémoire », c’est-à-dire un état stable à une valeur donnée, 0 ou 1, avec
la possibilité de changer cette valeur avec certaines entrées. La théorie
mathématique utile pour concevoir ces circuits est la théorie des automates finis.
Les bascules, mémoires de 1 bit, les registres, mémoires de n bits, et les
compteurs sont des exemples de circuits séquentiels utiles dans les systèmes
informatiques.
Exemple
La figure 4.4 donne la table de définition et le circuit logique d’une bascule RS.
Un 1 dans S (sef) met la bascule à 1. Un 1 dans R (reset) met la bascule à 0. La
valeur de la bascule se lit sur la sortie Q. On pourra vérifier que le circuit de
droite implante bien la table de définition de gauche en prenant des exemples de

43
valeurs en entrée et en les faisant « tourner » dans le circuit jusqu’à un état
stabilisé.

S RQ Résultats
0 0 Q Sortie inchangée
0 1 0 Mise à 0
1 0 1 Mise à 1
1 1 Entrées interdites
Figure 4.4 Une bascule RS
Remarque
Les circuits logiques ne doivent pas être confondus avec les circuits intégrés. Un
circuit intégré est une petite plaquette de silicium placée dans un boîtier. Sur
cette plaquette sont gravés jusqu’à plusieurs millions d’éléments actifs
(transistors) et passifs (résistances, condensateurs, diodes, etc.). L’exemple le
plus connu est le microprocesseur, qui est un processeur suffisamment
miniaturisé pour tenir dans un boîtier unique.

4.1.6 L’amélioration des performances des processeurs

L’architecture effective des processeurs actuels est beaucoup plus complexe que
ce qui a été décrit jusqu’ici. Plusieurs éléments contribuent à l’amélioration des
performances.
L’augmentation de la fréquence d’horloge est un moyen simple pour gagner de
la vitesse. Cette approche connaît cependant des limites, liées par exemple à la
vitesse de propagation des signaux électriques et aux problèmes de dissipation
de la chaleur.
L’introduction de différents niveaux de mémoire cache a déjà été évoquée au
paragraphe 3.1.4 Ils permettent d’accélérer l’accès aux ressources, en particulier
la mémoire centrale. On a déjà évoqué aussi la présence des unités de calcul
spécialisées, comme les FPU pour accélérer les calculs sur les nombres réels
codés en virgule flottante (cf. paragraphe 6.6).
Le parallélisme au niveau du traitement des instructions est une voie exploitée
depuis longtemps. Le concept de pipeline permet de paralléliser différentes
phases de l’exécution des instructions : au minimum les phases chercher,
décoder, exécuter, comme le schématise la figure 4.5. Souvent, les découpages
en phases sont beaucoup plus fins.

44
 Figure4.5 : fonctionnement d’un pipeline
En complément d’un pipeline, on peut trouver une unité de prédiction de
branchement qui exploite l’historique des branchements déjà effectués. Elle
permet au processeur d’anticiper l’effet d’un branchement conditionnel, ce qui
est important pour éviter de commencer inutilement le traitement d’instructions
qui ne seront finalement pas exécutées.
Avec une architecture superscalaire, le processeur cherche à exploiter au
maximum le traitement parallèle des instructions, grâce à plusieurs unités de
calcul. La combinaison du parallélisme entre instructions et du parallélisme au
niveau du traitement des instructions conduit à de multiples pipelines parallèles.
L’optimisation du jeu d’instructions est une voie de nature différente. On est
passé, au fil du temps, de jeux d’instructions comportant beaucoup
d’instructions, puissantes et de tailles variables (approche CISC pour Complex
Instruction Set Computer}, à des jeux d’instructions avec moins d’instructions,
très optimisées et de tailles fixes (approche RISC pow Reduced Instruction Set
Computer), et actuellement à des approches mixtes tirant le meilleur parti des
deux philosophies.
La figure 4.6 donne une représentation un peu plus réaliste de l’architecture d’un
processeur H de type Intel Pentium monocœur. IFU signifie Instruction fetch
Unit. C’est l’unité chargée de rechercher la prochaine instruction, qui est ensuite
décodée par l’unité DEC et séquencée par g l’unité SEQ. Les processus
multicœurs sont abordés au paragraphe 4.2.2

45
4.2 LES SYSTÈMES DE TRAITEMENT
4.2.1 Généralités sur les systèmes parallèles
Un système parallèle est un ensemble de processeurs interconnectés qui
coopèrent pour F réaliser une certaine tâche de calcul. L’interconnexion peut
mettre en jeu un bus interne, un réseau local (LAN) classique ou spécialisé, un
réseau étendu (WAN), y compris Internet. I On distingue classiquement deux
classes de systèmes parallèles : les « systèmes à mémoire v partagée » et les «
systèmes à mémoire distribuée ».

Figure4.6 : architecture d’un processeur monocoeur

 Architecture à mémoire partagée
Dans ces systèmes, tous les processeurs ont accès à l’ensemble de la mémoire
par un chemin unique, bus ou réseau. Ce chemin peut constituer un goulot
d’étranglement quand le nombre de processeurs augmente. Les mémoires
caches, à un ou plusieurs niveaux, que l’on voit sur la figure 4.7 constituent une
réponse partielle à ce problème de performance.

Processeurs

caches

BUS OU Bus/réseau d’interconnexion

réseau

46
Figure4.7 : système à mémoire partagée
Cette architecture se retrouve par exemple dans les machines multiprocesseurs
symétriques à mémoire partagée (SMP pour Symmetric shared memory
Multiprocessor). Symétrique signifie que les processeurs reliés au bus
d’interconnexion jouent tous le même rôle.
Open MP {Open MultiProcessing) est une interface de programmation (API) qui
étend les langages de programmation classiques en calcul scientifique que sont
Fortran, C et C++. Open MP est devenu le standard de programmation pour le
calcul parallèle avec des machines SMP.
 Architecture à mémoire distribuée
Dans ces systèmes, seule la mémoire locale est accessible directement et
rapidement. Il faut gérer des échanges de messages entre les processeurs pour
les autres accès, beaucoup moins rapides, comme le montre la figure 4.8. On
parle aussi de système à architecture mémoire non uniforme {Non Uniform
Memory Architecture ou NUMA).

Processeurs

caches

Mémoire M M M
distribuée

Bus/réseau d’interconnexion

Figure 4.8 : système à mémoire distribuée

Cette organisation se retrouve par exemple dans les machines NUMA et dans les
clusters, constitués d’une grappe de machines, classiques ou SMP. Nous
détaillerons les principaux types de clusters au paragraphe 4.2.3
MPI {Message Passing Interface} est le standard de programmation par échange

47
de messages, (’’est une bibliothèque qui étend le Fortran, le C ou le C++.
Certains systèmes à mémoire distribuée cachent la distribution via une mémoire
partagée distribuée {Distributed. Shared-Memory multiprocessor ou DSM).
Tous les processeurs se partagent l’espace d’adressage global de cette mémoire
partagée distribuée, comme le montre la figure 4.9, ce qui facilite la
programmation au prix d’un certain coût à payer en efficacité. I .’implantation
de la mémoire partagée distribuée peut être matérielle ou logicielle.

Processeurs

caches

Gestionnaire de mémoire partagée distribuée

Bus/réseau d’interconnexion

figure 4.9 : système à mémoire partagée distribuée

4.2.2 Les CPU multicœurs
Un microprocesseur multicœur (multi-core) possède n (n 2) cœurs qui
fonctionnent en simultanéité au sein d’une même puce électronique. On parle
d’architecture CMP pour Chip-level Multiprocessing. Un cœur est un ensemble
de circuits capables d’exécuter des programmes de façon autonome. Toutes les
fonctionnalités nécessaires à l’exécution d’un programme sont présentes :
compteur ordinal, registres, unités de calcul, etc.
Des caches peuvent être associés à chaque cœur et des caches peuvent être
partagés entre les cœurs, ce qui constitue une spécificité notable par rapport aux
machines multiprocesseurs.
On retrouve dans les microprocesseurs multicœurs les deux architectures types
des systèmes parallèles :

48
- à mémoire partagée, avec un bus mémoire (c/ figure 4.10, où les « dies » sont
les plaquettes de silicium enchâssées dans le microprocesseur),
- à mémoire distribuée, avec des interconnexions NUMA entre les nœuds dotés
de RAM (cf. figure 4.11).

Figure4.10 : microprocesseur multicoeur à mémoire partagée

4.2.3 Clusters et grilles
Un cluster est une grappe de machines en réseau, ou nœuds, qui coopèrent dans
le cadre d’une tâche donnée. Les machines sont indépendantes, en général
similaires et situées en un même lieu géographique.
Dans un cluster, soit la tâche est dupliquée sur chaque machine, soit la tâche est
divisée, chaque machine effectuant une partie du travail. Le premier cas de
figure se rencontre

Figure4.11 : microprocesseur multicoeur à mémoire distribuée

49
par exemple dans le cadre de la haute disponibilité et de l’équilibrage de charge,
qui fait l’objet du paragraphe 4.2.4. Le second cas de figure se rencontre dans
les clusters de calcul à haute performance. Ces derniers accueillent des
simulations numériques complexes qui permettent de remplacer des expériences
impossibles à réaliser parce qu’elles sont dangereuses (simulations d’accident),
de longue durée (simulations en climatologie), inaccessibles (simulations en
astrophysique) ou interdites (simulations d’explosion de bombe nucléaire).
( )n parle de grille {grid) pour un ensemble de nœuds de très grande taille,
distribué par exemple au niveau mondial et constitué le plus souvent de
machines hétérogènes connectées par Internet.

4.2.4 Systèmes à haute disponibilité et à équilibrage de charge

la haute disponibilité est la garantie qu’un service offert sera accessible sans
interruption, ou avec un taux très faible d’interruption. La tolérance aux pannes,
c’est-à-dire l’aptitude à offrir un service sans interruption en présence d’une
panne, est une des conditions de la haute disponibilité.
Une disponibilité de 99 % (« deux neuf ») correspond à 3,65 jours
d’indisponibilité par an. 99 % (« trois neuf ») correspond à 8,76 heures. 99,99 %
(« quatre neuf ») correspond à 52,56 miminutes. À partir de ce niveau, on peut
parler de haute disponibilité. 99,999 % (« cinq neuf ») correspond à 5,26
minutes. 99,9999 % (« six neuf ») correspond à 31,5 secondes. A ces niveaux,
on parle de très haute disponibilité.
La recherche d’une haute disponibilité conduit à mettre en place des
architectures de systèmes particulières, utilisant diverses formes de redondance.
Le coût des solutions est bien entendu corrélé au niveau de disponibilité visé.
Soit, par exemple, le cas d’un serveur web (serveur HTTP). Connecté à Internet,
il reçoit des requêtes HTPP et renvoie des pages HTML statiques ou construites
dynamiquement à partir de données stockées le plus souvent dans une base de
données. L’architecture minimum avec un serveur et une base de données est
souvent insuffisante en termes de puissance, c’est-à-dire de nombre de requêtes
qui peuvent être servies, et de disponibilité.
L’équilibrage de charge {load balancing) consiste à répartir les requêtes sur
plusieurs serveurs agissant identiquement sur les mêmes données en parallèle
(un cluster de serveurs). C’est un exemple de redondance active où les moyens
redondants sont actifs simultanément. La machine qui porte le logiciel de
répartition de la charge constitue un point unique de défaillance {Single Point of
Failure ou SPOF), c’est-à-dire que son indisponibilité bloque la totalité du
système. Cette machine est souvent dupliquée avec un logiciel de type «
battement de cœur » (comme le logiciel heartbeat) qui teste périodiquement si le

50
serveur primaire fonctionne et effectue automatiquement le basculement vers le
serveur secondaire en cas de défaillance. C’est un exemple de redondance
passive où les moyens redondants sont mis en œuvre uniquement à la demande.
La figure 4.12 schématise ce genre d’architecture. Une technique similaire peut
être utilisée pour basculer le serveur de base de données d’un primaire à un
secondaire, les deux bases étant maintenues dans le même état par duplication
en continu des mises à jour.

Figure 4.12 : Architecture à équilibrage de charge d’un serveur web

51