C ++でコードスニペットの実行時間を計算する方法

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秒くらいかなと思います。

System.nanoTime()この場合、Javaではうまく機能することを覚えています。しかしclock()、C ++の関数から同じ正確な機能を取得することはできません。

解決策はありますか？

私が書いたこの関数を使用できます。を呼び出すGetTimeMs64()と、Unixエポックからシステムクロックを使用して経過したミリ秒数が返されます- time(NULL)ミリ秒を除いてと同じです。

WindowsとLinuxの両方で動作します。スレッドセーフです。

Windowsでは粒度が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
}

マイクロ秒を使用する別の実用的な例（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

これは満足のいく解像度を与える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;
}

https://gist.github.com/gongzhitaao/7062087から

#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マイクロ秒の差を測定できます。

一部のプログラムでは、そのような目的でRDTSを使用しました。RDTSCは時間ではなく、プロセッサの開始からのサイクル数です。秒単位で結果を得るには、システムで調整する必要がありますが、パフォーマンスを評価する場合は非常に便利です。サイクル数を秒に戻そうとせずに、サイクル数を直接使用することをお勧めします。

（上記のリンクはフランスのウィキペディアのページですが、C ++コードサンプルがあり、英語版はこちらです）

システムから時間情報を取得するには、標準ライブラリ関数を使用することをお勧めします。

より細かい解像度が必要な場合は、より多くの反復を実行します。プログラムを1回実行してサンプルを取得する代わりに、1000回以上実行します。

全体（ループ+パフォーマンスタイミング）を数回実行して平均化するよりも、パフォーマンスタイミングを1回だけ使用して内部ループを数回実行し、内部ループの繰り返しを分割して平均化する方が適切です。これにより、実際のプロファイルセクションに対してパフォーマンスタイミングコードのオーバーヘッドが削減されます。

適切なシステムのタイマー呼び出しをラップします。Windowsの場合、QueryPerformanceCounterはかなり高速で、「安全」に使用できます。

最新のX86 PCでも "rdtsc"を使用できますが、一部のマルチコアマシン（コアホッピングによりタイマーが変更される可能性があります）で問題が発生したり、何らかの速度ステップがオンになっている場合があります。

（Windows固有のソリューション）Windowsで正確なタイミングを取得する現在（2017年頃）の方法は、「QueryPerformanceCounter」を使用することです。このアプローチには、非常に正確な結果が得られるという利点があり、MSによって推奨されています。コードblobを新しいコンソールアプリに配置するだけで、実用的なサンプルを取得できます。ここで長い議論があります：高解像度タイムスタンプの取得

#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;
}

スレッドスケジューリングの完全な解決策は、各テストで正確に同じ時間になるはずですが、プログラムをOSに依存しないようにコンパイルし、コンピューターを起動して、OSのない環境でプログラムを実行することです。しかし、これはほとんど非現実的であり、せいぜい困難です。

OSフリー化の良い代替策は、現在のスレッドのアフィニティを1コアに設定し、優先度を最高に設定することです。この代替手段は、一貫した十分な結果を提供するはずです。

また、デバッグを妨げる最適化をオフにする必要があります。これは、g ++またはgccの場合、コマンドラインに追加-Ogすることを意味し、テストされるコードが最適化されないようにします。-O0それはこのようにコードの時限速度をスキュー、タイミング結果に含まれることになる余分な不要なオーバーヘッドを導入するためのフラグを使用すべきではありません。

逆に、最終的な製品ビルド-Ofastで使用する（または少なくとも-O3）ことを前提とし、「デッド」コードの除去の問題を無視する場合、どちらもに-Og比べて最適化をほとんど実行しません-Ofast。したがって-Og、最終製品のコードの実際の速度を誤って表す可能性があります。

さらに、すべての速度テストは（ある程度）偽証します：でコンパイルされた最終的な製品で-Ofastは、コードの各スニペット/セクション/関数は分離されません。むしろ、コードの各スニペットは継続的に次のスニペットに流れ込むため、コンパイラーはあらゆる場所からコードの断片を結合、マージ、および最適化することができます。

同時に、を頻繁に使用するコードスニペットをベンチマークしている場合realloc()、十分なメモリの断片化が発生している製品では、コードスニペットの実行が遅くなる可能性があります。したがって、「全体はその部分の合計よりも大きい」という表現がこの状況に適用されます。最終的な製品ビルドのコードは、速度テストしている個々のスニペットよりも著しく速くまたは遅く実行される可能性があるためです。

不整合を減らす可能性のある部分的な解決策は、デッドコード/ループの除去を防ぐためのテストに含まれる変数への-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;
}

また、タイマーについてはマイクジャービスの功績です。

より大きなコードスニペットを実行する場合は、コンピューターがフリーズしないように、反復回数を実際に減らす必要があることに注意してください（これは非常に重要です）。

実行されるたびに同じコードの時間を計測したい場合（たとえば、ボトルネックになっていると思われるプロファイリングコードの場合）に、Andreas Boniniの便利な関数のラッパー（わずかな変更）があります。

#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;
};

コードブロックをベンチマークする単純なクラス：

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;
}

boost :: timerはおそらく必要なだけの精度を与えるでしょう。どれほど時間a = a+1;がかかるかを説明するのに十分正確ではありませんが、数ナノ秒かかるような時間を計らなければならない理由は何ですか？

関数呼び出しをN回呼び出して平均を返すラムダを作成しました。

double c = BENCHMARK_CNT(25, fillVectorDeque(variable));

ここに c ++ 11ヘッダーがあります。

私は、クロノライブラリの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;
}

[cxx-rtimers][1]ローカル変数を作成できるコードブロックのランタイムに関する統計を収集するためのいくつかのヘッダーのみのルーチンを提供するGitHubでを確認することもできます。これらのタイマーには、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...
}

それは私がそれをする方法です、あまりコードではなく、理解しやすく、私のニーズに合います：

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
);

#include <omp.h>

double start = omp_get_wtime();

// code 

double finish = omp_get_wtime();

double total_time = finish - start;