Paralelización en memoria compartida (openMP)

Los compiladores disponibles en PROTEUS ofrecen soporte nativo para la especificación OpenMP (Open Multi-Processing). Este paradigma permite paralelizar código mediante directivas de preprocesador o comentarios de compilación sobre arquitecturas de memoria compartida (nodos multi-núcleo).

Directivas de habilitación por suite

Para que el compilador interprete las directivas OpenMP y enlace las bibliotecas de runtime correspondientes, se debe aplicar el flag específico de cada suite:

• GCC: -fopenmp

• LLVM/Clang: -fopenmp

• AOCC: -fopenmp

• Intel OneAPI: -qopenmp (o su alias -fiopenmp)

Ejemplos prácticos de sintaxis

• Compilación con GCC:

  gcc -O3 -fopenmp mi_codigo_omp.c -o ejecutable_omp.exe -lm
  

• Compilación con Intel OneAPI:

  icx -O3 -qopenmp mi_codigo_omp.c -o ejecutable_omp.exe
  

Ejecución y control de hilos

Una vez generado el ejecutable, el número de núcleos paralelos que consumirá la simulación no se define en la compilación, sino en el script de envío de Slurm mediante la variable de entorno estándar OMP_NUM_THREADS:

export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK
./ejecutable_omp.exe

Nota sobre el Paradigma Híbrido (MPI + OpenMP)

Los flags de OpenMP son completamente combinables con los wrappers de comunicación por paso de mensajes de MPI (mpicc, mpif90, etc.). Este enfoque híbrido es el más eficiente para simulaciones a gran escala en el clúster:

• MPI gestiona la intercomunicación entre los diferentes nodos asignados (memoria distribuida).

• OpenMP explota el paralelismo interno dentro de los múltiples núcleos de cada nodo (memoria compartida).

mpicc -O3 -fopenmp programa_hibrido.c -o programa_hibrido.exe -lm

Paralelización automática de bucles (Auto-parallelization)

Tanto la suite de GNU como la de Intel son capaces de analizar el flujo de datos de bucles estructurados independientes (bucles for en C o DO en Fortran) y transformarlos de manera automática en código multihilo, sin necesidad de que el investigador inserte directivas manuales.

Flags de activación:

• GCC: Implementa la directiva -ftree-parallelize-loops=N, donde N determina estrictamente el número de hilos fijos que se van a generar para el bucle.

  gcc -O3 -ftree-parallelize-loops=4 fuente.c -o auto_par.exe -lm
  

• Intel OneAPI (icx / ifx): Emplea el flag -qparallel (nota: sustituye al antiguo flag -parallel de la suite icc clásica). El número de hilos se controla en tiempo de ejecución mediante la variable de entorno OMP_NUM_THREADS.

  icx -O3 -qparallel fuente.c -o auto_par.exe
  

Limitaciones

Aunque la paralelización automática simplifica el desarrollo inicial, su uso en producción científica avanzada debe tratarse con extrema cautela debido a las siguientes restricciones técnicas:

1. Análisis de dependencias conservador: El compilador prioriza siempre la integridad matemática de los resultados. Si existe la más mínima ambigüedad en el flujo de datos (p.e., punteros que puedan solaparse, dependencias de iteraciones previas en la resolución de ecuaciones diferenciales o algoritmos de reducción), el compilador omitirá la paralelización por seguridad.

2. Sobrecarga por hilos (Overhead): La creación, sincronización y destrucción de hilos dinámicos tiene un coste temporal. Si la carga computacional interna del bucle es ligera, el proceso de sincronización degradará el rendimiento, haciendo que el programa corra más lento que en su versión puramente secuencial.

3. Recomendación metodológica: Para códigos de simulación física computacional de alta intensidad (como Dinámica Molecular, simulaciones de Lattice Boltzmann o métodos de Monte Carlo), se desaconseja delegar la concurrencia en el automatismo del compilador. Se recomienda encarecidamente el uso explícito de OpenMP o el uso de construcciones nativas del lenguaje moderno, tales como bucles DO CONCURRENT (Fortran 2008) o políticas de ejecución paralela std::execution::par (C++17), ya que aseguran un control riguroso sobre las condiciones de carrera y la localidad de la memoria caché.