Introducción a la computación de altas prestaciones

• Resolver problemas en un tiempo de ejecución inferior, utilizando más procesadores.

• Resolver problemas con más precisión, utilizando más memoria.

• Resolver problemas más reales, utilizando modelos matemáticos más complejos.

La predicción meteorológica

Un ejemplo de esto es la predicción meteorológica, que requiere gran capacidad de cálculo y de memoria. La predicción meteorológica es una función de la longitud, latitud, altura y tiempo. Para cada uno de estos puntos se deben calcular varios parámetros, como por ejemplo, la temperatura, presión, humedad y velocidad del viento. Hay casos en los que la predicción meteorológica se necesita en “tiempo real” (en cuestión de horas, no de días), como en el caso de la predicción de la formación, la trayectoria y el posible impacto de un huracán. Hay que tener en cuenta que llevar a cabo las simulaciones con una precisión insuficiente puede provocar perder detalles importantes y llegar a conclusiones poco acertadas que pueden tener consecuencias devastadoras. La figura 3 ilustra los resultados obtenidos con el modelo WRF ⁽⁴⁾ con dos niveles de precisión diferentes:

Figura 3. Predicciones meteorológicas con WRF de diferentes precisiones

Fuente: The National Center for Atmospheric Research

En la simulación del gráfico de la izquierda la cuadrícula es de 4 kilómetros cuadrados, mientras que en el de la derecha es de 10 kilómetros cuadrados. Se puede apreciar claramente que hay ciertos fenómenos que no se pueden observar con claridad en la figura de la derecha. Hay que tener en cuenta que una predicción cuidadosa de estos fenómenos, aparte del impacto directo en la población, también afecta a la economía (por ejemplo, se estima que en Estados Unidos el 40% de pequeñas/medianas empresas cierran en los siguientes 36 meses si se ven forzadas a cerrar 3 o más días después de un huracán). Así pues, disponer de computación de altas prestaciones puede llegar a salvar vidas y/o la economía de regiones.

Figura 4. Ejemplos de la necesidad de altas prestaciones

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
void *print_message_function( void *ptr );
main() {
   pthread_t thread1, thread2;
   char *message1 = "Thread 1";
   char *message2 = "Thread 2";
   int iret1, iret2;
   /* Crea flujos independientes, que ejecutarán la función */
   iret1 = pthread_create( &thread1, NULL, print_message_function, (void*) message1);
   iret2 = pthread_create( &thread2, NULL, print_message_function, (void*) message2);
   /* Espera a que todos los flujos acaben antes de continuar con el programa principal */
   pthread_join( thread1, NULL);
   pthread_join( thread2, NULL); 
   printf("Thread 1 returns: %d\n",iret1);
   printf("Thread 2 returns: %d\n",iret2);
   exit(0);
}
void *print_message_function( void *ptr ) {
   char *message;
   message = (char *) ptr;
   printf("%s \n", message);
}

#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
void Hello(void);
int main(int argc, char* argv[]) {
   /* Obtener el número de flujos del intérprete de órdenes */
   int thread_count = strtol(argv[1], NULL, 10);
#  pragma omp parallel num_threads(thread_count)
   Hello();
   return 0;
}
void Hello(void( {
   int my_rank = omp_get_thread_num();
   int thread_count = omp_get_num_threads();
   printf("Hello from thread %d of %d\n", my_rank, thread_count);
}
                

• Reservar memoria en el dispositivo.

• Transferir los datos necesarios desde el procesador principal al espacio de memoria asignado al dispositivo.

• Invocar la ejecución del kernel en cuestión.

• Transferir los datos con los resultados desde el dispositivo hacia el procesador principal.

• Liberar la memoria del dispositivo (si ya no es necesaria), una vez finalizada la ejecución del kernel.

__global__ matrix_add_gpu (fload *A, float *B, float *C, int N)
{ 
   int i = blockIdx.x * blockDim.x + threadIdx.x; 
   int j = blockIdx.y * blockDim.y + threadIdx.y; 
   int index = i + j*N; 
   if (i<N && j<N){
      C[index] = A[index] + B[index];
   }
}
int main(){ 
   dim3 dimBlock(blocksize, blocksize); 
   dim3 dimGrid(N/dimBlock.x, N/dimBlock.y);
   matrix_add_gpu<<<dimGrid, dimBlock>>>(a, b, c, N);
}

__kernel void matrix_add_opencl ( __global const float *A, 
                  __global const float *B,
                  __global float *C, 
                  int N) {
   int i = get_global_id(0); 
   int j = get_global_id(1); 
   int index = i + j*N; 
   if (i<N && j<N){
      C[index] = A[index] + B[index];
   }
}

• Estandarización. Las implementaciones de la especificación han hecho que se convirtiera en el estándar de paso de mensajes y que no sea necesario desarrollar programas diferentes para máquinas diferentes.

• Portabilidad. Los programas MPI funcionan sobre multiprocesadores de memoria compartida, multicomputadores de memoria distribuida, clústeres de computadores, sistemas heterogéneos, etc. siempre que haya una versión de MPI para ellos.

• Altas prestaciones. Los fabricantes han desarrollado implementaciones eficientes para sus equipos.

• Amplia funcionalidad. MPI incluye gran cantidad de funciones para llevar a cabo de manera sencilla las operaciones que suelen aparecer en programas de paso de mensajes.

#include <stdio.h>
#include <mpi.h>
int main ( int argc, char *argv[])
{
   int rank, size;
   MPI_Init (&argc, &argv);	/* starts MPI */
   MPI_Comm_rank (MPI_COMM_WORLD, &rank);	/* Obtiene el identificador del proceso */
   MPI_Comm_size (MPI_COMM_WORLD, &size);	/* Obtiene el número de procesos */
   printf( "Hello world from process %d of %d\n", rank, size );
   MPI_Finalize();
   return 0;
}

• Hay que incluir la librería de MPI (mpi.h).

• Todos los procesos ejecutan el mismo código desde el principio, con lo que todos tienen variables myrank y size. A diferencia de OpenMP, estas variables son diferentes y pueden estar en memorias diferentes en procesadores distintos.

• Los procesos trabajan de manera independiente hasta que se inicializa MPI con la función MPI_Init. A partir de este punto, los procesos pueden colaborar intercambiando datos, sincronizándose, etc.

• La función MPI_Finalize se llama cuando ya no es necesario que los procesos colaboren entre sí. Esta función libera todos los recursos reservados por MPI.

• Las funciones MPI tienen la forma MPI_Nombre(parámetros). De la misma manera que en OpenMP, es necesario que los procesos sepan su identificador (entre 0 y el número de procesos menos 1) y el número de procesos que se han puesto en marcha. Las funciones MPI_Comm_rank y MPI_Comm_size se utilizan para conseguir esto.

• Vemos que estas funciones tienen un parámetro MPI_COMM_WORLD que es una constante MPI y que identifica el comunicador al que están asociados todos los procesos. Un comunicador es un identificador de un grupo de procesos, y las funciones MPI han de identificar en qué comunicador se están realizando las operaciones que se llaman.

Double start, finish;
...
start = get_current_time();
/* Código que queremos medir */
...
finish = get_current_time();
printf("Tiempo transcurrido = %e segundos\n", finish-start);

Figura 19. Metodología clásica de análisis de rendimiento

• Basadas en tiempo de ejecución, mediante la cual se detecta qué parte de la aplicación paralela se ejecuta más tiempo.

• Basadas en contadores que indican el número de veces de un determinado acontecimiento en la aplicación (por ejemplo, el caso de PAPI).

• Basadas en muestreo, que generan medidas periódicamente sobre el estado de la aplicación.

• Basadas en trazas de acontecimientos, que proporcionan información asociada a acontecimientos concretos definidos en la aplicación.

Figura 20. Ejemplo de traza. Muestra un alto nivel de desbalanceo en una barrera MPI

• HPL: es el high performance Linpack que hemos comentado anteriormente.

• DGEMM: está centrado en la memoria y mide el rendimiento en coma flotante de la ejecución de la multiplicación de matrices de números reales de doble precisión.

• STREAM: es un benchmark basado en un programa sintético que mide el ancho de banda a memoria sostenido (en GB/s).

• PTRANS ⁽³⁹⁾ : está centrado en las comunicaciones entre pares de procesadores que se comunican entre ellos simultáneamente. Este benchmark está orientado a la evaluación de la capacidad de la red.

• Acceso aleatorio: está centrado en medir el rendimiento de accesos aleatorios a memoria (también denominado GUPS). Este benchmark está orientado a ver cuál es la latencia que el subsistema de memoria tiene por lecturas. En este caso, los accesos a memoria se generan de tal manera que no hay nunca reúso en las memorias caché y siempre se accede a la memoria final.

• FFT: es un benchmark que mide el rendimiento en punto flotante de la ejecución de una transformada discreta de Fourier compleja unidimensional de doble precisión.

• Ancho de banda y latencia de comunicaciones: es un conjunto de pruebas que miden la latencia y el ancho de banda de varios patrones de comunicaciones simultáneamente. Está basado en el benchmark b_eff ⁽⁴⁰⁾ .