Using the Cluster

Login

Damit das Resource Management System (RMS) Jobs auf die Compute Nodes verteilen kann, ist ein passwortloser SSH-Zugriff auf alle Nodes notwendig. Beim initialen Login auf dem Cluster wird automatisch ein SSH-Schlüsselpaar generiert, dieses wird unter ~/.ssh abgelegt. Der öffentliche Schlüssel wird in die Datei ~/.ssh/authorized_keys aufgenommen. Nun müssen noch die öffentlichen Schlüssel der Compute Nodes in die Datei ~/.ssh/known_hosts eingetragen werden.


Eine Verbindung zum Cluster wird mit folgendem Befehl aufgebaut:

  
  $ ssh -l USER zuse.cs.uni-potsdam.de
  

Eine Verbindung mit Zugriff auf die GUI wird mit folgendem Befehl aufgebaut:

  
  $ ssh -X -l USER zuse.cs.uni-potsdam.de
  

Dateiverwaltung

Auf dem Cluster hat jeder zugelassen User ein Home-Verzeichnis, welches über NFS an die Cluster Nodes verteilt wird. Dieses Verzeichnis wird nicht an die sonstigen Workstations des Institus exportiert, daher müssen alle benötigten Daten per scp oder rsync auf und von dem Cluster kopiert werden. In ein Backup ist der Cluster nicht eingebunden.


Mit folgenden Befehlen können Daten auf den Cluster kopiert werden:

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

Software

Das Paket `Environment Modules`, welches auf dem Cluster installiert ist, ist ein Werkzeug zur einfachen Verwaltung einer Software-Umgebung (PATH, MANPATH, etc.). Durch das Laden eines Softwarepakets werden für den Anwender automatisch die notwendigen Variablen wie etwa PATH, MANPATH, LD_LIBRARY_PATH gesetzt oder zusätzliche Initialisierungen durchgeführt


Liste der verfügbaren Module anzeigen:

  
  $ module avail
  

Liste der geladenen Module anzeigen:

  
  $ module list
  

Ein Module laden:

  
  $ module load file
  

Ein Module entfernen:

  
  $ module unload file
  

Alle Module entfernen:

  
  $ module purge
  

Wenn bestimmte Module automatisch beim Login geladen werden sollen, kann das z.B. in der ~/.bashrc eingetragen werden:

  
  # load modulefile into the shell environment
  module load torque maui
  

RMS

Die Ressourcen eines Clusters werden von einer zentralen Instanz, dem RMS (Resource Management System), verwaltet. Auf dem Zuse-Cluster wurde Torque als Resource Manager ausgewählt, diese Open Source Software basiert auf OpenPBS. Als Scheduler kommt das Open Source Produkt Maui zum Einsatz.


Der Resource Manager (Torque) informiert den Scheduler (Maui) über den Status aller Ressourcen. Im Anschluß werden die Reservierungen aktualisiert und Jobs, für die Reservierungen vorgenommen wurden, gestartet. Danach werden alle Jobs, für die es keine Reservierungen gibt, verarbeitet (Erstellung einer priorisierten Liste aller lauffähigen Jobs; Starten dieser Jobs in der Reihenfolge ihrer Priorität). Die Ressourcenanforderungen und die Verfügbarkeit der Ressourcen entscheidet, ob ein Job ausgeführt werden kann oder nicht. Nun kommt der Backfill-Mechanismus des Schedulers zum tragen. Da Maui anhand der priorisierten Liste weiß, welcher Job der nächste ist und welche Ressourcen er verbraucht, kann der Scheduler auch entscheiden, welche Jobs zusätzlich gestartet werden können, ohnen die bereits laufenden zu behindern. Diese Vorgehensweise erhöht die Auslastung des Systems. Am Ende eines Zyklus werden die Statistiken aktualisiert.


Mit dem Befehl qsub werden Jobs an das RMS übergeben. Benötigte Ressourcen können in einem Skript oder direkt an der Kommandozeile angefordert werden.

  
  $ qsub job.pbs
  $ qsub -l nodes=2:ppn=2 job.pbs
  

Einfache Ressourcen Beschreibung:

  • Zwei Nodes anfordern:
    qsub -l nodes=2
  • Zwei Nodes mit je zwei CPUs anfordern:
    qsub -l nodes=2:ppn=2
  • Node node001 und node002 mit je zwei CPUs anfordern:
    qsub -l nodes=node001:ppn=2+node002:ppn=2
  • Zwei Minuten Ausführungszeit anfordern:
    qsub -l walltime=00:02:00

Einfaches Batch-Skript:

  
  #!/bin/bash

  # Name des Jobs
  #PBS -N MyTestJob

  # Output und Error in eine Datei schreiben
  #PBS -j oe

  # Job ist nicht wiederholbar
  #PBS -r n

  # Email verschicken, wenn Job (a)bricht, (b)eginnt und/oder (e)ndet
  ##PBS -m ae
  ##PBS -M mail@example.com

  # keine Email verschicken
  #PBS -m n

  # Ressourcen Beschreibung
  #PBS -l walltime=00:30:00
  #PBS -l nodes=2:ppn=1

  # Arbeitsverzeichnis wechseln
  cd $PBS_O_WORKDIR

  # Programm, das gestartet werden soll:
  mpirun -np 2 -machinefile $PBS_NODEFILE mpi
  

Manche Anwendungen und Benchmarks müssen die Knoten exclusiv nutzen können. Im Normalbetrieb versucht das RMS so viele Jobs auf den Knoten zu starten, bis alle Cores ausgenutzt werden. Für den Exklusivbetrieb der Knoten muss dem qsub noch folgender Parameter übergeben werden:

  
  $ qsub -l nodes=2 -W x=NACCESSPOLICY:SINGLEJOB
  

Oder im Skript als erweiterter Kommentar der Form:

  
  #PBS -W x=NACCESSPOLICY:SINGLEJOB
  

Befehle zu Statusinformationen:

  • Anzeige der verfügbaren Ressourcen:
    showbf [-A | -v]
  • Anzeige aktiver, wartender und blockierender Jobs:
    showq [-r | -i | -b]
  • Den Status des Systems anzeigen:
    showstate
  • Den Status des Jobs ausführlich anzeigen:
    checkjob JOB-ID
    qstat [-an | -rn | -i]
  • Den Status des Nodes ausführlich anzeigen:
    checknode NODE
  • Anzeige von statistischen Daten über User, Gruppen und Nodes:
    showstats [-u | -g | -n | -v]
  • Anzeige von statistischen Daten des Schedulers:
    showgrid
  • Anzeige von Daten des Schedulers über Jobs, Nodes, Reservierungen und Fairshare:
    diagnose [-j | -n | -r | -f]
  • Alle Jobs des Users anzeigen:
    qstat -u USER
  • Den Status der Queues anzeigen:
    qstat [-Q | -Qf]

Befehle zur Jobverwaltung:

  • Einen Job anhalten und löschen:
    canceljob JOB-ID
    qdel JOB-ID
  • Einen Job anhalten:
    sethold JOB-ID
    qhold JOB-ID
  • Setzt einen angehaltenen Job fort:
    releasehold JOB-ID
    qrls JOB-ID
  • Einen Job sofort starten:
    runjob -x JOB-ID
  • Verschiebt einen Job innerhalb einer Queue:
    qorder JOB-ID-OLD JOB-ID-NEW
  • Verschiebt einen Job von einer Queue in eine andere:
    qmove QUEUE JOB-ID

Befehle zu Reservierungen:

  • Anzeige der aktuellen Reservierungen:
    showres
  • Eine Reservierung erstellen:
    setres
  • Eine Reservierung löschen:
    releaseres

Befehle bei Probleme mit einzelnen Jobs:

  • Checkjob bewertet die Fähigkeit einen Job sofort zu starten:
    checkjob -v
  • Detailliert Statusinformationen der Knoten:
    checknode
  • Detailliert Zusammenfassung der Jobs:
    diagnose -j
  • Aus welchen Gründen ist der Job als "blocked" oder "non-queued" markiert:
    diagnose -q
  • Anzeige der verfügbaren Ressourcen:
    showbf -v

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 GNU und Intel unterstützen OpenMP. Um OpenMP zu nutzen muss beim GNU-Compiler (gcc) die Compile-Option -fopenmp gesetzt werden, beim Intel-Compiler (icc) heist die Option -openmp.


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 omp.c
  

Mit folgendem Aufruf wird das Programm gestartet:

  
  $ OMP_NUM_THREADS=4 ./omp
  

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, Mvapich und Intel MPI installiert.


Einfaches Beispiel:

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

  int main(int argc, char **argv)
  {
    int rank, size, i;
    char buf[256];
    MPI_Status status;                    /* MPI Status         */
    MPI_Init(&argc, &argv);               /* MPI Initialisieren */
    MPI_Comm_size(MPI_COMM_WORLD, &size); /* MPI size abfragen  */
    MPI_Comm_rank(MPI_COMM_WORLD, &rank); /* MPI rank abfragen  */
    if(rank==0)
    {
      for(i=1; i<size; i++)
      {
        /* MPI Nachricht empfangen */
        MPI_Recv(buf, 256, MPI_CHAR, MPI_ANY_SOURCE, 1, MPI_COMM_WORLD, &status);
        printf("From %d of %d: %s\n", status.MPI_SOURCE, size, buf);
      }
    }
    else
    {
      sprintf(buf, "Hello, World! I am a MPI Process running on ");
      gethostname(buf + strlen(buf), 100);
      /* MPI Nachricht an Prozess 0 senden */
      MPI_Send(buf, 256, MPI_CHAR, 0, 1, MPI_COMM_WORLD);
    }
    MPI_Finalize(); /* MPI beenden */

    return 0;
  }
  

Mit folgendem Aufruf wird das Programm compiliert:

  
  $ mpicc -o mpi mpi.c
  

Mit folgendem Aufruf wird das Programm gestartet:

  
  $ mpirun -np 4 -machinefile NODEFILE mpi           
  

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