Dossier complet — Architecture des ordinateurs

L1 · S1 · Informatique fondamentale

Dossier pédagogique original Matrice MI. Contenu d’entraînement non officiel; il ne remplace pas le support ou la maquette d’un établissement.

Objectifs d’apprentissage

• Convertir et interpréter des entiers non signés et signés entre les bases 2, 10 et 16, en justifiant le complément à deux et les limites de représentation.

• Décrire précisément le cycle recherche–décodage–exécution d’une instruction et suivre les échanges entre compteur ordinal, registres, unité arithmétique et mémoire.

• Relier une adresse, une cellule mémoire, un mot et une instruction simple dans un modèle de machine von Neumann, sans confondre valeur et emplacement.

• Comparer registres, caches, mémoire vive et stockage selon latence, capacité, coût et persistance, puis estimer un temps moyen d’accès avec un modèle donné.

• Lire une trace élémentaire d’assembleur ou de pseudo-assembleur, repérer les dépendances et communiquer l’exécution par un diagramme CPU–mémoire vérifiable.

Prérequis

• Savoir manipuler les entiers, les puissances de 2 et les conversions arithmétiques élémentaires.

• Comprendre les variables, affectations, conditions et boucles d’un langage de programmation introductif.

• Savoir lire un tableau, une chronologie et une formule simple, et distinguer une donnée de son adresse.

Cours

1. Représentation des nombres

Idée centrale

Un ordinateur manipule des suites de bits. En base 2, la position i porte le poids $2^i$ ; l’hexadécimal regroupe exactement quatre bits, ce qui rend les longues valeurs lisibles. Un entier non signé sur $n$ bits est compris entre $0$ et $2^n-1$. Pour les entiers signés, le complément à deux encode $-x$ par l’inversion des bits de $x$ puis l’ajout de 1 : sur 8 bits, $11111101_2$ vaut $253$ comme non signé, mais $-3$ comme signé. Cette dualité impose d’annoncer le type et la largeur. Erreur fréquente : ajouter un bit de signe à une écriture non signée sans recalculer la valeur.

Exemple guidé. Convertir $45_{10}$ : $45=32+8+4+1$, donc $00101101_2=2D_{16}$. Pour $-3$ sur 8 bits, $3=00000011$, inversion 11111100, ajout 1 : 11111101. En contrôlant, $253-256=-3$.

Point de contrôle : décoder 10110010 dans les deux conventions et justifier la différence.

Points-clés

• Une largeur de mot fixe borne l’intervalle représentable et doit être explicitée.
• Le complément à deux permet une addition binaire commune aux positifs et aux négatifs.
• Binaire, hexadécimal et décimal décrivent la même suite de bits, mais pas toujours le même type.

2. Processeur et cycle d’instruction

De l’adresse à l’action

Le processeur contient notamment un compteur ordinal (PC), un registre d’instruction (IR), des registres généraux, une unité arithmétique et logique (UAL), une unité de commande et des interfaces mémoire. Le cycle élémentaire est recherche, décodage, exécution : le PC fournit l’adresse, l’instruction est copiée dans l’IR, puis le PC avance (sauf branchement). Le décodage identifie l’opération et les modes d’adressage ; l’exécution lit ou écrit les opérandes et met éventuellement à jour les indicateurs. Un branchement conditionnel remplace le PC seulement si son test est vrai. Erreur fréquente : croire qu’une instruction LOAD calcule elle-même une adresse sans distinguer adresse effective et contenu lu.

Exemple guidé. État initial PC=100, mémoire[100]=LOAD R1,[200], mémoire[200]=37. Recherche : IR reçoit l’instruction et PC devient 101. Décodage : adresse effective 200. Exécution : R1 reçoit 37 ; PC reste 101.

Point de contrôle : dans une trace, annoter à chaque ligne la valeur du PC avant et après l’instruction, puis signaler tout saut.

Points-clés

• Le PC pointe la prochaine instruction, tandis que l’IR conserve celle qui est décodée.
• Une lecture mémoire transfère une valeur située à une adresse, ce ne sont pas des synonymes.
• Un branchement modifie le flot séquentiel et peut empêcher l’instruction suivante d’être exécutée.

3. Mémoire et hiérarchie

Exploiter la localité

La hiérarchie place près du processeur des mémoires petites et rapides : registres, cache, mémoire vive, puis stockage persistant. Un cache exploite la localité temporelle (réutiliser bientôt la même donnée) et spatiale (accéder aux adresses voisines). Avec un temps de succès $t_c$, une probabilité de défaut $p$ et un temps supplémentaire de mémoire $t_m$, un modèle simple donne $t_{moyen}=t_c+p\,t_m$ ; il faut annoncer si $t_m$ inclut ou non la recherche initiale. Erreur fréquente : multiplier par la probabilité de succès au lieu de pondérer succès et défaut, ou comparer des capacités sans parler de latence.

Exemple guidé. Si $t_c=2$ ns, $p=0{,}05$ et la pénalité de défaut vaut 80 ns, alors $t_{moyen}=2+0{,}05\times80=6$ ns. Avec $p=0{,}20$, il devient 18 ns : une hausse des défauts coûte davantage que quelques nanosecondes de cache.

Exemple d’application supplémentaire. En C, un tableau $128\times128$ d’entiers de 4 octets est rangé par lignes. Une ligne occupe $128\times4=512$ octets. Si une ligne de cache contient 64 octets, elle transporte 16 entiers consécutifs : parcourir une ligne complète provoque donc environ 8 défauts de cache à froid. Parcourir une colonne saute de 512 octets à chaque élément et touche jusqu’à 128 lignes différentes pour 128 valeurs. Sous ces hypothèses, le parcours ligne par ligne exploite beaucoup mieux la localité spatiale. L’ordre des boucles importe : faire varier l’indice de colonne à l’intérieur de la boucle intérieure respecte la disposition mémoire; inverser les boucles multiplie les accès éloignés. Les défauts réels dépendent aussi de l’associativité et de la taille du cache.

Point de contrôle : recalculer le temps pour $p=0{,}01$ et vérifier que le résultat reste entre le temps de succès et la pénalité ajoutée.

Points-clés

• La localité explique pourquoi un cache peut accélérer un programme malgré sa faible capacité.
• Un temps moyen dépend de la définition précise de la pénalité de défaut.
• Capacité, latence, débit et persistance sont des critères différents.

4. Mémoire, adresses et transferts

Organiser l’espace mémoire

Une mémoire adressable par octet associe une adresse à chaque octet ; un mot de 32 bits occupe alors quatre adresses consécutives. L’alignement peut accélérer les accès et certaines architectures refusent un mot mal aligné. L’endianness décrit l’ordre des octets en mémoire : en little-endian, l’octet de poids faible est placé à la plus petite adresse. Les bus transportent séparément ou logiquement adresses, données et commandes. Il faut distinguer la taille d’une adresse, qui limite l’espace adressable, de la taille d’un mot, qui influence les opérations. Erreur fréquente : lire 0x12345678 comme une valeur indépendante de l’ordre des octets.

Exemple guidé. Stocker 0x12345678 à l’adresse 1000 sur quatre octets en little-endian donne : mémoire[1000]=78, [1001]=56, [1002]=34, [1003]=12. La reconstruction inverse fournit bien 0x12345678.

Point de contrôle : écrire la disposition big-endian de la même valeur et préciser quelle convention est utilisée avant tout décodage.

Points-clés

• Adresse, octet, mot et valeur sont des notions distinctes à relier explicitement.
• L’endianness modifie l’ordre en mémoire, pas la valeur abstraite du nombre.
• La largeur d’adresse borne l’espace adressable, tandis que la largeur de mot concerne les données traitées.

5. Instructions, registres et trace d’exécution

Lire une petite machine

Un pseudo-assembleur rend visibles les transferts : LOAD R1,[A], ADD R1,R2, STORE [A],R1 et JNZ R1,label. Une instruction possède un opcode et des opérandes ; son mode peut être immédiat (#5), registre (R1) ou mémoire ([A]). Pour analyser un programme, construire un tableau PC–instruction–registres–mémoire évite les intuitions trompeuses. Une dépendance impose l’ordre : on ne peut pas utiliser le résultat d’une instruction avant son écriture. Erreur fréquente : confondre LOAD R1,[A] (lire mémoire) et LOAD R1,#A (charger l’adresse ou une constante selon le jeu d’instructions).

Exemple guidé. Avec A=4, B=7, exécuter LOAD R1,[A]; LOAD R2,[B]; ADD R1,R2; STORE [A],R1. Après les deux lectures, R1=4 et R2=7 ; l’addition donne R1=11 ; le stockage fixe A=11.

Point de contrôle : produire la trace complète et vérifier que B n’a jamais été modifié.

Points-clés

• Le mode d’adressage détermine si l’opérande est une constante, un registre ou une adresse mémoire.
• Une table d’état rend vérifiables les effets de chaque instruction.
• La trace doit séparer valeurs des registres, contenu mémoire et évolution du PC.

6. Pipeline, dépendances et aléas d’exécution

Cours magistral

Principe du pipeline

Un pipeline découpe le traitement d’une instruction en étapes séparées par des registres. Dans un modèle pédagogique à cinq étages, IF recherche l’instruction, ID la décode et lit les registres, EX réalise le calcul, MEM accède à la mémoire et WB écrit le résultat. Sans pipeline, une instruction monopolise les ressources pendant toute la durée des cinq étapes. Avec pipeline, plusieurs instructions avancent simultanément, à condition que chaque étape ait une ressource disponible. La latence d’une instruction reste approximativement la somme des étapes, tandis que le débit idéal devient une instruction par cycle après remplissage. Ce modèle suppose des étages équilibrés, des registres de pipeline fiables et un flot sans dépendance bloquante.

Un aléa structurel apparaît lorsque deux étapes réclament la même ressource au même cycle. Un aléa de données survient lorsqu’une instruction consomme une valeur qui n’est pas encore écrite. Pour une dépendance RAW (« Read After Write »), le processeur peut transmettre directement le résultat depuis EX vers l’entrée de l’étape suivante : c’est le forwarding. Si la valeur n’est pas encore disponible, il insère une bulle, c’est-à-dire un cycle où une étape reste en attente. Un aléa de contrôle vient d’un branchement dont la destination n’est pas encore connue ; les instructions spéculatives peuvent alors être annulées si le test est faux.

Exemple résolu

Considérons trois instructions sans conflit structurel : ADD R1,R2,R3, puis SUB R4,R1,R5, puis AND R6,R7,R8. SUB dépend de R1. Dans le pipeline à cinq étages, ADD entre en IF au cycle 1, ID au cycle 2 et EX au cycle 3. SUB entre en EX au cycle 4 : la valeur produite par ADD est transmise directement au stade EX. AND entre en EX au cycle 5. Avec ce forwarding, les trois instructions se terminent au cycle 7, soit $5+(3-1)$ cycles. Sans forwarding, SUB attend la disponibilité de R1 écrite par ADD en WB; selon la convention où WB écrit avant la lecture ID du même cycle, cette dépendance ajoute deux cycles. Le total atteint alors 9 cycles.

Erreurs fréquentes

Confondre débit et latence conduit à croire qu’une instruction isolée est cinq fois plus rapide. Il faut aussi préciser à quel moment une donnée devient disponible et ne pas appliquer le forwarding à une valeur encore produite par une lecture mémoire. Enfin, un branchement pris peut vider plusieurs étages : ignorer cette pénalité surestime le débit réel.

À retenir

Le pipeline améliore le débit, pas nécessairement la latence d’une instruction. Les dépendances et les ressources partagées déterminent les bulles ; forwarding, attente et prédiction de branchement sont des compromis d’architecture. Un diagramme cycle–étage rend chaque hypothèse contrôlable.

Points-clés

• Le pipeline chevauche les étapes et vise un débit proche d’une instruction par cycle.
• Les aléas RAW peuvent être résolus par forwarding ou par insertion de bulles.
• Les branchements introduisent un aléa de contrôle et une pénalité possible.
• Un diagramme cycle–étage distingue précisément latence, débit et attente.

7. Entrées-sorties, interruptions et accès direct mémoire

Cours magistral

Organiser les entrées-sorties

Un périphérique est plus lent et moins régulier que le processeur ; un contrôleur d’E/S sert donc d’interface. Il expose typiquement un registre de données, un registre d’état et un registre de commande. En scrutation, le processeur lit périodiquement l’état jusqu’à ce que le bit prêt soit positionné. Une interruption inverse l’initiative : le contrôleur signale un événement, le processeur sauvegarde un contexte minimal, exécute une routine de service, acquitte la cause puis reprend au point interrompu. Cette solution suppose que les interruptions soient masquables ou hiérarchisées et que la routine soit courte et réentrante lorsque c’est nécessaire.

Pour un gros bloc, le DMA (Direct Memory Access) permet au contrôleur de transférer directement les données entre périphérique et mémoire. Le processeur programme une adresse de départ, une longueur et une direction, puis le contrôleur demande l’accès au bus. À la fin, une interruption indique le succès ou l’erreur. Pendant le transfert, le processeur peut calculer, mais il faut traiter la cohérence du cache : une donnée modifiée dans le cache n’est pas forcément visible en mémoire, et une donnée reçue peut laisser une ancienne copie dans le cache. Les architectures proposent alors écriture différée, invalidation ou opérations de nettoyage explicites.

Exemple résolu

On veut transférer 4096 octets. En scrutation, supposons que le périphérique fournisse un octet toutes les 100 cycles et qu’un test d’état occupe le processeur pendant 20 cycles. En moyenne, cinq tests couvrent l’attente de chaque octet; sur 4096 octets, environ $4096\times100=409600$ cycles processeur sont occupés. Cette estimation inclut les tests et ne doit pas leur ajouter une seconde fois le même temps. Avec une interruption par octet, le transfert périphérique dure toujours 409600 cycles à ce débit, tandis que chaque routine d’interruption coûte 60 cycles au processeur : son occupation atteint $4096\times60=245760$ cycles. Avec DMA par blocs de 1024 octets, quatre programmations à 200 cycles et une interruption finale à 500 cycles donnent $4\times200+500=1300$ cycles de gestion processeur. Le transfert physique garde ses 409600 cycles, mais le processeur est libéré pendant l’essentiel de l’opération. Le résultat dépend de l’hypothèse que le contrôleur peut réellement prendre le bus sans bloquer le calcul.

Erreurs fréquentes

Une interruption ne transporte pas automatiquement la donnée : elle signale un événement et exige une lecture du registre ou du tampon. DMA ne signifie pas « sans protocole » : adresse, longueur, direction et état d’erreur doivent être définis. Enfin, comparer seulement le temps total oublie la charge processeur et la cohérence des caches.

À retenir

La scrutation privilégie la simplicité, l’interruption économise l’attente et le DMA réduit les copies et interventions pour les blocs. Le choix dépend du débit, de la taille des transferts, de la latence acceptable et des garanties de cohérence mémoire.

Points-clés

• Un contrôleur d’E/S sépare les registres de données, d’état et de commande.
• La scrutation occupe le processeur, tandis que l’interruption le réveille sur événement.
• Le DMA transfère des blocs avec une programmation initiale et un signal de fin.
• La cohérence cache–mémoire doit être explicitement assurée lors d’un DMA.

8. Mémoire virtuelle, pagination et traduction d’adresses

Cours magistral

Du cadre virtuel à la mémoire physique

La mémoire virtuelle donne à chaque processus un espace d’adresses privé, même si la mémoire vive est partagée. Dans une pagination simple, l’adresse virtuelle est découpée en numéro de page et déplacement. Si la taille de page vaut $2^p$ octets, les $p$ bits de poids faible forment le déplacement ; les bits restants désignent la page. Une table des pages associe chaque page virtuelle à un cadre physique et contient des bits de présence, de protection et parfois de modification. Cette traduction protège les processus : une page absente ou interdite déclenche une faute contrôlée plutôt qu’un accès silencieusement erroné.

La traduction à chaque accès mémoire coûterait un accès supplémentaire à la table. Un TLB (Translation Lookaside Buffer) mémorise donc quelques associations récentes. En cas de succès, la traduction est rapide ; en cas d’échec, la table des pages est consultée, puis l’entrée peut être installée dans le TLB. Si la page n’est pas présente, le système choisit un cadre libre ou une page à évincer, écrit éventuellement la page modifiée sur stockage, charge la nouvelle page et reprend l’instruction fautive. Cette procédure suppose que l’état des registres et la cause de la faute soient sauvegardés correctement.

Exemple résolu

Supposons des adresses virtuelles de 16 bits et des pages de 256 octets. Donc $p=8$ : les huit bits bas sont le déplacement et les huit bits hauts le numéro de page. Pour l’adresse 0x3A7C, le numéro de page est 0x3A et le déplacement 0x7C. Si la table associe la page 0x3A au cadre physique 0x12, l’adresse physique concatène 0x12 et 0x7C, soit 0x127C. Le déplacement reste inchangé : seule la page est relocalisée. Si l’entrée TLB est absente mais la page présente, on paie une consultation de table puis on réessaie. Si elle est absente, il faut en plus le chargement depuis le stockage.

Prenons un accès TLB de 1 ns, un taux d’absence TLB de 10 % avec consultation de table à 20 ns, et un taux de défaut de page de $10^{-4}$ avec surcoût supplémentaire de 5 ms. En ignorant le coût du second accès après remplissage, le coût moyen approché est $1+0{,}1\times20+10^{-4}\times5\,000\,000=5021$ ns, car $10^{-4}\times5$ ms vaut 500 ns. L’unité doit être uniformisée avant l’addition.

Erreurs fréquentes

Confondre page virtuelle et cadre physique annule la protection. Le déplacement ne change pas pendant la traduction. Il ne faut pas additionner des millisecondes à des nanosecondes sans conversion, ni conclure qu’un TLB supprime les défauts de page.

À retenir

La pagination sépare adresse virtuelle et emplacement physique. TLB, bits de protection et gestion des fautes transforment cette abstraction en mécanisme de performance et d’isolation.

Points-clés

• Une adresse paginée sépare numéro de page et déplacement intra-page.
• La table des pages traduit une page virtuelle en cadre physique et porte des protections.
• Le TLB accélère les traductions mais ne remplace pas la gestion des pages absentes.
• Les temps moyens exigent des unités homogènes et des hypothèses explicites.

9. Parallélisme, multicœur et loi d’accélération

Cours magistral

Exploiter plusieurs formes de parallélisme

Le parallélisme consiste à faire progresser plusieurs opérations dans un même intervalle. Le pipeline exploite le parallélisme d’instructions, tandis qu’un processeur multicœur exécute plusieurs fils sur des unités distinctes. Il faut distinguer latence d’une tâche et débit d’un ensemble de tâches. Doubler le nombre de cœurs ne double le temps d’exécution que si le travail est suffisamment indépendant, si la mémoire suit et si la synchronisation reste négligeable. Une instruction vectorielle peut aussi traiter plusieurs éléments, mais seulement si les données ont un même traitement et un format compatible.

La loi d’Amdahl borne l’accélération d’un programme lorsque seule une fraction est parallélisable. Si $s$ est la fraction séquentielle et $p$ le nombre de cœurs idéaux, alors $T(p)=T(1)\left(s+\frac{1-s}{p}\right)$ et $S(p)=\frac{1}{s+(1-s)/p}$. Les conditions sont importantes : mêmes données, même algorithme, absence de surcoût supplémentaire et partage parfait de la partie parallèle. Dans un système réel, les verrous, les communications, les défauts de cache et la charge mémoire ajoutent un terme de coût ; le résultat réel est donc inférieur à la borne idéale.

Exemple résolu

Un programme prend 100 ms sur un cœur. L’analyse mesure 25 % de partie séquentielle et 75 % parallélisable. Avec quatre cœurs idéaux, la formule donne $T(4)=100\left(0{,}25+0{,}75/4\right)=100\times0{,}4375=43{,}75$ ms. L’accélération vaut $100/43{,}75\approx2{,}29$, et non 4. Même avec un nombre infini de cœurs, le temps minimal serait $100\times0{,}25=25$ ms : l’accélération maximale est donc 4. Supposons maintenant 5 ms de synchronisation fixe par exécution parallèle ; le temps devient 48,75 ms et le gain tombe à environ 2,05. Cette étape montre pourquoi une mesure doit documenter la taille du problème et les coûts de coordination.

Pour choisir un découpage, on peut attribuer des blocs indépendants à quatre cœurs, puis réduire les résultats avec une opération associative. Si les blocs partagent une variable mise à jour sans protection, une course rend le résultat non déterministe. Des verrous ou une réduction locale évitent cette erreur, mais augmentent parfois la synchronisation.

Erreurs fréquentes

Confondre fréquence et nombre de cœurs masque les limites de la mémoire. Appliquer Amdahl sans identifier la fraction séquentielle donne un optimisme artificiel. Enfin, une parallélisation correcte doit préserver la dépendance des données et définir l’ordre ou l’associativité de la réduction.

À retenir

Le parallélisme améliore le débit sous contraintes de dépendances, de mémoire et de coordination. La loi d’Amdahl fournit une borne calculable ; mesurer le temps réel et les surcoûts est indispensable avant de conclure.

Points-clés

• Latence et débit décrivent deux effets différents du parallélisme.
• La loi d’Amdahl borne l’accélération par la fraction séquentielle.
• Synchronisation, mémoire et cohérence réduisent le gain idéal des cœurs.
• Un découpage sûr respecte les dépendances et protège les écritures partagées.

Exercices corrigés

Exercice 1 · Fondamental

Convertir 173 en base 2 puis en base 16. Écrire aussi -83 sur 8 bits en complément à deux et préciser le résultat de la lecture non signée des mêmes bits.

Correction détaillée

Pour 173, on décompose 173=128+32+8+4+1, donc 173=10101101₂. En groupant par quatre bits, 1010 1101 donne AD₁₆. Pour 83, 83=01010011₂ sur 8 bits ; inversion : 10101100 ; ajout de 1 : 10101101₂. Comme non signé, ces bits valent 128+32+8+4+1=173. Comme signé, 173-256=-83. La même suite de bits ne suffit donc pas à déterminer une valeur sans convention de type.

Exercice 2 · Fondamental

Dans une machine où PC=40, mémoire[40]=LOAD R3,[120], mémoire[120]=9 et chaque instruction occupe une cellule, donner l’état de PC, IR et R3 après la recherche, puis après l’exécution.

Correction détaillée

Avant la recherche : PC=40 et R3 est inchangé. La recherche copie mémoire[40] dans IR, donc IR=LOAD R3,[120], puis avance PC à 41. Le décodage calcule l’adresse effective 120. L’exécution lit mémoire[120]=9 et écrit R3=9. Après l’exécution : PC=41, IR conserve l’instruction courante et R3=9. L’adresse 120 n’est pas la valeur 9 : elle sert à localiser la donnée.

Exercice 3 · Intermédiaire

On stocke 0xCAFEBABE à l’adresse 0x1000 dans une mémoire little-endian adressable par octet. Donner les quatre octets puis calculer le temps moyen pour un cache de 3 ns, un taux de défaut de 8 % et une pénalité de 50 ns.

Correction détaillée

Little-endian place l’octet faible en premier : mémoire[0x1000]=BE, [0x1001]=BA, [0x1002]=FE, [0x1003]=CA. Pour le cache, avec le modèle t_moyen=t_c+p×pénalité, on obtient 3+0,08×50=3+4=7 ns. Le taux de succès est 92 %, mais il n’est pas nécessaire de recalculer séparément ici car les 3 ns sont déjà le coût du succès et la pénalité est le coût additionnel d’un défaut.

Exercice 4 · Intermédiaire

Exécuter la trace suivante avec A=5 et B=2 : LOAD R1,[A] ; LOAD R2,[B] ; SUB R1,R2 ; JNZ R1,fin ; STORE [A],R1 ; fin: STORE [B],R1. Indiquer l’instruction STORE exécutée et l’état final.

Correction détaillée

Après les deux LOAD, R1=5 et R2=2. SUB R1,R2 donne R1=3. Le test JNZ constate que R1 est non nul, donc le PC saute à fin et l’instruction STORE [A],R1 est ignorée. À l’étiquette fin, STORE [B],R1 écrit 3 dans B. État final : A=5, B=3, R1=3, R2=2. L’erreur classique serait d’exécuter les deux STORE en oubliant que le branchement modifie le flot.

Exercice 5 · Avancé

Un programme effectue 1 000 accès. Le cache L1 coûte 1 ns en cas de succès ; un défaut L1 (probabilité 0,10) ajoute 8 ns pour consulter L2, puis, parmi ces défauts, 20 % nécessitent la mémoire vive et ajoutent 70 ns. Estimer le temps total et expliquer les hypothèses.

Correction détaillée

On raisonne par accès avec des pénalités additives. Le coût moyen vaut 1 + 0,10×8 + 0,10×0,20×70 = 1+0,8+1,4 = 3,2 ns. Pour 1 000 accès, le temps estimé est 3 200 ns, soit 3,2 µs. Le terme mémoire vive ne concerne que 20 % des défauts L1, donc sa probabilité globale est 0,02 ; il ne faut pas ajouter 0,20×70 à tous les accès. Ce calcul suppose des accès indépendants, aucune contention, aucune écriture différée et des pénalités déjà exprimées comme temps supplémentaires. Dans une machine réelle, ces hypothèses doivent être vérifiées avant de comparer à une mesure.

Quiz d’autoévaluation

Question 1

Quelle est la valeur non signée de 11111101₂ sur 8 bits ?

• -3 ✓ 253 • 125 • 256

Explication : Les poids actifs sont 128+64+32+16+8+4+1=253. La valeur -3 correspond à la lecture signée en complément à deux.

Question 2

Quel registre indique normalement l’adresse de la prochaine instruction ?

• IR ✓ PC • UAL • ACC

Explication : Le compteur ordinal, ou PC, contient l’adresse de la prochaine instruction, sauf lorsqu’un branchement la remplace.

Question 3

Que fait principalement une instruction LOAD R1,[A] ?

• Elle écrit R1 dans A ✓ Elle lit la donnée à A dans R1 • Elle additionne A et R1 • Elle efface la mémoire

Explication : Les crochets désignent un accès mémoire : la valeur située à l’adresse A est transférée vers R1.

Question 4

Combien de bits forment un chiffre hexadécimal ?

• 2 ✓ 4 • 8 • 16

Explication : Un chiffre hexadécimal a 16 possibilités, soit 2⁴ ; il représente donc exactement quatre bits.

Question 5

Quelle localité justifie le chargement de données voisines dans une ligne de cache ?

✓ La localité spatiale • La localité syntaxique • La localité signée • La localité de contrôle

Explication : La localité spatiale signifie qu’une adresse proche de celle consultée a de bonnes chances d’être utilisée prochainement.

Question 6

Sur 8 bits en complément à deux, quelle est la valeur de 10000000₂ ?

• 128 ✓ -128 • -0 • 0

Explication : Le bit de signe est actif et la valeur minimale représentable sur 8 bits signés est -2⁷=-128.

Question 7

Quel événement modifie explicitement le flot séquentiel d’exécution ?

• Une addition sans débordement ✓ Un branchement pris • Une lecture de registre • Une conversion hexadécimale

Explication : Un branchement pris remplace le PC par une cible ; l’instruction immédiatement suivante n’est alors pas forcément exécutée.

Question 8

Avec t_c=2 ns, p=0,1 et une pénalité additionnelle de 30 ns, quel est le temps moyen ?

• 2,3 ns • 3 ns ✓ 5 ns • 32 ns

Explication : Le modèle donne 2+0,1×30=5 ns. La pénalité est pondérée par la probabilité de défaut.

Glossaire

• Bit — Unité d’information prenant deux états, généralement notés 0 et 1.
• Complément à deux — Convention de codage des entiers signés qui permet de représenter les négatifs et d’utiliser la même addition binaire.
• Compteur ordinal (PC) — Registre contenant l’adresse de la prochaine instruction à rechercher, sauf changement de flot.
• Registre d’instruction (IR) — Registre qui conserve l’instruction actuellement recherchée et décodée par le processeur.
• Adresse effective — Adresse mémoire réellement calculée à partir d’une instruction et de son mode d’adressage.
• Endianness — Règle qui fixe l’ordre des octets d’une valeur multi-octets en mémoire.
• Cache — Mémoire rapide de petite capacité conservant des données susceptibles d’être réutilisées bientôt.
• Localité — Propriété d’un programme dont les accès réutilisent souvent les mêmes données ou des adresses voisines.

TP · Tracer l’exécution d’un mini-programme CPU–mémoire

Une machine pédagogique possède 16 cellules mémoire, des registres R0 et R1, un PC et les instructions LOAD, ADD, STORE et JNZ. Une équipe doit expliquer comment une valeur 6 située en mémoire[4] devient 10 en ajoutant mémoire[5]=4, puis est stockée en mémoire[6].

Objectifs

• Construire un état initial et un état final sans confondre adresse et contenu.

• Annoter les phases recherche, décodage et exécution d’au moins quatre instructions.

• Utiliser une représentation binaire ou hexadécimale cohérente pour les adresses et valeurs.

• Vérifier la trace par un diagramme des transferts CPU–mémoire.

Étapes

1. Définir la largeur des cellules, initialiser PC=0, mémoire[4]=6, mémoire[5]=4 et le reste à 0.

2. Écrire la séquence LOAD R0,[4] ; LOAD R1,[5] ; ADD R0,R1 ; STORE [6],R0 et numéroter les instructions.

3. Remplir un tableau avec PC avant, instruction, PC après, R0, R1 et mémoire[6] après chaque étape.

4. Dessiner les flèches de lecture et d’écriture entre processeur et mémoire, puis contrôler le résultat attendu.

5. Ajouter un test d’erreur : remplacer [5] par #5, expliquer la différence et corriger le diagramme.

Livrables attendus

• Une trace tabulaire complète et datée des états du processeur et de la mémoire.

• Un diagramme CPU–mémoire légendé indiquant adresses, valeurs et direction des transferts.

• Une courte note comparant l’opérande mémoire [5] et la constante immédiate #5.

Critères d’évaluation

• Exactitude du résultat final mémoire[6]=10 et conservation des données sources : 30 %.

• Trace PC–registres complète, sans saut de phase ni confusion adresse-valeur : 30 %.

• Diagramme lisible, flèches et unités d’information correctement légendées : 20 %.

• Explication du mode immédiat et test d’erreur reproductible : 20 %.

Piste de résolution

La trace attendue donne R0=6 après le premier LOAD, R1=4 après le second, puis R0=10 après ADD et mémoire[6]=10 après STORE. Le PC avance séquentiellement d’une instruction à l’autre. Le diagramme doit montrer deux lectures mémoire vers les registres, une opération interne à l’UAL, puis une écriture de R0 vers l’adresse 6. Avec #5, R1 reçoit la constante 5 et le résultat devient 11 : ce cas confirme que crochets et immédiat ne désignent pas la même source.

Sujets originaux d’entraînement (non officiels)

Sujet original de préparation — Architecture des ordinateurs

Sujet original non officiel, conçu pour l’entraînement ; il ne s’agit jamais d’une épreuve d’années passées ni d’un document institutionnel.

Exercice 1

Sur 8 bits, convertir 198 en hexadécimal et donner sa valeur signée en complément à deux. Expliquer chaque étape.

Correction : 198=128+64+4+2, donc 198=11000110₂= C6₁₆. Le bit de signe vaut 1. Pour décoder en signé, 198-256=-58 ; la valeur est donc -58. On peut contrôler en codant 58=00111010, inversion 11000101, ajout 1=11000110.

Exercice 2

Avec PC=12 et la séquence LOAD R0,[30] ; ADD R0,#2 ; STORE [31],R0, mémoire[30]=8, établir la trace des registres et de la mémoire.

Correction : La première instruction est recherchée à 12, puis PC passe à 13 et R0 reçoit 8. ADD avec l’immédiat 2 donne R0=10 et PC passe à 14. STORE écrit 10 à l’adresse 31 et PC passe à 15. La mémoire[30] reste 8, mémoire[31] devient 10. Le symbole #2 désigne une constante, contrairement à [2] qui demanderait une lecture à une adresse.

Exercice 3

Comparer deux caches : A a t_c=2 ns et p=0,12 ; B a t_c=4 ns et p=0,03, avec une pénalité de défaut de 40 ns. Calculer les temps moyens et choisir selon ce critère.

Correction : Pour A : 2+0,12×40=6,8 ns. Pour B : 4+0,03×40=5,2 ns. B est préférable selon le seul temps moyen, malgré un accès réussi plus lent, car ses défauts sont moins fréquents. Ce choix suppose la même pénalité, aucun coût de cohérence et des probabilités représentatives de la charge.

Sujet original de préparation — Seconde série

Sujet original non officiel, proposé pour réviser autrement ; il ne s’agit jamais d’une épreuve d’années passées ni d’un cours officiel.

Exercice 1

Écrire sur 8 bits le complément à deux de -37, puis vérifier la valeur obtenue en lecture signée et non signée.

Correction : 37=00100101₂. Inversion : 11011010₂. Ajout de 1 : 11011011₂. En non signé, 128+64+16+8+2+1=219. En signé, 219-256=-37. Le contrôle par l’inversion et l’ajout de 1 confirme le codage.

Exercice 2

Une instruction JNZ R0,24 est exécutée avec R0=0 puis avec R0=5. Décrire dans chaque cas l’évolution du PC si l’adresse de l’instruction est 20 et si elle occupe une cellule.

Correction : La recherche à l’adresse 20 avance d’abord le PC à 21. Si R0=0, la condition non nul est fausse : le PC reste 21, l’exécution continue séquentiellement. Si R0=5, la condition est vraie : le PC est remplacé par 24. Dans ce second cas, l’instruction à l’adresse 21 n’est pas exécutée.

Exercice 3

Une valeur 0x10203040 est stockée à 0x200 en little-endian. Un programme lit quatre octets puis les assemble. Donner les octets et expliquer comment retrouver la valeur.

Correction : Les octets sont 40 à 0x200, 30 à 0x201, 20 à 0x202 et 10 à 0x203. Pour reconstruire la valeur, le programme remet 10 au poids fort, puis 20, 30 et 40 au poids faible : 0x10 20 30 40, soit 0x10203040. Lire la suite brute 40 30 20 10 comme une écriture hexadécimale dans cet ordre inverserait les poids et produirait une autre valeur.

Parcours de révision sur quatre semaines

Semaine 1 · Bases 2 et 16, entiers signés, complément à deux et limites sur n bits.

Faire dix conversions manuelles, corriger les confusions signé/non signé et expliquer trois résultats à voix haute. Avant de terminer, reformule les notions sans tes notes, vérifie les résultats dans le cours et note une difficulté précise à reprendre la semaine suivante.

Semaine 2 · Processeur, registres, PC, IR et cycle recherche–décodage–exécution.

Tracer cinq petits programmes avec une colonne PC avant/après et vérifier chaque branchement. Avant de terminer, reformule les notions sans tes notes, vérifie les résultats dans le cours et note une difficulté précise à reprendre la semaine suivante.

Semaine 3 · Adresses, mots, endianness et hiérarchie mémoire.

Représenter trois valeurs multi-octets dans les deux ordres et résoudre quatre temps moyens d’accès. Avant de terminer, reformule les notions sans tes notes, vérifie les résultats dans le cours et note une difficulté précise à reprendre la semaine suivante.

Semaine 4 · Assembleur, intégration et préparation des sujets originaux.

Réaliser le TP en temps limité, passer le quiz sans notes puis corriger les erreurs avec le glossaire. Avant de terminer, reformule les notions sans tes notes, vérifie les résultats dans le cours et note une difficulté précise à reprendre la semaine suivante.