How to Get CPU Usage of Processes and Threads

• Download demo project (.NET 2.0) - 13.6 KB
• Download source (.NET 1.1) - 18.1 KB

Background

My journey began when I had to write a Task Manager look alike that also had some netstat features. I searched the web for methods of getting the CPU usage but the best I could find was only advices for using PerformanceCounter("Processor","% Process Time",ProcessName) for monitoring the usage value. I tried it and it's a good method as long as you use only a few (1-3) PerformanceCounters because it consumes a lot of CPU which got me to a usage of 6% - 18% for my own Task Manager for just the refresh operation every 2 seconds.

CPU Usage Calculation Concept

For calculating the CPU usage of processes, we need to get a value that indicates for how much time they have used the processor in a certain period of time, this value is equal to the sum of the time that the kernel and the user have spent on these processes, I will demonstrate two ways to achieve this value:

• the API way - using the GetSystemTimes() function
• the managed way - using the System.Diagnostics namespace

After we get this value, we keep it for the next run (the refresh time is usually 1.5 seconds), we then decrease the new value from the old value and divide it by the refresh time. I know it sounds complicated, the following code will explain it better:

private void CalcCpu()
{
    // refresh delay 1.5 seconds    
    int RefreshInterval = 1500; 
    // keeps the previous usage value.
    long OldRawUsageValue = GetCurrentUsageValue(); 
    // keeps the current usage value.
    long NewRawUsageValue;
    // holds the cpu usage in a friendly reading way. 
    string CpuUsage; 

    Thread.Sleep(RefreshInterval);

    while (KeepCalculation)
    {
        NewRawUsageValue = GetCurrentUsageValue();
        CpuUsage = ((int)((NewRawUsageValue - OldRawUsageValue) / 
                                  RefreshInterval)).ToString() + "%";
        Thread.Sleep(RefreshInterval);
        OldRawUsageValue = NewRawUsageValue;
    }
}

The API Approach

After I was left with some bitter taste of the .NET 2.0 changes and some of the comments I got here, I decided to write an API version for this. Surprisingly, I found many C++ articles on this and even some old VB code. I migrated the code by following ejor's article Get CPU Usage with GetSystemTimes. My big thanks go to PInvoke for their contribution to the translated API availability which helped me a lot. This API version does not include the CPU usage of threads (the code is very similar to that of process code); I was too lazy to write it.

For getting the CPU usage, using the API approach, we need a function called GetProcessTimes. This function gets us four parameters CreationTime, ExitTime, KernelTime and UserTime. We won't use the first two, the other two (KernelTime and UserTime) are equivalent to the managed version Process.TotalProcessorTime.TotalMilliseconds, after realizing that this pretty much goes the same way as the managed version, just that it is a bit more difficult to get the GetSystemTimes to work than to use the System.Diagnostic.Process class, but the benefit comes in the way of better performance.

.NET 2.0 Style

If you have tried running the old version on .NET 2.0, you'll be surprised to see that what was good enough for .NET 1.1 is not good for .NET 2.0. Well, I don't know why for some reason Microsoft decided not to allow gathering any information about the system idle process (which was allowed in .NET 1.1). Well, for a quick solution, I used a PerformanceCounter, but there is only one instance of it so it keeps the overall performance pretty satisfying. What we do here is use the PerformanceCounter to monitor the idle process CPU usage as we know that the real CPU usage is 100% - idle CPU usage% (you can also do this by monitoring the "_Total" value and 100 - _Total == idle CPU usage).

private static void UpdateCpuUsagePercent(
                           Process[] NewProcessList)
{
    double Total = 0;
    ProcessInfo TempProcessInfo;
    TotalCpuUsageValue = TotalCpuUsage.NextValue();

    foreach (Process TempProcess in NewProcessList)
    {
        if (TempProcess.Id == 0) continue;
        TempProcessInfo = ProcessInfoByID(TempProcess.Id);
        if (TempProcessInfo == PROCESS_INFO_NOT_FOUND)
          Total += 
            TempProcess.TotalProcessorTime.TotalMilliseconds;
        else
          Total += TempProcess.TotalProcessorTime.TotalMilliseconds - 
                                          TempProcessInfo.OldCpuUsage;
    }
    CpuUsagePercent = Total / (100 - TotalCpuUsageValue);
}

The New Method

I came up with a new way of calculating 1% of the CPU usage by having it depend on some specific process. What we do here is get all the CPU usage raw (double) values and what we get is the total CPU usage. By dividing this with 100, we get 1%. This method is better because it's not process specific of course, and it even cancels the single PerformanceCounter of the last solution:

private static void UpdateCpuUsagePercent(
                            Process[] NewProcessList)
{
   double Total = 0;
   ProcessInfo TempProcessInfo;

   foreach (Process TempProcess in NewProcessList)
   {
      TempProcessInfo = ProcessInfoByID(TempProcess.Id);
      if (TempProcessInfo == PROCESS_INFO_NOT_FOUND)
         Total += TempProcess.TotalProcessorTime.TotalMilliseconds;
      else
         Total += TempProcess.TotalProcessorTime.TotalMilliseconds - 
                                         TempProcessInfo.OldCpuUsage;
   }
   CpuUsagePercent = Total / 100;
}

The Old Method

After breaking my head for two days and thinking of creative ways to achieve a better way to do this, I decided to use a single PerformanceCounter to get some value that will help me calculate the rest of the values.

The Solution

I created a PerformanceCounter for the CPU idle process and got its usage %, then I used Process.GetProcesses() to get a Process[] array. The Process class has a property called TotalProcessorTime.TotalMilliseconds which gives us how much time the processor has spent on this process. I save this value and the next time I check it (every 1.5 seconds - the refresh rate), I decrease it from the last value giving me the raw output of how much millisecond equals the idle CPU usage %.

Now by dividing this value with the CPU usage %, I get how much millisecond is 1% of CPU:

private static void UpdateCpuUsagePercent()
{
    long NewIdleCpuUsage = (long) 
      Process.GetProcessById(0).TotalProcessorTime.TotalMilliseconds;

    CpuUsagePercent = IdleCpuUsage.NextValue();
    CpuUsagePercent = 
        (NewIdleCpuUsage - OldIdleCpuUsage) / CpuUsagePercent;
    OldIdleCpuUsage = NewIdleCpuUsage;
}

Knowing this, I can calculate for each process or thread (which also has the TotalProcessorTime.TotalMilliseconds property) the CPU usage, by dividing its TotalProcessorTime.TotalMilliseconds with the CPU 1%, and the output we get is its CPU usage %:

private static ProcessInfo 
  GetProcessInfo(ProcessInfo TempProcess,Process CurrentProcess)
{
    long NewCpuUsage = (long) 
         CurrentProcess.TotalProcessorTime.TotalMilliseconds; 

    TempProcess.CpuUsage = ((NewCpuUsage - TempProcess.OldCpuUsage) / 
                             CpuUsagePercent).ToString("F",ValueFormat);
    TempProcess.OldCpuUsage = NewCpuUsage;

    return TempProcess;
}

Using the Code

Choose your own way. I don't know if the API version is always good, it requires much more work than the managed one, but if you are after your own "Task Manager" you should definitely take the API one.

Conclusion

Once again, we take into consideration the performance and ease of coding when we compare managed .NET and the uncomfortable API.

History

• 2^nd May, 2005: Initial version

License

This article has no explicit license attached to it, but may contain usage terms in the article text or the download files themselves. If in doubt, please contact the author via the discussion board below.

A list of licenses authors might use can be found here.