Heterogene Rechnerarchitekturen Online - Exam

Aufgabe 1)

Im Rahmen des Moduls 'Heterogene Rechnerarchitekturen Online' an der Universität Erlangen-Nürnberg hast Du über die Definition und Klassifizierung von heterogenen Systemen gelernt. Heterogene Systeme kombinieren verschiedene Typen von Recheneinheiten wie CPU, GPU und FPGA, um die Systemleistung zu steigern. Diese Systeme bieten höhere Flexibilität und Effizienz durch spezialisierte Hardware. Sie werden nach der Art der Integration in Multi-Node Systeme und Single-Node Systeme klassifiziert. Beispiele sind Systeme, die CPU und GPU für High-Performance Computing kombinieren oder FPGAs einsetzen, um Algorithmen zu beschleunigen. Programmiersprachen und Modelle wie OpenCL, CUDA und HLS werden verwendet, um diese Systeme zu programmieren. Wichtige Aspekte dieser Systeme sind Datenverteilung, Synchronisation und Energieeffizienz.

a)

Aufgabe 1: Erläutere den Unterschied zwischen einem Multi-Node System und einem Single-Node System in der Klassifizierung heterogener Systeme. Gehe dabei auf die typischen Einsatzmöglichkeiten und die Vor- und Nachteile ein.

Lösung:

Unterschied zwischen einem Multi-Node System und einem Single-Node System in der Klassifizierung heterogener Systeme:

• Single-Node System: Ein Single-Node System ist ein Einzelrechner, der mehrere Arten von Recheneinheiten wie CPU, GPU und gegebenenfalls FPGA in einem einzigen physischen System integriert. Diese Systeme sind in der Lage, eine hohe Leistung durch die enge Integration und den schnellen Datenaustausch zwischen den verschiedenen Recheneinheiten zu erzielen.

• Typische Einsatzmöglichkeiten:
  • Desktop- und Workstation-Anwendungen
  • Virtualisierung
  • High-Performance Computing (HPC) in kleineren Maßstäben
  • Videoverarbeitung und Grafikrendering
• Vorteile:
  • Einfache Verwaltung und Wartung
  • Geringere Latenzzeiten durch die lokale Verbindung der Recheneinheiten
  • Kosteneffizienz bei kleineren Projekten
  • Energieeffizienter im Vergleich zu verteilten Systemen
• Nachteile:
  • Begrenzte Skalierbarkeit
  • Physische Begrenzungen in Bezug auf Platz und Kühlung

• Multi-Node System: Ein Multi-Node System besteht aus mehreren vernetzten Knoten, wobei jeder Knoten eine oder mehrere Arten von Recheneinheiten (CPU, GPU, FPGA usw.) enthalten kann. Diese Knoten arbeiten zusammen, um komplexe Aufgaben zu bewältigen und hohe Rechenleistungen zu erzielen.

• Typische Einsatzmöglichkeiten:
  • Großangelegte HPC-Anwendungen
  • Cloud-Computing-Infrastrukturen
  • Big Data-Analysen
  • Maschinelles Lernen und KI
• Vorteile:
  • Hohe Skalierbarkeit durch Hinzufügen weiterer Knoten
  • Flexibilität bei der Kombination und Nutzung verschiedener Recheneinheiten
  • Verteilte Verarbeitung großer Datenmengen
• Nachteile:
  • Komplexere Verwaltung und Wartung
  • Höhere Latenzzeiten aufgrund der Netzwerkkommunikation zwischen den Knoten
  • Erhöhter Energieverbrauch
  • Kostenintensiv in der Implementierung und Wartung

b)

Aufgabe 2: Betrachte ein komplexes Rechenproblem, das durch die Kombination von CPU und GPU in einem High-Performance Computing System gelöst werden soll. Beschreibe die Schritte zur Datenverteilung und Synchronisation zwischen CPU und GPU. Welche Herausforderungen könnten dabei auftreten und wie können diese überwunden werden?

Lösung:

Aufgabe 2: Betrachtung der Datenverteilung und Synchronisation zwischen CPU und GPU in einem High-Performance Computing (HPC) System:

• Schritte zur Datenverteilung und Synchronisation:
  1. Datenaufteilung: Definiere das Rechenproblem und teile die Aufgaben in kleinere Subaufgaben, die entweder auf der CPU oder der GPU effizienter ausgeführt werden können. Ein Teil der Daten kann auf der CPU und ein anderer Teil auf der GPU verarbeitet werden.
  2. Datenübertragung: Übertrage die relevanten Daten von der CPU zum GPU-Speicher. Dies erfolgt normalerweise über Hochgeschwindigkeits-Interconnects wie PCIe.
  3. Initialisierung: Initialisiere die GPU mit den nötigen Kernel-Funktionen und Startparametern. Diese Kernel berechnen die Aufgaben, die ihnen zugewiesen wurden.
  4. Ausführung: Starte die Ausführung der GPU-Kernel. Die CPU kann entweder auf das Ergebnis der GPU warten oder parallel weiterarbeiten.
  5. Synchronisation: Stelle sicher, dass die CPU wartet, bis die GPU ihre Berechnungen abgeschlossen hat. Dies kann durch Synchronisations-Mechanismen wie Ereignisse oder Flag-Variablen erreicht werden.
  6. Datenrückführung: Übertrage die durch die GPU berechneten Ergebnisse zurück in den CPU-Speicher.
  7. Zusammenführung: Kombiniere die Ergebnisse der CPU- und GPU-Berechnungen, um das Gesamtresultat des Rechenproblems zu erhalten.
• Herausforderungen und ihre Überwindung:
  1. Datenübertragungslatenz: Die Übertragung großer Datenmengen zwischen CPU und GPU kann zeitintensiv sein. Lösung: Nutze Streaming und Pipelining-Techniken, um Datenübertragungen und Berechnungen zu überlappen.
  2. Synchronisation: Die Synchronisation zwischen CPU und GPU kann zu Engpässen führen. Lösung: Verwende effiziente Synchronisations-Methoden wie CUDA-Streams und OpenCL-Events, um Wartezeiten zu minimieren.
  3. Lastverteilung: Eine ungleichmäßige Lastverteilung kann zu einer ineffizienten Nutzung der Ressourcen führen. Lösung: Verwende dynamische Lastverteilung und Load-Balancing-Algorithmen, um die Arbeitslast gleichmäßig zwischen CPU und GPU zu verteilen.
  4. Speicherbegrenzungen: GPUs haben oft begrenzten Speicher im Vergleich zu CPUs. Lösung: Nutze Techniken wie Speicherkompression, Datenpartitionierung und effizientes Speichermanagement, um den verfügbaren Speicher optimal zu nutzen.
  5. Entwicklungsaufwand: Die Programmierung für heterogene Systeme kann komplex und zeitaufwändig sein. Lösung: Verwende höher-abstrahierte Programmiersprachen und Bibliotheken wie OpenCL, CUDA, und HLS, um die Entwicklung zu erleichtern und zu beschleunigen.

c)

Aufgabe 3: FPGAs werden häufig verwendet, um spezifische Algorithmen zu beschleunigen. Ein Beispiel ist die Implementierung eines Matrix-Multiplikationsalgorithmus. Erkläre, wie Du diesen Algorithmus in Hochsprachenbeschreibung (HLS) implementieren würdest. Gehe dabei auf die Vor- und Nachteile der Verwendung von FPGAs ein.

Lösung:

Aufgabe 3: Implementierung eines Matrix-Multiplikationsalgorithmus mithilfe von Hochsprachenbeschreibung (HLS) auf einem FPGA:

• Schritte zur Implementierung in HLS:
  1. Algorithmus Analyse: Analysiere den Matrix-Multiplikationsalgorithmus und identifiziere die unabhängigen Operationen, die parallelisiert werden können.
  2. Code schreiben: Schreibe den Code in einer Hochsprache wie C oder C++, der für die HLS-Tools geeignet ist. Ein einfaches Beispiel für die Implementation könnte wie folgt aussehen:

  #include #define N 3void matrix_multiply(float A[N][N], float B[N][N], float C[N][N]) {#pragma HLS INTERFACE bram port=A#pragma HLS INTERFACE bram port=B#pragma HLS INTERFACE bram port=C#pragma HLS INTERFACE s_axilite port=returnfloat sum;Row_Loop: for (int i = 0; i < N; i++) {    Col_Loop: for (int j = 0; j < N; j++) {        sum = 0;        Product_Sum: for (int k = 0; k < N; k++) {            sum += A[i][k] * B[k][j];        }        C[i][j] = sum;    }}}

  1. Vorbereitung der HLS-Tools: Lade den geschriebenen Code in die HLS-Tools (z.B. Vivado HLS von Xilinx). Die Tools konvertieren den Code in eine Hardwarebeschreibung (HDL), die auf dem FPGA ausgeführt wird.
  2. Simulation und Verifikation: Simuliere den generierten HDL-Code, um sicherzustellen, dass er korrekt funktioniert. Dies beinhaltet die Verifikation der Funktionalität und die Validierung der Ergebnisse.
  3. Synthese: Führe die Synthese durch, um den HDL-Code in eine bitstream Datei zu konvertieren, die auf dem FPGA implementiert werden kann.
  4. Implementierung und Test: Lade den bitstream auf das FPGA und teste die Implementierung in der realen Hardware, um sicherzustellen, dass die Leistung den Erwartungen entspricht und dass es keine Probleme gibt.
• Vor- und Nachteile der Verwendung von FPGAs:
  • Vorteile:
    • Hohe Leistungsfähigkeit: FPGAs können spezialisierte Hardware-Implementierungen verwenden, um Rechenoperationen sehr effizient durchzuführen.
    • Parallelität: FPGAs erlauben eine hohe Parallelität, was bedeutet, dass viele Rechenoperationen gleichzeitig ausgeführt werden können.
    • Flexibilität: FPGAs sind rekonfigurierbar und können somit für unterschiedliche Anwendungen angepasst werden.
    • Geringe Latenz: Direkte Hardware-Implementierung führt zu sehr niedrigen Latenzzeiten.
  • Nachteile:
    • Entwicklungsaufwand: Die Entwicklung für FPGAs ist oft komplizierter und zeitaufwändiger als die Entwicklung für CPUs oder GPUs.
    • Kosten: FPGAs können teurer sein, sowohl in Bezug auf die Hardwarekosten als auch auf die Entwicklungskosten.
    • Weniger Flexibilität: Während FPGAs rekonfigurierbar sind, bieten sie im Vergleich zu CPUs weniger Flexibilität in der Laufzeitanpassung.
    • Power Consumption: FPGAs können mehr Energie verbrauchen als spezialisierte ASICs (Application-Specific Integrated Circuits).

Aufgabe 2)

Du bist verantwortlich für die Optimierung einer Softwareanwendung, die intensive Berechnungen durchführt. Die Anwendung soll so umgestaltet werden, dass sie besser von modernen multi-core Prozessoren profitieren kann. Erläutere detailliert, welche Konzepte der Parallelität Du anwenden würdest, um die Effizienz zu steigern.

a)

Beschreibe, wie Du die Verwendung von Threads und Prozessen in der Anwendung abwägst. Welche Vor- und Nachteile sind mit der Verwendung von Threads im Vergleich zu unabhängigen Prozessen verbunden?

Lösung:

Threads vs. Prozesse in der Softwareoptimierung:

• Threads:
  • Vorteile:
    • Schneller Start und geringerer Overhead: Threads werden innerhalb eines Prozesses erstellt und teilen denselben Speicherbereich, was zu einem schnelleren Start und geringeren Speicherbedarf führt.
    • Gemeinsamer Speicher: Threads können denselben Speicher und Ressourcen teilen, was die Kommunikation und das Teilen von Daten erleichtert.
  • Nachteile:
    • Komplexität: Die Verwendung von Threads erhöht die Komplexität der Programmierung, insbesondere beim Umgang mit gleichzeitigen Zugriffen auf gemeinsame Daten (Synchronisationsprobleme).
    • Potenzielle Sicherheitsrisiken: Da Threads denselben Speicherbereich teilen, kann ein fehlerhafter Thread den gesamten Prozess kompromittieren.
• Prozesse:
  • Vorteile:
    • Isolierung: Prozesse sind voneinander isoliert, was bedeutet, dass ein Fehler in einem Prozess die anderen Prozesse nicht beeinflusst.
    • Sicherheit: Jeder Prozess hat seinen eigenen Speicherbereich, wodurch potenzielle Sicherheitsrisiken aufgrund gemeinsam genutzter Ressourcen minimiert werden.
  • Nachteile:
    • Größerer Overhead: Prozesse benötigen mehr Speicher und Zeit für die Erstellung, da sie separate Instanzen sind und über Inter-Prozess-Kommunikation (IPC) kommunizieren müssen.
    • Schwierige Kommunikation: Daten zwischen Prozessen zu teilen ist komplexer und erfordert oft Mechanismen wie Pipes, Message Queues oder Shared Memory.

Abwägung:

• Wenn hohe Performance und geringe Latenz entscheidend sind und die Anwendung sicher parallelisiert werden kann, sind Threads aufgrund ihrer geringeren Erstellungskosten und effizienteren gemeinsamen Nutzung von Ressourcen vorzuziehen.
• Wenn Sicherheit und Stabilität wichtiger sind sowie eine strikte Isolation erforderlich ist, bieten Prozesse Vorteile, obwohl sie höhere Verwaltungskosten mit sich bringen.

In der Praxis wird oft eine Kombination aus beiden Ansätzen verwendet, um die Vorteile beider Methoden zu nutzen und die Schwächen zu minimieren.

b)

Stelle Dir vor, dass ein Teil der Berechnungen sehr stark voneinander abhängig ist, während andere Teile unabhängig voneinander ausgeführt werden können. Erkläre, wie Du synchrone und asynchrone Ausführungen gestalten würdest. Welche Synchronisationstechniken würdest Du verwenden, um Zustandskonflikte zu vermeiden, und warum?

Lösung:

Gestaltung von synchronen und asynchronen Ausführungen:

• Synchrone Ausführung:
  • Beschreibung: Teile der Berechnungen, die stark voneinander abhängig sind, müssen in einer bestimmten Reihenfolge ausgeführt werden. Hierbei erfolgt die Ausführung sequenziell, um sicherzustellen, dass die Abhängigkeiten korrekt berücksichtigt werden.
  • Beispiel: Wenn eine Berechnung auf das Ergebnis einer vorherigen Berechnung angewiesen ist, muss die zweite Berechnung warten, bis die erste abgeschlossen ist.
  • Verwendung: Synchrone Ausführungen sind wichtig bei Tasks, die in einer strikt definierten Reihenfolge ablaufen müssen, um korrekte Resultate zu gewährleisten.
• Asynchrone Ausführung:
  • Beschreibung: Teile der Berechnungen, die unabhängig voneinander ausgeführt werden können, werden parallel durchgeführt. Dies maximiert die Ausnutzung der verfügbaren Kerne eines multi-core Prozessors.
  • Beispiel: Wenn mehrere Berechnungen unabhängig voneinander ausgeführt werden können, können sie gleichzeitig auf verschiedenen Kernen berechnet werden.
  • Verwendung: Die asynchrone Ausführung ist ideal für unabhängige Tasks, die keinen direkten Einfluss aufeinander haben, um die Effizienz zu steigern.

Synchronisationstechniken zur Vermeidung von Zustandskonflikten:

• Mutexe (Mutual Exclusion):
  • Beschreibung: Ein Mutex ist ein Mechanismus, der sicherstellt, dass nur ein Thread gleichzeitig auf eine Ressource zugreifen kann. Wenn ein Thread eine Ressource sperrt, müssen andere Threads warten, bis die Sperre freigegeben wird.
  • Verwendung: Mutexe sind nützlich, wenn es gemeinsame Datenstrukturen gibt, die von mehreren Threads modifiziert werden können.
  • Warum: Sie verhindern Zustandskonflikte, indem sie sicherstellen, dass keine zwei Threads gleichzeitig kritische Abschnitte des Codes ausführen.
• Semaphore:
  • Beschreibung: Ein Semaphore ist ein allgemeineres Synchronisationsmittel als ein Mutex. Es erlaubt die Steuerung der Anzahl der Threads, die auf eine Ressource zugreifen können.
  • Verwendung: Semaphore können verwendet werden, um den Zugang zu einer begrenzten Anzahl von Ressourcen zu kontrollieren, z.B. eine begrenzte Anzahl von Datenbankverbindungen.
  • Warum: Sie bieten eine flexible Möglichkeit, den gleichzeitigen Zugriff auf mehrere Instanzen einer Ressource zu regulieren.
• Condition Variables:
  • Beschreibung: Eine Condition Variable wird verwendet, um Threads zu synchronisieren, indem sie Signalisierung und Wartebedingungen unterstützen. Ein Thread kann warten, bis eine bestimmte Bedingung erfüllt ist, und ein anderer Thread kann die Bedingung signalisieren.
  • Verwendung: Condition Variables sind nützlich, wenn Threads auf bestimmte Ereignisse oder Zustandsänderungen warten müssen, bevor sie fortfahren können.
  • Warum: Sie ermöglichen eine flexible und effiziente Warte- und Signalisierungsmechanismen zwischen Threads.
• Barrieren (Barriers):
  • Beschreibung: Eine Barriere ist ein Synchronisationsmechanismus, der sicherstellt, dass eine Gruppe von Threads bis zu einem bestimmten Punkt synchronisiert wird. Threads, die die Barriere erreichen, müssen warten, bis alle anderen Threads die Barriere erreicht haben.
  • Verwendung: Barrieren sind nützlich, um sicherzustellen, dass alle Threads bis zu einem bestimmten Punkt fortschreiten, bevor sie weiterarbeiten.
  • Warum: Sie helfen dabei, Diskrepanzen und Inkonsistenzen durch unsynchronisierte Threads zu vermeiden.

Zusammenfassung: Durch den kombinatorischen Einsatz von synchronen und asynchronen Ausführungen und den richtigen Einsatz von Synchronisationstechniken wie Mutexen, Semaphore, Condition Variables und Barrieren kannst Du sicherstellen, dass Deine Anwendung effizient und fehlerfrei auf multi-core Prozessoren läuft, ohne in Zustandskonflikte zu geraten.

Aufgabe 3)

Architektur verteilter Systeme: Die Architektur verteilter Systeme beschreibt die Struktur und Organisation von Software- und Hardwarekomponenten, die an verschiedenen geographischen Standorten ausgeführt werden, und deren koordinierte Interaktion, um eine gemeinschaftliche Aufgabe zu erfüllen. Verteilte Systeme bestehen aus mehreren autonomen Prozessen oder Computern und die Kommunikation erfolgt meist über Netzwerke. Zu den wichtigen Herausforderungen gehören Konsistenz, Fehlertoleranz, Replizierung und Synchronisation, sowie Sicherheitsaspekte wie Authentifizierung, Autorisierung und Verschlüsselung. Beispiele für verteilte Systeme sind Client-Server-Architekturen, Peer-to-Peer-Netzwerke und Cloud-Computing. Zur Kommunikation werden Protokolle wie HTTP, TCP/IP und SOAP verwendet, und Algorithmen wie Paxos oder Raft zur Konsensfindung. Middleware wie CORBA oder J2EE dient als Vermittler zwischen den Komponenten.

a)

Beschreibe ausführlich, warum die Konsistenz eine zentrale Herausforderung für verteilte Systeme ist. In Deine Antwort sollten folgende Punkte berücksichtigt werden:

• Erkläre das CAP-Theorem und seine Bedeutung für verteilte Systeme.
• Gib ein Beispiel, bei dem eine hohe Konsistenz erforderlich ist und erkläre, wie sie erreicht werden kann.
• Disktutiere die Nachteile von Konsistenzmechanismen in verteilten Systemen.

Lösung:

Konsistenz in verteilten Systemen:

Konsistenz stellt in verteilten Systemen eine zentrale Herausforderung dar, da mehrere autonome Prozesse oder Computer synchron arbeiten müssen, um kohärente Daten zu gewährleisten. Nachfolgend werden die Aspekte des CAP-Theorems, ein Beispiel für hohe Konsistenzanforderungen und die Nachteile von Konsistenzmechanismen erörtert.

• CAP-Theorem:

  Das CAP-Theorem, formuliert von Eric Brewer, besagt, dass es in einem verteilten System unmöglich ist, gleichzeitig die drei folgenden Eigenschaften vollständig zu gewährleisten:

  • Konsistenz (Consistency): Alle Knoten im System sehen zu jeder Zeit die gleichen Daten.
  • Verfügbarkeit (Availability): Jeder Anforderer eines gültigen Knotens erhält eine Antwort auf seine Anfrage, auch bei Teilausfällen.
  • Partitionstoleranz (Partition Tolerance): Das System funktioniert auch bei Netzwerkpartitionen weiter.

  In der Praxis bedeutet das, dass man nur zwei dieser Eigenschaften gleichzeitig vollständig erreichen kann, was eine strategische Entscheidung zur Priorisierung erfordert. Im Kontext der Konsistenz heißt das, dass zur Erreichung von Konsistenz auf die vollständige Verfügbarkeit oder die Partitionstoleranz verzichtet werden muss.

• Beispiel für hohe Konsistenzanforderungen:

  Bank- und Finanzsysteme sind ein klassisches Beispiel für Anwendungen, die eine hohe Konsistenz erfordern. Angenommen, ein Benutzer tätigt eine Überweisung von Konto A zu Konto B. Es muss sichergestellt werden, dass der abgehobene Betrag sowohl vom Konto A korrekt abgezogen als auch dem Konto B gutgeschrieben wird. Dies kann durch die Verwendung von verteilten Transaktionssystemen realisiert werden, bei denen das Two-Phase Commit (2PC) oder Paxos-Protokoll zur Anwendung kommt. Diese Mechanismen koordinieren Transaktionen über verschiedene Knoten hinweg und stellen sicher, dass alle Operationen entweder vollständig abgeschlossen oder vollständig zurückgesetzt werden können.

• Nachteile von Konsistenzmechanismen:

  Die Implementierung von starken Konsistenzmechanismen bringt einige Nachteile mit sich:

  • Leistungseinbußen: Konsistenzmechanismen wie 2PC oder Paxos verursachen zusätzlichen Overhead durch die Kommunikation zwischen Knoten und durch das Warten auf Bestätigungen, was die Systemleistung beeinträchtigen kann.
  • Verfügbarkeitsprobleme: Zur Wahrung der Konsistenz könnte das System in bestimmten Situationen nicht verfügbar sein, insbesondere während Netzwerkpartitionen oder bei Knotenausfällen.
  • Komplexität der Implementierung: Das Entwerfen und Implementieren konsistenter verteilter Systeme erfordert komplexe Algorithmen und eine präzise Koordination, was den Entwicklungsaufwand und die Fehleranfälligkeit erhöht.

c)

Überlege ein Szenario, in dem Sicherheitsaspekte in einem verteilten System von entscheidender Bedeutung sind:

• Entwickle ein sicheres Kommunikationsprotokoll für die Authentifizierung und Autorisierung der Benutzer.
• Erkläre, wie Verschlüsselungstechniken eingesetzt werden können, um die Integrität und Vertraulichkeit der Daten zu gewährleisten.

from cryptography.fernet import Fernet# Generiere Schlüsselkey = Fernet.generate_key()cipher_suite = Fernet(key)# Originalnachrichtnachricht = b'Nachricht im verteilten System'# Verschlüsselungcipher_text = cipher_suite.encrypt(nachricht)print('Verschlüsselte Nachricht:', cipher_text)# Entschlüsselungplain_text = cipher_suite.decrypt(cipher_text)print('Entschlüsselte Nachricht:', plain_text)

Lösung:

Sicherheitsaspekte in verteilten Systemen:

In vielen Szenarien sind Sicherheitsaspekte in verteilten Systemen von entscheidender Bedeutung, beispielsweise in einem medizinischen Datensystem, wo patientenbezogene Daten auf verschiedenen Servern gespeichert werden. In einem solchen System müssen Authentifizierung, Autorisierung und Verschlüsselung strikt umgesetzt werden, um die Integrität und Vertraulichkeit der sensiblen Daten zu gewährleisten.

• Sicheres Kommunikationsprotokoll für Authentifizierung und Autorisierung:
  • Authentifizierung: Jeder Benutzer muss seine Identität durch sichere Verfahren wie Benutzername-Passwort-Kombination oder Zwei-Faktor-Authentifizierung nachweisen. Diese Anmeldeinformationen sollten niemals im Klartext übertragen werden, sondern durch TLS/SSL geschützt.
  • Autorisierung: Nach erfolgreicher Authentifizierung wird dem Benutzer ein Token, wie z.B. ein JSON Web Token (JWT), ausgestellt. Dieses Token enthält Informationen über die Zugriffsberechtigungen des Benutzers und wird bei jeder nachfolgenden Anfrage verwendet, um festzustellen, ob der Benutzer berechtigt ist, bestimmte Aktionen auszuführen. Die Prüfung erfolgt durch Abgleich des Tokens mithilfe eines Middleware-Dienstes.
• Verschlüsselungstechniken zur Sicherstellung von Integrität und Vertraulichkeit:
  • Vertraulichkeit: Daten, sowohl in Ruhe als auch während der Übertragung, müssen verschlüsselt werden. Symmetrische Verschlüsselung (z.B. AES) kann verwendet werden, um große Datenmengen zu verschlüsseln. Asymmetrische Verschlüsselung (z.B. RSA) kann verwendet werden, um Schlüsselaustausch sicher zu gestalten.
  • Integrität: Um die Integrität der Daten zu gewährleisten, können kryptographische Hash-Funktion (z.B. SHA-256) eingesetzt werden. Diese Funktionen generieren Hash-Werte, die zur Überprüfung der Datenintegrität verwendet werden. Zusätzlich zur Verschlüsselung können digitale Signaturen eingesetzt werden, um sicherzustellen, dass Daten nicht manipuliert worden sind.

Beispiel einer Nachrichtverschlüsselung und -entschlüsselung in Python:

from cryptography.fernet import Fernet# Generiere Schlüsselkey = Fernet.generate_key()cipher_suite = Fernet(key)# Originalnachrichtnachricht = b'Nachricht im verteilten System'# Verschlüsselungcipher_text = cipher_suite.encrypt(nachricht)print('Verschlüsselte Nachricht:', cipher_text)# Entschlüsselungplain_text = cipher_suite.decrypt(cipher_text)print('Entschlüsselte Nachricht:', plain_text.decode('utf-8'))

In diesem Script:

• Ein Schlüssel wird generiert und zur Initialisierung eines Fernet-Verschlüsselungsobjekts verwendet.
• Die Nachricht wird verschlüsselt und der verschlüsselte Text wird dargestellt.
• Die verschlüsselte Nachricht wird entschlüsselt und die entzifferte Nachricht wird ausgegeben.

Aufgabe 4)

Hochleistungsrechnen umfasst eine Vielzahl von Konzepten, die für die effiziente Nutzung von Rechenressourcen für komplexe Berechnungen von zentraler Bedeutung sind. In diesem Kontext ist es unerlässlich, sich mit paralleler Programmierung, verteilten Systemen, Skalierbarkeit, Performance sowie unterschiedlichen Architekturen wie CPU, GPU und FPGA auseinanderzusetzen. Anwendungsbeispiele umfassen die Wettervorhersage und Genomsequenzierung, während Werkzeuge wie MPI, OpenMP und CUDA oft zum Einsatz kommen. Dazu gehört auch die Anwendung von Algorithmen zur Dekomposition und Lastverteilung sowie das Benchmarking und die Optimierung.

a)

Erläutere die Unterschiede zwischen paralleler Programmierung und verteilten Systemen. Gehe dabei insbesondere auf ihre Implementierung und Anwendungsbereiche ein. Nimm spezifischen Bezug auf die Werkzeuge MPI und OpenMP und wie diese jeweils in diesen beiden Bereichen eingesetzt werden.

Lösung:

Unterschiede zwischen paralleler Programmierung und verteilten Systemen:

• Parallele Programmierung:
  • Definition: Parallele Programmierung bezieht sich auf die gleichzeitige Ausführung mehrerer Berechnungen oder Prozesse. Dies erfolgt typischerweise auf einer einzigen Maschine mit mehreren Prozessorkernen oder auf einer GPU. Das Ziel ist es, die Rechenleistung durch gleichzeitige Durchführung von Aufgaben zu maximieren.
  • Implementierung: Hierfür werden Werkzeuge wie OpenMP (Open Multi-Processing) verwendet. OpenMP ermöglicht die parallele Ausführung von Code-Abschnitten, indem es Compiler-Direktiven, Laufzeitbibliotheken und Umweltvariablen nutzt. Programmierer können Abschnitte ihres Codes markieren, die parallel ausgeführt werden sollen.
  • Anwendungsbereiche: Beispiele für Anwendungen der parallelen Programmierung sind numerische Simulationen, Bildverarbeitung, Machine Learning und wissenschaftliche Berechnungen, die große Datenmengen schnell verarbeiten müssen.
• Verteilte Systeme:
  • Definition: Verteilte Systeme bestehen aus mehreren Computern, die über ein Netzwerk miteinander verbunden sind und zusammenarbeiten, um eine gemeinsame Aufgabe zu erfüllen. Die Hauptidee ist, große Rechen- oder Datenaufgaben auf mehrere Maschinen zu verteilen, um Skalierbarkeit und Fehlertoleranz zu erreichen.
  • Implementierung: In verteilten Systemen wird häufig MPI (Message Passing Interface) eingesetzt. MPI bietet Bibliotheken, die es ermöglichen, Nachrichten zwischen verschiedenen Prozessen zu senden und zu empfangen, die auf unterschiedlichen Rechnern laufen. Es ist besonders nützlich für Anwendungen, die eine hohe Skalierbarkeit über viele Knoten erfordern.
  • Anwendungsbereiche: Beispiele für Anwendungen verteilte Systeme sind Wettervorhersage, Finanzmodellierung, Suchmaschinenindizierung und wissenschaftliche Simulationen, die auf großen verteilten Datenmengen arbeiten.
• Konkreter Einsatz von MPI und OpenMP:
  • MPI: In verteilten Systemen wird MPI verwendet, um Daten zwischen verschiedenen Knoten in einem Netzwerk auszutauschen. Es eignet sich für Anwendungen, die auf Cluster von Computern oder Supercomputern ausgeführt werden, wo die Kommunikation zwischen Knoten entscheidend ist. Ein typisches Beispiel ist die Parallelisierung von Wettermodellen, bei dem verschiedene Teile des Modells auf unterschiedlichen Knoten berechnet und Ergebnisse regelmäßig ausgetauscht werden.
  • OpenMP: OpenMP wird in paralleler Programmierung verwendet, um die Ausführung von Code-Segmenten auf mehreren Prozessorkernen derselben Maschine zu organisieren. Es ist besonders nützlich für Anwendungen, die auf Einzelrechnern mit mehreren Kernen oder auf GPUs laufen. Ein Anwendungsbeispiel ist die Beschleunigung von numerischen Simulationen oder die Bearbeitung großer Bilddatenmengen auf einer Workstation.

b)

Gegeben sei ein Beispiel für eine Wettervorhersage-Simulation, die parallel ausgeführt wird. Angenommen, die Simulation läuft zunächst auf einer einzelnen CPU mit einer Rechenzeit von 8 Stunden. Nun soll die Simulation auf 4 GPUs parallelisiert werden.

• Berechne die zu erwartende Rechenzeit, wenn jede GPU die gleiche Last übernimmt und der Overhead vernachlässigbar ist.
• Diskutiere, wie sich die Leistung (Speedup) und Effizienz der Simulation verändern, wenn der Overhead doch nicht vernachlässigbar ist und 10% der Gesamtrechenzeit auf Synchronisationsbedarf zurückzuführen ist.

Lösung:

Wettervorhersage-Simulation auf 4 GPUs parallelisiert:

• Berechnung der zu erwartenden Rechenzeit ohne Overhead:

• Gegeben ist eine initiale Rechenzeit von 8 Stunden auf einer einzelnen CPU.
• Diese Rechenzeit wird durch die Anzahl der GPUs geteilt, wenn jede GPU die gleiche Last übernimmt.
• Rechenzeit mit 4 GPUs = \(\frac{8 \text{ Stunden}}{4} = 2 \text{ Stunden}\)

• Leistung (Speedup) und Effizienz ohne Overhead:
  • Speedup = \(\frac{8 \text{ Stunden}}{2 \text{ Stunden}} = 4\)
  • Effizienz = \(\frac{4}{4} = 1 \text{ (bzw. 100%) }\)

• Diskussion der Leistung (Speedup) und Effizienz mit Overhead:
  • Nehmen wir an, dass 10% der Gesamtrechenzeit auf Synchronisationsbedarf zurückzuführen ist. Dies bedeutet, dass nur 90% der Zeit effektiv für die Berechnung genutzt werden.
  • Neue Rechenzeit unter Berücksichtigung des Overheads: Effektive Rechenzeit = \(0.9 \times 8 \text{ Stunden} = 7.2 \text{ Stunden}\)
  • Die effektive Rechenzeit für die Berechnungen wird durch 4 GPUs geteilt: Effektive Rechenzeit pro GPU = \(\frac{7.2 \text{ Stunden}}{4} = 1.8 \text{ Stunden}\)
  • Zusätzlich müssen wir den Overhead (10% der effektiven Rechenzeit) berücksichtigen: Gesamtrechenzeit mit Overhead = 1.8 \text{ Stunden} + (1.8 \text{ Stunden} \times 0.1) = 1.8 \text{ Stunden} + 0.18 \text{ Stunden} = 1.98 \text{ Stunden}
  • Speedup mit Overhead = \(\frac{8 \text{ Stunden}}{1.98 \text{ Stunden}} \approx 4.04\)
  • Effizienz mit Overhead = \(\frac{4.04}{4} \approx 1.01 \text{ (bzw. 101%) }\)

• Es ist jedoch anzumerken, dass der Speedup und die Effizienzwerte unter der Annahme berechnet wurden, dass die Gesamtarbeit gleichmäßig aufgeteilt wird und die Synchronisation 10% der Rechenzeit auf jedem GPU betrifft. Tatsächlich können diese Zahlen je nach Art der Arbeitslastverteilung und den tatsächlichen Synchronisationsanforderungen variieren. In der Realität kann dies oft zu einem weniger idealen Ergebnis führen.