Upload
internet
View
108
Download
0
Embed Size (px)
Citation preview
Arquitectura de Computadores II
Paulo MarquesDepartamento de Eng. InformáticaUniversidade de [email protected]
2004
/200
5
0. Introdução
2
Programa
Aspectos quantitativos no desenho de sistemas Pipelining Avançado Caches e hierarquia de memória Arquitectura de alguns processadores modernos Sistema de Entrada/Saída Multiprocessadores e Clusters
3
Modelo de Funcionamento
Aulas Teóricas Conceitos teóricos sobre arquitectura de computadores Discussão de artigos que serão fornecidos
Aulas práticas Apoio à realização dos mini-projectos (grupos de 2) Realização de dois mini-testes (devidamente anunciados)
Avaliação Exame / Exame de Recurso: 12 valores (min=5) 2 Mini-testes: 2 valores (min=0) 4 Mini-projectos: 6 valores (min=2)
Casos especiais Trab. Estudantes: Mini-testes no gabinete (caso
necessário) Época Especial: Exame para 20 valores
4
Bibliografia
Computer Architecture: A Quantitative Approach, 3rd Ed.J. Hennessy & D. PattersonMorgan Kaufmann, ISBN 1-55860-724-2May 2002
Computer Organization and Design, 3rd Ed.D. Patterson & J. HennessyMorgan Kaufmann, ISBN 1-55860-604-1 August 2004 Apenas para revisão de aspectos básicos
Serão fornecidos alguns artigos
5
Professores
Paulo [email protected] D2.5 / Laboratório E5.4Horário de Atendimento: Seg. 11h-12h / Qui. 10h-12h
Marco [email protected]ório E6.2Horário de Atendimento: Sex. 14h-18h
Arquitectura de Computadores II
Paulo MarquesDepartamento de Eng. InformáticaUniversidade de [email protected]
2004
/200
5
Revisão de alguns conceitos básicos
7
Processadores RISC
RISC = Reduced Instruction Set Computer
ISA (Instruction Set Architecture) simples e uniforme Arquitectura LOAD/STORE
Todas as operações são sobre dados em registos Existem operações de LOAD/STORE com a memória
Instruções uniformes e de tamanho igual Register file grande e de registos genéricos
Comparação com CISC Operações complexas são difíceis de implementar em
hardware Operações complexas tornam os sistemas lentos É difícil antever quais as operações que irão ser necessárias Registos com propósitos especiais O compilador pode eficientemente traduzir operações de alto
nível
8
Instruções do MIPS
Características Operações de cálculo (ALU) são sempre apenas entre
registos Apenas existem duas instruções que mexem com memória
(load/store) Todas as instruções têm o mesmo tamanho (32 bits) O número de formatos de instruções é reduzido (3)
Tipos de instruções ALU (e.g. ADD R1,R2,R3 / ADDI R1,R2,5)
Dois registos de origem e um de destino Um registo de origem, um valor imediato e um registo de
destino LOAD/STORE (e.g. SD 8(R2),R1)
Um registo base, um deslocamento e um registo de origem BRANCH/JUMP
Dois registos a comparar e um valor imediato (offset) Um valor imediato (offset)
9
Instruções do MIPS
LD R1,(8)R2ADDI R1, 10JR (R1)
ADD R1,R2,R3
J 4000
(exemplos)
10
Execução de uma instrução
IF – Instruction Fetch Envia para a memória o endereço de PC e obtém a instrução
corrente Incrementa o PC
ID – Instruction Decode Descodifica a instrução Lê os registos [Calcula o possível end. de destino, num salto, e caso o seja,
realiza-o] EXE – Execution / Address Calculation
Instruções ALU: Realiza o cálculo Instruções LOAD/STORE: Calcula o endereço a utilizar
MEM – Memory Access Instruções LOAD/STORE: Lê ou escreve na memória
WB – Write Back Instruções ALU: Escreve o resultado no registo destino Instrução LOAD: Escreve o resultado no registo destino
11
MIPS Datapath (Implementação Multi-ciclo)
Nota: Esta implementação não corresponde directamente às fases atrás mencionadas!
12
Implementação Multi-ciclo
Cada instrução demora um número variado de ciclos de relógio
No entanto, em cada momento, só existe uma instrução em execução
CPI = Clocks per Instruction Tempo Execução = Instruções x CPImédio x Trelógio
IF ID EXE MEM WB
Saltos: 2 ciclosStore: 4 ciclosOutros: 5 ciclos
13
Máquina de Estados do MIPS (simplificada)
PCWritePCSource = 10
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA =1ALUSrcB = 00ALUOp= 10
RegDst = 1RegWrite
MemtoReg = 0
MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1ALUSrcB = 10ALUOp = 00
RegDst = 0RegWrite
MemtoReg =1
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchInstruction decode/
register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R-type)
(Op
= 'B
EQ')
(Op
= 'J
') (O
p = 'SW')
(Op
= 'L
W')
4
01
9862
753
Start
14
Como aumentar a performance?
Iniciar uma instrução em cada ciclo de relógio! Adicionar registos entre os diversos “estados” do
processador
Speedup máximo = Número de fases do pipeline
Throughput: Número de instruções completadas por unidade de tempo Aumenta
Latência: Tempo que cada instrução demora a executar Aumenta
15
MIPS Datapath (Implementação Pipelined)
16
Pipeline ao longo do tempo...
IM Reg DM RegALU
IM Reg DM RegALU
CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7
Time (in clock cycles)
lw $2, 200($0)
lw $3, 300($0)
Programexecutionorder(in instructions)
lw $1, 100($0) IM Reg DM RegALU
17
Pipeline vs. Multi-ciclo
Instructionfetch
Reg ALUData
accessReg
8 nsInstruction
fetchReg ALU
Dataaccess
Reg
8 nsInstruction
fetch
8 ns
Time
lw $1, 100($0)
lw $2, 200($0)
lw $3, 300($0)
2 4 6 8 10 12 14 16 18
2 4 6 8 10 12 14
...
Programexecutionorder(in instructions)
Instructionfetch
Reg ALUData
accessReg
Time
lw $1, 100($0)
lw $2, 200($0)
lw $3, 300($0)
2 nsInstruction
fetchReg ALU
Dataaccess
Reg
2 nsInstruction
fetchReg ALU
Dataaccess
Reg
2 ns 2 ns 2 ns 2 ns 2 ns
Programexecutionorder(in instructions)
18
Aspectos importantes dos pipelines
CPI >= Número de fases do pipeline O CPI não é igual ao número de fases do pipeline devido
aos conflitos que surgem! A performance do pipeline está limitada pela fase
mais comprida As diversas fases do pipeline têm de realizar
aproximadamente o mesmo trabalho O tamanho de cada fase também está limitado
pelo clock skew e latch overhead Se TClock Clock_Skew + Latch_Overhead, então não vale
a pena aumentar o número de fases do pipeline
19
Conflitos
Estruturais Um certo elemento do processador não pode ser utilizado
por duas fases diferentes do pipeline ao mesmo tempo (e.g. memória: IF Vai à memória buscar uma instrução; MEMAcede à memória; resolvido utilizando duas caches)
Resolúveis duplicando o hardware ou com interlocks (bolhas)
De dados Quando uma operação depende de resultados que ainda
estão a ser calculados (ou carregados)
De controlo Saltos (alteram o PC)Tudo isto leva à introdução de “bolhas” no pipeline!
20
Dependências de Dados
IM Reg
IM Reg
CC 1 CC 2 CC 3 CC 4 CC 5 CC 6
Time (in clock cycles)
sub $2, $1, $3
Programexecutionorder(in instructions)
and $12, $2, $5
IM Reg DM Reg
IM DM Reg
IM DM Reg
CC 7 CC 8 CC 9
10 10 10 10 10/– 20 – 20 – 20 – 20 – 20
or $13, $6, $2
add $14, $2, $2
sw $15, 100($2)
Value of register $2:
DM Reg
Reg
Reg
Reg
DM
21
Forwarding
IM Reg
IM Reg
CC 1 CC 2 CC 3 CC 4 CC 5 CC 6
Time (in clock cycles)
sub $2, $1, $3
Programexecution order(in instructions)
and $12, $2, $5
IM Reg DM Reg
IM DM Reg
IM DM Reg
CC 7 CC 8 CC 9
10 10 10 10 10/– 20 – 20 – 20 – 20 – 20
or $13, $6, $2
add $14, $2, $2
sw $15, 100($2)
Value of register $2 :
DM Reg
Reg
Reg
Reg
X X X – 20 X X X X XValue of EX/MEM :X X X X – 20 X X X XValue of MEM/WB :
DM
22
Há dependências de dados não resolúveis...
lw $2, 20($1)
Programexecutionorder(in instructions)
and $4, $2, $5
or $8, $2, $6
add $9, $4, $2
slt $1, $6, $7
Reg
IM
Reg
Reg
IM DM
CC 1 CC 2 CC 3 CC 4 CC 5 CC 6Time (in clock cycles)
IM Reg DM RegIM
IM DM Reg
IM DM Reg
CC 7 CC 8 CC 9 CC 10
DM Reg
RegReg
Reg
bubble
23
Dependências de Controlo (saltos)
Problema dos saltos O salto é detectado no final do ID, no entanto já foi feito o
fetch de uma nova instrução
Abordagem simples (Predict Not Taken) Continua o fetch como se nada fosse Se a instrução da qual é feito o fetch é incorrecta,
transforma-a num NOP (funciona porque só existem alterações reais nas fases MEM e WB; o salto é descoberto no fim de ID)
Perca de performance demasiado elevada
IF ID EXE MEM WB
IF ID EXE MEM WB
IF ID EXE MEM WB
J IF ID EXE MEM WB
IF -- -- -- --
IF ID EXE MEM WB
Not taken Taken
24
Delay Slot e Nullifying Branch
A instrução a seguir ao Branch é sempre executada
O compilador tem de lá colocar uma instrução adequada ou um NOP
No caso do “Nullifying Branch”, o compilador inclui na própria instrução o que ele previu que iria acontecer
Não funciona para pipeline agressivos
25
Unidades funcionais não completamente pipelined
Floating-point unit Pode considerar-se que a fase EXE pode demorar
vários ciclos Ocorrem bolhas se existem conflitos estruturais ou
dependências de dados (incluindo WAW!)
26
Excepções: O grande problema dos pipelines
Dois tipos fundamentais de excepções: Verdadeiras EXCEPÇÕES
(e.g. divisão por zero, overflow, page fault) Interrupções (de hardware ou traps)
No caso das excepções é necessário a meio de uma instrução anulá-la, assim como todas as outras que estão a decorrer no pipeline e invocar o Sistema Operativo
RESTARTABLE (e.g. Page Fault) vs. TERMINATE (e.g. Illegal Instruction)
Grande problema: Processadores “out-of-order” e unidades não fully-pipelined (e.g. FP unit)
27
Material para ler
Computer Architecture: A Quantitative Approach Appendix A
A1, A2, A3, A4 (menor profundidade) A5 (menor profundidade)
28
Algumas questões de revisão...
Porque é que o registo R0 do MIPS é sempre 0? Porque é que a maioria dos processadores RISC tem caches
de instruções e de dados separadas? Sendo possível colocar tantos transístores dentro de um
integrado, porque é que não se aumenta muito mais o número de registos dos processadores (e.g. 128)?
Sendo possível colocar tantos transístores dentro de um integrado, porque é que não se aumenta muito mais o número de unidades funcionais existentes?
Se o throughput do processador (e velocidade de relógio) tende a aumentar com o tamanho do pipeline, porque é que não se aumenta muito mais o número de fases dos mesmos?
Como é que é possível haver funções recursivas se a instrução JAL (Jump-And-Link) guarda sempre o endereço de retorno no registo R31 (i.e. $RA)?
Porque é que é necessário haver uma instrução especial RFE (Return-from-exception)?