CEG 3556: Conception Avancée de Systèmes

Informatiques (Hiver 2022)

Prof. Rami Abielmona
Solutions Potentielles pour Quiz #2: Processeur
à Cycle Simple

16 Mars, 2022

Instructions
Ce quiz durera 35 minutes. Veuillez accomplir la question suivante, et répondez
au meilleur de vos capacités. Énoncez tous les prétentions et acronymes qui
sont utilisés dans le quiz, et n’oubliez pas de soumettre votre questionnaire sur
Brightspace.

Question I
Cette question se concerne avec la conception du processeur a pipeline.

1
Solution

1 2
7
8
9
5

Figure 1: Datapath avec indexes

2
 Registre 1 Nom (Index)
Solution pour LW $12, 100($2): Registres entre stages: Bloque de ressource:
I-Type, OpCode=0x23, Rs=2, Rt=12 Immediate=100 Registre 2 Inputs Outputs
... Description
Fetch IF/ID Décode ID/EX Exécute EX/MEM Mémoire MEM/WB WriteBack
Mémoire Registres (2) ALUSrc=1 Mux de WB (6) Mémoire de données (8) MemToReg Mux (9)
d’instructions (1) ALUOp=Add
Branche=0
RegWrite=0 Read Data 1=$2 RegDst=0 Input0=12 Output=12 MemRead=1 ReadData Input0=$2+100 Output
MemRead=1
$PC Instruction Read Register 1=2 Read Data 2=$12 Input1=0 MemWrite=0 MemWrite=0 =M[$2+100] Input1 =M[$2+100]
RegDst=0 RegWrite=1
Read Register 2=12 Adresse=$2+100 =M[$2+100]
Branche=0 MemToReg=1
L’instruction qui se trouve WriteData=$12 MemToReg=1
MemRead=1
dans l’adresse $PC de la Rs est lit comme spécifié dans l’instruction. MemWrite=0 Rt=12 est choisi comme registre de
mémoire d’instructions est Noter que le deuxième Read Register est write back. L’adresse calculée est envoyée à Le mot lu de la mémoire est
Instruction
lue. 12 et Read Data 2 est $12, mais ceci n’est la mémoire de données. $12 se sélectionné comme information à
pas important puisqu’on ne l’utilise pas. RegWrite=1 trouve aussi à l’entrée WriteData écrire dans le registre.
RegWrite=1
Mux d’OpB (5) MemToReg=1 mais sera ignoré puisque
MemToReg=1
MemWrite=0
Registres (2)
Sign Extend (3) Input0=$12 Output=100
Input1=100 WriteData=M[$2+100]
$PC+4 ALUSrc=1 ReadData= WriteRegister=12
Instruction[15-0]=100 Output=100
M[$2+100]
Immediate est choisi comme OpB de $PC+4+ShitLeft2(100)
L’instruction[15-0] est convertie en 32 bits, Finalement, le mot qui a été cherché
l’ALU. (Pas Important)
en gardant le signe. Read Data 1=$2 dans la mémoire est écrit au registre
Rt=12, ce qui complète l’instruction
Unité de Contrôle (4) ALU (7)
Read Data 2=$12
OpCode=0x23 ALUSrc=1 OpA=$2 Zéro=0 Zéro=0
ALUOp=Add SignExtend = 100 OpB=100 ALUResult=$2+100 $2+100
RegDst=0 ALUOp=Add
$PC+4 Branch=0
MemRead=1
MemWrite=0 L’adresse qui doit être envoyée à la
Instruction[20-16]=12 mémoire de données est calculée. ALUResult=$2+100
RegWrite=1
MemToReg=1
WriteBack
Les signaux de contrôle appropriés sont Register=12
déterminés d’après l’instruction Instruction[15-11]=0 WriteBack Register=12
 Registre 1 Nom (Index)
Solution pour instruction Add $5, $1, $3: Registres entre stage: Bloque de ressource:
R-Type, OpCode=0x00, Rs=5, Rt=1, Rd=3, Funct=0x20, Shamt=0 Registre 2 Inputs Outputs
... Description
Fetch IF/ID Décode ID/EX Exécute EX/MEM Mémoire MEM/WB WriteBack
Mémoire Registres (2) ALUSrc=0 Mux de WB (6) MemToReg Mux (9)
d’instruction (1) ALUOp=Funct
Branche=0
RegWrite=0 Read Data 1=$5 RegDst=1 Input0=1 Output=3 Input0=$5+$1 Output=M[$5+$1]
MemRead=0
$PC Instruction Read Register 1=5 Read Data 2=$1 Input1=3 MemWrite=0 Input1=M[$5+$1]
RegDst=1 RegWrite=1
Read Register 2=1 MemToReg=1
Branche=0 MemToReg=0
L’instruction qui se trouve MemRead=0
dans l’adresse $PC de la Rs et Rt sont lu, comme spécifie l’ MemWrite=0 Rd=3 est choisi comme registre de La somme qui a été calculéé à l’étape
mémoire d’instructions est instruction. write back. exécute est selectionnéé.
Instruction
lue.
RegWrite=1 RegWrite=1
Unité de Contrôle (4) MemToReg=0 Mux d’OpB (5) MemToReg=0 Registres (2)
OpCode=0x00 ALUSrc=0 Input0=$1 Output=$1 WriteData=$5+$1
ALUOp=Funct Input1=0x00001420 WriteRegister=3
RegDst=1 ALUSrc=1 ReadData=
$PC+4
Branch=0 M[$5+$1]
MemRead=0 Finalement, la somme qui a été calculéé
Rt est choisi comme OpB. $PC+4+ShitLeft2(100) à l’étape exécute est écrite au registre 3.
MemWrite=0
(Pas Important) Ceci complète l’instruction.
RegWrite=1 Read Data 1=$5
MemToReg=0
Read Data 2=$1 ALU (7)
Les signaux de contrôle appropriés sont
déterminés d’après l’instruction. Le code
pour l’ALU est déterminé par funct, ce qui OpA=$5 Zéro=0 Zéro=0
SignExtend=
est normal pour les instructions type R. OpB=$1 ALUResult=$5+$1 $5+$1
0x00001420
Dans ce cas, il est évident que ALUOp sera ALUOp=Add
(Pas Important)
$PC+4 éventuellement Add.
La somme de Rs + Rt est calculée.
ALUResult=$5+$1
Instruction[20-16]=1
WriteBack
Register=3
Instruction[15-11]=3 WriteBack Register=3