我想知道在我的c++程序中某个函数在Linux上执行需要多少时间。之后，我想做一个速度比较。我看到了几个时间函数，但最终从boost。空间:
process_user_cpu_clock, captures user-CPU time spent by the current process
现在，我不清楚如果我使用上述函数，我会得到哪个CPU在该函数上花费的唯一时间吗?
其次，我找不到任何使用上述功能的例子。请问有谁能告诉我如何使用上面的功能?
p.s.:现在，我使用std::chrono::system_clock::now()以秒为单位获得时间，但这给了我不同的结果，因为不同的CPU负载每次。
当前回答
如果你想要安全的时间和代码行，你可以用一行宏来测量函数的执行时间:
a)实现如上所述的时间测量类(这是我的android实现):
class MeasureExecutionTime{
private:
const std::chrono::steady_clock::time_point begin;
const std::string caller;
public:
MeasureExecutionTime(const std::string& caller):caller(caller),begin(std::chrono::steady_clock::now()){}
~MeasureExecutionTime(){
const auto duration=std::chrono::steady_clock::now()-begin;
LOGD("ExecutionTime")<<"For "<<caller<<" is "<<std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()<<"ms";
}
};
b)添加一个方便的宏，它使用当前函数名作为TAG(在这里使用宏很重要，否则__FUNCTION__将计算为MeasureExecutionTime而不是你想测量的函数
#ifndef MEASURE_FUNCTION_EXECUTION_TIME
#define MEASURE_FUNCTION_EXECUTION_TIME const MeasureExecutionTime measureExecutionTime(__FUNCTION__);
#endif
c)在你想要测量的函数的开头写你的宏。例子:
void DecodeMJPEGtoANativeWindowBuffer(uvc_frame_t* frame_mjpeg,const ANativeWindow_Buffer& nativeWindowBuffer){
MEASURE_FUNCTION_EXECUTION_TIME
// Do some time-critical stuff
}
这将导致以下输出:
ExecutionTime: For DecodeMJPEGtoANativeWindowBuffer is 54ms
请注意，这(和所有其他建议的解决方案一样)将测量函数被调用和返回之间的时间，而不一定是CPU执行函数的时间。但是，如果您不给调度程序任何更改，通过调用sleep()或类似方法来挂起正在运行的代码，则两者之间没有区别。
其他回答
我建议使用steady_clock，它保证是单调的，不像high_resolution_clock。
#include <iostream>
#include <chrono>
using namespace std;
unsigned int stopwatch()
{
static auto start_time = chrono::steady_clock::now();
auto end_time = chrono::steady_clock::now();
auto delta = chrono::duration_cast<chrono::microseconds>(end_time - start_time);
start_time = end_time;
return delta.count();
}
int main() {
stopwatch(); //Start stopwatch
std::cout << "Hello World!\n";
cout << stopwatch() << endl; //Time to execute last line
for (int i=0; i<1000000; i++)
string s = "ASDFAD";
cout << stopwatch() << endl; //Time to execute for loop
}
输出:
Hello World!
62
163514
您可以使用一个简单的类来进行这种测量。
class duration_printer {
public:
duration_printer() : __start(std::chrono::high_resolution_clock::now()) {}
~duration_printer() {
using namespace std::chrono;
high_resolution_clock::time_point end = high_resolution_clock::now();
duration<double> dur = duration_cast<duration<double>>(end - __start);
std::cout << dur.count() << " seconds" << std::endl;
}
private:
std::chrono::high_resolution_clock::time_point __start;
};
唯一需要做的是在函数的开始处创建一个对象
void veryLongExecutingFunction() {
duration_calculator dc;
for(int i = 0; i < 100000; ++i) std::cout << "Hello world" << std::endl;
}
int main() {
veryLongExecutingFunction();
return 0;
}
就是这样。可以修改该类以满足您的需求。
如果你想要安全的时间和代码行，你可以用一行宏来测量函数的执行时间:
a)实现如上所述的时间测量类(这是我的android实现):
class MeasureExecutionTime{
private:
const std::chrono::steady_clock::time_point begin;
const std::string caller;
public:
MeasureExecutionTime(const std::string& caller):caller(caller),begin(std::chrono::steady_clock::now()){}
~MeasureExecutionTime(){
const auto duration=std::chrono::steady_clock::now()-begin;
LOGD("ExecutionTime")<<"For "<<caller<<" is "<<std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()<<"ms";
}
};
b)添加一个方便的宏，它使用当前函数名作为TAG(在这里使用宏很重要，否则__FUNCTION__将计算为MeasureExecutionTime而不是你想测量的函数
#ifndef MEASURE_FUNCTION_EXECUTION_TIME
#define MEASURE_FUNCTION_EXECUTION_TIME const MeasureExecutionTime measureExecutionTime(__FUNCTION__);
#endif
c)在你想要测量的函数的开头写你的宏。例子:
void DecodeMJPEGtoANativeWindowBuffer(uvc_frame_t* frame_mjpeg,const ANativeWindow_Buffer& nativeWindowBuffer){
MEASURE_FUNCTION_EXECUTION_TIME
// Do some time-critical stuff
}
这将导致以下输出:
ExecutionTime: For DecodeMJPEGtoANativeWindowBuffer is 54ms
请注意，这(和所有其他建议的解决方案一样)将测量函数被调用和返回之间的时间，而不一定是CPU执行函数的时间。但是，如果您不给调度程序任何更改，通过调用sleep()或类似方法来挂起正在运行的代码，则两者之间没有区别。
#include <iostream>
#include <chrono>
void function()
{
// code here;
}
int main()
{
auto t1 = std::chrono::high_resolution_clock::now();
function();
auto t2 = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>( t2 - t1 ).count();
std::cout << duration<<"/n";
return 0;
}
这对我很管用。
注意:
high_resolution_clock不能在不同的标准库实现中实现一致，应该避免使用它。它通常只是std::chrono::steady_clock或std::chrono::system_clock的别名，但它是哪一个取决于库或配置。当它是system_clock时，它不是单调的(例如，时间可以倒退)。
例如，对于gcc的libstdc++，它是system_clock，对于MSVC，它是steady_clock，对于clang的libc++，它取决于配置。
通常应该直接使用std::chrono::steady_clock或std::chrono::system_clock，而不是std::chrono::high_resolution_clock:使用steady_clock测量持续时间，使用system_clock测量时钟时间。
在c++ 11中，这是一个非常容易使用的方法。 我们可以从头文件中使用std::chrono::high_resolution_clock 我们可以编写一个方法，以易于阅读的形式打印方法执行时间。
例如，要找到1到1亿之间的所有质数，大约需要1分40秒。 因此，执行时间打印为:
Execution Time: 1 Minutes, 40 Seconds, 715 MicroSeconds, 715000 NanoSeconds
代码在这里:
#include <iostream>
#include <chrono>
using namespace std;
using namespace std::chrono;
typedef high_resolution_clock Clock;
typedef Clock::time_point ClockTime;
void findPrime(long n, string file);
void printExecutionTime(ClockTime start_time, ClockTime end_time);
int main()
{
long n = long(1E+8); // N = 100 million
ClockTime start_time = Clock::now();
// Write all the prime numbers from 1 to N to the file "prime.txt"
findPrime(n, "C:\\prime.txt");
ClockTime end_time = Clock::now();
printExecutionTime(start_time, end_time);
}
void printExecutionTime(ClockTime start_time, ClockTime end_time)
{
auto execution_time_ns = duration_cast<nanoseconds>(end_time - start_time).count();
auto execution_time_ms = duration_cast<microseconds>(end_time - start_time).count();
auto execution_time_sec = duration_cast<seconds>(end_time - start_time).count();
auto execution_time_min = duration_cast<minutes>(end_time - start_time).count();
auto execution_time_hour = duration_cast<hours>(end_time - start_time).count();
cout << "\nExecution Time: ";
if(execution_time_hour > 0)
cout << "" << execution_time_hour << " Hours, ";
if(execution_time_min > 0)
cout << "" << execution_time_min % 60 << " Minutes, ";
if(execution_time_sec > 0)
cout << "" << execution_time_sec % 60 << " Seconds, ";
if(execution_time_ms > 0)
cout << "" << execution_time_ms % long(1E+3) << " MicroSeconds, ";
if(execution_time_ns > 0)
cout << "" << execution_time_ns % long(1E+6) << " NanoSeconds, ";
}
