Plongée au coeur du framework .NET 4.5 : FinaxysConseil et architecture IT-FINANCE• 160 collaborateurs spécialisés en IT-F...
Plongée au coeur du framework .NET 4.5 : MindMatcherMoteur de recherche innovant appliqué au domaine durecrutement• Startu...
Lesnouveautésduframework.NET4.5Plongée au coeur du framework .NET 4.5 : de quoi va-t-on parler ?
AgendaPlongée au coeur du framework .NET 4.5 : agendaGarbagecollectorJITTERConcurrenceADebugging1 234Q/A5
Fonctionnement généralPlongée au coeur du framework .NET 4.5 : fonctionnement général du garbage collectorGarbagecollector...
Plongée au coeur du framework .NET 4.5 : fonctionnement général du garbage collectorFondamentaux sur le Garbage Collector ...
Plongée au coeur du framework .NET 4.5 : fonctionnement général du garbage collectorUne animation pour expliquer tout çaMé...
Plongée au coeur du framework .NET 4.5 : fonctionnement général du garbage collectorLes points faibles du GC• Le GC pause ...
ConfigurationPlongée au coeur du framework .NET 4.5 : configuration du garbage collectorGarbagecollectorJITTERDebugging1Q/...
Plongée au coeur du framework .NET 4.5 : une pause philosophiqueUne pausephilosophique« Ne change le paramétrage du GC qu’...
Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorConfiguration workstation/server<configuration>...
Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorConfiguration workstation/server<configuration>...
Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorConfiguration concurrent/non concurrent<configu...
Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorLes différentes collections du point de vue des...
Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorLes différentes collections du point de vue des...
Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorLes différentes collections du point de vue des...
Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorLes différentes collections du point de vue des...
Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorDernier réglage :System.Runtime.GCSettings.Late...
Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorFinalement : l’arbre de décisionAppliquer lesco...
Large Object HeapPlongée au coeur du framework .NET 4.5 : Large Object HeapGarbagecollectorJITTERDebugging1Q/AConcurrence
Plongée au coeur du framework .NET 4.5 : Large Object HeapLe Large Object Heap (LOH pour lesintimes)• Il est long de compa...
Plongée au coeur du framework .NET 4.5 : Large Object HeapAvant, le LOH acceptait les gros objets, mais pas trop gros quan...
Fonctionnement généralPlongée au coeur du framework .NET 4.5 : fonctionnement général du JITTERGarbagecollectorJITTERDebug...
Plongée au coeur du framework .NET 4.5 : fonctionnement général du JITTERLe compilateur Just-In-Time (JITTER pour lesintim...
Multicore JITPlongée au coeur du framework .NET 4.5 : Multicore JITGarbagecollectorJITTERDebuggingQ/A2Concurrence
Plongée au coeur du framework .NET 4.5 : Multicore JITAccélérer le JIT : le Multicore JIT• Permet d’enregistrer dans un fi...
MPGOPlongée au coeur du framework .NET 4.5 : Managed Profile Guided OptimizationGarbagecollectorJITTERDebuggingQ/A2Concurr...
Plongée au coeur du framework .NET 4.5 : Managed Profile Guided Optimization• Le code généré par NGEN.exe estgénéralement ...
Plongée au coeur du framework .NET 4.5 : Managed Profile Guided OptimizationLe Managed Profile Guided Optimization : comme...
ReadOnlyReadOnlyPlongée au coeur du framework .NET 4.5 : Managed Profile Guided OptimizationLe Managed Profile Guided Opti...
NGEN AutomatiquePlongée au coeur du framework .NET 4.5 : NGEN AutomatiqueGarbagecollectorJITTERDebuggingQ/A2Concurrence
Plongée au coeur du framework .NET 4.5 : NGEN AutomatiqueAméliorer NGEN : Le NGENautomatique• Disponible uniquement sous W...
Re-JIT & Memory HeapDebugging APIsPlongée au coeur du framework .NET 4.5 : Re-JIT & Memory Heap Debugging APIsGarbagecolle...
Plongée au coeur du framework .NET 4.5 : Re-JIT & Memory Heap Debugging APIs APIsRe-JIT & Memory Heap DebuggingAPIs• Re-JI...
Plongée au coeur du framework .NET 4.5 : Motivations async/awaitGarbagecollectorJITTERConcurrenceDebuggingQ/A4MotivationsF...
• Croissance d’Internet / du Cloud• Utilisateurs réclament des interfaces plusdisponibles• La latence provient de deux sou...
Synchrone &Asynchrone au quotidienC’est l’histoired’un coup de filPlongée au coeur du framework .NET 4.5 : Motivations asy...
• Offre une meilleure combinaison efficacité/scalabilité• Evite de bloquer des threads• Appelant n’a pas à coder une couch...
À quoi ressemblerait la méthodeasynchrone la plus simple possible ?Plongée au coeur du framework .NET 4.5 : Motivations as...
Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas – Du synchrone à l’asynchronestring GetWebPag...
Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas – Utilisation deAction<TResult>void GetWebPag...
Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas – Utilisation deTask<TResult>Task<string> Get...
Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas – Implémentation avec Task<TResult>Task<strin...
Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas – Introduction d’une boucle !string GetWebPag...
Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas –Adaptation du codeTask<string> GetWebPageAsy...
Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas – Utilisation de C# 5.0Task<string> GetWebPag...
• Continuations et code impératif ne peuvent pasêtre mélangé proprement !• Ceci explique pourquoi nous avons besoin dusupp...
ASYNC / AWAITSynchrone vs AsynchronePlongée au coeur du framework .NET 4.5 : Motivations async/await
Plongée au coeur du framework .NET 4.5 : Fondamentaux async/awaitGarbagecollectorJITTERDebuggingQ/AConcurrence4Motivations...
• Task• Task<TResult>• Généralement retourné depuis des APIs async .NET 4.5– Vous pouvez aussi produire vos propres méthod...
• async Task FooAsync(…);• Peut-être attendu• “Retourne le contrôle”• Délègue le traitement enasynchrone• Utilisable par d...
• Céder le contrôleawait Task.Delay(5000);await Task.Yield();• Exécution en tâche de fondvar result = await Task.Run(() =>...
ASYNC / AWAITMise au point d’un code asynchronePlongée au coeur du framework .NET 4.5 : Fondamentaux async/await
Plongée au coeur du framework .NET 4.5 : Performances async/awaitGarbagecollectorJITTERDebuggingQ/AConcurrence4Motivations...
• Des années d’expérience dans la production de code synchroneAnalyse d’une simple méthode synchronePlongée au coeur du fr...
• Les méthodes asynchrones ont-elles un coûtfaible ?Plongée au coeur du framework .NET 4.5 : Performances du parallélismeA...
• “await task;” se poursuit sur:– Le SynchronizationContext courant– Si nul alors « await » utilise le TaskScheduler coura...
• Task.ConfigureAwait(bool continueOnCapturedContext)– true (défaut)• Poste une continuation vers le contexte actuel/sched...
Plongée au coeur du framework .NET 4.5 : Performances async/awaitUtiliser ConfigureAwait(false)async void button1_Click(…)...
• Les variables locales doivent survivre à la suspension d’exécution– Compilateur converti les variables locales en champs...
Plongée au coeur du framework .NET 4.5 : Parallélisme, quoi de neuf en 4.5GarbagecollectorJITTERDebuggingQ/AConcurrence4Qu...
• ConcurrentExclusiveSchedulerPair– Fourni un support pour orchestrer des tâches de type lecteur/écrivain• CancellationTok...
CONTRÔLER L’EXÉCUTIONConcurrentExclusiveSchedulerPairPlongée au coeur du framework .NET 4.5 : Parallélisme, quoi de neuf e...
Plongée au coeur du framework .NET 4.5 : Parallélisme, quoi de neuf en 4.5PERFORMANCE ENTRE 4.0 ET4.5
Plongée au coeur du framework .NET 4.5 : Parallélisme, quoi de neuf en 4.5.NET 4.5 & Visual Studio2012ParallelPatternLibra...
Plongée au coeur du framework .NET 4.5 : Q/AGarbagecollectorJITTERConcurrenceDebuggingQ/A5
Plongée au coeur du framework .NET 4.5 : SourcesSources• CLR via C# by Jeffrey Richter (the best !)• http://blogs.msdn.com...
Formez-vous en ligneRetrouvez nos évènementsFaites-vous accompagnergratuitementEssayer gratuitement nossolutions ITRetrouv...
Prochain SlideShare
Chargement dans…5
×

Plongée au cœur du Framework .NET 4.5

806 vues

Publié le

La nouvelle version du Framework .NET apporte des innovations majeures qui permettent encore plus de performance et accroissent le champ des possibles. Du poste client au serveur d’entreprise, ce jeu de nouvelles fonctionnalités logée au cœur du noyau vous offrent une gestion plus fine de votre code et donnent un nouveau souffle à vos applications. Ne manquez pas cette session et venez découvrir comment augmenter considérablement les performances de vos programmes et tirer parti de toute la puissance des ordinateurs modernes.

0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
806
Sur SlideShare
0
Issues des intégrations
0
Intégrations
3
Actions
Partages
0
Téléchargements
36
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive
  • Je sais pas si on va garder ce slide : c’est juste histoire de resituer le contexte de ce dont on va parler
  • Agenda
  • Titre de chapitre 4eme version
  • Le GC gère les allocations (new) et désallocations de mémoire (delete)Le GC est de type « générationnel », c’est-à-dire qu’il classe les objets par portion selon leur date de création. En effet, expérimentalement on constate que :Plus un objet est récent, plus courte sera sa durée de viePlus un objet est vieux, plus longue sera sa durée de vieRéclamer la mémoire sur une petite portion est plus rapide que sur toute la mémoireLe GC .NET contient 3 générations : la 0 est celle contenant les objet les plus récents, la 2 est celle contenant les objets les plus vieux
  • Les blocs de couleurs sont éditables et peuvent reprendre la couleur du type de session qui est donnée.
  • Les blocs de couleurs sont éditables et peuvent reprendre la couleur du type de session qui est donnée.
  • Titre de chapitre 4eme version
  • Les blocs de couleurs sont éditables et peuvent reprendre la couleur du type de session qui est donnée.
  • A finir
  • A finir
  • Les collections 0 et 1 sonttoujoursblocantes
  • A finir
  • A finir
  • A finir
  • A finir
  • A finir
  • A finir
  • Titre de chapitre 4eme version
  • L’existence du LOH part d’une constatation simple : il est long de compacter (= déplacer) des gros objectsPour pallier à ce problème, les objets considérés « gros » (aujourd’hui définit comme étant supérieurs ou égaux à 84988 octets) ne sont pas placés dans les tas classiques (les tas générationnels) mais dans le LOH.Lors d’une collection, les objets non-accessibles sont libérés, mais le LOH n’est pas compacté. Cela veux dire qu’il n’est pas géré comme les tas générationnels (dans lequel une allocation revient à déplacer un pointeur), mais comme une « free list » classique (de la même façon que les ‘new’ en C++) : la création d’un gros objet est donc beaucoup plus lente
  • Titre de chapitre 4eme version
  • Titre de chapitre 4eme version
  • Titre de chapitre 4eme version
  • Titre de chapitre 4eme version
  • Titre de chapitre 4eme version
  • Titre de chapitre 4eme version
  • Titre de chapitre 4eme version
  • Titre de chapitre 4eme version
  • Exemple de page de code pour le secteur dev
  • Exemple de page de code pour le secteur dev
  • Exemple de page de code pour le secteur dev
  • Exemple de page de code pour le secteur dev
  • Exemple de page de code pour le secteur dev
  • Exemple de page de code pour le secteur dev
  • Exemple de page de code pour le secteur dev
  • Titre de chapitre 4eme version
  • Titre de chapitre 4eme version
  • Titre de chapitre 4eme version
  • Titre de chapitre 4eme version
  • Plongée au cœur du Framework .NET 4.5

    1. 1. Plongée au coeur du framework .NET 4.5 : FinaxysConseil et architecture IT-FINANCE• 160 collaborateurs spécialisés en IT-Finance• CA 2012 (prév.) de 16M€• Une large palette d’expertises :• Conseil SI & fonctionnel Finance,• AMOA SI et métiers Finance• Ingénierie logicielle (architecture, études, conception, développement, intégration continue)• Technologies Microsoft C++ et C#/.NET 4.0• Support et production applicative• Un accompagnement global sur l’ensemble du cycle de vie projet, du cadrage à la recette, avec une démarchequalité intégrée• Une contractualisation sur mesure : forfait, centre de service, assistance technique groupée ou assistance techniquesimple• Nos références :
    2. 2. Plongée au coeur du framework .NET 4.5 : MindMatcherMoteur de recherche innovant appliqué au domaine durecrutement• Startup fondée en 2011• 5 fondateurs• Fonctionnalités principales :• Méthodes de recherche probabilistes• Aucune structuration des documents• Aucun mot clef : utilisation du CV ou de l’offre d’emploi comme clef de recherche• Algorithme d’enrichissement automatique• Apprentissage par réseaux de neurones des préférences de l’utilisateur• Rapidité et simplicité• La pertinence augmente avec la taille de la base de documentshttp://www.mindmatcher.orgcontact@mindmatcher.org
    3. 3. Lesnouveautésduframework.NET4.5Plongée au coeur du framework .NET 4.5 : de quoi va-t-on parler ?
    4. 4. AgendaPlongée au coeur du framework .NET 4.5 : agendaGarbagecollectorJITTERConcurrenceADebugging1 234Q/A5
    5. 5. Fonctionnement généralPlongée au coeur du framework .NET 4.5 : fonctionnement général du garbage collectorGarbagecollectorJITTERConcurrenceDebugging1Q/A
    6. 6. Plongée au coeur du framework .NET 4.5 : fonctionnement général du garbage collectorFondamentaux sur le Garbage Collector (GC pour lesintimes)• Le GC gère la mémoire• Le GC est de type « générationnel » car :– Plus un objet est récent, plus courte sera sa durée de vie– Plus un objet est vieux, plus longue sera sa durée de vie– Réclamer la mémoire sur une petite portion est plusrapide que sur toute la mémoire• Le GC .NET utilise 3 générations
    7. 7. Plongée au coeur du framework .NET 4.5 : fonctionnement général du garbage collectorUne animation pour expliquer tout çaMémoire allouée dans le processusA B C D EGénération 0Etape 0 (démarrage du processus)• Le GC alloue une portion de mémoire (généralement 32Mo)• Le GC décide d’une quantité de mémoire à allouer à la génération 0• Une fois que c’est fini, il donne la main au code utilisateurFEtape 1 (exécution du code utilisateur)• L’utilisateur alloue des objets….• …jusqu’à ce que le budget de la génération 0 soit epuiséEtape 2 (le GC reprend la main et déclenche une collection en 4 phases)void main(){A a = new A();B b = new B();C c = new C();D d = new D();E e = new E();F f = new F();Console.WriteLine("{0}{1}{2}{3}",a,c,e,f);}F f = new F();• Phase 1 : le GC pause tous les threadsConsole.WriteLine("{0}{1}{2}{3}",a,c,e,f);}• Phase 2 : il regarde les objets qui ne sont plus utilisés (marquage)B D• Phase 3 : il compacte les objets (compactage)Génération 1• Phase 4 : il alloue l’objet et redonne la main au code utilisateurFEtapes suivantes : le GC continue à gérer les objets de la même façon, encréant la génération 2 dans un deuxième passage (si des objets de lagénération 1 sont toujours accessibles) et en allouant plus de mémoiredans le processus si besoinG H I JMémoire allouée dans le processusGénération 0Génération 2Mémoire allouée dans le processus…Génération 0Génération 1Génération 2
    8. 8. Plongée au coeur du framework .NET 4.5 : fonctionnement général du garbage collectorLes points faibles du GC• Le GC pause tous les threads pendantqu’il travaille• Un seul thread fait tout le travail• Marquer et compacter la génération 2peut-être très longLes différents moyens de configurer le GC permettent de diminuer l’impact de telou tel point
    9. 9. ConfigurationPlongée au coeur du framework .NET 4.5 : configuration du garbage collectorGarbagecollectorJITTERDebugging1Q/AConcurrence
    10. 10. Plongée au coeur du framework .NET 4.5 : une pause philosophiqueUne pausephilosophique« Ne change le paramétrage du GC qu’après mûre réflexion »Parole de sage, par Gordon Liuhttp://msdn.microsoft.com/en-us/library/ff647790.aspx
    11. 11. Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorConfiguration workstation/server<configuration><runtime><gcServer enabled=“false"/></runtime></configuration>• Mode workstation (par défaut)– Optimisé pour les applications graphiques– Le GC essaie de minimiser le temps passé à faire sontravail, et donc minimise le temps de pause desthreads, pour une meilleure expérience utilisateur– Plusieurs processus sur une même machine peuventêtre en mode workstation sans poser de problèmede performance
    12. 12. Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorConfiguration workstation/server<configuration><runtime><gcServer enabled=“true"/></runtime></configuration>• Mode server– Optimisé pour les applications serveurs– Le GC crée un thread par processeur logique (avecune priorité haute)– Le GC crée un tas managé et un Large Object Heappar processeur logique– Le GC part du principe qu’il a toute la puissance del’ordinateur à sa disposition : une seule applicationpar ordinateur devrait utiliser ce mode
    13. 13. Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorConfiguration concurrent/non concurrent<configuration><runtime><gcConcurrent enabled=“true"/></runtime></configuration>• Mode concurrent (mode par défaut)– Utilise un ou plusieurs threads dédiés à la collectionde la génération 2– Lors d’une collection de génération 2 :• Les autres threads managés ne sont(pratiquement) pas stoppés• Une collection de génération 0 ou 1 estpossible (mais reste bloquante)<configuration><runtime><gcConcurrent enabled=“false"/></runtime></configuration>• Mode non concurrent– Le thread qui demande la collection fait le travail etbloque les autres threads
    14. 14. Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorLes différentes collections du point de vue desthreadsUser thread 1User thread 2User thread 3Workstation / non concurrentuser workingGC workingsuspendedCollecte des génération 0, 1 et/ou 2
    15. 15. Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorLes différentes collections du point de vue desthreadsUser thread 1User thread 2User thread 3Workstation / concurrent (mode par défaut)user workingforeground GC workingsuspendedGC background threadbackground GC workingCollecte desgénération 0 et 1Collecte de la génération 2 idle
    16. 16. Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorLes différentes collections du point de vue desthreadsUser thread 1User thread 2User thread 3Server / concurrent (sur un biprocesseur)GC background thread CPU 0Collecte des génération 0 et 1(répartition du travail entre les threads)Collecte de la génération 2 (répartitiondu travail entre les threadsuser workingforeground GC workingsuspendedbackground GC workingidleGC thread CPU 0GC thread CPU 1GC background thread CPU 1
    17. 17. Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorLes différentes collections du point de vue desthreadsUser thread 1User thread 2User thread 3Server / non concurrent (sur un biprocesseur)Collecte des génération 0, 1 et/ou 2(répartition du travail entre les threads)user workingsuspendedGC workingidleGC thread CPU 0GC thread CPU 1
    18. 18. Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorDernier réglage :System.Runtime.GCSettings.LatencyMode• 4 valeurs possibles– Batch : par default en Server mode, passe en mode non concurrent– Interactive : par default en Workstation mode, passe en mode concurrent– LowLatency : à utiliser de manière temporaire, le GC évite le plus possible lescollections de génération 2– SustainedLowLatency : le GC ne fait des collections de génération 2 que si l’OSdéclenche le « Low Memory Condition ». Attention, dans ce mode il vaut mieuxavoir beaucoup de mémoire vive…
    19. 19. Plongée au coeur du framework .NET 4.5 : configuration du garbage collectorFinalement : l’arbre de décisionAppliquer lesconseils deMicrosoftMode = Server / concurrentSi pas suffisant, tenter dans l’ordre :- LowLatency dans les opérationscritiques- SustainedLowLatency (et acheterbeaucoup de RAM !)- Augmenter le nombre de CPUMode = Workstation / concurrentSi pas suffisant, tenter dans l’ordre :- LowLatency dans les opérationscritiques- Workstation / non concurrent- Mettre l’application seule sur unordinateurMode workstation obligé.Tenter dans l’ordre :- Mode concurrent- Acheter une nouvellemachine L’application neréponds paspendant delongs moments ?Machinemono-processeur ?Applicationseule surl’ordinateur ?Problèmede GC ?ouinonouiouinonnon
    20. 20. Large Object HeapPlongée au coeur du framework .NET 4.5 : Large Object HeapGarbagecollectorJITTERDebugging1Q/AConcurrence
    21. 21. Plongée au coeur du framework .NET 4.5 : Large Object HeapLe Large Object Heap (LOH pour lesintimes)• Il est long de compacter (= déplacer) des gros objetsPour remédier à ce problème :– Le GC alloue les objets considérés « gros » (>85Ko) dans le LOH.– le LOH n’est pas compacté : on gagne en temps dans le GC, mais la création d’un grosobjet est par contre beaucoup plus lente• Le framework .NET 4.5 apporte une amélioration de 30%de la vitesse d’allocation dans le LOH par rapport auframework 4.
    22. 22. Plongée au coeur du framework .NET 4.5 : Large Object HeapAvant, le LOH acceptait les gros objets, mais pas trop gros quandmême• Pour allouer des objets plus gros que 2Go avec le framework 4.5• Ce n’est disponible qu’en 64bits• Cela ne change pas le fait qu’un Array ne peut pas contenir plus de 0xFFFFFFFF = 4,294,967,295éléments toutes dimensions confondues, et chaque dimension ne peut pas contenir plus de0X7FEFFFFF = 2,146,435,071 indexes (0x7FFFFFC7 = 2,147,483,591 si ce sont des bytes)• La taille maximum du type String ne change pas (à savoir 0x7fffffff = 2,147,483,647 caractères)<configuration><runtime><gcAllowVeryLargeObjects enabled="true" /></runtime></configuration>
    23. 23. Fonctionnement généralPlongée au coeur du framework .NET 4.5 : fonctionnement général du JITTERGarbagecollectorJITTERDebuggingQ/A2Concurrence
    24. 24. Plongée au coeur du framework .NET 4.5 : fonctionnement général du JITTERLe compilateur Just-In-Time (JITTER pour lesintimes)• Transforme à la volée le code IL (résultat de la compilationde source .NET) en code assembleur• Ne fait la compilation qu’à la demande (just in time), et uneseule fois par fonction• Certaines applications/services ont besoin de démarrer leplus vite possible, et souffrent du temps de JIT• Il est possible de compiler à l’avance (NGEN.exe) mais celapose d’autres problèmesMAIS !
    25. 25. Multicore JITPlongée au coeur du framework .NET 4.5 : Multicore JITGarbagecollectorJITTERDebuggingQ/A2Concurrence
    26. 26. Plongée au coeur du framework .NET 4.5 : Multicore JITAccélérer le JIT : le Multicore JIT• Permet d’enregistrer dans un fichier lesdécisions du JITTER, ainsi que la liste desfonctions à compiler• Seulement deux lignes à ajouter• De 20% à 50% de gain sur les démarragesd’applicationProfileOptimization.SetProfileRoot(@"C:Startup");ProfileOptimization.StartProfile("Startup.Profile");
    27. 27. MPGOPlongée au coeur du framework .NET 4.5 : Managed Profile Guided OptimizationGarbagecollectorJITTERDebuggingQ/A2Concurrence
    28. 28. Plongée au coeur du framework .NET 4.5 : Managed Profile Guided Optimization• Le code généré par NGEN.exe estgénéralement moins optimal que celui duJITTER• Le MPGO remédie (en partie) à ce problèmeAméliorer NGEN : le Managed Profile GuidedOptimization
    29. 29. Plongée au coeur du framework .NET 4.5 : Managed Profile Guided OptimizationLe Managed Profile Guided Optimization : commentl’utiliser ?• 4 étapes– Compilation des assembly– Utilisation de l’exécutable MPGO.exe– Utilisation de l’exécutable ainsi lancé– OptimisationMpgo.exe –scenario Toto.exe –OutDir .Data –AssemblyList Toto.exeNGEN.exe .DataToto.exe
    30. 30. ReadOnlyReadOnlyPlongée au coeur du framework .NET 4.5 : Managed Profile Guided OptimizationLe Managed Profile Guided Optimization : ça fait quoiexactement ?Espacemémoireutiliséparl’assemblyEspacemémoireduprocessusPageFonction 1Fonction 2ReadOnlyCopy-on-writeCopy-on-writeCopy-on-writeReadOnlyReadOnlyLa mémoire est divisée en pagesUne page peut être :ReadOnly (le code des fonctions)Copy-on-write (les membre statiques)Localité des fonctionsLocalité des données Donnée 1Donnée 2Le MPGO s’assure de compartimenter la mémoireentre très/peu utilisé et Readonly/Copy-on-writeFonctionstrès utiliséesDonnées très utiliséesFonctionspeu utiliséesDonnées peuutilisées
    31. 31. NGEN AutomatiquePlongée au coeur du framework .NET 4.5 : NGEN AutomatiqueGarbagecollectorJITTERDebuggingQ/A2Concurrence
    32. 32. Plongée au coeur du framework .NET 4.5 : NGEN AutomatiqueAméliorer NGEN : Le NGENautomatique• Disponible uniquement sous Windows 8(version desktop, pas serveur)• Selon la fréquence d’utilisation, installe oudésinstalle la version native des assembly• Cibles :– Sous .NET 3.5 et 4.0, le framework seulement– Sous .NET 4.5• Applications desktop : seulement dans le GAC– Windows Store App : tout
    33. 33. Re-JIT & Memory HeapDebugging APIsPlongée au coeur du framework .NET 4.5 : Re-JIT & Memory Heap Debugging APIsGarbagecollectorJITTERConcurrenceDebuggingQ/A3
    34. 34. Plongée au coeur du framework .NET 4.5 : Re-JIT & Memory Heap Debugging APIs APIsRe-JIT & Memory Heap DebuggingAPIs• Re-JIT : il est possible deprofiler temporairement ducode, puis revenir commeavant, sans redémarrer leprocessus• ICoreDebugProcess5 :permet d’énumerer trèsfacilement les objets des tasmanagés• …
    35. 35. Plongée au coeur du framework .NET 4.5 : Motivations async/awaitGarbagecollectorJITTERConcurrenceDebuggingQ/A4MotivationsFondamentauxPerformances
    36. 36. • Croissance d’Internet / du Cloud• Utilisateurs réclament des interfaces plusdisponibles• La latence provient de deux sources- Calcul CPU intensif- Entrées/Sorties (Disque, Réseaux …)La latence devient un sujet très importantPlongée au coeur du framework .NET 4.5 : Motivations async/await
    37. 37. Synchrone &Asynchrone au quotidienC’est l’histoired’un coup de filPlongée au coeur du framework .NET 4.5 : Motivations async/await
    38. 38. • Offre une meilleure combinaison efficacité/scalabilité• Evite de bloquer des threads• Appelant n’a pas à coder une couche de plomberie• Appelant est dégagé de problèmes de threading• Offre une forme d’abstraction vis-à-vis de la concurrenceLes avantages de l’asynchronismePlongée au coeur du framework .NET 4.5 : Motivations async/await
    39. 39. À quoi ressemblerait la méthodeasynchrone la plus simple possible ?Plongée au coeur du framework .NET 4.5 : Motivations async/await
    40. 40. Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas – Du synchrone à l’asynchronestring GetWebPage (string uri){......}void Test(){string html = GetWebPage(“...”);Console.WriteLine (html);}
    41. 41. Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas – Utilisation deAction<TResult>void GetWebPageAsync (string uri, Action<string> continuation){......}void Test(){GetWebPageAsync(“...”, Console.WriteLine);}
    42. 42. Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas – Utilisation deTask<TResult>Task<string> GetWebPageAsync (string uri){......}Task<TResult>PropriétéResult PropriétéExceptionMéthodeContinueWith()
    43. 43. Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas – Implémentation avec Task<TResult>Task<string> GetWebPageAsync (string uri){......}void Test(){GetWebPageAsync(“...”).ContinueWith (task =>Console.WriteLine (task.Result));}
    44. 44. Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas – Introduction d’une boucle !string GetWebPage (string uri){......}void Test(){for (int i = 0; i < 5; i++){string html = GetWebPage(“...”);Console.WriteLine (html);}}
    45. 45. Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas –Adaptation du codeTask<string> GetWebPageAsync (string uri){......}int _i = 0;void Test(){GetWebPageAsync(“...”).ContinueWith (task =>{Console.WriteLine (task.Result);if (++_i < 5) Test();});}
    46. 46. Plongée au coeur du framework .NET 4.5 : Motivations async/awaitEtude de cas – Utilisation de C# 5.0Task<string> GetWebPageAsync (string uri){......}async void Test(){for (int i = 0; i < 5; i++){string html = await GetWebPageAsync(“...”);Console.WriteLine (html);}}Continuation s’exécutera dans le même thread de l’appelant lorsque GetWebPageAsync sera terminée.Donc pas de problème de mise à jour inter-threads vis-à-vis de l’interface graphique.GetWebPageAsync retourne après avoir initialisée l’appel asynchroneLa boucle est capturée aussi de manière similaire au « yield return »
    47. 47. • Continuations et code impératif ne peuvent pasêtre mélangé proprement !• Ceci explique pourquoi nous avons besoin dusupport du langage pour produire du codeasynchrone facilement maintenable– Moins de ligne de code à écrire– Complexité cyclomatique fortement réduitePourquoi utiliser le support async / await?Plongée au coeur du framework .NET 4.5 : Motivations async/await
    48. 48. ASYNC / AWAITSynchrone vs AsynchronePlongée au coeur du framework .NET 4.5 : Motivations async/await
    49. 49. Plongée au coeur du framework .NET 4.5 : Fondamentaux async/awaitGarbagecollectorJITTERDebuggingQ/AConcurrence4MotivationsFondamentauxPerformances
    50. 50. • Task• Task<TResult>• Généralement retourné depuis des APIs async .NET 4.5– Vous pouvez aussi produire vos propres méthodesasynchrones• Attendre une tâche qui s’exécute déjà• Attendre directement un appel asynchrone• Ou attendre plusieurs fois• Stocker la tâche et attendre ultérieurementQuel type pouvons-nous attendre avec le mot clef await?Plongée au coeur du framework .NET 4.5 : Fondamentaux async/await
    51. 51. • async Task FooAsync(…);• Peut-être attendu• “Retourne le contrôle”• Délègue le traitement enasynchrone• Utilisable par des Task Helpers• Utilisable par des méthodes delibrairies• async void Foo_Click(…);• Ne peut être attendu• “Fire and forget”• Poursuis un flot d’exécutionindépendant• Utilisable par des eventhandlers• Utilisable pour surcharger desméthodes “void”Retourner une Task versus retourner voidPlongée au coeur du framework .NET 4.5 : Fondamentaux async/await
    52. 52. • Céder le contrôleawait Task.Delay(5000);await Task.Yield();• Exécution en tâche de fondvar result = await Task.Run(() => { … work … });• Composition ParallèleTask first = await Task.WhenAny(task1, task2);var results = await Task.WhenAll(task1, task2);Task helpersPlongée au coeur du framework .NET 4.5 : Fondamentaux async/await
    53. 53. ASYNC / AWAITMise au point d’un code asynchronePlongée au coeur du framework .NET 4.5 : Fondamentaux async/await
    54. 54. Plongée au coeur du framework .NET 4.5 : Performances async/awaitGarbagecollectorJITTERDebuggingQ/AConcurrence4MotivationsFondamentauxPerformances
    55. 55. • Des années d’expérience dans la production de code synchroneAnalyse d’une simple méthode synchronePlongée au coeur du framework .NET 4.5 : Performances async/awaitpublic static void SimpleBody() {Console.WriteLine("Hello, Async World!");}.method public hidebysig static void SimpleBody() cil managed{.maxstack 8L_0000: ldstr "Hello, Async World!"L_0005: call void [mscorlib]System.Console::WriteLine(string)L_000a: ret}• Des années d’expérience à produire du code optimisé
    56. 56. • Les méthodes asynchrones ont-elles un coûtfaible ?Plongée au coeur du framework .NET 4.5 : Performances du parallélismeAnalyse dune simple méthode asynchronepublic static async Task SimpleBody() {Console.WriteLine("Hello, Async World!");}.method public hidebysig static class [mscorlib]System.Threading.Tasks.Task SimpleBody() cil managed{.custom instance void [mscorlib]System.Diagnostics.DebuggerStepThroughAttribute::.ctor() = ( 01 00 00 00 )// Code size 32 (0x20).maxstack 2.locals init ([0] valuetype Program/<SimpleBody>d__0 V_0)IL_0000: ldloca.s V_0IL_0002: call valuetype [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder[mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder::Create()IL_0007: stfld valuetype [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder Program/<SimpleBody>d__0::<>t__builderIL_000c: ldloca.s V_0IL_000e: call instance void Program/<SimpleBody>d__0::MoveNext()IL_0013: ldloca.s V_0IL_0015: ldflda valuetype [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder Program/<SimpleBody>d__0::<>t__builderIL_001a: call instance class [mscorlib]System.Threading.Tasks.Task [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder::get_Task()IL_001f: ret}s.method public hidebysig instance void MoveNext() cil managed{// Code size 66 (0x42).maxstack 2.locals init ([0] bool <>t__doFinallyBodies, [1] class [mscorlib]System.Exception <>t__ex).try{IL_0000: ldc.i4.1IL_0001: stloc.0IL_0002: ldarg.0IL_0003: ldfld int32 Program/<SimpleBody>d__0::<>1__stateIL_0008: ldc.i4.m1IL_0009: bne.un.s IL_000dIL_000b: leave.s IL_0041IL_000d: ldstr "Hello, Async World!"IL_0012: call void [mscorlib]System.Console::WriteLine(string)IL_0017: leave.s IL_002f}catch [mscorlib]System.Exception{IL_0019: stloc.1IL_001a: ldarg.0IL_001b: ldc.i4.m1IL_001c: stfld int32 Program/<SimpleBody>d__0::<>1__stateIL_0021: ldarg.0IL_0022: ldflda valuetype [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilderProgram/<SimpleBody>d__0::<>t__builderIL_0027: ldloc.1IL_0028: call instance void[mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder::SetException(class [mscorlib]System.Exception)IL_002d: leave.s IL_0041}IL_002f: ldarg.0IL_0030: ldc.i4.m1IL_0031: stfld int32 Program/<SimpleBody>d__0::<>1__stateIL_0036: ldarg.0IL_0037: ldflda valuetype [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilderProgram/<SimpleBody>d__0::<>t__builderIL_003c: call instance void [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder::SetResult()IL_0041: ret}
    57. 57. • “await task;” se poursuit sur:– Le SynchronizationContext courant– Si nul alors « await » utilise le TaskScheduler courant• Au niveau du code applicatif:– Ce comportement est presque toujours ce que vous voulez• Au niveau du code d’une librairie :– Ce comportement n’est jamais ce que vous voulez !Plongée au coeur du framework .NET 4.5 : Performances async/awaitSynchronizationContext
    58. 58. • Task.ConfigureAwait(bool continueOnCapturedContext)– true (défaut)• Poste une continuation vers le contexte actuel/scheduler– false• Si possible, poursuivre lexécution de la continuation dans une tâche du pool• Implications– Performance• Eviter si possible le marshaling inter-threads, très couteux• Deadlock– Le code ne devrait pas bloquer le thread de l’interface graphique pour éviter des« dead-locks » potentielsPlongée au coeur du framework .NET 4.5 : Performances async/awaitSynchronizationContext
    59. 59. Plongée au coeur du framework .NET 4.5 : Performances async/awaitUtiliser ConfigureAwait(false)async void button1_Click(…){await DoWorkAsync();}async void button1_Click(…){DoWorkAsync().Wait();}async Task DoWorkAsync(){await Task.Run(…);Console.WriteLine("Done task");}1. DoWorkAsync appelédepuis thread graphique3. Await capture leSynchronizationContext et engendreune continuation à exécuter lorsquela tâche sera terminée4. IHM bloque enattendant que la méthodeDoWorkAsync termine satâche6. thread graphique esttoujours bloqué en attenteque l’opérationasynchrone se termine.Deadlock!.ConfigureAwait(false) évite le deadlock.async Task DoWorkAsync(){await Task.Run(…).ConfigureAwait(false);Console.WriteLine("Done task");}2. Task.Run exécute la tâchedans le pool de threads5. Task.Run se termine dans le pool & invoque lacontinuation qui est repoussée dans le thread graphique
    60. 60. • Les variables locales doivent survivre à la suspension d’exécution– Compilateur converti les variables locales en champs dans la machine à état• La machine à état “boxe” les variables à la première suspension– Plus il y a de variables locales plus il y a d’allocations !• Éviter les variables inutiles pour minimise le nombre de champs alloués et recopiésLimiter les variables localesPlongée au coeur du framework .NET 4.5 : Performances async/awaitpublic static async Task FooAsync() {var dto = DateTimeOffset.Now;var dt = dto.DateTime;await Task.Delay(1000);Console.WriteLine(dt);}[CompilerGenerated, StructLayout(LayoutKind.Sequential)]private struct <FooAsync>d__0 : <>t__IStateMachine {public DateTimeOffset <dto>5__1;public DateTime <dt>5__2;...}public static async Task FooAsync() {var dt = DateTimeOffset.Now.DateTime;await Task.Delay(1000);Console.WriteLine(dt);}[CompilerGenerated, StructLayout(LayoutKind.Sequential)]private struct <FooAsync>d__0 : <>t__IStateMachine {public DateTime <dt>5__2;...}
    61. 61. Plongée au coeur du framework .NET 4.5 : Parallélisme, quoi de neuf en 4.5GarbagecollectorJITTERDebuggingQ/AConcurrence4Quoi de neuf en 4.5 ?
    62. 62. • ConcurrentExclusiveSchedulerPair– Fourni un support pour orchestrer des tâches de type lecteur/écrivain• CancellationTokenSource intégration d’un timeout– Nouveauté CancellationTokenSource(timeout).Token• ThreadLocal<T>.Values– Facilite l’implémentation du pattern Fork/Join avec réduction• TaskCreationOptions– Plus de contrôle avec l’intégration de code provenant de tierces parties• DenyChildAttach, HideScheduler• EnumerablePartitionerOptions– Nouvelle option NoBuffering• …Encore plus d’options pour contrôlerl’exécutionPlongée au coeur du framework .NET 4.5 : Parallélisme, quoi de neuf en 4.5
    63. 63. CONTRÔLER L’EXÉCUTIONConcurrentExclusiveSchedulerPairPlongée au coeur du framework .NET 4.5 : Parallélisme, quoi de neuf en 4.5
    64. 64. Plongée au coeur du framework .NET 4.5 : Parallélisme, quoi de neuf en 4.5PERFORMANCE ENTRE 4.0 ET4.5
    65. 65. Plongée au coeur du framework .NET 4.5 : Parallélisme, quoi de neuf en 4.5.NET 4.5 & Visual Studio2012ParallelPatternLibraryTask Parallel LibraryPLINQManaged NativeWindowsOperating SystemRuntimeProgramming ModelsCLR ThreadPoolTask SchedulerResource ManagerDataStructuresDataStructuresToolsToolingParallelDebuggerConcurrencyVisualizerAsyncAgentsLibraryStacksTasksWatchCPUThreadsCoresC#/VB/F#AsyncDataflow C++AMPDirectXGPUCPU GPUConcRTTask SchedulerResource ManagerNew UpdatedIEnumerable<T> TakeTop<T>(this IEnumerable<T> source,int count){return source.AsParallel().OrderBy(k => k).Take(count);}var tl = newThreadLocal<int>(trackAllValues: true);Parallel.For(0, 1000, i =>{tl.Value += Compute(i);});int result = tl.Values.Sum();var consumer = newActionBlock<int>(item => Process(item));…consumer.Post(42);consumer.Post(43);…async Task<string> ReplaceAsync(Stream input,string oldText, string newText){string contents = await newStreamReader(input).ReadToEndAsync();return contents.Replace(oldText, newText);}Task t = Task.WhenAny(Task.Delay(10000)),Task.Run(() =>Parallel.ForEach(…)));
    66. 66. Plongée au coeur du framework .NET 4.5 : Q/AGarbagecollectorJITTERConcurrenceDebuggingQ/A5
    67. 67. Plongée au coeur du framework .NET 4.5 : SourcesSources• CLR via C# by Jeffrey Richter (the best !)• http://blogs.msdn.com/b/dotnet• http://msdn.microsoft.com/en-us/magazine/hh882452.aspx• http://www.techbubbles.com/microsoft/multicore-jit-in-net-framework-4-5/• http://msdn.microsoft.com/en-us/library/0xy59wtx(v=vs.110).aspx• http://msdn.microsoft.com/en-us/library/e7k32f4k(v=vs.110).aspx• http://blogs.microsoft.co.il/blogs/pavely• http://blogs.msdn.com/b/davbr• http://blogs.msdn.com/b/pfxteam/• http://blogs.microsoft.co.il/blogs/sasha• http://eknowledger.wordpress.com/2012/04/27/clr-4-5-managed-profile-guided-optimization-mpgo/
    68. 68. Formez-vous en ligneRetrouvez nos évènementsFaites-vous accompagnergratuitementEssayer gratuitement nossolutions ITRetrouver nos expertsMicrosoftPros de l’ITDéveloppeurswww.microsoftvirtualacademy.comhttp://aka.ms/generation-apphttp://aka.ms/evenements-developpeurshttp://aka.ms/itcamps-franceLes accélérateursWindows Azure, Windows Phone,Windows 8http://aka.ms/telechargementsLa Dev’Team sur MSDNhttp://aka.ms/devteamL’IT Team sur TechNethttp://aka.ms/itteam

    ×