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
Exemplo do Alg. Tomasulo
• 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)
Exemplo do Alg. Tomasulo
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 Load1 No
LD F2 45+ R3 Load2 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
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 Load1 Yes 34+R2
LD F2 45+ R3 Load2 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 ... F301 FU Load1
Exemplo Tomasulo: Ciclo 2
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 Load1 Yes 34+R2
LD F2 45+ R3 2 Load2 Yes 45+R3
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 ... F302 FU Load2 Load1
Nota: pode haver multiplos loads pendentes
19/06/2015
23
Exemplo Tomasulo: Ciclo 3
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 3 Load1 Yes 34+R2
LD F2 45+ R3 2 Load2 Yes 45+R3
MULTD F0 F2 F4 3 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 Yes MULTD R(F4) Load2
Mult2 No
Register result status:
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?
Exemplo Tomasulo: Ciclo 4
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 Load2 Yes 45+R3
MULTD F0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4
DIVD F10 F0 F6
ADDD F6 F8 F2
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
Add1 Yes SUBD M(A1) Load2
Add2 No
Add3 No
Mult1 Yes MULTD R(F4) Load2
Mult2 No
Register result status:
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
Exemplo Tomasulo: Ciclo 5
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTD F0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4
DIVD F10 F0 F6 5
ADDD F6 F8 F2
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
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
Register result status:
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
Exemplo Tomasulo: Ciclo 6
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTD F0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4
DIVD F10 F0 F6 5
ADDD F6 F8 F2 6
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
1 Add1 Yes SUBD M(A1) M(A2)
Add2 Yes ADDD M(A2) Add1
Add3 No
9 Mult1 Yes MULTD M(A2) R(F4)
Mult2 Yes DIVD M(A1) Mult1
Register result status:
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
Exemplo Tomasulo: Ciclo 7
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTD F0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 7
DIVD F10 F0 F6 5
ADDD F6 F8 F2 6
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
0 Add1 Yes SUBD M(A1) M(A2)
Add2 Yes ADDD M(A2) Add1
Add3 No
8 Mult1 Yes MULTD M(A2) R(F4)
Mult2 Yes DIVD M(A1) Mult1
Register result status:
Clock F0 F2 F4 F6 F8 F10 F12 ... F307 FU Mult1 M(A2) Add2 Add1 Mult2
• Add1 (SUBD) completa; alguem esperando por add1?
Exemplo Tomasulo: Ciclo 8
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTD F0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDD F6 F8 F2 6
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
Add1 No
2 Add2 Yes ADDD (M-M) M(A2)
Add3 No
7 Mult1 Yes MULTD M(A2) R(F4)
Mult2 Yes DIVD M(A1) Mult1
Register result status:
Clock F0 F2 F4 F6 F8 F10 F12 ... F308 FU Mult1 M(A2) Add2 (M-M) Mult2
19/06/2015
26
Exemplo Tomasulo: Ciclo 9
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTD F0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDD F6 F8 F2 6
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
Add1 No
1 Add2 Yes ADDD (M-M) M(A2)
Add3 No
6 Mult1 Yes MULTD M(A2) R(F4)
Mult2 Yes DIVD M(A1) Mult1
Register result status:
Clock F0 F2 F4 F6 F8 F10 F12 ... F309 FU Mult1 M(A2) Add2 (M-M) Mult2
Exemplo Tomasulo: Ciclo 10
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTD F0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDD F6 F8 F2 6 10
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
Add1 No
0 Add2 Yes ADDD (M-M) M(A2)
Add3 No
5 Mult1 Yes MULTD M(A2) R(F4)
Mult2 Yes DIVD M(A1) Mult1
Register result status:
Clock F0 F2 F4 F6 F8 F10 F12 ... F3010 FU Mult1 M(A2) Add2 (M-M) Mult2
• Add2 (ADDD) completa; alguem esperando por add2?
19/06/2015
27
Exemplo Tomasulo: Ciclo 11Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTD F0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDD F6 F8 F2 6 10 11
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
Add1 No
Add2 No
Add3 No
4 Mult1 Yes MULTD M(A2) R(F4)
Mult2 Yes DIVD M(A1) Mult1
Register result status:
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!
Exemplo Tomasulo: Ciclo 12
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTD F0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDD F6 F8 F2 6 10 11
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
Add1 No
Add2 No
Add3 No
3 Mult1 Yes MULTD M(A2) R(F4)
Mult2 Yes DIVD M(A1) Mult1
Register result status:
Clock F0 F2 F4 F6 F8 F10 F12 ... F3012 FU Mult1 M(A2) (M-M+M)(M-M) Mult2
19/06/2015
28
Exemplo Tomasulo: Ciclo 13
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTD F0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDD F6 F8 F2 6 10 11
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
Add1 No
Add2 No
Add3 No
2 Mult1 Yes MULTD M(A2) R(F4)
Mult2 Yes DIVD M(A1) Mult1
Register result status:
Clock F0 F2 F4 F6 F8 F10 F12 ... F3013 FU Mult1 M(A2) (M-M+M)(M-M) Mult2
Exemplo Tomasulo: Ciclo 14
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTD F0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDD F6 F8 F2 6 10 11
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
Add1 No
Add2 No
Add3 No
1 Mult1 Yes MULTD M(A2) R(F4)
Mult2 Yes DIVD M(A1) Mult1
Register result status:
Clock F0 F2 F4 F6 F8 F10 F12 ... F3014 FU Mult1 M(A2) (M-M+M)(M-M) Mult2
19/06/2015
29
Exemplo Tomasulo: Ciclo 15
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
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
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
Add1 No
Add2 No
Add3 No
0 Mult1 Yes MULTD M(A2) R(F4)
Mult2 Yes DIVD M(A1) Mult1
Register result status:
Clock F0 F2 F4 F6 F8 F10 F12 ... F3015 FU Mult1 M(A2) (M-M+M)(M-M) Mult2
• Mult1 (MULTD) completa; alguem esperando pormult1?
Exemplo Tomasulo: Ciclo 16
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
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
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
Add1 No
Add2 No
Add3 No
Mult1 No
40 Mult2 Yes DIVD M*F4 M(A1)
Register result status:
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?)
Exemplo Tomasulo: Ciclo 55
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
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
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
Add1 No
Add2 No
Add3 No
Mult1 No
1 Mult2 Yes DIVD M*F4 M(A1)
Register result status:
Clock F0 F2 F4 F6 F8 F10 F12 ... F3055 FU M*F4 M(A2) (M-M+M)(M-M) Mult2
19/06/2015
31
Exemplo Tomasulo: Ciclo 56Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
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 56
ADDD F6 F8 F2 6 10 11
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
Add1 No
Add2 No
Add3 No
Mult1 No
0 Mult2 Yes DIVD M*F4 M(A1)
Register result status:
Clock F0 F2 F4 F6 F8 F10 F12 ... F3056 FU M*F4 M(A2) (M-M+M)(M-M) Mult2
• Mult2 (DIVD) completa; alguem esperando pormult2?
Exemplo Tomasulo: Ciclo 57
• In-order issue, out-of-order execution e out-of-order completion.
Instruction status: Exec Write
Instruction j k Issue Comp Result Busy Address
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 56 57
ADDD F6 F8 F2 6 10 11
Reservation Stations: S1 S2 RS RS
Time Name Busy Op Vj Vk Qj Qk
Add1 No
Add2 No
Add3 No
Mult1 No
Mult2 Yes DIVD M*F4 M(A1)
Register result status:
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.