Arquitectura de Computadores II

Paulo MarquesDepartamento de Eng. InformáticaUniversidade de Coimbrapmarques@dei.uc.pt

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 Marquespmarques@dei.uc.ptGabinete D2.5 / Laboratório E5.4Horário de Atendimento: Seg. 11h-12h / Qui. 10h-12h

Marco Vieiramvieira@dei.uc.ptLaboratório E6.2Horário de Atendimento: Sex. 14h-18h

Arquitectura de Computadores II

Paulo MarquesDepartamento de Eng. InformáticaUniversidade de Coimbrapmarques@dei.uc.pt

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)?