mpi

Author: liciascl

material/aulas/aula07/index.md

@@ -0,0 +1,131 @@
+Message Passing Interface (MPI) é um padrão para comunicação de dados em computação paralela. Existem várias modalidades de computação paralela, e dependendo do problema que se está tentando resolver, pode ser necessário passar informações entre os vários processadores ou nós de um cluster, e o MPI oferece uma infraestrutura para essa tarefa.
+
+Para iniciarmos o nosso estudo de MPI, implemente os desafios abaixo, entendendo como encadear sends e receives, e o impacto nos resultados.
+
+
+## **Ping-pong**
+
+A ideia é medir a **latência de comunicação ponto a ponto**.
+
+Implemente o ping-pong: rank 0 envia uma mensagem ao rank 1, que responde.
+Faça duas versões:
+
+   * **Bloqueante** (`MPI_Send/MPI_Recv`)
+   * **Não-bloqueante** (`MPI_Isend/Irecv + MPI_Wait`)
+
+Rode os testes:
+
+   * Mensagens de **16 B, 1 KB, 64 KB, 1 MB**
+   * Em 2, 3 e 4 nós 
+
+Analise: 
+
+   * Para mensagens pequenas, o que domina: **latência fixa** ou **tamanho da mensagem**?
+   * A partir de que tamanho de mensagem o gargalo passa a ser a **largura de banda** da rede?
+
+Código base:
+```cpp
+#include <mpi.h>        // Biblioteca principal do MPI para comunicação entre processos
+#include <iostream>    
+#include <cstring>      
+
+int main(int argc, char** argv) {
+    int rank;               // Variável que armazenará o "rank" (identificador) do processo
+    MPI_Status status;      // Estrutura que armazenará o status da comunicação MPI
+    char mensagem[100];     // Vetor de caracteres para armazenar a mensagem a ser enviada/recebida
+
+    // Inicializa o ambiente MPI (todos os processos são iniciados)
+    MPI_Init(&argc, &argv);
+
+    // Descobre o "rank" do processo atual dentro do comunicador global (MPI_COMM_WORLD)
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+    // Se este for o processo de rank 0 (emissor inicial)
+    if (rank == 0) {
+        // Copia a string "Olá" para a variável mensagem
+        std::strcpy(mensagem, "Olá");
+
+        // Envia a mensagem para o processo de rank 1
+        // Parâmetros: buffer, tamanho, tipo, destino, tag, comunicador
+        MPI_Send(mensagem, std::strlen(mensagem) + 1, MPI_CHAR, 1, 0, MPI_COMM_WORLD);
+
+        // Imprime no terminal que a mensagem foi enviada
+        std::cout << "Processo 0 enviou: " << mensagem << std::endl;
+
+        // Aguarda a resposta do processo 1
+        // Parâmetros: buffer, tamanho máximo, tipo, origem, tag, comunicador, status
+        MPI_Recv(mensagem, 100, MPI_CHAR, 1, 0, MPI_COMM_WORLD, &status);
+
+        // Imprime a mensagem recebida
+        std::cout << "Processo 0 recebeu: " << mensagem << std::endl;
+    }
+
+    // Se este for o processo de rank 1 (receptor inicial)
+    else if (rank == 1) {
+        // Recebe a mensagem enviada pelo processo 0
+        MPI_Recv(mensagem, 100, MPI_CHAR, 0, 0, MPI_COMM_WORLD, &status);
+
+        // Imprime a mensagem recebida
+        std::cout << "Processo 1 recebeu: " << mensagem << std::endl;
+
+        // Prepara a resposta "Oi"
+        std::strcpy(mensagem, "Oi");
+
+        // Envia a resposta de volta ao processo 0
+        MPI_Send(mensagem, std::strlen(mensagem) + 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
+
+        // Imprime que a mensagem foi enviada
+        std::cout << "Processo 1 enviou: " << mensagem << std::endl;
+    }
+
+    else {
+        // Todos os outros processos apenas informam que estão ociosos
+        std::cout << "Processo " << rank << " está ocioso neste exercício." << std::endl;
+    }
+
+    // Finaliza o ambiente MPI (todos os processos encerram)
+    MPI_Finalize();
+
+    return 0;
+}
+```
+
+
+## **Token em anel**
+
+A ideia é perceber o custo de **coletar informações sequencialmente**.
+
+Implemente o token em anel: cada rank adiciona uma informação nova ao vetor e passa adiante.
+Execute em 2, 3 e 4 nós .
+Compare com o mesmo problema usando `MPI_Gather`.
+
+Analise:
+
+   * Como cresce o tempo do anel com o número de processos?
+   * Qual o gargalo de percorrer todos em sequência?
+   * Qual a vantagem de usar `MPI_Gather`?
+
+---
+
+
+## **Alternância**
+
+A ideia é entender como funciona uma **distribuição de tarefas**.
+
+Rank 0 possui 13 tarefas cada uma com diferentes niveis de complexidade. Implemente uma distribuição dinâmica de tarefas, o worker que terminar primeiro recebe a próxima tarefa.
+
+O que acontece quando as tarefas variam muito de custo?
+
+
+
+
+# O que você deve entregar:
+
+Para cada exercício:
+
+1. **Código** (disponível no repositório do github).
+2. **Tabela de resultados** (parâmetros usados, tempos medidos).
+3. **Gráficos**: tempo × P, tempo × tamanho, throughput × blocos, etc.
+4. **Discussão**: Análise dos resultados
+
+**Envie o seu relatório com as suas análises até as 23h59 de 04/09 pelo [GitHub Classroom](https://classroom.github.com/a/ilH4AsH_)** 

material/teoria/MPI.md

@@ -0,0 +1,134 @@
+## Conceitos básicos de MPI
+
+MPI (Message Passing Interface) é um padrão para programação paralela em memória compartilhada, o seja, em vários nós de computação. Cada processo é identificado por um **rank** (um número de 0 até `size-1`), todos os processos de um programa MPI formam um **comunicador** (por padrão `MPI_COMM_WORLD`).
+
+## Comunicação ponto a ponto
+
+### Envio e recebimento **bloqueantes**
+
+```cpp
+MPI_Send(buffer, count, MPI_CHAR, destino, tag, MPI_COMM_WORLD);
+MPI_Recv(buffer, count, MPI_CHAR, origem, tag, MPI_COMM_WORLD, &status);
+```
+
+* `buffer`: ponteiro para os dados.
+* `count`: número de elementos.
+* `MPI_CHAR`, `MPI_INT`, `MPI_DOUBLE` etc.
+* `destino` / `origem`: rank do processo de envio/recebimento.
+* `tag`: identificador da mensagem (permite diferenciar mensagens).
+* `status`: metadados sobre a recepção.
+
+### Envio e recebimento **não-bloqueantes**
+
+```cpp
+MPI_Request req;
+MPI_Isend(buffer, count, MPI_INT, destino, tag, MPI_COMM_WORLD, &req);
+MPI_Wait(&req, MPI_STATUS_IGNORE);
+```
+
+```cpp
+MPI_Request req;
+MPI_Irecv(buffer, count, MPI_INT, origem, tag, MPI_COMM_WORLD, &req);
+MPI_Wait(&req, MPI_STATUS_IGNORE);
+```
+
+* Permitem **sobrepor comunicação e computação**.
+* Precisa sempre de `MPI_Wait` (ou `MPI_Test`).
+
+
+## Comunicação coletiva
+
+* **Broadcast**
+
+```cpp
+MPI_Bcast(buffer, count, MPI_INT, root, MPI_COMM_WORLD);
+```
+
+Envia `buffer` do processo `root` para todos.
+
+* **Scatter**
+
+```cpp
+MPI_Scatter(sendbuf, count, MPI_INT, recvbuf, count, MPI_INT, root, MPI_COMM_WORLD);
+```
+
+Distribui partes de um vetor do root para todos.
+
+* **Gather**
+
+```cpp
+MPI_Gather(sendbuf, count, MPI_INT, recvbuf, count, MPI_INT, root, MPI_COMM_WORLD);
+```
+
+Cada processo envia dados para o root.
+
+* **Reduce**
+
+```cpp
+MPI_Reduce(&valor_local, &valor_total, 1, MPI_INT, MPI_SUM, root, MPI_COMM_WORLD);
+```
+
+Combina valores de todos os processos (soma, máximo, mínimo, etc.).
+
+* **Barrier**
+
+```cpp
+MPI_Barrier(MPI_COMM_WORLD);
+```
+
+Todos os processos param até que todos cheguem aqui.
+
+---
+
+## Medição de tempo
+
+```cpp
+double t0 = MPI_Wtime();
+// ... código ...
+double t1 = MPI_Wtime();
+if(rank==0) std::cout << "Tempo = " << (t1-t0) << " segundos\n";
+```
+
+---
+
+## Estruturas úteis
+
+* **MPI\_Status** → contém informações de mensagens recebidas (como rank origem).
+
+```cpp
+MPI_Status status;
+MPI_Recv(buf, n, MPI_INT, origem, tag, MPI_COMM_WORLD, &status);
+int origem_real; MPI_Get_count(&status, MPI_INT, &origem_real);
+```
+
+* **Tags** → permitem diferenciar mensagens diferentes em paralelo.
+
+
+## Compilação e execução
+
+Compilar:
+
+```bash
+mpic++ programa.cpp -o programa
+```
+
+Executar com SLURM (arquivo `job.slurm`):
+
+```bash
+#!/bin/bash
+#SBATCH --job-name=mpi_job
+#SBATCH --ntasks=4
+#SBATCH --time=00:05:00
+#SBATCH --partition=normal
+srun ./programa arg1 arg2
+```
+
+Submit:
+
+```bash
+sbatch job.slurm
+```
+
+
+Documentação:
+[https://www.physics.rutgers.edu/~haule/509/MPI_Guide_C++.pdf](https://www.physics.rutgers.edu/~haule/509/MPI_Guide_C++.pdf)

mkdocs.yml

@@ -38,7 +38,7 @@ nav:
         - "Aula 04 - Heurísticas e Aleatoriedade": aulas/aula04/index.md
         - "Aula 05 - Programação paralela em CPU": aulas/aula05/index.md
         - "Aula 06 - Efeitos colaterais do paralelismo": aulas/aula06/index.md
-        #- "Aula 07 - Programação Distribuída": aulas/aula07/index.md
+        - "Aula 07 - Programação Distribuída": aulas/aula07/index.md
         #- "Aula 08 - Programação Paralela e Distribuída": aulas/aula08/index.md
         #- "Aula 09 - Programação Paralela em GPU": aulas/aula09/index.md
 
@@ -49,6 +49,7 @@ nav:
         - "Lista de Comandos" : teoria/comandos.md
         - "Heurísticas" : teoria/heuristicas.md
         - "OpenMP" : teoria/openmp.md
+        - "MPI" : teoria/MPI.md
 extra_javascript:
     - https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS_HTML
     - https://cdnjs.cloudflare.com/ajax/libs/js-yaml/4.0.0/js-yaml.min.js