You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
578 lines
64 KiB
578 lines
64 KiB
; ==++==
|
|
;
|
|
; Copyright (c) Microsoft Corporation. All rights reserved.
|
|
;
|
|
; ==--==
|
|
//------------------------------------------------------------------------
|
|
// WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
|
|
//
|
|
// AUTO GENERATED FILE. DO NOT EDIT. USE $/com99/src/profile/perfmonhelp
|
|
//
|
|
// WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
|
|
//------------------------------------------------------------------------
|
|
|
|
// CORPerfMonSymbols.ini file
|
|
[info]
|
|
drivername=.NETFramework
|
|
symbolfile=CORPerfMonSymbols.h
|
|
|
|
[languages]
|
|
009=English
|
|
000=Neutral
|
|
; 001=Arabic
|
|
; 004=Chinese
|
|
; 007=German
|
|
; 00D=Hebrew
|
|
; 011=Japanese
|
|
; 012=Korean
|
|
; 00A=Spanish
|
|
; 00C=French
|
|
; 010=Italian
|
|
|
|
[objects]
|
|
DotNetCLR_Memory_OBJECT_009_NAME=.NET CLR Memory
|
|
DotNetCLR_Loading_OBJECT_009_NAME=.NET CLR Loading
|
|
DotNetCLR_Jit_OBJECT_009_NAME=.NET CLR Jit
|
|
DotNetCLR_Interop_OBJECT_009_NAME=.NET CLR Interop
|
|
DotNetCLR_LocksAndThreads_OBJECT_009_NAME=.NET CLR LocksAndThreads
|
|
DotNetCLR_Security_OBJECT_009_NAME=.NET CLR Security
|
|
DotNetCLR_Remoting_OBJECT_009_NAME=.NET CLR Remoting
|
|
DotNetCLR_Excep_OBJECT_009_NAME=.NET CLR Exceptions
|
|
DotNetCLR_Memory_OBJECT_000_NAME=.NET CLR Memory
|
|
DotNetCLR_Loading_OBJECT_000_NAME=.NET CLR Loading
|
|
DotNetCLR_Jit_OBJECT_000_NAME=.NET CLR Jit
|
|
DotNetCLR_Interop_OBJECT_000_NAME=.NET CLR Interop
|
|
DotNetCLR_LocksAndThreads_OBJECT_000_NAME=.NET CLR LocksAndThreads
|
|
DotNetCLR_Security_OBJECT_000_NAME=.NET CLR Security
|
|
DotNetCLR_Remoting_OBJECT_000_NAME=.NET CLR Remoting
|
|
DotNetCLR_Excep_OBJECT_000_NAME=.NET CLR Exceptions
|
|
|
|
[text]
|
|
DotNetCLR_Memory_OBJECT_009_NAME=.NET CLR Memory
|
|
DotNetCLR_Memory_OBJECT_009_HELP=Counters for CLR Garbage Collected heap.
|
|
|
|
GEN0_COLLECTIONS_COUNTER_009_NAME=# Gen 0 Collections
|
|
GEN0_COLLECTIONS_COUNTER_009_HELP=This counter displays the number of times the generation 0 objects (youngest; most recently allocated) are garbage collected (Gen 0 GC) since the start of the application. Gen 0 GC occurs when the available memory in generation 0 is not sufficient to satisfy an allocation request. This counter is incremented at the end of a Gen 0 GC. Higher generation GCs include all lower generation GCs. This counter is explicitly incremented when a higher generation (Gen 1 or Gen 2) GC occurs. _Global_ counter value is not accurate and should be ignored. This counter displays the last observed value.
|
|
|
|
GEN1_COLLECTIONS_COUNTER_009_NAME=# Gen 1 Collections
|
|
GEN1_COLLECTIONS_COUNTER_009_HELP=This counter displays the number of times the generation 1 objects are garbage collected since the start of the application. The counter is incremented at the end of a Gen 1 GC. Higher generation GCs include all lower generation GCs. This counter is explicitly incremented when a higher generation (Gen 2) GC occurs. _Global_ counter value is not accurate and should be ignored. This counter displays the last observed value.
|
|
|
|
GEN2_COLLECTIONS_COUNTER_009_NAME=# Gen 2 Collections
|
|
GEN2_COLLECTIONS_COUNTER_009_HELP=This counter displays the number of times the generation 2 objects (older) are garbage collected since the start of the application. The counter is incremented at the end of a Gen 2 GC (also called full GC). _Global_ counter value is not accurate and should be ignored. This counter displays the last observed value.
|
|
|
|
GEN0_BYTES_PROMOTED_COUNTER_009_NAME=Promoted Memory from Gen 0
|
|
GEN0_BYTES_PROMOTED_COUNTER_009_HELP=This counter displays the bytes of memory that survive garbage collection (GC) and are promoted from generation 0 to generation 1; objects that are promoted just because they are waiting to be finalized are not included in this counter. This counter displays the value observed at the end of the last GC; its not a cumulative counter.
|
|
|
|
GEN1_BYTES_PROMOTED_COUNTER_009_NAME=Promoted Memory from Gen 1
|
|
GEN1_BYTES_PROMOTED_COUNTER_009_HELP=This counter displays the bytes of memory that survive garbage collection (GC) and are promoted from generation 1 to generation 2; objects that are promoted just because they are waiting to be finalized are not included in this counter. This counter displays the value observed at the end of the last GC; its not a cumulative counter. This counter is reset to 0 if the last GC was a Gen 0 GC only.
|
|
|
|
GEN0_PROMOTION_RATE_009_NAME=Gen 0 Promoted Bytes/Sec
|
|
GEN0_PROMOTION_RATE_009_HELP=This counter displays the bytes per second that are promoted from generation 0 (youngest) to generation 1; objects that are promoted just because they are waiting to be finalized are not included in this counter. Memory is promoted when it survives a garbage collection. This counter was designed as an indicator of relatively long-lived objects being created per sec. This counter displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
GEN1_PROMOTION_RATE_009_NAME=Gen 1 Promoted Bytes/Sec
|
|
GEN1_PROMOTION_RATE_009_HELP=This counter displays the bytes per second that are promoted from generation 1 to generation 2 (oldest); objects that are promoted just because they are waiting to be finalized are not included in this counter. Memory is promoted when it survives a garbage collection. Nothing is promoted from generation 2 since it is the oldest. This counter was designed as an indicator of very long-lived objects being created per sec. This counter displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
GEN0_FINALIZATION_BYTES_PROMOTED_COUNTER_009_NAME=Promoted Finalization-Memory from Gen 0
|
|
GEN0_FINALIZATION_BYTES_PROMOTED_COUNTER_009_HELP=This counter displays the bytes of memory that are promoted from generation 0 to generation 1 just because they are waiting to be finalized. This counter displays the value observed at the end of the last GC; its not a cumulative counter.
|
|
|
|
GEN1_FINALIZATION_BYTES_PROMOTED_COUNTER_009_NAME=Promoted Finalization-Memory from Gen 1
|
|
GEN1_FINALIZATION_BYTES_PROMOTED_COUNTER_009_HELP=This counter displays the bytes of memory that are promoted from generation 1 to generation 2 just because they are waiting to be finalized. This counter displays the value observed at the end of the last GC; its not a cumulative counter. This counter is reset to 0 if the last GC was a Gen 0 GC only.
|
|
|
|
GEN0_HEAP_SIZE_COUNTER_009_NAME=Gen 0 heap size
|
|
GEN0_HEAP_SIZE_COUNTER_009_HELP=This counter displays the maximum bytes that can be allocated in generation 0 (Gen 0); its does not indicate the current number of bytes allocated in Gen 0. A Gen 0 GC is triggered when the allocations since the last GC exceed this size. The Gen 0 size is tuned by the Garbage Collector and can change during the execution of the application. At the end of a Gen 0 collection the size of the Gen 0 heap is infact 0 bytes; this counter displays the size (in bytes) of allocations that would trigger the next Gen 0 GC. This counter is updated at the end of a GC; its not updated on every allocation.
|
|
|
|
GEN1_HEAP_SIZE_COUNTER_009_NAME=Gen 1 heap size
|
|
GEN1_HEAP_SIZE_COUNTER_009_HELP=This counter displays the current number of bytes in generation 1 (Gen 1); this counter does not display the maximum size of Gen 1. Objects are not directly allocated in this generation; they are promoted from previous Gen 0 GCs. This counter is updated at the end of a GC; its not updated on every allocation.
|
|
|
|
GEN2_HEAP_SIZE_COUNTER_009_NAME=Gen 2 heap size
|
|
GEN2_HEAP_SIZE_COUNTER_009_HELP=This counter displays the current number of bytes in generation 2 (Gen 2). Objects are not directly allocated in this generation; they are promoted from Gen 1 during previous Gen 1 GCs. This counter is updated at the end of a GC; its not updated on every allocation.
|
|
|
|
LARGE_OBJECT_SIZE_COUNTER_009_NAME=Large Object Heap size
|
|
LARGE_OBJECT_SIZE_COUNTER_009_HELP=This counter displays the current size of the Large Object Heap in bytes. Objects greater than 20 KBytes are treated as large objects by the Garbage Collector and are directly allocated in a special heap; they are not promoted through the generations. This counter is updated at the end of a GC; its not updated on every allocation.
|
|
|
|
SURVIVE_FINALIZE_COUNTER_009_NAME=Finalization Survivors
|
|
SURVIVE_FINALIZE_COUNTER_009_HELP=This counter displays the number of garbage collected objects that survive a collection because they are waiting to be finalized. If these objects hold references to other objects then those objects also survive but are not counted by this counter; the "Promoted Finalization-Memory from Gen 0" and "Promoted Finalization-Memory from Gen 1" counters represent all the memory that survived due to finalization. This counter is not a cumulative counter; its updated at the end of every GC with count of the survivors during that particular GC only. This counter was designed to indicate the extra overhead that the application might incur because of finalization.
|
|
|
|
NUM_HANDLES_COUNTER_009_NAME=# GC Handles
|
|
NUM_HANDLES_COUNTER_009_HELP=This counter displays the current number of GC Handles in use. GCHandles are handles to resources external to the CLR and the managed environment. Handles occupy small amounts of memory in the GCHeap but potentially expensive unmanaged resources.
|
|
|
|
ALLOCATION_RATE_COUNTER_009_NAME=Allocated Bytes/sec
|
|
ALLOCATION_RATE_COUNTER_009_HELP=This counter displays the rate of bytes per second allocated on the GC Heap. This counter is updated at the end of every GC; not at each allocation. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
INDUCED_GC_COUNTER_009_NAME=# Induced GC
|
|
INDUCED_GC_COUNTER_009_HELP=This counter displays the peak number of times a garbage collection was performed because of an explicit call to GC.Collect. Its a good practice to let the GC tune the frequency of its collections.
|
|
|
|
PER_TIME_IN_GC_COUNTER_009_NAME=% Time in GC
|
|
PER_TIME_IN_GC_COUNTER_009_HELP=% Time in GC is the percentage of elapsed time that was spent in performing a garbage collection (GC) since the last GC cycle. This counter is usually an indicator of the work done by the Garbage Collector on behalf of the application to collect and compact memory. This counter is updated only at the end of every GC and the counter value reflects the last observed value; its not an average.
|
|
|
|
PER_TIME_IN_GC_COUNTER_BASE_009_NAME=Not Displayed
|
|
PER_TIME_IN_GC_COUNTER_BASE_009_HELP=Not Displayed.
|
|
|
|
TOTAL_HEAP_SIZE_COUNTER_009_NAME=# Bytes in all Heaps
|
|
TOTAL_HEAP_SIZE_COUNTER_009_HELP=This counter is the sum of four other counters; Gen 0 Heap Size; Gen 1 Heap Size; Gen 2 Heap Size and the Large Object Heap Size. This counter indicates the current memory allocated in bytes on the GC Heaps.
|
|
|
|
TOTAL_COMMITTED_MEM_COUNTER_009_NAME=# Total committed Bytes
|
|
TOTAL_COMMITTED_MEM_COUNTER_009_HELP=This counter displays the amount of virtual memory (in bytes) currently committed by the Garbage Collector. (Committed memory is the physical memory for which space has been reserved on the disk paging file).
|
|
|
|
TOTAL_RESERVED_MEM_COUNTER_009_NAME=# Total reserved Bytes
|
|
TOTAL_RESERVED_MEM_COUNTER_009_HELP=This counter displays the amount of virtual memory (in bytes) currently reserved by the Garbage Collector. (Reserved memory is the virtual memory space reserved for the application but no disk or main memory pages have been used.)
|
|
|
|
GC_PINNED_OBJECTS_009_NAME=# of Pinned Objects
|
|
GC_PINNED_OBJECTS_009_HELP=This counter displays the number of pinned objects encountered in the last GC. This counter tracks the pinned objects only in the heaps that were garbage collected e.g. a Gen 0 GC would cause enumeration of pinned objects in the generation 0 heap only. A pinned object is one that the Garbage Collector cannot move in memory.
|
|
|
|
GC_SINKBLOCKS_009_NAME=# of Sink Blocks in use
|
|
GC_SINKBLOCKS_009_HELP=This counter displays the current number of sync blocks in use. Sync blocks are per-object data structures allocated for storing synchronization information. Sync blocks hold weak references to managed objects and need to be scanned by the Garbage Collector. Sync blocks are not limited to storing synchronization information and can also store COM interop metadata. This counter was designed to indicate performance problems with heavy use of synchronization primitives.
|
|
|
|
DotNetCLR_Loading_OBJECT_009_NAME=.NET CLR Loading
|
|
DotNetCLR_Loading_OBJECT_009_HELP=Statistics for CLR Class Loader.
|
|
|
|
LOADING_CLASSES_TOTAL_009_NAME=Total Classes Loaded
|
|
LOADING_CLASSES_TOTAL_009_HELP=This counter displays the cumulative number of classes loaded in all Assemblies since the start of this application.
|
|
|
|
LOADING_TIME_009_NAME=% Time Loading
|
|
LOADING_TIME_009_HELP=Reserved for future use.
|
|
|
|
LOADING_ASMSEARCHLEN_009_NAME=Assembly Search Length
|
|
LOADING_ASMSEARCHLEN_009_HELP=Reserved for future use.
|
|
|
|
LOADING_LOADFAILURES_TOTAL_009_NAME=Total # of Load Failures
|
|
LOADING_LOADFAILURES_TOTAL_009_HELP=This counter displays the peak number of classes that have failed to load since the start of the application. These load failures could be due to many reasons like inadequate security or illegal format. Full details can be found in the profiling services help.
|
|
|
|
LOADING_LOADFAILURES_INST_009_NAME=Rate of Load Failures
|
|
LOADING_LOADFAILURES_INST_009_HELP=This counter displays the number of classes that failed to load per second. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval. These load failures could be due to many reasons like inadequate security or illegal format. Full details can be found in the profiling services help.
|
|
|
|
LOADING_HEAPSIZE_009_NAME=Bytes in Loader Heap
|
|
LOADING_HEAPSIZE_009_HELP=This counter displays the current size (in bytes) of the memory committed by the class loader across all AppDomains. (Committed memory is the physical memory for which space has been reserved on the disk paging file.)
|
|
|
|
LOADING_APPDOMAINS_UNLOADED_TOTAL_009_NAME=Total appdomains unloaded
|
|
LOADING_APPDOMAINS_UNLOADED_TOTAL_009_HELP=This counter displays the total number of AppDomains unloaded since the start of the application. If an AppDomain is loaded and unloaded multiple times this counter would count each of those unloads as separate.
|
|
|
|
LOADING_APPDOMAINS_UNLOADED_INST_009_NAME=Rate of appdomains unloaded
|
|
LOADING_APPDOMAINS_UNLOADED_INST_009_HELP=This counter displays the number of AppDomains unloaded per second. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
LOADING_CLASSES_CUR_009_NAME=Current Classes Loaded
|
|
LOADING_CLASSES_CUR_009_HELP=This counter displays the current number of classes loaded in all Assemblies.
|
|
|
|
LOADING_CLASSES_INST_009_NAME=Rate of Classes Loaded
|
|
LOADING_CLASSES_INST_009_HELP=This counter displays the number of classes loaded per second in all Assemblies. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
LOADING_APPDOMAINS_CUR_009_NAME=Current appdomains
|
|
LOADING_APPDOMAINS_CUR_009_HELP=This counter displays the current number of AppDomains loaded in this application. AppDomains (application domains) provide a secure and versatile unit of processing that the CLR can use to provide isolation between applications running in the same process.
|
|
|
|
LOADING_APPDOMAINS_TOTAL_009_NAME=Total Appdomains
|
|
LOADING_APPDOMAINS_TOTAL_009_HELP=This counter displays the peak number of AppDomains loaded since the start of this application. AppDomains (application domains) provide a secure and versatile unit of processing that the CLR can use to provide isolation between applications running in the same process.
|
|
|
|
LOADING_APPDOMAINS_INST_009_NAME=Rate of appdomains
|
|
LOADING_APPDOMAINS_INST_009_HELP=This counter displays the number of AppDomains loaded per second. AppDomains (application domains) provide a secure and versatile unit of processing that the CLR can use to provide isolation between applications running in the same process. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
LOADING_ASSEMBLIES_CUR_009_NAME=Current Assemblies
|
|
LOADING_ASSEMBLIES_CUR_009_HELP=This counter displays the current number of Assemblies loaded across all AppDomains in this application. If the Assembly is loaded as domain-neutral from multiple AppDomains then this counter is incremented once only. Assemblies can be loaded as domain-neutral when their code can be shared by all AppDomains or they can be loaded as domain-specific when their code is private to the AppDomain.
|
|
|
|
LOADING_ASSEMBLIES_TOTAL_009_NAME=Total Assemblies
|
|
LOADING_ASSEMBLIES_TOTAL_009_HELP=This counter displays the total number of Assemblies loaded since the start of this application. If the Assembly is loaded as domain-neutral from multiple AppDomains then this counter is incremented once only. Assemblies can be loaded as domain-neutral when their code can be shared by all AppDomains or they can be loaded as domain-specific when their code is private to the AppDomain.
|
|
|
|
LOADING_ASSEMBLIES_INST_009_NAME=Rate of Assemblies
|
|
LOADING_ASSEMBLIES_INST_009_HELP=This counter displays the number of Assemblies loaded across all AppDomains per second. If the Assembly is loaded as domain-neutral from multiple AppDomains then this counter is incremented once only. Assemblies can be loaded as domain-neutral when their code can be shared by all AppDomains or they can be loaded as domain-specific when their code is private to the AppDomain. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
DotNetCLR_Jit_OBJECT_009_NAME=.NET CLR Jit
|
|
DotNetCLR_Jit_OBJECT_009_HELP=Stats for CLR Jit.
|
|
|
|
TOTAL_METHODS_JITTED_009_NAME=# of Methods Jitted
|
|
TOTAL_METHODS_JITTED_009_HELP=This counter displays the total number of methods compiled Just-In-Time (JIT) by the CLR JIT compiler since the start of the application. This counter does not include the pre-jitted methods.
|
|
|
|
JITTED_IL_CUR_009_NAME=# of IL Bytes Jitted
|
|
JITTED_IL_CUR_009_HELP=This counter displays the total IL bytes jitted since the start of the application. This counter is exactly equivalent to the "Total # of IL Bytes Jitted" counter.
|
|
|
|
JITTED_IL_TOTAL_009_NAME=Total # of IL Bytes Jitted
|
|
JITTED_IL_TOTAL_009_HELP=This counter displays the total IL bytes jitted since the start of the application. This counter is exactly equivalent to the "# of IL Bytes Jitted" counter.
|
|
|
|
JITTED_IL_INST_009_NAME=IL Bytes Jitted / sec
|
|
JITTED_IL_INST_009_HELP=This counter displays the rate at which IL bytes are jitted per second. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
JIT_FAILURES_009_NAME=Standard Jit Failures
|
|
JIT_FAILURES_009_HELP=This counter displays the peak number of methods the JIT compiler has failed to JIT since the start of the application. This failure can occur if the IL cannot be verified or if there was an internal error in the JIT compiler.
|
|
|
|
TIME_IN_JIT_009_NAME=% Time in Jit
|
|
TIME_IN_JIT_009_HELP=This counter displays the percentage of elapsed time spent in JIT compilation since the last JIT compilation phase. This counter is updated at the end of every JIT compilation phase. A JIT compilation phase is the phase when a method and its dependencies are being compiled.
|
|
|
|
TIME_IN_JIT_BASE_009_NAME=Not Displayed
|
|
TIME_IN_JIT_BASE_009_HELP=Not Displayed.
|
|
|
|
DotNetCLR_Interop_OBJECT_009_NAME=.NET CLR Interop
|
|
DotNetCLR_Interop_OBJECT_009_HELP=Stats for CLR interop.
|
|
|
|
CURRENT_CCW_009_NAME=# of CCWs
|
|
CURRENT_CCW_009_HELP=This counter displays the current number of Com-Callable-Wrappers (CCWs). A CCW is a proxy for the .NET managed object being referenced from unmanaged COM client(s). This counter was designed to indicate the number of managed objects being referenced by unmanaged COM code.
|
|
|
|
CURRENT_STUBS_009_NAME=# of Stubs
|
|
CURRENT_STUBS_009_HELP=This counter displays the current number of stubs created by the CLR. Stubs are responsible for marshalling arguments and return values from managed to unmanaged code and vice versa; during a COM Interop call or PInvoke call.
|
|
|
|
NUM_MARSHALLING_009_NAME=# of marshalling
|
|
NUM_MARSHALLING_009_HELP=This counter displays the total number of times arguments and return values have been marshaled from managed to unmanaged code and vice versa since the start of the application. This counter is not incremented if the stubs are inlined. (Stubs are responsible for marshalling arguments and return values). Stubs usually get inlined if the marshalling overhead is small.
|
|
|
|
TOTAL_TLB_IMPORTS_009_NAME=# of TLB imports / sec
|
|
TOTAL_TLB_IMPORTS_009_HELP=Reserved for future use.
|
|
|
|
TOTAL_TLB_EXPORTS_009_NAME=# of TLB exports / sec
|
|
TOTAL_TLB_EXPORTS_009_HELP=Reserved for future use.
|
|
|
|
DotNetCLR_LocksAndThreads_OBJECT_009_NAME=.NET CLR LocksAndThreads
|
|
DotNetCLR_LocksAndThreads_OBJECT_009_HELP=Stats for CLR Locks and Threads.
|
|
|
|
CONTENTION_TOTAL_009_NAME=Total # of Contentions
|
|
CONTENTION_TOTAL_009_HELP=This counter displays the total number of times threads in the CLR have attempted to acquire a managed lock unsuccessfully. Managed locks can be acquired in many ways; by the "lock" statement in C# or by calling System.Monitor.Enter or by using MethodImplOptions.Synchronized custom attribute.
|
|
|
|
CONTENTION_INST_009_NAME=Contention Rate / sec
|
|
CONTENTION_INST_009_HELP=Rate at which threads in the runtime attempt to acquire a managed lock unsuccessfully. Managed locks can be acquired in many ways; by the "lock" statement in C# or by calling System.Monitor.Enter or by using MethodImplOptions.Synchronized custom attribute.
|
|
|
|
QUEUE_LENGTH_CUR_009_NAME=Current Queue Length
|
|
QUEUE_LENGTH_CUR_009_HELP=This counter displays the total number of threads currently waiting to acquire some managed lock in the application. This counter is not an average over time; it displays the last observed value.
|
|
|
|
QUEUE_LENGTH_TOTAL_009_NAME=Queue Length Peak
|
|
QUEUE_LENGTH_TOTAL_009_HELP=This counter displays the total number of threads that waited to acquire some managed lock since the start of the application.
|
|
|
|
QUEUE_LENGTH_INST_009_NAME=Queue Length / sec
|
|
QUEUE_LENGTH_INST_009_HELP=This counter displays the number of threads per second waiting to acquire some lock in the application. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
CURRENT_LOGICAL_THREADS_009_NAME=# of current logical Threads
|
|
CURRENT_LOGICAL_THREADS_009_HELP=This counter displays the number of current .NET thread objects in the application. A .NET thread object is created either by new System.Threading.Thread or when an unmanaged thread enters the managed environment. This counters maintains the count of both running and stopped threads. This counter is not an average over time; it just displays the last observed value.
|
|
|
|
CURRENT_PHYSICAL_THREADS_009_NAME=# of current physical Threads
|
|
CURRENT_PHYSICAL_THREADS_009_HELP=This counter displays the number of native OS threads created and owned by the CLR to act as underlying threads for .NET thread objects. This counters value does not include the threads used by the CLR in its internal operations; it is a subset of the threads in the OS process.
|
|
|
|
RECOGNIZED_THREADS_CUR_009_NAME=# of current recognized threads
|
|
RECOGNIZED_THREADS_CUR_009_HELP=This counter displays the number of threads that are currently recognized by the CLR; they have a corresponding .NET thread object associated with them. These threads are not created by the CLR; they are created outside the CLR but have since run inside the CLR at least once. Only unique threads are tracked; threads with same thread ID re-entering the CLR or recreated after thread exit are not counted twice.
|
|
|
|
RECOGNIZED_THREADS_TOTAL_009_NAME=# of total recognized threads
|
|
RECOGNIZED_THREADS_TOTAL_009_HELP=This counter displays the total number of threads that have been recognized by the CLR since the start of this application; these threads have a corresponding .NET thread object associated with them. These threads are not created by the CLR; they are created outside the CLR but have since run inside the CLR at least once. Only unique threads are tracked; threads with same thread ID re-entering the CLR or recreated after thread exit are not counted twice.
|
|
|
|
RECOGNIZED_THREADS_INST_009_NAME=rate of recognized threads / sec
|
|
RECOGNIZED_THREADS_INST_009_HELP=This counter displays the number of threads per second that have been recognized by the CLR; these threads have a corresponding .NET thread object associated with them. These threads are not created by the CLR; they are created outside the CLR but have since run inside the CLR at least once. Only unique threads are tracked; threads with same thread ID re-entering the CLR or recreated after thread exit are not counted twice. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
DotNetCLR_Security_OBJECT_009_NAME=.NET CLR Security
|
|
DotNetCLR_Security_OBJECT_009_HELP=Stats for CLR Security.
|
|
|
|
SECURITY_TOTALRTCHECKS_009_NAME=Total Runtime Checks
|
|
SECURITY_TOTALRTCHECKS_009_HELP=This counter displays the total number of runtime Code Access Security (CAS) checks performed since the start of the application. Runtime CAS checks are performed when a caller makes a call to a callee demanding a particular permission; the runtime check is made on every call by the caller; the check is done by examining the current thread stack of the caller. This counter used together with "Stack Walk Depth" is indicative of performance penalty for security checks.
|
|
|
|
SECURITY_TIMEAUTHORIZE_009_NAME=% Time Sig. Authenticating
|
|
SECURITY_TIMEAUTHORIZE_009_HELP=Reserved for future use.
|
|
|
|
SECURITY_LINKCHECKS_009_NAME=# Link Time Checks
|
|
SECURITY_LINKCHECKS_009_HELP=This counter displays the total number of linktime Code Access Security (CAS) checks since the start of the application. Linktime CAS checks are performed when a caller makes a call to a callee demanding a particular permission at JIT compile time; linktime check is performed once per caller. This count is not indicative of serious performance issues; its indicative of the security system activity.
|
|
|
|
SECURITY_TIMERTCHECKS_009_NAME=% Time in RT checks
|
|
SECURITY_TIMERTCHECKS_009_HELP=This counter displays the percentage of elapsed time spent in performing runtime Code Access Security (CAS) checks since the last such check. CAS allows code to be trusted to varying degrees and enforces these varying levels of trust depending on code identity. This counter is updated at the end of a runtime security check; it represents the last observed value; its not an average.
|
|
|
|
SECURITY_TIMERTCHECKS_BASE_009_NAME=Not Displayed
|
|
SECURITY_TIMERTCHECKS_BASE_009_HELP=Not Displayed.
|
|
|
|
SECURITY_DEPTHSECURITY_009_NAME=Stack Walk Depth
|
|
SECURITY_DEPTHSECURITY_009_HELP=This counter displays the depth of the stack during that last runtime Code Access Security check. Runtime Code Access Security check is performed by crawling the stack. This counter is not an average; it just displays the last observed value.
|
|
|
|
DotNetCLR_Remoting_OBJECT_009_NAME=.NET CLR Remoting
|
|
DotNetCLR_Remoting_OBJECT_009_HELP=Stats for CLR Remoting.
|
|
|
|
CONTEXT_REMOTECALLS_INST_009_NAME=Remote Calls/sec
|
|
CONTEXT_REMOTECALLS_INST_009_HELP=This counter displays the number of remote procedure calls invoked per second. A remote procedure call is a call on any object outside the caller;s AppDomain. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
CONTEXT_CHANNELS_009_NAME=Channels
|
|
CONTEXT_CHANNELS_009_HELP=This counter displays the total number of remoting channels registered across all AppDomains since the start of the application. Channels are used to transport messages to and from remote objects.
|
|
|
|
CONTEXT_PROXIES_009_NAME=Context Proxies
|
|
CONTEXT_PROXIES_009_HELP=This counter displays the total number of remoting proxy objects created in this process since the start of the process. Proxy object acts as a representative of the remote objects and ensures that all calls made on the proxy are forwarded to the correct remote object instance.
|
|
|
|
CONTEXT_CLASSES_009_NAME=Context-Bound Classes Loaded
|
|
CONTEXT_CLASSES_009_HELP=This counter displays the current number of context-bound classes loaded. Classes that can be bound to a context are called context-bound classes; context-bound classes are marked with Context Attributes which provide usage rules for synchronization; thread affinity; transactions etc.
|
|
|
|
CONTEXT_OBJALLOC_009_NAME=Context-Bound Objects Alloc / sec
|
|
CONTEXT_OBJALLOC_009_HELP=This counter displays the number of context-bound objects allocated per second. Instances of classes that can be bound to a context are called context-bound objects; context-bound classes are marked with Context Attributes which provide usage rules for synchronization; thread affinity; transactions etc. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
CONTEXT_CONTEXTS_009_NAME=Contexts
|
|
CONTEXT_CONTEXTS_009_HELP=This counter displays the current number of remoting contexts in the application. A context is a boundary containing a collection of objects with the same usage rules like synchronization; thread affinity; transactions etc.
|
|
|
|
CONTEXT_REMOTECALLS_TOTAL_009_NAME=Total Remote Calls
|
|
CONTEXT_REMOTECALLS_TOTAL_009_HELP=This counter displays the total number of remote procedure calls invoked since the start of this application. A remote procedure call is a call on any object outside the caller;s AppDomain.
|
|
|
|
DotNetCLR_Excep_OBJECT_009_NAME=.NET CLR Exceptions
|
|
DotNetCLR_Excep_OBJECT_009_HELP=Runtime statistics on CLR exception handling.
|
|
|
|
EXCEP_THROWN_TOTAL_009_NAME=# of Exceps Thrown
|
|
EXCEP_THROWN_TOTAL_009_HELP=This counter displays the total number of exceptions thrown since the start of the application. These include both .NET exceptions and unmanaged exceptions that get converted into .NET exceptions e.g. null pointer reference exception in unmanaged code would get re-thrown in managed code as a .NET System.NullReferenceException; this counter includes both handled and unhandled exceptions. Exceptions that are re-thrown would get counted again. Exceptions should only occur in rare situations and not in the normal control flow of the program.
|
|
|
|
EXCEP_THROWN_INST_009_NAME=# of Exceps Thrown / sec
|
|
EXCEP_THROWN_INST_009_HELP=This counter displays the number of exceptions thrown per second. These include both .NET exceptions and unmanaged exceptions that get converted into .NET exceptions e.g. null pointer reference exception in unmanaged code would get re-thrown in managed code as a .NET System.NullReferenceException; this counter includes both handled and unhandled exceptions. Exceptions should only occur in rare situations and not in the normal control flow of the program; this counter was designed as an indicator of potential performance problems due to large (>100s) rate of exceptions thrown. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
TOTAL_EXCEP_FILTERS_RUN_009_NAME=# of Filters / sec
|
|
TOTAL_EXCEP_FILTERS_RUN_009_HELP=This counter displays the number of .NET exception filters executed per second. An exception filter evaluates whether an exception should be handled or not. This counter tracks the rate of exception filters evaluated; irrespective of whether the exception was handled or not. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
TOTAL_EXCEP_FINALLYS_RUN_009_NAME=# of Finallys / sec
|
|
TOTAL_EXCEP_FINALLYS_RUN_009_HELP=This counter displays the number of finally blocks executed per second. A finally block is guaranteed to be executed regardless of how the try block was exited. Only the finally blocks that are executed for an exception are counted; finally blocks on normal code paths are not counted by this counter. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
EXCEPT_STACK_DEPTH_009_NAME=Throw To Catch Depth / sec
|
|
EXCEPT_STACK_DEPTH_009_HELP=This counter displays the number of stack frames traversed from the frame that threw the .NET exception to the frame that handled the exception per second. This counter resets to 0 when an exception handler is entered; so nested exceptions would show the handler to handler stack depth. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
DotNetCLR_Memory_OBJECT_000_NAME=.NET CLR Memory
|
|
DotNetCLR_Memory_OBJECT_000_HELP=Counters for CLR Garbage Collected heap.
|
|
|
|
GEN0_COLLECTIONS_COUNTER_000_NAME=# Gen 0 Collections
|
|
GEN0_COLLECTIONS_COUNTER_000_HELP=This counter displays the number of times the generation 0 objects (youngest; most recently allocated) are garbage collected (Gen 0 GC) since the start of the application. Gen 0 GC occurs when the available memory in generation 0 is not sufficient to satisfy an allocation request. This counter is incremented at the end of a Gen 0 GC. Higher generation GCs include all lower generation GCs. This counter is explicitly incremented when a higher generation (Gen 1 or Gen 2) GC occurs. _Global_ counter value is not accurate and should be ignored. This counter displays the last observed value.
|
|
|
|
GEN1_COLLECTIONS_COUNTER_000_NAME=# Gen 1 Collections
|
|
GEN1_COLLECTIONS_COUNTER_000_HELP=This counter displays the number of times the generation 1 objects are garbage collected since the start of the application. The counter is incremented at the end of a Gen 1 GC. Higher generation GCs include all lower generation GCs. This counter is explicitly incremented when a higher generation (Gen 2) GC occurs. _Global_ counter value is not accurate and should be ignored. This counter displays the last observed value.
|
|
|
|
GEN2_COLLECTIONS_COUNTER_000_NAME=# Gen 2 Collections
|
|
GEN2_COLLECTIONS_COUNTER_000_HELP=This counter displays the number of times the generation 2 objects (older) are garbage collected since the start of the application. The counter is incremented at the end of a Gen 2 GC (also called full GC). _Global_ counter value is not accurate and should be ignored. This counter displays the last observed value.
|
|
|
|
GEN0_BYTES_PROMOTED_COUNTER_000_NAME=Promoted Memory from Gen 0
|
|
GEN0_BYTES_PROMOTED_COUNTER_000_HELP=This counter displays the bytes of memory that survive garbage collection (GC) and are promoted from generation 0 to generation 1; objects that are promoted just because they are waiting to be finalized are not included in this counter. This counter displays the value observed at the end of the last GC; its not a cumulative counter.
|
|
|
|
GEN1_BYTES_PROMOTED_COUNTER_000_NAME=Promoted Memory from Gen 1
|
|
GEN1_BYTES_PROMOTED_COUNTER_000_HELP=This counter displays the bytes of memory that survive garbage collection (GC) and are promoted from generation 1 to generation 2; objects that are promoted just because they are waiting to be finalized are not included in this counter. This counter displays the value observed at the end of the last GC; its not a cumulative counter. This counter is reset to 0 if the last GC was a Gen 0 GC only.
|
|
|
|
GEN0_PROMOTION_RATE_000_NAME=Gen 0 Promoted Bytes/Sec
|
|
GEN0_PROMOTION_RATE_000_HELP=This counter displays the bytes per second that are promoted from generation 0 (youngest) to generation 1; objects that are promoted just because they are waiting to be finalized are not included in this counter. Memory is promoted when it survives a garbage collection. This counter was designed as an indicator of relatively long-lived objects being created per sec. This counter displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
GEN1_PROMOTION_RATE_000_NAME=Gen 1 Promoted Bytes/Sec
|
|
GEN1_PROMOTION_RATE_000_HELP=This counter displays the bytes per second that are promoted from generation 1 to generation 2 (oldest); objects that are promoted just because they are waiting to be finalized are not included in this counter. Memory is promoted when it survives a garbage collection. Nothing is promoted from generation 2 since it is the oldest. This counter was designed as an indicator of very long-lived objects being created per sec. This counter displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
GEN0_FINALIZATION_BYTES_PROMOTED_COUNTER_000_NAME=Promoted Finalization-Memory from Gen 0
|
|
GEN0_FINALIZATION_BYTES_PROMOTED_COUNTER_000_HELP=This counter displays the bytes of memory that are promoted from generation 0 to generation 1 just because they are waiting to be finalized. This counter displays the value observed at the end of the last GC; its not a cumulative counter.
|
|
|
|
GEN1_FINALIZATION_BYTES_PROMOTED_COUNTER_000_NAME=Promoted Finalization-Memory from Gen 1
|
|
GEN1_FINALIZATION_BYTES_PROMOTED_COUNTER_000_HELP=This counter displays the bytes of memory that are promoted from generation 1 to generation 2 just because they are waiting to be finalized. This counter displays the value observed at the end of the last GC; its not a cumulative counter. This counter is reset to 0 if the last GC was a Gen 0 GC only.
|
|
|
|
GEN0_HEAP_SIZE_COUNTER_000_NAME=Gen 0 heap size
|
|
GEN0_HEAP_SIZE_COUNTER_000_HELP=This counter displays the maximum bytes that can be allocated in generation 0 (Gen 0); its does not indicate the current number of bytes allocated in Gen 0. A Gen 0 GC is triggered when the allocations since the last GC exceed this size. The Gen 0 size is tuned by the Garbage Collector and can change during the execution of the application. At the end of a Gen 0 collection the size of the Gen 0 heap is infact 0 bytes; this counter displays the size (in bytes) of allocations that would trigger the next Gen 0 GC. This counter is updated at the end of a GC; its not updated on every allocation.
|
|
|
|
GEN1_HEAP_SIZE_COUNTER_000_NAME=Gen 1 heap size
|
|
GEN1_HEAP_SIZE_COUNTER_000_HELP=This counter displays the current number of bytes in generation 1 (Gen 1); this counter does not display the maximum size of Gen 1. Objects are not directly allocated in this generation; they are promoted from previous Gen 0 GCs. This counter is updated at the end of a GC; its not updated on every allocation.
|
|
|
|
GEN2_HEAP_SIZE_COUNTER_000_NAME=Gen 2 heap size
|
|
GEN2_HEAP_SIZE_COUNTER_000_HELP=This counter displays the current number of bytes in generation 2 (Gen 2). Objects are not directly allocated in this generation; they are promoted from Gen 1 during previous Gen 1 GCs. This counter is updated at the end of a GC; its not updated on every allocation.
|
|
|
|
LARGE_OBJECT_SIZE_COUNTER_000_NAME=Large Object Heap size
|
|
LARGE_OBJECT_SIZE_COUNTER_000_HELP=This counter displays the current size of the Large Object Heap in bytes. Objects greater than 20 KBytes are treated as large objects by the Garbage Collector and are directly allocated in a special heap; they are not promoted through the generations. This counter is updated at the end of a GC; its not updated on every allocation.
|
|
|
|
SURVIVE_FINALIZE_COUNTER_000_NAME=Finalization Survivors
|
|
SURVIVE_FINALIZE_COUNTER_000_HELP=This counter displays the number of garbage collected objects that survive a collection because they are waiting to be finalized. If these objects hold references to other objects then those objects also survive but are not counted by this counter; the "Promoted Finalization-Memory from Gen 0" and "Promoted Finalization-Memory from Gen 1" counters represent all the memory that survived due to finalization. This counter is not a cumulative counter; its updated at the end of every GC with count of the survivors during that particular GC only. This counter was designed to indicate the extra overhead that the application might incur because of finalization.
|
|
|
|
NUM_HANDLES_COUNTER_000_NAME=# GC Handles
|
|
NUM_HANDLES_COUNTER_000_HELP=This counter displays the current number of GC Handles in use. GCHandles are handles to resources external to the CLR and the managed environment. Handles occupy small amounts of memory in the GCHeap but potentially expensive unmanaged resources.
|
|
|
|
ALLOCATION_RATE_COUNTER_000_NAME=Allocated Bytes/sec
|
|
ALLOCATION_RATE_COUNTER_000_HELP=This counter displays the rate of bytes per second allocated on the GC Heap. This counter is updated at the end of every GC; not at each allocation. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
INDUCED_GC_COUNTER_000_NAME=# Induced GC
|
|
INDUCED_GC_COUNTER_000_HELP=This counter displays the peak number of times a garbage collection was performed because of an explicit call to GC.Collect. Its a good practice to let the GC tune the frequency of its collections.
|
|
|
|
PER_TIME_IN_GC_COUNTER_000_NAME=% Time in GC
|
|
PER_TIME_IN_GC_COUNTER_000_HELP=% Time in GC is the percentage of elapsed time that was spent in performing a garbage collection (GC) since the last GC cycle. This counter is usually an indicator of the work done by the Garbage Collector on behalf of the application to collect and compact memory. This counter is updated only at the end of every GC and the counter value reflects the last observed value; its not an average.
|
|
|
|
PER_TIME_IN_GC_COUNTER_BASE_000_NAME=Not Displayed
|
|
PER_TIME_IN_GC_COUNTER_BASE_000_HELP=Not Displayed.
|
|
|
|
TOTAL_HEAP_SIZE_COUNTER_000_NAME=# Bytes in all Heaps
|
|
TOTAL_HEAP_SIZE_COUNTER_000_HELP=This counter is the sum of four other counters; Gen 0 Heap Size; Gen 1 Heap Size; Gen 2 Heap Size and the Large Object Heap Size. This counter indicates the current memory allocated in bytes on the GC Heaps.
|
|
|
|
TOTAL_COMMITTED_MEM_COUNTER_000_NAME=# Total committed Bytes
|
|
TOTAL_COMMITTED_MEM_COUNTER_000_HELP=This counter displays the amount of virtual memory (in bytes) currently committed by the Garbage Collector. (Committed memory is the physical memory for which space has been reserved on the disk paging file).
|
|
|
|
TOTAL_RESERVED_MEM_COUNTER_000_NAME=# Total reserved Bytes
|
|
TOTAL_RESERVED_MEM_COUNTER_000_HELP=This counter displays the amount of virtual memory (in bytes) currently reserved by the Garbage Collector. (Reserved memory is the virtual memory space reserved for the application but no disk or main memory pages have been used.)
|
|
|
|
GC_PINNED_OBJECTS_000_NAME=# of Pinned Objects
|
|
GC_PINNED_OBJECTS_000_HELP=This counter displays the number of pinned objects encountered in the last GC. This counter tracks the pinned objects only in the heaps that were garbage collected e.g. a Gen 0 GC would cause enumeration of pinned objects in the generation 0 heap only. A pinned object is one that the Garbage Collector cannot move in memory.
|
|
|
|
GC_SINKBLOCKS_000_NAME=# of Sink Blocks in use
|
|
GC_SINKBLOCKS_000_HELP=This counter displays the current number of sync blocks in use. Sync blocks are per-object data structures allocated for storing synchronization information. Sync blocks hold weak references to managed objects and need to be scanned by the Garbage Collector. Sync blocks are not limited to storing synchronization information and can also store COM interop metadata. This counter was designed to indicate performance problems with heavy use of synchronization primitives.
|
|
|
|
DotNetCLR_Loading_OBJECT_000_NAME=.NET CLR Loading
|
|
DotNetCLR_Loading_OBJECT_000_HELP=Statistics for CLR Class Loader.
|
|
|
|
LOADING_CLASSES_TOTAL_000_NAME=Total Classes Loaded
|
|
LOADING_CLASSES_TOTAL_000_HELP=This counter displays the cumulative number of classes loaded in all Assemblies since the start of this application.
|
|
|
|
LOADING_TIME_000_NAME=% Time Loading
|
|
LOADING_TIME_000_HELP=Reserved for future use.
|
|
|
|
LOADING_ASMSEARCHLEN_000_NAME=Assembly Search Length
|
|
LOADING_ASMSEARCHLEN_000_HELP=Reserved for future use.
|
|
|
|
LOADING_LOADFAILURES_TOTAL_000_NAME=Total # of Load Failures
|
|
LOADING_LOADFAILURES_TOTAL_000_HELP=This counter displays the peak number of classes that have failed to load since the start of the application. These load failures could be due to many reasons like inadequate security or illegal format. Full details can be found in the profiling services help.
|
|
|
|
LOADING_LOADFAILURES_INST_000_NAME=Rate of Load Failures
|
|
LOADING_LOADFAILURES_INST_000_HELP=This counter displays the number of classes that failed to load per second. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval. These load failures could be due to many reasons like inadequate security or illegal format. Full details can be found in the profiling services help.
|
|
|
|
LOADING_HEAPSIZE_000_NAME=Bytes in Loader Heap
|
|
LOADING_HEAPSIZE_000_HELP=This counter displays the current size (in bytes) of the memory committed by the class loader across all AppDomains. (Committed memory is the physical memory for which space has been reserved on the disk paging file.)
|
|
|
|
LOADING_APPDOMAINS_UNLOADED_TOTAL_000_NAME=Total appdomains unloaded
|
|
LOADING_APPDOMAINS_UNLOADED_TOTAL_000_HELP=This counter displays the total number of AppDomains unloaded since the start of the application. If an AppDomain is loaded and unloaded multiple times this counter would count each of those unloads as separate.
|
|
|
|
LOADING_APPDOMAINS_UNLOADED_INST_000_NAME=Rate of appdomains unloaded
|
|
LOADING_APPDOMAINS_UNLOADED_INST_000_HELP=This counter displays the number of AppDomains unloaded per second. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
LOADING_CLASSES_CUR_000_NAME=Current Classes Loaded
|
|
LOADING_CLASSES_CUR_000_HELP=This counter displays the current number of classes loaded in all Assemblies.
|
|
|
|
LOADING_CLASSES_INST_000_NAME=Rate of Classes Loaded
|
|
LOADING_CLASSES_INST_000_HELP=This counter displays the number of classes loaded per second in all Assemblies. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
LOADING_APPDOMAINS_CUR_000_NAME=Current appdomains
|
|
LOADING_APPDOMAINS_CUR_000_HELP=This counter displays the current number of AppDomains loaded in this application. AppDomains (application domains) provide a secure and versatile unit of processing that the CLR can use to provide isolation between applications running in the same process.
|
|
|
|
LOADING_APPDOMAINS_TOTAL_000_NAME=Total Appdomains
|
|
LOADING_APPDOMAINS_TOTAL_000_HELP=This counter displays the peak number of AppDomains loaded since the start of this application. AppDomains (application domains) provide a secure and versatile unit of processing that the CLR can use to provide isolation between applications running in the same process.
|
|
|
|
LOADING_APPDOMAINS_INST_000_NAME=Rate of appdomains
|
|
LOADING_APPDOMAINS_INST_000_HELP=This counter displays the number of AppDomains loaded per second. AppDomains (application domains) provide a secure and versatile unit of processing that the CLR can use to provide isolation between applications running in the same process. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
LOADING_ASSEMBLIES_CUR_000_NAME=Current Assemblies
|
|
LOADING_ASSEMBLIES_CUR_000_HELP=This counter displays the current number of Assemblies loaded across all AppDomains in this application. If the Assembly is loaded as domain-neutral from multiple AppDomains then this counter is incremented once only. Assemblies can be loaded as domain-neutral when their code can be shared by all AppDomains or they can be loaded as domain-specific when their code is private to the AppDomain.
|
|
|
|
LOADING_ASSEMBLIES_TOTAL_000_NAME=Total Assemblies
|
|
LOADING_ASSEMBLIES_TOTAL_000_HELP=This counter displays the total number of Assemblies loaded since the start of this application. If the Assembly is loaded as domain-neutral from multiple AppDomains then this counter is incremented once only. Assemblies can be loaded as domain-neutral when their code can be shared by all AppDomains or they can be loaded as domain-specific when their code is private to the AppDomain.
|
|
|
|
LOADING_ASSEMBLIES_INST_000_NAME=Rate of Assemblies
|
|
LOADING_ASSEMBLIES_INST_000_HELP=This counter displays the number of Assemblies loaded across all AppDomains per second. If the Assembly is loaded as domain-neutral from multiple AppDomains then this counter is incremented once only. Assemblies can be loaded as domain-neutral when their code can be shared by all AppDomains or they can be loaded as domain-specific when their code is private to the AppDomain. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
DotNetCLR_Jit_OBJECT_000_NAME=.NET CLR Jit
|
|
DotNetCLR_Jit_OBJECT_000_HELP=Stats for CLR Jit.
|
|
|
|
TOTAL_METHODS_JITTED_000_NAME=# of Methods Jitted
|
|
TOTAL_METHODS_JITTED_000_HELP=This counter displays the total number of methods compiled Just-In-Time (JIT) by the CLR JIT compiler since the start of the application. This counter does not include the pre-jitted methods.
|
|
|
|
JITTED_IL_CUR_000_NAME=# of IL Bytes Jitted
|
|
JITTED_IL_CUR_000_HELP=This counter displays the total IL bytes jitted since the start of the application. This counter is exactly equivalent to the "Total # of IL Bytes Jitted" counter.
|
|
|
|
JITTED_IL_TOTAL_000_NAME=Total # of IL Bytes Jitted
|
|
JITTED_IL_TOTAL_000_HELP=This counter displays the total IL bytes jitted since the start of the application. This counter is exactly equivalent to the "# of IL Bytes Jitted" counter.
|
|
|
|
JITTED_IL_INST_000_NAME=IL Bytes Jitted / sec
|
|
JITTED_IL_INST_000_HELP=This counter displays the rate at which IL bytes are jitted per second. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
JIT_FAILURES_000_NAME=Standard Jit Failures
|
|
JIT_FAILURES_000_HELP=This counter displays the peak number of methods the JIT compiler has failed to JIT since the start of the application. This failure can occur if the IL cannot be verified or if there was an internal error in the JIT compiler.
|
|
|
|
TIME_IN_JIT_000_NAME=% Time in Jit
|
|
TIME_IN_JIT_000_HELP=This counter displays the percentage of elapsed time spent in JIT compilation since the last JIT compilation phase. This counter is updated at the end of every JIT compilation phase. A JIT compilation phase is the phase when a method and its dependencies are being compiled.
|
|
|
|
TIME_IN_JIT_BASE_000_NAME=Not Displayed
|
|
TIME_IN_JIT_BASE_000_HELP=Not Displayed.
|
|
|
|
DotNetCLR_Interop_OBJECT_000_NAME=.NET CLR Interop
|
|
DotNetCLR_Interop_OBJECT_000_HELP=Stats for CLR interop.
|
|
|
|
CURRENT_CCW_000_NAME=# of CCWs
|
|
CURRENT_CCW_000_HELP=This counter displays the current number of Com-Callable-Wrappers (CCWs). A CCW is a proxy for the .NET managed object being referenced from unmanaged COM client(s). This counter was designed to indicate the number of managed objects being referenced by unmanaged COM code.
|
|
|
|
CURRENT_STUBS_000_NAME=# of Stubs
|
|
CURRENT_STUBS_000_HELP=This counter displays the current number of stubs created by the CLR. Stubs are responsible for marshalling arguments and return values from managed to unmanaged code and vice versa; during a COM Interop call or PInvoke call.
|
|
|
|
NUM_MARSHALLING_000_NAME=# of marshalling
|
|
NUM_MARSHALLING_000_HELP=This counter displays the total number of times arguments and return values have been marshaled from managed to unmanaged code and vice versa since the start of the application. This counter is not incremented if the stubs are inlined. (Stubs are responsible for marshalling arguments and return values). Stubs usually get inlined if the marshalling overhead is small.
|
|
|
|
TOTAL_TLB_IMPORTS_000_NAME=# of TLB imports / sec
|
|
TOTAL_TLB_IMPORTS_000_HELP=Reserved for future use.
|
|
|
|
TOTAL_TLB_EXPORTS_000_NAME=# of TLB exports / sec
|
|
TOTAL_TLB_EXPORTS_000_HELP=Reserved for future use.
|
|
|
|
DotNetCLR_LocksAndThreads_OBJECT_000_NAME=.NET CLR LocksAndThreads
|
|
DotNetCLR_LocksAndThreads_OBJECT_000_HELP=Stats for CLR Locks and Threads.
|
|
|
|
CONTENTION_TOTAL_000_NAME=Total # of Contentions
|
|
CONTENTION_TOTAL_000_HELP=This counter displays the total number of times threads in the CLR have attempted to acquire a managed lock unsuccessfully. Managed locks can be acquired in many ways; by the "lock" statement in C# or by calling System.Monitor.Enter or by using MethodImplOptions.Synchronized custom attribute.
|
|
|
|
CONTENTION_INST_000_NAME=Contention Rate / sec
|
|
CONTENTION_INST_000_HELP=Rate at which threads in the runtime attempt to acquire a managed lock unsuccessfully. Managed locks can be acquired in many ways; by the "lock" statement in C# or by calling System.Monitor.Enter or by using MethodImplOptions.Synchronized custom attribute.
|
|
|
|
QUEUE_LENGTH_CUR_000_NAME=Current Queue Length
|
|
QUEUE_LENGTH_CUR_000_HELP=This counter displays the total number of threads currently waiting to acquire some managed lock in the application. This counter is not an average over time; it displays the last observed value.
|
|
|
|
QUEUE_LENGTH_TOTAL_000_NAME=Queue Length Peak
|
|
QUEUE_LENGTH_TOTAL_000_HELP=This counter displays the total number of threads that waited to acquire some managed lock since the start of the application.
|
|
|
|
QUEUE_LENGTH_INST_000_NAME=Queue Length / sec
|
|
QUEUE_LENGTH_INST_000_HELP=This counter displays the number of threads per second waiting to acquire some lock in the application. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
CURRENT_LOGICAL_THREADS_000_NAME=# of current logical Threads
|
|
CURRENT_LOGICAL_THREADS_000_HELP=This counter displays the number of current .NET thread objects in the application. A .NET thread object is created either by new System.Threading.Thread or when an unmanaged thread enters the managed environment. This counters maintains the count of both running and stopped threads. This counter is not an average over time; it just displays the last observed value.
|
|
|
|
CURRENT_PHYSICAL_THREADS_000_NAME=# of current physical Threads
|
|
CURRENT_PHYSICAL_THREADS_000_HELP=This counter displays the number of native OS threads created and owned by the CLR to act as underlying threads for .NET thread objects. This counters value does not include the threads used by the CLR in its internal operations; it is a subset of the threads in the OS process.
|
|
|
|
RECOGNIZED_THREADS_CUR_000_NAME=# of current recognized threads
|
|
RECOGNIZED_THREADS_CUR_000_HELP=This counter displays the number of threads that are currently recognized by the CLR; they have a corresponding .NET thread object associated with them. These threads are not created by the CLR; they are created outside the CLR but have since run inside the CLR at least once. Only unique threads are tracked; threads with same thread ID re-entering the CLR or recreated after thread exit are not counted twice.
|
|
|
|
RECOGNIZED_THREADS_TOTAL_000_NAME=# of total recognized threads
|
|
RECOGNIZED_THREADS_TOTAL_000_HELP=This counter displays the total number of threads that have been recognized by the CLR since the start of this application; these threads have a corresponding .NET thread object associated with them. These threads are not created by the CLR; they are created outside the CLR but have since run inside the CLR at least once. Only unique threads are tracked; threads with same thread ID re-entering the CLR or recreated after thread exit are not counted twice.
|
|
|
|
RECOGNIZED_THREADS_INST_000_NAME=rate of recognized threads / sec
|
|
RECOGNIZED_THREADS_INST_000_HELP=This counter displays the number of threads per second that have been recognized by the CLR; these threads have a corresponding .NET thread object associated with them. These threads are not created by the CLR; they are created outside the CLR but have since run inside the CLR at least once. Only unique threads are tracked; threads with same thread ID re-entering the CLR or recreated after thread exit are not counted twice. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
DotNetCLR_Security_OBJECT_000_NAME=.NET CLR Security
|
|
DotNetCLR_Security_OBJECT_000_HELP=Stats for CLR Security.
|
|
|
|
SECURITY_TOTALRTCHECKS_000_NAME=Total Runtime Checks
|
|
SECURITY_TOTALRTCHECKS_000_HELP=This counter displays the total number of runtime Code Access Security (CAS) checks performed since the start of the application. Runtime CAS checks are performed when a caller makes a call to a callee demanding a particular permission; the runtime check is made on every call by the caller; the check is done by examining the current thread stack of the caller. This counter used together with "Stack Walk Depth" is indicative of performance penalty for security checks.
|
|
|
|
SECURITY_TIMEAUTHORIZE_000_NAME=% Time Sig. Authenticating
|
|
SECURITY_TIMEAUTHORIZE_000_HELP=Reserved for future use.
|
|
|
|
SECURITY_LINKCHECKS_000_NAME=# Link Time Checks
|
|
SECURITY_LINKCHECKS_000_HELP=This counter displays the total number of linktime Code Access Security (CAS) checks since the start of the application. Linktime CAS checks are performed when a caller makes a call to a callee demanding a particular permission at JIT compile time; linktime check is performed once per caller. This count is not indicative of serious performance issues; its indicative of the security system activity.
|
|
|
|
SECURITY_TIMERTCHECKS_000_NAME=% Time in RT checks
|
|
SECURITY_TIMERTCHECKS_000_HELP=This counter displays the percentage of elapsed time spent in performing runtime Code Access Security (CAS) checks since the last such check. CAS allows code to be trusted to varying degrees and enforces these varying levels of trust depending on code identity. This counter is updated at the end of a runtime security check; it represents the last observed value; its not an average.
|
|
|
|
SECURITY_TIMERTCHECKS_BASE_000_NAME=Not Displayed
|
|
SECURITY_TIMERTCHECKS_BASE_000_HELP=Not Displayed.
|
|
|
|
SECURITY_DEPTHSECURITY_000_NAME=Stack Walk Depth
|
|
SECURITY_DEPTHSECURITY_000_HELP=This counter displays the depth of the stack during that last runtime Code Access Security check. Runtime Code Access Security check is performed by crawling the stack. This counter is not an average; it just displays the last observed value.
|
|
|
|
DotNetCLR_Remoting_OBJECT_000_NAME=.NET CLR Remoting
|
|
DotNetCLR_Remoting_OBJECT_000_HELP=Stats for CLR Remoting.
|
|
|
|
CONTEXT_REMOTECALLS_INST_000_NAME=Remote Calls/sec
|
|
CONTEXT_REMOTECALLS_INST_000_HELP=This counter displays the number of remote procedure calls invoked per second. A remote procedure call is a call on any object outside the caller;s AppDomain. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
CONTEXT_CHANNELS_000_NAME=Channels
|
|
CONTEXT_CHANNELS_000_HELP=This counter displays the total number of remoting channels registered across all AppDomains since the start of the application. Channels are used to transport messages to and from remote objects.
|
|
|
|
CONTEXT_PROXIES_000_NAME=Context Proxies
|
|
CONTEXT_PROXIES_000_HELP=This counter displays the total number of remoting proxy objects created in this process since the start of the process. Proxy object acts as a representative of the remote objects and ensures that all calls made on the proxy are forwarded to the correct remote object instance.
|
|
|
|
CONTEXT_CLASSES_000_NAME=Context-Bound Classes Loaded
|
|
CONTEXT_CLASSES_000_HELP=This counter displays the current number of context-bound classes loaded. Classes that can be bound to a context are called context-bound classes; context-bound classes are marked with Context Attributes which provide usage rules for synchronization; thread affinity; transactions etc.
|
|
|
|
CONTEXT_OBJALLOC_000_NAME=Context-Bound Objects Alloc / sec
|
|
CONTEXT_OBJALLOC_000_HELP=This counter displays the number of context-bound objects allocated per second. Instances of classes that can be bound to a context are called context-bound objects; context-bound classes are marked with Context Attributes which provide usage rules for synchronization; thread affinity; transactions etc. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
CONTEXT_CONTEXTS_000_NAME=Contexts
|
|
CONTEXT_CONTEXTS_000_HELP=This counter displays the current number of remoting contexts in the application. A context is a boundary containing a collection of objects with the same usage rules like synchronization; thread affinity; transactions etc.
|
|
|
|
CONTEXT_REMOTECALLS_TOTAL_000_NAME=Total Remote Calls
|
|
CONTEXT_REMOTECALLS_TOTAL_000_HELP=This counter displays the total number of remote procedure calls invoked since the start of this application. A remote procedure call is a call on any object outside the caller;s AppDomain.
|
|
|
|
DotNetCLR_Excep_OBJECT_000_NAME=.NET CLR Exceptions
|
|
DotNetCLR_Excep_OBJECT_000_HELP=Runtime statistics on CLR exception handling.
|
|
|
|
EXCEP_THROWN_TOTAL_000_NAME=# of Exceps Thrown
|
|
EXCEP_THROWN_TOTAL_000_HELP=This counter displays the total number of exceptions thrown since the start of the application. These include both .NET exceptions and unmanaged exceptions that get converted into .NET exceptions e.g. null pointer reference exception in unmanaged code would get re-thrown in managed code as a .NET System.NullReferenceException; this counter includes both handled and unhandled exceptions. Exceptions that are re-thrown would get counted again. Exceptions should only occur in rare situations and not in the normal control flow of the program.
|
|
|
|
EXCEP_THROWN_INST_000_NAME=# of Exceps Thrown / sec
|
|
EXCEP_THROWN_INST_000_HELP=This counter displays the number of exceptions thrown per second. These include both .NET exceptions and unmanaged exceptions that get converted into .NET exceptions e.g. null pointer reference exception in unmanaged code would get re-thrown in managed code as a .NET System.NullReferenceException; this counter includes both handled and unhandled exceptions. Exceptions should only occur in rare situations and not in the normal control flow of the program; this counter was designed as an indicator of potential performance problems due to large (>100s) rate of exceptions thrown. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
TOTAL_EXCEP_FILTERS_RUN_000_NAME=# of Filters / sec
|
|
TOTAL_EXCEP_FILTERS_RUN_000_HELP=This counter displays the number of .NET exception filters executed per second. An exception filter evaluates whether an exception should be handled or not. This counter tracks the rate of exception filters evaluated; irrespective of whether the exception was handled or not. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
TOTAL_EXCEP_FINALLYS_RUN_000_NAME=# of Finallys / sec
|
|
TOTAL_EXCEP_FINALLYS_RUN_000_HELP=This counter displays the number of finally blocks executed per second. A finally block is guaranteed to be executed regardless of how the try block was exited. Only the finally blocks that are executed for an exception are counted; finally blocks on normal code paths are not counted by this counter. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|
|
EXCEPT_STACK_DEPTH_000_NAME=Throw To Catch Depth / sec
|
|
EXCEPT_STACK_DEPTH_000_HELP=This counter displays the number of stack frames traversed from the frame that threw the .NET exception to the frame that handled the exception per second. This counter resets to 0 when an exception handler is entered; so nested exceptions would show the handler to handler stack depth. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
|
|
|