Directivas OpenMP

Hola amigos en el post pasado estuve hablandoles un poco sobre algunas pragmas y mencione algunas clausulas utilizadas en OpenMP. Hoy regreso hablandoles un poco mas sobre ello, con algunos ejemplos y explicando algunas directivas.  Los ejemplos y algunos conceptos fueron tomados de esta fuente, puesto que me gusta mucho como explican y son bastante claros los ejemplos.

Directivas OpenMP

Directivas de reparto

Directiva for

La directiva for especifica que las iteraciones del bucle siguiente inmediatamente se deben ejecutar en paralelo por el grupo de procesadores.

Sintaxis 

#pragma omp for [clausulas]  newline 
                schedule (type ,[chunk]) 
                ordered
                private (list) 
                shared (list) 
                reduction (operator: list) 
               
                bucle for(){}

Ejemplo:

#include 
#define CHUNKSIZE 100
#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;
chunk = CHUNKSIZE;

#pragma omp parallel shared(a,b,c,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 */
}

Clausulas

schedule: Decide como se distribuiyen las iteraciones de un bucle entre los hilos la planificación por defecto depende de la implementación.

• schedule(static,chunk) : distribuye un subconjunto de iteraciones en cada thread de modo circular. El tamaño viene dado por "chunk" si no se especifica chunk, la distribucion es por bloques.
• schedule(dynamic,chunk) : El valor por defecto de chunk es 1, es casi igual que static, pero los bloques se reparten dinamicamente a medida que los hilos van finalizando.
• schedule(guided,chunk) :  Con \[N\] iteraciones y \[p\] hilos se distribuye dinamicamente en \[\frac{N}{kp}\] iteraciones en cada hilo, donde \[k\] depende de la iteración.

Directiva sections

La directiva sections nos permite repartir o distribuir trozos de nuestro codigo. Este es un esquema de como trabajaria la diretiva sections.

float A[100];
#pragma omp parallel 
#pragma omp sections shared(A)
{   #pragma omp section
          calculamedia(A);
    #pragma omp section 
          calculamaximo(A);
    #pragma omp section
          calculadesviacion(A);
}

Directiva single

Sirve para que un solo hilo ejecute ese bloque.

#pragma omp single [clausulas]
      {bloque estructurado}

Directiva reduction

Inicialmente las iteraciones del bucle paralelo se distribuirán en bloques de igual tamaño para cada hilo.
Al final del bucle paralelo, todos los hilo compartiran sus valores de "resultado" para actualizar la copia global el hilo maestro. 

#include <omp.h>
#include <stdio.h>

int 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);
}

Directivas de sincronización  master, critical, barrier, atomic, ordered.

Directiva master

Para esta directiva el bloque de codigo solo lo hace el maestro y no tiene barreras, los demas hilos saltan el bloque de codigo y continuan la ejecución del programa.

#pragma omp master
      {bloque estructurado} 

Directiva critical
Esta directiva especifica partes criticas del código, que los hilos deben ejecutar todos uno a la vez. A veces sirbe mas que todo para variables compartidas para que no hayan colisiones.

#pragma omp critical [nombre]
      {bloque estructurado} 

Directiva barrier
Esta directiva especifica una barrera en la que todos y cada uno de los hilos debera esperar al otro, una vez todos hayan llegado a la barrera, continuan su trabajo en paralelo.

#pragma omp barrier 

Directiva atomic

Asegura que una locación de memoria especifica, va a ser actualizada de forma atomica, es decir no se van a produsir multiples escrituras desde diferentes hilos. Si notan la diferencia, atomic sincroniza a través de variables compartidas y critical sincroniza a través de instrucciones.

  

#pragma omp atomic
      statement_expression 

Directiva ordered

Se utiliza dentro de bucles para que partes dentro del bucle se realicen en orden. 

#pragma omp for ordered [clauses...]
   (loop region)
#pragma omp ordered  newline
   structured_block
   (endo of loop region) 

Bueno amigos esto es todo por hoy, hasta un nuevo post posiblemente sea una recopilación de algunos códigos que he ejecutado con OpenMP y mas adelante estare hablando sobre MPI hasta una nueva ocasión.

Sumario :