我必须在几秒钟内计算C ++代码段的执行时间。它必须在Windows或Unix机器上运行。
我使用以下代码执行此操作的代码。 （之前导入）
clock_t startTime = clock();
// some code here
// to compute its execution duration in runtime
cout << double( clock() - startTime ) / (double)CLOCKS_PER_SEC<< " seconds." << endl;
然而，对于小输入或短语句，例如a = a + 1，我得到“0秒”结果。我认为它必须是0.0000001秒之类的东西。
我记得Java中的System.nanoTime()在这种情况下效果很好。但是，我无法从C ++的clock()函数中获得相同的功能。
你有解决方案吗？
答案 0 :(得分：113)
你可以使用我写的这个功能。你调用GetTimeMs64()，它使用系统时钟返回自unix纪元以来经过的毫秒数 - 就像time(NULL)一样，除了毫秒。
它适用于Windows和Linux;它是线程安全的。
请注意，窗口的粒度为15毫秒;在Linux上它是依赖于实现的，但它通常也是15毫秒。
#ifdef _WIN32
#include <Windows.h>
#else
#include <sys/time.h>
#include <ctime>
#endif
/* Remove if already defined */
typedef long long int64; typedef unsigned long long uint64;
/* Returns the amount of milliseconds elapsed since the UNIX epoch. Works on both
* windows and linux. */
uint64 GetTimeMs64()
{
#ifdef _WIN32
/* Windows */
FILETIME ft;
LARGE_INTEGER li;
/* Get the amount of 100 nano seconds intervals elapsed since January 1, 1601 (UTC) and copy it
* to a LARGE_INTEGER structure. */
GetSystemTimeAsFileTime(&ft);
li.LowPart = ft.dwLowDateTime;
li.HighPart = ft.dwHighDateTime;
uint64 ret = li.QuadPart;
ret -= 116444736000000000LL; /* Convert from file time to UNIX epoch time. */
ret /= 10000; /* From 100 nano seconds (10^-7) to 1 millisecond (10^-3) intervals */
return ret;
#else
/* Linux */
struct timeval tv;
gettimeofday(&tv, NULL);
uint64 ret = tv.tv_usec;
/* Convert from micro seconds (10^-6) to milliseconds (10^-3) */
ret /= 1000;
/* Adds the seconds (10^0) after converting them to milliseconds (10^-3) */
ret += (tv.tv_sec * 1000);
return ret;
#endif
}
答案 1 :(得分：42)
我有另一个使用微秒（UNIX，POSIX等）的工作示例。
#include <sys/time.h>
typedef unsigned long long timestamp_t;
static timestamp_t
get_timestamp ()
{
struct timeval now;
gettimeofday (&now, NULL);
return now.tv_usec + (timestamp_t)now.tv_sec * 1000000;
}
...
timestamp_t t0 = get_timestamp();
// Process
timestamp_t t1 = get_timestamp();
double secs = (t1 - t0) / 1000000.0L;
这是我们编码的文件：
https://github.com/arhuaco/junkcode/blob/master/emqbit-bench/bench.c
答案 2 :(得分：35)
这是C ++ 11中的一个简单解决方案，它为您提供令人满意的解决方案。
#include <iostream>
#include <chrono>
class Timer
{
public:
Timer() : beg_(clock_::now()) {}
void reset() { beg_ = clock_::now(); }
double elapsed() const {
return std::chrono::duration_cast<second_>
(clock_::now() - beg_).count(); }
private:
typedef std::chrono::high_resolution_clock clock_;
typedef std::chrono::duration<double, std::ratio<1> > second_;
std::chrono::time_point<clock_> beg_;
};
或者在* nix上，对于c ++ 03
#include <iostream>
#include <ctime>
class Timer
{
public:
Timer() { clock_gettime(CLOCK_REALTIME, &beg_); }
double elapsed() {
clock_gettime(CLOCK_REALTIME, &end_);
return end_.tv_sec - beg_.tv_sec +
(end_.tv_nsec - beg_.tv_nsec) / 1000000000.;
}
void reset() { clock_gettime(CLOCK_REALTIME, &beg_); }
private:
timespec beg_, end_;
};
以下是示例用法：
int main()
{
Timer tmr;
double t = tmr.elapsed();
std::cout << t << std::endl;
tmr.reset();
t = tmr.elapsed();
std::cout << t << std::endl;
return 0;
}
答案 3 :(得分：18)
#include <boost/progress.hpp>
using namespace boost;
int main (int argc, const char * argv[])
{
progress_timer timer;
// do stuff, preferably in a 100x loop to make it take longer.
return 0;
}
当progress_timer超出范围时，它将打印出自创建以来经过的时间。
更新：我做了一个简单的独立替换（OSX / iOS但易于移植）：https://github.com/catnapgames/TestTimerScoped
答案 4 :(得分：5)
答案 5 :(得分：3)
在我写的一些程序中，我使用RDTS来达到这个目的。 RDTSC不是关于时间，而是关于处理器启动的周期数。你必须在你的系统上校准它以获得第二个结果，但是当你想要评估性能时它真的很方便，直接使用周期数而不试图将它们改回秒来更好。
（以上链接到法语维基百科页面，但它有C ++代码示例，英文版本为here）
答案 6 :(得分：2)
我建议使用标准库函数从系统中获取时间信息。
如果您想要更精细的分辨率，请执行更多的执行迭代。而不是运行程序一次并获取样本，运行1000次或更多次。
答案 7 :(得分：2)
最好只运行内部循环几次，性能时间只有一次，并且平均内部循环重复次数比运行整个事物（循环+性能时间）几次和平均值。这将减少性能计时代码与实际配置文件部分的开销。
为适当的系统包裹您的定时器呼叫。对于Windows，QueryPerformanceCounter使用起来非常快速且“安全”。
您也可以在任何现代X86 PC上使用“rdtsc”，但某些多核计算机上可能会出现问题（核心跳跃可能会更改计时器），或者如果您启用了某种速度步骤。
答案 8 :(得分：2)
线程调度的完整可靠解决方案（每个测试应该产生完全相同的时间）是将程序编译为独立于操作系统并启动计算机以便在无OS环境中运行程序。然而，这在很大程度上是不切实际的，而且最多也是困难的。无操作系统的一个很好的替代方案就是将当前线程的亲和力设置为1核心，将优先级设置为最高。替代方案应提供足够一致的结果。
此外，您应该关闭会干扰调试的优化，这对于g ++或gcc意味着adding -Og to the command line，以防止被测试的代码被优化掉。不应使用-O0标志，因为它会引入额外的不需要的开销，这些开销将包含在时序结果中，从而扭曲了代码的定时速度。相反，两者都假设您在最终生产构建中使用-Ofast（或者至少是-O3）而忽略了＆＃34; dead＆＃34;与-Og相比，代码消除-Ofast执行的优化很少;因此-Og可能会歪曲最终产品中代码的实际速度。此外，所有速度测试（在某种程度上）都是perjure：在使用-Ofast编译的最终产品中，代码的每个片段/部分/功能都不是孤立的;相反，每个代码片段不断地流入下一个代码片段，从而允许编译器潜在地连接，合并和优化来自所有地方的代码片段。同时，如果您正在对大量使用realloc的代码进行基准测试，那么代码片段可能会在具有足够高内存碎片的生产产品中运行得更慢。因此，表达＆＃34;整体超过其各部分的总和＆＃34;适用于这种情况，因为最终生产版本中的代码可能比您正在进行速度测试的单个代码段明显更快或更慢。可以减少不一致的部分解决方案是使用-Ofast进行速度测试，并在测试中涉及的变量中添加asm volatile("" :: "r"(var))以防止死代码/循环消除。
以下是如何在Windows计算机上对平方根函数进行基准测试的示例。
// set USE_ASM_TO_PREVENT_ELIMINATION to 0 to prevent `asm volatile("" :: "r"(var))`
// set USE_ASM_TO_PREVENT_ELIMINATION to 1 to enforce `asm volatile("" :: "r"(var))`
#define USE_ASM_TO_PREVENT_ELIMINATION 1
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <chrono>
#include <cmath>
#include <windows.h>
#include <intrin.h>
#pragma intrinsic(__rdtsc)
#include <cstdint>
class Timer {
public:
Timer() : beg_(clock_::now()) {}
void reset() { beg_ = clock_::now(); }
double elapsed() const {
return std::chrono::duration_cast<second_>
(clock_::now() - beg_).count(); }
private:
typedef std::chrono::high_resolution_clock clock_;
typedef std::chrono::duration<double, std::ratio<1> > second_;
std::chrono::time_point<clock_> beg_;
};
unsigned int guess_sqrt32(register unsigned int n) {
register unsigned int g = 0x8000;
if(g*g > n) {
g ^= 0x8000;
}
g |= 0x4000;
if(g*g > n) {
g ^= 0x4000;
}
g |= 0x2000;
if(g*g > n) {
g ^= 0x2000;
}
g |= 0x1000;
if(g*g > n) {
g ^= 0x1000;
}
g |= 0x0800;
if(g*g > n) {
g ^= 0x0800;
}
g |= 0x0400;
if(g*g > n) {
g ^= 0x0400;
}
g |= 0x0200;
if(g*g > n) {
g ^= 0x0200;
}
g |= 0x0100;
if(g*g > n) {
g ^= 0x0100;
}
g |= 0x0080;
if(g*g > n) {
g ^= 0x0080;
}
g |= 0x0040;
if(g*g > n) {
g ^= 0x0040;
}
g |= 0x0020;
if(g*g > n) {
g ^= 0x0020;
}
g |= 0x0010;
if(g*g > n) {
g ^= 0x0010;
}
g |= 0x0008;
if(g*g > n) {
g ^= 0x0008;
}
g |= 0x0004;
if(g*g > n) {
g ^= 0x0004;
}
g |= 0x0002;
if(g*g > n) {
g ^= 0x0002;
}
g |= 0x0001;
if(g*g > n) {
g ^= 0x0001;
}
return g;
}
unsigned int empty_function( unsigned int _input ) {
return _input;
}
unsigned long long empty_ticks=0;
double empty_seconds=0;
Timer my_time;
template<unsigned int benchmark_repetitions>
void benchmark( char* function_name, auto (*function_to_do)( auto ) ) {
register unsigned int i=benchmark_repetitions;
register unsigned long long start=0;
my_time.reset();
start=__rdtsc();
while ( i-- ) {
auto result = (*function_to_do)( i << 7 );
#if USE_ASM_TO_PREVENT_ELIMINATION == 1
asm volatile("" :: "r"(
// There is no data type in C++ that is smaller than a char, so it will
// not throw a segmentation fault error to reinterpret any arbitrary
// data type as a char. Although, the compiler might not like it.
result
));
#endif
}
if ( function_name == nullptr ) {
empty_ticks = (__rdtsc()-start);
empty_seconds = my_time.elapsed();
std::cout<< "Empty:\n" << empty_ticks
<< " ticks\n" << benchmark_repetitions << " repetitions\n"
<< std::setprecision(15) << empty_seconds
<< " seconds\n\n";
} else {
std::cout<< function_name<<":\n" << (__rdtsc()-start-empty_ticks)
<< " ticks\n" << benchmark_repetitions << " repetitions\n"
<< std::setprecision(15) << (my_time.elapsed()-empty_seconds)
<< " seconds\n\n";
}
}
int main( void ) {
void* Cur_Thread= GetCurrentThread();
void* Cur_Process= GetCurrentProcess();
unsigned long long Current_Affinity;
unsigned long long System_Affinity;
unsigned long long furthest_affinity;
unsigned long long nearest_affinity;
if( ! SetThreadPriority(Cur_Thread,THREAD_PRIORITY_TIME_CRITICAL) ) {
SetThreadPriority( Cur_Thread, THREAD_PRIORITY_HIGHEST );
}
if( ! SetPriorityClass(Cur_Process,REALTIME_PRIORITY_CLASS) ) {
SetPriorityClass( Cur_Process, HIGH_PRIORITY_CLASS );
}
GetProcessAffinityMask( Cur_Process, &Current_Affinity, &System_Affinity );
furthest_affinity = 0x8000000000000000ULL>>__builtin_clzll(Current_Affinity);
nearest_affinity = 0x0000000000000001ULL<<__builtin_ctzll(Current_Affinity);
SetProcessAffinityMask( Cur_Process, furthest_affinity );
SetThreadAffinityMask( Cur_Thread, furthest_affinity );
const int repetitions=524288;
benchmark<repetitions>( nullptr, empty_function );
benchmark<repetitions>( "Standard Square Root", standard_sqrt );
benchmark<repetitions>( "Original Guess Square Root", original_guess_sqrt32 );
benchmark<repetitions>( "New Guess Square Root", new_guess_sqrt32 );
SetThreadPriority( Cur_Thread, THREAD_PRIORITY_IDLE );
SetPriorityClass( Cur_Process, IDLE_PRIORITY_CLASS );
SetProcessAffinityMask( Cur_Process, nearest_affinity );
SetThreadAffinityMask( Cur_Thread, nearest_affinity );
for (;;) { getchar(); }
return 0;
}
另外，还有Mike Jarvis的计时器。
请注意（这非常重要）如果您要运行更大的代码片段，那么您必须调低迭代次数以防止计算机冻结。
答案 9 :(得分：2)
（Windows特定解决方案） 目前（大约2017年）在Windows下获得准确计时的方法是使用＆＃34; QueryPerformanceCounter＆＃34;。这种方法的好处是可以提供非常准确的结果，并且是MS推荐的。只需将代码blob放入一个新的控制台应用程序即可获得工作样本。这里有一个冗长的讨论：Acquiring High resolution time stamps
#include <iostream>
#include <tchar.h>
#include <windows.h>
int main()
{
constexpr int MAX_ITER{ 10000 };
constexpr __int64 us_per_hour{ 3600000000ull }; // 3.6e+09
constexpr __int64 us_per_min{ 60000000ull };
constexpr __int64 us_per_sec{ 1000000ull };
constexpr __int64 us_per_ms{ 1000ull };
// easy to work with
__int64 startTick, endTick, ticksPerSecond, totalTicks = 0ull;
QueryPerformanceFrequency((LARGE_INTEGER *)&ticksPerSecond);
for (int iter = 0; iter < MAX_ITER; ++iter) {// start looping
QueryPerformanceCounter((LARGE_INTEGER *)&startTick); // Get start tick
// code to be timed
std::cout << "cur_tick = " << iter << "\n";
QueryPerformanceCounter((LARGE_INTEGER *)&endTick); // Get end tick
totalTicks += endTick - startTick; // accumulate time taken
}
// convert to elapsed microseconds
__int64 totalMicroSeconds = (totalTicks * 1000000ull)/ ticksPerSecond;
__int64 hours = totalMicroSeconds / us_per_hour;
totalMicroSeconds %= us_per_hour;
__int64 minutes = totalMicroSeconds / us_per_min;
totalMicroSeconds %= us_per_min;
__int64 seconds = totalMicroSeconds / us_per_sec;
totalMicroSeconds %= us_per_sec;
__int64 milliseconds = totalMicroSeconds / us_per_ms;
totalMicroSeconds %= us_per_ms;
std::cout << "Total time: " << hours << "h ";
std::cout << minutes << "m " << seconds << "s " << milliseconds << "ms ";
std::cout << totalMicroSeconds << "us\n";
return 0;
}
答案 10 :(得分：1)
如果您希望每次执行时都需要对同一段代码进行计时（例如，对于您认为可能是瓶颈的分析代码），这里有一个包装（稍微修改）Andreas Bonini＆＃39;我发现有用的功能：
#ifdef _WIN32
#include <Windows.h>
#else
#include <sys/time.h>
#endif
/*
* A simple timer class to see how long a piece of code takes.
* Usage:
*
* {
* static Timer timer("name");
*
* ...
*
* timer.start()
* [ The code you want timed ]
* timer.stop()
*
* ...
* }
*
* At the end of execution, you will get output:
*
* Time for name: XXX seconds
*/
class Timer
{
public:
Timer(std::string name, bool start_running=false) :
_name(name), _accum(0), _running(false)
{
if (start_running) start();
}
~Timer() { stop(); report(); }
void start() {
if (!_running) {
_start_time = GetTimeMicroseconds();
_running = true;
}
}
void stop() {
if (_running) {
unsigned long long stop_time = GetTimeMicroseconds();
_accum += stop_time - _start_time;
_running = false;
}
}
void report() {
std::cout<<"Time for "<<_name<<": " << _accum / 1.e6 << " seconds\n";
}
private:
// cf. http://stackoverflow.com/questions/1861294/how-to-calculate-execution-time-of-a-code-snippet-in-c
unsigned long long GetTimeMicroseconds()
{
#ifdef _WIN32
/* Windows */
FILETIME ft;
LARGE_INTEGER li;
/* Get the amount of 100 nano seconds intervals elapsed since January 1, 1601 (UTC) and copy it
* * to a LARGE_INTEGER structure. */
GetSystemTimeAsFileTime(&ft);
li.LowPart = ft.dwLowDateTime;
li.HighPart = ft.dwHighDateTime;
unsigned long long ret = li.QuadPart;
ret -= 116444736000000000LL; /* Convert from file time to UNIX epoch time. */
ret /= 10; /* From 100 nano seconds (10^-7) to 1 microsecond (10^-6) intervals */
#else
/* Linux */
struct timeval tv;
gettimeofday(&tv, NULL);
unsigned long long ret = tv.tv_usec;
/* Adds the seconds (10^0) after converting them to microseconds (10^-6) */
ret += (tv.tv_sec * 1000000);
#endif
return ret;
}
std::string _name;
long long _accum;
unsigned long long _start_time;
bool _running;
};
答案 11 :(得分：1)
只是一个对代码块进行基准测试的简单类：
using namespace std::chrono;
class benchmark {
public:
time_point<high_resolution_clock> t0, t1;
unsigned int *d;
benchmark(unsigned int *res) : d(res) {
t0 = high_resolution_clock::now();
}
~benchmark() { t1 = high_resolution_clock::now();
milliseconds dur = duration_cast<milliseconds>(t1 - t0);
*d = dur.count();
}
};
// simple usage
// unsigned int t;
// { // put the code in a block
// benchmark bench(&t);
// // ...
// // code to benchmark
// }
// HERE the t contains time in milliseconds
// one way to use it can be :
#define BENCH(TITLE,CODEBLOCK) \
unsigned int __time__##__LINE__ = 0; \
{ benchmark bench(&__time__##__LINE__); \
CODEBLOCK \
} \
printf("%s took %d ms\n",(TITLE),__time__##__LINE__);
int main(void) {
BENCH("TITLE",{
for(int n = 0; n < testcount; n++ )
int a = n % 3;
});
return 0;
}
答案 12 :(得分：0)
#include <omp.h>
double start = omp_get_wtime();
// code
double finish = omp_get_wtime();
double total_time = finish - start;
答案 13 :(得分：0)
那是我的方法，不需要太多代码，易于理解，可以满足我的需求：
void bench(std::function<void()> fnBench, std::string name, size_t iterations)
{
if (iterations == 0)
return;
if (fnBench == nullptr)
return;
std::chrono::high_resolution_clock::time_point start, end;
if (iterations == 1)
{
start = std::chrono::high_resolution_clock::now();
fnBench();
end = std::chrono::high_resolution_clock::now();
}
else
{
start = std::chrono::high_resolution_clock::now();
for (size_t i = 0; i < iterations; ++i)
fnBench();
end = std::chrono::high_resolution_clock::now();
}
printf
(
"bench(*, \"%s\", %u) = %4.6lfs\r\n",
name.c_str(),
iterations,
std::chrono::duration_cast<std::chrono::duration<double>>(end - start).count()
);
}
用法：
bench
(
[]() -> void // function
{
// Put your code here
},
"the name of this", // name
1000000 // iterations
);
答案 14 :(得分：0)
您还可以查看GitHub上的[cxx-rtimers][1]，它提供了一些仅限标头的例程，用于收集任何代码块运行时的统计信息，您可以在其中创建局部变量。这些定时器的版本在C ++ 11上使用std :: chrono，或者在Boost库中使用定时器，或者使用标准POSIX定时器函数。这些计时器将报告平均值，最大值和最大值。在函数内花费的最小持续时间，以及调用它的次数。它们可以简单地用于以下内容：
#include <rtimers/cxx11.hpp>
void expensiveFunction() {
static rtimers::cxx11::DefaultTimer timer("expensive");
auto scopedStartStop = timer.scopedStart();
// Do something costly...
}
答案 15 :(得分：0)
我创建了一个简单的实用程序来测量代码块的性能，使用chrono库的high_resolution_clock：https://github.com/nfergu/codetimer。
可以针对不同的键记录计时，并且可以显示每个键的计时的聚合视图。
用法如下：
#include <chrono>
#include <iostream>
#include "codetimer.h"
int main () {
auto start = std::chrono::high_resolution_clock::now();
// some code here
CodeTimer::record("mykey", start);
CodeTimer::printStats();
return 0;
}
答案 16 :(得分：0)
我创建了一个lambda，它调用了N次函数调用并返回平均值。
double c = BENCHMARK_CNT(25, fillVectorDeque(variable));
您可以找到c ++ 11标题here。
答案 17 :(得分：0)
boost::timer可能会为您提供所需的准确度。它远远不够准确，无法告诉你a = a+1;需要多长时间，但我还有什么理由需要花费几纳秒的时间？