Exploring Computer Organisation and Architecture

# Exploring Computer Organisation and Architecture ## Objectifs et prérequis **Objectifs** : À la fin de ce chapitre, l'étudiant sera capable de : - Expliquer les concepts fondamentaux de l'organisation et de l'architecture des ordinateurs. - Décrire les composants principaux d'un processeur et leur rôle dans le cycle machine. - Analyser les architectures avancées de processeurs (pipelining, superscalaire, multi-cœur). - Expliquer les mécanismes de communication système, de synchronisation et de timing. - Différencier les interruptions, le polling et le traitement parallèle. - Interpréter et écrire des instructions assembleur avec différents modes d'adressage. - Appliquer ces connaissances dans une activité d'intégration pratique. **Prérequis** : Connaissances de base en systèmes numériques (binaire, hexadécimal), logique booléenne, et notions introductives en algorithmique et programmation (quelconque langage de haut niveau). --- ## I. Introduction to Computer Organisation and Architecture – Part 1 L'organisation d'un ordinateur fait référence à la manière dont ses composants matériels sont interconnectés et fonctionnent ensemble pour exécuter des instructions. L'architecture, quant à elle, définit l'ensemble des caractéristiques visibles par le programmeur : jeu d'instructions, formats de données, modes d'adressage, etc. > **À retenir** : L'organisation concerne *comment* les choses sont faites (implémentation matérielle), tandis que l'architecture concerne *quoi* est fait (spécification fonctionnelle vue par le logiciel). Un ordinateur typique suit le modèle de von Neumann : une unité centrale de traitement (CPU), une mémoire principale (RAM), des périphériques d'entrée/sortie (E/S), et un bus système qui les relie. Le CPU exécute des instructions stockées en mémoire en suivant un cycle séquentiel : fetch, decode, execute. Le bus système est composé de trois parties : - **Bus d'adresse** : transmet l'adresse de la mémoire ou du périphérique à accéder. - **Bus de données** : transmet les données réelles entre le CPU, la mémoire et les E/S. - **Bus de contrôle** : transmet les signaux de commande (lecture/écriture, interruption, horloge). > **À retenir** : La largeur du bus d'adresse détermine l'espace mémoire adressable : $2^n$ adresses pour un bus de $n$ bits. Par exemple, un bus de 20 bits permet d'adresser $2^{20} = 1\,048\,576$ octets = 1 Mo. La fréquence d'horloge (mesurée en Hz) détermine le rythme auquel le CPU exécute des opérations. Un cycle d'horloge est le temps entre deux fronts successifs du signal d'horloge. Plus la fréquence est élevée, plus le CPU peut exécuter d'instructions par seconde (en théorie). **Exemple résolu** : Un processeur fonctionne à 3,2 GHz. Quelle est la durée d'un cycle d'horloge ? $$ T = \frac{1}{f} = \frac{1}{3,2 \times 10^9} = 0,3125 \times 10^{-9} \text{ s} = 0,3125 \text{ ns} $$ Donc, un cycle d'horloge dure 0,3125 nanosecondes. **Exercice d'application** : Un système utilise un bus d'adresse de 24 bits. Quelle est la taille maximale de la mémoire adressable en mégaoctets (Mo) ? **Correction** : Nombre d'adresses = $2^{24} = 16\,777\,216$ Puisque chaque adresse pointe généralement vers un octet : Taille = $16\,777\,216$ octets = $\frac{16\,777\,216}{1024^2} = 16$ Mo **Réponse** : 16 Mo. --- ## II. Introduction to Computer Organisation and Architecture – Part 2 Les performances d'un système informatique dépendent de plusieurs facteurs : la fréquence d'horloge, le nombre d'instructions exécutées par cycle (IPC), l'efficacité de la mémoire cache, et l'architecture du processeur. Le temps d'exécution d'un programme se calcule comme suit : $$ \text{Temps d'exécution} = \frac{\text{Nombre d'instructions} \times \text{CPI}}{\text{Fréquence d'horloge}} $$ où CPI (Cycles Per Instruction) est le nombre moyen de cycles d'horloge nécessaires pour exécuter une instruction. > **À retenir** : Réduire le CPI ou augmenter la fréquence d'horloge diminue le temps d'exécution, mais augmenter la fréquence peut augmenter la consommation d'énergie et la chaleur dégagée (loi de l'alimentation dynamique : $P \propto C V^2 f$). La mémoire cache est une petite mémoire rapide située près du CPU qui stocke copie des données et instructions fréquemment utilisées. Elle réduit le temps d'accès à la mémoire principale (RAM), qui est beaucoup plus lente. Les niveaux de cache sont généralement L1 (le plus rapide, intégré au noyau), L2 (plus grand, parfois partagé), et L3 (encore plus grand, souvent partagé entre tous les cœurs). L'accès au L1 prend typiquement 1 à 4 cycles, au L2 10 à 20 cycles, et au L3 20 à 40 cycles, contre 100+ cycles pour la RAM. **Exemple résolu** : Un programme exécute 2 millions d'instructions. Son CPI moyen est de 1,5. Le processeur tourne à 2,5 GHz. Quel est le temps d'exécution ? $$ \text{Temps} = \frac{2 \times 10^6 \times 1,5}{2,5 \times 10^9} = \frac{3 \times 10^6}{2,5 \times 10^9} = 1,2 \times 10^{-3} \text{ s} = 1,2 \text{ ms} $$ **Réponse** : 1,2 milliseconde. **Exercice d'application** : Deux processeurs A et B exécutent le même programme. A a une fréquence de 3,0 GHz et un CPI de 2,0. B a une fréquence de 2,4 GHz et un CPI de 1,2. Lequel est plus rapide ? **Correction** : Temps A = $\frac{I \times 2,0}{3,0 \times 10^9}$ Temps B = $\frac{I \times 1,2}{2,4 \times 10^9} = \frac{I \times 0,5}{1,0 \times 10^9}$ Rapport Temps A / Temps B = $\frac{2,0 / 3,0}{1,2 / 2,4} = \frac{0,666}{0,5} = 1,333$ Donc A est 1,33 fois plus lent que B → **B est plus rapide**. **Réponse** : Le processeur B est plus rapide. --- ## III. Advanced Processor Architectures – Part 1 Pour dépasser les limites du traitement séquentiel, les architectures modernes utilisent le **pipelining** (pipelining). Cette technique divise l'exécution d'une instruction en plusieurs étapes (étapes de pipeline), permettant de traiter plusieurs instructions simultanément, chacune à une étape différente. Un pipeline classique comporte 5 étapes : 1. **IF** (Instruction Fetch) : lecture de l'instruction depuis la mémoire. 2. **ID** (Instruction Decode) : décodage et lecture des registres. 3. **EX** (Execute) : exécution de l'opération (ALU). 4. **MEM** (Memory Access) : accès à la mémoire si nécessaire (charge/store). 5. **WB** (Write Back) : écriture du résultat dans un registre. > **À retenir** : Dans un pipeline idéal de $k$ étapes, après un délai d'initialisation de $k$ cycles, une instruction est terminée à chaque cycle d'horloge. Le débit théorique devient 1 instruction par cycle (IPC = 1), contre moins de 1 sans pipeline. Cependant, des **risques** (hazards) peuvent interrompre ce flot : - **Risque de structure** : deux instructions nécessitent le même ressource matérielle en même temps (ex : un seul port mémoire). - **Risque de données** : une instruction dépend du résultat d'une précédente encore en pipeline (ex : $R1 \leftarrow R2 + R3$ suivi de $R4 \leftarrow R1 + R5$). - **Risque de contrôle** : causé par un branchement (jump/branch), où la prochaine instruction à fetch est inconnue jusqu'à la résolution du branchement. Pour gérer les risques de données, on utilise : - **Transfert de données (forwarding/bypassing)** : envoyer directement le résultat d'une étape EX vers l'entrée ALU d'une instruction suivante. - **Interblocage (stalling)** : insérer des cycles d'attente (nop) si le forwarding n'est pas possible (ex : charge suivie immédiatement d'utilisation). > **À retenir** : Le forwarding réduit fortement les stalls dus aux risques de données, mais ne les élimine pas entièrement (ex : charge-use hazard nécessite souvent un stall d'un cycle). **Exemple résolu** : Considérons le séquence d'instructions : ``` LW R1, 0(R2) ; charge mot depuis mémoire ADD R3, R1, R4 ; R3 = R1 + R4 ``` Sans forwarding, le ADD doit attendre que le LW termine WB. Avec un pipeline de 5 étapes, cela causerait un stall de 1 cycle après le LW. Avec forwarding depuis MEM vers EX, le résultat du LW est disponible à la fin de l'étape MEM, donc le ADD peut l'utiliser en EX sans stall. **Exercice d'application** : Dans un pipeline de 5 étapes, une séquence de 10 instructions est exécutée. S'il y a 2 stalls dus à des risques de données, quel est le nombre total de cycles d'horloge utilisés ? **Correction** : Sans stall : cycles = $5 + (10 - 1) = 14$ (k + n - 1) Avec 2 stalls : $14 + 2 = 16$ **Réponse** : 16 cycles. --- ## IV. Advanced Processor Architectures – Part 2 Pour aller au-delà du pipelining scalaire (une instruction par cycle), les architectures **superscalaires** permettent d'émettre et d'exécuter plusieurs instructions en parallèle dans un même cycle d'horloge, grâce à plusieurs unités fonctionnelles (ALU, FPU, ports mémoire, etc.). > **À retenir** : Un processeur superscalaire de largeur $n$ peut émettre jusqu'à $n$ instructions par cycle. Son IPC théorique peut dépasser 1 (jusqu'à $n$ en idéal). Cependant, l'émission multiple dépend de la disponibilité des ressources et de l'absence de risques. Le **planificateur d'émission** (issue unit) vérifie les dépendances et les ressources libres avant d'émettre des instructions. Une autre avancée est le **processing parallèle à plusieurs cœurs (multi-core)** : un seul die contient plusieurs noyaux de traitement indépendants, chacun avec son propre pipeline, ses caches L1/L2, partageant parfois un cache L3 et le bus système. > **À retenir** : Le multi-core permet une amélioration réelle des performances pour les tâches parallélisables (loi d'Amdahl), contrairement au simple aumento de fréquence qui rencontre des limites physiques (puissance, chaleur). La loi d'Amdahl donne l'accélération maximale possible grâce à la parallélisation : $$ \text{Accélération} = \frac{1}{(1 - p) + \frac{p}{n}} $$ où $p$ est la fraction du programme pouvant être parallélisée, et $n$ est le nombre de cœurs. **Exemple résolu** : Un programme est parallélisable à 80 %. Quelle est l'accélération maximale avec 4 cœurs ? $$ \text{Accélération} = \frac{1}{(1 - 0,8) + \frac{0,8}{4}} = \frac{1}{0,2 + 0,2} = \frac{1}{0,4} = 2,5 $$ **Réponse** : Accélération maximale de 2,5 fois. **Exercice d'application** : Un processeur dual-core exécute une tâche où 60 % du code est parallélisable. Quelle est l'accélération théorique ? **Correction** : $$ \text{Accélération} = \frac{1}{(1 - 0,6) + \frac{0,6}{2}} = \frac{1}{0,4 + 0,3} = \frac{1}{0,7} \approx 1,428 $$ **Réponse** : Environ 1,43 fois plus rapide qu'un seul cœur. --- ## V. System Communication and Timing La communication entre le CPU, la mémoire et les périphériques d'entrée/sortie (E/S) se fait via le **bus système**. Ce bus doit gérer des vitesses très différentes : le CPU est rapide, la mémoire moyenne, les E/S lentes. Pour éviter que le CPU ne soit bloqué par des périphériques lents, on utilise des **techniques de tamponnage (buffering)** et de **transfert direct en mémoire (DMA - Direct Memory Access)**. > **À retenir** : Le DMA permet à un périphérique (ex : carte réseau, disque dur) de lire/écrire directement dans la mémoire principale sans intervention du CPU, libérant ce dernier pour d'autres tâches. Lorsqu'un périphérique DMA veut utiliser le bus, il envoie une requête de bus (BUS REQUEST). Le contrôleur de bus (souvent intégré au northbridge ou au CPU) lui accorde l'accès en désactivant temporairement le CPU (bus grant). Le périphérique effectue alors son transfert, puis libère le bus. Le **timing** est crucial : les signaux sur le bus doivent respecter des temps de setup et de hold pour être correctement échantillonnés par l'horloge. Des retards de propagation dans les fils peuvent causer des problèmes de synchronisation à haute fréquence. Les bus modernes utilisent souvent des protocoles synchrones ou semi-synchrones avec des signaux de strobe (ex : strobe d'adresse, strobe de données) pour améliorer la fiabilité. **Exemple résolu** : Un transfert DMA de 4 Ko (4096 octets) se fait à une vitesse de 100 Mo/s. Quelle est la durée du transfert ? $$ \text{Temps} = \frac{4096}{100 \times 10^6} = 4,096 \times 10^{-5} \text{ s} = 40,96 \ \mu s $$ **Réponse** : 40,96 microsecondes. **Exercice d'application** : Un périphérique E/S génère une interruption toutes les 5 ms. Le CPU tourne à 2 GHz. Combien de cycles d'horloge s'écoulent entre deux interruptions ? **Correction** : Période = 5 ms = $5 \times 10^{-3}$ s Cycles = $2 \times 10^9 \times 5 \times 10^{-3} = 10 \times 10^6 = 10\,000\,000$ **Réponse** : 10 millions de cycles. --- ## VI. The Processor, Its Components and the machine cycle Le processeur (CPU) est composé de plusieurs unités fonctionnelles clés : - **Unité de contrôle (CU)** : génère les signaux de contrôle qui dirigent les opérations (basés sur l'instruction en cours). - **Unité arithmétique et logique (ALU)** : effectue les opérations arithmétiques (addition, soustraction) et logiques (ET, OU, NON, décalage). - **Registres** : petites mémoires rapides à l'intérieur du CPU utilisées pour stocker des opérandes, des adresses, ou des états (ex : accumulateur, compteur de programme PC, registre d'instruction IR). - **Bus internes** : relient les composants du CPU (registres, ALU, CU). > **À retenir** : Le compteur de programme (PC) contient l'adresse de la prochaine instruction à exécuter. Il est généralement incrémenté après chaque fetch, sauf en cas de branchement. Le **cycle machine** est la séquence de base que le CPU répète indéfiniment pour exécuter des instructions : 1. **Fetch** : lire l'instruction depuis la mémoire à l'adresse indiquée par PC, puis incrémenter PC. 2. **Decode** : décoder l'instruction dans l'IR, déterminer l'opcode et les opérandes. 3. **Execute** : effectuer l'opération spécifiée (ALU, accès mémoire, branchement, etc.). Certaines architectures ajoutent des étapes explicites pour l'accès mémoire ou l'écriture de résultat, mais le cycle fetch-decode-execute reste le noyau. > **À retenir** : La durée d'un cycle machine dépend de l'instruction : certaines prennent un cycle (ex : addition registre-registre), d'autres plusieurs (ex : charge mémoire, multiplication). **Exemple résolu** : Supposons qu'une instruction ADD prend 1 cycle, une LOAD prend 3 cycles (fetch, decode, adresse calcul, accès mémoire, write back), et une MULT prend 4 cycles. Quelle est la durée moyenne du cycle machine si 50 % des instructions sont ADD, 30 % LOAD, et 20 % MULT ? $$ \text{CPI moyen} = (0,5 \times 1) + (0,3 \times 3) + (0,2 \times 4) = 0,5 + 0,9 + 0,8 = 2,2 $$ **Réponse** : CPI moyen = 2,2 cycles par instruction. **Exercice d'application** : Dans un système, le PC vaut 0x1000. Après le fetch d'une instruction de 4 octets située à cette adresse, quelle est la nouvelle valeur du PC ? **Correction** : PC initial = 0x1000 Taille instruction = 4 octets = 0x4 Nouveau PC = 0x1000 + 0x4 = 0x1004 **Réponse** : 0x1004. --- ## VII. Interrupts, Polling and Parallel Processing Lorsque un périphérique a besoin d'attention (ex : frappe de touche, arrivée de paquet réseau), il peut signaler cela au CPU de deux manières principales : **polling** ou **interruption**. Dans le **polling**, le CPU vérifie périodiquement l'état du périphérique en lisant un registre de statut. Cette méthode est simple mais gaspille des cycles si le périphérique est rarement actif. > **À retenir** : Le polling convient aux périphériques rapides ou fréquemment actifs ; l'interruption est préférable pour les périphériques lents ou sporadiques. Dans le modèle d'**interruption**, le périphérique envoie un signal d'interruption au CPU via une ligne dédiée. Le CPU termine l'instruction en cours, sauvegarde son état (PC, registres), puis exécute une **routine de service d'interruption (ISR)**. Après l'ISR, il restaure l'état et reprend l'exécution normale. > **À retenir** : Les interruptions peuvent être masquables (peut être ignorée si le drapeau d'interruption est désactivé) ou non masquables (NMI, utilisée pour les événements critiques comme une panne de puissance). Le **traitement parallèle** implique l'exécution simultanée de plusieurs tâches. Cela peut se faire au niveau : - **Instructionnel** (pipelining, superscalaire), - **De tâche** (multi-threading, multi-core), - **De processus** (systèmes d'exploitation multi-tâches). La **cohérence de cache** devient critique en multi-core : si deux cœurs modifient des copies de la même variable en cache, ils peuvent voir des valeurs incohérentes. Des protocoles comme MESI (Modified, Exclusive, Shared, Invalid) assurent la cohérence. **Exemple résolu** : Un périphérique génère une interruption toutes les 10 ms. Le CPU exécute une instruction toutes les 50 ns en moyenne. Combien d'instructions sont exécutées entre deux interruptions ? **Correction** : Temps entre interruptions = 10 ms = $10 \times 10^{-2}$ s = 0,01 s Temps par instruction = 50 ns = $50 \times 10^{-9}$ s Nombre d'instructions = $\frac{0,01}{50 \times 10^{-9}} = \frac{0,01}{5 \times 10^{-8}} = 0,2 \times 10^6 = 200\,000$ **Réponse** : 200 000 instructions. **Exercice d'application** : Comparer le polling et l'interruption pour un clavier qui génère une frappe toutes les 2 secondes en moyenne. Le CPU tourne à 1 GHz. Chaque vérification de polling prend 100 ns. Quelle méthode consomme moins de CPU ? **Correction** : - Polling : si vérifié toutes les 1 ms (pour réactivité), alors en 2 s : $2000$ vérifications. Temps perdu = $2000 \times 100 \text{ ns} = 200\,000 \text{ ns} = 0,2 \text{ ms}$ sur 2 s → taux d'utilisation = $0,2 / 2000 = 0,01\%$ - Interruption : une seule interruption toutes les 2 s. Temps pour sauvegarder état, exécuter ISR, restaurer ≈ 10 µs (estimation). Temps perdu = $10 \mu s = 0,01 \text{ ms}$ sur 2 s → taux = $0,01 / 2000 = 0,005\%$ **Réponse** : L'interruption consomme moins de CPU (0,005 % vs 0,01 %). --- ## VIII. Assembly Instructions and Addressing Modes Le langage assembleur est une représentation lisible par l'humain des instructions machine. Chaque instruction correspond à une opération de bas niveau exécutée par le CPU. Une instruction assembleur typique a la forme : ``` [étiquette:] mnémonique [opérandes] [; commentaire] ``` Exemple : `ADD R1, R2, R3` signifie : R1 ← R2 + R3. Les **modes d'adressage** spécifient comment déterminer l'opérande effectif (adresse ou valeur réelle utilisée par l'instruction). Les principaux sont : 1. **Adressage immédiat** : l'opérande est une constante contenue dans l'instruction même. Exemple : `MOV R5, #10` → R5 ← 10 Syntaxe : `#valeur` 2. **Adressage direct** : l'opérande est l'adresse mémoire où se trouve la donnée. Exemple : `LOAD R3, 0x2000` → R3 ← M[0x2000] Syntaxe : `adresse` 3. **Adressage indirect** : l'instruction contient un registre qui pointe vers l'adresse mémoire de l'opérande. Exemple : `LOAD R2, (R4)` → R2 ← M[R4] Syntaxe : `(registre)` ou `*registre` 4. **Adressage basé** : l'adresse effective = contenu d'un registre de base + déplacement immédiat. Exemple : `LOAD R1, 0x10(R5)` → R1 ← M[R5 + 0x10] Syntaxe : `déplacement(registre)` 5. **Adressage indexé** : similaire au basé, mais souvent utilisé avec un registre d'index pour les tableaux. Exemple : `LOAD R3, (R6, R7)` → R3 ← M[R6 + R7] Syntaxe : `(base, index)` > **À retenir** : Le choix du mode d'adressage affecte la flexibilité, la longueur de l'instruction, et le nombre de cycles nécessaires (ex : adressage immédiat est rapide, indirect peut nécessiter un accès mémoire supplémentaire). **Exemple résolu** : Écrire l'instruction assembleur pour charger dans R3 la valeur stockée à l'adresse contenue dans R5 plus 12. **Correction** : Adressage basé : déplacement = 12, registre de base = R5 Syntaxe : `LOAD R3, 12(R5)` **Réponse** : `LOAD R3, 12(R5)` **Exercice d'application** : Donnez l'effet de l'instruction suivante : `ADD R4, R1, #7` en mode adressage immédiat. **Correction** : R4 ← R1 + 7 **Réponse** : R4 reçoit la somme de R1 et de la constante 7. --- ## IX. Integration Activity Cette activité vise à intégrer les concepts du chapitre dans un contexte pratique. L'étudiant doit analyser un petit système embarqué (ex : une carte de développement avec un processeur simple) et répondre à des questions sur son organisation, son architecture, et son fonctionnement. **Scénario** : Un microcontrôleur possède : - Un bus d'adresse de 16 bits, - Un bus de données de 8 bits, - Un processeur à pipeline de 3 étapes (fetch, decode, execute), - Une fréquence d'horloge de 8 MHz, - Une mémoire ROM de 4 Ko et une RAM de 1 Ko, - Un périphérique UART (communication série) accessible via adressage mémoire à l'adresse 0xFF00. **Questions** : 1. Quelle est la taille totale de l'espace mémoire adressable par ce microcontrôleur ? **Correction** : Bus d'adresse = 16 bits → $2^{16} = 65\,536$ octets = 64 Ko **Réponse** : 64 Ko. 2. Quelle fraction de l'espace mémoire est occupée par la ROM (4 Ko) ? **Correction** : $\frac{4}{64} = \frac{1}{16} = 0,0625$ → 6,25 % **Réponse** : 6,25 %. 3. Si une instruction prend en moyenne 2,5 cycles d'horloge, combien d'instructions peuvent être exécutées par seconde ? **Correction** : Fréquence = 8 MHz = $8 \times 10^6$ Hz Instructions par seconde = $\frac{8 \times 10^6}{2,5} = 3,2 \times 10^6$ = 3,2 MIPS **Réponse** : 3,2 millions d'instructions par seconde (3,2 MIPS). 4. Pour lire un octet depuis l'UART à l'adresse 0xFF00, quel mode d'adressage serait le plus approprié si l'adresse est connue à l'avance ? **Correction** : Adresse fixe connue → adressage direct **Réponse** : Adressage direct (ex : `LOAD R0, 0xFF00`). 5. Dessinez schématiquement le chemin des données lors d'une instruction de type `ADD R1, R2, R3` dans ce processeur à 3 étapes. **Correction** : - **Fetch** : l'instruction est lue depuis la mémoire via le bus d'adresse et données, stockée dans IR. - **Decode** : l'ALU est configurée pour l'addition, les registres R2 et R3 sont lus. - **Execute** : l'ALU calcule R2 + R3, le résultat est écrit dans R1. (Pas d'accès mémoire nécessaire pour cette instruction registre-registre). **Réponse** : Voir description ci-dessus. 6. Si le périphérique UART génère une interruption chaque fois qu'un octet est reçu, et qu'il reçoit 100 octets par seconde, quelle est la fraction de temps CPU utilisée par le traitement des interruptions, sachant que chaque ISR prend 20 µs ? **Correction** : Temps par interruption = 20 µs Nombre d'interruptions par seconde = 100 Temps total perdu par seconde = $100 \times 20 \times 10^{-6} = 2 \times 10^{-3}$ s = 2 ms Fraction = $\frac{0,002}{1} = 0,002$ = 0,2 % **Réponse** : 0,2 % du temps CPU est utilisé pour les interruptions. --- ## Synthèse du chapitre - L'organisation d'un ordinateur concerne l'implémentation matérielle des composants et leurs interconnexions (bus, CPU, mémoire, E/S). - L'architecture définit les caractéristiques visibles par le logiciel (jeu d'instructions, registres, modes d'adressage). - Le modèle de von Neumann sous-tend la plupart des ordinateurs : mémoire programme/données unique, bus système, cycle fetch-decode-execute. - Les performances dépendent de la fréquence d'horloge, du CPI, et de l'efficacité du pipeline et de la mémoire cache. - Le pipelining permet d'augmenter le débit d'instructions en découpant l'exécution en étapes, mais introduit des risques (structure, données, contrôle) gérés par forwarding et stalling. - Les architectures superscalaires émettent plusieurs instructions par cycle ; le multi-core permet le traitement parallèle réel. - La loi d'Amdahl quantifie l'accélération limitée par la partie séquentielle d'un programme. - Le DMA permet aux périphériques d'accéder directement à la mémoire sans intervention du CPU, améliorant l'efficacité. - Le polling vérifie périodiquement l'état des périphériques ; l'interruption permet une réaction asynchrone avec moins de gaspillage de CPU. - Le cycle machine de base est fetch-decode-execute, réalisé par l'ALU, l'unité de contrôle, et les registres (PC, IR). - Les modes d'adressage (immédiat, direct, indirect, basé, indexé) déterminent comment les opérandes sont spécifiés en langage assembleur. - Une activité d'intégration permet d'appliquer ces concepts à un système concret (microcontrôleur) pour analyser l'adressage, les performances, et l'E/S. --- ## Glossaire > **À retenir** : Chaque terme ci-dessous est défini avec précision pour une utilisation dans le contexte de l'organisation et de l'architecture des ordinateurs. - **Bus d'adresse** : ensemble de lignes qui transmet l'adresse de la mémoire ou du périphérique à accéder lors d'une opération de lecture ou d'écriture. - **Bus de données** : ensemble de lignes qui transmet les données réelles entre le CPU, la mémoire, et les périphériques d'entrée/sortie. - **Bus de contrôle** : ensemble de lignes qui transmet les signaux de commande (lecture/écriture, interruption, demande de bus) pour synchroniser les opérations. - **CPI (Cycles Per Instruction)** : nombre moyen de cycles d'horloge nécessaires pour exécuter une instruction ; indicateur clé d'efficacité du processeur. - **Pipeline** : technique qui décompose l'exécution d'une instruction en plusieurs étapes séquentielles permettant le traitement parallèle de plusieurs instructions. - **Forwarding (bypassing)** : mécanisme qui permet de transmettre directement le résultat d'une instruction en cours d'exécution à une instruction suivante ayant besoin de cet opérande, réduisant les temps d'attente. - **DMA (Direct Memory Access)** : méthode permettant à un périphérique de transférer des données vers/from la mémoire principale sans intervention du CPU, libérant ce dernier pour d'autres tâches. - **Interruption** : signal matériel envoyé par un périphérique au CPU pour indiquer qu'il nécessite un service immédiat, provoquant l'exécution d'une routine de service d'interruption (ISR). - **Polling** : méthode où le CPU vérifie périodiquement l'état d'un périphérique en lisant son registre de statut pour déterminer s'il nécessite une action. - **Mode d'adressage immédiat** : mode où l'opérande est une constante incluse directement dans l'instruction machine (ex : `#5`). - **Multi-core** : architecture où un seul circuit intégré contient plusieurs noyaux de traitement indépendants permettant l'exécution parallèle de tâches. - **Loi d'Amdahl** : formule qui donne l'accélération maximale possible d'un système grâce à la parallélisation, limitée par la fraction séquentielle du programme.