Bacharelado em Cincia da Computao

DCC-IM / UFRJ

Programao Paralela e
Distribuda - OpenMP
Um curso prtico
Gabriel P. Silva

Roteiro
Introduo ao OpenMP
Regies Paralelas
Diretivas de Compartilhamento de
Trabalho
Laos Paralelos
Sincronizao
OpenMP 2.0

Introduo ao OpenMP

Breve Histria do OpenMP

Existe uma falta histrica de padronizao nas
diretivas para compartilhamento de memria.
Cada fabricante fazia a sua prpria.
O frum OpenMP foi iniciado pela Digital, IBM,
Intel, KAI e SGI. Agora inclui todos os grandes
fabricantes.
O padro OpenMP para Fortran foi liberado em
Outubro de 1997. A verso 2.0 foi liberada em
Novembro de 2000.
O padro OpenMP C/C++ foi liberado em Outubro
de 1998. A verso 2.0 foi liberada em Maro de
2002.

Sistemas de Memria Compartilhada

O OpenMP foi projetado para a programao de
computadores paralelos com memria
compartilhada.
A facilidade principal a existncia de um nico
espao de endereamento atravs de todo o
sistema de memria.
Cada processador pode ler e escrever em
todas as posies de memria.
Um espao nico de memria
Dois tipos de arquitetura:
Memria Compartilhada Centralizada

Memria Compartilhada Distribuda

Sistemas de Memria Compartilhada

Sun Enterprise/SunFire, Cray

SV1, Compaq ES, multiprocessor
PCs, nodes of IBM SP, NEC SX5

Sistemas de Memria Compartilhada

A maioria dos sistemas de memria compartilhada
distribuda so clusters:

SGI Origin, HP Superdome, Compaq GS,

Earth Simulator, ASCI White

Threads
Uma thread um processo peso leve.
Cada thread pode ser seu prprio fluxo de
controle em um programa.
As threads podem compartilhar dados com
outras threads, mas tambm tm dados
privados.
As threads se comunicam atravs de uma rea
de dados compartilhada.
Uma equipe de threads um conjunto de
threads que cooperam em uma tarefa.
A thread master responsvel pela
coordenao da equipe de threads.

Threads
Thread 1
PC

Dados
Privados

Thread 2
PC

Dados
Privados

Thread 3
PC

Dados
Privados

Dados Compartilhados

Diretivas e Sentinelas
Uma diretiva uma linha especial de cdigo
fonte com significado especial apenas para
determinados compiladores.
Uma diretiva se distingue pela existncia de
uma sentinela no comeo da linha.
As sentinelas do OpenMP so:

Fortran: !$OMP (ou C$OMP ou *$OMP)

C/C++: #pragma omp

Regio Paralela
A regio paralela a estrutura bsica de
paralelismo no OpenMP.
Uma regio paralela define uma seo do
programa.
Os programas comeam a execuo com uma
nica thread ( a thread master).
Quando a primeira regio paralela
encontrada, a thread master cria uma equipe
de threads (modelo fork/join).

Regio Paralela
Cada thread executa as sentenas que esto
dentro da regio paralela.
No final da regio paralela, a thread master
espera pelo trmino das outras threads e
continua ento a execuo de outras
sentenas.

Regio Paralela

Dados Privados e Compartilhados

Dentro de uma regio paralela, as variveis
podem ser privadas ou compartilhadas.
Todas as threads vem a mesma cpia das
variveis compartilhadas.
Todas as threads podem ler ou escrever nas
variveis compartilhadas.
Cada thread tem a sua prpria cpia de
variveis privadas: essas so invisveis para as
outras threads.
Uma varivel privada pode ser lida ou escrita
apenas pela sua prpria thread.

Laos Paralelos
Os laos so a principal fonte de paralelismo em
muitas aplicaes.
Se as iteraes de um lao so independentes
(podem ser executadas em qualquer ordem),
ento podemos compartilhar as iteraes entre
threads diferentes.
Por exemplo, se tivermos duas threads e o lao:
for (i = 0; i<100; i++){
a[i] = a[i] + b[i];}
ns podemos fazer as iteraes 0-49 em uma
thread e as iteraes 50-99 na outra.

Sincronizao
H necessidade de assegurar que as aes nas
variveis compartilhadas ocorram na maneira
correta: por ex.: a thread 1 deve escrever na
varivel A antes da thread 2 faa a sua leitura,
ou a thread 1 deve ler a varivel A antes que a
thread 2 faa sua escrita.
Note que as atualizaes para variveis
compartilhadas (p.ex. a = a + 1) no so
atmicas! Se duas threads tentarem fazer isto
ao mesmo tempo, uma das atualizaes pode
ser perdida.

Exemplo de Sincronizao
Thread 1

Thread 2

Programa

load a
add a 1
store a

load a
add a 1
store a

Dados
Privados

10
11

Dados
Compartilhados

10
11

10
11

Redues
Uma reduo produz um nico valor a partir de
operaes associativas como soma,
multiplicao, mximo, mnimo, e , ou. Por
exemplo:
b = 0;
for (i=0; i<n; i++){
b += a[i];}
Permitindo que apenas uma thread por vez
atualize a varivel b removeria todo o
paralelismo.
Ao invs disto, cada thread pode acumular sua
prpria cpia privada, ento essas cpias so
reduzidas para dar o resultado final.

Regies Paralelas

Diretiva para Regies Paralelas

Um cdigo dentro da regio paralela
executado por todas as threads.
Sintaxe:
C/C++:
#pragma omp parallel
{
block
}

10

Diretiva para Regies Paralelas

Exemplo:
call fred()
#pragma omp parallel
{
call billy()
}
call daisy()

Funes teis
Freqentemente so utilizadas para encontrar o
nmero de threads que esto sendo utilizadas.
C/C++:
#include <omp.h>
int omp_get_num_threads(void);
Nota importante: retorna 1 se a chamada fora
de uma regio paralela.

11

Funes teis
Tambm so utilizadas para encontrar o
nmero atual da thread em execuo.
C/C++:
#include <omp.h>
int omp_get_thread_num(void);
Retorna valores entre 0 e
omp_get_num_threads() - 1

Exemplo
...
printf (Alo paralelo das threads: \n);
#pragma omp parallel
{
printf(%d \n, omp_get_thread_num());
}
printf(de volta ao mundo seqencial \n);
...

12

Clusulas
Especificam informao adicional na diretiva de
regio paralela:
C/C++:
#pragma omp parallel [clausulas]
Clusulas so separadas por vrgula ou espao
no Fortran, e por espao no C/C++.

Variveis Privadas e Compartilhadas

Dentro de uma regio paralela as variveis
podem ser compartilhadas (todas as threads
vem a mesma cpia) ou privada (cada thread
tem a sua prpria cpia).
Clusulas SHARED, PRIVATE e DEFAULT
C/C++:
shared(list)
private(list)
default(shared|none)

13

Variveis Privadas e Compartilhadas

Exemplo: cada thread inicia a sua
prpria coluna de uma matriz
compartilhada:
#pragma omp parallel \
default(none) private (i, myid) \
shared(a,n)
myid = omp_get_thread_num();
for(i = 0; i < n; i++){
a[i][myid] = 1.0;
}

0 1 2 3

/* end parallel */

Variveis Privadas e Compartilhadas

Como decidir quais variveis devem ser
compartilhadas e quais privadas?
A maioria das variveis so compartilhadas.
O ndices dos laos so privados.
Variveis temporrias dos laos so
compartilhadas.
Variveis apenas de leitura compartilhadas
Matrizes principais Compartilhadas
Escalares do tipo write-before-read
usualmente privados.
s vezes a deciso deve ser baseada em fatores
de desempenho.

14

Valor inicial de variveis privadas

Variveis privadas no tem valor inicial no incio
da regio paralela.
Para dar um valor inicial deve-se utilizar a
clusula FIRSTPRIVATE:

C/C++:
firstprivate(list)

Valor inicial de variveis privadas

Exemplo:
b = 23.0;
.....
#pragma omp parallel firstprivate(b) private(i,myid)
{
myid = omp_get_thread_num();
for (i=0; i<n; i++){
b += c[myid][i];
}
c[myid][n] = b;
}

15

Redues
Uma reduo produz um nico valor a partir de
operaes associativas como adio,
multiplicao, mximo, mnimo, e, ou.
desejvel que cada thread faa a reduo em
uma cpia privada e ento reduzam todas elas
para obter o resultado final.
Uso da clusula REDUCTION:
C/C++:
reduction(op:list)

Redues
Onde op pode ser:

Operao
Valor Inicial
+ --> soma
0
- --> subtrao
0
* --> multiplicao
1
& --> e
todos os bits em 1
| --> ou
0
^ --> equiv. lgica
0
&& --> not equiv. lgica
1
|| --> mx
0

16

Redues
Exemplo:
b = 0;
#pragma parallel private (i, myid) reduction (+:b)
myid = omp_get_thread_num();
for (i = 0; i < n; i++)
{
b = b + c[i][myid];
}
/* omp end parallel */
/* b retorna a soma de todos os elementos da matriz
*/

Clusula IF
Podemos fazer a diretiva da regio paralela ser
condicional.
Pode ser til se no houver trabalho suficiente
para tornar o paralelismo interessante.
C/C++:
if (scalar expression)

17

Clusula IF
Exemplo:
#pragma omp parallel if (tasks > 1000)
{
while(tasks > 0) donexttask();
}

Diretivas para
Compartilhamento de
Trabalho

18

Diretivas para Compartilhamento de

Trabalho
Diretivas que aparecem dentro de uma regio
paralela e indicam como o trabalho deve ser
compartilhado entre as threads.
Laos do/for paralelos
Sees paralelas
Diretivas MASTER e SINGLE

Laos do/for paralelos

Laos so a maior fonte de paralelismo na
maioria dos cdigos. Diretivas paralelas de laos
so portanto muito importantes!
Um lao do/for paralelo divide as iteraes do
lao entre as threads.
Apresentaremos aqui apenas a forma bsica.
Sintaxe C/C++:
#pragma omp for [clausulas]
for loop

19

Laos do/for paralelos

Sem clusulas adicionais, a diretiva DO/FOR
usualmente particionar as iteraes o mais
igualmente possvel entre as threads.
Contudo, isto dependente de implementao
e ainda h alguma ambigidade:
Ex:. 7 iteraes, 3 threads. Pode ser
particionado como 3+3+1 ou 3+2+2

Laos do/for paralelos

Como voc pode dizer se um lao paralelo ou
no?
Teste: se o lao d o mesmo resultado se
executado na ordem inversa ento ele quase
certamente paralelo.
Desvios para fora do lao no so permitidos.
Exemplos:
1.
for (i=1; i< n; i++)
{
a[i] = 2*a[i-1];
}

20

Laos do/for paralelos

2.
ix = base;
for (i=0; i < n; i++) {
a[ix] = a[ix]* b[i];
ix = ix + stride;
}
3.
for (i=0; i<n; i++){
b[i]= (a[i] - a[i-1)])*0.5;
}

Exemplo de Laos Paralelos

Exemplo:
#pragma omp parallel
#pragma omp for
for (i=1; i <=n; i++){
b[i] = (a[i]- a[i-1])*0.5;
}
/* end parallel for */

21

A diretiva DO/FOR paralela

Esta construo to comum que existe uma
forma que combina a regio paralela e a
diretiva do/for:
Sintaxe C/C++:
#pragma omp parallel for [clausulas]
for loop

Exemplo (saxpy)
#pragma omp parallel for
for (i=0; i < n; i++)
{
z[i] = a * x[i] + y;
}
Este exemplo realiza a operao multiply-add,
que uma multiplicao de um vetor por um
valor que em seguida somado a outro.

22

Clusulas
A diretiva DO/FOR pode ter clusulas PRIVATE e
FIRSTPRIVATE as quais se referem ao escopo do
lao.
Note que a varivel de ndice do lao paralelo
PRIVATE por padro (mas outros ndices de
laos no so).
A diretiva PARALLEL DO/FOR pode usar todas as
clusulas disponveis para a diretiva PARALLEL.

Sees Paralelas
Permitem blocos separados de cdigo serem
executados em paralelo (ex. Diversas
subrotinas independentes)
No escalvel: o cdigo fonte deve determinar
a quantidade de paralelismo disponvel.
Raramente utilizada, exceto com paralelismo
aninhado (que no ser abordado aqui).

23

Sees Paralelas
C/C++:
#pragma omp sections [clausulas]
{
[ #pragma omp section ]
structured-block
[ #pragma omp section
structured-block
...]
}

Sees Paralelas
Exemplo:
#pragma omp parallel
#pragma omp sections
{
#pragma omp section
init(x);
#pragma omp section
init(y);
#pragma omp section
init(z);
}

24

Sees Paralelas
Diretivas SECTIONS podem ter as clusulas
PRIVATE, FIRSTPRIVATE, LASTPRIVATE.
Cada seo deve conter um bloco estruturado:
no pode haver desvio para dentro ou for a de
uma seo.
Forma abreviada C/C++:
#pragma omp parallel sections [clausulas]
{
...
}

Diretiva SINGLE
Indica que um bloco de cdigo deve ser
executado apenas por uma thread.
A primeira thread que alcanar a diretiva
SINGLE ir executar o bloco.
Outras threads devem esperar at que o bloco
seja executado.
Sintaxe C/C++:
#pragma omp single [clausulas]
structured block

25

Diretiva SINGLE
Exemplo:
#pragma omp parallel
{
setup(x);
#pragma omp single
{
input(y);
}
work(x,y);
}

Diretiva SINGLE
A diretiva SINGLE pode ter clusulas PRIVATE e
FIRSTPRIVATE.
A diretiva deve conter um bloco estruturado:
no pode haver desvio dentro ou para fora do
dele.

26

Diretiva MASTER
Indica que um bloco seve ser executado apenas
pela thread master (thread 0).
Outras threads pulam o bloco e continuam a
execuo: diferente da diretiva SINGLE neste
aspecto.
Na maior parte das vezes utilizada para E/S.
Sintaxe C/C++:
#pragma omp master
structured block

Mais sobre laos

paralelos do/for

27

Clusula LASTPRIVATE
Algumas vezes necessrio que se saiba o valor
que uma varivel privada ter na sada de um
lao (normalmente indefinido)
Sintaxe:
C/C++: lastprivate(list)
Tambm se aplica diretiva sections (a varivel
tem um valor atribudo a ela a ltima seo.)

Clusula LASTPRIVATE
Exemplo:
#pragma omp parallel
#pragma for lastprivate (i)
for (i=0,func(l,m,n)){
d[i]=d[i]+e*f[i];
}
ix = i-1;
...
/* pragma end for */

28

Clusula SCHEDULE
A clusula SCHEDULE permite uma variedade de
opes por especificar quais iteraes dos laos
so executadas por quais threads.
Sintaxe:
C/C++: schedule (kind[, chunksize])
onde kind pode ser
STATIC, DYNAMIC, GUIDED ou RUNTIME
e chunksize uma expresso inteira com valor
positivo.
Ex.: #pragma for schedule(DYNAMIC,4)

Escalonamento STATIC
Sem a especificao de chunksize, o espao de
iterao dividido em pedaos
(aproximadamente) iguais e cada pedao
atribudo a cada thread (escalonamento block).
Se o valor de chunksize especificado, o espao
de iterao dividido em pedaos, cada um com
chunksize iteraes, e os pedaos so atribudos
ciclicamente a cada thread (escalonamento
block cyclic)

29

Escalonamento STATIC

Escalonamento DYNAMIC
O escalonamento DYNAMIC divide o espao de
iterao em pedaos de tamanho chunksize, e os
atribui para as threads com uma poltica firstcome-first-served.
i.e. se uma thread terminou um pedao, ela
recebe o prximo pedao na lista.
Quando nenhum valor de chunksize
especificado, o valor padro 1.

30

Escalonamento GUIDED
O escalonamento GUIDED similar ao
DYNAMIC, mas os pedaos iniciam grandes e se
tornam pequenos exponencialmente.
O tamanho do prximo pedao (a grosso
modo) o nmero de iteraes restantes dividido
pelo nmero de threads.
O valor chunksize especifica o tamanho mnimo
dos pedaos.
Quando nenhum valor de chunksize
especificado, o padro 1.

Escalonamentos
DYNAMIC e GUIDED

31

Escalonamento RUNTIME
O escalonamento RUNTIME delega a escolha do
escalonamento para a execuo, quando
determinado pelo valor da varivel de ambiente
OMP_SCHEDULE.
$ export OMP_SCHEDULE=guided,4
ilegal especificar um valor de chunksize com o
escalonamento RUNTIME.

Escolhendo um Escalonamento
Quando utilizar um escalonamento?
STATIC: melhor para laos balanceados
menor sobrecarga.
STATIC,n : melhor para laos com
desbalanceamento suave.
DYNAMIC : til se as iteraes tem grande
variao de carga, mas acaba com a localidade
espacial dos dados.
GUIDED: freqentemente menos cara que
DYNAMIC, mas tenha cuidado com laos onde
as primeiras iteraes so as mais caras!
Use RUNTIME para experimentao adequada.

32

Diretiva ORDERED
Pode especificar o cdigo dentro de um lao que
dever ser executado na ordem em que seria se
executado seqencialmente.

Sintaxe:
C/C++: #pragma omp ordered
structured block
Pode aparecer dentro de uma diretiva DO/FOR
que tiver a clusula ORDERED especificada.

Diretiva ORDERED
Exemplo:
#pragma omp parallel for ordered
for (j =0; j < n; j++)
...
#pragma omp ordered
printf (%d %d \n, j,count[j])
...

33

Sincronizao

O que necessrio?
necessrio sincronizar aes em variveis
compartilhadas.
necessrio assegurar a ordenao correta de
leituras e escritas.
necessrio proteger a atualizao de variveis
compartilhadas (no atmicas por padro).

34

Diretiva BARRIER
Nenhuma thread pode prosseguir alm de ma
barreira at que todas as outras threads
chegarem at ela.
Note que h uma barreira implcita no final das
diretivas DO/FOR, SECTIONS e SINGLE.
Sintaxe:
C/C++:
#pragma omp barrier
Ou nenhuma ou todas as threads devem
encontrar a barreira: seno DEADLOCK!!

Diretiva BARRIER
Exemplo:
#pragma omp parallel private(i,myid,neighb)
{
myid = omp_get_thread_num();
neighb = myid 1;
if (myid == 0) neighb = omp_get_num_threads()-1;
...
a[myid] = a[myid]*3.5;
#pragma omp barrier
b[myid] = a[neighb] + c
...
}

Barreira requerida para forar a sincronizao

em a

35

Clusula NOWAIT
A clusula NOWAIT pode ser usada para
suprimir as barreiras implcitas no final das
diretivas DO/FOR, SECTIONS e SINGLE.
(Barreiras so caras!)
Sintaxe:
C/C++: #pragma omp for nowait

for loop
Igualmente para SECTIONS e SINGLE.

Clusula NOWAIT
Exemplo: Dois laos sem dependncias
#pragma omp parallel
{
#pragma omp for nowait
for (j=0; j < n; j++){
a[j] = c * b[j];
}
#pragma omp for nowait
for (i=0; i < m; i++){
x[i] = sqrt(y[i]) * 2.0;
}
}

36

Clusula NOWAIT
Use com EXTREMO CUIDADO!
muito fcil remover uma barreira que
necessria.
Isto resulta no pior tipo de erro:
comportamento no-determinstico da
aplicao (s vezes o resultado correto, s
vezes no, o comportamento se altera no
depurador, etc.).
Pode ser um bom estilo de codificao colocar a
clusula NOWAIT em todos os lugares e fazer
todas as barreiras explicitamente.

Clusula NOWAIT
Exemplo:
#pragma omp for
for (j =0; j < n; j++){
a[j]= b[j] + c[j];
}
#pragma omp for
for (j =0; j < n; j++){
d[j] = e[j] * f;
}
#pragma omp for
for (j =0; j < n; j++){
z[j] = (a[j]+a(j+1)) * 0.5;
}

Pode-se remover a
primeira barreira, OU a
segunda, mas no
ambas, j que h uma
dependncia em a

37

Sees Crticas
Uma seo crtica um bloco de cdigo que s
pode ser executado por uma thread por vez.
Pode ser utilizado para proteger a atualizao
de variveis compartilhadas.
A diretiva CRITICAL permite que as sees
crticas recebam nomes.
Se uma thread est em uma seo crtica com
um dado nome, nenhuma outra thread pode
estar em uma seo crtica com o mesmo nome
( embora elas possam estar em sees crticas
com outros nomes).

Diretiva CRITICAL
Sintaxe:
C/C++: #pragma omp critical [( name )]

structured block
Se o nome omitido, um nome nulo assumido
(todas as sees crticas sem nome tem
efetivamente o mesmo nome).

38

Diretiva CRITICAL
Exemplo: colocando e retirando de uma pilha
#pragma omp parallel shared(stack), private(inext,inew)
...
#pragma omp critical (stackprot)
{
inext = getnext(stack};
}
work(inext,inew);
#pragma omp critical (stackprot)
if (inew > 0) putnew(inew,stack);
}
...

Diretiva ATOMIC
Usada para proteger uma atualizao nica
para uma varivel compartilhada.
Aplica-se apenas a uma nica sentena.
Sintaxe:
C/C++: #pragma omp atomic

statement
Onde statement deve ter uam das seguintes

formas:
x binop = expr, x++, ++x, x--, or --x
and binop is one of +, *, -, /, &, ^, <<, or >>

39

Diretiva ATOMIC
Note que a avaliao de expr no atmica.
Pode ser mais eficiente que usar diretivas
CRITICAL, por exemplo, se diferentes
elementos do arranjo podem ser protegidos
separadamente.

Diretiva ATOMIC
Exemplo (computar o grau de cada vrtice em um
grafo):
#pragma omp parallel for
for (j=0; j<nedges; j++){
#pragma omp atomic
degree[edge[j].vertex1]++;
#pragma omp atomic
degree[edge[j].vertex2]++;
}

40

Rotinas Lock
Ocasionalmente pode ser necessrio mais
flexibilidade que a fornecida pelas diretivas
CRITICAL e ATOMIC.
Um lock uma varivel especial que pode ser
marcada por uma thread. Nenhuma outra thread
pode marcar o lock at que a thread que o
marcou o desmarque.
Marcar um lock pode tanto pode ser bloqueante
como no bloqueante.
Um lock deve ter um valor inicial antes de ser
usado e pode ser destrudo quando no for mais
necessrio.
Variveis de lock no devem ser usadas para
qualquer outro propsito.

Rotinas Lock Sintaxe

C/C++:
#include <omp.h>
void omp_init_lock(omp_lock_t *lock);
void omp_set_lock(omp_lock_t *lock);
int omp_test_lock(omp_lock_t *lock);
void omp_unset_lock(omp_lock_t *lock);
void omp_destroy_lock(omp_lock_t *lock);

Existem tambm rotinas de lock aninhveis que

permitem a uma mesma thread ativar um lock
mltiplas vezes antes de liber-lo o mesmo
nmero de vezes.

41

Rotinas Lock Exemplo

Exemplo:
call omp_init_lock(ilock)
#pragma omp parallel shared(ilock)
...
do {
do_something_else(); }
while ( ~ omp_test_lock(ilock))
work();
omp_unset_lock(ilock);
...

Escolhendo a Sincronizao
Como uma regra simples, use a diretiva ATOMIC
sempre que possvel, j que permite o mximo
de otimizao.
Se no for possvel use a diretiva CRITICAL.
Tenha cuidado de usar diferentes nomes
sempre que possvel.
Como um ltimo recurso voc pode ter que usar
as rotinas lock, mas isto deve ser uma
ocorrncia muito rara.

42

Funcionalidades
Adicionais

OpenMP 2.0

43

Novidades no Fortran 2.0

Suporte completo do Fortran 90/95:
Diretiva WORKSHARE para sintaxe de arranjos.
Diretiva THREADPRIVATE/COPYIN em
variveis (ex. para dados modulares).
Comentrios In-line em diretivas.
Redues em arranjos.
Clusula COPYPRIVATE na diretiva END SINGLE
(propaga o valor para todas as threads).
Clusula NUM_THREADS em regies paralelas.
Rotinas de temporizao.
Vrios esclarecimentos (e.g. reprivatisao de
variveis permitida.)

Novidades no C/C++ 2.0

Clusula COPYPRIVATE na diretiva END SINGLE
(propaga o valor para todas as threads).
Clusula NUM_THREADS em regies paralelas.
Rotinas de temporizao.
Vrias correes e esclarecimentos.

44

Redues em arranjos
Arranjos podem ser usados como variveis de
reduo (anteriormente s escalares e
elementos de um arranjo).
Exemplo:
#pragma omp parallel for private (i) reduction (+:b)
for (j = 0; j < N; j++)
for (i=0; i < M; i++)
b(i) = b(i) + b(i,j);

Clusula COPYPRIVATE
Difunde o valor de uma varivel privada para
todas as threads no final de uma diretiva
SINGLE.
Talvez o uso mais importante seja a leitura de
valores de variveis privadas.
Sintaxe:
C/C++:

#pragma omp single copyprivate(list)

45

Clusula COPYPRIVATE
Exemplo:
#pragma omp parallel private (a,b)
{
...
#pragma omp single copyprivate(a)
{
scanf (Entre com o valor = %d, a);
}
b = a * a;
...
}

Clusula NUMTHREADS
A clusula NUMTHREADS da verso 2.0 do
OpenMP especifica o nmero de threads que vo
executar a diretiva.
!$OMP PARALLEL DO NUM_THREADS(4)
DO I = 1,4
!$OMP PARALLEL DO NUM_THREADS(TOTALTHREADS/4)
DO J = 1,N
A(I,J) = B(I,J)
END DO
END DO

Nota: O valor colocado na clusula se sobrepe ao

valor da varivel de ambiente OMP_NUM_THREADS
(ou da chamada omp_set_num_threads() )

46

Esclarecimentos
Os padres 2.0 tanto para Fortran como o
C/C++ cotmm um grande nmero de correes
e esclarecimentos.
Se alguma coisa no est clara no padro
1.0/1.1, vale a pena ler a seo correspondente
na verso 2.0, mesmo que fvoc no esteja
utilizando um compulador compatvel com
averso 2.0.

Usando o OpenMP
Comparaes com Troca de Mensagem:

Algoritmo de decomposio de domnio o

mesmo, mas a implementao mais
simples:
Nenhuma necessidade de troca de mensagens,

clulas fantasma ou buffers de sombra.

Dados globais, variveis de campo compartilhadas:

leitura por qualquer thread, escrita pode ser

compartilhada.

Paraleliza apenas partes do cdigo que so

significativas, no h necessidade de
converter o cdigo todo.
Pr-processamento, ps-processamento pode ser

deixado parte.

47

Usando o OpenMP
OMP_NUM_THREADS especifica o nmero de
threads para serem usadas durante a execuo
de regies paralelas.
O valor padro para esta varivel 1.
OMP_NUM_THREADS threads sero usadas para
executar o programa independente do nmero
de processadores fsicos disponveis no sistema.
Como resultado, voc pode executar programas
com mais threads do que o nmero de
processadores fsicos e eles vo executar
corretamente. Contudo, o desempenho da
execuo dos programas nesta maneira poder
ser ineficiente.

Usando o OpenMP
OMP_SCHEDULE especifica o tipo de
escalonamento para diviso das iteraes do
lao entre as threads, para uso pelas clusulas
omp for e omp parallel for com uso da
clsula de escalonamento runtime.
O valor padro para esta varivel "static".
Se o tamanho do chunk no for especificado, um
valor de 1 assumido, exceto no cado de
escalonamento esttico.
Exemplos do uso da clusula OMP_SCHEDULE
so os seguintes:
$ setenv OMP_SCHEDULE "static, 5"
$ setenv OMP_SCHEDULE "guided, 8"
$ setenv OMP_SCHEDULE "dynamic"

48

Usando o OpenMP
MPSTKZ aumenta o tamanho das pilhas
utilizadas pelas threads executando regies
paralelas. Para uso com programas que utilizam
grandes quantidades de variveis locais s
threads nas rotinas chamadas nas regies
paralelas.
O valor deve ser um inteiro <n> concatenado
com M ou m para especificar o tamanho da pilha
em n megabytes: por exemplo
$ setenv MPSTKZ 8M

Usando o OpenMP
Compilando cdigo OpenMP paralelizado para
C/C++ usando o compilador Intel.
C:
icc -o myprog myprog.c -openmp -openmp_report2

C++:
icc -o myprog myprog.C -openmp -openmp_report2

Habilitando -openmp_report2 oferece como

sada diagnstico de paralelizao durante o
tempo de compilao.

49

Limitaes
fcil paralelizar cdigo serial para o OpenMP.
OpenMP pode executar em modo serial

Contudo:
Para mquinas com memria compartilhada
apenas.
Limitada escalabilidade depois de 8
processadores no h muito speed-up.
Sobrecarga para paralelizao de regies
paralelas e laos paralelos.

Limitaes
OpenMP atualmente no define ou especifica
construes para controlar a correspondncia
entre threads e processadores.
Processos podem migrar, causando overhead.
Este comportamento dependente de sistema.
Solues para este caso, especficas para cada
sistemas, podem ser oferecidas em algumas
implementaes.

50

Referncias OpenMP
http://www.openmp.org
Official web site: language specifications, links
to compilers and tools, mailing lists
http://www.compunity.org
OpenMP community site: more links, events,
resources
http://scv.bu.edu/SCV/Tutorials/OpenMP/
http://www.ccr.buffalo.edu/documents/CCR_op
enmp_pbs.PDF
http://www.epcc.ed.ac.uk/research/openmpben
ch/
Book: Parallel Programming in OpenMP,
Chandra et. al., Morgan Kaufmann, ISBN
1558606718.

51