TinyGPU cluster (Tier3)

The TinyGPU cluster is one of a group of small special-purpose clusters. TinyGPU is intended for running applications utilizing GPU accelerators.

There are a number of different machines with different types of GPUs (mostly of consumer type) in TinyGPU.

Access, User Environment, and File Systems

Access to the machines

TinyGPU shares a frontend node with TinyFat. To access the systems, please connect to tinyx.nhr.fau.de via ssh.

While it is possible to ssh directly to a compute node, a user is only allowed to do this when they have a batch job running there. When all batch jobs of a user on a node have ended, all of their shells will be killed automatically.

File Systems

The following table summarizes the available file systems and their features. Also, check the description of the HPC file systems.

Node-local storage $TMPDIR

Each node has at least 880 GB of local SSD capacity for temporary files available under $TMPDIR (also accessible via /scratchssd). All files in these directories will be deleted at the end of a job without any notification. Important data to be kept can be copied to a cluster-wide volume at the end of the job, even if the job is canceled by a time limit.

Please only use the node-local SSDs if you can really profit from their use, as like all consumer SSDs they only support a limited number of writes, so in other words, by writing to them, you “use them up”.

Batch Processing

All user jobs must be submitted to the cluster by means of the batch system The submitted jobs are routed into a number of queues (depending on the needed resources, e.g. runtime) and sorted according to some priority scheme.

All nodes on TinyGPU currently use Slurm as a batch system. Please see the batch system description for general information about how to use Slurm. In the following, only the features specific to TinyGPU will be described.

Slurm (RTX2080Ti, RTX3080, V100 and A100 nodes)

To specify to which cluster jobs should be submitted, command wrappers are available for most Slurm commands. This means that jobs can be submitted from the woody frontend via sbatch.tinygpu. Other examples are srun.tinygpu, salloc.tinygpu, sinfo.tinygpu and squeue.tinygpu. These commands are equivalent to using the option --clusters=tinygpu. When resubmitting jobs from the compute nodes themselves, only use sbatch, i.e. without the .tinygpu suffix.

In contrast to other clusters, the compute nodes are not allocated exclusively but are shared among several jobs – the GPUs themselves are always granted exclusively. Resources are granted on a per-GPU basis. The corresponding share of the resources of the host system (CPU cores, RAM) is automatically allocated. This means, that it is sufficient to request the number of GPUs you want to use, e.g. with --gres=gpu:1. To request a specific GPU type, use e.g. --gres=gpu:rtx3080:1. For the V100 and A100 nodes, you have to additionally specify --partition=v100 or --partition=a100 and use --gres=gpu:v100:1 or --gres=gpu:a100:1. If you do not request a specific GPU type, your job will run on any available node in the work partition (i.e. RTX2080Ti or RTX3080 GPUs). Jobs that do not request at least one GPU will be rejected by the scheduler. There is no “devel” queue available on TinyGPU. The maximum walltime any job can request is 24h. In contrast to the Torque GPU nodes, there is currently no way to access hardware performance counters on the Slurm GPU nodes.

We recommend always using srun instead of mpirunor mpiexecto start your parallel application, since it automatically uses the allocated resources (number of tasks, cores per task, …) and also binds the tasks to the allocated cores. If you have to use mpirun, make sure to check that the binding of your processes is correct (e.g. with --report-bindings for OpenMPI and export I_MPI_DEBUG=4 for IntelMPI). OpenMP threads are not automatically pinned to specific cores. In order for the application to run efficiently, this has to be done manually.

Since September 5th, 2022, the woody frontend woody3 runs the same Ubuntu version as the Slurm compute nodes of TinyGPU.

An interactive job is still recommended to compile software GPU software for the Slurm nodes.

We still recommend using the sbatch option --export=none to prevent this export. Additionally, unset SLURM_EXPORT_ENV has to be called before srun to ensure that it is executed correctly. Both options are already included in the example scripts below.[/notice-hinweis]

Example Slurm Batch Scripts (RTX2080Ti, RTX3080, V100 and A100 nodes only)

For the most common use cases, examples are provided below. Note that these scripts possibly have to be adapted to your specific application and use case!

#!/bin/bash -l
#
# start 2 MPI processes
#SBATCH --ntasks=2
# allocate nodes for 6 hours
#SBATCH --time=06:00:00
# allocated one GPU (type not specified)
#SBATCH --gres=gpu:1
# job name 
#SBATCH --job-name=Testjob
# do not export environment variables
#SBATCH --export=NONE

# do not export environment variables
unset SLURM_EXPORT_ENV

srun --mpi=pmi2 ./executable.exe

#!/bin/bash -l
#
# start 2 MPI processes
#SBATCH --ntasks=2
# requests 8 OpenMP threads per MPI task
#SBATCH --cpus-per-task=16
# allocated one A100 GPGPU
#SBATCH --gres=gpu:a100:1
#SBATCH --partition=a100
# allocate nodes for 6 hours
#SBATCH --time=06:00:00
# job name 
#SBATCH --job-name=Testjob
# do not export environment variables
#SBATCH --export=NONE

# do not export environment variables
unset SLURM_EXPORT_ENV

# cpus-per-task has to be set again for srun
export SRUN_CPUS_PER_TASK=$SLURM_CPUS_PER_TASK

# set number of threads to requested cpus-per-task 
export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK srun --mpi=pmi2 ./executable_hybrid.exe

#!/bin/bash -l #
# requests 8 OpenMP threads
#SBATCH --cpus-per-task=8
# allocated one GTX3080 GPU
#SBATCH --gres=gpu:gtx3080:1
# allocate nodes for 6 hours 
#SBATCH --time=06:00:00 
# job name #SBATCH --job-name=Testjob 
# do not export environment variables 
#SBATCH --export=NONE 

# do not export environment variables 
unset SLURM_EXPORT_ENV 

# cpus-per-task has to be set again for srun
export SRUN_CPUS_PER_TASK=$SLURM_CPUS_PER_TASK

# set number of threads to requested cpus-per-task export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK
 srun --mpi=pmi2 ./executable_hybrid.exe

Interactive Slurm Shell (RTX2080Ti, RTX3080, V100 and A100 nodes only)

To generate an interactive Slurm shell on one of the compute nodes, the following command has to be issued on the frontend:
salloc.tinygpu --gres=gpu:1 --time=00:30:00
This will give you an interactive shell for 30 minutes on one of the nodes, allocating 1 GPU and the respective number of CPU cores. There, you can then for example compile your code or do test runs of your binary. For MPI-parallel binaries, use sruninstead of mpirun.

Please note that sallocautomatically exports the environment of your shell on the login node to your interactive job. This can cause problems if you have loaded any modules due to the version differences between the frontend and the TinyGPU compute nodes. To mitigate this, purge all loaded modules via module purge before issuing the salloc command.

Attach to a running job

On the frontend node, the following steps are necessary:

1. Check on which node the job is running with squeue.tinygpu.
2. If you have only one job running on a node, you can use ssh <nodename> to connect to it. You will be placed in the allocation of the job.
3. If you have multiple jobs running on a node, you can attach to a running job srun --pty --jobid YOUR-JOBID bash. This will give you a shell on the first node of your job and you can run top, nvidia-smi, etc. to check your job.

Attaching to a running job can be used e.g. to check GPU utilization via nvidia-smi. For more information on nvidia-smi and GPU profiling, see Working with NVIDIA GPUs.

Software

The frontend only has a limited software installation with regard to GPGPU computing. It is recommended to compile code on one of the TinyGPU nodes, i.e. by requesting an interactive job on TinyGPU.

cuDNN is installed as a system package on the nodes – no module required.

The V100 may require at least CUDA 9.0. The RTX2080Ti may require at least CUDA 10.0. The A100 and RTX3080 require at least CUDA 11.x.

Host software using AVX512 instructions will only run on tg06x/tg07x/tg08x. Host software compiled specifically for Intel processors might not run on tg09x.