[new:10/8/2010]Les Parallel Extensions, connues jusqu’à lors sous le nom de Parallel Framework Extensions (ou PFX) forment une librairie permettant de faciliter la construction d’algorithmes parallèles (multi-thread) tirant partie des machines multi-cœur. Je vous en avais déjà parlé, ainsi que de P-Linq les extensions parallèles pour LINQ. Deux choses importantes à savoir aujourd’hui : les Parallel Extensions font partie de .NET 4 (VS 2010, Silverlight…) et une nouvelle librairie arrive, les Reactive Extensions !
Parallélisme
J’avais abordé le sujet dans mon billet “La bombe Parallèle ! PLINQ, et PCP Parallel Computing Platform” il y a 2 ans presque jour pour jour… Pour ceux qui n’ont pas suivi je rappellerai donc juste quelques points essentiels développés dans ce billet :
- La loi de Moore reste valable mais l’équivalence gain de puissance = fréquence du processeur plus élevée, elle, est morte…
- Pour continuer à faire évoluer la puissance des ordinateurs les fondeurs optimisent les puces mais surtout multiplient les cœurs au sein d’une même puce.
- Il y a deux ans, les double-cœurs se banalisaient. Les QuadCore se sont banalisés entre temps et pour une poignée de dollar ont achète aujourd’hui par exemple des i870 à 4 cœurs multithreadés (donc 8 cœurs apparents). Demain les 32, 64 cores seront la norme.
- Pour tirer partie de cette puissance le développeur ne peut plus se dire “si mon client trouve mon soft trop lent, il n’a qu’à acheter une machine plus rapide”. Cela ne servira à rien… Aujourd’hui la responsabilité est totalement du coté du développeur qui doit apprendre à utiliser tous les cœurs des machines en même temps s’il veut que ses programmes profitent de la puissance des nouvelles machines. Pas d’échappatoire.
- En dehors de quelques geeks, je le vois bien autour de moi et chez mes clients, peu de développeurs semblent avoir bien saisi ce que cela impliquait…
Dès qu’on créé un nouveau thread dans une application on peut dire qu’on “fait du parallélisme”. Certes, ce n’est pas faux. Donc beaucoup de développeurs l’ont fait au moins une fois dans les dernières années, un peu comme M. Jourdain faisait de la prose sans le savoir…
Mais cela n’a rien à voir avec le vrai parallélisme qui implique des langages, des librairies, des plateformes étudiés pour et surtout une nouvelle façon de penser le code ! Programmer en asynchrone est particulièrement déroutant (on voit comment certains ont du mal sous Silverlight avec ce concept qui devient incontournable dans certaines situations).
Pour les anglophones je vous renvoie à un autre de mes billets listant articles et vidéos sur le sujet, c’est une introduction toujours valable au sujet : “Mondes Parallèles [Webcasts sur le parallélisme + article ]”
Le Framework .NET et le parallélisme
Le petit schéma ci-dessous (repiqué de Wikipédia) rappelle l’architecture simplifiée du Framework .NET ainsi que les ajouts essentiels selon les versions. On remarque au sommet, version 4.0, que le parallélisme fait son entrée “officielle” après quelques années de béta test :
Sous .NET 4.0 les choses se présentent ainsi en deux volets distincts: La Task Parallel Livrary, et Parallel LINQ (P-LINQ).
P-LINQ
P-LINQ est une extension parallèle du moteur LINQ. Il parallélise l’exécution des requêtes automatiquement, pour l’instant dans les saveurs Linq to Xml et Linq to Objects. Tous les objets peuvent être utilisés, toutes les requêtes existantes peuvent être transformées pour utiliser P-LINQ (ou presque). Il faut en effet que les listes d’objets supportent IParallelEnumerable une interface de P-LINQ qui utilise TPL pour son exécution (mais il existe une méthode System.Linq.ParallelEnumerable.AsParallel qui transforme une liste IEnumerable<T> en une liste utilisable sous P-LINQ, rien de compliqué donc !).
Vous pouvez lire en complément cet article de MSDN Magazine (en français) : Exécution de requêtes sur les processeurs multicœur.
TPL (Task Parallel Library)
TPL est la librairie qui expose les facilités du moteur parallèle de .NET 4.0. C’est TPL qui offre, notamment, des extensions comme For ou ForEach entièrement parallèles bien qu’utilisant des appels de méthodes et des delegates standard. Sous cette forme, tous les langages .NET peuvent bénéficier de ces services. Tout le travail pénible et délicat consistant à répartir la tâche entre plusieurs threads, terminer correctement ces derniers, autant que celui consistant à créer le nombre de threads adapté au nombre de cœurs de la machine hôte, tout cela est pris en charge par TPL !
Tasks et Future
TPL introduit aussi la notion de Task et Future. Une Task (tâche) peut être vue comme un thread, mais en beaucoup plus léger (sans forcément créer de threads au niveau OS). Les Tasks sont empilées et gérées par le Task Manager et sont exécutées quand leur tour arrive dans un thread pool.
Les “Future” sont des Task qui retournent des données. Le principe reste le même sauf qu’un mécanisme permet d’être averti que le travail est terminé et que les données sont prêtes.
Les méthodes
On trouve par exemple Parallel.Invoke qui exécute tout delegate de type Action de façon parallèle sans avoir à se soucier du “comment”.
Evoqués plus haut, on trouve aussi Parallel.For et Parallel.ForEach qui sont les équivalents parallèles des boucles For et Foreach de C#. On peut utiliser ces boucles partout dans son code où il y avait des For et Foreach “normaux” (en prenant garde aux effets de bord liés à l’asynchronisme !).
Le blog de l’équipe Parallel Programming
Si le sujet vous intéresse (et il doit vous intéresser ! – dans le sens du devoir professionnel) je vous recommande le blog de l’équipe qui a créée les extensions parallèles, c’est un point fort chez MS aujourd’hui de permettre aux équipes de communiquer directement avec les développeurs, il faut en profiter. C’est ici : http://blogs.msdn.com/b/pfxteam/
Les Reactive Extensions (Rx)
Quelle est cette nouvelle librairie et comment se positionne-t-elle par rapport à ce que nous venons de voir ?
Les Rx n’introduisent pas vraiment de nouveautés quant aux mécanismes parallèles qui, eux, sont implémentés dans le Framerwork 4.0 (TPL et P-LINQ). En revanche, les Rx viennent jouer le rôle de chef d’orchestre, d’unificateurs pour simplifier l’accès à toutes les méthodes de programmation asynchrone proposées.
Les Rx sont encore dans leur labo, disponibles mais pas encore intégrées au Framework (il faut donc les télécharger à part). Toutefois elles se basent sur deux interfaces, IObservable<T> et IObserver<T> qui elles sont déjà définies dans .NET 4.0.
Le fonctionnement de ces interfaces est simple : IObservable<T> est une sorte de IEnumerable<T>. La différence essentielle est qu’on peut énumérer tout le contenu d’une liste IENumerable en se déplaçant dedans, alors qu’avec IObservable<T> on s’enregistre auprès de la liste pour être prévenu qu’un nouvel élément est disponible. De l’asynchrone pur et une mise en œuvre de la design pattern “Producteur-Consommateur” .
A ce titre vous pouvez lire dans le C# Programming Guide de MSDN l’article suivant “How to: Synchronize a Producer and a Consumer Thread (C# Programming Guide)”.
Des exemples
La programmation synchrone est un exercice de style qui réclame de se “mettre dans le mood”, et les exemples, même simples, deviennent forcément plus compliqués que le “Hello World” traditionnel…
Je vous reparlerais des Rx, de TPL et de P-LINQ dans les semaines et mois à venir car ces extensions qui sont supportées par WPF mais aussi par Silverlight permettent d’améliorer sensiblement la réactivité des applications.
Pour l’instant je vais éviter les redites, et puisqu’il existe sur la question une série de billets très bien faits (et en français) écrits par Flavien Charlon, je ne peux que vous en conseiller la lecture :
De même, toujours en français, un article de Thomas Jaskula décrit comment gérer un drag’n drop asynchrone avec les RX : Commencer à jouer avec Reactive Extensions (Rx) – Drag & Drop.
Sans oublier le DevLab des Rx chez Microsoft : DevLabs: Reactive Extensions for .NET (Rx)
Conclusion
Je devrais plutôt dire “Introduction” ! Car il ne s’agit pas ici de conclure sur le sujet mais bien de l’introduire et de vous inciter à aller de l’avant en suivant les liens proposés et en pratiquant vous mêmes des tests de ces nouvelles technologies.
N’oubliez pas qu’il s’agit d’une modification radicale et incontournable de la programmation moderne, un passage obligatoire pour faire en sorte que vos applications puissent tourner sur les machines vendues aujourd’hui et demain. Ne négligez pas aujourd’hui le parallélisme si vous ne voulez pas que demain vos clients ne négligent vos applications !
Et surtout : Stay Tuned !