BUT INFO · S12 · IUT ROBERT SCHUMAN

Architecture des ordinateurs

Le cours, chapitre par chapitre

Synthèse des CM0, CM1 et CM2. Les encadrés orange sont les points qui tombent le plus souvent en QCM. Évaluations : CC1 QCM (coef. 0,25), CC2 QCM (coef. 0,35), CC3 TP noté (coef. 0,40).

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.

NiveauCouchePassage vers le niveau inférieur
5Langages d'application (C, Java…)Compilation
4Langage d'assemblageAssembleur
3Système d'exploitationAppels système
2Jeu d'instructions (ISA), propre à chaque machineMicro-programmes
1Micro-architecture (UAL, registres…)Matériel
0Logique 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.

BusSensTransporte
AdressesUnidirectionnel (simplex)Les adresses des cases mémoire visées par le CPU
DonnéesBidirectionnel (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.
RegistreContient
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'étatQuelques 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émoireAccèsVolatileTempsUsage
SRAML/ÉOui≈ 10 nsCaches ; plus chère
DRAML/ÉOui≈ 60 nsMémoire centrale (DIMM) ; peu coûteuse
ROMLectureNon≈ 150 nsBIOS ; quelques centaines de Ko
MasseL/ÉNonlenteDisque 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.

  1. Compilation : C → assembleur.
  2. Assemblage : code binaire, calcul des adresses, résolution des étiquettes.
  3. 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.

@InstructionEffet
36lw $t0, 20($zero)$t0 ← 7 (y)
40lw $t1, 24($zero)$t1 ← 10 (x)
44add $t2, $t0, $t1$t2 ← 17
48sw $t2, 16($zero)RAM[16] ← 17 (z)
CM2 · 3

Segments mémoire et pile

SegmentContenuRepère
.textInstructions 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.

Format R (Register) — add, sub, and, or, slt
opcode=06rs5rt5rd5shamt5funct6
Format I (Immediate) — addi, andi, ori, slti, lw, sw, beq, bne
opcode6rs5rt5immédiat16
Format J (Jump) — j
opcode6instr_index = adresse ÷ 426
NomN°Rôle
$zero0Constante 0
$at1Réservé à l'assembleur
$v0–$v12–3Valeurs de retour
$a0–$a34–7Arguments
$t0–$t78–15Temporaires (sauvés par l'appelant)
$s0–$s716–23Sauvegardés (sauvés par l'appelé)
$t8–$t924–25Temporaires
$k0–$k126–27Réservés OS
$gp · $sp · $fp · $ra28 · 29 · 30 · 31Global, 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

InstructionFmtEffet
add $rd, $rs, $rtR$rd ← $rs + $rt (détecte l'overflow ; addu non)
sub $rd, $rs, $rtR$rd ← $rs − $rt (subu sans overflow)
and / or $rd, $rs, $rtRET / OU bit à bit
slt $rd, $rs, $rtR$rd ← 1 si $rs < $rt, sinon 0
lw $rt, C($rs)I$rt ← RAM[$rs + C]
sw $rt, C($rs)IRAM[$rs + C] ← $rt
addi $rt, $rs, CI$rt ← $rs + C (pas de subi : addi $rt, $rs, -C)
andi / ori $rt, $rs, CIET / OU avec une constante
slti $rt, $rs, CI$rt ← 1 si $rs < C, sinon 0
beq / bne $rs, $rt, EtiqISaut si égaux / différents : PC ← PC + 4 + 4 × imm16
j EtiqJPC ← (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).

Simulateur : z = x + y, cycle par cycle

L'exemple du CM2, déroulé comme sur les transparents : ce qui change à chaque étape est surligné en orange. Modifiez x et y pour refaire l'exercice avec d'autres valeurs.

DÉPART

CPU

UNITÉ DE COMMANDE
PC
RI
Décodeur
UNITÉ DE TRAITEMENT
UAL
$t0
$t1
$t2
INTERFACE MÉMOIRE
RA (registre adresse)
RD (registre de données)
BUS D'ADRESSES
CPU → RAM
BUS DE DONNÉES
CPU ↔ RAM
BUS DE COMMANDES
CPU ↔ RAM

Mémoire (RAM)

@Contenu

Encodeur / décodeur MIPS32

Tapez une instruction pour voir ses champs en binaire et son code hexadécimal, ou collez un code hexadécimal pour retrouver l'instruction. Instructions reconnues : add, addu, sub, subu, and, or, slt, addi, addiu, andi, ori, slti, lw, sw, beq, bne, j.

Pour beq/bne, le 3e opérande est le décalage imm16 (en instructions). Pour j, donnez l'adresse cible en octets (multiple de 4).

Entraînement

Encodez l'instruction tirée au hasard, puis vérifiez.

Calculs : bus, mémoire, unités

Les trois calculs du CM1, avec le détail des étapes à recopier sur la copie.

Débit d'un bus

Capacité d'une mémoire

Conversion d'unités

UnitéValeur

Fréquence d'horloge

Flashcards

Cliquez sur la carte (ou Espace) pour la retourner. Classez-la ensuite : les cartes « À revoir » reviennent dans le paquet.

QCM d'entraînement

Format proche des CC sur Moodle : une seule bonne réponse, correction immédiate et explication.