ArcOrdPartie I Nov 2019

Architectures des ordinateurs
Mohsine Eleuldj eleuldj@emi.ac.ma

Département Génie Informatique
Ecole Mohammadia d'Ingénieurs
Novembre 2023
Architecture des ordinateurs, nov. 2023 2
Support de cours et TP
n Support du cours
q Plateforme Moodle : Architectures des ordinateurs
q https://moodle.emi.ac.ma/course/view.php?id=69
n Référence
q Cours de Onur Mutlu, Carnegie Mellon University, PA, USA
q http://www.ece.cmu.edu/~ece447/s15/doku.php?id=schedule
n Travaux pratiques
q MARS (Mips Assembler and Runtime Simulator)
http://courses.missouristate.edu/KenVollmar/mars
q Installation au préalable de JRE (Java Runtime Environment)

Evaluation des connaissances
n Evaluation dans Moodle
q Quiz (6 en ≈10 mn) : 30%
q Travaux pratiques (2 à 3) : 20 %
q Contrôle final avec documentation (≈45 mn) : 50%
n Quiz et Contrôle avec SAB (Save Exam Browser)

q Télécharger SAB selon votre système d’exploitation
q Installer SAB dans votre ordinateur
q Lancer le fichier de configuration qui vous sera envoyé par email
q Tutorial : https://www.youtube.com/watch?v=fEXZcj4G58g
n Travaux pratiques
q Dépôt dans Moodle
q Remise par groupe de 4 élèves choisis aléatoirement

Plan du cours
page
I Introduction 6
II Concepts fondamentaux 22
III ISA et microarchitecture 30
IV Principes de ISA 46
V Microarchitecture 72
VI Hiérarchies de la mémoire 133
VII Gestion de la mémoire cache 156
Annexe : MARS 168

Chapitre 1
Introduction
Contenu
Définition de l’architecture des ordinateurs
Niveaux d’abstraction
Problème de ralentissement
Matériel et logiciel
Mosquée Hassan II
Érigée en partie sur la mer, c'est un complexe religieux et culturel,
aménagé sur neuf hectares et comporte une salle de prières, une salle
d'ablutions, des bains, une école coranique (madrasa), une bibliothèque et
un musée.
La salle de prière peut accueillir 25 000 fidèles d'une superficie totale de

20 000 m2 et l'esplanade 80 000 fidèles (l'ensemble complet peut accueillir
105 000 personnes).
La mosquée Hassan II est l'une des plus grandes mosquées du monde, et

possède un minaret d'une hauteur de 200 à 210 m selon les sources, le
plus haut du monde. Des artisans recrutés dans toutes les villes du
royaume avaient sculpté 53000 m2 de bois et assemblé plus de 10 000 m2
de zellige (céramiques) pour le lieu de culte.
(http://www.mosquee-hassan2.com/)

Suppositions de l’architecture
n Beaucoup de travail, persévérance, dévouement (pendant
des années)
n Compréhension des constructions existantes
n Utilisation des principes de construction
n Bon jugement et intuition
n Créativité
n Innovation (S'éloigner des sentiers battus et idées
préconçues)
n Forte combinaison des compétences (environnement,
mathématique, conception, construction, art, …)
n …

Rôle d'un architecte (d'ordinateur)
n Regarder en arrière (passé)

q Comprendre les conceptions existantes, les analyser et les évaluer
n Regarder en avant (futur)
q Créer et être attentif aux nouvelles conceptions (aux rêveurs)
q Evaluer les compromis(tradeoffs) des nouvelles conceptions
n Regarder en haut (cahier des charges, matériaux, …)
q Comprendre le problème à résoudre et sa nature
q Développer les idées pour la résolution de ce problème
n Regarder en bas (réalisation, corps de métier, …)
q Comprendre les possibilités des technologies d'implémentation
q Prédire et adopter les technologies du futur (conception des
années à venir)
Définitions de l'architecture des ordinateurs
n In computer engineering, computer architecture is a set of
rules and methods that describe the functionality,
organization, and implementation of computer systems. The
architecture of a system refers to its structure in terms of
separately specified components of that system and their
interrelationships (https://en.wikipedia.org/wiki/
Computer_architecture)
n L’architecture des ordinateurs est la conception interne d'un
système informatique, déterminant comment les composants
matériels (CPU, mémoire, E/S) interagissent pour exécuter
des programmes. Elle inclut également le système
d'exploitation. Cette structure détermine les performances et
la capacité d'un ordinateur à traiter des données et à exécuter
des tâches (https://openai.com/chatgpt)
Modèles de calcul
Programme C
(modèle de calcul)
Vue du programmeur (software)
Comment un programme s'exécute-t-il
sur des circuits électroniques ?
Vue Architecte/microarchitecte
Que se passe-t-il entre les deux Comment concevoir un ordinateur
pour atteindre les objectifs ?
modèles ?
Comment un ordinateur utilise-t-il des

portes logiques et des fils pour
Vue du concepteur du matériel
satisfaire les spécifications ? (hardware)
Circuits électroniques
(modèle de calcul)
Niveaux de transformation
Comment garantir qu'un problème soit résolu par les circuits
électroniques ?
Problème
Algorithme
Pile de calcul
Programme
(computing stack)
Runtime System
(VM, OS, MM)
Objet de
ISA (Architecture) ce cours
Microarchitecture
Logic
Circuits
Electronique

Niveau de transformation et abstraction
n Niveau de transformation crée une abstraction
q Un niveau doit connaître l'interface du niveau inférieur sans
connaître son implémentation
q Par exemple, un programmeur en Java n'a pas besoin de
connaître l'architecture interne (ISA) et comment l'ordinateur
exécute les instructions
n L’abstraction améliore la productivité

q Se concentrer sur l’abstraction et ne pas se préoccuper des
décisions prises dans les niveaux inférieurs ni supérieurs
q Par exemple, le programmeur n'a pas besoin de spécifier les
signaux de contrôle des transistors pour chaque cycle d'horloge
n Pourquoi avons nous besoin de connaître ce qui se passe

dans les niveaux inférieurs ou supérieurs ?
Connaissance des niveaux d'abstraction
n Aussi longtemps que « tout va bien », ce qui se passe dans
les niveaux inférieurs ou supérieurs n'est pas un problème
n Qu'arrive-t-il si le programme que vous avez écrit :

q S'exécute lentement ?
q Ne s'exécute pas correctement ?
q Consomme beaucoup d'énergie ?
n Qu'arrive-t-il si le matériel que vous avez conçu est :

q Très difficile à programmer ?
q Très lent à cause de l'absence des fonctions prédéfinies du langage ?
n Qu'arrive-t-il si vous voulez concevoir un système :

q Plus efficace ?
q Plus performant ?
Example : Système Multi-Core
Multi-Core
Chip
L2 CACHE 1
L2 CACHE 0
SHARED L3 CACHE
DRAM INTERFACE
CORE 0 CORE 1
DRAM BANKS
DRAM MEMORY
CONTROLLER
L2 CACHE 2
L2 CACHE 3
CORE 2 CORE 3
*Die photo credit: AMD Barcelona

Différence de ralentissement (Slowdown)
High priority
Memory Performance Hog

Low priority
(Core 0) (Core 1)
Moscibroda and Mutlu, “Memory performance attacks: Denial of memory service
in multi-core systems,” USENIX Security 2007.
Pourquoi la différence des ralentissements ?
CORE
matlab1 gcc 2
CORE Multi-Core
Chip
L2 L2
CACHE CACHE
unfairness
INTERCONNECT
Shared DRAM
DRAM MEMORY CONTROLLER Memory System
DRAM DRAM DRAM DRAM

Bank 0 Bank 1 Bank 2 Bank 3

DRAM Bank Operation
Access Address:
(Row 0, Column 0) Columns
(Row 0, Column 1)
(Row 0, Column 85)
Row decoder
(Row 1, Column 0)
Rows
Row address 0
1
Row 01
Row
Empty Row Buffer CONFLICT
HIT !
Column address 0
1
85 Column mux
Data

Contrôleur DRAM
n Les contrôleurs DRAM (Dynamic RAM) actuels :
q plusieurs applications partagent le contrôleur DRAM
q ont un tampon ligne
q un accès mémoire qui provoque un conflit de ligne prend un
temps plus important par rapport à un accès sans conflit de ligne
q stratégie d'ordonnancement communément utilisée : Row-hit first
(priorité aux applications qui accèdent à des adresses
consécutives)
n Les stratégies d'ordonnancement DRAM ne sont pas adaptées

pour certaines applications
n Les contrôleurs DRAM sont vulnérables aux attaques de déni
de service (DOS)
Une fois la cause du problème détectée
n Comment allez-vous résoudre le problème ?
n Quel est le “bon” niveau d'abstraction pour résoudre le
problème ?
q Programme ?
Problème
q Système d'exploitation ? Algorithme
q Compilateur ? Program/Language
q matériel (Memory controller) ? Runtime System
q Matériel (DRAM) ? (VM, OS, MM)
q Circuits ? ISA (Architecture)

Microarchitecture
n Deux autres objectifs de ce cours :
Logic
q Permettre une réflexion critique
Circuits
q Permettre une réflexion globale
Electronique

Matériel versus logiciel
n Ce cours fait partie des “cours matériel”
n Cependant, si vous maîtriser le matériel et le logiciel, vous

seriez en mesure de :
q Développer un meilleur logiciel si vous compreniez le matériel
sous-jacent
q Concevoir un meilleur matériel si vous compreniez quel logiciel
sera exécuté
q Concevoir un meilleur système de calcul (computing system) si
vous compreniez le matériel et le logiciel

Chapitre 2
Concepts fondamentaux
Contenu
Point de vue de l’utilisateur
Loi de Moore
Architecture des ordinateurs
Niveaux de transformation
n Point de vue de l'utilisateur : ordinateur conçu pour les
utilisateurs
Problème
Algorithme
Programme/Langage User
Pile de calcul Runtime System

(computing stack) (VM, OS, MM)
ISA
Microarchitecture
Logic
Circuits
Electronique
n Tous les niveaux de la pile doivent être optimisés pour
l'utilisateur
Number of transistors on an integrated circuit doubles ~ every two years
Image source: Wikipedia
Pourquoi étudier l'architecture des ord. ?
n Permettre de concevoir de meilleurs systèmes : ordinateur
plus rapide, moins cher, plus réduit, plus fiable,…
q En exploitant les avancées technologiques/circuits
n Considérer de nouvelles applications

q Intelligence artificielle (reconnaissance de forme,…)
q Visualisation 3D, Réalité virtuelle
q Géonomique personnalisée, Médecine personnalisée,…
n Permettre des solutions satisfaisantes aux problèmes

q Innovation logicielle implique des changements dans l'architecture des
ordinateurs
n Amélioration de la performance > 50% par année
n Comprendre le fonctionnement des ordinateurs
Architecture des ordinateurs d’aujourd'hui
n L'industrie est dans une transition de paradigmes (vers les
systèmes multi-core et au-delà) – Plusieurs conceptions de
systèmes différentes
n Plusieurs problèmes difficiles sont dûs à cette transition

q Power/energy constraints à multi-core?
q Complexity of design à multi-core?
q Difficulties in technology scaling à new technologies?
q Memory wall/gap
q Reliability wall/issues
q Programmability wall/problem
q Huge hunger for data and new data-intensive applications
n Des réponses définitives à ces problèmes ne sont pas

évidentes
Besoins des ordinateurs d’aujourd'hui
n Ces problèmes concernent tous les niveaux de la pile de
calcul
Problème
Plusieurs nouvelles
demandes du haut Algorithme
Demandes changeantes
Programme/Language User et rapides de la part des
utilisateurs
Runtime System
(VM, OS, MM)
ISA
Microarchitecture
Plusieurs nouvelles
Logic
Demandes issues du bas
Circuits
Electronique

Composants des ordinateurs d’aujourd'hui
n Les ordinateurs sont très différents des 10 à 20 dernières
années
Hybrid Memory Cube
Heterogeneous Persistent Memory/Storage

Processors and
Accelerators Every component and its
interfaces, as well as
entire system designs
are being re-examined
General Purpose GPUs
Evolution des l’architecture des ordinateurs
n Vous pourriez révolutionner la fabrication des ordinateurs si
vous comprenez aussi bien le matériel que le logiciel et que
vous les modifiez en conséquence
n Vous pourriez inventer de nouveaux paradigmes pour le

calcul, la communication et le stockage
n Recommended book: Thomas Kuhn,

“The Structure of Scientific Revolutions” (1962)

Architecture des ordinateurs
Chapitre 3
ISA et microarchitecture
Contenu
Modèle de Von Neumann
Modèle de flot de contrôle
Modèle du flot de données
Microarchitecture
Unités d'un ordinateur
n Calcul (computing) qui exécute un ensemble d'instructions
d'où l'appellation ISA (Instruction Set Architecture)
n Communication ou entrée/sortie (I/O)
n Mémoire (stockage temporaire et permanent)

Modèle Von Neumann
n Appelé aussi architecture de Von Neumann et a 2 propriétés :
n Programme enregistré
q Instructions du programme sont enregistrées dans la mémoire
(représentée par un tableau)
q Mémoire contient des instructions et des données. L'interprétation de la
valeur stockée dépend d'un signal de contrôle
n Traitement séquentiel des instructions

q une instruction est traitée à la fois (cherchée de la mémoire, décodée
et exécutée)
q Pointeur d'instruction ou compteur ordinal (PC : Program Counter)
identifie l'instruction courante (contient l'adresse de l'instruction
courante)
q PC est incrémenté par 1 sauf dans le cas de branchement

Structure du modèle Von Neumann
Mémoire
RAM RDM
Unité de traitement
Unité (CPU) Unité
d'entrée de sortie
ALU Temp
Unité de contrôle RAM : Registre d'adresse mémoire

RDM : Registre des données mémoire
Temp ; Registre temporaire
PC RI PC : Compteur ordinal
RI : Registre d'instruction
ALU : Arithmetic and Logic Unit
Exercice
Décrire les étapes de l'exécution des instructions suivantes sur
une architecture Von Neumann (MIPS):
a) Instruction de chargement immédiat

li $v0, 4 # mettre la valeur 4 dans le registre v0
b) Instruction de branchement conditionnel

beq $v2, 173 # si le registre v4 contient la valeur 0 alors
# la prochaine instruction est dans l'adresse 173

Modèle du flot de contrôle
n Le modèle de Van Neumann est un modèle de flot de
contrôle : une instruction est cherchée de la mémoire et
exécutée
q L’adresse de l’instruction est identifiée par le contenu de PC
q Les instructions sont exécutées séquentiellement sauf si c'est
une instruction de branchement
n Question : Ce modèle est-t-il la seule manière avec laquelle

un ordinateur peut fonctionner ?
n Réponse : Non. Mais c'est le paradigme de calcul de la

plupart des ordinateurs depuis plusieurs décennies

Modèle du flot de données (Dataflow)
n Dans un modèle de flot de données, une instruction est
cherchée de la mémoire et exécutée (déclenchée ou “fired” en
anglais) :
q Lorsque les opérandes sont prêts
q Il n'y a pas de PC (pointeur d'instruction)
q L'ordre des instructions est spécifié par la dépendance du flot de
données
n chaque instruction spécifie qui doit recevoir le résultat
n une instruction est déclenchée lorsque tous les opérandes sont reçus
q Plusieurs instructions peuvent s'exécuter en parallèle

Flot de contrôle versus flot de données
n Considérons les deux programmes ci-dessous
a b
v <= a + b;
w <= b * 2;
x <= v - w + *2
y <= v + w v w
z <= x * y
- +
x y
Flot de contrôle
(Sequentiel) *
Flot de données
z (parallèle)
n Que calculent les programmes ?
n Quel est le flot des programmes ?
n Quelle est la signification de l'ordre des instructions ?
n Quelle est la signification de la localisation du stockage ?
n Quel modèle est plus naturel pour vous comme programmeur ?
Noeud du modèle flot de données
n Dans une machine flot de données, un programme est
composé de nœuds de flot de données
q Un nœud peut être déclenché (instruction fetched and
executed) quand toutes ses entrées sont prêtes (ont des
jetons ou “tokens”)
n Représentation d'un nœud flot de données

Types des noeuds dans le flot de données

Example d'un program flot de données
1 N
Entrées : N (nombre entier) et 1

Sortie : out
Quelle est la valeur de out ?
out

PC dans les modèles ISA
n Avons nous besoin de PC dans une ISA ?
q Oui: orientée par le contrôle (Control-driven), exé. séquentielle
n une instruction est exécutée quand elle est pointée par le PC
n PC est incrémentée de 1 automatiquement (sauf pour les
branchements)
q Non: orientée par les données (Data-driven), exé. parallèle
n une instruction est exécutée quant toutes les valeurs de ses
opérandes sont disponibles (data flow)
n Critères du choix (tradeoffs) des 2 modèles ISA :

q Facilité de la programmation (pour un programmeur moyen) ?
q Facilité de la compilation ?
q Performance: Extraction du parallélisme ?
q Complexité du matériel ?
Quelques ISA d’aujourd’hui
n Les principales ISA d'aujourd'hui utilisent le modèle de Van
Neumann :
q x86 (famille Intel qui regroupe le 8080, 8086, 80286, 80386,
80486, pentium, …)
q ARM (Advanced RISC Machine developed by Arm Ltd)
q Mips (Microprocessor without Interlocked Pipelined Stages)
q SPARC (Scalable Processor ARChitecture developed by Sun)
q Alpha (64 bits RISC ISA developed by DEC)
q PowerPC (Performance Optimization With Enhaced RISC-
Performance Computing deveoped by Apple-IBM-Motorola
alliance)

ISA versus Microarchitecture
n ISA
q Interface entre le logiciel et le matériel Problème
q Le programmeur a besoin de connaître Algorithme
comment écrire et mettre au point Programme
(debug) ses programmes ISA
n Microarchitecture Microarchitecture
q Implémentation spécifique d'une ISA Circuits
Electronique
q Non visible au programmeur
n Microprocesseur
q ISA, microarchitecture, circuits
q “Architecture” = ISA + microarchitecture

ISA versus Microarchitecture
n Analogie avec l'automobile
q interface du conducteur : Pédales (accélération et frein) + volant
q Intérieur du moteur : implémente la conduite
n Implémentations (microarchitecture) peuvent être différentes

tout en respectant les spécifications (ISA)
q instruction Add peut être implémentée par plusieurs additionneurs
n Bit serial, ripple carry, carry lookahead
q x86 ISA a plusieurs implémentations: 286, 386, 486, Pentium, Pentium
Pro, Pentium 4, Core, …
n En général, les microarchitectures changent plus rapidement

que ISA
q Peu de ISAs (x86, ARM, SPARC, MIPS, Alpha) mais beaucoup de
microarchitectures. Pourquoi ?
Microarchitecture
n Implémentation de ISA sous des contraintes de conception
et selon des objectifs
n Caractéristiques :
q Pipelined instruction execution: Intel 80486 uarch
q Multiple instructions at a time: Intel Pentium uarch
q Separate instruction and data caches
q In-order versus out-of-order instruction execution (data
availability)
q Memory access scheduling policy
q Superscalar processing (multiple instruction issue?)
q Clock gating (reducing dynamic power dissipation)
q Caching ? Levels, size, associativity, replacement policy
q Voltage/frequency scaling (automatically adjusted)
q Error correction ? Architecture des ordinateurs, nov. 2023
45
Chapitre 4
Principes de ISA
Contenu
Format d’instruction
Types de données
Mémoire et registres
Etat architectural
Modes d’adressage
Interface d’E/S
Exécution d’une instruction
Fossé sémantique
Différentes ISA à traves les décénies
n x86
n PDP-x: Programmed Data Processor (PDP-11)
n VAX
n IBM 360
n CDC 6600
n SIMD ISAs: CRAY-1, Connection Machine
n VLIW ISAs: Multiflow, Cydrome, IA-64 (EPIC)
n PowerPC, POWER
n RISC ISAs: Alpha, Mips, SPARC, ARM
n Quelles sont les différences fondamentales ?

q Comment sont spécifiées les instructions
q Quelle est la complexité des instructions
Format d’instruction
n Composé de :
q Code d’opération : spécifie ce que fait l’instruction
q Opérandes : spécifient les données
q Mode d’adressage : comment obtenir les opérandes ?
n Exemple du processeur Alpha:

Format d’instruction de Mips
Mips : processeur qui sera étudié dans les chapitres 5 et 6 et
Travaux Pratiques
< ----------------------- 32 bits --------------------- >

0 rs rt rd shamt funct R-type
6-bit 5-bit 5-bit 5-bit 5-bit 6-bit
opcode rs rt immediate I-type

6-bit 5-bit 5-bit 16-bit
opcode immediate J-type

6-bit 26-bit

Nombre d’opérandes d’une opération
On parlera d’un opérande ou adresse dans une opération
n 0 opérande : machine à pile (stack machine)
q op # opération (add, mult, …) sur les 2 valeurs du sommet
q PUSH A # empiler une valeur ou contenu d’une adresse
q POP A # désempiler le sommet dans une adresse
n 1 opérande : machine à accumulateur
q op ACC # effectuer une opération dans l’accumulateur
q load A # charger le contenu de A dans l’accumulateur
q store A # Sauvegader le contenu de l’accumulateur dans A
n 2 opérandes: machine à deux opérandes
q op S,D # effectuer une opération entre la source S et la Destination D
n 3 opérandes : machine à 3 opérandes
q op S1,S2,D #effectuer une opération entre les sources S1 et S2
et la destination D
Fonctionnement de la machine à pile
Programme
PUSH 98
PUSH 12
PUSH 45
ADD
MUL
POP C

Machines à plusieurs opérandes
n Ecrire les programmes de calcul de c = a + b pour les 3
machines :
q machine à 1 opérande :
LOAD a ; ACC ß (a)
ADD b ; ACC ß (ACC) + (b)
STORE c ; c ß (ACC)
q machine à 2 opérandes :
ADD a,b ; a ß (a)+(b)
STORE c,a ; c ß (a)
q Machine à 3 opérandes :
ADD c,a,b ; c ß (a) + (b)
n Avantage et inconvénients ?
Exercice
Considérons l’expression arithmétique suivante :
x = (5 + 4 * 3) / (5 + 2 * 3 – 1)
a) Représenter cette expression dans un arbre

b) Déduire le parcours postfixe (GDR). Supposons que pour les
opérations non commutatives (- et /), le premier opérande est
celui de gauche.
c) Est-ce que c’est le seul arbre postfixe de cette expression ?
d) Ecrire le programme de ce calcul pour une machine à pile en
utilisant les instructions : PUSH, POP, MUL, ADD, DIV, SUB.
e) Simuler l’exécution de ce programme.
f) Quelle est l’intérêt de l’expression postfixe ?

Représentation de l’expression
/
+ +
5 * 5 -
4 3 * 1
2 3
x = (5 + 4 * 3) / (5 + 2 * 3 – 1)
Représentation Postfix (GDR) : 5 4 3 * + 5 2 3 * 1 - + /
programme d’une machine à pile
PUSH 5 # charger 5 dans la première position
PUSH 4 # charger 4 dans la deuxième position
PUSH 3 # charger 3 dans la troisième position
MUL # charger dans la deuxième position le produit 4*3=12
ADD # charger dans la première position la somme 5+12=17
PUSH 5 # charger 5 dans la deuxième position
PUSH 2 # charger 2 dans la troisième position
PUSH 3 # charger 3 dans la quatrième position
MUL # charger dans la troisième position le produit 2*3=6
PUSH 1 # charger 1 dans la quatrième position
SUB # charger dans la troisième position la soustraction 6-1=5
ADD # charger dans la deuxième position la somme 5+5=10
DIV # charger dans la première position la division 17/10=1,7
POP x # sauvegarder 1,7 dans l’dresse x

Machine à pile (Stack Machine)
+ petite taille des instructions (aucun opérande)
q Logique simple
q Programme compacte
+ Efficacité des appels des procédures

q tous les paramètres de la procédure sont dans la pile
q Pas de cycles additionnels pour le passage des paramètres
-- Calculs sont difficilement exprimables en notation postfixe et

difficilement adaptés aux machines à pile
q Ne peut pas effectuer des opérations sur plusieurs opérandes au
même temps
q inflexible
Types de données
n Définition: Représentation des informations exploitées par
les instructions
n Exemples :
q integer, floating point, binary, decimal, BCD, Character, String,
Linked liste, Queue, Stack, vector of bit, …
n Quel est l’avantage de plusieurs types de données de haut
niveau dans une ISA ? Quel est l’inconvénient ?
n Concept du fossé sémantique (semantic gap)
q Types de données sont étroitement couplés (coupled tightly)
avec la complexité des instructions
n Example: Early RISC architectures vs. Intel 432
q Early RISC: entier (integer) est le seul type de données
q Intel 432: Type de données objet (capability based machine)
Organisation de la mémoire
q Espace adresse : Combien de localisations mémoire sont
identifiables uniquement ?
q Adressabilité: Combien d’information sont elles identifiables dans
une case (cellule) mémoire ?
q Adressable par octet : plupart des ISA, Mips
q Adressable par bit: Burroughs 1700. Intérêt ?
q Adressable par 64 bits: certains superordinateurs. Intérêt,
q Adressable par 32-bit : First Alpha
q Questions :
q Comment additionner 2 nombres 32-bit avec une
adressabilité par octet ?
q Comment additionner 2 nombres 8-bit (1 octet) avec une
adressabilité par 32-bit ?
q Représentation Big endian vs. little endian? (MSB at low or
high byte)
Registres
n Registers
q Combien ?
q Taille de chaque registre ?
n Intérêt des registres ?

q Localité spatiale (références ou données) des programmes
q Localité temporelle : une valeur récemment accédée ou
produite est utilisée plus d’une fois
n Mémoriser cette valeur dans le registre évite un accès mémoire à
chaque fois que nous avons besoin de cette valeur

Evolution des registres
n Accumulateur
q Héritage des machines basées sur l’addition (boulier,...)
n Accumulateur + registres d’adresse
q Besoin d’un registre d’indirection (contient une adresse)
q Initialement les registres d’adresse étaient dédiés à charger une
adresse pour l’indirection
q Par la suite des opérations arithmétiques sont devenues
possibles
n Registres d’ordre général (GPR : General Purpose Registers)
q Les registres impliqués dans toutes les opérations :
arithmétiques, adresses, indexe…
q De quelques registres, à 32 registres (cas commun dans les
RISC) à 128 dans Intel IA-64

Etat architectural (visible au programmeur)
M[0]
M[1]
M[2]
M[3] Registres
M[4] -Localisés dans l’UCT
-Portent des noms dans une ISA
(par opposition aux adresses)
- général vs. dédié (spécial)
M[N-1]
Mémoire : Tableau de stockage PC
indexé par une adresse Adresse mémoire de
l’instruction courante
Instructions (et les programmes) spécifient comment

transformer le contenu (valeurs) de l’état visible au
Architecture des ordinateurs, nov. 2023
programmeur 61
Etat invisible au programmeur
n Le programmeur ne peut pas accéder directement
n Exemples :
q Etat de la microarchitecture
q Etat de la mémoire cache
q Registres du pipeline
q Registre de la pile

Architectures de traitement
n Architecture Load/store : instructions opèrent uniquement
sur de registres : MIPS, ARM et plusieurs architectures RISC
q Exemple de Mips
add $t2, $t0, $t1 # t2 ß (t0) + (t1)
n Architecture Memory/memory : instructions peuvent opérer

également sur des localisations mémoire : x86, VAX et
plusieurs architectures CISC
q Exemples
ADD R1, R2 ; R1 ß (R1) + (R2)
ADD R1,6722 ; R1 ß (R1) + (6722)
ADD 127,6722 ; 127 ß (127) + (6722)

Modes d’adressage
n Spécifie comment obtenir l’opérande
q Absolute LW rt, 10000
use immediate value as address
q Register Indirect: LW rt, (rbase)
use GPR[rbase] as address
q Displaced or based: LW rt, offset(rbase)
use offset+GPR[rbase] as address
q Indexed: LW rt, (rbase, rindex)
use GPR[rbase]+GPR[rindex] as address
q Memory Indirect LW rt ((rbase))
use value at M[ GPR[ rbase ] ] as address
q Auto inc/decrement LW rt, (rbase)
use GRP[rbase] as address, but inc. or dec. GPR[rbase] each time
Intérêt des modes d’adressage
n Avantage des modes d’adressage:
q Permet un meilleur accès à la mémoire : certains accès sont
mieux exprimés avec différents modes à réduction du
nombre d’instructions et de la taille du programme :
n Accès aux éléments d’un tableau (mode autoincrement)
n indirection
n …
n Inconvénient:
q plus de tâches pour le compilateur
q Plus de tâches pour le microarchitecte

Interface des organes d’E/S
n Association mémoire des E/S
q Une section de la mémoire est associée aux organes d’E/S
(clavier, écran, …)
q Les opérations d’E/S (load et store) utilisent les localisations
de cette section pour accéder aux organes
n Exemple : syscall dans le cas de Mips
n Instructions d’E/S spéciales

q Dans x86, les instructions IN and OUT utilisent les ports de la
puce
n Comparaison ?
q Quelle est la méthode la plus générale ?

Modes privilégiés et interruptions
n Modes privilégiés
q Utilisateur vs superviseur
q Qui peut exécuter une instructions ?
n Gestion des exceptions et interruptions

q Quelle procédure faut-il exécuter lorsque une anomalie est constatée
pendant l’exécution d’une instruction ?
q Quelle procédure faut-il exécuter lorsqu’un organe externe demande
le processeur
q Interruptions vectorisée ou non vectorisée (premiers Mips)

Instruction complexe vs. simple
n Instruction complexe : la tâche d’une instruction est importante
par exemple (insertion dans une liste chaînée, FFT, copie de
chaînes de caractères, évaluation d’un polynôme,…)
n Instruction simple : la tâche d’une instruction est faible par
exemple (Add, XOR, Multiply,…)
n Avantages des instructions complexes
+ programme plus dense à taille plus petite à meilleure
utilisation de la mémoire, taux de réussite du cache (hit)
+ compilateur plus simple: optimisation plus simple
n Inconvénients des instructions complexes
- Grande charge de travail à compilateur a moins d’opportunité
d’optimiser (optimisation dans une granularité fine est limitée)
- Matériel plus complexe à transformation du haut niveau aux
signaux de contrôle et l’optimisation doit être faite par matériel
Fossé sémantique
n Où doit-on placer ISA ?
q Plus proche du langage de haut niveau (HLL) à fossé
sémantique faible et instructions complexes
q Plus proche des signaux de contrôle du matériel à fossé
sémantique important et instructions simples
Program/Language
Fossé sémantique
ISA (Architecture)
n Compilateur et matériel complexes vs. Compilateur

complexe et matériel simple
Fossé sémantique de CISC et RISC
n RISC: Reduced Instruction Set Computer
n CISC: Complex Instruction Set Computer
n CISC vs. RISC

q CISC à Initialement motivé par une simplification de l’écriture
du programme
q RISC à permettre un meilleur contrôle du compilateur et son
optimisation
n RISC est motivée par
q Simplification du matériel à coût moins élevé, fréquence plus
grande et possibilité d’exploiter les dernière technologies
q Permettre au compilateur une meilleure optimisation du code
(Détecter plus facilement le parallélisme)

Importance du fossé sémantique
n Très petit fossé sémantique
q ISA est (presque) semblable à un langage de haut niveau
q Exemples :
n Java machines (JVM)
n LISP machines
n Object-oriented machines
n Très grand fossé sémantique

q A chaque instruction correspond un ensemble important de
signaux de contrôle
q Permet l’optimisation des compilateurs

Chapitre 5
Microarchitecture
Contenu
Traitement d’une instruction
Chemin des données
Contrôle câblé et microprogrammé
Période du cycle d’horloge
Etat Architectural
M[0]
M[1]
M[2]
M[3] Registres
M[4] -Localisés dans l’UCT
-Portent des noms dans une ISA
(par opposition aux adresses)
- général vs. dédié (spécial)
M[N-1]
Mémoire : Tableau de stockage PC
indexé par une adresse Adresse mémoire de
l’instruction courante
Instructions (et les programmes) spécifient comment

transformer le contenu (valeurs) de l’état visible au
programmeur 73
EA = Etat architectural avant le traitement de l’instruction
Traitement de l’instruction
EA’ = Etat architectural après le traitement de l’instruction
n Traitement d’une instruction : Transformation de EA à EA’

selon les spécifications de l’instruction dans l’architecture
ISA
Moteur simple de traitement d’une instruction
EA’ EA
Logique Logique
combinatoire Séquentielle
n Qu’est ce qui détermine la période du cycle d’horloge ?

n Que détermine le chemin critique d’un circuit logique
combinatoire ?

Machines Single-cycle vs. Multi-cycle
n Machine Single-cycle
q Toute instruction est traitée en un seul cycle d’horloge.
q Toutes les mises à jour se font à la fin du traitement de l’instruction
q Inconvénient : l’instruction la plus lente détermine la période du cycle
d’horloge à période du cycle d’horloge longue
n Machine Multi-cycle
q Traitement d’une instruction est divisée en des cycles/étages multiples
q Mises à jour peuvent se faire pendant le traitement de l’instruction
q EA est mis à jour seulement à la fin du traitement de l’instruction
q Avantage : le plus lent étage détermine la période du cycle d’horloge

n Une instruction est traitée par l’unité de contrôle étape par
étape selon le modèle de Von Newmann
n Le traitement d’une instruction est une séquence d’étapes.
En général, il y a six étapes dans un cycle d’instruction :
q Innstruction Fetch (recherche)
q Decode
q Evaluate Address
q Fetch Operands
q Execute
q Store Result
n Certaines instructions prennent moins d’étapes. Exemple ?

Pipeline : Assemblage de voitures
Considérons une chaîne de montage de voitures composée de 3 postes
d'assemblage (M: moteur, R: roues et P: portes) où nous voulons assembler 5
voitures (Vi, 1 ≤ i ≤ 5).
Châssis M R P Voitures
Quel est le temps d’assemblage sans et avec pipeline sachant que le temps de
montage d'une voiture est 3h et que le temps d'un poste est 1h ?
Poste
V1 V2 V3 V4 V5
P
V1 V2 V3 V4 V5
R
V1 V2 V3 V4 V5
M
1 2 3 4 5 6 7 8 heure
Pipeline de l’exécution d’un programme
q CI : Chercher l’instruction de la mémoire
q DI : Décoder l’instruction
q EA : Evaluer les adresses
q CO : Chercher les opérandes
q EI : Exécuter l’instruction
q ER : Enregistrer le résultat
Programme Résultats
CI DI EA CO EI ER
(instructions) (données)
Inconvénients :
• conflit d'accès à la mémoire (CI et CO et mémoire à une entrée par exemple)
• instructions de branchement ou d'interruption (BR ou INT)
Cas avantageux :
• exécution de la même instruction sur plusieurs données (traitement vectoriel)

Moteur du traitement des instructions
n L’exécution d’une instruction transforme un EA à autre EA’
n La transformation est faite par les unités fonctionnelles
q Additionneur, multiplieur,….
n Moteur de traitement d’instruction comprend deux

composants :
q Chemin des données (Datapath) : Eléments matériels pour
transformer les signaux des données
n Unités fonctionnelles qui opèrent sur les données
n Structures matérielles (i.e. fils, bus, multiplexeurs) permettant
d’acheminer le flot de données aux unités fonctionnelles et registres
n Unités de stockage pour emmagasiner les données (i.e., registres)
q Logique de contrôle (Control logic) : Eléments matériels pour
déterminer les signaux de contrôle en spécifiant aux chemins de
données ce qu’ils doivent faire avec les données
Performance d’une microarchitecture
Hypothèses :
q P : période du cycle d’horloge
q C(i) : nombre de cycles d’horloge de l’instruction i
q CM : nombre moyen des cycles d’horloge
q t(i) : temps d’exécution de l’instruction i
q T(n): temps d’exécution d’un programme exécutant n instructions
n t(i) = C(i) * P
n T(n) = Σ1≤i≤n [C(i) * P] = n * CM * P

n Performance d’une microarchitecture Single-cycle
q C(i) = CM = 1 et P est longue
n Performance d’une microarchitecture Multi-cycle
q C(i) différent par instruction, CM est petit et P est courte
A Single-Cycle Microarchitecture
A Closer Look
Remember…
n Single-cycle machine
AS’ AS
Sequential
Combinational
Logic
Logic
(State)

Let’s Start with the State Elements
n Data and control inputs 5 Read 3
register 1
Read
on Register 5 data 1
s Read
numbers register 2
Registers Data AL
PC 5 Write
Instruction Add Sum register
Read
ion Write data 2
ory Data data
RegWrite
uction memory b. Program counter c. Adder

a. Registers b
MemWrite
Instruction
address
Address Read
PC data 16
Sign
Instruction Add Sum
extend
Write Data
Instruction
data memory
memory
MemRead
a. Instruction memory b. Program counter c. Adder
Architecture des ordinateurs, nov. 2023a. Data memory unit b. Sign-exten

84
**Based on original figure from [P&H CO&D, COPYRIGHT 2004 Elsevier. ALL RIGHTS RESERVED.]
For Now, We Will Assume
n Memory (instruction and data) and register file (registers)
n Combinational read
q output of the read data port is a combinational function of the
register file contents and the corresponding read select port
(RegWrite = 0)
q 2 registers could be red simultaneously
n Synchronous write
q the selected register is updated on the positive edge clock
transition when write enable is asserted (RegWrite = 1)
n Cannot affect read output in between clock edges
n Single-cycle, synchronous memory
q Contrast this with memory that tells when the data is ready
q i.e., Ready bit: indicating the read or write is done

Instruction Processing
n 5 generic steps (P&H book)
q Instruction fetch (IF)
q Instruction decode and register operand fetch (ID/RF)
q Execute/Evaluate memory address (EX/AG)
q Memory operand fetch (MEM)
q Store/writeback result (WB)
WB
IF Data
Register #
PC Address Instruction Registers ALU Address
Register #
Instruction
memory ID/RF Data
Register # EX/AG memory
Data
MEM
86
What Is To Come: The Full MIPS Datapath
PCSrc1=Jump
Instruction [25– 0] Shift Jump address [31– 0]
left 2
26 28 0 1
PC+4 [31– 28] M M

u u
x x
ALU
Add result 1 0
Add
RegDst Shift PCSrc2=Br Taken
Jump left 2
4 Branch
MemRead
Instruction [31– 26]
Control MemtoReg
ALUOp
MemWrite
ALUSrc
RegWrite
Instruction [25– 21] Read

Read register 1
PC address Read
Instruction [20– 16] data 1
Read
register 2 Zero
bcond
Instruction 0 Registers Read ALU ALU
[31– 0] 0 Read
M Write data 2 result Address 1
Instruction u register M data
u M
memory Instruction [15– 11] x u
1 Write x Data
data x
1 memory 0
Write
data
16 32
Instruction [15– 0] Sign
extend ALU ALU operation
control
**Based on original figure from [P&H CO&D, COPYRIGHT 2004 Elsevier. Architecture des ordinateurs, nov. 2023 87
ALL RIGHTS RESERVED.] JAL, JR, JALR omitted
Single-Cycle Datapath for
Arithmetic and Logical Instructions
R-Type ALU Instructions
n Assembly (e.g., register-register signed addition)
ADD rdreg rsreg rtreg
n Machine encoding
0 rs rt rd 0 ADD R-type
n Semantics
if MEM[PC] == ADD rd rs rt
GPR[rd] ← GPR[rs] + GPR[rt]
PC ← PC + 4

ALU Datapath
Add
4
ALU operation
25:21 Read 3
Read register 1
PC address Read
20:16 Read data 1
register 2 Zero
Instruction
Instruction Registers ALU ALU
15:11 Write result
Instruction register
Read
memory data 2
Write
data
RegWrite
1
IF ID EX MEM WB
if MEM[PC] == ADD rd rs rt
GPR[rd] ← GPR[rs] + GPR[rt]
Combinational
PC ← PC + 4
state update logic
**Based on original figure from [P&H CO&D, COPYRIGHT 2004 Elsevier. ALL RIGHTS RESERVED.] 90
I-Type ALU Instructions
n Assembly (e.g., register-immediate signed additions)
ADDI rtreg rsreg immediate16
n Machine encoding
ADDI rs rt immediate I-type

n Semantics
if MEM[PC] == ADDI rt rs immediate
GPR[rt] ← GPR[rs] + sign-extend (immediate)
PC ← PC + 4

Datapath for R and I-Type ALU Insts.
Add
4
3 ALU operation
Read
Read 25:21
PC register 1 Mem
address Read
data 1
Read
20:16 Zero
Instruction register 2
15:11
Write result Address
Instruction register
Read
memory data 2
Write Dat
RegDest data
mem
isItype RegWrite
ALUSrc
Write
data
116 32
Sign isItype Mem
extend
IF ID EX MEM WB
if MEM[PC] == ADDI rt rs immediate
GPR[rt] ← GPR[rs] + sign-extend (immediate) Combinational
PC ← PC + 4 Architecture des ordinateurs, nov. 2023 state update logic 92
Data Movement Instructions
Load Instructions
n Assembly (e.g., load 4-byte word)
LW rtreg offset16 (basereg)
n Machine encoding
LW base rt offset I-type
n Semantics
if MEM[PC]==LW rt offset16 (base)
EA = sign-extend(offset) + GPR[base]
GPR[rt] ← MEM[ translate(EA) ]
PC ← PC + 4

LW Datapath
Add
0
4 add
ALU operation MemWrite
Read 3
Read register 1 MemWrite
PC address Read
data 1
Read
Instruction register 2 Zero Address Read
Instruction Registers ALU ALU data 16
Write Read
result Address
Instruction register data
Read Data
memory data 2 Write
Write data Data memory
data
memory
RegDest RegWrite Write
isItype 1 16
ALUSrc data
MemRead
Sign
32
isItype MemRead
extend
1
a. Data memory unit b. S
if MEM[PC]==LW rt offset16 (base) IF ID EX MEM WB

GPR[rt] ← MEM[ translate(EA) ]
Combinational
PC ← PC + 4
Architecture des ordinateurs, nov. 2023 state update logic 95
Store Instructions
n Assembly (e.g., store 4-byte word)
SW rtreg offset16 (basereg)
n Machine encoding
SW base rt offset I-type

n Semantics
if MEM[PC]==SW rt offset16 (base)
MEM[ translate(EA) ] ← GPR[rt]
PC ← PC + 4

SW Datapath
Add
1
4 add
ALU operation MemWrite
Read 3
PC address Read
data 1
Read
Instruction register 2 Zero Address Read
Instruction Registers ALU ALU data 16
Write Read
result Address
Read Data
memory data 2 Write
Write data Data memory
data
memory
isItype 016 ALUSrc
data
MemRead
Sign
32
isItype MemRead
extend
0
a. Data memory unit b. S
if MEM[PC]==SW rt offset16 (base) IF ID EX MEM WB

MEM[ translate(EA) ] ← GPR[rt]
Combinational
PC ← PC + 4
Architecture des ordinateurs, nov. 2023 state update logic 97
Load-Store Datapath
Add
4
addALU operation
Read 3 isStore
PC address Read
data 1
Read
Instruction register 2 Zero
Write Read
result Address
Read
memory data 2
Write Data
data
memory
data
isItype !isStore
16 32
ALUSrc
Sign isItype MemRead
extend
isLoad
**Based on original figure from [P&H CO&D, COPYRIGHT Architecture des ordinateurs, nov. 2023 98
2004 Elsevier. ALL RIGHTS RESERVED.]
Datapath for Non-Control-Flow Insts.
Add
Read 3 ALU operation isStore

PC address Read
data 1
Read
Write Read
result Address
Read
memory data 2
Write Data
data
memory
data
isItype !isStore
16 32
ALUSrc
Sign isItype MemRead
extend
isLoad
MemtoReg
isLoad
Control Flow Instructions
Unconditional Jump Instructions
n Assembly
J immediate26
n Machine encoding
J immediate J-type
6-bit 26-bit
n Semantics
if MEM[PC]==J immediate26
target = { PC[31:28], immediate26, 2’b00 }
PC ← target

Unconditional Jump Datapath
isJ Add
PCSrc
4
X ALU operation
Read 3 0
PC address Read
data 1
Read
Write Read
result Address
Read
memory data 2
concat Write Data
data
?
memory
RegWrite Write
data
ALUSrc
0 16 32
Sign X MemRead
extend
**Based on original figure from [P&H CO&D, COPYRIGHT 0

if MEM[PC]==J immediate26
PC = { PC[31:28], immediate26, 2’b00 }
What about JR, JAL, JALR?
102
Conditional Branch Instructions
n Assembly (e.g., branch if equal)
BEQ rsreg rtreg immediate16
n Machine encoding
BEQ rs rt immediate I-type

n Semantics (assuming no branch delay slot)

if MEM[PC]==BEQ rs rt immediate16
target = PC + 4 + sign-extend(immediate) x 4
if GPR[rs]==GPR[rt] then PC ← target
else PC ← PC + 4

Conditional Branch Datapath (for you to finish)
watch out
PC + 4 from instruction datapath
Add
PCSrc Add Sum Branch target
4
Shift
left 2
Read
PC address subALU operation
Read 3
Instruction register 1
Read
Instruction data 1
Read
Instruction register 2 To branch
memory Registers ALU bcond
Zero
concat Write control logic
register
Read
data 2
Write
data
RegWrite
16 0 Sign
32
extend
How to uphold the delayed branch semantics?

Putting It All Together
PCSrc1=Jump
left 2
26 28 0 1
PC+4 [31– 28] M M

u u
x x
ALU
Add result 1 0
Add
Jump left 2
4 Branch
MemRead
Control MemtoReg
ALUOp
MemWrite
ALUSrc
RegWrite

Read register 1
PC address Read
Read
register 2 Zero
bcond
[31– 0] 0 Read
u M
1 Write x Data
data x
1 memory 0
Write
data
16 32
control
**Based on original figure from [P&H CO&D, COPYRIGHT 2004 Elsevier. Architecture des ordinateurs, nov. 2023 105
ALL RIGHTS RESERVED.] JAL, JR, JALR omitted
Single-Cycle Control Logic
Single-Cycle Hardwired Control
n As combinational function of Inst=MEM[PC]
31 26 21 16 11 6 0

31 26 21 16 0

31 26 0

6-bit 26-bit
n Consider
q All R-type and I-type ALU instructions
q LW and SW
q BEQ, BNE, BLEZ, BGTZ
q J, JR, JAL, JALR

Single-Bit Control Signals
When De-asserted When asserted Equation

GPR write select GPR write select opcode==0
RegDest according to rt, i.e., according to rd, i.e.,
inst[20:16] inst[15:11]
2nd ALU input from 2nd 2nd ALU input from sign- (opcode!=0) &&
ALUSrc GPR read port extended 16-bit (opcode!=BEQ) &&
immediate
(opcode!=BNE)
Steer ALU result to GPR steer memory load to opcode==LW
MemtoReg
write port GPR wr. port
GPR write disabled GPR write enabled (opcode!=SW) &&
(opcode!=Bxx) &&
RegWrite
(opcode!=J) &&
(opcode!=JR))
JAL and JALR require additional RegDest and MemtoReg options
Single-Bit Control Signals
When De-asserted When asserted Equation

Memory read disabled Memory read port opcode==LW
MemRead return load value
Memory write disabled Memory write enabled opcode==SW
MemWrite
According to PCSrc2 next PC is based on 26- (opcode==J) ||

PCSrc1 bit immediate jump (opcode==JAL)
target
next PC = PC + 4 next PC is based on 16- (opcode==Bxx) &&
PCSrc2 bit immediate branch “bcond is satisfied”
target

JR and JALR require additional PCSrc options
ALU Control
n case opcode
‘0’ ⇒ select operation according to funct
‘ALUi’ ⇒ selection operation according to opcode
‘LW’ ⇒ select addition
‘SW’ ⇒ select addition
‘Bxx’ ⇒ select bcond generation function
__ ⇒ don’t care
n Example ALU operations

q ADD, SUB, AND, OR, XOR, NOR, etc.
q bcond on equal, not equal, LE zero, GT zero, etc.

R-Type ALU
PCSrc1=Jump
left 2
26 28 0 1
PC+4 [31– 28] M M

u u
x x
ALU
Add result 1 0
Add
Jump left 2
4 Branch
MemRead
Control MemtoReg
ALUOp
MemWrite
ALUSrc
1
RegWrite
0
Read register 1
PC address Read
Read
register 2 bcond
Zero
[31– 0] 0 Read
u M
1 Write x Data
data x
1 memory 0
Write
data
16 32
0
Sign
ALU operation
funct
extend ALU
control
I-Type ALU
PCSrc1=Jump
left 2
26 28 0 1
PC+4 [31– 28] M M

u u
x x
ALU
Add result 1 0
Add
Jump left 2
4 Branch
MemRead
Control MemtoReg
ALUOp
MemWrite
ALUSrc
1
RegWrite
0
Read register 1
PC address Read
Read
register 2 bcond
Zero
[31– 0] 0 Read
u M
1 Write x Data
data x
1 memory 0
Write
data
16 32
0
Sign
ALU operation
opcode
extend ALU
control
**Based on original figure from [P&H CO&D, COPYRIGHT 2004 Architecture des ordinateurs, nov. 2023 112
Elsevier. ALL RIGHTS RESERVED.]
LW
PCSrc1=Jump
left 2
26 28 0 1
PC+4 [31– 28] M M

u u
x x
ALU
Add result 1 0
Add
Jump left 2
4 Branch
MemRead
Control MemtoReg
ALUOp
MemWrite
ALUSrc
1
RegWrite
0
Read register 1
PC address Read
Read
register 2 bcond
Zero
[31– 0] 0 Read
u M
1 Write x Data
data x
1 memory 0
Write
data
16 32
1
Sign
ALU operation
Add
extend ALU
control
SW
PCSrc1=Jump
left 2
26 28 0 1
PC+4 [31– 28] M M

u u
x x
ALU
Add result 1 0
Add
Jump left 2
4 Branch
MemRead
Control MemtoReg
ALUOp
MemWrite
ALUSrc
0
RegWrite
1
Read register 1
PC address Read
Read
register 2 bcond
Zero
[31– 0] 0 Read
X
M
X
memory x u
Instruction [15– 11] Write x u
1 data Data x
1 memory 0
Write
data
16 32
0
Sign
ALU operation
Add
extend ALU
control
Branch (Not Taken)
Some control signals are dependent
on the processing of data
PCSrc1=Jump
left 2
26 28 0 1
PC+4 [31– 28] M M

u u
x x
ALU
Add result 1 0
Add
Jump left 2
4 Branch
MemRead
Control MemtoReg
ALUOp
MemWrite
ALUSrc
0
RegWrite
0
Read register 1
PC address Read
Read
register 2 bcond
Zero
[31– 0] 0 Read
X
M
X
memory x u
1 data Data x
1 memory 0
Write
data
16 32
0
Sign
ALU operation
bcond
extend ALU
control
Branch (Taken)
Some control signals are dependent
on the processing of data
PCSrc1=Jump
left 2
26 28 0 1
PC+4 [31– 28] M M

u u
x x
ALU
Add result 1 0
Add
Jump left 2
4 Branch
MemRead
Control MemtoReg
ALUOp
MemWrite
ALUSrc
0
RegWrite
0
Read register 1
PC address Read
Read
register 2 bcond
Zero
[31– 0] 0 Read
X
M
X
memory x u
1 data Data x
1 memory 0
Write
data
16 32
0
Sign
ALU operation
bcond
extend ALU
control
Jump
Instruction [25– 0] Shift Jump address [31– 0] PCSrc1=Jump

left 2
26 28 0 1
PC+4 [31– 28] M M

u u
x x
Add
RegDst
Jump
Shift
left 2
ALU
Add result
X 1 0
4
PCSrc2=Br Taken
Branch
MemRead
Control MemtoReg
ALUOp
MemWrite
ALUSrc
RegWrite
Read
register 1 0
0
PC address Read
Read
register 2 Zero
Instruction 0 Registers Read ALUbcond
[31– 0] 0 ALU
M Write data 2 result Address Read 1
u M
X
X
Write x
X
1 data Data x
1 memory 0
Write
data
16 32
extend ALU
ALU operation
0
X
control
What is in That Control Box?
n Combinational Logic à Hardwired Control
q Idea: Control signals generated combinationally based on
instruction
q Necessary in a single-cycle microarchitecture…
n Sequential Logic à Sequential/Microprogrammed Control

q Idea: A memory structure contains the control signals
associated with an instruction
q Control Store

Evaluating the Single-Cycle
Microarchitecture
A Single-Cycle Microarchitecture
n Is this a good idea/design?
n When is this a good design?
n When is this a bad design?
n How can we design a better microarchitecture?

A Single-Cycle Microarchitecture: Analysis
n Every instruction takes 1 cycle to execute
q CPI (Cycles per instruction) is strictly 1
n How long each instruction takes is determined by how long

the slowest instruction takes to execute
q Even though many instructions do not need that long to
execute
n Clock cycle time of the microarchitecture is determined by

how long it takes to complete the slowest instruction
q Critical path of the design is determined by the processing
time of the slowest instruction

What is the Slowest Instruction to Process?
n Let’s go back to the basics
n All six phases of the instruction processing cycle take a single

machine clock cycle to complete
q Fetch 1. Instruction fetch (IF)
q Decode 2. Instruction decode and
q Evaluate Address register operand fetch (ID/RF)
q Fetch Operands 3. Execute/Evaluate memory address (EX/AG)
q Execute 4. Memory operand fetch (MEM)
5. Store/writeback result (WB)
q Store Result
n Do each of the above phases take the same time (latency)

for all instructions?
Single-Cycle Datapath Analysis
n Assume
q memory units (read or write): 200 ps
q ALU and adders: 100 ps
q register file (read or write): 50 ps
q other combinational logic: 0 ps
steps IF ID EX MEM WB
Delay
resources mem RF ALU mem RF
R-type 200 50 100 50 400

I-type 200 50 100 50 400
LW 200 50 100 200 50 600
SW 200 50 100 200 550
Branch 200 50 100 350
Jump 200 Architecture des ordinateurs, nov. 2023 200 123
Let’s Find the Critical Path
PCSrc1=Jump
left 2
26 28 0 1
PC+4 [31– 28] M M

u u
x x
ALU
Add result 1 0
Add
Jump left 2
4 Branch
MemRead
Control MemtoReg
ALUOp
MemWrite
ALUSrc
RegWrite

Read register 1
PC address Read
Read
register 2 bcond
Zero
[31– 0] 0 Read
u M
1 Write x Data
data x
1 memory 0
Write
data
16 32
control
[Based on original figure from P&H CO&D, COPYRIGHT 2004 Architecture des ordinateurs, nov. 2023 124
R-Type and I-Type ALU
PCSrc1=Jump
left 2
26 28 0 1
PC+4 [31– 28] M M

u u
x x
ALU
100ps
Add result 1 0
Add
Jump left 2
4 Branch
MemRead
Control MemtoReg
ALUOp
100ps
MemWrite
ALUSrc
RegWrite

Read register 1
PC Read
200ps
address
data 1
250ps
register 2 bcond
Zero
[31– 0] 0 Read
Instruction register M data
400ps
u M
memory x u
Instruction [15– 11] u
350ps
1 Write x Data
data x
1 memory 0
Write
data
16 32
control
[Based on original figure from P&H CO&D, COPYRIGHT Architecture des ordinateurs, nov. 2023 125
LW
PCSrc1=Jump
left 2
26 28 0 1
PC+4 [31– 28] M M

u u
x x
ALU
100ps
Add result 1 0
Add
Jump left 2
4 Branch
MemRead
Control MemtoReg
ALUOp
100ps
MemWrite
ALUSrc
RegWrite

Read register 1
PC Read
200ps
address
data 1
250ps
register 2 bcond
Zero
[31– 0]
550ps
M Write data 2 0 Address Read
result data 1
Instruction u register M
u M
600ps 350ps
1 Write x Data
data x
1 memory 0
Write
data
16 32
control
SW
PCSrc1=Jump
left 2
26 28 0 1
PC+4 [31– 28] M M

u u
x x
ALU
100ps
Add result 1 0
Add
Jump left 2
4 Branch
MemRead
Control MemtoReg
ALUOp
100ps
MemWrite
ALUSrc
RegWrite

Read register 1
PC Read
200ps
address
data 1
250ps
register 2 bcond
Zero
[31– 0] 0 Read
u M
350ps 550ps
1 Write x Data
data x
1 memory 0
Write
data
16 32
control
Branch Taken
PCSrc1=Jump
left 2
26 28 0 1
200ps
PC+4 [31– 28] M M
u u
100ps ALU
Add result 1
x x
0
Add
Jump left 2
4 Branch
MemRead
Control MemtoReg
ALUOp
350ps
MemWrite
ALUSrc
RegWrite
PC
Read
register 1
Read
350ps
200ps
address
data 1
250ps
register 2 bcond
Zero
[31– 0] 0 Read
u M
1 Write x Data
data x
1 memory 0
Write
data
16 32
control
Jump
PCSrc1=Jump
left 2
26 28 0 1
PC+4 [31– 28] M M

u u
100ps ALU
Add result 1
x x
0
Add
Jump left 2
4 Branch
MemRead
Control MemtoReg
ALUOp
200ps
MemWrite
ALUSrc
RegWrite

Read register 1
PC Read
200ps
address
Read
register 2 bcond
Zero
[31– 0] 0 Read
u M
1 Write x Data
data x
1 memory 0
Write
data
16 32
control
Control Logic for MIPS FSM
Microprogrammed Control for MIPS FSM
Microprogrammed vs. Hardwired Control
n Advantages
n Disadvantages
n You should be very familiar with this right now

Chapitre 6
Hiérarchie de la mémoire
Contenu
Mémoire d’un système moderne
Technologies des mémoires (SRAM, DRAM)
Hiérarchie mémoire
Mémoire cache
Mémoire dans un système moderne
L2 CACHE 1
L2 CACHE 0
SHARED L3 CACHE
DRAM INTERFACE
CORE 0 CORE 1
DRAM BANKS
DRAM MEMORY
CONTROLLER
L2 CACHE 2
L2 CACHE 3
CORE 2 CORE 3

Critères d’une mémoire idéale
n Temps d’accès nul (latence)
n Capacité infinie
n Coût nul
n Bande passante infinie (support des accès multiples en
parallèle)

Critères sont contradictoires
n Plus grande capacité ⇒ plus lente
q plus de temps pour déterminer la localisation de la cellule
mémoire
q Plus de temps pour transférer son contenu
n Plus rapide ⇒ plus chère

q Technologie mémoire: SRAM, DRAM, Disque et Bande (Tape)
n Plus grande passante ⇒ plus chère

q Plus de puces (bank), plus de ports, plus grande fréquence,
et/ou technologie plus rapide

Technologie mémoire : Cellule DRAM
n Dynamic Random Access Memory
n Etat de la charge de la capacité indique la valeur stockée
q Capacité est chargée ou déchargée ⇒ valeur est 1 ou 0
q 1 capacité
q 1 transistor d’accès à la capacité
n A cause des fuites, au bout d’un certain temps la capacité

perd sa charge
q La cellule DRAM perd sa charge row enable
q La cellule DRAM a besoin d’être rafraichie
_bitline
Technologie mémoire : Cellule SRAM
n Static Random Access Memory
n Deux inverseurs permettent le stockage d’un bit
q Le chemin du retour permet de mémoriser la valeur dans la
cellule
q 4 transistors pour le stockage
q 2 transistors pour l’accès
row select
_bitline
bitline

Organisation d’une puce mémoire
Row Decoder
bit-cell array
Address 2n
n+m bits n
2n rows x 2m columns
(n≈m to minimize
overall latency)
2m
m-k
Column Decoder
2k

Exercice
Considérons une mémoire RAM d’une capacité de 24 bits.
Supposons qu’elle est organisée sous forme d’un tableau de
4 lignes et 6 colonnes et qu’un mot mémoire est composé
de 3 bits.
a) Dessiner l’organisation de cette mémoire
b) Dessiner le décodeur ligne
c) Dessiner le décodeur colonne
d) Dessin le tableau sachant que la cellule de base est :
q DRAM
q SRAM

DRAM vs. SRAM
n DRAM
q Accès plus lent (capacité)
q Densité plus grande (cellule = 1 transistor + 1 capacité)
q Coût plus faible
q Rafraîchissement (énergie, performance, circuiterie)
q Processus de fabrication : capacités et transistors
n SRAM
q Accès plus rapide (sans capacité)
q Densité plus faible (cellule = 6 transistors)
q Coût plus élevé
q Pas de rafraîchissement
q Processus de fabrication : transistors sans capacités
Contraintes des mémoires
n Plus grande ⇒ Plus lente
q SRAM : 512 octets, ~ 100 ps (pico seconde)
q SRAM : 1K (Kilo) à 1M (Méga) octets, ~ 1 ns (nano seconde)
q DRAM : 1G (Giga) octets, ~ 50 ns
q Disque dur : 1T (Téra) Octets, ~ 10 ms (milli seconde)
n Plus rapide ⇒ plus chère

q SRAM : < 10$ par 1M octets
q DRAM : < 1$ par 1M octets
q Disque dur : < 1$ par 1G octets
n Autres technologies émergentes

q Flash memory, PC-RAM, MRAM, RRAM (pas encore mature)

n Caractéristiques d’une mémoire idéale
q accès rapide
q grande capacité (taille)
q Coût faible
n Ces caractéristiques sont contradictoires et ne peuvent pas

être réunies dans un seul niveau de la mémoire
n Idée :
q Avoir plusieurs niveaux de stockage (de plus en plus grands et
lents lorsqu’on s’éloigne du processeur)
q Garantir que la plupart des données référencées par le
processeur soient dans les niveaux les plus rapides
Transférer ce qui est utilisé ici Petite

Rapide
Moins chère par octet

Grâce à la localité des
Plus rapide par octet

références, la mémoire apparait
comme aussi rapide que le
premier niveau et aussi grande
que le dernier niveau
Grande
Sauvegarder tout ici Lente
Intérêt du cache
n Programme : instruction 1, 2, … et 200 (3 sections)
n Section 1 : instruction 1, 2, …, 90 1
n section 2 : instruction 91, 92,… et 100 (1000 itérations) Section 1
n Section 3 : instruction 101, 102, … et 200
90
boucle
Section 2
(1000 fois)
100
n Quel est le pourcentage des instructions de la section 2 Section 3

par rapport à celles du programme ?
n Quel est le pourcentage du temps d’exécution des 200
instructions de la section 2 par rapport à celui du
Programme
programme en entier ?
n Où mémoriser ce programme ?
Hiérarchie de la mémoire d’un ordinateur
Main
Memory Hard
CPU Cache Disk
(DRAM)
RF

Localité des références
n Principe général : le passé est un ”bon” indicateur
d’anticipation du future proche (profile)
q Localité temporelle
q Localité spatiale
n Cas d’un programme : un programme typique a beaucoup
de localités de références (composé de boucles)
q Localité temporelle: Un programme a tendance à référencer la
même référence plusieurs fois dans une période de temps,
q Localité spatiale: Un programme a tendance à référencer des
références appartenant à une même zone mémoire (plusieurs
localisations) dans une période de temps
n Exemples :
q Exécutions des instructions (séquentielles, boucles)
q Accès aux données (tableau, pile, fichier, …)
Mémoire cache (le cache)
n Cache : Mémoire rapide qui exploite le principe de la
localité des références. Elle permet de sauvegarder une
copie des :
q données accédées récemment (localité temporelle)
q adresses adjacentes aux adresses récemment accédées
(localité spatiale)
n Gestion du cache
q Divisée en blocs de tailles identiques
q Accès d’une référence en lecture
n accès à une référence implique le transfert de tout le bloc qui la
contient au cache
q Accès d’une référence en écriture
n Cohérence des données entre le cache et la RAMrincipale:
n Copie simultanée d
n Copie en différé Architecture des ordinateurs, nov. 2023
148
Hiérarchie du cache
n Le cache doit être étroitement intégré au pipeline
q Idéalement l’accès doit prendre un cycle d’horloge
n Pipeline performant implique une grande mémoire cache
q Ce qui risque de prendre plusieurs cycles d’horloge
n Solution : Hiérarchie cache
Main
Level 2 Memory
CPU Level1 Cache (DRAM)
RF Cache

Gestion manuelle vs. automatique
n Manuelle: Le programmeur gère les transferts des données à
travers les niveaux
q Tâche difficile pour les programmes longs
q Cas des premiers ordinateurs (années 50)
q Cas de certains processeurs embarqués
n Automatique: Le matériel gère les transferts de données à

travers les niveaux
q Simplification de la tâche du programmeur
q Transparence au programmeur : il n’a pas besoin de connaître
la taille ni le fonctionnement du cache

Hiérarchie mémoire moderne
Register File
32 words, sub-nsec
manual/compiler
Memory register spilling
L1 cache
Abstraction ~32 KB, ~nsec
L2 cache
512 KB ~ 1MB, many nsec Automatic
HW cache
L3 cache, management
.....
Main memory (DRAM),

GB, ~100 nsec
automatic
Swap Disk
demand
100 GB, ~10 msec paging
Example : Intel Pentium 4
n Technology : 90nm
n Frequency : 3.6 GHz
n L1 D-cache
q Capacity = 16 KB
q Access time = 4 cycles int / 9 cycles fp
n L2 D-cache
q Capacity = 1 MB
q Access time = 18 cycles int / 18 cycles fp
n Main memory
q Capacity = 8 GB
q Access time = ~ 50ns or 180 cycles

Chapitre 7
Gestion de la mémoire cache
Contenu
Recherche d’une référence
Structure du cache
Correspondances
directe, associative et associative par ensemble
Stratégies de remplacement
aléatiire, FIFO, LRU, …
Cache : Rappel
n composant qui mémorise les résultats utilisés fréquemment
afin d’éviter le temps de latence dû à l’accès à la RAM
(exemple : cache web)
n Bloc : Unité of stockage dans le cache et RAM d’une taille
fixe
Bloc 0
Bloc 1
Bloc 0
Bloc 1
…
…
Bloc n
CPU
Cache
Bloc m
RAM
Recherche d’une référence
n Lorsqu’une donnée est référencée par le CPU, le contenu de son
adresse est recherché dans la mémoire des étiquettes (Tag store):
1. Si la donnée n’est pas dans le cache (Miss) alors on transfère le
bloc qui la contient de la RAM vers le cache
2. Sinon
3. On accède à la donnée de la cache
n Choix importants de la conception d’un cache

q Placement : où et comment placer un bloc dans le cache ?
q Replacement: quel bloc remplacer pour laisser de la place ?
q Granularité de gestion: quelle taille des blocs, uniforme ?
q Politique d’écriture: comment écrire dans les blocs du cache ?
q Instructions/données: doivent elles avoir des caches différentes ?

Structure du cache
Cache
Address
Tag Store Data Store
(is the address

in the cache?
+ bookkeeping)
Hit/miss ? Data
Cache hit rate = # hits / # accesses = # hits / (# hits + # misses)

Accès au cache
n Chaque bloc correspond à une localisation dans le cache
déterminée par les bits de l’adresse
n 3 types de correspondances :
q directe
q Associative
q associative par ensemble
n Exemple qui illustrera les 3 correspondances dans la suite de ce

chapitre :
q RAM = 256 octets adressables par octet ⇒ adresse = 8 bits
q Cache = 64 octets
q bloc = 8 octets ⇒ RAM = 32 blocs et Cache = 8 blocs

Schéma de l’exemple illustratif
0
1
2
3
4
5
6
7
8
9
10
11
12
0 13
1 14
2 15
3 16
4 17
Transfert 5 Transfert 18
CPU (octet)
6
7 (bloc) 19
20
Cache 21
22
23
24
n Soit a = 01011010 une adresse référencée par le CPU 25
26
n Où se trouve a dans la RAM ? 27
28
n Lorsque a est référencée, où sera transféré le bloc qui 29
30
contient a dans le cache ? 31

RAM
158
Correspondance directe
0
n Le bloc k de la RAM est transféré 1
2
au bloc (k mod 8) du cache 3
4
5
6
7
8
9
10
étiquette bloc 11
12
0 13
1 14
2 15
3 01
16
4 17
5 18
6
7
… 19
20
Cache 21
22
23
24
25
n Soit a = 01011010 une adresse 26
27
étiquette bloc octet 28
29
30
01 011 010 31

RAM
159
Coresp. directe : recherche d’une référence
étiquette bloc octet
a 01 011 010
n Recherche de la référence a (contenu de l’adresse a)

q Aller au bloc du cache désigné par le champ ”bloc” de a
q Si l’étiquette du bloc ≠ champ ”étiquette” de a alors
n Transférer le bloc de la RAM
n Mettre le champ ”étiquette” de a dans étiquette
q Récupérer le contenu de l’octet désigné par le champ ”octet”
de a
n Que se passe-t-il si les blocs suivants sont référencés ?

0, 8, 0, 8, 0, 8, 0, 8
Correspondance associative
0
n Le bloc k de la RAM est transféré à n’importe 1
2
quel bloc (k mod 8) du cache 3
4
5
… 6
7
8
9
10
étiquette bloc 11
12
0 13
1 14
2 15
3 01011 16
4 17
5 18
6 19
7
… 20
Cache 21
22
23
24
25
27
étiquette octet 28
29
30
01011 010 31

RAM
161
Corresp. associative : recherche d’une référence
n Recherche de la référence a (contenu de l’adresse a)
q Si le champ ”étiquette” de a ne correspond à aucune étiquette
du cache alors
n Transférer le bloc qui contient a au cache de manière associative
n Mettre le champ ”étiquette” dans le cache
de a
n Si le cache est plein, quel est le bloc qui sera remplacé ?
n Quelle est la meilleure correspondance (directe ou

associative) ?

Stratégies de remplacement
n Qu’arrive-t-il si le cache est plein et on veut transférer un
nouveau bloc (remplacer un bloc) ?
q Random
q FIFO (First In Fist Out)
q LRU (Least Recently Used) how to implement?
q Not most recently used
q Least frequently used?
q Least costly to re-fetch?
q Hybrid replacement policies
q Optimal replacement policy?

Correspondance associative par ensemble
0
n Le bloc k de la RAM est transféré à n’importe 1
2
quel bloc de l’ensemble (k mod 4) du cache 3
4
5
6
7
8
9
10
étiquette bloc 11
12
0
1
} ens 0 13
14
2
3 } ens 1 15
16
4
5 } ens 2 17
18
6 …
7 010 } ens 3 19
20
Cache 21
22
23
24
25
27
étiquette ensemble octet 28
29
30
010 11 010 31

RAM
164
Correspondance associative par ensemble :
recherche d’une référence
n Recherche d’une référence a (contenu de l’adresse a)
q Aller à l’ensemble désigné par le champ ”ensemble” de a
q Si le champ ”étiquette” de a ne correspond à aucune étiquette
de l’ensemble alors
n Transférer le bloc qui contient a au cache de manière associative
dans l’ensemble
n Mettre le champ ”étiquette” dans le cache
de a
n Si le cache est plein, quel est le bloc qui sera remplacé ?

Associativité par ensemble
n Cas particuliers de la correspondance associative par ensemble
q ∣ensemble∣= 1 bloc ⇒ correspondance directe
q ∣ensemble∣= ∣cache∣ ⇒ correspondance associative
n Degré d’associativité : Combien de blocs peuvent-ils correspondre au
même ensemble ?
n Augmentation du degré d’associativité :
q ++ augmentation du hit rate
q -- diminution du temps d’accès du cache
q -- augmentation du coût du matériel (plus de comparateurs)
hit rate
associativity
Fréquence de l’utilisation du cache
n Lorsque le CPU fait référence à une adresse (donnée ou
instruction), il doit faire :
q une comparaison d’étiquettes (correspondance direct)
q ou plusieurs comparaisons d’étiquettes (correspondance

associatives)
n Problème : surcharge (overhead) ⇒ Ralentissement du

temps de traitement
n Solution : pour réduire le temps des comparaisons, un

circuit spécialisé est utilisé pour sauvegarder les étiquettes.
Il est appelé une mémoire associative ou mémoire adressée
par contenu.
Annexe : MARS
(Mips Assembly and Runtime
Simulator)
Interface MARS
Boutons et vitesse d’exécution
Registre/
Edit/Execute Coproc 1/
Coproc 0
Message/ Run I/O

Registres
n $zero : valeur nulle constante

n $at : assembler temporaly réservé
n $v0 et $v1 : retour des arguments de fonctions
n $a0,…,$a3 : arguments des fonctions
n $t0,…,$t9 : temporaires
n $s0,…,$s9 : saved temporarly pour les appels de fonctions
n $k0 et $k1 : kernel réservés
n $gp : global area pointer
n $sp : stuck pointer
n $fp : frame pointer
n $ra : return adress
n pc : Program counter (ou IP : Instruction pointer)
réservé
n hi : partie supérieure
n lo : partie inférieure
Premier programme
.data
monMessage: .asciiz "Mon premier message"
.text
li $v0,4 # v0 ß4
la $a0,monMessage # a0 ß
monMessage
syscall # appel système

Exercice 1
• Créer un nouveau fichier qui contiendra votre premier programme en langage
d’assemblage (File/new)
• Editer le programme précédent dans l’onglet de la fenêtre Edit
• Sauvegarder le programme dans un fichier (File/Save as ..)
• Assembler (Run/Assemble) et voir le contenu de l’onglet Mars Messages
• Exécuter le programme (Run/Go) et voir le contenu des onglets Mars
Messages et run I/O
• Identifier la localisation des données (Data Segment) et du programme (Text
Segment)
• Modifier la représentation des adresses et des valeurs (Hexadecimal Adresses,
Hexadecimal Values et ASCII)
• Modifier la vitesse d’exécution du programme (Run speed 1 inst/sec)
• Exécuter le programme étape par étape (Run/Step) et voir l’évolution des
contenus des registres utilisés
Interface MARS (Onglet Edit)

Interface MARS (Onglet Execute)

Addition
.data
nombre1: .word 15 # déclaration du premier terme entier
nombre2: .word 3 # déclaration du deuxième terme entier
message: .asciiz "Somme= " # déclaration du message
.text
lw $t0, nombre1 # t0 <-- (nombre 1)
lw $t1, nombre2 # t1 <-- (nombre 2)
add $t2, $t0, $t1 # t2 <-- (t0) + (t1)
li $v0,4 # afficher la message

la $a0,message
syscall
li $v0, 1 # afficher la somme
add $a0, $zero, $t2
syscall
Exercice 2
n Localiser les valeurs des variables dans la section .data.
n Modifier le programme pour afficher :
Nombe1 + nombre2 = somme
n Exécuter le programme pour :
nombre1=2147483649 et nombre2=3
nombre1=2147483647 et nombre2=1
n Modifier le programme pour effectuer le produit en
utilisant :
uniquement l’addition.
la multiplication.
n Exécuter le dernier programme en prenant :
nombre1=0x100000 et nombre2=0x1000

Exercice 3 : Qu’affiche ce programme ?
.data
a: .word 3 # nombre
b: .word 5 # exposant
.text
lw $t0, a # charger a dans un registre
lw $t1, b # charger b dans un registre
li $t2, 1 # initialiser le résultat à 1
boucle : beq $t1, $zero, affiche # tant que t1 != 0

mul $t2, $t0, $t2 # multiplier le résultat par a
subi $t1, $t1, 1 # retrancher 1 de b
j boucle # se brancher à l'adresse
boucle
affiche : li $v0,1
add $a0, $zero, $t2 # imprimer le produit
syscall
Exercice 4
• Ecrire un programme en langage d’assemblage pour le

calcul du n! où n est un entier naturel.
n! = n x (n-1) x … 2 x 1
n sera saisie au clavier.
TP pour le lundi 9 janvier en groupe

Formats d’instructions de Mips
3 types :



6-bit 26-bit

Exemples de codage
R-type
Add $t2, $t0, $t1 # t2 ß (t0) + (t1)
0109502016 = 0000 0001 0000 1001 0101 0000 0010 00002
---rs--- ---rt--- ---rd---
I-type
li $v0, 4 # v0 ß 4
3c2402000416 = 0010 0100 0000 0010 0000 0000 0000 01002
---rs--- ---rt--- ---------
immediate----------
J-type
J boucle # aller à l’adresse boucle
0810000516 = 0000 1000 0001 0000 0000 0000 0000 01012
---code-- ----------------
immediate----------------

ArcOrdPartie I Nov 2019

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

ArcOrdPartie I Nov 2019

Transféré par

Droits d'auteur :

Formats disponibles

Architectures des ordinateurs

Mohsine Eleuldj eleuldj@emi.ac.ma

Architecture des ordinateurs, nov. 2023 3

n Quiz et Contrôle avec SAB (Save Exam Browser)

Architecture des ordinateurs, nov. 2023 4

III ISA et microarchitecture 30

VI Hiérarchies de la mémoire 133

VII Gestion de la mémoire cache 156

Annexe : MARS 168

Architecture des ordinateurs, nov. 2023 5

La salle de prière peut accueillir 25 000 fidèles d'une superficie totale de

La mosquée Hassan II est l'une des plus grandes mosquées du monde, et

Architecture des ordinateurs, nov. 2023 7

Architecture des ordinateurs, nov. 2023 8

n Regarder en arrière (passé)

Comment un ordinateur utilise-t-il des

Architecture des ordinateurs, nov. 2023 12

n L’abstraction améliore la productivité

n Pourquoi avons nous besoin de connaître ce qui se passe

n Qu'arrive-t-il si le programme que vous avez écrit :

n Qu'arrive-t-il si le matériel que vous avez conçu est :

n Qu'arrive-t-il si vous voulez concevoir un système :

*Die photo credit: AMD Barcelona

Memory Performance Hog

DRAM DRAM DRAM DRAM

Architecture des ordinateurs, nov. 2023 17

Architecture des ordinateurs, nov. 2023 18

n Les stratégies d'ordonnancement DRAM ne sont pas adaptées

q Circuits ? ISA (Architecture)

Architecture des ordinateurs, nov. 2023 20

n Cependant, si vous maîtriser le matériel et le logiciel, vous

Architecture des ordinateurs, nov. 2023 21

Pile de calcul Runtime System

n Considérer de nouvelles applications

n Permettre des solutions satisfaisantes aux problèmes

n Plusieurs problèmes difficiles sont dûs à cette transition

n Des réponses définitives à ces problèmes ne sont pas

Architecture des ordinateurs, nov. 2023 27

Hybrid Memory Cube

Heterogeneous Persistent Memory/Storage

n Vous pourriez inventer de nouveaux paradigmes pour le

n Recommended book: Thomas Kuhn,

Architecture des ordinateurs, nov. 2023 29

Architecture des ordinateurs, nov. 2023 31

n Traitement séquentiel des instructions

Architecture des ordinateurs, nov. 2023 32

Unité de contrôle RAM : Registre d'adresse mémoire

a) Instruction de chargement immédiat

b) Instruction de branchement conditionnel

Architecture des ordinateurs, nov. 2023 34

n Question : Ce modèle est-t-il la seule manière avec laquelle

n Réponse : Non. Mais c'est le paradigme de calcul de la

Architecture des ordinateurs, nov. 2023 35

Architecture des ordinateurs, nov. 2023 36

n Représentation d'un nœud flot de données

Architecture des ordinateurs, nov. 2023 38

Architecture des ordinateurs, nov. 2023 39

Entrées : N (nombre entier) et 1

Quelle est la valeur de out ?

Architecture des ordinateurs, nov. 2023 40

n Critères du choix (tradeoffs) des 2 modèles ISA :

Architecture des ordinateurs, nov. 2023 42

Architecture des ordinateurs, nov. 2023 43