Simplest Possible Performance Counter Example

Question

What is the smallest amount of C# code to get a performance counter up and running?

I simply want to measure the number of CPU cycles and/or time between two points in my code. I've skimmed through all the waffle on the web but it seems like WAY more code than is necessary for such a trivial task. I just want to get a quick measurement up and running and concentrate more on what I'm working on.

Answer 1

I don't think you need a performance counter for that. Do you need more than the timing you can get from StopWatch ? It is very accurate.

Stopwatch watch = Stopwatch.StartNew();

// Do work

watch.Stop();
// elapsed time is in watch.Elapsed

However, to answer the question you actually asked: If you just want to query existing counters, it is in fact quite simple. Here is a full example:

using System;
using System.Diagnostics;
using System.Linq;

static class Test
{
    static void Main()
    {
        var processorCategory = PerformanceCounterCategory.GetCategories()
            .FirstOrDefault(cat => cat.CategoryName == "Processor");
        var countersInCategory = processorCategory.GetCounters("_Total");

        DisplayCounter(countersInCategory.First(cnt => cnt.CounterName == "% Processor Time"));
    }

    private static void DisplayCounter(PerformanceCounter performanceCounter)
    {
        while (!Console.KeyAvailable)
        {
            Console.WriteLine("{0}\t{1} = {2}",
                performanceCounter.CategoryName, performanceCounter.CounterName, performanceCounter.NextValue());
            System.Threading.Thread.Sleep(1000);
        }
    }
}

Of course, the process will need appropiate permissions to access the performance counters you need.

Answer 2

I like something that can take any code block and wrap it with stopwatch profiling code to measure time spent executing it:

    using System.Diagnostics;
    using System.Threading;

    public static T Profile<T>(Func<T> codeBlock, string description = "")
    {
        Stopwatch stopWatch = new Stopwatch();
        stopWatch.Start();
        T res = codeBlock();
        stopWatch.Stop();
        TimeSpan ts = stopWatch.Elapsed;
        const double thresholdSec = 2;
        double elapsed = ts.TotalSeconds;
        if(elapsed > thresholdSec)
          System.Diagnostics.Debug.Write(description + " code was too slow! It took " +
             elapsed + " second(s).");
        return res;
    }

Then call it like that:

    Profile(() => MyObj.MySlowMethod());

or:

    Profile(() => MyObj.MySlowMethod(), "I can explain why");

Answer 3

There is no trivial way to get this up and running in .NET. However, the simplest way I've found is to build on top of the Enterprise Library which provides some out of the box capabilities for working with performance counters. For example: the Performance Counter Handler

The Enterprise Library also gives you some capabilities for much more easily managing the installation of performance counters.

Additionally, it let's you build on top of it so, you can create an AvergeTimeMeter which allows you to just do this:

private static EnterpriseLibraryPerformanceCounter averageRequestTimeCounter = PerformanceCounterManager.GetEnterpriseLibraryCounter(MadPerformanceCountersListener.AverageRequestTime);
private static EnterpriseLibraryPerformanceCounter averageRequestTimeCounterBase = PerformanceCounterManager.GetEnterpriseLibraryCounter(MadPerformanceCountersListener.AverageRequestTimeBase);

public void DoSomethingWeWantToMonitor()
{
    using (new AverageTimeMeter(averageRequestTimeCounter, averageRequestTimeCounterBase))
    {
        // code here that you want to perf mon
    }
}

This allows you to simply encapsulate the code you want to monitor in a using block - and concentrate on the code you actually want to work on rather than worrying about all the performance counter infrastructure.

To do this, you'll create a re-usable AverageTimeMeter class like this:

public sealed class AverageTimeMeter : IDisposable
{
    private EnterpriseLibraryPerformanceCounter averageCounter;
    private EnterpriseLibraryPerformanceCounter baseCounter;
    private Stopwatch stopWatch;
    private string instanceName;

    public AverageTimeMeter(EnterpriseLibraryPerformanceCounter averageCounter, EnterpriseLibraryPerformanceCounter baseCounter, string instanceName = null)
    {
        this.stopWatch = new Stopwatch();
        this.averageCounter = averageCounter;
        this.baseCounter = baseCounter;
        this.instanceName = instanceName;
        this.stopWatch.Start();
    }

    public void Dispose()
    {
        this.stopWatch.Stop();
        if (this.baseCounter != null)
        {
            this.baseCounter.Increment();
        }

        if (this.averageCounter != null)
        {
            if (string.IsNullOrEmpty(this.instanceName))
            {
                this.averageCounter.IncrementBy(this.stopWatch.ElapsedTicks);
            }
            else
            {
                this.averageCounter.SetValueFor(this.instanceName, this.averageCounter.Value + this.stopWatch.ElapsedTicks);
            }
        }
    }

}

You have to register your performance counters (shown in the EntLib examples) but this should get your started.