EXEMPLO_1 
  
// diretiva parallel
// função omp_get_thread_num()
// compile with gcc
// omp_parallel.cpp
      
#include <stdio.h>  
#include <omp.h>  
  
int main() {  
   #pragma omp parallel num_threads(4)  
   {  
      int i = omp_get_thread_num();  
      printf_s("Hello from thread %d\n", i);  
   }  
}  

Output
Hello from thread 0  
Hello from thread 1  
Hello from thread 2  
Hello from thread 3  

1.1 O que ocorre sob a diretiva parallel no código sujacente ?

1.2 Qual o efeito de num_threads ?

1.3 O que realiza a função omp_get_thread_num() ?

=====================================================================

EXEMPLO_2

// omp_master.cpp  
// compile with: /openmp   
#include <omp.h>  
#include <stdio.h>  
  
int main( )   
{  
    int a[5], i;  
  
    #pragma omp parallel  
    {  
        // Perform some computation.  
        #pragma omp for  
        for (i = 0; i < 5; i++)  
            a[i] = i * i;  
  
        // Print intermediate results.  
        #pragma omp master  
            for (i = 0; i < 5; i++)  
                printf_s("a[%d] = %d\n", i, a[i]);  
  
        // Wait.  
        #pragma omp barrier  // Sincroniza todas as threads paralelas; todas as threads pausam na barreira, 
                             // até que todas as threads executem a barreira.
  
        // Continue with the computation.  
        #pragma omp for  // Faz com que o trabalho feito e um loop for, dentro de uma região paralela, 
                         // seja dividido entre threads. Cada i é uma thread.
        for (i = 0; i < 5; i++)  
            a[i] += i;
        printf_s("a[%d] = %d\n", i, a[i]); // Bosco
    }  
}  

Output
a[0] = 0  
a[1] = 1  
a[2] = 4  
a[3] = 9  
a[4] = 16  

2.1 Qual a diferença entre #pragma omp for e o for (i = 0; i < 5; i++) ?

2.2 O que significa #pragma omp master ?

A diretiva master permite especificar que uma seção de código deve ser executada em uma única thread, 
não necessariamente a thread principal.


2.3 O que significa #pragma omp barrier ?

2.4 O que significa #pragma omp for sobre o for (i = 0; i < 5; i++) ?



=========================================================================

EXEMPLO_3

// omp_sections.cpp  
// compile with: /openmp   
#include <stdio.h>  
#include <omp.h>  
  
int main() {  
    #pragma omp parallel sections num_threads(4)  
    {  
        printf_s("Hello from thread %d\n", omp_get_thread_num());
        
        // definindo uma seção paralela  
        #pragma omp section  
        printf_s("Hello from thread %d\n", omp_get_thread_num());  
    }  
}  

Output
Hello from thread 0  
Hello from thread 0  

3.1 Qual a diferença entre #pragma omp parallel e #pragma omp section ?

3.2 Quantas seções paralelas são programadas no código acima ?



=========================================================================

EXEMPLO_4

// omp_atomic.cpp  
// compile with: /openmp   
#include <stdio.h>  
#include <omp.h>  
  
#define MAX 10  
  
int main() {  
   int count = 0;  
   #pragma omp parallel num_threads(MAX)  
   {  
      #pragma omp atomic  // count é um local de memória que você deseja proteger contra várias gravações
      count++;  
   }  
   printf_s("Number of threads: %d\n", count);  
}  

Output
Number of threads: 10  

4.1 Qual o efeito de #pragma omp atomic sobre a variável count ?

==========================================================================

EXEMPLO_5

// omp_critical.cpp  
// compile with: /openmp   
#include <omp.h>  
#include <stdio.h>  
#include <stdlib.h>  
  
#define SIZE 10  
  
int main()   
{  
    int i;  
    int max;  
    int a[SIZE];  
  
    for (i = 0; i < SIZE; i++)   
    {  
        a[i] = rand();  
        printf_s("%d\n", a[i]);  
    }  
  
    max = a[0];  
    #pragma omp parallel for num_threads(4)  
        for (i = 1; i < SIZE; i++)   
        {  
            if (a[i] > max)  
            {  
                #pragma omp critical  
                {  
                    // compare a[i] and max again because max   
                    // could have been changed by another thread after   
                    // the comparison outside the critical section  
                    if (a[i] > max)  
                        max = a[i];  
                }  
            }  
        }  
  
    printf_s("max = %d\n", max);  
}  

Output
41  
18467  
6334  
26500  
19169  
15724  
11478  
29358  
26962  
24464  
max = 29358  

5.1 Qual o efeito de #pragma omp critical  sobre o código if (a[i] > max) max = a[i]; ?

5.2 Qual a diferença básica entre as diretivas atomic e critical ?

atomic = Especifica que um local de memória que será atualizado numa única etapa de processamento, 
         relativa a outras threads. (Lê-modifica-escreve)

critical = A diretiva “critical” do OpenMP é completamente genérica - pode cercar qualquer
           bloco arbitrário de código. Ao passo que em uma diretiva “atomic” existe sobre uma única
           expressão.