Pipelining Ana Cristina Alves de Oliveira ufcg. edu

Apresentação em tema: "Pipelining Ana Cristina Alves de Oliveira ufcg. edu"— Transcrição da apresentação:

1 Pipelining Ana Cristina Alves de Oliveira cristina@dsc. ufcg. edu
Pipelining Ana Cristina Alves de Oliveira Arquitetura de Computadores Mestrado em Ciências da Computação Depto. de Sistemas e Computação – UFCG

2 Roteiro Introdução Visão Geral sobre Pipelining Pipeline Superescalar
Pipeline Dinâmico Exemplos Resumo Conclusões Referências Well, let’s begin with the fundamental motivation of my work… the duality of the synchronous and the asynchronous systems. What is an asynchronous distributed system? It’s a system where the nodes are interconnected through a reliable network. That is to say, that messages exchanged between correct processes are eventually delivered. However, no assumptions are on the communication delays or on the processing speeds. Almost every asynchronous system can be classified as asynchronous. But this is not very useful. That’s because most of the distributed problems are not solved in this model.

3 Introdução Pipeline é uma técnica que explora o paralelismo entre as instruções, considerando um fluxo de execução sequencial É invisível ao programador O pipeline começa uma instrução a cada ciclo de clock Não reduz o tempo gasto para completar uma instrução Aumenta a vazão das instruções iniciadas e terminadas na unidade de tempo Estamos considerando o processador deste trabalho como sendo o MIPS On the other hand, we have the synchronous systems. In synchronous systems there are bounded delays for messages exchanged between processes. In addition, the delay processing delays are also bound. Well, in the synchronous systems, a large number of fundamental problems have known solutions. However, synchronous systems are not very practical. Since, in order to guarantee those bound, the system load must be carefully controlled.

4 Tempo entre Instruções (Ti)
Tipipeline = Tinão-pipeline / nº de estágios Classe Busca Leit. Reg Op. ULA Aces. Dado Escr. Reg Tempo Total Load word (lw) 2 ns 1 ns 8 ns Store word (sw) 7 ns Add, sub, and, or, slt 6 ns beq 5 ns So, we follow the second school! We also assume that systems are equipped with synchronous subsystems. Physically, our model is this one. Nodes are connected through a switched Ethernet network. Logically, the systems are composed of an asychronous where the user applications run. And of a synchronous part, where just very special tasks run.

5 Conflitos do Pipeline: Estruturais e de Controle
Conflitos estruturais O hardware não pode suportar a combinação de instruções no mesmo ciclo de clock Exemplo: Suponha que exista apenas uma memória para dados e instruções. Ocorrerá este conflito se uma instrução acessar um dado na memória (lw), enquanto outra tenta escrever na memória (sw) simultaneamente Conflitos de controle Necessidade de tomar uma decisão com base nos resultados de uma instrução, enquanto outras estão sendo executadas So... what does a synchronous subsystem have? Basically, the synchronous subsystem should be able to timely execute tasks and to allow that these tasks communicate with bounded latencies. In our implementation, the communication with bounded delays is provided by the FastNet message exchange service. The timely execution is provided by the Periodic Task Executor. The term periodic here is due to the fact that besides requiring timely execution, our tasks are periodic.

6 Conflitos do Pipeline: Soluções para o Conflito de Controle (1)
Parada do Pipeline: conhecida como “bolha” Execução sequencial com a inserção de uma instrução de nop após um desvio condicional Degrada o desempenho consideravelmente Predição Em geral, é adotada para tratar os desvios condicionais executados em pipeline Não retarda o pipeline se a previsão for correta Esquema simples: sempre predizer que a condição vai falhar Preditores dinâmicos em hardware fazem predições dependendo do comportamento anterior de cada desvio

7 Conflitos do Pipeline: Soluções para o Conflito de Controle (2)
Decisão retardada: conhecida como “desvio retardado” (delayed branch) Sempre executa a instrução seguinte à instrução de desvio, cuidando para que a escolha seja uma instrução não afetada pela decisão do desvio Tipicamente, os compiladores preenchem cerca de 50% dos slots que seguem o desvio condicional com instruções úteis Utilizada no processador MIPS

8 Conflitos do Pipeline: Conflitos por Dados
A execução de uma instrução depende do resultado de outra, que ainda está no pipeline Não é preciso esperar o término da instrução para tentar resolver este conflito Solução Adiantamento ou bypass: obtenção antecipada de determinado item faltante a uma operação, a partir de recursos internos da máquina

9 Conflitos do Pipeline: Reordenação do Código para Evitar Paradas
Encontre o conflito deste código: # reg $t1 possui o end. de v[k] lw $t0, 0($t1) # reg $t0 (temp) = v[k] lw $t2, 4($t1) # reg $t2 = v[k+1] sw $t2, 0($t1) # v[k] = reg $t2 sw $t0, 4($t1) # v[k+1] = reg $t0 (temp) Reordene as instruções de modo a evitar parada do pipeline em função do conflito To develop the message exchange service, our first step was make some assumptions: no messages are lost, no switch or cabling faults occur and only FastNet messages are prioritized. The third assumption is the weakest one since we can enforce it. The second assumption, we believe is realistic. We will alleviate the third assumption later.

10 Conflitos do Pipeline: Reordenação do Código para Evitar Paradas
Código reordenado deste código: # reg $t1 possui o end. de v[k] lw $t0, 0($t1) # reg $t0 (temp) = v[k] lw $t2, 4($t1) # reg $t2 = v[k+1] sw $t0, 4($t1) # v[k+1] = reg $t0 (temp) sw $t2, 0($t1) # v[k] = reg $t2 A troca de lugar das 2 instruções de store elimina a possibilidade do conflito To develop the message exchange service, our first step was make some assumptions: no messages are lost, no switch or cabling faults occur and only FastNet messages are prioritized. The third assumption is the weakest one since we can enforce it. The second assumption, we believe is realistic. We will alleviate the third assumption later.

11 Código em C para a Função
swap(int v[], int k) { int temp; temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; } Here is how we estimated the communication latency. Ttransmission is the time a message takes to be transmitted by the network interface. Tnetwork is the time a message spends traveling in the network. Treception is the time a message takes to be received by the network interface and then, processed by the interrupt handler. Further, we divided the network time into wire time, processing time in the switch and time waiting in an output port of the queue. Treception was divided into the time the network interface takes to receive the message and issue an interrupt and the time until the interrupt is processed and the message is delivered. Well, lets get rid of the simple terms first. Twire, the time a message spends traveling in the wires in a LAN is negligible. Typical values for the switch processing time are below 10 us. We did some experiments to measure the interrupt handling latency and obtained a value of 81 us.

12 Pipeline Superescalar
Replicação dos componentes internos do processador para que ele possa colocar várias instruções em cada estágio do pipeline Permite que a taxa de instruções prontas na unidade de tempo exceda à taxa do clock Exemplo: um processador de 1000Mhz, superescalar, com 4 instruções simultâneas pode operar em uma taxa de pico de 4 bilhões de instruções por segundo Desvantagem: trabalho extra de manutenção Now we have the following expression. Tqueue is the time a message can wait in the output queue of the switch. In the worst case a message could arrive in the queue when the transmission of a low priority message had just begun. The time for transmitting a full-size low priority message is 122 us. Also, the high priority queue could have a high priority message from each of the other nodes. Finally, the two last terms were estimated through an experiment. First, an experiment to measure the latency was executed. Then, we got the smaller latency and assumed that in this case, the latency was exclusively due to t_nic_send, t_processing and t_nic_receive. We discounted t_proc and the remaining was an estimate for the value of t_nic_send and t_nic_receive.

13 Pipeline Dinâmico Ou Escalonamento Dinâmico do Pipeline
Executado pelo hardware para evitar conflitos no pipeline É normalmente associado a recursos extras de hardware As instruções posteriores podem prosseguir em paralelo O modelo de execução de instruções é bem mais complexo Now we have the following expression. Tqueue is the time a message can wait in the output queue of the switch. In the worst case a message could arrive in the queue when the transmission of a low priority message had just begun. The time for transmitting a full-size low priority message is 122 us. Also, the high priority queue could have a high priority message from each of the other nodes. Finally, the two last terms were estimated through an experiment. First, an experiment to measure the latency was executed. Then, we got the smaller latency and assumed that in this case, the latency was exclusively due to t_nic_send, t_processing and t_nic_receive. We discounted t_proc and the remaining was an estimate for the value of t_nic_send and t_nic_receive.

14 Exemplo 1: Implementação Simples de Pipeline
Especificações : É como o MIPS, exceto por: Não modifica a ordem de execução (sem desvio retardado e sem reescalonamento por software) Registradores não podem ser lidos e escritos em um mesmo ciclo de clock Após um desvio, não se pode fazer uma busca por nova instrução até que a comparação seja feita Sem adiantamento Complete os estágios do pipeline a seguir ==> MR WB IF ID

15 Exemplo 2: Implementação de pipeline para MIPS
10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15 Estes endereços estão em octal Desvio atrasado é tarefa do compilador: ‘ori’ será uma tarefa fora da ordem

16 Início: Busca10 n n n n Inst. Mem Decode WB Ctrl Mem Ctrl PC Next PC
= IR im rs rt Reg. File Reg File A M S Exec B Mem Access D Data Mem IF 10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15

17 Busca 14, Decodifica 10 n n n Inst. Mem Decode WB Ctrl Mem Ctrl PC
lw r1, r2(35) Decode WB Ctrl Mem Ctrl PC Next PC 14 = IR im 2 rt Reg. File Reg File A M S Exec B Mem Access D Data Mem ID 10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15 IF

18 Busca 20, Decodifica 14, Exec 10 n n Inst. Mem Decode WB Ctrl Mem Ctrl
addI r2, r2, 3 Decode WB Ctrl lw r1 Mem Ctrl PC Next PC 20 = IR 2 rt 35 Reg. File Reg File M r2 S Exec B Mem Access D Data Mem EX 10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15 ID IF

19 Busca 24, Decod. 20, Exec 14, Mem 10 n Inst. Mem Decode WB Ctrl Mem
sub r3, r4, r5 Decode addI r2, r2, 3 WB Ctrl lw r1 Mem Ctrl PC Next PC 24 = IR 4 5 3 Reg. File Reg File M r2 r2+35 Exec B Mem Access D Data Mem M 10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15 EX ID IF

20 Busca 30, Dcd 24, Ex 20, Mem 14, WB 10 Inst. Mem Decode WB Mem Ctrl
addI r2 WB Ctrl lw r1 Mem Ctrl PC Next PC = IR Reg. File Reg File M[r2+35] r2+3 Exec Mem Access D Data Mem ID IF EX M WB 10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15

21 Busca 30, Dcd 24, Ex 20, Mem 14, WB 10 Inst. Mem Decode WB Ctrl Mem
beq r6, r7 100 Inst. Mem Decode addI r2 WB Ctrl sub r3 lw r1 Mem Ctrl PC Next PC 30 = sub IR 6 7 Reg. File Reg File r4 M[r2+35] r2+3 Exec r5 Mem Access D Data Mem ID IF EX M WB 10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15 Note que o desvio retardado: sempre executa ori após beq

22 Busca 34, Dcd 30, Ex 24, Mem 20, WB 14 Inst. Mem Decode WB Mem Ctrl x
PC Next PC 34 = x x x x IR x x x Reg. File r1=M[r2+35] Reg File x Exec x x x Mem Access D Data Mem 10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15 WB M EX ID Take the branch – r6-r7 = 0 IF

23 Busca 34, Dcd 30, Ex 24, Mem 20, WB 14 Inst. Mem Decode WB Ctrl Mem
ori r8, r9 17 Decode addI r2 WB Ctrl sub r3 beq Mem Ctrl PC Next PC 34 =0 IR 9 xx 100 Reg. File r1=M[r2+35] Reg File r6 r2+3 r4-r5 Exec r7 Mem Access D Data Mem 10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15 WB M EX ID Take the branch – r6-r7 = 0 IF

24 Busca 100, Dcd 34, Ex 30, Mem 24, WB 20 Inst. Mem Decode WB Ctrl Mem
ori r8 sub r3 WB Ctrl add r10, r11, r12 beq Mem Ctrl or 11 12 17 Reg. File IR r1=M[r2+35] Reg File r9 r4-r5 xxx Exec r2 = r2+3 x Mem Access D Data Mem 10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15 Next PC 100 PC Problema?

25 Busca 100, Dcd 34, Ex 30, Mem 24, WB 20 Inst. Mem Decode WB Ctrl Mem
ori r8 sub r3 WB Ctrl add r10, r11, r12 beq Mem Ctrl or 11 12 17 Reg. File IR r1=M[r2+35] Reg File r9 r4-r5 xxx Exec r2 = r2+3 x Mem Access D Data Mem 10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15 Next PC 100 PC Apenas 1 instrução deveria estar atrasada

26 Busca 104, Dcd 100, Ex 34, Mem 30, WB 24 Destrói a instrução extra n
Inst. Mem Decode add r10 ori r8 beq WB Ctrl and r13, r14, r15 Mem Ctrl add 14 15 xx Reg. File IR r1=M[r2+35] Reg File r11 r9 | 17 xxx Exec r2 = r2+3 r3 = r4-r5 r12 Mem Access D Data Mem 10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15 Next PC 104 PC Destrói a instrução extra

27 Busca 108, Dcd 104, Ex 100, Mem 34, WB 30 n Inst. Mem Decode WB Mem
add r10 ori r8 and r13 WB Ctrl Mem Ctrl xx Reg. File IR r1=M[r2+35] Reg File r14 r9 | 17 r11+r12 Exec r2 = r2+3 r3 = r4-r5 r15 Mem Access D Data Mem 10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15 Next PC 108 PC

28 Busca 112, Dcd 108, Ex 104, Mem 100, WB 34 Destrói a instrução extra n
NO WB NO Ovflow and r13 Inst. Mem Decode add r10 WB Ctrl Mem Ctrl Reg. File IR r1=M[r2+35] Reg File r11+r12 r14 & R15 Exec r2 = r2+3 r3 = r4-r5 r8 = r9 | 17 Mem Access D Data Mem 10 lw r1, r2(35) 14 addI r2, r2, 3 20 sub r3, r4, r5 24 beq r6, r7, 100 30 ori r8, r9, 17 34 add r10, r11, r12 100 and r13, r14, 15 Next PC 114 PC Destrói a instrução extra

29 Resumo O que o torna fácil o pipeline?
Todas as instruções têm o mesmo tamanho Poucos formatos para a instrução Operandos da memória aparecem apenas em loads e stores Conflitos estruturais: caso exista apenas 1 memória para instruções e dados Conflitos de controle: preocupação com instruções de desvio Conflitos de dados: instruções que depedem de instruções anteriores

30 Resumo 5 Estágios: Busca: busca instruções na memória Decodificação: pega o valor do registrador e decodifica as informações de controle Execução: executa operações aritméticas/cálculo de endereços Memória: faz operações da mémoria (load e store) Escreve no registrador: escreve resultados de volta nos registradores Pipelines passam o controle da informação pelo pipe assim como os dados se movem no pipe Balancear o tamanho das instruções torna o pipeline mais suave Aumentar o tamanho do pipeline, aumenta o impacto de conflitos

31 Conclusões O pipeline melhora o throughput, mas não altera o tempo de execução de uma instrução A latência introduz dificuldades devido às dependências nos programas Redução do custo das dependências com: Hardware para adiantamento de dados Predição de desvios Processamento superescalar e escalonamento dinâmico tem melhorado cerca de 60% ao ano o desempenho dos processadores desde 1986 Com os avanços na tecnologia de processamento, o sistema de memória é que passa a ser o gargalo (lei de Amdahl)

32 Referências Patterson, D. A.; Hennessy, J. L. Organização e projeto de computadores: A interface HARDWARE/SOFTWARE. Rio de Janeiro, LTC, 2ª ed., 2000. Programmed Introdution to MIPS Assembly Language. SPIM - A MIPS32 Simulator. Aplicações Avançadas de Microprocessadores: Colectânea de Problemas.

33 Contato Ana Cristina A. de Oliveira Projeto Failure Spotter
Projeto Failure Spotter