Aula3

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Aula 3: Revisão – MIPS Multiciclo
Professor: Leandro Marzulo
Arquiteturas Avançadas de Computadores
Implementação Multiciclo
Dividir as instruções em etapas
Cada etapa leva um ciclo de clock
É necessário balancear a quantidade de trabalho realizada em cada etapa/ciclo para que levem o mesmo tempo
O tempo do ciclo é dado pela etapa mais lenta
Restringir cada etapa a usar no máximo uma grande unidade funcional para q elas não precisem ser replicadas
Entre etapas
No final de uma etapa, armazenar dados que serão usados nas etapas seguintes de uma mesma instrução
Registradores especiais (invisíveis ao programador)
Dados usados em instruções posteriores são armazenados em elementos de estado visíveis (banco de registradores, PC, memória).
2
Etapas
Busca de instrução e incremento do PC (IF = Instruction Fetch)
Decodificação da instrução e acesso ao banco de registradores (ID = Instruction Decode)
Execução, computação do endereço de memória ou finalização de instruções de desvio condicional (EX)
Acesso a memória ou finalização de instruções do tipo R ou de lógica e aritmética com imediato (MEM)
Finalização de Leitura na Memória (WB = Write Back)
Instruções levam entre 3 e 5 ciclos!
3
ALU
Ctl
Caminho de Dados - Implementação Multiciclo
MDR
Read Register 1
Read Data 1
Read Register 2
Read Data 2
Write Register
Register File
Write Data
S.
Ext
[15-0]
16
32
A
B
4
28
PC + 4 [31-28]
<<2
26
AluOut
2
[5-0]
32
PCWriteCond
PCSource
PCWrite
AluOP
IorD
AluSrcB
MemRead
AluSrcA
[31-0]
Jump
Address
MemWrite
RegWrite
IRWrite
RegDst
MemReg
[25-0]
[15-11]
<<2
0
1
0
1
0
1
2
3
0
1
2
PC
0
1
Instruction
[31-26]
Instruction
[25-21]
Instruction
[20-16]
Instruction
[15-0]
Instruction
Register
Address
Read Data
Memory
Write Data
Zero
 
Result
0
1
4
Control
Instruções e etapas
Tipo R
Jump
Beq
LW
SW
IF
ID
EX
MEM
IF
ID
EX
IF
ID
EX
IF
ID
EX
MEM
IF
ID
EX
MEM
WB
5
Passo 1: Busca de instrução e incremento do PC (IF)
Use o PC para buscar a instrução e armazená-la no registrador de instruções (IR). Usar a ALU para incrementar o PC com 4 e armazenar o resultado de volta no PC.
Descrição em RTL (Register-Transfer Language):
	IR = Memory[PC];
	PC = PC + 4;
6
00
00
01
0
0
X
0
1
0
1
0
1
X
ALU
Ctl
Passo 1: Busca de instrução e incremento do PC (IF)
MDR
Read Register 1
Read Data 1
Read Register 2
Read Data 2
Write Register
Register File
Write Data
S.
Ext
[15-0]
16
32
A
B
4
28
PC + 4 [31-28]
<<2
26
AluOut
2
[5-0]
32
PCWriteCond
PCSource
PCWrite
AluOP
IorD
AluSrcB
MemRead
AluSrcA
[31-0]
Jump
Address
MemWrite
RegWrite
IRWrite
RegDst
MemReg
[25-0]
[15-11]
<<2
0
1
0
1
0
1
2
3
0
1
2
PC
0
1
Instruction
[31-26]
Instruction
[25-21]
Instruction
[20-16]
Instruction
[15-0]
Instruction
Register
Address
Read Data
Memory
Write Data
Zero
 
Result
0
1
7
Control
Passo 2: Decodificação da instrução e acesso ao BR (ID)
Ler registradores RS e RT (adiantando caso a instrução use esses campos).
 Usar a ALU para computar o endereço do branch (adiantando caso seja um branch).
Descrição em RTL (Register-Transfer Language):
	A = Reg[IR[25-21]];
B = Reg[IR[20-16]];
ALUOut = PC + (sign-extend(IR[15-0]) << 2);
8
XX
00
11
0
0
X
0
0
X
0
0
0
X
ALU
Ctl
Caminho de Dados - Implementação Multiciclo
MDR
Read Register 1
Read Data 1
Read Register 2
Read Data 2
Write Register
Register File
Write Data
S.
Ext
[15-0]
16
32
A
B
4
28
PC + 4 [31-28]
<<2
26
AluOut
2
[5-0]
32
PCWriteCond
PCSource
PCWrite
AluOP
IorD
AluSrcB
MemRead
AluSrcA
[31-0]
Jump
Address
MemWrite
RegWrite
IRWrite
RegDst
MemReg
[25-0]
[15-11]
<<2
0
1
0
1
0
1
2
3
0
1
2
PC
0
1
Instruction
[31-26]
Instruction
[25-21]
Instruction
[20-16]
Instruction
[15-0]
Instruction
Register
Address
Read Data
Memory
Write Data
Zero
 
Result
0
1
9
Control
Passo 3: Execução, computação do endereço de memória ou finalização de instruções de desvio condicional (EX)
Depende do tipo de instrução
Instrução de acesso a memória (LW, SW):
Cálculo do endereço de acesso
ALUOut = A + sign-extend(IR[15-0]);
Tipo R:
Execução da operação
ALUOut = A op B;
Branch - BEQ (término da instrução):
Comparação e desvio condicional
if (A==B) PC = ALUOut;
jump (término da instrução):
Desvio
 	 PC = PC[31-28] || (IR[25-0] << 2)
10
XX
00
10
1
0
X
0
0
X
0
0
0
X
ALU
Ctl
Passo 3: EX – LW, SW 
MDR
Read Register 1
Read Data 1
Read Register 2
Read Data 2
Write Register
Register File
Write Data
S.
Ext
[15-0]
16
32
A
B
4
28
PC + 4 [31-28]
<<2
26
AluOut
2
[5-0]
32
PCWriteCond
PCSource
PCWrite
AluOP
IorD
AluSrcB
MemRead
AluSrcA
[31-0]
Jump
Address
MemWrite
RegWrite
IRWrite
RegDst
MemReg
[25-0]
[15-11]
<<2
0
1
0
1
0
1
2
3
0
1
2
PC
0
1
Instruction
[31-26]
Instruction
[25-21]
Instruction
[20-16]
Instruction
[15-0]
Instruction
Register
Address
Read Data
Memory
Write Data
Zero
 
Result
0
1
11
Control
XX
10
00
1
0
X
0
0
X
0
0
0
X
ALU
Ctl
Passo 3: EX – Tipo R
MDR
Read Register 1
Read Data 1
Read Register 2
Read Data 2
Write Register
Register File
Write Data
S.
Ext
[15-0]
16
32
A
B
4
28
PC + 4 [31-28]
<<2
26
AluOut
2
[5-0]
32
PCWriteCond
PCSource
PCWrite
AluOP
IorD
AluSrcB
MemRead
AluSrcA
[31-0]
Jump
Address
MemWrite
RegWrite
IRWrite
RegDst
MemReg
[25-0]
[15-11]
<<2
0
1
0
1
0
1
2
3
0
1
2
PC
0
1
Instruction
[31-26]
Instruction
[25-21]
Instruction
[20-16]
Instruction
[15-0]
Instruction
Register
Address
Read Data
Memory
Write Data
Zero
 
Result
0
1
12
Control
01
01
00
1
0
X
1
0
X
0
0
0
X
ALU
Ctl
Passo 3: EX – Branch - BEQ
MDR
Read Register 1
Read Data 1
Read Register 2
Read Data 2
Write Register
Register File
Write Data
S.
Ext
[15-0]
16
32
A
B
4
28
PC + 4 [31-28]
<<2
26
AluOut
2
[5-0]
32
PCWriteCond
PCSource
PCWrite
AluOP
IorD
AluSrcB
MemRead
AluSrcA
[31-0]
Jump
Address
MemWrite
RegWrite
IRWrite
RegDst
MemReg
[25-0]
[15-11]
<<2
0
1
0
1
0
1
2
3
0
1
2
PC
0
1
Instruction
[31-26]
Instruction
[25-21]
Instruction
[20-16]
Instruction
[15-0]
Instruction
Register
Address
Read Data
Memory
Write Data
Zero
 
Result
0
1
13
Control
10
XX
XX
X
0
X
0
1
X
0
0
0
X
ALU
Ctl
Passo 3: EX – Jump
MDR
Read Register 1
Read Data 1
Read Register 2
Read Data 2
Write Register
Register File
Write Data
S.
Ext
[15-0]
16
32
A
B
4
28
PC + 4 [31-28]
<<2
26
AluOut
2
[5-0]
32
PCWriteCond
PCSource
PCWrite
AluOP
IorD
AluSrcB
MemRead
AluSrcA
[31-0]
Jump
Address
MemWrite
RegWrite
IRWrite
RegDst
MemReg
[25-0]
[15-11]
<<2
0
1
0
1
0
1
2
3
0
1
2
PC
0
1
Instruction
[31-26]
Instruction
[25-21]
Instruction
[20-16]
Instruction
[15-0]
Instruction
Register
Address
Read Data
Memory
Write Data
Zero
 
Result
0
1
14
Control
Passo 4: Acesso a memória ou finalização de instruções do tipo R (MEM)
Depende do tipo de instrução
Instrução de acesso a memória (LW, SW):
O acesso é feito
Load
 MDR = Memory[ALUOut];
Store
 Memory[ALUOut] = B;
Tipo R:
O resultado da operação é gravado no banco de registradores (a instrução termina)
 Reg[IR[15-11]] = ALUOut;
15
XX
XX
XX
X
0
X
0
0
1
1
0
0
X
ALU
Ctl
Passo 4: MEM - LW
MDR
Read Register 1
Read Data 1
Read Register 2
Read Data 2
Write Register
Register File
Write Data
S.
Ext
[15-0]
16
32
A
B
4
28
PC + 4 [31-28]
<<2
26
AluOut
2
[5-0]
32
PCWriteCond
PCSource
PCWrite
AluOP
IorD
AluSrcB
MemRead
AluSrcA
[31-0]
Jump
Address
MemWrite
RegWrite
IRWrite
RegDst
MemReg
[25-0]
[15-11]
<<2
0
1
0
1
0
1
2
3
0
1
2
PC
0
1
Instruction
[31-26]
Instruction
[25-21]
Instruction
[20-16]
Instruction
[15-0]
Instruction
Register
Address
Read Data
Memory
Write Data
Zero
 
Result
0
1
16
Control
XX
XX
XX
X
0
X
0
0
1
0
1
0
X
ALU
Ctl
Passo 4: MEM - SW
MDR
Read Register 1
Read Data 1
Read Register 2
Read Data 2
Write Register
Register File
Write Data
S.
Ext
[15-0]
16
32
A
B
4
28
PC + 4 [31-28]
<<2
26
AluOut
2
[5-0]
32
PCWriteCond
PCSource
PCWrite
AluOP
IorD
AluSrcB
MemRead
AluSrcA
[31-0]
Jump
Address
MemWrite
RegWrite
IRWrite
RegDst
MemReg
[25-0]
[15-11]
<<2
0
1
0
1
0
1
2
3
0
1
2
PC
0
1
Instruction
[31-26]
Instruction
[25-21]
Instruction
[20-16]
Instruction
[15-0]
Instruction
Register
Address
Read Data
Memory
Write Data
Zero
 
Result
0
1
17
Control
XX
XX
XX
X
1
1
0
0
X
0
0
0
1
ALU
Ctl
Passo 4: MEM – Tipo R
MDR
Read Register 1
Read Data 1
Read Register 2
Read Data 2
Write Register
Register File
Write Data
S.
Ext
[15-0]
16
32
A
B
4
28
PC + 4 [31-28]
<<2
26
AluOut
2
[5-0]
32
PCWriteCond
PCSource
PCWrite
AluOP
IorD
AluSrcB
MemRead
AluSrcA
[31-0]
Jump
Address
MemWrite
RegWrite
IRWrite
RegDst
MemReg
[25-0]
[15-11]
<<2
0
1
0
1
0
1
2
3
0
1
2
PC
0
1
Instruction
[31-26]
Instruction
[25-21]
Instruction
[20-16]
Instruction
[15-0]
Instruction
Register
Address
Read Data
Memory
Write Data
Zero
 
Result
0
1
18
Control
Passo 5: Finalização de Leitura na Memória (WB)
Load armazena o resultado da leitura no Banco de Registradores (instrução termina)
 Reg[IR[20-16]]= MDR;
Importante: Não há impedimento no caminho de dados (ou de controle) para que que o passo 5 seja eliminado e suas ações sejam transferidas para o passo 4. Podemos fazer
 Reg[IR[20-16]]= Memory[ALUOut];
 para completar o LW no passo 4. Isso também permite eliminar o MDR.
Não fazemos assim pois o acesso a memória é a operação mais lenta e, portanto, o passo 4 é o que determina o tamanho do ciclo. Se concatenarmos os passos 4 e 5 estaremos aumentando o tamanho do ciclo PARA TODOS OS PASSOS!
19
XX
XX
XX
X
1
0
0
0
X
0
0
0
0
ALU
Ctl
Passo 5: Finalização de Leitura na Memória (WB) - LW
MDR
Read Register 1
Read Data 1
Read Register 2
Read Data 2
Write Register
Register File
Write Data
S.
Ext
[15-0]
16
32
A
B
4
28
PC + 4 [31-28]
<<2
26
AluOut
2
[5-0]
32
PCWriteCond
PCSource
PCWrite
AluOP
IorD
AluSrcB
MemRead
AluSrcA
[31-0]
Jump
Address
MemWrite
RegWrite
IRWrite
RegDst
MemReg
[25-0]
[15-11]
<<2
0
1
0
1
0
1
2
3
0
1
2
PC
0
1
Instruction
[31-26]
Instruction
[25-21]
Instruction
[20-16]
Instruction
[15-0]
Instruction
Register
Address
Read Data
Memory
Write Data
Zero
 
Result
0
1
20
Control
Controle
21
Tarefa – Valendo Nota!!!
É necessário modificar o caminho de dados multiciclo apresentado para incluir instruções ADDi e SUBi?
E a máquina de estados do controle?
Como fica a solução final (caminho de dados e controle) incluindo essas instruções?
Mostre a simulação e o RTL para todas as etapas destas duas instruções no projeto.
Contatos
23
leandro@ime.uerj.br
lmarzulo@cos.ufrj.br
leandro.marzulo@gmail.com