Técnicas de Paralelização

Transcrição

1 Técnicas de Paralelização 3 Linha de Produção (Pipelining) 5.1

2 Computação em pipeline Divisão do problema num conjunto de tarefas que têm de ser concluídas uma após outra (base da programação sequencial). Cada tarefa é executada por um processo. 5.2

3 Exemplo Somar os elementos de um array: Versão sequencial: for (i = 0; i < n; i++) sum = sum + a[i]; O ciclo pode ser desdobrado em: sum = sum + a[0]; sum = sum + a[1]; sum = sum + a[2]; sum = sum + a[3]; sum = sum + a[4];

4 Pipeline para um ciclo desdobrado: Pseudo -código para processo i Recv da esquerda a Soma Soma = Soma + a[i] Send Soma para a direita 5.4

5 Outro Exemplo Filtro de frequências Programa para remover frequências específicas (f 0, f 1, f 2,f 3, etc.) de um sinal digitalizado f(t). 5.5

6 Utilização do pipeline Assumindo que um problema pode ser dividido numa sequência de tarefas sequenciais, a estratégia de pipeline pode dar resultado em três tipos de problemas: 1. Se mais do que uma instância do problema vai ser executada. 2. Se uma série de itens de dados têm de ser processados, e cada item requer várias operações. 3. Se a informação para iniciar o próximo processo pode ser passada para a frente antes do processo completar todos as operações. 5.6

7 Diagrama espaço-tempo para pipeline Tipo 1 5.7

8 Diagrama espaço tempo alternativo 5.8

9 Diagrama espaço-tempo para pipeline Tipo 2 5.9

10 Diagrama espaço-tempo para pipeline Tipo 3 Processamento em pipeline quando há informação que passa para o próximo antes do anterior terminar. 5.10

11 Se o número de etapas é maior que o número de processadores, um grupo de etapas pode ser atribuído a cada processador. 5.11

12 Exemplos de soluções pipeline 5.13

13 Exemplo 1 Somatório Computação pipeline tipo

14 Código para o processo i: recv(&accumulation, Pi-1); accumulation = accumulation + number; send(&accumulation, Pi+1); Processo P0: send(&number, P1); Último processo, Pn-1: recv(&number, Pn-2); accumulation = accumulation + number; 5.15

15 SPMD program if (process > 0) { recv(&accumulation, Pi-1); accumulation = accumulation + number; } if (process < n-1) send(&accumulation, P i+1); O resultado final está no último processo Em vez da operações de adição, outras operações podem ser feitas. 5.16

16 Processo master e configuração em anel: 5.17

17 Ordenação Versão paralela de ordenação por inserção: 5.18

18 Pipeline para ordenar por inserção Computação pipeline tipo

19 Código para processo Pi: recv(&number, Pi-1); if (number > x) { send(&x, Pi+1); x = number; } else send(&number, Pi+1); Com n números, o processo i aceita n-i números e passa à frente n-i-1 números. 5.20

20 Ordenação por inserção com resultados devolvidos ao master usando comunicação bidirecional 5.21

21 i==rank Cada Ciclo 1 Comparação e 1 Troca Pseudo-código right_procno=n-i-1; recv(&x, P i-1 ); for (j = 0; j < right_procno; j++) { } recv(&number, P i-1 ); if (number > x) { } send (&x, P i+1 ); x = number; else send (&number, P i+1 ); Cada Ciclo 1 Recv 1 Send send (&x, Pi-1); for (j = 0; j < right_procno; j++) { recv(&number, Pi+1); send (&number, Pi-1); } Envio dos dados ordenados para esquerda para o processo mestre

22 Exemplo 3 : Geração de números primos (Crivo de Eratóstenes) Para encontrar os números primos entre 2 e n, gera-se a série de todos os números inteiros até n. O número 2 é o primeiro número primo e todos os múltiplos de 2 são removidos da lista, pois não podem ser primos. Considera-se o próximo número da lista e removem-se os seus múltiplos até chegar a n. Somente se analisam os números até n, porque os números maiores que são múltiplos de algum número menor que n já foram examinados. n 5.23

23 Código sequencial for (i =2; i < n; i++) prime[i] = 1; for (i =2; i < =sqrt_n; i++) if (prime[i] == 1) // inicializar array todos os numeros como primos // 1 o numero i é primo // para cada numero // se for primo for (j = i + i; j < n; j = j + i) // eliminar múltiplos deste primo prime[j] = 0; // eliminação: 0 não é primo

24 Exemplo 3 : Geração de números primos Crivo de Eratóstenes Computação pipeline tipo

25 Pseudo-código A sequência de inteiros é gerada e alimenta a primeira etapa do pipeline. Esta etapa elimina todos os múltiplos de 2 e passa os números restantes para a segunda etapa, Para cada processador P i : recv(&x, P i-1 ); // repetir para cada número recv(&number, P i-1 ); if ((number %x)!= 0 ) send (&number, P i+1 );

26 Pseudo-código Como a quantidade de números não é a mesma para cada processador, utiliza-se uma mensagem de finalização: recv(&x, P i-1 ); for (j= 0; j < n; j++) { recv(&number, P i-1 ); if (number == terminator) break; if (number % x )!= 0) send (&number, P i+1 ); } - Otimização : considerar só números impares

27 Resolver um sistema de equações lineares Na forma triangular superior Com a s e b s contantes e x s as variáveis a calcular 5.25

28 Resolução por substituição Calcula-se primeiro o x 0 a partir da última equação: O valor obtido para x 0 é substituído na equação seguinte para calcular x 1 : A assim por diante: 5.26

29 Solução em pipeline A primeira etapa calcula x 0 e passa x 0 para o segunda etapa, esta calcula x 1 a partir de x 0 e passa ambos, x 0 e x 1 para a etapa seguinte, que calcula x 2 a partir de x 0 e x 1, e por aí adiante. Computação pipeline tipo

30 O processo i (0 < i < n) recebe os valores x 0, x 1, x 2,, x i-1 e calcula x i pela equação: 5.28

31 Código Sequencial Dadas as constantes a i,j e b k armazenadas nos arrays a[ ][ ] and b[ ], e o array x[ ] onde serão guardadas as varáveis: x[0] = b[0]/a[0][0]; for (i = 1; i < n; i++) { sum = 0; For (j = 0; j < i; j++ sum = sum + a[i][j]*x[j]; x[i] = (b[i] - sum)/a[i][i]; } 5.29

32 Código paralelo P i (1 < i < n) : for (j = 0; j < i; j++) { recv(&x[j], Pi-1); send(&x[j], Pi+1); } sum = 0; for (j = 0; j < i; j++) sum = sum + a[i][j]*x[j]; x[i] = (b[i] - sum)/a[i][i]; send(&x[i], Pi+1); Podemos reescrever: 5.30

33 Código paralelo sum = 0; for (j = 0; j < i; j++) { recv(&x[j], Pi-1); send(&x[j], Pi+1); sum = sum + a[i][j]*x[j]; } x[i] = (b[i] - sum)/a[i][i]; send(&x[i], Pi+1); Non-Blocking para aumentar performance

34 Pipeline processing using back substitution 5.31