TinyFat cluster

The TinyFat cluster is one of a group of small special-purpose clusters. Memoryhog and the TinyFat cluster are intended for running serial or moderately parallel (OpenMP) applications that require large amounts of memory in one machine. They are mostly used for pre-/post-processing work for jobs on other clusters. The nodes are only connected by GBit ethernet. Therefore, only single-node jobs are allowed on this cluster. In general, the documentation for Woody applies, this page will only list the differences.

There are a number of different machines in TinyFat:

Hostnames #
nodes
CPUs and number of cores per machine Main memory
(in GB)
Additional comments and
required qsub parameters
memoryhog
(formerly tf020)
1 4x Intel Xeon X7560 (“Nehalem EX”) @2,27 GHz
= 32 cores/64 threads
512 interactively accessible without batch job
tf040-tf042
(not always generally available)
3 2x Intel Xeon E5-2680 v4 (“Broadwell”) @2.4 GHz
= 28 cores/56 threads
512 10 GBit Ethernet, 1 TB Intel 750 SSD
-q broadwell512 -l nodes=1:ppn=56
tf050-tf057
(not always generally available)
8 2x Intel Xeon E5-2643 v4 (“Broadwell”) @3.4 GHz
= 12 cores/24 threads
256 10 GBit Ethernet, 1 TB Intel 750 SSD
-q broadwell256 -l nodes=1:ppn=24
tf060-tf095
(not generally available)
36 2x AMD Rome 7502 @2.5 GHz
= 64 cores/128 threads (SMT enabled)
512 10 GBit Ethernet, 3.5 TB NVMe SSD

These nodes Slurm as batch queuing system and run already Ubuntu 20.04.

All Broadwell-based nodes have been purchased by specific groups or special projects. These users have priority access and nodes may be reserved exclusively for them.

All AMD Rome-based nodes have been purchased by specific groups or special projects. These users have priority access and nodes may be reserved exclusively for them.

Access, User Environment, and File Systems

Access to the machines

TinyFat does not have its own frontend node.  Access to the system is granted through the woody frontend nodes via ssh. Please connect to

woody.rrze.uni-erlangen.de

and you will be routed to one of the frontends. 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.

One exception to this is memoryhog, which can be used interactively without a batch job. Every HPC user can log in directly to memoryhog.rrze.uni-erlangen.de to run their memory-intensive workloads. This of course means you need to be considerate of other users. Processes hogging up too many resources or running for too long will be killed without notice.

File Systems

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

File system overview for the Woody cluster
Mount point Access via Purpose Technology, size Backup Data lifetime Quota
/home/hpc $HOME Storage of source, input, important results central servers YES + Snapshots Account lifetime YES (restrictive)
/home/vault $HPCVAULT Mid- to long-term storage central servers YES + Snapshots Account lifetime YES
/home/woody $WORK storage for small files NFS limited Account lifetime YES
/scratchssd $TMPDIR Temporary job data directory Node-local SSD, between 750 GB and 3.5 TB NO Job runtime NO

Node-local storage $TMPDIR

Each node has at least 750 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 see the section on batch processing for examples on how to use $TMPDIR.

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 (except on memoryhog) 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.

The nodes on TinyFat currently use two different batch systems: all Broadwell-based nodes still use Torque, whereas the newer AMD Rome-based nodes have been switched to Slurm. Please see the batch system description for general information about the two batch systems. In the following, only the features specific to TinyFat will be described.

Torque

To submit batch jobs to TinyFat, you need to use qsub.tinyfat instead of the normal qsub command on the Woody front ends. Be sure to use the correct parameters for qsub as specified in the table above.
To check the status of your jobs, use qstat.tinyfat instead of the normal qstat.

Slurm

Similar command wrappers as for Torque also exist for Slurm. This means that jobs can be submitted from the woody frontend via sbatch.tinyfat. Other examples are srun.tinyfat, salloc.tinyfat, sinfo.tinyfat and squeue.tinyfat. These commands are equivalent to using the option --clusters=tinyfat.

In contrast to other clusters, the Rome-based compute nodes are not allocated exclusively but are shared among several jobs. However, users will only have access to resources (cores, memory) allocated by their job. Exclusive access to the whole node can be requested by using the --exclusive option.

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. For more information, see e.g. the HPC Wiki.

Per default, 8000MB of memory are allocated per physical core. If your application needs a higher ratio than this, more memory can be requested with the option --mem=<memory in MByte>.

The Slurm compute nodes are already running on a newer Ubuntu version than the other nodes and the woody frontend. This might cause problems since Slurm automatically exports the environment of the submit host (woody) to the job. Therefore, we 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.

Example Slurm Batch Scripts

Although SMT is enabled on these nodes, per default only one task per (physical) core is scheduled. If you want to use Hyperthreads, this has to be explicitly specified.

For the most common use cases, examples are provided below.

In this example, the executable will be run using 2 MPI processes for a total job walltime of 6 hours. Each process is running on a physical core and hyperthreads are not used. The job can use up to 16000MB of main memory.

!/bin/bash -l
#
# start 2 MPI processes
#SBATCH --ntasks=2
# 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

srun --mpi=pmi2 ./executable.exe

In this example, the executable will be run using 2 MPI processes for a total job walltime of 6 hours. Only one physical core is allocated and each process is running on one of its hardware threads. The job can use up to 8000MB of main memory.

!/bin/bash -l
#
# start 2 MPI processes
#SBATCH --ntasks=2
# specify to use hyperthreads
#SBATCH --hint=multithread
#equivalent to
##SBATCH --ntasks-per-core=2
# 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

srun --mpi=pmi2 ./executable.exe

In this example, the executable will be run using 2 MPI processes with 8 OpenMP threads each for a total job walltime of 6 hours. 16 cores are allocated in total and each OpenMP thread is running on a physical core. Hyperthreads are not used. The job can use up to 16*8000MB=128000MB of main memory.

OpenMP is not Slurm-aware, so you need to specify OMP_NUM_THREADS in your script. It should match the number of cores requested via --cpus-per-task.

For a more efficient computation, OpenMP threads should be pinned to the compute cores. This can be achieved by the following environment variables: OMP_PLACES=coresOMP_PROC_BIND=true. For more information, see e.g. the HPC Wiki.

!/bin/bash -l
#
# start 2 MPI processes
#SBATCH --ntasks=2
# requests 8 OpenMP threads per MPI task
#SBATCH --cpus-per-task=8
# do not use hyperthreads
#SBATCH --hint=nomultithread
# 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

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

In this example, the executable will be run using 2 MPI processes with 8 OpenMP threads each for a total job walltime of 6 hours. 8 cores are allocated in total and each OpenMP thread is running on one of its hardware threads.  The job can use up to 8*8000MB=64000MB of main memory.

OpenMP is not Slurm-aware, so you need to specify OMP_NUM_THREADS in your script. It should match the number of cores requested via --cpus-per-task.

For a more efficient computation, OpenMP threads should be pinned to the compute cores. This can be achieved by the following environment variables: OMP_PLACES=threadsOMP_PROC_BIND=true. For more information, see e.g. the HPC Wiki.

!/bin/bash -l #
# start 2 MPI processes 
#SBATCH --ntasks=2
# requests 8 OpenMP threads per MPI task
#SBATCH --cpus-per-task=8
# 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 

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

In this example, the executable will be run using 6 OpenMP threads for a total job walltime of 6 hours. 6 cores are allocated in total and each OpenMP thread is running on a physical core.  The job can use up to 6*8000MB=48000MB of main memory.

OpenMP is not Slurm-aware, so you need to specify OMP_NUM_THREADS in your script. It should match the number of cores requested via --cpus-per-task.

For a more efficient computation, OpenMP threads should be pinned to the compute cores. This can be achieved by the following environment variables: OMP_PLACES=coresOMP_PROC_BIND=true. For more information, see e.g. the HPC Wiki.

!/bin/bash -l #
# requests 6 OpenMP threads
#SBATCH --cpus-per-task=6
# do not use hyperthreads
#SBATCH --hint=nomultithread
# 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 

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

In this example, the executable will be run using 6 OpenMP threads for a total job walltime of 6 hours. 3 cores are allocated in total and each OpenMP thread is running on one of its hardware threads.  The job can use up to 3*8000MB=24000MB of main memory.

OpenMP is not Slurm-aware, so you need to specify OMP_NUM_THREADS in your script. It should match the number of cores requested via --cpus-per-task.

For a more efficient computation, OpenMP threads should be pinned to the compute cores. This can be achieved by the following environment variables: OMP_PLACES=threadsOMP_PROC_BIND=true. For more information, see e.g. the HPC Wiki.

!/bin/bash -l #
# requests 6 OpenMP threads
#SBATCH --cpus-per-task=6
# 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 

# 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

To generate an interactive slurm shell on one of the compute nodes, the following command has to be issued on the woody frontend:
salloc --cpus-per-task=10 --time=00:30:00
This will give you an interactive shell for 30 minutes on one of the nodes, allocating 10 physical cores and 80000MB memory. There, you can then for example start the execution of a shared-memory parallel binary:
srun ./my_shared_memory_program.exe
It is executed using 32 threads and up to 128 GBytes of memory (the units are MBytes). Additional tuning and resource settings (e.g. OpenMP environment variables and pining) have to be performed before issuing the srun command.

Software

The Slurm nodes were already upgraded to a newer Ubuntu version and therefore use different software versions and modules than the Torque nodes and the woody frontend. Therefore, it is recommended to compile code directly on the nodes i.e. by requesting an interactive job.

Host software compiled specifically for Intel processors might not run on tf060-tf095.