Aller au contenu
ELECTRONICS ENGINEERINGelectronics-engineering.com
Systèmes informatiques

Architecture des ordinateurs : le modèle de von Neumann, performances et loi d'Amdahl

UC, mémoire et bus, l'architecture de Harvard, le cycle d'instruction, l'équation des performances avec un exemple, la loi d'Amdahl avec démonstration et exemples.

https://www.electronics-engineering.com/fr/architecture-de-von-neumann-performances-loi-d-amdahl/

Pas encore de vote : soyez le premier à noter cette page.

Un ordinateur, du microcontrôleur d’un lave-linge au processeur d’un serveur, exécute une séquence d’instructions prises en mémoire. L’organisation de base est encore celle proposée par von Neumann en 1945 ; ce qui a énormément changé, c’est la façon de la construire pour aller vite. Dans cette leçon, nous traitons le modèle de von Neumann, le cycle d’instruction, la façon de mesurer les performances et la loi d’Amdahl, qui dit combien on peut gagner grâce à une amélioration.

Le modèle de von Neumann

Schéma fonctionnel d'un ordinateur suivant le modèle de von Neumann
L’unité centrale contient l’unité de commande, l’unité arithmétique et logique et les registres, dont le compteur ordinal et le registre d’instruction. Elle est reliée par un bus à la mémoire principale, qui contient à la fois les instructions et les données, et aux périphériques d’entrée et de sortie.
  • L’UC (unité centrale, CPU) contient l’unité de commande (CU), qui interprète les instructions et pilote tout le reste ; l’unité arithmétique et logique (ALU), qui fait les calculs ; les registres, de minuscules mémoires très rapides. Deux registres spéciaux : le compteur ordinal (PC) avec l’adresse de l’instruction suivante et le registre d’instruction (IR) avec celle en cours d’exécution.
  • La mémoire principale contient à la fois les données et les instructions : c’est l’idée du programme enregistré, qui rend l’ordinateur universel (changer de tâche signifie charger un autre programme, pas recâbler la machine).
  • Les périphériques d’entrée et de sortie (E/S) et le bus qui relie le tout.

Dans l’architecture de Harvard, instructions et données vivent dans des mémoires séparées, avec deux bus : on peut lire en même temps une instruction et une donnée. De nombreux microcontrôleurs et processeurs de signal l’utilisent ; les processeurs modernes sont de von Neumann vers la mémoire principale, mais ont des caches séparés pour les instructions et pour les données.

Le cycle d’instruction

L’unité centrale répète indéfiniment :

  1. lecture (fetch) : lire en mémoire l’instruction à l’adresse contenue dans le PC et la placer dans l’IR ; le PC passe à l’instruction suivante ;
  2. décodage : l’unité de commande détermine de quelle instruction il s’agit et lit les opérandes dans les registres ;
  3. exécution : l’ALU calcule, ou la mémoire est lue ou écrite ;
  4. écriture (write back) du résultat dans un registre.

Un saut modifie le PC, et la lecture suivante continue à partir d’un autre point du programme : c’est ainsi que sont réalisés les boucles, les conditions et les appels de fonctions. Tout est cadencé par une horloge, un signal périodique dont la fréquence (quelques gigahertz aujourd’hui) fixe le rythme des circuits.

Mesurer les performances

Le temps d’exécution d’un programme est

    \[ T_{CPU} = N_{instr}\cdot\mathrm{CPI}\cdot T_{clk} = \frac{N_{instr}\cdot\mathrm{CPI}}{f_{clk}} \]

où N_{instr} est le nombre d’instructions exécutées et CPI le nombre moyen de cycles d’horloge par instruction.

Exemple. 2\cdot 10^9 instructions, CPI moyen 1,5, horloge de 3 GHz : T = 2\cdot 10^9\cdot 1.5/3\cdot 10^9 = 1 s.

Les trois facteurs dépendent de choses différentes : N_{instr} de l’algorithme, du compilateur et du jeu d’instructions ; le CPI de l’organisation du processeur (pipeline, caches) ; la fréquence de la technologie et de la profondeur du pipeline. En améliorer un en détériore souvent un autre, c’est pourquoi la fréquence seule ne dit pas quel processeur est le plus rapide. Une comparaison honnête mesure le temps sur de vrais programmes (benchmarks).

La loi d’Amdahl

Théorème. Si une fraction p du temps d’exécution est accélérée d’un facteur s, l’accélération globale est

    \[ S = \frac{1}{(1 - p) + p/s} \]

et elle ne dépasse jamais \frac{1}{1 - p}, aussi grand que soit s.

Démonstration. Le temps d’origine, normalisé à 1, se divise en une partie non accélérée, 1 - p, et une partie accélérée p, qui devient p/s. Le nouveau temps est (1 - p) + p/s, et l’accélération est le rapport de l’ancien au nouveau temps. Quand s \to \infty, le dénominateur tend vers 1 - p. ∎

Exemples.

  • Accélérer de 4 fois une partie qui prend 80 % du temps : S = 1/(0.2 + 0.2) = 2.5. Même avec une accélération infinie, elle ne peut pas dépasser 1/0.2 = 5.
  • Un programme parallélisable à 95 % sur 16 cœurs : S = 1/(0.05 + 0.95/16) \approx 9.1 ; avec une infinité de cœurs, au plus 20.

La leçon pratique : optimiser le cas courant, et la partie qui reste lente finit toujours par dominer. Avant d’optimiser un programme, il faut mesurer où le temps passe réellement (avec un profileur) au lieu de deviner.

La suite du cours

Les leçons suivantes suivent le parcours d’une instruction : comment elle est codée (jeu d’instructions), comment le matériel fait l’arithmétique, comment le processeur l’exécute (chemin de données et pipeline), où elle trouve les données (caches et mémoire virtuelle), comment elle dialogue avec le monde extérieur (entrées et sorties) et comment plusieurs processeurs travaillent ensemble (parallélisme).

S’abonner
Notifier de
guest
1 commentaire
Le plus ancien
Plus récent Les plus votés
1
0
Vous avez apprécié cet article ? Merci de laisser un commentaire.x