Blog de JP Gouigoux

Executive summary : Un principe de base pour la protection des machines virtuelles est de considérer qu’elles sont au moins aussi sensibles que des machines physiques. Bref, elles doivent être patchées comme les autres. Par contre, cette comparaison ne prétend pas limiter les besoins de sécurité des machines virtuelles, car elles ont également des besoins spécifiques (sécurisation des fichiers de disque virtuel, des machines avec l’hyperviseur, etc.) et des caractéristiques rendant plus difficile leur sécurisation (application des patchs sur une machine virtuelle éteinte, ce qui constituera une partie importante de la session, avec la présentation de l’outil Microsoft dédié à ce cas de figure).

On retrouve à cette session un des intervenants de la précédente, mais vu le public et le calme dans la préparation comme dans la salle, je sens que ça va être beaucoup plus sage. Ca m’évitera d’ailleurs de me ramasser un cadenas dans la tronche. Oui, sur la session précédente, les intervenants lançaient des (petits) cadenas dans le public. J’ai réussi à sauver mon netbook, c’est déjà çà…

Session présentée par Pascal Saulière (http://blogs.technet.com/pascals pour les diapos), Architecte pour Microsoft France.

Contexte

On se place dans un contexte de virtualisation serveur, et non pas du client ou des applications. Bref, surtout sur Hyper-V.

La flexibilité des machines virtuelles fait qu’on tendance à créer des machines virtuelles à chaque nouveau besoin métier. Du coup, on utilise des images qui ne sont pas nécessairement patchées comme source. Il y a aussi plus de fichiers .vhd à maîtriser, alors qu’ils peuvent en plus être un peu n’importe où sur des SAN. D’où un besoin plus fort de gestion et de supervision.

Microsoft a publié un guide de sécurité Hyper-V, disponible sur http://go.microsoft.com/fwlink/?LinkId=140067. Il parle de durcissement d’Hyper-V, de délégation, et de méthodes de patch des machines virtuelles.

Durcissement

Avant tout, il faut protéger la partition parente, donc réduire la surface d’attaque sur l’endroit où on fait tourner Hyper-V. Typiquement, il ne faut jamais avoir d’autre rôle pour un serveur Hyper-V, et surtout pas contrôleur de domaine. L’idéal est d’ailleurs de le faire fonctionner en mode core, c’est-à-dire sans la GUI, et l’administrer par la console Hyper-V à distance. Ceci permet de limiter la surface d’attaque, et également de gagner en termes de ressources, ainsi qu’en nombre de patchs à mettre à jour.

Carte réseau dédiée pour la partition parente et le management d’Hyper-V. Et donc bien sûr une deuxième ou plus pour les machines virtuelles elles-mêmes, mais à part. On peut en profiter pour isoler les accès extérieurs.

Bien utiliser les stratégies de groupe adaptées (voir dans le guide).

Délégation d’administration

Consiste à dire qu’il y a une différence entre un administrateur Hyper-V et un administrateur de machines virtuelles. Authorization Manager permet de définir les autorisations de manière bien découpée.

SCVMM (System Center Virtual Machin Manager) est un outil avancé pour gérer les machines virtuelles, et ajoute un niveau d’abstraction pour la délégation, les templates de machines virtuelles, etc.

Protection des machines virtuelles

Principe de base : ce sont des machines comme les autres. Donc durcissement de l’OS : firewall, GPO, etc.

Par contre, en plus, ça vaut le coup de traiter en plus les VHD comme des fichiers sensibles. Chiffrement bitlocker par exemple, et en tout cas audit et gestion des contrôle d’accès.

Pour tout ce est de la maintenance, il faut bien sûr gérer la mise à jour. Et c’est là que se pose le véritable problème : si on a beaucoup de machines virtuelles, ça veut dire beaucoup de machines à patcher.

Autres bonnes pratiques

Ne pas considérer comme sûre l’isolation de deux VM : elle ne pourra jamais être aussi bonne que l’isolation physique. Du coup, il ne faut pas mettre sur une même machine physique des machines virtuelles qui auraient un niveau de sécurité différent. Typiquement, une VM “face à internet” doit être mise à part des autres.

Attention aux composants d’intégration (VM Additions, etc.) : la synchronisation d’horloge est importante pour l’authentification, les audits, etc. Microsoft a fourni du code Open Source pour inclusion de ces addins dans Linux. Ils sont déjà intégrés dans SuSE.

Le gros problème : la mise à jour des VM

On passe plus de temps sur cette partie car c’est là où il y a le plus de boulot. En théorie, on doit faire un test du patch en copiant un snaphsot de la machine de production, en testant, puis en appliquant la mise à jour sur la production et de mettre à jour l’image de sauvegarde à la fin. Ces enchaînements d’actions pourraient d’ailleurs s’automatiser avec PowerShell.

Le souci est surtout pour les machines virtuelles qui sont éteintes. Du coup, elles ne passent pas automatiquement sur la diffusion de mise à jour par WSUS. Comment garantir que le jour où on va les rallumer, tout se passera bien ? Typiquement, les VM pour des tests applicatifs, ou les VM clientes qui sont stockées dans la bibliothèque de SCVMM risquent de manquer le patch tuesday, donc ne respectent potentiellement plus les règles de conformité AD, ou peuvent se faire infecter.

La solution : offline virtual machine servicing tool (http://www.microsoft.com/vmservicing) qui est un guide avec des outils et des scripts permettant, en s’appuyant sur Hyper-V, SCVMM, SCCM et WSUS pour patcher des machines en les allumant, appliquant le patch, éteignant et les stockant de retour dans la bibliothèque. Le processus a lieu sur des serveurs Hyper-V dédiés à la maintenance, qui sont appelés des Maintenance Hosts.

La démarche de l’outil :

• Identifier les machines offline à patcher.
• Trouver un maintenance host avec suffisamment de capacité pour prendre en charge les machines à patcher, en faisant en plusieurs jobs si nécessaire.
• Patcher avec SCCM ou WSUS.
• Rapport temps-réel sur le statut des jobs.

Les contraintes sont que :

• Toutes les VM doivent être pilotées par SCVMM.
• L’environnement de patch doit être opérationnel avec une machine dans le domaine, avec le client WSUS Ou SCCM sur toutes les VM.
• Il faut identifier des machines dédiées (ou en tout cas, dédiées sur un temps partiel et sur un VLAN séparé) comme Maintenance Host.

Demo

OVMST 2.1 est présenté sur un Windows Server 2008 R2.

Un peu décevant à partir de ce point de la session, car la démo se fait sur une seule machine, avec beaucoup d’hypothèses simplificatrices. C’est un peu dommage de passer beaucoup de temps sur ce point, au lieu de plus parler des problématiques de sécurité sur machines virtuelles. Du coup, le libellé de la session est un peu trompeur, car on a parlé pendant 20 minutes de la sécurité, et pendant tout le reste de l’outil pour le patch des machines offline. C’est intéressant, mais c’est loin de représenter les deux tiers du sujet…

L’intervenant reconnaissant que, pour le reste de la session, il ne restait qu’à attendre que le processus démontré finisse, quelques mains se lèvent pour poser des questions. On apprend du coup qu’on ne peut pas utiliser ce processus pour patcher des templates.

Note : Hyper-V Server est la version gratuite d’Hyper-V.

Executive summary : Je ne ferai pas de résumé sur cette session pour deux raisons. La première est que, m’intéressant pas mal à la sécurité, je n’ai pas appris grand chose, et que du coup, je n’ai pas été très motivé pour prendre des notes. La seconde raison est que le contenu étant très riche et basé sur beaucoup de démonstration par exemple, il est difficile de faire passer la connaissance apporter sans se lancer dans des descriptions très complexes.

Bon, je tiens à préciser d’entrée de jeu que je ne fais que reprendre l’intitulé de la session, qui s’appelle réellement “Maman, j’ai rétréci les virus !”. J’imagine que le contenu sera plus sérieux que le titre…

Encore une session bien remplie : on ne refuse pas encore de monde, mais ça sera le cas dans 30 secondes.

La session de l’an dernier par les mêmes personnes étaient “Le virus est mort. Vive les malwares !”.

Introduction

Les accès internet sont désormais ubiquitaires. 85% des internautes font leurs comptes en ligne, et 70% des gens pensent acheter sur internet pour Noël.

L’idée de la session est de donner des arguments pour faire prendre les réflexes sur la sécurité.

Résumé des conclusions semestrielles de Microsoft : de plus en plus, les attaques proviennent des applications tierces (Flash, Quicktime, etc.) et non plus du navigateur lui-même, vu que l’effort de sécurisation qui a été fait a bien blindé les applications standards.

Note : ZoomIt est en téléchargement sur Microsoft.com

Tendances

Les chevaux de troie sont encore en augmentation. Les malwares les plus diffusés ne sont pas du tout les plus médiatisés. Or ce sont eux qui seront utilisés comme vecteurs dans le futur. Les attaques de fishing ont explosé grâce aux réseaux sociaux.

Sécurité = Comportement + Technologie.

Attention aux données qu’on met sur les réseaux sociaux, qui ne sont pas nécessairement privées, mais qui peuvent être utiles pour retrouver un mot de passe (nom de l’animal domestique, date de naissance, etc.)

Le reste des conseils porte sur les réseaux sociaux. Vu que personnellement, je préfère ne pas les utiliser du tout, et que je ne les connais pas, je ne vais pas reprendre tout, mais ça relève surtout du bon sens. Par exemple, ne pas informer tout le monde qu’on part en vacances pendant 3 mois pour ne pas tenter les cambrioleurs. De mon point de vue, le plus simple est de considérer simplement que ce que vous affichez sur Facebook ou autre est tout simplement public. Et vous n’iriez pas mettre une affichette chez votre boulanger pour dire que vous partez en vacances…

Finalement, ce que je trouve le plus gênant est la difficulté de purger les caches des moteurs de recherche. Si encore on pouvait à un moment fermer son compte de réseau social et qu’il ne restait rien, ça serait déjà pas mal. Mais le fait que Google garde le cache fait que l’information reste disponible.

Conseils

123people.fr est un aggrégateur de données personnelles, sous forme de moteur de recherche. Amazon rend par exemple publiques les données des wish lists, ou en tout cas les rendaient publiques aux USA.

Pour des choix de mots de passe, on peut utiliser des positions géométriques sur le clavier, ou bien les premières lettres d’une phrase, etc.

Pour les questions secrètes, ça vaut le coup de répondre avec des réponses fausses, mais dont on se rappelle bien sûr.

Autres attaques

On est aujourd’hui à 4% de mails légitimes renvoyés sur Exchange (statistiques Microsoft).

Les certificats étendus font apparaître la barre de navigation en vert dans le navigateur.

Attention aux URL courtes, car on ne sait pas sur quoi elle pointe. Il existe par contre des plugins pour voir l’adresse complète avant d’aller dessus.

ScareWare : voir ddanchev.blogspot.com

Conclusion

Session franchement portée sur l’humour, les intervenants ayant l’air de bien se connaître. Par contre, pour le contenu, ce sont les recommandations standards. Evidemment, un peu plus de profondeur que pour du grand public, mais des gens qui se tiennent au courant des problématiques de sécurité sur internet n’apprendront pas grand chose.

Executive summary : Bernard Ourghanlian nous fait un topo complet des problèmes et challenges de sécurité dans le mode Cloud. On couvre toute la problématique depuis l’application jusqu’à la sécurité physique des données. Beaucoup de points très intéressants. On se rend compte de la masse de défis à relever pour assurer la sécurité sur ce genre d’infrastructure, ainsi que les problématiques légales qui sont levées à cause de la localisation géographique potentiellement multiples des données.

La session est présentée par Bernard Ourghanlian en personne, qui est le responsable de la sécurité pour Microsoft. Il précise que cette séance sera une introduction, avec une définition du modèle de sécurité, la présentation du Cloud Security Alliance, etc.

Définitions

“Above The Cloud” est un article de Berkeley qui a pris de la hauteur pour mieux définir la notion de Cloud.

Software As A Service est une très vieille idée, vu que c’est là-dessus que se basent les mainframes. La nouveauté est plutôt sur les approches HaaS, IaaS, Paas (Hardware, Infrastructure, Platform As A Service), avec les avantages suivants :

• Illusion de ressources infinies
• Suppression de l’investissement initial
• Possibilité de disponibilité pour des temps très court

La justification du Cloud Computing n’est pas technique mais purement économique, grâce aux économies d’échelle. C’est d’ailleurs en grande partie la raison pour laquelle les acteurs du Cloud sont issus du grand public. On est 5 à 7 fois moins cher, à énergie informatique égale, sur un système avec 10 000 à 100 000 machines qu’avec 1 000.

Caractéristiques essentielles du continuum Cloud:

• A la demande.
• Accès réseau ubiquitaire.
• Mise en commun des ressources : indépendance de l’emplacement (impactant sur la sécurité) et homogénéité.
• Elasticité rapide (consommation à la demande).
• Service mesuré en permanence, en lien avec le contrat sur le niveau de service.

Une petite image pour mieux expliquer le concept de continuum :

SaaS : on consomme un produit fini.

PaaS : déploiement d’applications et de services dans le Cloud. C’est Azure chez Microsoft. Du coup, le client final n’est pas client d’Azure.

IaaS : encore moins de compétence, car il s’agit juste d’abstraire la partie gestion de machines, et c’est le client qui s’occupe de l’installation des machines, virtuelles en général.

Quatre modèles de déploiement du Cloud :

• Public Cloud : infrastructure partagée avec d’autres clients.
• Private Cloud : Cloud dans l’intranet ou externe, mais propriété complète de l’appelant.
• Community Cloud : propriété d’une communauté, par exemple un gouvernement.
• Hybrid Cloud : composition de plusieurs formes de Cloud permettant la portabilité des données ou des services.

Tous les dix ans, un changement d’infrastructure : Mainframe, Client Serveur, Web, SOA, Cloud de 1970 à 2010.

Problématique de sécurité

Dans le papier de Berkeley sont notées 10 obstacles au Cloud. La confidentialité des données et l’auditabilité en fait partie. Le chiffrement des données de bout en bout est un problème en mode Cloud, car si les clés sont sur le Cloud, la sécurité n’est pas garantie en termes de confidentialité par rapport aux propriétaires du Cloud, et si les clés sont chez le client du Cloud, il ne peut pas garantir la sécurité de bout en bout. La mise en place d’un canal sécurisé ne suffit pas car cela sécurise juste le transfert.

Questions sur les données :

• Qui a accès aux données ?
• A n’importe quel moment ?
• Que se passe-t-il si j’arrête mon contrat ? (Clause de réversibilité dans les contrats)

Contexte légal et réglementaire :

• Où sont stockées les données ? (Délai de rétention de données en fonction du pays où sont entreposées les données)
• Combien de temps de stockage ?
• Quel régime juridique s’applique à des données stockées dans un pays, créées dans un autre et utilisées par une personne dans un troisième ?
• Comment sont gérées les réquisitions éventuelles ?

Avantages en termes de sécurité du Cloud :

• Réduction de l’exposition à des données sensibles, par limitation des points d’entrée.
• Homogénéité du Cloud, qui simplifie l’audit et les tests de sécurité.
• Beaucoup d’automatisation dans les Clouds (archivage, mises à jour, etc.), et donc une sécurité meilleure que celle qu’on pourrait avoir chez soi.
• Redondance / Récupération en cas de désastre : un mode intéressant peut être d’utiliser le Cloud comme système secondaire de backup en cas de désastre.

Les défis :

• Confiance envers le fournisseur.
• Perte de contrôle physique.
• Responsabilité indirecte de l’administrateur.
• etc.

Le diagnostic d’une application dans le Cloud reste bien sûr de la responsabilité du client du Cloud. Mais du coup, typiquement, le Cloud doit lui donner accès aux logs.

Sur du SaaS, la seule responsabilité qui reste est celle de la donnée. Tout ce qui est OS, logiciel utilise, énergie, etc. est du ressort du fournisseur.

En PaaS, on a en plus la responsabilité sur l’application.

En IaaS, on a la responsabilité sur tout ce qui est au-dessus de l’hyperviseur.

Challenges

Le Jericho forum propose une vue de la sécurité des Cloud : le modèle de cube.

L’utilisateur du Cloud a la responsabilité de l’application (qualité de codage en termes de sécurité). Le fournisseur du Cloud assure la sécurité physique, réseau, électrique, etc. Tout ce qui est entre les deux est de la responsabilité partagée.

Provisionning : La méthode de provisionning doit elle-même être sécurisée.

Stockage de données : On peut provisionner la localisation des données, pour des raisons légales mais aussi de latence réseau. Le chiffrement peut être réalisé au niveau de la donnée ou au niveau du transport. Il faut aussi bien gérer l’isolation des données par rapport à un autre client du Cloud. L’unité de déploiement matériel chez Microsoft est un conteneur avec 450 serveurs.

Infrastructure du Cloud : Publication de masters de machines sécurisées et trustées. Attention à la dépendance à l’hyperviseur, qui doit absolument être TRES sécurisé (d’où les efforts de Microsoft pour essayer de prouver le code d’HyperV de manière formelle).

Services de support : On peut avoir besoin d’un pare-feu ou de logs de journalisation, mais du coup, il faut aussi gérer un opérateur de maintenance en plus de l’opérateur du Cloud. Il y a le problème de renvoi de responsabilité, de mise à jour des logiciels, etc.

Réseau du Cloud : Bonne capacité de résistance à des DOS, avec sécurité périmétrique, mais avec le problème du zonage des applications.

Conclusion

Avantages sécurité du Cloud :

• Données dispersées.
• La sécurité est une marque importante du fournisseur de Cloud, sur laquelle il va mettre de gros moyens.
• Possibilités avancées de pot de miel.
• Le tiers de confiance ne sait pas quelles sont vos données les plus sensibles, contrairement par exemple à votre administrateur in-house.

Défis :

• Dispersion des données.
• Challenge sur l’harmonisation.
• Problèmes légaux de rétention de données.
• Défis de la journalisation.
• Isolement de la donnée.
• Cible attractive pour des pirates.
• Besoins de chiffrement dédié au Cloud.

Ce qui est dur, aux TechDays, c’est de choisir une tranche horaire sans session. Il y en a tellement d’intéressantes qu’on pourrait ne faire que ça… Mais il y aussi des rendez-vous, qu’il est pratique de mener sur place, et puis un tour parmi les exposants révèle souvent son lot de bonnes surprises, alors je saute cette session. J’aurais bien regardé ce qu’il y avait sur Blend 3, mais ça sera pour une autre fois. Si quelqu’un pouvait m’envoyer ses notes, comme je le fais dans ce blog, ça serait très apprécié. La demande vaut d’ailleurs pour toutes les autres sessions !

Executive summary : C’est en général le premier jour des TechDays que Microsoft annonce les grandes nouveautés, et le troisième qu’ils parlent du futur. On reste dans les bonnes vieilles habitudes, et nous avons le droit à des présentations futuristes, mais qui sont bel et bien réelles. En particulier, l’interaction avec une console de jeu par les mouvements du corps humain, qui sera livré dans la console XBox à la fin de cette année. Microsoft semble également vouloir mieux faire descendre la recherche dans ses produits, avec la mise en place des Microsoft Labs qui font l’interface entre les deux.

Ils aiment bien les shows à l’Américaine, chez Microsoft ! La musique fait tellement de bruit pour accueillir les intervenants que j’en ai encore les oreilles qui sifflent.

Cette session plénière est tournée vers le futur.

Programmation par les enfants

On commence par la possibilité de réaliser des interfaces permettant à des enfants de programmer. Kodu est un jeu programmable avec une interface spécifique sur des enchaînements cause-conséquence. Une vidéo montre des enfants programmant des actions de jeu. Ils doivent avoir autour de 6 et 8 ans.

C’est un exemple de programmation par métaphore. Bien sûr, on est à un haut niveau d’abstraction, c’est-à-dire que les enfants n’ont pas programmé les fondements du jeu, mais plutôt le manipulent. Il faut des développeurs bas niveau pour mettre en place cette infrastructure. Mais en même temps, n’est-ce pas ce que nous faisons tous ? Qui a mis en place une pile HTTP, alors que nous l’utilisons tous dans notre code ?

L’idée est que faire programmer des enfants permet d’apprendre sur l’amélioration de l’ergonomie, et semble aussi important pour le futur, car beaucoup de jeunes savent utiliser les programmes, mais ne savent pas les créer, ce qui est un peu dommage, car comme dit Bernard Ourghanlian, c’est comme savoir lire et pas écrire.

Des retours intéressants sont d’avoir des interfaces de programmation avec le moins de code possible, et avec une aide à la programmation tolérante aux erreurs.

Robotics Studio pour Lego Mindstorms

NxtNet sur Codeplex : SDK.NET pour Mindstorms NXT en Open Source.

On peut connecter une manette XBox sur un robot Lego et faire de la programmation événementielle pour relier les actions de la manette aux moteurs ou bien inversement les actions des capteurs sur la vibration de la manette.

Il y a une approche modulaire très importante.

Programmer sans code

Les deux précédentes démonstration font voir des méthodes de programmation sans code, qui s’adapte bien aux défis des prochaines années. Pour le parallélisme, par exemple, il est intéressant de prendre un niveau d’abstraction pour ne pas avoir à gérer les threads, par exemple. De la même manière que l’élévation de niveau avec le GC permet de ne plus avoir à gérer soi-même la mémoire.

Quel est le prochain niveau d’abstraction ? Les méthodes formelles pour coder sans bug et avec du code prouvé mathématiquement sont extrêmement complexes. Un autre point d’inflexion possible pourrait être les DSL, c’est-à-dire avoir des langages spécialisés pour un domaine de traitement particulier. Bernard Ourghanlian donne l’exemple d’Excel, qui est un DSL.

Une démonstration est menée sur une extension de Visual Studio permettant de générer du code fonctionnel à partir de diagrammes. Dans ce cas, non seulement on a un DSL, mais en plus avec une couche d’abstraction graphique.

Un autre exemple est le parcours d’architecture qu’il y a dans Visual Studio 2010 en version ultimate. Sans même parler de DSL, ça semble être une excellente manière de s’approprier du code d’une application inconnue. A tester…

Pour passer le saut quantique nécessaire à l’évolution, il faut que les modèles sur les DSL se débarrassent des problèmes de synchronisation modèle-code, afin que, du point de vue extérieur, on ait vraiment le sentiment que c’est le modèle qui s’exécute.

Agilité

Ca ne suffira toutefois pas à réduire le nombre de projets en échec. Pour cela, Microsoft pousse de plus en plus les méthodes agiles, et montrent une utilisation de la méthode Scrum.

Une tâche est créée dans TFS, et l’attribution des tâches se fait sur une table Surface.

Interface Utilisateur Naturelle

L’idée est d’améliorer l’immersion, pas seulement avec de la voix ou du touch, mais avec de la 3D, de la reconnaissance des mouvements, etc. A terme, on voudrait avoir un ordinateur qui ne travaille plus sous notre commande, mais en notre nom.

Projet Natal inclus dans la XBox à partir de Noël prochain : le but est de ne plus avoir besoin de la manette. Des émetteurs infrarouge enregistrent les mouvements du corps humain, qui devient du coup le périphérique d’entrée. Ce qui est surtout intéressant est que ça s’adapte aux mouvements de chaque personne plutôt que de demander à chacun de s’adapter à la machine.

Starnav.fr permet de piloter un ordinateur par les mouvements de la tête enregistrée par une webcam. Une démo est réalisée.

R&D

Création des Microsoft Labs, qui ont pour but de faire le lien entre Microsoft Research et les produits. Typiquement, PhotoSynth a été produit comme ceci.

La démo qui suit est sur la recherche améliorée sur le web. Aujourd’hui, quand on va sur le web, on ne cherche que sur la structure, et non pas la donnée du web. Pivot utilise les métadonnées des fiches wikipedia pour structurer dynamiquement la recherche dans plusieurs millions de points d’entrée de données. Il y a donc eu indexation d’un contenu web par Pivot pour offrir une meilleure expérience de recherche dans Bing, et tout est basé sur les standards du web, selon les intervenants.

GetPivot.com pour tester.

La dernière démonstration est assez impressionnante, avec des milliers de pages de journal indexées sur une seule image à la mode DeepZoom, et dans lesquelles on peut zoomer jusqu’aux conditions particulières de réservation d’un hôtel dans une publicité dans un des numéros du journal.

Executive summary : Les pontes de F# viennent à Paris pour nous présenter non pas une introduction à F#, mais l’état de la recherche et développement sur F# : parallélisation par agents dans le langage, accélération par utilisation du GPU, et WebSharper, une utilisation de F# pour unifier les différents langages de développement utilisés sur une application web.

Cette session est présentée par Don Syme, qui est le ponte de F#, ainsi que Robert Pickering et Adam Granicz, et est en anglais (je le mets pour que ceux qui ont du mal en anglais et qui n’ont pas pu venir aient moins de regrets).

Enfin, on sort des sessions tutoriels ou d’introduction, pour avoir une session un plus avancée sur F#. En particulier, la session va parler de la programmation parallèle avec F#. Ensuite, la session mettra en avant les possibilités de placer du code F# sur du GPU, en utilisant des arbres d’expression. Cette technologie sert aussi à WebSharper pour créer des sites web composites en transformant le code en JavaScript.

Array.Parallel.map au lieu de Array.map pour bénéficier de la parallélisation.

Le site fsharp.net est mis en avant pour les ressources sur F#. Pour les livres, il y a Beginning F# et Expert F# chez Apress, Programming F# chez O’Reilly.

F# pour la programmation parallèle

F# est très adapté au traitement de données, et se retrouve donc bien placé pour de la parallélisation. Déjà, le langage force l’immuabilité dans de nombreux cas.

Async.Parallel [ for i in 0 .. 20 –> computeTask i ]

Une utilisation de F# est de gérer des agents, bien plus légers que des threads. La classe est MailboxProcessor.

type Agent<’T> = Microsoft.fsharp.control.MailBoxProcessor<&;rsquo;T>

let Agent = Agent.Start(fun inbox –>

    async { while true do

        let! msg = inbox.Receive()

        printfn “got message %s” msg } )

Note : Managed DirectX pour l’affichage de triangles.

Une démonstration de mouvements dynamiques sur des courbes est menée, avec des agents utilisés pour les calculs dynamiques, tandis que l’affichage prend des résultats sur la simulation à intervalles de temps résultats

Quotations et F# sur GPU

Basé sur Microsoft Accelerator qui compile les programmes vers des cibles DX9 ou 64 bits.

Démonstration sur le jeu de la vie.

[<ReflectedDefinition>] permet de marquer les fonctions pour qu’elles puissent être compilées en mode accéléré.

Dommage que le présentateur n’ait pas développé sur cette notion de quotations dont Don Syme a parlé avant, mais sans préciser ce que ça représentait exactement.

WebSharper

Il s’agit d’un produit commercial, certainement le premier à prendre F# pour faire du développement web. http://intellifactory.com pour plus de détails.

L’idée est de se servir de la puissance du langage pour envoyer plus de traitement sur le client, au lieu de continuer à surcharger le serveur. Un peu comme ce qui était prévu (mais n’a visiblement toujours pas été atteint) par AJAX.

Idéalement, F# serait utilisé pour générer tous les autres langages dont on a besoin, à savoir SQL, MDX, C#, HTML, CSS, JavaScript, etc.

“Write F#, run JavaScript”. Le produit s’installe de manière simple sur IIS, et s’intègre bien à ASP.NET, en mode zero-configuration.

Pour résumer, on permet d’exécuter du JavaScript sur le client, mais en écrivant du F#. Ce qui permet de mieux gérer la robustesse du code, le typage, etc. et d’avoir moins d’erreur à la runtime. Les séquences de feuilles web sont vues par WebSharper comme des “flowlets”. Du coup, un site web complet peut par exemple être représenté par une simple valeur F#.

La démonstration sur les formulaires est assez impressionnante : un simple code F# sous forme d’enchaînement de type pipeline d’actions métier permet d’enrichir au fur et à mesure le comportement visuel et de validation d’un formulaire généré dynamiquement sur le client.

Conclusion

Intéressant pour les résultats obtenus, mais la session ne cherchait pas vraiment à faire voir du code et à l’expliquer, mais plutôt à faire de la démonstration de ce qui est fait en recherche. Par exemple, Accelerator est en version 2, mais c’est toujours sur Microsoft Research.

Executive summary : Session très impressionnante, comme l’est le rythme de développement de Silverlight depuis la version 2. Les fonctionnalités ajoutées sur la version 4 sont vraiment très nombreuses. Certaines sont purement orientées grand public (webcam, etc.) mais d’autres (mode Out Of Browser, gestion des crédentiels, Drag & Drop, impression, gestion du clic droit, MVVM, etc.) vont permettre de créer de manière sérieuse des applications pour l’entreprise. Avec la version 3, Flex avait déjà du souci à se faire, mais vu tout ce que la version 4 amène, Adobe va devoir frapper un grand coup si ils veulent améliorer leur place dans le développement RIA.

Merci à mon chef qui a bien voulu échanger avec moi sa session Silverlight 4, et aller prendre des notes sur la mise en place d’un bus de services d’entreprise. Ca va me permettre de voir cette session un peu spéciale, dans le sens où elle est présentée par Julien, de la communauté DotNet-France, qui m’a récemment accueilli.

20 minutes avant le début de la session, la file d’attente s’étendait plus loin que celle de la salle suivante. Bref, il va falloir refuser du monde. C’est même étonnant de la part de Microsoft d’avoir mis cette session sur une aussi petite salle : c’est pourtant typiquement le genre de session qui draine beaucoup de monde…

Introduction

Comme vous le savez certainement, Microsoft a récemment mis les bouchées double sur Silverlight, avec, la version 3 à peine sortie, la version 4 qui pointe le bout de son nez avec encore de nombreuses évolutions. C’est le but de cette session de montrer ces améliorations.

Aurélien Norie, de Microsoft Services, et Julien Dollon, donc, de la communauté DotNet-France, présentent cette session.

Roadmap

Silverlight 1 est paru en 2007, avec du XAML et du JavaScript, pour traiter de la vidéo et de l’animation. La première vraie version est la 2, sortie en 2008. On pouvait désormais faire du .NET dans Silverlight. Ensuite, Silverlight 3 a apporté en 2009 de nombreux contrôles supplémentaires et des améliorations importantes (Pixel Shader, accélération GPU).

Trois chiffres :

• 45% d’adoption du plugin sur les machines (bien aidé par Roland Garros, diffusé en streaming sur du Silverlight).
• 2x : Silverlight 4 promet une exécution deux fois plus rapide que la version précédente.
• 10 secondes pour charger le plugin.

Les demandes de la communauté ont été satisfaites :

• Drag & Drop sur le bureau.
• Impression.
• Gestion plus aboutie du clic droit.

Démonstration

Visual Studio 2010 Beta 2 pour le développement de Silverlight 4. Visual Studio permet de cibler la runtime Silverlight ciblée.

Drag & Drop

Aujourd’hui, si on droppe une image sur le navigateur, on sort du coup de l’application Silverlight pour afficher l’image à la place.

Sur un Canvas, on active le AllowDrop et on s’abonne à l’évènement Drop. Dans le delegate, on récupère le tableau de FileInfo qui contient les fichiers qui ont été droppés sur le contrôle.

Clic droit

Pour l’instant, on voit le menu contextuel de Silverlight. On peut se brancher sur l’évènement contextuel pour afficher un menu qui est en XAML.

Impression

On crée un objet de type PrintDocument. Sur l’évènement PrintPage, on place sur la propriété PageVisual le contrôle à imprimer, puis on fixe le HasMorePages à false. On peut ensuite appeler simplement Print() sur le PrintDocument à partir du code.

Le fond d’écran n’est pas pris en compte au niveau de l’impression si il n’est pas sur le contrôle à imprimer, logiquement. Ce qui est pratique car on veut souvent avoir un fond de couleur sur une application, mais imprimer sur un fond blanc.

Médias et Silverlight 4

Vidéo

Les DRM sont supportés sur les vidéos même en mode déconnecté.

SmootStreaming permet, depuis Windows Server 2008R2 et IIS7 de générer des flux avec différentes qualité, et de les faire afficher dans Silverlight, avec une lecture en continue, car le problème de bande passante est réglé en diminuant la qualité et pas en suspendant de temps en temps la lecture.

Webcam & microphone

Les flux audio et vidéo sont accessibles dans le code, ainsi que le choix du périphérique. Il y a bien sûr une autorisation préalable de l’utilisateur.

Interfaces fluides

Animation de chargement et de déchargement d’éléments dans une liste, en quelques clics dans Blender.

Démonstration suivante

Webcam

C’est l’objet CaptureSource qui se charge de la capture vidéo en provenance de la webcam. Cet objet nous permet de récupérer une VideoBrush qu’on pourra appliquer dans un contrôle conteneur, du coup, de la vidéo.

On peut piloter la webcam à utiliser ainsi que le format d’enregistrement. Ceci est d’ailleurs réalisé par le code .NET, et pas extériorisé dans un panneau de configuration de Silverlight, ce qui est pratique car on peut piloter du coup plusieurs webcams les unes après les autres dans Silverlight.

Gestion des styles

On a désormais à disposition des styles implicites, comme en WPF : on peut supprimer l’association d’un contrôle à un style, et associer le style à un type, et à toutes les instances de ce type.

Easing style démontrés dans Blender : on peut appliquer des styles de mouvements fluides prédéfinis.

Pixel Shader effects depuis Silverlight 3 : on peut appliquer des effets vidéo.

Encore une démonstration : réalité augmentée dans Silverlight !

On peut se servir de l’image capturée par la webcam pour retrouver des marqueurs en papier, les passer dans une API (SLARToolkit) pour retrouver l’orientation de ce papier, puis ajouter des objets 3D dessus en utilisant la nouvelle fonctionnalité de projection 3D de Silverlight.

Démonstration vraiment impressionnante… On a vu il y a quelques mois sur internet des applications sur la réalité augmentée, et il y a eu un pic d’intérêt pour cette technologie, mais ça semblait nécessiter des puissances de traitement importantes. La voir sur un plugin de 4 Mo, c’est assez bluffant !

Communication avec les services

Support des NetworkCredentials dans la pile HTTP client : moins sexy que la démonstration précédente, bien sûr, mais de mon point de vue, très important. C’est le genre de fonctionnalité qui, pour une application industrielle, est absolument obligatoire pour l’adoption de Silverlight.

Possibilité de scénario Trusted, pour avoir un mode Out Of Browser avec plus de droits sur le client. Dans les settings OOB, on peut cocher une option pour demander à être exécuté en mode Trusted. On a alors le droit d’aller chercher des services.

UDP Multicast pour écouter des entrées socket, typiquement du chat.

Contenu riche

Le contrôle RichTextArea permet de récupérer du texte formaté depuis Word par exemple. Il y a aussi le support de l’écriture de gauche à droite. Le texte enrichi affiché à l’écran est en fait lui-même du XAML.

Architecture d’entreprise

MVVM : pattern désormais possible en Silverlight (Commanding supporté)

Compatibilité des assemblages .NET : on peut désormais utiliser les librairies externes développées pour Silverlight dans une autre application.

Gestion améliorée de la validation et de la navigation de page.

Enfin, inclusion du Managed Extension Framework, qui permet de gérer des applications composites.

Mode Out Of Browser :

• Application sandboxée.
• Hébergement HTML.
• Notifications “toast”.
• Gestion de la taille de fenêtre par défaut.
• En mode FullTrust, accès au système de fichiers (en tout cas dans les dossiers utilisateurs), ainsi que l’interop COM (Ouvrir word, ajouter un élément dans le calendrier Outlook).

Dernière démonstration

On peut exporter de la donnée vers Excel, et réceptionner des évènements venant d’Excel sur des modifications de données. Dommage qu’on n’ait pas le temps de voir plus en détails comment ça fonctionne, parce que c’est vraiment très intéressant pour des applications en entreprise. En posant la question à la fin, il se trouve qu’on passe par un évènement COM qui est SheetModified, ou quelque chose approchant, et auquel on abonne l’application Silverlight, qui a le droit de faire ceci car on est en mode Trusted Out Of Browser.

Conclusion

Une des sessions les plus enthousiasmantes des TechDays, en particulier la démonstration de réalité augmentée. En résumé, on est bien loin de Silverlight 1 et ses codes JavaScript absolument inutilisables, et désormais à un niveau de fonctionnalité qui permet d’envisager des applications industrielles sur Silverlight.

Executive summary : La CLR .NET se charge de la gestion de mémoire. Il ne devrait donc jamais y avoir de fuites… Vous avez certainement déjà entendu cette erreur. Eh bien si, car seule la mémoire managée est gérée. Tout ce qui est lié à des ressources ou handles Win32, ou bien en interop mémoire, peut poser problème. La session montre aussi que c’est souvent des problèmes liés aux évènements desquels on oublie de se désabonner, en particulier lorsque ce sont des évènements statiques, car la durée de fixation des dépendances est alors la durée de vie de l’application.

La session est présentée par Yann Schwartz et Fabrice Marguerie, tous deux architectes .NET, respectivement chez Polom et MetaSapiens.

Principes

D’abord, une petite introduction est faite sur la gestion de la mémoire .NET. La gestion de la mémoire en .NET est réalisée par la CLR, et le Garbage Collector est responsable du recyclage de la mémoire. Par contre, il y a bien sûr des cas où on ne peut pas libérer la mémoire :

• Références statiques
• GCHandle (ce qui fait le lien mémoire dans le cas d’interopérabilité)
• Références des piles (une par thread)
• Finalization queue

Et encore on ne parle pas du code non managé.

Détection et correction

On commence avec perfmon.exe, le moniteur de performances de Windows, en ajoutant un compteur Processus / Octets privés pour l’application en question.

Attention, ce n’est pas parce que la mémoire augmente que la mémoire n’est pas relâchée. Donc, on met un bouton dans l’application pour forcer le garbage collection (ça peut être intéressant de mettre un bouton caché dans une application pour ça). Et si effectivement le compteur ne redescend pas lors du GC, c’est vraiment une fuite.

Approches complémentaires :

• dotTrace pour un audit de haut niveau
• .NET Memory Profiler pour plus de détails
• WinDbg pour aller vraiment au fond des choses

JetBrains DotTrace

On commence par une démonstration de dotTrace. On regarde les root paths sur l’instance de l’objet qui garde de la mémoire. Microsoft.Win32.SystemEvents est une liste d’évènements statiques qui restent en vie toute la durée de l’application. Du coup, si une instance reste abonnée, elle ne peut pas être purgée.

Si on fait deux snapshots dotTrace, on a ensuite des icones pour faire du différentiel, voir les nouveaux objets, etc. On voit par exemple que l’application test s’abonne pour une fenêtre à l’événement SystemEvents.InstalledFontsChanged et ne s’en désabonne pas sur l’événement Disposed(). Note : on ne peut pas le faire sur la surcharge du Dispose() car elle est déjà réalisé dans le designer de la WinForms.

L’abonnement à un évènement fait qu’on vit autant de temps que l’objet exposant l’évènement. En effet, en interne, on passe un point d’entrée de fonction à un délégué sur une autre classe pour qu’elle nous appelle sur cette fonction. Du coup, ceci vaut pour un évènement statique, de manière drastique car c’est lié à la vie complète de l’application, mais aussi pour n’importe quel évènement exposé par un objet qui serait lui-même non supprimé par le garbage collector.

SciTech .NET Memory Profiler

Le produit est aussi commercial. Il permet contrairement à dotTrace de se brancher sur une application en cours. Il permet également l’analyse de dump mémoire post-mortem.

Cet outil donne des conseils, en relevant par exemple les instances qui ont été disposées, mais sont encore en vie. Typiquement, la fenêtre est fermée, et le Dipose() est donc appelé immédiatement en WinForms, mais il y a encore des instances qui pointent sur elle.

Attention, on a le même problème sur les closures dans des implémentations d’évènements avec des méthodes lambda.

WinDbg

Débogueur natif et managé, avec un mode graphique et une installation minimale pour pouvoir être placé sur un serveur en production si nécessaire (30 Mo).

Extensions managées : sos.dll pour la gestion mémoire. cmdtree permet d’afficher une fenêtre avec des raccourcis pour charger sos, l’utiliser, etc.

!DumpHeap, !DumpObject, et !GCRoot sont les trois commandes les plus utilisées. Elles permettent de voir le tas, de faire un espion sur un objet particulier, et de voir toutes les racines utilisées.

La liste de commandes réalisées est la suivante :

1. !DumpHeap –stat –type MonApplication pour voir nos objets.
2. !DumpHeap –mt Identifiant du type concerné.
3. !do (abréviation du DumpObject) Identifiant de l’objet.
4. !GCRoot Identifiant de l’objet.

Dans le cas d’exemple, on se rend compte que l’abonnement à un évènement statique est fait par le ContextMenu de WinForms. Du coup, il est essentiel de bien faire un Dispose(), si on ne passe pas par le designer. Quand on passe par le designer, il crée un ContextMenuStrip en lui passant this.Components, c’est-à-dire en se plaçant dans le container. Du coup, le Dispose() du container parcours tous les contrôles contenus et fait le Dispose() en automatique.

Dernier cas de problème

Plus le temps de faire le reste de la démo complète, mais ProcessExplorer de SysInternals permet de voir des choses en plus, en particulier les processus .NET sont en jaune. On voit dans l’exemple que csc.exe est sans arrêt lancé. Comme on génère des librairies en mémoire pour les XmlSerializer (bug sur le constructeur avec plus d’un paramètre, qui ne met pas en cache), et que l’AppDomain ne peut pas les décharger, on se retrouve à garder la mémoire occupée.

Prévention

Il est important de :

• Bien appeler les Dispose().
• Enrichir les Dispose() avec les désabonnements.
• Code compilé à la volée (XSL/T compilé, sérialisation Xml, anciennement RegExp) : mettre dans des AppDomain séparés et les supprimer si nécessaire.
• Faire attention aux problèmes spécifiques à des technologies.
• Contrôler la possession des objets : le créateur n’est pas nécessairement celui qui tient l’objet, et donc en charge de leur libération.
• Bien faire un –= pour chaque +=.
• Utiliser les using et Dispose.
• Utiliser si nécessaire des WeakEvents (garde le lien mais pas si il est le seul).
• EventBroker pour des cas complexes.
• Au pire, recycler les applications sur les serveurs.

Une bonne idée est d’intégrer un écran de monitoring dans une application, qui permet de suivre les objets en vie dans un logiciel.

VMMap de Sysinternals à voir, ainsi que les autres références que je n’ai pas eu le temps de prendre en note.

[Edit]

Suite migration du blog depuis l’ancienne plateforme, je rajoute les commentaires à la main…

Fabrice Marguerie :

Merci pour le compte-rendu !
Les transparents et le code source de l’application exemple sont disponibles : weblogs.asp.net/…/…slides-and-source-code.aspx

Executive summary : le modèle de développement de SharePoint avec Visual Studio est beaucoup plus complet sur les versions 2010. On retrouve en particulier la possibilité d’utiliser Linq, de consommer des services exposés en REST, etc. Bref, SharePoint monte au niveau des autres technologies développables dans Visual Studio .NET. Ceci n’est vrai que pour les versions 2010 des deux produits.

Visual Studio 2010 promet une intégration beaucoup plus importante des développements SharePoint.

Remarque préalable : pour développer en SharePoint, il faut un SharePoint en local, et donc, vu que la version 2010 n’est que 64 bits, il faut une machine de développement en 64 bits elle aussi.

SharePoint Foundation est la version light de SharePoint Server.

Note : Boot sur VHD, retour d’expérience de l’intervenant : 3% de perte de performance environ, par rapport à du boot normal. Mais du coup, plus rapide que de la virtualisation.

Nouveautés

SharePoint 2010 apporte les fonctionnalités nouvelles suivantes :

• API Linq To SharePoint
• Interfaces à SharePoint en REST et Client Object Model
• XSL/T Views
• External lists

On dispose désormais d’un concepteur visuel pour les webparts, dans Visual Studio 2010. Quand on crée ce genre de projet, VS ajoute automatiquement un répertoire Features et un répertoire Packages. Les packages permettent de regrouper tout ce qui doit être déployé en même temps que la feature, typiquement les images, les applications Silverlight, etc.

Visual Studio 2010 permet de mettre en place un dossier mappé sur ceux de déploiement de SharePoint. Par exemple, pour bien mettre les images dans Layout / Images, on peut créer un dossier mappé dessus dans le projet VS2010, et poser les images dedans. Il y a donc, plus qu’un plugin, une véritable intégration dans VS2010.

Note : Dans le code C#, SPContext.Current.Web pour accéder au web de SharePoint. Oui, je ne connais rien du tout à la programmation SharePoint, donc je note même ce genre de chose qui est très basique.

Demos

Le débogage est démontré : ça fonctionne bien, et il n’y a plus besoin d’attacher le processus à la main.

SharePoint Designer 2010 permet de manipuler de l’XSL/T sans voir de code comme on le ferait dans Visual Studio.

SharePoint Learning Kit à chercher sur internet pour trouver des tutoriels. C’est une ressource recommandée par l’intervenant.

SPLinq

Linq For SharePoint vient avec un utilitaire logiquement appelé SPMetal. On lui passe l’URL du site web, et il génère les classes typées pour toutes les listes du site. ShareLinq transforme automatiquement les requêtes Linq en CAML, mais c’est du coup transparent pour l’utilisateur.

REST

On peut créer des sorties de service REST dans SharePoint pour qu’il envoie les listes de données dans ce format.

J’arrête là la prise de notes, car je ne connais pas assez SharePoint pour que ça ait de l’utilité à partir d’ici. Une remarque, toutefois : je ne sais pas si ça vient des versions utilisées, mais il y a encore de nombreuses petites imperfections dans le produit.

Executive summary : quand on parle de programmation parallèle, on pense immédiatement threads, locks, etc. Avant de se jeter dans ceci, il est bon de prendre un peu d’altitude et de faire de la modélisation des problèmes de concurrence comme on le ferait pour n’importe quel besoin métier. Il y a d’ailleurs des méthodes bien rôdées pour cela.

Première session technique, présentée par Bruno Boucard, sur la façon de créer ou de modifier un logiciel pour avoir un bon parallélisme. Pas orienté code, mais très bien du point de vue de l’architecture, et en particulier des approches que je n’ai pour l’instant pas trouvées dans de la littérature. De plus, du retour d’expérience très pratique qui ajoute une réelle valeur à la session.

Décomposition du travail d’architecture pour la parallélisation

Il est important de bien suivre une approche réfléchie et ne pas se lancer tête baissée dans le code. Ca paraît évident, mais la programmation parallèle a une telle réputation de domaine d’expert qu’on ne pense pas nécessairement à la partie non-technique. Les étapes proposées sont :

1. Mesurer la performance : cette étape est essentielle pour avoir une référence, sur laquelle on pourra se baser pour savoir si la parallélisation qu’on met en place résulte effectivement en une amélioration des performances globales de l’application.
2. Trouver la concurrence :
   1. L’application à paralléliser est-elle orientée données ou orientée traitements ? Ceci va bien sûr modifier l’approche de parallélisation.
   2. Trouver les dépendances fonctionnelles (inaltérables) ou techniques (sur lesquelles on peut éventuellement travailler) avec de l’outillage type NDepend.
   3. Décomposer les tâches à l’aide de ces informations, et en regardant bien la granularité des tâches, c’est-à-dire le nombre d’instructions dans chaque. Si on est sur des tâches très granulaires, attention à la partie incompressible (démarrage d’un thread, etc.).
3. On recherche alors le meilleur algorithme pour ce genre de fonctionnement :
   1. Données linéaires ou récursives => décomposition géométrique ou récursive.
   2. Tâches linéaires ou récursives => parallélisme des tâches ou division des tâches.
   3. Flux de données régulier ou pas => approche de type pipeline ou coordination orientée événements.

Quelques notes supplémentaires

Attention au problème de false-sharing : si on crée deux ensembles de données proches en mémoire (membres d’une même classe, index adjacents dans un tableau, etc.), on risque, lors de la mise en concurrence, de se retrouver avec des mises à jour importantes du cache L2 qui pénalisent la performance. Une démo montre qu’on prend facilement un facteur de 5 sur ce genre de détail.

Parcours d’un arbre : on est typiquement dans le cas récursif. On peut donc utiliser une parallélisation récursive, en faisant particulièrement attention à la profondeur de l’arbre, qui est le principal paramètre jouant sur le type de décomposition.

Diviser pour mieux régner : le bon exemple qui fait tout de suite comprendre de quoi on parle est le quicksort. Dans cet algorithme de tri, on découpe de manière récursive la liste en deux domaines, puis on traite chacun des ensembles de manière séparé. Attention dans ce cas-là : il ne faut pas non plus trop gonfler le nombre de tâches, car on perd alors en performance.

Les agents sont des systèmes qui isolent les données, et qui communiquent uniquement par des canaux. En gros, ça revient à porter l’immuabilité, qui est très importante pour la parallélisation, à un niveau plus haut dans l’architecture logicielle : ce n’est plus seulement une instance de classe qui est immuable, mais un ensemble de données qui est, vu de l’extérieur, comme fixé pendant que l’agent prend en charge son traitement. Du coup, l’agent peut se concentrer sur son traitement métier sans se préoccuper des locks, priorités, etc.

La programmation parallèle a aussi ses best practices, et propose plusieurs patterns d’utilisation dans les programmes :

• Single Program Multiple Data : plusieurs traitements identiques sur des données découpées en blocs typiquement de même taille.
• Master Worker : le master push du boulot aux workers par une queue, et les workers traitent.
• Boucle parallèle : décomposition géométrique de données.
• Fork / Join : on lance plusieurs tâches en parallèle et on attend leur fin. Cette méthode s’adapte bien à de nombreux cas.

Pour éviter au maximum les locks retardant les threads si ils lisent de la donnée partagée, on peut utiliser le Thread Local Storage.

ConcurrentQueue<T> encapsule une Queue<T> en l’exposant de la même manière, mais en garantissant une prise en charge efficace des locks, et en la masquant au consommateur.

Conclusions

Les conclusions du présentateur de la session sont les suivantes :

• Prendre un haut niveau d’abstraction.
• Utiliser des solutions simples à maintenir.
• Attention à bien utiliser des librairies threadsafe.
• Ne jamais préjuger de l’ordre d’exécution : l’ordre d’exécution des threads n’est pas déterministe, et on peut très bien se retrouver avec une application qui fonctionne dans certains cas et pas d’autres. Attention donc à bien tester la justesse du code.

Il insiste également sur l’importance de l’itératif. Comme pour le code métier, il faut itérer pour arriver à un bon résultat. Le but derrière étant de revenir au Free Lunch, bref la bonne vieille époque où les applications allaient plus vite car les processeurs augmentaient en fréquence. Sauf que maintenant, il faut arriver à architecturer les applications de façon qu’elles gagnent automatiquement en performance lorsque le nombre de cœurs augmente, l’augmentation de performance par la montée en fréquence étant tarie.

Personnellement, je retiens surtout la notion de modélisation, d’architecture en étape pour mettre en place le parallélisme, et je note les trois bouquins référencés par Thierry Boucard, à savoir :

• Patterns for Parallel Programming
• Concurrency in Programming Languages
• The Art of Concurrency

On a souvent tendance à prendre le parallélisme du point de vue technique (PLinq, OpenMP, etc.), mais, comme d’habitude, il est essentiel de prendre de la hauteur pour faire des bons programmes. Bref, une session très utile pour prendre le problème de la parallélisation par le bon bout.