arquitetura e organização de computadores 2claudio/cursos/aoc2/slides/aoc2_aula9.0_2p.pdf · a...

19/06/2015

1

Arquitetura e Organização de

Computadores 2

Paralelismo em Nível de Instrução e a sua Exploração

Introdução

Pipelining torna-se uma técnica universal em 1985 Explora a potencial sobreposição da execução de instruções

para melhorar o desempenho. “Paralelismo em Nível de Instrução”

Duas abordagens para explorar o paralelismo de instruções: Hardware-based dynamic approaches

Usadas em processadores de desktops e servidores

Não utilizada de forma extensiva em processadores voltados ao Mercado de equipamentos móveis (PMP processors)

Compiler-based static approaches Restrito ao mundo das aplicações científicas

19/06/2015

2

Paralelismo em Nível de Instrução

O objetivo principal do ILP é a maximização do CPI

Pipeline CPI = Ideal pipeline CPI +

Structural stalls +

Data hazard stalls +

Control stalls

O Paralelismo no bloco básico é limitado Em programas típicos, a frequência média de desvios é de 15-25%.

Assim, o tamanho típico do bloco básico = 3-6 instruções executadas entre um par de desvios.

Devemos explorar o ILP em diversos blocos básicos, quebrando a fronteira dos desvios...

Paralelismo em Nível de Instrução

Paralelismo em Nível de Loop Desdobramento de laços estaticamente ou dinamicamente

Uso de SIMD (processadores vetoriais e GPUs)

Desafios: Dependência dos Dados

Instrução j é dependente de dados gerados pela instrução i se:

Instrução i produz um resultado que pode ser usado pela instrução j

Instrução j é dependente dos dados da instrução k e a instrução k é dependente de dados da instrução i

Instruções dependentes não podem ser executadas simultaneamente

19/06/2015

3

Dependência de Dados

As dependências são propriedades dos programas

A organização Pipeline determina se a dependência é detectada e se ela causa parada (stall)

Uma dependência de dados transmite três coisas: Possibilidade de um hazard.

A ordem em que os resultados podem ser calculados.

O limite máximo de paralelismo a ser explorado

As dependências que fluem através da memória são mais difíceis de serem detectadas.

Dependências de Nome

Ocorre quando duas instruções usam o mesmo registrador ou local de memória, chamado nome, mas não existe fluxo de dados entre as instruções associadas. Não é uma dependência verdadeira, mas é um problema na reordenação

de instruções (reordering instructions)

Antidependência - WAR

Ordem inicial (i antes de j) deve ser preservada

Dependência de saída -WAW

Ordem deve ser preservada

Solução - utilizar técnica de renomeação de registrador.

19/06/2015

4

Outros fatores

Data Hazards Read after write (RAW)

Write after write (WAW)

Write after read (WAR)

Dependência de Controle Determina a ordenação de uma instrução I com relação a

uma instrução de desvio. Uma instrução que é dependente de controle em um desvio não

pode ser movida para antes do desvio, de modo que sua execução nãoseja mais controlada por ele.

Uma instrução que não é dependente de controle em um desvio nãopode ser movida para depois do desvio…

Fluxo de DadosFluxo de dados (data flow) através das instruções que produzem resultados e que os utilizam

(consomem)

• branches fazem o fluxo ser dinâmico, determina qual instrução é fornecedora do dado

• Exemplo 1:

DADDU R1, R2, R3

BEQZ R4, L1

DSUBU R1, R1, R6

L1: …

OR R7, R1, R8

• OR depende de DADDU ou de

DSUBU?

• O fluxo de dados deve ser preservado

na execução

• Exemplo 2:

DADDU R1, R2, R3

BEQZ R12, L2

DSUBU R4, R5, R6

DADDU R5, R4, R9

L2:

OR R7, R8, R9

• Suponha que (R4) não é usado após o

rótulo L2 e que DSUBU não gera

exceção neste caso.

• O fluxo de dados não é afetado se

trocarmos a ordem das instruções

BEQZ e DSUBU

19/06/2015

5

Técnicas para redução de stalls

Technique Reduces

Dynamic scheduling Data hazard stalls

Dynamic branch

prediction

Control stalls

Issuing multiple

instructions per cycle

Ideal CPI

Speculation Data and control stalls

Dynamic memorydisambiguation

Data hazard stalls involvingmemory

Loop unrolling Control hazard stalls

Basic compiler pipelinescheduling

Data hazard stalls

Compiler dependence

analysis

Ideal CPI and data hazard stalls

Software pipelining and

trace scheduling

Ideal CPI and data hazard stalls

Compiler speculation Ideal CPI, data and control stalls

Técnicas de Compilador para Explorar ILP

Pipeline scheduling

Separar a instrução dependente da instrução fonte, considerando a latência da instrução fonte.

Exemplo:

for (i=999; i>=0; i=i-1)

x[i] = x[i] + s;

19/06/2015

6

Pipeline Stalls

Loop: L.D F0,0(R1)

stall

ADD.D F4,F0,F2

stall

stall

S.D F4,0(R1)

DADDUI R1,R1,#-8

stall (assume integer load latency is 1)

BNE R1,R2,Loop

Pipeline Scheduling

Scheduled code:

Loop: L.D F0,0(R1)

DADDUI R1,R1,#-8

ADD.D F4,F0,F2

stall

stall

S.D F4,8(R1)

BNE R1,R2,Loop

19/06/2015

7

Desdobramento de Laço (Loop Unrolling)

Loop unrolling Desdobramento por um fator 4 (assumir # elementos é divisível por 4)

Eliminar instruções desnecessárias

Loop: L.D F0,0(R1)

ADD.D F4,F0,F2

S.D F4,0(R1) ;drop DADDUI & BNE

L.D F6,-8(R1)

ADD.D F8,F6,F2

S.D F8,-8(R1) ;drop DADDUI & BNE

L.D F10,-16(R1)

ADD.D F12,F10,F2

S.D F12,-16(R1) ;drop DADDUI & BNE

L.D F14,-24(R1)

ADD.D F16,F14,F2

S.D F16,-24(R1)

DADDUI R1,R1,#-32

BNE R1,R2,Loop

nota: número de registradores vivos x registradores no laço original

Loop Unrolling/Pipeline Scheduling Pipeline schedule the unrolled loop:

Loop: L.D F0, 0(R1)

L.D F6, -8(R1)

L.D F10, -16(R1)

L.D F14, -24(R1)

ADD.D F4, F0, F2

ADD.D F8, F6, F2

ADD.D F12, F10, F2

ADD.D F16, F14, F2

S.D F4, 0(R1)

S.D F8, -8(R1)

DADDUI R1, R1, #-32

S.D F12,16(R1)

S.D F16, 8(R1)

BNE R1, R2, Loop

19/06/2015

8

Strip Mining

E se o número de iterações do laço é desconhecido?

Número de iterações = n

Meta: realizar k cópias do corpo do laço

Solução: construir dois pares de laços

O primeiro executa n mod k vezes

O segundo executa n / k vezes

“Strip mining”

Previsão dinâmica de saltos: o conceito

A predição (ou previsão) de saltos condicionais é vital para processadores de elevado desempenho, porque evita que as dependências de controle se tornem num fator limitativo.

Esquema mais simples:

Uso da tabela de predição do resultado do teste “branch-predictionbuffer” / ”branch history table”.

A tabela é uma memória indexada pelo bits menos significativos do endereço da instrução condicional.

Cada posição tem 1 bit que indica se o salto foi recentemente tomado ou não.

Problema de desempenho: um ciclo efetuado 10 vezes tem uma taxa de acerto de 80% (duas predições erradas), embora fosse de esperar pelo menos 90% (porquê?).

Solução: usar mais bits (2!) — um contador com “saturação”.

19/06/2015

9

Branch Prediction Basic 1-bit predictor:

Operação de desvio:

Predict taken ou not taken

Basic 2-bit predictor: Operação de desvio:

Predict taken ou not taken

Muda a previsão se errar duas previsões consecutivamente.

Predição de Correlação (correlating predictor): Múltiplos previsores de 2-bits para cada operação de desvio.

Um previsor para cada combinação possível de saídas dos n desvios anteriores.

Predição Local (local predictor): Múltiplos previsores de 2-bits para cada operação de desvio.

Um previsor para cada combinação possível de saídas das últimas n ocorrências desse desvio.

Predição de Torneio (tournament predictor): Combina a predição de correlação com a predição local.

Basic 1-bit predictor

Desempenho = ƒ(precisão, custo do misprediction)

Branch History Table: Bits menos significativos do PC usados como índice de

uma tabela de valores de 1 bit

Informa se o desvio foi tomado ou não na última vez

Não há comparação do endereço (menos HW, mas pode não ser a operação de

desvio correta)

0 1 1 0 0 1 1 1 0 0 0 0 0 1 0 1

0 1 2 3 4 5 6 7 8 9 A B C D E F

Addi r2, r0, 7Bne r0, r2, 0xfff00002Add r3, r5, r7

0xaaa00028

BranchHistoryTable

19/06/2015

10

Basic 1-bit predictor

(continuação) …

Quando constata o erro de previsão, atualiza a entrada

correta, elimina as instruções erradas do pipeline e recomeça

com a busca da instrução alvo (0xfff00002).

Problema: em um loop, 1-bit BHT irá causar

2 mispredictions (em média nos loops – na entrada e na saída):

No fim do loop quando ele termina

Na entrada do loop quando ele prevê exit no lugar de looping

Em um loop com 10 iterações, somente 80% de precisão mesmo que

a opção pelo desvio é realizado (taken) em 90% do tempo.

Basic 2-bit predictor - (Jim Smith, 1981)

Solução: esquema com 2-bit onde só há troca na previsão se houver duas previsões erradas em sequencia:

Vermelho: not taken

Verde: taken

Adicionado uma Histerese (inércia) para realizar a decisão

11

0001

10

PredictTaken PredictTaken

Predict Not Taken Predict Not Taken

NT

NT

T

TT

T

NT

NT

19/06/2015

11

Predição de Correlação

Para melhorar a qualidade de predição é necessário

considerar o comportamento recente de outros saltos

condicionais (predição com correlação ou de dois níveis).

Se os saltos b1 e b2 não forem tomados, então b3 é certamente tomado, o

que não pode ser predito considerando apenas um único salto.

if (aa==2)aa = 0;

if (bb==2)bb = 0;

if (aa!=bb) {. . .

DSUBUI R3,R1,#2BNEZ R3,L1 ;salto b1 (aa!=2)DADD R1,R0,R0 ;aa=0

L1: DSUBUI R3,R2,#2BNEZ R3,L2 ;salto b2 (bb!=2)DADD R2,R0,R0 ;bb=0

L2: DSUBU R3,R1,R2 ;R3=aa-bbBEQZ R3,L3 ;salto b3 (aa==bb)

Preditor de Correlação

O desfecho de um salto condicional pode ser predito melhor, se o desfecho dos saltos imediatamente precedentes for levado em consideração.

Em geral, um preditor (m, n) usa o comportamente dos m saltos precedentes para escolher um de 2m

preditores, cada um dos quais é um preditor de n bits.

Neste contexto, diz-se que os m saltos precedentes constituem a história global, enquanto cada um dos preditores individuais regista a história local, i.e., o comportamento anterior do salto a predizer.

O número de bits da tabela de um preditor (m, n) é dado por

2m × n × nº de posições da tabela

A utilização de k bits do endereço permite selecionar uma de 2k posições

Branch address (4 bits)

2-bits per branch

local predictors

Prediction

2-bit global

branch history

(01 = not taken then taken)

Esquema preditor (2,2) : 2-bit globais e 2-bit locais

19/06/2015

12

Predição de Torneio

Constituem um exemplo de predição multi-nível de saltos;

Um previsor de torneio faz uma “competição” entre previsores, escolhendo em cada situação qual previsão usar (dos previsores em competição). Tipicamente, dois previsores estão em competição, sendo um deles global (p. ex., do tipo previsor por correlação) e o outro local (p. ex., previsor do tipo (0,2)).

Usam múltiplas tabelas de predição e um selecionador para escolher qual usar;

geralmente um nível baseia-se em informação global e outro em informação local;

Implementações atuais:

contador “saturado” de 2 bits para escolher entre dois níveis;

obtêm melhores resultados para tamanhos médios (8 KB–32 KB);

cada tabela de predição pode ter mais que um nível (p.ex. Alpha 21264).

Predição de Torneio – 2 bits Na prática, um previsor de torneio usa um contador com saturação para escolher entre dois

previsores . Com base no endereço da instrução a predizer, o previsor consulta uma tabela com 2 bits, que indicam o previsor a usar. Dependendo do resultado da predição dos dois sub previsores, o contador é atualizado, conforme ilustrado na figura abaixo.

A notação X/Y, em que X e Y podem ser 0 (falha) ou 1 (acerto), indica o desfecho de cada sub previsor.

19/06/2015

13

Tournament Predictor no Alpha 21264 4K 2-bit counters para escolha a partir da predição global ou da

predição local

Global preditor: também tem 4K entradas e é indexado por uma história dos últimos 12 branches; cada entrada no global preditor é uma predição standard de 2-bit 12-bit pattern: bit i 0 => i-ésimo branch (anterior) not taken;

bit i 1 => i-ésimo branch (anterrior) taken;

Local preditor: consiste de uma predição de 2 níveis: Top level: local history table consistindo de 1024 entradas de 10-bit; cada

entrada de 10-bit corresponde aos 10 branches mais recentes para a entrada. História de 10-bit permite casar 10 branchs.

Next level: A entrada seleciona a partir da local history table é usada como indice da tabela de 1K entradas formando um contador de 3-bit, que fornece a predição local

Tamanho total: 4K*2 + 4K*2 + 1K*10 + 1K*3 = 29K bits!

(~180,000 transistores)

Branch Prediction Performance

Branch predictor performance

19/06/2015

14

Dynamic Scheduling Possibilita o tratamento de casos em que as dependências não são

conhecidas em tempo de compilação; Reorganiza a ordem de execução de instruções para reduzir stalls enquanto

mantem o fluxo de dados.

Vantagens: O compilador não precisa ter conhecimento da microarquitetura

Trata de casos que não são conhecidos em tempo de compilação Simplifica o compilador

Por exemplo, casos que envolvem referências à memória

Permite que um código compilado para um pipeline execute de forma eficiente em um pipeline diferente

Desvantagem: Substancial aumento na complexidade do hardware

Dificulta o tratamento de exceções

Serve de base a especulação de hardware (hardware speculation), uma técnica com vantagens apreciáveis para o desempenho.

HW : Paralelismo de Instruções Exemplo de utilidade de sequenciamento dinâmico:

DIV.D F0,F2,F4ADD.D F10,F0,F8SUB.D F12,F8,F14

A dependência da instrução ADD.D em relação a DIV.D leva a CPU a protelar.

Contudo, SUB.D não depende de nenhuma instrução anterior (em execução) e poderia executar imediatamente (sem esperar que as duas instruções precedentes sejam completamente ou parcialmente executadas.)

Neste contexto, “execução” refere-se ao processamento geralmente efetuado no(s) estágio(s) EX.

O objetivo principal do sequenciamento dinâmico é evitar os conflitos causados por dependências (estruturais, de dados ou de controle).

Habilitar out-of-order execution e permitir out-of-order completion.

Em um pipeline com escalonamento dinâmico todas as instruções passam pelo estágio issue (decodificação, hazard estrutural?) em ordem (in-order issue).

19/06/2015

15

HW : Paralelismo de Instruções

out-of-order completion: problemas com exceções

out-of-order completion deve preservar o comportamento sob exceções como se fosse executado em uma máquina in-order.

Processadores com sequenciamento dinâmico preservam o comportamento sob exceções garantindo que as instruções não possam gerar exceções até que o processador saiba que a instrução que gerou a exceção está sendo executada.

Processadores com sequenciamento dinâmico podem gerar exceções imprecisas: uma exceção é dita imprecisa se o estado do processador quando ela foi gerada não corresponde exatamente ao estado que ela ocorreria se a instrução fosse executada sequencialmente. Uma instrução fora de ordem já foi completada e uma instrução anterior

a ela gera a exceção.

Uma instrução fora de ordem ainda não foi completada e uma instrução posterior a ela gera a exceção.

Scheduling Dinâmico: Implementação - MIPS

Pipeline simples tem 1 estágio que verifica se há hazard estrutural e de dados: Instruction Decode (ID), também chamado de InstructionIssue

Quebrar o estágio ID do pipeline de 5 estágios em dois estágios:

Issue — Decodificação das instruções, verificação de hazards estruturais

Read operands — Espera até não haver data hazards, então lê os operandos

Estágio EX segue o de leitura de operandos como no pipeline simples.

OBS.: - A execução pode levar múltiplos ciclos, dependendo da instrução

O pipeline permite múltiplas instruções em EX, tem múltiplas unidades funcionais (FUs)

19/06/2015

16

Algoritmo de Tomasulo IBM 360/91 (1967 - não havia caches; tempo de acesso à memória grande

e instruções de FP com grandes latências (delay))

Objetivo: Alcançar um alto desempenho sem a necessidade de um compilador especial.

Combina a monitorização da disponibilidade de operandos (evitar conflitos RAW) com register renaming (minimizar conflitos WAW e WAR). Register renaming (RR) modifica o nome dos registradores-destino de forma a

que as escritas fora de ordem não afetem instruções que dependem de um valor anterior do operando.

Esta abordagem usa estações de reserva (reservation stations) para implementar register renaming. Uma estação de reserva obtém e “guarda” um operando tão logo este esteja disponível; referências a registradores são substituídas por referências a estações (instruções pendentes designam qual a estação que fornece os dados de entrada); quando ocorrem escritas sobrepostas, apenas a última é efetuada.

Descendentes: Alpha 21264, HP 8000, MIPS 10000, Pentium III, PowerPC 604, …

Algoritmo de Tomasulo Controle & buffers distribuído na Function Units (FU)

FU buffers chamado de “reservation stations”; mantem operandos pendentes

Substituição dos Registradores nas instruções por valores ou apontadores para a reservation stations (RS): denominado registerrenaming ; Evita os hazards WAR e WAW

Se existir mais estações de reserva do que registradores, então pode-se fazer otimizações não realizadas pelos compiladores

Resultados da RS para a FU, (sem usar os registradores), broadcasts dos resultados para todas as FUs usando o Common Data Bus

Load e Stores tratados como FUs com RSs

19/06/2015

17

Register Renaming

Exemplo: WAR(f8); WAW(f6) e RAW(f0,f6 e f8)

DIV.D F0,F2,F4

ADD.D F6,F0,F8

S.D F6,0(R1)

SUB.D F8,F10,F14

MUL.D F6,F10,F8

No código existem 3 dependências verdadeiras e 2 dependências de nome:

Antidependência entre ADD.D e SUB.D via F8 ! conflito WAR.

Dependência de saída entre ADD.D e MUL.D via F6 ! conflito WAW.

A utilização de “registradores” auxiliares elimina as dependências de nomes.

No caso atual, os “registradores” são os buffers das estações de reserva.

Register Renaming

Exemplo - Suponha dois registradores temporários S e T

DIV.D F0,F2,F4

ADD.D S,F0,F8

S.D S,0(R1)

SUB.D T,F10,F14

MUL.D F6,F10,T

Now only RAW hazards remain, which can be strictly ordered

1) Neste exemplo o register rename pode ser

realizado pelo compilador (análise estática)

2) F8 deve ser substituído por T no resto do

código – requer análise mais sofisticada

(branchs, ...)

19/06/2015

18

Register Renaming

Register renaming is provided by reservation stations (RS) Contains:

The instruction

Buffered operand values (when available)

Reservation station number of instruction providing the operand values

RS fetches and buffers an operand as soon as it becomes available (not necessarily involving register file)

Pending instructions designate the RS to which they will send their output Result values broadcast on a result bus, called the common data bus

(CDB)

Only the last output updates the register file

As instructions are issued, the register specifiers are renamed with the reservation station

May be more reservation stations than registers

Tomasulo’s Algorithm

Load and store buffers

Contain data and addresses, act like reservation stations

19/06/2015

19

Reservation Station

Op: Operação a ser executada na unidade (e.g., + or –)

Vj, Vk: Valores dos operantos Fontes Store buffers tem camposV, resultados devem ser armazenados

Qj, Qk: Reservation stations produzirá os operandoscorrespondentes (valores a serem escritos) Qj,Qk = 0 => ready

Store buffers tem somente Qi para RS producing result

Busy: Indica que a reservation station e sua FU estão busy

A: Mantem informação sobre o end. de memória calculado para load ou store

Register result status (campo Qi no register file) — Indica para cadaregistrador a unidade funcional (reservation station) que irá escreve-lo. Em branco se não há instruções pendentes que escreve no registrador.

Estágios do algoritmo de Tomasulo Issue

pega a instrução na “FP Op Queue”

Se a reservation station está livre (não há hazard estrutural), issues instr & envia operandos (renames registers)

Execute executa a operação sobre os operandos (EX)

Se os dois operandos estão prontos executa a operação;

Se não, monitora o Common Data Bus (espera pelo cálculo do operando, essa espera resolve RAW) (quando um operando está pronto reservation table)

Write result termina a execução (WB)

Broadcast via Common Data Bus o resultados para todas unidades; marca a reservation station como disponível.

19/06/2015

20

Exemplo

Exemplo do Alg. Tomasulo

• Trecho de programa a ser executado:

1 L.D F6,34(R2)2 L.D F2,45(R3)3 MUL.D F0,F2,F44 SUB.D F8,F2,F65 DIV.D F10,F0,F66 ADD.D F6,F8,F2

RAW?: (1-4); (1-5); (2-3); (2-4); (2-6); ....WAW?: (1-6)WAR?: (5-6)

19/06/2015

21


• Assumir as seguintes latências:– Load: 1 ciclo

– Add; 2 ciclos

– Multiplicação: 10 ciclos

– Divisão: 40 ciclos

• Load-Store:– Calcula o endereço efetivo (FU)

– Load ou store buffers

– Acesso à memória (somente load)

– Write Result» Load: envia o valor para o registador e/ou reservation stations

» Store: escreve o valor na memória

» (escritas somente no estágio “WB” – simplifica o algoritmo de Tomasulo)


Instruction status: Exec Write

Instruction j k Issue Comp Result Busy Address

LD F6 34+ R2 Load1 No


MULTD F0 F2 F4 Load3 No

SUBD F8 F6 F2

DIVD F10 F0 F6

ADDD F6 F8 F2

Reservation Stations: S1 S2 RS RS

Time Name Busy Op Vj Vk Qj Qk

Add1 No

Add2 No

Add3 No

Mult1 No

Mult2 No

Register result status:

Clock F0 F2 F4 F6 F8 F10 F12 ... F300 FU

Clock cycle

Latência (que falta) da FU

Instruções doprograma

3 Load/Buffers

3 FP Adder R.S.2 FP Mult R.S.

3 estágios da execução

19/06/2015

22

Exemplo Tomasulo: Ciclo 1Instruction status: Exec Write


LD F6 34+ R2 1 Load1 Yes 34+R2



SUBD F8 F6 F2

DIVD F10 F0 F6

ADDD F6 F8 F2



Add1 No

Add2 No

Add3 No

Mult1 No

Mult2 No


Clock F0 F2 F4 F6 F8 F10 F12 ... F301 FU Load1

Exemplo Tomasulo: Ciclo 2






SUBD F8 F6 F2

DIVD F10 F0 F6

ADDD F6 F8 F2



Add1 No

Add2 No

Add3 No

Mult1 No

Mult2 No


Clock F0 F2 F4 F6 F8 F10 F12 ... F302 FU Load2 Load1

Nota: pode haver multiplos loads pendentes

19/06/2015

23




LD F6 34+ R2 1 3 Load1 Yes 34+R2


MULTD F0 F2 F4 3 Load3 No

SUBD F8 F6 F2

DIVD F10 F0 F6

ADDD F6 F8 F2



Add1 No

Add2 No

Add3 No

Mult1 Yes MULTD R(F4) Load2

Mult2 No


Clock F0 F2 F4 F6 F8 F10 F12 ... F303 FU Mult1 Load2 Load1

• Nota: nomes dos registradores são removidos (“renamed”) na Reservation Stations; MULT issued

• Load1 completa; alguem esperando por Load1?




LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 Load2 Yes 45+R3


SUBD F8 F6 F2 4

DIVD F10 F0 F6

ADDD F6 F8 F2



Add1 Yes SUBD M(A1) Load2

Add2 No

Add3 No

Mult1 Yes MULTD R(F4) Load2

Mult2 No


Clock F0 F2 F4 F6 F8 F10 F12 ... F304 FU Mult1 Load2 M(A1) Add1

• Load2 completa; alguem esperando por Load2?

19/06/2015

24




LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No


SUBD F8 F6 F2 4

DIVD F10 F0 F6 5

ADDD F6 F8 F2



2 Add1 Yes SUBD M(A1) M(A2)

Add2 No

Add3 No

10 Mult1 Yes MULTD M(A2) R(F4)

Mult2 Yes DIVD M(A1) Mult1


Clock F0 F2 F4 F6 F8 F10 F12 ... F305 FU Mult1 M(A2) M(A1) Add1 Mult2

• Timer inicia a contagem regressiva para Add1, Mult1




LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No


SUBD F8 F6 F2 4

DIVD F10 F0 F6 5

ADDD F6 F8 F2 6




Add2 Yes ADDD M(A2) Add1

Add3 No




Clock F0 F2 F4 F6 F8 F10 F12 ... F306 FU Mult1 M(A2) Add2 Add1 Mult2

• Issue ADDD, dependência de nome em F6?

19/06/2015

25




LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No


SUBD F8 F6 F2 4 7

DIVD F10 F0 F6 5

ADDD F6 F8 F2 6




Add2 Yes ADDD M(A2) Add1

Add3 No




Clock F0 F2 F4 F6 F8 F10 F12 ... F307 FU Mult1 M(A2) Add2 Add1 Mult2

• Add1 (SUBD) completa; alguem esperando por add1?




LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No


SUBD F8 F6 F2 4 7 8

DIVD F10 F0 F6 5

ADDD F6 F8 F2 6



Add1 No

2 Add2 Yes ADDD (M-M) M(A2)

Add3 No




Clock F0 F2 F4 F6 F8 F10 F12 ... F308 FU Mult1 M(A2) Add2 (M-M) Mult2

19/06/2015

26




LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No


SUBD F8 F6 F2 4 7 8

DIVD F10 F0 F6 5

ADDD F6 F8 F2 6



Add1 No


Add3 No








LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No


SUBD F8 F6 F2 4 7 8

DIVD F10 F0 F6 5

ADDD F6 F8 F2 6 10



Add1 No


Add3 No





• Add2 (ADDD) completa; alguem esperando por add2?

19/06/2015

27



LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No


SUBD F8 F6 F2 4 7 8

DIVD F10 F0 F6 5

ADDD F6 F8 F2 6 10 11



Add1 No

Add2 No

Add3 No




Clock F0 F2 F4 F6 F8 F10 F12 ... F3011 FU Mult1 M(A2) (M-M+M)(M-M) Mult2

• Resultado de ADDD é escrito!

• Todas as instruções mais rápidas terminam neste ciclo!




LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No


SUBD F8 F6 F2 4 7 8

DIVD F10 F0 F6 5

ADDD F6 F8 F2 6 10 11



Add1 No

Add2 No

Add3 No





19/06/2015

28




LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No


SUBD F8 F6 F2 4 7 8

DIVD F10 F0 F6 5

ADDD F6 F8 F2 6 10 11



Add1 No

Add2 No

Add3 No








LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No


SUBD F8 F6 F2 4 7 8

DIVD F10 F0 F6 5

ADDD F6 F8 F2 6 10 11



Add1 No

Add2 No

Add3 No





19/06/2015

29




LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No

MULTD F0 F2 F4 3 15 Load3 No

SUBD F8 F6 F2 4 7 8

DIVD F10 F0 F6 5

ADDD F6 F8 F2 6 10 11



Add1 No

Add2 No

Add3 No





• Mult1 (MULTD) completa; alguem esperando pormult1?




LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No

MULTD F0 F2 F4 3 15 16 Load3 No

SUBD F8 F6 F2 4 7 8

DIVD F10 F0 F6 5

ADDD F6 F8 F2 6 10 11



Add1 No

Add2 No

Add3 No

Mult1 No

40 Mult2 Yes DIVD M*F4 M(A1)


Clock F0 F2 F4 F6 F8 F10 F12 ... F3016 FU M*F4 M(A2) (M-M+M)(M-M) Mult2

• Agora é só esperar que Mult2 (DIVD) complete

19/06/2015

30

Pulando alguns ciclos (façam como exercício os ciclos faltantes?)




LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No


SUBD F8 F6 F2 4 7 8

DIVD F10 F0 F6 5

ADDD F6 F8 F2 6 10 11



Add1 No

Add2 No

Add3 No

Mult1 No




19/06/2015

31



LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No


SUBD F8 F6 F2 4 7 8

DIVD F10 F0 F6 5 56

ADDD F6 F8 F2 6 10 11



Add1 No

Add2 No

Add3 No

Mult1 No




• Mult2 (DIVD) completa; alguem esperando pormult2?


• In-order issue, out-of-order execution e out-of-order completion.



LD F6 34+ R2 1 3 4 Load1 No

LD F2 45+ R3 2 4 5 Load2 No


SUBD F8 F6 F2 4 7 8

DIVD F10 F0 F6 5 56 57

ADDD F6 F8 F2 6 10 11



Add1 No

Add2 No

Add3 No

Mult1 No

Mult2 Yes DIVD M*F4 M(A1)


Clock F0 F2 F4 F6 F8 F10 F12 ... F3057 FU M*F4 M(A2) (M-M+M)(M-M) Result

19/06/2015

32

Por que Tomasulo sobrepõe iterações de loops?

Register renaming

Multiplas iterações usam diferentes destinos físicos para os

registradores (loop unrolling dinâmico).

Reservation stations

Permite que instruções adiantem em relação as operações

inteiras de controle

Valores antigos dos regs estão no buffer – evita WAR stall

Tomasulo monta o data flow dependency graph on the fly.

Vantagens do Algoritmo de Tomasulo

1. Lógica de detecção de hazard distribuída

reservation stations e CDB distribuido

Se múltiplas instruções esperam por um único resultado e já

possuem o outro operando elas podem recebe-lo

simultaneamente (broadcast no CDB)

Se é usado um register file centralizado, as unidades só

poderão ler seus resultados quando o barramento estiver

disponível.

2. Eliminação dos hazards WAW e WAR stalls

19/06/2015

33

Interrupções Precisas?

Tomasulo:

In-order issue,

out-of-order execution,

out-of-order completion

É necessário cuidados com aspectos do out-of-order

completion para que se tenha breakpoints precisos no

stream de instruções.

Relação entre

Interrupções Precisas e Especulação

Especulação é uma forma de adivinhação.

Importante para branch prediction:

É necessário um bom sistema de adivinhação para prever a

direção do desvio (branch).

Se especularmos e estivermos errado, é necessário voltar

e reiniciar a execução a partir do ponto em que foi feita a

previsão incorreta :

Isto é semelhante ao que ocorre nas exceções precisas!

Técnica para interrupções/exceções precisas e

especulação: in-order completion ou commit

19/06/2015

34

Suporte de HW para interrupções precisas

Buffer para os resultados de instruções que não terminaram (uncommittedinstructions):

reorder buffer 3 campos: instr, destino, valor

Usar número do reorder buffer no lugar da reservation station quando a execução completar

Suprir operandos entre execution complete & commit

(Reorder buffer pode ser operando source => mais regs como RS)

Instructions commit

Uma vez que a instrução commits, o resultado é colocado no registrador

Como resultado é mais fácil desfazer instruções especuladas devido a um “mispredicted branches” ou uma exceção

Reorder

BufferFP

Op

Queue

FP Adder FP Adder

Res Stations Res Stations

FP Regs

Algoritmo de Tomasulo Especulativo - passos

1. Issue — pega a instrução da FP Op Queue Se há reservation station e reorder buffer slot livres: issue instr & envia

operandos & reorder buffer no. para o destino (este estágio é comumente chamado de “dispatch”)

2. Execution — opera sobre os operandos (EX) Quando ambos os operandos estão prontos executa; se não monitora o

CDB a espera do resultado; quando ambos estiverem na reservation station, executa; verifica se há RAW (comumente chamado de “issue”)

3. Write result — termina a execução (WB) Escreve, usando o Common Data Bus, em todas FUs que estão

esperando por esse valor & reorder buffer; marca a reservation station como disponível.

4. Commit — atualiza o registrador com o resultado em reorder Quando a instr. é a primeira no reorder buffer & o resultado está

presente: atualiza o registrador com o resultado (ou store na memória) e remove a instr. do reorder buffer. Se Mispredicted branch então flushes reorder buffer (normalmente chamado de “graduation”)

19/06/2015

35

Complexidade do HW com reorder buffer

(ROB)

Como encontrar a última versão do registrador?

(como definido no artigo Smith) é necessário uma rede de comparação associativa

Uso de register result status buffer para descobrir qual reorder buffer recebeu o valor

É necessário que o ROB tenha várias portas (como o banco de registradores)

Reorder

BufferFP

Op

Queue

FP Adder FP Adder

Res Stations Res Stations

FP Regs

Com

par ne

twork

Reorder Table

Dest

Reg

Resu

lt

Exce

ptions

?

Valid

Prog

ram C

ount

er

Hardware-Based Speculation

Execute instructions along predicted execution paths but

only commit the results if prediction was correct

Instruction commit: allowing an instruction to update the

register file when instruction is no longer speculative

Need an additional piece of hardware to prevent any

irrevocable action until an instruction commits

I.e. updating state or taking an execution

19/06/2015

36

Reorder Buffer

Reorder buffer – holds the result of instruction between completion and commit

Four fields:

Instruction type: branch/store/register

Destination field: register number

Value field: output value

Ready field: completed execution?

Modify reservation stations:

Operand source is now reorder buffer instead of functional unit

Reorder Buffer

Register values and memory values are not written until

an instruction commits

On misprediction:

Speculated entries in ROB are cleared

Exceptions:

Not recognized until it is ready to commit

19/06/2015

37

Bibliografia

David Patterson e John Hennessy,

Arquitetura e Organização de

Computadores – uma abordagem

quantitativa, 5ª Edição, ed. Campus.

arquitetura e organização de computadores 2claudio/cursos/aoc2/slides/aoc2_aula9.0_2p.pdf · a...

Documents