Supercomputing Praktikum - Exam

Aufgabe 1)

Message Passing Interface (MPI): Du hast die Aufgabe, ein Programm zu entwickeln, das die Kommunikation zwischen mehreren Prozessen unter Verwendung der MPI-Bibliothek ermöglicht. Dabei sollen verschiedene Kommunikationstechniken gezeigt werden.

a)

Implementiere eine einfache Punkt-zu-Punkt-Kommunikation zwischen zwei Prozessen. Nutze die MPI-Funktionen MPI_Init, MPI_Comm_rank, MPI_Send und MPI_Recv. Der erste Prozess soll eine Ganzzahl (zum Beispiel 42) an den zweiten Prozess senden. Überprüfe, ob die Zahl korrekt empfangen wurde und gib das Ergebnis auf der Konsole aus.

'#include #include int main(int argc, char** argv) {    MPI_Init(&argc, &argv);    int rank;    MPI_Comm_rank(MPI_COMM_WORLD, &rank);    if (rank == 0) {        int number = 42;        MPI_Send(&number, 1, MPI_INT, 1, 0, MPI_COMM_WORLD);    } else if (rank == 1) {        int number;        MPI_Recv(&number, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);        printf('Received number %d', number);    }    MPI_Finalize();    return 0;}'

Lösung:

Message Passing Interface (MPI): Du hast die Aufgabe, ein Programm zu entwickeln, das die Kommunikation zwischen mehreren Prozessen unter Verwendung der MPI-Bibliothek ermöglicht. Dabei sollen verschiedene Kommunikationstechniken gezeigt werden.Implementiere eine einfache Punkt-zu-Punkt-Kommunikation zwischen zwei Prozessen. Nutze die MPI-Funktionen MPI_Init, MPI_Comm_rank, MPI_Send und MPI_Recv. Der erste Prozess soll eine Ganzzahl (zum Beispiel 42) an den zweiten Prozess senden. Überprüfe, ob die Zahl korrekt empfangen wurde und gib das Ergebnis auf der Konsole aus.

#include <mpi.h>#include <stdio.h>int main(int argc, char** argv) {    MPI_Init(&argc, &argv);    int rank;    MPI_Comm_rank(MPI_COMM_WORLD, &rank);    if (rank == 0) {       int number = 42;       MPI_Send(&number, 1, MPI_INT, 1, 0, MPI_COMM_WORLD);    } else if (rank == 1) {       int number;       MPI_Recv(&number, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);       printf('Received number %d', number);    }    MPI_Finalize();    return 0;}

b)

Erweitere das vorherige Programm, sodass es mehrere Prozesse unterstützt und eine kollektive Kommunikation durchführt. Verwende die MPI-Funktion MPI_Bcast, um eine Nachricht vom Prozess 0 an alle anderen Prozesse im Kommunikationskreis zu senden. Implementiere dabei die Verteilung einer Fließkommazahl 37.5 und überprüfe die Korrektheit des Empfangs in allen Prozessen.

'#include #include int main(int argc, char** argv) {    MPI_Init(&argc, &argv);    int rank, size;    MPI_Comm_rank(MPI_COMM_WORLD, &rank);    MPI_Comm_size(MPI_COMM_WORLD, &size);    float number = 0.0;    if (rank == 0) {        number = 37.5;    }    MPI_Bcast(&number, 1, MPI_FLOAT, 0, MPI_COMM_WORLD);    printf('Process %d received number %f', rank, number);    MPI_Finalize();    return 0;}'

Lösung:

Message Passing Interface (MPI): Du hast die Aufgabe, ein Programm zu entwickeln, das die Kommunikation zwischen mehreren Prozessen unter Verwendung der MPI-Bibliothek ermöglicht. Dabei sollen verschiedene Kommunikationstechniken gezeigt werden.Erweitere das vorherige Programm, sodass es mehrere Prozesse unterstützt und eine kollektive Kommunikation durchführt. Verwende die MPI-Funktion MPI_Bcast, um eine Nachricht vom Prozess 0 an alle anderen Prozesse im Kommunikationskreis zu senden. Implementiere dabei die Verteilung einer Fließkommazahl 37.5 und überprüfe die Korrektheit des Empfangs in allen Prozessen.

#include <mpi.h>#include <stdio.h>int main(int argc, char** argv) {    MPI_Init(&argc, &argv);    int rank, size;    MPI_Comm_rank(MPI_COMM_WORLD, &rank);    MPI_Comm_size(MPI_COMM_WORLD, &size);    float number = 0.0;    if (rank == 0) {       number = 37.5;    }    MPI_Bcast(&number, 1, MPI_FLOAT, 0, MPI_COMM_WORLD);    printf('Process %d received number %f', rank, number);    MPI_Finalize();    return 0;}

Aufgabe 2)

Überlegungen und Implementierung von Load-Balancing Methoden:Du bist verantwortlich für die Entwicklung eines parallelen Programms zur Simulation von Flüssigkeitsströmungen. Die Simulation ist sehr rechenintensiv und soll auf einem Cluster mit mehreren Prozessoren durchgeführt werden. Das Ziel ist es, die Berechnungszeit zu minimieren und die Ressourcenauslastung zu maximieren. Dabei sollen die Konzepte der Lastverteilung berücksichtigt werden.

a)

Erläutere den Hauptunterschied zwischen statischen und dynamischen Load-Balancing Methoden. Wann würdest Du eine statische Methode bevorzugen, und wann wäre eine dynamische Methode vorteilhafter? Begründe Deine Antwort mit Beispielen aus der Simulation von Flüssigkeitsströmungen.

Lösung:

Hauptunterschied zwischen statischen und dynamischen Load-Balancing Methoden

• Statische Load-Balancing Methoden:
• Bei statischen Methoden wird die Arbeitsaufteilung vor Beginn der Berechnungen festgelegt.
• Jeder Prozessor erhält einen festen Anteil der Arbeit und dieser Anteil ändert sich während der gesamten Simulation nicht.
• Der Vorteil einer statischen Methode ist die geringe Kommunikation zwischen den Prozessoren und die einfache Implementierung.
• Beispiel: Stelle Dir vor, dass Dein Programm vor Beginn der Simulation das gesamte Strömungsfeld in gleich große Regionen aufteilt und diese Regionen dann den Prozessoren zuweist.
• Optimale Wahl, wenn das Arbeitsvolumen der einzelnen Teile gut vorhersehbar und gleichmäßig verteilt ist sowie wenig variabel während der Simulation.
• Dynamische Load-Balancing Methoden:
• Bei dynamischen Methoden wird die Arbeitsaufteilung während der Laufzeit überwacht und bei Bedarf angepasst.
• Die Arbeit kann also „im Flug“ zwischen den Prozessoren umverteilt werden, um eine gleichmäßige Auslastung zu gewährleisten.
• Der Vorteil ist eine bessere Anpassung an die tatsächliche Workload, aber das Kommunikations- und Verwaltungsoverhead ist höher.
• Beispiel: Bei der Strömungssimulation kann während der Berechnung festgestellt werden, dass in einem bestimmten Teil des Strömungsfeldes mehr Rechenoperationen erforderlich sind als in anderen Bereichen. In diesem Fall könnten Teile der Arbeit von stärker belasteten Prozessoren zu weniger belasteten Prozessoren verschoben werden.
• Optimale Wahl, wenn das Arbeitsvolumen der Teile stark variiert oder schwer vorhersehbar ist.
• Wann statische Methoden bevorzugt werden:
• Wenn die Arbeitslast gleichmäßig verteilt ist und keine großen Schwankungen im Rechenaufwand erwartet werden.
• Wenn wenig Kommunikation zwischen den Prozessoren gewünscht ist.
• Beispiel: Eine Simulation von Flüssigkeitsströmungen, bei der das Strömungsfeld gleichmäßig und ohne Turbulenzen aufgeteilt ist, könnte mit einer statischen Methode effizienter umgesetzt werden.
• Wann dynamische Methoden vorteilhafter sind:
• Wenn die Arbeitslast stark variiert oder nicht vorhersagbar ist.
• Wenn eine gleichmäßige Auslastung der Prozessoren gewährleistet werden muss.
• Beispiel: Eine Simulation, bei der plötzliche Änderungen in der Strömungsdynamik oder lokale Turbulenzen auftreten, würde von dynamischen Load-Balancing Methoden profitieren, da sie die Last je nach Bedarf effizient umverteilen können.

Aufgabe 3)

Im Rahmen dieses Praktikums zur Supercomputing werden wir uns mit der Performance-Analyse und Optimierung von Anwendungen auf Supercomputern befassen. Ziel ist es, die Effizienz von Codes zu maximieren, indem wir Flaschenhälse identifizieren und geeignete Optimierungstechniken anwenden.

• Flaschenhalsidentifikation: CPU, Speicher, Netzwerk
• Verwendung von Profiling-Tools: gprof, perf, Vtune
• Grundlegende Leistungsmetriken: FLOPs, Bandbreite, Latenz
• Code-Optimierungstechniken: Parallelisierung, Vektorisierung, Speicherzugriff
• Wichtige Kennzahlen: Speedup, Skalierbarkeit, Effizienz

a)

1. Betrachten wir ein Programm, das auf einem Supercomputer läuft und einen sehr hohen FLOPs (Floating Point Operations per Second) Wert hat, aber dennoch nicht die erwartete Performance erreicht. Welche Flaschenhälse könnten die Ursache dafür sein? Verwende die grundlegenden Leistungsmetriken, um Deine Antwort zu begründen. Welche Tools würdest du verwenden, um diese Flaschenhälse zu identifizieren? Erläutere kurz die Anwendung und die Auswertung der Ergebnisse.

Lösung:

Um die Ursachen für die unerwartet niedrige Performance eines Programms mit hohem FLOPs-Wert zu identifizieren, sollten wir folgende mögliche Flaschenhälse in Betracht ziehen:

• CPU-Nutzung: Obwohl das Programm einen hohen FLOPs-Wert hat, könnte die CPU nicht effizient genutzt werden. Dies kann auf eine unzureichende Parallelisierung oder Vektorisierung des Codes hinweisen.
• Speicherbandbreite: Der Zugriff auf den Speicher kann ein limitierender Faktor sein. Wenn die Speicherbandbreite nicht ausreicht, um die Daten schnell genug zu den Recheneinheiten zu liefern, wird die Performance stark beeinträchtigt.
• Speicherlatenz: Hohe Latenzzeiten beim Speicherzugriff können ebenfalls die Ursache sein. Wenn die CPU lange auf Daten aus dem Hauptspeicher warten muss, kann dies die Performance drastisch verringern.
• Netzwerklatenz und Bandbreite: In verteilten Systemen oder parallelen Rechnungen kann auch das Netzwerk zum Flaschenhals werden. Hohe Latenzzeiten oder unzureichende Bandbreite im Netzwerk können die Kommunikationszeiten zwischen Knoten erhöhen und somit die Gesamteffizienz senken.

Verwendung von Profiling-Tools zur Identifikation der Flaschenhälse:

• gprof: Dieses Tool hilft, die CPU-Zeit zu profilieren, die von verschiedenen Teilen des Programms verbraucht wird. Es bietet Informationen darüber, welcher Teil des Codes am meisten Zeit in Anspruch nimmt, und hilft dabei, ineffiziente CPU-Nutzung zu identifizieren.
• perf: Mit perf kann die Hardware-Performance detailliert analysiert werden. Es bietet Informationen über CPU-Caches, Zweigvorhersagen, Speicherzugriffsmuster und mehr. Dadurch kann man erkennen, ob Speicherbandbreite oder Speicherlatenz ein Problem darstellt.
• Vtune: Intel's Vtune ist ein fortschrittliches Profiler-Tool, das detaillierte Einblicke in die CPU- und Speichernutzung bietet. Es zeigt Flaschenhälse auf, die durch schlechte Cache-Nutzung, unzureichende Parallelisierung, oder ineffiziente Speicherzugriffe entstehen.

Anwendung und Auswertung der Ergebnisse:

• gprof: Starte das Programm mit gprof, um ein Profiling-Datenfile zu erzeugen. Dieses File kann mit gprof {programmname} gmon.out analysiert werden, um eine Übersicht über die Zeitverteilung im Programm zu erhalten.
• perf: Verwende perf stat und perf record, um verschiedene Performance-Metriken zu sammeln und zu analysieren. Die gesammelten Daten können mit perf report visualisiert werden, um Engpässe in der CPU und Speicherzugriffen zu identifizieren.
• Vtune: Starte die Analyse mit Vtune, indem Du das Programm damit ausführst. Vtune erzeugt eine detaillierte Berichtsübersicht, die zeigt, wo die meiste Zeit verbracht wird und welche Ressourcen am meisten belastet werden. Dies ermöglicht eine tiefgehende Analyse und gezielte Optimierung des Codes.

b)

2. Du hast einen Algorithmus parallelisiert, und die Messung mit dem Profiling-Tool gprof zeigt, dass die meiste Zeit in einem bestimmten Funktionsaufruf verbraucht wird. Die Funktion ist einfach und wird oft aufgerufen. Wie würdest du vorgehen, um die Performance dieser Funktion zu verbessern? Erwäge verschiedene Optimierungstechniken und erkläre die jeweils erwarteten Verbesserungen. Stelle auch mathematisch dar, wie die Effizienz \(\text{Eff}\) und der Speedup \(\text{S}\) zu berechnen sind. Hierbei ist die Effizienz definiert als \(\text{Eff} = \frac{S}{P}\), wobei \(\text{P}\) die Anzahl der Prozessoren darstellt.

Lösung:

Um die Performance einer oft aufgerufenen und einfachen Funktion zu verbessern, die laut gprof viel Zeit in Anspruch nimmt, können folgende Optimierungstechniken angewendet werden:

• Inline-Funktion: Bei kleinen und einfachen Funktionen kann das Inlining, d.h. das Ersetzen des Funktionsaufrufs durch den eigentlichen Funktionscode, den Overhead des Funktionsaufrufs vermeiden und somit die Ausführungszeit reduzieren.
• Schleifenentfaltung (Loop Unrolling): Wenn die Funktion in einer Schleife häufig aufgerufen wird, kann man die Schleife entfalten, um die Anzahl der Funktionsaufrufe zu verringern. Dies reduziert den Kontrollfluss-Overhead und verbessert die Nutzung von Pipelines und Caches.
• Optimierung der Speicherzugriffe: Wenn die Funktion viele Speicherzugriffe ausführt, sollten diese optimiert werden. Verbesserte Datenlokalität oder die Nutzung von Caches kann die Leistung signifikant erhöhen.
• Parallelisierung und Vektorisierung: Falls möglich, sollten Teile der Funktion parallelisiert oder mit SIMD (Single Instruction, Multiple Data) Anweisungen vektorisiert werden. Dies kann die Rechenleistung erheblich steigern.

Erwartete Verbesserungen:

• Inlining: Reduktion des Overheads durch den Wegfall der Funktionsaufrufe.
• Schleifenentfaltung: Verminderung des Overheads der Schleifensteuerung, Verbesserung der Pipeline- und Cache-Auslastung.
• Optimierung der Speicherzugriffe: Schnellere Datenzugriffe und verbesserte Datenlokalität.
• Parallelisierung und Vektorisierung: Bessere Nutzung der verfügbaren Rechenressourcen und höhere Datenparallelität.

Berechnung der Effizienz \( \text{Eff} \) und des Speedups \( \text{S} \):

• Speedup \( S \): Der Speedup ist das Verhältnis der Ausführungszeit des seriellen Algorithmus zur Ausführungszeit des parallelisierten Algorithmus:
• \[ S = \frac{T_s}{T_p} \]
• wobei \( T_s \) die Ausführungszeit des seriellen Programms und \( T_p \) die Ausführungszeit des parallelen Programms ist.
• Effizienz \( \text{Eff} \): Die Effizienz eines parallelisierten Programms wird als Verhältnis des Speedups zur Anzahl der Prozessoren \( P \) definiert:
• \[ \text{Eff} = \frac{S}{P} = \frac{T_s}{P \times T_p} \]
• \( P \) ist hierbei die Anzahl der Prozessoren.

Durch die Anwendung der genannten Optimierungstechniken können die Werte von \( T_p \) verbessert werden, was zu einem höheren Speedup \( S \) führt. Dies resultiert letztlich in einer höheren Effizienz \( \text{Eff} \).

c)

3. Das Programm, das du analysierst, zeigt zwar eine gute Skalierbarkeit, jedoch leidet es unter hohen Speicherlatenzen. Welche Optimierungstechniken würdest du anwenden, um die Speicherzugriffe zu verbessern? Gib konkrete Beispiele und Szenarien an und diskutiere, wie Vektorisierung und Speicherzugriffsmuster die Latenz reduzieren können. Berechne mathematisch, wie eine effizientere Nutzung des Speichers die Bandbreite erhöhen könnte.

Lösung:

Wenn ein Programm unter hohen Speicherlatenzen leidet, obwohl es eine gute Skalierbarkeit zeigt, können verschiedene Optimierungstechniken angewendet werden, um die Speicherzugriffe zu verbessern. Hier sind einige Strategien und deren konkrete Anwendung:

• Cache-Blockierung (Blocking): Durch das Umstrukturieren von Schleifen kann die Datenlokalität verbessert und der Cache effizienter genutzt werden. Die Idee dahinter ist, Schleifen so zu verändern, dass Datenblöcke, die häufig verwendet werden, zusammen im Cache gehalten werden und dadurch weniger oft aus dem Hauptspeicher nachgeladen werden müssen.
• Prefetching: Moderne Prozessoren unterstützen Hardware-Prefetching, aber auch softwareseitiges Prefetching kann eingesetzt werden. Hierbei werden Daten, die in Zukunft benötigt werden, bereits vor der tatsächlichen Nutzung in den Cache geladen, um Wartezeiten zu minimieren.
• Optimierung der Speicherzugriffsmuster: Ein zusammenhängendes Zugriffsverhalten auf Speicherbereiche (strided access) kann die Effizienz erhöhen. Beispielsweise sollten Datenstrukturen so organisiert werden, dass aufeinanderfolgende Schleifeniteration auf benachbarte Speicherbereiche zugreifen.
• Vektorisierung: Vektorisierung kann durch die Nutzung von SIMD-Anweisungen (Single Instruction, Multiple Data) erreicht werden. Dies erlaubt es einer einzigen Anweisung, auf mehrere Datenpunkte gleichzeitig zuzugreifen und diese zu verarbeiten. Dies reduziert die Anzahl der benötigten Speicherzugriffe und verbessert die Ausnutzung der Speicherbandbreite.

Konkrete Beispiele und Szenarien:

• Cache-Blockierung: Angenommen, wir haben eine Matrix-Multiplikation. Anstatt die Matrizen in einer einfachen Schleife zu multiplizieren, können wir Blockgrößen definieren und die Berechnung auf kleinere Teilmatrizen (Blöcke) anwenden. Dadurch bleiben die benötigten Daten länger im Cache.
• Prefetching: Wenn wir wissen, dass Daten in der Zukunft benötigt werden, können wir explizite Prefetching-Anweisungen verwendenwie __builtin_prefetch in C/C++, um die Daten vorzeitig in den Cache zu laden:

// Beispiel: Prefetch einer Datenstruktur in C/C++for (int i = 0; i < n; i++) {    __builtin_prefetch(&data[i+1], 0, 1); // Prefetch der nächsten Daten    // Aktuelle Datenverarbeitung    process(data[i]);}

• Optimierung der Speicherzugriffsmuster: Bei der Verarbeitung von zwei 1D-Arrays in einer Schleife ist es effizienter, die Arrays „in-Interleaved“ anstatt „zwischenverbindlich“ zu verarbeiten wenn diese Zugriffe auf nahegelegenen Speicherbereiche liegen.

// Beispiel: Strided Access in C/C++for (int i = 0; i < n; i += 4) {    // Zugriff auf benachbarte Speicherbereiche    process(data[i], data[i+1], data[i+2], data[i+3]);}

• Vektorisierung: Durch die Nutzung von SIMD-Befehlen kann die Speicherbandbreite effizienter genutzt werden. Hier ein Beispielszenario in C/C++ mit SIMD-Intrinsics:

#include  // Header für AVX-Intrinsics// Beispiel: Vektorisierung einer Schleifevoid vectorized_function(float *a, float *b, float *c, int n) {    for (int i = 0; i < n; i += 8) {        // Laden Sie 8 float-Werte aus a und b        __m256 va = _mm256_load_ps(&a[i]);        __m256 vb = _mm256_load_ps(&b[i]);        // Ausführen einer SIMD-Operation (z.B. Addition)        __m256 vc = _mm256_add_ps(va, vb);        // Speichern Sie das Ergebnis in c        _mm256_store_ps(&c[i], vc);    }}

Mathematische Berechnung der Effizienzsteigerung:

Die Bandbreite (B) ist definiert durch:

• \[ B = \frac{D}{T} \]

wobei \( D \) die Datenmenge ist, die übertragen wird, und \( T \) die Zeit für die Übertragung. Durch die Vektorisierung und Optimierung der Speicherzugriffe wird die Übertragungszeit \( T \) reduziert, was die effektive Bandbreite erhöht.

Angenommen, durch eine Speicheroptimierung reduziert sich die Zeit für die Datenübertragung von \( T \) auf \( T' \), dann gilt:

• \[ B' = \frac{D}{T'} \]

Wenn die Optimierung die Datenübertragungszeit um den Faktor \( k \) reduziert, also

• \[ T' = \frac{T}{k} \]

dann wird die neue Bandbreite

• \[ B' = \frac{D}{T / k} = k \cdot B \]

Das bedeutet, dass die Bandbreite durch einen Faktor \( k \) erhöht wird, was zu einer effizienteren Nutzung der Speicherressourcen führt.

Aufgabe 4)

Benchmarks und Benchmarking-Tools: Um die Leistungsfähigkeit von Supercomputern zu messen und zu bewerten, kommen verschiedene Benchmarks zum Einsatz. Dazu gehören unter anderem LINPACK, SPEC und HPCG. LINPACK misst die Leistungsfähigkeit bei der Lösung von linearen Gleichungen, während SPEC eine Sammlung von Benchmarks zur Bewertung verschiedener Aspekte der Computerleistung umfasst. HPCG hingegen fokussiert sich auf die Performance bei Conjugate Gradient Berechnungen. Eine umfassende Benchmark-Abdeckung ist essentiell, um den richtigen Supercomputer auszuwählen und zu optimieren.

a)

• Subexercise 1: Berechne die theoretische Peak Performance eines Supercomputers mit den folgenden Spezifikationen und vergleiche sie mit einem LINPACK-Benchmark-Ergebnis. Angenommen, Du hast einen Supercomputer mit 10.000 Knoten, jeder Knoten enthält zwei 2,6 GHz Prozessoren mit 16 Kernen pro Prozessor. Jeder Kern kann 4 Fließkommaoperationen pro Zyklus durchführen.
• Formel für die theoretische Peak Performance:
• Peak Performance (in FLOPs) = Anzahl der Knoten × Anzahl der Prozessoren pro Knoten × Kerne pro Prozessor × Zyklen pro Sekunde pro Kern × Fließkommaoperationen pro Zyklus.
• Basierend auf diesen Daten:
• Berechne die Peak Performance in PetaFLOPs.

'write your code actual here'

Lösung:

• Subexercise 1: Berechne die theoretische Peak Performance eines Supercomputers mit den folgenden Spezifikationen und vergleiche sie mit einem LINPACK-Benchmark-Ergebnis. Angenommen, Du hast einen Supercomputer mit 10.000 Knoten, jeder Knoten enthält zwei 2,6 GHz Prozessoren mit 16 Kernen pro Prozessor. Jeder Kern kann 4 Fließkommaoperationen pro Zyklus durchführen.
• Formel für die theoretische Peak Performance:
• Peak Performance (in FLOPs) = Anzahl der Knoten × Anzahl der Prozessoren pro Knoten × Kerne pro Prozessor × Zyklen pro Sekunde pro Kern × Fließkommaoperationen pro Zyklus.
• Basierend auf diesen Daten:
• Berechne die Peak Performance in PetaFLOPs.

# Gegebene Daten:anzahl_der_knoten = 10000prozessoren_pro_knoten = 2kerne_pro_prozessor = 16zyklen_pro_sekunde_pro_kern = 2.6e9  # 2.6 GHz in Zyklen pro Sekundefliesskommaoperationen_pro_zyklus = 4# Formel für die theoretische Peak Performancepeak_performance_flt_ops_sek = (anzahl_der_knoten *                                 prozessoren_pro_knoten *                                 kerne_pro_prozessor *                                 zyklen_pro_sekunde_pro_kern *                                 fliesskommaoperationen_pro_zyklus)# Umrechnung in PetaFLOPs (1 PetaFLOP = 10^15 FLOPs)peak_performance_pflops = peak_performance_flt_ops_sek / 1e15peak_performance_pflops

• Anzahl der Knoten: 10.000
• Anzahl der Prozessoren pro Knoten: 2
• Anzahl der Kerne pro Prozessor: 16
• Zyklen pro Sekunde pro Kern: 2,6 GHz = 2,6 × 10⁹ Zyklen pro Sekunde
• Anzahl der Fließkommaoperationen pro Zyklus: 4

• Berechne die Gesamtheit der Operationen pro Sekunde:
• Gesamtanzahl der Kerne im gesamten Supercomputer:
• 10.000 (Knoten) × 2 (Prozessoren pro Knoten) × 16 (Kerne pro Prozessor) = 320.000 Kerne
• Operationen pro Sekunde pro Kern:
• 2,6 × 10⁹ Zyklen pro Sekunde × 4 Fließkommaoperationen pro Zyklus = 10,4 × 10⁹ FLOPs pro Sekunde pro Kern
• Gesamtleistung des Supercomputers (in FLOPs):
• 320.000 Kerne × 10,4 × 10⁹ FLOPs pro Sekunde = 3,328 × 10¹⁵ FLOPs
• Umrechnung in PetaFLOPs:
• 3,328 × 10¹⁵ FLOPs / 10¹⁵ = 3,328 PetaFLOPs

• Die theoretische Peak Performance des Supercomputers beträgt 3,328 PetaFLOPs.

b)

• Subexercise 2: Analyse und Vergleich der Leistungsbewertung von SPEC und HPCG Benchmarks. Anhand eines ausgewählten Systems, welches im SPEC- und im HPCG-Benchmark getestet wurde, vergleiche dessen Ergebnisse und diskutiere, welche Benchmark für welche spezifischen Zielanwendungen aussagekräftiger ist.
• Beziehe in Deine Analyse spezifische Benchmark-Daten mit ein und erkläre, warum ein Benchmark im Vergleich zum anderen gegebenenfalls höhere oder niedrigere Ergebnisse zeigt. Diskutiere, welche der beiden Benchmarks für die Optimierung von Supercomputer-Systemen im akademischen Forschungsbereich sinnvoller ist.

'write your code actual here'

Lösung:

• Subexercise 2: Analyse und Vergleich der Leistungsbewertung von SPEC und HPCG Benchmarks. Anhand eines ausgewählten Systems, welches im SPEC- und im HPCG-Benchmark getestet wurde, vergleiche dessen Ergebnisse und diskutiere, welche Benchmark für welche spezifischen Zielanwendungen aussagekräftiger ist.
• Beziehe in Deine Analyse spezifische Benchmark-Daten mit ein und erkläre, warum ein Benchmark im Vergleich zum anderen gegebenenfalls höhere oder niedrigere Ergebnisse zeigt. Diskutiere, welche der beiden Benchmarks für die Optimierung von Supercomputer-Systemen im akademischen Forschungsbereich sinnvoller ist.

• Einführung:SPEC und HPCG sind zwei weit verbreitete Benchmarks zur Bewertung der Leistung von Supercomputern, dienen jedoch unterschiedlichen Zwecken. SPEC fokussiert sich auf eine Vielzahl von Anwendungsbereichen, während HPCG speziell auf Konjugierte-Gradienten-Methoden ausgerichtet ist.
• Benchmarks und ihre Zielanwendungen:
  • SPEC:SPEC (Standard Performance Evaluation Corporation) bietet eine Sammlung von Benchmarks, die verschiedene Bereiche der Computerleistung bewerten, darunter CPU-Performance, Speicherzuordnung und I/O. Es ist vielseitig und liefert eine umfassende Leistungsbewertung über viele Anwendungsbereiche hinweg.
  • HPCG:HPCG (High Performance Conjugate Gradients) ist auf die Leistung bei Konjugierte-Gradienten-Berechnungen spezialisiert. Es simuliert Arbeitslasten, die in wissenschaftlichen und technischen Anwendungen häufig vorkommen, und ist reflektiver für reale wissenschaftliche Rechenanwendungen als LINPACK.
• Spezifische Benchmark-Daten:
  • Angenommen, wir haben ein System, auf dem die folgenden Daten gemessen wurden:
  • SPEC-Performance: 500 Punkte
  • HPCG-Performance: 0,5 TFLOPs
• Analyse der Ergebnisse:
  • SPEC:Die SPEC-Performance mit 500 Punkten zeigt, dass das System gut diverse Arbeitslasten wie mathematische Berechnungen, Datenverarbeitung und sogar einige wissenschaftliche Anwendungen bewältigen kann. Die hohe Punktzahl deutet auf eine starke allgemeine Rechenleistung hin.
  • HPCG:Die HPCG-Performance mit 0,5 TFLOPs ist spezifischer für wissenschaftliche Anwendungen, die Konjugierte-Gradienten-Methoden verwenden. Diese geringe Anzahl an FLOPs im Vergleich zur theoretischen Peak Performance weist darauf hin, dass HPCG die realistischeren Szenarien für wissenschaftliche Berechnungen besser simuliert.
• Diskussion:
  • Aussagekraft für spezifische Zielanwendungen:SPEC liefert eine umfassende Bewertung über viele Anwendungsbereiche hinweg, was es vielseitig macht. HPCG hingegen ist spezifisch und liefert Einblicke in die wissenschaftliche Rechenleistung.
  • Erklärung der Unterschiede:Die niedrigere HPCG-Leistung im Vergleich zur theoretischen Peak Performance und zum SPEC-Ergebnis liegt an der realistischen Arbeitslast. SPEC-Benchmarks enthalten synthetische Tests, die möglicherweise nicht alle Systemengpässe aufdecken, während HPCG „Real-World“-Szenarien besser widerspiegelt.
  • Optimierung im akademischen Forschungsbereich:Für die Optimierung von Supercomputern im akademischen Forschungsbereich ist HPCG sinnvoller, da es realistische wissenschaftliche Rechenlasten simuliert. Es hilft dabei, Systemschwächen und Engpässe zu identifizieren, die für High-Performance-Computing in der Wissenschaft kritisch sind.

• Beide Benchmarks haben ihre Stärken und spezifischen Anwendungen. SPEC bietet eine generelle Leistungsbewertung und ist nützlich für eine umfassende Systemanalyse, während HPCG spezifische Einblicke in wissenschaftliche Berechnungsleistungen bietet und für akademische Forschungszwecke wichtiger sein kann.