PerformanceCounterType 列挙体
PerformanceCounter インスタンスの NextValue メソッドを計算するために使用する数式を指定します。
<Serializable>
Public Enum PerformanceCounterType
[C#]
[Serializable]
public enum PerformanceCounterType
[C++]
[Serializable]
__value public enum PerformanceCounterType
[JScript]
public
Serializable
enum PerformanceCounterType
解説
いくつかのカウンタ タイプは生データを表しますが、1 つ以上のカウンタ サンプルに基づいて計算される値を表すカウンタ タイプもあります。使用できるカウンタ タイプは、次のカテゴリに分類されます。
- 平均: 一定期間の値を計測し、最後の 2 つの計測値の平均を表示します。平均カウンタは、使用するサンプルの数値を追跡するベース カウンタに関連付けられます。
- 差: 最後の測定値をその前の測定値から減算し、結果が正の場合は差を表示します。負の場合はゼロを表示します。
- 即時: 直前の測定値を表示します。
- パーセント: 計算した値をパーセントとして表示します。
- 割合: 増加するイベントの回数を一定期間サンプリングし、回数の値のキャッシュをアクティビティの割合を表示する期間で変化した値で除算します。
パフォーマンス カウンタ データをサンプリングするとき、平均を表すカウンタ タイプを使用すると、生データ値が意味のある値になります。たとえば、生データ カウンタの NumberOfItems64 は、サンプルによってかなり異なるデータを示します。カウンタが返す値の平均を計算する数式は、(X0 +X 1 +・X n)/n です。ここで、各 X i は生のカウンタ サンプルです。
割合カウンタは、平均カウンタと似ていますが、リソースが使用されるに従い割合が増加する場合により役立ちます。平均をすばやく計算する数式は ((Xn -X 0)/(T n -T 0))/ 頻度です。ここで、各 X i はカウンタ サンプル、各 T i は、対応するサンプルが取得された時刻です。結果は、1 秒あたりの平均使用率です。
メモ 特に指定がない場合、時間の単位は秒です。
アプリケーションを実装するとき (カスタム パフォーマンス カウンタを作成し、書き込むとき)、計算で使用される付属するベース カウンタに依存するパフォーマンス カウンタ タイプを使用することがあります。ベース カウンタは、アプリケーションで使用する CounterCreationDataCollection コレクションの中で、関連付けられているカウンタの直後に置く必要があります。ベース カウンタ タイプと、それぞれに対応するパフォーマンス カウンタ タイプの一覧を次の表に示します。
| ベース カウンタ タイプ | パフォーマンス カウンタ タイプ |
|---|---|
| AverageBase | AverageTimer32
AverageCount64 |
| CounterMultiBase | CounterMultiTimer
CounterMultiTimerInverse CounterMultiTimer100Ns CounterMultiTimer100NsInverse |
| RawBase | RawFraction |
| SampleBase | SampleCounter
SampleFraction |
メンバ
| メンバ名 | 説明 |
|---|---|
| AverageBase | AverageTimer32 や AverageCount64 など、時間または回数の平均を計算するために使用されるベース カウンタ。"操作ごとの時間" または "操作ごとの回数" を表すカウンタの計算に使用する分母を格納します。 |
| AverageCount64 | 処理された項目の数を操作中の平均で示す平均カウンタ。このタイプのカウンタは、完了した処理数に対する処理された項目の比率を表示します。比率は、最後の間隔で処理された項目数と、最後の間隔で完了した操作の数を比較することによって計算されます。
数式: (N1 -N 0)/(B 1 -B 0) で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取りを表し、B 1 と B 0 はそれぞれに対応する AverageBase 値を表します。つまり、分子はサンプル間隔中に処理された項目数を表し、分母はサンプル間隔中に完了した操作の数を表します。 このタイプのカウンタには、PhysicalDisk\ Avg.Disk Bytes/Transfer などがあります。 |
| AverageTimer32 | 処理または操作を完了するまでに経過した時間の平均を計測する平均カウンタ。このタイプのカウンタは、サンプル間隔で完了した処理または操作に対する、その間隔での経過時間の合計の比率を表示します。このカウンタ タイプは、システム時計のタイマ刻みで時間を計測します。
数式: ((N1 -N 0)/F)/(B 1 -B 0) で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取りを表し、B 1 と B 0 はそれぞれに対応する AverageBase 値を表し、F は 1 秒あたりのタイマ刻み数を表します。F の値が数式で考慮されるため、結果は秒単位で表示されます。つまり、分子は最後のサンプル間隔中にカウントされたタイマ刻み数を表し、F はタイマ刻みの頻度を表し、分母は最後のサンプル間隔中に完了した操作の数を表します。 このタイプのカウンタには、PhysicalDisk\ Avg.Disk sec/Transfer などがあります。 |
| CounterDelta32 | 2 つの最新のサンプル間隔を使用して、その間の計測対象の属性の変化を示す差カウンタ。
数式: N1 -N 0 で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取りを表します。 |
| CounterDelta64 | 2 つの最新のサンプル間隔を使用して、その間の計測対象の属性の変化を示す差カウンタ。 CounterDelta32 カウンタ タイプと同じですが、大きな値を処理できるように、大きなフィールドを使用します。
数式: N1 -N 0 で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取りを表します。 |
| CounterMultiBase | サンプリングする項目の数を示すベース カウンタ。複数の似た項目について、タイミングをとりながらサンプリングされた項目の平均を取得する計算で、分母として使用されます。 CounterMultiTimer 、 CounterMultiTimerInverse 、 CounterMultiTimer100Ns 、および CounterMultiTimer100NsInverse で使用します。 |
| CounterMultiTimer | 1 つ以上のコンポーネントのアクティブな時間をサンプル間隔の合計時間に対するパーセントで表示するパーセント カウンタ。分子は、同時に運用されるコンポーネントのアクティブな時間を記録するため、結果のパーセントは 100 パーセントを超えることがあります。
このカウンタはマルチタイマです。マルチタイマは、プロセッサやディスクなど、コンポーネントの複数のインスタンスからデータを収集します。このカウンタ タイプは、システム パフォーマンス タイマのタイマ刻みの単位で時間を計測するという点で、100 ナノ秒単位で計測する CounterMultiTimer100Ns と異なります。 数式: ((N1 - N 0)/ (D 1 - D 0)) × 100/ B で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取りを表し、D 1 と D 0 はそれぞれに対応する時間の読み取り (100 ナノ秒単位) を表し、変数 B は監視するコンポーネントのベース カウンタを表します (カウンタ タイプが CounterMultiBase のベース カウンタを使用)。つまり、分子は、監視するコンポーネントがアクティブだったサンプル間隔の一部分を表し、分母は、サンプル間隔の経過時間の合計を表します。 |
| CounterMultiTimer100Ns | 1 つ以上のコンポーネントのアクティブな時間をサンプル間隔の合計時間に対するパーセントで示すパーセント カウンタ。時間を 100 ナノ秒 (ns) 単位で計測します。
このカウンタ タイプはマルチタイマです。マルチタイマは、プロセッサやディスクなど、コンポーネントの複数のインスタンスを監視するようにデザインされています。 数式: ((N1 - N 0)/ (D 1 - D 0)) × 100/ B で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取りを表し、D 1 と D 0 はそれぞれに対応する時間の読み取り (100 ナノ秒単位) を表し、変数 B は監視するコンポーネントのベース カウンタを表します (カウンタ タイプが CounterMultiBase のベース カウンタを使用)。つまり、分子は、監視するコンポーネントがアクティブだったサンプル間隔の一部分を表し、分母は、サンプル間隔の経過時間の合計を表します。 |
| CounterMultiTimer100NsInverse | 1 つ以上のコンポーネントのアクティブな時間をサンプル間隔の合計時間に対するパーセントで示すパーセント カウンタ。このカウンタ タイプは、時間を 100 ナノ秒 (ns) 単位で計測します。コンポーネントがアクティブでなかった時間を計測し、監視するオブジェクト数かける 100 パーセントから計測値を減算することによってアクティブな時間を導出します。
このカウンタ タイプは逆マルチタイマです。マルチタイマは、プロセッサやディスクなど、コンポーネントの複数のインスタンスを監視するようにデザインされています。逆カウンタは、コンポーネントがアクティブでない時間を計測し、アクティブでない時間の計測値からアクティブな時間を導出します。 数式: (B - ((N1 - N 0)/ (D 1 - D 0))) × 100 で計算されます。ここで、分母はサンプル間隔の経過時間合計を表し、分子はその間隔で監視対象コンポーネントがアクティブでなかった時間を表し、B はカウンタ タイプが CounterMultiBase のベース カウンタを使用して監視するコンポーネントの数を表します。 |
| CounterMultiTimerInverse | 1 つ以上のコンポーネントのアクティブな時間をサンプル間隔の合計時間に対するパーセントで示すパーセント カウンタ。コンポーネントがアクティブでなかった時間を計測し、監視するオブジェクト数かける 100 パーセントから計測値を減算することによってアクティブな時間を導出します。
このカウンタ タイプは逆マルチタイマです。マルチタイマは、プロセッサやディスクなど、コンポーネントの複数のインスタンスを監視します。逆カウンタは、コンポーネントがアクティブでない時間を計測し、この計測値からアクティブな時間を導出します。 このカウンタは、システム パフォーマンス タイマのタイマ刻みの単位で時間を計測するという点で、100 ナノ秒単位で計測する CounterMultiTimer100NsInverse と異なります。 数式: (B - ((N1 - N 0)/ (D 1 - D 0))) × 100 で計算されます。ここで、分母はサンプル間隔の経過時間合計を表し、分子はその間隔で監視対象コンポーネントがアクティブでなかった時間を表し、B はカウンタ タイプが CounterMultiBase のベース カウンタを使用して監視するコンポーネントの数を表します。 |
| CounterTimer | コンポーネントがアクティブだった平均時間をサンプル時間合計に対するパーセントで示すパーセント カウンタ。
数式: (N1 - N 0)/ (D 1 - D 0) で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取りを表し、D 1 と D 0 はそれぞれに対応する時間読み取りです。つまり、分子は、監視するコンポーネントがアクティブだったサンプル間隔の一部分を表し、分母は、サンプル間隔の経過時間の合計を表します。 |
| CounterTimerInverse | サンプル間隔中に記録されたアクティブな時間の平均パーセントを表示するパーセント カウンタ。このカウンタの値は、サービスがアクティブでなかった時間のパーセントを監視し、この値を 100 パーセントから減算することによって計算されます。
逆カウンタ タイプです。逆カウンタは、コンポーネントがアクティブでない時間を計測し、この計測値からアクティブな時間を導出します。このカウンタ タイプは CounterTimer100NsInv と同じですが、100 ナノ秒単位ではなく、システム パフォーマンス タイマのタイマ刻みの単位で時間を計測するという点が異なります。 数式: (1- ((N1 - N 0)/ (D 1 - D 0))) × 100 で計算されます。ここで、分子はその間隔で監視対象コンポーネントがアクティブでなかった時間を表し、分母はサンプル間隔の経過時間合計を表します。 |
| CountPerTimeInterval32 | 一定時間の間のリソースに対するキューの長さの平均を監視するようにデザインされた平均カウンタ。間隔の存続期間で分割された最後の 2 つのサンプル間隔の間で監視されたキューの長さの差を示します 。このカウンタ タイプは、通常、キューに置かれた項目または待機中の項目の数を追跡するために使用されます。
数式: (N1 - N 0)/ (D 1 - D 0) で計算されます。ここで、分子はキューの項目数を表し、分母は最後のサンプル間隔の経過時間を表します。 |
| CountPerTimeInterval64 | 一定時間の間のリソースに対するキューの長さの平均を監視する平均カウンタ。このカウンタ タイプは、間隔の存続期間で分割された最後の 2 つのサンプル間隔の間で監視されたキューの長さの差を示します 。このカウンタ タイプは、 CountPerTimeInterval32 と同じですが、大きな値を処理できるように、大きなフィールドを使用します。このカウンタ タイプは、通常、キューに置かれたまたは待機中の大量または多数の項目の数を追跡するために使用されます。
数式: (N1 - N 0)/ (D 1 - D 0) で計算されます。ここで、分子はキューの項目数を表し、分母はサンプル間隔の経過時間を表します。 |
| ElapsedTime | コンポーネントまたはプロセスが開始された時間と、この値が計算された時間の間の合計時間を示す差タイマ。
数式: (D0 - N 0)/ F で計算されます。ここで、D 0 は現在時刻を表し、N 0 はオブジェクトが開始された時刻を表し、F は 1 秒間に経過する時間単位数を表します。F の値が数式で考慮されるため、結果は秒単位で表示されます。 このタイプのカウンタには、System\ System Up Time などがあります。 |
| NumberOfItems32 | 最新の記録値を示す即時カウンタ。項目または操作の単純なカウントを保持するときなどに使用します。
数式: なし。平均は表示されませんが、収集した生データが表示されます。 このタイプのカウンタには、Memory\Available Bytes などがあります。 |
| NumberOfItems64 | 最新の記録値を示す即時カウンタ。大量の項目または操作の単純なカウントを保持するときなどに使用します。 NumberOfItems32 と同じですが、大きな値を処理できるように、大きなフィールドを使用します。
数式: なし。平均は表示されませんが、収集した生データが表示されます。 |
| NumberOfItemsHEX32 | 最新の記録値を 16 進形式で示す即時カウンタ。項目または操作の単純なカウントを保持するときなどに使用します。
数式: なし。平均は表示されませんが、収集した生データが表示されます。 |
| NumberOfItemsHEX64 | 最新の記録値を示す即時カウンタ。大量の項目または操作の単純なカウントを保持するときなどに使用します。 NumberOfItemsHEX32 と同じですが、大きな値を処理できるように、大きなフィールドを使用します。
数式: なし。平均は表示されませんが、収集した生データが表示されます。 |
| RateOfCountsPerSecond32 | サンプル間隔の各秒で完了した平均操作数を示す差カウンタ。このタイプのカウンタは、システム時計のタイマ刻みで時間を計測します。
数式: (N1 - N 0)/ ( (D 1 -D 0)/ F) で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取りを表し、D 1 と D 0 はそれぞれに対応する時間読み取りを表し、F は 1 秒あたりのタイマ刻み数を表します。つまり、分子は最後のサンプル間隔中に実行された操作の数を表し、分母は最後のサンプル間隔中に経過したタイマ刻み数を表し、F はタイマ刻みの頻度を表します。F の値が数式で考慮されるため、結果は秒単位で表示されます。 このタイプのカウンタには、System\ File Read Operations/sec などがあります。 |
| RateOfCountsPerSecond64 | サンプル間隔の各秒で完了した平均操作数を示す差カウンタ。このタイプのカウンタは、システム時計のタイマ刻みで時間を計測します。このカウンタ タイプは RateOfCountsPerSecond32 タイプと同じですが、バイト転送速度など 1 秒ごとに大量の項目数または操作数を追跡するために、大きな値を処理できるように、大きなフィールドを使用します。
数式: (N1 - N 0)/ ( (D 1 -D 0)/ F) で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取りを表し、D 1 と D 0 はそれぞれに対応する時間読み取りを表し、F は 1 秒あたりのタイマ刻み数を表します。つまり、分子は最後のサンプル間隔中に実行された操作の数を表し、分母は最後のサンプル間隔中に経過したタイマ刻み数を表し、F はタイマ刻みの頻度を表します。F の値が数式で考慮されるため、結果は秒単位で表示されます。 このタイプのカウンタには、System\ File Read Bytes/sec などがあります。 |
| RawBase | 通常の算術的な分数を表すカウンタの分母を格納するベース カウンタ。 RawFraction 値の計算で分母として使用する前に、この値がゼロを超えることを確認してください。 |
| RawFraction | セットに対するサブセットの比率をパーセントで示す即時パーセント カウンタ。たとえば、ディスクで使用中のバイト数とディスクの総バイト数を比較します。このタイプのカウンタは、一定期間の平均ではなく、現在のパーセントだけを表示します。
数式: (N0/ D 0) × 100 で計算されます。ここで、D 0 は計測対象の属性 (カウンタ タイプが RawBase のベース カウンタを使用) を表し、N0 は、その属性の 1 つのコンポーネントを表します。 このタイプのカウンタには、Paging File\% Usage Peak などがあります。 |
| SampleBase | 取得したサンプリング割り込みの回数を格納するベース カウンタ。サンプリング分数の分母として使用されます。サンプリング分数は、サンプリング割り込みに対して 1 (または true) だったサンプルの数です。 SampleCounter または SampleFraction の計算で分母として使用する前に、この値が 0 より大きいことを確認してください。 |
| SampleCounter | 1 秒間に完了した平均操作数を示す平均カウンタ。このタイプのカウンタがデータをサンプリングすると、各サンプリング割り込みが 1 または 0 を返します。カウンタ データは、サンプリングされたデータの数です。システム パフォーマンス タイマのタイマ刻みの時間単位を計測します。
数式: (N1 - N 0)/ ((D 1 - D 0)/ F) で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取り、D 1 と D 0 はそれぞれに対応する SampleBase 値、F は 1 秒間に経過するタイマ刻みの数です。つまり、分子は完了した操作の数を表し、分母は経過時間をシステム パフォーマンス タイマのタイマ刻みの単位で表します。F が数式で考慮されるため、結果は秒単位で表示されます。 |
| SampleFraction | 最後の 2 つのサンプル間隔中に発生したすべての操作に対するヒット カウントの平均比率を示すパーセント カウンタ。
数式: ((N1 - N 0)/ (D 1 - D 0)) × 100 で計算されます。ここで、分子は最後のサンプル間隔で成功した操作の数を表し、分母は、カウンタ タイプが SampleBase のカウンタを使用して、サンプル間隔で完了したすべての操作 (計測対象のタイプの操作) の数の変化を表します。 このタイプのカウンタには、Cache\Pin Read Hits % などがあります。 |
| Timer100Ns | コンポーネントのアクティブな時間をサンプル間隔の合計経過時間に対するパーセントで示すパーセント カウンタ。時間を 100 ナノ秒 (ns) 単位で計測します。このタイプのカウンタは、あるコンポーネントのある時点でのアクティビティを計測するようにデザインされています。
数式: (N1 - N 0)/ (D 1 - D 0) × 100 で計算されます。ここで、分子は監視対象コンポーネントがアクティブだったサンプル間隔の一部分を表し、分母はサンプル間隔の経過時間合計を表します。 このタイプのカウンタには、Processor\ % User Time などがあります。 |
| Timer100NsInverse | サンプル間隔中に記録されたアクティブな時間の平均パーセントを示すパーセント カウンタ。
逆カウンタです。このタイプのカウンタは、サービスがアクティブでなかった時間を計測し、アクティブな時間のパーセントを 100 パーセントから減算することによってアクティブな時間を計算します。 数式: (1- ((N1 - N 0)/ (D 1 - D 0))) × 100 で計算されます。ここで、分子はその間隔で監視対象コンポーネントがアクティブでなかった時間を表し、分母はサンプル間隔の経過時間合計を表します。 このタイプのカウンタには、Processor\ % Processor Time などがあります。 |
使用例
[Visual Basic, C#, C++] PerformanceCounterType 列挙体に含まれるカウンタ タイプのいくつかを次に示します。
[Visual Basic, C#, C++] AverageCount64
Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
_
Public Class App
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 'Main
Private Shared Function SetupCategory() As Boolean
If Not PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") Then
Dim CCDC As New CounterCreationDataCollection()
' Add the counter.
Dim averageCount64 As New CounterCreationData()
averageCount64.CounterType = PerformanceCounterType.AverageCount64
averageCount64.CounterName = "AverageCounter64Sample"
CCDC.Add(averageCount64)
' Add the base counter.
Dim averageCount64Base As New CounterCreationData()
averageCount64Base.CounterType = PerformanceCounterType.AverageBase
averageCount64Base.CounterName = "AverageCounter64SampleBase"
CCDC.Add(averageCount64Base)
' Create the category.
PerformanceCounterCategory.Create("AverageCounter64SampleCategory", "Demonstrates usage of the AverageCounter64 performance counter type.", CCDC)
Return True
Else
Console.WriteLine("Category exists - AverageCounter64SampleCategory")
Return False
End If
End Function 'SetupCategory
Private Shared Sub CreateCounters()
' Create the counters.
PC = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64Sample", False)
BPC = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64SampleBase", False)
PC.RawValue = 0
BPC.RawValue = 0
End Sub 'CreateCounters
Private Shared Sub CollectSamples(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 + " = " + value))
PC.IncrementBy(value)
BPC.Increment()
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 'CollectSamples
Private Shared Sub CalculateResults(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))))
' 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 'CalculateResults
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
' 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(s0 As CounterSample, 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(s As CounterSample)
Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
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 'OutputSample
End Class 'App
[C#]
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
public class App {
private static PerformanceCounter PC;
private static PerformanceCounter BPC;
public static void Main()
{
ArrayList samplesList = new ArrayList();
SetupCategory();
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
}
private static bool SetupCategory()
{
if ( !PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") )
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageCount64 = new CounterCreationData();
averageCount64.CounterType = PerformanceCounterType.AverageCount64;
averageCount64.CounterName = "AverageCounter64Sample";
CCDC.Add(averageCount64);
// Add the base counter.
CounterCreationData averageCount64Base = new CounterCreationData();
averageCount64Base.CounterType = PerformanceCounterType.AverageBase;
averageCount64Base.CounterName = "AverageCounter64SampleBase";
CCDC.Add(averageCount64Base);
// Create the category.
PerformanceCounterCategory.Create("AverageCounter64SampleCategory",
"Demonstrates usage of the AverageCounter64 performance counter type.",
CCDC);
return(true);
}
else
{
Console.WriteLine("Category exists - AverageCounter64SampleCategory");
return(false);
}
}
private static void CreateCounters()
{
// Create the counters.
PC = new PerformanceCounter("AverageCounter64SampleCategory",
"AverageCounter64Sample",
false);
BPC = new PerformanceCounter("AverageCounter64SampleCategory",
"AverageCounter64SampleBase",
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 j = 0; j < 100; j++)
{
int value = r.Next(1, 10);
Console.Write(j + " = " + value);
PC.IncrementBy(value);
BPC.Increment();
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]) );
}
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// 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("++++++++++++++++++++++");
}
}
[C++]
#using <mscorlib.dll>
#using <System.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;
// Output information about the counter sample.
void OutputSample(CounterSample s) {
Console::WriteLine(S"\r\n+++++++++++");
Console::WriteLine(S"Sample values - \r\n");
Console::WriteLine(S" BaseValue = {0}", __box(s.BaseValue));
Console::WriteLine(S" CounterFrequency = {0}", __box(s.CounterFrequency));
Console::WriteLine(S" CounterTimeStamp = {0}", __box(s.CounterTimeStamp));
Console::WriteLine(S" CounterType = {0}", __box(s.CounterType));
Console::WriteLine(S" RawValue = {0}", __box(s.RawValue));
Console::WriteLine(S" SystemFrequency = {0}", __box(s.SystemFrequency));
Console::WriteLine(S" TimeStamp = {0}", __box(s.TimeStamp));
Console::WriteLine(S" TimeStamp100nSec = {0}", __box(s.TimeStamp100nSec));
Console::WriteLine(S"++++++++++++++++++++++");
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// 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
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
float MyComputeCounterValue(CounterSample s0, CounterSample s1) {
float numerator = (float)s1.RawValue - (float)s0.RawValue;
float denomenator = (float)s1.BaseValue - (float)s0.BaseValue;
float counterValue = numerator / denomenator;
return(counterValue);
}
bool SetupCategory() {
if (!PerformanceCounterCategory::Exists(S"AverageCounter64SampleCategory")) {
CounterCreationDataCollection* CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData* averageCount64 = new CounterCreationData();
averageCount64->CounterType = PerformanceCounterType::AverageCount64;
averageCount64->CounterName = S"AverageCounter64Sample";
CCDC->Add(averageCount64);
// Add the base counter.
CounterCreationData* averageCount64Base = new CounterCreationData();
averageCount64Base->CounterType = PerformanceCounterType::AverageBase;
averageCount64Base->CounterName = S"AverageCounter64SampleBase";
CCDC->Add(averageCount64Base);
// Create the category.
PerformanceCounterCategory::Create(S"AverageCounter64SampleCategory",
S"Demonstrates usage of the AverageCounter64 performance counter type.",
CCDC);
return(true);
} else {
Console::WriteLine(S"Category exists - AverageCounter64SampleCategory");
return(false);
}
}
void CreateCounters(PerformanceCounter*& PC, PerformanceCounter*& BPC) {
// Create the counters.
PC = new PerformanceCounter(S"AverageCounter64SampleCategory",
S"AverageCounter64Sample", false);
BPC = new PerformanceCounter(S"AverageCounter64SampleCategory",
S"AverageCounter64SampleBase", false);
PC->RawValue=0;
BPC->RawValue=0;
}
void CollectSamples(ArrayList* samplesList, PerformanceCounter* PC, PerformanceCounter* BPC) {
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(S"{0} = {1}", __box(j), __box(value));
PC->IncrementBy(value);
BPC->Increment();
if ((j % 10) == 9) {
OutputSample(PC->NextSample());
samplesList->Add(__box(PC->NextSample()));
} else
Console::WriteLine();
System::Threading::Thread::Sleep(50);
}
}
void CalculateResults(ArrayList* samplesList) {
for (int i = 0; i < (samplesList->Count - 1); i++) {
// Output the sample.
OutputSample(*__try_cast<__box CounterSample*>(samplesList->Item[i]));
OutputSample(*__try_cast<__box CounterSample*>(samplesList->Item[i+1]));
// Use .NET to calculate the counter value.
Console::WriteLine(S".NET computed counter value = {0}",
__box(CounterSampleCalculator::ComputeCounterValue(
*__try_cast<__box CounterSample*>(samplesList->Item[i]),
*__try_cast<__box CounterSample*>(samplesList->Item[i+1]))));
// Calculate the counter value manually.
Console::WriteLine(S"My computed counter value = {0}",
__box(MyComputeCounterValue(
*__try_cast<__box CounterSample*>(samplesList->Item[i]),
*__try_cast<__box CounterSample*>(samplesList->Item[i+1]))));
}
}
int main() {
ArrayList* samplesList = new ArrayList();
PerformanceCounter* PC;
PerformanceCounter* BPC;
SetupCategory();
CreateCounters(PC, BPC);
CollectSamples(samplesList, PC, BPC);
CalculateResults(samplesList);
}
[Visual Basic, C#, C++] AverageTimer32
Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.InteropServices
Imports Microsoft.VisualBasic
Public Class App
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("AverageTimer32SampleCategory") Then
Dim CCDC As New CounterCreationDataCollection()
' Add the counter.
Dim averageTimer32 As New CounterCreationData()
averageTimer32.CounterType = PerformanceCounterType.AverageTimer32
averageTimer32.CounterName = "AverageTimer32Sample"
CCDC.Add(averageTimer32)
' Add the base counter.
Dim averageTimer32Base As New CounterCreationData()
averageTimer32Base.CounterType = PerformanceCounterType.AverageBase
averageTimer32Base.CounterName = "AverageTimer32SampleBase"
CCDC.Add(averageTimer32Base)
' Create the category.
PerformanceCounterCategory.Create( _
"AverageTimer32SampleCategory", _
"Demonstrates usage of the AverageTimer32 performance counter type", CCDC)
Return True
Else
Console.WriteLine(("Category exists - " + _
"AverageTimer32SampleCategory"))
Return False
End If
End Function
Private Shared Sub CreateCounters()
' Create the counters.
PC = New PerformanceCounter("AverageTimer32SampleCategory", _
"AverageTimer32Sample", False)
BPC = New PerformanceCounter("AverageTimer32SampleCategory", _
"AverageTimer32SampleBase", False)
PC.RawValue = 0
BPC.RawValue = 0
End Sub
Private Shared Sub CollectSamples(samplesList As ArrayList)
Dim perfTime As Long = 0
Dim r As New Random(DateTime.Now.Millisecond)
' Loop for the samples.
Dim i As Integer
For i = 0 To 9
QueryPerformanceCounter(perfTime)
PC.RawValue = perfTime
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(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( _
s0 As CounterSample, _
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(s As CounterSample)
Console.WriteLine("+++++++++++")
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
<DllImport("Kernel32.dll")> _
Public Shared Function _
QueryPerformanceCounter(ByRef value As Long) As Boolean
End Function
End Class
[C#]
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Runtime.InteropServices;
public class App
{
private static PerformanceCounter PC;
private static PerformanceCounter BPC;
public static void Main()
{
ArrayList samplesList = new ArrayList();
SetupCategory();
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
}
private static bool SetupCategory()
{
if ( !PerformanceCounterCategory.Exists("AverageTimer32SampleCategory") )
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageTimer32 = new CounterCreationData();
averageTimer32.CounterType = PerformanceCounterType.AverageTimer32;
averageTimer32.CounterName = "AverageTimer32Sample";
CCDC.Add(averageTimer32);
// Add the base counter.
CounterCreationData averageTimer32Base = new CounterCreationData();
averageTimer32Base.CounterType = PerformanceCounterType.AverageBase;
averageTimer32Base.CounterName = "AverageTimer32SampleBase";
CCDC.Add(averageTimer32Base);
// Create the category.
PerformanceCounterCategory.Create("AverageTimer32SampleCategory",
"Demonstrates usage of the AverageTimer32 performance counter type",
CCDC);
return(true);
}
else
{
Console.WriteLine("Category exists - " + "AverageTimer32SampleCategory");
return(false);
}
}
private static void CreateCounters()
{
// Create the counters.
PC = new PerformanceCounter("AverageTimer32SampleCategory",
"AverageTimer32Sample",
false);
BPC = new PerformanceCounter("AverageTimer32SampleCategory",
"AverageTimer32SampleBase",
false);
PC.RawValue = 0;
BPC.RawValue = 0;
}
private static void CollectSamples(ArrayList samplesList)
{
long perfTime = 0;
Random r = new Random( DateTime.Now.Millisecond );
// Loop for the samples.
for (int i = 0; i < 10; i++) {
QueryPerformanceCounter(out perfTime);
PC.RawValue = perfTime;
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(" 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("++++++++++++++++++++++");
}
[DllImport("Kernel32.dll")]
public static extern bool QueryPerformanceCounter(out long value);
}
[C++]
#using <mscorlib.dll>
#using <System.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;
using namespace System::Runtime::InteropServices;
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
// 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
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
float MyComputeCounterValue(CounterSample s0, CounterSample s1) {
__int64 n1 = s1.RawValue;
__int64 n0 = s0.RawValue;
unsigned __int64 f = s1.SystemFrequency;
__int64 d1 = s1.BaseValue;
__int64 d0 = s0.BaseValue;
double numerator = (double)(n1 - n0);
double denomenator = (double)(d1 - d0);
float counterValue = (float)(( numerator / f ) / denomenator);
return counterValue;
}
// Output information about the counter sample.
void OutputSample(CounterSample s) {
Console::WriteLine(S"+++++++++++");
Console::WriteLine(S"Sample values - \r\n");
Console::WriteLine(S" BaseValue = {0}", __box(s.BaseValue));
Console::WriteLine(S" CounterFrequency = {0}", __box(s.CounterFrequency));
Console::WriteLine(S" CounterTimeStamp = {0}", __box(s.CounterTimeStamp));
Console::WriteLine(S" CounterType = {0}", __box(s.CounterType));
Console::WriteLine(S" RawValue = {0}", __box(s.RawValue));
Console::WriteLine(S" SystemFrequency = {0}", __box(s.SystemFrequency));
Console::WriteLine(S" TimeStamp = {0}", __box(s.TimeStamp));
Console::WriteLine(S" TimeStamp100nSec = {0}", __box(s.TimeStamp100nSec));
Console::WriteLine(S"++++++++++++++++++++++");
}
[DllImport(S"Kernel32.dll")]
extern bool QueryPerformanceCounter([Out] __int64* value);
bool SetupCategory() {
if (!PerformanceCounterCategory::Exists(S"AverageTimer32SampleCategory")) {
CounterCreationDataCollection* CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData* averageTimer32 = new CounterCreationData();
averageTimer32->CounterType = PerformanceCounterType::AverageTimer32;
averageTimer32->CounterName = S"AverageTimer32Sample";
CCDC->Add(averageTimer32);
// Add the base counter.
CounterCreationData* averageTimer32Base = new CounterCreationData();
averageTimer32Base->CounterType = PerformanceCounterType::AverageBase;
averageTimer32Base->CounterName = S"AverageTimer32SampleBase";
CCDC->Add(averageTimer32Base);
// Create the category.
PerformanceCounterCategory::Create(S"AverageTimer32SampleCategory",
S"Demonstrates usage of the AverageTimer32 performance counter type",
CCDC);
return(true);
} else {
Console::WriteLine(S"Category exists - AverageTimer32SampleCategory");
return(false);
}
}
void CreateCounters(PerformanceCounter*& PC, PerformanceCounter*& BPC) {
// Create the counters.
PC = new PerformanceCounter(S"AverageTimer32SampleCategory",
S"AverageTimer32Sample", false);
BPC = new PerformanceCounter(S"AverageTimer32SampleCategory",
S"AverageTimer32SampleBase", false);
PC->RawValue = 0;
BPC->RawValue = 0;
}
void CollectSamples(ArrayList* samplesList, PerformanceCounter* PC, PerformanceCounter* BPC) {
__int64 perfTime = 0;
Random* r = new Random(DateTime::Now.Millisecond);
// Loop for the samples.
for (int i = 0; i < 10; i++) {
QueryPerformanceCounter(&perfTime);
PC->RawValue = perfTime;
BPC->IncrementBy(10);
System::Threading::Thread::Sleep(1000);
Console::WriteLine(S"Next value = {0}", __box(PC->NextValue()));
samplesList->Add(__box(PC->NextSample()));
}
}
void CalculateResults(ArrayList* samplesList) {
for (int i = 0; i < (samplesList->Count - 1); i++) {
// Output the sample.
OutputSample(*__try_cast<__box CounterSample*>(samplesList->Item[i]));
OutputSample(*__try_cast<__box CounterSample*>(samplesList->Item[i+1]));
// Use .NET to calculate the counter value.
Console::WriteLine(S".NET computed counter value = {0}",
__box(CounterSample::Calculate(*__try_cast<__box CounterSample*>(samplesList->Item[i]),
*__try_cast<__box CounterSample*>(samplesList->Item[i+1]))));
// Calculate the counter value manually.
Console::WriteLine(S"My computed counter value = {0}",
__box(MyComputeCounterValue(*__try_cast<__box CounterSample*>(samplesList->Item[i]),
*__try_cast<CounterSample*>(samplesList->Item[i+1]))));
}
}
void main() {
ArrayList* samplesList = new ArrayList();
PerformanceCounter* PC;
PerformanceCounter* BPC;
SetupCategory();
CreateCounters(PC, BPC);
CollectSamples(samplesList, PC, BPC);
CalculateResults(samplesList);
}
[Visual Basic, C#, C++] ElapsedTime
Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.InteropServices
Imports Microsoft.VisualBasic
Public Class App
Private Shared PC As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
SetupCategory()
CreateCounters()
CollectSamples(samplesList)
End Sub
Private Shared Function SetupCategory() As Boolean
If Not PerformanceCounterCategory.Exists("ElapsedTimeSampleCategory") Then
Dim CCDC As New CounterCreationDataCollection()
' Add the counter.
Dim ETimeData As New CounterCreationData()
ETimeData.CounterType = PerformanceCounterType.ElapsedTime
ETimeData.CounterName = "ElapsedTimeSample"
CCDC.Add(ETimeData)
' Create the category.
PerformanceCounterCategory.Create("ElapsedTimeSampleCategory", _
"Demonstrates usage of the ElapsedTime performance counter type.", CCDC)
Return True
Else
Console.WriteLine("Category exists - ElapsedTimeSampleCategory")
Return False
End If
End Function 'SetupCategory
Private Shared Sub CreateCounters()
' Create the counter.
PC = New PerformanceCounter("ElapsedTimeSampleCategory", _
"ElapsedTimeSample", False)
End Sub 'CreateCounters
Private Shared Sub CollectSamples(samplesList As ArrayList)
Dim pcValue As Long
Dim Start As DateTime
' Initialize the counter.
QueryPerformanceCounter(pcValue)
PC.RawValue = pcValue
Start = DateTime.Now
' Loop for the samples.
Dim j As Integer
For j = 0 To 999
' 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())
samplesList.Add(PC.NextSample())
End If
' reset the counter on 100th iteration.
If j Mod 100 = 0 Then
QueryPerformanceCounter(pcValue)
PC.RawValue = pcValue
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(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
' Reads the counter information to enable setting the RawValue.
<DllImport("Kernel32.dll")> _
Public Shared Function _
QueryPerformanceCounter(ByRef value As Long) As Boolean
End Function
End Class
[C#]
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Runtime.InteropServices;
public class App
{
private static PerformanceCounter PC;
public static void Main()
{
ArrayList samplesList = new ArrayList();
SetupCategory();
CreateCounters();
CollectSamples(samplesList);
}
private static bool SetupCategory()
{
if ( !PerformanceCounterCategory.Exists("ElapsedTimeSampleCategory") )
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData ETimeData = new CounterCreationData();
ETimeData.CounterType = PerformanceCounterType.ElapsedTime;
ETimeData.CounterName = "ElapsedTimeSample";
CCDC.Add(ETimeData);
// Create the category.
PerformanceCounterCategory.Create("ElapsedTimeSampleCategory",
"Demonstrates usage of the ElapsedTime performance counter type.",
CCDC);
return(true);
}
else
{
Console.WriteLine("Category exists - ElapsedTimeSampleCategory");
return(false);
}
}
private static void CreateCounters()
{
// Create the counter.
PC = new PerformanceCounter("ElapsedTimeSampleCategory",
"ElapsedTimeSample",
false);
}
private static void CollectSamples(ArrayList samplesList)
{
long pcValue;
DateTime Start;
// Initialize the counter.
QueryPerformanceCounter(out pcValue);
PC.RawValue = pcValue;
Start = DateTime.Now;
// Loop for the samples.
for (int j = 0; j < 1000; 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());
samplesList.Add( PC.NextSample() );
}
// Reset the counter on 100th iteration.
if (j % 100 == 0)
{
QueryPerformanceCounter(out pcValue);
PC.RawValue = pcValue;
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("++++++++++++++++++++++");
}
// Reads the counter information to enable setting the RawValue.
[DllImport("Kernel32.dll")]
public static extern bool QueryPerformanceCounter(out long value);
}
[C++]
#using <mscorlib.dll>
#using <System.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;
using namespace System::Runtime::InteropServices;
void OutputSample(CounterSample s) {
Console::WriteLine(S"\r\n+++++++++++");
Console::WriteLine(S"Sample values - \r\n");
Console::WriteLine(S" BaseValue = {0}", __box(s.BaseValue));
Console::WriteLine(S" CounterFrequency = {0}", __box(s.CounterFrequency));
Console::WriteLine(S" CounterTimeStamp = {0}", __box(s.CounterTimeStamp));
Console::WriteLine(S" CounterType = {0}", __box(s.CounterType));
Console::WriteLine(S" RawValue = {0}", __box(s.RawValue));
Console::WriteLine(S" SystemFrequency = {0}", __box(s.SystemFrequency));
Console::WriteLine(S" TimeStamp = {0}", __box(s.TimeStamp));
Console::WriteLine(S" TimeStamp100nSec = {0}", __box(s.TimeStamp100nSec));
Console::WriteLine(S"++++++++++++++++++++++");
}
// Reads the counter information to enable setting the RawValue.
[DllImport(S"Kernel32.dll")]
extern bool QueryPerformanceCounter([Out] __int64* value);
bool SetupCategory() {
if (!PerformanceCounterCategory::Exists(S"ElapsedTimeSampleCategory")) {
CounterCreationDataCollection* CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData* ETimeData = new CounterCreationData();
ETimeData->CounterType = PerformanceCounterType::ElapsedTime;
ETimeData->CounterName = S"ElapsedTimeSample";
CCDC->Add(ETimeData);
// Create the category.
PerformanceCounterCategory::Create(S"ElapsedTimeSampleCategory",
S"Demonstrates usage of the ElapsedTime performance counter type.",
CCDC);
return true;
} else {
Console::WriteLine(S"Category exists - ElapsedTimeSampleCategory");
return false;
}
}
void CreateCounters(PerformanceCounter*& PC) {
// Create the counter.
PC = new PerformanceCounter(S"ElapsedTimeSampleCategory",
S"ElapsedTimeSample", false);
}
void CollectSamples(ArrayList* samplesList, PerformanceCounter* PC) {
__int64 pcValue;
DateTime Start;
// Initialize the counter.
QueryPerformanceCounter(&pcValue);
PC->RawValue = pcValue;
Start = DateTime::Now;
// Loop for the samples.
for (int j = 0; j < 1000; j++) {
// Output the values.
if ((j % 10) == 9) {
Console::WriteLine(S"NextValue() = {0}", __box(PC->NextValue()));
Console::WriteLine(S"Actual elapsed time = {0}", __box(DateTime::Now.Subtract(Start)));
OutputSample(PC->NextSample());
samplesList->Add(__box(PC->NextSample()));
}
// reset the counter on 100th iteration.
if (j % 100 == 0) {
QueryPerformanceCounter(&pcValue);
PC->RawValue = pcValue;
Start = DateTime::Now;
}
System::Threading::Thread::Sleep(50);
}
Console::WriteLine(S"Elapsed time = {0}", __box(DateTime::Now.Subtract(Start)));
}
void main() {
ArrayList* samplesList = new ArrayList();
PerformanceCounter* PC;
SetupCategory();
CreateCounters(PC);
CollectSamples(samplesList, PC);
}
[Visual Basic, C#, C++] NumberOfItems32
Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
_
Public Class NumberOfItems64
Private Shared PC As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
SetupCategory()
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End Sub 'Main
Private Shared Function SetupCategory() As Boolean
If Not PerformanceCounterCategory.Exists("NumberOfItems32SampleCategory") Then
Dim CCDC As New CounterCreationDataCollection()
' Add the counter.
Dim NOI64 As New CounterCreationData()
NOI64.CounterType = PerformanceCounterType.NumberOfItems64
NOI64.CounterName = "NumberOfItems32Sample"
CCDC.Add(NOI64)
' Create the category.
PerformanceCounterCategory.Create("NumberOfItems32SampleCategory", "Demonstrates usage of the NumberOfItems32 performance counter type.", 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 'CreateCounters
Private Shared Sub CollectSamples(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 + " = " + value))
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 'CollectSamples
Private Shared Sub CalculateResults(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))))
' 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 'CalculateResults
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
Private Shared Function MyComputeCounterValue(s0 As CounterSample, 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(s As CounterSample)
Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
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 'OutputSample
End Class 'NumberOfItems64
[C#]
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
public class NumberOfItems64
{
private static PerformanceCounter PC;
public static void Main()
{
ArrayList samplesList = new ArrayList();
SetupCategory();
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
}
private static bool SetupCategory()
{
if ( !PerformanceCounterCategory.Exists("NumberOfItems32SampleCategory") )
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData NOI64 = new CounterCreationData();
NOI64.CounterType = PerformanceCounterType.NumberOfItems64;
NOI64.CounterName = "NumberOfItems32Sample";
CCDC.Add(NOI64);
// Create the category.
PerformanceCounterCategory.Create("NumberOfItems32SampleCategory",
"Demonstrates usage of the NumberOfItems32 performance counter type.",
CCDC);
return(true);
}
else
{
Console.WriteLine("Category exists - NumberOfItems32SampleCategory");
return(false);
}
}
private static void CreateCounters()
{
// Create the counter.
PC = new PerformanceCounter("NumberOfItems32SampleCategory",
"NumberOfItems32Sample",
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("++++++++++++++++++++++");
}
}
[C++]
#using <mscorlib.dll>
#using <System.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;
float MyComputeCounterValue(CounterSample s0, CounterSample s1) {
float counterValue = (float)s1.RawValue;
return counterValue;
}
// Output information about the counter sample.
void OutputSample(CounterSample s) {
Console::WriteLine(S"\r\n+++++++++++");
Console::WriteLine(S"Sample values - \r\n");
Console::WriteLine(S" BaseValue = {0}", __box(s.BaseValue));
Console::WriteLine(S" CounterFrequency = {0}", __box(s.CounterFrequency));
Console::WriteLine(S" CounterTimeStamp = {0}", __box(s.CounterTimeStamp));
Console::WriteLine(S" CounterType = {0}", __box(s.CounterType));
Console::WriteLine(S" RawValue = {0}", __box(s.RawValue));
Console::WriteLine(S" SystemFrequency = {0}", __box(s.SystemFrequency));
Console::WriteLine(S" TimeStamp = {0}", __box(s.TimeStamp));
Console::WriteLine(S" TimeStamp100nSec = {0}", __box(s.TimeStamp100nSec));
Console::WriteLine(S"++++++++++++++++++++++");
}
bool SetupCategory() {
if (!PerformanceCounterCategory::Exists(S"NumberOfItems32SampleCategory")) {
CounterCreationDataCollection* CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData* NOI64 = new CounterCreationData();
NOI64->CounterType = PerformanceCounterType::NumberOfItems64;
NOI64->CounterName = S"NumberOfItems32Sample";
CCDC->Add(NOI64);
// Create the category.
PerformanceCounterCategory::Create(S"NumberOfItems32SampleCategory",
S"Demonstrates usage of the NumberOfItems32 performance counter type.",
CCDC);
return true;
} else {
Console::WriteLine(S"Category exists - NumberOfItems32SampleCategory");
return false;
}
}
void CreateCounters(PerformanceCounter*& PC) {
// Create the counter.
PC = new PerformanceCounter(S"NumberOfItems32SampleCategory",
S"NumberOfItems32Sample", false);
PC->RawValue=0;
}
void CollectSamples(ArrayList* samplesList, PerformanceCounter* PC) {
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(S"{0} = {1}", __box(j), __box(value));
PC->IncrementBy(value);
if ((j % 10) == 9) {
OutputSample(PC->NextSample());
samplesList->Add(__box(PC->NextSample()));
} else
Console::WriteLine();
System::Threading::Thread::Sleep(50);
}
}
void CalculateResults(ArrayList* samplesList) {
for (int i = 0; i < (samplesList->Count - 1); i++) {
// Output the sample.
OutputSample(*__try_cast<__box CounterSample*>(samplesList->Item[i]));
OutputSample(*__try_cast<__box CounterSample*>(samplesList->Item[i+1]));
// Use .NET to calculate the counter value.
Console::WriteLine(S".NET computed counter value = {0}",
__box(CounterSampleCalculator::ComputeCounterValue(*__try_cast<__box CounterSample*>(samplesList->Item[i]),
*__try_cast<__box CounterSample*>(samplesList->Item[i+1]))));
// Calculate the counter value manually.
Console::WriteLine(S"My computed counter value = {0}",
__box(MyComputeCounterValue(*__try_cast<__box CounterSample*>(samplesList->Item[i]),
*__try_cast<__box CounterSample*>(samplesList->Item[i+1]))));
}
}
void main() {
ArrayList* samplesList = new ArrayList();
PerformanceCounter* PC;
SetupCategory();
CreateCounters(PC);
CollectSamples(samplesList, PC);
CalculateResults(samplesList);
}
[Visual Basic, C#, C++] NumberOfItems64
Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
_
Public Class NumberOfItems64
Private Shared PC As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
SetupCategory()
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End Sub 'Main
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 performance counter type.", 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 'CreateCounters
Private Shared Sub CollectSamples(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 + " = " + value))
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 'CollectSamples
Private Shared Sub CalculateResults(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))))
' 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 'CalculateResults
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
Private Shared Function MyComputeCounterValue(s0 As CounterSample, 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(s As CounterSample)
Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
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 'OutputSample
End Class 'NumberOfItems64
[C#]
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
public class NumberOfItems64
{
private static PerformanceCounter PC;
public static void Main()
{
ArrayList samplesList = new ArrayList();
SetupCategory();
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.",
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("++++++++++++++++++++++");
}
}
[C++]
#using <mscorlib.dll>
#using <System.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;
float MyComputeCounterValue(CounterSample s0, CounterSample s1) {
float counterValue = (float)s1.RawValue;
return counterValue;
}
// Output information about the counter sample.
void OutputSample(CounterSample s) {
Console::WriteLine(S"\r\n+++++++++++");
Console::WriteLine(S"Sample values - \r\n");
Console::WriteLine(S" BaseValue = {0}", __box(s.BaseValue));
Console::WriteLine(S" CounterFrequency = {0}", __box(s.CounterFrequency));
Console::WriteLine(S" CounterTimeStamp = {0}", __box(s.CounterTimeStamp));
Console::WriteLine(S" CounterType = {0}", __box(s.CounterType));
Console::WriteLine(S" RawValue = {0}", __box(s.RawValue));
Console::WriteLine(S" SystemFrequency = {0}", __box(s.SystemFrequency));
Console::WriteLine(S" TimeStamp = {0}", __box(s.TimeStamp));
Console::WriteLine(S" TimeStamp100nSec = {0}", __box(s.TimeStamp100nSec));
Console::WriteLine(S"++++++++++++++++++++++");
}
bool SetupCategory() {
if (!PerformanceCounterCategory::Exists(S"NumberOfItems64SampleCategory")) {
CounterCreationDataCollection* CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData* NOI64 = new CounterCreationData();
NOI64->CounterType = PerformanceCounterType::NumberOfItems64;
NOI64->CounterName = S"NumberOfItems64Sample";
CCDC->Add(NOI64);
// Create the category.
PerformanceCounterCategory::Create(S"NumberOfItems64SampleCategory",
S"Demonstrates usage of the NumberOfItems64 performance counter type.",
CCDC);
return true;
} else {
Console::WriteLine(S"Category exists - NumberOfItems64SampleCategory");
return false;
}
}
void CreateCounters(PerformanceCounter*& PC) {
// Create the counters.
PC = new PerformanceCounter(S"NumberOfItems64SampleCategory",
S"NumberOfItems64Sample", false);
PC->RawValue=0;
}
void CollectSamples(ArrayList* samplesList, PerformanceCounter* PC) {
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(S"{0} = {1}", __box(j), __box(value));
PC->IncrementBy(value);
if ((j % 10) == 9) {
OutputSample(PC->NextSample());
samplesList->Add(__box(PC->NextSample()));
} else
Console::WriteLine();
System::Threading::Thread::Sleep(50);
}
}
void CalculateResults(ArrayList* samplesList) {
for (int i = 0; i < (samplesList->Count - 1); i++) {
// Output the sample.
OutputSample(*__try_cast<__box CounterSample*>(samplesList->Item[i]));
OutputSample(*__try_cast<__box CounterSample*>(samplesList->Item[i+1]));
// Use .NET to calculate the counter value.
Console::WriteLine(S".NET computed counter value = {0}",
__box(CounterSampleCalculator::ComputeCounterValue(
*__try_cast<__box CounterSample*>(samplesList->Item[i]),
*__try_cast<__box CounterSample*>(samplesList->Item[i+1]))));
// Calculate the counter value manually.
Console::WriteLine(S"My computed counter value = {0}",
__box(MyComputeCounterValue(
*__try_cast<__box CounterSample*>(samplesList->Item[i]),
*__try_cast<__box CounterSample*>(samplesList->Item[i+1]))));
}
}
void main() {
ArrayList* samplesList = new ArrayList();
PerformanceCounter* PC;
SetupCategory();
CreateCounters(PC);
CollectSamples(samplesList, PC);
CalculateResults(samplesList);
}
[Visual Basic, C#, C++] RateOfCountsPerSecond32
Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
_
Public Class App
Private Shared PC As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
SetupCategory()
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End Sub 'Main
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.", 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 'CreateCounters
Private Shared Sub CollectSamples(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 + " = " + value))
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 'CollectSamples
Private Shared Sub CalculateResults(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))))
' 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 'CalculateResults
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
' 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(s0 As CounterSample, 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(s As CounterSample)
Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
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 'OutputSample
End Class 'App
[C#]
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
public class App
{
private static PerformanceCounter PC;
public static void Main()
{
ArrayList samplesList = new ArrayList();
SetupCategory();
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.",
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("++++++++++++++++++++++");
}
}
[C++]
#using <mscorlib.dll>
#using <System.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// 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
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
float MyComputeCounterValue(CounterSample s0, CounterSample s1) {
float numerator = (float)(s1.RawValue - s0.RawValue);
float denomenator = (float)(s1.TimeStamp - s0.TimeStamp) / (float)s1.SystemFrequency;
float counterValue = numerator / denomenator;
return counterValue;
}
// Output information about the counter sample.
void OutputSample(CounterSample s) {
Console::WriteLine(S"\r\n+++++++++++");
Console::WriteLine(S"Sample values - \r\n");
Console::WriteLine(S" BaseValue = {0}", __box(s.BaseValue));
Console::WriteLine(S" CounterFrequency = {0}", __box(s.CounterFrequency));
Console::WriteLine(S" CounterTimeStamp = {0}", __box(s.CounterTimeStamp));
Console::WriteLine(S" CounterType = {0}", __box(s.CounterType));
Console::WriteLine(S" RawValue = {0}", __box(s.RawValue));
Console::WriteLine(S" SystemFrequency = {0}", __box(s.SystemFrequency));
Console::WriteLine(S" TimeStamp = {0}", __box(s.TimeStamp));
Console::WriteLine(S" TimeStamp100nSec = {0}", __box(s.TimeStamp100nSec));
Console::WriteLine(S"++++++++++++++++++++++");
}
bool SetupCategory() {
if (!PerformanceCounterCategory::Exists(S"RateOfCountsPerSecond32SampleCategory")) {
CounterCreationDataCollection* CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData* rateOfCounts32 = new CounterCreationData();
rateOfCounts32->CounterType = PerformanceCounterType::RateOfCountsPerSecond32;
rateOfCounts32->CounterName = S"RateOfCountsPerSecond32Sample";
CCDC->Add(rateOfCounts32);
// Create the category.
PerformanceCounterCategory::Create(S"RateOfCountsPerSecond32SampleCategory",
S"Demonstrates usage of the RateOfCountsPerSecond32 performance counter type.",
CCDC);
return true;
} else {
Console::WriteLine(S"Category exists - RateOfCountsPerSecond32SampleCategory");
return false;
}
}
void CreateCounters(PerformanceCounter*& PC) {
// Create the counter.
PC = new PerformanceCounter(S"RateOfCountsPerSecond32SampleCategory",
S"RateOfCountsPerSecond32Sample", false);
PC->RawValue=0;
}
void CollectSamples(ArrayList* samplesList, PerformanceCounter* PC) {
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(S"{0} = {1}", __box(j), __box(value));
if ((j % 10) == 9) {
Console::WriteLine(S"; NextValue() = {0}", __box(PC->NextValue()));
OutputSample(PC->NextSample());
samplesList->Add(__box(PC->NextSample()));
} else
Console::WriteLine();
System::Threading::Thread::Sleep(50);
}
}
void CalculateResults(ArrayList* samplesList) {
for (int i = 0; i < (samplesList->Count - 1); i++) {
// Output the sample.
OutputSample(*__try_cast<__box CounterSample*>(samplesList->Item[i]));
OutputSample(*__try_cast<__box CounterSample*>(samplesList->Item[i+1]));
// Use .NET to calculate the counter value.
Console::WriteLine(S".NET computed counter value = {0}",
__box(CounterSampleCalculator::ComputeCounterValue(
*__try_cast<__box CounterSample*>(samplesList->Item[i]),
*__try_cast<__box CounterSample*>(samplesList->Item[i+1]))));
// Calculate the counter value manually.
Console::WriteLine(S"My computed counter value = {0}",
__box(MyComputeCounterValue(
*__try_cast<__box CounterSample*>(samplesList->Item[i]),
*__try_cast<__box CounterSample*>(samplesList->Item[i+1]))));
}
}
void main() {
ArrayList* samplesList = new ArrayList();
PerformanceCounter* PC;
SetupCategory();
CreateCounters(PC);
CollectSamples(samplesList, PC);
CalculateResults(samplesList);
}
[Visual Basic, C#, C++] RateOfCountsPerSecond64
Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
_
Public Class App
Private Shared PC As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
SetupCategory()
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End Sub 'Main
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.", 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 'CreateCounters
Private Shared Sub CollectSamples(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 + " = " + value))
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 'CollectSamples
Private Shared Sub CalculateResults(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))))
' 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 'CalculateResults
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
' 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(s0 As CounterSample, 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(s As CounterSample)
Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
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 'OutputSample
End Class 'App
[C#]
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
public class App
{
private static PerformanceCounter PC;
public static void Main()
{
ArrayList samplesList = new ArrayList();
SetupCategory();
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.",
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("++++++++++++++++++++++");
}
}
[C++]
#using <mscorlib.dll>
#using <System.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// 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
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
float MyComputeCounterValue(CounterSample s0, CounterSample s1) {
float numerator = (float)(s1.RawValue - s0.RawValue);
float denomenator = (float)(s1.TimeStamp - s0.TimeStamp) / (float)s1.SystemFrequency;
float counterValue = numerator / denomenator;
return counterValue;
}
void OutputSample(CounterSample s) {
Console::WriteLine(S"\r\n+++++++++++");
Console::WriteLine(S"Sample values - \r\n");
Console::WriteLine(S" BaseValue = {0}", __box(s.BaseValue));
Console::WriteLine(S" CounterFrequency = {0}", __box(s.CounterFrequency));
Console::WriteLine(S" CounterTimeStamp = {0}", __box(s.CounterTimeStamp));
Console::WriteLine(S" CounterType = {0}", __box(s.CounterType));
Console::WriteLine(S" RawValue = {0}", __box(s.RawValue));
Console::WriteLine(S" SystemFrequency = {0}", __box(s.SystemFrequency));
Console::WriteLine(S" TimeStamp = {0}", __box(s.TimeStamp));
Console::WriteLine(S" TimeStamp100nSec = {0}", __box(s.TimeStamp100nSec));
Console::WriteLine(S"++++++++++++++++++++++");
}
bool SetupCategory() {
if (!PerformanceCounterCategory::Exists(S"RateOfCountsPerSecond64SampleCategory")) {
CounterCreationDataCollection* CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData* rateOfCounts64 = new CounterCreationData();
rateOfCounts64->CounterType = PerformanceCounterType::RateOfCountsPerSecond64;
rateOfCounts64->CounterName = S"RateOfCountsPerSecond64Sample";
CCDC->Add(rateOfCounts64);
// Create the category.
PerformanceCounterCategory::Create(S"RateOfCountsPerSecond64SampleCategory",
S"Demonstrates usage of the RateOfCountsPerSecond64 performance counter type.",
CCDC);
return true;
} else {
Console::WriteLine(S"Category exists - RateOfCountsPerSecond64SampleCategory");
return false;
}
}
void CreateCounters(PerformanceCounter*& PC) {
// Create the counter.
PC = new PerformanceCounter(S"RateOfCountsPerSecond64SampleCategory",
S"RateOfCountsPerSecond64Sample", false);
PC->RawValue=0;
}
void CollectSamples(ArrayList* samplesList, PerformanceCounter* PC) {
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(S"{0} = {1}", __box(j), __box(value));
if ((j % 10) == 9) {
Console::WriteLine(S"; NextValue() = {0}", __box(PC->NextValue()));
OutputSample(PC->NextSample());
samplesList->Add(__box(PC->NextSample()));
} else
Console::WriteLine();
System::Threading::Thread::Sleep(50);
}
}
void CalculateResults(ArrayList* samplesList) {
for (int i = 0; i < (samplesList->Count - 1); i++) {
// Output the sample.
OutputSample(*__try_cast<__box CounterSample*>(samplesList->Item[i]));
OutputSample(*__try_cast<__box CounterSample*>(samplesList->Item[i+1]));
// Use .NET to calculate the counter value.
Console::WriteLine(S".NET computed counter value = {0}",
__box(CounterSampleCalculator::ComputeCounterValue(
*__try_cast<__box CounterSample*>(samplesList->Item[i]),
*__try_cast<__box CounterSample*>(samplesList->Item[i+1]))));
// Calculate the counter value manually.
Console::WriteLine(S"My computed counter value = {0}",
__box(MyComputeCounterValue(
*__try_cast<__box CounterSample*>(samplesList->Item[i]),
*__try_cast<__box CounterSample*>(samplesList->Item[i+1]))));
}
}
void main() {
ArrayList* samplesList = new ArrayList();
PerformanceCounter* PC;
SetupCategory();
CreateCounters(PC);
CollectSamples(samplesList, PC);
CalculateResults(samplesList);
}
[Visual Basic, C#, C++] RawFraction
Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
_
Public Class App
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 'Main
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.", 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 'CreateCounters
Private Shared Sub CollectSamples(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 + " = " + 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 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 'CollectSamples
Private Shared Sub CalculateResults(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))))
' Calculate the counter value manually.
Console.WriteLine(("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample))))
Next i
End Sub 'CalculateResults
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
' 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(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(s As CounterSample)
Console.WriteLine("+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
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 'OutputSample
End Class 'App
[C#]
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
public class App
{
private static PerformanceCounter PC;
private static PerformanceCounter BPC;
public static void Main()
{
ArrayList samplesList = new ArrayList();
SetupCategory();
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.",
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("++++++++++++++++++++++");
}
}
[C++]
#using <mscorlib.dll>
#using <System.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// 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
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
float MyComputeCounterValue(CounterSample rfSample) {
float numerator = (float)rfSample.RawValue;
float denomenator = (float)rfSample.BaseValue;
float counterValue = (numerator / denomenator) * 100;
return counterValue;
}
// Output information about the counter sample.
void OutputSample(CounterSample s) {
Console::WriteLine(S"+++++++++++");
Console::WriteLine(S"Sample values - \r\n");
Console::WriteLine(S" BaseValue = {0}", __box(s.BaseValue));
Console::WriteLine(S" CounterFrequency = {0}", __box(s.CounterFrequency));
Console::WriteLine(S" CounterTimeStamp = {0}", __box(s.CounterTimeStamp));
Console::WriteLine(S" CounterType = {0}", __box(s.CounterType));
Console::WriteLine(S" RawValue = {0}", __box(s.RawValue));
Console::WriteLine(S" SystemFrequency = {0}", __box(s.SystemFrequency));
Console::WriteLine(S" TimeStamp = {0}", __box(s.TimeStamp));
Console::WriteLine(S" TimeStamp100nSec = {0}", __box(s.TimeStamp100nSec));
Console::WriteLine(S"++++++++++++++++++++++");
}
bool SetupCategory() {
if (!PerformanceCounterCategory::Exists(S"RawFractionSampleCategory")) {
CounterCreationDataCollection* CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData* rf = new CounterCreationData();
rf->CounterType = PerformanceCounterType::RawFraction;
rf->CounterName = S"RawFractionSample";
CCDC->Add(rf);
// Add the base counter.
CounterCreationData* rfBase = new CounterCreationData();
rfBase->CounterType = PerformanceCounterType::RawBase;
rfBase->CounterName = S"RawFractionSampleBase";
CCDC->Add(rfBase);
// Create the category.
PerformanceCounterCategory::Create(S"RawFractionSampleCategory",
S"Demonstrates usage of the RawFraction performance counter type.",
CCDC);
return true;
} else {
Console::WriteLine(S"Category exists - RawFractionSampleCategory");
return false;
}
}
void CreateCounters(PerformanceCounter*& PC, PerformanceCounter*& BPC) {
// Create the counters.
PC = new PerformanceCounter(S"RawFractionSampleCategory",
S"RawFractionSample", false);
BPC = new PerformanceCounter(S"RawFractionSampleCategory",
S"RawFractionSampleBase", false);
PC->RawValue=0;
BPC->RawValue=0;
}
void CollectSamples(ArrayList* samplesList, PerformanceCounter* PC, PerformanceCounter* BPC) {
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(S"{0} = {1}", __box(j), __box(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(S"; NextValue() = {0}", __box(PC->NextValue()));
OutputSample(PC->NextSample());
samplesList->Add(__box(PC->NextSample()));
} else
Console::WriteLine();
System::Threading::Thread::Sleep(50);
}
}
void CalculateResults(ArrayList* samplesList) {
for (int i = 0; i < samplesList->Count; i++) {
// Output the sample.
OutputSample(*__try_cast<__box CounterSample*>(samplesList->Item[i]));
// Use .NET to calculate the counter value.
Console::WriteLine(S".NET computed counter value = {0}",
__box(CounterSampleCalculator::ComputeCounterValue(
*__try_cast<__box CounterSample*>(samplesList->Item[i]))));
// Calculate the counter value manually.
Console::WriteLine(S"My computed counter value = {0}",
__box(MyComputeCounterValue(
*__try_cast<__box CounterSample*>(samplesList->Item[i]))));
}
}
void main() {
ArrayList* samplesList = new ArrayList();
PerformanceCounter* PC;
PerformanceCounter* BPC;
SetupCategory();
CreateCounters(PC, BPC);
CollectSamples(samplesList, PC, BPC);
CalculateResults(samplesList);
}
[JScript] JScript のサンプルはありません。Visual Basic、C#、および C++ のサンプルを表示するには、このページの左上隅にある言語のフィルタ ボタン .gif)
をクリックします。
必要条件
名前空間: System.Diagnostics
プラットフォーム: Windows NT Server 4.0, Windows NT Workstation 4.0, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 ファミリ
アセンブリ: System (System.dll 内)