Dependência verdadeira de dados Dependência de recursos Dependência de ramo In-order issue Dynamic issue Vertical waste Horizontal waste

20 

Loading.... (view fulltext now)

Loading....

Loading....

Loading....

Loading....

Texto

(1)

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

(2)

• 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

(3)

• 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

(4)

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

(5)

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

(6)

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

(7)

• 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

(8)

• 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

(9)

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

(10)

 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

(11)

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

(12)

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

(13)

• 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)

(14)

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

(15)

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

(16)

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

(17)

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)

(18)

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);

(19)

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

(20)

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

Imagem

Referências

temas relacionados :