# GPU Workstations

## Hardware

Für Berechnungen in Lehre stehen an der Fachhochschule verschiedene Workstations zur Verfügung. Eine Übersicht über die Maschinen findest Du ![hier](https://gitea.fhgr.ch/CDS/infrastruktur-dok/src/branch/main "Hardware Übersicht")

## Zugriff

Der Zugriff erfolgt über SSH aus den Netzen (WLAN, VPN) der FH Graubünden. Wie eine SSH Verbindung eingerichtet wird, ist hier ![hier](https://gitea.fhgr.ch/CDS/infrastruktur-dok/src/branch/main/Lab-Login-Tutorial.md "SSH Einrichten") beschrieben. 

## Architektur

Alle Workstations für die Lehre sind nach dem folgenden Muster aufgebaut:

|Was|Beschreibung|
|---|---|
|Login|Für das Login mit SSH verwendest Du deinen FH Graubünden Benutzername und Passwort|
|Homeverzeichnis mit einer Quota von 80GB pro Benutzer|Welche Möglichkeiten Du hast falls dein Homeverzeichnis voll ist, siehst Du hier ![Troubleshooting](https://gitea.fhgr.ch/CDS/infrastruktur-dok/src/branch/main/Installation-Tensorflow.md#troubleshooting)|
|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 ![Installation Tensorflow](https://gitea.fhgr.ch/CDS/infrastruktur-dok/src/branch/main/Installation-Tensorflow.md) 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 im Dokument ![Installation Tensorflow](https://gitea.fhgr.ch/CDS/infrastruktur-dok/src/branch/main/Installation-Tensorflow.md) beschrieben oder in der ![Apptainer Dokumentation](https://apptainer.org/docs/user/latest/)|


## Job Scheduler und Partitionen

Da alle Workstation an der FH auch ein Mehrbenutzersysteme sind, 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. Daher musst Du bei einer GPU Berechnung zwingend ![Slurm](https://slurm.schedmd.com/quickstart.html) verwenden.

Grundsätzlich folgt Slurm auf den Workstations 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. Die möglichen Partitionen kannst Du mit dem Befehl ```sinfo``` anzeigen lassen. Typischerweise gibt es für die Studierenden die foglenden zwei Partition

|Partition | Zweck | Maximale Dauer|
|-------|--------------|----|
| Debug | Zum Testen und Experimentieren| 5 Min|
| Students| Für lange laufende Berechnungen| 7 Tage|

Falls deine Berechnung weniger als sieben Tage benögtigt, sind dir deine Mitstudierenden sicherlich sehr dankbar, wenn Du den Slurmjob beendest sobald deine Berechnung abgeschlossen ist. 

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.

Übrigens: sobald deine Berechnung fertig ist beende auch deinen Slurmjob, zum Beispiel mit ```scancel```. Somit wird die GPU für den nächsten Benutzer freigegeben.

## Slurm

Slurm auf den Workstations wird nur zwingend benötigt, wenn deine Berechnung auf der GPU ausgeführt werden soll. Jobs, die nur auf der CPU rechnen, müssen Slurm nicht verwenden. Bei sehr intensiver und lange anhaltender CPU Belegung, empfehlen wir jedoch eine Nutzung von Slurm, damit eine parallel laufende GPU Berechnung nicht gestört wird.

Welche Hardware wir auf dem Rechner zur Verfügung haben, können wir uns mit dem Befehl

```
 sinfo -o "%N  %c  %m  %G" | column -t
```

anzeigen lassen.

Mit dem Befehl `srun` kann ein Slurmjob auf dem Cluster ausgeführt werden. Als simples Beispiel berechnen wir hier die Primfaktoren einer grossen Zahl`

```
srun -G a100:1 -p students -n 64 factor 1234567890123456789012345678901234567890
```
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 und pro Core zwei hyperthreading Cores zur Verfügung haben, können wir den Parameter `-n` auf maximal 64 setzen. Die Option `-G a100:1` fordert eine Nvidia A100 GPU für die Berechnung an.  Sobald die Computerresource frei ist, wird der Befehl `srun` ausgeführt und es werden auf der CPU 64 Prozesse gestartet. Sobald die Berechnung abgeschlossen ist, wird das Ergebniss auf der Kommandozeile ausgegeben.

Für nicht-interaktive und länger laufende Jobs ist es sinnvoll `sbatch` zu verwenden. Damit muss nicht gewartet werden bis die Workstation frei wird, sondern der Jobscheduler übernimmt das Skript und bringt es zur Ausführung sobald die Hardwareresourcen frei sind. An welcher Reihe sich mein Job befindet, kann mit dem Befehl

`squeue` angezeigt werden.

Für `sbatch` 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 --output="slurm-%j.out"     ## Logfile. The logfile is written to the current directory
#SBATCH --error="slurm-%j.err"     ## Logfile. The logfile is written to the current directory
#SBATCH --time=1:30:00              ## Time limit. Should be equal or smaller than the partitions time limit. In this example the job will be interrupted after 1h and 30 min.
#SBATCH --job-name="Mein Test"      ## Job name.  This will be used in naming directories for the job.
#SBATCH --partition=students        ## Partition to launch job in
#SBATCH --cpus-per-task=1           ## The number of threads the code will use
#SBATCH --ntasks-per-node=64        ## Number of tasks (processes/threads) to run

# Execute the python script and pass the argument '90'
srun python3 my-mpiProg.py 90
```

Es ist auch möglich eine interaktive Slurm Session zu nutzen. Dazu kann zum Beispiel der folgende Befehl am Workstation Prompt eingegeben werden:

```
salloc -p staff --time=00:01:00
```
Danach können 



[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