计算Windows Mobile / CE设备上的当前CPU使用率

Question

In the core system there is no single call which retrieves the CPU usage for the whole system. From what I can find online with bits and pieces of sample code I need to calculate this total % but I cant get my head around the Math involved and im hoping someone can help on that front.

Im writing this in C# and pinvoking some functions to get thread timings. Below is the code ive got so far. For each running thread I can get the timings with GetThreadTick and GetThreadTimings. I just cant think how these values will help me calculate the % CPU usage.

Im also aware that any calculation I do will affect the CPU usage itself.

    public static int Calc()
    {
        int dwCurrentThreadTime1 = 0;
        int dwCurrentThreadTime2 = 0;

        FILETIME ftCreationTime = new FILETIME();
        FILETIME ftExitTime = new FILETIME();
        FILETIME ftKernelTime = new FILETIME();
        FILETIME ftUserTime = new FILETIME();
        PROCESSENTRY pe32 = new PROCESSENTRY();
        THREADENTRY32 te32 = new THREADENTRY32();

        IntPtr hsnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPHEAPLIST | TH32CS_SNAPMODULE | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD, 0);
        if (hsnapshot == IntPtr.Zero)
            return -1;

        pe32.dwSize = (uint)Marshal.SizeOf(pe32);
        te32.dwSize = Marshal.SizeOf(te32);

        int retval = Process32First(hsnapshot, ref pe32);

        while (retval == 1)
        {
            int retval2 = Thread32First(hsnapshot, ref te32);

            while(retval2 == 1)
            {
                if (te32.th32OwnerProcessID == pe32.th32ProcessID)
                {                        
                    int dwCurrentTickTime1 = GetTickCount();
                    GetThreadTimes((IntPtr)te32.th32ThreadID, ref ftCreationTime, ref ftExitTime, ref ftKernelTime, ref ftUserTime);

                    GetThreadTick(ref ftKernelTime, ref ftUserTime);
                }
                retval2 = Thread32Next(hsnapshot, ref te32);
            }
            retval = Process32Next(hsnapshot, ref pe32);
        }
        CloseToolhelp32Snapshot(hsnapshot);
        return dwCurrentThreadTime1;
    }

Answer 1

You can use GetIdleTime or CeGetIdleTimeEx (single core or multi-core version) to get the time the CPU has spent in idle state and use this value to calculate the load percentage of the CPU (or each core). This function requires that the BSP supports idle counters, if this support is missing in the BSP you will not get meaningful values.

Answer 2

In my cpumon I use GetThreadTick for user and kernel time spent for all threads and build a sum for all processes: http://www.hjgode.de/wp/2012/12/14/mobile-development-a-remote-cpu-monitor-and-cpu-usage-analysis/

code snippet:

    /// <summary>
    /// build thread and process list periodically and fire update event and enqueue results for the socket thread
    /// </summary>
    void usageThread()
    {
        try
        {
            int interval = 3000;

            uint start = Process.GetTickCount();
            Dictionary<uint, thread> old_thread_List;// = Process.GetThreadList();

            string exeFile = Process.exefile;
            //read all processes
            Dictionary<uint, process> ProcList = Process.getProcessNameList();
            DateTime dtCurrent = DateTime.Now;

            //######### var declarations
            Dictionary<uint, thread> new_ThreadList;
            uint duration;
            long system_total;
            long user_total, kernel_total;      //total process spend in user/kernel
            long thread_user, thread_kernel;    //times the thread spend in user/kernel
            DWORD dwProc;
            float user_percent;
            float kernel_percent;    
            ProcessStatistics.process_usage usage;
            ProcessStatistics.process_statistics stats = null;

            string sProcessName = "";
            List<thread> processThreadList = new List<thread>();

            //extended list
            List<threadStatistic> processThreadStatsList = new List<threadStatistic>(); //to store thread stats
            while (!bStopMainThread)
            {
                eventEnableCapture.WaitOne();
                old_thread_List = Process.GetThreadList();  //build a list of threads with user and kernel times

                System.Threading.Thread.Sleep(interval);

                //get a new thread list
                new_ThreadList = Process.GetThreadList();   //build another list of threads with user and kernel times, to compare

                duration = Process.GetTickCount() - start;

                ProcList = Process.getProcessNameList();    //update process list
                dtCurrent = DateTime.Now;
                system_total = 0;
                statisticsTimes.Clear();
                //look thru all processes
                foreach (KeyValuePair<uint, process> p2 in ProcList)
                {
                    //empty the process's thread list
                    processThreadList=new List<thread>();
                    processThreadStatsList = new List<threadStatistic>();

                    user_total     = 0;  //hold sum of thread user times for a process
                    kernel_total   = 0;  //hold sum of thread kernel times for a process
                    sProcessName = p2.Value.sName;

                    //SUM over all threads with that ProcID
                    dwProc = p2.Value.dwProcID;
                    foreach (KeyValuePair<uint, thread> kpNew in new_ThreadList)
                    {
                        thread_user = 0;
                        thread_kernel = 0;
                        //if the thread belongs to the process
                        if (kpNew.Value.dwOwnerProcID == dwProc)
                        {
                            //is there an old thread entry we can use to calc?
                            thread threadOld;
                            if (old_thread_List.TryGetValue(kpNew.Value.dwThreadID, out threadOld))
                            {
                                thread_user=Process.GetThreadTick(kpNew.Value.thread_times.user) - Process.GetThreadTick(old_thread_List[kpNew.Value.dwThreadID].thread_times.user);
                                user_total += thread_user;
                                thread_kernel =Process.GetThreadTick(kpNew.Value.thread_times.kernel) - Process.GetThreadTick(old_thread_List[kpNew.Value.dwThreadID].thread_times.kernel);
                                kernel_total += thread_kernel;
                            }
                            //simple list
                            thread threadsOfProcess = new thread(kpNew.Value.dwOwnerProcID, kpNew.Value.dwThreadID, kpNew.Value.thread_times);
                            processThreadList.Add(threadsOfProcess);

                            //extended list
                            threadStatistic threadStats = 
                                new threadStatistic(
                                    kpNew.Value.dwOwnerProcID, 
                                    kpNew.Value.dwThreadID, 
                                    new threadtimes(thread_user, thread_kernel), 
                                    duration, 
                                    dtCurrent.Ticks);
                            processThreadStatsList.Add(threadStats);

                        }//if dwProcID matches
                    }
                    //end of sum for process
                    user_percent      = (float)user_total / (float)duration * 100f;
                    kernel_percent    = (float)kernel_total / (float)duration * 100f;
                    system_total = user_total + kernel_total;

                    // update the statistics with this process' info
                    usage = new ProcessStatistics.process_usage(kernel_total, user_total);
                    // update process statistics
                    stats = new ProcessStatistics.process_statistics(p2.Value.dwProcID, p2.Value.sName, usage, dtCurrent.Ticks, duration, processThreadStatsList);

                    //add or update the proc stats
                    if (exeFile != p2.Value.sName || bIncludeMySelf)
                    {
                        statisticsTimes[p2.Value.sName] = stats;
                            procStatsQueueBytes.Enqueue(stats.ToByte());
                    }

                    start = Process.GetTickCount();
                }//foreach process

                onUpdateHandler(new ProcessStatsEventArgs(statisticsTimes, duration));
                procStatsQueueBytes.Enqueue(ByteHelper.endOfTransferBytes);
                ((AutoResetEvent)eventEnableSend).Set();
            }//while true
        }
        catch (ThreadAbortException ex)
        {
            System.Diagnostics.Debug.WriteLine("ThreadAbortException: usageThread(): " + ex.Message);
        }
        catch (Exception ex)
        {
            System.Diagnostics.Debug.WriteLine("Exception: usageThread(): " + ex.Message);
        }
        System.Diagnostics.Debug.WriteLine("Thread ENDED");
    }

Answer 3

The calculation to obtain the idle time for the whole system is documented on MSDN .

Here's a C# sample:

using System;
using System.Runtime.InteropServices;
using System.Threading;

class Program
{
    static void Main()
    {
        for(;;)
        {
            uint startTick = GetTickCount();
            uint startIdle = GetIdleTime();

            Thread.Sleep(1000);

            uint stopTick = GetTickCount();
            uint stopIdle = GetIdleTime();

            uint percentIdle = (100 * (stopIdle - startIdle)) / stopTick - startTick);

            Console.WriteLine("CPU idle {0}%", percentIdle);
        }
    }

    [DllImport("coredll.dll")]
    static extern uint GetTickCount();

    [DllImport("coredll.dll")]
    static extern uint GetIdleTime();
}

And the equivalent C/C++ implementation:

#include "windows.h"

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPTSTR, int)
{
    for(;;)
    {
        DWORD startTick = GetTickCount();
        DWORD startIdle = GetIdleTime();

        Sleep(1000);

        DWORD stopTick = GetTickCount();
        DWORD stopIdle = GetIdleTime();

        DWORD percentIdle = (100 * (stopIdle - startIdle)) / (stopTick - startTick);

        _tprintf(L"CPU idle %d%%\r\n", percentIdle);
    }

    return 0;
}

On most CE platforms, performing this calculation just once every second has an absolutely negligible overhead.