We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Diagnostics \ CounterSampleCalculator

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright file="CounterSampleCalculator.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  16. namespace System.Diagnostics
  17. {
  18.     using System.Threading;
  19.     using System;
  20.     using System.ComponentModel;
  21.     using Microsoft.Win32;
  22.     using System.Text;
  23.     using System.IO;
  24.     using System.Runtime.InteropServices;
  25.     using System.Security.Permissions;
  26.     using System.Globalization;
  27.     using System.Runtime.Versioning;
  28.    
  29.     /// <devdoc>
  30.     /// Set of utility functions for interpreting the counter data
  31.     /// NOTE: most of this code was taken and ported from counters.c (PerfMon source code)
  32.     /// </devdoc>
  33.     public static class CounterSampleCalculator
  34.     {
  35.         static bool perfCounterDllLoaded = false;
  36.        
  37.         /// <devdoc>
  38.         /// Converts 100NS elapsed time to fractional seconds
  39.         /// </devdoc>
  40.         /// <internalonly/>
  41.         private static float GetElapsedTime(CounterSample oldSample, CounterSample newSample)
  42.         {
  43.             float eSeconds;
  44.             float eDifference;
  45.            
  46.             if (newSample.RawValue == 0) {
  47.                 // no data [start time = 0] so return 0
  48.                 return 0f;
  49.             }
  50.             else {
  51.                 float eFreq;
  52.                 eFreq = (float)(ulong)oldSample.CounterFrequency;
  53.                
  54.                 if (oldSample.UnsignedRawValue >= (ulong)newSample.CounterTimeStamp || eFreq <= 0f)
  55.                     return 0f;
  56.                
  57.                 // otherwise compute difference between current time and start time
  58.                 eDifference = (float)((ulong)newSample.CounterTimeStamp - oldSample.UnsignedRawValue);
  59.                
  60.                 // convert to fractional seconds using object counter
  61.                 eSeconds = eDifference / eFreq;
  62.                
  63.                 return eSeconds;
  64.             }
  65.         }
  66.        
  67.         /// <devdoc>
  68.         /// Computes the calculated value given a raw counter sample.
  69.         /// </devdoc>
  70.         public static float ComputeCounterValue(CounterSample newSample)
  71.         {
  72.             return ComputeCounterValue(CounterSample.Empty, newSample);
  73.         }
  74.        
  75.         /// <devdoc>
  76.         /// Computes the calculated value given a raw counter sample.
  77.         /// </devdoc>
  78.         public static float ComputeCounterValue(CounterSample oldSample, CounterSample newSample)
  79.         {
  80.             int newCounterType = (int)newSample.CounterType;
  81.             if (oldSample.SystemFrequency == 0) {
  82.                 if ((newCounterType != NativeMethods.PERF_RAW_FRACTION) && (newCounterType != NativeMethods.PERF_COUNTER_RAWCOUNT) && (newCounterType != NativeMethods.PERF_COUNTER_RAWCOUNT_HEX) && (newCounterType != NativeMethods.PERF_COUNTER_LARGE_RAWCOUNT) && (newCounterType != NativeMethods.PERF_COUNTER_LARGE_RAWCOUNT_HEX) && (newCounterType != NativeMethods.PERF_COUNTER_MULTI_BASE)) {
  83.                    
  84.                     // Since oldSample has a system frequency of 0, this means the newSample is the first sample
  85.                     // on a two sample calculation. Since we can't do anything with it, return 0.
  86.                     return 0f;
  87.                 }
  88.             }
  89.             else if (oldSample.CounterType != newSample.CounterType) {
  90.                 throw new InvalidOperationException(SR.GetString(SR.MismatchedCounterTypes));
  91.             }
  92.            
  93.             if (newCounterType == NativeMethods.PERF_ELAPSED_TIME)
  94.                 return (float)GetElapsedTime(oldSample, newSample);
  95.            
  96.             NativeMethods.PDH_RAW_COUNTER newPdhValue = new NativeMethods.PDH_RAW_COUNTER();
  97.             NativeMethods.PDH_RAW_COUNTER oldPdhValue = new NativeMethods.PDH_RAW_COUNTER();
  98.            
  99.             FillInValues(oldSample, newSample, oldPdhValue, newPdhValue);
  100.            
  101.             LoadPerfCounterDll();
  102.            
  103.             NativeMethods.PDH_FMT_COUNTERVALUE pdhFormattedValue = new NativeMethods.PDH_FMT_COUNTERVALUE();
  104.             long timeBase = newSample.SystemFrequency;
  105.             int result = SafeNativeMethods.FormatFromRawValue((uint)newCounterType, NativeMethods.PDH_FMT_DOUBLE | NativeMethods.PDH_FMT_NOSCALE | NativeMethods.PDH_FMT_NOCAP100, ref timeBase, newPdhValue, oldPdhValue, pdhFormattedValue);
  106.            
  107.             if (result != NativeMethods.ERROR_SUCCESS) {
  108.                 // If the numbers go negative, just return 0. This better matches the old behavior.
  109.                 if (result == NativeMethods.PDH_CALC_NEGATIVE_VALUE || result == NativeMethods.PDH_CALC_NEGATIVE_DENOMINATOR || result == NativeMethods.PDH_NO_DATA)
  110.                     return 0;
  111.                 else
  112.                     throw new Win32Exception(result, SR.GetString(SR.PerfCounterPdhError, result.ToString("x", CultureInfo.InvariantCulture)));
  113.             }
  114.            
  115.             return (float)pdhFormattedValue.data;
  116.            
  117.         }
  118.        
  119.        
  120.         // This method figures out which values are supposed to go into which structures so that PDH can do the
  121.         // calculation for us. This was ported from Window's cutils.c
  122.         private static void FillInValues(CounterSample oldSample, CounterSample newSample, NativeMethods.PDH_RAW_COUNTER oldPdhValue, NativeMethods.PDH_RAW_COUNTER newPdhValue)
  123.         {
  124.             int newCounterType = (int)newSample.CounterType;
  125.            
  126.             switch (newCounterType) {
  127.                 case NativeMethods.PERF_COUNTER_COUNTER:
  128.                 case NativeMethods.PERF_COUNTER_QUEUELEN_TYPE:
  129.                 case NativeMethods.PERF_SAMPLE_COUNTER:
  130.                 case NativeMethods.PERF_OBJ_TIME_TIMER:
  131.                 case NativeMethods.PERF_COUNTER_OBJ_TIME_QUEUELEN_TYPE:
  132.                     newPdhValue.FirstValue = newSample.RawValue;
  133.                     newPdhValue.SecondValue = newSample.TimeStamp;
  134.                    
  135.                     oldPdhValue.FirstValue = oldSample.RawValue;
  136.                     oldPdhValue.SecondValue = oldSample.TimeStamp;
  137.                     break;
  138.                 case NativeMethods.PERF_COUNTER_100NS_QUEUELEN_TYPE:
  139.                    
  140.                     newPdhValue.FirstValue = newSample.RawValue;
  141.                     newPdhValue.SecondValue = newSample.TimeStamp100nSec;
  142.                    
  143.                     oldPdhValue.FirstValue = oldSample.RawValue;
  144.                     oldPdhValue.SecondValue = oldSample.TimeStamp100nSec;
  145.                     break;
  146.                 case NativeMethods.PERF_COUNTER_TIMER:
  147.                 case NativeMethods.PERF_COUNTER_TIMER_INV:
  148.                 case NativeMethods.PERF_COUNTER_BULK_COUNT:
  149.                 case NativeMethods.PERF_COUNTER_LARGE_QUEUELEN_TYPE:
  150.                 case NativeMethods.PERF_COUNTER_MULTI_TIMER:
  151.                 case NativeMethods.PERF_COUNTER_MULTI_TIMER_INV:
  152.                    
  153.                     newPdhValue.FirstValue = newSample.RawValue;
  154.                     newPdhValue.SecondValue = newSample.TimeStamp;
  155.                    
  156.                     oldPdhValue.FirstValue = oldSample.RawValue;
  157.                     oldPdhValue.SecondValue = oldSample.TimeStamp;
  158.                     if (newCounterType == NativeMethods.PERF_COUNTER_MULTI_TIMER || newCounterType == NativeMethods.PERF_COUNTER_MULTI_TIMER_INV) {
  159.                         // this is to make PDH work like PERFMON for
  160.                         // this counter type
  161.                         newPdhValue.FirstValue *= (uint)newSample.CounterFrequency;
  162.                         if (oldSample.CounterFrequency != 0) {
  163.                             oldPdhValue.FirstValue *= (uint)oldSample.CounterFrequency;
  164.                         }
  165.                     }
  167.                    
  168.                     if ((newCounterType & NativeMethods.PERF_MULTI_COUNTER) == NativeMethods.PERF_MULTI_COUNTER) {
  169.                         newPdhValue.MultiCount = (int)newSample.BaseValue;
  170.                         oldPdhValue.MultiCount = (int)oldSample.BaseValue;
  171.                     }
  173.                    
  174.                    
  175.                     break;
  176.                 case NativeMethods.PERF_COUNTER_RAWCOUNT:
  177.                 case NativeMethods.PERF_COUNTER_RAWCOUNT_HEX:
  178.                 case NativeMethods.PERF_COUNTER_DELTA:
  179.                 case NativeMethods.PERF_COUNTER_LARGE_RAWCOUNT:
  180.                 case NativeMethods.PERF_COUNTER_LARGE_RAWCOUNT_HEX:
  181.                 case NativeMethods.PERF_COUNTER_LARGE_DELTA:
  182.                     //
  183.                     // These counters do not use any time reference
  184.                     //
  185.                     newPdhValue.FirstValue = newSample.RawValue;
  186.                     newPdhValue.SecondValue = 0;
  187.                    
  188.                     oldPdhValue.FirstValue = oldSample.RawValue;
  189.                     oldPdhValue.SecondValue = 0;
  190.                     break;
  191.                 case NativeMethods.PERF_100NSEC_TIMER:
  192.                 case NativeMethods.PERF_100NSEC_TIMER_INV:
  193.                 case NativeMethods.PERF_100NSEC_MULTI_TIMER:
  194.                 case NativeMethods.PERF_100NSEC_MULTI_TIMER_INV:
  195.                     //
  196.                     // These counters use the 100 Ns time base in thier calculation
  197.                     //
  198.                     newPdhValue.FirstValue = newSample.RawValue;
  199.                     newPdhValue.SecondValue = newSample.TimeStamp100nSec;
  200.                    
  201.                     oldPdhValue.FirstValue = oldSample.RawValue;
  202.                     oldPdhValue.SecondValue = oldSample.TimeStamp100nSec;
  203.                     if ((newCounterType & NativeMethods.PERF_MULTI_COUNTER) == NativeMethods.PERF_MULTI_COUNTER) {
  204.                         newPdhValue.MultiCount = (int)newSample.BaseValue;
  205.                         oldPdhValue.MultiCount = (int)oldSample.BaseValue;
  206.                     }
  208.                     break;
  209.                 case NativeMethods.PERF_SAMPLE_FRACTION:
  210.                 case NativeMethods.PERF_RAW_FRACTION:
  211.                 case NativeMethods.PERF_LARGE_RAW_FRACTION:
  212.                 case NativeMethods.PERF_PRECISION_SYSTEM_TIMER:
  213.                 case NativeMethods.PERF_PRECISION_100NS_TIMER:
  214.                 case NativeMethods.PERF_PRECISION_OBJECT_TIMER:
  215.                 case NativeMethods.PERF_AVERAGE_TIMER:
  216.                 case NativeMethods.PERF_AVERAGE_BULK:
  217.                     //
  218.                     // These counters use two data points
  219.                     //
  220.                     newPdhValue.FirstValue = newSample.RawValue;
  221.                     newPdhValue.SecondValue = newSample.BaseValue;
  222.                    
  223.                     oldPdhValue.FirstValue = oldSample.RawValue;
  224.                     oldPdhValue.SecondValue = oldSample.BaseValue;
  225.                     break;
  226.                 default:
  227.                    
  228.                     // an unidentified counter was returned so
  229.                     newPdhValue.FirstValue = 0;
  230.                     newPdhValue.SecondValue = 0;
  231.                    
  232.                     oldPdhValue.FirstValue = 0;
  233.                     oldPdhValue.SecondValue = 0;
  234.                     break;
  235.             }
  236.         }
  237.        
  238.         [ResourceExposure(ResourceScope.None)]
  239.         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
  240.         private static void LoadPerfCounterDll()
  241.         {
  242.             if (perfCounterDllLoaded)
  243.                 return;
  244.            
  245.             new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert();
  246.            
  247.             // load perfcounter.dll manually, since it usually isn't on the path.
  248.             IntPtr mscorwksHandle = NativeMethods.GetModuleHandle("mscorwks.dll");
  249.             if (mscorwksHandle == IntPtr.Zero)
  250.                 throw new Win32Exception();
  251.            
  252.             int size = 132;
  253.             StringBuilder filename;
  254.             using (Process currentProc = Process.GetCurrentProcess()) {
  255.                 HandleRef procHandleRef = new HandleRef(null, currentProc.Handle);
  256.                 HandleRef mscorwksHandleRef = new HandleRef(null, mscorwksHandle);
  257.                 do {
  258.                     size *= 2;
  259.                     filename = new StringBuilder(size);
  260.                     size = NativeMethods.GetModuleFileNameEx(procHandleRef, mscorwksHandleRef, filename, size);
  261.                     if (size == 0)
  262.                         throw new Win32Exception();
  263.                 }
  264.                 while (size == filename.Capacity);
  265.             }
  266.            
  267.             string installPath = Path.GetDirectoryName(filename.ToString());
  268.             string perfcounterPath = Path.Combine(installPath, "perfcounter.dll");
  269.             if (SafeNativeMethods.LoadLibrary(perfcounterPath) == IntPtr.Zero)
  270.                 throw new Win32Exception();
  271.            
  272.             perfCounterDllLoaded = true;
  273.         }
  274.     }
  275. }

Developer Fusion