PLINQ og Rx

1. PLINQ og Rx Enkel parallellprogrammering og nyskapende eventhåndtering BEKK Fagdag 20.11.2009 Åsmund Eldhuset

2. Agenda • Del 1  PLINQ (Parallel LINQ) • Del 2  Rx (Reactive Extensions) • Del 3  Progging!

3. Del 1  PLINQ (Parallel LINQ)

4. 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

5. 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 > 42select 2 * i • Etter: from i in data.AsParallel() where i > 42select 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

6. 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

7. 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()

8. 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

9. Operatorparallellisme Thread 1 where p(x) select f(x) data result Thread 2 where p(x) select f(x) Thread 1 Thread 2 data result where p(x) select f(x) Thread 1 Thread 2 where p(x) select f(x) data result Thread 3 Thread 4 where p(x) select f(x) Intraoperator / partisjonering Interoperator / pipelining Kombinering av disse http://msdn.microsoft.com/en-us/magazine/cc163329.aspx

10. 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

11. 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

12. 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 == 0selectcount++;res.Last(); // Force evaluation Riktig #1 (ekstern synkronisering):int count = 0;var res = from i in data.AsParallel() where i % 2 == 0selectInterlocked.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();

13. Del 2  Rx (Reactive Extensions)

14. 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...)

15. Sekvensdiagram - IEnumerable<T> / IEnumerator<T> Our thread IEnumerator<T> IEnumerable<T> GetEnumerator() new IEnumerator<T> IEnumerator<T> Current() Get() T T

16. Sekvensdiagram - IObservable<T> / IObserver<T> Our thread IObserver<T> IObservable<T> GUI thread new IObserver<T> Subscribe(IObserver<T>) IDisposable (call some method from the actual class of the IObservable<T>) OnNext(T) (trigger event and pass the T instance)

17. IEnumerable<T> / IEnumerator<T> interfaceIEnumerable<T>{IEnumerator<T> GetEnumerator();} interfaceIEnumerator<T> { T Current { get; } // Might throw exceptionbool MoveNext();}

18. Omskriving La oss prøve å lage de "motsatte" interfacene, ved å bytte om på parametre og returverdier interfaceIEnumerable<T>{IEnumerator<T> GetEnumerator();} interfaceIDualEnumerable<T>{void SetDualEnumerator(IDualEnumerator<T>);} interfaceIObservable<T> { IDisposable Subscribe(IObserver<T> observer);}

19. Omskriving interfaceIEnumerator<T> { T Current { get; } // Might throw exceptionbool MoveNext();} interfaceIDualEnumerator<T> { T|Exception GetCurrent();bool MoveNext();} interfaceIDualEnumerator<T> {void SetCurrent(T|Exception); MoveNext(bool);} interfaceIDualEnumerator<T> {void SetCurrent(T);void SetException(Exception); MoveNext();} interfaceIObserver<T> {void OnNext(T value);void OnError(Exception exception);void OnCompleted();}

20. IObservable<T> / IObserver<T> interfaceIObservable<T> { IDisposable Subscribe(IObserver<T> observer);} interfaceIObserver<T> {void OnCompleted();void OnError(Exception exception);void OnNext(T value);}

21. 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 selectnew { mm.EventArgs.X, mm.EventArgs.Y }; • Gir en IObservable<'a>, hvor 'a er en new { int X, int Y }

22. 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

23. Cross join av events • from a in eventAfromb ineventBselect ... • (Ser ut til å) fungere som følger: • For hver event fra eventB, utløs en event for hver event som hittil har kommet fra eventA • Hvis eventB signaliserer at den er ferdig (OnCompleted()), vil de mottatte eventene fra eventA nullstilles, og LINQ vil re-subscribe til eventB

24. "Extension events" Syntaksen for å få tak i en IObservable for en event er strevsom Bør innkapsles i extension methods internalstaticclassExtensionMethods {publicstaticIObservable<IEvent<MouseEventArgs>> GetMouseMove(thisControl control) {returnObservable.FromEvent<MouseEventArgs> (control, "MouseMove"); }} Har også en alternativ overload av FromEvent<>() http://themechanicalbride.blogspot.com/2009/07/developing-with-rx-part-1-extension.html

25. 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 inObservable.Return(newUnit()) .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)

26. Kombinering av events a 0 1 2 3 4 b 0 1 2 a.Merge(b) 0 1 2 0 3 1 2 4 0 1 2 a.Zip(b, func) a.Until(b) 0 1 2 a.WaitUntil(b) 0 1 2 3 4

27. 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(...)

28. Del 3  Progging!

29. 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

30. Rx: Oppgave 1 - Drag-and-drop / Paint • En drag-and-drop-operasjon består av følgende sekvens av events: • En MouseDown • Vilkårlig mange MouseMove • 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 • Se prosjektet Part5_Events, mappen Painting • Rediger Program.cs for å aktivere PaintForm • http://mnajder.blogspot.com/2009/08/and-drop-with-reactive-framework.html

31. Rx: Oppgave 2 - Autocompletion • Klassen MockWebService simulerer en web service for autocompletion som det tar tre sekunder å gjøre et (synkront) kall til • Vi ønsker følgende oppførsel for AutocompletionForm: • Ett sekund etter at man har sluttet å skrive i tekstboksen, skal det gjøres et oppslag mot web servicen • Når resultatene kommer, skal de vises i listeboksen - med mindre teksten er endret siden kallet startet • Pakk kallet inn i en Observable.ToAsync() • Kjør en LINQ-spørring for å abonnere på eventene på rett vis • Se prosjektet Part5_Events, mappen Autocompletion • Rediger Program.cs for å aktivere AutocompletionForm • http://mnajder.blogspot.com/2009/08/incremental-find-with-reactive.html

32. PLINQ: Oppgave 1 - Mandelbrotfraktal Koseoppgave på slutten av dagen Se prosjektet Part4_Plinq

33. 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

34. 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/

35. Åsmund Eldhuset Konsulent, Avdeling Trondheim 959 39 826 aasmund.eldhuset@bekk.no