Multi-Core Programmierung für Realtime-Systeme

Realtime Parallelität spielt heute eine immer größere Rolle, da sich im allgemeinen IoT-Trend die Realisierung solcher Systeme nicht mehr nur auf den Embedded Bereich beschränkt sondern mit Realtime Linux auch auf vielen Edge Servern zu finden ist. 

In diesem praxisnahen Seminar lernen Sie Realtime-Programmierung auf Basis prioritätsbasierter Betriebssysteme und Mulitcore-CPUs für Ihre Projekte mit den C++ und P-Thread APIs effizient umzusetzen. 

Wir beginnen mit den Grundlagen der Parallelen Programmierung wie Threads und Synchronisation, und schauen uns dann an, was sich ändert, wenn wir vom gewohnten Zeitscheiben-Scheduling auf ein „hartes“ prioritätsbasiertes Realtime-Scheduling wechseln. Wir sehen, welche spezifischen Herausforderungen (z.B. Priority Inversion) sich in einem Realtime-Umfeld ergeben und wie diese bewältigt werden können. Migrationskonzepte von Single- auf Multicore-CPUs und hardwarenahe Themen wie Memory Model und Memory Barriers ermöglichen Ihnen die direkte Anwendung des Gelernten in Ihren Projekten.

Lernziele sind:

• Grundlagen und praktische Anwendung der Parallelen Programmierung beherrschen
• Umgang mit den relevanten APIs in C++ / C beherrschen
• praktische Auswirkungen des prioritätsbasierten Realtime-Scheduling verstehen
• Eigenschaften aktueller Multi-Core CPUs und deren Memory-Modelle kennen
• Migrationskonzepte für die Einführung von Multi-Core-CPUs in Realtime-Systemen bewerten können

Methodik

• Das Seminar ist interaktiv, die aktuellen Projekte der Teilnehmer werden thematisiert.
• Der Praxistransfer wird durch zahlreiche Programmierübungen sichergestellt (C++ mit Realtime-Linux ).

• Entwickler und Software-Architekten, die parallele Software für Realtime-Systeme mit Multi-Core-CPUs entwickeln oder dies planen
• kein Vorwissen über Parallele Programmierung erforderlich
• auch für Entwickler von Nicht-Echtzeit-Systemen geeignet

Montag, 18. und Dienstag, 19. November 2024
9.00 bis 12.15 und 13.15 bis 17.00 Uhr

Folgende Themenfelder werden behandelt:

1. Programmierung von Threads in Echtzeit-Systemen
2. Hardwarenahe Aspekte der Parallelität in Multicore-CPUs
3. Software-Architekturen und Migrationskonzepte für Multicore-CPUs in Echtzeit-Systemen

1. Programmierung von Threads in Echtzeit-Systemen

Die Thread-Programmierung ist die Schlüsseltechnologie für die Parallelität und somit für die Ausnutzung einer Multicore-CPU. Die Thread-Programmierung wird von Grund auf erschlossen und die für Realtime-Systeme wichtigsten Thread-APIs werden eingeführt (C++11 Threads, p-Threads). Die Besonderheiten von Echtzeit-Systemen und hardwarenahen Programmiertechniken für Embedded-Systeme werden gezielt herausgearbeitet.

1.1 Parallelität

• Performancesteigerung durch Parallelisierung von Algorithmen
• Performance durch Parallelisierung auf der Ebene der Software-Architektur
• Risiken und Kosten von Threads in ressourcenbeschränkten Embedded-Systems
• Besonderheiten der Parallelität bei prioritätsbasiertem Realtime-Scheduling

1.2 Synchronisation

• Einsatz und Implementierungskonzepte von Synchronisationsprimitiven auf allen Ebenen des Hardware-Software Stacks (z.B. Mutex, Semaphor, Spinlock)
• Ziele der Synchronisation (Datenkonsistenz)
• Risiken der Synchronisation (z.B. Deadlock, Performance-Kosten)
• Spezifika der Synchronisation in Echtzeit-Systemen (z.B. Priority-Inversion, Priority-Inheritance)

1.3 Koordination

• Producer-Consumer-Szenarien
• Ablaufsteuerungen mit dem Monitor-Pattern
• Semantik der Condition-Variable

2. Hardwarenahe Aspekte der Parallelität in Multicore-CPUs

• Um sichere, effiziente und vorhersagbare Software für Multicore-CPUs zu entwickeln, ist es gerade für hardwarenahe Entwickler unabdingbar, die Konzepte der Memory-Modelle dieser CPUs zu kennen („Relaxed Consistent Memory Models“). Alle modernen Multicore-CPUs erlauben in gewissem Maße unerwartete Umsortierungen des Programmablaufs beim Zusammenspiel mehrerer Threads, wenn keine geeigneten Maßnahmen in der Software getroffen werden. Im Seminar werden die typischen Memory-Modelle aktueller Multicore-CPUs eingeführt (ARM, Intel), und es wird gezeigt, wie sich auf Software-Ebene die Konsistenz der Speicherzugriffe herstellen lässt (Memory-Barrieres in RISC und CISC CPUs).
• Synchronisation und Locking sind ebenfalls nur mit Grundlagen in der Hardware zu verstehen und zu realisieren. Es werden Anwendung und Implementierungskonzepte von Spinlocks und atomaren Instruktionen in Hardware und Software eingeführt und ihre Relevanz für Echtzeit-Systeme erläutert.

3. Software-Architekturen und Migrationskonzepte für Multicore-CPUs in Echtzeit-Systemen

• Die meisten heute existierenden Echtzeit-Systeme basieren auf Software-Architekturen, die ursprünglich für Singlecore-CPUs entworfen wurden. Viele dieser Systeme müssen in naher Zukunft auf Multicore-CPUs migriert werden. Tragfähige Software-Architekturen und erfolgreiche Migrationspfade für den Umstieg von Singlecore- auf Multicore-Hardware werden aufgezeigt. Dabei werden unterschiedliche Architektur-Paradigmen verglichen (z.B. SMP vs. AMP) und es wird anhand erfolgreicher sowie gescheiterter realer Projekte aufgezeigt.