6

C++ 中有什么方法可以计算在 CPU 时间内运行给定程序或例程需要多长时间？

我使用在 Windows 7 上运行的 Visual Studio 2008。

4

5 回答 5

6

如果您想知道进程使用的 CPU 时间总量，那么（直接或通过编译器内在函数）clock都不rdtsc是最好的选择，至少 IMO 是这样。如果您需要代码是可移植的，那么您能做的最好的事情就是使用clock，尽可能在系统静止状态下进行测试，并希望获得最好的结果（但如果您这样做，请注意clockis的分辨率CLOCKS_PER_SEC，这可能会或可能会不是 1000，即使是，您的实际时间分辨率通常也不会那么好——它可能会给您以毫秒为单位的时间，但至少通常一次提前几十毫秒）。

但是，由于您似乎并不介意特定于 Windows 的代码，因此您可以做得更好。至少如果我对您要查找的内容的理解是正确的，那么您真正想要的可能是GetProcessTimes，它将（分别）告诉您进程的内核模式和用户模式 ​​CPU 使用情况（以及开始时间和退出时间，如果您愿意，您可以从中计算所用的挂墙时间）。还有QueryProcessCycleTime，它将告诉您进程使用的 CPU 时钟周期总数（所有线程中用户模式和内核模式的总和）。就个人而言，我很难想象后者有多大用处——计算单个时钟周期对于小型代码部分需要进行密集优化，但我不太确定您将如何将其应用到完整的过程中。GetProcessTimes使用 FILETIME 结构，它支持 100 纳秒的分辨率，但实际上大多数时候你会看到调度程序的时间片的倍数（它随 windows 的版本而变化，但在毫秒到几十毫秒的数量级）。

在任何情况下，如果您真的想要从头到尾的时间，GetProcessTimes会让您这样做——如果您生成程序（例如，使用CreateProcess），您将获得进程的句柄，该句柄将在子进程退出时发出信号. 然后，您可以调用GetProcessTimes该句柄，并检索时间，即使孩子已经退出 - 只要该进程的至少一个句柄保持打开状态，该句柄将保持有效。

于 2012-09-27T04:11:15.207 回答
4

这是一种方法。它以毫秒为单位测量例行执行时间。

clock_t begin=clock();在路由执行之前开始，并clock_t end=clock();在例程退出后立即开始。

然后将这两个时间集相互减去，结果是毫秒值。

#include <stdio.h>
#include <iostream>
#include <time.h>
using namespace std;

double get_CPU_time_usage(clock_t clock1,clock_t clock2)
{
    double diffticks=clock1-clock2;
    double diffms=(diffticks*1000)/CLOCKS_PER_SEC;
    return diffms;
} 

void test_CPU_usage()
{
  cout << "Standby.. measuring exeution time:  ";

  for (int i=0; i<10000;i++)
  {
        cout << "\b\\" << std::flush;
        cout << "\b|" << std::flush;
        cout << "\b/" << std::flush;
        cout << "\b-" << std::flush;
  }

  cout << " \n\n";
}

int main (void)
{

    clock_t begin=clock();

    test_CPU_usage();

    clock_t end=clock();

    cout << "Time elapsed: " << double(get_CPU_time_usage(end,begin)) << " ms ("<<double(get_CPU_time_usage(end,begin))/1000<<" sec) \n\n";
    return 0;
}
于 2012-09-26T17:01:39.033 回答
2

__rdtscp内在函数将为您提供 CPU 周期时间，但有一些警告。这是MSDN 文章

这实际上取决于您要测量的内容。为了获得更好的结果，平均进行几百万次（如果不是十亿次）迭代。

于 2012-09-26T17:09:13.620 回答
2

clock() 函数 [由 Visual C++ 2008 提供] 不返回程序使用的处理器时间，但它应该返回（根据 C 标准和/或 C++ 标准）。也就是说，为了测量 Windows 上的 CPU 时间，我有这个帮助程序类（它不可避免地是不可移植的）：

class ProcessorTimer
{
  public:
    ProcessorTimer() { start(); }
    void start() { ::GetProcessTimes(::GetCurrentProcess(), &ft_[3], &ft_[2], &ft_[1], &ft_[0]); }
    std::tuple<double, double> stop()
    {
        ::GetProcessTimes(::GetCurrentProcess(), &ft_[5], &ft_[4], &ft_[3], &ft_[2]);
        ULARGE_INTEGER u[4];
        for (size_t i = 0; i < 4; ++i)
        {
            u[i].LowPart = ft_[i].dwLowDateTime;
            u[i].HighPart = ft_[i].dwHighDateTime;
        }
        double user = (u[2].QuadPart - u[0].QuadPart) / 10000000.0;
        double kernel = (u[3].QuadPart - u[1].QuadPart) / 10000000.0;
        return std::make_tuple(user, kernel);
    }
  private:
    FILETIME ft_[6];
};


class ScopedProcessorTimer
{
  public:
    ScopedProcessorTimer(std::ostream& os = std::cerr) : timer_(ProcessorTimer()), os_(os) { }
    ~ScopedProcessorTimer()
    {
        std::tuple<double, double> t = timer_.stop();
        os_ << "user " << std::get<0>(t) << "\n";
        os_ << "kernel " << std::get<1>(t) << "\n";
    }
  private:
    ProcessorTimer timer_;
    std::ostream& os_;
}

例如，可以通过在该 {} 块的开头定义一个 ScopedProcessorTimer 来测量执行该块需要多长时间。

于 2012-10-11T17:55:44.413 回答
0

此代码是进程 Cpu 使用情况 

ULONGLONG LastCycleTime = NULL;
LARGE_INTEGER LastPCounter;
LastPCounter.QuadPart = 0; // LARGE_INTEGER Init

                           // cpu get core number
SYSTEM_INFO sysInfo;
GetSystemInfo(&sysInfo);
int numProcessors = sysInfo.dwNumberOfProcessors;

HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, Process::pid);

if (hProcess == NULL)
    nResult = 0;

int count = 0;
while (true)
{
    ULONG64 CycleTime;
    LARGE_INTEGER qpcLastInt;

    if (!QueryProcessCycleTime(hProcess, &CycleTime))
        nResult = 0;

    ULONG64 cycle = CycleTime - LastCycleTime;

    if (!QueryPerformanceCounter(&qpcLastInt))
        nResult = 0;

    double Usage = cycle / ((double)(qpcLastInt.QuadPart - LastPCounter.QuadPart));

    // Scaling
    Usage *= 1.0 / numProcessors;
    Usage *= 0.1;

    LastPCounter = qpcLastInt;
    LastCycleTime = CycleTime;

    if (count > 3)
    {
        printf("%.1f", Usage);
        break;
    }

    Sleep(1); // QueryPerformanceCounter Function Resolution is 1 microsecond

    count++;
}

CloseHandle(hProcess);
于 2017-07-03T15:31:56.067 回答