Architecture des Ordinateurs 1

Principes clés – Von Neumann

• Mémoire unique pour les instructions ET les données (programme stocké).
• Bus unique pour le transfert instructions/données → goulot d'étranglement (Von Neumann bottleneck).
• Exécution séquentielle : fetch → decode → execute, cycle par cycle.
• 4 composants : UAL (calculs), Unité de Contrôle (séquencement), Mémoire, Entrées/Sorties.
• Avantage : simplicité, 1 seul espace d'adressage. Inconvénient : lenteur due au bus partagé.

Principes clés – Harvard

• Mémoires séparées : une pour les instructions, une pour les données.
• Bus séparés → accès simultané instructions + données → plus rapide.
• Permet le pipeline efficace : fetch d'instruction en parallèle avec l'accès données.
• Inconvénient : complexité matérielle, deux espaces d'adressage distincts.

Conversions rapides

Binaire → Décimal : $N = \sum b_i \cdot 2^i$. Ex : $1011_2 = 1\cdot8 + 0\cdot4 + 1\cdot2 + 1\cdot1 = 11_{10}$.

Décimal → Binaire : divisions successives par 2, lire les restes de bas en haut.

Binaire → Hexadécimal : grouper par 4 bits (de droite à gauche). $1011\,1100_2 = \text{BC}_{16}$.

Hexadécimal → Binaire : chaque chiffre hexa sur 4 bits. $\text{3F}_{16} = 0011\,1111_2$.

Le Complément à 2 (standard universel)

Sur $n$ bits, le complément à 2 d'un nombre $A$ est $2^n - A$. Méthode pratique :

1. Complémenter tous les bits (inverser 0↔1 = complément à 1).
2. Ajouter 1 au résultat.

Plage sur $n$ bits : $[-2^{n-1},\; 2^{n-1}-1]$. Exemple sur 8 bits : $[-128,\;+127]$.

Exemple : $-5$ sur 8 bits → $+5 = 0000\,0101_2$ → complément → $1111\,1010_2$ → $+1$ → $1111\,1011_2$.

Extension de signe : recopier le bit de poids fort (MSB) vers la gauche. $-5$ sur 16 bits : $1111\,1111\,1111\,1011_2$.

Format IEEE 754 – 32 bits (float)

Structure : 1 bit signe S | 8 bits exposant E (biaisé de +127) | 23 bits mantisse M (bit implicite 1).

$V = (-1)^S \times (1.M) \times 2^{E-127}$

Cas spéciaux : $E=0, M=0$ → $0$ ; $E=255, M=0$ → $\pm\infty$ ; $E=255, M\neq0$ → NaN.

Exemple : $-6.625_{10}$ → S=1, $6.625=110.101_2=1.10101\times2^2$ → $E=2+127=129=1000\,0001_2$, $M=10101\,00...0$. Résultat : $1\,1000\,0001\,1010\,1000\,...0$.

À connaître par cœur pour l'examen

• Idempotence : $A + A = A$, $A \cdot A = A$
• Complémentarité : $A + \overline{A} = 1$, $A \cdot \overline{A} = 0$
• Commutativité : $A+B = B+A$, $A\cdot B = B\cdot A$
• Associativité : $(A+B)+C = A+(B+C)$
• Distributivité : $A\cdot(B+C) = A\cdot B + A\cdot C$
• Absorption : $A + A\cdot B = A$
• De Morgan : $\overline{A+B} = \overline{A}\cdot\overline{B}$, $\overline{A\cdot B} = \overline{A}+\overline{B}$
• Éléments neutres : $A+0=A$, $A\cdot1=A$

Demi-additionneur – 2 entrées, 2 sorties

Somme $S = A \oplus B$ (XOR)  |  Retenue $C_{out} = A \cdot B$ (AND)

Full Adder – 3 entrées (A, B, C_in), 2 sorties

Somme : $S = A \oplus B \oplus C_{in}$

Retenue sortante : $C_{out} = A\cdot B + C_{in}\cdot(A \oplus B)$

Un additionneur $n$ bits se construit en chaînant $n$ full adders (carry ripple adder). Le temps de propagation est proportionnel à $n$ (délai de propagation de la retenue).

MUX $2^n$:1 – $2^n$ entrées de données, $n$ entrées de sélection, 1 sortie

Un multiplexeur sélectionne 1 entrée parmi $2^n$ selon les bits de sélection.

MUX 2:1 : $S = \overline{S_0}\cdot I_0 + S_0\cdot I_1$ (1 bit de sélection $S_0$).

MUX 4:1 : $S = \overline{S_1}\,\overline{S_0}\,I_0 + \overline{S_1}S_0\,I_1 + S_1\overline{S_0}\,I_2 + S_1S_0\,I_3$.

Application : un MUX $2^n$:1 peut implémenter n'importe quelle fonction logique de $n$ variables en connectant les entrées à 0 ou 1 selon la table de vérité.

Décodeur $n$ vers $2^n$ – $n$ entrées, $2^n$ sorties (une seule active à la fois)

Décodeur 2→4 : avec entrées $A_1,A_0$, sorties $D_0=\overline{A_1}\,\overline{A_0},\; D_1=\overline{A_1}A_0,\; D_2=A_1\overline{A_0},\; D_3=A_1A_0$.

Utilisation : sélection de périphériques (chip select), décodage d'adresses mémoire, implémentation de fonctions logiques (avec une porte OR sur les sorties).

Bascule RS (Reset-Set)

NOR-RS : $S=1$ → $Q=1$ (set). $R=1$ → $Q=0$ (reset). $R=S=0$ → mémorise. $R=S=1$ → interdit (état indéterminé).

Table caractéristique : $Q_{t+1} = S + \overline{R}\cdot Q_t$ (avec $R\cdot S=0$).

Bascule D (Data) – La plus utilisée en pratique

La bascule D recopie l'entrée D sur la sortie Q lors du front d'horloge (rising edge ou falling edge).

Équation : $Q_{t+1} = D$ (après le front d'horloge).

Avantage : élimine le problème RS ($S=R=1$ interdit). 1 seule entrée de données. Utilisée dans les registres et les compteurs synchrones.

Bascule JK – La plus polyvalente

La bascule JK résout le problème de l'état interdit RS : $J=K=1$ → basculement (toggle, $Q_{t+1} = \overline{Q_t}$).

Registre $n$ bits

Un registre est un ensemble de $n$ bascules D partageant la même horloge. Capacité de stockage = $n$ bits.

Registre à décalage (shift register) : à chaque front d'horloge, les bits sont décalés d'une position ($Q_i$ → $Q_{i+1}$). Utilisé pour la conversion série/parallèle et les multiplications/divisions par $2^n$.

Registre à chargement parallèle : charge $n$ bits simultanément via une entrée Load.

Compteurs synchrones et asynchrones

Compteur asynchrone (ripple) : chaque bascule est cadencée par la sortie de la précédente. Simple mais lent (délai cumulatif = $n \times t_{pd}$).

Compteur synchrone : toutes les bascules partagent la même horloge. Plus rapide, plus complexe.

Compteur modulo-N : cycle $0 \to 1 \to \dots \to N-1 \to 0$. Avec $k$ bascules, $N \leq 2^k$. Remise à zéro quand le compte atteint $N$ (décodeur + reset).

Comparaison SRAM / DRAM

• SRAM : 6 transistors par bit, très rapide (~1-10 ns), chère, utilise des bascules → cache processeur.
• DRAM : 1 transistor + 1 condensateur par bit, plus lente (~50-100 ns), bon marché, nécessite un rafraîchissement périodique (toutes les ~64 ms) → RAM principale.
• La DRAM est ~4× plus dense que la SRAM mais ~10× plus lente.

Composants du datapath

• UAL (ALU) : effectue les opérations arithmétiques (+, −, ×) et logiques (AND, OR, XOR, shifts).
• Banc de registres : stocke les opérandes et résultats intermédiaires (ex : 32 registres de 32 bits sur MIPS).
• Bus internes : transportent les données entre registres, UAL et mémoire.
• Registres spécialisés : PC (Program Counter), IR (Instruction Register), MAR (Memory Address Register), MDR (Memory Data Register).

Deux types d'implémentation

UC câblée (hardwired) : logique combinatoire fixe → rapide, mais non modifiable. Utilisée dans les processeurs RISC simples.

UC microprogrammée : séquence de micro-instructions stockée en ROM → flexible mais plus lente. Utilisée dans les processeurs CISC (x86).

Fetch → Decode → Execute (cycle von Neumann)

1. Fetch (recherche) : l'instruction pointée par PC est chargée depuis la mémoire dans IR. PC ← PC + 1 (ou +4 selon l'architecture).
2. Decode (décodage) : l'UC décode l'instruction → identifie le code opération (opcode), les opérandes, et active les signaux de contrôle.
3. Execute (exécution) : l'UAL effectue l'opération, lit/écrit les registres ou la mémoire selon l'instruction.
4. Write Back : le résultat est écrit dans le registre de destination (pour les instructions de type R sur MIPS).