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

#!/bin/bash ### Las líneas #SBATCH configuran los recursos de la tarea ### (aunque parezcan estar comentadas) ### Nombre de la tarea #SBATCH --job-name=gpu_job ### Cola de trabajos a la cual enviar. #SBATCH --partition=gpu ### Procesos a largar. ### Por defecto, se usa un solo proceso para tareas GPU. #SBATCH --ntasks-per-node=1 ### Tiempo de ejecucion. Formato dias-horas:minutos. #SBATCH --time 3-0:00 ### Script que se ejecuta al arrancar el trabajo ### Cargar el entorno del usuario incluyendo la funcionalidad de modules ### No tocar . /etc/profile ### Cargar los módulos para la tarea # FALTA: Agregar los módulos necesarios module load cuda ### Largar el programa # FALTA: Cambiar el nombre del programa srun NOMBRE_DEL_PROGRAMA

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

#!/bin/bash ### Las líneas #SBATCH configuran los recursos de la tarea ### (aunque parezcan estar comentadas) ### Nombre de la tarea #SBATCH --job-name=mpi_job ### Tiempo de ejecucion. Formato dias-horas:minutos. #SBATCH --time 3-0:00 ### Numero de procesos a ser lanzados. #SBATCH --ntasks=112 #SBATCH --nodes=2 ### Nombre de partcion #SBATCH --partition=batch ### Script que se ejecuta al arrancar el trabajo ### Cargar el entorno del usuario incluyendo la funcionalidad de modules ### No tocar . /etc/profile ### Cargar los módulos para la tarea # FALTA: Agregar los módulos necesarios module load clemente ... ### Largar el programa con los cores detectados ### La cantidad de nodos y cores se detecta automáticamente # FALTA: Cambiar el nombre del programa srun NOMBRE_DEL_PROGRAMA

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

#!/bin/bash ### Las líneas #SBATCH configuran los recursos de la tarea ### (aunque parezcan estar comentadas) ### Nombre de la tarea #SBATCH --job-name=openmp_job ### Cola de trabajos a la cual enviar. #SBATCH --partition=batch ### Procesos a largar. ### Es OpenMP, o sea que un proceso en un nodo y muchos hilos. #SBATCH --ntasks=1 ### Hilos por proceso ### Poner el mismo valor acá que en OMP_NUM_THREADS/MKL_NUM_THREADS #SBATCH --cpus-per-task=56 ### Tiempo de ejecucion. Formato dias-horas:minutos. #SBATCH --time 3-0:00 ### Script que se ejecuta al arrancar el trabajo ### Cargar el entorno del usuario incluyendo la funcionalidad de modules ### No tocar . /etc/profile ### Configurar OpenMP/MKL/etc con la cantidad de cores detectada. export OMP_NUM_THREADS=56 export MKL_NUM_THREADS=56 ### Cargar los módulos para la tarea # FALTA: Agregar los módulos necesarios module load clemente etc... ### Largar el programa # FALTA: Cambiar el nombre del programa srun NOMBRE_DEL_PROGRAMA

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

#!/bin/bash #### NOTA: ESTE SCRIPT ES VIEJO ### Las líneas #SBATCH configuran los recursos de la tarea ### (aunque parezcan estar comentadas) ### Nombre de la tarea #SBATCH --job-name=nombre ### Cantidad de nodos a usar #SBATCH --nodes=1 ### GPUs por nodo (menor o igual 2) ### OJO: Todos los procesos en un nodo ven ambas GPU con gpu:2! ### Llamar al programa con /opt/mendieta/bin/split_cpu.sh para dividirlas. #SBATCH --gres=gpu:1 ### Procesos por nodo #SBATCH --ntasks-per-node=1 ### Cores por proceso (OpenMP/Pthreads/etc) ### Recordar exportar OMP_NUM_THREADS/MKL_NUM_THREADS/etc con el mismo valor #SBATCH --cpus-per-task=1 export OMP_NUM_THREADS=1 ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana. #SBATCH --time 7-0:00 ### Environment setup . /etc/profile ### Environment modules module load cuda/5.0 ### Ejecutar la tarea ### NOTA: srun configura MVAPICH2 y MPICH con lo puesto arriba, ### no hay que llamar a mpirun. srun algun_programa_gpu

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

#!/bin/bash ### Las líneas #SBATCH configuran los recursos de la tarea ### (aunque parezcan estar comentadas) ### Nombre de la tarea #SBATCH --job-name=programa_mpi ### Cola a usar (capacity, capability, gpu) #SBATCH --partition=capability ### Cantidad de nodos a usar #SBATCH --nodes=1 ### Cantidad de procesos a lanzar por nodo ### capacity=16, capability=18, gpu=20 #SBATCH --ntasks-per-node=18 ### Cores por proceso (para MPI+OpenMP) #SBATCH --cpus-per-task=1 export OMP_NUM_THREADS=1 export MKL_NUM_THREADS=1 ### GPUs por nodo ### capacity/capability=0, gpu=1 (K20X) o 2 (M2090) #SBATCH --gres=gpu:0 ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana. #SBATCH --time 7-0:00 ### Script que se ejecuta al arrancar el trabajo ### Cargar el entorno del usuario incluyendo la funcionalidad de modules ### No tocar . /etc/profile ### Cargar los módulos para la tarea # FALTA: Agregar los módulos necesarios module load etcetera ### Largar el programa con los cores detectados ### La cantidad de nodos y cores se detecta automáticamente # FALTA: Cambiar el nombre del programa srun programa

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

#!/bin/bash ### Las líneas #SBATCH configuran los recursos de la tarea ### (aunque parezcan estar comentadas) ### Nombre de la tarea #SBATCH --job-name=programa_openmp ### Cola de trabajos a usar ### Es OpenMP, no podemos usar más de un nodo, así que capacity #SBATCH --partition=capacity ### Procesos a largar. ### Es OpenMP, o sea que un proceso en un nodo y muchos hilos. #SBATCH --ntasks=1 ### Hilos por proceso ### Poner el mismo valor acá que en OMP_NUM_THREADS/MKL_NUM_THREADS #SBATCH --cpus-per-task=16 ### GPUs (0 o 1) #SBATCH --gres=gpu:0 ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana. ### Traten de acotarlo. #SBATCH --time 7-0:00 ### Script que se ejecuta al arrancar el trabajo ### Cargar el entorno del usuario incluyendo la funcionalidad de modules ### No tocar . /etc/profile ### Configurar OpenMP/MKL/etc con la cantidad de cores detectada. export OMP_NUM_THREADS=16 export MKL_NUM_THREADS=16 ### Cargar los módulos para la tarea # FALTA: Agregar los módulos necesarios module load etcetera ### Largar el programa # FALTA: Cambiar el nombre del programa srun programa

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

#!/bin/bash ### NOTA: ### GAMESS requiere un directorio ~/scr en el home del usuario para correr ### Cantidad de cores (menor o igual a 16) #SBATCH --ntasks=16 CORES=16 ### Nombre de la tarea #SBATCH --job-name=gamess ### Correr en un solo nodo hasta que veamos cómo hacer para lanzar en muchos #SBATCH --nodes=1 ### Cores por proceso (OpenMP/Pthreads/etc) ### GAMESS corre uno solo #SBATCH --cpus-per-task=1 export OMP_NUM_THREADS=1 export MKL_NUM_THREADS=1 ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana. #SBATCH --time 1-0:00 ### Environment setup . /etc/profile ### Environment modules module load md/gamess/20130501 ### Ejecutar la tarea ### NOTA: srun configura MVAPICH2 y MPICH con lo puesto arriba, ### no hay que llamar a mpirun. rungms $1 00 ${CORES}

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

#!/bin/bash ### Las líneas #SBATCH configuran los recursos de la tarea ### (aunque parezcan estar comentadas) ### Usar cola gpu #SBATCH --partition=gpu ### Nombre de la tarea #SBATCH --job-name=gromacs ### Cantidad de nodos a usar #SBATCH --nodes=2 ### Procesos por nodo #SBATCH --ntasks-per-node=1 ### GPUs por nodo #SBATCH --gres=gpu:1 ### Cores por nodo #SBATCH --cpus-per-task=20 export OMP_NUM_THREADS=20 export MKL_NUM_THREADS=20 ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana. #SBATCH --time 7-0:00 ### Environment setup . /etc/profile ### Environment modules module load md/gromacs/5.0.2 ### Largar el progrma en cuestion srun mdrun_mpi

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

#!/bin/bash ### Las líneas #SBATCH configuran los recursos de la tarea ### (aunque parezcan estar comentadas) ### Nombre de la tarea #SBATCH --job-name=lammps ### Cola a usar (capacity, capability, gpu) #SBATCH --partition=gpu ### Cantidad de nodos a usar #SBATCH --nodes=1 ### Cantidad de procesos a lanzar por nodo ### capacity=16, capability=18, gpu=20 #SBATCH --ntasks-per-node=20 ### Cores por proceso ### LAMMPS está compilado con OpenMP, probar combinaciones #SBATCH --cpus-per-task=1 export OMP_NUM_THREADS=1 export MKL_NUM_THREADS=1 ### GPUs por nodo ### capacity/capability=0, gpu=1 (K20X) o 2 (M2090) #SBATCH --constraint=kepler #SBATCH --gres=gpu:1 ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana. #SBATCH --time 7-0:00 ### Script que se ejecuta al arrancar el trabajo ### Cargar el entorno del usuario incluyendo la funcionalidad de modules ### No tocar . /etc/profile ### Cargar los módulos para la tarea # FALTA: Agregar los módulos necesarios module load md/lammps/15may15 ### Largar el programa con los cores detectados ### La cantidad de nodos y cores se detecta automáticamente # FALTA: agregar parámetros srun lmp_mendieta (...)

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

#!/bin/bash ### Las líneas #SBATCH configuran los recursos de la tarea ### (aunque parezcan estar comentadas) ### Nombre de la tarea #SBATCH --job-name=test-phi-mpi ### Cola a usar #SBATCH --partition=phi ### No queremos compartir xeon phis, poca memoria #SBATCH --exclusive ### Usar un xeon phi de 57 cores #SBATCH --nodes=1 #SBATCH --ntasks-per-node=57 ### Cores por proceso (para MPI+OpenMP) #SBATCH --threads-per-core=4 ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana. #SBATCH --time 7-0:00
CC=mpiicc CFLAGS=-Wall -Wextra -O2 -mmic -openmp -mkl=parallel TARGETS=proctest proctest: proctest.o $(CC) $(CFLAGS) -o $@ $< .PHONY: clean clean: rm -f *.o $(TARGETS)
#include #include #include "mpi.h" int main(int argc, char ** argv) { MPI_Init(&argc, &argv); int commsize, commrank; MPI_Comm_size(MPI_COMM_WORLD, &commsize); MPI_Comm_rank(MPI_COMM_WORLD, &commrank); #pragma omp parallel { int omptid = omp_get_thread_num(); int ompthreads = omp_get_num_threads(); #pragma omp critical printf("MPI:%d/%d OMP:%d/%d\n", commrank, commsize, omptid, ompthreads); } MPI_Finalize(); return 0; }

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

#!/bin/bash ### Las líneas #SBATCH configuran los recursos de la tarea ### (aunque parezcan estar comentadas) ### Nombre de la tarea #SBATCH --job-name=test-phi-openmp ### Cola a usar #SBATCH --partition=phi ### No queremos compartir xeon phis, poca memoria #SBATCH --exclusive ### Un solo proceso para OpenMP #SBATCH --ntasks=1 ### Cores por proceso #SBATCH --cpus-per-task=57 #SBATCH --threads-per-core=4 ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana. #SBATCH --time 7-0:00 ### Script que se ejecuta al arrancar el trabajo ### Cargar el entorno del usuario ### (en phi: MKL e Intel MPI) ### No tocar . /etc/profile ### No tenemos módulos en los xeon phi ### Hasta 4 hilos por core export OMP_NUM_THREADS=228 export MKL_NUM_THREADS=228 ### Largar el programa srun ./proctest
CC=icc CFLAGS=-Wall -Wextra -O2 -mmic -openmp -mkl=parallel TARGETS=proctest proctest: proctest.o $(CC) $(CFLAGS) -o $@ $< .PHONY: clean clean: rm -f *.o $(TARGETS)
#include #include int main(int argc, char ** argv) { #pragma omp parallel { int omptid = omp_get_thread_num(); int ompthreads = omp_get_num_threads(); #pragma omp critical printf("OMP:%d/%d\n", omptid, ompthreads); } return 0; }

                      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

#!/bin/bash ### Las líneas #SBATCH configuran los recursos de la tarea ### (aunque parezcan estar comentadas) ### Nombre de la tarea #SBATCH --job-name=flash ### Cola de trabajos a la cual enviar. #SBATCH --partition=batch ### Procesos a largar. ### Es OpenMP. #SBATCH --ntasks=32 #SBATCH --nodes=1 ### Hilos por proceso ### Poner el mismo valor acá que en OMP_NUM_THREADS/MKL_NUM_THREADS ### Tiempo de ejecucion. Formato dias-horas:minutos. #SBATCH --time 1-0:0 ### Cargar el entorno del usuario incluyendo la funcionalidad de modules ### No tocar . /etc/profile ### Configurar OpenMP/MKL/etc con la cantidad de cores detectada. export OMP_NUM_THREADS=32 export MKL_NUM_THREADS=32 ### Cargar los módulos para la tarea module load gcc/7 module load flash/4.4 ### Corre el programa time srun ./flash4