Fehlertolerierende Softwarearchitekturen (Vorlesung mit Übung) - Exam

Aufgabe 1)

Fehlertoleranz ist die Fähigkeit eines Systems, trotz Fehlern im Hardware- oder Softwarebetrieb weiterzulaufen. Ihre Bedeutung liegt in der Erhöhung der Systemsicherheit und Zuverlässigkeit. Wichtige Kernkonzepte beinhalten Redundanz, Diversität, Fehlererkennung und -korrektur.

• Methode N-version programming: Diese Technik verwendet mehrere implementierte Versionen derselben Software, um Fehler durch Mehrheitsentscheidung zu beheben.
• Checkpointing: Speichert den Zustand eines Systems zu bestimmten Zeitpunkten, um bei Fehlern darauf zurückzugreifen und von einem fehlerfreien Punkt erneut zu starten.
• Error detection codes: Nutzt Codiertechniken wie Paritätsbits oder CRC (Cyclic Redundancy Check) zur Erkennung von Fehlern in Datenübertragungen.

Typische Messgrößen, die in der Fehlertoleranz verwendet werden, sind Mean Time Between Failures (MTBF) und Mean Time To Repair (MTTR). Sie geben Aufschluss über die durchschnittliche Zeitdauer zwischen Fehlern bzw. die durchschnittliche Zeit zur Behebung eines Fehlers.

Fehlertolerierende Systeme werden insbesondere in kritischen Bereichen eingesetzt, wie in der Luft- und Raumfahrt, der Medizintechnik und im Bankenwesen.

a)

Beschreibe das Konzept der Redundanz und gib ein konkretes Beispiel, wie es in der Fehlertoleranz angewendet wird. Erkläre dabei auch den Unterschied zwischen aktiver und passiver Redundanz.

Lösung:

Redundanz in der Fehlertoleranz

Redundanz ist ein Konzept, das in fehlertoleranten Systemen verwendet wird, um die Verfügbarkeit und Zuverlässigkeit zu erhöhen. Es bezieht sich auf die Bereitstellung zusätzlicher Komponenten oder Systeme, die in Betrieb genommen werden, wenn die primäre Komponente oder das primäre System ausfällt. Es gibt zwei Hauptarten von Redundanz: aktive und passive Redundanz.

Aktive Redundanz

Bei der aktiven Redundanz laufen mehrere Komponenten parallel, sodass eine von ihnen im Falle eines Ausfalls die Arbeit sofort übernehmen kann, ohne dass ein Zeitverlust entsteht. Dies erhöht die Systemzuverlässigkeit, da es keine Unterbrechung der Funktionalität gibt. Ein konkretes Beispiel für aktive Redundanz ist ein Server-Cluster, bei dem mehrere Server die gleichen Anfragen gleichzeitig bearbeiten. Fällt ein Server aus, können die anderen Server nahtlos übernehmen.

Passive Redundanz

Bei der passiven Redundanz gibt es ebenfalls zusätzliche Komponenten, aber diese bleiben inaktiv, bis die primäre Komponente ausfällt. Beim Ausfall der primären Komponente wird die Backup-Komponente manuell oder automatisch aktiviert. Ein typisches Beispiel ist ein Standby-Generator, der bei einem Stromausfall automatisch gestartet wird, um die Stromversorgung aufrechtzuerhalten.

Konkretes Beispiel: Redundanz in Flugzeugen

Ein konkretes Beispiel für Redundanz in der Praxis ist die Anwendung in der Luftfahrt. Ein modernes Verkehrsflugzeug ist häufig mit mehrfachen redundanten Systemen ausgestattet, wie zum Beispiel redundanten Hydrauliksystemen, um die Steuerflächen des Flugzeugs zu bewegen. Sollte ein Hydrauliksystem ausfallen, kann ein anderes Hydrauliksystem die Kontrolle übernehmen und somit sicherstellen, dass das Flugzeug weiterhin sicher betrieben werden kann.

b)

Ein System hat einen MTBF von 2000 Stunden und eine MTTR von 2 Stunden. Berechne die Verfügbarkeit des Systems und interpretiere das Ergebnis. Wie würde sich die Verfügbarkeit verändern, wenn die MTTR auf 4 Stunden ansteigen würde?

Berechnet die Verfügbarkeit (\text{Verfügbarkeit}) mit der Formel:

• \text{\text{Verfügbarkeit}} = \frac{\text{MTBF}}{\text{MTBF} + \text{MTTR}}

Lösung:

Berechnung der Verfügbarkeit eines Systems

Um die Verfügbarkeit eines Systems zu berechnen, nutzen wir die gegebene Formel:

Verfügbarkeit = \(\frac{\text{MTBF}}{\text{MTBF} + \text{MTTR}}\)

Fall 1: Gegebene Werte MTBF = 2000 Stunden und MTTR = 2 Stunden

Setzen wir die Werte in die Formel ein:

• \(\text{Verfügbarkeit} = \frac{2000}{2000 + 2}\)

Das ergibt:

\(\text{Verfügbarkeit} = \frac{2000}{2002} \approx 0.999\)

Die Verfügbarkeit des Systems ist also 0.999 oder 99.9%. Das bedeutet, dass das System sehr zuverlässig ist und 99.9% der Zeit funktionsfähig bleibt.

Fall 2: MTTR steigt auf 4 Stunden

Setzen wir jetzt die neuen Werte in die Formel ein:

• \(\text{Verfügbarkeit} = \frac{2000}{2000 + 4}\)

Das ergibt:

\(\text{Verfügbarkeit} = \frac{2000}{2004} \approx 0.998\)

Die Verfügbarkeit des Systems sinkt auf etwa 0.998 oder 99.8%, wenn die MTTR auf 4 Stunden ansteigt. Dies zeigt, dass selbst eine geringe Erhöhung der Reparaturzeit die Verfügbarkeit eines Systems merklich beeinflussen kann, auch wenn es sich in diesem Fall nur um einen geringen Rückgang handelt.

Aufgabe 2)

Du hast ein Software-System, das in einer kritischen Umgebung eingesetzt wird, wie z. B. ein Flugzeugnavigationssystem. Dieses System muss extrem zuverlässig sein und darf unter keinen Umständen ausfallen. Berücksichtige hierbei die Unterschiede zwischen Fehlervermeidung und Fehlertoleranz.

a)

Beschreibe detailliert, wie Du Fehlervermeidung in diesem System umsetzen würdest. Welche Techniken würdest Du verwenden und warum? Erläutere dies anhand von beispielhaften Maßnahmen, die in der Entwicklung dieses Systems ergriffen werden könnten.

Lösung:

Fehlervermeidung in einem kritischen System wie einem Flugzeugnavigationssystem ist von höchster Priorität. Hier sind detaillierte Schritte und Techniken, um Fehlervermeidung sicherzustellen:

• Strikte Anforderungen und Spezifikationen: - Entwickle detaillierte Spezifikationen und Anforderungen, die alle Funktionen und Leistungsstandards definieren. Dies minimiert Missverständnisse und Fehlinterpretationen. - Führe Überprüfungen der Anforderungen durch, um sicherzustellen, dass alle Stakeholder ein gemeinsames Verständnis haben.
• Formale Methoden: - Verwende formale Modellierungstechniken wie Z-Notation oder VDM. Diese Methoden helfen, mathematisch überprüfbare Modelle des Systems zu erstellen, die Logikfehler minimieren. - Formale Verifikation kann auch dazu verwendet werden, die Korrektheit von Algorithmen und Systemverhalten zu beweisen.
• Modulare Architektur: - Entwickle das System in unabhängigen, gut getesteten Modulen, die einzeln überprüft werden können. Dies erleichtert das Auffinden und Beheben von Fehlern. - Verwende einfache, gut dokumentierte Schnittstellen zwischen den Modulen.
• Code-Reviews und Pair Programming: - Führe regelmäßig Code-Reviews durch, bei denen mehrere Entwickler den Code überprüfen. Dies hilft, potenzielle Fehler frühzeitig zu erkennen. - Pair Programming kann ebenfalls nützlich sein, da zwei Entwickler gleichzeitig an einem Problem arbeiten und sich gegenseitig überwachen.
• Automatisierte Tests und Continuous Integration: - Implementiere eine umfangreiche Testabdeckung mit Unit-Tests, Integrationstests und Systemtests. - Verwende Continuous Integration (CI) Systeme, um sicherzustellen, dass Änderungen konstant getestet und integriert werden. - Automatisierte Tests sollten bei jeder Änderung des Codes ausgeführt werden, um sicherzustellen, dass neue Fehler sofort erkannt werden.
• Statische Code-Analyse: - Nutze Werkzeuge zur statischen Analyse, um potenzielle Fehler, Schwachstellen und Codegerüche im Code zu identifizieren. - Diese Analysewerkzeuge können helfen, Probleme wie nicht initialisierte Variablen, Speicherlecks oder Verletzungen der Codierungsstandards zu entdecken.
• Dokumentation und Schulung: - Stelle sicher, dass alle Entwickler umfassend geschult sind und die Dokumentation des Systems verstehen. - Dokumentiere alle Aspekte des Codes und der Architektur sorgfältig, um langfristige Wartung und Verständnis zu erleichtern.
• Verwendung von Standardsoftware und erprobten Technologien: - Verwende nach Möglichkeit bewährte und standardisierte Softwarekomponenten und Bibliotheken. - Vermeide die Einführung neuer Technologien, die noch nicht ausgereift oder vollständig verstanden sind.
• Redundanz und Fallback-Mechanismen: - Implementiere Redundanzsysteme, die bei Ausfall eines Teilsystems die Kontrolle übernehmen können. - Plane Fallback-Mechanismen, die das System in einen sicheren Zustand versetzen können, falls ein Fehler auftritt.

Durch die Kombination dieser Techniken lässt sich die Fehlervermeidung in einem kritischen System wie einem Flugzeugnavigationssystem signifikant erhöhen. Jede Technik fordert Disziplin und Sorgfalt während des gesamten Entwicklungsprozesses, um die Zuverlässigkeit und Sicherheit des Systems zu gewährleisten.

b)

Angenommen, trotz aller Maßnahmen zur Fehlervermeidung tritt ein Fehler im System auf. Beschreibe eine Strategie zur Fehlertoleranz, die sicherstellt, dass das System weiterhin funktionstüchtig bleibt. Welche Techniken würdest Du konkret einsetzen und wie würden sie im Kontext des Flugzeugnavigationssystems wirken?

Lösung:

Fehlertoleranz ist ein wesentlicher Aspekt eines kritischen Systems wie eines Flugzeugnavigationssystems. Hier sind detaillierte Strategien und Techniken zur Fehlertoleranz, um sicherzustellen, dass das System weiterhin funktionstüchtig bleibt:

• Redundante Systeme: - Implementiere mehrfach redundante Systeme, bei denen mehrere unabhängige Instanzen desselben Subsystems gleichzeitig arbeiten. Falls eine Instanz ausfällt, kann eine andere nahtlos übernehmen. - Beispiel: Mehrere Navigationscomputer, die parallel laufen, sodass wenn ein Computer ausfällt, ein anderer sofort die Kontrolle übernehmen kann.
• Fehlererkennung und -diagnose: - Entwickle Mechanismen zur kontinuierlichen Überwachung und Diagnose des Systems, um Fehler frühzeitig zu erkennen. - Beispiel: Selbsttest-Routinen und diagnostische Protokolle, die ständig den Zustand der Hardware und Software überwachen und Fehlermeldungen an das zentrale Kontrollsystem senden.
• Failover-Mechanismen: - Implementiere automatische Failover-Mechanismen, die bei Erkennung eines Fehlers sofort auf ein Backup-System umschalten. - Beispiel: Falls der primäre Flugsteuerungscomputer ausfällt, übernimmt sofort ein sekundärer Computer die Kontrolle ohne merkbare Verzögerung für die Besatzung.
• Voting-Systeme: - Verwende eine Mehrheitsentscheidung (Voting-System) bei kritischen Entscheidungen. Drei oder mehr parallele Systeme treffen Entscheidungen, und die Mehrheit bestimmt das Ergebnis. - Beispiel: Drei Navigationssysteme berechnen gleichzeitig den Kurs. Wenn eines eine abweichende Berechnung liefert, entscheiden die beiden übereinstimmenden Berechnungen.
• Datenreplikation und -synchronisation: - Stelle sicher, dass alle kritischen Daten in Echtzeit repliziert und synchronisiert werden. - Beispiel: Kontinuierliche Synchronisation der Navigationsdaten zwischen primären und sekundären Systemen, um sicherzustellen, dass im Falle eines Ausfalls keine Daten verloren gehen.
• Graceful Degradation: - Entwickle das System so, dass es bei einem Teilfehler seine Funktionalität auf einem minimal akzeptablen Niveau weiterführen kann. - Beispiel: Wenn ein Sensor ausfällt, gibt das System eine Warnung aus, verwendet aber weiterhin alternative Sensoren zur Bestimmung der Position.
• Diversität in der Implementierung: - Benutze unterschiedliche Implementierungen für redundante Systeme, um das Risiko gleichzeitiger Fehler zu minimieren. - Beispiel: Zwei Navigationssysteme, die auf unterschiedlichen Plattformen (z.B. unterschiedliche Betriebssysteme oder Programmiersprachen) basieren.
• Watchdog-Timer: - Implementiere Watchdog-Timer, die das System neu starten oder eine alternative Operation initiieren, wenn ein Teil des Systems nicht innerhalb einer bestimmten Zeit antwortet. - Beispiel: Wenn ein Navigationscomputer innerhalb einer bestimmten Zeitspanne nicht reagiert, führt der Watchdog-Timer einen automatischen Neustart des Computers durch.
• Logging und Auditing: - Führe umfassende Protokollierung und Überwachung der Systemaktivitäten durch, um Fehlerursachen zu analysieren und zu dokumentieren. - Beispiel: Detaillierte Logs aller Software-Operationen, die zur Fehlerdiagnose und zukünftigen Fehlervermeidung verwendet werden können.

Durch die Kombination dieser Techniken lässt sich die Fehlertoleranz in einem Flugzeugnavigationssystem signifikant erhöhen. Auch wenn Fehler auftreten, bleibt das System funktionsfähig und gewährleistet die Sicherheit und Zuverlässigkeit des Flugzeugs.

Aufgabe 3)

In einem sicherheitskritischen System wird sowohl physikalische als auch logische Fehlererkennung implementiert, um die Zuverlässigkeit und Verfügbarkeit des Systems sicherzustellen. Du entscheidest Dich, einen ECC-Speicher (Error-Correcting Code) für die physikalische Fehlererkennung und Try-Catch-Blöcke im Programmcode für die logische Fehlererkennung zu verwenden. Nehmen wir an, Du arbeitest an einem System, das Echtzeitdaten aus Sensoren verarbeitet und dabei sowohl Hardware- als auch Software-Komponenten beinhaltet.

a)

Für die physikalische Fehlererkennung in Deinem System planst Du, ECC-Speicher zu verwenden. Erkläre, wie ECC-Speicher funktioniert und beschreibe den Prozess der Fehlererkennung und -korrektur bei einem Speicherfehler. Berechne die Anzahl der zusätzlichen Bits, die benötigt werden, um einen 64-Bit-Datenwort mit einem Hamming-Code zu schützen, der 1-bit Fehler korrigieren kann.

Lösung:

Funktionsweise von ECC-Speicher:

ECC-Speicher (Error-Correcting Code) ist eine Art von Speicher, der integrierte Mechanismen zur Fehlererkennung und -korrektur verwendet. Dies erfolgt durch das Hinzufügen von Redundanz-Datenbits zu den Originaldatenbits, wodurch Fehler erkannt und korrigiert werden können. Der häufigste ECC-Algorithmus ist der Hamming-Code.

Der Hamming-Code funktioniert, indem er Paritätsbits an bestimmten Positionen innerhalb des Datenworts einfügt. Diese Paritätsbits sind so platziert, dass sie Überlappungen in ihrer Überprüfung haben, wodurch es möglich wird, die genaue Position eines fehlerhaften Bits zu identifizieren und diesen Fehler zu korrigieren.

Prozess der Fehlererkennung und -korrektur:

• Schritt 1: Bei der Speicherung der Daten werden zusätzliche Paritätsbits berechnet und zu den Daten hinzugefügt. Diese zusätzlichen Bits sind speziell angeordnet, um spätere Fehlererkennung und -korrektur zu ermöglichen.
• Schritt 2: Beim Abrufen der Daten werden die Paritätsbits erneut berechnet und mit den gespeicherten Paritätsbits verglichen. Weicht ein gespeichertes Paritätsbit von einem neu berechneten Paritätsbit ab, zeigt dies einen Fehler.
• Schritt 3: Die spezifischen Positionen der Paritätsbits und ihre Überlappungen ermöglichen das Identifizieren der exakten Position des fehlerhaften Bits.
• Schritt 4: Der Hamming-Code kann dann die Daten im Speicher korrigieren, indem er das fehlerhafte Bit umkehrt.

Berechnung der zusätzlichen Bits:

Um die Anzahl der zusätzlichen Bits zu berechnen, die für einen 64-Bit-Datenwort mit einem Hamming-Code benötigt werden, der einen 1-bit Fehler korrigieren kann, verwenden wir die folgende Formel:

2^r ≥ m + r + 1

Hierbei ist r die Anzahl der erforderlichen Redundanzbits, und m ist die Anzahl der Datenbits. Für ein 64-Bit-Datenwort (m=64) lösen wir die Formel für r:

• 64 + r + 1 = 2^r
• 65 + r = 2^r

Testen wir verschiedene Werte für r:

• Für r = 6: 65 + 6 = 71, aber 2⁶ = 64 (nicht ausreichend)
• Für r = 7: 65 + 7 = 72, aber 2⁷ = 128 (ausreichend)

Also sind 7 zusätzliche Bits erforderlich, um ein 64-Bit-Datenwort mit einem Hamming-Code zu schützen, der einen 1-bit Fehler korrigieren kann.

b)

Betrachten wir nun die logische Fehlererkennung. Implementiere einen Code in einer Programmiersprache Deiner Wahl, der Daten von Sensoren liest und eine einfache Verarbeitung durchführt. Verwende Try-Catch-Blöcke, um mögliche Ausnahmen zu behandeln, die während der Datenverarbeitung auftreten könnten. Erläutere, welche Art von Fehlern Deine Try-Catch-Blöcke erkennen und behandeln können.

Lösung:

Implementierung eines Programmcodes mit Try-Catch-Blöcken:

In diesem Beispiel verwenden wir Python als Programmiersprache. Der folgende Code liest Daten von Sensoren und führt eine einfache Verarbeitung durch. Try-Catch-Blöcke werden verwendet, um mögliche Ausnahmen zu behandeln:

import random# Funktion zum Lesen von Sensordaten (simuliert), die zufällig Fehler erzeugen könntendef read_sensor_data(sensor_id):    # Simulieren eines zufälligen Fehlers    if random.random() < 0.1:   # 10% Wahrscheinlichkeit eines Fehlers        raise ValueError(f'Fehler beim Lesen von Sensor {sensor_id}')    return random.uniform(20.0, 30.0)# Funktion zur Verarbeitung von Sensordatendef process_sensor_data(data):    # Simulieren eines zufälligen Fehler    if random.random() < 0.05:  # 5% Wahrscheinlichkeit eines Fehlers        raise RuntimeError('Fehler bei der Verarbeitung der Sensordaten')    # Einfache Verarbeitung: Durchschnitt berechnen    return sum(data) / len(data)# Hauptprogrammsensor_ids = [1, 2, 3, 4, 5]all_data = []for sensor_id in sensor_ids:    try:        # Sensordaten lesen        data = read_sensor_data(sensor_id)        all_data.append(data)        print(f'Daten von Sensor {sensor_id}: {data}')    except ValueError as e:        print(f'Warnung: {e}')try:    # Verarbeiten gesammelter Sensordaten    average_value = process_sensor_data(all_data)    print(f'Durchschnittswert der Sensordaten: {average_value}')except RuntimeError as e:    print(f'Fehler: {e}')except Exception as e:    print(f'Ein unerwarteter Fehler ist aufgetreten: {e}')

Erläuterung der Fehlerarten:

• ValueError: Diese Ausnahme tritt auf, wenn beim Lesen der Sensoren ein Fehler auftritt. Dies könnte durch fehlerhafte oder unvollständige Sensordaten verursacht werden.
• RuntimeError: Diese Ausnahme tritt während der Verarbeitung der Sensordaten auf. Dies könnte durch Berechnungsfehler oder unerwartete Zustände während der Verarbeitung verursacht werden.
• Exception: Dies ist eine allgemeine Ausnahme, die jede andere Art von Fehler abfängt, die nicht explizit behandelt wurde. Dies dient als Fallback, um unerwartete Fehler zu erkennen und zu behandeln.

Durch die Verwendung von Try-Catch-Blöcken können diese Fehler erkannt und entsprechende Maßnahmen ergriffen werden, um die Zuverlässigkeit und Verfügbarkeit des Systems zu gewährleisten.

Aufgabe 4)

Fehlermaskierung vs. FehlerkorrekturFehlermaskierung: Verbergen von Fehlern durch Umgehung oder Neutralisierung. Fehlerkorrektur: Erkennen und Beheben von Fehlern im System.

• Fehlermaskierung: Ziel ist es, dass der Fehler das System nicht beeinflusst.
• Beispiel: Triple Modular Redundancy (TMR) nutzt drei Module und Mehrheitsvotum.
• Fehlerkorrektur: Ziel ist es, den Fehler tatsächlich zu beheben.
• Beispiel: Hamming-Code und CRC (Cyclic Redundancy Check) korrigieren Fehler in Daten.
• Fehlermaskierung: Sofortige Problemlösung, sichtbarer Fehler bleibt verborgen, führt zu potenziellen Akkumulation unerkannter Fehler
• Fehlerkorrektur: Längerer Prozess, umfasst Fehlerdiagnose und -behebung, kann zur Systemverlangsamung führen aufgrund zusätzlicher Verarbeitung.

a)

Gib eine detaillierte Erklärung und ein praktisches Beispiel zu Triple Modular Redundancy (TMR). Erkläre, wie dieser Mechanismus zur Fehlermaskierung funktioniert und diskutiere seine Vor- und Nachteile.

Lösung:

Triple Modular Redundancy (TMR)

Detaillierte Erklärung:Triple Modular Redundancy (TMR) ist ein Fehlerredundanzverfahren, das zur Fehlermaskierung genutzt wird. Es basiert auf der Idee, kritische Systemkomponenten dreifach zu replizieren und deren Ausgaben durch ein Mehrheitsvotum zu konsolidieren. Dadurch wird sichergestellt, dass ein fehlerhaftes Modul keine Auswirkung auf die endgültige Ausgabe hat, solange die anderen beiden Module korrekt funktionieren.

Funktionsweise:Das TMR-System besteht aus drei identischen Modulen oder Einheiten, die dieselbe Aufgabe gleichzeitig ausführen. Ihre Ausgaben werden dann an eine Voting-Logik weitergeleitet, die die drei Ergebnisse vergleicht und das Ergebnis wählt, das mindestens von zwei der drei Module übereinstimmt.

Praktisches Beispiel:Stell Dir eine Raumsonde vor, die sich auf einer wichtigen Mission im Weltall befindet. Eine kritische Berechnung wie die Navigation der Sonde könnte durch TMR abgesichert werden. Hier sind die CPU, die diese Berechnung durchführt, dreifach vorhanden. Alle drei CPUs führen die Navigation berechnungen gleichzeitig durch und geben ihre Ergebnisse an einen Mehrheitswähler weiter, der dann das mehrheitliche Ergebnis als das korrekte Ergebnis auswählt.

Vor- und Nachteile:

• Vorteile:
  • Fehlermaskierung: TMR kann einen einzelnen Fehler in einem der Module maskieren, indem sichergestellt wird, dass die korrekte Funktionalität erhalten bleibt.
  • Erhöhte Zuverlässigkeit: Da das Mehrheitsvotum den Fehler eines einzelnen Moduls maskiert, steigt die Zuverlässigkeit des Gesamtsystems erheblich.
  • Sofortige Problemlösung: Fehler werden direkt maskiert, ohne Verzögerung, wodurch das System ununterbrochen weiterarbeiten kann.
• Nachteile:
  • Kosten: Die dreifache Replikation der Hardware erhöht die Kosten erheblich.
  • Platzbedarf: Die zusätzliche Hardware benötigt mehr Platz, was in einigen Anwendungen problematisch sein kann.
  • Leistungsaufnahme: Mehr Module bedeuten auch eine höhere Leistungsaufnahme, was in energieempfindlichen Systemen wie Satelliten kritisch sein kann.
  • Potenzielle Fehlerakkumulation: Da Fehler maskiert werden und somit nicht sofort erkannt und behoben werden, könnten sich potenziell unerkannte Fehler im System akkumulieren.

b)

Betrachte den Hamming-Code. Angenommen, Du hast die 4-Bit-Datenfolge 1101. Bestimme den resultierenden Hamming-Code, indem Du die entsprechenden Paritätsbits berechnest und hinzufügst. Erläutere dabei Schritt für Schritt, wie Fehler erkannt und korrigiert werden können.

Lösung:

Der Hamming-Code

Schritt-für-Schritt-Berechnung des Hamming-Codes:Angenommen, wir haben eine 4-Bit-Datenfolge, nämlich 1101. Um den Hamming-Code zu bestimmen, müssen wir zunächst die Positionen der Daten- und Paritätsbits festlegen.

1. Bestimmen der Positionen:Im Hamming-Code sind bestimmte Bit-Positionen für die Paritätsbits vorgesehen. Für eine Nachrichtenlänge von 4-Bits sind 3 Paritätsbits erforderlich. Die Positionen der Paritätsbits sind Potenzen von 2. Daher haben wir:

• Position 1: Paritätsbit (P1)
• Position 2: Paritätsbit (P2)
• Position 3: Datenbit (D1)
• Position 4: Paritätsbit (P3)
• Position 5: Datenbit (D2)
• Position 6: Datenbit (D3)
• Position 7: Datenbit (D4)

Daraus ergibt sich die folgende Struktur: P1, P2, D1, P3, D2, D3, D4Die Datenbits 1101 werden entsprechend auf die Positionen gelegt:P1, P2, 1, P3, 1, 0, 1

2. Berechnen der Paritätsbits:Wir berechnen nun die Paritätsbits anhand der Datenbits:

• P1 deckt alle Bit-Positionen ab, deren binäre Repräsentation das niederwertigste Bit (least significant bit - LSB) ist 1. Das sind die Positionen 1, 3, 5, und 7.Daraus ergibt sich: P1 = Parität (bit 1, bit 3, bit 5, bit 7) = Parität (P1, 1, 1, 1) = 1
• P2 deckt alle Bit-Positionen ab, deren binäre Repräsentation das zweithöchstwertige Bit (second significant bit - LSB) ist 1. Das sind die Positionen 2, 3, 6, und 7.Daraus ergibt sich: P2 = Parität (bit 2, bit 3, bit 6, bit 7) = Parität (P2, 1, 0, 1) = 0
• P3 deckt alle Bit-Positionen ab, deren binäre Repräsentation das dritthöchste Bit (third significant bit - LSB) ist 1. Das sind die Positionen 4, 5, 6, und 7.Daraus ergibt sich: P3 = Parität (bit 4, bit 5, bit 6, bit 7) = Parität (P3, 1, 0, 1) = 0

Finaler Hamming-Code:Insgesamt erhalten wir den Hamming-Code:P1, P2, D1, P3, D2, D3, D4 = 1010110

Fehlererkennung und -korrektur:

• Fehlererkennung: Angenommen, ein Bit kippt um. Der Empfänger überprüft mittels Paritätsbits die Integrität der empfangenen Daten. Die Parität jedes der Paritätsbits wird neu berechnet und mit den empfangenen Paritätsbits verglichen. Unterschiede weisen auf eine Fehlerbit-Position hin.
• Fehlerkorrektur: Wenn ein Fehler erkannt wird, addiert der Empfänger die Positionen der fehlerhaften Paritätsbits. Die Summe gibt die Bit-Position des Fehlers an. Der Empfänger invertiert dann dieses Bit, um den Fehler zu korrigieren. Beispiel: Würden Paritäten an Position 1 und 2 und 4 fehlschlagen, sumiert der Empfänger 1+2+4=7, und invertiert Bit 7, um den Fehler zu korrigieren.

c)

Schätze die Auswirkungen auf die Systemleistung ab, wenn man in einem Echtzeitsystem Fehlermaskierungs- und Fehlerkorrekturmechanismen verwendet. Vergleiche die Reaktionszeiten und Ressourcenanforderungen und diskutierte, unter welchen Szenarien welche Methode bevorzugt wird.

Lösung:

Auswirkungen von Fehlermaskierungs- und Fehlerkorrekturmechanismen auf die Systemleistung

In Echtzeitsystemen spielt die Reaktionszeit eine entscheidende Rolle. Hier werden die Auswirkungen auf die Systemleistung von Fehlermaskierungs- und Fehlerkorrekturmechanismen im Hinblick auf Reaktionszeiten und Ressourcenanforderungen betrachtet.

Fehlermaskierung:Fehlermaskierungstechniken wie Triple Modular Redundancy (TMR) sind darauf ausgerichtet, auftretende Fehler sofort zu neutralisieren, ohne dass das System dabei verzögert wird.

• Reaktionszeiten: Die Reaktionszeit ist bei der Fehlermaskierung minimal, da Fehler sofort maskiert werden. Die Gesamtleistung des Systems bleibt weitgehend unbeeinflusst.
• Ressourcenanforderungen: Fehlermaskierung erfordert zusätzliche Hardware- und/oder Softwaremodule, was zu höheren Kosten und größerem Platzbedarf führt. Ebenfalls kann der Stromverbrauch in energieempfindlichen Systemen problematisch sein.
• Vorteile:
  • Sofortige Lösung und Aufrechterhaltung der Systemreaktionszeiten.
  • Geeignet für Systeme, bei denen Verfügbarkeit und kontinuierliche Betriebsbereitschaft von hoher Bedeutung sind (z.B. Flugzeugsteuerungen, medizinische Geräte).
• Nachteile:
  • Höhere Hardwarekosten und komplexere Architektur.
  • Potenziell unerkannte Fehler könnten sich im System ansammeln und später schwerwiegendere Probleme verursachen.

Fehlerkorrektur:Fehlerkorrekturmechanismen wie der Hamming-Code und CRC erkennen und beheben Fehler im System.

• Reaktionszeiten: Fehlerkorrektur erfordert zusätzliches Processing für Fehlererkennung und -behebung, was zu längeren Reaktionszeiten führt. In einem Echtzeitsystem könnte dies die Leistungsanforderungen beeinträchtigen.
• Ressourcenanforderungen: Diese Mechanismen benötigen Rechenleistung, um Fehler zu detektieren und zu korrigieren. Dies kann die CPU-Last erhöhen und zusätzlichen Speicherplatz beanspruchen.
• Vorteile:
  • Fehler werden tatsächlich behoben, was die Integrität und Zuverlässigkeit der Daten erhöht.
  • Eignet sich gut für Systeme, bei denen Datenkorrektur notwendig ist (z.B. Speicher- und Kommunikationseinrichtungen).
• Nachteile:
  • Längere Prozesszeiten können zu Verzögerungen führen, was in zeitkritischen Systemen problematisch ist.
  • Erhöhte CPU-Auslastung und zusätzlicher Ressourcenverbrauch.

Vergleich und Szenarien:

• Szenarien für Fehlermaskierung:
  • In Anwendungen, wo kontinuierliche Verfügbarkeit und Sofortreaktionen wichtig sind, wie in Luftfahrt-, Raumfahrt- und medizinischen Geräten.
  • Systeme, bei denen eine schnelle Fehlerneutralisierung die höchste Priorität hat und Hardwarekosten akzeptabel sind.
• Szenarien für Fehlerkorrektur:
  • In Anwendungen, die Datensicherheit und -integrität erfordern, wie in Datenspeichersystemen oder Netzwerkanwendungen.
  • Systeme, die mit längeren Verarbeitungszeiten und zusätzlichem Ressourcenverbrauch umgehen können.

Fazit:Die Wahl zwischen Fehlermaskierung und Fehlerkorrektur hängt von den spezifischen Anforderungen des Echtzeitsystems ab. Wenn minimale Reaktionszeit und Betriebskontinuität entscheidend sind, wird Fehlermaskierung bevorzugt. Wenn hingegen Datenintegrität und Fehlerkorrektur entscheidend sind, kommt die Fehlerkorrektur zum Einsatz.