PLINQ og Rx
-
Upload
jacinta-bernal -
Category
Documents
-
view
34 -
download
3
description
Transcript of PLINQ og Rx
PLINQ og Rx
Enkel parallellprogrammering og nyskapende eventhåndtering
BEKK Fagdag 20.11.2009
Åsmund Eldhuset
Agenda
Del 1 PLINQ (Parallel LINQ)
Del 2 Rx (Reactive Extensions)
Del 3 Progging!
Del 1 PLINQ (Parallel LINQ)
PLINQ (Parallel LINQ)
En del av Parallel Extensions for .NET 4.0 (et stort rammeverk for parallellprogrammering)
Gir SQL-aktig adgang til metoder for parallell behandling av sekvenser og spørringer
Egner seg for problemer som har dataparallellisme (den samme operasjonen gjøres på mange dataelementer)
Egner seg ikke for problemer som har oppgaveparallellisme (flere forskjellige operasjoner gjøres samtidig) - det har man andre konstruksjoner i Parallel Extensions for
En del overhead; lønner seg bare for tunge beregninger
AsParallel()
PLINQ er ekstremt enkelt i bruk: ta en eksisterende spørring og sett inn .AsParallel() etter datasettet
– Dette gir en IParallelQuery<T>, som implementerer IEnumerable<T> og har samme extension methods (Count(), ForAll(), GroupBy(), Sum(), Where() osv.)
Resten av spørringen ser ut som en vanlig LINQ-spørring
– Før: from i in data where i > 42 select 2 * i
– Etter: from i in data.AsParallel() where i > 42 select 2 * i
Kan også bruke funksjonssyntaksen:data.AsParallel().Where(i => i > 42).Select(i => 2 * i)
Merk: binære operatorer (f.eks. join / Join()) blir parallelle hvis og bare hvis den venstre datakilden er parallell
Deklarativ parallellisme
SQL og LINQ er deklarative språk
– Man sier hva man vil ha i stedet for hvordan man vil at det skal skje
Siden man slipper å spesifisere implementasjonsdetaljene, åpner dette for:
– Automatisk optimalisering av treet som representerer uttrykket (alle kompilatorer og databasemotorer gjør dette)
– Reordering
– Common subexpression elimination
– Automatisk parallellisering
– Optimalisering kan foregå både statisk og runtime
Vi skal se litt på hva som skjer bak kulissene
Lazy evaluation
Som i vanlig LINQ
– De fleste operatorer produserer ikke noe output før de blir bedt om det, og evaluerer ikke mer av inputen sin enn nødvendig
– Unntak: Sort() må evaluere hele inputen, og Join() må evaluere ett subtre
– Hvis du bare er ute etter sideeffektene av en spørring, tving gjennom evaluering ved f.eks. å kalle Last()
Prosesseringstyper
Pipelined processing
– Én consumer-tråd, mange producer-tråder
– Brukes av de fleste operatorene
Stop-and-go processing
– Alle trådene er producers og bygger opp resultatlisten; deretter vil én tråd iterere over resultatene
– Brukes av ToList(), ToArray() og Sort()
Inverted enumeration
– (Inntil) én tråd per element som skal behandles
– Brukes av ForAll()
http://msdn.microsoft.com/en-us/magazine/cc163329.aspx
Operatorparallellisme
Intraoperator / partisjonering
Interoperator / pipelining
Kombinering av disse
http://msdn.microsoft.com/en-us/magazine/cc163329.aspx
Thread 2
Thread 1
data
where p(x)
where p(x)
select f(x)
select f(x)
result
Thread 4Thread 3
Thread 2Thread 1
data
where p(x)
where p(x)
select f(x)
select f(x)
result
Thread 2Thread 1
data where p(x) select f(x) result
Gotcha: Resultatrekkefølge
Rekkefølgen på resultatelementene er ikkedeterministisk (åpner for bedre parallellisering)
Legg på .AsOrdered() etter .AsParallel() for å tvinge resultatene til å stå i samme rekkefølge som inputelementene de stammer fra
Gotcha: Exceptionhåndtering
Når en av PLINQ-trådene kaster en exception, dreper PLINQ alle trådene sine
– ...men før den rekker å gjøre det, har kanskje noen av de andre trådene også kastet exceptions
Dokumentasjonen påstår at uansett om én eller flere exceptions blir kastet, vil PLINQ pakke dem inn i en AggregateException, som har en InnerExceptions[]-property
– ...men så vidt jeg kan se, er det alltid den originale exceptionen som blir kastet
Uansett er det ofte best å håndtere exceptions inni predikatene, for å unngå at hele beregningen dør
Gotcha: Feilbruk av delt minne
Data som ligger utenfor datasettet kan aksesseres av flere tråder samtidig race conditions
Feil (men trygt, om enn tåpelig, i vanlig LINQ):int count = 0;var res = from i in data.AsParallel() where i % 2 == 0 select count++;res.Last(); // Force evaluation
Riktig #1 (ekstern synkronisering):int count = 0;var res = from i in data.AsParallel() where i % 2 == 0select Interlocked.Increment(ref count);res.Last();
Riktig #2 (utnytt LINQ sine operatorer):int count = (from i in data.AsParallel() where i % 2 == 0 select i).Count();
Del 2 Rx (Reactive Extensions)
Rx (Reactive Extensions)
Lar oss se på en event som en kilde som produserer en sekvens av objekter
– Hvert objekt inneholder informasjon om én trigging av eventen
– Sekvensen kan vi manipulere ved hjelp av f.eks. LINQ
Gjør enkelte former for eventhåndtering og asynkron programmering mye lettere og mer elegant
Nettopp releaset; begrenset med dokumentasjon (men mange blogginnlegg...)
Sekvensdiagram - IEnumerable<T> / IEnumerator<T>
Our thread
IEnumerator<T> IEnumerable<T>
GetEnumerator()
new
IEnumerator<T>
IEnumerator<T>
Current()
Get()
T
T
Sekvensdiagram - IObservable<T> / IObserver<T>
Our thread
GUI thread
IObserver<T> IObservable<T>
new
Subscribe(IObserver<T>)
IDisposable
OnNext(T)
IObserver<T>
(call some method from the actual class of the IObservable<T>)
(trigger event and pass the T instance)
IEnumerable<T> / IEnumerator<T>
interface IEnumerable<T> {IEnumerator<T> GetEnumerator();
}
interface IEnumerator<T> {T Current { get; } // Might throw exceptionbool MoveNext();
}
Omskriving
La oss prøve å lage de "motsatte" interfacene, ved å bytte om på parametre og returverdier
interface IEnumerable<T> {IEnumerator<T> GetEnumerator();
}
interface IDualEnumerable<T> {void SetDualEnumerator(IDualEnumerator<T>);
}
interface IObservable<T> {IDisposable Subscribe(IObserver<T> observer);
}
Omskriving
interface IEnumerator<T> {T Current { get; } // Might throw exceptionbool MoveNext();
} interface IDualEnumerator<T> {
T|Exception GetCurrent();bool MoveNext();
} interface IDualEnumerator<T> {
void SetCurrent(T|Exception);MoveNext(bool);
} interface IDualEnumerator<T> {
void SetCurrent(T);void SetException(Exception);MoveNext();
} interface IObserver<T> {
void OnNext(T value);void OnError(Exception exception);void OnCompleted();
}
IObservable<T> / IObserver<T>
interface IObservable<T> {IDisposable Subscribe(IObserver<T> observer);
}
interface IObserver<T> {void OnCompleted();void OnError(Exception exception);void OnNext(T value);
}
Hvordan lage observables
var obs = Observable.FromEvent<MouseEventArgs> (this, "MouseMove");
– Gir en IObservable<Event<MouseEventArgs>>
– LINQ behandler en IObservable<T> som en sekvens av T-instanser
var mouseMove = from mm in obs select new { mm.EventArgs.X, mm.EventArgs.Y };
– Gir en IObservable<'a>, hvor 'a er en new { int X, int Y }
Registrering og avregistrering
Vi kan nå subscribe til vår IObservable:
– mouseMove.Subscribe(e => Console.WriteLine("{0}, {1}", e.X, e.Y));
– Subscribe() er en extension method som lar oss oppgi et lambdauttrykk som så vil bli pakket inn i en IObserver
Typisk unsubscriber man en annen plass enn der man subscriber, og da er ikke from-resultatet tilgjengelig lenger
Subscribe() returnerer en IDisposable
– Dispose() på denne vil unsubscribe
Cross join av events
TODO
"Extension events"
Syntaksen for å få tak i en IObservable for en event er strevsom
Bør innkapsles i extension methods
internal static class ExtensionMethods {public static
IObservable<IEvent<MouseEventArgs>> GetMouseMove(this Control control) {
return Observable.FromEvent<MouseEventArgs>
(control, "MouseMove");}
}
Har også en alternativ overload av FromEvent<>()
http://themechanicalbride.blogspot.com/2009/07/developing-with-rx-part-1-extension.html
Timing
a.Until(b) spesifiserer at man bare er interessert i events fra a inntil det kommer en event fra b
– Gjør det enkelt å kansellere subscriptions når visse hendelser inntreffer
a.Delay(t)
– Venter i t millisekunder med å videresende events fra a
Observable.Return(x)
– Lager en sekvens med bare ett element: x
from a in eventAfrom b in Observable.Return(new Unit()) .Delay(1000).Until(eventB)select a
– Hver gang eventA utløses, vil vi få vite om den ett sekund senere - med mindre eventB utløses i mellomtiden
– (Unit er en slags void-verdi)
Kombinering av events
0 1 2
0 1
3 4
2
0 1 2
012 3 4
0 1 2 0 13 42
a
b
a.Merge(b)
a.Until(b)
a.WaitUntil(b)
a.Zip(b, func) 0 1 2
Asynkron programmering
Observable.ToAsync() lager en asynkron utgave av en funksjon
– Når den resulterende funksjonen kalles, får man en IObservable som produserer resultater når funksjonen blir ferdig
var sqrt = Observable.ToAsync<int, double> ((number) => Math.Sqrt(number));
from s in sqrt(42) ... Hvis koden som abonnerer på den asynkrone funksjonen skal
røre GUI'et, må du kalle s.SubscribeOnWindowsForms(this).Subscribe(...)
Del 3 Progging!
Installasjon
Rx for VS2008: http://msdn.microsoft.com/en-us/devlabs/ee794896.aspx
– Prosjekter trenger referanse til System.Reactive og System.CoreEx
Parallel Extensions for VS2008: http://www.microsoft.com/downloads/details.aspx?FamilyId=348F73FD-593D-4B3C-B055-694C50D2B0F3
– Prosjekter trenger referanse til System.Threading
Den utleverte koden og LF'ene kan sjekkes ut anonymt over SVN:svn co http://linqkurs.googlecode.com/svn/trunk/ linq
Rx: Oppgave 1 - Drag-and-drop
En drag-and-drop-operasjon består av følgende sekvens av events:
1. En MouseDown
2. Vilkårlig mange MouseMove
3. En MouseUp
Vi ønsker å abonnere på eventen "musebevegelse mens en drag-and-drop fopegår"
Bruk cross join og en passende extension method for å kombinere disse event-strømmene
...og gjør noe interessant (f.eks. tegne et punkt på skjermen) for hver slik musebevegelse
http://mnajder.blogspot.com/2009/08/and-drop-with-reactive-framework.html
Rx: Oppgave 2 - Autocompletion
TODO
http://mnajder.blogspot.com/2009/08/incremental-find-with-reactive.html
PLINQ: Oppgave 1 - Mandelbrotfraktal
Se prosjektet Part4_Plinq
Referanser og ressurser
http://msdn.microsoft.com/en-us/magazine/cc163329.aspx - korreksjoner i http://blogs.msdn.com/pfxteam/archive/2007/11/29/6558508.aspx
http://www.bluebytesoftware.com/code/07/01/2007_01_POPL_DAMP_plinq.ppt
http://codebetter.com/blogs/matthew.podwysocki/archive/2009/10/14/introducing-the-reactive-framework-part-i.aspx og http://codebetter.com/blogs/matthew.podwysocki/archive/2009/11/03/introduction-to-the-reactive-framework-part-ii.aspx
Referanser og ressurser
Foredrag med skaperne av LINQ og Rx:
– http://channel9.msdn.com/shows/Going+Deep/Kim-Hamilton-and-Wes-Dyer-Inside-NET-Rx-and-IObservableIObserver-in-the-BCL-VS-2010/
– http://channel9.msdn.com/shows/Going+Deep/Expert-to-Expert-Brian-Beckman-and-Erik-Meijer-Inside-the-NET-Reactive-Framework-Rx/
– http://channel9.msdn.com/shows/Going+Deep/E2E-Erik-Meijer-and-Wes-Dyer-Reactive-Framework-Rx-Under-the-Hood-1-of-2/
BEKK CONSULTING ASSKUR 39, VIPPETANGEN. P.O. BOX 134 SENTRUM, 0102 OSLO, NORWAY.
WWW.BEKK.NO
Åsmund EldhusetKonsulent, Avdeling Trondheim
959 39 [email protected]