Arquitectura de
Computadores II
2004/2005
0. Introdução
Paulo Marques
Departamento de Eng. Informática
Universidade de Coimbra
[email protected]
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
2
Modelo de Funcionamento

Aulas Teóricas



Aulas práticas



Apoio à realização dos mini-projectos (grupos de 2)
Realização de dois mini-testes (devidamente anunciados)
Avaliação




Conceitos teóricos sobre arquitectura de computadores
Discussão de artigos que serão fornecidos
Exame / Exame de Recurso:
2 Mini-testes:
4 Mini-projectos:
12 valores (min=5)
2 valores (min=0)
6 valores (min=2)
Casos especiais


Trab. Estudantes: Mini-testes no gabinete (caso necessário)
Época Especial: Exame para 20 valores
3
Bibliografia

Computer Architecture: A Quantitative Approach, 3rd Ed.
J. Hennessy & D. Patterson
Morgan Kaufmann, ISBN 1-55860-724-2
May 2002

Computer Organization and Design, 3rd Ed.
D. Patterson & J. Hennessy
Morgan Kaufmann, ISBN 1-55860-604-1
August 2004


Apenas para revisão de aspectos básicos
Serão fornecidos alguns artigos
4
Professores

Paulo Marques
[email protected]
Gabinete D2.5 / Laboratório E5.4
Horário de Atendimento: Seg. 11h-12h / Qui. 10h-12h

Marco Vieira
[email protected]
Laboratório E6.2
Horário de Atendimento: Sex. 14h-18h
5
Arquitectura de
Computadores II
2004/2005
Revisão de alguns
conceitos básicos
Paulo Marques
Departamento de Eng. Informática
Universidade de Coimbra
[email protected]
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
7
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)
8
Instruções do MIPS
(exemplos)
LD
R1,(8)R2
ADDI R1, 10
JR
(R1)
ADD R1,R2,R3
J
4000
9
Execução de uma instrução

IF – Instruction Fetch



ID – Instruction Decode





Instruções ALU: Realiza o cálculo
Instruções LOAD/STORE: Calcula o endereço a utilizar
MEM – Memory Access


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


Envia para a memória o endereço de PC e obtém a instrução corrente
Incrementa o PC
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
10
MIPS Datapath (Implementação Multi-ciclo)
Nota: Esta implementação não corresponde directamente às fases atrás mencionadas!
11
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
IF
ID
EXE
MEM
WB
Saltos: 2 ciclos
Store: 4 ciclos
Outros: 5 ciclos


CPI = Clocks per Instruction
Tempo Execução = Instruções x CPImédio x Trelógio
12
Máquina de Estados do MIPS (simplificada)
Instruction decode/
register fetch
Instruction fetch
=
(Op
2
'LW
=
(Op
') or
'SW
')
6
')
EQ
'B
)
ype
R-t
=
(Op
Branch
completion
Execution
ALUSrcA = 1
ALUSrcB = 10
ALUOp = 00
8
ALUSrcA =1
ALUSrcB = 00
ALUOp = 10
Jump
completion
9
ALUSrcA = 1
ALUSrcB = 00
ALUOp = 01
PCWriteCond
PCSource = 01
PCWrite
PCSource = 10
(O
p
=
'S
')
W
(Op = 'LW')
ALUSrcA = 0
ALUSrcB = 11
ALUOp = 00
(Op = 'J')
Memory address
computation
1
=
Start
MemRead
ALUSrcA = 0
IorD = 0
IRWrite
ALUSrcB = 01
ALUOp = 00
PCWrite
PCSource = 00
(O
p
0
Memory
access
3
Memory
access
5
MemRead
IorD = 1
R-type completion
7
MemWrite
IorD = 1
RegDst = 1
RegWrite
MemtoReg = 0
Write-back step
4
RegDst = 0
RegWrite
MemtoReg = 1
13
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 
14
MIPS Datapath (Implementação Pipelined)
15
Pipeline ao longo do tempo...
Time (in clock cycles)
Program
execution
order
(in instructions)
lw $1, 100($0)
lw $2, 200($0)
lw $3, 300($0)
CC 1
CC 2
IM
Reg
IM
CC 3
ALU
Reg
IM
CC 4
CC 5
DM
Reg
ALU
Reg
DM
ALU
CC 6
CC 7
Reg
DM
Reg
16
Pipeline vs. Multi-ciclo
Program
execution
Time
order
(in instructions)
lw $1, 100($0)
2
Instruction
Reg
fetch
lw $2, 200($0)
4
6
8
ALU
Data
access
10
12
14
ALU
Data
access
16
18
Reg
Instruction
Reg
fetch
8 ns
lw $3, 300($0)
Reg
Instruction
fetch
8 ns
...
8 ns
Program
execution
Time
order
(in instructions)
2
lw $1, 100($0)
Instruction
fetch
lw $2, 200($0)
2 ns
lw $3, 300($0)
4
Reg
Instruction
fetch
2 ns
6
ALU
Reg
Instruction
fetch
2 ns
8
Data
access
ALU
Reg
2 ns
10
14
12
Reg
Data
access
Reg
ALU
Data
access
2 ns
2 ns
Reg
2 ns
17
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
18
Conflitos

Estruturais



De dados


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; MEMAcede à
memória; resolvido utilizando duas caches)
Resolúveis duplicando o hardware ou com interlocks (bolhas)
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!
19
Dependências de Dados
Time (in clock cycles)
CC 1
Value of
register $2: 10
CC 2
CC 3
CC 4
CC 5
CC 6
CC 7
CC 8
CC 9
10
10
10
10/– 20
– 20
– 20
– 20
– 20
DM
Reg
Program
execution
order
(in instructions)
sub $2, $1, $3
and $12, $2, $5
or $13, $6, $2
add $14, $2, $2
sw $15, 100($2)
IM
Reg
IM
DM
Reg
IM
DM
Reg
IM
Reg
DM
Reg
IM
Reg
Reg
Reg
DM
Reg
20
Forwarding
Time (in clock cycles)
CC 1
Value of register $2 : 10
Value of EX/MEM : X
Value of MEM/WB : X
CC 2
CC 3
CC 4
CC 5
CC 6
CC 7
CC 8
CC 9
10
X
X
10
X
X
10
– 20
X
10/– 20
X
– 20
– 20
X
X
– 20
X
X
– 20
X
X
– 20
X
X
DM
Reg
Program
execution order
(in instructions)
sub $2, $1, $3
and $12, $2, $5
or $13, $6, $2
add $14, $2, $2
sw $15, 100($2)
IM
Reg
IM
Reg
IM
DM
Reg
IM
Reg
DM
Reg
IM
Reg
DM
Reg
Reg
DM
Reg
21
Há dependências de dados não resolúveis...
Program
Time (in clock cycles)
execution
CC 1
CC 2
order
(in instructions)
lw $2, 20($1)
and $4, $2, $5
or $8, $2, $6
IM
CC 3
Reg
IM
Reg
IM
CC 4
CC 5
DM
Reg
Reg
IM
CC 6
CC 7
DM
Reg
Reg
DM
CC 8
CC 9
CC 10
Reg
bubble
add $9, $4, $2
slt $1, $6, $7
IM
DM
Reg
IM
Reg
Reg
DM
Reg
22
Dependências de Controlo (saltos)

Problema dos saltos


Abordagem simples (Predict Not Taken)



J
O salto é detectado no final do ID, no entanto já foi feito o fetch
de uma nova instrução
IF
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
ID
IF
EXE MEM WB
ID
IF
Not taken
EXE MEM WB
ID
IF
ID
EXE MEM WB
IF
EXE MEM WB
--
--
IF
ID
--
--
EXE MEM WB
Taken
23
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
24
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!)
25
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)
26
Material para ler
Computer Architecture: A Quantitative Approach
 Appendix A



A1, A2, A3,
A4 (menor profundidade)
A5 (menor profundidade)
27
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 (Returnfrom-exception)?
28