CAP 2
• Arquitetura convencional: processador, memória e caminho de dados
• Processadores atuais usam múltiplas unidades funcionais e executa múltiplas instruções no mesmo ciclo o Pipeline
Limitações
• Tempo: estágio mais lento • Predição deve ser boa Solução: múltiplos pipelines
Agendamento de instruções
• Dependência verdadeira de dados: resultado de uma operação é entrada para a próxima • Dependência de recursos: Duas operações usam o mesmo recurso
• Dependência de ramo: Instruções depois de uma condicional não podem ser preditas deterministicamente anteriormente
Mecanismos
• In-order issue: instruções são requisitadas em ordem
• Dynamic issue: instruções podem ser requisitadas fora de ordem (geralmente melhor performance)
Considerações de eficiência
• As unidades funcionais podem não ficar ocupadas o tempo todo • Vertical waste: Nenhuma unidade funcional é usada durante um ciclo
• Horizontal waste: somente algumas unidades funcionais são usadas durante um ciclo • Performance geramlente limitada
o Paralelismo limitado em instruções comuns o Dependências
o Incapacidade do programador em gerar o paralelismo • Processadores Very Long Instruction Word (VLIW)
o Maior preocupação na construção de um processador: custo de hardware e complexidade de programação o Análise em tempo de execução e empacotamento das instruções que podem ser executadas juntas
o Hardware mais simples
o Predições são mais complicadas nesse caso
o Performance altamente dependente do compilador Desenrolamento de loops
Execução especulativa Predição de ramos
o Limitados a paralelismos de 4 ramos ou 8 ramos • O gargalo geralmente é o sistema de memória
o Latência: Tempo entre o pedido de um dado e a disponibilidade do mesmo
o Largura de Banda: Taxa em que os dados são mandados da memória para o processador • Solução da latência: Caches
o Pequena
o Baixa latência e alta largura de banda o Cache hit
Porcentagem de pedidos de dados satisfeitos pelo cache Geralmente determina a performance de um programa Localidades espacial e temporal
• Solução da largura de banda: aumento do tamanho dos blocos de memória • Meios alternativos de esconder a latência
o Prefetching:
Cache miss causa paradas no programa
É necessária memória extra para guardar resultados dos prefetches Requer mais recursos de hardware de memória
o multithreading
Uso de execução concorrente para buscar dados enquanto outras threads estão processando ou buscando outros dados
Nesse caso assumimos que a memória é capaz de responder a vários pedidos e o processador muda de thread a cada ciclo
A velocidade passa de limitado por latência para limitado por largura de banda Requer mais recursos de hardware de memória
o Localidade espacial
• Estrutura de controle de programas paralelos
o Granularidade: de nível de instrução a nível de processos
o SIMD -> uma unidade de controle central que despacha uma só instrução para todos os processadores Nem todas aplicações funcionam dessa maneira
o MIMD -> cada processador tem sua própria unidade de controle Mais hardware
• Modelos de comunicação em plataformas paralelas
o Acesso a memória compartilhada (multiprocessadores) Memória acessível por todos os processadores
UMA: Uniform Memory Access -> tempo uniforme para acessar qualquer parte da memória NUMA: Non-uniform Memory Access
Pode similar passage de mensagem o Troca de mensagens (multicomputadores)
Cada processador tem sua própria memória Pouco hardware além da rede de comunicação • Arquitetura de um computador paralelo ideal
o PRAM -> extensão de RAM
p processadores e uma memória global uniformemente acessível Clock em comum
EREW: Exclusive read, Exclusive Write CREW: Concurrent read, Exclusive Write ERCW: Exclusive read, Concurrent Write
• Concurrent write
o Common: Escreve somente se todos os valores são idênticos
o Arbitrary: Escreve o dado de um processador aleatoriamente escolhido o Priority: Segue uma ordem de prioridade pré-determinada
o Sum: Escreve a soma de todos os dados CRCW: Concurrent read, Concurrent Write
• Complexidade física de um computador paralelo ideal
o Processadores e memórias são conectados via switches
o O tempo a nível de palavras de um sistema de p processadores e m palavras tem complexidade O(pm) • Redes de interconexões em computadores paralelos
o Transmite dados entre processadores e para a memória o Interconexões são feitas de switches e links
Estáticas (direct networks)
• Links de comunicação ponto a ponto
Dinâmicas (indirect networks)
• Links de comunicação e switches
o Processos falam com a rede pelas interfaces de rede • Topologias de rede
o Buses
Primeiras e mais simples máquinas
Todos processadores acessam o mesmo bus Distância: O(1)
Broadcast
o Crossbars
Grid de switches
Custo: O(p²)
Problema: espaço e custo o Rede de múltiplos estágios
Compromisso entre performance e custo
Rede de múltiplos estágios Omega
• Log p estágios, p -> número de inputs/outputs • Input i é conectado com output j, então:
o Redes completamente conectadas
Cada processador é conectado com todos os outros Número de links: O(p²)
Hardware inconcebível para altos valores de p Estática
o Star connected
Todos nós conectados a um nó comum Distância: O(1)
Gargalo: nó central Estática
o Matrizes
D dimensões: 2D vizinhos Caso especial: hipercubo
Distância: sum(node1 xor node2) • O(log p), p -> número de nós Vizinhos: log p
o Redes baseadas em árvores
Distância: O(2 log p)
Links próximos da raiz tem maior tráfego
• Desenvolvendo redes de interconexão estáticas
o Diâmetro: distância entre os dois pontos mais distantes de uma rede Array linear: p-1
Matriz 2D: 2(sqrt(p) – 1) Hipercubo: log p
Árvore: log p
Completamente conectada: 1
o Largura de bissecção: mínima quantidade de links que deve ser cortados para dividir a rede em duas iguais Array linear: 1
Matriz 2D: sqrt(p) Hipercubo: p/2
Completamente conectada: p²/4 o Custo: Número de links e switches
• Coerência de cache em sistemas multiprocessadores
o Invalidação ou Atualização
Protocolo de atualização pode gerar significante overhead Overhead de falsos compartilhamentos
A maioria das máquinas atualmente usam protocolo de invalidação • Estados
o Compartilhado: Várias cópias válidas distribuídas o Inválido: O dado é inválido, necessária nova leitura o Sujo: Só existe essa cópia. Invalidação não é necessária
Sistema de cache Snoopy: Broadcast de invalidações
• Se um dado é marcado como sujo o processador pode trabalhar com ele dentro do cache sem gerar tráfego
Sistemas baseados em diretórios
• Envio de notificações somente aos processadores necessários
• Diretório mantém essas informações e informações de tag para cada dado em um cache
• Custo de comunicação em máquinas paralelas
o Junto com ociosidade e contenção, é o maior overhead de programas paralelos o Depende de várias características
Semântica do programa Topologia da rede
Manipulação e roteamento de dados Protocolos de softwares associados o Tempo total de transferência
Startup time (ts): Tempo de preparação
Per-hop time (th): Função do número de trocas. Fatores como latência de troca, delas da rede, etc...
Per-word transfer time (tw): Determinado pelo comprimento da mensagem. Fatores como largura
de banda dos links, checagem e correção de erros, etc... • m palavras e l links em redes descongestionadas
• th geralmente é pequeno
o Técnicas de roteamento
Roteamento de pacotes
• Quebra a mensagem em pacotes
• Cada pacote pode seguir um caminho, então cada um tem seu cabeçalho •
Roteamento Cut-Through
• Divide a mensagem em unidades básicas (flits) • Todos pelo mesmo caminho
• , sendo tw bem pequeno
o Modelo simplificado de custo de passagem de mensagens
Th é pequeno e m é grande
• Modelos de custo para máquinas memória compartilhada o Caches com memória finita resultam em cache thrashing
o Overheads por invalidações e atualizações são difíceis de quantificar o Localidade espacial é difícil de modelar
o Falso compartilhamento e contenção são difíceis de modelar • Mecanismos de roteamento para redes de interconecção
o Roteamento pode evitar deadlocks
• Técnicas de mapeamento em grafos
o Embutir um padrão de comunicação conhecido em uma dada topologia de interconexão o Portar um algoritmo de uma topologia para outra
o Métricas
Congestão do mapeamento: Número máximo de arestas mapeadas sobre qualquer aresta Dilatação do mapeamento: Número máximo de arestas em que qualquer aresta é mapeada Expansão do mapeamento: Razão entre o número de nós do grafo novo em relação ao antigo o Incorporação de um array linear em um hipercubo
Array 2d elementos em hipercubo de d dimensões
i -> G(i,d)
Exemplo
• As métricas são todas 1
o Incorporação de uma matriz em um hipercubo
Exemplo
As métricas são todas 1
o Incorporação de um hipercubo em uma matriz 2D
Cada subcubo com sqrt(p) nós é mapeado em uma linha da matriz de sqrt(p) nós
CAP 3 – Princípios de Design de Algoritmos Paralelos (//) • Decomposição, tarefas e grafo de dependências
o Decompor o problema em tarefas que podem ser executadas em // o Existem várias maneiras de decompor um problema
o Ilustração: grafos
o Granularidade da decomposição
O número de tarefas determina a granularidade • Granularidade fina: Muitas tarefas • Granularidade grossa: Poucas tarefas o Grau de concorrência
Número de tarefas que pode ser executado em paralelo
Máximo grau de concorrência: quando o grau de concorrência varia ao longo do programa Grau médio de concorrência
Quanto mais fina a granularidade, maior o grau de concorrência
• Caminho crítico
o Caminho: sequência de processamento
o Comprimento: Comprimento do maior caminho de um grafo de dependências de um programa // • Limites de performance em //
o O grau de concorrência é limitado para um dado problema
o A performance também é limitada pela troca de informações entre tarefas • Grafo de interação entre tarefas
o Comunicação entre tarefas
o Grafo de dependência: dependências de controle o Grafo de interação: dependência de dados o Granularidade e comunicação
Geralmente se a granularidade é mais fina, a comunicação é maior • Processos e mapeamento
o Em geral o número de tarefas de uma decomposição excede o número de elementos de processamento disponíveis Algoritmo // deve fornecer um mapa de tarefas para processos
• Crítico para a performance de um algoritmo
• Determinado pelos grafos de dependência E de interação
o Grafo de dependência: Garante que o trabalho é igualmente distribuído entre os processos o Grafo de interação: Garante mínimo de interação
• Minimizar o tempo de execução em paralelo
o Mapeamento de tarefas independentes para diferentes processos
o Tarefas do caminho crítico devem ir o mais rápido possível para os processadores o Mapeamento de tarefeas com densa comunicação para o mesmo processo o Conflitantes entre si
• Técnicas de decomposição o Decomposição recursiva
Geralmente utilizados em problemas solúveis pela técnica de divisão e conquista Quicksort
o Decomposição de dados
Identificação dos dados em que as operações são feitas Divisão desses dados em várias tarefas
Pode ser dividido de várias formas
Criticamente impactante para a performance do algoritmo Input data
Output data
Intermediate data
Regra do “dono calcula”
• O processo que tem um determinado dado é responsável pelos cálculos relacionados a ele o Decomposição exploratória
Teste de todas as possibilidades até encontrar a solução o Decomposição especulativa
As dependências entre tarefas as vezes não são conhecidas a priori
Abordagem conservativa: identificação de tarefas independentes somente quando é garantido que elas não tem dependências. Pode ocasionar pouca concorrência
Abordagem otimista: agendamento das tarefas mesmo quando ele pode potencialmente estar errado. Precisa de um mecanismo de roll-back
o Decomposição Híbrida
Uso de mais de um tipo de decomposição • Características de tarefas
o Geração de tarefas
Geração estática de tarefas: Tarefas concorrentes podem ser identificadas a priori. Problemas regularmente estruturados. Geralmente decomposição de dados ou decomposição recursiva
Geração dinâmica de tarefas: Tarefas geradas em tempo de execução. Geralmente decomposições exploratória e especulativa
o Tamanho de tarefas
Uniforme: Tarefas do mesmo tamanho
Não Uniforme: pode ser determinada ou estimada a priori ou não o Tamanho dos dados associados às tarefas
Pequeno: A comunicação entre processos pode ser feita facilmente Grande
• Características das interações entre tarefas
o Interações estáticas: Conhecidas a priori. Relativamente mais simples de codificar nos programas o Interações dinâmicas: Não são conhecidas a priori. Mais difícil de codificar
o Interações regulares: Tem um padrão definido. Os padrões podem ser explorados para melhorar a performance. o Interações irregulares: Não tem topologias bem definidas
o Somente leitura: Somente leitura dos dados associados a outras tarefas o Leitura e escrita: Lê e pode escrever sobre os dados. Mais difíceis de codificar
o Interação One-way: Pode ser iniciado e finalizado por uma só das tarefas. Mais difíceis de ser codificadas o Interação Two-way: Requer participação das duas tarefas
• Técnicas de mapeamento de tarefas para processos o Minimizar overheads de comunicação e ociosidade
o Ociosidade
Mapeamento estático: Mapeamento feito a priori. Boa estimativa do tamanho de cada tarefa • Mapeamento baseado em particionamento de dados
o Distribuição em blocos de matriz
• Mapeamento baseado no particionamento do grafo de tarefas • Mapeamento híbrido
Mapeamento dinâmico: Mapeamento em tempo de execução. Tarefas geradas em tempo de execução ou tamanhos desconhecidos
• Centralizado: mestre e escravos o Mestre pode se tronar um gargalo
o Processo pode pegar algumas tarefas de uma vez • Distribuído:
o Cada processo mande e recebe trabalho de outros o Quem inicia a transferência de trabalho?
o Quanto trabalho é transferido?
o Quando uma transferência é desencadeada? • Minimização de overheads de interação
o Maximizar a localidade de dados o Minimizar o volume de troca de dados o Minimizar a frequência de interações o Minimizar contenções e hot-spots o Overlap de interações e instruções o Overlap de interações e interações
o Uso de comunicação em grupo ao invés de P2P • Modelos de algoritmos paralelos
o Modelo de paralelismo de dados: Tarefas são estaticamente mapeada a processos e cada tarefa faz operações similares em dados diferentes
o Modelo de grafo de tarefas: Começando com um grafo de dependências. A relação entre tarefas é usada para promover localidade e reduzir custos de interação
o Modelo de mestres e escravos: Alguns processos geram trabalho e alocam para os trabalhadores estática ou dinamicamente
o Modelo de pipeline: Uma linha de dados passa através de vários processos e cada um deles faz uma tarefa sobre ele.
o Modelos híbridos: Vários modelos aplicados hierarquicamente ou sequencialmente
CAP 6 – Programação usando o paradigma de passagem de mensagem • Princípios de Passagem de Mensagem
o p processos, cada um com a sua memória o Dados explicitamente particionados o Paradigmas:
Assíncrono: Tarefas concorrentes assíncronas
Vagamente síncrona: Tarefas sincronizam quando precisam se comunicar o Geralmente usado SPMD (Single Program Multiple Data)
o Funções de transferência de dados
send(void *sendbuf, int nelems, int dest) receive(void *recvbuf, int nelems, int source) • Operações bloqueantes não bufferizadas
o send retorna apenas depois de todos os dados serem transferidos o Problemas: possibilidade de deadlock e latência
o Em operações bufferizadas, a função retorna depois de ter copiado os dados pro buffer • Operações bloqueantes bufferizadas
o Solução para a latência
o Ainda há possibilidade de deadlock
o Retorna das funções antes de realmente ser seguro o Geralmente acompanhado de operação check-status
o Quando bem utilizado, pode sobrepor comunicação com cálculos para se evitarem latências o Bibliotecas de passagem de mensagem geralmente tem as funções bloqueantes e não bloqueantes • Protocolos de send e receive
• MPI: Message Passing Interface
o Biblioteca de rotinas para passagem de mensagens o C e Fortran
o Funções e constantes para C no final do arquivo • Comunicadores
o Define um domínio de comunicação (conjunto de processos que podem se comunicar entre si) o Informações guardadas em variáveis do tipo MPI_Comm
o Usados como argumentos em todas as funções de comunicação o Cada processo pode pertencer a vários comunicadores
• Topologias e incorporações
o MPI permite organizações dos processadores em matrizes k-dimensionais o Os mapeamentos das organizações podem ser feitos de várias formas
o Topologias cartesianas • Comunicação coletiva
o Todos os processos envolvidos devem chamar o mesmo comando o Barreira
o Broadcast o Redução
CAP 7 – Plataformas de memória compartilhada • Modelos de programação
o Concorrência e sincronização
o Dados privados por padrão. Pode ser alterado o Toda memória é global
• Threads
o Pilha de chamada de função é local para cada thread o Facilidade de programação
• POSIX Thread API (pthread) o C: #include <pthread.h>
o Funções e constantes para C no final do arquivo • Sincronização
o Segmento crítico: exclusão mútua (mutex-lock) o Produtor-Consumidor
o Tipos de mutex Normal
• Deadlock se houver 2 tentativas de uma mesma thread travar Recursivo
• Uma mesma thread pode travar quantas vezes quiser consecutivamente Error-check
• Reporta erro se uma thread tentar travar 2 vezes o Serialização
o Para diminuir a latência, pode-se usar trylock o Variáveis de condição
Permite que uma thread seja bloqueada até que um dado chegue a um determinado estado Sempre tem um mutex associado
• Controle dos atributos de threads, mutex e sincronização o attributes objects
o Propriedades de threads, mutex e variáveis de condição o Funções de manipulação no final do arquivo
• Sincronização composta o Read-Write Locks
Estrutura de dados é lida frequentemente mas escrita pouco Read lock quando outras trheads já estão com read lock
Thread realiza uma condition wait se já existem threads com write lock o Barreiras
Espera todas as threads chegarem Contador + mutex + variáel de condição Linear: O(n)
Log: O(log n) • Programas assíncronos
o Não confie em previsões de tempo o Quando necessário, use sincronização • OpenMP
o Baseado na diretiva #pragma o #pragma omp directive [clause list]
o Executa sequencialmente até encontrar uma diretiva de paralelização #pragma omp parallel [clause list]
o Thread master fica dom ID 0 o Clause list
Paralelização condicional • if (scalar expression)
o Paraleliza se scalar expression for true Grau de concorrência
• num threads (integer expression)
o Número de threads criadas Manipulação de dados
• private (variable list)
o Lista de variáveis privadas • firstprivate (variable list)
o Variáveis inicializadas antes da diretiva parallel • Shared (variable list)
o Variáveis compartilhadas • default (shared) ou default (none)
Redução: Como uma determinada variável das threads vai se combiner depois do trecho paralelo • reduction (operator: private variable list)
o Operadores: +, *, -, &, |, ^, &&, || o Paralelização de for
#pragma omp for [clause list] /* for loop */
Clause list
• schedule(scheduling class[, parameter])
o static, dynamic, guided, and runtime • nowait
o Não espera o término de todas as threads para sair da região do #pragma omp for o Seções
#pragma omp sections [clause list]
• Divide o bloco em várias seções que podem ser executadas em paralelo o Paralelismo aninhado
Ativado usando a variável de ambiente OMP_NESTED o Sincronização
#pragma omp barrier
• Barreira
#pragma omp single [clause list]
• Região executada por apenas uma thread
#pragma omp máster
• Região executada apenas pela thread master #pragma omp critical [(name)]
• Região executada por uma thread por vez
#pragma omp ordered
• Região executada em ordem sequencial Funções no final
Variáveis de ambiente no final • Threads explícitas x Diretivas
o Diretivas são mais fáceis
o Em threads explícitas a movimentação dos dados é mais aparente, o que pode aliviar overheads de transmissão de dados, false shared e contenções
o Threads explícitas permite tratamento direto de condition Waits, locks de diferentes tipos e aumento de flexibilidade na criação de sincronização composta
o Threads explícitas são mais usadas que OpenMP, ferramentas e suporte para elas são mais fáceis de achar
CAP 5 - Modelagem analítica para sistemas paralelos • Modelagem analítica básica
o Programa sequencial é avaliado pelo seu tempo de execução em função do tamanho da entrada
o Programa paralelo depende do tamanho da entrada, número de processadores e comunicação da máquina o Sistema paralelo é a combinação entre um algoritmo paralelo e uma plataforma
o Medidas de tempo Wall clock time
• Do início do primeiro processo até o fim do último • Fontes de overhead em programas paralelos
o Aumentar o número de processadores não diminui o tempo proporcionalmente o Cálculos extras
Dificuldade de paralelização
Repetição de cálculos para se evitar comunicação o Comunicação
o Ociosidade
Carregamento não uniforme Sincronização
Componentes seriais o Contenção
o Tempo de execução serial
Tempo gasto do início ao fim da execução de uma máquina sequencial (TS)
o Tempo de execução paralela
Tempo gasto do início da execução do primeiro processo ao fim da execução do último (TP)
o TALL = pTP : Soma dos tempos de cada processo.
o Overhead total: TO = TALL - TS = pTP - TS
o Speedup: S = TS / TP
Sempre consideramos o programa sequencial mais eficiente 0 < S < p
Superlinear
• Pode ocorrer quando o programa paralelo faz menos trabalho que o sequencial o Exemplo: busca em uma árvore não estruturada
• Pode ocorrer com aumento de cache-hit devido ao aumento de memórias cache o Eficiência: E = S / p
Medida de fração do tempo em que um elemento de processamento é útil 0 < E <= 1
o Custo de um sistema paralelo: TALL = pTP
Custo ótimo: TALL = TS => E = 1
• Efeito da granularidade na performance
o Subdimensionamento: uso de menos processadores que o máximo possível o Comunicação diminui • Escalabilidade o 𝐸𝐸 = 𝑆𝑆 𝑝𝑝= 1 1+𝑇𝑇𝑂𝑂𝑇𝑇𝑆𝑆 o 𝑇𝑇𝑂𝑂 aumenta com p
o Logo E diminui com o aumento de p o Lei de Amdahl
𝑆𝑆(𝑛𝑛) = 1
(1−𝑃𝑃)+𝑆𝑆(𝑃𝑃)𝑃𝑃
o 𝑇𝑇𝑂𝑂 = 𝑇𝑇𝑂𝑂(𝑇𝑇𝑆𝑆, 𝑝𝑝)
o Sistemas paralelos escaláveis
TO aumenta sublinearmente com TS
Aumentando-se o tamanho do problema e o número de processadores simultaneamente, pode-se manter a eficiência constante
Sempre podem ser feitos de custo ótimo o Isoeficiência de escalabilidade
Para um tamanho de problema (W) fixo, E diminui com o aumento de p Em alguns casos, para p cte, E aumenta com o aumento de W
Ambos tem assíntota no infinito
o A escalabilidade é determinada pela razão com que W deve aumentar com respeito a p para E = cte o Quanto menor essa razão, melhor
o Função de isoeficiência: 𝑊𝑊 = 𝑊𝑊(𝑝𝑝) para E = cte o Custo ótimo e a função de isoeficiência
o Lower bound: Ω(𝑝𝑝) o Grau de concorrência
Máximo número de tarefas que podem ser executadas em paralelo em um algoritmo (C) o Tempo mínimo de execução
o Tempo mínimo de execução de custo ótimo
o É importante a escolha da métrica certa quando se quer analisar o desempenho de um programa paralelo (speedup, eficiência, custo...)
• Outras métricas de escalabilidade
o Em sistemas com memória limitada, isso deve ser leado em conta Scaled Speedup (SS)
W aumenta linearmente com p
Sistema escalável: SS aumenta linearmente
Se a eficiência aumenta qse linearmente, então o sistema é escalável • Fração serial (f)
o Aumento de processadores aumenta o overhead de disputas, o que indica uma escalabilidade ruim
FUNÇÕES • MPI
o int MPI_Init(int *argc, char ***argv) Inicializa MPI
o int MPI_Finalize() Finaliza MPI
o int MPI_Comm_size(MPI_Comm comm, int *size) Quantidade de processos
o int MPI_Comm_rank(MPI_Comm comm, int *rank) Número do processo atual (0...p-1)
o int MPI_Send(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm) send
o int MPI_Recv(void *buf, int count, MPI_Datatype datatype, int sourc, int tag, MPI_Comm comm,\ MPI_Status *status)
receive (mensagem pode ser menor ou igual ao tamanho especificado)
o int MPI_Get_count(MPI_Status *status, MPI_Datatype datatype, int *count) Quantidade de dados recebida
o int MPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype senddatatype, int dest, int sendtag,\
void *recvbuf, int recvcount, MPI_Datatype recvdatatype, int source, int recvtag,\ MPI_Comm comm, MPI_Status *status)
Mesma função para enviar e receber
int recvtag, MPI_Comm comm, MPI_Status *status) Mesma função anterior usando apenas um buffer para envio e recebimento
o int MPI_Cart_create(MPI_Comm comm_old, int ndims, int *dims, int *periods, int reorder,\ MPI_Comm *comm_cart)
Cria um comunicador de ndims dimensões em topologia cartesiana o int MPI_Cart_coord(MPI_Comm comm_cart, int rank, int maxdims, int *coords)
Converte o número do processo em coordenadas cartesianas o int MPI_Cart_rank(MPI_Comm comm_cart, int *coords, int *rank)
Converte coordenadas cartesianas no número do processo
o int MPI_Cart_shift(MPI_Comm comm_cart, int dir, int s_step, int *rank_source, int *rank_dest) Desloca os dados em uma determinada direção
o int MPI_Isend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm,\ MPI_Request *request)
send não bloqueante
o int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm,\ MPI_Request *request)
receive não bloqueante
o int MPI_Test(MPI_Request *request, int *flag, MPI_Status *status) Testa se um send ou receive não bloqueante foi finalizado o int MPI_Wait(MPI_Request *request, MPI_Status *status)
Espera o término de send’s e de receive’s o int MPI_Barrier(MPI_Comm comm)
Barreira
o int MPI_Bcast(void *buf, int count, MPI_Datatype datatype, int source, MPI_Comm comm) Broadcast
o int MPI_Reduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int target,\ MPI_Comm comm) Redução Operações pré-definidas: • MPI_MAX o Máximo • MPI_MIN o Mínimo • MPI_SUM o Soma • MPI_PROD o Produto • MPI_LAND o AND lógico • MPI_BAND
o AND bit a bit
• MPI_LOR o OR lógico • MPI_BOR o OR bit a bit • MPI_LXOR o XOR lógico • MPI_BXOR
o XOR bit a bit • MPI_MAXLOC
o Mínima localização do máximo • MPI_MINLOC
o Mínima localização do mínimo
o int MPI_Allreduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op,\ MPI_Comm comm)
Redução com resultado para todos os processos
o int MPI_Scan(void *sendbuf, void *recvbuf, int count,MPI_Datatype datatype, MPI_Op op,\ MPI_Comm comm)
Redução cumulativa
o int MPI_Gather(void *sendbuf, int sendcount, MPI_Datatype senddatatype, void *recvbuf, int recvcount,\ MPI_Datatype recvdatatype, int target, MPI_Comm comm)
Junta dados em um só processo
o int MPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype senddatatype, void *recvbuf, int recvcount,\ MPI_Datatype recvdatatype, MPI_Comm comm)
Junta os dados em todos os processos
o int MPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype senddatatype, void *recvbuf, int recvcount, MPI_Datatype recvdatatype, int source, MPI_Comm comm)
Manda dados para todos os processos (uma parte para cada)
MPI_Datatype recvdatatype, MPI_Comm comm) Envia dados de todos os processos para todos os processos
o int MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm *newcomm) Divide um comunicador
o int MPI_Cart_sub(MPI_Comm comm_cart, int *keep_dims, MPI_Comm *comm_subcart) Divide um comunicador cartesiano
• Pthreads
o int pthread_create(pthread_t *thread_handle, const pthread_attr_t *attribute, void * (*thread_function)(void *), void *arg)
Cria uma thread executendo uma função o int pthread_join(pthread_t thread, void **ptr);
Espera pelo término da execução de uma thread o int pthread_mutex_lock(pthread_mutex_t *mutex_lock);
Trava um mutex
o int pthread_mutex_unlock (pthread_mutex_t *mutex_lock); Destrava um mutex
o int pthread_mutex_init (pthread_mutex_t *mutex_lock, const pthread_mutexattr_t *lock_attr); Inicializa um mutex
o int pthread_mutex_trylock (pthread_mutex_t *mutex_lock); Tenta travar e retorna o sucesso ou não da operação
o int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); Espera at´q que cond seja true
o int pthread_cond_signal(pthread_cond_t *cond); Marca uma condição
o int pthread_cond_broadcast(pthread_cond_t *cond); Broadcast de uma condição
o int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr); Inicia uma variável de condição
o int pthread_cond_destroy(pthread_cond_t *cond); Destrói uma variável de condição
o int pthread_attr_init(pthread_attr_t *attr); Inicializa um attribute object de thread o int pthread_attr_destroy(pthread_attr_t *attr);
Destrói um attribute object de thread
o int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate); o int pthread_attr_setguardsize_np(pthread_attr_t *attr, size_t guardsize); o int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
Configura o tamanho da pilha
o int pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched); o int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);
o int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param); o int pthread_mutexattr_init(pthread_mutexattr_t *attr);
Inicializa um attribute object de mutex
o int pthread_mutexattr_destroypthread_mutexattr_t *attr); Destrói um attribute object de thread
o pthread_mutexattr_settype_np (pthread_mutexattr_t *attr, int type); Configura o tipo de mutex especificado
Type:
• PTHREAD_MUTEX_NORMAL_NP • PTHREAD_MUTEX_RECURSIVE_NP • PTHREAD_MUTEX_ERRORCHECK_NP • OpenMP
o void omp_set_num_threads (int num_threads); Configura número padrão de threads o int omp_get_num_threads ();
Número de threads em uma região parallel o int omp_get_max_threads ();
Máximo de trheads disponíveis o int omp_get_thread_num ();
Número da thread atual o int omp_get_num_procs ();
Número de processos disponíveis o int omp_in_parallel();
Verifica se está em uma região paralela o void omp_set_dynamic (int dynamic_threads);
Configura se as threads disponíveis podem ser ajustadas em tempo de execução o int omp_get_dynamic ();
Verifica se as threads disponíveis podem ser ajustadas em tempo de execução o void omp_set_nested (int nested);
Configura paralelismo aninhado o int omp_get_nested ();
Verifica se o paralelismo aninhado está ativado o void omp_init_lock (omp_lock_t *lock);
Inicializa um lock
o void omp_destroy_lock (omp_lock_t *lock); Destrói um lock
o void omp_set_lock (omp_lock_t *lock); Trava um lock
o void omp_unset_lock (omp_lock_t *lock); Destrava um lock
o int omp_test_lock (omp_lock_t *lock);
Testa se um lock está travado sem travá-lo o
CONSTANTES • MPI
o MPI_SUCCESS
Operação realizada com sucesso o MPI_COMM_WORLD
Comunicador que inclui todos os processos o MPI_TAG_UB
Valor máximo permitido para a tag o MPI_ANY_SOURCE
Aceita qualquer fonte o MPI_ANY_TAG
Aceita qualquer tag
TIPOS DE DADOS • MPI
o MPI_CHAR
signed char o MPI_SHORT
signed short int o MPI_INT
signed int o MPI_LONG
signed long int o MPI_UNSIGNED_CHAR unsigned char o MPI_UNSIGNED_SHORT
unsigned short int o MPI_UNSIGNED
unsigned int o MPI_UNSIGNED_LONG
unsigned long int o MPI_FLOAT float o MPI_DOUBLE double o MPI_LONG_DOUBLE long double o MPI_BYTE
Tipo de dados referente a 1 byte o MPI_PACKED
Conjunto de dados não contíguos o MPI_Status
{ int MPI_SOURCE, MPI_TAG, MPI_ERROR; }; Status de recebimento o MPI_2INT pair de int o MPI_SHORT_INT short e int o MPI_LONG_INT long e int o MPI_LONG_DOUBLE_INT long double e int o MPI_FLOAT_INT float e int o MPI_DOUBLE_INT double e int VARIÁVEIS DE AMBIENTE • OpenMP o OMP_NUM_THREADS
Número de threads default o OMP_SET_DYNAMIC
Determina se o número de threads pode ser alterado dinamicamente o OMP_NESTED
Configura o paralelismo aninhado o OMP_SCHEDULE
