Compteurs de performance dans le .NET Compact Framework
Mise à jour : novembre 2007
Le .NET Compact Framework ne prend pas en charge les objets PerformanceCounter, ceux-ci n'ayant pas de rapport avec Windows CE et le .NET Compact Framework. Toutefois, le .NET Compact Framework contient un jeu de compteurs de performance prédéfinis pour analyser les types de charge de votre application sur le .NET Compact Framework. Ces compteurs ne sont pas extensibles.
Vous pouvez générer un fichier sur votre périphérique contenant des statistiques de performance sur votre application. Pour une procédure pas à pas, consultez Comment : générer des statistiques des performances.
Les compteurs de performance sont utiles pour comprendre les conséquences du Garbage collection et de la compilation juste-à-temps sur les performances de l'application. Ces statistiques vous permettent de voir où procéder à des optimisations.
Le fichier de statistiques répertorie les compteurs de performance avec les colonnes suivantes.
Colonne |
Description |
---|---|
Total |
Récapitulation des occurrences. |
Données les plus récentes |
Derniers renseignements. |
N |
Nombre d'occurrences. |
Moyenne |
Intermédiaire entre d'autres valeurs. |
Min |
Valeur minimale. |
Max |
Valeur maximale. |
Compteurs .NET Compact Framework
Les compteurs de performance sont organisés dans les catégories suivantes :
Chargeur |
Compilation JIT |
Génériques |
Exceptions |
Threads et verrous |
Interopérabilité |
Garbage collection |
Réseau |
Mémoire |
Windows Forms |
Compteurs de chargeur
Les compteurs suivants concernent la partie du Common Language Runtime (CLR) qui est responsable de la résolution et du chargement des composants référencés par votre application, tels que les assemblys et les classes.
Nom et nom court |
Description |
Type de compteur |
---|---|---|
Temps total d'exécution du programme (ms) RunTime |
Le temps écoulé depuis l'appel au CLR, en millisecondes. |
Calculé |
Domaines d'application créés napplication domains |
Le nombre de domaines d'application créés dans le processus de l'application. |
Simple |
Domaines d'application déchargés napplication domainsUnloaded |
Le nombre de domaines d'application déchargés au cours de l'exécution de l'application. |
Simple |
Assemblys chargés nAssembliesloaded |
Le nombre d'assemblys chargés dans tous les domaines d'application pour l'application. |
Simple |
Classes chargées nClassesloaded |
Le nombre de classes chargées dans tous les domaines d'application au cours de l'exécution de l'application. |
Simple |
Méthodes chargées nMethodsloaded |
Le nombre total des méthodes chargées dans tous les domaines d'application au cours de l'exécution de l'application. |
Simple |
Compteurs génériques
Les compteurs génériques sont des compteurs de chargeur spécifiques à la fonctionnalité des génériques du .NET Compact Framework. Le CLR utilise des génériques en interne. Par conséquent, des valeurs peuvent apparaître sur ces compteurs même si votre application n'utilise pas explicitement les génériques.
Nom et nom court |
Description |
Type de compteur |
---|---|---|
Types fermés chargés nInstGenericTypesLoaded |
Le nombre des types génériques uniques chargés dans tous les domaines d'application. Un type fermé est une classe générique associée à un type de données spécifique. Par exemple, une instance de MyGenericType<Int32> est un type fermé. |
Simple |
Types fermés chargés par définition nMaxClosedTypes |
Le nombre maximal de types génériques uniques créés pour une définition donnée dans tous les domaines d'application. Par exemple, si une application instancie MyGenericType<Int32>, MyGenericType<String> et MyGenericType<Single>, les types fermés chargés pour la définition MyGenericType<T> sont au nombre de trois (3). Un nombre important (plusieurs centaines ou plus) dans la colonne Max peut indiquer une pression du jeu de travail concernant le code compilé par le JIT et les structures de données CLR. |
StaticOnly |
Types ouverts chargés nOpenTypesLoaded |
Le nombre des types génériques ouverts créés dans tous les domaines d'application. Un type ouvert est une classe générique qui a été chargée, mais qui n'est associée à aucun type de données spécifique. Les types ouverts sont en général uniquement créés dans des scénarios de réflexion. Par exemple, le chargement d'une instance de MyGenericType<T> à l'aide de la réflexion incrémentera le compteur Types ouverts chargés. When the type has been bound, such as in MyGenericType<String>, it becomes a closed type and the Closed Types Loaded counter is incremented. Le CLR du .NET Compact Framework utilise la réflexion en interne et peut être la source des types ouverts. Par exemple, les services Web et la sérialisation XML utilisent la réflexion en interne. |
Simple |
Méthodes fermées chargées nInstGenericMethodsLoaded |
Le nombre des méthodes génériques uniques chargées dans tous les domaines d'application. Une méthode fermée est une méthode générique associée à un type de données spécifique. Il se peut que le type contenant la méthode ne soit pas générique. Par exemple, une instance de MyType.ProcessData<Int32>() est une méthode fermée. |
Simple |
Méthodes fermées chargées par définition nMaxClosedMethods |
Le nombre maximal de méthodes génériques uniques créées pour une définition donnée dans tous les domaines d'application. Ce compteur est très similaire au compteur Types fermés chargés par définition. À l'aide des instances suivantes de MyType.ProcessData<Int32>(), MyType.ProcessData<String>() et MyType.ProcessData<Single>(), trois méthodes fermées seront créées pour la définition MyType.ProcessData<T>(). Comme avec le compteur Types fermés chargés par définition, un nombre important (plusieurs centaines ou plus) dans la colonne Max peut indiquer une pression du jeu de travail concernant le code compilé par le JIT et les structures de données CLR. |
StaticOnly |
Méthodes ouvertes chargées nOpenMethodsLoaded |
Nombre des méthodes génériques ouvertes créées dans tous les domaines d'application. Les méthodes ouvertes sont en général uniquement créées dans des scénarios de réflexion. Une méthode ouverte est une méthode générique qui a été chargée, mais qui n'est associée à aucun type spécifique. Le runtime du .NET Compact Framework utilise la réflexion en interne et peut être la source des méthodes ouvertes. |
Simple |
Compteurs de threads et de verrous
Les compteurs suivants concernent les modèles de thread, les verrous, les minuteries et les pools de threads. Ces compteurs peuvent aider à identifier des problèmes de performance liés aux threads en fournissant des données sur l'utilisation des threads, des minuteries et des verrous au cours de l'exécution de votre application.
Nom et nom court |
Description |
Type de compteur |
---|---|---|
Threads d'un pool de threads nThreads |
Le nombre de threads actuellement dans le pool de threads. Ce compteur dénombre les threads démarrés à l'aide de la méthode QueueUserWorkItem. Ce compteur n'inclut pas les threads démarrés à l'aide de la méthode Start. |
MinMax |
Minuteries en attente nPendingTimers |
Le nombre de minuteries placées en file d'attente. |
MinMax |
Minuteries planifiées nTimersStarted |
Le nombre des minuteries qui sont en cours d'exécution ou dont l'exécution est planifiée. |
Simple |
Minuteries différées par limite de pool de threads nTimersDelayed |
Le nombre des minuteries qui ont été différées par la limite de pool de threads. |
Simple |
Éléments de travail placés en file d'attente nWorkItemsQueued |
Le nombre des éléments de travail mis en file d'attente dans le pool de threads. |
Simple |
Appels Monitor.Enter incontestés nUncontestedMonitor |
Le nombre des appels passés à la méthode Enter qui n'ont pas été contestés. |
Simple |
Appels Monitor.Enter contestés nContestedMonitor |
Le nombre des appels passés à Enter qui ont été contestés. Dans les applications multithread, si Thread1 détient un verrou et que Thread2 ait besoin d'accéder au code protégé par ce verrou, le compteur Appels Monitor.Enter contestés est incrémenté. |
Simple |
Compteurs Garbage collection
Les compteurs suivants concernent les opérations de garbage collection.
Nom et nom court |
Description |
Type de compteur |
---|---|---|
Octets alloués (natifs + managés) cbPeakMemUsage |
Le nombre maximal des octets en usage par le CLR, comprenant les mémoires native et managée. |
Calculé |
Objets managés alloués nObjectsAllocated |
Le nombre des objets alloués par le garbage collector. |
Simple |
Objets managés inutilisés alloués nObjectsAllocatedNotUsed |
Le nombre des objets alloués qui n'ont jamais été utilisés. |
Simple |
Octets managés alloués cbAllocated |
Le nombre des octets alloués par le garbage collector. |
Complexe |
Octets managés inutilisés alloués cbAllocatedNotUsed |
Le nombre des octets alloués qui n'ont jamais été utilisés. |
Complexe |
Objets de type chaîne managés alloués nStrings |
Le nombre des objets de type chaîne managés alloués par le garbage collector. |
Simple |
Octets des objets de type chaîne alloués nStringBytes |
Le nombre des octets d'objets de type chaîne alloués par le garbage collector. |
Simple |
Opérations garbage collection (GC) nGC |
Le nombre des exécutions du garbage collector. |
Simple |
Octets rassemblés par GC cbGarbage |
Le nombre des octets rassemblés par le garbage collector. |
Complexe |
Octets managés en usage après GC cbLive |
Le nombre des octets alloués aux objets actifs après le dernier garbage collection. |
MinMax |
Octets totaux en usage après GC cbWorkingSetMem |
Le nombre des octets de mémoire, native et managée, en usage après le dernier garbage collection. |
MinMax |
Compactages GC nCompactions |
Le nombre de condensations du tas par le garbage collector. |
Simple |
Suspension de code nPitches |
Le nombre de fois que le garbage collector a ignoré le code compilé par le JIT. |
Simple |
Appels aux GC.Collect nInduced |
Le nombre de fois que l'application a appelé la méthode Collect. |
Simple |
Temps de latence GC (ms) msLatency |
La durée totale, en millisecondes, que le garbage collector a utilisée pour rassembler des objets et condenser le tas. Le temps de latence du garbage collector inclut le temps de collecte des objets managés hors portée, ainsi que le temps de compactage, si nécessaire, du tas de garbage collector. |
Complexe |
Objets épinglés nPinned |
Le nombre des objets épinglés rencontrés lors de l'exécution d'un garbage collection. Les objets épinglés sont des objets dont les emplacements en mémoire ne peuvent pas être modifiés. Par exemple, une mémoire tampon utilisée pour communiquer entre des codes managé et non managé est un objet épinglé. Les objets épinglés ne peuvent pas être déplacés par le garbage collector pendant le compactage du tas. |
Simple |
Objets déplacés par compacteur nObjMoved |
Le nombre des objets déplacés par le garbage collector pendant un compactage. |
Simple |
Objets non déplacés par compacteur nObjNotMoved |
Le nombre des objets qui n'ont pas été déplacés par le garbage collector pendant un compactage. Les objets peuvent ne pas être déplacés pour plusieurs raisons. Certains objets ne peuvent pas être déplacés, mais ces objets sont rares. D'autres objets ne sont pas déplacés, car ils font partie du tas qui n'a pas besoin d'être compacté. |
Simple |
Objets finalisés nFinalizersRun |
Le nombre des objets pour lesquels un finaliseur a été exécuté. |
Simple |
Types valeur boxed nBoxes |
Nombre de types de valeur boxed. |
Simple |
Compteurs mémoires
Les compteurs suivants concernent les tas de mémoire managés par le garbage collector.
Nom et nom court |
Description |
Type de compteur |
---|---|---|
Tas de processus HeapDefault |
Le nombre des octets actuellement en usage par le tas par défaut du CLR. Le Tas de processus contient une mémoire allouée par le CLR qui n'entre pas dans les autres tas répertoriés dans ce tableau. |
MinMax |
Tas à court terme HeapShortTerm |
Le nombre des octets actuellement en usage par le tas à court terme du CLR. Le Tas à court terme contient une mémoire allouée par le CLR pour une utilisation temporaire. |
MinMax |
Tas JIT (juste-à-temps) HeapJitCodeBuffer |
Le nombre des octets en usage par le tas du compilateur JIT. Le Tas JIT contient le code natif généré lorsque le compilateur JIT du .NET Compact Framework compile une méthode managée. La compilation JIT se produit dès qu'une méthode managée est exécutée pour la première fois, ou dès qu'une méthode est exécutée pour la première fois après que le code a été ignoré. |
MinMax |
Tas de domaine d'application HeapAppDomain |
Le nombre des octets en usage par le tas de domaine d'application du CLR. Le Tas de domaine d'application contient la représentation dynamique des métadonnées utilisées par le chargeur de l'assembly du CLR. |
MinMax |
Tas GC HeapGC |
Le nombre des octets en usage par le tas de garbage collector. Le Tas GC contient une mémoire allouée par les applications et le .NET Compact Framework. |
MinMax |
Compteurs de compilation JIT
Les compteurs suivants concernent les opérations de compilateur JIT.
Nom et nom court |
Description |
Type de compteur |
---|---|---|
Octets natifs traités avec Jit cbJittedNative |
Le nombre des octets de code natif générés par le compilateur JIT. |
Complexe |
Méthodes traitées avec Jit nMethodsJitted |
Le nombre des méthodes générées par le compilateur JIT. |
Simple |
Octets suspendus cbPitched |
Le nombre des octets de code natif générés par le compilateur JIT qui a été ignoré. |
Complexe |
Méthodes suspendues nMethodsPitched |
Le nombre des méthodes générées par le compilateur JIT qui a été ignoré. À moins que votre application n'ait été déplacée vers l'arrière-plan lors de son exécution, toute valeur positive du compteur Méthodes suspendues indique que l'application s'est exécutée avec sollicitation de la mémoire. |
Simple |
Temps de latence de suspension des méthodes (ms) msPitchLatency |
La durée totale, en millisecondes, de suspension des méthodes générées par le compilateur JIT. |
Complexe |
Compteurs d'exceptions
Les compteurs suivants concernent les exceptions.
Nom et nom court |
Description |
---|---|
Exceptions levées nExceptions |
Le nombre des exceptions managées qui ont été levées. Étant donné que la levée d'une exception entraîne une consommation significative des ressources, le suivi du nombre d'exceptions levées par votre application peut aider à identifier les éventuels problèmes de conception. |
Compteurs d'interopérabilité
Les compteurs suivants concernent l'interopérabilité avec le code natif.
Nom et nom court |
Description |
Type de compteur |
---|---|---|
Appels de code non managé nPInvoke |
Le nombre des appels de code non managé depuis le code managé vers le code natif, à l'exception des appels de code non managé CLR internes. |
Simple |
Appels COM utilisant un vtable nComVTable |
Le nombre des appels depuis le code managé vers le code natif à l'aide de la méthode vtable de COM Interop. |
Simple |
Appels COM utilisant IDispatch nComIDispatch |
Le nombre des appels depuis le code managé vers le code natif à l'aide de la méthode IDispatch de COM Interop. |
Simple |
Marshaling complexe nMarshal |
Le nombre des objets marshalés depuis le code managé vers le code natif qui ont impliqué la copie ou la transformation de données. |
Simple |
Wrappers RCW (Runtime Callable Wrapper) cTotalRcw |
Le nombre total des wrappers RCW (Runtime Callable Wrapper) COM qui ont été créés. Des wrappers RCW (Runtime Callable Wrapper) sont créés lorsqu'un code managé exécuté via le runtime du .NET Compact Framework appelle un objet COM non managé. |
Simple |
Compteurs de réseau
Les compteurs suivants concernent les opérations d'envoi et de réception du réseau.
Nom et nom court |
Description |
Type de compteur |
---|---|---|
Octets de socket transmis nBytesSent |
Le nombre total des octets envoyés via des sockets. |
Simple |
Octets de socket reçus nBytesReceived |
Le nombre total des octets reçus via des sockets. |
Simple |
Compteurs Windows Forms
Les compteurs suivants concernent l'espace de noms System.Windows.Forms.
Nom et nom court |
Description |
Type de compteur |
---|---|---|
Contrôles créés nControlsCreated |
Le nombre total des contrôles créés par l'application. |
Simple |
Pinceaux créés nBrushesCreated |
Le nombre total des objets Brush créés par l'application. |
Simple |
Stylets créés nPensCreated |
Le nombre total des objets Pen créés par l'application. |
Simple |
Bitmaps créées nBitmapsCreated |
Le nombre total des objets Bitmap créés par l'application. |
Simple |
Zones créées nRegionsCreated |
Le nombre total des objets Region créés par l'application. |
Simple |
Polices créées nFontsCreated |
Le nombre total des objets Font créés par l'application. |
Simple |
Graphiques créés (FromImage) nGraphicsFromImage |
Le nombre total des objets Graphics créés par la méthode FromImage. |
Simple |
Graphiques créés (CreateGraphics) nGraphicsCreateGraphics |
Le nombre total des objets Graphics créés par la méthode CreateGraphics. |
Simple |
Voir aussi
Tâches
Comment : générer des statistiques des performances