EXEMPLO_6

/* Uso da cláusula reduction */
/* Especifica que uma ou mais variáveis que são particulares 
   a cada thread, fazem parte de uma operação de redução no final da região paralela.
*/
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>

int main (int argc, char *argv[]) {
 int i, n;
 float a[100], b[100], sum;

 n = 100; /* Some initializations */
 for (i=0; i < n; i++)
    a[i] = b[i] = i * 1.0;

 sum = 0.0;
 #pragma omp parallel for reduction(+:sum)
 for (i=0; i < n; i++)
     sum = sum + (a[i] * b[i]);
 printf(" Sum = %f\n",sum);
}


1. Para que serve a cláusula reduction(+:sum) ? 

2. Qual o resultado obtido após a redução da variável sum ?


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


EXEMPLO_7

/* Uso das diretivas parallel, for, master */
/* Uso das cláusulas shared, private, schedule, nowait */
/* CHUNK é o tamanho do segmento de iterações, no caso existem 100, divididas de 10 em 10, sendo CHUNK uma constante inteira 
/* com CHUNKSIZE igual a 10. */
// 
#include <omp.h>
#define CHUNKSIZE 10
#define N 100
main() {
   int i, chunk;
   float a[N], b[N], c[N];
   /* Algumas inicializacoes */
   for (i=0; i < N; i++)
       a[i] = b[i] = i * 1.0;
       chunk = CHUNKSIZE; 
   //
   #pragma omp parallel shared(a,b,c,chunk) private(i) {
       // threads são paralelizadas com o código imediatamente abaixo
       #pragma omp for schedule(static,chunk) nowait
           for (i=0; i < N; i++)
               c[i] = a[i] + b[i];
       //
   } // fim da secção paralela/
   //
   // print final results.  
   #pragma omp master  
       for (i = 0; i < N; i++)  
           printf_s("a[%d] = %d\n", i, a[i]);
}


1. O que significa shared(a,b,c,chunk) ?

2. O que significa private(i) ?

3. O que significa schedule(static,chunk) ? O que acontece ?

4. E se usarmos schedule(dynamic,chunk), o que acontece ?


================================================================================================
EXEMPLO_8

// omp_nowait.cpp  
// compile with: /openmp /c
// Uso da cláusula nowait   
#include <stdio.h>  
  
#define SIZE 5  
  
void test(int *a, int *b, int *c, int size)   
{  
    int i;  
    #pragma omp parallel  
    {  
        #pragma omp for nowait  
        for (i = 0; i < size; i++)  
            b[i] = a[i] * a[i];  
  
        #pragma omp for nowait  
        for (i = 0; i < size; i++)  
            c[i] = a[i]/2;  
    }  
}  
  
int main( )   
{  
    int a[SIZE], b[SIZE], c[SIZE];  
    int i;  
  
    for (i=0; i<SIZE; i++)  
        a[i] = i;  
  
    test(a,b,c, SIZE);  
  
    for (i=0; i<SIZE; i++)  
        printf("%d, %d, %d\n", a[i], b[i], c[i]);  
}  


Output
0, 0, 0  
1, 1, 0  
2, 4, 1  
3, 9, 1  
4, 16, 2  

1. O que significa a cláusula nowait no código acima ?

   Esta cláusula substitui a barreira implícita em uma diretiva. No caso a diretiva for. A cláusula nowait 
   pode ser também aplicada na diretiva sections.
   
===================================================================================================================

EXEMPLO_9

/* Ilustra o uso de algumas funções do OpenMP */

#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
int main (int argc, char *argv[]) {
    
    int nthreads, tid, procs, maxt, inpar, dynamic, nested;

    /* Start parallel region */
    #pragma omp parallel private(nthreads, tid) {
 
       /* Obtain thread number */
       tid = omp_get_thread_num();  // 
  
       /* Only master thread does this */
       if (tid == 0) {
          printf("Thread %d getting info...\n", tid);

     
       /* Get environment information */
          procs = omp_get_num_procs(); // omp_get_num_procs() retorna o número de processadores que estão disponíveis quando 
                                       // a função for chamada.
          nthreads = omp_get_num_threads(); omp_get_num_threads() retorna o número de threads na região paralela.
          maxt = omp_get_max_threads(); // omp_get_max_threads() retorna o número máximo de threads permitidos                             
          inpar = omp_in_parallel(); // omp_in_parallel() retorna zero, se for chamada dentro de uma região paralela.
          nested = omp_get_nested(); // omp_get_nested() retorna um valor que indica se 
                                     // o paralelismo aninhado está habilitado.
 
       /* Print environment information */
          printf("Number of processors = %d\n", procs);
          printf("Number of threads = %d\n", nthreads);
          printf("Max threads = %d\n", maxt);
          printf("In parallel? = %d\n", inpar);
       }
 } /* parallel done */
} 

1. Para que serve a função omp_get_num_procs() ?


2. Para que serve a função omp_get_num_threads() ?


3. Para que serve a função omp_get_max_threads() ?


4. Para que serve a função omp_in_parallel() ?

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

EXEMPLO_10

#include <omp.h>
#define N 1000

main() {
  int i, chunk;
  float a[N], b[N], c[N];

  // Some initializations
  for (i=0; i < N; i++)
      a[i] = b[i] = i * 1.0;

  #pragma omp parallel shared(a,b,c) 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];

     } // fim de secções
}



1. Para que serve o primeiro section ?



2. Para que serve o segundo section ?