3. Pipelining Avançado 3.1. Escalonamento Dinâmico

Arquitectura de Computadores II

Paulo MarquesDepartamento de Eng. InformáticaUniversidade de [email protected]

2004

/200

5

3. Pipelining Avançado3.1. Escalonamento Dinâmico

2

Pipelining Avançado?

3

Instruction Level Parallelism

Explorar o potencial paralelismo existente numa sequência (fluxo) de instruções

(...) a = x + y;

b = x - y;c = x*x + y*y;(...)

Existem duas grandes abordagens para explorar ILP: Dinâmicas Baseadas em Hardware Estáticas Baseadas em Software (Compilador)

Limitações ao ILP... CPIPipeline = CPIIdeal +

Structural_Hazzards + Data_Stalls + Control_Stalls

4

Paralelismo Disponível

Bloco Básico: Uma sequência “limpa” de instruções sem saltos (excepto para a sua entrada e no seu ponto de saída)

Loop: L.D F0, 0(R1)ADD.D F4, F0, F2S.D F4, 0(R1)DADDUI R1, R1, -8BNE R1, R2, Loop

Tamanho médio de um bloco básico em programas MIPS: 4 a 7 instruções!!!

É necessário haver técnicas para explorar o paralelismo para além de blocos básicos!

5

Como ir além dos blocos básicos?

Exemplo: Loop Unrolling

Este tipo de operações pode ser feito... Pelo compilador

(e.g. gcc m.c -funroll-loops matrix.c -o m; instruções vectoriais)

Pelo processador(escalonamento dinâmico, processadores vectoriais)

for (i=0; i<N; i++) x[i] = y[i] + 5;

for (i=0; i<N; i+=4) { x[i] = y[i] + 5; x[i+1] = y[i+1] + 5; x[i+2] = y[i+2] + 5; x[i+3] = y[i+3] + 5;}

6

Primeiro tipo de limitações: Dados

(Verdadeiras) Dependências de Dados

Loop: LW R1, 0(R20)

ADDU R2, R1, R4

SW R2, 80(R20)

ADDI R20, R20, -8

BNE R20, R6, Loop

Para o programa executar correctamente, as instruções em causa têm de ser executadas na sequência em que aparecem Não podem executar fora de ordem ou ao mesmo tempo! É difícil de lidar com dependências que envolvam de

memória

7

Dependências de Nome

Dependências de Nome: ocorrem quando sequências de instruções utilizam os mesmos registos sem que exista verdadeiro fluxo de dados entre elas

As dependências de nome são resolúveis alterando o nome dos registos (register renaming)

Loop: LW R1, 0(R20)ADDU R2, R1, R4SW R2, 80(R20)ADDI R20, R20, -8LW R1, 0(R20)ADDU R2, R1, R4SW R2, 80(R20)

Antidependência

Dependência deSaída

8

Data Hazzards

RAW: Read after Write Uma instrução tenta ler os dados antes da instrução que

os produz os escrever Verdadeiras dependências de dados; a ordem tem de ser

preservada; uso de forwarding ou introdução de stalls WAW: Write after Write

Uma instrução tenta escrever os seus dados quando uma anterior ainda não o fez

Não pode ocorrer no pipeline simples dos MIPS WAR: Write after Read

Uma instrução tenta escrever os seus dados num destino antes de uma instrução anterior ter oportunidade de usar os dados nesse destino

Tipicamente só ocorre se as instruções não forem executadas em ordem

9

Segundo tipo de limitações: Controlo

Uma instrução que tem uma dependência de controlo relativamente a um salto não pode ser movida para antes do salto

Uma instrução que não tem uma dependência de controlo relativamente a um salto não pode ser movida para depois do salto (de forma a que já não é controlada pelo mesmo)

if (cond1) { S1;}if (cond2) { S2;}

Dependência de controlo

Dependência de controlo

10

Qual é a relevância de tudo isto?

Nós não queremos preservar a ordem de execução das instruções...

Nós não queremos apenas executar saltos e instruções que existam apenas no programa...

Para a execução do programa ser correcto, tudo o que tem de ser preservado é: Os fluxos de dados existentes no programa original O comportamento nos casos em que existam excepções

Um processador de elevada performancepode:

- Executar instruções fora de ordem!!!- Executar instruções especulativamente que nunca deveriam ser executadas!!!

11

CDC 6600, Scoreboard & Seymour Cray

CDC 6600, 1965

12

Escalonamento Dinâmico com um Scoreboard

Divide-se a fase ID em duas: Issue: Descodificação da instrução e verificação de

dependências estruturais Read Operands: Espera até que não existam

dependências de dados e então lê os operandos

In-order issue Assim que as dependências estão resolvidas, a instrução

é enviada para uma unidade funcional disponível As instruções podem “ultrapassar-se” na parte de leitura

de operandos

Out-of-order Execution / Completion As instruções começam a executar assim que já não

existam dependências de dados (nem estruturais!) Out-of-order Execution => Out-of-order Completion

13

Novos conflitos de dados que podem surgir...

WAR (Write-After-Read)

WAW (Write-After-Write)

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

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

-- O scoreboard têm de lidar com estes problemas-- Objectivo do scoreboard: executar uma instrução quão cedo quanto possível, desde que não hajam dependências

14

Aspecto de um Scoreboard para o MIPS (FP!)

Mantém a informaçãosobre todas as instruçõesem execução

15

Operação do “Novo” Pipeline

IF – Instrucution Fetch (Vai buscar a instrução à memória) IS – Issue

Se existe uma unidade funcional livre para a instrução E nenhuma outra instrução irá escrever no endereço destino da instrução então a instrução é enviada para a unidade funcionar e o Scoreboard actualizado (resolve WAW)

RD – Read Operands O Scoreboard verifica quando é que os operandos da instrução

ficam disponíveis (i.e. nenhuma outra instrução tem uma escrita pendente). Quando estão disponíveis, o Scoreboard informa a unidade funcional que pode prosseguir com a leitura (resolve RAW)

EX – Execution A unidade funcional executa a operação. Quando a operação

completa, a mesma informa o Scoreboard WR – Write Result

O Scoreboard verifica se não existem conflitos WAR (i.e. instruções pendentes que ainda não leram os registos necessários – dados de outras instruções anteriores – numa altura em que estamos a tentar escrever). Quando não existem, o Scoreboard informa a unidade funcional que pode escrever o registo destino

16

Componentes do ScoreboardIn

stru

ções

Issu

edou

pen

ding

(W

indo

w)

Uni

dade

s F

unci

onai

s E

xist

ente

s

Ocupada?OperaçãoRegisto DestinoRegistos OrigemQuem produz regs. origemFi e Fj ready

AND not read

Esc

ritas

Pen

dent

es

17

Vamos a um exemplo...

Os slides seguintes foram obtidos de:CS 505: Computer ArchitectureSpring 2005(c) Thu D. Nguyen

http://paul.rutgers.edu/courses/cs505/s05/

18

Scoreboard Example

Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2LD F2 45+ R3MULTD F0 F2 F4SUBD F8 F6 F2DIVD F10 F0 F6ADDD F6 F8 F2

Functional unit status: dest S1 S2 FU FU Fj? Fk?Time Name Busy Op Fi Fj Fk Qj Qk Rj Rk

Integer NoMult1 NoMult2 NoAdd NoDivide No

Register result status:Clock F0 F2 F4 F6 F8 F10 F12 ... F30

FU

19

Scoreboard Example: Cycle 1

Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1LD F2 45+ R3MULTD F0 F2 F4SUBD F8 F6 F2DIVD F10 F0 F6ADDD F6 F8 F2


Integer Yes Load F6 R2 YesMult1 NoMult2 NoAdd NoDivide No


1 FU Integer

20


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2LD F2 45+ R3MULTD F0 F2 F4SUBD F8 F6 F2DIVD F10 F0 F6ADDD F6 F8 F2




2 FU Integer

• Issue 2nd LD?

21


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3LD F2 45+ R3MULTD F0 F2 F4SUBD F8 F6 F2DIVD F10 F0 F6ADDD F6 F8 F2


Integer Yes Load F6 R2 NoMult1 NoMult2 NoAdd NoDivide No


3 FU Integer

• Issue MULT?

22


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3MULTD F0 F2 F4SUBD F8 F6 F2DIVD F10 F0 F6ADDD F6 F8 F2




4 FU

23


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5MULTD F0 F2 F4SUBD F8 F6 F2DIVD F10 F0 F6ADDD F6 F8 F2




5 FU Integer

24


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6MULTD F0 F2 F4 6SUBD F8 F6 F2DIVD F10 F0 F6ADDD F6 F8 F2


Integer Yes Load F2 R3 YesMult1 Yes Mult F0 F2 F4 Integer No YesMult2 NoAdd NoDivide No


6 FU Mult1 Integer

25


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7

MULTD F0 F2 F4 6SUBD F8 F6 F2 7DIVD F10 F0 F6ADDD F6 F8 F2


Integer Yes Load F2 R3 NoMult1 Yes Mult F0 F2 F4 Integer No YesMult2 NoAdd Yes Sub F8 F6 F2 Integer Yes NoDivide No


7 FU Mult1 Integer Add

26

Scoreboard Example: Cycle 8a

Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7MULTD F0 F2 F4 6SUBD F8 F6 F2 7DIVD F10 F0 F6 8ADDD F6 F8 F2


Integer Yes Load F2 R3 NoMult1 Yes Mult F0 F2 F4 Integer No YesMult2 NoAdd Yes Sub F8 F6 F2 Integer Yes NoDivide Yes Div F10 F0 F6 Mult1 No Yes


8 FU Mult1 Integer Add Divide

27

Scoreboard Example: Cycle 8b

Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6SUBD F8 F6 F2 7DIVD F10 F0 F6 8ADDD F6 F8 F2


Integer NoMult1 Yes Mult F0 F2 F4 Yes YesMult2 NoAdd Yes Sub F8 F6 F2 Yes YesDivide Yes Div F10 F0 F6 Mult1 No Yes


8 FU Mult1 Add Divide

28


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4

LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9SUBD F8 F6 F2 7 9DIVD F10 F0 F6 8ADDD F6 F8 F2


Integer No10 Mult1 Yes Mult F0 F2 F4 Yes YesMult2 No

2 Add Yes Sub F8 F6 F2 Yes YesDivide Yes Div F10 F0 F6 Mult1 No Yes


9 FU Mult1 Add Divide

• Read operands for MULT & SUB? Issue ADDD?

Note Remaining

29


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9SUBD F8 F6 F2 7 9DIVD F10 F0 F6 8ADDD F6 F8 F2


Integer No9 Mult1 Yes Mult F0 F2 F4 No NoMult2 No

1 Add Yes Sub F8 F6 F2 No NoDivide Yes Div F10 F0 F6 Mult1 No Yes

Register result status:Clock F0 F2 F4 F6 F8 F10 F12 ... F3010 FU Mult1 Add Divide

30


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9SUBD F8 F6 F2 7 9 11DIVD F10 F0 F6 8ADDD F6 F8 F2



0 Add Yes Sub F8 F6 F2 No NoDivide Yes Div F10 F0 F6 Mult1 No Yes


31


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9SUBD F8 F6 F2 7 9 11 12DIVD F10 F0 F6 8ADDD F6 F8 F2


Integer No7 Mult1 Yes Mult F0 F2 F4 No NoMult2 NoAdd NoDivide Yes Div F10 F0 F6 Mult1 No Yes

Register result status:Clock F0 F2 F4 F6 F8 F10 F12 ... F3012 FU Mult1 Divide

• Read operands for DIVD?

32


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9SUBD F8 F6 F2 7 9 11 12DIVD F10 F0 F6 8ADDD F6 F8 F2 13


Integer No6 Mult1 Yes Mult F0 F2 F4 No NoMult2 NoAdd Yes Add F6 F8 F2 Yes YesDivide Yes Div F10 F0 F6 Mult1 No Yes


33


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9SUBD F8 F6 F2 7 9 11 12DIVD F10 F0 F6 8ADDD F6 F8 F2 13 14



2 Add Yes Add F6 F8 F2 Yes YesDivide Yes Div F10 F0 F6 Mult1 No Yes


34


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9

SUBD F8 F6 F2 7 9 11 12DIVD F10 F0 F6 8ADDD F6 F8 F2 13 14



1 Add Yes Add F6 F8 F2 No NoDivide Yes Div F10 F0 F6 Mult1 No Yes


35


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9SUBD F8 F6 F2 7 9 11 12DIVD F10 F0 F6 8ADDD F6 F8 F2 13 14 16



0 Add Yes Add F6 F8 F2 No NoDivide Yes Div F10 F0 F6 Mult1 No Yes


36




Integer No2 Mult1 Yes Mult F0 F2 F4 No NoMult2 NoAdd Yes Add F6 F8 F2 No NoDivide Yes Div F10 F0 F6 Mult1 No Yes


• Why not write result of ADD???

WAR Hazard!

37






38


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9 19SUBD F8 F6 F2 7 9 11 12DIVD F10 F0 F6 8ADDD F6 F8 F2 13 14 16




39


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9 19 20SUBD F8 F6 F2 7 9 11 12DIVD F10 F0 F6 8ADDD F6 F8 F2 13 14 16


Integer NoMult1 NoMult2 NoAdd Yes Add F6 F8 F2 No NoDivide Yes Div F10 F0 F6 Yes Yes

Register result status:Clock F0 F2 F4 F6 F8 F10 F12 ... F3020 FU Add Divide

40


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9 19 20SUBD F8 F6 F2 7 9 11 12DIVD F10 F0 F6 8 21ADDD F6 F8 F2 13 14 16


Integer NoMult1 NoMult2 NoAdd Yes Add F6 F8 F2 No NoDivide Yes Div F10 F0 F6 Yes Yes

Register result status:Clock F0 F2 F4 F6 F8 F10 F12 ... F3021 FU Add Divide

• WAR Hazard is now gone...

41


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9 19 20SUBD F8 F6 F2 7 9 11 12DIVD F10 F0 F6 8 21ADDD F6 F8 F2 13 14 16 22


Integer NoMult1 NoMult2 NoAdd No

39 Divide Yes Div F10 F0 F6 No No

Register result status:Clock F0 F2 F4 F6 F8 F10 F12 ... F3022 FU Divide

42

Skip a couple of cycles...

43


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9 19 20SUBD F8 F6 F2 7 9 11 12DIVD F10 F0 F6 8 21 61ADDD F6 F8 F2 13 14 16 22


Integer NoMult1 NoMult2 NoAdd No

0 Divide Yes Div F10 F0 F6 No No

Register result status:Clock F0 F2 F4 F6 F8 F10 F12 ... F3061 FU Divide

44


Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9 19 20SUBD F8 F6 F2 7 9 11 12DIVD F10 F0 F6 8 21 61 62ADDD F6 F8 F2 13 14 16 22



Register result status:Clock F0 F2 F4 F6 F8 F10 F12 ... F3062 FU

45

Review: Scoreboard Example: Cycle 62

Instruction status: Read Exec WriteInstruction j k Issue Oper Comp ResultLD F6 34+ R2 1 2 3 4LD F2 45+ R3 5 6 7 8MULTD F0 F2 F4 6 9 19 20SUBD F8 F6 F2 7 9 11 12DIVD F10 F0 F6 8 21 61 62ADDD F6 F8 F2 13 14 16 22



Register result status:Clock F0 F2 F4 F6 F8 F10 F12 ... F3062 FU

• In-order issue; out-of-order execute & commit

46

Pontos chave da técnica Scoreboarding

In-order Issue, Out-of-order Execution and Completion

Se não é possível fazer o Issue, todo o pipeline pára Tamanho do buffer entre a fase IF e ISSUE

Limitações ILP disponível num bloco básico (verdadeiras

dependências) Tamanho da janela do Scoreboard Tipo e número de unidades funcionais disponíveis Presença de anti-dependências e dependências de saída

47

Processadores Modernos...

Utilizam uma forma avançada de Scoreboarding Algoritmo de Tomasulo (IBM 360/91)

Ideias base: Verifica quando os operandos das instruções estão

disponíveis (semelhante ao Scoreboard Reais dependências de dados)

Register Renaming para evitar WAR e WAW

LW R1, 0(R20)ADDU R2, R1, R4SW R2, 80(R20)ADDI R20, R20, -8LW R1, 0(R20)ADDU R2, R1, R4SW R2, 80(R20)

LW R1, 0(R20)ADDU R2, R1, R4SW R2, 80(R20)ADDI R20, R20, -8LW R1, 0(R20)ADDU R10, R1, R4SW R10, 80(R20)

48

Componentes do Hardware de Tomasulo

Múltiplas Unidades Funcionais

Reservation Stations (RS) Mantêm os operandos aguardando ser lançados Fazem a gestão local do lançamento

Common Data BUS (CDB) Os dados vão directamente para as reservation stations

sem passar pelos registos Gestão distribuída dos dados

49

Estrutura do Hardware de Tomasulo

50

Algoritmo (Simplificado)

ISSUE Obtêm a instrução da Instruction Queue e envia-a para a

RS correcta (se disponível), com o valor dos operandos. Se os operandos não estão disponíveis, envia a instrução indicando as unidades funcionais que irão produzir os resultados.

Renomeia os registos de forma a evitar WAR e WAW! EXECUTE

Se os operandos não estão disponíveis espera até que eles surgirem no CDB. Nessa altura, a instrução pode ser executada. Note-se que na mesma unidade funcional, esta execução não tem de ser em ordem.

Os conflitos RAW (verdadeiras dependências) são evitadas esperando até que os operandos estejam disponíveis.

WRITE RESULT Quando uma instrução acaba de executar, o resultado é

escrito no CDB. Isto implica que todas as RS que estejam à espera do resultado obtêm o valor. Os registos/memória também são escritos nesta altura.

51

The Devil is in the Details...

This is a picture of someone murdering Tomasulo, whose algorithm is thoroughly inexplicable...(http://www.llamas.org/notes/cmsc411.html)

52

Material para ler

Computer Architecture: A Quantitative Approach Secções 3.1 e 3.2

Ao ler 3.2, ler apenas até ao Algoritmo de Tomasulo Apêndice A.8

Contém o algoritmo/estrutura utilizado no Scoreboard A restante parte da Secção 3.2

Contém um overview do Algoritmo de Tomasulo



2004

/200

5

3. Pipelining Avançado3.2. Redução do Custo dos Saltos

54

Onde estamos nós?

Num pipeline profundo,é essencial reduzir ocusto dos saltos!!!

55

Reduzir a penalidade nos saltos

Se um pipeline é profundo, o número bolhas que um salto potencialmente introduz é bastante elevado

Se falamos de um processador multi-issue (capaz de fazer o issue de mais do que uma instrução por ciclo de relógio), então saltos surgem N vezes mais depressa!

A ideia base é prever dinamicamente qual a direcção que um salto condicional toma

56

Branch Prediction Buffer / Branch History Table

0Branch History Table

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

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

ADDI R2, R0, 5BNE R0, R2, 0xA14FC326ADDI R6, R7, R8

0 Not Taken1 Taken

Lookup

Último: NOT TAKEN; faz fetch da instrução seguinte

1004

57

Branch Prediction Buffer / Branch History Table

0Branch History Table

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

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

ADDI R2, R0, 5BNE R0, R2, 0xA14FC326ADDI R6, R7, R8

0 Not Taken1 Taken

Quando descobre que se enganou,actualiza a entrada correcta, eliminaas instruções erradas do pipelinee recomeça o fetch de 0xA14FC326

58

Demasiado simplista...

Suponhamos um salto. Mesmo que este seja quase sempre tomado (e.g. um ciclo for ou while), quase de certeza que o mesmo é previsto incorrectamente duas vezes (em vez de uma) quando o mesmo não é tomado

for (i=0; i<10; i++){ ...}

Ao executar repetidamentea previsão fica Taken

Na última iteração, a previsão é errada (inevitável)

Ao voltar a entrar, a previsão é NOT Taken,mas a “nova” primeira iteração vai quase secerteza ser Taken!!!

Num ciclo de 10 iterações, previmos erradamente duas: 20%!!

59

2-bit Predictor

Tem de falhar pelo menos duas vezes antes da previsão ser alterada

60

Buffer de 4K vs. Buffer Infinito

O factor limitante não é o tamanho do buffer, é a qualidade das previsões!

61

Correlating Branch Predictors

if (x == 10){ specialCase = true;}

(...)

if (specialCase){ (...)}

Estes saltos estão correlacionados!

Nenhum esquema “simples”como o anterior conseguecapturar o comportamentodeste tipo de código!

62

Correlating Branch Predictors

NT/NT NT/T T/NT T/T

63

Performance Global

Tournament Predictors [Ideia]: Para cada salto, utilizar diferentes predictors, consoante o qual seja melhor para o salto em causa...

64

Branch-Target Buffer

Os Branch Predictors predizem de forma bastante adequada se um salto vai ocorrer ou não. Mas, caso este ocorra, como é que eu sei de ir buscar a

próxima instrução (fetch)? Calcular o endereço de destino (PC+offset) pode ser

demasiado longo; O endereço de destino pode estar num registo (salto

indirecto)

Solução: Utilizar uma cache de saltos anteriores!

65

Branch-Target Buffer (BTB)

66

Uso do Branch Target Buffer

Instr. no buffer?

Previsão SaltoPenalida

de (Ciclos)

SIM TAKEN TAKEN 0

SIM TAKENNOT

TAKEN2

NÃO -- TAKEN 2

NÃO --NOT

TAKEN0

67

Return Branch Predictors

Sempre que é chamada uma rotina, o return é um salto indirecto. No entanto, se a rotina é chamada de diferentes locais, o PC destino é variável. A performance de um Branch Target Buffer não será muito boa Utiliza-se uma cache em forma de stack em que sempre que é

feita uma chamada, é guardado o endereço de retorno! (ATENÇÃO: Isto não é o stack normal do programa!!!)

68

Material para ler


Ler “rapidamente” a parte “Integrated Instruction Fetch Units” mas dando atenção à parte de “Instruction Prefetch”



2004

/200

5

3. Pipelining Avançado3.3. Processadores Multi-Issue

70

Pipelining Avançado

Scoreboarding / Tomasulo Objectivo: CPI = 1 (IPC = 1)

Processadores Actuais (Multi-Issue) Objectivo: CPI < 1 (IPC > 1)

Processadores Multi-Issue Super-escalares [e.g. Intel Pentium 4, AMD Opteron] Very Large Instruction Word (VLIW) [e.g. Intel Itanium2]

71

Nomenclatura

Processador

Front-end

FU1 FU2 FU3 FU4 FU5 FU6

Memória

Back-end

FSB = Front-Side Bus

IF / ID / Issue

Execute / Commit

72

Super-escalares vs. VLIW

Instrução 1

Instrução 2

Instrução 3

Instrução ...

Instrução N

Integer Unit 1

Integer Unit 2

FP Unit 1

FP Unit 2

Processor Frontend

INT1 INT2 FP1 FP2

INT1 INT2 FP1 FP2

INT1 INT2 FP1 FP2

INT1 INT2 FP1 FP2

INT1 INT2 FP1 FP2

Integer Unit 1

Integer Unit 2

FP Unit 1

FP Unit 2

Processor Frontend

73

Super-escalares vs. VLIW (típicos)

Super-Escalares Escalonamento dinâmico, baseado no hardware Out-of-order execution Hardware mais complicado Compiladores “relativamente” simples Melhor adaptados ao ILP existente

VLIW (ou EPIC na terminologia Intel/HP) Escalonamento estático, baseado em software In-order Execution Hardware mais simples Compiladores evoluídos Tipicamente não muito bem adaptados ao ILP existente

(problemas de largura de banda com a memória e da explosão do tamanho dos programas)

74

Aspecto de um pipeline MIPS super-escalar estático

IF ID EXE MEM WB

IF ID EXE MEM WB

IF ID EXE MEM WB

IF ID EXE MEM WB

IF ID EXE MEM WB

IF ID EXE MEM WB

IF ID EXE MEM WB

IF ID EXE MEM WB

IF ID EXE MEM WB

IF ID EXE MEM WB

INT Op

FP Op

INT Op

FP Op

INT Op

FP Op

INT Op

FP Op

INT Op

FP Op

75

Pipeline Super-escalar c/ Escalonamento Dinâmico

Re-order buffer (ROB)

76

Questão

O que é que acontece com as operações de load/store para memória? Como é que apenas existe “commit” no final?

77

E o que acontece nos saltos?

Se temos um processador N multi-issue, isso quer dizer que os saltos chegam N vezes mais depressa! 4 ou mais em processadores modernos...

O tamanho médio de um bloco básico é 4 a 7 instruções! Necessidade de “ajuda” do compilador devido a um

overhead demasiado grande dos saltos e a estes surgirem “demasiado rápido”

Conclusão: “simplesmente” prever os saltos já não é suficiente! Execução Especulativa

78

Hardware de Tomasulo com o ROB

No algoritmo de Tomasulo,assim que uma instruçãoescrevia um resultado, todasas outras viam-no no registerfile. Com o ROB, os registossó são actualizados quandouma instrução já não éespeculativa!

79

Material para ler


Atenção: Não vimos em profundidade as alterações necessárias ao Algoritmo de Tomasulo para termos execução especulativa

3. Pipelining Avançado 3.1. Escalonamento Dinâmico

Documents

Transcript of 3. Pipelining Avançado 3.1. Escalonamento Dinâmico