PerformanceCounterType Enumeráció
Definíció
Fontos
Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.
Olyan teljesítményszámlálótípusokat határoz meg, amelyek közvetlenül natív típusokra képeznek le.
public enum class PerformanceCounterTypepublic enum PerformanceCounterType[System.ComponentModel.TypeConverter(typeof(System.Diagnostics.AlphabeticalEnumConverter))]
public enum PerformanceCounterTypetype PerformanceCounterType = [<System.ComponentModel.TypeConverter(typeof(System.Diagnostics.AlphabeticalEnumConverter))>]
type PerformanceCounterType = Public Enum PerformanceCounterType- Öröklődés
- Attribútumok
Mezők
| Name | Érték | Description |
|---|---|---|
| NumberOfItemsHEX32 | 0 | Azonnali számláló, amely a legutóbb megfigyelt értéket hexadecimális formátumban jeleníti meg. Például az elemek vagy műveletek egyszerű számának fenntartására szolgál. |
| NumberOfItemsHEX64 | 256 | Azonnali számláló, amely a legutóbb megfigyelt értéket jeleníti meg. Például nagyon sok elem vagy művelet egyszerű számának fenntartására szolgál. Ez megegyezik azzal a kivételel NumberOfItemsHEX32 , hogy nagyobb mezőket használ a nagyobb értékek elhelyezéséhez. |
| NumberOfItems32 | 65536 | Azonnali számláló, amely a legutóbb megfigyelt értéket jeleníti meg. Például az elemek vagy műveletek egyszerű számának fenntartására szolgál. Az ilyen típusú számlálók közé tartozik a Memória\Rendelkezésre álló bájtok. |
| NumberOfItems64 | 65792 | Azonnali számláló, amely a legutóbb megfigyelt értéket jeleníti meg. Például nagyon sok elem vagy művelet egyszerű számának fenntartására szolgál. Ez megegyezik azzal a kivételel NumberOfItems32 , hogy nagyobb mezőket használ a nagyobb értékek elhelyezéséhez. |
| CounterDelta32 | 4195328 | Különbségszámláló, amely a mért attribútum változását mutatja a két legutóbbi mintaintervallum között. |
| CounterDelta64 | 4195584 | Különbségszámláló, amely a mért attribútum változását mutatja a két legutóbbi mintaintervallum között. Ez ugyanaz, mint a CounterDelta32 számláló típusa, kivéve, hogy nagyobb mezőket használ a nagyobb értékek elhelyezéséhez. |
| SampleCounter | 4260864 | Egy átlagos számláló, amely az egy másodperc alatt végrehajtott műveletek átlagos számát mutatja. Ha egy ilyen típusú számláló mintát vesz az adatokból, minden mintavételezési megszakítás egy vagy nulla értéket ad vissza. A számlálóadatok a mintavételezett adatok száma. A rendszerteljesítmény-időzítő időegységeiben méri az időt. |
| CountPerTimeInterval32 | 4523008 | Egy átlagos számláló, amelynek célja az üzenetsorok átlagos hosszának figyelése egy erőforrás számára az idő függvényében. Az utolsó két mintaintervallum során megfigyelt üzenetsorhosszok közötti különbséget mutatja az intervallum időtartamával osztva. Ez a számlálótípus általában az üzenetsorba helyezett vagy várakozó elemek számának nyomon követésére szolgál. |
| CountPerTimeInterval64 | 4523264 | Egy átlagos számláló, amely az üzenetsorok átlagos hosszát figyeli egy erőforrás számára az idő függvényében. Az ilyen típusú számlálók az utolsó két mintaintervallum során megfigyelt üzenetsorhosszok közötti különbséget jelenítik meg az intervallum időtartamával osztva. Ez a számlálótípus megegyezik CountPerTimeInterval32 azzal a kivételel, hogy nagyobb mezőket használ a nagyobb értékek elhelyezéséhez. Ezt a számlálótípust általában nagy mennyiségű vagy nagyon nagy számú, várólistára helyezett vagy várakozó elem nyomon követésére használják. |
| RateOfCountsPerSecond32 | 272696320 | Különbségszámláló, amely a mintaintervallum minden másodpercében végrehajtott műveletek átlagos számát mutatja. Az ilyen típusú számlálók az időt a rendszer óraóra ketyegésével mérték. Az ilyen típusú számlálók közé tartozik a System\ File Read Operations/sec. |
| RateOfCountsPerSecond64 | 272696576 | Különbségszámláló, amely a mintaintervallum minden másodpercében végrehajtott műveletek átlagos számát mutatja. Az ilyen típusú számlálók az időt a rendszer óraóra ketyegésével mérték. Ez a számlálótípus megegyezik a RateOfCountsPerSecond32 típussal, de nagyobb mezőket használ a nagyobb értékek fogadására a nagy mennyiségű elem vagy művelet másodpercenkénti nyomon követéséhez, például bájtátviteli sebességhez. Az ilyen típusú számlálók közé tartozik a System\ File Read Bytes/sec. |
| RawFraction | 537003008 | Egy pillanatnyi százalékos számláló, amely egy részhalmaz százalékos arányát jeleníti meg. Összehasonlítja például a lemezen használt bájtok számát a lemezen található bájtok teljes számával. Az ilyen típusú számlálók csak az aktuális százalékot jelenítik meg, nem pedig az átlagot az idő függvényében. Az ilyen típusú számlálók közé tartozik a Lapozófájl\% Kihasználtsági csúcs. |
| CounterTimer | 541132032 | Százalékos számláló, amely azt az átlagos időt jeleníti meg, amikor egy összetevő aktív a teljes mintaidő százalékában. |
| Timer100Ns | 542180608 | Százalékszámláló, amely egy összetevő aktív idejét jeleníti meg a mintaintervallum teljes eltelt idejének százalékában. 100 nanoszekundum (ns) egységben méri az időt. Az ilyen típusú számlálók úgy vannak kialakítva, hogy egyszerre egy összetevő tevékenységét mérik. Az ilyen típusú számlálók közé tartozik a Processzor\% felhasználói idő. |
| SampleFraction | 549585920 | Százalékos számláló, amely az összes művelethez tartozó találatok átlagos arányát mutatja az utolsó két mintaintervallumban. Az ilyen típusú számlálók közé tartozik a Cache\Pin Read Hits %. |
| CounterTimerInverse | 557909248 | Százalékos számláló, amely a mintaintervallum alatt megfigyelt aktív idő átlagos százalékos arányát jeleníti meg. Ezeknek a számlálóknak az értékét úgy számítjuk ki, hogy figyeli a szolgáltatás inaktív állapotának százalékos arányát, majd kivonja az értéket 100 százalékból. Ez egy inverz számlálótípus. A rendszerteljesítmény-időzítő időegységeiben méri az időt. |
| Timer100NsInverse | 558957824 | Százalékos számláló, amely a mintaintervallum alatt megfigyelt aktív idő átlagos százalékos arányát mutatja. Ez egy inverz számláló. Az ilyen típusú számlálók közé tartozik a Processzor\% processzoridő. |
| CounterMultiTimer | 574686464 | Egy százalékszámláló, amely egy vagy több összetevő aktív idejét jeleníti meg a mintaintervallum teljes időtartamának százalékában. Mivel a számláló az egyidejűleg működő összetevők aktív idejét rögzíti, az eredményül kapott százalékos érték meghaladhatja a 100 százalékot. Ez a számlálótípus abban különbözik CounterMultiTimer100Ns , hogy a rendszerteljesítmény-időzítő időegységeiben méri az időt, nem pedig 100 nanoszekundumos egységben. Ez a számlálótípus többidős. |
| CounterMultiTimer100Ns | 575735040 | Egy százalékszámláló, amely egy vagy több összetevő aktív idejét jeleníti meg a mintaintervallum teljes időtartamának százalékában. 100 nanoszekundumos (ns) egységben méri az időt. Ez a számlálótípus többidős. |
| CounterMultiTimerInverse | 591463680 | Egy százalékszámláló, amely egy vagy több összetevő aktív idejét jeleníti meg a mintaintervallum teljes időtartamának százalékában. Az aktív időt úgy nyeri ki, hogy megméri, hogy az összetevők nem voltak aktívak, és kivonja az eredményt 100%-ból a monitorozott objektumok számával. Ez a számlálótípus inverz multitimer. Abban különbözik CounterMultiTimer100NsInverse , hogy a rendszerteljesítmény-időzítő időegységeiben méri az időt, nem pedig 100 nanoszekundumos egységben. |
| CounterMultiTimer100NsInverse | 592512256 | Egy százalékszámláló, amely egy vagy több összetevő aktív idejét jeleníti meg a mintaintervallum teljes időtartamának százalékában. Az ilyen típusú mérőidő számlálói 100 nanoszekundumos (ns) egységben mérik az időt. Az aktív időt úgy nyerik ki, hogy megmérik, hogy az összetevők nem voltak aktívak, és kivonják az eredményt abból, hogy megszorozzák a 100 százalékot a megfigyelt objektumok számával. Ez a számlálótípus inverz multitimer. |
| AverageTimer32 | 805438464 | Egy átlagos számláló, amely egy folyamat vagy művelet elvégzéséhez átlagosan szükséges időt méri. Az ilyen típusú számlálók a mintaintervallum teljes eltelt idejének és az adott időszakban befejezett folyamatok vagy műveletek számának arányát jelenítik meg. Ez a számlálótípus a rendszer órajeleiben méri az időt. Az ilyen típusú számlálók közé tartozik a PhysicalDisk\ Avg. Disk sec/Transfer. |
| ElapsedTime | 807666944 | A különbség időzítője, amely az összetevő vagy folyamat indítása és az érték kiszámítása közötti teljes időt mutatja. Az ilyen típusú számlálók közé tartozik a System\ System Up Time . |
| AverageCount64 | 1073874176 | Egy átlagos számláló, amely azt mutatja, hogy egy művelet során átlagosan hány elem lesz feldolgozva. Az ilyen típusú számlálók a feldolgozott elemek és a végrehajtott műveletek számának arányát jelenítik meg. Az arány kiszámítása az utolsó intervallumban feldolgozott elemek számának és az utolsó intervallumban végrehajtott műveletek számának összehasonlításával történik. Az ilyen típusú számlálók közé tartozik a PhysicalDisk\ Avg. Disk Bytes/Transfer. |
| SampleBase | 1073939457 | Egy alapszámláló, amely a mintavételezési megszakítások számát tárolja, és nevezőként használatos a mintavételi törtben. A mintavételezési tört azoknak a mintáknak a száma, amelyek egy minta megszakításához 1 (vagy |
| AverageBase | 1073939458 | Az idő vagy a darabszám átlagának kiszámításához használt alapszámláló, például AverageTimer32 és AverageCount64. Tárolja a nevezőt a számláló kiszámításához a "műveletenkénti idő" vagy a "darabszám műveletenként" megjelenítése érdekében. |
| RawBase | 1073939459 | Egy olyan alapszámláló, amely egy általános aritmetikai törtet tartalmazó számláló nevezőjének tárolására szolgál. Ellenőrizze, hogy ez az érték nullánál nagyobb-e, mielőtt nevezőként használna egy RawFraction értékszámításban. |
| CounterMultiBase | 1107494144 | Egy alapszámláló, amely a mintavételezett elemek számát jelzi. Nevezőként használják a számításokban, hogy átlagot kapjon a mintában szereplő elemek között több, de hasonló elem időzítésekor. A , CounterMultiTimer, CounterMultiTimerInverseés CounterMultiTimer100Ns.CounterMultiTimer100NsInverse |
Példák
Az alábbi példák az enumerálás számos számlálótípusát szemléltetik PerformanceCounterType .
AverageCount64
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
public class App
{
private static PerformanceCounter avgCounter64Sample;
private static PerformanceCounter avgCounter64SampleBase;
public static void Main()
{
ArrayList samplesList = new ArrayList();
// If the category does not exist, create the category and exit.
// Performance counters should not be created and immediately used.
// There is a latency time to enable the counters, they should be created
// prior to executing the application that uses the counters.
// Execute this sample a second time to use the category.
if (SetupCategory())
return;
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
}
private static bool SetupCategory()
{
if ( !PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") )
{
CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageCount64 = new CounterCreationData();
averageCount64.CounterType = PerformanceCounterType.AverageCount64;
averageCount64.CounterName = "AverageCounter64Sample";
counterDataCollection.Add(averageCount64);
// Add the base counter.
CounterCreationData averageCount64Base = new CounterCreationData();
averageCount64Base.CounterType = PerformanceCounterType.AverageBase;
averageCount64Base.CounterName = "AverageCounter64SampleBase";
counterDataCollection.Add(averageCount64Base);
// Create the category.
PerformanceCounterCategory.Create("AverageCounter64SampleCategory",
"Demonstrates usage of the AverageCounter64 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, counterDataCollection);
return(true);
}
else
{
Console.WriteLine("Category exists - AverageCounter64SampleCategory");
return(false);
}
}
private static void CreateCounters()
{
// Create the counters.
avgCounter64Sample = new PerformanceCounter("AverageCounter64SampleCategory",
"AverageCounter64Sample",
false);
avgCounter64SampleBase = new PerformanceCounter("AverageCounter64SampleCategory",
"AverageCounter64SampleBase",
false);
avgCounter64Sample.RawValue=0;
avgCounter64SampleBase.RawValue=0;
}
private static void CollectSamples(ArrayList samplesList)
{
Random r = new Random( DateTime.Now.Millisecond );
// Loop for the samples.
for (int j = 0; j < 100; j++)
{
int value = r.Next(1, 10);
Console.Write(j + " = " + value);
avgCounter64Sample.IncrementBy(value);
avgCounter64SampleBase.Increment();
if ((j % 10) == 9)
{
OutputSample(avgCounter64Sample.NextSample());
samplesList.Add( avgCounter64Sample.NextSample() );
}
else
{
Console.WriteLine();
}
System.Threading.Thread.Sleep(50);
}
}
private static void CalculateResults(ArrayList samplesList)
{
for(int i = 0; i < (samplesList.Count - 1); i++)
{
// Output the sample.
OutputSample( (CounterSample)samplesList[i] );
OutputSample( (CounterSample)samplesList[i+1] );
// Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " +
CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i+1]) );
// Calculate the counter value manually.
Console.WriteLine("My computed counter value = " +
MyComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i+1]) );
}
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// Description - This counter type shows how many items are processed, on average,
// during an operation. Counters of this type display a ratio of the items
// processed (such as bytes sent) to the number of operations completed. The
// ratio is calculated by comparing the number of items processed during the
// last interval to the number of operations completed during the last interval.
// Generic type - Average
// Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number
// of items processed during the last sample interval and the denominator (D)
// represents the number of operations completed during the last two sample
// intervals.
// Average (Nx - N0) / (Dx - D0)
// Example PhysicalDisk\ Avg. Disk Bytes/Transfer
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
{
Single numerator = (Single)s1.RawValue - (Single)s0.RawValue;
Single denomenator = (Single)s1.BaseValue - (Single)s0.BaseValue;
Single counterValue = numerator / denomenator;
return(counterValue);
}
// Output information about the counter sample.
private static void OutputSample(CounterSample s)
{
Console.WriteLine("\r\n+++++++++++");
Console.WriteLine("Sample values - \r\n");
Console.WriteLine(" BaseValue = " + s.BaseValue);
Console.WriteLine(" CounterFrequency = " + s.CounterFrequency);
Console.WriteLine(" CounterTimeStamp = " + s.CounterTimeStamp);
Console.WriteLine(" CounterType = " + s.CounterType);
Console.WriteLine(" RawValue = " + s.RawValue);
Console.WriteLine(" SystemFrequency = " + s.SystemFrequency);
Console.WriteLine(" TimeStamp = " + s.TimeStamp);
Console.WriteLine(" TimeStamp100nSec = " + s.TimeStamp100nSec);
Console.WriteLine("++++++++++++++++++++++");
}
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.Versioning
<SupportedOSPlatform("Windows")>
Public Class App1
Private Shared avgCounter64Sample As PerformanceCounter
Private Shared avgCounter64SampleBase As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
'If the category does not exist, create the category and exit.
'Performance counters should not be created and immediately used.
'There is a latency time to enable the counters, they should be created
'prior to executing the App1lication that uses the counters.
'Execute this sample a second time to use the counters.
If Not (SetupCategory()) Then
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End If
End Sub
Private Shared Function SetupCategory() As Boolean
If Not PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") Then
Dim counterDataCollection As New CounterCreationDataCollection()
' Add the counter.
Dim averageCount64 As New CounterCreationData()
averageCount64.CounterType = PerformanceCounterType.AverageCount64
averageCount64.CounterName = "AverageCounter64Sample"
counterDataCollection.Add(averageCount64)
' Add the base counter.
Dim averageCount64Base As New CounterCreationData()
averageCount64Base.CounterType = PerformanceCounterType.AverageBase
averageCount64Base.CounterName = "AverageCounter64SampleBase"
counterDataCollection.Add(averageCount64Base)
' Create the category.
PerformanceCounterCategory.Create("AverageCounter64SampleCategory",
"Demonstrates usage of the AverageCounter64 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, counterDataCollection)
Return True
Else
Console.WriteLine("Category exists - AverageCounter64SampleCategory")
Return False
End If
End Function 'SetupCategory
Private Shared Sub CreateCounters()
' Create the counters.
avgCounter64Sample = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64Sample", False)
avgCounter64SampleBase = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64SampleBase", False)
avgCounter64Sample.RawValue = 0
avgCounter64SampleBase.RawValue = 0
End Sub
Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)
Dim r As New Random(DateTime.Now.Millisecond)
' Loop for the samples.
Dim j As Integer
For j = 0 To 99
Dim value As Integer = r.Next(1, 10)
Console.Write(j.ToString() + " = " + value.ToString())
avgCounter64Sample.IncrementBy(value)
avgCounter64SampleBase.Increment()
If j Mod 10 = 9 Then
OutputSample(avgCounter64Sample.NextSample())
samplesList.Add(avgCounter64Sample.NextSample())
Else
Console.WriteLine()
End If
System.Threading.Thread.Sleep(50)
Next j
End Sub
Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
Dim i As Integer
For i = 0 To (samplesList.Count - 1) - 1
' Output the sample.
OutputSample(CType(samplesList(i), CounterSample))
OutputSample(CType(samplesList((i + 1)), CounterSample))
' Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
' Calculate the counter value manually.
Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
Next i
End Sub
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
' Description - This counter type shows how many items are processed, on average,
' during an operation. Counters of this type display a ratio of the items
' processed (such as bytes sent) to the number of operations completed. The
' ratio is calculated by comparing the number of items processed during the
' last interval to the number of operations completed during the last interval.
' Generic type - Average
' Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number
' of items processed during the last sample interval and the denominator (D)
' represents the number of operations completed during the last two sample
' intervals.
' Average (Nx - N0) / (Dx - D0)
' Example PhysicalDisk\ Avg. Disk Bytes/Transfer
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
Dim numerator As [Single] = CType(s1.RawValue, [Single]) - CType(s0.RawValue, [Single])
Dim denomenator As [Single] = CType(s1.BaseValue, [Single]) - CType(s0.BaseValue, [Single])
Dim counterValue As [Single] = numerator / denomenator
Return counterValue
End Function 'MyComputeCounterValue
' Output information about the counter sample.
Private Shared Sub OutputSample(ByVal s As CounterSample)
Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
Console.WriteLine((" BaseValue = " + s.BaseValue.ToString()))
Console.WriteLine((" CounterFrequency = " + s.CounterFrequency.ToString()))
Console.WriteLine((" CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
Console.WriteLine((" CounterType = " + s.CounterType.ToString()))
Console.WriteLine((" RawValue = " + s.RawValue.ToString()))
Console.WriteLine((" SystemFrequency = " + s.SystemFrequency.ToString()))
Console.WriteLine((" TimeStamp = " + s.TimeStamp.ToString()))
Console.WriteLine((" TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
Console.WriteLine("++++++++++++++++++++++")
End Sub
End Class
AverageTimer32
using System;
using System.Collections;
using System.Diagnostics;
using System.Runtime.Versioning;
[SupportedOSPlatform("Windows")]
public class App2
{
private static PerformanceCounter PC;
private static PerformanceCounter BPC;
private const String categoryName = "AverageTimer32SampleCategory";
private const String counterName = "AverageTimer32Sample";
private const String baseCounterName = "AverageTimer32SampleBase";
public static void Main()
{
ArrayList samplesList = new ArrayList();
// If the category does not exist, create the category and exit.
// Performance counters should not be created and immediately used.
// There is a latency time to enable the counters, they should be created
// prior to executing the application that uses the counters.
// Execute this sample a second time to use the category.
if (SetupCategory())
return;
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists(categoryName))
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageTimer32 = new CounterCreationData();
averageTimer32.CounterType = PerformanceCounterType.AverageTimer32;
averageTimer32.CounterName = counterName;
CCDC.Add(averageTimer32);
// Add the base counter.
CounterCreationData averageTimer32Base = new CounterCreationData();
averageTimer32Base.CounterType = PerformanceCounterType.AverageBase;
averageTimer32Base.CounterName = baseCounterName;
CCDC.Add(averageTimer32Base);
// Create the category.
PerformanceCounterCategory.Create(categoryName,
"Demonstrates usage of the AverageTimer32 performance counter type",
PerformanceCounterCategoryType.SingleInstance, CCDC);
Console.WriteLine("Category created - " + categoryName);
return (true);
}
else
{
Console.WriteLine("Category exists - " + categoryName);
return (false);
}
}
private static void CreateCounters()
{
// Create the counters.
PC = new PerformanceCounter(categoryName,
counterName,
false);
BPC = new PerformanceCounter(categoryName,
baseCounterName,
false);
PC.RawValue = 0;
BPC.RawValue = 0;
}
private static void CollectSamples(ArrayList samplesList)
{
Random r = new Random(DateTime.Now.Millisecond);
// Loop for the samples.
for (int i = 0; i < 10; i++)
{
PC.RawValue = Stopwatch.GetTimestamp();
BPC.IncrementBy(10);
System.Threading.Thread.Sleep(1000);
Console.WriteLine("Next value = " + PC.NextValue().ToString());
samplesList.Add(PC.NextSample());
}
}
private static void CalculateResults(ArrayList samplesList)
{
for (int i = 0; i < (samplesList.Count - 1); i++)
{
// Output the sample.
OutputSample((CounterSample)samplesList[i]);
OutputSample((CounterSample)samplesList[i + 1]);
// Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " +
CounterSample.Calculate((CounterSample)samplesList[i],
(CounterSample)samplesList[i + 1]));
// Calculate the counter value manually.
Console.WriteLine("My computed counter value = " +
MyComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i + 1]));
}
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
// PERF_AVERAGE_TIMER
// Description - This counter type measures the time it takes, on
// average, to complete a process or operation. Counters of this
// type display a ratio of the total elapsed time of the sample
// interval to the number of processes or operations completed
// during that time. This counter type measures time in ticks
// of the system clock. The F variable represents the number of
// ticks per second. The value of F is factored into the equation
// so that the result can be displayed in seconds.
//
// Generic type - Average
//
// Formula - ((N1 - N0) / F) / (D1 - D0), where the numerator (N)
// represents the number of ticks counted during the last
// sample interval, F represents the frequency of the ticks,
// and the denominator (D) represents the number of operations
// completed during the last sample interval.
//
// Average - ((Nx - N0) / F) / (Dx - D0)
//
// Example - PhysicalDisk\ Avg. Disk sec/Transfer
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
{
Int64 n1 = s1.RawValue;
Int64 n0 = s0.RawValue;
ulong f = (ulong)s1.SystemFrequency;
Int64 d1 = s1.BaseValue;
Int64 d0 = s0.BaseValue;
double numerator = (double)(n1 - n0);
double denominator = (double)(d1 - d0);
Single counterValue = (Single)((numerator / f) / denominator);
return (counterValue);
}
// Output information about the counter sample.
private static void OutputSample(CounterSample s)
{
Console.WriteLine("+++++++++++");
Console.WriteLine("Sample values - \r\n");
Console.WriteLine(" CounterType = " + s.CounterType);
Console.WriteLine(" RawValue = " + s.RawValue);
Console.WriteLine(" BaseValue = " + s.BaseValue);
Console.WriteLine(" CounterFrequency = " + s.CounterFrequency);
Console.WriteLine(" CounterTimeStamp = " + s.CounterTimeStamp);
Console.WriteLine(" SystemFrequency = " + s.SystemFrequency);
Console.WriteLine(" TimeStamp = " + s.TimeStamp);
Console.WriteLine(" TimeStamp100nSec = " + s.TimeStamp100nSec);
Console.WriteLine("++++++++++++++++++++++");
}
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.InteropServices
Imports System.Runtime.Versioning
<SupportedOSPlatform("Windows")>
Public Class App
Private Const categoryName As String = "AverageTimer32SampleCategory"
Private Const counterName As String = "AverageTimer32Sample"
Private Const baseCounterName As String = "AverageTimer32SampleBase"
Private Shared PC As PerformanceCounter
Private Shared BPC As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
SetupCategory()
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End Sub
Private Shared Function SetupCategory() As Boolean
If Not PerformanceCounterCategory.Exists(categoryName) Then
Dim CCDC As New CounterCreationDataCollection()
' Add the counter.
Dim averageTimer32 As New CounterCreationData()
averageTimer32.CounterType = PerformanceCounterType.AverageTimer32
averageTimer32.CounterName = counterName
CCDC.Add(averageTimer32)
' Add the base counter.
Dim averageTimer32Base As New CounterCreationData()
averageTimer32Base.CounterType = PerformanceCounterType.AverageBase
averageTimer32Base.CounterName = baseCounterName
CCDC.Add(averageTimer32Base)
' Create the category.
PerformanceCounterCategory.Create( _
categoryName, _
"Demonstrates usage of the AverageTimer32 performance counter type", _
PerformanceCounterCategoryType.SingleInstance, CCDC)
Console.WriteLine("Category created - " + categoryName)
Return True
Else
Console.WriteLine(("Category exists - " + _
categoryName))
Return False
End If
End Function
Private Shared Sub CreateCounters()
' Create the counters.
PC = New PerformanceCounter(categoryName, _
counterName, False)
BPC = New PerformanceCounter(categoryName, _
baseCounterName, False)
PC.RawValue = 0
BPC.RawValue = 0
End Sub
Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)
Dim r As New Random(DateTime.Now.Millisecond)
' Loop for the samples.
Dim i As Integer
For i = 0 To 9
PC.RawValue = Stopwatch.GetTimeStamp()
BPC.IncrementBy(10)
System.Threading.Thread.Sleep(1000)
Console.WriteLine(("Next value = " + PC.NextValue().ToString()))
samplesList.Add(PC.NextSample())
Next i
End Sub
Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
Dim i As Integer
Dim sample1 As CounterSample
Dim sample2 As CounterSample
For i = 0 To (samplesList.Count - 1) - 1
' Output the sample.
sample1 = CType(samplesList(i), CounterSample)
sample2 = CType(samplesList(i + 1), CounterSample)
OutputSample(sample1)
OutputSample(sample2)
' Use .NET to calculate the counter value.
Console.WriteLine((".NET computed counter value = " _
+ CounterSample.Calculate(sample1, sample2).ToString()))
' Calculate the counter value manually.
Console.WriteLine(("My computed counter value = " _
+ MyComputeCounterValue(sample1, sample2).ToString()))
Next i
End Sub
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
' PERF_AVERAGE_TIMER
' Description - This counter type measures the time it takes, on
' average, to complete a process or operation. Counters of this
' type display a ratio of the total elapsed time of the sample
' interval to the number of processes or operations completed
' during that time. This counter type measures time in ticks
' of the system clock. The F variable represents the number of
' ticks per second. The value of F is factored into the equation
' so that the result can be displayed in seconds.
'
' Generic type - Average
'
' Formula - ((N1 - N0) / F) / (D1 - D0), where the numerator (N)
' represents the number of ticks counted during the last
' sample interval, F represents the frequency of the ticks,
' and the denominator (D) represents the number of operations
' completed during the last sample interval.
'
' Average - ((Nx - N0) / F) / (Dx - D0)
'
' Example - PhysicalDisk\ Avg. Disk sec/Transfer
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
Private Shared Function MyComputeCounterValue( _
ByVal s0 As CounterSample, _
ByVal s1 As CounterSample) As Single
Dim n1 As Int64 = s1.RawValue
Dim n0 As Int64 = s0.RawValue
Dim f As Decimal = CType(s1.SystemFrequency, Decimal)
Dim d1 As Int64 = s1.BaseValue
Dim d0 As Int64 = s0.BaseValue
Dim numerator As Double = System.Convert.ToDouble(n1 - n0)
Dim denominator As Double = System.Convert.ToDouble(d1 - d0)
Dim counterValue As Single = CType(numerator, Single)
counterValue = counterValue / CType(f, Single)
counterValue = counterValue / CType(denominator, Single)
Return counterValue
End Function
' Output information about the counter sample.
Private Shared Sub OutputSample(ByVal s As CounterSample)
Console.WriteLine("+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Cr _
+ ControlChars.Lf)
Console.WriteLine((" CounterType = " + _
s.CounterType.ToString()))
Console.WriteLine((" RawValue = " + _
s.RawValue.ToString()))
Console.WriteLine((" BaseValue = " _
+ s.BaseValue.ToString()))
Console.WriteLine((" CounterFrequency = " + _
s.CounterFrequency.ToString()))
Console.WriteLine((" CounterTimeStamp = " + _
s.CounterTimeStamp.ToString()))
Console.WriteLine((" SystemFrequency = " + _
s.SystemFrequency.ToString()))
Console.WriteLine((" TimeStamp = " + _
s.TimeStamp.ToString()))
Console.WriteLine((" TimeStamp100nSec = " + _
s.TimeStamp100nSec.ToString()))
Console.WriteLine("++++++++++++++++++++++")
End Sub
End Class
Eltelt idő
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Runtime.InteropServices;
public class App
{
public static void Main()
{
CollectSamples();
}
public static void CollectSamples()
{
const String categoryName = "ElapsedTimeSampleCategory";
const String counterName = "ElapsedTimeSample";
// If the category does not exist, create the category and exit.
// Performance counters should not be created and immediately used.
// There is a latency time to enable the counters, they should be created
// prior to executing the application that uses the counters.
// Execute this sample a second time to use the category.
if ( !PerformanceCounterCategory.Exists(categoryName) )
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData ETimeData = new CounterCreationData();
ETimeData.CounterType = PerformanceCounterType.ElapsedTime;
ETimeData.CounterName = counterName;
CCDC.Add(ETimeData);
// Create the category.
PerformanceCounterCategory.Create(categoryName,
"Demonstrates ElapsedTime performance counter usage.",
PerformanceCounterCategoryType.SingleInstance, CCDC);
// Return, rerun the application to make use of the new counters.
return;
}
else
{
Console.WriteLine("Category exists - {0}", categoryName);
}
// Create the performance counter.
PerformanceCounter PC = new PerformanceCounter(categoryName,
counterName,
false);
// Initialize the counter.
PC.RawValue = Stopwatch.GetTimestamp();
DateTime Start = DateTime.Now;
// Loop for the samples.
for (int j = 0; j < 100; j++)
{
// Output the values.
if ((j % 10) == 9)
{
Console.WriteLine("NextValue() = " + PC.NextValue().ToString());
Console.WriteLine("Actual elapsed time = " + DateTime.Now.Subtract(Start).ToString());
OutputSample(PC.NextSample());
}
// Reset the counter on every 20th iteration.
if (j % 20 == 0)
{
PC.RawValue = Stopwatch.GetTimestamp();
Start = DateTime.Now;
}
System.Threading.Thread.Sleep(50);
}
Console.WriteLine("Elapsed time = " + DateTime.Now.Subtract(Start).ToString());
}
private static void OutputSample(CounterSample s)
{
Console.WriteLine("\r\n+++++++++++");
Console.WriteLine("Sample values - \r\n");
Console.WriteLine(" BaseValue = " + s.BaseValue);
Console.WriteLine(" CounterFrequency = " + s.CounterFrequency);
Console.WriteLine(" CounterTimeStamp = " + s.CounterTimeStamp);
Console.WriteLine(" CounterType = " + s.CounterType);
Console.WriteLine(" RawValue = " + s.RawValue);
Console.WriteLine(" SystemFrequency = " + s.SystemFrequency);
Console.WriteLine(" TimeStamp = " + s.TimeStamp);
Console.WriteLine(" TimeStamp100nSec = " + s.TimeStamp100nSec);
Console.WriteLine("++++++++++++++++++++++");
}
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.InteropServices
Imports System.Runtime.Versioning
<SupportedOSPlatform("Windows")>
Public Class App2
Public Shared Sub Main()
CollectSamples()
End Sub
Private Shared Sub CollectSamples()
Dim categoryName As String = "ElapsedTimeSampleCategory"
Dim counterName As String = "ElapsedTimeSample"
If Not PerformanceCounterCategory.Exists(categoryName) Then
Dim CCDC As New CounterCreationDataCollection()
' Add the counter.
Dim ETimeData As New CounterCreationData()
ETimeData.CounterType = PerformanceCounterType.ElapsedTime
ETimeData.CounterName = counterName
CCDC.Add(ETimeData)
' Create the category.
PerformanceCounterCategory.Create(categoryName,
"Demonstrates ElapsedTime performance counter usage.",
PerformanceCounterCategoryType.SingleInstance, CCDC)
Else
Console.WriteLine("Category exists - {0}", categoryName)
End If
' Create the counter.
Dim PC As PerformanceCounter
PC = New PerformanceCounter(categoryName, counterName, False)
' Initialize the counter.
PC.RawValue = Stopwatch.GetTimestamp()
Dim Start As DateTime = DateTime.Now
' Loop for the samples.
Dim j As Integer
For j = 0 To 99
' Output the values.
If j Mod 10 = 9 Then
Console.WriteLine(("NextValue() = " _
+ PC.NextValue().ToString()))
Console.WriteLine(("Actual elapsed time = " _
+ DateTime.Now.Subtract(Start).ToString()))
OutputSample(PC.NextSample())
End If
' Reset the counter every 20th iteration.
If j Mod 20 = 0 Then
PC.RawValue = Stopwatch.GetTimestamp()
Start = DateTime.Now
End If
System.Threading.Thread.Sleep(50)
Next j
Console.WriteLine(("Elapsed time = " +
DateTime.Now.Subtract(Start).ToString()))
End Sub
Private Shared Sub OutputSample(ByVal s As CounterSample)
Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++")
Console.WriteLine("Sample values - " + ControlChars.Cr _
+ ControlChars.Lf)
Console.WriteLine((" BaseValue = " _
+ s.BaseValue.ToString()))
Console.WriteLine((" CounterFrequency = " +
s.CounterFrequency.ToString()))
Console.WriteLine((" CounterTimeStamp = " +
s.CounterTimeStamp.ToString()))
Console.WriteLine((" CounterType = " +
s.CounterType.ToString()))
Console.WriteLine((" RawValue = " +
s.RawValue.ToString()))
Console.WriteLine((" SystemFrequency = " +
s.SystemFrequency.ToString()))
Console.WriteLine((" TimeStamp = " +
s.TimeStamp.ToString()))
Console.WriteLine((" TimeStamp100nSec = " +
s.TimeStamp100nSec.ToString()))
Console.WriteLine("+++++++")
End Sub
End Class
NumberOfItems32
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
public class NumberOfItems32
{
private static PerformanceCounter PC;
public static void Main()
{
ArrayList samplesList = [];
// If the category does not exist, create the category and exit.
// Performance counters should not be created and immediately used.
// There is a latency time to enable the counters, they should be created
// prior to executing the application that uses the counters.
// Execute this sample a second time to use the category.
if (SetupCategory())
return;
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
}
private static bool SetupCategory()
{
if ( !PerformanceCounterCategory.Exists("NumberOfItems32SampleCategory") )
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData NOI32 = new CounterCreationData
{
CounterType = PerformanceCounterType.NumberOfItems32,
CounterName = "NumberOfItems32Sample"
};
CCDC.Add(NOI32);
// Create the category.
PerformanceCounterCategory.Create("NumberOfItems32SampleCategory",
"Demonstrates usage of the NumberOfItems32 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, CCDC);
return(true);
}
else
{
Console.WriteLine("Category exists - NumberOfItems32SampleCategory");
return(false);
}
}
private static void CreateCounters()
{
// Create the counter.
PC = new PerformanceCounter(
"NumberOfItems32SampleCategory",
"NumberOfItems32Sample",
false)
{
RawValue = 0
};
}
private static void CollectSamples(ArrayList samplesList)
{
Random r = new( DateTime.Now.Millisecond );
// Loop for the samples.
for (int j = 0; j < 100; j++)
{
int value = r.Next(1, 10);
Console.Write(j + " = " + value);
PC.IncrementBy(value);
if ((j % 10) == 9)
{
OutputSample(PC.NextSample());
samplesList.Add( PC.NextSample() );
}
else
{
Console.WriteLine();
}
System.Threading.Thread.Sleep(50);
}
}
private static void CalculateResults(ArrayList samplesList)
{
for(int i = 0; i < (samplesList.Count - 1); i++)
{
// Output the sample.
OutputSample( (CounterSample)samplesList[i] );
OutputSample( (CounterSample)samplesList[i+1] );
// Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " +
CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i+1]) );
// Calculate the counter value manually.
Console.WriteLine("My computed counter value = " +
MyComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i+1]) );
}
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
{
Single counterValue = s1.RawValue;
return(counterValue);
}
// Output information about the counter sample.
private static void OutputSample(CounterSample s)
{
Console.WriteLine("\r\n+++++++++++");
Console.WriteLine("Sample values - \r\n");
Console.WriteLine(" BaseValue = " + s.BaseValue);
Console.WriteLine(" CounterFrequency = " + s.CounterFrequency);
Console.WriteLine(" CounterTimeStamp = " + s.CounterTimeStamp);
Console.WriteLine(" CounterType = " + s.CounterType);
Console.WriteLine(" RawValue = " + s.RawValue);
Console.WriteLine(" SystemFrequency = " + s.SystemFrequency);
Console.WriteLine(" TimeStamp = " + s.TimeStamp);
Console.WriteLine(" TimeStamp100nSec = " + s.TimeStamp100nSec);
Console.WriteLine("++++++++++++++++++++++");
}
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.Versioning
<SupportedOSPlatform("Windows")>
Public Class NumberOfItems32
Private Shared PC As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
'If the category does not exist, create the category and exit.
'Performance counters should not be created and immediately used.
'There is a latency time to enable the counters, they should be created
'prior to executing the application that uses the counters.
'Execute this sample a second time to use the counters.
If Not (SetupCategory()) Then
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End If
End Sub
Private Shared Function SetupCategory() As Boolean
If Not PerformanceCounterCategory.Exists("NumberOfItems32SampleCategory") Then
Dim CCDC As New CounterCreationDataCollection()
' Add the counter.
Dim NOI32 As New CounterCreationData()
NOI32.CounterType = PerformanceCounterType.NumberOfItems32
NOI32.CounterName = "NumberOfItems32Sample"
CCDC.Add(NOI32)
' Create the category.
PerformanceCounterCategory.Create("NumberOfItems32SampleCategory", _
"Demonstrates usage of the NumberOfItems32 performance counter type.", _
PerformanceCounterCategoryType.SingleInstance, CCDC)
Return True
Else
Console.WriteLine("Category exists - NumberOfItems32SampleCategory")
Return False
End If
End Function 'SetupCategory
Private Shared Sub CreateCounters()
' Create the counter.
PC = New PerformanceCounter("NumberOfItems32SampleCategory", "NumberOfItems32Sample", False)
PC.RawValue = 0
End Sub
Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)
Dim r As New Random(DateTime.Now.Millisecond)
' Loop for the samples.
Dim j As Integer
For j = 0 To 99
Dim value As Integer = r.Next(1, 10)
Console.Write(j.ToString() + " = " + value.ToString())
PC.IncrementBy(value)
If j Mod 10 = 9 Then
OutputSample(PC.NextSample())
samplesList.Add(PC.NextSample())
Else
Console.WriteLine()
End If
System.Threading.Thread.Sleep(50)
Next j
End Sub
Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
Dim i As Integer
For i = 0 To (samplesList.Count - 1) - 1
' Output the sample.
OutputSample(CType(samplesList(i), CounterSample))
OutputSample(CType(samplesList((i + 1)), CounterSample))
' Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
' Calculate the counter value manually.
Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
Next i
End Sub
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
Dim counterValue As [Single] = s1.RawValue
Return counterValue
End Function 'MyComputeCounterValue
' Output information about the counter sample.
Private Shared Sub OutputSample(ByVal s As CounterSample)
Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
Console.WriteLine(" BaseValue = " + s.BaseValue.ToString())
Console.WriteLine(" CounterFrequency = " + s.CounterFrequency.ToString())
Console.WriteLine(" CounterTimeStamp = " + s.CounterTimeStamp.ToString())
Console.WriteLine(" CounterType = " + s.CounterType.ToString())
Console.WriteLine(" RawValue = " + s.RawValue.ToString())
Console.WriteLine(" SystemFrequency = " + s.SystemFrequency.ToString())
Console.WriteLine(" TimeStamp = " + s.TimeStamp.ToString())
Console.WriteLine(" TimeStamp100nSec = " + s.TimeStamp100nSec.ToString())
Console.WriteLine("++++++++++++++++++++++")
End Sub
End Class
NumberOfItems64
using System;
using System.Collections;
using System.Diagnostics;
using System.Runtime.Versioning;
[SupportedOSPlatform("Windows")]
public class NumberOfItems64_1
{
private static PerformanceCounter PC;
public static void Main()
{
ArrayList samplesList = new ArrayList();
// If the category does not exist, create the category and exit.
// Perfomance counters should not be created and immediately used.
// There is a latency time to enable the counters, they should be created
// prior to executing the application that uses the counters.
// Execute this sample a second time to use the category.
if (SetupCategory())
return;
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists("NumberOfItems64SampleCategory"))
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData NOI64 = new CounterCreationData();
NOI64.CounterType = PerformanceCounterType.NumberOfItems64;
NOI64.CounterName = "NumberOfItems64Sample";
CCDC.Add(NOI64);
// Create the category.
PerformanceCounterCategory.Create("NumberOfItems64SampleCategory",
"Demonstrates usage of the NumberOfItems64 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, CCDC);
return (true);
}
else
{
Console.WriteLine("Category exists - NumberOfItems64SampleCategory");
return (false);
}
}
private static void CreateCounters()
{
// Create the counters.
PC = new PerformanceCounter("NumberOfItems64SampleCategory",
"NumberOfItems64Sample",
false);
PC.RawValue = 0;
}
private static void CollectSamples(ArrayList samplesList)
{
Random r = new Random(DateTime.Now.Millisecond);
// Loop for the samples.
for (int j = 0; j < 100; j++)
{
int value = r.Next(1, 10);
Console.Write(j + " = " + value);
PC.IncrementBy(value);
if ((j % 10) == 9)
{
OutputSample(PC.NextSample());
samplesList.Add(PC.NextSample());
}
else
{
Console.WriteLine();
}
System.Threading.Thread.Sleep(50);
}
}
private static void CalculateResults(ArrayList samplesList)
{
for (int i = 0; i < (samplesList.Count - 1); i++)
{
// Output the sample.
OutputSample((CounterSample)samplesList[i]);
OutputSample((CounterSample)samplesList[i + 1]);
// Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " +
CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i + 1]));
// Calculate the counter value manually.
Console.WriteLine("My computed counter value = " +
MyComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i + 1]));
}
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
{
Single counterValue = s1.RawValue;
return (counterValue);
}
// Output information about the counter sample.
private static void OutputSample(CounterSample s)
{
Console.WriteLine("\r\n+++++++++++");
Console.WriteLine("Sample values - \r\n");
Console.WriteLine(" BaseValue = " + s.BaseValue);
Console.WriteLine(" CounterFrequency = " + s.CounterFrequency);
Console.WriteLine(" CounterTimeStamp = " + s.CounterTimeStamp);
Console.WriteLine(" CounterType = " + s.CounterType);
Console.WriteLine(" RawValue = " + s.RawValue);
Console.WriteLine(" SystemFrequency = " + s.SystemFrequency);
Console.WriteLine(" TimeStamp = " + s.TimeStamp);
Console.WriteLine(" TimeStamp100nSec = " + s.TimeStamp100nSec);
Console.WriteLine("++++++++++++++++++++++");
}
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.Versioning
<SupportedOSPlatform("Windows")>
Public Class NumberOfItems64_1
Private Shared PC As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
'If the category does not exist, create the category and exit.
'Performance counters should not be created and immediately used.
'There is a latency time to enable the counters, they should be created
'prior to executing the application that uses the counters.
'Execute this sample a second time to use the counters.
If Not (SetupCategory()) Then
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End If
End Sub
Private Shared Function SetupCategory() As Boolean
If Not PerformanceCounterCategory.Exists("NumberOfItems64SampleCategory") Then
Dim CCDC As New CounterCreationDataCollection()
' Add the counter.
Dim NOI64 As New CounterCreationData()
NOI64.CounterType = PerformanceCounterType.NumberOfItems64
NOI64.CounterName = "NumberOfItems64Sample"
CCDC.Add(NOI64)
' Create the category.
PerformanceCounterCategory.Create("NumberOfItems64SampleCategory",
"Demonstrates usage of the NumberOfItems64_1 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, CCDC)
Return True
Else
Console.WriteLine("Category exists - NumberOfItems64SampleCategory")
Return False
End If
End Function 'SetupCategory
Private Shared Sub CreateCounters()
' Create the counters.
PC = New PerformanceCounter("NumberOfItems64SampleCategory", "NumberOfItems64Sample", False)
PC.RawValue = 0
End Sub
Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)
Dim r As New Random(DateTime.Now.Millisecond)
' Loop for the samples.
Dim j As Integer
For j = 0 To 99
Dim value As Integer = r.Next(1, 10)
Console.Write((j.ToString() + " = " + value.ToString()))
PC.IncrementBy(value)
If j Mod 10 = 9 Then
OutputSample(PC.NextSample())
samplesList.Add(PC.NextSample())
Else
Console.WriteLine()
End If
System.Threading.Thread.Sleep(50)
Next j
End Sub
Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
Dim i As Integer
For i = 0 To (samplesList.Count - 1) - 1
' Output the sample.
OutputSample(CType(samplesList(i), CounterSample))
OutputSample(CType(samplesList((i + 1)), CounterSample))
' Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
' Calculate the counter value manually.
Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
Next i
End Sub
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
Dim counterValue As [Single] = s1.RawValue
Return counterValue
End Function 'MyComputeCounterValue
' Output information about the counter sample.
Private Shared Sub OutputSample(ByVal s As CounterSample)
Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
Console.WriteLine((" BaseValue = " + s.BaseValue.ToString()))
Console.WriteLine((" CounterFrequency = " + s.CounterFrequency.ToString()))
Console.WriteLine((" CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
Console.WriteLine((" CounterType = " + s.CounterType.ToString()))
Console.WriteLine((" RawValue = " + s.RawValue.ToString()))
Console.WriteLine((" SystemFrequency = " + s.SystemFrequency.ToString()))
Console.WriteLine((" TimeStamp = " + s.TimeStamp.ToString()))
Console.WriteLine((" TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
Console.WriteLine("++++++++++++++++++++++")
End Sub
End Class
Mintafráció
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
// Provides a SampleFraction counter to measure the percentage of the user processor
// time for this process to total processor time for the process.
public class App
{
private static PerformanceCounter perfCounter;
private static PerformanceCounter basePerfCounter;
private static Process thisProcess = Process.GetCurrentProcess();
public static void Main()
{
ArrayList samplesList = new ArrayList();
// If the category does not exist, create the category and exit.
// Performance counters should not be created and immediately used.
// There is a latency time to enable the counters, they should be created
// prior to executing the application that uses the counters.
// Execute this sample a second time to use the category.
if (SetupCategory())
return;
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists("SampleFractionCategory"))
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData sampleFraction = new CounterCreationData();
sampleFraction.CounterType = PerformanceCounterType.SampleFraction;
sampleFraction.CounterName = "SampleFractionSample";
CCDC.Add(sampleFraction);
// Add the base counter.
CounterCreationData sampleFractionBase = new CounterCreationData();
sampleFractionBase.CounterType = PerformanceCounterType.SampleBase;
sampleFractionBase.CounterName = "SampleFractionSampleBase";
CCDC.Add(sampleFractionBase);
// Create the category.
PerformanceCounterCategory.Create("SampleFractionCategory",
"Demonstrates usage of the SampleFraction performance counter type.",
PerformanceCounterCategoryType.SingleInstance, CCDC);
return (true);
}
else
{
Console.WriteLine("Category exists - SampleFractionCategory");
return (false);
}
}
private static void CreateCounters()
{
// Create the counters.
perfCounter = new PerformanceCounter("SampleFractionCategory",
"SampleFractionSample",
false);
basePerfCounter = new PerformanceCounter("SampleFractionCategory",
"SampleFractionSampleBase",
false);
perfCounter.RawValue = thisProcess.UserProcessorTime.Ticks;
basePerfCounter.RawValue = thisProcess.TotalProcessorTime.Ticks;
}
private static void CollectSamples(ArrayList samplesList)
{
// Loop for the samples.
for (int j = 0; j < 100; j++)
{
perfCounter.IncrementBy(thisProcess.UserProcessorTime.Ticks);
basePerfCounter.IncrementBy(thisProcess.TotalProcessorTime.Ticks);
if ((j % 10) == 9)
{
OutputSample(perfCounter.NextSample());
samplesList.Add(perfCounter.NextSample());
}
else
{
Console.WriteLine();
}
System.Threading.Thread.Sleep(50);
}
}
private static void CalculateResults(ArrayList samplesList)
{
for (int i = 0; i < (samplesList.Count - 1); i++)
{
// Output the sample.
OutputSample((CounterSample)samplesList[i]);
OutputSample((CounterSample)samplesList[i + 1]);
// Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " +
CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i + 1]));
// Calculate the counter value manually.
Console.WriteLine("My computed counter value = " +
MyComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i + 1]));
}
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// Description - This counter type provides A percentage counter that shows the
// average ratio of user proccessor time to total processor time during the last
// two sample intervals.
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
{
Single numerator = (Single)s1.RawValue - (Single)s0.RawValue;
Single denomenator = (Single)s1.BaseValue - (Single)s0.BaseValue;
Single counterValue = 100 * (numerator / denomenator);
return (counterValue);
}
// Output information about the counter sample.
private static void OutputSample(CounterSample s)
{
Console.WriteLine("\r\n+++++++++++");
Console.WriteLine("Sample values - \r\n");
Console.WriteLine(" BaseValue = " + s.BaseValue);
Console.WriteLine(" CounterFrequency = " + s.CounterFrequency);
Console.WriteLine(" CounterTimeStamp = " + s.CounterTimeStamp);
Console.WriteLine(" CounterType = " + s.CounterType);
Console.WriteLine(" RawValue = " + s.RawValue);
Console.WriteLine(" SystemFrequency = " + s.SystemFrequency);
Console.WriteLine(" TimeStamp = " + s.TimeStamp);
Console.WriteLine(" TimeStamp100nSec = " + s.TimeStamp100nSec);
Console.WriteLine("++++++++++++++++++++++");
}
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.Versioning
' Provides a SampleFraction counter to measure the percentage of the user processor
' time for this process to total processor time for the process.
<SupportedOSPlatform("Windows")>
Public Class App3
Private Shared perfCounter As PerformanceCounter
Private Shared basePerfCounter As PerformanceCounter
Private Shared thisProcess As Process = Process.GetCurrentProcess()
Public Shared Sub Main()
Dim samplesList As New ArrayList()
' If the category does not exist, create the category and exit.
' Performance counters should not be created and immediately used.
' There is a latency time to enable the counters, they should be created
' prior to executing the application that uses the counters.
' Execute this sample a second time to use the category.
If SetupCategory() Then
Return
End If
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End Sub
Private Shared Function SetupCategory() As Boolean
If Not PerformanceCounterCategory.Exists("SampleFractionCategory") Then
Dim CCDC As New CounterCreationDataCollection()
' Add the counter.
Dim sampleFraction As New CounterCreationData()
sampleFraction.CounterType = PerformanceCounterType.SampleFraction
sampleFraction.CounterName = "SampleFractionSample"
CCDC.Add(sampleFraction)
' Add the base counter.
Dim sampleFractionBase As New CounterCreationData()
sampleFractionBase.CounterType = PerformanceCounterType.SampleBase
sampleFractionBase.CounterName = "SampleFractionSampleBase"
CCDC.Add(sampleFractionBase)
' Create the category.
PerformanceCounterCategory.Create("SampleFractionCategory", "Demonstrates usage of the SampleFraction performance counter type.", PerformanceCounterCategoryType.SingleInstance, CCDC)
Return True
Else
Console.WriteLine("Category exists - SampleFractionCategory")
Return False
End If
End Function 'SetupCategory
Private Shared Sub CreateCounters()
' Create the counters.
perfCounter = New PerformanceCounter("SampleFractionCategory", "SampleFractionSample", False)
basePerfCounter = New PerformanceCounter("SampleFractionCategory", "SampleFractionSampleBase", False)
perfCounter.RawValue = thisProcess.UserProcessorTime.Ticks
basePerfCounter.RawValue = thisProcess.TotalProcessorTime.Ticks
End Sub
Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)
' Loop for the samples.
Dim j As Integer
For j = 0 To 99
perfCounter.IncrementBy(thisProcess.UserProcessorTime.Ticks)
basePerfCounter.IncrementBy(thisProcess.TotalProcessorTime.Ticks)
If j Mod 10 = 9 Then
OutputSample(perfCounter.NextSample())
samplesList.Add(perfCounter.NextSample())
Else
Console.WriteLine()
End If
System.Threading.Thread.Sleep(50)
Next j
End Sub
Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
Dim i As Integer
For i = 0 To (samplesList.Count - 1)
' Output the sample.
OutputSample(CType(samplesList(i), CounterSample))
OutputSample(CType(samplesList((i + 1)), CounterSample))
' Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)))
' Calculate the counter value manually.
Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)))
Next i
End Sub
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
' Description - This counter type provides A percentage counter that shows the
' average ratio of user proccessor time to total processor time during the last
' two sample intervals.
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
Dim numerator As [Single] = CType(s1.RawValue, [Single]) - CType(s0.RawValue, [Single])
Dim denomenator As [Single] = CType(s1.BaseValue, [Single]) - CType(s0.BaseValue, [Single])
Dim counterValue As [Single] = 100 * (numerator / denomenator)
Return counterValue
End Function 'MyComputeCounterValue
' Output information about the counter sample.
Private Shared Sub OutputSample(ByVal s As CounterSample)
Console.WriteLine(vbCr + vbLf + "+++++++++++")
Console.WriteLine("Sample values - " + vbCr + vbLf)
Console.WriteLine(" BaseValue = " + s.BaseValue)
Console.WriteLine(" CounterFrequency = " + s.CounterFrequency)
Console.WriteLine(" CounterTimeStamp = " + s.CounterTimeStamp)
Console.WriteLine(" CounterType = " + s.CounterType)
Console.WriteLine(" RawValue = " + s.RawValue)
Console.WriteLine(" SystemFrequency = " + s.SystemFrequency)
Console.WriteLine(" TimeStamp = " + s.TimeStamp)
Console.WriteLine(" TimeStamp100nSec = " + s.TimeStamp100nSec)
Console.WriteLine("++++++++++++++++++++++")
End Sub
End Class
RateOfCountsPerSecond32
using System;
using System.Collections;
using System.Diagnostics;
using System.Runtime.Versioning;
[SupportedOSPlatform("Windows")]
public class App3
{
private static PerformanceCounter PC;
public static void Main()
{
ArrayList samplesList = new ArrayList();
// If the category does not exist, create the category and exit.
// Perfomance counters should not be created and immediately used.
// There is a latency time to enable the counters, they should be created
// prior to executing the application that uses the counters.
// Execute this sample a second time to use the category.
if (SetupCategory())
return;
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists("RateOfCountsPerSecond32SampleCategory"))
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData rateOfCounts32 = new CounterCreationData();
rateOfCounts32.CounterType = PerformanceCounterType.RateOfCountsPerSecond32;
rateOfCounts32.CounterName = "RateOfCountsPerSecond32Sample";
CCDC.Add(rateOfCounts32);
// Create the category.
PerformanceCounterCategory.Create("RateOfCountsPerSecond32SampleCategory",
"Demonstrates usage of the RateOfCountsPerSecond32 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, CCDC);
return (true);
}
else
{
Console.WriteLine("Category exists - RateOfCountsPerSecond32SampleCategory");
return (false);
}
}
private static void CreateCounters()
{
// Create the counter.
PC = new PerformanceCounter("RateOfCountsPerSecond32SampleCategory",
"RateOfCountsPerSecond32Sample",
false);
PC.RawValue = 0;
}
private static void CollectSamples(ArrayList samplesList)
{
Random r = new Random(DateTime.Now.Millisecond);
// Initialize the performance counter.
PC.NextSample();
// Loop for the samples.
for (int j = 0; j < 100; j++)
{
int value = r.Next(1, 10);
PC.IncrementBy(value);
Console.Write(j + " = " + value);
if ((j % 10) == 9)
{
Console.WriteLine("; NextValue() = " + PC.NextValue().ToString());
OutputSample(PC.NextSample());
samplesList.Add(PC.NextSample());
}
else
{
Console.WriteLine();
}
System.Threading.Thread.Sleep(50);
}
}
private static void CalculateResults(ArrayList samplesList)
{
for (int i = 0; i < (samplesList.Count - 1); i++)
{
// Output the sample.
OutputSample((CounterSample)samplesList[i]);
OutputSample((CounterSample)samplesList[i + 1]);
// Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " +
CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i + 1]));
// Calculate the counter value manually.
Console.WriteLine("My computed counter value = " +
MyComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i + 1]));
}
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// PERF_COUNTER_COUNTER
// Description - This counter type shows the average number of operations completed
// during each second of the sample interval. Counters of this type
// measure time in ticks of the system clock. The F variable represents
// the number of ticks per second. The value of F is factored into the
// equation so that the result can be displayed in seconds.
//
// Generic type - Difference
//
// Formula - (N1 - N0) / ( (D1 - D0) / F), where the numerator (N) represents the number
// of operations performed during the last sample interval, the denominator
// (D) represents the number of ticks elapsed during the last sample
// interval, and F is the frequency of the ticks.
//
// Average - (Nx - N0) / ((Dx - D0) / F)
//
// Example - System\ File Read Operations/sec
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
{
Single numerator = (Single)(s1.RawValue - s0.RawValue);
Single denomenator = (Single)(s1.TimeStamp - s0.TimeStamp) / (Single)s1.SystemFrequency;
Single counterValue = numerator / denomenator;
return (counterValue);
}
// Output information about the counter sample.
private static void OutputSample(CounterSample s)
{
Console.WriteLine("\r\n+++++++++++");
Console.WriteLine("Sample values - \r\n");
Console.WriteLine(" BaseValue = " + s.BaseValue);
Console.WriteLine(" CounterFrequency = " + s.CounterFrequency);
Console.WriteLine(" CounterTimeStamp = " + s.CounterTimeStamp);
Console.WriteLine(" CounterType = " + s.CounterType);
Console.WriteLine(" RawValue = " + s.RawValue);
Console.WriteLine(" SystemFrequency = " + s.SystemFrequency);
Console.WriteLine(" TimeStamp = " + s.TimeStamp);
Console.WriteLine(" TimeStamp100nSec = " + s.TimeStamp100nSec);
Console.WriteLine("++++++++++++++++++++++");
}
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.Versioning
<SupportedOSPlatform("Windows")>
Public Class App4
Private Shared PC As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
'If the category does not exist, create the category and exit.
'Performance counters should not be created and immediately used.
'There is a latency time to enable the counters, they should be created
'prior to executing the App4lication that uses the counters.
'Execute this sample a second time to use the counters.
If Not (SetupCategory()) Then
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End If
End Sub
Private Shared Function SetupCategory() As Boolean
If Not PerformanceCounterCategory.Exists("RateOfCountsPerSecond32SampleCategory") Then
Dim CCDC As New CounterCreationDataCollection()
' Add the counter.
Dim rateOfCounts32 As New CounterCreationData()
rateOfCounts32.CounterType = PerformanceCounterType.RateOfCountsPerSecond32
rateOfCounts32.CounterName = "RateOfCountsPerSecond32Sample"
CCDC.Add(rateOfCounts32)
' Create the category.
PerformanceCounterCategory.Create("RateOfCountsPerSecond32SampleCategory", _
"Demonstrates usage of the RateOfCountsPerSecond32 performance counter type.", _
PerformanceCounterCategoryType.SingleInstance, CCDC)
Return True
Else
Console.WriteLine("Category exists - RateOfCountsPerSecond32SampleCategory")
Return False
End If
End Function 'SetupCategory
Private Shared Sub CreateCounters()
' Create the counter.
PC = New PerformanceCounter("RateOfCountsPerSecond32SampleCategory", "RateOfCountsPerSecond32Sample", False)
PC.RawValue = 0
End Sub
Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)
Dim r As New Random(DateTime.Now.Millisecond)
' Initialize the performance counter.
PC.NextSample()
' Loop for the samples.
Dim j As Integer
For j = 0 To 99
Dim value As Integer = r.Next(1, 10)
PC.IncrementBy(value)
Console.Write((j.ToString() + " = " + value.ToString()))
If j Mod 10 = 9 Then
Console.WriteLine(("; NextValue() = " + PC.NextValue().ToString()))
OutputSample(PC.NextSample())
samplesList.Add(PC.NextSample())
Else
Console.WriteLine()
End If
System.Threading.Thread.Sleep(50)
Next j
End Sub
Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
Dim i As Integer
For i = 0 To (samplesList.Count - 1) - 1
' Output the sample.
OutputSample(CType(samplesList(i), CounterSample))
OutputSample(CType(samplesList((i + 1)), CounterSample))
' Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
' Calculate the counter value manually.
Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
Next i
End Sub
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
' PERF_COUNTER_COUNTER
' Description - This counter type shows the average number of operations completed
' during each second of the sample interval. Counters of this type
' measure time in ticks of the system clock. The F variable represents
' the number of ticks per second. The value of F is factored into the
' equation so that the result can be displayed in seconds.
'
' Generic type - Difference
'
' Formula - (N1 - N0) / ( (D1 - D0) / F), where the numerator (N) represents the number
' of operations performed during the last sample interval, the denominator
' (D) represents the number of ticks elapsed during the last sample
' interval, and F is the frequency of the ticks.
'
' Average - (Nx - N0) / ((Dx - D0) / F)
'
' Example - System\ File Read Operations/sec
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
Dim numerator As [Single] = CType(s1.RawValue - s0.RawValue, [Single])
Dim denomenator As [Single] = CType(s1.TimeStamp - s0.TimeStamp, [Single]) / CType(s1.SystemFrequency, [Single])
Dim counterValue As [Single] = numerator / denomenator
Return counterValue
End Function 'MyComputeCounterValue
' Output information about the counter sample.
Private Shared Sub OutputSample(ByVal s As CounterSample)
Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
Console.WriteLine((" BaseValue = " + s.BaseValue.ToString()))
Console.WriteLine((" CounterFrequency = " + s.CounterFrequency.ToString()))
Console.WriteLine((" CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
Console.WriteLine((" CounterType = " + s.CounterType.ToString()))
Console.WriteLine((" RawValue = " + s.RawValue.ToString()))
Console.WriteLine((" SystemFrequency = " + s.SystemFrequency.ToString()))
Console.WriteLine((" TimeStamp = " + s.TimeStamp.ToString()))
Console.WriteLine((" TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
Console.WriteLine("++++++++++++++++++++++")
End Sub
End Class
Másodpercenkénti számlálási arány64
using System;
using System.Collections;
using System.Diagnostics;
using System.Runtime.Versioning;
[SupportedOSPlatform("Windows")]
public class App4
{
private static PerformanceCounter PC;
public static void Main()
{
ArrayList samplesList = new ArrayList();
// If the category does not exist, create the category and exit.
// Perfomance counters should not be created and immediately used.
// There is a latency time to enable the counters, they should be created
// prior to executing the application that uses the counters.
// Execute this sample a second time to use the category.
if (SetupCategory())
return;
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists("RateOfCountsPerSecond64SampleCategory"))
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData rateOfCounts64 = new CounterCreationData();
rateOfCounts64.CounterType = PerformanceCounterType.RateOfCountsPerSecond64;
rateOfCounts64.CounterName = "RateOfCountsPerSecond64Sample";
CCDC.Add(rateOfCounts64);
// Create the category.
PerformanceCounterCategory.Create("RateOfCountsPerSecond64SampleCategory",
"Demonstrates usage of the RateOfCountsPerSecond64 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, CCDC);
return (true);
}
else
{
Console.WriteLine("Category exists - RateOfCountsPerSecond64SampleCategory");
return (false);
}
}
private static void CreateCounters()
{
// Create the counter.
PC = new PerformanceCounter("RateOfCountsPerSecond64SampleCategory",
"RateOfCountsPerSecond64Sample",
false);
PC.RawValue = 0;
}
private static void CollectSamples(ArrayList samplesList)
{
Random r = new Random(DateTime.Now.Millisecond);
// Initialize the performance counter.
PC.NextSample();
// Loop for the samples.
for (int j = 0; j < 100; j++)
{
int value = r.Next(1, 10);
PC.IncrementBy(value);
Console.Write(j + " = " + value);
if ((j % 10) == 9)
{
Console.WriteLine("; NextValue() = " + PC.NextValue().ToString());
OutputSample(PC.NextSample());
samplesList.Add(PC.NextSample());
}
else
{
Console.WriteLine();
}
System.Threading.Thread.Sleep(50);
}
}
private static void CalculateResults(ArrayList samplesList)
{
for (int i = 0; i < (samplesList.Count - 1); i++)
{
// Output the sample.
OutputSample((CounterSample)samplesList[i]);
OutputSample((CounterSample)samplesList[i + 1]);
// Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " +
CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i + 1]));
// Calculate the counter value manually.
Console.WriteLine("My computed counter value = " +
MyComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i + 1]));
}
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// PERF_COUNTER_COUNTER
// Description - This counter type shows the average number of operations completed
// during each second of the sample interval. Counters of this type
// measure time in ticks of the system clock. The F variable represents
// the number of ticks per second. The value of F is factored into the
// equation so that the result can be displayed in seconds.
//
// Generic type - Difference
//
// Formula - (N1 - N0) / ( (D1 - D0) / F), where the numerator (N) represents the number
// of operations performed during the last sample interval, the denominator
// (D) represents the number of ticks elapsed during the last sample
// interval, and F is the frequency of the ticks.
//
// Average - (Nx - N0) / ((Dx - D0) / F)
//
// Example - System\ File Read Operations/sec
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
{
Single numerator = (Single)(s1.RawValue - s0.RawValue);
Single denomenator = (Single)(s1.TimeStamp - s0.TimeStamp) / (Single)s1.SystemFrequency;
Single counterValue = numerator / denomenator;
return (counterValue);
}
private static void OutputSample(CounterSample s)
{
Console.WriteLine("\r\n+++++++++++");
Console.WriteLine("Sample values - \r\n");
Console.WriteLine(" BaseValue = " + s.BaseValue);
Console.WriteLine(" CounterFrequency = " + s.CounterFrequency);
Console.WriteLine(" CounterTimeStamp = " + s.CounterTimeStamp);
Console.WriteLine(" CounterType = " + s.CounterType);
Console.WriteLine(" RawValue = " + s.RawValue);
Console.WriteLine(" SystemFrequency = " + s.SystemFrequency);
Console.WriteLine(" TimeStamp = " + s.TimeStamp);
Console.WriteLine(" TimeStamp100nSec = " + s.TimeStamp100nSec);
Console.WriteLine("++++++++++++++++++++++");
}
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.Versioning
<SupportedOSPlatform("Windows")>
Public Class App5
Private Shared PC As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
'If the category does not exist, create the category and exit.
'Performance counters should not be created and immediately used.
'There is a latency time to enable the counters, they should be created
'prior to executing the App5lication that uses the counters.
'Execute this sample a second time to use the counters.
If Not (SetupCategory()) Then
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End If
End Sub
Private Shared Function SetupCategory() As Boolean
If Not PerformanceCounterCategory.Exists("RateOfCountsPerSecond64SampleCategory") Then
Dim CCDC As New CounterCreationDataCollection()
' Add the counter.
Dim rateOfCounts64 As New CounterCreationData()
rateOfCounts64.CounterType = PerformanceCounterType.RateOfCountsPerSecond64
rateOfCounts64.CounterName = "RateOfCountsPerSecond64Sample"
CCDC.Add(rateOfCounts64)
' Create the category.
PerformanceCounterCategory.Create("RateOfCountsPerSecond64SampleCategory", _
"Demonstrates usage of the RateOfCountsPerSecond64 performance counter type.", _
PerformanceCounterCategoryType.SingleInstance, CCDC)
Return True
Else
Console.WriteLine("Category exists - RateOfCountsPerSecond64SampleCategory")
Return False
End If
End Function 'SetupCategory
Private Shared Sub CreateCounters()
' Create the counter.
PC = New PerformanceCounter("RateOfCountsPerSecond64SampleCategory", "RateOfCountsPerSecond64Sample", False)
PC.RawValue = 0
End Sub
Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)
Dim r As New Random(DateTime.Now.Millisecond)
' Initialize the performance counter.
PC.NextSample()
' Loop for the samples.
Dim j As Integer
For j = 0 To 99
Dim value As Integer = r.Next(1, 10)
PC.IncrementBy(value)
Console.Write((j.ToString() + " = " + value.ToString()))
If j Mod 10 = 9 Then
Console.WriteLine(("; NextValue() = " + PC.NextValue().ToString()))
OutputSample(PC.NextSample())
samplesList.Add(PC.NextSample())
Else
Console.WriteLine()
End If
System.Threading.Thread.Sleep(50)
Next j
End Sub
Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
Dim i As Integer
For i = 0 To (samplesList.Count - 1) - 1
' Output the sample.
OutputSample(CType(samplesList(i), CounterSample))
OutputSample(CType(samplesList((i + 1)), CounterSample))
' Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " + _
CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
' Calculate the counter value manually.
Console.WriteLine("My computed counter value = " + _
MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
Next i
End Sub
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
' PERF_COUNTER_COUNTER
' Description - This counter type shows the average number of operations completed
' during each second of the sample interval. Counters of this type
' measure time in ticks of the system clock. The F variable represents
' the number of ticks per second. The value of F is factored into the
' equation so that the result can be displayed in seconds.
'
' Generic type - Difference
'
' Formula - (N1 - N0) / ( (D1 - D0) / F), where the numerator (N) represents the number
' of operations performed during the last sample interval, the denominator
' (D) represents the number of ticks elapsed during the last sample
' interval, and F is the frequency of the ticks.
'
' Average - (Nx - N0) / ((Dx - D0) / F)
'
' Example - System\ File Read Operations/sec
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
Dim numerator As [Single] = CType(s1.RawValue - s0.RawValue, [Single])
Dim denomenator As [Single] = CType(s1.TimeStamp - s0.TimeStamp, [Single]) / CType(s1.SystemFrequency, [Single])
Dim counterValue As [Single] = numerator / denomenator
Return counterValue
End Function 'MyComputeCounterValue
Private Shared Sub OutputSample(ByVal s As CounterSample)
Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
Console.WriteLine((" BaseValue = " + s.BaseValue.ToString()))
Console.WriteLine((" CounterFrequency = " + s.CounterFrequency.ToString()))
Console.WriteLine((" CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
Console.WriteLine((" CounterType = " + s.CounterType.ToString()))
Console.WriteLine((" RawValue = " + s.RawValue.ToString()))
Console.WriteLine((" SystemFrequency = " + s.SystemFrequency.ToString()))
Console.WriteLine((" TimeStamp = " + s.TimeStamp.ToString()))
Console.WriteLine((" TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
Console.WriteLine("++++++++++++++++++++++")
End Sub
End Class
RawFraction
using System;
using System.Collections;
using System.Diagnostics;
using System.Runtime.Versioning;
[SupportedOSPlatform("Windows")]
public class App5
{
private static PerformanceCounter PC;
private static PerformanceCounter BPC;
public static void Main()
{
ArrayList samplesList = new ArrayList();
// If the category does not exist, create the category and exit.
// Performance counters should not be created and immediately used.
// There is a latency time to enable the counters, they should be created
// prior to executing the application that uses the counters.
// Execute this sample a second time to use the counters.
if (SetupCategory())
return;
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists("RawFractionSampleCategory"))
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData rf = new CounterCreationData();
rf.CounterType = PerformanceCounterType.RawFraction;
rf.CounterName = "RawFractionSample";
CCDC.Add(rf);
// Add the base counter.
CounterCreationData rfBase = new CounterCreationData();
rfBase.CounterType = PerformanceCounterType.RawBase;
rfBase.CounterName = "RawFractionSampleBase";
CCDC.Add(rfBase);
// Create the category.
PerformanceCounterCategory.Create("RawFractionSampleCategory",
"Demonstrates usage of the RawFraction performance counter type.",
PerformanceCounterCategoryType.SingleInstance, CCDC);
return (true);
}
else
{
Console.WriteLine("Category exists - RawFractionSampleCategory");
return (false);
}
}
private static void CreateCounters()
{
// Create the counters.
PC = new PerformanceCounter("RawFractionSampleCategory",
"RawFractionSample",
false);
BPC = new PerformanceCounter("RawFractionSampleCategory",
"RawFractionSampleBase",
false);
PC.RawValue = 0;
BPC.RawValue = 0;
}
private static void CollectSamples(ArrayList samplesList)
{
Random r = new Random(DateTime.Now.Millisecond);
// Initialize the performance counter.
PC.NextSample();
// Loop for the samples.
for (int j = 0; j < 100; j++)
{
int value = r.Next(1, 10);
Console.Write(j + " = " + value);
// Increment the base every time, because the counter measures the number
// of high hits (raw fraction value) against all the hits (base value).
BPC.Increment();
// Get the % of samples that are 9 or 10 out of all the samples taken.
if (value >= 9)
PC.Increment();
// Copy out the next value every ten times around the loop.
if ((j % 10) == 9)
{
Console.WriteLine("; NextValue() = " + PC.NextValue().ToString());
OutputSample(PC.NextSample());
samplesList.Add(PC.NextSample());
}
else
{
Console.WriteLine();
}
System.Threading.Thread.Sleep(50);
}
}
private static void CalculateResults(ArrayList samplesList)
{
for (int i = 0; i < samplesList.Count; i++)
{
// Output the sample.
OutputSample((CounterSample)samplesList[i]);
// Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " +
CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i]));
// Calculate the counter value manually.
Console.WriteLine("My computed counter value = " +
MyComputeCounterValue((CounterSample)samplesList[i]));
}
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// Formula from MSDN -
// Description - This counter type shows the ratio of a subset to its set as a percentage.
// For example, it compares the number of bytes in use on a disk to the
// total number of bytes on the disk. Counters of this type display the
// current percentage only, not an average over time.
//
// Generic type - Instantaneous, Percentage
// Formula - (N0 / D0), where D represents a measured attribute and N represents one
// component of that attribute.
//
// Average - SUM (N / D) /x
// Example - Paging File\% Usage Peak
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
private static Single MyComputeCounterValue(CounterSample rfSample)
{
Single numerator = (Single)rfSample.RawValue;
Single denomenator = (Single)rfSample.BaseValue;
Single counterValue = (numerator / denomenator) * 100;
return (counterValue);
}
// Output information about the counter sample.
private static void OutputSample(CounterSample s)
{
Console.WriteLine("+++++++++++");
Console.WriteLine("Sample values - \r\n");
Console.WriteLine(" BaseValue = " + s.BaseValue);
Console.WriteLine(" CounterFrequency = " + s.CounterFrequency);
Console.WriteLine(" CounterTimeStamp = " + s.CounterTimeStamp);
Console.WriteLine(" CounterType = " + s.CounterType);
Console.WriteLine(" RawValue = " + s.RawValue);
Console.WriteLine(" SystemFrequency = " + s.SystemFrequency);
Console.WriteLine(" TimeStamp = " + s.TimeStamp);
Console.WriteLine(" TimeStamp100nSec = " + s.TimeStamp100nSec);
Console.WriteLine("++++++++++++++++++++++");
}
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.Versioning
<SupportedOSPlatform("Windows")>
Public Class App6
Private Shared PC As PerformanceCounter
Private Shared BPC As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
'If the category does not exist, create the category and exit.
'Performance counters should not be created and immediately used.
'There is a latency time to enable the counters, they should be created
'prior to executing the App6lication that uses the counters.
'Execute this sample a second time to use the counters.
If Not (SetupCategory()) Then
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End If
End Sub
Private Shared Function SetupCategory() As Boolean
If Not PerformanceCounterCategory.Exists("RawFractionSampleCategory") Then
Dim CCDC As New CounterCreationDataCollection()
' Add the counter.
Dim rf As New CounterCreationData()
rf.CounterType = PerformanceCounterType.RawFraction
rf.CounterName = "RawFractionSample"
CCDC.Add(rf)
' Add the base counter.
Dim rfBase As New CounterCreationData()
rfBase.CounterType = PerformanceCounterType.RawBase
rfBase.CounterName = "RawFractionSampleBase"
CCDC.Add(rfBase)
' Create the category.
PerformanceCounterCategory.Create("RawFractionSampleCategory",
"Demonstrates usage of the RawFraction performance counter type.",
PerformanceCounterCategoryType.SingleInstance, CCDC)
Return True
Else
Console.WriteLine("Category exists - RawFractionSampleCategory")
Return False
End If
End Function 'SetupCategory
Private Shared Sub CreateCounters()
' Create the counters.
PC = New PerformanceCounter("RawFractionSampleCategory", "RawFractionSample", False)
BPC = New PerformanceCounter("RawFractionSampleCategory", "RawFractionSampleBase", False)
PC.RawValue = 0
BPC.RawValue = 0
End Sub
Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)
Dim r As New Random(DateTime.Now.Millisecond)
' Initialize the performance counter.
PC.NextSample()
' Loop for the samples.
Dim j As Integer
For j = 0 To 99
Dim value As Integer = r.Next(1, 10)
Console.Write((j.ToString() + " = " + value.ToString()))
' Increment the base every time, because the counter measures the number
' of high hits (raw fraction value) against all the hits (base value).
BPC.Increment()
' Get the % of samples that are 9 or 10 out of all the samples taken.
If value >= 9 Then
PC.Increment()
End If
' Copy out the next value every ten times around the loop.
If j Mod 10 = 9 Then
Console.WriteLine(("; NextValue() = " + PC.NextValue().ToString()))
OutputSample(PC.NextSample())
samplesList.Add(PC.NextSample())
Else
Console.WriteLine()
End If
System.Threading.Thread.Sleep(50)
Next j
End Sub
Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
Dim i As Integer
For i = 0 To samplesList.Count - 1
' Output the sample.
OutputSample(CType(samplesList(i), CounterSample))
' Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample)).ToString())
' Calculate the counter value manually.
Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample)).ToString())
Next i
End Sub
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
' Formula from MSDN -
' Description - This counter type shows the ratio of a subset to its set as a percentage.
' For example, it compares the number of bytes in use on a disk to the
' total number of bytes on the disk. Counters of this type display the
' current percentage only, not an average over time.
'
' Generic type - Instantaneous, Percentage
' Formula - (N0 / D0), where D represents a measured attribute and N represents one
' component of that attribute.
'
' Average - SUM (N / D) /x
' Example - Paging File\% Usage Peak
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
Private Shared Function MyComputeCounterValue(ByVal rfSample As CounterSample) As [Single]
Dim numerator As [Single] = CType(rfSample.RawValue, [Single])
Dim denomenator As [Single] = CType(rfSample.BaseValue, [Single])
Dim counterValue As [Single] = numerator / denomenator * 100
Return counterValue
End Function 'MyComputeCounterValue
' Output information about the counter sample.
Private Shared Sub OutputSample(ByVal s As CounterSample)
Console.WriteLine("+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
Console.WriteLine((" BaseValue = " + s.BaseValue.ToString()))
Console.WriteLine((" CounterFrequency = " + s.CounterFrequency.ToString()))
Console.WriteLine((" CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
Console.WriteLine((" CounterType = " + s.CounterType.ToString()))
Console.WriteLine((" RawValue = " + s.RawValue.ToString()))
Console.WriteLine((" SystemFrequency = " + s.SystemFrequency.ToString()))
Console.WriteLine((" TimeStamp = " + s.TimeStamp.ToString()))
Console.WriteLine((" TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
Console.WriteLine("++++++++++++++++++++++")
End Sub
End Class
Megjegyzések
Az PerformanceCounterType enumerálás olyan teljesítményszámláló-típusokat határoz meg, amelyek közvetlenül natív típusokra képeznek le.
Egyes számlálótípusok nyers adatokat, míg mások számított értékeket jelölnek, amelyek egy vagy több számlálómintán alapulnak. Az alábbi kategóriák az elérhető számlálók típusait sorolják be.
- Átlag: Egy érték mérése az idő függvényében, és az utolsó két mérés átlagát jeleníti meg. Az egyes átlagszámlálókhoz egy alapszámláló tartozik, amely nyomon követi az érintett minták számát.
- Különbség: Kivonja az előzőből az utolsó mérést, és ha a különbség pozitív, megjeleníti azt; ha negatív, nulla jelenik meg.
- Pillanatnyi: a legutóbbi mérést jeleníti meg.
- Százalék: A számított értékeket százalékos értékként jeleníti meg.
- Ráta: Az események számának növelését mutatja be az idő függvényében, és megosztja a számértékek változását az idő változásával a tevékenység sebességének megjelenítéséhez.
A nyers teljesítményszámláló-értékek jobb értelmezéséhez érdemes egy átlagot képviselő számlálótípust használni a mintavételezés során. A nyers adatszámláló NumberOfItems64 például olyan adatokat tehet közzé, amelyek meglehetősen véletlenszerűek a mintából a mintába. A számláló által visszaadott értékek átlagos kiszámításának képlete (X 0 +X 1 +...+X n)/n, ahol minden X i egy nyers számlálóminta.
A rátaszámlálók hasonlóak az átlagos számlálókhoz, de hasznosabbak olyan helyzetekben, amikor a ráta az erőforrás használatával nő. Az átlagot gyorsan kiszámító képlet ((X n -X 0)/(T n -T 0)) / gyakoriság, ahol minden X i számlálóminta, és minden T i a megfelelő minta készítésének időpontja. Az eredmény a másodpercenkénti átlagos használat.
A többidős számlálók egy összetevő egynél több példányából, például processzorból vagy lemezről gyűjtenek adatokat.
Az inverz számlálók azt az időt mérik, amikor egy összetevő nem aktív, és ebből a mérésből származtatják az aktív időt.
Note
Ha másként nem jelezzük, az idő alapja másodperc.
Az alkalmazások (egyéni teljesítményszámlálók létrehozása és írása) során olyan teljesítményszámláló-típusokkal dolgozhat, amelyek a számításokban használt kiegészítő alapszámlálóra támaszkodnak. Az alapszámlálónak közvetlenül a társított számláló után kell lennie az CounterCreationDataCollection alkalmazás által használt gyűjteményben. Az alábbi táblázat az alapszámláló-típusokat és a hozzájuk tartozó teljesítményszámláló-típusokat sorolja fel.
| Alapszámláló típusa | Teljesítményszámláló-típusok |
|---|---|
AverageBase |
AverageTimer32AverageCount64 |
RawBase |
RawFraction |
CounterMultiBase |
CounterMultiTimerCounterMultiTimerInverseCounterMultiTimer100NsCounterMultiTimer100NsInverse |
SampleBase |
SampleFraction |
A számított értékeket képviselő számlálók némelyike a következő képleteket használja:
AverageCount64: (N1 – N0)/(B1 – B0), ahol az N 1 és az N 0 teljesítményszámláló, a B1 és a B0 pedig a hozzájuk tartozóAverageBaseértékek. A számláló tehát a mintaintervallum során feldolgozott elemek számát, a nevező pedig a mintaintervallum során végrehajtott műveletek számát jelöli.AverageTimer32: ((N1 – N0)/F)/(B1 – B0), ahol az N1 és az N0 a teljesítményszámláló értékei, a B1 és a B0 a megfelelőAverageBaseértékek, az F pedig a másodpercenkénti ütemek száma. Az F értéke az egyenletbe van belevéve, hogy az eredmény másodpercek alatt megjeleníthető legyen. A számláló tehát az utolsó mintaintervallumban megszámlált kullancsok számát, az F a kullancsok gyakoriságát, a nevező pedig az utolsó mintaintervallumban végrehajtott műveletek számát jelöli.CounterDelta32: N1 – N0, ahol az N1 és az N0 teljesítményszámláló érték.CounterDelta64: N1 – N0, ahol az N1 és az N0 teljesítményszámláló érték.CounterMultiTimer: ((N1 - N0) / (D1 - D0)) x 100 / B, ahol az N1 és az N0 teljesítményszámláló, a D1 és a D0 a megfelelő időmérő a rendszerteljesítmény-időzítő ketyegéseiben, a B változó pedig a figyelt összetevők alapszámát jelöli (típusalapúCounterMultiBasealapszámláló használatával). A számláló tehát a mintaintervallum azon részeit jelöli, amelyek során a figyelt összetevők aktívak voltak, a nevező pedig a mintaintervallum teljes eltelt idejét jelöli.CounterMultiTimer100Ns: ((N1 - N0) / (D1 - D0)) x 100 / B, ahol az N1 és az N0 teljesítményszámláló, a D1 és a D0 a hozzájuk tartozó időértékek 100 nanoszekundumos egységekben, a B változó pedig a figyelt összetevők alapszámát jelöli (típusalapúCounterMultiBasealapszámláló használatával). A számláló tehát a mintaintervallum azon részeit jelöli, amelyek során a figyelt összetevők aktívak voltak, a nevező pedig a mintaintervallum teljes eltelt idejét jelöli.CounterMultiTimer100NsInverse: (B - ((N1 - N0) / (D1 - D0))) x 100, ahol a nevező a mintaintervallum teljes eltelt idejét jelöli, a számláló a figyelt összetevők inaktív állapotának időtartamát, a B pedig a figyelt összetevők számát jelöli egy alap típusúCounterMultiBaseszámláló használatával .CounterMultiTimerInverse: (B- ((N1 - N0) / (D1 - D0))) x 100, ahol a nevező a mintaintervallum teljes eltelt idejét jelöli, a számláló a figyelt összetevők inaktív állapotának időtartamát, a B pedig a figyelendő összetevők számát jelöli egy alap típusúCounterMultiBaseszámláló használatával .CounterTimer: (N1 - N0) / (D1 - D0), ahol az N1 és az N0 teljesítményszámláló, a D1 és a D0 pedig a megfelelő időolvasás. A számláló tehát a mintaintervallum azon részeit jelöli, amelyek során a figyelt összetevők aktívak voltak, a nevező pedig a mintaintervallum teljes eltelt idejét jelöli.CounterTimerInverse: (1- ((N1 - N0) / (D1 - D0))) x 100, ahol a számláló a figyelt összetevők inaktív állapotának időtartamát jelöli, a nevező pedig a mintaintervallum teljes eltelt idejét jelöli.CountPerTimeInterval32: (N1 – N0) / (D1 – D0), ahol a számláló az üzenetsor elemeinek számát jelöli, a nevező pedig az utolsó mintaintervallum során eltelt időt jelöli.CountPerTimeInterval64: (N1 – N0) / (D1 – D0), ahol a számláló az üzenetsor elemeinek számát, a nevező pedig a mintaintervallum során eltelt időt jelöli.ElapsedTime: (D0 – N0) / F, ahol a D0 az aktuális időt, az N0 az objektum indításának időpontját, az F pedig az egy másodperc alatt eltelt időegységek számát jelöli. Az F értéke az egyenletbe van belevéve, hogy az eredmény másodpercek alatt megjeleníthető legyen.NumberOfItems32: Nincs. Nem jelenít meg átlagot, hanem az összegyűjtött nyers adatokat jeleníti meg.NumberOfItems64: Nincs. Nem jelenít meg átlagot, hanem az összegyűjtött nyers adatokat jeleníti meg.NumberOfItemsHEX32: Nincs. Nem jelenít meg átlagot, hanem az összegyűjtött nyers adatokat jeleníti meg.NumberOfItemsHEX64: Nincs. Nem jelenít meg átlagot, hanem a gyűjtött nyers adatokat jeleníti megRateOfCountsPerSecond32: (N1 - N0) / ((D1 - D0) / F), ahol az N1 és az N0 teljesítményszámláló, a D1 és a D0 a megfelelő időérték, az F pedig a másodpercenkénti kullancsok számát jelöli. Így a számláló az utolsó mintaintervallumban végrehajtott műveletek számát, a nevező az utolsó mintaintervallum során eltelt kullancsok számát, az F pedig a kullancsok gyakoriságát jelöli. Az F értéke az egyenletbe van belevéve, hogy az eredmény másodpercek alatt megjeleníthető legyen.RateOfCountsPerSecond64: (N1 - N0) / ((D1 - D0) / F), ahol az N1 és az N0 teljesítményszámláló, a D1 és a D0 a megfelelő időérték, az F pedig a másodpercenkénti kullancsok számát jelöli. Így a számláló az utolsó mintaintervallumban végrehajtott műveletek számát, a nevező az utolsó mintaintervallum során eltelt kullancsok számát, az F pedig a kullancsok gyakoriságát jelöli. Az F értéke az egyenletbe van belevéve, hogy az eredmény másodpercek alatt megjeleníthető legyen.RawFraction: (N0/ D0) x 100, ahol a D0 egy mért attribútumot jelöl (típusalapúRawBasealapszámláló használatával), az N0 pedig az attribútum egyik összetevőjét jelöli.SampleCounter: (N1 - N0) / ((D1 - D0) / F), ahol a számláló (N) a befejezett műveletek számát jelöli, a nevező (D) a rendszerteljesítmény-időzítő időegységeiben az eltelt időt, az F pedig az egy másodperc alatt eltelt tikkek számát jelöli. Az F függvény az egyenletbe van belevéve, hogy az eredmény másodpercek alatt megjeleníthető legyen.SampleFraction: ((N1 - N0) / (D1 - D0)) x 100, ahol a számláló az utolsó mintaintervallumban végrehajtott sikeres műveletek számát jelöli, a nevező pedig a mintaintervallum során végrehajtott összes művelet (a mért típus) számának változását jelzi, típusszámlálókSampleBasehasználatával.Timer100Ns: (N1 - N0) / (D1 - D0) x 100, ahol a számláló annak a mintaintervallumnak a részeit jelöli, amelyben a figyelt összetevők aktívak voltak, a nevező pedig a mintaintervallum teljes eltelt idejét jelöli.Timer100NsInverse: (1- ((N1 - N0) / (D1 - D0))) x 100, ahol a számláló a figyelt összetevők inaktív állapotának időtartamát jelöli, a nevező pedig a mintaintervallum teljes eltelt idejét jelöli.
