Guide d'utilisation de l'outil: Analyse des performances d'exécution à l'aide des outils Rational PurifyPlus (Windows et UNIX)
Ce guide d'utilisation de l'outil décrit l'utilisation des outils Rational PurifyPlus pour obtenir un code exempt d'erreurs et de fuite de mémoire, qui utilise la mémoire de façon efficace et qui fournit des performances optimales.
Outil: Rational PurifyPlus
Relations
Description principale

Ce guide d'utilisation de l'outil peut s'utiliser avec les systèmes Microsoft Windows et UNIX.

Les outils PurifyPlus comprennent Rational Purify, Rational PureCoverage et Rational Quantify.

manuel d'aide Pour en savoir plus sur les outils PurifyPlus, lisez le manuel Guide d'initiation de PurifyPlus (version Windows ou version UNIX).

manuel d'aide Pour obtenir des informations étape par étape sur l'utilisation des outils PurifyPlus, consultez l'aide en ligne pour l'outil.

Analyse des performances d'exécution 

L'analyse des performances d'exécution comprend ce qui suit :

  • Détection des erreurs et des fuites de mémoire (programmes C/C++ sous Windows et UNIX).
    • Utilisez Purify pour identifier ces problèmes, dans votre propre code ainsi que dans les composants utilisés par votre logiciel, même lorsque vous ne disposez pas de la source.
    • Utilisez PureCoverage pour vous assurer que le code a été couvert en entier. (Vous pouvez également utiliser PureCoverage indépendamment de Purify pour recueillir des données de couverture pour le code géré C/C++, Java et .NET.)
  • Profilage de l'utilisation de la mémoire (code géré Java et .NET sous Windows). Utilisez Purify pour déterminer là où la mémoire est utilisée de manière inefficace.
  • Profilage des performances (Windows et UNIX). Utilisez Quantify pour indiquer là où votre programme passe le plus de temps de façon à pouvoir éliminer les principaux goulots d'étranglement de performances.

L'analyse d'exécution avec les outils PurifyPlus permet d'obtenir un code sans erreur, qui fonctionne avec une efficacité maximale.

Etapes outil

Pour réaliser l'analyse d'exécution avec les outils PurifyPlus :

1. Exécutez votre programme sous Purify pour recueillir les données d'erreur, de fuite et de couverture (programmes C/C++ sous Windows et UNIX) 

Purify détecte les erreurs d'exécution difficiles à trouver, y compris les fuites de mémoire dans votre propre code et dans les composants utilisés par votre logiciel. Il signale les erreurs de mémoire telles que les erreurs de bornes de tableau, l'accès par des pointeurs tombants, les lectures de mémoire non initialisées, les erreurs d'attribution de mémoire et les fuites de mémoire, de façon à ce que vous puissiez les résoudre avant tout endommagement. Si votre système dispose de Rational PureCoverage, vous pouvez également voir les sections de votre code que vous avez testées ou pas. 

Commencez par exécuter votre programme sous Purify :

  • Sous un système Windows :
    • Si vous travaillez dans Microsoft Visual Studio 6, sélectionnez d'abord l'élément de menu Visual Studio Purify > Démarrer l'intégration dans Purify. Si votre système dispose de PureCoverage, sélectionnez Purify > Recueillir données de couverture également, en donnant l'ordre à Purify de surveiller la couverture de code. Puis exécutez votre programme dans Visual Studio comme d'habitude.
    • Si vous utilisez Purify en programme autonome, non intégré à Visual Studio, sélectionnez Fichier > Exécuter. Dans la boîte de dialogue Exécuter fichier, sélectionnez Recueillir données erreur, fuite et couverture (ou Recueillir données erreur et fuite si vous n'avez pas PureCoverage sur votre système) et exécutez votre programme.
  • Sous un système UNIX, ajoutez le mot purify. Ajoutez-le au début de votre ligne de compilation/lien. Si votre système dispose de PureCoverage, ajoutez purecov également. Par exemple :
    % purify purecov cc -g hello_world.c
    Puis exécutez le programme comme d'habitude.
Lorsque utilisez le programme, Purify dresse la liste des erreurs d'exécution dans l'afficheur Purify. Lorsque vous quittez le programme, Purify signale les fuites de mémoire.

Analysez les en-têtes de messages pour identifier les erreurs critiques. Agrandissez les messages pour obtenir des informations de diagnostic plus détaillées, y compris le code qui a généré l'erreur. A partir de l'afficheur, vous pouvez ouvrir le code source dans votre éditeur, sur la ligne sur laquelle l'erreur s'est produite, et effectuer votre correction directement.

Une fois que vous avez corrigé les erreurs et reconstruit le programme, vérifiez vos corrections en exécutant à nouveau le programme mis à jour et en comparant les nouveaux résultats à l'exécution précédente. Répétez le cycle d'instrumentation et d'exécution, d'analyse et de correction jusqu'à ce que votre programme s'exécute correctement.

Si vous recueillez des données de couverture pour les exécutions du programme, vous pouvez également voir les sections de votre code que vous n'avez pas vérifiées. Utilisez ces informations pour ajuster la portée de l'analyse de l'exécution afin de rechercher toutes les erreurs de votre programme, à tout moment.

manuel d'aide Pour en savoir plus, consultez les rubriques suivantes dans l'index de l'aide en ligne de Purify :

  • programmes en cours d'exécution
  • messages Purify
  • code source
  • données de couverture

2. Exécutez votre programme sous Purify pour détecter une utilisation inefficace de la mémoire (code géré Java et .NET sous Windows) 

Purify vous aide à identifier les problèmes de mémoire de code géré Java et .NET. Avec Purify, vous pouvez déterminer :

  • la quantité de mémoire utilisée par votre programme
  • la quantité de mémoire nouvelle consommée par votre programme pour un ensemble d'actions spécifique 
  • quelles méthodes et quels objets du programme consomment tant de mémoire 
  • quels objets peuvent empêcher des objets non nécessaires d'être jetés 
  • où il serait conseillé d'imposer une récupération de place pour améliorer les performances
Commencez par exécuter votre programme sous Purify.
  • Si vous travaillez dans Microsoft Visual Studio .NET, IBM WSWB ou IBM WSS AD, sélectionnez d'abord l'élément de menu PurifyPlus > Purify > Démarrer l'intégration dans Purify. Puis exécutez votre programme comme d'habitude.
  • Si vous utilisez Purify en programme autonome, non intégré à Visual Studio .NET ou WSWB/WSS AD, sélectionnez Fichier > Exécuter dans l'interface utilisateur Purify. Dans la boîte de dialogue Exécuter programme, sélectionnez Recueillir données de profilage de mémoire et exécutez votre programme.
Une fois que votre programme a terminé ses procédures d'initialisation, utilisez la commande de capture Purify pour marquer d'un repère l'utilisation de la mémoire à ce moment. La capture est votre base pour savoir comment votre programme utilise la mémoire lorsqu'il s'exécute.   

Une fois que vous avez la capture, vous pouvez enregistrer la mémoire que votre programme utilise lorsqu'il fonctionne. Exécutez les parties du programme qui, selon vous, pourraient comporter des fuites de mémoire. Purify affiche un diagramme d'attribution de la mémoire qui indique les variations en temps réel de l'utilisation de la mémoire actuelle. Lorsque vous observez une augmentation de mémoire attribuée, effectuez une autre capture.

Comparez les deux captures pour identifier des méthodes qui pourraient être à l'origine des fuites de mémoire. Quittez votre programme et comparez (ou "diff") les deux captures. Purify affiche un diagramme d'appels qui indique les méthodes responsables des plus grandes quantités de mémoire attribuées lorsque votre programme était en cours d'exécution, entre le moment où vous avez pris la première et la deuxième capture. Vous pouvez vous concentrer sur des méthodes spécifiques dans le diagramme d'appels pour les étudier de plus près.

Si la quantité de mémoire attribuée à une méthode est étonnamment importante, examinez votre code source et révisez-le, si nécessaire, pour libérer de la mémoire lorsqu'on n'en a plus besoin.

Une fois que vous avez identifié des méthodes qui semblent comporter des problèmes de mémoire, analysez ces méthodes au niveau des objets. Recherchez des objets qui auraient du être libérés et jetés, mais ne l'ont pas été, peut-être parce que d'autres objets comportent une référence inutile à ces derniers. 

manuel d'aide Pour en savoir plus, consultez les rubriques suivantes dans l'index d'aide en ligne Purify : 

  • programmes en cours d'exécution
  • comparaison d'exécutions
  • navigateur de données

3. Exécutez votre programme sous Quantify pour trouver les goulots d'étranglement des performances (Windows et UNIX).

Quantify fournit un ensemble de données de performances complètes, précises et faciles à interpréter pour votre programme et ses composants, pour que vous puissiez identifier et éliminer les goulots d'étranglement des performances dans votre code.

Commencez par exécuter le programme sous Quantify pour recueillir des données de performances :

  • Sous un système Windows :
    • Si vous travaillez dans Microsoft Visual Studio 6, sélectionnez d'abord l'élément de menu Visual Studio Quantify > Démarrer l'intégration dans Quantify. Puis exécutez votre programme dans Visual Studio comme d'habitude.
    • Si vous travaillez dans Microsoft Visual Studio .NET, IBM WSWB ou IBM WSS AD, sélectionnez l'élément de menu PurifyPlus > Quantify > Démarrer l'intégration dans Quantify. Puis exécutez votre programme comme d'habitude.
    • Si vous utilisez Quantify en programme autonome, non intégré à Visual Studio ou WSWB/WSS AD, sélectionnez Fichier > Exécuter pour exécuter votre programme dans l'interface utilisateur Quantify.
  • Sous un système UNIX, ajoutez le mot quantify au début de la ligne compilation/lien. Par exemple :
         % quantify cc -g hello_world.c
    
    Puis exécutez le programme comme d'habitude.

Lorsque vous utilisez votre code, Quantify enregistre des données relatives aux performances de votre programme et affiche l'activité de ses unités d'exécution et fibres. Lorsque vous quittez le programme, Quantify a un profil précis de sa performance que vous pouvez utiliser pour trouver et diagnostiquer des goulots d'étranglement.

L'affichage des données Quantify comprend :

  • une fenêtre de diagramme d'appels qui décrit graphiquement la structure et la performance d'appel des fonctions du programme
  • une fenêtre Liste des fonctions qui énumère toutes les fonctions avec des données de performances
  • une fenêtre Détail des fonctions qui affiche des données pour une fonction particulière, ses appelants et ses descendants
  • une fenêtre Source annotée qui indique les données de performances ligne par ligne sur une copie du code source

Avec les données recueillies, vous serez en mesure d'identifier les goulots d'étranglement des performances tels que les calculs et recalculs inutiles, les calculs prématurés ou les appels bibliothèque excessifs et chers.

Une fois que vous avez modifié votre code pour éliminer ou minimiser les goulots d'étranglement, exécutez à nouveau le programme mis à jour sous Quantify. Comparez ensuite les nouveaux résultats à l'exécution précédente en créant un ensemble de données "diff", qui donne des indications claires sur les améliorations et les régressions des performances.

Pour en savoir plus, consultez les rubriques suivantes dans l'index d'aide en ligne Quantify :

  • programmes en cours d'exécution
  • comparaison d'exécutions
  • fenêtre de diagramme d'appels
  • fenêtre de source annotée