Programmierung für Multicore CPUsdownload.microsoft.com/download/2/D/E/2DE178B0-305E-4883...C#,...

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!

http://blog.mischel.com/2008/08/04/multicore-crisis



“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

http://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

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







PLINQ


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();…}

Demo

BackgroundWorker Klasse

in

.NET

AgendaEinleitung

Free Lunch is over







PLINQ


„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

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

Demo

TPL

PLINQ

CDC

AgendaEinleitung

Free Lunch is over







PLINQ


Existierende Applikationen??

Existierendes

Programm

Re

facto

ring

„Multicore-fähiges“

Programm

Architekturmodell einer „multicore-fähigen“ Applikation auf Windows (.NET 4.0)?

ServerWindows

Communication Foundation

(WCF)

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











http://www.microsoft.com/ccrdss/

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

http://en.wikipedia.org/wiki/Gustafson's_law





http://msdn.microsoft.com/en-us/concurrency/default.aspx



http://www.microsoft.com/ccrdss/

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

http://msdn.microsoft.com/en-us/magazine/cc163329.aspx




http://blogs.msdn.com/pfxteam/

http://blog.mischel.com/2008/08/04/multicore-crisis/



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

http://www.bluebytesoftware.com/books/winconc/winconc_book_resources.html

http://www.bluebytesoftware.com/books/winconc/winconc_book_resources.html

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





Vielen Dank!Fragen

???

Programmierung für Multicore CPUsdownload.microsoft.com/download/2/D/E/2DE178B0-305E-4883...C#,...

Documents

Transcript of Programmierung für Multicore CPUsdownload.microsoft.com/download/2/D/E/2DE178B0-305E-4883...C#,...