Introdução ao OpenMPgrenoble.ime.usp.br/~gold/cursos/2014/labprogII/aulas/aulaOpenMP.pdf · de paralelismo físico. ... Implementação de Threads em Linguagens de ProgramaçãoI

Introdução ao OpenMP

Threads em CPU multicore

Rogério A. Gonçalves1,2 Alfredo Goldman2

1Departamento de Computação (DACOM)Universidade Tecnológica Federal do Paraná (UTFPR)

2Departamento de Ciência da Computação (DCC)Instituto de Matemática e Estatística (IME)

Universidade de São Paulo (USP)

[email protected], {rag, gold}@ime.usp.br

MAC0242 - Laboratório de Programação II

Gonçalves, Goldman Introdução ao OpenMP 12 de novembro de 2014 1 / 49

Roteiro

1 Introdução

2 Implementação de Threads

3 Abordagem do OpenMP

4 Diretivas de Compilação

5 Variáveis de Ambiente

6 Diretivas de Compilação

7 Diretivas de Sincronização

8 Bibliogra�a

9 Dúvidas


Objetivos

Uma visão geral sobre utilização de multithreading.

Alguns conceitos sobre concorrência e paralelismo.

Apresentar uma introdução sobre OpenMP com exemplos práticos.

Atividades.


Conceitos I

Arquitetura e Organização de Computadores e Sistemas Operacionais.

Monoprocessado x multiprocessado.

Monoprogramado x multiprogramado.

Processo: programa executando em um computador.

Múltiplos processos podem estar em execução ao mesmo tempo:browser, player de músicas, editor de textos...

Thread: parte de um programa. Processo Leve. Tarefa.


Conceitos II

Cada processo pode possuir uma ou múltiplas threads.

Exemplos:Um editor de textos, várias tarefas (typing, spell checking, printing...)Um servidor web, cada requisição atendida por uma thread.


Conceitos I

Em um computador convencional (single core):Cada processo gera pelo menos uma thread (�uxo de execuçãoprincipal).

Um processo é escalonado para execução, logo uma thread está emexecução por vez.Quando uma thread pára (por exemplo, devido a um page fault):

O estado da thread é guardado (registradores, ...)O estado de outra thread em espera é carregado no processador einicia-se sua execução.O que é chamado de troca de contexto (context switching).

Para o usuário parece que todas as threads executam simultaneamente.

Em um computador com processador multicore tem-se a possibilidadede paralelismo físico.


Conceitos II

Concorrência: Múltiplas tarefas estão logicamente ativas em ummesmo momento.

Paralelismo: Múltiplas tarefas estão realmente ativas em ummesmo momento.


Implementação de Threads em Linguagens de Programação I

Basicamente em todas as linguagens que suportam threads aimplementação segue a ideia de se ter uma função que é o código aser executado pela thread quando ela for criada.

Na linguagem C, podemos utilizar a biblioteca Pthreads doGNU/Linux.

Implementa a API padrão POSIX (IEEE 1003.1c) para criação esincronismo de thread.

A API especi�ca o comportamento da biblioteca de threads, aimplementação �ca para o desenvolvimento da biblioteca.

A especi�cação POSIX determina que os registradores do processador,a pilha e a máscara de sinal sejam mantidos individualmente para cadathread.



Básico de Pthreads:

Criar uma nova thread1 i n t p th r ead_crea t e ( pthread_t ∗ thread ,2 con s t pthread_att r_t ∗ a t t r ,3 vo i d ∗ (∗ s t a r t_ r o u t i n e ) ( vo i d ∗) ,4 vo i d ∗ arg ) ;

Aguardar pelo término de outra thread1 i n t p th r ead_jo i n ( pthread_t th , vo i d ∗∗ th r ead_re tu rn ) ;

Terminar a thread1 vo i d p th r ead_ex i t ( vo i d ∗ r e t v a l ) ;

Cancelar a execução da thread1 i n t p th read_cance l ( pthread_t th r ead ) ;



Na linguagem C com Pthreads:



Em Java existem pelo menos duas formas de criarmos threads.

Figura 1: Criação por Herança Figura 2: Implementação de Interface



Em Python também podemos criar threads:

Figura 3: Por herança Figura 4: Por alvo


Padrão OpenMP

Padrão OpenMP (Open Multi-Processing) (Chapman, 2008)

É Conjunto de diretivas de compilação mais um pequeno conjunto defunções de biblioteca e variáveis de ambiente que usam como base aslinguagens C/C++ e Fortran.

As diretivas de compilação são usadas para anotar o código eguiar o compilador no processo de tradução e paralelização de código.

Nas linguagens C e C++ as diretivas OpenMP são identi�cadas pelo#pragma omp, enquanto que na linguagem Fortran, as diretivas sãoidenti�cadas pela sentinela !$omp.

O código anotado com diretivas de preprocessamento (#pragma) étratado e então o código paralelo é gerado.


OpenMP

O OpenMP implementa o modelo fork-join.

As threads são criadas a partir de blocos de código anotados.

A master thread executa sequencialmente até encontrar a primeiraconstrução que delimita uma região paralela.

Uma operação similar a um fork acontece, fazendo com que um timede threads seja criado para executar o bloco que representa a regiãoparalela (a thread mestre participa do time).Gonçalves, Goldman Introdução ao OpenMP 12 de novembro de 2014 14 / 49

OpenMP

Vantagens do uso de OpenMP:Poucas alterações no código serial existente.Fácil compreensão e uso das diretivas.Suporte a paralelismo aninhado.Ajuste dinâmico do número de threads.

Sintaxe dos elementos de OpenMP para C/C++.Variáveis de Ambiente: OMP_NOMESão variáveis que controlam a execução do programa escrito comOpenMP.Diretivas de Compilação: #pragma omp diretiva [cláusula]

Instrui o compilador para processar a seção de código após adiretiva.Biblioteca e Rotinas: omp_serviço(...)Rotinas que manipulam e monitoram as threads, os processadorese as variáveis de ambiente. Existem rotinas para a sincronizaçãodas threads e para medir tempo.


Diretivas de Compilação: Construtor Paralelo (exe-001) I

Construtor Paralelo: #pragma omp parallel

É a diretiva mais importante do OpenMP.

É responsável pela indicação da região do código que será executadaem paralelo.

Se esse construtor não for especi�cado o programa será executado deforma sequencial.

Quando a thread inicial encontra um construtor paralelo ela cria umgrupo de threads que irão executar o código e torna-se a thread

mestre desse grupo.

Porém, esse construtor não divide o trabalho entre as threads, apenascria a região paralela.


Diretivas de Compilação: Construtor Paralelo (exe-001) II

Sintaxe

1 #pragma omp p a r a l l e l [ c l a u s u l a , . . . ] n o v a l i n h a2 I n s t r u c a o

Cláusulas que podem ser utilizadas nesse construtor

1 i f ( e x p r e s s a o l o g i c a )2 p r i v a t e ( l i s t a de v a r i a v e i s )3 sha r ed ( l i s t a de v a r i a v e i s )4 f i r s t p r i v a t e ( l i s t a de v a r i a v e i s )5 d e f a u l t ( sha r ed | none )6 copy i n ( l i s t a de v a r i a v e i s )7 r e d u c t i o n ( ope rado r : l i s t a de v a r i a v e i s )8 num_threads ( v a r i a v e l i n t e i r a )


Diretivas de Compilação: Construtor Paralelo (exe-001) III

Hello World!!!

1 #inc lude <s t d i o . h>2

3 i n t main ( ) {4 p r i n t f ( " He l l o World ! ! ! \ n" ) ;5 r e t u r n 0 ;6 }

1 #inc lude <s t d i o . h>2 #inc lude <omp . h>3

4 i n t main ( ) {5 #pragma omp p a r a l l e l6 {7 i n t i d = omp_get_thread_num ( ) ;8 p r i n t f ( "Thread[%d ] : He l l o World ! ! ! \ n" , i d ) ;9 }10 r e t u r n 0 ;11 }


Diretivas de Compilação: Construtor Paralelo (exe-001) IV

Condicional de Compilação - Para tornar possível a compilação de umprograma OpenMP tanto na versão paralela quanto na versãosequencial.

1 #inc lude <s t d i o . h>2 #i f d e f _OPENMP3 #inc lude <omp . h>4 #e l s e5 #def ine omp_get_thread_num ( ) 06 #end i f7

8 i n t main ( ) {9 #pragma omp p a r a l l e l10 {11 i n t i d = omp_get_thread_num ( ) ;12 p r i n t f ( "Thread[%d ] : He l l o World ! ! ! \ n" , i d ) ;13 }14 r e t u r n 0 ;15 }


Variáveis de Ambiente do OpenMP - (exe-002) I1 i n t main ( ) {2 i n t i ;3 i n t O_P; /∗ Numero de P r o c e s s ado r e s . ∗/4 i n t O_T; /∗ Numero de t h r e ad s OpenMP . ∗/5 i n t O_ID ; /∗ I d da Thread OpenMP . ∗/67 p r i n t f ( "Teste 1 −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\n" ) ;8 O_P = omp_get_num_procs ( ) ; /∗ Recupera o numero de p r o c e s s a d o r e s . ∗/9 O_T = omp_get_num_threads ( ) ; /∗ Recupera o numero de t h r e ad s . ∗/10 O_ID = omp_get_thread_num ( ) ; /∗ r e c up e r a o i d da th r ead OpenMP . ∗/11 p r i n t f ( "Thread i d : %d #Procs : %d #Threads : %d\n" , O_ID, O_P, O_T) ;1213 p r i n t f ( "Teste 2 −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\n" ) ;14 #pragma omp p a r a l l e l15 {16 O_P = omp_get_num_procs ( ) ;17 O_T = omp_get_num_threads ( ) ;18 O_ID = omp_get_thread_num ( ) ;19 p r i n t f ( "Thread i d : %d #Procs : %d #Threads : %d\n" , O_ID, O_P, O_T) ;20 }2122 p r i n t f ( "Teste 3 −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\n" ) ;23 #pragma omp p a r a l l e l num_threads (8 )24 {25 O_P = omp_get_num_procs ( ) ;26 O_T = omp_get_num_threads ( ) ;27 O_ID = omp_get_thread_num ( ) ;28 p r i n t f ( "Thread i d : %d #Procs : %d #Threads : %d\n" , O_ID, O_P, O_T) ;29 }30 r e t u r n 0 ;31 }


Variáveis de Ambiente do OpenMP - (exe-002) II

Terminalrogerio@guarani:aula -intro -openmp/src/exe -002$ ./variaveis -omp -03

Teste 1 --------------------------------------------

Thread id: 0 #Procs: 2 #OpenMP Threads: 1

Teste 2 --------------------------------------------



Teste 3 --------------------------------------------









rogerio@guarani:aulas -openmp/aula -intro -openmp/src/exe -002$


Construtores de compartilhamento de trabalho I

São construtores responsáveis pela distribuição de trabalho entre asthreads.Em C/C++ existem três tipos de Construtores de Compartilhamentode Trabalho:

Diretiva for

Diretiva sections

Diretiva single

Indicam a forma como o trabalho será dividido, mas não criam novasthreads.

Estas diretivas devem estar dentro de uma região paralela.

Existe uma barreira implícita no �nal do construtor, todas as threadsesperam até que a última thread �nalize sua execução.



Construtor: #pragma omp for

Faz com que as iterações do laço de repetição localizado logo abaixoda diretiva sejam executadas em paralelo.

As iterações são distribuídas entre as threads do grupo criado naregião paralela.

Sintaxe

1 #pragma omp f o r [ c l a u s u l a , . . . ]2 f o r−l oop


Construtores de compartilhamento de trabalho II

Cláusulas que podem ser utilizadas nesse construtor

1 p r i v a t e ( l i s t a de v a r i v e i s )2 f i r s t p r i v a t e ( l i s t a de v a r i v e i s )3 l a s t p r i v a t e ( l i s t a de v a r i a v e i s )4 r e d u c t i o n ( ope rado r : l i s t a de v a r i a v e i s )5 s c h edu l e ( t i po , [ , tamanho do chunk ] )6 nowa i t7 o rd e r ed



Exemplo [exe-003]:

1 #def ine SIZE 162

3 i n t main ( ) {4 i n t A[ SIZE ] , i ;5 #pragma omp p a r a l l e l f o r6 f o r ( i = 0 ; i < SIZE ; i++){7 A[ i ] = i ∗ i ;8 p r i n t f ( "Th[%d ] : %02d = %03d\n" , omp_get_thread_num ( ) ,

i , A [ i ] ) ;9 }10

11 r e t u r n 0 ;12 }



Terminalrogerio@guarani:aula -intro -openmp/src/exe -003$ ./vetquad -omp -03

Th[0]: 00 = 000

Th[0]: 01 = 001

Th[0]: 02 = 004

Th[0]: 03 = 009

Th[0]: 04 = 016

Th[0]: 05 = 025

Th[0]: 06 = 036

Th[0]: 07 = 049

Th[1]: 08 = 064

Th[1]: 09 = 081

Th[1]: 10 = 100

Th[1]: 11 = 121

Th[1]: 12 = 144

Th[1]: 13 = 169

Th[1]: 14 = 196

Th[1]: 15 = 225

rogerio@guarani:aula -intro -openmp/src/exe -003$



Exemplo [exe-003]:

1 #def ine SIZE 162

3 i n t main ( ) {4 i n t A[ SIZE ] , i ;5 #pragma omp p a r a l l e l f o r s c h edu l e ( s t a t i c , 2)6 f o r ( i = 0 ; i < SIZE ; i++){7 A[ i ] = i ∗ i ;8 p r i n t f ( "Th[%d ] : %02d = %03d\n" , omp_get_thread_num ( ) ,

i , A [ i ] ) ;9 }10

11 r e t u r n 0 ;12 }




Th[0]: 00 = 000

Th[0]: 01 = 001

Th[0]: 04 = 016

Th[0]: 05 = 025

Th[0]: 08 = 064

Th[0]: 09 = 081

Th[0]: 12 = 144

Th[0]: 13 = 169

Th[1]: 02 = 004

Th[1]: 03 = 009

Th[1]: 06 = 036

Th[1]: 07 = 049

Th[1]: 10 = 100

Th[1]: 11 = 121

Th[1]: 14 = 196

Th[1]: 15 = 225




Exemplo [exe-003]:

1 #def ine SIZE 162

3 i n t main ( ) {4 i n t A[ SIZE ] , i ;5 #pragma omp p a r a l l e l f o r s c h edu l e ( s t a t i c , 2) num_threads

(4 )6 f o r ( i = 0 ; i < SIZE ; i++){7 A[ i ] = i ∗ i ;8 p r i n t f ( "Th[%d ] : %02d = %03d\n" , omp_get_thread_num ( ) ,

i , A [ i ] ) ;9 }10

11 r e t u r n 0 ;12 }




Th[2]: 04 = 016

Th[2]: 05 = 025

Th[2]: 12 = 144

Th[2]: 13 = 169

Th[3]: 06 = 036

Th[3]: 07 = 049

Th[3]: 14 = 196

Th[3]: 15 = 225

Th[0]: 00 = 000

Th[0]: 01 = 001

Th[0]: 08 = 064

Th[0]: 09 = 081

Th[1]: 02 = 004

Th[1]: 03 = 009

Th[1]: 10 = 100

Th[1]: 11 = 121




Exemplo [exe-003]:

1 #def ine SIZE 162

3 i n t main ( ) {4 i n t A[ SIZE ] , i ;5 #pragma omp p a r a l l e l f o r s c h edu l e ( s t a t i c , 2) num_threads

(4 ) o rd e r ed6 f o r ( i = 0 ; i < SIZE ; i++){7 A[ i ] = i ∗ i ;8 p r i n t f ( "Th[%d ] : %02d = %03d\n" , omp_get_thread_num ( ) ,

i , A [ i ] ) ;9 }10

11 r e t u r n 0 ;12 }




Th[2]: 04 = 016

Th[2]: 05 = 025

Th[1]: 02 = 004

Th[1]: 03 = 009

Th[3]: 06 = 036

Th[3]: 07 = 049

Th[0]: 00 = 000

Th[0]: 01 = 001

Th[0]: 08 = 064

Th[0]: 09 = 081

Th[1]: 10 = 100

Th[1]: 11 = 121

Th[2]: 12 = 144

Th[2]: 13 = 169

Th[3]: 14 = 196

Th[3]: 15 = 225




Construtor: #pragma omp sections

É utilizado para dividir tarefas entre as threads em blocos de códigoque não possuem iterações.

Cada thread irá executar um bloco de código diferente especi�cadopor #pragma omp section. executar.

Sintaxe

1 #pragma omp s e c t i o n s [ c l a u s u l a , . . . ] n o v a l i n h a2 {3 #pragma omp s e c t i o n no v a l i n h a4 i n s t r u c a o5 #pragma omp s e c t i o n no v a l i n h a6 i n s t r u c a o7 }



Exemplo sections:

1 vo i d somarVetores ( doub l e ∗a , doub l e ∗b , doub l e ∗c , i n t n ) {2 f o r ( i n t i = 0 ; i < n ; i++){3 c [ i ] = a [ i ] + b [ i ] ;4 }5 }6

7 vo i d s u b t r a i r V e t o r e s ( doub l e ∗a , doub l e ∗b , doub l e ∗d , i n tn ) {

8 f o r ( i n t i = 0 ; i < n ; i++){9 d [ i ] = a [ i ] − b [ i ] ;10 }11 }



1 i n t main ( ) {2 /∗ . . . ∗/3 #pragma omp p a r a l l e l4 {5 #pragma omp s e c t i o n s6 {7 #pragma omp s e c t i o n8 somarVetores ( a , b , c , n ) ;9

10 #pragma omp s e c t i o n11 s u b t r a i r V e t o r e s ( a , b , d , n ) ;12 }13 }14 r e t u r n 0 ;15 }



Construtor: #pragma omp single

Indica que o trecho de código deve ser executado por apenas umathread.

A primeira thread que atingir a região executará, não necessariamentea mestre.

As outras threads esperam em uma barreira implícita no �nal doconstrutor single, até que a thread que encontrou o construtortermine.

Sintaxe

1 #pragma omp s i n g l e [ c l a u s u l a , . . . ]2 i n s t r u c a o . . .



1 i n t main ( ) {2 i n t A[ SIZE ] , i ;3

4 #pragma omp p a r a l l e l num_threads (4 )5 {6 #pragma omp s i n g l e7 p r i n t f ( " I n i c i o da r e g i a o p a r a l e l a , numero de t h r e ad s =

%d\n" , omp_get_num_threads ( ) ) ;8

9 #pragma omp f o r s c h edu l e ( s t a t i c , 3)10 f o r ( i = 0 ; i < SIZE ; i++){11 A[ i ] = i ∗ i ;12 p r i n t f ( "Thread %d execu ta a i t e r a c a o %02d do loop . \ n

" , omp_get_thread_num ( ) , i ) ;13 }14 }15 r e t u r n 0 ;16 }


Construtores de compartilhamento de trabalho III


Inicio da regiao paralela , numero de threads = 4

Thread 2 executa a iteracao 06 do loop.


















Diretivas de sincronização I

Como uma variável pode ser privada (private) ou compartilhada(shared).

Uma vez que as variáveis compartilhadas são visíveis por todas asthreads que executam o código.

O acesso a elas deve ser sincronizado par evitar "condições de corrida".

O construtor critical restringe a execução de uma tarefa a apenasuma thread por vez.

Sintaxe

1 #pragma omp c r i t i c a l [ ( nome) ] n o v a l i n h a2 i n s t r u c a o


Diretivas de sincronização II

Quando uma thread encontra uma sessão crítica, ela espera no inícioda mesma até que nenhuma thread esteja executando as instruções daregião crítica.


Diretivas de sincronização III

1 #def ine SIZE 162

3 i n t main ( ) {4 i n t A[ SIZE ] , B [ SIZE ] , i ;5 i n t aux_dot = 0 ;6 i n t dot = 0 ;7

8 f o r ( i = 0 ; i < SIZE ; i++){9 A[ i ] = i ;10 B[ i ] = i ;11 }12

13 #pragma omp p a r a l l e l f i r s t p r i v a t e ( dot )14 {15 #pragma omp s i n g l e16 p r i n t f ( " I n i c i o da r e g i a o p a r a l e l a , numero de t h r e ad s =

%d\n" , omp_get_num_threads ( ) ) ;17

18 #pragma omp f o r


Diretivas de sincronização IV

19 f o r ( i = 0 ; i < SIZE ; i++){20 aux_dot += A[ i ] ∗ B[ i ] ;21 p r i n t f ( "Thread %d execu ta a i t e r a c a o %02d do loop :

%d ∗ %d = %d −> %d \n" , omp_get_thread_num ( ) , i, A [ i ] , B [ i ] , (A [ i ] ∗ B[ i ] ) , aux_dot ) ;

22 }23

24 #pragma omp c r i t i c a l25 dot += aux_dot ;26

27 #pragma omp master28 p r i n t f ( "Produto f i n a l : %d . \ n" , dot ) ;29 }30

31 r e t u r n 0 ;32 }


Diretivas de sincronização V

Terminalrogerio@guarani:aula -intro -openmp/src/exe -007$ ./ vetdot

Inicio da regiao paralela , numero de threads = 2

Thread 1 executa a iteracao 08 do loop: 8 * 8 = 64 -> 64
















Produto final: 1240.



Diretivas de sincronização I

A diretiva barrier é utilizada para sincronizar todas as threads emum determinado ponto do código.


Diretivas de sincronização II

Quando uma thread encontra uma barreira, ela espera até que todasas threads cheguem naquele ponto e, a partir daí, elas continuam aexecução.

Os construtores como parallel, for, sections e single tem barreirasimplícitas.

Utilizadas para evitar condições de corrida, impedindo que uma thread

acesse uma variável antes que ela seja atulizada.

Sintaxe

1 #pragma omp b a r r i e r n o v a l i n h a


Diretivas de sincronização III

1 i n t main ( ) {2 i n t i d ;3 #pragma omp p a r a l l e l p r i v a t e ( i d ) num_threads (8 )4 {5 i d = omp_get_thread_num ( ) ;6

7 i f ( i d < omp_get_num_threads ( ) /2)8 system ( " s l e e p 3" ) ;9

10 p r i n t f ( "[%d ] Antes da b a r r e i r a . \ n" , i d ) ;11

12 #pragma omp b a r r i e r13 p r i n t f ( "[%d ] Depo i s da b a r r e i r a . \ n" , i d ) ;14 }15

16 r e t u r n 0 ;17 }


Diretivas de sincronização IV

Terminalrogerio@guarani:aula -intro -openmp/src/exe -008$ ./ barrier

[6] Antes da barreira.








[2] Depois da barreira.










Referências

Tutorial de OpenMP C/C++:

http://www.lncc.br/pdf_consultar.php?idt_arquivo=4286


http://www.lncc.br/pdf_consultar.php?idt_arquivo=4286

Obrigado!

[email protected]

[email protected]


Documents

Introdução ao OpenMPgrenoble.ime.usp.br/~gold/cursos/2014/labprogII/aulas/aulaOpenMP.pdf · de paralelismo físico. ... Implementação de Threads em Linguagens de ProgramaçãoI