forked from CDS/infrastruktur-dok
178 lines
9.8 KiB
Markdown
178 lines
9.8 KiB
Markdown
# GPU Workstations
|
|
|
|
## Hardware
|
|
|
|
Für Berechnungen in der Forschung und Lehre stehen an der Fachhochschule verschiedene Workstations zur Verfügung. Eine Übersicht über die Maschinen findest Du hier 
|
|
|
|
## Zugriff
|
|
|
|
Der Zugriff erfolgt über SSH aus den Netzen (WLAN, VPN) der FH Graubünden. Wie eine SSH Verbindung eingerichtet wird, ist hier  beschrieben.
|
|
|
|
## Architektur
|
|
|
|
Alle Workstations für die Lehre sind nach dem folgenden Muster aufgebaut:
|
|
|
|
|Was|Beschreibung|
|
|
|---|---|
|
|
|Homeverzeichnis mit einer Quota von 80GB pro Benutzer|Welche Möglichkeiten Du hast falls dein Homeverzeichnis voll ist, siehst Du hier |
|
|
|Ein Verzeichnis ```/scratch``` für die temporäre Ablage von grossen Datenmengen|In diesem Verzeichnis bitte keine vertrauliche Daten ablegen |
|
|
|Slurm für den Zugriff auf die GPUs|Wie das funktioniert steht im Abschnitt [Job Scheduler und Partitionen](#job-scheduler-und-partitionen)|
|
|
|Installation zusätzlicher Software|Zusätzlichen Pakete können über die Software Anaconda/Miniconda oder Pip installiert werden. Wie das funktioniert ist zum Beispiel im Dokument  beschrieben|
|
|
|Container|Für die Arbeit mit Containern ist die Software Apptainer installiert. Wie mit Apptainer Software installiert werden kann (auch für Software die Rootrechte benötigt) ist auch im Dokument  beschrieben.|
|
|
|
|
*
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## Clusterfilesystem und Homeverzeichnis
|
|
|
|
Auf dem Cluster wird das Homeverzeichnis von jedem Benutzer automatisch mit [NFS][9] auf die Computenodes exportiert. Das heisst, dass auf jedem Node, egal ob Master oder Computenode die Daten des Homeverzeichnisses zur Verfügung stehen. Übrigens: auf deinem Homeverzeichnis steht jedem Anwender 80 GB Speicherplatz zur Verfügung. Wieviel Speicherplatz Du bereits belegt hast, kannst Du mit dem Befehl `quota -fs /` ausfindig machen.
|
|
|
|
Des weiteren gibt es unter dem Verzeichnis `/scratch` ein geshartes Filesystem mit einer Grösse von ca. 500 TB. Hier kommt BeeGFS, ein paralleles Filesysteme zum Einsatz das Speicherplatz von allen Computenodes unter dem Mountpoint (Verzeichnis) `/scratch` vereint. Daher kann es nur genutzt werden wenn alle Computenodes gestartet sind. Wie das Homverzeichnis ist auch das /scratch Laufwerk von allen Nodes zugreifbar.
|
|
|
|
Bitte beachte, dass Dateien unter dem Verzeichnis `/scratch` von allen Clusterbenutzern gelesen aber nur vom Dateieigentümer verändert werden können.
|
|
|
|
## Stromverbrauch und Energiesparmodus
|
|
|
|
Mit dem Befehl
|
|
|
|
```
|
|
sudo /usr/local/bin/get-powerUsage.bash
|
|
```
|
|
kann der momentane Stromverbrauch des Clusters in Erfahrung gebracht werden. Dabei ist der Stromverbrauch des High Performance Transports (in unserem Falle Infiniband) nicht mit eingerechnet.
|
|
|
|
Der Energiesparmodus wird aktiviert, falls der letzte Slurm Job vor mehr als 90 Minuten abgeschlossen wurde oder falls nach dem Start der Nodes 90 Minuten kein Slurmjob gestartet wurde. Solange Slurmjobs ausgeführt werden, werden die belegeten Clusternodes nicht in einen Energiestparmodus versetzt oder ausgeschaltet.
|
|
|
|
## Installation von zusätzlicher Software
|
|
|
|
Viele Machinlearning und Deeplearning Frameworks oder Python Module können über Anaconda, Miniconda oder Apptainer installiert werden. Für Anhaltspunkte wie das gemacht werden kann, siehe die Anleitung [Softwareinstalltionen auf den Workstations][8]
|
|
|
|
|
|
## Job Scheduler und Partitionen
|
|
|
|
Da ein Cluster auch ein Mehrbenutzersystem ist, können dessen Resourcen nicht jederzeit frei verwendete werden. Daher kommt ein Jobscheduler zum Einsatz, der Rechenjobs mit den zur Verfügung stehenden Ressourcen möchglichst optimal zur Ausführung bringt. Auf lithium.fhgr.ch werden die Jobs durch [Slurm][6] verwaltet.
|
|
|
|
Grundsätzlich folgt Slurm auf Lithium dem [FIFO mit Backfill][7] Prinzip. Vereinfacht gesagt bedeutet das, dass der erste eingereichte Job zuerst abgearbeitet wird. Weiter wird die Ressourcennutzung durch sogenannte Partitionen eingeschränkt. Diese bestimmen wie lange ein Benutzer einen Slurm-Job ausführen darf. Momentan sind die folgenden Partitionen konfiguriert:
|
|
|
|
| Anwendergruppe / Partitionen | Debug | Studierende | Mitarbeitende
|
|
|------------------------------|-------|--------------|---------------
|
|
| Studierende | 5 Min | 3 h | kein Zugriff
|
|
| Mitarbeitende | 5 Min | kein Zugriff | 12 h
|
|
|
|
Eine Berechnung die länger als die durch die Partition vorgegebene Zeit läuft wird **abgebrochen**. Diese Limite ist dazu da, damit ein Benutzer nicht irrtümlich oder absichtlich den Cluster für eine unbegrenzte Zeit blockieren kann. Daher empfiehlt es sich dringend, im Skript sogenannte 'Checkpoints' zu implementieren. Wie Checkpoints im Falle von Tensorflow oder Keras implementiert werden, findest Du [hier][11]. Checkpoints schützen übrigens auch vor einem Zeitverlust bei einem Stromausfall.
|
|
|
|
Falls Du deutlich mehr als die oben erwähnten Zeitspannen für eine Berechnung brauchst, melde dich beim DAViS Admin.
|
|
|
|
## Erste Schritte auf dem Cluster
|
|
|
|
Mit dem Befehl srun kann ein Slurmjob auf dem Cluster ausgeführt werden. Als simples Beispiel dient hier der Befehl 'hostname', der den Namen des lokalen Rechners anzeigt.
|
|
|
|
```
|
|
srun -p students -n $((36*5)) -N5 hostname
|
|
```
|
|
Mit der Option `-p` wird die Partition ausgewählt, im obigen Fall die 'students' Partition. Mit der Option `-n` teilen wir Slurm mit, wieviele parallele Tasks (Prozesse) wir ausführen wollen. Da wir pro Computenode 36 physische Cores haben (Hyperthreading ist deaktiviert) können wir auf dem Cluster maximal 180 Prozesse starten. Die Option `-N` teilt Slurm mit wieviele Computenodes für die Berechnung verwendet werden sollen. Im obigen Fall sollten wir daher genau 180 Zeilen Output erhalten.
|
|
|
|
Mit dem Befehl ```squeue``` kann angezeigt werden welche Jobs momentan ausgeführt werden und welche Jobs auf Ressourcen warten.
|
|
|
|
Für nicht-interaktive und länger laufende Jobs ist es sinnvoll `sbatch` zu verwenden. Damit muss nicht gewartet werden bis der Cluster frei wird, sondern der Jobscheduler informiert den Anwender per Mail sobald das Skript zur Ausführung kommt.
|
|
|
|
Dafür muss ein Shellskript geschrieben werden das einerseits einen Abschnitt enthält mit Informationen für Slurm (diese Befehle sind mit `#SBATCH` gekenntzeichnet) andererseits einen Abschnitt der den Befehl zum Starten der Berechnungen enthält. Dies könnte zum Beispiel so aussehen:
|
|
|
|
```
|
|
#!/bin/bash
|
|
|
|
#SBATCH --nodes=5 ## Number of computenodes
|
|
#SBATCH --output="slurm-%j.out" ## Logfile
|
|
#SBATCH --time=240:00 ## Time limit. Should be equal or smaller than the partitions time limit
|
|
#SBATCH --job-name="test-mpi" ## Job name. This will be used in naming directories for the job.
|
|
#SBATCH --partition=staff ## Partition to launch job in
|
|
#SBATCH --cpus-per-task=1 ## The number of threads the code will use
|
|
#SBATCH --ntasks-per-node=1 ## Number of tasks (processes/threads) to run
|
|
#SBATCH --mail-type=BEGIN,END ## Sends a Email when Job starts and when the Job ends
|
|
#SBATCH --mail-user=<mail address> ## Mail Address
|
|
|
|
|
|
# Load an environment
|
|
module load py3-mpi4py
|
|
|
|
# Execute the python script and pass the argument '90'
|
|
srun python3 my-mpiProg.py 90
|
|
```
|
|
## MPI Hello World
|
|
|
|
Der Cluster unterstützt das Message Passing Interface welches das parallele und verteilte Rechnen eines Programms auf mehreren Nodes erlaubt. Um MPI zu nutzen, muss der Programmcode angepasst werden. Ein Hello World mit C und MPI sieht zum Beispiel so aus:
|
|
|
|
```
|
|
#include <stdio.h>
|
|
#include "mpi.h"
|
|
int main(int argc, char *argv[]) {
|
|
|
|
char hostname[1024];
|
|
hostname[1023] = '\0';
|
|
gethostname(hostname, 1023);
|
|
|
|
int ierr;
|
|
ierr = MPI_Init(&argc, &argv);
|
|
printf( "Hello from %s\n", hostname);
|
|
ierr = MPI_Finalize( );
|
|
exit(ierr);
|
|
}
|
|
```
|
|
|
|
Da das Programm die MPICH Impelmentierung nutzen soll, laden wir zuerste das entsprechende Module
|
|
```
|
|
module load intel mpich
|
|
```
|
|
Danach speichern wird den obigen Programmcode in der Datei hello_world_mpich.c und übersetzen den Sourcecode mit dem Befehl:
|
|
|
|
```
|
|
mpicc ./hello_world_mpich.c -o hello_world_mpich
|
|
```
|
|
Falls noch nicht erfolgt, sollten sptätestens jetzt, die Cluster Resourcen mit dem Befehl ```salloc``` alloziert werden. Falls alle Clusterresourcen frei sind können diese für einen Benutzer der Gruppe 'Staff' wie folgt alloziert werden:
|
|
|
|
```
|
|
salloc -p staff -n 180 -N 5
|
|
```
|
|
|
|
Danach kann das Program mit dem Befehl
|
|
|
|
```
|
|
mpirun ./hello_world_mpich
|
|
```
|
|
ausgführt werden. Der Output sieht wie folgt aus:
|
|
|
|
```
|
|
...
|
|
Hello from computenode1
|
|
Hello from computenode4
|
|
Hello from computenode4
|
|
Hello from computenode1
|
|
Hello from computenode1
|
|
Hello from computenode1
|
|
Hello from computenode5
|
|
Hello from computenode4
|
|
Hello from computenode4
|
|
Hello from computenode4
|
|
Hello from computenode4
|
|
Hello from computenode4
|
|
Hello from computenode4
|
|
Hello from computenode4
|
|
...
|
|
````
|
|
|
|
|
|
|
|
[1]: https://de.wikipedia.org/wiki/Beowulf_(Cluster) "Beowulf Cluster"
|
|
[2]: https://openhpc.community/ "OpenHPC"
|
|
[3]: https://warewulf.org/ "Warewulf"
|
|
[4]: https://docs.oracle.com/en/servers/x86/x86-server-x5-2l/ "Handbücher"
|
|
[5]: https://en.wikipedia.org/wiki/Remote_direct_memory_access
|
|
[6]: https://slurm.schedmd.com/
|
|
[7]: https://slurm.schedmd.com/sched_config.html
|
|
[8]: https://gitea.fhgr.ch/CDS/infrastruktur-dok/src/branch/main/Installation-Tensorflow.md
|
|
[9]: https://de.wikipedia.org/wiki/Network_File_System
|
|
[10]:https://top500.org/
|
|
[11]:https://www.tensorflow.org/guide/checkpoint |