Universidade Estadual de Campinas

Centro Nacional de Processamento de Alto Desempenho So Paulo

Apostila de Treinamento:

Introduo ao OpenMP

Reviso: 2010

ndice
1. Conceitos 1. Shared Memory 2. Distributed Memory 3. Data Parallel Programming 4. Threads/MultiThreads Introduo ao OpenMP 1. O que OpenMP 2. Histrico Modelo de Programao OpenMP Diretivas OpenMP 1. Formato Fortran 2. Formato C/C++ 3. Construo PARALLEL Exerccio 1 Exerccio 2 Exerccio 3 4. Construo Compartilhada Diretiva DO / for Diretiva SECTIONS Diretiva SINGLE Exerccio 4 Exerccio 5 Exerccio 6 5. Construo combinada PARALLEL/Compartilhada Diretiva PARALLEL DO / parallel for Diretiva PARALLEL SECTIONS Exerccio 7 6. Construes de Sincronizao Diretiva MASTER Diretiva CRITICAL Exerccio 8 Diretiva BARRIER Diretiva ATOMIC Diretiva FLUSH Diretiva ORDERED 7. Regras de Operao das Diretivas Exerccio 9 Rotinas 1. OMP_SET_NUM_THREADS 2. OMP_GET_NUM_THREADS 3. OMP_GET_MAX_THREADS 4. OMP_GET_THREAD_NUM 5. OMP_GET_NUM_PROCS 6. OMP_IN_PARALLEL 7. OMP_SET_DYNAMIC 8. OMP_GET_DYNAMIC 9. OMP_SET_NESTED 10. OMP_GET_NESTED 11. OMP_INIT_LOCK 12. OMP_DESTROY_LOCK 13. OMP_SET_LOCK 14. OMP_UNSET_LOCK 15. OMP_TEST_LOCK Variveis de Ambiente 1. OMP_SCHEDULE 2. OMP_NUM_THREADS 3. OMP_DYNAMIC 4. OMP_NESTED Exerccio 10 Exerccio 11 Referencias 03 03 04 04 05 07 07 07 08 10 10 11 12 20 21 22 23 23 28 32 33 34 35 36 36 38 39 40 41 41 43 44 44 45 46 47 48 49 49 49 50 50 52 52 52 53 53 53 54 54 54 55 55 56 56 56 56 56 57 58 59

2.

3. 4.

5.

6.

7.

1. Conceitos
O uso de paralelismo em computadores, e entre computadores, agora a regra e no mais a exceo. Internamente em um processador, diversas unidades funcionais executam tarefas em paralelo que esto escondidas no conjunto de instrues da arquitetura do processador, transparente para o usurio. Em algumas aplicaes especficas ou em determinados programas, os compiladores podem automaticamente detectar e explorar o paralelismo entre vrios processadores de uma maneira eficiente (Ex.: loops). No entanto, na maioria dos casos, os programadores necessitam instruir aos compiladores, quando e onde utilizar aes paralelas. No uma tarefa trivial, pois inclui tcnicas de replicao de dados, movimentao de dados, balanceamento entre a carga de execuo e comunicao. Para simplificar a tarefa dos programadores, alguns modelos de sistemas de programao paralela foram desenvolvidos, cada um com o seu prprio modelo de programao. Os mais importantes so: Shared Memory; Distributed Memory/Message Passing; Data-parallel programming; Threads/MultiThreads.
_

1 Shared Memory

Ambiente com vrios processadores que compartilham o espao de endereamento de uma nica memria. Os processadores podem operar independentemente, mas compartilham os recursos d mesma memria; mudanas num endereo da memria por um processador, visvel por todos os outros processadores, tornando a programao mais simples. Os processos compartilham um espao de endereamento comum, no qual o acesso feito no modo assncrono; no h necessidade de especificar explicitamente a comunicao entre os processos. A implementao desse modelo pode ser feita pelos compiladores nativos do ambiente.

2 Distributed Memory

Ambiente com vrios processadores, cada um com sua prpria memria e interconectados por uma rede de comunicao. Programao complexa. O programador responsvel pela comunicao entre os processadores. As tarefas compartilham dados atravs de comunicao de envio e recebimento de mensagens (message-passing); mltiplas tarefas iniciadas e distribudas pelos processadores do ambiente, utilizando o seu prprio endereamento de memria;

O programador responsvel por determinar todo o paralelismo e a comunicao entre as tarefas; Implementaes: PVM, Linda, MPI. 3 Data Parallel Programming

Modelo de programao que utiliza memria compartilhada, permitindo a todas as tarefas acesso a estrutura de dados na memria global; O trabalho paralelo efetuado em um conjunto de dados, e os dados devem estar organizados na forma de conjuntos (loops), aonde cada tarefa ir trabalhar com parties diferentes dessa estrutura de dados e efetuar a mesma operao em sua partio da estrutura de dados; Implementaes: Fortran90/95, HPF - High Performance Fortran, MPI e OpenMP. 4

4 Threads/Multithreads

A estrutura responsvel pela manuteno de todas as informaes necessrias execuo de um programa, como contedo de registradores e espao de memria, chama-se processo. O conceito de processo pode ser definido como sendo o ambiente onde se executa um programa. O processo pode ser dividido em trs elementos bsicos que juntos mantm todas as informaes necessrias execuo do programa: O Contexto de Hardware constitui-se, basicamente, no contedo de registradores: program counter (PC), stack pointer (SP) e bits de estado. Durante a execuo de um processo, o contexto de hardware estar armazenado nos registradores do processador. No momento em que o processo perde a utilizao da CPU, o sistema salva suas informaes. O Contexto de Software especifica as caractersticas do processo que vo influir na execuo de um programa, como, por exemplo, o nmero mximo de arquivos abertos simultaneamente ou o tamanho do buffer para operaes de E/S. Essas caractersticas so determinadas no momento da criao do processo, mas algumas podem ser alteradas durante sua existncia. O Espao de Endereamento a rea de memria do processo aonde o programa ser executado, alm do espao para os dados utilizados por ele. Cada processo possui seu prprio espao de endereamento, que deve ser protegido do acesso dos demais processos. Um programa uma seqncia de instrues, composto por desvios, repeties (iteraes) e chamadas de procedimentos e/ou funes. Em um ambiente de programao monothread, um processo suporta apenas um programa no seu espao de endereamento e apenas uma instruo do programa executada por vez. Caso seja necessrio criar aplicaes concorrentes e paralelas, so implementados mltiplos processos independentes e/ou subprocessos. A utilizao desses subprocessos independentes permite dividir uma aplicao em partes que podem trabalhar de forma concorrente. O uso de subprocessos no desenvolvimento de aplicaes concorrentes demanda consumo de diversos recursos do sistema. Sempre que um novo processo criado, o sistema deve alocar recursos (contexto de hardware, contexto de software e espao de endereamento) para cada processo, alm de consumir tempo de CPU. No caso do trmino do processo, o sistema dispensa tempo para liberar os recursos previamente solicitados. Como cada processo possui seu prprio espao de endereamento, a comunicao entre os subprocessos torna-se difcil e lenta, pois utiliza mecanismos tradicionais como pipes, sinais, semforos, memria compartilhada ou troca de mensagem. Alm disto, o compartilhamento de recursos comuns aos subprocessos concorrentes, como memria e arquivos abertos, no simples.

Na tentativa de diminuir o tempo gasto na criao e eliminao de subprocessos, bem como economizar recursos do sistema como um todo, foi introduzido o conceito de thread. No ambiente multithread, cada processo pode responder a vrias solicitaes concorrentemente ou mesmo simultaneamente, se houver mais de um processador. Em um ambiente multithread, no existe a idia de um programa, mas de threads (linhas). O processo, neste ambiente, tem pelo menos um thread de execuo, podendo compartilhar o seu espao de endereamento com inmeros threads, que podem ser executados de forma concorrente e/ou simultnea, no caso de mltiplos processadores. Cada thread possui seu prprio conjunto de registradores (contexto de hardware), porm, compartilha o mesmo espao de endereamento, temporizadores e arquivos, de forma natural e eficiente com as demais threads do processo.

A grande diferena entre subprocessos e threads em relao ao espao de endereamento. Enquanto subprocessos possuem, cada um, espaos independentes e protegidos, threads compartilham o mesmo espao de endereamento do processo, sem nenhuma proteo, permitindo que um thread possa alterar dados de outro thread. Apesar dessa possibilidade, threads so desenvolvidas para trabalhar de forma cooperativa, efetuando uma tarefa em conjunto.

2. Introduo ao OpenMP
1 O que OpenMP?

OpenMP uma interface de programao (API), portvel, baseada no modelo de programao paralela de memria compartilhada para arquiteturas de mltiplos processadores. composto por trs componentes bsicos: Diretivas de Compilao; Biblioteca de Execuo; Variveis de Ambiente.

OpenMP est disponvel para uso com os compiladores C/C++ e Fortran, podendo ser executado em ambientes Unix e Windows (Sistemas Multithreads). Definido e mantido por um grupo composto na maioria por empresas de hardware e software, denominado como OpenMP ARB (Architecture Review Board). Hardware: Compaq (Digital), Hewlett-Packard Company, Intel Corporation, International Business Machines (IBM) , Kuck & Associates, Inc. (KAI) , Silicon Graphics, Inc. , Sun Microsystems, Inc., U.S. Department of Energy ASCI program . Software: Absoft Corporation , Edinburgh Portable Compilers , GENIAS Software GmBH , Myrias Computer Technologies, Inc. , The Portland Group, Inc. (PGI) , ADINA R&D, Inc. , ANSYS, Inc. , Dash Associates , Fluent, Inc. , ILOG CPLEX Division , Livermore Software Technology Corporation (LSTC) , MECALOG SARL , Oxford Molecular Group PLC , The Numerical Algorithms Group Ltd. (NAG).

2 Histrico

No incio da dcada de 90, fabricantes de mquinas de memria compartilhada e similar, desenvolveram extenses do compilador Fortran com um conjunto especial de instrues denominadas de diretivas de execuo que permitiam: Usurio, programador Fortran (programao serial), adicionar instrues para identificar loops que poderiam ser paralelizados; O compilador passa a ser responsvel pela paralelizao automtica desses loop por entre os processadores do ambiente SMP.

O primeiro padro, ANSI X3H5, para testes foi lanado em 1994, mas nunca foi adotado devido ao grande uso e interesse, na poca, por mquinas de memria distribuda (clusters). Um novo padro foi desenvolvido em 1997 a partir do padro anterior, quando as arquiteturas de memria compartilhada se tornaram mais comum. Em 28 de Outubro de 1997 foi divulgado e disponibilizado o OpenMP Fortran API e no final de 1998 foi disponibilizado o OpenMP C/C++ API. Informaes do OpenMP em http://www.openmp.org/

3. Modelo de Programao Paralela

Paralelismo baseado em Threads: Processo de memria compartilhada que consiste de mltiplos threads; Paralelismo explcito: O OpenMP um recurso de programao paralela que permite ao programador total controle sobre a paralelizao do cdigo; Modelo Fork Join :

1. Todos os programas OpenMP comeam como um processo simples: Thread Mestre. O thread mestre executa sequencialmente at a primeira definio de uma regio paralela ser encontrada.

2. FORK (bifurcar): O thread mestre cria um conjunto (team) de threads paralelos.

3. Os comandos de um programa que esto inseridos na regio paralela sero executados em paralelo pelos diversos threads criados.

4. JOIN (unir): Quando o conjunto de threads completar a execuo dos comandos na regio paralela, os threads so sincronizados e finalizados, permanecendo apenas o thread mestre.

Baseado em diretivas de compilao: Todo paralelismo do OpenMP especificado atravs de diretivas de compilao.

Suporta paralelismo recursivo: Permite que em uma regio paralela existam outras regies que podem ser executadas em paralelo, e assim sucessivamente. Depende da implementao OpenMP.

Threads dinmico: possvel durante a execuo do programa alterar o nmero de threads que sero criados. Depende da implementao OpenMP

Exemplo de estrutura OpenMP Fortran

PROGRAM HELLO INTEGER VAR1, VAR2, VAR3 *** Cdigo serial . . . *** Incio da seo paralela. Fork um grupo de threads. !$OMP PARALLEL PRIVATE(VAR1, VAR2) SHARED(VAR3) *** Seo paralela executada por todas as threads . . . Todas as threads efetuam um join a thread mestre e finalizam

***

!$OMP END PARALLEL *** Cdigo serial . . . END

C / C++
#include <omp.h> main () { int var1, var2, var3; *** Cdigo serial . . . *** Incio da seo paralela. Fork um grupo de threads. #pragma omp parallel private(var1, var2) shared(var3) { *** Seo paralela executada por todas as threads . . . *** Todas as threads efetuam um join a thread mestre e finalizam } *** Cdigo serial . . . }

4-Diretivas OpenMP
4.1-Formato FORTRAN
Identificador (sentinel) Todas as diretivas OpenMP do Fortran devem comear com um identificador (sentinel). Os identificadores aceitos dependem do cdigo fonte Fortran:
!$OMP C$OMP *$OMP

Diretiva Diretiva OpenMP vlida

[atributos,] Campo opcional. Os atributos podem aparecer em qualquer ordem.

Exemplo:

!$OMP PARALLEL DEFAULT(SHARED) PRIVATE(BETA,PI)

Formato fixo (Fortran77): !$OMP C$OMP *$OMP so aceitos e devem comear na coluna 1;

Formato livre (Fortran90,95): !$OMP o nico identificador aceito. Pode aparecer em qualquer coluna, mas deve ser precedido por um espao em branco;

Os compiladores Fortran, normalmente necessitam de uma opo de compilao que indica ao compilador para ativar e interpretar todas as diretivas OpenMP;

Diversas diretivas do Fortran OpenMP identificam sees do cdigo que sero executadas em paralelo. Essas diretivas trabalham em pares, iniciando e finalizando a seo.

!$OMP diretiva [ cdigo Fortran ] !$OMP end diretiva

10

4.2-Formato C/C++
#pragma omp Obrigatrio para todas as diretivas OpenMP C/C++ Diretiva Diretiva OpenMP vlida. [atributos,] Campo opcional. Os atributos podem aparecer em qualquer ordem. Nova linha Obrigatrio. Precede uma estrutura de bloco.

Exemplo:

#pragma omp parallel default(shared) private(beta,pi)

Segue as regras de sintaxe do C/C++ ;

Case sensitive ;

Linhas de diretivas muito longas podem continuar em diversas linhas, acrescentando o caractere de nova linha (\) no final da diretiva.

11

4.3 Construo PARALLEL

Identifica um bloco de cdigo que ser executa por mltiplos threads. a construo fundamental do OpenMP. Formato:
!$OMP PARALLEL [atributo ...] IF (expresso lgica) PRIVATE (lista) SHARED (lista) DEFAULT (PRIVATE | SHARED | NONE) FIRSTPRIVATE (lista) REDUCTION (operador: lista) COPYIN (lista) Bloco de cdigo !$OMP END PARALLEL

Fortran

C/C++

#pragma omp parallel [atributo ...] nova_linha if (expresso lgica) private (lista) shared (lista) default (shared | none) firstprivate (lista) reduction (operador: lista) copyin (lista) estrutura de bloco

Atributos:

IF
Especifica uma condio para que o grupo de threads seja criado, se o resultado for verdadeiro. Se falso, a regio definida como paralela, ser executada somente pela thread mestre.

12

Observaes 1-Fork/Join Quando uma thread chega a uma definio de regio paralela, ela cria um conjunto de threads e passa a ser a thread mestre. A thread mestre faz parte do conjunto de threads e possui o nmero de identificao 0. A partir do incio da regio paralela, o cdigo duplicado e todas as threads executaro esse cdigo. Existe um ponto de sincronizao (barreira) no final da regio paralela, sincronizando o fim de execuo de cada thread. Somente a thread mestre continua desse ponto.

13

2-O nmero de trheads

Em uma execuo com o OpenMP, o nmero de threads determinado pelos seguintes fatores, em ordem de precedncia:

1. Utilizao da funo omp_set_num_threads() no cdigo Fortran ou C/C++; 2. Definindo a varivel de ambiente OMP_NUM_THREADS, antes da execuo; 3. Implementao padro do ambiente: nmero de processadores em um n.

3-Threads dinmico

Um programa com vrias regies paralelas, utilizara o mesmo nmero de thread para executar cada regio. Isso pode ser alterado permitindo que durante a execuo do programa, o nmero de threads seja ajustado dinamicamente para uma determinada regio paralela. Dois mtodos disponveis:

1. Utilizao da funo omp_set_dynamic() no cdigo Fortran ou C/C++; 2. Definindo a varivel de ambiente OMP_DYNAMIC, antes da execuo.

4-Regies paralelas recursivas

Uma regio paralela dentro de outra regio paralela resulta na criao de um novo grupo de threads de apenas uma thread, por default. possvel definir um nmero maior de threads, utilizando um dos dois mtodos disponveis:

1. Utilizao da funo omp_set_nested()no cdigo Fortran ou C/C++; 2. Definindo a varivel de ambiente OMP_NESTED, antes da execuo.

5-Restries

No permitido caminhar para dentro ou fora (branch) de uma estrutura de blocos definida por uma diretiva OpenMP e somente um IF permitido.

14

Exemplo:
Programa Hello World; Todas as threads executaro o cdigo da regio paralela definida pela diretiva OpenMP; So utilizadas rotinas da biblioteca OpenMP para obter a identificao de cada thread e o nmero threads que participam da execuo.

Fortran
PROGRAM HELLO INTEGER NTHREADS, TID, OMP_GET_NUM_THREADS, + OMP_GET_THREAD_NUM C Fork a team of threads giving them their own copies of variables !$OMP PARALLEL PRIVATE(NTHREADS, TID) C Obtain and print thread id TID = OMP_GET_THREAD_NUM() PRINT *, Hello World from thread = , TID Only master thread does this IF (TID .EQ. 0) THEN NTHREADS = OMP_GET_NUM_THREADS() PRINT *, Number of threads = , NTHREADS END IF

C All threads join master thread and disband !$OMP END PARALLEL END

C / C++
#include <omp.h> main () { int nthreads, tid; /* Fork a team of threads giving them their own copies of variables */ #pragma omp parallel private(nthreads, tid) { /* Obtain and print thread id */ tid = omp_get_thread_num(); printf(Hello World from thread = %d\n, tid); /* Only master thread does this */ if (tid == 0) { nthreads = omp_get_num_threads(); printf(Number of threads = %d\n, nthreads); } } /* All threads join master thread and terminate */ }

15

Atributos Comuns

Em programao OpenMP importante entender como utilizado o dado em uma thread (Data scope).

Devido ao fato do OpenMP ser baseado no modelo de programao de memria compartilhada, a maioria das variveis so compartilhadas entre as threads por definio (Variveis Globais).

Variveis globais, so as variveis definidas:

Fortran: COMMON blocks, Atributo SAVE , variveis MODULE C: Variveis estticas

Variveis no compartilhadas, locais, privadas: Variveis de ndice (loops) Variveis locais de subrotinas

Os atributos comuns so utilizados por diversas diretivas (PARALLEL, DO/for, e SECTIONS) para controlar o acesso as dados.

Definem como os dados das variveis sero transferidos das sees seriais para as sees paralelas.

Definem quais as variveis sero visveis por todas as threads e quais sero locais.

16

Atributos:
PRIVATE
Declara que as variveis listadas sero de uso especfico de cada thread. Essas variveis no so iniciadas.

SHARED (default)
Declara que as variveis listadas iro compartilhar o seu contedo com todas as threads de um grupo. As variveis existem em apenas um endereo de memria, que pode ser lido e escrito por todas as threads do grupo.

DEFAULT
Permite que o programador defina o atributo default para as variveis em uma regio paralela (PRIVATE, SHARED ou NONE).

FIRSTPRIVATE
Define uma lista de variveis com o atributo PRIVATE, mas sendo inicializadas automaticamente, de acordo com o valor que possuam no programa (thread mestre) antes de uma regio paralela.

LASTPRIVATE
Define uma lista de variveis com o atributo PRIVATE e copia o valor da ltima iterao de um loop da ltima thread que finalizou.

REDUCTION
Efetua uma operao de reduo em uma lista de variveis. Essas variveis devem ser escalares e terem sido definidas com o atributo SHARED, no contexto em que elas participaro.

17

Exemplo: REDUCTION Produto de vetores

As iteraes do loop paralelo sero distribudas em tamanhos iguais para cada thread do grupo (SCHEDULE STATIC). No final da construo paralela do loop, todas as threads iro adicionar o seu valor do resultado para thread mestre com a varivel global.

Fortran
PROGRAM DOT_PRODUCT INTEGER N, CHUNK, I PARAMETER (N=100) PARAMETER (CHUNK=10) REAL A(N), B(N), RESULT ! Some initializations DO I = 1, N A(I) = I * 1.0 B(I) = I * 2.0 ENDDO RESULT= 0.0 !$OMP PARALLEL DO !$OMP& DEFAULT(SHARED) PRIVATE(I) !$OMP& SCHEDULE(STATIC,CHUNK) !$OMP& REDUCTION(+:RESULT) DO I = 1, N RESULT = RESULT + (A(I) * B(I)) ENDDO !$OMP END DO NOWAIT PRINT *, Final Result= , RESULT END

C / C++
#include <omp.h> main () { int I, n, chunk; float a[100], b[100], result; /* Some initializations */ n = 100; chunk = 10; result = 0.0; for (I=0; I < n; I++) { a[I] = I * 1.0; b[I] = I * 2.0; } #pragma omp parallel for \ default(shared) private(i) \ schedule(static,chunk) \ reduction(+:result) for (I=0; I < n; I++) result = result + (a[I] * b[I]); printf(Final result= %f\n,result); }

18

Observaes e restries do atributo REDUCTION: 1. Variveis da lista devem ser do tipo escalar. No so possveis variveis do tipo array (vetores); 2. Uma cpia privada de cada varivel da lista criada e iniciada, dependendo da operao de reduo;

3. Devem ser declaradas como SHARED; 4. As cpias so atualizadas localmente pelas threads;

5. No final da construo, as cpias locais so combinadas atravs do operador em nico valor, na varivel compartilhada da thread mestre. 6. A varivel utilizada na operao de reduo deve ser utilizada dentro de uma regio paralela e em expresses da seguinte forma:

Fortran x = x operator expr x = expr operator x (exceto subtrao) x = intrinsic(x, expr) x = intrinsic(expr, x)

C / C++ x = x op expr x = expr op x (exceto subtrao) x binop = expr x++ ++x x --x

x uma varivel escalar da lista

x uma varivel escalar da lista

expression uma expresso escalar que no faz expression uma expresso escalar que no referncia a x faz referncia a x intrinsic pode ser: MAX, MIN, IAND, IOR, IEOR operator pode ser: +, *, -, .AND., .OR., .EQV., .NEQV. op pode ser: +, *, -, /, &, ^, |, &&, || binop pode ser: +, *, -, /, &, ^, |

19

Exerccio 1
O objetivo desse exerccio entender como se compila e executa um programa utilizando OpenMP. O programa HELLO, o mais simples possvel; em paralelo vrias threads iro imprimir um hello. 1 Caminhe para a pasta ~/curso/openmp/ex1 cd ~/curso/openmp/ex1 2 Se quiser, verifique o contedo do programa omp_hello.f ou omp_hello.c more omp_hello.f 3 Compilao Basicamente, as implementaes de Fortran e C/C++ que utilizam OpenMP so adaptaes a compiladores que j existem e dependem da utilizao de opes de compilao. Ambiente IBM/AIX Compilador: xlf_r e xlc_r opo: -qsmp=omp xlf_r omp_hello.f -qsmp=omp -o hello xlc_r omp_hello.c -qsmp=omp -o hello Ambiente INTEL/LINUX Compilador: ifort e icc opo: -openmp ifort omp_hello.f -openmp -o hello icc omp_hello.c -openmp -o hello 4 Execuo Antes da execuo do programa, ser necessrio especificar o nmero de threads que iro participar da execuo. No caso desse exerccio, a maneira mais fcil ser definir a varivel de ambiente OMP_NUM_THREADS. Ambiente IBM/csh setenv OMP_NUM_THREADS <nmero de threads>

Ambiente LINUX/bash export OMP_NUM_THREADS=<nmero de threads>

20

Exerccio 2
O objetivo desse exerccio entender como se compila e executa um programa utilizando OpenMP. O programa omp_prod_vet, simula o produto entre vetores, utilizando o atributo REDUCTION da diretiva DO/for do OpenMP . 1 Caminhe para a pasta ~/curso/openmp/ex2 cd ~/curso/openmp/ex2 2 Se quiser, verifique o contedo do programa omp_prod_vet.f ou omp_prod_vet.c more omp_prod_vet.f 3 Compilao Basicamente, as implementaes de Fortran e C/C++ que utilizam OpenMP so adaptaes a compiladores que j existem e dependem da utilizao de opes de compilao. Ambiente IBM/AIX Compilador: xlf_r e xlc_r opo: -qsmp=omp xlf_r omp_prod_vet.f -qsmp=omp -o prod xlc_r omp_prod_vet.c -qsmp=omp -o prod Ambiente INTEL/LINUX Compilador: ifort e icc opo: -openmp ifort omp_prod_vet.f -openmp -o prod icc omp_prod_vet.c -openmp -o prod 4 Execuo Antes da execuo do programa, ser necessrio especificar o nmero de threads que iro participar da execuo. No caso desse exerccio, a maneira mais fcil ser definir a varivel de ambiente OMP_NUM_THREADS. Ambiente IBM/csh setenv OMP_NUM_THREADS <nmero de threads>

Ambiente LINUX/bash export OMP_NUM_THREADS=<nmero de threads>

21

Exerccio 3
O objetivo desse exerccio entender como se compila e executa um programa utilizando OpenMP. O programa omp_mm, simula a operao de multiplicao de matrizes, utilizando OpenMP para paralelizar a operao. 1 Caminhe para a pasta ~/curso/openmp/ex3 cd ~/curso/openmp/ex3 2 Edite o programa omp_mm.f ou omp_mm.c e adicione a diretiva DO/for do OpenMP nas posies indicadas no programa. vi omp_mm.f ou vi omp_mm.c ou pico omp_mm.f ou pico omp_mm.c 3 Compilao Basicamente, as implementaes de Fortran e C/C++ que utilizam OpenMP so adaptaes a compiladores que j existem e dependem da utilizao de opes de compilao. Ambiente IBM/AIX Compilador: xlf_r e xlc_r opo: -qsmp=omp xlf_r omp_mm.f -qsmp=omp -o mm xlc_r omp_mm.c -qsmp=omp -o mm Ambiente INTEL/LINUX Compilador: ifort e icc opo: -openmp ifort omp_mm.f -openmp -o mm icc omp_mm.c -openmp -o mm 4 Execuo Antes da execuo do programa, ser necessrio especificar o nmero de threads que iro participar da execuo. No caso desse exerccio, a maneira mais fcil ser definir a varivel de ambiente OMP_NUM_THREADS. Ambiente IBM/csh setenv OMP_NUM_THREADS <nmero de threads>

Ambiente LINUX/bash export OMP_NUM_THREADS=<nmero de threads>

22

4.4Construes de Trabalho Compartilhado

Esse tipo de construo divide a execuo de uma regio paralela por entre os membros do grupo de threads;

Esse tipo de construo deve estar dentro de uma regio paralela definida pelo OpenMP, afim de executar em paralelo;

No existe sincronizao (barreira) no incio de uma construo compartilhada, mas existe no final.

Trs tipos de construes:

DO / for Compartilha as iteraes de loops por entre o grupo de threads. Representa a implementao de paralelismo de dados.

SECTIONS Quebra o trabalho em sees separadas, aonde cada seo ser executada por uma thread do grupo. Representa a implementao de paralelismo funcional, por cdigo.

SINGLE Determina que uma seo da regio paralela, seja executada por uma nica thread.

23

Diretiva compartilhada DO/for

A diretiva DO / for especifica que as iteraes de um loop sejam distribudas e executadas em paralelo pelo grupo de threads. A regio paralela tem que ter sido identificada antes.

Formato:
!$OMP DO [atributos ...] SCHEDULE (tipo [,chunk]) ORDERED PRIVATE (lista) FIRSTPRIVATE (lista) LASTPRIVATE (lista) SHARED (lista) REDUCTION (operador | intrinsic : lista) do_loop !$OMP END DO [ NOWAIT ]

Fortran

C/C++

#pragma omp for [atributo ...] nova_linha schedule (tipo [,chunk]) ordered private (lista) firstprivate (lista) lastprivate (lista) shared (lista) reduction (operador: lista) nowait for_loop

24

Atributos:

SCHEDULE Descreve como as iteraes do loop sero divididas por entre os threads: STATIC - O loop ser dividido em pedaos de tamanho chunk e distribudo estaticamente para cada thread (por ordem de trhead); Se o parmetro chunk no for definido, o compilador ir dividir o loop de maneira contnua e em partes iguais (quando possvel), para cada thread.

DYNAMIC - O loop ser dividido em pedaos de tamanho chunk e distribudo dinamicamente para cada thread (pela thread disponvel); Quando uma thread finaliza um chunk, outra e atribuda para processamento. O tamanho padro de chunk, neste caso, 1.

25

GUIDED O nmero de iteraes para cada thread ir variar, comeando com um valor grande e sendo reduzido exponencialmente, a medida que enviado o tamanho do loop para cada thread. Neste caso, o valor de chunk o tamanho mnimo permitido para o nmero de iteraes, se no for especificado, ser de 1. 1Th=46/411 2Th=(46-11)/48 3Th=(46-11-8)/46 4Th=(46-11-8-6)5 ...

RUNTIME - A deciso do agendamento feita durante a execuo do programa,

com a definio da varivel de ambiente OMP_SCHEDULE. Neste caso o parmetro chunk no definido na diretiva. export OMP_SCHEDULE = GUIDED,4

ORDERED utilizado quando existe num loop de uma regio paralela, comandos que
devem ser executados sequencialmente, na ordem do loop. Observaes 1-Se o atributo nowait (C/C++) ou NO WAIT (Fortran) for especificado, as threads no sero sincronizadas no final do loop paralelo, continuando a execuo para o prximo comando. 2-No possvel desviar para for a de um loop associado a diretiva DO/for.

26

Exemplo:
Programa Adio de Vetores; Os vetores A, B, C, e a varivel N, sero compartilhados por entre todas as threads; A varivel I ser local para cada Thread; As iteraes do loop sero distribudas dinamicamente em tamanho CHUNK; As threads no sero sincronizadas ao completarem o trabalho (NOWAIT). Fortran
PROGRAM VEC_ADD_DO INTEGER N, CHUNK, I PARAMETER (N=1000) PARAMETER (CHUNK=100) REAL A(N), B(N), C(N) ! Some initializations DO I = 1, N A(I) = I * 1.0 B(I) = A(I) ENDDO !$OMP PARALLEL SHARED(A,B,C,N) PRIVATE(I) !$OMP DO SCHEDULE(DYNAMIC,CHUNK) DO I = 1, N C(I) = A(I) + B(I) ENDDO !$OMP END DO NOWAIT !$OMP END PARALLEL END

C / C++
#include <omp.h> #define CHUNK 100 #define N 1000 main () { int i, n, chunk; float a[N], b[N], c[N]; /* Some initializations */ for (i=0; i < N; i++) a[i] = b[i] = i * 1.0; n = N; chunk = CHUNK; #pragma omp parallel shared(a,b,c,n,chunk) private(i) { #pragma omp for schedule(dynamic,chunk) nowait for (i=0; i < n; i++) c[i] = a[i] + b[i]; } } /* end of parallel section */

27

Diretiva Compartilhada SECTIONS

Diretiva que divide o trabalho de forma no iterativa em sees separadas, aonde cada seo ser executada por uma thread do grupo. Representa a implementao de paralelismo funcional, ou seja, por cdigo.

Formato:
!$OMP SECTIONS [atributo ...] PRIVATE (lista) FIRSTPRIVATE (lista) LASTPRIVATE (lista) REDUCTION (operador | intrinsic : lista) !$OMP SECTION

Fortran
block !$OMP SECTION

block !$OMP END SECTIONS [ NOWAIT ]

#pragma omp sections [atributo ...] nova_linha private (lista) firstprivate (lista) lastprivate (lista) reduction (operador: lista) nowait {

C/C++

#pragma omp section estrutura de bloco #pragma omp section estrutura de bloco }

nova_linha

nova_linha

28

Observaes 1-A diretiva SECTIONS define a seo do cdigo sequncial aonde ser definida as sees independentes, atravs da diretiva SECTION; 2-Cada SECTION executada por uma thread do grupo; 3-Existe um ponto de sincronizao implcita no final da diretiva SECTIONS, a menos que, se especifique o atributo nowait (C/C++) ou NOWAIT (Fortran); 4-Se existirem mais threads do que sees, o OpenMP decidir, quais threads executaro os blocos de SECTION, e quais, no executaro.

29

Exemplo:

Programa Adio de Vetores; O primeiro n/2 iteraes do loop ser distribudo para a primeira thread e o resto ser distribudo para a segunda thread; As threads no possuem um ponto de sincronizao devido ao atributo (NOWAIT).

Fortran
PROGRAM VEC_ADD_SECTIONS INTEGER N, I PARAMETER (N=1000) REAL A(N), B(N), C(N) ! Some initializations DO I = 1, N A(I) = I * 1.0 B(I) = A(I) ENDDO !$OMP PARALLEL SHARED(A,B,C,N), PRIVATE(I) !$OMP SECTIONS !$OMP SECTION DO I = 1, N/2 C(I) = A(I) + B(I) ENDDO !$OMP SECTION DO I = 1+N/2, N C(I) = A(I) + B(I) ENDDO !$OMP END SECTIONS NOWAIT !$OMP END PARALLEL END

30

C / C++
#include <omp.h> #define N 1000 main () { int i, n; float a[N], b[N], c[N]; /* Some initializations */ for (i=0; i < N; i++) a[i] = b[i] = i * 1.0; n = N; #pragma omp parallel shared(a,b,c,n) private(i) { #pragma omp sections nowait { #pragma omp section for (i=0; i < n/2; i++) c[i] = a[i] + b[i]; #pragma omp section for (i=n/2; i < n; i++) c[i] = a[i] + b[i]; } } } /* end of sections */ /* end of parallel section */

31

Diretiva SINGLE

Diretiva que determina que o cdigo identificado seja executado por somente uma thread do grupo.

Formato:

!$OMP SINGLE [atributo ...] PRIVATE (lista) FIRSTPRIVATE (lista)

Fortran
cdigo !$OMP END SINGLE [ NOWAIT ]

C/C++

#pragma omp single [atributo ...] nova_linha private (lista) firstprivate (lista) nowait estrutura de bloco

Os threads do grupo que no executam a diretiva SINGLE, esperam o fim do processamento da thread que executa a diretiva, a menos que se especifique o atributo nowait (C/C++) ou NOWAIT (Fortran).

32

Exerccio 4
O objetivo desse exerccio entender como funciona a diretiva DO/for do OpenMP. 1 Caminhe para a pasta ~/curso/openmp/ex4 cd ~/curso/openmp/ex4 2 Edite o programa omp_do_for.f ou omp_do_for.c e codifique o que solicitado nas linhas com as setas. vi omp_do_for.f ou vi omp_do_for.c ou pico omp_do_for.f ou pico omp_do_for.c 3 Compilao Ambiente IBM/AIX Compilador: xlf_r e xlc_r opo: -qsmp=omp xlf_r omp_do_for.f -qsmp=omp -o dofor xlc_r omp_do_for.c -qsmp=omp -o dofor Ambiente INTEL/LINUX Compilador: ifort e icc opo: -openmp ifort omp_do_for.f -openmp -o dofor icc omp_do_for.c -openmp -o dofor 4 Execuo Antes da execuo do programa, ser necessrio especificar o nmero de threads que iro participar da execuo. Defina um nmero que possa visualizar e entender o resultado, entre 2 e 4. Ambiente IBM/csh setenv OMP_NUM_THREADS <nmero de threads> Ambiente LINUX/bash export OMP_NUM_THREADS=<nmero de threads>

33

Exerccio 5
Edite novamente o programa e faa as modificaes necessrias para que o programa execute em paralelo, somente se, o nmero N for maior que 1000, e o loop paralelo do tipo esttico sem tamanho definido. Varie o valor de N. 1 Caminhe para a pasta ~/curso/openmp/ex5 cd ~/curso/openmp/ex5 2 Edite o programa omp_do_for.f ou omp_do_for.c e codifique o que solicitado nas linhas com as setas. vi omp_do_for.f ou vi omp_do_for.c ou pico omp_do_for.f ou pico omp_do_for.c 3 Compilao Ambiente IBM/AIX Compilador: xlf_r e xlc_r opo: -qsmp=omp xlf_r omp_do_for.f -qsmp=omp -o dofor xlc_r omp_do_for.c -qsmp=omp -o dofor Ambiente INTEL/LINUX Compilador: ifort e icc opo: -openmp ifort omp_do_for.f -openmp -o dofor icc omp_do_for.c -openmp -o dofor 4 Execuo Antes da execuo do programa, ser necessrio especificar o nmero de threads que iro participar da execuo. Defina um nmero que possa visualizar e entender o resultado, entre 2 e 4. Ambiente IBM/csh setenv OMP_NUM_THREADS <nmero de threads> Ambiente LINUX/bash export OMP_NUM_THREADS=<nmero de threads>

34

Exerccio 6
Edite o programa omp_sections.f ou omp_sections.c e faa as modificaes necessrias para que o programa execute em paralelo, e execute duas sees separadas, uma para cada thread. Defina apenas 2 threads para a execuo desse exerccio. 1 Caminhe para a pasta ~/curso/openmp/ex6 cd ~/curso/openmp/ex6 2 Edite o programa omp_sections.f ou omp_sections.c . Este programa possui na regio paralela, duas sees que podem ser executadas em threads separadas. Identifique as sees e acrescente as diretivas threads necessrias. vi omp_sections.f ou vi omp_sections.c ou pico omp_sections.f ou pico omp_sections.c 3 Compilao Ambiente IBM/AIX Compilador: xlf_r e xlc_r opo: -qsmp=omp xlf_r omp_sections.f -qsmp=omp -o sections xlc_r omp_sections.c -qsmp=omp -o sections Ambiente INTEL/LINUX Compilador: ifort e icc opo: -openmp ifort omp_sections.f -openmp -o sections icc omp_sections.c -openmp -o sections 4 Execuo Antes da execuo do programa, ser necessrio especificar o nmero de threads que iro participar da execuo. Defina um nmero que possa visualizar e entender o resultado, entre 2 e 4. Ambiente IBM/csh setenv OMP_NUM_THREADS <nmero de threads> Ambiente LINUX/bash export OMP_NUM_THREADS=<nmero de threads>

35

4.5-Construes Combinadas e Compartilhadas PARALLEL

O objetivos das diretivas combinadas so as de reduzir o nmero de instrues OpenMP para determinadas regies paralelas melhorando a compreenso do cdigo. uma construo mais conveniente.

Diretiva PARALLEL DO/for

Determina uma regio paralela e simultaneamente distribui as iteraes do loop na regio, por entre os threads de um grupo. A diretiva DO/for tem que vir imediatamente aps a palavra PARALLEL. Formato:
!$OMP PARALLEL DO [atributo ...] IF (expresso lgica) DEFAULT (PRIVATE | SHARED | NONE) SCHEDULE (tipo [,chunk]) SHARED (lista) PRIVATE (lista) FIRSTPRIVATE (lista) LASTPRIVATE (lista) REDUCTION (operador | intrinsic : lista) COPYIN (lista) do loop !$OMP END PARALLEL DO

Fortran

C/C++

#pragma omp parallel for [atributo ...] nova_linha if (expresso lgica) default (shared | none) schedule (tipo [,chunk]) shared (lista) private (lista) firstprivate (lista) lastprivate (lista) reduction (operador: lista) copyin (lista) for loop

36

Exemplo

As iteraes sero distribudas em blocos de mesmo tamanho por entre as threads.

Fortran
PROGRAM VECTOR_ADD INTEGER N, I, CHUNK PARAMETER (N=1000) PARAMETER (CHUNK=100) REAL A(N), B(N), C(N) ! Some initializations DO I = 1, N A(I) = I * 1.0 B(I) = A(I) ENDDO

!$OMP PARALLEL DO !$OMP& SHARED(A,B,C) PRIVATE(I) !$OMP& SCHEDULE(STATIC,CHUNK) DO I = 1, N C(I) = A(I) + B(I) ENDDO !$OMP END PARALLEL DO END

C / C++
#include <omp.h> #define N 1000 #define CHUNK 100 main () {

int i, n, chunk; float a[N], b[N], c[N]; /* Some initializations */ for (i=0; i < N; i++) a[i] = b[i] = i * 1.0; n = N; chunk = CHUNK; #pragma omp parallel for \ shared(a,b,c) private(i) \ schedule(static,chunk) for (i=0; i < n; i++) c[i] = a[i] + b[i]; }

37

Diretiva PARALLEL SECTIONS

Diretiva combinada que determina a regio paralela e simultaneamente as sees que cada thread ir executar. A diretiva SECTIONS tem que vir imediatamente aps a palavra PARALLEL. Formato:

Fortran

!$OMP PARALLEL SECTIONS [atributo ...] DEFAULT (PRIVATE | SHARED | NONE) SHARED (lista) PRIVATE (lista) FIRSTPRIVATE (lista) LASTPRIVATE (lista) REDUCTION (operador | intrinsic : lista) COPYIN (lista) ORDERED cdigo !$OMP END PARALLEL SECTIONS

C/C++

#pragma omp parallel sections [atributo ...] nova_linha default (shared | none) shared (lista) private (lista) firstprivate (lista) lastprivate (lista) reduction (operador: lista) copyin (lista) ordered cdigo

38

Exerccio 7
O objetivo desse exerccio entender as caractersticas e os detalhes das diretivas combinadas PARALLEL DO do OpenMP. 1 Caminhe para a pasta ~/curso/openmp/ex7 cd ~/curso/openmp/ex7 2 Edite o programa omp_combinado.f ou omp_combinado.c . Este programa possui na regio paralela, um loop que pode ser executado em threads separadas, no entanto, alguns detalhes na codificao do programa e na regra de utilizao do PARALLEL DO, ocasionam erros de compilao. Tente entender os erros e corrija-os; compare com o exemplo da apostila. vi omp_combinado.f ou vi omp_combinado.c ou pico omp_combinado.f ou pico omp_combinado.c 3 Compilao Ambiente IBM/AIX Compilador: xlf_r e xlc_r opo: -qsmp=omp xlf_r omp_combinado.f -qsmp=omp -o comb xlc_r omp_combinado.c -qsmp=omp -o comb Ambiente INTEL/LINUX Compilador: ifort e icc opo: -openmp ifort omp_combinado -openmp -o comb icc omp_combinado -openmp -o comb 4 Execuo Antes da execuo do programa, ser necessrio especificar o nmero de threads que iro participar da execuo. Defina um nmero que possa visualizar e entender o resultado, entre 2 e 4. Ambiente IBM/csh setenv OMP_NUM_THREADS <nmero de threads> Ambiente LINUX/bash export OMP_NUM_THREADS=<nmero de threads>

39

4.6-Construes de Sincronizao
Considere o exemplo abaixo no qual duas threads em dois processadores distintos, esto ambos tentando alterar a varivel x ao mesmo tempo ( x inicialmente 0 ). THREAD 1:
increment(x) { x = x + 1; }

THREAD 2:
increment(x) { x = x + 1; }

THREAD 1:
10 20 30 LOAD A, (x address) ADD A, 1 STORE A, (x address)

THREAD 2:
10 20 30 LOAD A, (x address) ADD A, 1 STORE A, (x address)

Para compreender o que acontece durante a execuo, vamos visualizar as instrues em assembler. Uma possvel execuo seria: 1-Thread 1 carrega o valor de x no registro A. 2-Thread 2 carrega o valor de x no registro A. 3-Thread 1 adiciona 1 ao registro A. 4-Thread 2 adiciona 1 ao registro A. 5-Thread 1 armazena o registro A no endereo x. 6-Thread 2 armazena o registro A no endereo x.

O resultado final ser x=1, ao invs de 2.

Para contornar essa situao, a alterao do valor de x deve ser sincronizado por entre as duas threads, para garantir o resultado correto. O OpenMP possui uma variedade de construes de sincronizao que controla como sera a execuo de cada thread em relao ao grupo de threads.

40

Diretiva MASTER

Determina a regio que ser executada apenas pela thread mestre do grupo. Todas as outras threads do grupo pulam essa seo do cdigo. Formato:

!$OMP MASTER

Fortran

cdigo !$OMP END MASTER

#pragma omp master

<nova_linha>

C/C++
cdigo

No existe sincronizao implcita entre as threads.

Diretiva CRITICAL

Determina que a regio do cdigo deva ser executada somente por uma thread de cada vez. Formato:

!$OMP CRITICAL [ nome ]

Fortran

cdigo !$OMP END CRITICAL

#pragma omp critical [ nome ]

<nova_linha>

C/C++
cdigo

Se um thread estiver executando uma regio CRITICAL as outras threads iro bloquear a execuo quando alcanarem essa regio, e cada uma executar a regio por ordem de chegada.

O nome de uma regio CRITICAL opcional.

41

Exemplo

Ambas as sees iro executar em paralelo, em duas threads diferentes. Devido a diretiva CRITICAL em torno da expresso de adio de x, somente uma thread por vez ir ler, incrementar e escrever em x.

Fortran
PROGRAM CRITICAL INTEGER X X = 0 !$OMP PARALLEL SHARED(X) !$OMP SECTIONS !$OMP SECTION !$OMP CRITICAL X = X + 1 !$OMP END CRITICAL !$OMP SECTION !$OMP CRITICAL X = X + 1 !$OMP END CRITICAL !$OMP END SECTIONS NOWAIT !$OMP END PARALLEL END

C / C++
#include <omp.h> main() { int x; x = 0; #pragma omp parallel shared(x) { #pragma omp sections nowait { #pragma omp section #pragma omp critical x = x + 1; #pragma omp section #pragma omp critical x = x + 1; } } } /* end of sections */ /* end of parallel section */

42

Exerccio 8
O objetivo desse exerccio entender a diretiva CRITICAL do OpenMP. 1 Caminhe para a pasta ~/curso/openmp/ex8 cd ~/curso/openmp/ex8 2 Edite o programa omp_critical.f ou omp_critical.c . Este programa possui na regio paralela, uma operao que deve ser executada serialmente pelas threads, ou seja, uma de cada vez. Determine qual a operao e adicione a diretiva apropriada para a execuo correta do programa. vi omp_critical.f ou vi omp_critical.c ou pico omp_critical.f ou pico omp_critical.c 3 Compilao Ambiente IBM/AIX Compilador: xlf_r e xlc_r opo: -qsmp=omp xlf_r omp_critical.f -qsmp=omp -o critical xlc_r omp_critical.c -qsmp=omp -o critical Ambiente INTEL/LINUX Compilador: ifort e icc opo: -openmp ifort omp_critical.f -openmp -o critical icc omp_critical.c -openmp -o critical 4 Execuo Antes da execuo do programa, ser necessrio especificar o nmero de threads que iro participar da execuo. Defina um nmero que possa visualizar e entender o resultado, entre 2 e 4. Ambiente IBM/csh setenv OMP_NUM_THREADS <nmero de threads> Ambiente LINUX/bash export OMP_NUM_THREADS=<nmero de threads>

43

Diretiva BARRIER

Diretiva que sincroniza todas as threads de um grupo. Formato:

Fortran !$OMP BARRIER

C/C++

#pragma omp barrier

<nova_linha>

Quando uma thread executa essa diretiva, ela para de processar e espera por todas as threads chegarem nessa diretiva. Quando isso acontecer, as threads voltam a processar o restante do cdigo. Todas as threads de uma regio paralela devem executar a diretiva BARRIER.

Diretiva ATOMIC

Diretiva que especifica, que imediatamente o prximo endereo de memria, seja atualizado pontualmente por cada thread, e no simultaneamente por todas as threads. Seria similar a diretiva CRITICAL. Formato:

!$OMP ATOMIC

Fortran
expressio

#pragma omp atomic

newline

C/C++
expresso

A thread executar, somente, imediatamente o prximo comando.

44

Esse comando dever possuir o seguinte formato: Fortran x = x operador expr x = expr operador x x = intrinsica(x, expr) x = intrinsica(expr, x) C / C++ x binop = expr x++ ++x x---x

x uma varivel escalar expresso uma expresso escalar que no faz referncia a x intrinsica uma funo como: MAX, MIN, IAND, IOR, ou IEOR operador pode ser: +, *, -, /, .AND., .OR., .EQV., or .NEQV.

x uma varivel escalar expresso uma expresso escalar que no faz referncia a x binop um operador, podendo ser: +, *, -, /, &, ^, |, >>, or <<

Importante: Somente a leitura e gravao da varivel x ser atmica ou pontual. A avaliao da expresso, no ser, sendo feita simultaneamente por todas as threads.

Diretiva FLUSH

Determina a atualizao dos dados compartilhados entre os threads em memria. Representa uma barreira, garantindo que todas as operaes realizadas por todas as threads at o momento do flush foram realizadas. Formato:

Fortran

!$OMP FLUSH

(lista)

C/C++

#pragma omp flush (lista)

<nova_linha>

Essa diretiva necessria para instruir o compilador que as variveis da lista, devem ser lidas ou escritas do sistema de memria, ou seja, as variveis no podem permanecer nos registradores locais de cada cpu. opcional fornecer as variveis que se deseja atualizar os dados, mas se no for feito, todas as variveis utilizadas no programa sero atualizadas na memria. 45

A ao dessa diretiva implcita em outras diretivas, desde que no seja utilizado o atributo NOWAIT. Fortran BARRIER CRITICAL e END CRITICAL END DO END PARALLEL END SECTIONS END SINGLE ORDERED e END ORDERED
barrier critical ordered parallel for sections single

C / C++

Diretiva ORDERED

Determina que as iteraes do loop, na regio paralela, sejam executados na ordem sequncial. S pode ser utilizada junto com as diretivas, DO / for com o atributo ORDERED. DO ou PARALLEL DO (Fortran) for ou parallel for (C/C++)

Formato:
!$OMP DO ORDERED [atributos...] (loop) !$OMP ORDERED

Fortran

(cdigo) !$OMP END ORDERED (fim do loop) !$OMP END DO #pragma omp for ordered [atributos...] (loop)

C/C++

#pragma omp ordered cdigo (fim do loop)

<nova_linha>

As threads necessitam esperar para executar a sua parte de um loop, se as iteraes anteriores, na ordem do loop, ainda no tiverem terminado.

46

4.7-Regras de Operao das Diretivas

As regras se aplicam a todas implementaes de OpenMP, para os compiladores Fortran e C/C++;

As diretivas DO/for, SECTIONS, SINGLE, MASTER e BARRIER s sero utilizadas se estiverem em uma regio paralela definida pela diretiva PARALLEL. Se a regio paralela no tiver sido definida, essas diretivas no tero nenhuma ao;

A diretiva ORDERED s ser utilizada junto com a diretiva DO/for;

A diretiva ATOMIC tem ao em todas as threads utilizadas durante o processamento do programa;

Uma diretiva PARALLEL dentro de outra diretiva PARALLEL, logicamente, estabelece um novo grupo, que ser composto apenas pela thread que alcanar a nova regio paralela, primeiro;

A diretiva BARRIER no permitida dentro das regies definidas pelas diretivas DO/for, ORDERED, SECTIONS, SINGLE, MASTER e CRITICAL;

Qualquer diretiva pode ser executada fora de uma regio definida pela diretiva PARALLEL, no entanto ser executado apenas pela thread MASTER.

47

Exerccio 9
O objetivo desse exerccio entender a diretiva BARRIER do OpenMP. 1 Caminhe para a pasta ~/curso/openmp/ex9 cd ~/curso/openmp/ex9 2 Edite o programa omp_barrier.f ou omp_barrier.c . Este programa possui um erro durante a execuo. Tente entender o erro, verifique as regras de utilizao das diretivas OpenMP. Corrija o problema. vi omp_barrier.f ou vi omp_barrier.c ou pico omp_barrier.f ou pico omp_barrier.c 3 Compilao Ambiente IBM/AIX Compilador: xlf_r e xlc_r opo: -qsmp=omp xlf_r omp_barrier.f -qsmp=omp -o barrier xlc_r omp_barrier.c -qsmp=omp -o barrier Ambiente INTEL/LINUX Compilador: ifort e icc opo: -openmp ifort omp_barrier.f -openmp -o barrier icc omp_barrier.c -openmp -o barrier 4 Execuo Antes da execuo do programa, ser necessrio especificar o nmero de threads que iro participar da execuo. Defina um nmero que possa visualizar e entender o resultado, entre 2 e 4. Ambiente IBM/csh setenv OMP_NUM_THREADS <nmero de threads> Ambiente LINUX/bash export OMP_NUM_THREADS=<nmero de threads>

48

5-Rotinas
O OpenMP padro possui uma biblioteca com rotinas de API (Aplication Program Interface), que possibilitam uma grande variedade de funes:

Verifica o nmero de threads ativas; Determina o nmero de threads que sero usadas; Funo que bloqueia a execuo; Funo de cronometragem; Funo que define ambiente de execuo, como paralelismo recursivo e ajuste dinmico de threads; Para o compilador C/C++ necessrio especificar o arquivo (include) omp.h;

5.1-OMP_SET_NUM_THREADS

Esta subrotina/funo determina o nmero de threads que sero utilizadas para a prxima regio paralela; Formato:

Fortran SUBROUTINE OMP_SET_NUM_THREADS(scalar_integer_expression)

C/C++

void omp_set_num_threads(int num_threads)

Esta rotina s pode ser executada na parte serial do cdigo, antes definio de uma regio paralela. Esta rotina tem precedncia sobre a varivel de ambiente OMP_NUM_THREADS.

5.2-OMP_GET_NUM_THREADS

Esta subrotina/funo retorna o nmero de threads que esto sendo utilizadas em uma regio paralela.

Fortran INTEGER FUNCTION OMP_GET_NUM_THREADS()

C/C++

int omp_get_num_threads(void)

Esta funo tem que ser executada dentro de uma regio paralela.

49

5.3-OMP_GET_MAX_THREADS

Esta subrotina/funo retorna o nmero mximo de threads que o programa pode utilizar.

Fortran INTEGER FUNCTION OMP_GET_MAX_THREADS()

C/C++

int omp_get_max_threads(void)

Geralmente, reflete o nmero de threads definidos pela varivel de ambiente OMP_NUM_THREADS ou pela funo OMP_SET_NUM_THREADS(). Esta funo pode ser executada em qualquer parte do programa, na regio serial ou na regio paralela.

5.4-OMP_GET_THREAD_NUM

Esta subrotina/funo retorna a identificao da thread que est executando, dentro de um grupo. A identificao ser um numero entre 0 e OMP_GET_NUM_THREADS-1. A thread mestre do grupo sempre ser identificada como 0.

Fortran INTEGER FUNCTION OMP_GET_THREAD_NUM()

C/C++

int omp_get_thread_num(void)

Se a funo for executada de uma regio paralela recursiva ou da regio serial, o valor retornado ser 0.

50

Exemplos: Fortran Determinao do nmero de threads em uma regio paralela. Exemplo 1: Correto Forma correta de determinar o nmero de threads numa regio paralela.
PROGRAM HELLO INTEGER TID, OMP_GET_THREAD_NUM !$OMP PARALLEL PRIVATE(TID) TID = OMP_GET_THREAD_NUM() PRINT *, 'Hello World from thread = ', TID ... !$OMP END PARALLEL END

Exemplo2 2: Incorreto A varivel TID, tem que ser PRIVATE (local).

PROGRAM HELLO INTEGER TID, OMP_GET_THREAD_NUM !$OMP PARALLEL TID = OMP_GET_THREAD_NUM() PRINT *, 'Hello World from thread = ', TID ... !$OMP END PARALLEL END

Exemplo 3: Incorreto A funo OMP_GET_THREAD_NUM foi utilizada fora da regio paralela.

PROGRAM HELLO INTEGER TID, OMP_GET_THREAD_NUM TID = OMP_GET_THREAD_NUM() PRINT *, 'Hello World from thread = ', TID !$OMP PARALLEL ... !$OMP END PARALLEL END

51

5.5-OMP_GET_NUM_PROCS

Esta subrotina/funo retorna o nmero de processadores disponveis para a execuo do programa.

Fortran INTEGER FUNCTION OMP_GET_NUM_PROCS()

C/C++

int omp_get_num_procs(void)

5.6-OMP_IN_PARALLEL

Esta subrotina/funo pode ser chamada para determinar se uma seo do cdigo est sendo executada em paralelo, ou no.

Fortran LOGICAL FUNCTION OMP_IN_PARALLEL()

C/C++

int omp_in_parallel(void)

Para o Fortran, a funo retorna .TRUE. se for chamada de uma regio que esteja executando em paralelo, caso contrrio, retornar .FALSE. Para o C/C++, retornar um inteiro diferente de 0, se for paralelo, caso contrrio, retornar 0.

5.7-OMP_SET_DYNAMIC

Esta subrotina/funo, ativa ou desativa a capacidade do programa de ajustar dinamicamente (durante a execuo), o nmero de threads disponveis para a execuo de regies paralelas.

Fortran SUBROUTINE OMP_SET_DYNAMIC(expresso lgica)

C/C++

void omp_set_dynamic(int dynamic_threads)

Para o Fortran, se a expresso resolver para .TRUE. permitir o ajuste. Para o C/C++, se dynamic_threads tiver um valor diferente de 0, permitir o ajuste. A subrotina/funo OMP_SET_DYNAMIC tem precedncia sobre a varivel dinmica OMP_DYNAMIC. Deve ser chamada da seo serial do programa.

52

5.8-OMP_GET_DYNAMIC
Verifica se est disponvel o ajuste dinmico de threads.

Fortran LOGICAL FUNCTION OMP_GET_DYNAMIC()

C/C++

int omp_get_dynamic(void)

Para o Fortran, esta funo retorna .TRUE. se ajuste dinmico est disponvel. Para o C/C++, esta funo retorna um valor diferente de 0 se ajuste dinmico est disponvel.

5.9-OMP_SET_NESTED
Esta funo utilizada para ativar ou desativar o paralelismo recursivo.

Fortran SUBROUTINE OMP_SET_NESTED(scalar_logical_expression)

C/C++

void omp_set_nested(int nested)

Fortran: .TRUE. ativar .FALSE. desativar. C/C++ : 0 ativar = 0 desativar. O paralelismo recursivo est ativo por default.

5.10-OMP_GET_NESTED
Esta funo verifica se o paralelismo recursivo est ativo ou no.

Fortran LOGICAL FUNCTION OMP_GET_NESTED()

C/C++

int omp_get_nested(void)

Fortran: C/C++ :

.TRUE. ativado 0 ativado

.FALSE. desativado. = 0 desativado.

53

5.11-OMP_INIT_LOCK
Esta subrotina/funo inicia para o OpenMP as variveis de bloqueio, indicando para as threads as variveis de bloqueio. A varivel tem que ser definida com tipo LOCK
INTEGER(OMP_LOCK_KIND) var

Fortran SUBROUTINE OMP_INIT_LOCK(var)

C/C++

void omp_init_lock(omp_lock_t *lock)

5.12-OMP_DESTROY_LOCK
Esta subrotina/funo finaliza qualquer associao de bloqueio de uma determinada varivel.

Fortran SUBROUTINE OMP_DESTROY_LOCK(var)

C/C++

void omp_destroy_lock(omp_lock_t *lock) void omp_destroy_nest__lock(omp_nest_lock_t *lock)

5.13-OMP_SET_LOCK
Esta subrotina/funo solicita o bloqueio de uma varivel, ou aguarda que uma varivel bloqueada esteja disponvel.

Fortran SUBROUTINE OMP_SET_LOCK(var)

C/C++

void omp_set_lock(omp_lock_t *lock) void omp_set_nest__lock(omp_nest_lock_t *lock)

54

5.14-OMP_UNSET_LOCK
Esta subrotina/funo libera o bloqueio de uma determinada varivel.

Fortran SUBROUTINE OMP_UNSET_LOCK(var)

C/C++

void omp_unset_lock(omp_lock_t *lock) void omp_unset_nest__lock(omp_nest_lock_t *lock)

5.15-OMP_TEST_LOCK
Esta subrotina/funo testa e bloqueia, se uma varivel de bloqueio, est disponvel para ser bloqueada, mas sem parar a execuo da thread.

Fortran SUBROUTINE OMP_TEST_LOCK(var)

C/C++

void omp_test_lock(omp_lock_t *lock) void omp_test_nest__lock(omp_nest_lock_t *lock)

Fortran: C/C++ :

.TRUE. Ativado bloqueio .FALSE. No possvel o bloqueio. 0 Ativado bloqueio = 0 No possvel o bloqueio.

55

6-Variveis de Ambiente
So parmetros definidos no ambiente operacional antes da execuo do programa. O OpenMP possui quatro definies de variveis, que controlam a execuo do cdigo paralelo. O nome dessas variveis deve vir sempre em letras maisculas.

6.1-OMP_SCHEDULE
O valor dessa varivel determina como as iteraes de um loop so agendadas por entre os threads. Essa varivel de ambiente utilizada somente para as diretivas DO, PARALLEL DO (Fortran) e for, parallel for (C/C++). Exemplos: Ambiente csh (IBM/AIX)
setenv OMP_SCHEDULE "guided, 4" setenv OMP_SCHEDULE "dynamic"

Ambientes bsh/bash/ksh (Linux)

export OMP_SCHEDULE="guided, 4" export OMP_SCHEDULE="dynamic"

6.2-OMP_NUM_THREADS
Define o nmero mximo de threads durante a execuo. Exemplos: Ambiente csh (IBM/AIX)
setenv OMP_NUM_THREADS 8

Ambientes bsh/bash/ksh (Linux)

export OMP_NUM_THREADS=8

6.3-OMP_DYNAMIC
Habilita ou no, o ajuste dinmico no nmero de threads para a execuo de regies paralelas. Valores possveis TRUE ou FALSE. Exemplos: Ambiente csh (IBM/AIX)
setenv OMP_DYNAMIC TRUE

Ambientes bsh/bash/ksh (Linux)

export OMP_DYNAMIC=TRUE

6.4-OMP_NESTED
Habilita ou no, o paralelismo recursivo. Exemplos: Ambiente csh (IBM/AIX)
setenv OMP_NESTED TRUE

Ambientes bsh/bash/ksh (Linux)

export OMP_NESTED=TRUE

56

Exerccio 10
O objetivo desse exerccio entender a definio das variveis nas diretivas do OpenMP. 1 Caminhe para a pasta ~/curso/openmp/ex10 cd ~/curso/openmp/ex10 2 Edite o programa omp_erro.f ou omp_erro.c . Este programa produz resultados incorretos. Verifique como foi definida e utilizada a varivel de reduo na regio paralela. vi omp_erro.f ou vi omp_erro.c ou pico omp_erro.f ou pico omp_erro.c 3 Compilao Ambiente IBM/AIX Compilador: xlf_r e xlc_r opo: -qsmp=omp xlf_r omp_erro.f -qsmp=omp -o erro xlc_r omp_erro.c -qsmp=omp -o erro Ambiente INTEL/LINUX Compilador: ifort e icc opo: -openmp ifort omp_erro.f -openmp -o erro icc omp_erro.c -openmp -o erro 4 Execuo Antes da execuo do programa, ser necessrio especificar o nmero de threads que iro participar da execuo. Defina um nmero que possa visualizar e entender o resultado, entre 2 e 4. Ambiente IBM/csh setenv OMP_NUM_THREADS <nmero de threads> Ambiente LINUX/bash export OMP_NUM_THREADS=<nmero de threads>

57

Exerccio 11
O objetivo desse exerccio tentar paralelizar um programa com loops. 1 Caminhe para a pasta ~/curso/openmp/ex11 cd ~/curso/openmp/ex11 2 Edite o programa loop.f ou omp_loop.c . Analise as regies com loops e tente acrescentar as diretivas OpenMP, de maneira que, esses loops sejam executados pro threads. vi loop.f ou vi loop.c ou pico loop.f ou pico loop.c 3 Compilao Ambiente IBM/AIX Compilador: xlf_r e xlc_r opo: -qsmp=omp xlf_r loop.f -qsmp=omp -o loop xlc_r loop.c -qsmp=omp -o loop Ambiente INTEL/LINUX Compilador: ifort e icc opo: -openmp ifort loop.f -openmp -o loop icc loop.c -openmp -o loop 4 Execuo Antes da execuo do programa, ser necessrio especificar o nmero de threads que iro participar da execuo. Defina um nmero que possa visualizar e entender o resultado, entre 2 e 4. Ambiente IBM/csh setenv OMP_NUM_THREADS <nmero de threads> Ambiente LINUX/bash export OMP_NUM_THREADS=<nmero de threads>

58

7-Referncias
SP Parallel Programming II Workshop - "OpenMP". Maui High Performance Computing Center. 1998. The OpenMP web site. www.openmp.org "OpenMP". Workshop Presentation. Lawrence Livermore National Laboratory John Engle, October, 1998. "Introduction to Parallel Programming ". Lawrence Livermore National Laboratory.

Blaise Barney, Livermore Computing.

Programao Paralela e Distribuda OpenMP. DCC-IM / UFRJ Gabriel P. Silva - Bacharelado em Cincia da Computao Parallel Programming Using OpenMP H. Birali Runesha and Shuxia Zhang Ferramentas para Programao em Processadores Multi-Core Prof. Dr. Gerson Geraldo H. Cavalheiro Departamento de Informtica Universidade Federal de Pelotas Introduo ao OpenMP Fernando Silva DCC-FCUP Operating System Concepts Silberschatz, Galvin and Gagne Multithread - Instituto de Matemtica da UFRJ/NCE - Depto de Cincia da Computao Luiz Paulo Maia

59