Dag 3 was er geen keynote, dus ook geen nieuwe spectaculaire onthullingen of releases. Toch waren er volop interessante en leerzame sessies. Naast de sessies over SharePoint 2010 development, Excel services, en Visual Studio tricks, heb ik een aantal sessies gevolgd over Parallel progamming. Hierbij kwamen onder andere F# en PLINQ aan bod.

Dag 3 was er geen keynote, dus ook geen nieuwe spectaculaire onthullingen of releases. Toch waren er volop interessante en leerzame sessies. Naast de sessies over SharePoint 2010 development, Excel services, en Visual Studio tricks, heb ik een aantal sessies gevolgd over Parallel progamming. Hierbij kwamen onder andere F# en PLINQ aan bod.
Parallel programming
Laat ik eerst omschrijven waarom Parallel zo hot is. De afgelopen decennia werden de computer processors steeds sneller en sneller. De kloksnelheden groeiden explosief, maar daarmee is ook het energie verbruik van de processoren explosief toegenomen. Inmiddels lopen we tegen de grenzen aan van de hoeveelheid die we door een processor kunnen pompen.
De makkelijkste oplossing is om meerdere processoren in een computer stoppen. Het rekenwerk kan dan door meerdere processoren worden gedaan. Inmiddels doen we dit al een paar jaar zo, maar deze rekenkracht wordt alleen optimaal gebruikt als de programmacode van het software hier ook rekening mee houdt. De berekeningen moeten parallel worden uitgevoerd, zodat alle processoren een deel van het rekenwerk oplossen. In de code worden meerdere “threads” aangemaakt waarop gerekend wordt. Hier komen echter de problemen. Het blijkt niet zo makkelijk om je code zo te schrijven dat het geschikt is voor parallel programming.
De verschillende threads zouden namelijk hetzelfde object in het geheugen kunnen aanspreken of aanpassen, zonder dat dit de bedoeling is. Een ander probleem kan optreden als het ene proces moet wachten op de uitkomst van een ander proces, dan kan het dus niet parallel uitgevoerd worden. Dan zijn er nog de 'racing conditions'; afhankelijk van het proces dat als eerste klaar is, komt er een andere uitkomst. Dergelijke problemen worden vaak opgelost met locks op objecten, maar dit is natuurlijk niet bevordelijk voor de performance en kan deadlocks veroorzaken. Verder kan het voorkomen dat de Garbage collector van .Net roet in het eten gooit en de performance verslechtert.
Problemen, problemen. Op de PDC wordt vooral veel gesproken over de problemen die dit met zich meebrengt. Maar gelukkig ook een aantal positieve berichten: Plinq en F#
PLINQ
PLINQ is een uitbreiding op LINQ to Objects (Language Integrated Query) voor het parallel uitvoeren van de queries. Dit klinkt simpel en eigenlijk is dat het ook! Hiervoor worden allerlei problemen genoemd, waarom is PLINQ dan ineens simpel? Linq queries voer je over het algemeen uit op collecties. Collecties kun je makkelijk in meerdere groepen delen (zoveel als je processors hebt), elke processor rekent een groep uit en voeg de resultaten samen. Het volgende voorbeeld:
int[] input = ...
bool[] output = input.AsParallel()
       .Select(x => IsPrime(x))
       .ToArray();
Let op de toevoeging “.AsParallel()” die ervoor zorgt dat meerdere processors gaan uitrekenen of de waardes in de input-array een priem waarde zijn.
Parallel programming in F# en PLINQ
Nu is een Array naar Array berekening het meest eenvoudige scenario. Maar ook andere scenarios kunnen worden uitgevoerd. In deze situaties kan het wel voorkomen dat er een lock gebruikt wordt, maar de verschillende threads rekenen het resultaat uit in eigen buffers die vervolgens worden samengevoegd tot 1 resultaat.
Parallel programming in F# en PLINQ
Daarnaast zijn er ook statements toe tevoegen aan de PLINQ query die zorgen voor ordening, grouping en asynchroon processing.
Natuurlijk zitten er nog wel wat haken en ogen aan PLINQ. Zo kan PLINQ  beter overweg met Value-types dan met Reference-types en de Garbage Collector kan soms de performance verslechteren i.p.v. verbeteren. Daarom tip 1: meten, meten en nog eens meten.
F#
F# is een Functionele, object georïenteerde programmeertaal voor het .Net Framework. De taal lijkt op niets dat ik tot nu toe gebruikt heb, maar ik was onder de indruk. En dan vooral van de mogelijkheden rondom Parallel- en Asynchroon programmeren. Door de syntax en de architectuur van de taal is hij per definitie beter geschikt voor Parallel programming dan de andere .Net talen. Tijdens de presentatie werd er een demo getoond rondom een asynchrone aanroep, waar de C# code vrij onduidelijk werd door alle delegates en methodes. Het zelfde voorbeeld in F# was stukken korter en overzichtelijker.
Let prog =
Async {
       Printfn "starting.."
       Do | Async.Sleep(5000)
       Printfn "Finishing"
       }
Hij is hoogstens onduidelijk door de onbekendheid van de taal. Ik denk dat ik binnenkort hier meer in ga duiken, want de demo was indrukwekkend. Tijd om zelf eens uit te zoeken of het daadwerkelijk zo goed bruikbaar is. Ofwel: ik zou deze blog de komende tijd zeker in de gaten houden! More to come..