Verlässliche Systemsoftware (SS23, LSF: 042631)

Topic outline

• Allgemeines

  Collapse all Expand all
  • 

    Ankündigungen Forum
  • Eingebettete Systeme durchdringen praktisch alle Bereiche des täglichen Lebens. Immer häufiger übernehmen diese sicherheitskritischen Echtzeitsysteme Aufgaben, welche hohe Anforderungen an die funktionale Sicherheit stellen. Beispiele hierfür sind Fahrerassistenzsysteme in modernen Automobilen, medizinische Geräten, Prozessanlagen oder Flugzeugen. Fehlfunktionen in diesen Anwendungen ziehen mitunter katastrophale Konsequenzen nach sich: finanziell, materiell bis hin zu Personenschäden. Die Entwicklung sicherer und robuster Systeme gewinnt daher in der Forschung und Entwicklung zunehmend an Bedeutung.
    

  • Wichtige Hinweise zum Format der Lehrveranstaltung

    Die Veranstaltung findet im Sommersemester 2023 wieder in Präsenz statt.

    • Davon unberührt stehen Ihnen die Online-Materialien der Vorsemester uneingeschränkt zur Verfügung.
      
    • Aufgrund der Raumsituation ist die Teilnehmerzahl begrenzt, daher ist eine Voranmeldung in LSF zwingend erforderlich.
    • In der Veranstaltung werden Programmierkenntnisse in C/C++ vorausgesetzt. Einen Eindruck über den Ablauf der Übungen können Sie sich weiter unten machen.
    • Gruppenarbeit: Die Übungen werden in Dreiergruppen bearbeitet und in persönlichen Gesprächen (Präsenz oder Online) abgegeben. Die verteilte Versionsverwaltung git wird im Rahmen der Übungen vermittelt und dient als Kollaborations- und Abgabewerkzeug.
      
    • Die Laborarbeit in Form einer betreuten Rechnerübung findet Online oder in Präsenz statt.
    • In jedem Fall sollten sich Gruppen gemäß der Vorlieben (Präsenz/Online) homogen zusammenschließen.

    
    

    Anmeldung

    Bitte melden Sie sich in LSF an, bei Überbuchung erfolgt die Vergabe der Plätze nach der ersten Vorlesung im Losverfahren.
    

    
    
  • Voraussetzungen

    Die Veranstaltung ist inhaltlich weitgehend in sich abgeschlossen und für alle Studierenden mit einer Begeisterungsfähigkeit für praktische, systemnahe Informatik geeignet. Allgemein sind grundlegenden Betriebssystemkenntnissen, systemnaher Programmierung von eingebetteten Systemen und ein gewisses Durchhaltevermögen äußerst hilfreich.

    Für die Bearbeitung der Übungsaufgaben sind entsprechend grundlegenden Programmierkenntnissen in C und/oder C++ notwendig. Weiterhin sind grundlegende Erfahrungen im Umgang mit der Linux-Umgebung in den Pools beziehungsweise deren eigenständige Aneignung erforderlich.

    Selbsttest: Programmierkenntnisse

    Zur Einordnung der eigenen C-Kenntnisse haben wir einen kleinen Selbsttest zusammengestellt. Wenn Sie (mit etwas knobeln) die Fragen beantworten und auch die Programmieraufgabe lösen können, sollten keine handwerklichen Probleme mit den Übungsaufgaben haben und können sich voll auf die zu vermittelnden Konzepte konzentrieren. Fällt Ihnen die Beantwortung der Fragen schwer, sollten die fraglichen Programmierkonzepte und die Bedeutung der unbekannten Schlüsselwörter vor Belegung des Moduls nachrecherchiert werden, da diese nicht im Rahmen der Übung vermittelt werden können.

    (Quelltext: sensor.c)
    

  • 
    

    Termin für die Vorlesung
    

    • Zeit: Donnerstags, 12-14 Uhr (c.t.)
      
    • Ort: Raum 205 (OH16)
    • Achtung: Die Vorlesung startet erst am 13.04. (2. Woche)
      

    
    

    Termin für die Übung
    

    • Zeit: Mittwochs, 14-16 Uhr (c.t.)
      
    • Ort: Raum 205 (OH16)
    • Achtung: Die Übung startet erst am 19.04. (3. Woche)
      

    
    

    Termin für die Rechnerübung

    • Zeit: Donnerstags, 14-16 Uhr (c.t.)
    • Ort: Raum E07 (OH16)
    • Zugang zum Labor ausserhalb der Übung zu den normalen Bürozeiten jederzeit möglich
      

  • Dozent

    
    

    Prof. Dr. Peter Ulbrich

    
    

• Vorlesung
  • Inhalt der Vorlesung

    Die Veranstaltung Verlässliche Systemsoftware stellt Methoden und Techniken für die Entwicklung sicherheitskritischer Systeme aus Sicht der Systemsoftware (Betriebssystem- / Maschinenprogrammebene) in den Mittelpunkt. Ziel der Vorlesung ist die zuverlässige Entwicklung von Software (frei von internen Fehlern) ebenso wie die Entwicklung zuverlässiger Software (robust gegenüber äußeren Fehlern). Im Fokus steht hierbei weniger die Vermittlung von theoretischer Grundkenntnisse, sondern vielmehr deren praktischer Einsatz in Form von:

    • Fehlersuche und -vermeidung: funktional, räumlich und zeitlich,
    • unter Einsatz existierender Werkzeuge und Methoden wie sich auch in der Industrie zum Einsatz kommen.
    • Robuste Echtzeitsysteme durch Fehlertoleranz und Verteilung

    
    Auf diese Weise wird ein Fundament für die konstruktive Umsetzung verlässlicher Systeme gelegt werden. Dieses Modul vermittelt daher fundierte Anknüpfungspunkte für die Entwicklung verlässlicher (Echtzeit-)systeme.
    
    

    

  • Vorlesungsfolien

  • Kapitel	Vorlesung	Thema	Folien	Screencasts
    1	13.04.	1. Organisatorisches X. Was sind Echtzeitsysteme in 10 Minuten	Animiert | A4 Animiert | A4
    2	13.04.	2. Einleitung 2.1. Therac-25 2.2. Ariane 5 2.3. Mars Climate Orbiter	Animiert | A4	Video Video Video
    3	20.04.	3. Grundlagen 3.1. Begriffsdefinition: Fehler 3.2. Verlässlichkeitsmodelle 3.3. Fehler und Systementwurf 3.4. Software- und Hardwarefehler	Animiert | A4	Video Video Video Video
    4	27.04.	4. Fehlertoleranz durch Redundanz 4.1. Grundlagen 4.2. Strukturelle Redundanz 4.3. Umsetzungsalternativen und Beispiele 4.4. Diversität	Animiert | A4	Video Video Video Video
    5	04.05.	5. Codierung 5.1. Grundlagen 5.2. Arithmetische Codierung 5.3. Heterogener Einsatz von Redundanz	Animiert | A4	Video Video Video
    6	11.05.	6. Fehlerinjektion 6.1. Grundlagen 6.2. Fehlerinjektionstechniken 6.3. Auswertung und Interpretation	Animiert | A4	Video Video Video
    	18.05.	Christi Himmelfahrt
    7	25.05.	7. Dynamisches Testen 7.1. Testarten und Konzepte 7.2. Bewertung von Testfällen 7.3. Durchführung und Testumgebung	Animiert | A4	Video Video Video
    8	01.06.	8. Grundlagen der statischen Programmanalyse 8.1. Vom Testen zur Verifikation 8.2. Abstraktion der Programmsemantik 8.3. Analyse & Vereinfachung	Animiert | A4	Video Video Video
    	08.06.	Fronleichnam
    9	15.06.	9. Verifikation nicht-funktionaler Eigenschaften 9.1. Speicherverbrauch 9.2. Ausführungszeit
    10	22.06.	10. Verifikation funktionaler Eigenschaften: Design-by-Contract 10.1. Grundlagen 10.2. Formale Spezifikation 10.3. Praktische Überlegungen
    11	29.06.	11. Fallstudie Reaktorschutzsystem 11.1. Sizewell B
    12	06.07.	12. Zusammenfassung

  • 
    

    Literatur

  • Zur Begleitung und Vertiefung des Vorlesungsinhalts kann auf folgende Fachbücher zurückgegriffen werden:

    • Michael Lyu, editor. Software Fault Tolerance, volume 3 of Trends in Software. John Wiley & Sons, Inc., 1995. http://www.cse.cuhk.edu.hk/~lyu/book/sft/.
    • Shubu Mukherjee. Architecture Design for Soft Errors. Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 2008.
    • Olga Goloubeva, Maurizia Rebaudengo, Matteo Sonza Reorda, and Massimo Violante. Software-Implemented Hardware Fault Tolerance. Springer-Verlag, 233 Spring Street, New York, NY 10013, USA, 2006.

    Hierbei ist aber zu beachten, dass sich der Inhalt der Vorlesung nicht streng an einem dieser Bücher orientiert und sich keineswegs auf diese Bücher beschränkt. Die gezielte Aufarbeitung der einzelnen Vorlesungskapitel kann anhand der Literaturhinweise am Ende der jeweiligen Foliensätze erfolgen. Grundlegende Erläuterungen zu den Fachbegriffen und Grundtechniken fehlertoleranter Systeme sollten darüber hinaus in jedem Fachbuch vermittelt werden, das sich mit diesem Themengebiet befasst.

• Übungen
  • Ziel der Übung

    Analog zur Vorlesung befassen sich die Übungsaufgaben mit der zuverlässigen Entwicklung zuverlässiger Software. Im Rahmen eines Produktentwicklungszyklus werden in den Übungsaufgaben sowohl selbstgeschriebene als auch fremde Codestücke unter die Lupe genommen. Die Programmiersprache ist hierbei vorwiegend C. Als Vorraussetzung für die Übung sollte man deshalb grundlegende C-Kenntnisse mitbringen.

    Zuverlässige Software entwickeln

    Während der erste Teil sich auf das Finden von Entwicklungsfehlern konzentriert, betrachten wir in der zweiten Hälfte auch Fehler, die zur Laufzeit auftreten können. Hierzu zählen vor allem unerwartete Hardwarefehler, die den Programmfluss bzw. Rechenergebnisse beeinflussen können. In der Übung werden wir hierzu verschiedene konstruktive Maßnahmen kennenlernen und umsetzen, die die Software gegen derartige Fehlerszenarien härten können.

    Zuverlässig entwickeln

    Ein wesentlicher Bestandteil dieser Veranstaltung ist das Kennenlernen und der Umgang mit Werkzeugen, die die Entwicklung verlässlicher Systeme unterstützen. Hierzu zählen u.a.:

    • Versionsverwaltung von Quellcode mit Hilfe von git
    • Softwaretest mittels CMake und CTest
    • Codeüberdeckungsanalyse mittels gcov (lcov)
    • Überdeckungsorientiertes Fuzzing mittels libFuzzer
    • Statische Bestimmung des Speicherbedarfs (StackAnalyzer)
    • Statische Codeanalyse mit Hilfe abstrakter Interpretation (Astrée)

  • Helpdesk

    Der HelpDesk findet online in unserem Matrix-Raum #vss-helpdesk:fachschaften.org (z.B. via Matrix-Server der Fachschaft) statt. Dort steht euch asynchron ein Tutor zur Seite, um Fragen zu beantworten und Hilfestellungen zu geben. Sollte die Textform nicht als Kommunikationskanal ausreichen, besteht die Möglichkeit, auf unseren Raum auf unseren BigBlueButton-Server auszuweichen.

    Matrix

    Matrix ist ein föderiertes Chat-System. Unsere Fachschaft betreibt einen Server dieser Föderation auf fachschaften.org und hat ausführlich dokumentiert, wie dieser genutzt werden kann. Kurzfassung:

    • neuen Account auf account.fachschaften.org anlegen (oder auf irgendeinem anderen Server der Matrix-Föderation)
    • dem Veranstaltungsraum #vss-helpdesk:fachschaften.org (z.B. via Matrix-Server der Fachschaft) beitreten.

    
    
  • Übungsmaterial
    

    Der Großteil der Videos wurde im Sommersemester 2020 aufgezeichnet. Sofern nötig, wurden diese neu eingespielt. Sollten sich dennoch veraltete Daten oder ins SS20 verweisende Links in den Videos finden, bitte entsprechend durch SS23 ersetzen (und uns mitteilen).

  • Kapitel	Start	Thema	Folien	Screencasts
    1	19.04.	1. Versionsverwaltung mit git 1.0 Organisatorisches 1.1 Nachschlagewerk: Reguläre Übungsfolien Git by Example	Animiert | A4 Animiert | A4	Video
    2	26.04.	2. Softwareentwurf, Festkommaarithmetik und Schnittstellendesign 2.0 Prinzipien des Softwareentwurfs 2.1 C als standardisierte Programmiersprache 2.2 Festkommaarithmetik 2.3 Softwareentwurf am Beispiel eines einfachen Filters 2.4 Aufgabe2: Filterimplementierung mit Festkommaarithmetik	Animiert | A4 Animiert | A4 Animiert | A4 Animiert | A4 Animiert | A4	Video Video Video Video
    3	10.05.	3. Triple Modular Redundancy 3.0 Die Zahl 3 3.1 Replikation auf Quellcodeebene, Untersuchung von Binärdateien 3.2 Aufgabe 3: Triple Modular Redundancy Exkurs: Replikation in der Praxis Exkurs: Arbeiten mit Unixoiden Benutzerschnittstellen	Animiert | A4 Animiert | A4	Youtube Video Video Video Video
    4	10.05. & 17.05.	4. Kodierung und Fehlerraumanalyse 4.0 Untersuchung von Binärdateien im ELF Format 4.1 Fehlerinjektion (17.05.) 4.2 Implementierungsaspekte Arithmetische Codierung	Animiert | A4 Animiert | A4 Animiert | A4	Video Video
    5	31.05.	5. Testen 5.0 Dynamisches Testen 5.1 Exkurs: Werkzeuggestütztes Testen 5.2 Iteratorentwurf
    5	21.06.	6. Analyse und Verifikation funktionaler und nicht-funktionaler Eigenschaften 6.0 Verifikation Laufzeitfehler mittels Astrée 6.1 Funktionale Verifikation mittels Frama-C

  • 

    eCos Einführung - Codebeispiel für 2 Prozesse und 1 Alarm File
  • • eCos Dokumentation
      

• Übungsaufgaben
  • Nr	Übungsaufgabe	Ausgabe	Abgabe	Aufgabenblatt
    1	Versionsverwaltung mit git	19.04.	27.04.	PDF
    2	Filterimplementierung	26.04.	11.05.	PDF
    3	Triple Modular Redundancy	03.05.	25.05.	PDF
    4	Härtung mittels Codierung	11.05.	01.06.	PDF
    5	Dynamisches Testen	01.06.	22.06.
    6	Statsische Analyse	22.06.	06.07.