我想要找出在Linux上执行某个函数所需的时间。之后，我想进行速度比较。我看过几个计时函数，但最终选择了Boost库中的Chrono。
process_user_cpu_clock, captures user-CPU time spent by the current process
现在，我不确定如果我使用上面的函数，我是否只会得到CPU在该函数上花费的时间？
其次，我找不到使用上述功能的任何示例。有人可以帮忙告诉我如何使用上述函数吗？
P.S：目前，我正在使用std :: chrono :: system_clock :: now()以秒为单位获取时间，但由于每次CPU负载不同，这会给我不同的结果。
这是C++11中一个非常易于使用的方法。你需要从<chrono>头文件中使用std::chrono::high_resolution_clock。
使用方法如下：
#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
high_resolution_clock将给出函数运行所需的物理时间和实际时间。因此，在第一次运行时，CPU 的使用率比下一次运行时低。这里的“使用率”指其他应用程序使用 CPU 的情况。 - Victorsteady_clock 吗？high_resolution_clock 不可能是非单调的时钟吗？ - Gillespielong long number 更改为 volatile long long number。否则，优化器很可能会优化掉该循环，并且您将得到零运行时间。 - Kai Petzke这是一个函数，可以测量传递为参数的任何函数的执行时间：
#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
我在Scott Meyers的书中发现了一个通用泛型lambda表达式的例子，可以用来测量函数执行时间。(C++14)
auto timeFuncInvocation =
[](auto&& func, auto&&... params) {
// get time before function invocation
const auto& start = std::chrono::high_resolution_clock::now();
// function invocation using perfect forwarding
std::forward<decltype(func)>(func)(std::forward<decltype(params)>(params)...);
// get time after function invocation
const auto& stop = std::chrono::high_resolution_clock::now();
return stop - start;
};
#include <iostream>
#include <chrono>
#include <vector>
auto timeFuncInvocation =
[](auto&& func, auto&&... params) {
// get time before function invocation
const auto& start = high_resolution_clock::now();
// function invocation using perfect forwarding
for(auto i = 0; i < 100000/*largeNumber*/; ++i) {
std::forward<decltype(func)>(func)(std::forward<decltype(params)>(params)...);
}
// get time after function invocation
const auto& stop = high_resolution_clock::now();
return (stop - start)/100000/*largeNumber*/;
};
void f(std::vector<int>& vec) {
vec.push_back(1);
}
void f2(std::vector<int>& vec) {
vec.emplace_back(1);
}
int main()
{
std::vector<int> vec;
std::vector<int> vec2;
std::cout << timeFuncInvocation(f, vec).count() << std::endl;
std::cout << timeFuncInvocation(f2, vec2).count() << std::endl;
std::vector<int> vec3;
vec3.reserve(100000);
std::vector<int> vec4;
vec4.reserve(100000);
std::cout << timeFuncInvocation(f, vec3).count() << std::endl;
std::cout << timeFuncInvocation(f2, vec4).count() << std::endl;
return 0;
}
编辑： 当然，您始终需要记住编译器可能会优化掉某些内容。在这种情况下，像perf这样的工具可能会有用。
一个简单的程序，用于查找函数执行所需的时间。
#include <iostream>
#include <ctime> // time_t
#include <cstdio>
void function()
{
for(long int i=0;i<1000000000;i++)
{
// do nothing
}
}
int main()
{
time_t begin,end; // time_t is a datatype to store time values.
time (&begin); // note time before execution
function();
time (&end); // note time after execution
double difference = difftime (end,begin);
printf ("time taken for function() %.2lf seconds.\n", difference );
return 0;
}
clock_gettime的方法，并在struct timespec中处理结果，但这是C的解决方案而不是C ++的。 - Victor老版本的C++或C语言的简单方法：
#include <time.h> // includes clock_t and CLOCKS_PER_SEC
int main() {
clock_t start, end;
start = clock();
// ...code to measure...
end = clock();
double duration_sec = double(end-start)/CLOCKS_PER_SEC;
return 0;
}
秒级的时间精度为1.0/CLOCKS_PER_SEC
#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。
这是一个优秀的头文件类模板，用于测量函数或任何代码块的经过时间:
#ifndef EXECUTION_TIMER_H
#define EXECUTION_TIMER_H
template<class Resolution = std::chrono::milliseconds>
class ExecutionTimer {
public:
using Clock = std::conditional_t<std::chrono::high_resolution_clock::is_steady,
std::chrono::high_resolution_clock,
std::chrono::steady_clock>;
private:
const Clock::time_point mStart = Clock::now();
public:
ExecutionTimer() = default;
~ExecutionTimer() {
const auto end = Clock::now();
std::ostringstream strStream;
strStream << "Destructor Elapsed: "
<< std::chrono::duration_cast<Resolution>( end - mStart ).count()
<< std::endl;
std::cout << strStream.str() << std::endl;
}
inline void stop() {
const auto end = Clock::now();
std::ostringstream strStream;
strStream << "Stop Elapsed: "
<< std::chrono::duration_cast<Resolution>(end - mStart).count()
<< std::endl;
std::cout << strStream.str() << std::endl;
}
}; // ExecutionTimer
#endif // EXECUTION_TIMER_H
int main() {
{ // empty scope to display ExecutionTimer's destructor's message
// displayed in milliseconds
ExecutionTimer<std::chrono::milliseconds> timer;
// function or code block here
timer.stop();
}
{ // same as above
ExecutionTimer<std::chrono::microseconds> timer;
// code block here...
timer.stop();
}
{ // same as above
ExecutionTimer<std::chrono::nanoseconds> timer;
// code block here...
timer.stop();
}
{ // same as above
ExecutionTimer<std::chrono::seconds> timer;
// code block here...
timer.stop();
}
return 0;
}
由于这个类是一个模板，我们可以非常容易地指定我们想要测量和显示时间的方式。这是一个非常方便的实用类模板，可用于进行基准测试，并且非常易于使用。
stop() 成员函数并不是必需的，因为析构函数会自动停止计时器。 - Caseyobj.stop和它的“析构函数”之间有最小的时间间隔。 - Francis Cugler<chrono>？ - Francis Cugler如果你想节省时间和代码行数，你可以将函数执行时间的测量变为一行宏：
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) 添加一个便捷的宏来使用当前函数名作为标签（在这里使用宏很重要，否则__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
- 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, ";
}
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
clock_gettime。gcc定义其他时钟为：typedef system_clock steady_clock; typedef system_clock high_resolution_clock;在Windows上，使用QueryPerformanceCounter。 - Brandon