Architecture interne

du microprocesseur
Cours 07
Plan de la séance
Types de processeurs
Processeurs à l'étude INF1600
Implémentation de l’UAL
Notation RTN
Encodage des instructions

INF1600: Architecture des micro-ordinateurs 2

Plan de la séance
Types de processeurs
Processeurs à l'étude INF1600
Implémentation de l’UAL
Notation RTN
Encodage des instructions

INF1600: Architecture des micro-ordinateurs 3

 Approches pour l’encodage des instructions
• Il y a deux grandes approches:
• CISC: complex instruction set computing (ordinateur
à jeu d'instruction complexe (architecture x86))
• RISC: reduced instruction set computing (ordinateur
à jeu d'instructions réduit (ARM, PIC))
• Dans le cas du RISC, il est possible de faire qu’une tâche
par instructions, contrairement au CISC. Ainsi, le
programme RISC sera plus long que celui du CISC.
• L’encodage et le décodage des instructions avec le RISC
est plus simple et plus rapide que pour le CISC. Pour le
CISC les instructions peuvent avoir des formats
différents.

4
 Types d’architecture de jeu d'instructions (ISA)

Types de processeurs
Distinction entre RISC et CISC
• CISC: Complex Instruction Set Computer
• Cherche à réduire le nombre de lignes d’instructions assembleur (coût
de la mémoire)
• Le matériel compense en exécutant en dur des instructions complexes
• Permet d’exploiter un compilateur moins complexe
• Ex. MC68000, x86
• RISC: Reduced Instruction Set Computer
• Développe le matériel autour d’un ensemble réduit d’instructions
• Les instructions complexes peuvent être recomposées (par plusieurs
sous-instructions)
• Le compilateur fait le gros du travail
• Ex. ARM, MIPS, RISC-V

INF1600: Architecture des micro-ordinateurs 5

Types de processeurs
Distinction entre RISC et CISC
• CISC: Complex Instruction Set Computer
Instructions à largeur variable
• Moins utilisé de nos jours
• RISC: Reduced Instruction Set Computer
• Instructions à largeur fixe
• Dominant (utilisé même dans les x86/x64
récents)
NISC Technology and Toolset, University of California Irvine, [en ligne: [Link]
consulté le 2009/11/11

mPC : micro-controlleur de IR = Instruction Register

programme counter Décodeur : convertit
mPM : micro-mémoire instruction en signaux de ctrl

INF1600: Architecture des micro-ordinateurs 6

 Que représente cette image?
• MonarQ est bien un ordinateur équipé d’un
processeur quantique supraconducteur de
24 qubits, conçu à Montréal par Anyon
Systems qui réside à l’École de technologie
supérieure (ÉTS) ([Link])
• Il a été inauguré officiellement le 25
septembre 2024, au sein de Calcul Québec,
avec le soutien financier du gouvernement
fédéral et du gouvernement du Québec
• Il a une fidélité de qubit de 99,8 % et une
durée de cohérence de 32 ns, typiques des
technologies quantiques supraconductrices

INF1600: Architecture des micro-ordinateurs 7

 Écosystème du Quantique au Québec
Organisation / Entreprise Statut Localisation Activité principale
Pasqal (Canada) Privée Sherbrooke Fabrication d’ordinateurs quantiques (~100 qubits)
Quandela Privée Sherbrooke Informatique quantique photonique
Correction d’erreurs quantiques à base de codes
Nord Quantique Privée Sherbrooke
bosoniques
Anyon Systems Privée Montréal Ordinateurs supraconducteurs sur site + logiciels
Projet mixte (Privé + Ordinateur quantique supraconducteur (24 qubits)
MonarQ (Anyon/Calcul Québec) Montréal
Académique) accessible via Calcul Québec
Catalyseur de l’écosystème quantique québécois
OSBL / Zone
DistriQ Sherbrooke Zone DistriQ : Hub rassemblant +40 acteurs du
d’innovation
quantique (entreprises, laboratoires, centres)
Plateforme pour la commercialisation du quantique, en
PINQ² OSBL Québec
partenariat avec DistriQ
Consortium Accès matériel, simulation, formation, soutien en
Calcul Québec Montréal
universitaire informatique quantique

8 INF1600: Architecture des micro-ordinateurs

Types de processeurs
Processeur load-store Processeur registre-memory
• Distingue les accès mémoire et les • Permet de combiner des accès mémoire,
traitements ALU et a toujours un des accès registres et des traitements ALU
nombre fixe d’opérandes. en plus de permettre des opérations sur
• Typique des architectures RISC un nombre variable d’opérandes
• Ex: ARM, MIPS, RISC-V (Code Machine) • Typique des architectures CISC
• M[ADR2]  M[ADR2] + R[Rc] se faire • Ex. x86 (IA-32 AT&T)
en 3 instructions (ou plus): • M[Rb]  M[Rb] + R[Rc] est possible en une
instruction
• ACC  M[ADR1]
• ACC  ACC + R[Rc]
• M[ADR2]  ACC

INF1600: Architecture des micro-ordinateurs 9

Assembleur et langage machine Selon vous, quand
l’encodage est-il fixe et
quand est-il variable?
Assembleur
• L’ASM est un langage bas niveau (très proche de la machine)
• L’ASM est spécifique à une architecture de processeur (ARM  RISC-
V  x86) 0x0207
• Requiert une connaissance de l’architecture interne du processeur 0x010A
(au moins celle dite vue du programmeur, L3) 0x0008
0x010A
Langage machine 0x0009
• Une instruction ASM se traduit (typiquement avec de l’encodage) 0x030B
en une instruction en LM 0x0400
• Le LM est une traduction binaire de l’ASM (souvent présenté en
hexadécimal)
• Il existe différents types d’encodage: à longueur fixe et à longueur
variable
INF1600: Architecture des micro-ordinateurs 10
Types de processeurs

Instructions taille fixe Instructions taille variable

• Typique des architectures RISC • Typique des architectures CISC
• Ex: Code Machine • Ex. x86 (IA-32 AT&T)
• dec %eax pourrait s’encoder sur 3 octets :
Instruction Encodage Description 0x48 0xFF 0xC0
add ADR 0x00XX ACC  ACC + Mémoire[ADR] opcode : décrémentation
sub ADR 0x01XX ACC  ACC - Mémoire[ADR]
opadd : effet sur un registre
mul ADR 0x02XX ACC  ACC × Mémoire[ADR]
reg : registre à modifier
st ADR 0x08XX Mémoire[ADR]  ACC
ld ADR 0x07XX ACC  Mémoire[ADR] • movl %eax, 4(%ebx) pourrait ’encoder sur
stop 0x13XX Arrêt du programme 6 octets :
br ADR 0x0DXX PC  ADR 0x8B 0x1D 0x04 0x00 0x00 0x00
brz ADR 0x0EXX ACC = 0 ? PC  ADR : PC  PC + 1 opcode : move d’un registre à la mémoire
brnz ADR 0x0FXX ACC != 0 ? PC  ADR : PC  PC + 1 opadd : source eax, dest ebx + offset
offset : valeur de l’offset

INF1600: Architecture des micro-ordinateurs 11

Types de processeurs
Philosophie des processeurs RISC
• Une instruction par cycle (idéalement, pas toujours le cas sur architecture très
simple comme Heuring à 1 bus)
• Largeur d’instruction fixe
• Accès mémoire en charge/décharge uniquement (load-store)
• Modes d’adressages simplifiés
• Moins d’instructions, des instructions simples
• Chargement et branchement différés
• Préchargement d’instructions et exécution spéculative
• Confier le travail au compilateur

INF1600: Architecture des micro-ordinateurs 12

Types de processeurs
Comparaison : MIPS vs RISC-V vs ARM
• MIPS est principalement utilisée dans
l'enseignement et dans des systèmes
spécialisés, mais elle est moins courante
dans les produits modernes.
• RISC-V est une architecture moderne,
open-source, avec un énorme potentiel de
croissance dans les applications de
recherche, l'IoT et les systèmes embarqués.
• ARM est la plus populaire et largement
utilisée dans les appareils mobiles, les
systèmes embarqués, et plus récemment,
dans les serveurs, en raison de sa faible
consommation d'énergie et de son
écosystème riche.

INF1600: Architecture des micro-ordinateurs 13

Types de processeurs
RISC-V
RISC-V (prononcé "Risk Five") est une ISA de type RISC qui a été conçue pour être
ouverte, extensible et modulaire. Contrairement à d'autres architectures comme
x86 ou ARM, RISC-V est open-source, ce qui permet à n'importe qui de l'utiliser, de
la modifier et de l'adapter à des besoins spécifiques sans avoir à payer de licences.
• Modulaire : architecture de base est simple avec possibilité d’utiliser des
extensions optionnelles
• Extensible : possibilité d'ajouter facilement de nouvelles instructions
personnalisées (extensions spécifiques à l'application) (ex : IA)
• Versatile : possibilité d’utilisation pour différents types de processeurs, allant des
microcontrôleurs pour les objets connectés (IoT) jusqu'aux processeurs haute
performance
• Adoption en croissance : par exemple, Google, NVIDIA, Western Digital et
d'autres, ont commencé à adopter et à intégrer RISC-V dans leurs produits
INF1600: Architecture des micro-ordinateurs 14
Plan de la séance
Types de processeurs
Processeurs à l'étude INF1600
Implémentation de l’UAL
Notation RTN
Encodage des instructions

INF1600: Architecture des micro-ordinateurs 15

Processeur de Heuring
Contrôle et chemin de données à un bus interne

Format des instructions

INF1600: Architecture des micro-ordinateurs 16

Processeur de Heuring
Processeur de Heuring versus
Architecture de von Neumann

Unité de
contrôle

Unité
Arithmétique et
Entrées Logique (UAL) Sorties

BUS
Unité de
Mémoire

INF1600: Architecture des micro-ordinateurs 17

Processeur de Heuring
Processeur de Heuring à 1 bus interne
(chemin de données)
31 0 <31..0>
R0 31 0
registres PC Program Counter
à usage 32
général

31 0 Instruction Register
R31 IR
(aussi CIR pour Current Instruction Register)
ADD Registers
SUB
AND 31 0
Memory Address
A
OR Accumulator (AC) (aussi MAR pour Memory Address Register)
31 0
SHR MA

Mémoire
A B
SHRA 31 0
UAL
SHL C
MD
[Link]
Memory Data
SHC 12 (aussi MDR pour Memory Data Register)
31 0
NOT C
NEG
Computation
C=B (aussi CR pour Computation Register)
INC4 Computer Systems Design and Architecture (Vincent P. Heuring et Harry F. Jordan).

INF1600: Architecture des micro-ordinateurs 18

Processeur de Heuring
31 0 <31..0>
R0 31 0
Exemple d’instruction arithmétique: GPR 32
PC

• R[2]  R[0] + R[1]

31 0
R31 IR

Avant Après
31 0
R[0] 10 10 A
31 0
10 12 MA
R[1] 12 12

Memory
A B

ALU 31 0
MD
R[2] 13 22 C

31 0 22
C

Combien de cycles pour exécuter cette

instruction assembleur?

INF1600: Architecture des micro-ordinateurs 19

 Processeur de Heuring
31 0 <31..0>
Exemple de déplacement de données: R0 31
PC
0

GPR
• R[2]  M[1] 32

31 0
R31 IR
Avant Après Avant Après

R[0] 10 10 M[0] 120 120 31 0

A
31 0
R[1] 12 12 M[1] 122 122 MA

Memory
A B

ALU 31 0
R[2] 13 122 M[2] 123 123 MD
C

31 0
C
Combien de cycles pour exécuter cette
instruction assembleur?

INF1600: Architecture des micro-ordinateurs 20

Processeur de Heuring
Mémoire
01 IF CONDITION 31 0 <31..0>
Exemple de branchement: 02 INST #1
R0 31
PC
0

GPR
• PC  #ADDR 03 INST #2 32

04 INST #3
31 0
ELSE R31 IR
Important pour réaliser: 05 INST #4
• Des structures conditionnelles 06 INST #5
31 0
07 INST #6
• Des boucles END IF
A
31 0
• Des fonctions 08 INST #7 MA

Memory
A B
01 IF CONDITION 01 IF CONDITION
02 INST #1 05 INST #4 ALU 31 0
03 INST #2 06 INST #5 MD
04 INST #3 07 INST #6 C
08 INST #7 08 INST #7

31 0
C

Condition Condition
remplie pas remplie

INF1600: Architecture des micro-ordinateurs 21

 Opcode Inst. Arguments Description
1 ld ra, c2 Charger depuis une adresse absolue ; rb est le registre 0.

Processeur de 1
2
3
ld
ldr
st
ra, c2(rb)
ra, c1
ra, c2
Charger depuis une adresse avec déplacement.
Charger depuis une adresse relative.
Stocker à une adresse absolue ; rb est le registre 0.

Heuring 3
4
5
st
str
la
ra, c2(rb)
ra, c1
ra, c2
Stocker à une adresse avec déplacement.
Stocker à une adresse relative.
Charger l'adresse absolue dans ra ; rb est le registre 0.
5 la ra, c2(rb) Charger l'adresse avec déplacement dans ra.
Instructions 6
12
lar
add
ra, c1
ra, rb, rc
Charger l'adresse relative dans ra.
Additionner rb et rc, stocker le résultat dans ra.
13 addi ra, rb, c2 Additionner rb et une constante immédiate, stocker le résultat dans ra.
14 sub ra, rb, rc Soustraire rc de rb, stocker le résultat dans ra.
Inst. de Op c3(2:0) Arg. Conditions
15 neg ra, rc Calculer le complément à deux de rc et stocker le résultat dans ra.
branch. code
22 or ra, rb, rc OU logique entre rb et rc, stocker le résultat dans ra.
brnv 8 0 Jamais
23 ori ra, rb, c2 OU logique entre rb et une constante immédiate, stocker le résultat dans ra.
brlnv 9 0 ra Jamais
20 and ra, rb, rc ET logique entre rb et rc, stocker le résultat dans ra.
Enreg. PC dans ra
br 8 1 rb Toujours vers rb 21 andi ra, rb, c2 ET logique entre rb et une constante immédiate, stocker le résultat dans ra.
brl 9 1 ra, rb Toujours vers rb 24 not ra, rc Calculer le NON logique de rc et stocker le résultat dans ra.
Enreg. PC dans ra 26 shr ra, rb, c3 Décaler rb vers la droite dans ra d’un nombre de bits constant c3.
brzr 8 2 rb, rc Si R[rc] = 0 26 shr ra, rb, rc Décaler rb vers la droite dans ra d’un nombre de bits contenu dans rc ; c3 est 0.
brlzr 9 2 ra, rb, rc Si R[rc] = 0 27 shra ra, rb, c3 Décalage arithmétique à droite de rb dans ra par c3 bits.
Enreg. PC dans ra Décalage arithmétique à droite de rb dans ra par le nombre de bits contenu dans rc ; c3 est
27 shra ra, rb, rc
brnz 8 3 rb, rc Si R[rc] ≠ 0 0.
brlnz 9 3 ra, rb, rc Si R[rc] ≠ 0 28 shl ra, rb, c3 Décaler rb vers la gauche dans ra de c3 bits.
Enreg. PC dans ra 28 shl ra, rb, rc Décaler rb vers la gauche dans ra d’un nombre de bits contenu dans rc ; c3 est 0.
brpl 8 4 rb, rc Si R[rc] ≥ 0 29 shc ra, rb, c3 Rotation circulaire à gauche de rb dans ra par c3 bits.
brlpl 9 4 ra, rb, rc Si R[rc] ≥ 0 29 shc ra, rb, rc Rotation circulaire à gauche de rb dans ra par le nombre de bits contenu dans rc ; c3 est 0.
Enreg. PC dans ra
brmi 8 5 rb, rc Si R[rc] < 0 rb, rc, c3 ou Sauter à l'adresse contenue dans rb si rc satisfait la condition c3
8 or 9 br ou brl Sauter à rb si rc satisfait c3 et enregistrer PC dans ra
brlmi 9 5 ra, rb, rc Si R[rc] < 0 ra, rb, rc, c3 Voir tableau complémentaire
Enreg. PC dans ra
0 nop Aucune opération (insertion d’une bulle dans le pipeline)
31 stop Arrêter le programme

INF1600: Architecture des micro-ordinateurs 22

 Ici, on prend donc 3 cycles
Processeur de Heuring pour faire le EXECUTE.

Chemin de données à 1 bus interne : opération arithmétique

Ex : exécution de R[2]  R[2] + R[1]
31 0 <31..0>
R0 31 0
registres PC
à usage 32
1. Lecture R[2] (rb) et écriture dans Reg A
général
2. Lecture R[1] (rc) et addition avec Reg A et on écrit dans Reg C
31
IR
0 3. Écriture de C dans R[2] (ra)
R31

opcode ra rb rc c3
31 0
A opcode : code de l’instruction = 12
31 0 ra: registre destination = 2
MA

Mémoire
A B rb : deuxième registre source = 2
31 0
UAL
MD
rc : deuxième registre source = 1
C c3 : unused
31 0
C

Computer Systems Design and Architecture (Vincent P. Heuring et Harry F. Jordan).

INF1600: Architecture des micro-ordinateurs 23

Processeur de Heuring
Chemin de données à 1 bus interne : « fetch »
31 0
R0
<31..0> 31 0 Chargement de l’instruction dans Reg IR à partir de l’adresse dans Reg PC
registres PC
à usage 32
1. Écriture de Reg PC dans Reg MA, Écriture de PC + 4 dans Reg C
général
2. Lecture en mémoire et chargement de la donnée lue dans Reg MD,
31
IR
0 Écriture de C dans Reg PC (pour prochaine instruction)
R31
3. Écriture de MD dans Reg IR

31 0
A
31 0
MA

Mémoire
A B

UAL 31 0
MD
C
Considérant que le décode se faire de
31 0 manière asynchrone (donc ne consomme
C
aucune cycle), quel est le CPI de
R[2]  R[2] + R[1] ?
Computer Systems Design and Architecture (Vincent P. Heuring et Harry F. Jordan).

INF1600: Architecture des micro-ordinateurs 24

Processeur de Heuring
Chemin de données à 1 bus interne : chargement de données
31 0
R0
registres
<31..0> 31 0 Ex : exécution de R[2]  M[1]
PC
à usage 32
1. Chargement de l’adresse absolue 1 (c3) dans Reg MA
général
2. Lecture en mémoire et chargement de la donnée lue dans Reg MD
R31
31
IR
0
3. Écriture de MD dans R[2] (ra)

31 0 opcode ra rb c3
A
31 0 opcode : code de l’instruction = 1
MA
ra: registre destination = 2

Mémoire
A B

UAL 31
MD
0 rb : unused
C c3 : adresse absolue = 1
31 0
Quel est le CPI de
C R[2]  M[1] ?

Computer Systems Design and Architecture (Vincent P. Heuring et Harry F. Jordan).

INF1600: Architecture des micro-ordinateurs 25

Processeur de Heuring
Chemin de données à 2 bus internes : opération arithmétique
Bus A Bus B

Ex : exécution de R[2]  R[2] + R[1]

<31..0> 31 0 <31..0>
R0
registres
32 à usage
général
32 1. Bus B = Lecture R[2] (rb), Bus A = Écriture de la donnée lue dans Reg A
2. Bus B = Lecture R[1] (rc) et addition avec A,
R31
31 0 Bus A = Écriture dans R[2] (ra)
IR

31 0
PC
opcode ra rb rc c3
31 0
MA
opcode : code de l’instruction = 12
Mémoire

31 0 ra: registre destination = 2

MD

31 0
rb : deuxième registre source = 2
A
rc : deuxième registre source = 1
A B c3 : unused
UAL
C

Computer Systems Design and Architecture (Vincent P. Heuring et Harry F. Jordan).

INF1600: Architecture des micro-ordinateurs 26
Processeur de Heuring
Chemin de données à 3 bus internes : opération arithmétique
Bus C Bus A Bus B

<31..0> 31 0 <31..0> <31..0>

R0
registres
à usage
Ex : exécution de R[2]  R[2] + R[1]
32 32 32
général 1. Tout peut se faire en une étape:
R31
Bus A = lecture R[2] (rb), Bus B = lecture R[1] (rc) et addition
31
IR
0 et Bus C = écriture R[2] (ra)
31 0
PC
opcode ra rb rc c3
31 0
MA
Mémoire opcode : code de l’instruction = 12
31
MD
0 ra: registre destination = 2
rb : deuxième registre source = 2
rc : deuxième registre source = 1
A B
c3 : unused
UAL
C

Computer Systems Design and Architecture (Vincent P. Heuring et Harry F. Jordan).

INF1600: Architecture des micro-ordinateurs 27

 Instruction Encodage Description
Processeur-accumulateur add ADR
sub ADR
0x00XX
0x01XX
ACC  ACC + Mémoire[ADR]
ACC  ACC - Mémoire[ADR]
ACC  ACC × Mémoire[ADR]
(CodeMachine) mul ADR
st ADR
ld ADR
0x02XX
0x03XX
0x04XX
Mémoire[ADR]  ACC
ACC  Mémoire[ADR]
stop 0x05XX Arrêt du programme
br ADR 0x07XX PC  ADR
Memory brz ADR 0x08XX ACC = 0 ? PC  ADR : PC  PC + 1
+1 brnz ADR 0x09XX ACC != 0 ? PC  ADR : PC  PC + 1
data_in
1 PC 8 16 16 1 16
A ALU ACC op_alu opération
1 data_out 16
0 addr 0 0 B+A
0 B 1 B–A
8
IR 16 2 BXA
set_jump_pc

sel_acc_data
8

wr_pc wr_ir instructionsel_mem_addr wr_mem wr_acc

op_alu

Compteur 3 états :
• Fetch : sel_mem_addr = 1, wr_ir = 1
• Décode : décodage de l instruction pour génération des signaux de contrôle
• Execute : sel_mem_addr = 0 + selection des bonnes valeurs pour les signaux de contrôle en bleu selon instruction acc
(sel_jump_source = 1 si pas branchement et 0 si branchement)

INF1600: Architecture des micro-ordinateurs 28

 Instruction Encodage Description
add ADR 0x00XX ACC  ACC + Mémoire[ADR]
ACC  ACC - Mémoire[ADR]
Processeur-ACC-MA
sub ADR 0x01XX
mul ADR 0x02XX ACC  ACC × Mémoire[ADR]
st ADR 0x08XX Mémoire[ADR]  ACC
ld ADR 0x07XX ACC  Mémoire[ADR]

(CodeMachine) stop
br ADR
brz ADR
0x13XX
0x0DXX
0x0EXX
Arrêt du programme
PC  ADR
ACC = 0 ? PC  ADR : PC  PC + 1
brnz ADR 0x0FXX ACC != 0 ? PC  ADR : PC  PC + 1
Instruction + Encodage Description
shl 0x10XX ACC  ACC << 1
1 shr 0x11XX ACC  ACC >> 1
Memory
adda ADR 0x03XX MA  MA + Mémoire[ADR]
+1 0 suba ADR 0x04XX MA  MA - Mémoire[ADR]
data_in
1 PC 1 addx 0x05XX ACC  ACC + Mémoire[MA]
8 16 A ALU ACC 16
1 data_out 16
subx 0x06XX ACC  ACC - Mémoire[MA]
0 0 addr 0 lda ADR 0x09XX MA  Mémoire[ADR]
2 1
8
B
1 sta ADR 0x0AXX Mémoire[ADR]  MA
IR 16 0
MA 16 ldi 0x0BXX ACC  Mémoire[MA]
0 sti 0x0CXX Mémoire[MA]  ACC
sel_mem_data
sel_mem_addr
sel_pc_source

sel_acc_data
sel_ma_source
op_alu opération
alu_b_source

wr_pc wr_ir instruction wr_mem wr_acc wr_ma 0 B+A

op_alu
1 B–A
Compteur 3 états :
• Fetch : sel_mem_addr = 1, wr_ir = 1 2 BXA
• Décode : décodage de l instruction pour génération des signaux de contrôle
• Execute : sel_mem_addr = 0 ou 2 + selection des bonnes valeurs pour les signaux de contrôle en bleu selon instruction acc
3 B << 1
(sel_pc_source = 1 si pas branchement et 0 si branchement)
4 B >> 1

INF1600: Architecture des micro-ordinateurs 29

Processeur de Heuring versus
Processeur Accumulateur-MA

31 0 <31..0>
R0 31 0
registres PC 1
à usage Memory
32
général 0
+1
data_in
31 0 1
1 PC 8 16 16
R31 IR A ALU ACC
1 data_out 16
0 0 addr 0
2 1 B
8 1
31 0 MA 16
IR 16 0
A 0

sel_mem_data
sel_mem_addr
sel_pc_source
31 0 8

sel_acc_data
sel_ma_source
MA Mémoire

alu_b_source
A B

UAL 31 0 wr_pc wr_ir instruction wr_mem

op_alu wr_acc wr_ma
MD
C
Compteur 3 états :
31 0 • Fetch : sel_mem_addr = 1, wr_ir = 1
C • Décode : décodage de l instruction pour génération des signaux de contrôle
• Execute : sel_mem_addr = 0 ou 2 + selection des bonnes valeurs pour les signaux de contrôle en bleu selon instruction acc
(sel_pc_source = 1 si pas branchement et 0 si branchement)

INF1600: Architecture des micro-ordinateurs 30

 Processeur PolyRISC
Quel est le 16

CPI? 16
0
1

12 16 2
16 data_in 8

5 rdst
16
wr_reg

rsrc1 A A 8 addr
5 16
+1 0
12 12 addr dout 28 28 F 16 dout
1 16 din 16

rsrc2 B 16 B
5 wmem

PC inst_memory IR
4+4 registers ALU data_memory
op alu NZ
do_branch wr_pc wr_ir sel_reg_data wr_reg wr_mem
Unité de contrôle

Neumann
ou Harvard?

INF1600: Architecture des micro-ordinateurs 31

 Neumann

Processeur x86 simplifié ou Harvard?

Voici une correspondance entre le signal de contrôle UAL et

Contrôle et chemin de données l'opération réalisée en sortie :
•0 → X : La sortie de l'UAL prend la valeur de X.
•1 → Y : La sortie de l'UAL prend la valeur de Y.
•2 → X + Y : L'UAL effectue une addition entre X et Y.
•3 → X - Y : L'UAL effectue une soustraction entre X et Y.
•4 → X << Y : Décalage à gauche de X par Y bits.
•5 → X >> Y : Décalage à droite de X par Y bits.
•6 → Y + 4 : Ajout de 4 à Y.
•7 → Y - 4 : Soustraction de 4 à Y.
…
Bits 31-24
Bits 23-21 Bits 20-18 Bits 17-15 Bits 14-13 Bits 12-0 Bits 23-0
(Opcode)
Code UAL Registre Valeur
Registre Registre
destination - immédiate -
source B source C
/ source A
Code Accès Registre
Registre Registre
mémoire destination Échelle Offset -
base B index C
/ source *
Code saut Offset
- - - -
d’adresse

*Le registre A peut aussi est une adresse mémoire directe pour des opérations
mémoire-mémoire

INF1600: Architecture des micro-ordinateurs 32

Processeur x86 simplifié Ici, on prend donc 2 cycles
pour faire le EXECUTE.
Contrôle et chemin de données

Ex : exécution de R[2]  R[2] + R[1]

1. Charger R2 dans l'UAL (côté X)
2. Charger R1 dans l'UAL (côté Y), effectuer l’addition et
écrire le résultat dans R2

Combien de cycle pour le

« fetch »? Est-ce que c’est
parallélisable avec le
EXECUTE?

INF1600: Architecture des micro-ordinateurs 33

Processeur x86 simplifié
Contrôle et chemin de données
Cette architecture CISC permet des
opérations de type registre-mémoire

R0
R1 On pourrait associer
R2 les registre R0 à R7
aux registres utilisés
R3 en IA-32 AT&T
R4
R5
R6
R7

INF1600: Architecture des micro-ordinateurs 34

Processeur RISC-V
Contrôle et chemin de données
PCSrc

Mux
Add

Add
4
Shift
RegWrite
left 1

Instruction [19-15] Read

Read MemWrite
PC regi ster 1 Read
add ress Instruction [24-20] Read data 1
ALUSrc Zero Memto Reg
Instruction regi ster 2
[31-0] ALU ALU
Instruction [11-7] Write
Read Add ress Read
Inst ruction data 2 result data On y reviendra au cours 9

Mux
regi ster

Mux
mem ory
Write
data Regist ers
Write
Data
data
mem ory
32 64
Instruction [31-0] Imm ALU
Gen control MemRe ad

Instruction [30 ,14-12]

ALUOp

Computer Organization and Design RISC-V Edition (David A. Patterson & John L. Hennessy)

INF1600: Architecture des micro-ordinateurs 35

Notes pertinentes
• Voici un tableau sommaire comparatif des
architecture CISC 1 bus de données interne et
RISC avec 2 ou 3 bus de données.
• Notons qu’une architecture de Harvard se
définit par la présence de deux mémoires
séparées : l’une pour les instructions et
l’autre pour les données. Cette séparation
entraîne l’utilisation de deux bus distincts, ce
qui permet d’accéder aux instructions et aux
données en parallèle et améliore ainsi
l’efficacité du processeur.
• Dans les processeurs modernes (par ex. les CISC comme x86), cette séparation est rarement
complète : seule la cache L1 distingue instructions et données, tandis que la RAM (et les
caches L2/L3) reste partagée. On parle alors d’architecture Harvard modifiée.
• Références intéressantes :
• RISC-V BOOM
• Architecture Von Neumann et Harvard

INF1600: Architecture des micro-ordinateurs 36

Plan de la séance
Types de processeurs
Processeurs à l'étude INF1600
Implémentation de l’UAL
Notation RTN
Encodage des instructions

INF1600: Architecture des micro-ordinateurs 37

Implémentation de l’UAL
Processeur Heuring à un bus interne

« Tri-state buffer »
(ou buffer trois états)

INF1600: Architecture des micro-ordinateurs 38

Implémentation de l’UAL
Unité arithmétique et logique (UAL ou « ALU »)
• Plusieurs opérations possibles
• Mêmes entrées (souvent)
A
B
n n n 5
carry_in

additionneur « shifter » …
add/sub
n n

Sélection Multiplexeur (MUX)

d’opération n

INF1600: Architecture des micro-ordinateurs 39

Implémentation de l’UAL
Exemple 1:
Proposez une stratégie permettant de réduire la consommation d’énergie de l’UAL.

INF1600: Architecture des micro-ordinateurs 40

Implémentation de l’UAL
Exemple 1: solution
Proposez une stratégie permettant de réduire la consommation d’énergie de l’UAL.

A
B
n n n 5
carry_in
Deux solutions parmi tant d’autres (mais ce sont des techniques

additionneur « shifter » … avancées dont les avantages/inconvénients dépendent de plusieurs

facteurs) :
add/sub • On peut éliminer le MUX et utiliser des tri-state buffer
n n • On pourrait faire du clock clock gating. C’est une technique
pour réduire la consommation d'énergie de l'UAL, notamment en
désactivant l'horloge des parties inutilisées du circuit lorsque
add_select shift_select celles-ci ne sont pas sollicitées.
• Combiner plusieurs opérations arithmétiques dans le même bloc
n de logique combinatoire

INF1600: Architecture des micro-ordinateurs 41

 Implémentation de l’UAL
Processeur Heuring à un bus interne

B3 A3 B2 A2 B1 A1 B0 A0

Sub/Add’
ADD
SUB
AND
OR
SHR
X Y X Y X Y X Y
SHRA
Cout Cin Cout Cin Cout Cin Cout Cin SHL
S S S S SHC 12
NOT
S4 S3 S2 S1 S0 NEG
C=B
INC4
INF1600: Architecture des micro-ordinateurs 42
Plan de la séance
Types de processeurs
Exécution d'instructions
Processeurs à l'étude INF1600
Implémentation de l’UAL
Notation RTN
Encodage des instructions

INF1600: Architecture des micro-ordinateurs 43

Notation RTN (Register Transfer Notation)
Qu'est-ce que le RTN ?
• Langage formel pour décrire le comportement des instructions au niveau matériel
• Permet de spécifier les transferts de données entre registres, ALU et mémoire
À quoi sert le RTN
• Spécifier l’exécution des instructions (niveau instruction OU micro-instruction)
• Par exemple, pour une instruction ADD ra, rb, rc, on peut écrire en RTN : R[ra]←R[rb]+R[rc]
• Modéliser le fonctionnement du processeur
• On peut utiliser le RTN pour décrire le déroulement précis des cycles d’horloge et les déplacements de
données entre les registres et la mémoire.
• Concevoir et simuler des architectures avant implémentation matérielle
• Les concepteurs de processeurs utilisent RTN pour définir comment chaque instruction est exécutée au
niveau matériel avant de l’implémenter en circuits logiques.
Le RTN peut fonctionner à deux niveaux de granularité :
• Niveau instruction (RISC) → Une ligne RTN = instruction complète
• Niveau micro-instruction (CISC) → Plusieurs lignes RTN = décomposition

INF1600: Architecture des micro-ordinateurs 44

Notation RTN (Register Transfer Notation)
SRC (Simple RISC Computer) est un langage machine
Cela correspond à une liste binaire d’instructions exécutables
qui peuvent être interprétées soit par du matériel, soit par un
simulateur logiciel.
• SRC est un langage machine, c’est-à-dire une liste binaire
d’instructions exécutables
• RTN est un langage de description utilisé pour expliquer
comment ces instructions sont exécutées au niveau du
matériel (peut « spécifier » l’architecture du processeur).

Des compilateurs RTN existent pour de certains langages de

spécification (ex : VHDL), mais leur but varie : certains Ici, on utiliser le RTN pour
génèrent du code exécutable, d'autres servent à la vérification
ou à la simulation. modéliser le processeur

INF1600: Architecture des micro-ordinateurs 45

Notation RTN (Register Transfer Notation)
RTN Abstrait (Abstract RTN)
• Utilisé pour : Décrire les opérations d'une instruction sans se soucier des détails matériels (pipeline, bus, cycle
d’horloge, partage de ressources)
• Focus : Transferts de registres et opérations logiques/arithmétiques.
• Exemple pour l’instruction ADD ra, rb, rc : R[ra]←R[rb]+R[rc] (Pour le RISC → Une ligne RTN = instruction complète)
RTN Concret (Concrete RTN)
• Utilisé pour : Décrire les micro-opérations précises qui ont lieu au niveau matériel. Utile pour les concepteurs de
processeurs qui doivent organiser le pipeline, minimiser les conflits de bus et optimiser l’exécution.
• Focus : Organisation des bus, registres intermédiaires, cycles d’horloge, unités de calcul.
• Exemple pour l’instruction ADD ra, rb, rc (en supposant une architecture Heuring à 1 bus) :
• T1: A ← R[rb]
• T2: C ← A + R[rc]
• T3: R[ra] ← C
• Ici, on décrit précisément les étapes du cycle d’horloge, en montrant quels registres et bus sont impliqués.

INF1600: Architecture des micro-ordinateurs 46

Notation RTN
Exemple de distinction entre notation abstraite et concrète
• Abstrait:
IR  M[PC] : PC  PC+4; 31 0 <31..0> 31 0
• Concret:
R0
registres PC
Affectation à usage
général
32

MA  PC : C  PC+4 ; Cycle d’horloge 31 0

MD  M[MA] : PC  C ; R31 IR

IR  MD ; Concurrence
31 0
A
31 0
MA

Mémoire
A B

UAL 31 0
MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 47

Notation RTN
Distinction entre notation abstraite et concrète
• Abstrait:
IR  M[PC] : PC  PC+4; 31 0 <31..0> 31 0
• Concret:
R0
registres PC
à usage 32
général
MA  PC : C  PC+4 ; Instruction de 32 bits 31 0

MD  M[MA] : PC  C ; (4 octets) R31 IR

IR  MD ;
31 0
A
31 0
MA

Mémoire
A B

UAL 31 0
MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 48

Notation RTN
Distinction entre notation abstraite et concrète
• Abstrait:
31 0 <31..0>
R0 31 0
registres PC
à usage
IR  M[PC] : PC  PC+4;
32
général

• Concret:
31 0
Sur bus : PC R31 IR

MA  PC : C  PC+4 ; En parallèle : ALU INC4 et Load MA

Sur bus : C
MD  M[MA] : PC  C ;
31 0
A
En parallèle : Load PC et Load MD
IR  MD ;
31 0
MA

Mémoire
Sur bus : MD A B

UAL 31 0
Load IR MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 49

Notation RTN
Exemple 2:
Donnez le RTN concret du RTN abstrait suivant (processeur à un bus) :
IR  M[PC] : PC  PC+4; 31 0 <31..0> 31 0
R0

add (:=op=12): R[ra]  R[rb] + R[rc];

registres PC
à usage 32
général

31 0
R31 IR

31 0
A
31 0
MA

Mémoire
A B

UAL 31 0
MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 50

Notation RTN
opcode : code de l’instruction

Exemple 2: solution ra: registre destination

rb, rc : registres source
c3 : unused
Donnez le RTN concret du RTN abstrait suivant (processeur à un bus) :
IR  M[PC] : PC  PC+4; Chercher instr. 31 0 <31..0> 31 0
R0

R[ra]  R[rb] + R[rc];

registres PC
Exécuter instr. à usage 32
général

31 0
R31 IR
MA  PC : C  PC+4 ;
MD  M[MA] : PC  C ; 31 0
A
IR  MD ; 31
MA
0

A  R[rb];

Mémoire
A B

UAL 31 0

C  A + R[rc];
MD
C

R[ra]  C; 31
C
0

INF1600: Architecture des micro-ordinateurs 51

Notation RTN
Exemple 3:
Donnez le RTN concret du RTN abstrait suivant (processeur à un bus) :
st (:=op=3): M[disp]  R[ra]; 31 0 <31..0> 31 0
R0
registres PC
à usage 32
général

31 0
R31 IR

31 0
A
31 0
MA

Mémoire
A B

UAL 31 0
MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 52

Notation RTN
Exemple 3:solution opcode : code de l’instruction
ra: registre destination

Donnez le RTN concret du RTN abstrait suivant (un bus) : rb : 0

c2 : adresse (constante)

M[disp]  R[ra]; 31 0 <31..0> 31 0

R0
registres PC
à usage 32
général

MA  disp; # disp = IR<16..0> 31

IR
0
R31

MD  R[ra];
M[MA]  MD; 31
A
0

31 0
MA

Mémoire
A B

UAL 31 0
MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 53

Notation RTN
Exemple 4:
Donnez le RTN concret du RTN abstrait suivant (processeur à un bus) :
addi (:=op=13): R[ra]  R[rb] + c2; 31 0 <31..0> 31 0
R0
registres PC
à usage 32
général

31 0
R31 IR

31 0
A
31 0
MA

Mémoire
A B

UAL 31 0
MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 54

Notation RTN
opcode : code de l’instruction
ra: registre destination
Exemple 4: solution rb : registre source
c2 : valeur immédiate
Donnez le RTN concret du RTN abstrait suivant (un bus) :
R[ra]  R[rb] + c2; 31 0 <31..0> 31 0
R0
registres PC
à usage 32
général

A  R[rb]; 31
IR
0
R31

C  A + c2; # c2 = IR<16..0>
R[ra]  C; 31
A
0

31 0
MA

Mémoire
A B

UAL 31 0
MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 55

Notation RTN
Exemple 5:
Donnez le CPI du RTN abstrait suivant (processeur à un bus) :
addi (:=op=13): R[ra]  R[rb] + c2; 31 0 <31..0> 31 0
R0
registres PC
à usage 32
général

31 0
R31 IR

31 0
A
31 0
MA

Mémoire
A B

UAL 31 0
MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 56

Notation RTN
opcode : code de l’instruction
ra: registre destination
Exemple 5: solution rb : registre source
c2 : valeur immédiate
Donnez le CPI du RTN abstrait suivant (un bus) :
R[ra]  R[rb] + c2; R0
31 0 <31..0> 31 0
registres PC
à usage 32
général

MA  PC : C  PC+4 ; R31
31
IR
0

MD  M[MA] : PC  C ;
IR  MD ; 31
A
0

 R[rb]; CPI = 6 31 0
A MA

Mémoire
A B

 A + c2; # c2 = IR<16..0>
31 0
C UAL
C
MD

R[ra]  C; 31
C
0

INF1600: Architecture des micro-ordinateurs 57

Notation RTN
Exemple 6 :
Donnez le RTN concret du RTN abstrait suivant (processeur à un bus) :
br (:=op=8): PC  R[rb]; 31 0 <31..0> 31 0
R0
registres PC
à usage 32
général

31 0
R31 IR

31 0
A
31 0
MA

Mémoire
A B

UAL 31 0
MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 58

Notation RTN
opcode : code de l’instruction
ra: always unused for branch
rb : registre source (for branch destination)
Exemple 6 : solution rc : registre source (for condition, ici unused)
c3 : condition (ici condition = 1 donc always branch)
Donnez le RTN concret du RTN abstrait suivant (processeur à un bus) :
br (:=op=8): PC  R[rb]; 31 0 <31..0> 31 0
R0
registres PC
à usage 32
général

PC  R[rb]; 31
IR
0
R31

31 0
A
31 0
MA

Mémoire
A B

UAL 31 0
MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 59

Notation RTN Ici, la mémoire d’instruction est indépendante de celle des données.
On pourra paralléliser la récupération de l’instruction suivante et la
fin du travail sur les données!
Processeur x86 simplifié

Bits 31:24 Bits 23:21 Bits 20:18 Bits 17:15 Bits 14:13 Bits 12:0 Bits 23:0
Registre A
Registre B Registre C Valeur
Code UAL destination - -
source source immédiate
/ source
Code Registre A
Registre B Registre C
Accès destination Échelle Offset -
base Index
mémoire / source *
Adresse
Code Saut - - - - -
offset
*Le registre A peut aussi est une adresse mémoire directe pour des opérations mémoire-mémoire

Nbr de bits de
décalage
INF1600: Architecture des micro-ordinateurs 60
Notation RTN
Exemple 7 :
Donnez le RTN concret (x86 simplifié) de l’instruction:
R[ra]  R[ra] + R[rb]

INF1600: Architecture des micro-ordinateurs 61

Notation RTN
Exemple 7 : solution
Donnez le RTN concret (x86 simplifié) de l’instruction:
R[ra]  R[ra] + R[rb]
T  R[ra];
R[ra]  T + R[rb];

Si on considère aussi IR et EIP :

T  R[ra];
R[ra]  T + R[rb] : IR Mémoire1[EIP] : EIP  EIP + 4;

INF1600: Architecture des micro-ordinateurs 62

Notation RTN
Exemple 8 :
Donnez le RTN concret (x86 simplifié) de l’instruction:
Mémoire2[23 + R[1] + 8·R[2]]  R[0];

Note:
Mémoire2[deplacement + R[rb] + 2k ·R[rc]]  R[ra];

k = échelle =
nbr de bits de décalage à gauche
"00" : 20 = 1
"01" : 21 = 2
"10" : 22 = 4
"11" : 23 = 8
INF1600: Architecture des micro-ordinateurs 63
Notation RTN
Exemple 8 : solution
Donnez le RTN concret (x86 simplifié) de l’instruction:
Mémoire2[23 + R[1] + 8·R[2]]  R[0];

Note:
Mémoire2[deplacement + R[rb] + 2k·R[rc]]  R[ra];

T  R[2];
T  T << 3; (on a 3 = log2(8))
T  T + R[1];
MA  T + 23;
Mémoire2[MA]  R[0];

INF1600: Architecture des micro-ordinateurs 64

Notation RTN
Le registre A peut aussi est une adresse mémoire directe pour des
opérations mémoire-mémoire
Exemple 9 :
Donnez le RTN concret du RTN abstrait suivant
(x86 simplifié modifié):
Mémoire2[R[ra]]  Mémoire2[R[rb]];

INF1600: Architecture des micro-ordinateurs 65

Notation RTN L’ISA permet de faire des calculs d’adresse avec rb
et rc, mais ra doit contenir une adresse directe.

Mémoire2[R[ra]] 
Mémoire2[offset + R[rb] + 2k·R[rc]]; Le registre A peut aussi est une adresse mémoire directe pour des
opérations mémoire-mémoire
Exemple 9 : solution
Donnez le RTN concret du RTN abstrait suivant
(x86 simplifié modifié):
Mémoire2[R[ra]]  Mémoire2[R[rb]];

MA  R[rb];
T  Mémoire2[MA];
MA  R[ra];
Mémoire2[MA]  T;

INF1600: Architecture des micro-ordinateurs 66

Plan de la séance
Types de processeurs
Exécution d'instructions
Processeurs à l'étude INF1600
Implémentation de l’UAL
Notation RTN
Encodage des instructions

INF1600: Architecture des micro-ordinateurs 67

Encodage des instructions Combien
d’instructions
est-il possible
d’encoder?
Format des instructions du processeur Heuring
Types d’encodage 31 0 <31..0>
R0 31 0
registres PC
à usage 32
général

31 0
R31 IR

31 0
A
31 0
MA

Mémoire
A B
Type d’instructions
31 0
• UAL UAL
MD
C
• Accès mémoire (déplacement de données)
31 0
• Saut (branchement) C

INF1600: Architecture des micro-ordinateurs 68

 Encodage des instructions : Format des
instructions du processeur Heuring (p 22)
Encodage des instructions
opcode : code de l’instruction
Format des instructions du ra: registre destination (ou source pour certain store)

processeur Heuring opcode ra c1

Type 1 c1 : valeur immédiate ou un offset
31 0 <31..0>
R0 31 0
registres PC Opérations de load and store (add relative) avec ra, c1 et PC
à usage 32
général
opcode ra rb c2
31 0
R31 IR
Type 2 rb : registre source
c2 : valeur immédiate, un offset ou une adresse (constante)
31 0 Opérations impliquant un registre source et une constante
A
avec ra, rb et c2
31 0
MA
opcode ra rb rc c3
Mémoire
A B
31 0
UAL
MD rb : premier registre source
C
rc : deuxième registre source
31 0 Type 3 c3 : condition, compte ou constante
C
Opérations impliquant deux registres sources et une
constante avec ra, rb, rc et c3 et plus d’opérations de
branchements 69
INF1600: Architecture des micro-ordinateurs
Encodage des instructions
Format des instructions du processeur Heuring
Code UAL (encodage type 3)
• add (:=op=12): R[ra]  R[rb] + R[rc]
31 0 <31..0>
R0 31 0
registres PC

• sub (:=op=14): R[ra]  R[rb] - R[rc]

à usage 32
général

• neg (:=op=15): R[ra]  - R[rc] R31

31
IR
0

• and (:=op=20): R[ra]  R[rb] ∧ R[rc]

• or (:=op=21): R[ra]  R[rb] ∨ R[rc] 31
A
0

• not (:=op=22): R[ra]  ￢R[rc]

31 0
MA

Mémoire
A B
31 0
Rappel UAL
MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 70

Encodage des instructions
Format des instructions du processeur Heuring
Accès mémoire (encodage type 2)
• ld (:=op=1): R[ra]  M[disp]
31 0 <31..0>
R0 31 0
registres PC

• st (:=op=3): M[disp]  R[ra]

à usage 32
général

• la (:=op=20): R[ra]  disp R31

31
IR
0

disp = c2 (si rb = 0) 31 0
A
= rb + c2 (si rb /= 0) 31
MA
0

Mémoire
A B

UAL 31 0
MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 71

Encodage des instructions
Format des instructions du processeur
Heuring
31 0 <31..0>
R0 31 0
registres PC
à usage 32
général

31 0
R31 IR

31 0
A
31 0
MA

Mémoire
A B

UAL 31 0
MD
C

31 0
C

INF1600: Architecture des micro-ordinateurs 72

Encodage des instructions
Exemple 10 :
Quel est le type de l’instruction (processeur à un bus) :
add (:=op=12): R[ra]  R[rb] + R[rc]

INF1600: Architecture des micro-ordinateurs 73

Encodage des instructions
Exemple 10 : solution
Quel est le type de l’instruction (processeur à un bus) :
add (:=op=12): R[ra]  R[rb] + R[rc]

Type 3 (opération UAL)

INF1600: Architecture des micro-ordinateurs 74

Encodage des instructions
Exemple 11 :
Donnez l’encodage hexadécimal (processeur à un bus) de l’instruction:
R[5]  R[3] + R[12]

Rappel:
add (:=op=12): R[ra]  R[rb] + R[rc]

INF1600: Architecture des micro-ordinateurs 75

Encodage des instructions
Exemple 11 : solution
Donnez l’encodage hexadécimal (processeur à un bus) de l’instruction:
R[5]  R[3] + R[12]

Rappel:
add (:=op=12): R[ra]  R[rb] + R[rc]
01100 00101 00011 01100 0000 0000 0000

0110 0001 0100 0110 1100 0000 0000 0000

Rép.: 0x6146C000

INF1600: Architecture des micro-ordinateurs 76

Encodage des instructions
Exemple 12 :
Quel est le type de l’instruction (processeur à un bus) :
st (:=op=3): M[disp]  R[ra]

INF1600: Architecture des micro-ordinateurs 77

Encodage des instructions
Exemple 12 : solution
Quel est le type de l’instruction (processeur à un bus) :
st (:=op=3): M[disp]  R[ra]

Type 2 (opération transfert de données)

INF1600: Architecture des micro-ordinateurs 78

Encodage des instructions
Exemple 13 :
Donnez l’encodage hexadécimal (x86 simplifié) de
l’instruction:
R[1]  R[1] + R[2]
Note:
op=0x01: R[ra]  R[ra] + R[rb]

IR<31..24> IR<23..21> IR<20..18> IR<17..15> IR<14..13> IR<12..0>

0x01

INF1600: Architecture des micro-ordinateurs 79

Encodage des instructions
Exemple 13 : solution
Donnez l’encodage hexadécimal (x86 simplifié) de
l’instruction:
R[1]  R[1] + R[2]
Note:
op=0x01: R[ra]  R[ra] + R[rb]

IR<31..24> IR<23..21> IR<20..18> IR<17..15> IR<14..13> IR<12..0>

0x01 001 010 --- -- --…-

0000 0001 001 010 000 00 0000000000000

0000 0001 0010 1000 0000 0000 0000 0000
IR = 0x01280000

INF1600: Architecture des micro-ordinateurs 80

Encodage des instructions
Exemple 14 :
Donnez l’encodage hexadécimal (x86 simplifié) de
l’instruction:
Mémoire2[23 + R[5] + 8·R[6]]  R[4];

Note:
op=0x15 : Mémoire2[deplacement + R[rb] + 2k· R[rc]]  R[ra];

INF1600: Architecture des micro-ordinateurs 81

Encodage des instructions
Exemple 14 : solution
Donnez l’encodage hexadécimal (x86 simplifié) de
l’instruction:
Mémoire2[23 + R[5] + 8·R[6]]  R[4];
Note:
op=0x15 : Mémoire2[deplacement + R[rb] + 2k·R[rc]]  R[ra];

IR<31..24> IR<23..21> IR<20..18> IR<17..15> IR<14..13> IR<12..0>

0x15 100 101 110 11 0x17

0001 0101 100 101 110 11 0 0000 0001 0111

0001 0101 1001 0111 0110 0000 0001 0111
IR = 0x15976017

INF1600: Architecture des micro-ordinateurs 82