我想知道在我的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负载每次。
当前回答
#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测量时钟时间。
其他回答
如果你想要安全的时间和代码行，你可以用一行宏来测量函数的执行时间:
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()或类似方法来挂起正在运行的代码，则两者之间没有区别。
在c++ 11中，这是一个非常容易使用的方法。你必须使用std::chrono::high_resolution_clock from <chrono>头。
像这样使用它:
#include <chrono>
/* Only needed for the sake of this example. */
#include <iostream>
#include <thread>
void long_operation()
{
/* Simulating a long, heavy operation. */
using namespace std::chrono_literals;
std::this_thread::sleep_for(150ms);
}
int main()
{
using std::chrono::high_resolution_clock;
using std::chrono::duration_cast;
using std::chrono::duration;
using std::chrono::milliseconds;
auto t1 = high_resolution_clock::now();
long_operation();
auto t2 = high_resolution_clock::now();
/* Getting number of milliseconds as an integer. */
auto ms_int = duration_cast<milliseconds>(t2 - t1);
/* Getting number of milliseconds as a double. */
duration<double, std::milli> ms_double = t2 - t1;
std::cout << ms_int.count() << "ms\n";
std::cout << ms_double.count() << "ms\n";
return 0;
}
这将度量函数long_operation的持续时间。
可能的输出:
150ms
150.068ms
工作示例:https://godbolt.org/z/oe5cMd
我建议使用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
下面是一个函数，它将测量作为参数传递的任何函数的执行时间:
#include <chrono>
#include <utility>
typedef std::chrono::high_resolution_clock::time_point TimeVar;
#define duration(a) std::chrono::duration_cast<std::chrono::nanoseconds>(a).count()
#define timeNow() std::chrono::high_resolution_clock::now()
template<typename F, typename... Args>
double funcTime(F func, Args&&... args){
TimeVar t1=timeNow();
func(std::forward<Args>(args)...);
return duration(timeNow()-t1);
}
使用示例:
#include <iostream>
#include <algorithm>
typedef std::string String;
//first test function doing something
int countCharInString(String s, char delim){
int count=0;
String::size_type pos = s.find_first_of(delim);
while ((pos = s.find_first_of(delim, pos)) != String::npos){
count++;pos++;
}
return count;
}
//second test function doing the same thing in different way
int countWithAlgorithm(String s, char delim){
return std::count(s.begin(),s.end(),delim);
}
int main(){
std::cout<<"norm: "<<funcTime(countCharInString,"precision=10",'=')<<"\n";
std::cout<<"algo: "<<funcTime(countWithAlgorithm,"precision=10",'=');
return 0;
}
输出:
norm: 15555
algo: 2976
#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测量时钟时间。
