Upload
vunhu
View
224
Download
4
Embed Size (px)
Citation preview
Programmierung für
Multicore CPUs
Klaus RoheDeveloper Platform & Strategy GroupMicrosoft Deutschland [email protected]
AgendaEinleitung
Free Lunch is over
Multicore- und Multiprozessor-Architekturen
Grenzen der Parallelisierung
Parallelisierung und Programmarchitektur
Parallelisierung durch MultithreadingAllgemeine Probleme beim Multithreading
Multithreading in .NET
Neue Konzepte in .NET 4.0Task Parallel Library
PLINQ
Ausblick & Zusammenfassung
Taktrate der Intel Prozessoren
Das Prinzip „mehr Arbeit in weniger Zeit“ funktioniert nicht mehr =>
Arbeit muss auf mehr Ressourcen verteilt werden!
Quelle: http://blog.mischel.com/2008/08/04/multicore-crisis
Taktrate der einzelnen
Cores nimmt ab!Problem: Abwärme ist nicht mehr
beherrschbar bei Steigerung
der Taktrate!
“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 Sutterhttp://www.gotw.ca/publications/concurrency-ddj.htm
Multiprozessor Architekturen
Prozessor
Cache
Prozessor
Cache
Prozessor
Cache
Hauptspeicher
SMP Architektur
Prozessor
Cache
Bus
Speicher
Prozessor
Speicher
Prozessor
Speicher
Prozessor
Speicher
Prozessor
Speicher
Prozessor
Speicher
Prozessor
Speicher
Prozessor
Speicher
Prozessor
Speicher
Prozessor
Speicher
NUMA Architektur
•NUMA: Non Uniform Memory Access
•SMP: Symmetrical Multi Processor
Architektur von Multicore-Prozessoren(Intel Core 2 Duo)
Power-Management-Controller
L2-Cache mit Controllern (shared)
Bus-Schnittstelle und -Controller
Architektur-Ressourcen
Ausführungs-Ressourcen
L1-Caches
Cache-Controller
Core 0
Architektur-Ressourcen
Ausführungs-Ressourcen
L1-Caches
Cache-Controller
Core 1
FrontSideBus
Core 2 Duo Processor
Aus: T. Rauber, G. Rünger, Multicore: Parallele Programmierung, Heidelberg 2008, ISBN 978-3-540-73113-9, Seite 15
Grenzen der ParallelisierungDas 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
Veranschaulichung des Amdahlschen Gesetzes
S SP
P
P
P
P
P
S S
Zeit
Sequentielle
Verarbeitung
Parallele
Verarbeitung
(5 Prozessoren)
Nach,Joe Duffy, Concurrent Programming on Windows…, Seite 763
Grafische Darstellung des Amdahlschen Gesetzes
S: sequentieller Anteil
0,00
2,00
4,00
6,00
8,00
10,00
12,00
14,00
16,00
18,00
20,00
22,00
24,00
26,00
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32
Speedup (S = 0.01)
Speedup (S = 0.2)
Speedup (S= 0.5)
Anzahl
Prozessoren
Speedup
„Kritischer Pfad“Unausgewogene Lastverteilung
Nach,Joe Duffy, Concurrent Programming on Windows…, Seite 765
P
P
P
P
P
S S
Zeit
Effektiv Sequentiell
Gesetz von Gustafson („Amdahl optimistisch“)
S P
S P
Zeit = 1
Serielle Verarbeitung
Parallele Verarbeitung
Speedup = 1 / (S + P/N)Zeit = S + P/N
Fixed Size Model:
S P
S P
Zeit = S + PHypothetische
serielle
Verarbeitung
Parallele Verarbeitung:
Speedup = S + N * PZeit = 1
Scaled Size Model:
„Am
dahl“
„Gusta
fson“
Nach: http://www.scl.ameslab.gov/Publications/Gus/AmdahlsLaw/Amdahls.html
Parallelisierung & Programmarchitektur
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
Agent
Task
Daten
Agenten, Tasks & Daten
Nach Joe Duffy, Concurrent Programming on Windows…, Seite 7
Send
Reply
Task
A1
Task
A2
Task
An…
Data
A2
Task
B1
Task
B2
Task
Bn…
Data
B2… …
Agent A Agent B
AgendaEinleitung
Free Lunch is over
Multicore- und Multiprozessor-Architekturen
Grenzen der Parallelisierung
Parallelisierung und Programmarchitektur
Parallelisierung durch MultithreadingAllgemeine Probleme beim Multithreading
Multithreading in .NET
Neue Konzepte in .NET 4.0Task Parallel Library
PLINQ
Ausblick & Zusammenfassung
Multithreading
Unterstützung in modernen ProgrammiersprachenC/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
…
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?
Vereinfachtes Multithreading in .NET
Multithreading wird in .NET vereinfacht:
Erzeugen und Verwalten mit der ThreadPool Klasse
Asynchrones ProgrammiermodellMethoden und Web-Services
I/O Operationen, Datenbankzugriffe
Asynchrone Ausführung zeitintensiver Methoden in GUIs:
BackgroundWorker Klasse
BackgroundWorker in .NET
Agent A (UI Thread)
Agent B(BackgroundWorker Thread)
bgW = new BackgroundWorker();Register worker;Register workChanged;Register workCompleted;
worker { … }
workChanged { … }
workCompleted { … }
button_Click(…){
bgW.RunWorkerAsync(worker);
}
worker { …
ReportProgress();…}
AgendaEinleitung
Free Lunch is over
Multicore- und Multiprozessor-Architekturen
Grenzen der Parallelisierung
Parallelisierung und Programmarchitektur
Parallelisierung durch MultithreadingAllgemeine Probleme beim Multithreading
Multithreading in .NET
Neue Konzepte in .NET 4.0Task Parallel Library
PLINQ
Ausblick & Zusammenfassung
„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?
Core1
Core1
Core3
Core2
Core4
Core2
Core1
Core3
Core2
Core4
Core5
Core6
Hardwaregeneration
Single
Core
…
Microsoft Parallel Computing Initiative
Vereinfachte Entwicklung paralleler Programme auf der Microsoft Windows Plattform,
die korrekt, effizient und wartbar sind, für alleSoftwareentwickler
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
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
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.0CTP unter: http://www.microsoft.com/downloads/details.aspx?FamilyId=922B4655-93D0-4476-BDA4-94CF5F8D4814&displaylang=en
Architektur der Parallel Extensions
Task Parallel Library Coordination Data
Structures (CDS)
.NET Program
Proc 1 …
PLINQ Execution Engine
C# Compiler
VB Compiler
C++
Compiler
IL
Threads
Declarative
Queries Data Partitioning
Chunk
Range
Hash
Striped
Repartitioning
Operator Types
Map
Filter
Sort
Search
Reduce
Merging
Sync and Async
Order-Preserving
ForAll
Proc p
Parallel
Algorithms
Query Analysis
Thread-safe Collections
Synchronization Types
Coordination Types
Loop replacements
Imperative Task Parallelism
Scheduling
PLINQ
TPL or CDS
F# Compiler
Other .NET
Compiler
TasksEin 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);
}}
}
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();
}}
Einfache parallele Ausführung
Folge von Methodenaufrufen oder Programmstatements:
Falls sie unabhängig sind, parallelisierbar:
Method_A();Method_B();Method_C();
Parallel.Invoke(() => Method_A(),() => Method_B(),() => Method_C());
Parallele Schleifen
In Programmschleifen wird häufig hohe CPU- oder IO-Last erzeugt
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
for (int i = 0; i < n; i++) work(i);…foreach (T e in data) work(e);
Parallel.For(0, n, i => work(i));…Parallel.ForEach(data, e => work(e));
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];
}}
});}
Die TaskManager Klasse
TaskManager
WorkerThread 01 WorkerThread 02 WorkerThread 03
Task01
Task02
Task03
Task05
Task04
Task06
Task07
Task08
Task05
Task04
Work stealing
Task q
ueues
Parallel LINQ (PLINQ)
LINQ: Language Integrated Query
PLINQ abstrahiert von den Details der ParallelisierungFunktioniert für alle IEnumerable<T>
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;
Coordination Data Structures (CDS) (1)
Concurrent CollectionsImplementieren das Interface IConcurrentCollection<T>
ConcurrentQueue<T>, ConcurrentStack<T>
…
BlockingCollection<T>Blockiert, wenn Kapazitätsgrenzen unter- oder überschritten werden.
Consumer
Thread 2
Producer
Thread 1
BlockingQueue
Coordination Data Structures (CDS) (2)
SpinWait„Busy waiting“ ist machmal kostengünstiger als auf Synchronisation durch den Kernel zu warten.
SpinLockBasiert auf „Spinning“, kein Warten auf ein Kernel-Ereignis. Begründung s. o.
SemaphoreSlimLeichtgewichte Semaphor Implementierung
AgendaEinleitung
Free Lunch is over
Multicore- und Multiprozessor-Architekturen
Grenzen der Parallelisierung
Parallelisierung und Programmarchitektur
Parallelisierung durch MultithreadingAllgemeine Probleme beim Multithreading
Multithreading in .NET
Neue Konzepte in .NET 4.0Task Parallel Library
PLINQ
Ausblick & Zusammenfassung
Architekturmodell einer „multicore-fähigen“ Applikation auf Windows (.NET 4.0)?
ServerWindows
Communication Foundation
(WCF)
WCF ServiceWCF Service
WCF ServiceWCF Service
WCF ServiceWCF Service
Client mit
Grafischer
Benutzeroberfläche
Task
WCF service
request
Task
WCF service
request
Task
WCF service
request
Task
WCF service
requestNamed pipes
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)
http://research.microsoft.com/research/downloads/Details/6cfc842d-1c16-4739-afaf-edb35f544384/Details.aspx
Weiterentwicklung der Concurrency & Coordination Runtime (CCR) und Decentralized Software Services (DSS)
http://www.microsoft.com/ccrdss/#Product
Zusammenfassung
„Mulitcore“ ist Realität und Entwickler sollten analysieren, wie sie ihre Programme parallelisieren können.
Grenzen werden durch die Gesetze von Amdahl und Gustafsonbeschrieben.
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.
Weitere Informationen (1)
• Amdahl„s & Gustafson„s law:• http://en.wikipedia.org/wiki/Amdahl%27s_law
• http://en.wikipedia.org/wiki/Gustafson's_law
• http://www.scl.ameslab.gov/Publications/Gus/AmdahlsLaw/Amdahls.html
• Parallel Computing on msdn:• http://msdn.microsoft.com/en-us/concurrency/default.aspx
• Concurrency & Coordination Runtime (CCR) und Decentralized Software Services (DSS)• http://www.microsoft.com/ccrdss/#Product
Weitere Informationen (2)
• PLINQ:• http://msdn.microsoft.com/en-us/magazine/cc163329.aspx#S1
• Parallel FX team blog:• http://blogs.msdn.com/pfxteam/
• Multicore Crisis?• http://blog.mischel.com/2008/08/04/multicore-crisis/
• S. Gochman et al, Introduction to Intel Core Duo Processor Architecture, Intel Technology Journal, 10(2), Seite 89 – 97, 2006
Weitere Informationen (3)• Joe Duffy, Concurrent Programming on Windows:
Architecture, Principles, and Patterns, Addison Wesley, ISBN-13: 978-0-321-43482-1, 958 Seiten• http://www.bluebytesoftware.com/books/winconc/winconc_book_r
esources.html
• M. Herlihy, Nir Shavit, The Art of Multiprocessor Programming, Morgan Kaufmann, ISBN-13: 978-0-12-370591-4, 528 Seiten
• T. Rauber, G. Rünger, Multicore: Parallele Programmierung, Springer, ISBN: 978-3-540-73113-9, 164 Seiten
COMPUTER ZEITUNG 26.01.2009
Multicore-Herausforderung liegt in der Programmierung, Von Walter F. Tichy/rr
http://www.computerzeitung.de/articles/multicore-herausforderung_liegt_in_der_programmierung:/2009005/31800939_ha_CZ.html?null&print=1