3 pipelining avan ado 3 1 escalonamento din mico
This presentation is the property of its rightful owner.
Sponsored Links
1 / 79

3. Pipelining Avançado 3.1. Escalonamento Dinâmico PowerPoint PPT Presentation


  • 62 Views
  • Uploaded on
  • Presentation posted in: General

3. Pipelining Avançado 3.1. Escalonamento Dinâmico. Pipelining Avançado?. 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; (...)

Download Presentation

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

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


3 pipelining avan ado 3 1 escalonamento din mico

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


Pipelining avan ado

Pipelining Avançado?


Instruction level parallelism

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


Paralelismo dispon vel

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!


Como ir al m dos blocos b sicos

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;

}


Primeiro tipo de limita es dados

Primeiro tipo de limitações: Dados

  • (Verdadeiras) Dependências de Dados

    Loop:LWR1, 0(R20)ADDUR2, R1, R4SWR2, 80(R20)ADDIR20, R20, -8BNER20, 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


Depend ncias de nome

Antidependência

Dependência de

Saída

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:LWR1, 0(R20)ADDUR2, R1, R4SWR2, 80(R20)

ADDIR20, R20, -8LWR1, 0(R20)ADDUR2, R1, R4SWR2, 80(R20)


Data hazzards

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


Segundo tipo de limita es controlo

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


Qual a relev ncia de tudo isto

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 performance

pode:

- Executar instruções fora de ordem!!!

- Executar instruções especulativamente

que nunca deveriam ser executadas!!!


Cdc 6600 scoreboard seymour cray

CDC 6600, Scoreboard & Seymour Cray

  • CDC 6600, 1965


Escalonamento din mico com um scoreboard

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


Novos conflitos de dados que podem surgir

Novos conflitos de dados que podem surgir...

  • WAR (Write-After-Read)

  • WAW (Write-After-Write)

DIV.DF0, F2, F4

ADD.DF10, F0, F8

SUB.DF8, F12, F14

DIV.DF0, F2, F4

ADD.DF10, F0, F8

SUB.DF0, 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


Aspecto de um scoreboard para o mips fp

Mantém a informação

sobre todas as instruções

em execução

Aspecto de um Scoreboard para o MIPS (FP!)


Opera o do novo pipeline

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


Componentes do scoreboard

Escritas

Pendentes

Unidades Funcionais

Existentes

Instruções Issued

ou pending (Window)

Registos Origem

Quem produz regs. origem

Fi e Fj readyAND not read

Ocupada?

Operação

Registo Destino

Componentes do Scoreboard


Vamos a um exemplo

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/


Scoreboard example

Scoreboard Example


Scoreboard example cycle 1

Scoreboard Example: Cycle 1


Scoreboard example cycle 2

Scoreboard Example: Cycle 2

  • Issue 2nd LD?


Scoreboard example cycle 3

Scoreboard Example: Cycle 3

  • Issue MULT?


Scoreboard example cycle 4

Scoreboard Example: Cycle 4


Scoreboard example cycle 5

Scoreboard Example: Cycle 5


Scoreboard example cycle 6

Scoreboard Example: Cycle 6


Scoreboard example cycle 7

Scoreboard Example: Cycle 7


Scoreboard example cycle 8a

Scoreboard Example: Cycle 8a


Scoreboard example cycle 8b

Scoreboard Example: Cycle 8b


Scoreboard example cycle 9

Scoreboard Example: Cycle 9

Note

Remaining

  • Read operands for MULT & SUB? Issue ADDD?


Scoreboard example cycle 10

Scoreboard Example: Cycle 10


Scoreboard example cycle 11

Scoreboard Example: Cycle 11


Scoreboard example cycle 12

Scoreboard Example: Cycle 12

  • Read operands for DIVD?


Scoreboard example cycle 13

Scoreboard Example: Cycle 13


Scoreboard example cycle 14

Scoreboard Example: Cycle 14


Scoreboard example cycle 15

Scoreboard Example: Cycle 15


Scoreboard example cycle 16

Scoreboard Example: Cycle 16


Scoreboard example cycle 17

WAR Hazard!

Scoreboard Example: Cycle 17

  • Why not write result of ADD???


Scoreboard example cycle 18

Scoreboard Example: Cycle 18


Scoreboard example cycle 19

Scoreboard Example: Cycle 19


Scoreboard example cycle 20

Scoreboard Example: Cycle 20


Scoreboard example cycle 21

Scoreboard Example: Cycle 21

  • WAR Hazard is now gone...


Scoreboard example cycle 22

Scoreboard Example: Cycle 22


Skip a couple of cycles

Skip a couple of cycles...


Scoreboard example cycle 61

Scoreboard Example: Cycle 61


Scoreboard example cycle 62

Scoreboard Example: Cycle 62


Review scoreboard example cycle 62

Review: Scoreboard Example: Cycle 62

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


Pontos chave da t cnica scoreboarding

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


Processadores modernos

LWR1, 0(R20)ADDUR2, R1, R4SWR2, 80(R20)

ADDIR20, R20, -8LWR1, 0(R20)ADDUR10, R1, R4SWR10, 80(R20)

LWR1, 0(R20)ADDUR2, R1, R4SWR2, 80(R20)

ADDIR20, R20, -8LWR1, 0(R20)ADDUR2, R1, R4SWR2, 80(R20)

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


Componentes do hardware de tomasulo

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


Estrutura do hardware de tomasulo

Estrutura do Hardware de Tomasulo


Algoritmo simplificado

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.


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)

The Devil is in the Details...


Material para ler

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


3 pipelining avan ado 3 2 redu o do custo dos saltos

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


Onde estamos n s

Num pipeline profundo,

é essencial reduzir o

custo dos saltos!!!

Onde estamos nós?


Reduzir a penalidade nos saltos

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


Branch prediction buffer branch history table

Lookup

Branch Prediction Buffer / Branch History Table

Branch History Table

0

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

ADDIR2, R0, 5

BNE R0, R2, 0xA14FC326

ADDIR6, R7, R8

1004

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

0  Not Taken

1  Taken


Branch prediction buffer branch history table1

Branch Prediction Buffer / Branch History Table

Branch History Table

0

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

ADDIR2, R0, 5

BNE R0, R2, 0xA14FC326

ADDIR6, R7, R8

Quando descobre que se enganou,

actualiza a entrada correcta, elimina

as instruções erradas do pipeline

e recomeça o fetch de 0xA14FC326

0  Not Taken

1  Taken


Demasiado simplista

Ao voltar a entrar, a previsão é NOT Taken,

mas a “nova” primeira iteração vai quase se

certeza ser Taken!!!

Ao executar repetidamente

a previsão fica Taken

Na última iteração, a previsão é

errada (inevitável)

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

{

...

}

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


2 bit predictor

2-bit Predictor

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


Buffer de 4k vs buffer infinito

Buffer de 4K vs. Buffer Infinito

O factor limitante não é o

tamanho do buffer, é a

qualidade das previsões!


Correlating branch predictors

Correlating Branch Predictors

if (x == 10)

{

specialCase = true;

}

(...)

if (specialCase)

{

(...)

}

Estes saltos estão

correlacionados!

Nenhum esquema “simples”

como o anterior consegue

capturar o comportamento

deste tipo de código!


Correlating branch predictors1

Correlating Branch Predictors

NT/NT

NT/T

T/NT

T/T


Performance global

Performance Global

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


Branch target buffer

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!


Branch target buffer btb

Branch-Target Buffer (BTB)


Uso do branch target buffer

Uso do Branch Target Buffer


Return branch predictors

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


Material para ler1

Material para ler

Computer Architecture: A Quantitative Approach

  • Secções 3.4 e 3.5

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


3 pipelining avan ado 3 3 processadores multi issue

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


Pipelining avan ado1

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]


Nomenclatura

Nomenclatura

Memória

FSB = Front-Side Bus

Processador

IF / ID / Issue

Front-end

Back-end

FU1

FU2

FU3

FU4

FU5

FU6

Execute / Commit


Super escalares vs vliw

Super-escalares vs. VLIW

Instrução 1

INT1

INT2

FP1

FP2

Instrução 2

INT1

INT2

FP1

FP2

Instrução 3

INT1

INT2

FP1

FP2

Instrução ...

INT1

INT2

FP1

FP2

Instrução N

INT1

INT2

FP1

FP2

Processor Frontend

Processor Frontend

Integer Unit 1

Integer Unit 2

FP Unit 1

FP Unit 2

Integer Unit 1

Integer Unit 2

FP Unit 1

FP Unit 2


Super escalares vs vliw t picos

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)


Aspecto de um pipeline mips super escalar est tico

Aspecto de um pipeline MIPS super-escalar estático

INT Op

IF

ID

EXE

MEM

WB

FP Op

IF

ID

EXE

MEM

WB

INT Op

IF

ID

EXE

MEM

WB

FP Op

IF

ID

EXE

MEM

WB

IF

ID

EXE

MEM

WB

INT Op

FP Op

IF

ID

EXE

MEM

WB

IF

ID

EXE

MEM

WB

INT Op

FP Op

IF

ID

EXE

MEM

WB

IF

ID

EXE

MEM

WB

INT Op

IF

ID

EXE

MEM

WB

FP Op


Pipeline super escalar c escalonamento din mico

Re-order buffer (ROB)

Pipeline Super-escalar c/ Escalonamento Dinâmico


Quest o

Questão

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


E o que acontece nos saltos

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


Hardware de tomasulo com o rob

No algoritmo de Tomasulo,

assim que uma instrução

escrevia um resultado, todas

as outras viam-no no register

file. Com o ROB, os registos

só são actualizados quando

uma instrução já não é

especulativa!

Hardware de Tomasulo com o ROB


Material para ler2

Material para ler

Computer Architecture: A Quantitative Approach

  • Secções 3.6 e 3.7

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


  • Login