---

Zielgruppe:

Software-Entwickler, Software-Architekten, Projektleiter

Voraussetzungen:

Kenntnis der Programmiersprache C

Dauer:

3 Tage

Kursziel:

Dieser Kurs zeigt, wie die Prozessorleistung von Linux-Systemen - insbesondere bei modernen Multicore-Architekturen - bestmöglich genutzt werden kann. Er richtet sich an Softwareentwickler, die neue Applikationen entwickeln oder existierende Anwendungen optimieren müssen, und eignet sich insbesondere auch für die Anwendung unter Embedded Linux. Schwerpunkt des Kurses ist die Vorstellung des Pthread-APIs der NPTL-Bibliothek (Native Posix Threads Library). Dabei wird nicht nur der Funktionsumfang der Threadbibliothek eingehend behandelt, sondern auch auf mögliche Probleme und Lösungen, sowie auf Richtlinien für einen guten Softwareentwurf eingegangen. Darüber hinaus zeigt der Kurs aber auch, um wie viel einfacher eine Multithread-Applikationsentwicklung mithilfe von OpenMP sein kann, und bietet somit einen Einblick in eine völlig andere Art der Softwareentwicklung für Multithreading-Systeme.

---

Inhalt:

Einführung

• Prinzipielle Funktionsweise eines Threads
• Zuordnung von Code und Daten
• Threads vs. Prozesse
• Der Posix Standard und das Pthread API
• Das NPTL-Thread-Modell
• Schedulingkonzepte
• Threadzustände

Threads

• Threaderzeugung
• Parameterübergabe und Returnwerte
• Threadattribute
• Prioritäten und Scheduling
  • Time Sharing
  • Realtime
• Threads und Signale
• Threadlokaler Speicher
• Threadbeendigung

Synchronisation

• Flag-Synchronisation
• Race Conditions
• Mutexe
  • Rekursiver Zugriff
  • Deadlocks
  • Prioritätsinversion
  • Ceiling-Priorität
  • Fairness
• Reader-/Writer-Locks
• Semaphore
• Condition Variable
• Barrieren
• Einmal-Initialisierung

Multicore-Programmierung

• Wann lohnt sich Multicore?
• Amdahl’sches Gesetz
• Ansätze zur Leistungsoptimierung
• False Sharing
• Prozessor-Affinität
• Spinlocks
• Richtlinien für einen guten Applikationsentwurf

OpenMP

• Was ist OpenMP?
• Beispiel: Multithreadprogrammierung ohne (explizite) Threads
  
  

Nicht genau was Sie suchen?

Zielgruppe:

Softwareentwickler, die die Möglichkeiten der C++-Bibliothek nutzen wollen, um Multithread-Applikationen zu entwickeln.

Aufgrund der stetig zunehmenden Verbreitung von Multicore-Systemen ist dieses Training insbesondere für Entwickler geeignet, die ihre Applikationen parallelisieren wollen, um von dem Leistungszuwachs zusätzlicher Prozessorkerne profitieren zu können.

Voraussetzungen:

Gute Kenntnisse der Programmiersprache C++98 (einschließlich Templates).

Kenntnisse der (sonstigen) C++11-Spracheigenschaften sind vorteilhaft, aber keine Voraussetzung für den Kurs. Die anderen Spracheigenschaften von C++11, C++14, C++17 und C++20 werden im Kurs "Modernes C++" behandelt.

Dauer:

3 Tage (mit praktischen Übungen)

Kursziel:

Seit der C++11-Standard verfügbar ist, können Multithread-Applikationen auch plattformunabhängig direkt in C++ entwickelt werden. Dieser Kurs zeigt, welche Multithread-Eigenschaften die C++-Standardbibliothek seit Einführung der Standards C++11, C++14 and C++17 zur Verfügung stellt und wie diese angewendet werden können.

Die im Standard vorgesehenen Multithread-Funktionen sind üblicherweise nicht in der C++-Bibliothek selbst realisiert, sondern werden auf ein zugrunde liegendes Betriebssystem abgebildet. Für die richtige Anwendung benötigt man deshalb ein gutes Allgemeinverständnis der Threading-Modelle von Betriebssystemen, sowie deren Einflüsse auf das Verhalten einer Applikation. Deshalb geht der Kurs gezielt auf diese Thematik ein und bietet somit auch Entwicklern ohne Multithread-Erfahrung einen idealen Einstieg in die Multithread-Technologie.

---

Inhalt:

Einführung

• Multithreading-Grundlagen
• Threading-Modelle
• Single- und Multicoresysteme
• Nebenläufigkeit und Parallelität

Threadmanagement

• Erzeugen von Threads
• Parameterübergabe
• Thread-Identifikation
• Hintergrund-Threads
• Thread-Ablaufsteuerung
• Beenden von Threads

Zeitmanagement

• Absolute/relative Zeiten
• Timeouts

Sichere Nutzung von Ressourcen

• Sichere Initialisierung
• Threadlokaler Speicher
• Atomarer Speicherzugriff
• Mutexe
• Locks
• Deadlocks
• Condition Variable
• Nichtblockierender Zugriff

Asynchrone Operationen

• Futures
• Promise
• Packaged Task
• async

Praktische Übungen

Nicht genau was Sie suchen?

Zielgruppe:

Software-Entwickler, Software-Architekten, Projektleiter

Voraussetzungen:

Kenntnis der Programmiersprache C. Da auch viele C++-Beispiele gezeigt werden, sind C++-Kenntnisse hilfreich, aber nicht Voraussetzung. Somit eignet sich dieser Kurs auch für Teilnehmer, die ausschließlich mit C programmieren.

Dauer:

3 Tage (mit praktischen Übungen)

Kursziel:

Dieses Training zeigt, wie die Eigenschaften von Multitask-/Multithread-Systemen eingesetzt werden können bzw. welche Probleme gelöst werden müssen, um die Prozessorleistung, insbesondere bei modernen Multicore-Systemen, bestmöglich nutzen zu können. Es richtet sich an Entwickler, die existierende Applikationen optimieren, oder neue Applikationen entwerfen und implementieren müssen. Die Themen werden allgemeingültig behandelt, so dass das erworbene Wissen prinzipiell auf jede Multithreading- oder Multitasking-Plattform anwendbar ist. Gleichzeitig werden die Lehrinhalte durch eine Fülle von C- und C++-Code-Beispielen konkretisiert. Dabei werden sowohl plattformspezifische Lösungen, basierend auf Windows, Linux und RTEMS, als auch plattformunabhängige Lösungen auf Basis der C++-Multithread-Bibliothek vorgestellt, die seit C++11 zur Verfügung steht.

Inhalt:

MultithreaD-/MULTICORE Grundlagen

• Konzept Task/Thread (allg. Thread)
• Thread vs. Prozess
• Zuordnung von Code und Daten
• Scheduler und Thread-Zustandsmodell
• Allgemeine Schedulingmodelle
• Grunsätzliche Schedulingmechanismen
• Singlecore-/Multicore-Multithreading

Thread-Programmierung

• Threads und Funktionen
• Threads und Objekte
• Erzeugen und Starten von Threads
• Der Stack eines Threads
• Threadpriorität
• Sonstige Konfigurataionsparameter
• Parameterübergabe
• Thread-Beendigung
• Threadlokaler Speicher (TLS)
• Thread-Unterbrechung (Signale, Asynchrone Service Routinen)
• Thread-Terminierung (Thread-Cancellation)

Synchronisation

• Synchronisation mit Flag
• Volatile
• Speichermodell
• Speicherbarrieren
• Polling
• Ereignissynchronisation (Events)
• Zugriffssynchronisation (Mutexe)
• Atomare Operationen
• Typische Probleme und Lösungsansätze
• Deadlocks und Livelocks
• Mutex-Implementierungsdetails mit Laufzeitauswirkungen
• Zugriff auf Ressourcen mit mehreren Einheiten (Semaphore)
• Ressource-Zugriff mit Ereignisauslösung (Condition Variable)
• Synchronisation von Threads mit Interrupt-Service-Routinen

Multicore-Programmierung

• Wann lohnt sich der Einsatz von Multicore?
• Laufzeitmessungen klassischer Lösungen für ein Synchronisationsproblem
• Lösung mithilfe von Task Variablen
• False Sharing
• Prozessor-/Thread-Affinität
• Spinlocks
• Portierung von Singlecore-Applikationen auf Multicore-Systeme
• Wichtige Kriterien für ein gutes Multithread-Design

praktische Übungen

 

Nicht genau was Sie suchen?