Linaro Forge

Die Linaro Forge Suite bietet eine Reihe von Tools, die sowohl grafisch als auch über die Kommandozeile verfügbar sind und für das Debugging und Profiling von parallelen und sequenziellen Programmen zugeschnitten sind. Sie unterstützt viele parallele Architekturen und Modelle, darunter MPI, CUDA und OpenMP. Es besteht aus den folgenden Werkzeugen:

1. Linaro DDT: Dieses Tool ist auf das parallele Hochleistungs-Debugging von Anwendungen spezialisiert.
2. Linaro MAP: Dieses Tool ist für die Erstellung von Leistungsprofilen und Optimierungsanweisungen vorgesehen.
3. Linaro Performance Reports: Dieses Tool wird verwendet, um die Leistung sowohl von skalaren als auch von MPI-Anwendungen zusammenzufassen und zu charakterisieren.

Die Dokumentation ist online verfügbar.

Auf dem OMNI-Cluster ist Linaro Forge Version 23.1.1 installiert. Um diesen Debugger zu verwenden, laden Sie das Modul debugger/linaro-forge mit dem folgenden Befehl:

$ module load debugger/linaro_forge

Das Benutzerhandbuch in Englisch ist auch in PDF-Form im Installationsverzeichnis verfügbar, und zwar in folgendem Ordner:

/cm/shared/omni/apps/linaro_forge/23.1.1/doc/userguide-forge.pdf

Linaro DDT

Linaro DDT ist ein leistungsstarker grafischer Debugger, der für viele verschiedene Entwicklungsumgebungen geeignet ist. Dieses Tool unterstützt:

• C, C++, und alle Derivate von Fortran, einschließlich Fortran 90.
• Eingeschränkte Unterstützung für Python. Weitere Informationen finden Sie unter Python debugging.
• Parallele Programmiersprachen/Modelle einschließlich MPI, UPC und Fortran 2008 Co-Arrays.
• GPU-Sprachen wie HMPP, OpenMP Accelerators, CUDA, CUDA Fortran und HIP.

Die folgenden Schritte zeigen den Prozess der Verwendung dieses Tools zum Debuggen einer Anwendung.

1. Laden Sie zunächst das entsprechende Modul mit dem folgenden Befehl:

   $ module load debugger/linaro_forge

2. Starten Sie das Linaro DDT als grafische Anwendung in einem neuen Fenster mit folgendem Befehl:

   $ ddt &

   Es öffnet sich das folgende Fenster, in dem Linaro DDT standardmäßig ausgewählt ist.

   

   Hinweis: Wie alle anderen grafischen Anwendungen auf dem Cluster muss Ihre SSH-Verbindung mit X11-Unterstützung hergestellt werden, und auf Ihrem PC muss ein X-Server laufen; siehe auch hier.

3. Um ein Programm zu starten und zu debuggen, wählen Sie die Option RUN. Daraufhin öffnet sich ein neues Fenster, in dem die zu debuggende Anwendung ausgewählt werden sollte. Je nach Art der Anwendung wählen Sie die entsprchenden Optionen wie “OpenMP”, “MPI”, “CUDA”, usw. Dann klicken Sie auf die Schaltfläche “Run”, wodurch sich die DDT-Schnittstelle öffnet.

   

   Hinweis: Wenn Sie das Programm kompilieren, fügen Sie ein Debug-Flag zu Ihrem Kompilierbefehl hinzu. Bei den meisten Compilern ist dies -g. Es wird empfohlen, Compiler-Optimierungen zu deaktivieren, da sie beim Debuggen zu unerwarteten Ergebnissen führen können.

4. Die DDT-Schnittstelle öffnet einen Source Code Viewer, in dem Sie Breakpoints setzen, die Programmausführung kontrollieren, Stacks verfolgen können usw., um die Anwendung zu debuggen. Weitere Einzelheiten finden Sie in der Online-Dokumentation.

   

5. Um die Sitzung zu speichern, wählen Sie File ‣ Save Session. Dadurch werden HTML- und Textdateien exportiert, die mit dem folgenden Befehl angezeigt werden können:

   $ firefox name.html

   Ersetzen Sie in diesem Befehl die Datei name.html durch Ihren eigenen Dateinamen. Dies öffnet ein firefox-Fenster, in dem die Übersicht über die Anwendung angezeigt wird.

   

6. Um Ihre aktuelle Sitzung zu beenden, wählen Sie File ‣ End Session.

Verwendung der Befehlszeile

Um DDT ohne GUI auszuführen, verwenden Sie den folgenden Befehl:

$ ddt --offline ./executable_name.exe

Verwenden Sie ddt --help, um mehr über den Befehl zu erfahren. Die Ausgabe wird als HTML-Datei erzeugt.

Beispiel:

(base) [g056127]$ ddt --offline --openmp-threads=8 ./dotprod
Linaro Forge 23.1.1 - Linaro DDT

Debugging                : /home/g056127/openmp/dotprod
MPI implementation       : Auto-Detect (Open MPI)
Memory debugging enabled : No

Offline log written to: 'dotprod_1p_1n_4t_2024-02-15_19-51.html'

Linaro MAP

MAP ist ein Profiler auf Quellcodeebene, der anzeigt, wie viel Zeit für jede Codezeile aufgewendet wurde. Es zeigt die am längsten laufenden Codezeilen und erklärt, warum.

Die folgenden Schritte zeigen, wie Sie dieses Tool zum Debuggen einer Anwendung verwenden können.

1. Laden Sie zunächst das entsprechende Modul mit dem folgenden Befehl:

   $ module load debugger/linaro_forge/23.1.1 

2. Starten Sie Linaro MAP als grafische Anwendung in einem neuen Fenster mit folgendem Befehl:

   $ map &

   Es öffnet sich das folgende Fenster, in dem Linaro MAP standardmäßig ausgewählt ist.

   

   Hinweis: Wie alle anderen grafischen Anwendungen auf dem Cluster muss Ihre SSH-Verbindung mit X11-Unterstützung hergestellt werden, und auf Ihrem PC muss ein X-Server laufen; siehe auch hier.

3. Um ein Programm zu profilieren, wählen Sie die Option PROFILE. Dies öffnet eine Schnittstelle zur Auswahl des Programms und zur Konfiguration des Vorgangs. Je nach Art der Anwendung wählen Sie die richtigen Optionen wie “OpenMP”, “MPI”, “CUDA” usw. Klicken Sie dann auf die Schaltfläche “Ausführen”, wodurch die MAP-Schnittstelle geöffnet wird.

   

4. Die MAP-Schnittstelle zeigt den Quellcode, die Anwendungsaktivität und Metriken wie Speichernutzung, CPU-Nutzung usw. an. Sie zeigt die Speicher- und CPU-Nutzung für jede Zeile des Codes an.

   

5. Sie können das MAP-Profil unter File ‣ Save Profile Data as speichern. Die Erweiterung der Datei ist .map. Das Profil kann auch als JSON exportiert werden über File ‣ Export Profile Data as JSON. Das Kartenprofil kann mit der zweiten Option “LOAD PROFILE DATA FILE” auf der Startseite von Linaro MAP erneut angezeigt werden.

Verwendung der Befehlszeile

Um MAP ohne GUI auszuführen, verwenden Sie den folgenden Befehl:

$ map --profile ./executable_name.exe

Verwenden Sie map --help, um mehr über diesen Befehl zu erfahren. Dieser Befehl erzeugt eine MAP-Ausgabedatei mit der Erweiterung .map.

Beispiel:

(base) [g056127]$ map --profile --openmp-threads=8 ./dotprod
Linaro Forge 23.1.1 - Linaro MAP

Profiling            : /home/g056127/openmp/dotprod
Linaro Forge sampler : preload
MPI implementation   : Auto-Detect (Open MPI)

MAP analysing program...
MAP gathering samples...
MAP generated /home/g056127/openmp/dotprod_1p_1n_8t_2024-02-15_19-57.map

Linaro MAP profiling summary
============================
Profiling time:      4 seconds
Peak process memory: 8042729472 B (~7.49 GiB)

Compute:             100.0%     (3.8s) |=========|
MPI:                   0.0%     (0.0s) |
I/O:                   0.0%     (0.0s) |
  (based on time on the main thread)

Linaro Performance Reports

Linaro Performance Reports bietet die effektivste Möglichkeit, die Leistung von HPC-Anwendungsläufen zu charakterisieren und zu verstehen.

Ein einseitiger HTML-Bericht beantwortet eine Reihe von wichtigen Fragen für jede HPC-Site:

• Ist diese Anwendung für das System, auf dem sie läuft, optimiert?

• Profitiert sie von der Ausführung in diesem Maßstab?

• Gibt es I/O- oder Netzwerkengpässe, die die Leistung beeinträchtigen?

• Welche Hardware-, Software- oder Konfigurationsänderungen können vorgenommen werden, um die Leistung weiter zu verbessern?

Es gibt drei verschiedene Methoden zur Erstellung des Leistungsberichts, die im Folgenden beschrieben werden. Sie können jede der Methoden verwenden.

1. Verwendung der exe-Datei: Um den Leistungsbericht zu erstellen, verwenden Sie den folgenden Befehl:

   $ perf-report ./executable_name.exe

   Ersetzen Sie die Datei executable_name.exe durch Ihr Programm. Dieser Befehl erzeugt die beiden Dateien mit den Erweiterungen .html und .txt, die mit dem Browser angezeigt werden können.

2. Verwendung einer zuvor erstellten MAP-Ausgabedatei: Wenn Sie die Ausgabedatei .map bereits mit dem MAP-Tool erstellt haben, können Sie den folgenden Befehl verwenden, um den Leistungsbericht zu erstellen.

   $ perf-report profile.map

   Ersetzen Sie die Datei profile.map durch Ihre MAP-Ausgabedatei. Dieser Befehl erzeugt zwei Dateien mit den Erweiterungen .html und .txt, die mit einem Browser angezeigt werden können.

3. Verwendung der MAP-Schnittstelle: Sie können den Leistungsbericht auch über das Menü ” Reports ” anzeigen oder exportieren, das in der Menüleiste der MAP-Schnittstelle verfügbar ist (siehe unten):

   

   Weitere Einzelheiten finden Sie in der Online-Dokumentation.

Bash-Beispielskript

Nachfolgend finden Sie ein Beispiel für ein jobscript, mit dem Sie offline debuggen, ein Profil erstellen und den Leistungsbericht generieren können, während Sie Ihren Auftrag in die Warteschlange der HPC-Knoten stellen.

#!/bin/bash
#SBATCH --job-name=profiler         # name for your job
#SBATCH --partition=short           # partition to run in
#SBATCH --ntasks=1                  # total number of tasks across all nodes
#SBATCH --ntasks-per-node=16        # total number of tasks across all nodes<
#SBATCH --time=00:30:00             # total run time limit (HH:MM:SS)
#SBATCH --output=omni_%x_%j.out     # where to save the output ( %j = JobID, %x = scriptname)
#SBATCH --error=omni_%x_%j.err     # where to save error messages ( %j = JobID
#SBATCH --mem=75G                  # 75 GB RAM 

# Purge modules to get a pristine environment:
module purge

# Load default module
module load DefaultModules

# Load Linaro Forge
module load debugger/linaro_forge/23.1.1

# Command to offline debug
# replace `executable_name.exe` with executable program
ddt --offline ./executable_name.exe

# command to generate map profile
# replace `executable_name.exe` with executable program
# replace output file name 'profile'
# this generates a 'profile.map' file which can be viewed through Linaro MAP tool.

map --profile --output=profile ./executable_name.exe

# command to generate performance report
perf-report ./executable_name.exe

Wir empfehlen dringend die Lektüre der Online-Dokumentation, die von Linaro Limited bereitgestellt wird.