Herramientas de usuario

Herramientas del sitio

Traza: • ejecucion_de_trabajos
wiki:computo:ejecucion_de_trabajos

Cómputo

En marcha desde 2009
El nodo de cálculo es accesible sin el manejador de colas.

Procesador: Intel Xeon E5520
- 8 núcleos
- 8 fpu
- 16 cpu
Capacidad de Cómputo: 40.0 GFlops fma x 2 procesadores físicos = 80 DP GFlops fma
Aceleradora: NO
Particiones SLURM: NO
Memoria: 48 GB DDR3
Acceso: ssh username@mirta2

En marcha desde 2012
El nodo de cálculo es accesible sin el manejador de colas.

Procesador: AMD Opteron 6272SE
- 32 núcleos
- 16 fpu
- 32 cpu
Capacidad de Cómputo: 166,4 GFlops fma x 2 procesadores físicos = 332,8 DP GFlops fma
Aceleradora: NO
Particiones SLURM: NO
Memoria: 256 GB DDR4
Acceso: ssh username@mirta3

En marcha desde 2010
El nodo de cálculo es accesible sin el manejador de colas.

Procesador: AMD Opteron 6172
- 48 núcleos
- 24 fpu
- 48 cpu
Capacidad de Cómputo: 134,4 GFlops fma x 4 procesadores físicos = 537,6 DP GFlops fma
Aceleradora: NO
Particiones SLURM: NO
Memoria: 128 GB DDR4
Acceso: ssh username@sersic

Procesador: Intel Xeon E5-2660v4 x 14 - 168 núcleos físicos - 336 núcleos virtuales
Memoria: 640 + 64 GB
Acceso: ssh username@clemente
Almacenamiento: 1 TB /home
                               17 TB /mnt/clemente
Aceleradora: 1 Tesla 2070
Particiones SLURM: debug (2 minutos - 336 núcleos virtuales - Clemente01-06)
                                    batch (3 días - 280 núcleos virtuales - Clemente01-05)
                                    small (6 horas - 56 núcleos virtuales - Clemente06)
                                    gpu (3 días - 50 núcleos virtuales - Clemente06)
Conectividad: Infiniband DDR / Ethernet 1Gbps


Cabecera:


Sistema operativo:
                             Operating System: CentOS Linux 7 (Core)
                             Kernel: Linux 3.10.0-514.el7.x86_64
                             Architecture: x86-64


clemente[01-05]:
                             Procesador: 28 Cores [56 w/HT] Intel Xeon E5-2660v4
                             Socket(s): 2     Core(s) per socket: 14      Thread(s) per core: 2     
                             L1d cache: 32K   L1i cache: 32K    L2 cache: 256K   L3 cache: 35840K
                             Cpu MHz: 1200
                             Memoria: 128 GB DDR4
                             Acceso: ssh username@clemente[01-03]*
                             Almacenamiento: NO
                             Aceleradora: NO
                             Particiones SLURM: debug - batch


clemente06:
                     Procesador: 28 Cores [56 w/HT] Intel Xeon E5-2680v4
                     Socket(s): 2      Core(s) per socket: 14      Thread(s) per core: 2    
                     L1 cache 896 KB    L2 cache: 3584 KB    L3 cache: 35840 KB   
                     Cpu MHz: 1200
                     Memoria: 64 GB DDR4
                     Acceso: ssh username@clemente04*
                     Almacenamiento: NO
                     Aceleradora: Tesla 2070
                     Particiones SLURM: batch - debug - gpu - small


(*) A los nodos solo se puede acceder cuando hay un trabajo del usuario en ejecución


  • Tarea: ejecutar programas utilizando gpu
  • Ejecución: sbatch submit_gpu_job.sh
  • Partición: gpu
  • Tiempo máximo: 3 días

submit_gpu_job.sh
  1.                 #!/bin/bash
  2.  
  3.                 ### Las líneas #SBATCH configuran los recursos de la tarea
  4.                 ### (aunque parezcan estar comentadas)
  5.  
  6.                 ### Nombre de la tarea
  7.                 #SBATCH --job-name=gpu_job
  8.  
  9.                 ### Cola de trabajos a la cual enviar.
  10.                 #SBATCH --partition=gpu
  11.  
  12.                 ### Procesos a largar.
  13.                 ### Por defecto, se usa un solo proceso para tareas GPU.
  14.                 #SBATCH --ntasks-per-node=1
  15.  
  16.                 ### Tiempo de ejecucion. Formato dias-horas:minutos.
  17.                 #SBATCH --time 3-0:00
  18.  
  19.                 ### Script que se ejecuta al arrancar el trabajo
  20.  
  21.                 ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  22.                 ### No tocar
  23.                 . /etc/profile
  24.  
  25.                 ### Cargar los módulos para la tarea
  26.                 # FALTA: Agregar los módulos necesarios
  27.                 module load cuda
  28.  
  29.                 ### Largar el programa
  30.                 # FALTA: Cambiar el nombre del programa
  31.                 srun NOMBRE_DEL_PROGRAMA
  32.  

  • Tarea: ejecutar programas utilizando mpi
  • Ejecución: sbatch submit_mpi_job.sh
  • Partición: batch
  • Tiempo máximo: 3 días

submit_mpi_job.sh
  1.             #!/bin/bash
  2.  
  3.             ### Las líneas #SBATCH configuran los recursos de la tarea
  4.             ### (aunque parezcan estar comentadas)
  5.  
  6.             ### Nombre de la tarea
  7.             #SBATCH --job-name=mpi_job
  8.  
  9.             ### Tiempo de ejecucion. Formato dias-horas:minutos.
  10.             #SBATCH --time 3-0:00
  11.  
  12.             ### Numero de procesos a ser lanzados.
  13.  
  14.             #SBATCH --ntasks=112
  15.             #SBATCH --nodes=2
  16.  
  17.             ### Nombre de partcion
  18.             #SBATCH --partition=batch
  19.  
  20.             ### Script que se ejecuta al arrancar el trabajo
  21.  
  22.             ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  23.             ### No tocar
  24.             . /etc/profile
  25.  
  26.             ### Cargar los módulos para la tarea
  27.             # FALTA: Agregar los módulos necesarios
  28.             module load clemente ...
  29.  
  30.             ### Largar el programa con los cores detectados
  31.             ### La cantidad de nodos y cores se detecta automáticamente
  32.             # FALTA: Cambiar el nombre del programa
  33.             srun NOMBRE_DEL_PROGRAMA
  34.  

  • Tarea: ejecutar programas utilizando OPENMP
  • Ejecución: sbatch openmp
  • Partición: batch
  • Tiempo máximo: 3 días

submit_openmp_job.sh
  1.             #!/bin/bash
  2.  
  3.             ### Las líneas #SBATCH configuran los recursos de la tarea
  4.             ### (aunque parezcan estar comentadas)
  5.  
  6.             ### Nombre de la tarea
  7.             #SBATCH --job-name=openmp_job
  8.  
  9.             ### Cola de trabajos a la cual enviar.
  10.             #SBATCH --partition=batch
  11.  
  12.             ### Procesos a largar.
  13.             ### Es OpenMP, o sea que un proceso en un nodo y muchos hilos.
  14.             #SBATCH --ntasks=1
  15.  
  16.             ### Hilos por proceso
  17.             ### Poner el mismo valor acá que en OMP_NUM_THREADS/MKL_NUM_THREADS
  18.             #SBATCH --cpus-per-task=56
  19.  
  20.             ### Tiempo de ejecucion. Formato dias-horas:minutos.
  21.             #SBATCH --time 3-0:00
  22.  
  23.             ### Script que se ejecuta al arrancar el trabajo
  24.  
  25.             ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  26.             ### No tocar
  27.             . /etc/profile
  28.  
  29.             ### Configurar OpenMP/MKL/etc con la cantidad de cores detectada.
  30.             export OMP_NUM_THREADS=56
  31.             export MKL_NUM_THREADS=56
  32.  
  33.             ### Cargar los módulos para la tarea
  34.             # FALTA: Agregar los módulos necesarios
  35.             module load clemente etc...
  36.  
  37.             ### Largar el programa
  38.             # FALTA: Cambiar el nombre del programa
  39.             srun NOMBRE_DEL_PROGRAMA
  40.  

No está permitido ejecutar trabajos en la cabecera.
En caso de estar ejecutando un trabajo, se puede acceder a través de ssh a los nodos para ver la ejecución del mismo.
Pueden encontrarse ejemplos de script de lanzamiento en /usr/share/doc/clemente.

Clemente posee una partición llamada "gpu" exclusiva para ejecutar tareas de GPGPU.

Clemente posee una partición para trabajos en MPI llamada bach. Tiene un tiempo máximo de 5 días y un total de 224 núcleos con disponibilidad de conexión infiniband

Procesador:AMD EPYC 7282 16-Core Processor
Cores: 32 virtuales SMT
Memoria: 32 GB DDR4
Acceso: ssh username@alumnos.oac.uncor.edu
Almacenamiento:
Aceleradora: NO
Particiones SLURM: NO
                                   

Procesador: 112 + 260 + 16 cores
Memoria: 512 + 832 + 256 GB
Acceso: ssh username@mendieta.ccad.unc.edu.ar
Almacenamiento: 36 TB /home (quota 500 GB)
Aceleradora: 12 Tesla M2090 + 8 Tesla K20Xm + 14 Xeon Phi 31S1
Particiones SLURM: debug (2 minutos - 408 núcleos)
                                    mono (7 días - 1 nodo- 8 núcleos)
                                    multi (4 días - 8 nodo- 388 núcleos)
                                    gpu (7 días - 1 nodo- 8 núcleos)
                                    phi (4 días - 1 Xeon Phi)
Conectividad: Infiniband QDR / Ethernet 1Gbps


Cabecera:
                    Procesador: 6 Cores [12 w/HT] Intel Xeon E5-2620
                    Memoria: 16GB DDR3
                    Acceso: ssh username@mendieta.ccad.unc.edu.ar
                    Almacenamiento: 36TB /home (quota 500GB)
                    Aceleradora: Tesla 2070
                    Particiones SLURM: debug (2 minutos - 408 núcleos)
                                                      mono (7 días - 1 nodo - 8 núcleos)
                                                      multi (4 días - 8 nodos -288 núcleos)
                                                      gpu (7 días - 1 nodo - 8 núcleos - 3 GPU)
                                                      phi (4 días - 1 Xeon Phi)


mendieta[01-08]:
                             Procesador: 16 Cores Intel Xeon E5-2680
                             Memoria: 64 GB DDR3
                             Acceso: ssh username@mendieta[01-08]*
                             Almacenamiento: 192GB /scratch
                             Aceleradora: 3 Tesla M2090 | 3 Tesla K20Xm
                             Particiones SLURM: debug - mono - gpu


mendieta[09-21]:
                             Procesador: 20 cores Intel Xeon E5-2680v2
                             Memoria: 64 GB DDR3
                             Acceso: ssh username@clemente[09-21]*
                             Almacenamiento: 400GB /scratch
                             Aceleradora: Xeon Phi 31S1
                             Particiones SLURM: debug - multi - phi


mendieta[23]:
                             Procesador: 16 cores Intel Xeon E5-2670
                             Memoria: 256 GB DDR3
                             Acceso: ssh username@clemente23*
                             Almacenamiento: 192 /scratch
                             Aceleradora: NO
                             Particiones SLURM: mono


(*) A los nodos solo se puede acceder cuando hay un trabajo del usuario en ejecución


  • Tarea: ejecutar programas utilizando gpu
  • Ejecución: sbatch submit_gpu_job.sh
  • Partición: gpu
  • Tiempo máximo: 7 días

submit_gpu_job.sh
  1.             #!/bin/bash
  2.  
  3.             #### NOTA: ESTE SCRIPT ES VIEJO
  4.  
  5.             ### Las líneas #SBATCH configuran los recursos de la tarea
  6.             ### (aunque parezcan estar comentadas)
  7.  
  8.             ### Nombre de la tarea
  9.             #SBATCH --job-name=nombre
  10.  
  11.             ### Cantidad de nodos a usar
  12.             #SBATCH --nodes=1
  13.  
  14.             ### GPUs por nodo (menor o igual 2)
  15.             ### OJO: Todos los procesos en un nodo ven ambas GPU con gpu:2!
  16.             ###      Llamar al programa con /opt/mendieta/bin/split_cpu.sh para dividirlas.
  17.             #SBATCH --gres=gpu:1
  18.  
  19.             ### Procesos por nodo
  20.             #SBATCH --ntasks-per-node=1
  21.  
  22.             ### Cores por proceso (OpenMP/Pthreads/etc)
  23.             ### Recordar exportar OMP_NUM_THREADS/MKL_NUM_THREADS/etc con el mismo valor
  24.             #SBATCH --cpus-per-task=1
  25.             export OMP_NUM_THREADS=1
  26.  
  27.             ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  28.             #SBATCH --time 7-0:00
  29.  
  30.             ### Environment setup
  31.             . /etc/profile
  32.  
  33.             ### Environment modules
  34.             module load cuda/5.0
  35.  
  36.             ### Ejecutar la tarea
  37.             ### NOTA: srun configura MVAPICH2 y MPICH con lo puesto arriba,
  38.             ###       no hay que llamar a mpirun.
  39.             srun algun_programa_gpu
  40.  
  41.  

  • Tarea: ejecutar programas utilizando mpi
  • Ejecución: sbatch submit_mpi_job.sh
  • Partición: batch
  • Tiempo máximo: 7 días

submit_mpi_job.sh
  1.             #!/bin/bash
  2.  
  3.             ### Las líneas #SBATCH configuran los recursos de la tarea
  4.             ### (aunque parezcan estar comentadas)
  5.  
  6.             ### Nombre de la tarea
  7.             #SBATCH --job-name=programa_mpi
  8.  
  9.             ### Cola a usar (capacity, capability, gpu)
  10.             #SBATCH --partition=capability
  11.  
  12.             ### Cantidad de nodos a usar
  13.             #SBATCH --nodes=1
  14.  
  15.             ### Cantidad de procesos a lanzar por nodo
  16.             ### capacity=16, capability=18, gpu=20
  17.             #SBATCH --ntasks-per-node=18
  18.  
  19.             ### Cores por proceso (para MPI+OpenMP)
  20.             #SBATCH --cpus-per-task=1
  21.             export OMP_NUM_THREADS=1
  22.             export MKL_NUM_THREADS=1
  23.  
  24.             ### GPUs por nodo
  25.             ### capacity/capability=0, gpu=1 (K20X) o 2 (M2090)
  26.             #SBATCH --gres=gpu:0
  27.  
  28.             ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  29.             #SBATCH --time 7-0:00
  30.  
  31.  
  32.             ### Script que se ejecuta al arrancar el trabajo
  33.  
  34.             ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  35.             ### No tocar
  36.             . /etc/profile
  37.  
  38.             ### Cargar los módulos para la tarea
  39.             # FALTA: Agregar los módulos necesarios
  40.             module load etcetera
  41.  
  42.             ### Largar el programa con los cores detectados
  43.             ### La cantidad de nodos y cores se detecta automáticamente
  44.             # FALTA: Cambiar el nombre del programa
  45.             srun programa
  46.  

  • Tarea: ejecutar programas utilizando OPENMP
  • Ejecución: sbatch openmp
  • Partición: batch
  • Tiempo máximo: 3 días

submit_openmp_job.sh
  1.             #!/bin/bash
  2.  
  3.             ### Las líneas #SBATCH configuran los recursos de la tarea
  4.             ### (aunque parezcan estar comentadas)
  5.  
  6.             ### Nombre de la tarea
  7.             #SBATCH --job-name=programa_openmp
  8.  
  9.             ### Cola de trabajos a usar
  10.             ### Es OpenMP, no podemos usar más de un nodo, así que capacity
  11.             #SBATCH --partition=capacity
  12.  
  13.             ### Procesos a largar.
  14.             ### Es OpenMP, o sea que un proceso en un nodo y muchos hilos.
  15.             #SBATCH --ntasks=1
  16.  
  17.             ### Hilos por proceso
  18.             ### Poner el mismo valor acá que en OMP_NUM_THREADS/MKL_NUM_THREADS
  19.             #SBATCH --cpus-per-task=16
  20.  
  21.             ### GPUs (0 o 1)
  22.             #SBATCH --gres=gpu:0
  23.  
  24.             ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  25.             ### Traten de acotarlo.
  26.             #SBATCH --time 7-0:00
  27.  
  28.             ### Script que se ejecuta al arrancar el trabajo
  29.  
  30.             ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  31.             ### No tocar
  32.             . /etc/profile
  33.  
  34.             ### Configurar OpenMP/MKL/etc con la cantidad de cores detectada.
  35.             export OMP_NUM_THREADS=16
  36.             export MKL_NUM_THREADS=16
  37.  
  38.             ### Cargar los módulos para la tarea
  39.             # FALTA: Agregar los módulos necesarios
  40.             module load etcetera
  41.  
  42.             ### Largar el programa
  43.             # FALTA: Cambiar el nombre del programa
  44.             srun programa
  45.  
  46.  

  • Tarea: ejecutar programas utilizando
  • Ejecución: sbatch submit_gamess.sh
  • Partición: batch
  • Tiempo máximo: 1 días

submit_gamess.sh
  1.             #!/bin/bash
  2.  
  3.             ### NOTA:
  4.             ### GAMESS requiere un directorio ~/scr en el home del usuario para correr
  5.  
  6.             ### Cantidad de cores (menor o igual a 16)
  7.             #SBATCH --ntasks=16
  8.             CORES=16
  9.  
  10.             ### Nombre de la tarea
  11.             #SBATCH --job-name=gamess
  12.  
  13.             ### Correr en un solo nodo hasta que veamos cómo hacer para lanzar en muchos
  14.             #SBATCH --nodes=1
  15.  
  16.             ### Cores por proceso (OpenMP/Pthreads/etc)
  17.             ### GAMESS corre uno solo
  18.             #SBATCH --cpus-per-task=1
  19.             export OMP_NUM_THREADS=1
  20.             export MKL_NUM_THREADS=1
  21.  
  22.             ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  23.             #SBATCH --time 1-0:00
  24.  
  25.             ### Environment setup
  26.             . /etc/profile
  27.  
  28.             ### Environment modules
  29.             module load md/gamess/20130501
  30.  
  31.             ### Ejecutar la tarea
  32.             ### NOTA: srun configura MVAPICH2 y MPICH con lo puesto arriba,
  33.             ###       no hay que llamar a mpirun.
  34.             rungms $1 00 ${CORES}
  35.  

  • Tarea: ejecutar programas utilizando
  • Ejecución: sbatch submit_gromacs.sh
  • Partición: gpu
  • Tiempo máximo: 7 días

submit_gromacs.sh
  1.             #!/bin/bash
  2.  
  3.             ### Las líneas #SBATCH configuran los recursos de la tarea
  4.             ### (aunque parezcan estar comentadas)
  5.  
  6.             ### Usar cola gpu
  7.             #SBATCH --partition=gpu
  8.  
  9.             ### Nombre de la tarea
  10.             #SBATCH --job-name=gromacs
  11.  
  12.             ### Cantidad de nodos a usar
  13.             #SBATCH --nodes=2
  14.  
  15.             ### Procesos por nodo
  16.             #SBATCH --ntasks-per-node=1
  17.  
  18.             ### GPUs por nodo
  19.             #SBATCH --gres=gpu:1
  20.  
  21.             ### Cores por nodo
  22.             #SBATCH --cpus-per-task=20
  23.             export OMP_NUM_THREADS=20
  24.             export MKL_NUM_THREADS=20
  25.  
  26.             ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  27.             #SBATCH --time 7-0:00
  28.  
  29.             ### Environment setup
  30.             . /etc/profile
  31.  
  32.             ### Environment modules
  33.             module load md/gromacs/5.0.2
  34.  
  35.             ### Largar el progrma en cuestion
  36.             srun mdrun_mpi
  37.  

  • Tarea: ejecutar programas utilizando
  • Ejecución: sbatch submit_lammps.sh
  • Partición: gpu
  • Tiempo máximo: 7 días

submit_lammps.sh
  1.                 #!/bin/bash
  2.  
  3.                 ### Las líneas #SBATCH configuran los recursos de la tarea
  4.                 ### (aunque parezcan estar comentadas)
  5.  
  6.                 ### Nombre de la tarea
  7.                 #SBATCH --job-name=lammps
  8.  
  9.                 ### Cola a usar (capacity, capability, gpu)
  10.                 #SBATCH --partition=gpu
  11.  
  12.                 ### Cantidad de nodos a usar
  13.                 #SBATCH --nodes=1
  14.  
  15.                 ### Cantidad de procesos a lanzar por nodo
  16.                 ### capacity=16, capability=18, gpu=20
  17.                 #SBATCH --ntasks-per-node=20
  18.  
  19.                 ### Cores por proceso
  20.                 ### LAMMPS está compilado con OpenMP, probar combinaciones
  21.                 #SBATCH --cpus-per-task=1
  22.                 export OMP_NUM_THREADS=1
  23.                 export MKL_NUM_THREADS=1
  24.  
  25.                 ### GPUs por nodo
  26.                 ### capacity/capability=0, gpu=1 (K20X) o 2 (M2090)
  27.                 #SBATCH --constraint=kepler
  28.                 #SBATCH --gres=gpu:1
  29.  
  30.                 ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  31.                 #SBATCH --time 7-0:00
  32.  
  33.                 ### Script que se ejecuta al arrancar el trabajo
  34.  
  35.                 ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  36.                 ### No tocar
  37.                 . /etc/profile
  38.  
  39.                 ### Cargar los módulos para la tarea
  40.                 # FALTA: Agregar los módulos necesarios
  41.                 module load md/lammps/15may15
  42.  
  43.                 ### Largar el programa con los cores detectados
  44.                 ### La cantidad de nodos y cores se detecta automáticamente
  45.                 # FALTA: agregar parámetros
  46.                 srun lmp_mendieta (...)
  47.  

  • Tarea: ejecutar programas utilizando los núcleos xeon PHI con MPI
  • Ejecución: sbatch submit.sh
  • Partición: phi
  • Tiempo máximo: 7 días

submit.sh
  1.             #!/bin/bash
  2.  
  3.             ### Las líneas #SBATCH configuran los recursos de la tarea
  4.             ### (aunque parezcan estar comentadas)
  5.  
  6.             ### Nombre de la tarea
  7.             #SBATCH --job-name=test-phi-mpi
  8.  
  9.             ### Cola a usar
  10.             #SBATCH --partition=phi
  11.  
  12.             ### No queremos compartir xeon phis, poca memoria
  13.             #SBATCH --exclusive
  14.  
  15.             ### Usar un xeon phi de 57 cores
  16.             #SBATCH --nodes=1
  17.             #SBATCH --ntasks-per-node=57
  18.  
  19.             ### Cores por proceso (para MPI+OpenMP)
  20.             #SBATCH --threads-per-core=4
  21.  
  22.             ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  23.             #SBATCH --time 7-0:00
  24.  

Makefile
  1.              CC=mpiicc
  2.             CFLAGS=-Wall -Wextra -O2 -mmic -openmp -mkl=parallel
  3.  
  4.             TARGETS=proctest
  5.  
  6.             proctest: proctest.o
  7.                     $(CC) $(CFLAGS) -o $@ $<
  8.  
  9.             .PHONY: clean
  10.  
  11.             clean:
  12.                     rm -f *.o $(TARGETS)
  13.  
  14.  

proctest.c
  1.             #include <stdio.h>
  2.             #include <omp.h>
  3.  
  4.             #include "mpi.h"
  5.  
  6.             int main(int argc, char ** argv) {
  7.  
  8.                 MPI_Init(&argc, &argv);
  9.  
  10.                 int commsize, commrank;
  11.                 MPI_Comm_size(MPI_COMM_WORLD, &commsize);
  12.                 MPI_Comm_rank(MPI_COMM_WORLD, &commrank);
  13.  
  14.                 #pragma omp parallel
  15.                 {
  16.                     int omptid = omp_get_thread_num();
  17.                     int ompthreads = omp_get_num_threads();
  18.  
  19.                     #pragma omp critical
  20.                     printf("MPI:%d/%d   OMP:%d/%d\n", commrank, commsize, omptid, ompthreads);
  21.                 }
  22.  
  23.                 MPI_Finalize();
  24.                 return 0;
  25.             }
  26.  
  27.  

  • Tarea: ejecutar programas utilizando los núcleos xeon PHI con OPENMP
  • Ejecución: sbatch submit_omp.sh
  • Partición: phi
  • Tiempo máximo: 7 días

submit_omp.sh
  1.              #!/bin/bash
  2.  
  3.             ### Las líneas #SBATCH configuran los recursos de la tarea
  4.             ### (aunque parezcan estar comentadas)
  5.  
  6.             ### Nombre de la tarea
  7.             #SBATCH --job-name=test-phi-openmp
  8.  
  9.             ### Cola a usar
  10.             #SBATCH --partition=phi
  11.  
  12.             ### No queremos compartir xeon phis, poca memoria
  13.             #SBATCH --exclusive
  14.  
  15.             ### Un solo proceso para OpenMP
  16.             #SBATCH --ntasks=1
  17.  
  18.             ### Cores por proceso
  19.             #SBATCH --cpus-per-task=57
  20.             #SBATCH --threads-per-core=4
  21.  
  22.             ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  23.             #SBATCH --time 7-0:00
  24.  
  25.             ### Script que se ejecuta al arrancar el trabajo
  26.  
  27.             ### Cargar el entorno del usuario
  28.             ### (en phi: MKL e Intel MPI)
  29.             ### No tocar
  30.             . /etc/profile
  31.  
  32.             ### No tenemos módulos en los xeon phi
  33.             ### Hasta 4 hilos por core
  34.             export OMP_NUM_THREADS=228
  35.             export MKL_NUM_THREADS=228
  36.  
  37.             ### Largar el programa
  38.             srun ./proctest
  39.  

Makefile
  1.                 CC=icc
  2.                 CFLAGS=-Wall -Wextra -O2 -mmic -openmp -mkl=parallel
  3.  
  4.                 TARGETS=proctest
  5.  
  6.                 proctest: proctest.o
  7.                         $(CC) $(CFLAGS) -o $@ $<
  8.  
  9.                 .PHONY: clean
  10.  
  11.                 clean:
  12.                         rm -f *.o $(TARGETS)
  13.  

proctest.c
  1.                 #include <stdio.h>
  2.                 #include <omp.h>
  3.  
  4.                 int main(int argc, char ** argv) {
  5.  
  6.                     #pragma omp parallel
  7.                     {
  8.                         int omptid = omp_get_thread_num();
  9.                         int ompthreads = omp_get_num_threads();
  10.  
  11.                         #pragma omp critical
  12.                         printf("OMP:%d/%d\n", omptid, ompthreads);
  13.                     }
  14.  
  15.                     return 0;
  16.                 }
  17.  
  18.  
  19.  

                      Mulatona está conformada por 7 nodos con la siguiente descripción:
Procesador:  Cada nodo tiene 2 procesadores Intel Xeon E5-2683v4 de 16 núcleos
Memoria:  Cada procesador tiene 128 GiB de RAM
Acceso:  ssh username@mulatona.ccad.unc.edu.ar
Almacenamiento:  
Aceleradora:  
Particiones SLURM:  multi (4 días - 7 nodos)
                                   batch (7 días - 7 nodos)
Conectividad:  Infiniband QDR basada en placas Mellanox ConnectX-3 MT27500/MT27520


Cabecera:
                    Procesador: 8 Cores Intel Core Processor (Broadwell, IBRS) 1,8 GHz
                    Memoria: 8GB
                    Acceso: ssh username@mulatona.ccad.unc.edu.ar
                    Almacenamiento:
                    Aceleradora:
                    Particiones SLURM:


mulatona[01-07]:
                             Procesador: 16 Cores Intel Xeon E5-2683v4
                             Memoria:
                             Acceso: ssh username@mulatona[01-08]*
                             Almacenamiento:
                             Aceleradora:
                             Particiones SLURM: batch - multi


(*) A los nodos solo se puede acceder cuando hay un trabajo del usuario en ejecución


  • Tarea: ejemplo de ejecución de Flash
  • Ejecución: sbatch submit_flash_job.sh
  • Partición: batch
  • Tiempo máximo: 7 días

submit_flash_job.sh
  1.             #!/bin/bash
  2.  
  3.             ### Las líneas #SBATCH configuran los recursos de la tarea
  4.             ### (aunque parezcan estar comentadas)
  5.  
  6.             ### Nombre de la tarea
  7.             #SBATCH --job-name=flash
  8.  
  9.             ### Cola de trabajos a la cual enviar.
  10.             #SBATCH --partition=batch
  11.  
  12.             ### Procesos a largar.
  13.             ### Es OpenMP.
  14.             #SBATCH --ntasks=32
  15.  
  16.             #SBATCH --nodes=1
  17.  
  18.             ### Hilos por proceso
  19.             ### Poner el mismo valor acá que en OMP_NUM_THREADS/MKL_NUM_THREADS
  20.  
  21.             ### Tiempo de ejecucion. Formato dias-horas:minutos.
  22.             #SBATCH --time 1-0:0
  23.  
  24.             ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  25.             ### No tocar
  26.             . /etc/profile
  27.  
  28.             ### Configurar OpenMP/MKL/etc con la cantidad de cores detectada.
  29.             export OMP_NUM_THREADS=32
  30.             export MKL_NUM_THREADS=32
  31.  
  32.             ### Cargar los módulos para la tarea
  33.             module load gcc/7
  34.             module load flash/4.4 
  35.  
  36.             ### Corre el programa
  37.  
  38.             time srun  ./flash4
  39.  
wiki/computo/ejecucion_de_trabajos.txt · Última modificación: 2021/12/15 13:57 (editor externo)