CM0
Architecture en couches
Un ordinateur moderne est conçu en couches : chacune est une abstraction qui manipule ses propres objets, et l'on passe à la couche inférieure par traduction.
| Niveau | Couche | Passage vers le niveau inférieur |
| 5 | Langages d'application (C, Java…) | Compilation |
| 4 | Langage d'assemblage | Assembleur |
| 3 | Système d'exploitation | Appels système |
| 2 | Jeu d'instructions (ISA), propre à chaque machine | Micro-programmes |
| 1 | Micro-architecture (UAL, registres…) | Matériel |
| 0 | Logique numérique (circuits logiques) | — |
À retenirL'ISA (niveau 2) est l'interface entre le logiciel et le matériel.
CM1 · 1
Ordinateur et architecture de Von Neumann
Un ordinateur est un système programmable qui, via des programmes (suites d'instructions), traite des données. Il doit acquérir, stocker, traiter et restituer l'information. Traitements possibles : calculs arithmétiques, calculs logiques, ruptures de séquence selon un résultat, mise en forme des données.
Le modèle de Von Neumann (1945) découpe la machine en parties dédiées, met le programme dans la mémoire comme les données, et prévoit des entrées et sorties.
Mémoire (données + programme)
Unité de contrôle (UC)
séquence les opérations
UAL
calculs, logique, comparaisons
Entrées
Sorties
Bus : relient tous les composants
À retenir4 parties : UAL (calcule), UC (coordonne), mémoire (stocke instructions et données), E/S (interaction). La plupart des ordinateurs actuels suivent encore ce modèle.
CM1 · 2
Périphériques d'entrées / sorties
Un périphérique se branche via une interface d'E/S (série, parallèle, USB…). Les E/S regroupent tous les transferts entre le processeur et les périphériques.
- Selon le rôle : entrée (fournit des données), sortie (convertit les données vers un autre support), stockage.
- Selon le format : périphérique caractères (flux d'octets en série, ex. clavier) ou blocs (blocs de taille fixe ayant chacun une adresse, ex. RAM, ROM).
Un périphérique = le dispositif + son contrôleur (unité d'échange). Le contrôleur traduit les requêtes du CPU en commandes pour le périphérique et remonte celles du périphérique au CPU : la communication est bidirectionnelle.
CM1 · 3
Les bus
Un bus est un chemin électrique fait de lignes, chacune transportant 1 bit à la fois. Il relie le CPU, la mémoire et les contrôleurs d'E/S.
| Bus | Sens | Transporte |
| Adresses | Unidirectionnel (simplex) | Les adresses des cases mémoire visées par le CPU |
| Données | Bidirectionnel (duplex) | Instructions et données |
| Contrôle (commandes) | Bidirectionnel (duplex) | Ordres de l'UC : lecture, écriture, synchronisation |
Largeur = bits transmis simultanément (bus série ou parallèle). Débit = quantité transmise par seconde :
Débit (bits/s) = largeur (bits) × fréquence (Hz)
Exemple du cours : 32 bits à 33 MHz → 1 056 000 000 bits/s → ÷ 8 = 132 000 000 octets/s = 132 Mo/s (÷ 10⁶) ou 125,89 Mio/s (÷ 2²⁰). L'onglet Calculs refait ce calcul pour d'autres valeurs.
CM1 · 4
Le processeur (CPU)
Circuit intégré de millions de transistors, cadencé par une horloge. Fréquence (Hz) = nombre de tops par seconde : 2 GHz = 2 000 000 000 tops/s. Il se décompose en unité de contrôle, UAL, registres, bus internes et horloge.
- Unité de commande : compteur ordinal, séquenceur (rythme l'exécution sur l'horloge), décodeur (analyse l'instruction du RI), horloge.
- UAL : opérations sur entiers — arithmétiques, logiques (ET, OU, XOR, NON, NON-ET), comparaisons, décalages. Opérandes dans les registres de travail, résultat dans l'accumulateur.
| Registre | Contient |
| PC / CO (compteur ordinal) | L'adresse de la prochaine instruction. Initialisé à la 1re, incrémenté automatiquement. |
| RI (registre instruction) | L'instruction en cours d'exécution (taille = un mot mémoire). |
| RA / MAR (registre adresse) | L'adresse de la case mémoire lue ou écrite. |
| RD / MDR (registre de données) | La donnée qui transite entre CPU et mémoire. |
| Acc (accumulateur) | Les résultats de l'UAL. |
| Registre d'état | Quelques bits (souvent 8) : les flags sur le résultat de la dernière opération. |
PiègePC et RA contiennent des adresses ; RI et RD contiennent des données.
CM1 · 5
La mémoire
Une mémoire stocke, conserve et restitue de l'information binaire. Chaque case a une adresse unique.
- Adresse de n bits → au plus 2ⁿ cases (nombre de fils d'adresses).
- Chaque case contient un mot de m bits (nombre de fils de données).
Capacité = 2ⁿ × m
Ex. 3 fils d'adresses, 8 fils de données → 2³ × 8 = 64 bits. Caractéristiques : capacité, temps d'accès, débit, format du mot, volatilité.
La mémoire idéale (rapide, grande, sobre) n'existe pas : plus elle est rapide, plus elle est petite. D'où la hiérarchie :
vitesse, coût du bit, proximité CPU ↑
Registresdans le CPU
CacheSRAM ≈ 10 ns
Mémoire centraleDRAM ≈ 60 ns
Stockage de massedisque dur, clé USB
ArchivageCD-ROM, DVD
capacité, temps d'accès ↓
Cache : entre registres et RAM, 4 à 20 fois plus rapide que la RAM, petit et coûteux, en plusieurs couches. Il exploite la localité temporelle (un mot lu sera relu : boucles) et la localité spatiale (un voisin sera lu : on charge un bloc, ex. tableaux, piles). Si la donnée n'est pas dans le cache, la RAM l'envoie au cache, qui la garde et la transmet au CPU.
| Mémoire | Accès | Volatile | Temps | Usage |
| SRAM | L/É | Oui | ≈ 10 ns | Caches ; plus chère |
| DRAM | L/É | Oui | ≈ 60 ns | Mémoire centrale (DIMM) ; peu coûteuse |
| ROM | Lecture | Non | ≈ 150 ns | BIOS ; quelques centaines de Ko |
| Masse | L/É | Non | lente | Disque dur, clé USB, DVD |
Unités1 octet = 8 bits. Kio = 2¹⁰ = 1024 octets ; Ko = 10³ = 1000 octets. Même logique pour Mio/Mo (2²⁰ / 10⁶), Gio/Go, Tio/To. Un mot fait 4 octets en 32 bits, 8 octets en 64 bits.
CM2 · 1
Du C au binaire
Le CPU ne parle que binaire, le programmeur parle un langage évolué : ce fossé sémantique est comblé par l'assembleur et les outils de traduction.
- Compilation : C → assembleur.
- Assemblage : code binaire, calcul des adresses, résolution des étiquettes.
- Chargement : instructions et données placées en mémoire, exécution par le CPU.
int A = 3 + 5; // compilé en :
li $t0, 3 # $t0 ← 3 → 0x24080003
li $t1, 5 # $t1 ← 5 → 0x24090005
add $t0, $t0, $t1 # $t0 ← $t0+$t1 → 0x01094020
sw $t0, 8($zero) # RAM[8] ← $t0 → 0xAC080008
li est une pseudo-instruction : li $t0, 3 est codée addiu $t0, $zero, 3 ; move rd, rs devient addu rd, rs, $zero.
Chemin de données : les composants qui stockent, transfèrent et transforment les données (CPU, RAM, bus) et la façon dont ils sont interconnectés.
CM2 · 2
Le cycle Fetch / Decode / Execute
L'ordinateur est séquentiel : l'UC exécute les instructions une par une.
Tant que (VRAI) faire
Fetch : chercher l'instruction pointée par PC
Decode : décoder l'instruction
[charger les opérandes depuis la RAM si nécessaire]
Execute : exécuter l'instruction
Si pas un branchement : PC = PC + 4
Sinon : PC = adresse de branchement
Fin Tant Que
Exemple : z = x + y avec z en @16, y en @20, x en @24 et le programme à partir de @36. L'onglet Simulateur le déroule étape par étape, registre par registre.
| @ | Instruction | Effet |
| 36 | lw $t0, 20($zero) | $t0 ← 7 (y) |
| 40 | lw $t1, 24($zero) | $t1 ← 10 (x) |
| 44 | add $t2, $t0, $t1 | $t2 ← 17 |
| 48 | sw $t2, 16($zero) | RAM[16] ← 17 (z) |
CM2 · 3
Segments mémoire et pile
| Segment | Contenu | Repère |
.text | Instructions du programme | $pc |
.data (+ .bss) | Données initialisées (+ non initialisées) | $gp |
| Tas (heap) | Allocation dynamique ; grandit vers les adresses hautes | — |
| Pile (stack) | Appels de fonction ; grandit vers les adresses basses | $sp |
La pile compense le petit nombre de registres : elle sauvegarde le contexte (adresse de retour, registres, frame pointer), les variables locales et paramètres, et gère les appels imbriqués et la récursivité. Empiler fait diminuer $sp. Prologue = push du contexte ; épilogue = pop.
CM2 · 4
Jeu d'instructions et formats MIPS32
L'ISA est le vocabulaire du processeur : instructions de calcul, de déplacement de données (registres ↔ mémoire) et de contrôle (branchements, sauts). Une instruction = un opcode + des opérandes (registres, adresses, immédiats).
MIPS32 : architecture RISC, jeu réduit et régulier, toutes les instructions font 32 bits, 32 registres de 32 bits.
| Nom | N° | Rôle |
$zero | 0 | Constante 0 |
$at | 1 | Réservé à l'assembleur |
$v0–$v1 | 2–3 | Valeurs de retour |
$a0–$a3 | 4–7 | Arguments |
$t0–$t7 | 8–15 | Temporaires (sauvés par l'appelant) |
$s0–$s7 | 16–23 | Sauvegardés (sauvés par l'appelé) |
$t8–$t9 | 24–25 | Temporaires |
$k0–$k1 | 26–27 | Réservés OS |
$gp · $sp · $fp · $ra | 28 · 29 · 30 · 31 | Global, stack, frame pointer · adresse de retour |
PiègesImmédiat étendu en signe pour addi, slti, lw, sw, beq, bne ; par des zéros pour andi, ori. Les 2³² octets adressables viennent des adresses sur 32 bits, pas des 32 registres.
CM2 · 5
Instructions MIPS à connaître
| Instruction | Fmt | Effet |
add $rd, $rs, $rt | R | $rd ← $rs + $rt (détecte l'overflow ; addu non) |
sub $rd, $rs, $rt | R | $rd ← $rs − $rt (subu sans overflow) |
and / or $rd, $rs, $rt | R | ET / OU bit à bit |
slt $rd, $rs, $rt | R | $rd ← 1 si $rs < $rt, sinon 0 |
lw $rt, C($rs) | I | $rt ← RAM[$rs + C] |
sw $rt, C($rs) | I | RAM[$rs + C] ← $rt |
addi $rt, $rs, C | I | $rt ← $rs + C (pas de subi : addi $rt, $rs, -C) |
andi / ori $rt, $rs, C | I | ET / OU avec une constante |
slti $rt, $rs, C | I | $rt ← 1 si $rs < C, sinon 0 |
beq / bne $rs, $rt, Etiq | I | Saut si égaux / différents : PC ← PC + 4 + 4 × imm16 |
j Etiq | J | PC ← (PC+4)[31:28] ‖ instr_index ‖ 00 |
if … else
# if (r < 0) r = 0; else r = r + 1; (r dans $t0)
bge $t0, $zero, Sinon # si r >= 0
move $t0, $zero # r = 0
j Suite # sauter le else
Sinon: addi $t0, $t0, 1 # r = r + 1
Suite:
Boucle for
# for (i = 0; i < n; i++) { ... } (i : $t0, n : $t1, test : $t2)
add $t0, $zero, $zero # i = 0
Pour: slt $t2, $t0, $t1 # $t2 = 1 si i < n
beq $t2, $zero, Suite # sinon sortir
... # corps
addi $t0, $t0, 1 # i++
j Pour
Suite:
Structure d'un fichier .asm
.data # segment de données
msg: .asciiz "Hello, world!\n"
.text # segment de code
.globl _start
_start: li $v0, 4 # service 4 : print_string
la $a0, msg # $a0 = adresse de msg
syscall
li $v0, 10 # service 10 : exit
syscall
En mémoire, un mot est rangé en petit-boutiste : l'octet de poids faible d'abord (14 = 0x0000000E → 0E 00 00 00).