Klaus Rohe Developer Platform & Strategy Group Microsoft Deutschland GmbH klrohe@microsoft.com. Programmierung für Multicore CPUs

Transkript

1 Klaus Rohe Developer Platform & Strategy Group Microsoft Deutschland GmbH Programmierung für Multicore CPUs

2 Agenda Einleitung Free Lunch is over Multicore- und Multiprozessor-Architekturen Grenzen der Parallelisierung Parallelisierung und Programmarchitektur Parallelisierung durch Multithreading Allgemeine Probleme beim Multithreading Multithreading in.net Neue Konzepte in.net 4.0 Task Parallel Library PLINQ Ausblick & Zusammenfassung

3 Taktrate der Intel Prozessoren Problem: Abwärme ist nicht mehr beherrschbar bei Steigerung der Taktrate! Taktrate der einzelnen Cores nimmt ab! Das Prinzip mehr Arbeit in weniger Zeit funktioniert nicht mehr => Arbeit muss auf mehr Ressourcen verteilt werden! Quelle:

4 The Free Lunch is Over Applikationen werden nicht automatisch performanter, wenn man die nächste CPU Generation nimmt Normale Laptops und Desktops besitzen heute Multicore CPUs Singlethreaded Applikationen können nur einen Core nutzen Geringere Performance als auf hoch getackteten Single-Core Konsequenz: Softwareentwickler müssen Parallelisierung nutzen Multithreaded Software entwickeln ist sehr komplex!! Wie kann man die Entwicklung paralleler Programme vereinfachen? The Free Lunch Is Over, A Fundamental Turn Toward Concurrency in Software By Herb Sutter

5 Multiprozessor Architekturen SMP Architektur NUMA Architektur Prozessor Prozessor Prozessor Prozessor Prozessor Prozessor Prozessor Cache Cache Cache Cache Speicher Speicher Speicher Bus Prozessor Prozessor Prozessor Hauptspeicher Speicher Speicher Speicher Speicher Prozessor Prozessor Prozessor NUMA: Non Uniform Memory Access SMP: Symmetrical Multi Processor Speicher Speicher Speicher

6 Architektur von Multicore-Prozessoren (Intel Core 2 Duo) Core 2 Duo Processor Core 0 Core 1 Architektur-Ressourcen Architektur-Ressourcen Ausführungs-Ressourcen Ausführungs-Ressourcen L1-Caches L1-Caches Cache-Controller Cache-Controller Power-Management-Controller L2-Cache mit Controllern (shared) Bus-Schnittstelle und -Controller FrontSideBus Aus: T. Rauber, G. Rünger, Multicore: Parallele Programmierung, Heidelberg 2008, ISBN , Seite 15

7 Grenzen der Parallelisierung Das Amdahlsche Gesetz N: Zur Verfügung stehende Prozessoren. Bei der parallelen Implementierung eines Programms, bei der ein Zeitanteil 0 <= S <= 1 sequentiell ausgeführt wird, beträgt der maximal erreichbare Speedup: Speedup = 1 / (S + (1 S) / N) P = 1 S: parallel ausführbarer Zeitanteil des Programms Allgemeiner Grenzwert des Speedup: 1 / S

8 Veranschaulichung des Amdahlschen Gesetzes P S P P S Parallele Verarbeitung (5 Prozessoren) P P S P S Sequentielle Verarbeitung Zeit Nach,Joe Duffy, Concurrent Programming on Windows, Seite 763

9 Speedup Grafische Darstellung des Amdahlschen Gesetzes 26,00 24,00 22,00 20,00 18,00 16,00 14,00 12,00 10,00 Speedup (S = 0.01) Speedup (S = 0.2) Speedup (S= 0.5) S: sequentieller Anteil 8,00 6,00 4,00 2,00 0, Anzahl Prozessoren

10 Kritischer Pfad Unausgewogene Lastverteilung P P S P Effektiv Sequentiell S P P Zeit Nach,Joe Duffy, Concurrent Programming on Windows, Seite 765

11 Gustafson Amdahl Gesetz von Gustafson ( Amdahl optimistisch ) Fixed Size Model: Zeit = 1 S P Serielle Verarbeitung S P Zeit = S + P/N Parallele Verarbeitung Speedup = 1 / (S + P/N) Scaled Size Model: Zeit = S + P S P Hypothetische serielle Verarbeitung S Zeit = 1 P Parallele Verarbeitung: Speedup = S + N * P Nach:

12 Parallelisierung & Programmarchitektur Agent Task Daten Agenten sind Teile eines Programms, deren Zustand isoliert ist und die asynchron miteinander kommunizieren. Tasks sind Gruppen von Operationen (Methoden, Funktionen, ) die von Agenten parallel und asynchron ausgeführt werden können und die normal einen gemeinsamen Zustand besitzen. Daten: Dateien, Datenbanktabellen, Array, Listen oder Baumstrukturen im Hauptspeicher

13 Agenten, Tasks & Daten Send Agent A Reply Agent B Task A1 Task A2 Task An Task B1 Task B2 Task Bn Data A2 Data B2 Nach Joe Duffy, Concurrent Programming on Windows, Seite 7

14 Agenda Einleitung Free Lunch is over Multicore- und Multiprozessor-Architekturen Grenzen der Parallelisierung Parallelisierung und Programmarchitektur Parallelisierung durch Multithreading Allgemeine Probleme beim Multithreading Multithreading in.net Neue Konzepte in.net 4.0 Task Parallel Library PLINQ Ausblick & Zusammenfassung

15 Multithreading Unterstützung in modernen Programmiersprachen C/C++ Pthreads C#, Java, Python Allgemeine Konstrukte zum: Erzeugen von Threads Synchronisieren von Threads Sperren von Ressourcen, die von mehreren Threads gemeinsam genutzt werden Verwaltung von Threadpools

16 Probleme mit Multithreading Explicit multithreading ist komplex und problembehaftet: Zuverlässigkeit Race-Conditions Deadlocks Inkonsistentes Sperren von gemeinsamen Ressourcen und Serialisierbarkeitsprobleme Performance: Performanceprobleme durch zu extensives Sperren von gemeinsamen Ressourcen Probleme mit der Lastverteilung auf CPUs. Wie viele Threads müssen erzeugt werden, Alles Probleme, mit denen sich ein Programmierer aus Gründen der Produktivität nicht befassen sollte! Was gibt es schon heute für Möglichkeiten (im.net Framework) Multithreading zu vereinfachen?

17 Vereinfachtes Multithreading in.net Multithreading wird in.net vereinfacht: Erzeugen und Verwalten mit der ThreadPool Klasse Asynchrones Programmiermodell Methoden und Web-Services I/O Operationen, Datenbankzugriffe Asynchrone Ausführung zeitintensiver Methoden in GUIs: BackgroundWorker Klasse

18 BackgroundWorker in.net Agent A (UI Thread) bgw = new BackgroundWorker(); Register worker; Register workchanged; Register workcompleted; worker { } workchanged { } workcompleted { } button_click( ) { Agent B (BackgroundWorker Thread) worker { ReportProgress(); } bgw.runworkerasync(worker); }

19 Demo BackgroundWorker Klasse in.net

20 Agenda Einleitung Free Lunch is over Multicore- und Multiprozessor-Architekturen Grenzen der Parallelisierung Parallelisierung und Programmarchitektur Parallelisierung durch Multithreading Allgemeine Probleme beim Multithreading Multithreading in.net Neue Konzepte in.net 4.0 Task Parallel Library PLINQ Ausblick & Zusammenfassung

21 Getting the free lunch back Return of the free lunch for the multicore era: Wie kann man die Programmierung von Applikationen vereinfachen, die automatisch eine größere Anzahl an CPU-Kernen ausnutzen, die mit der nächsten Hardwaregeneration zu erwarten ist? Single Core Core1 Core2 Core1 Core2 Core3 Core1 Core2 Core3 Core4 Core5 Core4 Core6 Hardwaregeneration

22 Microsoft Parallel Computing Initiative Vereinfachte Entwicklung paralleler Programme auf der Microsoft Windows Plattform, die korrekt, effizient und wartbar sind, für alle Softwareentwickler Softwareentwickler Ermöglichen, Programme einfacher zu parallelisieren, damit sie sich auf die eigentliche Problemlösung konzentrieren können. Steigerung von Effizienz und Skalierbarkeit paralleler Programme Entwurf und Test paralleler Programme vereinfachen

23 Parallel Extensions To The.NET Framework 4.0 (kurz PFX).NET Bibliothek, keine Änderungen am Compiler Leichtgewichtig: User-Mode Unterstützt deklaratives und imperatives Parallelisieren von Daten und Tasks: Imperative data and task parallelism (Task Parallel Library) Declarative data parallelism (PLINQ) Coordination/synchronization constructs (Coordination Data Structures) Gemeinsames Exception-Handling Modell

24 Parallel Extensions To The.NET Framework 4.0 Warum benötigt man das alles? Bietet überschaubare Anzahl von Konzepten und reduziert die Komplexität für parallele Programmierung Ziel: Anwendungsprogrammierern die Entwicklung parallelisierbarer Programme zu vereinfachen! Anwendungsprogrammierer ist kein Experte für Multithreading und Parallelisierung!! Wann verfügbar: mit.net 4.0 CTP unter: D BDA4-94CF5F8D4814&displaylang=en

25 Architektur der Parallel Extensions.NET Program PLINQ Execution Engine Declarative Queries C# Compiler Parallel Algorithms Data Partitioning Chunk Range Hash Striped Repartitioning Query Analysis Operator Types Map Filter Sort Search Reduce Merging Sync and Async Order-Preserving ForAll VB Compiler C++ Compiler F# Compiler Other.NET Compiler PLINQ Task Parallel Library Loop replacements Imperative Task Parallelism Scheduling Threads Coordination Data Structures (CDS) Thread-safe Collections Synchronization Types Coordination Types IL TPL or CDS Proc 1 Proc p

26 Tasks Ein zentrales Konzept der Parallel Extensions (PFX) ist die Task: System.Threading.Tasks Führt eine Funktion in einem separaten Thread aus. class Program { static void Main(string[] args) { Console.WriteLine("\nThread id = {0} in Main. Thread.CurrentThread.ManagedThreadId); Task task = new Task(delegate { PrintPrimes(10); }); task.start(); task.wait(); } Console.Write("\nPress any key to exit!"); Console.ReadKey(); private static void PrintPrimes(ulong n) { Console.WriteLine("\nThread id = {1} in PrintPrimes({0}).\n", n, Thread.CurrentThread.ManagedThreadId); } } for (ulong i = 0; i <= n; i++) { if (PrimeFunctions.IsPrime(i)) Console.WriteLine("{0} is prime", i); }

27 Futures Ein Future ist eine Task mit einem Rückgabewert class Program { static void Main(string[] args) { Random rnd = new Random(); Task<int> task = new Task<int>(() => { Thread.Sleep(rnd.Next(1000, 10000)); return rnd.next(1, 43); }); task.start(); } } Console.WriteLine("Lottery in progress..."); Console.WriteLine(task.Result); Console.ReadKey();

28 Einfache parallele Ausführung Folge von Methodenaufrufen oder Programmstatements: Method_A(); Method_B(); Method_C(); Falls sie unabhängig sind, parallelisierbar: Parallel.Invoke( () => Method_A(), () => Method_B(), () => Method_C());

29 Parallele Schleifen In Programmschleifen wird häufig hohe CPU- oder IO-Last erzeugt for (int i = 0; i < n; i++) work(i); foreach (T e in data) work(e); Können parallelisiert werden, wenn die Iterationen unabhängig sind. Keine Veränderung globaler oder statischer Variablen, oder Abhängigkeit von lokalen Variablen, die in geschachtelten Schleifen verändert werden Parallel.For(0, n, i => work(i)); Parallel.ForEach(data, e => work(e));

30 TPL Parallel.For Beispiel // Sequentiell void SeqMatrixMult(int size, double[,] m1, double[,] m2, double[,] result) { for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { result[i, j] = 0; for (int k = 0; k < size; k++) { result[i, j] += m1[i, k] * m2[k, j]; } } } } // Mit TPL using System.Threading; void ParMatrixMult(int size, double[,] m1, double[,] m2, double[,] result) { Parallel.For( 0, size, delegate(int i) { for (int j = 0; j < size; j++) { result[i, j] = 0; for (int k = 0; k < size; k++) { result[i, j] += m1[i, k] * m2[k, j]; } } }); }

31 Die TaskManager Klasse TaskManager WorkerThread 01 WorkerThread 02 WorkerThread 03 Task01 Task06 Task04 Task02 Task03 Task04 Task05 Task07 Task08 Work stealing Task05 Task queues

32 Parallel LINQ (PLINQ) LINQ: Language Integrated Query class Person { public string Name { get; set; } public int Alter { get; set; } } Person[] Personen = { }; new Person {Name="Hans", Alter=35}, new Person {Name="Gustav", Alter=25}, new Person {Name="Peter", Alter=40}, new Person {Name="Karin", Alter=22} var ps = from p in Personen where p.alter < 40 select p; ps = from p in Personen.AsParallel() where p.alter < 40 select p; PLINQ abstrahiert von den Details der Parallelisierung Funktioniert für alle IEnumerable<T>

33 Coordination Data Structures (CDS) (1) Concurrent Collections Implementieren das Interface IConcurrentCollection<T> ConcurrentQueue<T>, ConcurrentStack<T> BlockingQueue Producer Thread 1 Consumer Thread 2 BlockingCollection<T> Blockiert, wenn Kapazitätsgrenzen unter- oder überschritten werden.

34 Coordination Data Structures (CDS) (2) SpinWait Busy waiting ist machmal kostengünstiger als auf Synchronisation durch den Kernel zu warten. SpinLock Basiert auf Spinning, kein Warten auf ein Kernel- Ereignis. Begründung s. o. SemaphoreSlim Leichtgewichte Semaphor Implementierung

35 Demo TPL PLINQ CDC

36 Agenda Einleitung Free Lunch is over Multicore- und Multiprozessor-Architekturen Grenzen der Parallelisierung Parallelisierung und Programmarchitektur Parallelisierung durch Multithreading Allgemeine Probleme beim Multithreading Multithreading in.net Neue Konzepte in.net 4.0 Task Parallel Library PLINQ Ausblick & Zusammenfassung

37 Existierende Applikationen?? Existierendes Programm Refactoring Multicore-fähiges Programm

38 Architekturmodell einer multicore-fähigen Applikation auf Windows (.NET 4.0)? Client mit Grafischer Benutzeroberfläche Task Task WCF service Task WCF service request Task WCF service request WCF service request request Named pipes Server Windows Communication Foundation (WCF) WCF Service WCF Service WCF Service WCF Service WCF Service WCF Service

39 Weitere Entwicklungen Neue Werkzeuge zum Entwerfen, Debuggen und Testen von parallelen Programmen in Visual Studio 10 Software Transactional Memory (STM) für die Synchronisation beim Zugriff auf gemeinsame Ressourcen Siehe auch: SXM, C# Software Transactional Memory (Microsoft Research) d-1c afaf-edb35f544384/details.aspx Weiterentwicklung der Concurrency & Coordination Runtime (CCR) und Decentralized Software Services (DSS)

40 Zusammenfassung Mulitcore ist Realität und Entwickler sollten analysieren, wie sie ihre Programme parallelisieren können. Grenzen werden durch die Gesetze von Amdahl und Gustafson beschrieben. Vereinfachte Konzepte für Multithreading sind heute schon verfügbar (sowohl unter.net, Java als auch ) Neue Möglichkeiten für vereinfachte Entwicklung von Multicore-fähigen Applikationen werden in Zukunft mit.net 4.0 verfügbar sein. Bestehende Anwendungen werden in den meisten Fällen Reengineering erfordern, um sie Multicore-fähig zu machen.

41 Weitere Informationen (1) Amdahl s & Gustafson s law: ahls.html Parallel Computing on msdn: Concurrency & Coordination Runtime (CCR) und Decentralized Software Services (DSS)

42 Weitere Informationen (2) PLINQ: Parallel FX team blog: Multicore Crisis? S. Gochman et al, Introduction to Intel Core Duo Processor Architecture, Intel Technology Journal, 10(2), Seite 89 97, 2006

43 Weitere Informationen (3) Joe Duffy, Concurrent Programming on Windows: Architecture, Principles, and Patterns, Addison Wesley, ISBN-13: , 958 Seiten esources.html M. Herlihy, Nir Shavit, The Art of Multiprocessor Programming, Morgan Kaufmann, ISBN-13: , 528 Seiten T. Rauber, G. Rünger, Multicore: Parallele Programmierung, Springer, ISBN: , 164 Seiten

44 COMPUTER ZEITUNG Multicore-Herausforderung liegt in der Programmierung, Von Walter F. Tichy/rr 39_ha_CZ.html?null&print=1

45 Vielen Dank! Fragen???