Multi-Core Programmierung für Embedded Realtime Systeme

Marwan Abu-Khalil

Kurzinformationen

04. Juni 2018 - 06. Juni 2018

München
€ 2090.00 zzgl. MwSt
€ 2487.10 inkl. MwSt

Neu

Auf Anfrage

Detailinformationen

Moderne Embedded-Realtime Systeme basieren auf Multi-Core CPUs, um den Performanceanforderungen von IoT und Edge-Computing zu genügen. In diesem Seminar wird die Parallele Programmierung von Grund auf erschlossen, und die Besonderheiten der Parallelität in Realtime-Systemen und in Embedded-Systemen werden erarbeitet. Die Teilnehmer lernen, parallele Software für Realtime-Systeme auf Multicore-CPUs zu entwerfen und zu programmieren. Das Seminar vermittelt sowohl den theoretischen Hintergrund als auch die konkrete praktische Anwendung. Die Seminarinhalte werden anhand realer Projektbeispiele vertieft und der Praxistransfer wird durch zahlreiche Programmierübungen sichergestellt.


Die herausragende Bedeutung der Parallelen Programmierung ergibt sich aus der Tatsache, dass für moderne CPUs nur noch geringe Taktratensteigerungen zu erwarten sind. Stattdessen steigt nur noch die Anzahl der Kerne in den CPUs an. Heute ist somit die stetig weitergehende Parallelisierbarkeit einer Software unabdingbare Voraussetzung für eine effiziente Performance und eine nachhaltige Skalierbarkeit. Dies gilt insbesondere im Embedded-Realtime-Bereich, in dem zwar seit jeher parallel programmiert wird, aber in der Vergangenheit oftmals Single-Core CPUs eingesetzt wurden. Multi-Cores sind jedoch der Schlüssel für die Teilhabe am Internet of Things (IoT) und für die Nutzbarkeit als  Edge-Computing Device: Erst durch die mit dem Multi-Core Einsatz einhergehende massive Performancesteigerung erschließen sich die, mit diesen Technologien verbundenen, Use-Cases und innovativen Geschäftsmodelle.


Da sich traditionelle Embedded-Realtime-Systeme mit ihren hardwarenahen Programmiertechniken jedoch oft implizit auf die sequentielle Abarbeitung auf einem Single-Core verlassen, ist diese Systemklasse durch die Multi-Core Revolution vor besondere Herausforderungen gestellt.


Um diesen Herausforderungen gewachsen zu sein, erarbeiten wir uns im Seminar den kompletten Software- Und Hardware-Stack der Parallelität. Wir beleuchten die klassische Thread-Programmierung, lernen Patterns für die Synchronisation und die Koordination anzuwenden, und wir untersuchen, welche der modernen Parallelitätsparadigmen, wie z.B. User-Mode Task-Scheduling, für den Einsatz in Realtime-Systemen geeignet sind. Wir lernen die Hardware-Grundlagen der Parallelität und der Synchronisation kennen, verstehen vor diesem Hintergrund die Relevanz von Spinlocks und Atomics, und wir lernen die Relaxed-Memory-Models der modernen Multi-Core Hardware zu handhaben.


Wir schauen uns an welche Auswirkungen prioritätsbasiertes Realtime-Scheduling auf das Verhalten von Threads hat, welche Features Realtime-Systeme für eine erfolgreiche Multi-Core Parallelität benötigen und wir lernen Realtime-Betriebssysteme (z.B. Realtime-Linux, VxWorks) und Realtime-Programmierumgebungen (z.B. Realtime-Java)  kennen.


Die Teilnehmer werden in die Lage versetzt, als Entwickler selbstständig sicheren und effizienten Code für parallele Realtime-Systeme zu entwickeln und als Architekten eigenverantwortlich Konzepte und Architekturen für parallele Software zu entwerfen und zu beurteilen.


Lernziele
Die Teilnehmer erlangen in diesem Seminar die folgenden Kompetenzen:

  • Parallele Programmierung in Realtime-Systemen mit Multicore-CPUs praktisch anwenden können
  • Risiken und Fallstricke der Parallelen Programmierung in ressourcenbeschränkten Embedded-Systemen kennen und vermeiden können
  • Aktuelle Parallelisierungstechnologien kennen und ihre Relevanz für Realtime-Systeme beurteilen können
  • Hardwarespezifika und Memory-Modelle aktueller Multicore-CPUs kennen und Maßnahmen für die Konsistenzsicherung beherrschen
  • Software-Architekturen und Migrationskonzepte für die Einführung von Multicore-CPUs in Embedded-Realtime-Systemen kennen und hinsichtlich ihrer Tragfähigkeit bewerten können


Themen
Das Seminar behandelt die folgenden Themenfelder:

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


1. Programmierung von Threads in Realtime-Systemen
Die Thread-Programmierung ist die Schlüsseltechnologie für die Parallelität und somit für die Ausnutzung einer Multicore-CPU. Im Seminar wird die Threadprogrammierung von Grund auf erschlossen und die wichtigsten Thread-APIs werden eingeführt (C++11, p-Threads, bei Bedarf auch Threads in Windows, Java, C#, VxWorks Tasks ). Die Besonderheiten von Realtime-Systemen und hardwarenahe Programmiertechniken für Embedded-Systeme werden gezielt herausgearbeitet. Prioritätsbasiertes Scheduling ist eine der zentralen Voraussetzungen für Realtime, es wird gezeigt, welche Risiken damit verbunden sind, und wie Architekten ihre Multi-Core Realtime Systeme effizient parallelisieren können.


Folgende Aspekte der Thread-Programmierung stehen im Mittelpunkt:

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 Realtime-Systemen (z.B. Priority-Inversion, Priority-Inheritance)

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

2. Moderne Parallelisierungsparadigmen in Realtime-Systemen
Moderne User-Mode Work-Stealing Task-Scheduler versprechen viele der Probleme klassischer Thread APIs zu lösen, und sie werden von den Betriebssystem-Herstellern in immer mehr Umgebungen unterstützt. Im Seminar wird die Programmierung mit solchen Task-Schedulern anhand von Standards für Embedded-Realtime Systeme (z.B. MTAPI) eingeführt.  Es wird aufgezeigt, für welche Architekturen und Anwendungsfälle dieses Paradigma geeignet ist und wo seine Grenzen und Risiken liegen.

3. 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 Embedded-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. Im Seminar werden Anwendung und Implementierungskonzepte von Spinlocks und Atomaren Instruktionen in Hardware und Software eingeführt und ihre Relevanz für Realtime-Systeme erläutert.

4. Software-Architekturen und Migrationskonzepte für Multicore-CPUs in Realtime-Systemen

Die meisten heute existierenden Realtime-Systeme basieren auf Software-Architekturen, die ursprünglich für Singlecore-CPUs entworfen wurden. Daher richtet das Seminar ein besonderes Augenmerk auf die Migration von Realtime Systemen von Single-Core auf Multi-Core CPUs. Es werden tragfähige Software-Architekturen und erfolgreiche Migrationspfade für den Umstieg auf Multi-Core-Hardware aufgezeigt. Dabei werden unterschiedliche Architektur-Paradigmen verglichen (z.B. SMP vs. AMP) und es wird anhand erfolgreicher sowie gescheiterter realer Projekte aufgezeigt, welche Architektur-Konzepte sich in der Praxis bewährt haben. Dabei werden Designaspekte auf allen Ebenen des Technologiestacks betrachtet (z.B. welche Synchronisationspatterns und welche Nebenläufigkeitskonzepte sich übertragen lassen und welche ersetzt werden müssen).

Abu-Khalil, Marwan

Marwan Abu-Khalil ist Senior-Software-Architekt für parallele und verteilte Systeme im Forschungsbereich der Siemens AG. Seit über 10 Jahren parallelisiert er Systeme vom Embedded-Device bis zum Server-Cluster. Er spricht regelmäßig auf Konferenzen über Parallelität. Er ist Ausbilder für zertifiziere Software-Architekten der Siemens AG.

Zielgruppe

Das Seminar richtet sich an Entwickler und Software-Architekten, die parallele Software für Realtime-Systeme auf Multicore-CPUs entwickeln oder dies für die Zukunft planen.
Es ist kein Vorwissen über Parallele Programmierung erforderlich.
Grundlagen der Softwareentwicklung und der Programmierung in einer der gängigen Programmiersprachen sind erforderlich, um die Codebeispiele und Übungsaufgaben zu verstehen.
Betriebssystem-Grundlagen sind hilfreich.
Das Seminar ist auch für Entwickler und Architekten von Nicht-Echtzeit-Systemen geeignet.

Hard- Software Voraussetzungen

Jeder Teilnehmer kann einen eigenen Laptop-Computer mitbringen, um die Programmierübungen zu bearbeiten.
Damit jeder Teilnehmer möglichst in seiner realen Umgebung übern kann, liegen die Programmierübungen und Musterlösungen in vielen APIs vor:
Die Realtime Übungen können in C++11 Threads, P-Threads und Realtime Java Threads bearbeitet werden.
Alle anderen Übungen können in folgenden APIs bearbeitet werden: C++11, P-Threads, Windows-API, Java, C#.

Sprachen

Seminar: Deutsch

Unterlagen: Deutsch

Methode

  • Das Seminar basiert auf umfangreichem Schulungsmaterial mit vielen Code-Beispielen.
  • Das Seminar ist interaktiv, die aktuellen Projekte der Teilnehmer werden thematisiert.
  • Teilnehmer können Kurzreferate zu ausgewählten Themen halten, Literatur wird bereitgestellt.
  • Der Praxistransfer wird durch zahlreiche Programmierübungen sowie konzeptionelle Übungen auf dem Papier sichergestellt.

Informationen

Unsere Leistungen - Sie erhalten:

  • Schulungsunterlagen als Printversion oder PDF (bei Seminaren mit Genehmigung durch den Referenten)
  • Ihr persönliches Teilnehmerzertifikat
  • Verpflegung während des Seminars
  • Ein 1-jähriges kostenloses Abonnement der Fachzeitschrift JavaSPEKTRUM oder OBJEKTspektrum
  • als Seminarteilnehmer sind Sie OOP-Alumni und erhalten 20% Rabatt auf den Teilnehmerpreis unserer jährlichen Fachkonferenz OOP!

Ihre Frühbucher-Vorteile gültig, bei einer Anmeldung bis 4 Wochen vor Seminarbeginn!

  • "sleep & training": 2 Übernachtungen + Frühstück im Tagungshotel inklusive!
    alternativ, wenn keine Hotelübernachtung benötigt wird:
  • "travel & training": 150 € Rabatt

Gruppenrabatt

Bei einer gleichzeitigen Anmeldung von 3-4 Mitarbeitern erhalten Sie 5% Gruppenrabatt, ab 5 Mitarbeitern erhöht sich der Gruppen-Rabatt auf 10%!

Inhouse-Seminare

Dieses Seminar ist auch als Inhouse-Schulung durchführbar. Schon ab einer kleinen Teilnehmerzahl von mind. 5 Mitarbeitern kalkulieren wir Ihnen gerne ein kostengünstiges Inhouse-Trainings-Angebot.

NRW-Bildungsscheck

SIGS-DATACOM ist zugelassener Bildungspartner des Landes NRW. Ihren NRW-Bildungsscheck für unsere Seminare einzulösen ist möglich! Weitere Informationen erhalten Sie unter:NRW Bildungsscheck!!