PLINQ og Rx Enkel parallellprogrammering og nyskapende eventhåndtering BEKK Fagdag Å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, som implementerer IEnumerable 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() 

Operatorparallellisme  Intraoperator / partisjonering  Interoperator / pipelining  Kombinering av disse  Thread 2 Thread 1 data where p(x) select f(x) result Thread 4Thread 3 Thread 2Thread 1 data where p(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 == 0 select 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 / IEnumerator Our thread IEnumerator IEnumerable GetEnumerator() new IEnumerator Current() Get() T T

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

IEnumerable / IEnumerator  interface IEnumerable { IEnumerator GetEnumerator(); }  interface IEnumerator { T Current { get; } // Might throw exception bool MoveNext(); }

Omskriving  La oss prøve å lage de "motsatte" interfacene, ved å bytte om på parametre og returverdier  interface IEnumerable { IEnumerator GetEnumerator(); }  interface IDualEnumerable { void SetDualEnumerator(IDualEnumerator ); }  interface IObservable { IDisposable Subscribe(IObserver observer); }

Omskriving  interface IEnumerator { T Current { get; } // Might throw exception bool MoveNext(); }  interface IDualEnumerator { T|Exception GetCurrent(); bool MoveNext(); }  interface IDualEnumerator { void SetCurrent(T|Exception); MoveNext(bool); }  interface IDualEnumerator { void SetCurrent(T); void SetException(Exception); MoveNext(); }  interface IObserver { void OnNext(T value); void OnError(Exception exception); void OnCompleted(); }

IObservable / IObserver  interface IObservable { IDisposable Subscribe(IObserver observer); }  interface IObserver { void OnCompleted(); void OnError(Exception exception); void OnNext(T value); }

Hvordan lage observables  var obs = Observable.FromEvent (this, "MouseMove"); – Gir en IObservable > – LINQ behandler en IObservable som en sekvens av T -instanser  var mouseMove = from mm in obs select new { mm.EventArgs.X, mm.EventArgs.Y }; – Gir en IObservable, 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  from a in eventA from b in eventB select...  (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

"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 > GetMouseMove(this Control control) { return Observable.FromEvent (control, "MouseMove"); } }  Har også en alternativ overload av FromEvent<>()  extension.html 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 eventA from 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 a b a.Merge(b) a.Until(b) a.WaitUntil(b) a.Zip(b, func) 012

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 ((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: –Prosjekter trenger referanse til System.Reactive og System.CoreEx  Parallel Extensions for VS2008: details.aspx?FamilyId=348F73FD-593D-4B3C-B C50D2B0F3http:// details.aspx?FamilyId=348F73FD-593D-4B3C-B C50D2B0F3 –Prosjekter trenger referanse til System.Threading  Den utleverte koden og LF'ene kan sjekkes ut anonymt over SVN: svn co linq

Rx: Oppgave 1 - Drag-and-drop / Paint  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  Se prosjektet Part5_Events, mappen Painting – Rediger Program.cs for å aktivere PaintForm 

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 

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

Referanser og ressurser  - korreksjoner i  P_plinq.ppt P_plinq.ppt  /introducing-the-reactive-framework-part-i.aspx og /introduction-to-the-reactive-framework-part-ii.aspx /introducing-the-reactive-framework-part-i.aspx /introduction-to-the-reactive-framework-part-ii.aspx

Referanser og ressurser  Foredrag med skaperne av LINQ og Rx: – Dyer-Inside-NET-Rx-and-IObservableIObserver-in-the-BCL-VS-2010/ Dyer-Inside-NET-Rx-and-IObservableIObserver-in-the-BCL-VS-2010/ – Beckman-and-Erik-Meijer-Inside-the-NET-Reactive-Framework-Rx/ Beckman-and-Erik-Meijer-Inside-the-NET-Reactive-Framework-Rx/ – Wes-Dyer-Reactive-Framework-Rx-Under-the-Hood-1-of-2/ Wes-Dyer-Reactive-Framework-Rx-Under-the-Hood-1-of-2/

BEKK CONSULTING AS SKUR 39, VIPPETANGEN. P.O. BOX 134 SENTRUM, 0102 OSLO, NORWAY. Åsmund Eldhuset Konsulent, Avdeling Trondheim