View
0
Download
0
Category
Preview:
Citation preview
Arquiteturas de Computadores
Implementação de MIPS multiciclo
Arquiteturas de Computadores
Fontes dos slides: Patterson &Hennessy book website(copyright Morgan Kaufmann)e Dr. Sumanta Guha
Assumindo que o período do relógio é fixo temos: CPI = 1
Tempo de ciclo determinado pela instrução de maior duração (load) mas várias instruções podem executar em menor tempo: perda de tempo
considere se tivermos instruções mais complicadas como ponto flutuante!
recursos usados mais que uma vez no mesmo ciclo precisam ser duplicados perda de área para hardware
Problemas de projeto monociclo
Relógio de período fixo vs. período variável em uma implementação monociclo
Considere uma máquina com uma unidade de PF. Assuma os seguintes atrasos nesta máquina: memória: 2 ns., ALU e somadores: 2 ns., soma FPU: 8 ns., multiplicação FPU: 16 ns.,
acesso a registradores (leitura ou escrita): 1 ns. multiplexadores, unidade de controle, acesso ao PC, extensão de sinal, fios: sem atraso
Assuma um programa com as seguintes instruções: todos carregamentos demoram o mesmo tempo e compõem 31% todos armazenamentos demoram o mesmo tempo e compõem 21% todas instruções R compõem 27% desvios compõem 5% saltos compõem 2% Somas e subtrações FP demoram o mesmo tempo e compõem 7% Multiplicações e divisões FP demoram o mesmo tempo e compõem 7%
Compare o desempenho de uma implementação monociclo onde o período do relógio é fixo e uma outra onde o período do relógio é o mínimo necessário para cada instrução
Solução
Valor do período para período fixo= maior tempo = 20 ns. Valor médio do período para período variável = 8 31% +
7 21% + 6 27% + 5 5% + 2 2% + 20 7% + 12 7% = 7.0 ns.
Então, desempenhovar-period /desempenhofixed-period = 20/7 = 2.9
Instruction Instr. Register ALU Data Register FPU FPU Totalclass mem. read oper. mem. write add/ mul/ time
sub div ns.Load word 2 1 2 2 1 8Store word 2 1 2 2 7R-format 2 1 2 0 1 6Branch 2 1 2 5Jump 2 2FP mul/div 2 1 1 16 20FP add/sub 2 1 1 8 12
Corrigindo o problema de projeto monociclo
Uma solução: um relógio com período variável para cada classe de instrução: inviável, dificuldade para implementar um relógio
com período variável Outra solução:
usar um ciclo de período pequeno… …cada instrução utiliza números de ciclos diferentes
fragmentando as instruções em passos que caibam em um ciclo de relógio
viável: abordagem multiciclo!
fragmenta cada instrução em passos cada passo é executado em um ciclo de relógio equilibra a quantidade de trabalho a ser feita em cada passo/ciclo de
modo que sejam aproximadamente iguais Restringe que em cada ciclo seja utilizada uma única unidade funcional
de modo a não ter que replicá-las Unidades funcionais podem ser compartilhadas entre diferentes passos
de uma mesma instrução Entre passos/ciclos
Ao final de um ciclo os dados são armazenados para serem usados em um ciclo posterior da mesma instrução Necessário introduzir registradores internos adicionais para armazenar estes
dados invisíveis ao programador Dados a serem usado em instruções posteriores são armazenados em
elementos de estado visíveis ao programador: registradores, PC, memória
Abordagem multiciclo
Diferenças Uma única memória para
dados e instruções Uma ALU, sem somadores extras Registradores para armazenar dados
entre ciclos
Abordagem multiciclo
PC
Instruction memory
Read address
Instruction
16 32
Add ALU result
M u x
Registers
Write registerWrite data
Read data 1
Read data 2
Read register 1Read register 2
Shift left 2
4
M u x
ALU operation3
RegWrite
MemRead
MemWrite
PCSrc
ALUSrcMemtoReg
ALU result
ZeroALU
Data memory
Address
Write data
Read data M
u x
Sign extend
Add
PC
Memory
Address
Instruction or data
Data
Instruction register
RegistersRegister #
Data
Register #
Register #
ALU
Memory data
register
A
B
ALUOut
Caminho de dados monociclo
Caminho de dados multiciclo
Caminho de dados multiciclo
Shift left 2
PC
Memory
MemData
Write data
M u x
0
1
RegistersWrite register
Write data
Read data 1
Read data 2
Read register 1
Read register 2
M u x
0
1
M u x
0
1
4
Instruction [15– 0]
Sign extend
3216
Instruction [25– 21]
Instruction [20– 16]
Instruction [15– 0]
Instruction register
1 M u x
0
32
M u x
ALU result
ALUZero
Memory data
register
Instruction [15– 11]
A
B
ALUOut
0
1
Address
Novos registradores internos em vermelho, novos multiplexadores em verde
Fragmentando instruções em passos
As instruções são fragmentadas nos seguintes passos potenciais –nem todas requerem todos os passos – cada passo executa em um período de relógio1. Busca da instrução e incremento do PC (IF)2. Decodificação da instrução e busca no registrador (ID)3. Execução, cálculo do endereço de memória, ou finalização de desvio (EX)4. Acesso à memória ou finalização de instrução R (MEM)5. Finalização de leitura da memória (WB)
Cada instrução MIPS requer de 3 a 5 ciclos (passos)
Use o PC para obter a instrução e colocá-la no registrador de instrução Incremente o PC de 4 e coloque o resultado de volta PC.
Pode ser descrita utilizando RTL (Register-Transfer Language):
IR = Memory[PC];PC = PC + 4;
Passo 1: Busca da instrução & Incremento do PC (IF)
Lê registradores rs e rt se precisar.Calcula o endereço de desvio caso a instrução seja de desvio
RTL:A = Reg[IR[25-21]];B = Reg[IR[20-16]];ALUOut = PC + (sign-extend(IR[15-0]) << 2);
Passo 2: Decodifica a Instrução e Busca no registrador (ID)
ALU executa uma das 4 funções dependendo do tipo de instrução Referência à memória:
ALUOut = A + sign-extend(IR[15-0]); Tipo R:
ALUOut = A op B; desvio (instrução é finalizada):
if (A==B) PC = ALUOut; salto (instrução é finalizada):PC = PC[31-28] || (IR(25-0) << 2)
Passo 3: Execução, Cálculo de endereço e finalização de desvio (EX)
Depende do tipo de instrução: Loads e stores acessam a memória
loadMDR = Memory[ALUOut];
store (instrução é finalizada)Memory[ALUOut] = B;
R-type (instrução é finalizada)Reg[IR[15-11]] = ALUOut;
Passo 4: Acesso à memória ou Finalização de instrução R (MEM)
Depende do tipo de instrução: Escreve memória no registrador (instrução é finalizada)
Reg[IR[20-16]]= MDR;
Importante: Não existe razão óbvia para não colocar este passo no passo 4 fazendoReg[IR[20-16]]= Memory[ALUOut];
Isso eliminaria o MDR.
A razão de isso não ser feito é tentar manter os passos com a mesma duração restringindo que cada passo contenha no máximo uma operação ALU, um acesso a registrador ou um acesso à memória
Passo 5: Finalização de leitura da memória (WB)
Resumo da execução de uma instrução
Nome do passo
Ações para instruções do tipo
RAções para instruções que
acessam a memóriaAções para
desvioAções para
saltosBusca da instrução IR = Memory[PC]
PC = PC + 4Decodificação da A = Reg [IR[25-21]]instrução/busca reg. B = Reg [IR[20-16]]
ALUOut = PC + (sign-extend (IR[15-0]) << 2)Execução, cálculo ALUOut = A op B ALUOut = A + sign-extend if (A ==B) then PC = PC [31-28] IIde endereço, finalização (IR[15-0]) PC = ALUOut (IR[25-0]<<2)de desvio e saltoFinalização de acesso à Reg [IR[15-11]] = Load: MDR = Memory[ALUOut]memória ou instr. R ALUOut or
Store: Memory [ALUOut] = B
1: IF
2: ID
3: EX
4: MEM
5: WB
Passo
Passo 1 da Execução multiciclo:Busca da instrução
IR = Memory[PC];PC = PC + 4;
4PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
BALUOUT
Passo 2 da Execução multiciclo: Decodificação da instrução e busca no registrador
A = Reg[IR[25-21]]; (A = Reg[rs])B = Reg[IR[20-15]]; (B = Reg[rt])ALUOut = (PC + sign-extend(IR[15-0]) << 2)
BranchTarget
Address
Reg[rs]
Reg[rt]
PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
BALUOUT
Passo 3 da Execução multiciclo: Instruções que referenciam a memória
ALUOut = A + sign-extend(IR[15-0]);
Mem.Address
Reg[rs]
Reg[rt]
PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
BALUOUT
Passo 3 da Execução multiciclo: Instrução com ALU (Tipo R)ALUOut = A op B
R-TypeResult
Reg[rs]
Reg[rt]
PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
BALUOUT
Passo 3 da Execução multiciclo: Instruções de desvioif (A == B) PC = ALUOut;
BranchTarget
Address
Reg[rs]
Reg[rt]
BranchTarget
Address
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
BALUOUT
Passo 3 da Execução multiciclo: Instruções de saltoPC = PC[31-28] concat (IR[25-0] << 2)
JumpAddress
Reg[rs]
Reg[rt]
BranchTarget
Address
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
BALUOUT
Passo 4 da Execução multiciclo:Acesso de leitura à memória (lw)MDR = Memory[ALUOut];
Mem.Data
PC + 4
Reg[rs]
Reg[rt]
Mem.Address
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
BALUOUT
Passo 4 da Execução multiciclo: Acesso de escrita à memória (sw)Memory[ALUOut] = B;
PC + 4
Reg[rs]
Reg[rt]
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
BALUOUT
Passo 4 da Execução multiciclo: Acesso à ALU ALU (Tipo R)Reg[IR[15:11]] = ALUOUT
R-TypeResult
Reg[rs]
Reg[rt]
PC + 4
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
BALUOUT
Passo 5 da Execução multiciclo: Finalização de leitura da memória (lw)Reg[IR[20-16]] = MDR;
PC + 4
Reg[rs]
Reg[rt]Mem.Data
Mem.Address
5 5
RD1
RD2
RN1 RN2 WN
WD
RegWrite
Registers
Operation
ALU
3
Zero
RD
WDMemRead
MemoryADDR
MemWrite
5
Instruction I
PC
IR
MDR
A
BALUOUT
Recommended