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 comunso Dependênciaso 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çãoo Análise em tempo de execução e empacotamento das instruções que podem ser executadas juntaso Hardware mais simpleso Predições são mais complicadas nesse casoo 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 mesmoo Largura de Banda: Taxa em que os dados são mandados da memória para o processador

Solução da latência: Cacheso Pequenao Baixa latência e alta largura de bandao 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 processoso 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 Mais barato

Modelos de comunicação em plataformas paralelaso 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 idealo 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 writeo Common: Escreve somente se todos os valores são idênticoso Arbitrary: Escreve o dado de um processador aleatoriamente escolhidoo Priority: Segue uma ordem de prioridade pré-determinadao 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 switcheso 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 paraleloso Transmite dados entre processadores e para a memóriao 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 Problema: Gargalo

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áticaso 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 multiprocessadoreso Hardware adicional para manter a coerência entre as cópias distribuídas pela rede

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

Estadoso Compartilhado: Várias cópias válidas distribuídaso Inválido: O dado é inválido, necessária nova leiturao 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

Overhead significante

Custo de comunicação em máquinas paralelaso Junto com ociosidade e contenção, é o maior overhead de programas paraleloso 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 pequenoo Modelo simplificado de custo de passagem de mensagens

Th é pequeno e m é grande

Modelos de custo para máquinas memória compartilhadao Caches com memória finita resultam em cache thrashingo Overheads por invalidações e atualizações são difíceis de quantificaro Localidade espacial é difícil de modelaro Falso compartilhamento e contenção são difíceis de modelar

Mecanismos de roteamento para redes de interconecçãoo Roteamento pode evitar deadlockso Roteamento pode evitar hot-spots: pacote é inicialmente enviado para um destino aleatório

Técnicas de mapeamento em grafoso Embutir um padrão de comunicação conhecido em uma dada topologia de interconexãoo Portar um algoritmo de uma topologia para outrao 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 1o Incorporação de uma matriz em um hipercubo

Exemplo

As métricas são todas 1

o Incorporação de uma matriz em um array linear

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ênciaso Decompor o problema em tarefas que podem ser executadas em //o Existem várias maneiras de decompor um problemao Ilustração: grafoso 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íticoo Caminho: sequência de processamentoo 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 problemao A performance também é limitada pela troca de informações entre tarefas

Grafo de interação entre tarefaso Comunicação entre tarefaso Grafo de dependência: dependências de controleo Grafo de interação: dependência de dadoso 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 processoso Grafo de interação: Garante mínimo de interação

Minimizar o tempo de execução em paraleloo Mapeamento de tarefas independentes para diferentes processoso Tarefas do caminho crítico devem ir o mais rápido possível para os processadoreso Mapeamento de tarefeas com densa comunicação para o mesmo processoo Conflitantes entre si

Técnicas de decomposiçãoo 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 eleo Decomposição exploratória

Teste de todas as possibilidades até encontrar a soluçãoo 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-backo 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 especulativao 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 tarefaso Interações estáticas: Conhecidas a priori. Relativamente mais simples de codificar nos programaso Interações dinâmicas: Não são conhecidas a priori. Mais difícil de codificaro 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 definidaso Somente leitura: Somente leitura dos dados associados a outras tarefaso Leitura e escrita: Lê e pode escrever sobre os dados. Mais difíceis de codificaro Interação One-way: Pode ser iniciado e finalizado por uma só das tarefas. Mais difíceis de ser codificadaso Interação Two-way: Requer participação das duas tarefas

Técnicas de mapeamento de tarefas para processoso Minimizar overheads de comunicação e ociosidadeo 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 escravoso Mestre pode se tronar um gargaloo Processo pode pegar algumas tarefas de uma vez

Distribuído: o Cada processo mande e recebe trabalho de outroso Quem inicia a transferência de trabalho?o Quanto trabalho é transferido?o Quando uma transferência é desencadeada?

Minimização de overheads de interaçãoo Maximizar a localidade de dadoso Minimizar o volume de troca de dadoso Minimizar a frequência de interaçõeso Minimizar contenções e hot-spotso Overlap de interações e instruções o Overlap de interações e interaçõeso Uso de comunicação em grupo ao invés de P2P

Modelos de algoritmos paraleloso Modelo de paralelismo de dados: Tarefas são estaticamente mapeada a processos e cada tarefa faz operações

similares em dados diferenteso 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çãoo Modelo de mestres e escravos: Alguns processos geram trabalho e alocam para os trabalhadores estática ou

dinamicamenteo 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 Mensagemo p processos, cada um com a sua memóriao Dados explicitamente particionadoso 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 bufferizadaso send retorna apenas depois de todos os dados serem transferidoso Problemas: possibilidade de deadlock e latênciao Em operações bufferizadas, a função retorna depois de ter copiado os dados pro buffer

Operações bloqueantes bufferizadaso Solução para a latênciao Ainda há possibilidade de deadlock

Operações não bloqueanteso Retorna das funções antes de realmente ser seguroo Geralmente acompanhado de operação check-statuso Quando bem utilizado, pode sobrepor comunicação com cálculos para se evitarem latênciaso Bibliotecas de passagem de mensagem geralmente tem as funções bloqueantes e não bloqueantes

Protocolos de send e receive

MPI: Message Passing Interfaceo Biblioteca de rotinas para passagem de mensagenso C e Fortrano Funções e constantes para C no final do arquivo

Comunicadoreso 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_Commo Usados como argumentos em todas as funções de comunicaçãoo Cada processo pode pertencer a vários comunicadores

Topologias e incorporaçõeso MPI permite organizações dos processadores em matrizes k-dimensionaiso 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 comandoo Barreirao Broadcasto Redução

CAP 7 – Plataformas de memória compartilhada Modelos de programação

o Concorrência e sincronizaçãoo Dados privados por padrão. Pode ser alteradoo Toda memória é global

Threadso Pilha de chamada de função é local para cada threado 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çãoo Segmento crítico: exclusão mútua (mutex-lock)o Produtor-Consumidoro 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çãoo Para diminuir a latência, pode-se usar trylocko 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çãoo attributes objectso Propriedades de threads, mutex e variáveis de condiçãoo Funções de manipulação no final do arquivo

Sincronização compostao 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íncronoso Não confie em previsões de tempoo Quando necessário, use sincronização

OpenMPo Baseado na diretiva #pragmao #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 0o 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 foro 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 Diretivaso Diretivas são mais fáceiso 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çõeso Threads explícitas permite tratamento direto de condition Waits, locks de diferentes tipos e aumento de

flexibilidade na criação de sincronização compostao 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 entradao Programa paralelo depende do tamanho da entrada, número de processadores e comunicação da máquinao Sistema paralelo é a combinação entre um algoritmo paralelo e uma plataformao Medidas de tempo

Wall clock time Do início do primeiro processo até o fim do último

Fontes de overhead em programas paraleloso Aumentar o número de processadores não diminui o tempo proporcionalmenteo Cálculos extras

Dificuldade de paralelização Repetição de cálculos para se evitar comunicação

o Comunicaçãoo Ociosidade

Carregamento não uniforme

Sincronização Componentes seriais

o Contenção

Métricas de performanceo 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 sequencialo Exemplo: busca em uma árvore não estruturada

Pode ocorrer com aumento de cache-hit devido ao aumento de memórias cacheo 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 performanceo Subdimensionamento: uso de menos processadores que o máximo possívelo Comunicação diminui

Escalabilidade

oE=S

p= 1

1+T OT S

o T O aumenta com po Logo E diminui com o aumento de po Lei de Amdahl

S (n )= 1

(1−P )+ PS(P)

o T O=T O(T S , p)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 ótimoo 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, melhoro W é o número de operações associadas com o melhor algoritmo sequencial

o Função de isoeficiência: W=W ( p) para E = cteo Custo ótimo e a função de isoeficiência

o Lower bound: Ω( p)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 escalabilidadeo Em sistemas com memória limitada, isso deve ser leado em contaScaled 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)

sendo 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 recebero int MPI_Sendrecv_replace(void *buf, int count, MPI_Datatype datatype, int dest, int sendtag, int source,\

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 cartesianao int MPI_Cart_coord(MPI_Comm comm_cart, int rank, int maxdims, int *coords)

Converte o número do processo em coordenadas cartesianaso int MPI_Cart_rank(MPI_Comm comm_cart, int *coords, int *rank)

Converte coordenadas cartesianas no número do processoo 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çãoo 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 bloqueanteo int MPI_Test(MPI_Request *request, int *flag, MPI_Status *status)

Testa se um send ou receive não bloqueante foi finalizadoo int MPI_Wait(MPI_Request *request, MPI_Status *status)

Espera o término de send’s e de receive’so int MPI_Barrier(MPI_Comm comm)

Barreirao int MPI_Bcast(void *buf, int count, MPI_Datatype datatype, int source, MPI_Comm comm)

Broadcasto 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_MAXo Máximo

MPI_MINo Mínimo

MPI_SUMo Soma

MPI_PRODo Produto

MPI_LANDo AND lógico

MPI_BANDo AND bit a bit

MPI_LORo OR lógico

MPI_BORo OR bit a bit

MPI_LXORo XOR lógico

MPI_BXORo XOR bit a bit

MPI_MAXLOCo Mínima localização do máximo

MPI_MINLOCo 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 processoso 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ó processoo 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 processoso 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)

o int MPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype senddatatype, void *recvbuf, int recvcount, \MPI_Datatype recvdatatype, MPI_Comm comm)

Envia dados de todos os processos para todos os processoso int MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm *newcomm)

Divide um comunicadoro int MPI_Cart_sub(MPI_Comm comm_cart, int *keep_dims, MPI_Comm *comm_subcart)

Divide um comunicador cartesiano

Pthreadso 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çãoo int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

Inicia uma variável de condiçãoo int pthread_cond_destroy(pthread_cond_t *cond);

Destrói uma variável de condiçãoo int pthread_attr_init(pthread_attr_t *attr);

Inicializa um attribute object de threado int pthread_attr_destroy(pthread_attr_t *attr);

Destrói um attribute object de threado 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 pilhao 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 mutexo int pthread_mutexattr_destroypthread_mutexattr_t *attr);

Destrói um attribute object de threado 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

OpenMPo void omp_set_num_threads (int num_threads);

Configura número padrão de threadso int omp_get_num_threads ();

Número de threads em uma região parallelo int omp_get_max_threads ();

Máximo de trheads disponíveiso int omp_get_thread_num ();

Número da thread atualo int omp_get_num_procs ();

Número de processos disponíveiso int omp_in_parallel();

Verifica se está em uma região paralelao void omp_set_dynamic (int dynamic_threads);

Configura se as threads disponíveis podem ser ajustadas em tempo de execuçãoo int omp_get_dynamic ();

Verifica se as threads disponíveis podem ser ajustadas em tempo de execuçãoo void omp_set_nested (int nested);

Configura paralelismo aninhadoo int omp_get_nested ();

Verifica se o paralelismo aninhado está ativadoo void omp_init_lock (omp_lock_t *lock);

Inicializa um locko void omp_destroy_lock (omp_lock_t *lock);

Destrói um locko void omp_set_lock (omp_lock_t *lock);

Trava um locko void omp_unset_lock (omp_lock_t *lock);

Destrava um locko int omp_test_lock (omp_lock_t *lock);

Testa se um lock está travado sem travá-loo

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 recebimentoo MPI_2INT

pair de into MPI_SHORT_INT

short e into MPI_LONG_INT

long e into MPI_LONG_DOUBLE_INT

long double e into MPI_FLOAT_INT

float e into MPI_DOUBLE_INT

double e int

VARIÁVEIS DE AMBIENTE

OpenMPo OMP_NUM_THREADS

Número de threads defaulto OMP_SET_DYNAMIC

Determina se o número de threads pode ser alterado dinamicamenteo OMP_NESTED

Configura o paralelismo aninhadoo OMP_SCHEDULE

Agendamento de tarefas para for