Datenschutzerklärung

Batch-System

Bei jedem Start eines Jobs auf dem Cluster werden zum Zwecke der Betriebs- und Datensicherheit sowie zu statistischen Zwecken folgende Daten in Protokolldateien gespeichert:

  • JobID
  • JobName
  • Partition
  • Account
  • AllocCPUS
  • State ExitCode

Eine Auflistung aller gespeicherten Daten kann in der Dokumentation des Batch-Systems eingesehen werden.


Die Daten werden maximal 1 Jahr gespeichert. Eine Zusammenführung mit anderen Datenbeständen erfolgt nicht.


Login

Bei jedem Zugriff auf das Cluster werden zum Zwecke der Betriebs- und Datensicherheit sowie zu statistischen Zwecken folgende Daten in Protokolldateien gespeichert:

  • Zeitpunkt des Zugriffs
  • IP Adresse
  • Fingerprint

Die Daten werden maximal 4 Wochen gespeichert. Eine Zusammenführung mit anderen Datenbeständen erfolgt nicht.

Frühere HPC Cluster

  • Single-chip Cloud Computer (SCC)

Aktuelle HPC Cluster Turing

Hardware

Alle Nodes sind mit 2 CPUs vom Typ Intel Xeon E5-2650v4, 64 GB Hauptspeicher und einem FDR Infiniband Adapter (Mellanox MCX353A-FCBT) ausgestattet.


Service-Nodes

  • Dell PowerEdge R430

Storage-Nodes

  • Dell PowerEdge R430
  • Dell MD1400 mit 16 TB

Compute-Nodes: node1 - node26

  • Dell PowerEdge R430

GPU-Nodes: node27 - node30

  • Dell PowerEdge R730
  • NVIDIA P4

Interconnect: FDR Infiniband

  • Mellanox SX6025, FDR Infiniband, 1 HE, 36 QSFP+ Ports

Interconnect: Gigabit Ethernet

  • Dell PowerConnect 6248

CPU: Intel Xeon E5-2650v4

  • Basistakt: 2.20GHz, Turbotakt: 2.90GHz, 12C/24T, L2-Cache: 3MB (12x 256kB), L3-Cache: 30MB, 9,6GT/s QPI

GPU: Nvidia P4, Pascal

  • SMs: 20
  • Cores/SM: 128
  • Cores/GPU: 2560
  • Memory Size: 8 GB
  • Compute Capability: 6.1

Login

Damit das Resource Management System (RMS) Jobs auf die Compute Nodes verteilen kann, ist ein passwortloser SSH-Zugang auf alle Nodes notwendig. Beim initialen Login wird daher ein SSH-Schlüsselpaar generiert und der öffentliche Teil in die Datei ~/.ssh/authorized_keys kopiert.


Der Zugang zum Cluster erfolgt ausschließlich über den Login-Node:

  
  $ ssh -l USER login.hpc.cs.uni-potsdam.de
  $ ssh -Y -l USER login.hpc.cs.uni-potsdam.de
  

Auf dem Login-Node ist der Terminal-Server X2Go installiert. Um den Service nutzten zu können, muss der X2Go-Client installiert und eine Session eingerichtet werden. Wenn der X2Go-Client zum ersten Mal startet, wird der Session Dialog automatisch aufgerufen.


Hier müssen folgende Parameter eingetellt werden:

  • Host: login.hpc.cs.uni-potsdam.de
  • Login: Username
  • SSH port: 22
  • Session type: LXDE oder XFCE
  • Connection speed: LAN

Datenhaltung

Die Home-Verzeichnisse werden über das parallele Dateisystem BeeGFS mit einer Kapazität von 34 TB auf allen Nodes im Cluster bereitgestellt. Die Anbindung erfolgt über Infiniband. In ein Backup ist das Cluster nicht eingebunden.


Mit folgenden Kommandos können Daten auf das Cluster kopiert werden:

  
  $ scp file USER@login.hpc.cs.uni-potsdam.de:~/
  $ rsync -av file USER@login.hpc.cs.uni-potsdam.de:~/
  

Auf dem Home-Verzeichnis sind Disk-Quotas aktiviert. Die Nutzung der eigenen Quota kann man sich mit folgendem Kommando anzeigen lassen:

  
  $ beegfs-ctl --getquota --uid USER
  

Software

Auf allen Cluster-Nodes ist Debian 9 als Betriebssystem installiert.


Environment Modules ist ein Hilfsmittel zur Verwaltung von Umgebungsvariablen der Shell. Typischerweise werden Variablen, die Suchpfade enthalten, erweitert oder verkürzt (PATH, MANPATHi, etc.). Durch Erweiterungen der Suchpfade wird Software aufrufbar gemacht.


Verfügbare Module anzeigen:

  
  $ module avail
  

Geladenen Module anzeigen:

  
  $ module list
  

Modul laden:

  
  $ module load program[/version]
  

Modul wechseln (z.B. Compiler-Version):

  
  $ module switch program program/version
  

Modul entladen:

  
  $ module unload program
  

Alle Module entladen:

  
  $ module purge
  

Sollen Module automatisch beim Login geladen werden, müssen diese z.B. in die ~/.bashrc eingetragen werden:

  
  # load modulefile into the shell environment
  module load program[/version]
  

Anwendersoftware und Tools

  • cdo: Climate Data Operators
  • ferret: CASE tool for data model editing
  • nco: Command-line operators to analyze netCDF files
  • ncview: X11 visual browser for NetCDF format files
  • R: statistical computation and graphics system

Nutzung des Batch-Systems

Die Ressourcen eines Clusters werden von einer zentralen Instanz, dem RMS (Resource Management System), verwaltet. Auf dem Turing-Cluster wurde Slurm als Resource Manager ausgewählt.


Im folgenden sind die wichtigsten Elemente von Slurm aufgeführt. Die vollständige Dokumentation ist unter http://slurm.schedmd.com/documentation.html zu finden.


Job abschicken:

  
  $ sbatch <job_script>
  

Interaktiv arbeiten:

  
  $ salloc [options]
  

Informationen zu den Partitionen und Nodes auflisten:

  
  $ sinfo -l
  

Status aller Jobs anzeigen:

  
  $ squeue
  

Alle eigenen Jobs anzeigen:

  
  $ squeue -u USER
  

Status eines Jobs anzeigen:

  
  $ squeue -j <job_id>
  

Zu erwartende Startzeit eines Jobs anzeigen:

  
  $ squeue --start -j <job_id>
  

Job löschen oder abbrechen:

  
  $ scancel <job_id>
  

Interaktives Arbeiten unter Kontrolle des RMS

Interaktives Arbeiten unter Kontrolle des Batch-Systems wird insbesondere bei der Entwicklung und Portierung paralleler Programme benötigt. Unter Slurm erfolgt die Zuweisung über das Kommandos salloc. Der Kontrollprozess selbst bleibt auf dem Node, von dem aus salloc aufgerufen wurde.


Mit folgendem Aufruf bekommt man N Nodes zugewiesen:

  
  $ salloc --nodes=N
  

Ein MPI-Programm kann man wie gewohnt aufrufen:

  
  $ srun ./mpi_hello_world
  

Ein OpenMP-Programm wird durch das Kommando srun auf dem zugewiesenen Node zur Ausführung gebracht:

  
  $ export OMP_NUM_THREADS=N
  $ srun ./mpi_hello_world
  

OpenMPI

OpenMPI unterstützt die PMI2-API nicht. Jobs können folgendermaßen gestartet werden:

  
  $ salloc -N 2 -n 4 --tasks-per-node 2 mpirun ./mpi_hello_world
  $ sbatch <job_script>
  

Einfaches Batch-Skript:

  
  #!/bin/bash

  # Do not forget to select a proper partition if the default
  # one is no fit for the job! 

  #SBATCH --output=out.%j
  #SBATCH --error=err.%j
  #SBATCH --nodes=2          # number of nodes
  #SBATCH --ntasks=4         # number of processor cores (i.e. tasks)
  #SBATCH --tasks-per-node=2 # number of tasks per node
  #SBATCH --exclusive
  #SBATCH --time=00:10:00    # walltime

  # Good Idea to stop operation on first error.
  set -e

  # Load environment modules for your application here.
  source /etc/profile.d/modules.sh
  module purge
  module load openmpi/3.0.0

  # Actual work starting here.
  mpirun ./mpi_hello_world
  

MPICH und MVAPICH

MPICH und MVAPICH verwenden die PMI2-API. Jobs können folgendermaßen gestartet werden:

  
  $ salloc -N 2 -n 4 --tasks-per-node=2 srun ./mpi_hello_world
  $ srun -N 2 -n 4 --tasks-per-node=2 ./mpi_hello_world
  $ sbatch <job_script>
  

Einfaches Batch-Skript:

  
  #!/bin/bash

  # Do not forget to select a proper partition if the default
  # one is no fit for the job! 

  #SBATCH --output=out.%j
  #SBATCH --error=err.%j
  #SBATCH --nodes=2          # number of nodes
  #SBATCH --ntasks=4         # number of processor cores (i.e. tasks)
  #SBATCH --tasks-per-node=2 # number of tasks per node
  #SBATCH --exclusive
  #SBATCH --time=00:10:00    # walltime

  # Good Idea to stop operation on first error.
  set -e

  # Load environment modules for your application here.
  source /etc/profile.d/modules.sh
  module purge
  module load mvapich2/2.3

  # Actual work starting here.
  srun ./mpi_hello_world
  

GPU

Die Nodes node27-node30 sind mit je zwei Tesla P4 GPUs ausgestattet. Über die Parameter --gres und --constraint können die GPUs vom Batch-Systems angefordert werden.


Ein Node mit einer GPU anfordern:

  
  $ srun --nodes=1 --gres=gpu:1 hostname
  

Ein Node mit zwei GPUs anfordern:

  
  $ srun --nodes=1 --gres=gpu:2 hostname
  

Zwei Nodes mit je einer GPU vom Typ P4 anfordern:

  
  $ srun --nodes=2 --gres=gpu:1 --constraint="gpu,p4" hostname
  

Zwei GPU Nodes vom Typ P4 anfordern:

  
  $ srun --nodes=2 --constraint="gpu,p4" hostname
  

Wichtige Job Parameter

Job-Name:--job-name=name
Stdout-Datei:--output=name
Stderr-Datei:--error=name
Partition:--partition=name
Anzahl der Nodes:--nodes=n
Anzahl der Cores:--ntasks=n
Prozesse pro Node:--tasks-per-node=n
GPUs pro Node:--gres=gpu:n
Nodes nicht teilen:--exclusive
Zeitlimit:--time=minutes, --time=hh:mm:ss
Email-Adresse:--mail-user=address
Email-Benachrichtigung:--mail-type=BEGIN, --mail-type=END, --mail-type=FAIL, --mail-type=ALL


Wichtige Umgebungsvariablen

$SLURM_JOBID:Job-ID
$SLURM_SUBMIT_DIR:Verzeichnis aus dem der Job abgeschickt wurde
$SLURM_JOB_NODELIST:Liste der zugewiesenen Nodes


Benchmarks

Netzwerk Ethernet

  
  $ iperf3 -s -A 2
  $ iperf3 -c <IP> -A 2 -f M -l 1M -t 12 -O 2

  [ ID] Interval           Transfer     Bandwidth
  [  4]   0.00-12.00  sec  1.32 GBytes  112 MBytes/sec   receiver
  

Netzwerk Infiniband IPoIB

  
  $ iperf3 -s -A 2
  $ iperf3 -c <IP> -A 2 -f M -l 1M -t 12 -O 2

  [ ID] Interval           Transfer     Bandwidth
  [  4]   0.00-12.00  sec  44.5 GBytes  3796 MBytes/sec  receiver
  

Netzwerk Infiniband RDMA

  
  $ ib_read_bw -F -R -s 1048576
  $ ib_read_bw <IP> -F -R -s 1048576

  #bytes     #iterations    BW peak[MB/sec]    BW average[MB/sec]   MsgRate[Mpps]
  1048576    1000           6120.37            6120.37              0.006120
  

  
  $ ib_write_bw -F -R -s 1048576
  $ ib_write_bw <IP> -F -R -s 1048576

  #bytes     #iterations    BW peak[MB/sec]    BW average[MB/sec]   MsgRate[Mpps]
  1048576    5000           6105.46            6105.38              0.006105
  

I/O lokale Filesystem

  
  $ dd if=/dev/zero of=/mnt/beegfs/storage/benchmark bs=1G count=10 oflag=direct

  10737418240 bytes (11 GB, 10 GiB) copied, 10.9005 s, 985 MB/s
  

I/O BeeGFS Filesystem

  
  $ dd if=/dev/zero of=/mnt/beegfs/client/benchmark bs=1G count=10 oflag=direct

  10737418240 bytes (11 GB, 10 GiB) copied, 6.4314 s, 1.7 GB/s
  

Paralleles Programmieren

Shared Memory

Für `Shared Memory` Programmierung, auf Multiprozessor-Systemen, hat sich OpenMP als de facto Standart etabiliert. OpenMP ist eine Spracherweiterung und Bibliothek für die Sprachen C, C++ und FORTRAN. Die Parallelisierung mittels OpenMP findet auf Thread-, bzw. Schleifenebene statt. Im OpenMP-Standard sind dafür spezielle Compiler-Direktiven definiert worden. Mit Hilfe dieser kann z. B. eine for-Schleife auf mehrere Threads und/oder Prozessoren aufgeteilt werden. Compiler die mit OpenMP nicht umgehen können interpretieren diese Anweisungen als Kommentare oder ignorieren sie einfach.


Die auf dem Cluster installierten Compiler unterstützen OpenMP. Um OpenMP zu nutzen muss beim GNU-Compiler (gcc) die Compile-Option -fopenmp gesetzt werden.


Einfaches Beispiel:

  
  #include <omp.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>

  int main(void) 
  {
  int id,i;

  #pragma omp parallel for private(id) /* OpenMP Pragma */
  for (i = 0; i < 8; ++i) 
  {
    id = omp_get_thread_num();
    printf("Hello World from thread %d\n", id);
    if (id == 0)
      printf("There are %d threads\n", omp_get_num_threads());
  }

  return 0;
  }
  

Mit folgendem Aufruf wird das Programm compiliert:

  
  $ gcc -Wall -fopenmp -o omp_hello_world omp_hello_world.c
  

Mit folgendem Aufruf wird das Programm gestartet:

  
  $ OMP_NUM_THREADS=4 ./omp_hello_world
  

Distributed Memory

Für `Distributed Memory` Programmierung gilt MPI (Message Passing Interface) als Standard. Ein Programm welches mit MPI parallelisiert wurde, besteht aus miteinander kommunizierenden Prozessen, die bei der Programmausführung parallel gestartet werden. Für den Datenaustausch werden Nachrichten verwendet. MPI selbst beschreibt lediglich den Nachrichtenaustausch auf verteilten Computersystemen, es wird eine Programmierschnittstelle bereitgestellt aber keine Implementierung. Diese werden durch Dritte als freie (quelloffene) oder kommerzielle Implementierung bereitgestellt.


Auf unserem Cluster wurde MPICH, OpenMPI und MVAPICH installiert.


Einfaches Beispiel:

  
  #include <mpi.h>
  #include <stdio.h>

  int main(int argc, char** argv) {
    // Initialize the MPI environment.
    MPI_Init(NULL, NULL);

    // Get the number of processes
    int world_size;
    MPI_Comm_size(MPI_COMM_WORLD, &world_size);

    // Get the rank of the process
    int world_rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);

    // Get the name of the processor
    char processor_name[MPI_MAX_PROCESSOR_NAME];
    int name_len;
    MPI_Get_processor_name(processor_name, &name_len);

    // Print off a hello world message
    printf("Hello world from processor %s, rank %d out of %d processors\n",
            processor_name, world_rank, world_size);

    // Finalize the MPI environment. No more MPI calls can be made after this
    MPI_Finalize();
  }
  

Mit folgendem Aufruf wird das Programm compiliert:

  
  $ mpicc -o mpi_hello_world mpi_hello_world.c
  

Mit folgendem Aufruf wird das Programm gestartet:

  
  $ mpirun -np 4 -hostfile NODEFILE ./mpi_hello_world
  

Applications

  • MOM (Modular Ocean Model): In cooperation with PIK (Potsdam Institute for Climate Impact Research)
  • Simulation of seismic waves: In cooperation with the Institute for Geosciences, University Potsdam
  • Gadget: In cooperation with AIP (Astrophysical Institute Potsdam)
  • Cellular automaton: A Game-of-Life like application for experiments

IT-Helpdesk

Bei technischen Problemen und Fragen zur Nutzung steht ein zentraler Helpdesk zur Verfügung:
helpdesk(at)cs.uni-potsdam.de