Exercício de MPI Relatório do Trabalho

Transcrição

1 PUC-Rio Programação Concorrente e Paralela Exercício de MPI Relatório do Trabalho Danilo Moret Professora: Noemi Rodriguez

2 Enunciado Leiam os capítulos 7 e 8 do livro Parallel Programming in C with MPI and OpenMP do Michael J. Quinn e resolvam o último exercício (8.12) do capítulo 8. O programa gerado deve ser executado no cluster da PUC em até 8 máquinas. A entrega do trabalho inclui, alem do código, um pequeno relatorio indicando os passos que seguiram para montar o programa e os resultados experimentais obtidos. Exercício 8.12: A binary search tree is a way of organizing n keys from a linearly ordered set to ensure their retrieval in ʘ(log n) time. If we know the probability of each key being accessed, we can create an optimal binary search tree that minimizes the average search time (Figure 8.21). Figure 8.22 (código equivalente da figura encontra-se no anexo) is a C program implementing a dynamic algorithm to find an optimal binary search tree, given a set of n probabilities. The program is adapted from pseudo-code in Baase and Van Gelder [5]; consult their textbook for more details on the algorithm. Use the partitioning-communication-agglomeration-mapping design methodology to implement a parallel version of this program. (Hint: You need to find an agglomeration that will allow multiple processes to be computing concurrently.) Preparação O código fonte da figura 8.22 foi digitado e compilado de forma tradicional em uma máquina Ubuntu usando o gcc versão Foram feitas pequenas alterações de estilo no programa e ele foi testado passando os dados por pipe na linha de comando do Linux. Foi identificado um problema com pipes muito grandes, e o modo de entrada foi alterado para passar a ler de um arquivo ao invés de pela entrada no console. O formato do arquivo obedece o estilo de entrada inicial: o valor da primeira linha deve ser um inteiro indicando quantas entradas são esperadas, em seguida é feita a entrada de um valor no formato float por linha. Para gerar a entrada aleatoriamente foi criado um pequeno script Lua. A montagem do programa partiu da adaptação do algoritmo inicial. Houveram dificuldades na escolha de qual particionamento usar: a primeira estratégia pensada foi em dividir o processamento para ser feito por diagonais, onde cada processo tomaria uma diagonal da tabela de custos do algoritmo dinâmico para calcular e passaria o valor da célula calculada para o próximo processo.

3 cost Valores dados Processo 1 Processo 2 Processo 3 Exemplo de particionamento em diagonal com 3 processos e entrada tamanho 8 Este particionamento apresentou dificuldades de implementação na fase de comunicação: o processo precisa de todas as células abaixo e à esquerda da célula que ele está calculando, e estas não estariam todas com o processo corrente nem o responsável pela diagonal abaixo. Ele precisaria portanto receber duas comunicações do processo responsável pela diagonal abaixo, uma com a linha e outra com a coluna. cost Valores dados Valores dependidos Célula atual Dependência de valores para cálculo de uma célula Outro particionamento foi tentado. Neste cada processo ficou responsável por preencher uma coluna da matriz de custos, de baixo para cima da matriz. A cada vez que ele precisasse dos valores à esquerda ele aguardaria a comunicação do processo responsável pela coluna anterior. Os processos tomariam as colunas ordenadamente conforme seus IDs, revezando-se a cada np processos.

4 cost Valores dados Processo 1 Processo 2 Processo 3 Exemplo de particionamento por colunas com 3 processos e entrada tamanho 8 Este particionamento foi implementado com sucesso. A cada célula calculada o processo envia de forma assíncrona para o processo responsável pela próxima coluna (o processo com o próximo ID) a linha inteira que ele acabou de calcular. Assim ele garante que está passando os valores já recebidos de outros processos. Os valores da coluna são calculados pelo próprio processo, sem precisar recebe-los de outros para prosseguir. Experimento e resultados O programa foi executado no cluster da PUC variando o tamanho da entrada e o número de processos usados. A bateria de testes foi executada via script, e o tempo tomado foi usando a ferramenta time do próprio sistema operacional. Portanto os tempos de execução são os tempos reais da execução completa do programa, incluindo a leitura do arquivo e a transmissão inicial entre os processos. Como a leitura do arquivo só é executada pelo processo raiz independente do número de processos, e os arquivos tem no máximo poucos kb, o impacto nos resultados é pequeno. O crescimento do tamanho da entrada resulta em um crescimento exponencial da tabela no algoritmo dinâmico, e os resultados foram comparados nos gráficos e tabelas abaixo com um valor de referência que seguia uma função proporcional ao quadrado da entrada. Já o comportamento conforme a quantidade de processos variava era o principal ponto a ser estudado, buscando em que ponto a carga extra gerada pela comunicação entre os processos iria sobrepujar a vantagem de se ter vários processos executando ao mesmo tempo. Pelos resultados, a diferença entre os tempos de execução não foi linear ou abaixo, como esperado. Na média, dado todos os tamanhos de entrada, a execução com 2 processos levou 2,51 vezes mais tempo que a execução com 4 processos, e a execução com 4 processos levou 3,7 vezes mais tempo que a execução com 8 processos. Isto pode evidenciar o Efeito de Amdahl, descrito no livro de onde o exercício foi retirado: o tempo ganho na execução em paralelo aumenta quanto maior é o tamanho da entrada. De fato, quando se analisam somente parte dos resultados - conforme visto na segunda tabela e gráfico - correspondentes a valores de entradas menores, a aceleração é de 3,09 de 2 para 4 processos, e de 1,35 de 4 para 8 processos. Ainda assim a razão do tempo de execução não estar diminuindo somente na proporção de novos processos não está totalmente clara.

5 Resultados dos experimentos (número de processos por tamanho da entrada, resultados em segundos, comparados com curva n e n²) np = 2 0,518 0,68 0,919 1,379 2,479 4,779 9, ,3 100,54 181,68 277,24 np = 4 0,529 0,62 0,68 0,78 0,94 1,25 2 6,15 15,41 37,72 75,01 123,8 np = 8 0,56 0,629 0,639 0,72 0,759 0,86 1,04 1,98 2,7 7,57 17,88 36,17 ~n 0, , , , , , , , ~n² 0, , , , ,5 83, , , , Série completa comparada 300 Tempo de execução (s) np = 2 np = 4 np = 8 ~n ~n² Tamanho do array de entrada

6 Subconjunto dos resultados dos experimentos (número de processos por tamanho da entrada, resultados em segundos, comparados com curva n e n²) np = 2 np = ,68 0,919 1,379 2,479 4,779 9,13 0,62 0,68 0,78 0,94 1,25 2 0,629 0,639 0,72 0,759 0,86 1,04 np = 8 ~n 0, , , ,5 1, ~n² 0, ,2 1, , ,7 3, Série de teste para entradas de tamanho entre 50 e 100 Tempo de execução (s) np = 2 np = 4 np = 8 ~n ~n² Tamanho do array de entrada

7 Implementações Código fonte equivalente a figura 8.22 (arquivo searchtree.c) #include <stdio.h> #include <stdlib.h> #include <float.h> void matrixalloc(void ***a, int m, int n, int size) { int i, j; void *memory; memory = (void *) malloc (m*n*size); *a = (void **) malloc (m * sizeof(void *)); for (i = 0; i < m; i++) { (*a)[i] = memory + (i * n * size); void treeoutput(int **root, int low, int high) { printf("tree: %d - %d; root: %d\n", low, high, root[low][high + 1]); if (low < root[low][high + 1] - 1) treeoutput(root, low, root[low][high + 1] - 1); if (root[low][high + 1] < high - 1) treeoutput(root, root[low][high + 1] + 1, high); int main(int argc, char *argv[]) { float bestcost, rcost, tempcost; int n, r, i, j, high, low, bestroot; int **root; float **cost; float *p; FILE *input; input = fopen(argv[1], "r"); fscanf(input, "%d\n", &n); p = (float *) malloc (n * sizeof(float)); for (i = 0; i < n; i++) { fscanf(input, "%f\n", &p[i]); fclose(input); matrixalloc((void ***) &cost, n + 1, n + 1, sizeof(float)); matrixalloc((void ***) &root, n + 1, n + 1, sizeof(int)); for (low = n; low >= 0; low--) { cost[low][low] = 0; root[low][low] = low; for (high = low + 1; high <= n; high++) { bestcost = FLT_MAX; tempcost = 0; for (j = low; j < high; j++) { tempcost += p[j];

8 for (r = low; r < high; r++) { rcost = tempcost + cost[low][r] + cost[r + 1][high]; if (rcost < bestcost) { bestcost = rcost; bestroot = r; cost[low][high] = bestcost; root[low][high] = bestroot; treeoutput(root, 0, n - 1); Código fonte final (arquivo mpi-obst.c) #include <stdio.h> #include <stdlib.h> #include <float.h> #include "mpi.h" void matrixalloc(void ***a, int m, int n, int size) { int i, j; void *memory; memory = (void *) malloc (m*n*size); *a = (void **) malloc (m * sizeof(void *)); for (i = 0; i < m; i++) { (*a)[i] = memory + (i * n * size); void treeoutput(int **root, int low, int high) { printf("tree: %d - %d; root: %d\n", low, high, root[low][high + 1]); if (low < root[low][high + 1] - 1) treeoutput(root, low, root[low][high + 1] - 1); if (root[low][high + 1] < high - 1) treeoutput(root, root[low][high + 1] + 1, high); int main(int argc, char *argv[]) { MPI_Status status; MPI_Request request; int n, i, x, y, pid, np, leftpid, rightpid, bestroot; float *a; float basecost, bestcost, localcost; float **costs; int **roots; FILE *input; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &pid); MPI_Comm_size(MPI_COMM_WORLD, &np); // Process zero reads how many inputs and the probabilities array if (pid == 0) { input = fopen(argv[1], "r"); fscanf(input, "%d\n", &n);

9 a = (float *) malloc (n * sizeof(float)); for (i = 0; i < n; i++) { fscanf(input, "%f\n", &a[i]); fclose(input); // Broadcast size and probabilities array to all processes MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD); if (pid!= 0) { a = (float *) malloc (n * sizeof(float)); MPI_Bcast(a, n, MPI_FLOAT, 0, MPI_COMM_WORLD); matrixalloc((void ***) &costs, n + 1, n + 1, sizeof(float)); matrixalloc((void ***) &roots, n + 1, n + 1, sizeof(int)); // Filling base cells on all processes for (i = 0; i < n; i++) { costs[i][i] = 0; roots[i][i] = i; costs[i][i + 1] = a[i]; roots[i][i + 1] = i; costs[n][n] = 0; roots[n][n] = n; // Each process gets a column, rotating for (y = pid + 2; y < n + 1; y = y + np) { // Each column is searched from bottom up for (x = y - 2; x >= 0; x--) { leftpid = (pid + np - 1) % np; rightpid = (pid + 1) % np; // If the value to the left of current cell is not available, wait // for it (and the whole line) from the previous process if (x < y - 2) { MPI_Recv(costs[x], n + 1, MPI_FLOAT, leftpid, x, MPI_COMM_WORLD, &status); MPI_Recv(roots[x], n + 1, MPI_INT, leftpid, x, MPI_COMM_WORLD, &status); // The algorithm itself basecost = 0; bestcost = FLT_MAX; for (i = x; i < y; i++) { basecost = basecost + a[i]; for (i = x; i < y; i++) { localcost = costs[x][i] + costs[i + 1][y] + basecost; if (localcost < bestcost) { bestcost = localcost; bestroot = i;

10 costs[x][y] = bestcost; roots[x][y] = bestroot; // If there's a column to the right, send the whole line to the next // process if (y < n) { MPI_Isend(costs[x], n + 1, MPI_FLOAT, rightpid, x, MPI_COMM_WORLD, &request); MPI_Isend(roots[x], n + 1, MPI_INT, rightpid, x, MPI_COMM_WORLD, &request); // Prints the output on the process responsible for the rightmost column if (pid == (n - 2) % np) { treeoutput(roots, 0, n - 1); MPI_Finalize(); return 0; Código fonte do gerador de entradas aleatórias (random-table.lua) local size = arg[1] print(size) for i = 1, size do print(math.random()) end