1 / 55

Pipeline

Pipeline. Lavanderia – analogia com o pipelining. Pipeline de instruções no MIPS. Fetch da instrução Leitura dos registradores e decodificação Execução da operação ou cálculo de endereço Acesso ao operando na memória Escrita do resultado em um registrador. Exemplo.

giselle-dodson
Download Presentation

Pipeline

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Pipeline

  2. Lavanderia – analogia com o pipelining

  3. Pipeline de instruções no MIPS • Fetch da instrução • Leitura dos registradores e decodificação • Execução da operação ou cálculo de endereço • Acesso ao operando na memória • Escrita do resultado em um registrador

  4. Exemplo • Compare o tempo médio entre instruções da implementação em single-cycle (uma instrução por ciclo) com uma implementação com pipeline. Supor maior tempo de operação para acesso à memória = 2ns, operação da ULA = 2ns e acesso ao register file = 1ns. (Instrs lw, sw, add, sub, and, or slt e beq). • Inicialmente suponha a execução de 3 instruções lw (tempo entre o início da 1ª instrução e o início da 4ª instrução)

  5. Tempo total para as oito instruções calculado a partir do tempo de cada componente

  6. P r o g r a m 2 4 6 8 1 0 1 2 1 4 1 6 1 8 e x e c u t i o n T i m e o r d e r ( i n i n s t r u c t i o n s ) I n s t r u c t i o n D a t a l w $ 1 , 1 0 0 ( $ 0 ) R e g A L U R e g f e t c h a c c e s s I n s t r u c t i o n D a t a l w $ 2 , 2 0 0 ( $ 0 ) R e g A L U R e g 8 n s f e t c h a c c e s s I n s t r u c t i o n l w $ 3 , 3 0 0 ( $ 0 ) 8 n s f e t c h . . . 8 n s P r o g r a m 1 4 2 4 6 8 1 0 1 2 e x e c u t i o n T i m e o r d e r ( i n i n s t r u c t i o n s ) I n s t r u c t i o n D a t a l w $ 1 , 1 0 0 ( $ 0 ) R e g A L U R e g f e t c h a c c e s s I n s t r u c t i o n D a t a l w $ 2 , 2 0 0 ( $ 0 ) 2 n s R e g A L U R e g f e t c h a c c e s s I n s t r u c t i o n D a t a l w $ 3 , 3 0 0 ( $ 0 ) 2 n s R e g A L U R e g f e t c h a c c e s s 2 n s 2 n s 2 n s 2 n s 2 n s Execução não-pipeline X pipeline

  7. OBS.: • Sob condições ideais, com estágios balanceados, o speedup do pipeline é igual ao número de estágios do pipeline ( 5 estágios , 5 vezes mais rápido) • Na realidade o tempo de execução de uma instrução é um pouco superior (overheads)  speedup é menor que o número de estágios do pipeline Suponha a execução de 1003 instruções com pipeline  1000 X 2ns + 14 = 2014 (para cada instrução adiciono 2ns) sem pipeline  1000 X 8ns + 24 = 8024 spedup = 8024 / 2014 = 3.98 ~~ 8 / 2

  8. Projeto de um conjunto de instruções para pipeline • O que torna a implementação mais fácil • Instruções de mesmo tamanho • Poucos formatos, com campos de registradores sempre dispostos no mesmo lugar (Simetria, no 2º estágio podemos ler registradores e decodificar ao mesmo tempo). • Acesso à memória apenas com as instruções lw e sw. • Operandos alinhados na memória: o dado pode ser transferido da memória para a CPU e CPU para a memória em um único estágio do pipeline.

  9. Projeto de um conjunto de instruções para pipeline • O que torna a implementação mais dificil • Hazard • Hazard Estrural • Hazard de Controle • Hazard de Dados

  10. Pipeline Hazards • Hazard Estrutural • O hardware não suporta uma combinação de instruções que queremos executar em um único período de clock • Ex.: escrever e ler da memória em um mesmo ciclo

  11. Pipeline Hazards • Hazard de Controle • Problemas devido à execução de instruções de desvio • Ex.: Quando um branch é tomado, como tratar a(s) instruções que seguem (fisicamente) o branch no programa e que já estão no pipeline

  12. P r o g r a m e x e c u t i o n 1 4 1 6 2 4 6 8 1 0 1 2 T i m e o r d e r ( i n i n s t r u c t i o n s ) I n s t r u c t i o n D a t a R e g A L U R e g a d d $ 4 , $ 5 , $ 6 f e t c h a c c e s s I n s t r u c t i o n D a t a b e q $ 1 , $ 2 , 4 0 R e g A L U R e g f e t c h a c c e s s 2 n s I n s t r u c t i o n D a t a l w $ 3 , 3 0 0 ( $ 0 ) R e g A L U R e g f e t c h a c c e s s 4 n s 2 n s Pipelining stalling para instruções branch

  13. P r o g r a m 2 4 6 8 1 0 1 2 1 4 e x e c u t i o n T i m e o r d e r ( i n i n s t r u c t i o n s ) I n s t r u c t i o n D a t a a d d $ 4 , $ 5 , $ 6 R e g A L U R e g f e t c h a c c e s s I n s t r u c t i o n D a t a b e q $ 1 , $ 2 , 4 0 R e g A L U R e g f e t c h a c c e s s 2 n s I n s t r u c t i o n D a t a l w $ 3 , 3 0 0 ( $ 0 ) R e g A L U R e g f e t c h a c c e s s 2 n s P r o g r a m 1 4 2 4 6 8 1 0 1 2 e x e c u t i o n T i m e o r d e r ( i n i n s t r u c t i o n s ) I n s t r u c t i o n D a t a a d d $ 4 , $ 5 , $ 6 R e g A L U R e g f e t c h a c c e s s I n s t r u c t i o n D a t a b e q $ 1 , $ 2 , 4 0 R e g A L U R e g f e t c h a c c e s s 2 n s b u b b l e b u b b l e b u b b l e b u b b l e b u b b l e I n s t r u c t i o n D a t a R e g A L U R e g o r $ 7 , $ 8 , $ 9 f e t c h a c c e s s 4 n s Branch prediction: Tentar “adivinhar” qual dos caminhos do branch será tomado O branch não será tomado

  14. P r o g r a m e x e c u t i o n 1 4 2 4 6 8 1 0 1 2 o r d e r T i m e ( i n i n s t r u c t i o n s ) I n s t r u c t i o n D a t a b e q $ 1 , $ 2 , 4 0 R e g A L U R e g f e t c h a c c e s s I n s t r u c t i o n D a t a a d d $ 4 , $ 5 , $ 6 R e g A L U R e g f e t c h a c c e s s 2 n s ( D e l a y e d b r a n c h s l o t ) I n s t r u c t i o n D a t a l w $ 3 , 3 0 0 ( $ 0 ) R e g A L U R e g f e t c h a c c e s s 2 n s 2 n s Pipeline delayed branch

  15. Hazard de Dados • Quando uma instrução necessita de um dado que ainda não foi calculado • Ex.: add $s0,$t0,$t1 sub $t2,$s0,$t3 • Soluções : • Compilador (programador) gera código livre de • data hazard (introduzindo, por ex., instruções nop • no código; alterando a ordem das instruções; ...) • Stall; Forwarding ou bypassing

  16. P r o g r a m e x e c u t i o n 2 4 6 8 1 0 o r d e r T i m e ( i n i n s t r u c t i o n s ) a d d $ s 0 , $ t 0 , $ t 1 I F I D E X M E M W B s u b $ t 2 , $ s 0 , $ t 3 M E M I F I D E X M E M W B Hazard de Dados

  17. 2 4 6 8 1 0 1 2 1 4 T i m e P r o g r a m e x e c u t i o n o r d e r ( i n i n s t r u c t i o n s ) I F I D l w $ s 0 , 2 0 ( $ t 1 ) E X M E M W B b u b b l e b u b b l e b u b b l e b u b b l e b u b b l e s u b $ t 2 , $ s 0 , $ t 3 I F I D W B E X M E M Hazard de Dados Stall

  18. Exemplo • Encontre o hazard no código abaixo e resolva-o: # $t1 tem o end. de v[k] lw $t0, 0($t1) # $t0 = v[k] lw $t2,4($t1) # $t2 = v[k+1] sw $t2, 0($t1) # v[k] = $t2 sw $t0, 4($t1) # v[k+1] = $t0 • Solução: • # $t1 tem o end. de v[k] • lw $t0, 0($t1) # $t0 = v[k] • lw $t2,4($t1) # $t2 = v[k+1] • sw $t0, 4($t1) # v[k+1] = $t0 • sw $t2, 0($t1) # v[k] = $t2

  19. I F : I n s t r u c t i o n f e t c h I D : I n s t r u c t i o n d e c o d e / E X : E x e c u t e / M E M : M e m o r y a c c e s s W B : W r i t e b a c k r e g i s t e r f i l e r e a d a d d r e s s c a l c u l a t i o n 0 M u x 1 A d d A d d 4 A d d r e s u l t S h i f t l e f t 2 R e a d r e g i s t e r 1 A d d r e s s P C R e a d d a t a 1 R e a d Z e r o r e g i s t e r 2 I n s t r u c t i o n R e g i s t e r s A L U R e a d A L U 0 R e a d W r i t e d a t a 2 r e s u l t A d d r e s s 1 d a t a r e g i s t e r M I n s t r u c t i o n M u D a t a u m e m o r y W r i t e x m e m o r y x d a t a 1 0 W r i t e d a t a 1 6 3 2 S i g n e x t e n d Pipeline: Idéia Básica • 5 estágios: Fetch; Decodificação e leitura dos regs; execução ou cálculo de end. ; acesso à memória; escrita no reg. destino O que é necessário para tornar cada divisão em estágios?

  20. Instruções sendo executadas pelo datapath

  21. 0 M u x 1 I F / I D E X / M E M M E M / W B I D / E X A d d A d d 4 A d d r e s u l t S h i f t l e f t 2 R e a d n o r e g i s t e r 1 i A d d r e s s P C t R e a d c u d a t a 1 r t R e a d s Z e r o n r e g i s t e r 2 I I n s t r u c t i o n R e g i s t e r s A L U R e a d A L U m e m o r y 0 R e a d W r i t e A d d r e s s d a t a 2 1 r e s u l t d a t a r e g i s t e r M M u D a t a u W r i t e x m e m o r y x d a t a 1 0 W r i t e d a t a 3 2 1 6 S i g n e x t e n d Pipelined Datapath Pode acontecer algum problema nesta solução se não existir dependência de dados? A execução de qual instrução causa o problema?

  22. Pipelined Datapath

  23. Pipelined Datapath

  24. l w 0 E x e c u t i o n M u x 1 I F / I D I D / E X E X / M E M M E M / W B A d d A d d 4 A d d r e s u l t S h i f t l e f t 2 R e a d n o r e g i s t e r 1 i A d d r e s s P C t R e a d c u d a t a 1 r t R e a d s Z e r o n r e g i s t e r 2 I I n s t r u c t i o n R e g i s t e r s A L U R e a d A L U m e m o r y 0 R e a d W r i t e A d d r e s s d a t a 2 r e s u l t 1 d a t a r e g i s t e r M M u D a t a u W r i t e x m e m o r y x d a t a 1 0 W r i t e d a t a 1 6 3 2 S i g n e x t e n d Pipelined Datapath

  25. Pipelined Datapath

  26. Pipelined Datapath

  27. s w 0 E x e c u t i o n M u x 1 I F / I D I D / E X E X / M E M M E M / W B A d d A d d 4 A d d r e s u l t S h i f t l e f t 2 R e a d n o r e g i s t e r 1 i A d d r e s s P C t R e a d c u d a t a 1 r R e a d t s Z e r o n r e g i s t e r 2 I I n s t r u c t i o n R e g i s t e r s A L U R e a d A L U m e m o r y 0 R e a d W r i t e A d d r e s s d a t a 2 r e s u l t 1 d a t a r e g i s t e r M M D a t a u u m e m o r y W r i t e x x d a t a 1 0 W r i t e d a t a 1 6 3 2 S i g n e x t e n d Pipelined Datapath

  28. Pipelined Datapath

  29. Pipelined Datapath

  30. Datapath Correto Problema na execução da instrução load. Qual é o erro?

  31. 0 M u x 1 I F / I D I D / E X E X / M E M M E M / W B A d d A d d 4 A d d r e s u l t S h i f t l e f t 2 n R e a d o i r e g i s t e r 1 t A d d r e s s P C c R e a d u r d a t a 1 t R e a d s n Z e r o r e g i s t e r 2 I I n s t r u c t i o n R e g i s t e r s A L U R e a d A L U m e m o r y 0 R e a d W r i t e A d d r e s s d a t a 2 r e s u l t 1 d a t a r e g i s t e r M M u D a t a u W r i t e x m e m o r y x d a t a 1 0 W r i t e d a t a 1 6 3 2 S i g n e x t e n d Datapath com os estágios usados para um instrução lw

  32. T i m e ( i n c l o c k c y c l e s ) P r o g r a m C C 1 C C 2 C C 3 C C 4 C C 5 C C 6 e x e c u t i o n o r d e r ( i n i n s t r u c t i o n s ) l w $ 1 0 , 2 0 ( $ 1 ) I M R e g A L U D M R e g s u b $ 1 1 , $ 2 , $ 3 I M R e g D M R e g A L U Representações Gráfica do Pipeline Ajuda a responder perguntas como: Quantos ciclos são gasto para executar este código? O que a ALU está fazendo durante o ciclo 10? Ajuda a entender os datapaths

  33. T i m e ( i n c l o c k c y c l e s ) P r o g r a m e x e c u t i o n o r d e r C C 1 C C 2 C C 3 C C 4 C C 5 C C 6 ( i n i n s t r u c t i o n s ) D a t a I n s t r u c t i o n I n s t r u c t i o n E x e c u t i o n l w $ 1 0 , $ 2 0 ( $ 1 ) W r i t e b a c k a c c e s s f e t c h d e c o d e D a t a I n s t r u c t i o n I n s t r u c t i o n E x e c u t i o n W r i t e b a c k s u b $ 1 1 , $ 2 , $ 3 a c c e s s f e t c h d e c o d e Representações Gráfica do Pipeline

  34. P C S r c 0 M u x 1 I F / I D I D / E X E X / M E M M E M / W B A d d A d d A d d 4 r e s u l t B r a n c h S h i f t R e g W r i t e l e f t 2 R e a d n M e m W r i t e o i r e g i s t e r 1 t P C A d d r e s s R e a d c u d a t a 1 r t R e a d A L U S r c s M e m t o R e g n Z e r o Z e r o r e g i s t e r 2 I I n s t r u c t i o n R e g i s t e r s A L U A L U R e a d m e m o r y 0 R e a d W r i t e d a t a 2 A d d r e s s r e s u l t 1 r e g i s t e r M d a t a M u D a t a u W r i t e x m e m o r y x d a t a 1 0 W r i t e d a t a I n s t r u c t i o n 6 1 6 [ 1 5 – 0 ] 3 2 S i g n A L U e x t e n d M e m R e a d c o n t r o l I n s t r u c t i o n [ 2 0 – 1 6 ] 0 M A L U O p I n s t r u c t i o n u [ 1 5 – 1 1 ] x 1 R e g D s t Controle do Pipeline

  35. Controle do Pipeline • 5 estágios. O que deve ser controlado em cada estágio? • 10: Fetch da instrução e incremento do PC • 20: Decodificação da instrução e Fetch dos registradores • 30: Execução • 40: Acesso à memória • 50: Write back

  36. Sinais de controle

  37. Sinais de controle

  38. Sinais de controle

  39. P C S r c I D / E X 0 M W B u E X / M E M x 1 C o n t r o l M W B M E M / W B E X M W B I F / I D A d d A d d 4 A d d e r e s u l t t i r B r a n c h W S h i f t g e e l e f t 2 t i R r W A L U S r c m g n R e a d e e o M i R t r e g i s t e r 1 A d d r e s s P C c o R e a d t u r m d a t a 1 t s R e a d e n Z e r o M I r e g i s t e r 2 I n s t r u c t i o n R e g i s t e r s A L U R e a d A L U m e m o r y 0 R e a d W r i t e d a t a 2 A d d r e s s r e s u l t 1 d a t a r e g i s t e r M M D a t a u u m e m o r y W r i t e x x d a t a 1 0 W r i t e d a t a I n s t r u c t i o n 1 6 3 2 6 [ 1 5 – 0 ] S i g n A L U M e m R e a d e x t e n d c o n t r o l I n s t r u c t i o n [ 2 0 – 1 6 ] 0 A L U O p M u I n s t r u c t i o n x [ 1 5 – 1 1 ] 1 R e g D s t Datapath com Controle

  40. lw $10, 20 ($1) sub $11, $2, $3 and $12, $4, $5 or $13, $6, $7 add $14, $8, $9 1o ciclo

  41. lw $10, 20 ($1) sub $11, $2, $3 and $12, $4, $5 or $13, $6, $7 add $14, $8, $9 2o ciclo

  42. lw $10, 20 ($1) sub $11, $2, $3 and $12, $4, $5 or $13, $6, $7 add $14, $8, $9 3o ciclo

  43. lw $10, 20 ($1) sub $11, $2, $3 and $12, $4, $5 or $13, $6, $7 add $14, $8, $9 4o ciclo

More Related