C++ 如何在 Linux/Windows 上测量 CPU 时间和挂钟时间？

How can I measure CPU time and wall clock time on both Linux/Windows?

提问by yak

I mean: how can I measure time my CPU spent on function execution and wall clock time it takes to run my function? (Im interested in Linux/Windows and both x86 and x86_64). See what I want to do (Im using C++ here but I would prefer C solution):

我的意思是：如何测量 CPU 花在函数执行上的时间以及运行函数所需的挂钟时间？（我对 Linux/Windows 以及 x86 和 x86_64 感兴趣）。看看我想做什么（我在这里使用 C++，但我更喜欢 C 解决方案）：

int startcputime, endcputime, wcts, wcte;

startcputime = cputime();
function(args);
endcputime = cputime();

std::cout << "it took " << endcputime - startcputime << " s of CPU to execute this\n";

wcts = wallclocktime();
function(args);
wcte = wallclocktime();

std::cout << "it took " << wcte - wcts << " s of real time to execute this\n";

Another important question: is this type of time measuring architecture independent or not?

另一个重要问题：这种时间测量架构是否独立？

回答by Mysticial

Here's a copy-paste solution that works on both Windows and Linux as well as C and C++.

这是一个适用于 Windows 和 Linux 以及 C 和 C++ 的复制粘贴解决方案。

As mentioned in the comments, there's a boost library that does this. But if you can't use boost, this should work:

正如评论中提到的，有一个 boost 库可以做到这一点。但如果你不能使用 boost，这应该有效：

//  Windows
#ifdef _WIN32
#include <Windows.h>
double get_wall_time(){
    LARGE_INTEGER time,freq;
    if (!QueryPerformanceFrequency(&freq)){
        //  Handle error
        return 0;
    }
    if (!QueryPerformanceCounter(&time)){
        //  Handle error
        return 0;
    }
    return (double)time.QuadPart / freq.QuadPart;
}
double get_cpu_time(){
    FILETIME a,b,c,d;
    if (GetProcessTimes(GetCurrentProcess(),&a,&b,&c,&d) != 0){
        //  Returns total user time.
        //  Can be tweaked to include kernel times as well.
        return
            (double)(d.dwLowDateTime |
            ((unsigned long long)d.dwHighDateTime << 32)) * 0.0000001;
    }else{
        //  Handle error
        return 0;
    }
}

//  Posix/Linux
#else
#include <time.h>
#include <sys/time.h>
double get_wall_time(){
    struct timeval time;
    if (gettimeofday(&time,NULL)){
        //  Handle error
        return 0;
    }
    return (double)time.tv_sec + (double)time.tv_usec * .000001;
}
double get_cpu_time(){
    return (double)clock() / CLOCKS_PER_SEC;
}
#endif

There's a bunch of ways to implement these clocks. But here's what the above snippet uses:

有很多方法可以实现这些时钟。但这是上面的代码片段使用的内容：

For Windows:

对于 Windows：

• Wall Time: Performance Counters
• CPU Time: GetProcessTimes()

• Wall Time：性能计数器
• CPU时间： GetProcessTimes()

For Linux:

对于 Linux：

• Wall Time: gettimeofday()
• CPU Time: clock()

• 墙上时间： gettimeofday()
• CPU时间： clock()

---

---

And here's a small demonstration:

这是一个小演示：

#include <math.h>
#include <iostream>
using namespace std;

int main(){

    //  Start Timers
    double wall0 = get_wall_time();
    double cpu0  = get_cpu_time();

    //  Perform some computation.
    double sum = 0;
#pragma omp parallel for reduction(+ : sum)
    for (long long i = 1; i < 10000000000; i++){
        sum += log((double)i);
    }

    //  Stop timers
    double wall1 = get_wall_time();
    double cpu1  = get_cpu_time();

    cout << "Wall Time = " << wall1 - wall0 << endl;
    cout << "CPU Time  = " << cpu1  - cpu0  << endl;

    //  Prevent Code Elimination
    cout << endl;
    cout << "Sum = " << sum << endl;

}

Output (12 threads):

输出（12 个线程）：

Wall Time = 15.7586
CPU Time  = 178.719

Sum = 2.20259e+011

回答by carlduke

C++11. Much easier to write!

C++11。写起来容易多了！

Use std::chrono::system_clockfor wall clock and std::clockfor cpu clock http://en.cppreference.com/w/cpp/chrono/system_clock

使用std::chrono::system_clock的挂钟和std::clock用于CPU时钟 http://en.cppreference.com/w/cpp/chrono/system_clock

#include <cstdio>
#include <ctime>
#include <chrono>

.... 

std::clock_t startcputime = std::clock();
do_some_fancy_stuff();
double cpu_duration = (std::clock() - startcputime) / (double)CLOCKS_PER_SEC;
std::cout << "Finished in " << cpu_duration << " seconds [CPU Clock] " << std::endl;


auto wcts = std::chrono::system_clock::now();
do_some_fancy_stuff();
std::chrono::duration<double> wctduration = (std::chrono::system_clock::now() - wcts);
std::cout << "Finished in " << wctduration.count() << " seconds [Wall Clock]" << std::endl;

Et voilà, easy and portable! No need for #ifdef _WIN32 or LINUX!

等等，简单便携！不需要#ifdef _WIN32 或 LINUX！

You could even use chrono::high_resolution_clockif you need more precision http://en.cppreference.com/w/cpp/chrono/high_resolution_clock

chrono::high_resolution_clock如果您需要更高的精度， 您甚至可以使用http://en.cppreference.com/w/cpp/chrono/high_resolution_clock

回答by Andre Holzner

To give a concrete example of @lip's suggestion to use boost::timerif you can (tested with Boost 1.51):

boost::timer如果可以的话，举一个@lip 建议的具体例子（用 Boost 1.51 测试）：

#include <boost/timer/timer.hpp>

// this is wallclock AND cpu time
boost::timer::cpu_timer timer;

... run some computation ...

boost::timer::cpu_times elapsed = timer.elapsed();
std::cout << " CPU TIME: " << (elapsed.user + elapsed.system) / 1e9 << " seconds"
          << " WALLCLOCK TIME: " << elapsed.wall / 1e9 << " seconds"
          << std::endl;

回答by syb0rg

Use the clockmethod in time.h:

使用time.h 中的clock方法：

clock_t start = clock();
/* Do stuffs */
clock_t end = clock();
float seconds = (float)(end - start) / CLOCKS_PER_SEC;

Unfortunately, this method returns CPU time on Linux, but returns wall-clock time on Windows(thanks to commenters for this information).

不幸的是，此方法在 Linux 上返回 CPU 时间，但在 Windows 上返回挂钟时间（感谢评论者提供此信息）。