O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Parallele Programmierung mit Visual Studio 2010 - Crashkurs

Book Description

Multicore-CPUs, die in den letzten Jahren in allen neuen Computern verbaut werden, beschleunigen ihren Rechner - aber nur, wenn die Anwendungen dafür optimiert sind. Dazu müssen Sie ihre Anwendungen mit Hilfe der parallelen Programmierung erstellen. Dieses Buch bietet einen strukturierten Einstieg in die Programmierung paralleler Anwendungen mit Visual Studio 2010. Es behandelt die TPL (Task Parallel Library) und allgemeine Konzepte der parallelen Programmierung in ausreichender Tiefe, damit Sie eigene Anwendungen für Multi-Core-Prozessoren optimieren können.

Table of Contents

  1. A Note Regarding Supplemental Files
  2. Vorwort
  3. Einleitung
    1. Für wen ist dieses Buch gedacht
    2. Für wen ist dieses Buch nicht gedacht
      1. Vorkenntnisse
    3. Aufbau dieses Buchs
      1. Der ideale Einstiegspunkt für Sie
    4. Konventionen und Besonderheiten dieses Buchs
    5. Systemanforderungen
    6. Beispieldateien zu diesem Buch
    7. Danksagung
    8. Support
    9. Bleiben Sie in Verbindung
  4. 1. Einführung in die parallele Programmierung
    1. Multicore-Programmierung
      1. Mehrfache Befehlsströme, mehrfache Datenströme
      2. Multithreading
      3. Synchronisierung
    2. Speedup
      1. Das Amdahlsche Gesetz
      2. Gustafsons Gesetz
    3. Entwurfsmuster
      1. Gleichzeitigkeit erkennen
        1. Das Task Decomposition-Muster
        2. Das Data Decomposition-Muster
        3. Das Group Tasks-Muster
        4. Das Order Tasks-Muster
        5. Das Data Sharing-Muster
      2. Algorithmische Struktur
      3. Unterstützende Strukturen
    4. Zusammenfassung
    5. Schnellreferenz
  5. 2. Aufgabenparallelität
    1. Einführung
      1. Threads
      2. Die Klasse Task
        1. Die Methode Parallel.Invoke
        2. Die Methode TaskFactory.StartNew
          1. Erzeugen Sie zwei Aufgaben für unterschiedliche Methoden und warten Sie, bis beide Aufgaben beendet wurden
          2. Erzeugen Sie zwei Aufgaben für unterschiedliche Methoden und warten Sie, bis die Aufgaben beendet wurden
        3. Die Methode Task.Start
      3. Func<TResult>-Delegaten verwenden
        1. Erzeugen Sie eine Aufgabe mithilfe eines Lambda-Ausdrucks
        2. Erzeugen Sie eine Aufgabe, die ein Daten-Objekt verwendet (in diesem Fall ein String)
    2. Unbehandelte Ausnahmen in Aufgaben
      1. Erzeugen Sie eine Aufgabe, die eine unbehandelte Ausnahme auslöst, und sammeln Sie diese mit der Methode Task.Wait ein
      2. Fangen und behandeln Sie die Ausnahmen dreier verschiedener Aufgaben
      3. Behandeln Sie Ausnahmen aus Aufgaben mittels einer Callback-Funktion
    3. Fallbeispiel: Sortieren
      1. Bubblesort
      2. Einfügesortieren
      3. Pivotsortieren
      4. Verwendung der Barrier-Klasse
      5. Überarbeitung der Pivotsortierung
    4. Aufgaben abbrechen
      1. Erzeugen Sie eine Aufgabe, die eine OperationCanceledException-Ausnahme auslöst
      2. Ein Beispiel
    5. Beziehungen zwischen Aufgaben
      1. Fortsetzungsaufgaben
        1. Erzeugen Sie eine Vorgänger- und eine Nachfolgeraufgabe und warten Sie, bis beide beendet sind
        2. Erzeugen Sie eine Vorgängeraufgabe und eine Nachfolgeraufgabe, in der Sie das Ergebnis des Vorgängers überprüfen
        3. Erzeugen Sie zwei Vorgängeraufgaben und überprüfen Sie die Ergebnisse beider Aufgaben im Nachfolger
        4. Setzen Sie die beschriebenen Szenarios in einer Anwendung um
      2. Eltern/Kind-Aufgaben
        1. Erzeugen Sie eine Aufgabe und eine Unteraufgabe
        2. Erzeugen Sie eine Eltern- und eine Kind-Aufgabe. Die Kind-Aufgabe soll ungefähr doppelt so lang zur Ausführung benötigen wie die Eltern-Aufgabe. Melden Sie den Status, den die Eltern-Aufgabe hat, wenn sie beendet wird.
      3. Die Work-Stealing-Warteschlange
    6. Zusammenfassung
    7. Schnellreferenz
  6. 3. Datenparallelität
    1. Sequenzielle Schleifen in parallele Aufgaben umwandeln
      1. Wann lohnt sich die Parallelisierung?
      2. Die parallele for-Schleife
        1. Erzeugen Sie eine Parallel.For-Schleife zur Reduzierung der Warenpreise
      3. Schleifen abbrechen
        1. Starten Sie eine Parallel.For-Schleife und brechen Sie sie vorzeitig ab
      4. Ausnahmen abfangen
      5. Abhängigkeiten
    2. Reduktion
      1. Reduzieren Sie eine Datenmenge auf einen Zählwert
      2. Reduzieren Sie eine Sammlung von ganzen Zahlen zu einer Folge von Fakultäten
    3. Verwendung des MapReduce-Entwurfmusters
      1. Erzeugen Sie eine Instanz von MapReduce, mit der Sie die Werte in einer Quellauflistung quadrieren und anschließend durch Aufaddierung der Schlüssel reduzieren
      2. Beispiel: Worthäufigkeiten
    4. Zusammenfassung
    5. Schnellreferenz
  7. 4. PLINQ
    1. Einführung in LINQ
      1. Erzeugen Sie eine LINQ-Abfrage und geben Sie das Abfrageergebnis aus
      2. PLINQ
        1. Führen Sie eine sequenzielle und eine parallele Abfrage auf einem Array von ganzen Zahlen aus. Benutzen Sie für die Where-Klausel die imperative Syntax.
    2. PLINQ-Operatoren und -Methoden
      1. Der ForAll-Operator
        1. Führen Sie eine parallele Abfrage auf einem string-Array aus
      2. ParallelExecutionMode
      3. WithMergeOptions
      4. AsSequential
      5. AsOrdered
      6. WithDegreeOfParallelism
    3. Ausnahmebehandlung
      1. Fangen Sie AggregateException-Ausnahmen in einer PLINQ-Abfrage ab und geben Sie das Abfrageergebnis aus
    4. Abbruch
    5. Reduktion
      1. Multiplizieren Sie mithilfe der ParallelEnumerable.Aggregate-Methode die korrespondierenden Elemente in zwei Matrizen und speichern Sie das Produkt in einer dritten Matrix
      2. Verwendung von MapReduce in PLINQ
    6. Zusammenfassung
    7. Schnellreferenz
  8. 5. Gleichzeitige Auflistungen
    1. Allgemeine Konzepte
      1. Das Producer-Consumer-Paradigma (Erzeuger-Verbraucher)
    2. Low-Level-Synchronisierung
      1. SpinLock
      2. SpinWait
        1. Zweiphasensynchronisierung
      3. ConcurrentStack
        1. Implementieren Sie mithilfe einer ConcurrentStack-Auflistung eine Klasse zum Protokollieren von Methodenaufrufen
      4. ConcurrentQueue
      5. ConcurrentBag
        1. Schreiben Sie eine Klasse, in der Sie die Liste der Kunden eines Ladens mithilfe einer ConcurrentBag-Auflistung verwalten
      6. ConcurrentDictionary
        1. Erzeugen Sie aus einem Array von ganzen Zahlen eine ConcurrentDictionary-Auflistung, wobei Sie die Zahlen als Schlüssel und die Anzahl der Vorkommen einer Zahl als Wert verwenden
      7. BlockingCollection
        1. Erzeugen Sie einen eigenen Thread, um Elemente aus einer BlockingCollection-Auflistung zu konsumieren
        2. Implementieren Sie das GetConsumingEnumerable-Modell zum Einfügen und Konsumieren von Elementen in und aus einer BlockingCollection-Auflistung
    3. Zusammenfassung
    4. Schnellreferenz
  9. 6. Eigene Implementierungen
    1. Gelegenheiten für eigene Implementierungen erkennen
    2. Eigene Producer-Consumer-Auflistungen
      1. Erzeugen Sie eine eigene Producer-Consumer-Auflistung, die identische Werte zusammenfasst
    3. Aufgaben-Partitionierer
      1. Führen Sie die Methoden in einem Array aus und geben Sie Meldungen aus, anhand deren sich erkennen lässt, welche Methode von welcher Aufgabe ausgeführt wird
      2. Verwenden Sie einen von der TPL erzeugten benutzerdefinierten Partitionierer, um ein Array von ganzen Zahlen mittels einer Parallel.ForEach-Schleife zu durchlaufen
    4. Fortgeschrittene Anwendungen für eigene Partitionierer
      1. Partitioner<TSource>
        1. Schreiben Sie einen eigenen Partitionierer, der den Partitionen eine immer größer werdende Blockgröße zuweist
      2. OrderablePartitioner<TSource>
    5. Eigene Taskplaner
      1. Der Kontext-Taskplaner
      2. Der Taskplaner
        1. Verwendung eines eigenen Taskplaners
        2. Erzeugen eines eigenen Planers
          1. Erzeugen Sie einen benutzerdefinierten Taskplaner, der Setup- und Cleanup-Methoden bereitstellt
    6. Zusammenfassung
    7. Schnellreferenz
  10. 7. Berichte und Debugging
    1. Debuggen mit Visual Studio 2010
      1. Livedebugging
      2. Post-Mortem-Analysen durchführen
      3. Threads debuggen
    2. Mit dem Fenster Parallele Aufgaben arbeiten
      1. Ermitteln Sie mithilfe des Parallele Aufgaben-Fensters die Ursachen eines Deadlocks
    3. Mit dem Fenster Parallele Stapel arbeiten
      1. Die Threadansicht
      2. Die Aufgabenansicht
    4. Mit dem Concurrency Visualizer arbeiten
      1. Die Ansicht CPU-Auslastung
      2. Die Ansicht Threads
        1. Die Berichte
      3. Die Ansicht Kerne
        1. Durchlaufen Sie eine Zahlen-Auflistung zuerst sequenziell, dann parallel und vergleichen Sie die Ergebnisse in der Ansicht Kerne
    5. Die Beispiel-Anwendung
    6. Zusammenfassung
    7. Schnellreferenz
  11. A. Über den Autor
    1. Donis Marshall
  12. Stichwortverzeichnis
  13. Copyright