Arquitectura de Computadorespaginas.fe.up.pt/~jcf/ensino/disciplinas/mieic/arq/2006...Execução...

Execução concorrente de instruções

João Canas Ferreira

Arquitectura de Computadores

FEUP/LEIC

Contém figuras de “Computer Organization and Design” (cap. 6), D. Patterson & J. Hennessey, 3a. ed., Elsevier

Tópicos

1 Execução sobreposta de instruções

2 Conflitos de dados e controlo

3 Caminho de dados para “pipelining”

ArqComp: Execução concorrente de instruções 2/33 2007-03-23





Uma analogia . . .

Time6 PM 7 8 9 10 11 12 1 2 AM

Task order

A B C D

Time6 PM 7 8 9 10 11 12 1 2 AM

Task order

A B C D


“Pipeline” MIPS

“Pipeline” (oleoduto, linha de montagem) de referência:

+ Cinco etapas correspondem a cinco andares:1. obter instrução (instruction fetch): IF2. descodificar instrução e ler registos instruction decoding: ID3. executar instrução ou calcular endereço: EX4. acesso a memória: MEM5. escrita num registo (write back): WB

Exemplo:

Classe IF Leit. reg. ALU op MEM ace. Escrita reg. Total

lw 200 ps 100 ps 200 ps 200 ps 100 ps 800 pssw 200 ps 100 ps 200 ps 200 ps 700 pstipo R 200 ps 100 ps 200 ps 100 ps 600 psbeq 200 ps 100 ps 200 ps 500 ps


CPU uniciclo vs. CPU com pipeline

Program execution order (in instructions)

lw $1, 100($0) lw $2, 200($0) lw $3, 300($0)

Time200 400 600 800 1000 1200 1400 1600 1800

Instruction fetch Reg ALU Data

access Reg


access Reg

Instruction fetch

800 ps

800 ps

800 ps


lw $1, 100($0) lw $2, 200($0) lw $3, 300($0)

Time200 400 600 800 1000 1200 1400


access Reg

Instruction fetch

Instruction fetch

Reg ALU Data access Reg


200 ps

200 ps

200 ps 200 ps 200 ps 200 ps 200 ps


Desempenho de pipeline

+ Situação ideal: todos os andares têm o mesmo tempo deexecução: pipeline em equilíbrio.

+ Nas condições ideais:

Tempo entre instruçõespipeline =Tempo entre instruçõessem pipeline

No de andares

+ O exemplo anterior tem poucas instruções:

Speedup =2400

1400= 1.71

Com mais um milhão de instruções:

Speedup =106 × 800+ 2400

106 × 200+ 14000=800002400

200001400≈ 4.0

+ A melhoria de desempenho é causada pelo aumento do débito(no de instruções executadas por unidade de tempo) e não pelaredução do tempo de execução das instruções individuais.

+ De facto, nenhuma instrução fica individualmente mais rápida.


O conjunto de instruções

+ As características do conjunto de instruções podem facilitar aconstrução de pipelines.

+ O conjunto de instruções MIPS:1. Instruções têm todas o mesmo tamanho: facilita a

obtenção de instruções (IF) e a sua descodificação (ID).2. Poucos formatos diferentes, com a especificação dos

registos (para leitura) nas mesmas posições: permite obteros operandos ao mesmo tempo que se procede àdescodificação (ID).

3. Acessos a memória apenas em load/store: andar deexecução pode ser usado para efectuar o cálculo doendereço efectivo (EX).

4. Alinhamento de operandos em memória: transferência deum item demora apenas um ciclo (MEM).


Representação gráfica da pipeline de referência

200 400 600 800 1000Time

add $s0, $t0, $t1 IF MEMID WBEX

+ Conceptualmente, existem duas memórias:1. memória de instruções: usada na etapa IF2. memória de dados: usada na etapa MEM

Na prática, existe geralmente apenas uma memória central: a “duplicação”é efectuada pela memória cache.

+ A cinzento: elementos usados no processamento da instrução.+ Para os elementos de memória:

É cinzento do lado esquerdo: leituraÉ cinzento do lado direito: escrita

+ Banco de registos: leitura no fim do ciclo; escrita no início dociclo.






Obstáculos ao funcionamento da “pipeline”

+ Existem situações em que a instrução seguinte não podecomeçar a execução no ciclo seguinte: conflito entreinstruções.(Em inglês: hazard; não é uma tradução literal).

+ Conflitos estruturais:É o suporte físico não permite a execução concorrente(geralmente, por falta de recursos).

+ Conflitos de dados:É os dados necessários não estão disponíveis, porque sãoproduzidos por uma instrução que ainda não terminou.

+ Conflitos de controlo:É a instrução a executar é ainda desconhecida (porque nãose sabe o resultado do salto condicional).

+ Todos os conflitos podem ser “resolvidos” por protelamento:É a instrução cuja execução devia ser iniciada “espera” pelofim da instrução em execução com que está em conflito.


Representação gráfica de “forwarding”

200 400 600 800 1000Time

add $t0, $t1$s0,

sub $t2, $t3$s0,

IF MEMID WBEX

IF MEMID WBEX


+ Alguns conflitos de dados podem ser resolvidos por forwarding:É utilização de um “atalho” (percurso alternativo internoentre os andares)

+ Condição para utilização de forwarding: o resultado requeridodeve estar disponível “algures” no caminho de dados.


Representação gráfica de protelamento

200 400 600 800 1000 1200 1400Time

lw 20($t1)$s0,

sub $t2, $t3$s0,

IF MEMID WBEX

IF MEMID WBEX


bubble bubble bubble bubble bubble

+ Forwarding não resolve o problema, porque é necessário“esperar” pelos dados fornecidos pela memória.

+ Assumiremos que a unidade de controlo é capaz de identificaros conflitos durante a etapa 2 (ID).

+ Se o conflito não for resolúvel por forwarding, a instrução nãopassa para a etapa EX.

+ Todas as instruções subsequentes também são proteladas.+ Nenhuma das instruções anteriores é protelada.


Conflito de controlo: resolução por protelamento

Aplicação de protelamento para “resolver” um conflito de dados.


add $4, $5, $6 beq $1, $2, 40 or $7, $8, $9

Time200 400 600 800 1000 1200 1400


access Reg

Instruction fetch

Instruction fetch



200 ps

400 ps


+ Assume-se que o caminho de dados é alterado de forma a queseja possível determinar o resultado da comparação e calcularo destino do salto ainda na etapa 2!

+ Mesmo nesta condições, uma instrução de salto condicionalrequer um ciclo de protelamento.

+ Em média, surge um salto condicional em cada 7-10 instruções!


Previsão de saltos

+ Para reduzir o impacto dos saltos condicionais (que em muitoscasos reais pode ser superior a 1 ciclo), o CPU pode prever oresultado da comparação (e, em casos mais sofisticados, oendereço do destino).

+ “Previsão” simples: assumir sempre que o salto não é tomado(a condição é falsa).É Caso a previsão venha a mostrar-se errada, é precisoanular a instrução em execução e passar a executar ainstrução correcta.

+ Esquema ligeiramente mais sofisticado pode prever algunssaltos como tomados e outros como não-tomados.

+ Soluções mais sofisticadas devem ser adaptativas (dinâmicas).


Conflito de controlo: previsão


add $4, $5, $6 beq $1, $2, 40 lw $3, 300($0)

Time200 400 600 800 1000 1200 1400


access Reg

Instruction fetch

Instruction fetch



200 ps

200 ps


add $4, $5, $6 beq $1, $2, 40 or $7, $8, $9

Time200 400 600 800 1000 1200 1400


access Reg

Instruction fetch

Instruction fetch



200 ps

400 ps







Caminho de dados uniciclo

WB: Write backMEM: Acesso memóriaIF: Obter instrução ID: descodificação/ leitura de registos

EX: execuçãocálculo endereço

Address Write data

Read data

Data Memory

Read register 1Read register 2

Write register

Write data

Registers

Read data 1

Read data 2

ALUZero

ALU result

ADD

Add result

Shift left 2

Address

Instruction

Instruction memory

Add

4

PC

Sign extend

16 32

0

0

0

1

1

1

Mux

Mux

Mux


Propagação de sinais de controlo

WB

M

EX

WB

M WB

Controlo

IF/ID ID/EX EX/MEM MEM/WB

Instrução


Caminho de dados “pipelined” (1/2)

Add

Address

Instructionmemory

Readregister 1

Instru

ction Read

register 2

W riteregister

W ritedata

Readdata 1

Readdata 2

RegistersAddress

W ritedata

Readdata

Datamemory

Add Addresult

ALU ALUresult

Zero

Shiftleft 2

Signextend

PC

4

ID/EXIF/ID EX/MEM MEM/WB

16 32

Mux

Mux

Mux

Esta versão contém um erro. Qual?


Caminho de dados “pipelined” (2/2)

Add

Address

Instructionmemory

Readregister 1

Instru

ction

Readregister 2

W riteregister

W ritedata

Readdata 1

Readdata 2

RegistersAddress

W ritedata

Readdata

Datamemory

Add Addresult

ALU ALUresult

Zero

Shiftleft 2

Signextend

PC

4


16 32

Mux

Mux

Mux

Esta versão já está correcta.


Pipeline em operação (1/3)

Programexecutionorder(in instructions)

lw $10, 20($1)

sub $11, $2, $3

add $12, $3, $4

lw $13, 24($1)

add $14, $5, $6

Time (in clock cycles)CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 1 CC 2 CC 3

IM DMReg Reg

IM DMReg Reg

IM DMReg Reg

IM DMReg Reg

IM DMReg Reg

ALU

ALU

ALU

ALU

ALU



Programexecutionorder(in instructions)

lw $10, 20($1)

sub $11, $2, $3

add $12, $3, $4

lw $13, 24($1)

add $14, $5, $6

Time (in clock cycles)CC 1 CC 2 CC 3 CC 4 CC 5

Instruction fetch

Instruction decode Execution Data

access Write back

CC 6 CC 1 CC 2 CC 3

Instruction fetch


access Write back

Instruction fetch


access Write back

Instruction fetch


access Write back

Instruction fetch


access Write back

Representação alternativa (e mais convencional).



Add

Address

Instructionmemory

Readregister 1

Readregister 2

W riteregister

W ritedata

Readdata 1

Readdata 2

RegistersAddress

W ritedata

Readdata

Datamemory

Add Addresult

ALU ALUresult

Zero

Shiftleft 2

Signextend

PC

4


Memory

sub $11, $2, $3

Write back

lw$10, 20($1)

Execution

add $12, $3, $4, $11

Instruction decode

lw $13, 24 ($1)

Instruction fetch

add $14, $5, $6

16 32

Instru

ction

Mux

Mux

Mux

“Fotografia” de um CPU em execução.


Exemplo de dependências numa “pipeline”

sub $2 , $1, $3

and $12, $2 , $5

or $13, $6, $2

add $14, $2 , $2

sw $15, 100 ($2)

TempoCC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8 CC 9

IM DMReg Reg

IM DMReg Reg

IM DMReg Reg

IM DMReg Reg

IM DMReg Reg

10 10 10 10 -20 -20 -20 -2010/-20 registo $2:

+ As ligações “para trás” indicam conflitos de dados.


Caminho de dados sem atalhos

Memóriade dados

Registos

Mux

ALU

ID/EX

a. Sem forwarding

EX/MEM MEM/WB


Caminho de dados com atalhos

ALU

b. Com forwarding

Memóriade dados

Registos

Mux

Mux

Mux

Mux

ID/EX EX/MEM MEM/WB

Unidade deForwarding

EX/MEM.RegisterRd

MEM/WB.RegisterRd

RsRt

RtRd

ForwardB

ForwardA


Caminho de dados com “forwarding”

Versão mais detalhada:

M

WB

WB

Memóriade dados

Registos

Memóriade instruções

Mux

Mux

Mux

Mux

ALU

ID/EX

EX/MEM

MEM/WB

Unidade deforwarding

EX/MEM.RegisterRd

MEM/WB.RegisterRd

Rs

Rt

Rt

Rd

PC

Controlo

EX

M

WB

IF/ID.RegisterRsIF/ID.RegisterRtIF/ID.RegisterRt

IF/ID.RegisterRd

Instr

uctio

n

IF/ID


Condições para utilização de “forwarding”

+ Conflito c/ instrução em EX:/*1*/ se (EX/MEM.RegWrite && EX/MEM.RegisterRd != 0 &&

(EX/MEM.RegisterRd == ID/EX.RegisterRs))1o operando da ALU vem do resultado anterior da ALU

/*2*/ se (EX/MEM.RegWrite && EX/MEM.RegisterRd != 0 &&(EX/MEM.RegisterRd == ID/EX.RegisterRt))

2o operando da ALU vem do resultado anterior da ALU

+ Conflito c/ instrução em MEM:/*3*/ se (MEM/WB.RegWrite && MEM/WB.RegisterRd != 0 &&

(EX/MEM.RegisterRd != ID/EX.RegisterRs) &&(MEM/WB.RegisterRd == ID/EX.RegisterRs))

1o operando da ALU vem do registo temporário MEM/WB

/*4*/ se (MEM/WB.RegWrite && MEM/WB.RegisterRd != 0 &&(EX/MEM.RegisterRd != ID/EX.RegisterRt) &&(MEM/WB.RegisterRd == ID/EX.RegisterRt))

2o operando da ALU vem do registo temporário MEM/WB


Conflito de controlo: exemplo

Reg

[40] beq $1, $3, 28

[44] and $12, $2, $5

[48] or $13, $6, $2

[52] add $14, $2, $2

(72) lw $4, 50($7)

Tempo (ciclos de relógio)CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8 CC 9

IM DMReg Reg

IM DMReg Reg

IM DM Reg

IM DMReg Reg

IM DMReg Reg

(Implementação não optimizada, ao contrário de folha 14).


Redução do atraso devido a saltos condicionais

+ Assumir que o salto é não-tomado. Se a previsão estiverincorrecta, anular a instrução (ou instruções) executadas porerro (converter em nop).

+ Efectuar o tratamento da instrução de salto condicional em 2ciclos (andares IF e ID):É Calcular o endereço de destino do salto no andar ID (usarum somador dedicado).

É Fazer o teste de igualdade no andar ID (usando portaslógicas XOR e OR). Problema: conflitos de dados extra.1. atalhos de ALU/MEM e de MEM/WB para forwarding;

2. protelamento (para esperar pelo resultado da ALU).

+ Na ausência de protelamentos, a penalidade para uma previsãoerrada (salto tomado) é de 1 ciclo.


Características da implementação de referência

Resumo:

+ “Pipeline” com cinco andares: IF, ID, EX, MEM, WB.

+ Detecção de conflitos é feita entra a instrução em ID e asinstruções em EX, MEM e WB.

+ Saltos condicionais: destino e resultado da comparaçãodeterminados em ID (implementação optimizada: folha 31, nãoa implementação básica: folha 30).

+ Previsão de saltos: não-tomado. Se a previsão estiver errada, ainstrução que não deve ser executada é anulada (transformadaem nop).

+ Conflitos de dados resolvidos por forwarding, se possível; senãoo CPU protela a execução da instrução em conflito (e dasseguintes).


Elementos de consulta

A explicação detalhada da organização interna tratada nestadisciplina encontra-se no livro recomendado:

+ [Patterson & Hennessy]:É Secções 6.1–6.3

As obras [Delgado & Ribeiro] (7.3.1–7.3.2) e [Arroz, Monteiro &Oliveira] (secção 15.3) também descrevem “pipelines”. Contudo,ambas as abordagens são consideravelmente diferentes (emboracompatíveis) da seguida aqui.


Notas:

33

Arquitectura de Computadorespaginas.fe.up.pt/~jcf/ensino/disciplinas/mieic/arq/2006...Execução...

Documents

Transcript of Arquitectura de Computadorespaginas.fe.up.pt/~jcf/ensino/disciplinas/mieic/arq/2006...Execução...