cuda - ¿Openacc vs openmp y mpi diferencias?

opencl

Question

Me preguntaba cuáles son las principales diferencias entre openacc y openmp. ¿Qué pasa con MPI, cuda y opencl? Entiendo las diferencias entre openmp y mpi, especialmente la parte sobre memoria compartida y distribuida ¿Alguno de ellos permite una configuración de procesamiento híbrido gpu-cpu?

Answer 1

En primer lugar, nunca programé utilizando OpenMP / MPI / OpenAcc / Cuda. La única API que conozco es OpenCL, así que ten cuidado con lo que digo a continuación, necesita confirmación: ¡p!

Me siento más cómodo con OpenCL pero creo que no hay mucha diferencia entre Cuda y OpenCL en su proceso de compilación: el compilador incorporará las funciones (es decir, núcleos dentro de su código C). Luego, en su programa OpenCL / Cuda, puede realizar el funcionamiento de la CPU entre dos tareas de GPU.

Para ellos, hay varios tipos de memoria:

• global: lectura / escritura por el cpu y el gpu
• local: solo lectura / escritura por gpu.
• privado: la memoria de un núcleo simple donde se almacenan todas las variables declaradas dentro de un núcleo (solo gpu-core)
• constante: la memoria utilizada para la definición de constantes (solo gpu-core)

Habría más que decir al respecto, pero puede encontrar fácilmente buenas guías al respecto en la red.

Luego, como su compilación está en línea, puede hacer un programa de GPU / CPU. Incluso puedes usar OpenMP con OpenCL en un mismo programa, no veo ningún problema en ello.

Answer 2

Lea acerca de los paradigmas compartidos y distribuidos, su pregunta puede responderse en dos cursos de nivel de grado con más detalle. Recomiendo asistir a la capacitación de verano del TACC (Texas Advanced Computing Center) si está realmente interesado en el aprendizaje práctico.

Answer 3

OpenAcc y OpenMPI permiten la computación paralela basada en directivas. OpenMPI intenta aprovechar múltiples núcleos de CPU, OpenAcc intenta utilizar los núcleos de GPU.

MPI - Interfaz de análisis de mensajes, es una especificación de modelo de programación para la comunicación entre nodos entre nodos y dentro de un nodo. El proceso del programa MPI tiene un espacio de dirección privado, que permite que el programa se ejecute en un espacio de memoria distribuida (clúster). Normalmente, MPI se usa en computación de alto rendimiento donde se usan protocolos de comunicación con alto ancho de banda y baja latencia (como Infiniband, etc.).

Con el reciente desarrollo en tecnologías de computación paralela como CUDA y OpenMP, MPI ha agregado características en su especificación para aprovechar la computación paralela ofrecida por los núcleos de cpu / gpu.

CUDA-Aware-MPI y / o los modelos de programación híbrida (MPI + OpenMP) ya están en uso. Esto significa que el programador de aplicaciones final puede escribir el mismo programa MPI sin manejar explícitamente CUDA u OpenMP. Esto ha reducido la carga para el usuario final.

Para Exammple sin CUDA_aware-GPU, el código para MPI_Send y MPI_Recv sería como

//MPI rank 0
cudaMemcpy(s_buf_h,s_buf_d,size,cudaMemcpyDeviceToHost);
MPI_Send(s_buf_h,size,MPI_CHAR,1,100,MPI_COMM_WORLD);
//MPI rank 1
MPI_Recv(r_buf_h,size,MPI_CHAR,0,100,MPI_COMM_WORLD, &status);
cudaMemcpy(r_buf_d,r_buf_h,size,cudaMemcpyHostToDevice);

pero con CUDA_awre_MPI

//MPI rank 0
MPI_Send(s_buf_d,size,MPI_CHAR,1,100,MPI_COMM_WORLD);
//MPI rank n-1
MPI_Recv(r_buf_d,size,MPI_CHAR,0,100,MPI_COMM_WORLD, &status);

Los bibliotecarios de MPI abordarán las preocupaciones de convertir los buffers de memoria del host a buffers de GPU.

Answer 4

OpenMP y OpenACC permiten la programación paralela basada en directivas.

OpenMP permite la programación paralela en plataformas de computación de memoria compartida, como por ejemplo CPUs multi-core. Es muy fácil de usar, ya que es suficiente decirle al compilador algunas directivas (anotaciones de código o pragmas) sobre cómo extraer el paralelismo que activa la síntesis de una versión paralela del código fuente de entrada.

Un ejemplo del programa OpenMP "Hello World" con pragmas es el siguiente

#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
int main (int argc, char *argv[])
{
int nthreads, tid;
/* Fork a team of threads giving them their own copies of variables */
#pragma omp parallel private(nthreads, tid)
{
/* Obtain thread number */
tid = omp_get_thread_num();
printf("Hello World from thread = %d/n", tid);
/* Only master thread does this */
if (tid == 0)
{
nthreads = omp_get_num_threads();
printf("Number of threads = %d/n", nthreads);
}
} /* All threads join master thread and disband */
}

La fuente del código anterior es OpenMP Exercise, donde encontrarás muchos otros ejemplos. En este ejemplo de "Hello World", el hilo maestro generará el número de hilos involucrados, mientras que cada hilo imprimirá Hello World desde thread = xxx .

OpenACC es una colección de directivas de compilación para especificar partes de un código C / C ++ o Fortran que se acelerará mediante un acelerador adjunto, como una GPU. Sigue prácticamente la misma filosofía de OpenMP y permite crear programas de alto nivel de host + acelerador, de nuevo sin la necesidad de administrar el lenguaje de programación del acelerador. Por ejemplo, OpenACC le permitirá simplemente acelerar los códigos C / C ++ existentes sin necesidad de aprender CUDA (por supuesto, con algunas penalizaciones de rendimiento).

Un código típico de OpenACC será similar al siguiente

#pragma acc kernels loop gang(32), vector(16)
for (int j=1; j<n-1; j++)
{
#pragma acc loop gang(16), vector(32)
for (int i=1; i<m-1; i++)
{
Anew[j][i] = 0.25f * (A[j][i+1] + A[j-1][i]);
...
}
} 

El código fuente anterior se tomó del blog Un Ejemplo de OpenACC (Parte 1) , donde puede encontrar material más útil para comprender la diferencia entre OpenMP y OpenACC.

Otras fuentes son las siguientes

¿Cómo se relaciona la API de OpenACC con la API de OpenMP? .

Directivas OpenACC y OpenMP

Shane Cook, Programación CUDA, Morgan Kaufmann (Capítulo 10)

Debido a su naturaleza, OpenACC permite la programación híbrida de CPU + GPU. También puede mezclar directivas OpenMP y OpenACC. Por ejemplo, en un sistema de 4 GPU, puede crear 4 subprocesos de CPU para descargar el trabajo informático a las 4 GPU disponibles. Esto se describe en el libro de Shane Cook. Sin embargo, debe mencionarse que OpenMP 4.0 también prevé directivas para el trabajo de descarga en aceleradores conectados, consulte

Informe técnico 1 de OpenMP sobre directivas para aceleradores adjuntos