OpenMP

OpenMP es una interfaz de programación de aplicaciones (API) para la programación multiproceso de memoria compartida en múltiples plataformas. Permite añadir concurrencia a los programas escritos en C, C++ y Fortran sobre la base del modelo de ejecución fork-join. Está disponible en muchas arquitecturas, incluidas las plataformas de Unix y de Microsoft Windows. Se compone de un conjunto de directivas de compilador, rutinas de biblioteca, y variables de entorno que influyen el comportamiento en tiempo de ejecución.

Definido conjuntamente por proveedores de hardware y de software, OpenMP es un modelo de programación portable y escalable que proporciona a los programadores una interfaz simple y flexible para el desarrollo de aplicaciones paralelas, para plataformas que van desde las computadoras de escritorio hasta supercomputadoras. Una aplicación construida con un modelo de programación paralela híbrido se puede ejecutar en un cluster de computadoras utilizando OpenMP y MPI, o a través de las extensiones de OpenMP para los sistemas de memoria distribuida.

Modelo de ejecución

OpenMP se basa en el modelo fork-join, paradigma que proviene de los sistemas Unix, donde una tarea muy pesada se divide en K hilos (fork) con menor peso, para luego "recolectar" sus resultados al final y unirlos en un solo resultado (join).

Sintaxis básica

La sintaxis básica que nos encontramos en una directiva de OpenMP es para C/C++:

# pragma omp <directiva> [cláusula [ , ...] ...]

para Fortran:

!$OMP  PARALLEL <directiva> [cláusulas]
    [ bloque de código ]
!$OMP END <directiva>

Modelo de Ejecución

Cuando se incluye una directiva OpenMP esto implica que se incluye una sincronización obligatoria en todo el bloque. Es decir, el bloque de código se marcará como paralelo y se lanzarán hilos según las características que nos dé la directiva, y al final de ella habrá una barrera para la sincronización de los diferentes hilos (salvo que implícitamente se indique lo contrario con la directiva nowait). Este tipo de ejecución se denomina fork-join.

Directivas

También se suelen llamar constructores:

parallel: Esta directiva nos indica que la parte de código que la comprende puede ser ejecutada por varios hilos.
for: Igual que parallel pero optimizado para los bucles for. Su formato es:
```
#pragma parallel for [cláusula, ... , cláusula]
```
section y sections: Indica secciones que pueden ejecutarse en paralelo pero por un único hilo.
single: La parte de código que define esta directiva, sólo se puede ejecutar un único hilo de todos los lanzados, y no tiene que ser obligatoriamente el hilo padre.
master: La parte de código definida, sólo se puede ejecutar por el hilo padre.
critical: Sólo un hilo puede estar en esta sección. Definen secciones críticas o condiciones de carrera.
atomic: Se utiliza cuando la operación atañe a sólo una posición de memoria, y tiene que ser actualizada sólo por un hilo simultáneamente. Operaciones tipo x++ o --x son las que usan esta cláusula.
flush: Esta directiva resuelve la consistencia, al exportar a todos los hilos un valor modificado de una variable que ha realizado otro hilo en el procesamiento paralelo.
shared:Los datos de la región paralela son compartidos,lo que significa que son visibles y accesibles por todos los threads. Por definición, todas las variables que trabajan en la región paralela son compartidas excepto el contador de iteraciones.
private:Los datos de la región paralela son privados para cada thread, lo que significa que cada thread tendrá una copia local que la usará como variable temporal. Una variable privada no es inicializada y tampoco se mantiene fuera de la región paralela. Por definición, el contador de iteraciones en OpenMP es privado.
default:Permite al programador que todas las variables de la región paralela sean shared o no para C/C++, o shared, firstprivate, private, o none para Fortran. La opción none fuerza al programador a declarar de que tipo será cada variable en la región paralela.
firstprivate:Como private pero se inicializa con el valor original.
reduction:Hace una operacion(suma, resta, multiplicación, etc) privada en cada iteración y al final suma cada resultado.

Cláusulas de Scheduling

schedule(tipo, chunk): Esto és útil si la carga procesal es un bucle do o un buble for. Las iteraciones son asignadas a los threads basandose en el método definido en la cláusula. Los tres tipos de scheduling son:

static: Aquí todas las iteraciones se reparten entre los threads antes de que estos ejecuten el bucle. Se reparten las iteraciones contiguas equitativamente entre todos los threads. Especificando un integer como parametro de chunk serán repartidas tantas iteraciones contiguas al mismo thread como el chunk indique.
dynamic: Aqui al igual que en static se reparten todas las iteraciones entre los threads. cuando un thread en concreto acaba las iteraciones asignadas, entonces ejecuta una de las iteraciones que estaban por ejecutar. El parámetro chunk define el número de iteraciones contiguas que cada thread ejecutará a la vez.
guided: Un gran número de iteraciones contiguas són asignadas a un thread. Dicha cantidad de iteraciones decrece exponencialmente con cada nueva assignación hasta un mínimo especificado por el parámetro chunk

Funciones

omp_set_num_threads: Fija el número de hilos simultáneos.
omp_get_num_threads: Devuelve el número de hilos en ejecución.
omp_get_max_threads: Devuelve el número máximo de hilos que lanzará nuestro programa en las zonas paralelas. Es muy útil para reservar memoria para cada hilo.
omp_get_thread_num: Devuelve el número del thread dentro del equipo (valor entre 0 y omp_get_num_threads()-1)
omp_get_num_procs: Devuelve en número de procesadores de nuestro ordenador o disponibles (para sistemas virtuales).
omp_set_dynamic: Valor booleano que nos permite expecificar si queremos que el número de hilos crezca y decrezca dinámicamente.

Véase también

Programación paralela

Web relacionadas

Sitio Oficial de OpenMP