我需要计算一个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() 函数中获得完全相同的功能。
你有解决方案吗？
GetTimeMs64()函数，它返回自Unix时代以来使用系统时钟流逝的毫秒数，就像使用time(NULL)一样，只不过是以毫秒为单位。#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
}
gettimeofday可能会给出意外的结果。如果这对您是一个问题，您可能需要考虑使用clock_gettime代替。 - AzmisovGetTickCount 有什么优势吗？ - MicroVirusgcc -std=c99 编译。 - AssimilaterGetTickCount 是自系统启动以来经过的时间，而我的函数返回自UNIX纪元以来的时间，这意味着您可以将其用于日期和时间。如果您只对两个事件之间经过的时间感兴趣，那么我的函数仍然是更好的选择，因为它是一个int64；GetTickCount是一个int32，并且每50天会溢出，这意味着如果您注册的两个事件在溢出之间，您可能会得到奇怪的结果。 - Andreas Bonini我有另一个可行的示例，它使用微秒（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
#include <sys/time.h>。 - niekas#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_;
};
#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;
}
/usr/lib/x86_64-linux-gnu/libstdc++.so.6: version GLIBCXX_3.4.19 not found (required by ../cpu_2d/g500)。 - user9869932#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超出范围时，它将打印自创建以来经过的时间。
更新：这里是一个不需要Boost即可工作的版本（在macOS/iOS上测试通过）：
#include <chrono>
#include <string>
#include <iostream>
#include <math.h>
#include <unistd.h>
class NLTimerScoped {
private:
const std::chrono::steady_clock::time_point start;
const std::string name;
public:
NLTimerScoped( const std::string & name ) : name( name ), start( std::chrono::steady_clock::now() ) {
}
~NLTimerScoped() {
const auto end(std::chrono::steady_clock::now());
const auto duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>( end - start ).count();
std::cout << name << " duration: " << duration_ms << "ms" << std::endl;
}
};
int main(int argc, const char * argv[]) {
{
NLTimerScoped timer( "sin sum" );
float a = 0.0f;
for ( int i=0; i < 1000000; i++ ) {
a += sin( (float) i / 100 );
}
std::cout << "sin sum = " << a << std::endl;
}
{
NLTimerScoped timer( "sleep( 4 )" );
sleep( 4 );
}
return 0;
}
Windows提供了QueryPerformanceCounter()函数，而Unix则有gettimeofday()函数。这两个函数都可以测量至少1微秒的差异。
#ifdef应该可以（根据你接受的答案来看是没问题的），然后我就不明白问题所在了：“#ifdef WIN32 #include <windows.h> ... #else ... #endif”。 - just somebody（适用于Windows的解决方案）
目前（约在2017年左右），获取准确计时的方法是使用“QueryPerformanceCounter”。这种方法具有给出非常精确结果的好处，且被微软公司推荐。只需将代码块放入新的控制台应用程序中即可获得一个可工作的示例。这里有一篇详细的讨论：获取高分辨率时间戳
#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;
}
-Ofast（或者至少使用了-O3），并忽略了“死”代码消除的问题，与-Ofast相比，-Og执行非常少的优化；因此，-Og可能会误导代码在最终产品中的实际速度。-Ofast编译的最终生产产品中，每个代码片段/部分/函数都不是孤立的；相反，每个代码片段都不断地流入下一个，从而使编译器有可能从各个地方加入、合并和优化代码片段。realloc()的代码片段进行基准测试，那么在内存碎片化严重的生产产品中，该代码片段可能会运行得更慢。因此，表达式“整体大于部分之和”适用于这种情况，因为最终生成的构建中的代码可能比您正在进行速度测试的单个代码片段运行得明显更快或更慢。-Ofast，并向涉及测试的变量添加asm volatile("" :: "r"(var))，以防止死代码/循环消除。// 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提供的计时器。
请注意（非常重要）：如果您将运行更大的代码片段，则必须降低迭代次数，以防止计算机冻结。
-O0代码进行基准测试是一种浪费时间的行为，因为与正常的-O2或-O3 -march=native相比，-O0的开销会因代码和工作负载而异。例如，额外命名的tmp变量在-O0下会增加时间成本。还有其他方法可以避免被优化掉的情况，例如使用volatile、非内联函数或空的内联汇编语句来隐藏优化器中的内容。 -O0甚至不能使用，因为代码在-O0下具有不同的瓶颈，而不是相同但更糟糕的瓶颈。 - Peter Cordes-Og 仍然不是很现实。至少 -O2，最好是 -O3 更为现实。使用 asm volatile("" ::: "+r"(var)) 或其他方法使编译器将一个值存储在寄存器中，并通过此方式打败常量传播。 - Peter Cordes-O3 更新了内容，并在代码片段中使用了 asm volatile("" ::: "+r"(var))。 - Jack Gasm volatile("" ::: "+r"( i )); 似乎是不必要的。在优化后的代码中，没有理由强制编译器将循环内的 i 和 i<<7 材料化。这会防止它优化为每次移位而不是 tmp -= 128。如果函数调用的结果是非 void 的，则使用函数调用的结果是好的。例如：int result = (*function_to_do)( i << 7 );。你可以在该结果上使用 asm 语句。 - Peter Cordesstandard_sqrt，而且我认为 (int) (reinterpret_cast<char>(result)) 不是一个左值。("+r" 是一个读写寄存器操作数；你可能只需要 asm volatile("" :: "r"(input_var) ) 而不是 asm volatile("" : "+r"(compiler_assumes_this_is_modified) )。顺便说一下，我打错字了：输出操作数在第一个冒号后面，破坏项在第三个冒号后面。所以 asm("" ::: "memory") 是一个内存屏障，但你不能把 "+r"(var) 放在那里。请参见 https://stackoverflow.com/tags/inline-assembly/info。 - Peter Cordes我建议使用标准库函数来获取系统时间信息。
如果你想要更精确的分辨率，那么执行更多次数的迭代。不是只运行程序一次并获得样本，而是运行1000次或更多次。