Multi-Core-Programmierung für Embedded Realtime Systeme

Marwan Abu-Khalil

Kurzinformationen

28. Okt. 2019 - 30. Okt. 2019

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

Die Seminarinhalte

  • Parallelisierung von Multi-Core Realtime-Systemen
  • Software-Architekturen für Realtime-Parallelität
  • Threads in Multi-Core Realtime-Systemen effizient programmieren
  • Migrationsprojekte von Single-Core zu Multi-Core mit embedded Realtime-Systemen durchführen
  • Memory-Modelle aktueller Multi-Core-Hardware sicher handhaben


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.

Seminarziel

In embedded Realtime-Systemen ist die effiziente Multi-Core Programmierung der Schlüssel zu  einer guten Performance. In diesem hands-on Seminar wird der gesamte Software-Hardware-Stack für die Parallelität in Realtime-Systemen von Grund auf erschlossen. Sie lernen Realtime-Betriebssysteme und Paradigmen der Realtime-Parallelität zu bewerten, um auf dieser Basis die richtigen Technologien und Architekturen für Ihr System auszuwählen.

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.

Voraussetzungen

Jeder Teilnehmer sollte einen Laptop für die Programmierübungen mitbringen. Darauf installiert sein muss die Virtualisierungssoftware:

Oracle Virtual Box.

Kostenloser Download hier:

http://www.oracle.com/technetwork/server-storage/virtualbox/downloads/index.html#vbox

Im Kurs wird ein Virtual-Box Image zur Verfügung gestellt, das alle Übungen und Lösungen enthält.

Die Non-Realtime Übungen können alternativ auch nativ auf dem PC  in C++ 11,  C# oder Java bearbeitet werden, dafür ist eine der beiden folgenden Umgebungen erforderlich:

-          Visual Studio 2012 oder neuer

Oder: 

-          Java 7 oder neuer, eventuell mir Eclipse-Installation

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!!

Disclaimer

Wir sind für die eigenen Inhalte, die wir zur Nutzung bereithalten, nach den allgemeinen Gesetzen verantwortlich. Von diesen eigenen Inhalten sind Querverweise (externe Links) auf die von anderen Anbietern bereit gehaltenen Inhalte zu unterscheiden. Diese fremden Inhalte stammen nicht von uns und spiegeln auch nicht unsere Meinung wider, sondern dienen lediglich der Information. Wir machen uns diese Inhalte nicht zu eigen und übernehmen trotz sorgfältiger inhaltlicher Kontrolle keine Haftung für die Inhalte externer Links. Für den Inhalt der verlinkten Seite sind ausschließlich deren Betreiber verantwortlich.