Message Passing Interface (MPI) Message Passing Interface - MO601 Gustavo Waku gustavo.waku@gmail.com

Message Passing Interface - MO601 Agenda Introdução e breve histórico Conceitos Básicos Comunicação ponto a ponto DeadLocks e Starvation Modos de comunicação e operações não bloqueantes Comunicação coletiva Topologia de Processos Entrada e Saída Paralela Fechamento Q&A Referências Bibliográficas Message Passing Interface - MO601

Introdução e Breve histórico O que é o MPI? É uma especificação que define um conjunto de apis para passagem de mensagens, estabelecendo padrões de comportamento. Várias implementações, comportamentos diferentes => sistemas heterogêneos, diversos fabr, necessidade de convergência. Adoção em ambientes hetetorêneos (portabilidade, facilidade de programar, grande nro de rotinas disponíveis). Atualmente especificado pelo MPI forum [http://mpj-express.org/] Utilizado em sistemas de alta performance. Message Passing Interface - MO601 Comentar sobre conceitos básicos, o que é o padrão MPI, quem cuida da sua especificação, Qual sua utilidade e principais vantagens Sobre a figura, comentar sobre a linha do tempo e as adições feitas no MPI2.0 e no MPI-3.0 MPI-1.0 basicamente comunicação ponto a ponto. MPI2.0 suporte a E/S paralela, operações remotas de memória e gerenciamento dinâmico de processos MPI-3.0, adição de comunicação coletiva não bloqueante (MPI_IBARRIER, MPI_ISCATTER, etc..). De uma versão para outra, pequenos incrementos e eventualmente mudança de assinatura, forçando algumas apis a serem deprecadas. 1994 1995 1997 2008 2009 2012 V1.0 Mai V1.1 Jun V1.2 Jul e V2.0 V1.2 Mai V2.1 Jun V2.2 Set V3.0 Set

Message Passing Interface - MO601 Conceitos Básicos Processo (Process) Identificado pelo rank (similar ao pid do linux, vai de 0 a N-1). Grupos (Group) Coleção de processos Contexto (Context) Particiona o espaço, e serve para isolar. Communicador (Communicator) Agrega os conceitos de Grupo + Contexto (MPI_COMM_WORLD, MPI_COMM_SELF) Intra-Communicator (dentro do grupo), Inter-Communicator (entre grupos) Message Passing Interface - MO601 Comentar sobre os conceitos básicos sobre os quais o MPI opera sobre.

Comunicação ponto a ponto Formação de pacotes e matching Como funciona Par send – receive DEST/SOURCE+ TAG + COMM => envelope matching Variantes com MPI_ANY_SOURCE, MPI_ANY_TAG. Assimetria entre send / receive. Como identificar processos? ( comm + rank ). Message Passing Interface - MO601 Matching de envelope ocorre quando o valor de souce/dest + tag + comm batem. Note que é necessário que o sender especifique quem vai receber, e o receiver especifica de quem ele recebe. Variantes ANY permitem receber mensagem de qualquer sender, No envio é necessário especificar necessariamente quem vai receber. Note a diferença em relação ao receive. São assimétricos.

Comunicação ponto a ponto Sends/Receives Bloqueantes, unidirecional Send Processo 0 Receive Processo 1 #include "mpi.h" int main( int argc, char *argv[]) { char message[20]; int myrank; MPI_Status status; MPI_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &myrank ); if (myrank == 0) /* code for process zero */ strcpy(message,"Hello, there"); MPI_Send(message, strlen(message)+1, MPI_CHAR, 1, 99, MPI_COMM_WORLD); } else if (myrank == 1) /* code for process one */ MPI_Recv(message, 20, MPI_CHAR, 0, 99, MPI_COMM_WORLD, &status); printf("received :%s:\n", message); MPI_Finalize(); return 0; } Message Passing Interface - MO601 Exemplo de send/receive bloqueante simples com fluxo unidirecional.

Comunicação ponto a ponto Sends/Receives Bloqueantes package p1; import mpi.*;   public class HelloWorldMPI { public static final int TAG = 99; public static void main(String[] args) throws Exception { MPI.Init(args) ; int myrank = MPI.COMM_WORLD.Rank(); int numprocs = MPI.COMM_WORLD.Size(); System.out.println("I am process <"+myrank+"> of total <"+ numprocs +"> processes."); char [] message1 = "Hello There, I`m process <0> speaking".toCharArray(); char [] buf1 = new char[message1.length]; char [] message2 = ("Hi, I`m process <" + myrank + "> speaking").toCharArray(); char [] buf2 = new char[message2.length]; if (myrank == 0) { for ( int i=1; i<numprocs; i++ ) { System.out.println(" process <0> sends message to: <" + i + ">"); MPI.COMM_WORLD.Send(message1, 0, message1.length, MPI.CHAR, i, TAG); } System.out.println(" process <0> waits to receive messages from <" + i + ">"); MPI.COMM_WORLD.Recv(buf2, 0, buf2.length, MPI.CHAR, i, TAG); } else { System.out.println(" process <"+ myrank +"> waits to receive from <0>"); MPI.COMM_WORLD.Recv(buf1, 0, buf1.length, MPI.CHAR, 0, TAG); System.out.println("process <"+ myrank +"> received: " + new String(buf1) + "!"); System.out.println(" process <"+ myrank +"> sends message back to <0>"); MPI.COMM_WORLD.Send(message2, 0, message2.length, MPI.CHAR, 0, TAG); MPI.Finalize(); P0 P1 P2 P3 PN … Message Passing Interface - MO601 Implementação em java dos processos. – usando MPJ library. Múltipos Processos: - P0 envia a mensagem e aguarda a resposta - Os demais recebem e enviam uma outra mensagem para P0

Comunicação ponto a ponto MPJ Express (0.38) is started in the multicore configuration I am process <3> of total <4> processes. process <3> waits to receive from <0> I am process <0> of total <4> processes. process <0> sends message to: <1> I am process <2> of total <4> processes. process <2> waits to receive from <0> I am process <1> of total <4> processes. process <1> waits to receive from <0> process <0> sends message to: <2> process <0> sends message to: <3> process <0> waits to receive messages from <1> process <1> received: Hello There, I`m process <0> speaking! process <1> sends message back to <0> process <3> received: Hello There, I`m process <0> speaking! process <3> sends message back to <0> process <2> received: Hello There, I`m process <0> speaking! process <2> sends message back to <0> process <0> received: Hi, I`m process <1> speaking process <0> waits to receive messages from <2> process <0> received: Hi, I`m process <2> speaking process <0> waits to receive messages from <3> process <0> received: Hi, I`m process <3> speaking P0 P1 (2) Inicia e Envia msg para P1 (5) Envia msg para P2 (6) Envia msg para P3 (7) Aguarda msg de P1 (14) Recebe msg de P1 (15) Recebe msg de P2 (16) Recebe msg de P3 (4) Inicia e aguarda P0 (8) Recebe msg de P0 (9) Envia msg para P0 P2 Message Passing Interface - MO601 (3) Inicia e aguarda P0 (12) Recebe msg de P0 (13) Envia msg para P0 P3 Mostrar a execução de um exemplo com N=4 do programa anterior. Andar passo a passo no diagrama da direita, mostrando como a execução funcionou. Objetivo é facilitar o entendimento do mecanismo geral do MPI. (1) Inicia e aguarda P0 (10) Recebe msg de P0 (11) Envia msg para P0

Deadlocks e Starvation Em uma comunicação síncrona, podem ocorrer deadlocks caso o programa tenha sido projetado de forma equivocada. Um exemplo é a situação em que um processo 0 envia uma mensagem ao processo 1 e fica esperando, o processo 1 envia para o processo 0 que também fica esperando. Uma maneira de evitar isso é fazer com que um deles comece recebendo a mensagem, e o outro enviando. Outras situações de deadlock podem ocorrer e devem ser observadas caso a caso. O padrão não especifica formas de identificar, apenas enumera alguns possíveis casos de deadlock. Message Passing Interface - MO601 Ilustrar o caso principal de deadlock com sends e receives bloqueantes. Send Processo 0 Receive Processo 1 Send Processo 0 Receive Processo 1

Deadlocks e Starvation O protocolo não garante justiça na comunicação. Suponha que um processo envie uma mensagem, o processo destino pode não receber a mensagem devido a mensagem ter sido sobreposta por outra mensagem enviada por outro processo. De maneira análoga, suponha vários processos receptores de mensagens produzidas por outro processo, é possível que algum deles nunca receba a mensagem produzida. É responsabilidade do programador garantir que não ocorra starvation. Message Passing Interface - MO601 Mostrar 2 casos de starvation. No caso o Receive, o tag e o commicator devem ser iguais ou do tipo ANY. Send Processo 0 Receive Processo 2 Processo 1 ?, X Processo 0 Processo 1 ?, X Send Receive Processo 2 Receive Processo 3 Receive

Modos de comunicação e operações não bloqueantes Bloqueantes e não bloqueantes (continuam ou não a execução) Local ou não local (depende ou não de um comando correspondente). Sends Bloqueantes: Standard (sujeito à disponibilidade de memória do sistema se a mensagem vai ser armazenada em buffer ou não; se ela for armazenada em buffer, o programa pode continuar assim que a mensagem for transferida ao buffer. Se não houver memória (ou por questões de desempenho) e a mensagem não for armazenada em buffer, o programa não retoma sua execução até que o comando receive correspondente seja invocado. – não local Buffered (copiada para um buffer temporário e não espera o comando receive correspondente para continuar a execução) – local Synchronous (só termina quando o comando receive correspondente é alcançado e a mensagem começou a ser recebida) – não local Ready (espera o comando receive correspondente ser alcançado para poder iniciar, semântica igual ao send standard e send synchronous.) – não local Mesma idéia para Sends não bloqueantes. (mas dividida em start e complete). send_start, send_complete, receive_start, receive_complete Receives não possuem tantas variantes, apenas bloq./não bloq. Message Passing Interface - MO601 Explicar os diversos tipos de chamada, bloqueantes, nao bloqueantes, locais, não locais, buffered, synchronous, ready, standard. Sends bloqueantes e não bloqueantes devem dividir o start do complete.

Modos de comunicação e operações não bloqueantes Message Passing Interface - MO601 Mostrar os diversos tipos de combinação possíveis VS característica de ser local e não local, assim como o comando MPI correspondente. Todas as combinações de send-receives bloqueantes e não bloqueantes são possíveis. Ex: send bloqueante – receive não bloqueante, etc…

Message Passing Interface - MO601 Comunicação Coletiva Objetivo: fornecer uma maneira de comunicação entre os processos de um grupo ou entre grupos de processos. Exemplos principais são barreiras e broadcasts. (APIS relacionadas: MPI_BARRIER, MPI_BCAST, MPI_SCATTER, MPI_GATHER, MPI_ALLGATHER, MPI_ALLTOALL ) MPI-3.0 adicionou operações assíncronas: MPI_ISCATTER, MPI_IBARRIER, etc… Message Passing Interface - MO601 Na broadcast, um dado é replicado para os demais processos do grupo. No scatter, ocorre a distribuição dos dados, a centralização ocorre no gather. O allgather centraliza a informação em cada um dos processos, e o complete exchange realiza uma espécie de transposição de dados.

Message Passing Interface - MO601 Comunicação Coletiva Exemplo de MPI_BCAST(buffer, count, datatype, root, comm) Broadcast de 100 inteiros do processo 0 (root) para cada processo dentro do grupo (comm) …. MPI_Comm comm; int array[100]; int root=0; ... MPI_Bcast(array, 100, MPI_INT, root, comm); Message Passing Interface - MO601 Trecho de código que faz a comunicação broadcast

Topologia (Virtual) de Processos Atributo extra e opcional dado ao intRA-comunicador Ajuda a prover um mecanismo de referência conveniente para processos (dentro de um grupo) Pode ajudar no mapeamento físico de processos O padrão MPI não estabelece como devem ser mapeados os processos em hardware. Cada fornecedor possui uma impl. Tipos suportados: Cartesiana, Grafal e Grafal Distribuída. Message Passing Interface - MO601

Message Passing Interface - MO601 E/S Paralela E/S tradicionalmente é feita de forma serial, uma possível otimização é criar vários processos fazendo uma computação e deixar um processo cuidando de toda a E/S. #include "mpi.h" #include <stdio.h> #define BUFSIZE 100 int main(int argc, char *argv[]) { int i, myrank, numprocs, buf[BUFSIZE]; MPI_Status status; FILE *myfile; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &myrank); MPI_Comm_size(MPI_COMM_WORLD, &numprocs); for (i=0; i<BUFSIZE; i++) buf[i] = myrank * BUFSIZE + i; if (myrank != 0) MPI_Send(buf, BUFSIZE, MPI_INT, 0, 99, MPI_COMM_WORLD); else { myfile = fopen("testfile", "w"); fwrite(buf, sizeof(int), BUFSIZE, myfile); for (i=1; i<numprocs; i++) { MPI_Recv(buf, BUFSIZE, MPI_INT, i, 99, MPI_COMM_WORLD, &status); } fwrite(buf, sizeof(int), BUFSIZE, myfile); } fclose(myfile); MPI_Finalize(); return 0; } Message Passing Interface - MO601 Vantagem: Simplicidade (com a delegação de E/S para 1 único processo). Desvantagem: Processo 0 precisa esperar por todos, pouca paralelização. Exemplo de programa tradicional, com 1 processo mexendo com E/S Todos os processos mandam para P0 a informação, perceba que o P0 faz N-1 chamadas de MPI_RECV.

Message Passing Interface - MO601 E/S Paralela Escrita em um único arquivo com MPI_FILE_SET_VIEW(fh, offset, etype, filetype, datarep, info) e MPI_FILE_WRITE. #include "mpi.h" #include <stdio.h> #define BUFSIZE 100 int main(int argc, char *argv[]) { int i, myrank, buf[BUFSIZE]; MPI_File thefile; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &myrank); for (i=0; i<BUFSIZE; i++) buf[i] = myrank * BUFSIZE + i; MPI_File_open(MPI_COMM_WORLD, "testfile", MPI_MODE_CREATE | MPI_MODE_WRONLY, MPI_INFO_NULL, &thefile); MPI_File_set_view(thefile, myrank * BUFSIZE * sizeof(int), MPI_INT, MPI_INT, "native", MPI_INFO_NULL); MPI_File_write(thefile, buf, BUFSIZE, MPI_INT, MPI_STATUS_IGNORE); MPI_File_close(&thefile); MPI_Finalize(); return 0; } Message Passing Interface - MO601 Mostrar exemplo de escrita paralela. Mostrar a diretiva de chamada MPI_SET_VIEW e o MPI_FILE_WRITE. Observar o comunicador MPI_COMM_WORLD na abertura do arquivo, possibilitando colaboração.

Message Passing Interface - MO601 E/S Paralela Leitura paralela, setando o ponteiro na posição com MPI_FILE_SET_VIEW e lendo com MPI_FILE_READ #include "mpi.h" #include <stdio.h> int main(int argc, char *argv[]) { int myrank, numprocs, bufsize, *buf, count; MPI_File thefile; MPI_Status status; MPI_Offset filesize; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &myrank); MPI_Comm_size(MPI_COMM_WORLD, &numprocs); MPI_File_open(MPI_COMM_WORLD, "testfile", MPI_MODE_RDONLY, MPI_INFO_NULL, &thefile); MPI_File_get_size(thefile, &filesize); /* in bytes */ filesize = filesize / sizeof(int); /* in number of ints */ bufsize = filesize / numprocs + 1; /* local number to read */ buf = (int *) malloc (bufsize * sizeof(int)); MPI_File_set_view(thefile, myrank * bufsize * sizeof(int), MPI_INT, MPI_INT, "native", MPI_INFO_NULL); MPI_File_read(thefile, buf, bufsize, MPI_INT, &status); MPI_Get_count(&status, MPI_INT, &count); printf("process %d read %d ints\n", myrank, count); MPI_File_close(&thefile); MPI_Finalize(); return 0; } Message Passing Interface - MO601 Mostrar um exemplo de leitura paralela

Message Passing Interface - MO601 Fechamento O padrão MPI define um conjunto de operações padrão + comportamento esperado Portabilidade e Facilidade de Uso Implementações Fortran, C, C++, Java Produtos Comerciais SGI Message Passing Toolkit WMPI II Sun MPI Intel MPI HP-MPI Message Passing Interface - MO601 O padrão MPI define um conjunto de operações padrão para operar com passagem de mensagem. Ao definir comportamento esperado, ele permite que diversas implementações em diversas linguagens sejam disponíveis (Fortran, C, C++, Java), assim como padronização de diversos produtos comerciais como (Scali MPI Connect, WMPI II,SGI Message Passing Toolkit, Intel MPI, Sun MPI, HP-MPI, MPI/Pro).

Message Passing Interface - MO601 Q&A ? Message Passing Interface - MO601

Referências Bibliográficas [1] MPI: A Message-Passing Interface Standard Version 3.0. Setembro 2012. Disponível em: http://www.mpi-forum.org/docs/mpi-3.0/mpi30-report.pdf. Acessado em outubro de 2012.   [2] Message Passing Interface. Disponível em: http://en.wikipedia.org/wiki/Message_ Passing_Interface. Acessado em: outubro de 2012. [3] MPJ Express. Disponível em: http://mpj-express.org/. Acessado em: outubro de 2012. [4] MPJ Express: An Implementation of MPI in Java Linux/UNIX/Mac User Guide. Disponível em: http://mpj-express.org/docs/guides/linuxguide.pdf. Acessado em: outubro de 2012. [5] Culler D. E.; Singh J. P. Kaufmman M. Parallel Computer Architecture. Morgan Kaufmann Publishers, 1999. [6] Gropp W.; Lusk E.; Thakur R. Using MPI-2 Advanced Features of the Message Passing Interface, MIT press, 1994. [7] Open MPI. Disponível em: http://www.open-mpi.org/. Acessado em: outubro de 2012. [8] Sun MPI 6.0 Software Programming and Reference Manual. Disponível em: http://docs.oracle.com/cd/E19061-01/hpc.cluster5/817-0085-10/. Acessado em: outubro de 2012. Message Passing Interface - MO601

Message Passing Interface - MO601 BACKUP Message Passing Interface - MO601

Message Passing Interface - MO601 E/S Paralela Uma forma alternativa seria escrever em múltiplos arquivos. #include "mpi.h" #include <stdio.h> #define BUFSIZE 100 int main(int argc, char *argv[]) { int i, myrank, buf[BUFSIZE]; char filename[128]; MPI_File myfile; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &myrank); for (i=0; i<BUFSIZE; i++) buf[i] = myrank * BUFSIZE + i; sprintf(filename, "testfile.%d", myrank); MPI_File_open(MPI_COMM_SELF, filename, MPI_MODE_WRONLY | MPI_MODE_CREATE, MPI_INFO_NULL, &myfile); MPI_File_write(myfile, buf, BUFSIZE, MPI_INT, MPI_STATUS_IGNORE); MPI_File_close(&myfile); MPI_Finalize(); return 0; } Message Passing Interface - MO601 Vantagem: Paralelização da escrita e computação. Desvantagens: os arquivos precisam ser juntados para utilização futura por um outro processo se uma aplicação for escrita de forma paralela, ela vai necessariamente paralelizar até no máximo o número de arquivos produzidos é difícil manusear e trafegar na rede vários arquivos, assim como manter lógica deles. Sobre E/S Paralela, um modelo alternativo em que há escrita em arquivos múltiplos.