Cloud-Task-Parallelisierung in.net: Jenseits der lokalen Prozessor-Power

Transkript

1 Cloud-Task-Parallelisierung in.net: Jenseits der lokalen Prozessor-Power Prof. Dr. Luc Bläser Hochschule für Technik Rapperswil Parallel 2013, Karlsruhe 15. Mai 2013

2 Stufen der Parallelisierung Multi-core Multiprocessor Computer Network Processor Computer Computer Computer Core Core CPU GPU Core Core CPU Phi Computer Computer 2-16 Cores GPU: 512 Cores Xeon Phi: 61 Cores Beliebig, z.b Core Cluster Standard nebenläufige Programmierung Besondere verteilte Programmierung

3 Ziel: Parallelisierung in der Cloud Entfernte Rechenpower lokal einbinden Massive Parallelisierung in der Cloud Z.B. auf Cluster mit vielen Multi-Cores Nodes Möglichst nahtlos und einfach nutzbar Gleiches Programmiermodel wie für lokale Cores Keinen explizite Teilung von Client/Server-Code Cloud Cluster Client Compute Compute Compute Node Node Node

4 Cloud Task Parallelisierung in.net Parallele Tasks in.net programmieren Automatisch in Cloud senden und dort ausführen Cloud-Seite hat z.b. einen MS HPC Cluster.NET Program Parallel Tasks Runtime Extension.NET Runtime Task Parallelization Service HPC Cluster Node Node Node Node

5 Überblick Programmiermodell Laufzeitsystem Experimentelle Resultate Schlussfolgerungen

6 Klassische.NET Task Parallelisierung Mehrere Zahlen parallel faktorisieren var tasklist = new List<Task<long>>(); foreach (var number in inputs) { var task = Task.Factory.StartNew( () => _Factorize(number) ); tasklist.add(task); } foreach (var task in tasklist) { Console.WriteLine(task.Result); } TPL Task starten Task Delegate (Lambda) Ende abwarten vor Resultat long _Factorize(long number) { for (long k = 2; k <= Math.Sqrt(number); k++) { if (number % k == 0) { return k; } } return number; }

7 Neue Cloud-Task Parallelisierung Analog zu TPL var distribution = new Distribution(ServiceUri, Authorization); var tasklist = new List<DistributedTask<long>>(); foreach (var number in inputs) { var task = DistributedTask.New( Task erzeugen () => _Factorize(number) ); tasklist.add(task); } Mehrere Tasks distribution.start(tasklist); gebündelt starten foreach (var task in tasklist) { Console.WriteLine(task.Result); } Service angeben Library referenzieren: HSR.CloudTaskParallelism.Client.Runtime

8 Datenparallelität Klassische.NET Parallelisierung Parallel.For(0, inputs.length, (i) => { outputs[i] = _Factorize(inputs[i]); }); Neue Cloud Task Parallelisierung distribution.parallelfor(0, inputs.length, (i) => { outputs[i] = _Factorize(inputs[i]); });

9 Distributed Tasks Sehr ähnlich zu TPL Lediglich Import einer Library: Kein Compile-Schritt Gebündelter Task-Start Minimierung der Netz-Roundtrips Task als.net Delegate/Lambda Allgemeines Programmiermodell Tasks müssen unabhängig sein Disjunkte Fields/Array Element-Zugriffe (ausser Read-Only)

10 Task Unabhängigkeit Kein Informationsfluss Zwischen gleichzeitig laufenden Distributed Tasks Zwischen laufenden Distributed Tasks und.net Umgebung Isolationsprinzipien Gemeinsam zugegriffener Speicher nur lesend Sonst disjunkte Speicherzugriffe Granularität: Field und Array Elemente Vereinfacht Verteilung Gilt ebenso für nicht-synchronisierte.net Tasks Write/Write Konflikte werden vom Laufzeitsystem erkannt

11 Distributed Task API Starten von Distributed Tasks distribution.start(taskset) Warten auf Beendigung distribution.await(taskset) Starten mit Warte-Barriere distribution.invoke(taskset) ParallelFor, ParallelForEach

12 Einschränkungen By Design Keine Interaktion / Synchronisation unter Tasks Kein Task-Starts in Tasks Kein I/O oder Systemcalls in Tasks (Sicherheitsgründe) Kein Unmanaged Code (Sicherheitsgründe) By Implementation Bestimmte Sprachfeatures noch nicht unterstützt Laufzeitsystem wird stetig weiter ausgebaut Genaue Liste später

13 Laufzeitsystem 1. Task Code und Daten serialisieren Distributed Tasks 9. Changes im Speicher updaten Distributed Task Client Runtime 2. Task starten Task Code & Data Results & Changes 8. Task-Ende mitteilen Task Parallelization Service (HTTPS) 3. Auf Rechner verteilen 7. Task Enddaten aggregieren Distributed Task Server Runtime 4. Code und Daten deserialisieren 6. Resultate/Changes serialisieren 5. Code generieren und Tasks parallel ausführen

14 Task Serialisierung Potentiell ausführbarer Task-Code Konservative Code-Analyse Ausgehend von Task Delegate Direkt und indirekt aufrufbare Methoden Potentiell verwendete Klassen und Fields Potentiell verwendete Task-Daten Partieller Heap Snapshot Graph erreichbarer Objekte mit zugreifbaren Fields Zugreifbare statische Fields/Konstanten Konsistenz wegen Task Isolation

15 Task Updates/Results Rückgabe vom Server bei Task Ende Task Delegate Rückgabewert Änderungen an Objekten/statischen Daten Field Updates Array Element Updates Neu erzeugte Objekte In-Place Updates bei Client Auf entsprechende Objekte des Input-Snapshots Teilweise Data Race Detection Write/Write-Konflikte unter Tasks erkannt

16 Stand der Implementierung Für Distributed Tasks noch nicht unterstützt Vererbung, Interfaces, Delegates Struct und Nullable Typen Multidimensional Arrays Geschachtelte Arrays sind unterstützt Ref und Out Parameter Exceptions Task Canceling & Monitoring => Work in Progress

17 Runtime (sec) Performance-Skalierung Primfaktorzerlegung Sequential Parallel Distributed Input set size Factorize a set of predefined numbers; Minimum of 3 measurements; Client Intel 2 Core, 2.9 GHz; Service Intel 2 Core, 2.9 GHz; 64 Bit, with Compiler Optimization Cluster MS HPC 2012, 32 Nodes Intel Xeon 12 Core 2.6GHz; 100MBit/s network, 1ms delay

18 Performance Kostenanteile Primfaktorzerlegung (10 Zahlen) Task Serialization HPC Dispatch Runtime (sec) 18.4 Node Execution Network Transfer

19 Performance-Vergleiche Drei weitere Beispiele (Laufzeiten in Sekunden) Mandelbrot (10000 x 1000 pixels) Knight Tours (6 x 6 board) Primes Scanner (range 10 7 ) Minimum of 3 measurements; Client Intel 2 Core, 2.9 GHz; Service Intel 2 Core, 2.9 GHz; 64 Bit, with Compiler Optimization Cluster MS HPC 2012, 32 Nodes Intel Xeon 12 Core 2.6GHz; 100MBit/s network, 1ms delay

20 Runtime (sec) Parallele Beschleunigung Laufzeit abhängig zur Anzahl Cluster Nodes/Cores # Cores Factorization of 100 predefined input numbers Client Intel 2 Core, 2.9 GHz; Service Intel 2 Core, 2.9 GHz; 64 Bit, with Compiler Optimization Cluster MS HPC 2012, 32 Nodes Intel Xeon 12 Core 2.6GHz; 100MBit/s network, 1ms delay

21 Performance Diskussion Speedup Hohe Parallelität durch viele leistungsfähige Cores Overheads Übertragung zwischen Client und Backend Durchsatz (Datenmenge) und Latenz (Netzdistanz) Task Serialisierung/Deserialisierung Dispatchen der Cluster-Jobs Parallelisierung muss Overheads kompensieren Viele Tasks Rechenintensive Tasks Tasks mit wenig Datentransfer

22 Schlussfolgerungen Nahtlose verteilte Task-Parallelisierung in.net Prinzipiell gleiches Programmiermodel wie lokale Tasks Illusion des Shared Memory Models trotz Verteilung Keine explizite Entwicklung von Remote Code Keine explizite Übertragung oder Kommunikation Write/Write Race Detection als zusätzliche Sicherung

23 Related Work Microsoft Dryad LINQ Verteilte Paralleliserung von.net LINQ Ausdrücken Keine Seiteneffekte / Heap Updates erlaubt (ohne Checks) Actors, MPI Kommunizierende Agenten/Prozesse/Threads Explizite Kommunikation, kein Shared Memory Grid Computing Runtime über verschiedene Rechner Weniger nahtlos: spezielle Grid Heap/Threads, oft explizit serialisierbare Objekte, explizites Remoting usw.

24 Ausblick & Ideen Parallelization-as-a-Service Virtualisierung der reinen Prozessorressourcen On-Demand oder Pay-to-Go Parallelization Technische Erweiterungen Language Feature Set ausbauen Model-Erweiterungen (Cancel/First Fetch, Interaktionen)

25 Danke für Ihr Interesse Projektwebseite Kontakt Prof. Dr. Luc Bläser HSR Hochschule für Technik Rapperswil IFS Institut für Software Rapperswil, Schweiz