コードチューニングのための時間計測

 C++でコード実行時間をナノ秒(ns)単位で計測する場合は、通常 std::chrono::steady_clock を使います。

#include <chrono>

#include <iostream>

 

int main()

{

auto start = std::chrono::steady_clock::now();

 

// 計測対象

volatile int sum = 0;

for (int i = 0; i < 1000000; ++i)

sum += i;

 

auto end = std::chrono::steady_clock::now();

 

auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(

end - start).count();

 

std::cout << ns << " ns\n";

}

関数化

template<class F>

long long measure_ns(F&& func)

{

auto start = std::chrono::steady_clock::now();

 

func();

 

auto end = std::chrono::steady_clock::now();

 

return std::chrono::duration_cast<

std::chrono::nanoseconds>(end - start).count();

}

使用例:

auto ns = measure_ns([]{

volatile int x = 0;

for (int i = 0; i < 1000000; ++i)

x += i;

});

 

std::cout << ns << " ns\n";

注意点

極めて短いコード（数ns～100ns程度）を計測する場合、

_mm_store_si128(...)

1回だけの計測ではタイマ精度やOS割込みの影響が大きくなります。

そのため、

constexpr int N = 1000000;

 

auto start = std::chrono::steady_clock::now();

 

for (int i = 0; i < N; ++i)

{

target_code();

}

 

auto end = std::chrono::steady_clock::now();

 

double ns_per_call =

std::chrono::duration_cast<std::chrono::nanoseconds>(

end - start).count()

/ static_cast<double>(N);

のように大量ループして1回当たりの時間を求める方が正確です。

さらにSIMD命令やCPUサイクル単位で測るなら、RDTSC/RDTSCP を使う方法もあります。

#include <x86intrin.h>

 

uint64_t t0 = __rdtsc();

 

target_code();

 

uint64_t t1 = __rdtsc();

 

std::cout << (t1 - t0) << " cycles\n";

ただし __rdtsc() は命令の並べ替えの影響を受けるため、ベンチマーク用途では通常

_mm_lfence();

t0 = __rdtsc();

 

target_code();

 

unsigned aux;

t1 = __rdtscp(&aux);

_mm_lfence();

のように LFENCE + RDTSC + RDTSCP + LFENCE を組み合わせます。

SSE/AVXレベルの最適化を評価するなら、chrono よりも RDTSCP で「サイクル数」を測定する方が有用です。例えば _mm_store_si128 と memcmp の比較などでは、nsよりcyclesの方が差が見えやすくなります。

サイクル数を時間に換算するには？

CPUサイクル数から時間への換算は、

$$\text{時間[s]}=\frac{\text{cycles}}{\text{CPU周波数[Hz]}}$$時間[s]=CPU周波数[Hz]cycles​

です。

例えば 4.0GHz のCPUで、

400 cycles

なら

$$400\mathrm{/}(4.0\times {10}^9)=100𝑛𝑠$$400/(4.0×109)=100ns

となります。

nsへ直接換算

$$\text{時間[ns]}=\frac{\text{cycles}\times {10}^9}{\text{CPU周波数[Hz]}}$$時間[ns]=CPU周波数[Hz]cycles×109​

4GHzなら

double ns = cycles / 4.0;

になります。

なぜなら4 GHz = 4 cycles/ns

だからです。

---

実際にはTurboで周波数が変わる

最近のCPUは

3.0GHz → 5.3GHz

のように動的に変化します。

そのため

cycles / CPU_GHz

で計算しても誤差があります。

ベンチマークでは通常、

cycles

のまま比較します。

実装A : 12 cycles

実装B : 18 cycles

のように。

---

TSCがInvariantの場合

最近のIntel/AMDでは TSC(Time Stamp Counter) が一定速度です。

例えば

t0 = __rdtsc();

sleep(1);

t1 = __rdtsc();

なら

t1 - t0 ≒ TSC周波数

です。

TSC周波数は実クロックとは異なり、

Base Clock

に固定されていることが多いです。

---

正確な換算方法

chrono と rdtsc を同時に計測して較正します。

auto t0 = std::chrono::steady_clock::now();

uint64_t c0 = __rdtsc();

 

std::this_thread::sleep_for(std::chrono::milliseconds(100));

 

auto t1 = std::chrono::steady_clock::now();

uint64_t c1 = __rdtsc();

 

double sec =

std::chrono::duration<double>(t1 - t0).count();

 

double tsc_hz = (c1 - c0) / sec;

すると

C++

ns = cycles * 1e9 / tsc_hz;

で高精度に換算できます。

SIMDコード（_mm_store_si128、memcmp、8byte比較など）の性能評価なら、ユーザーさんの用途では ns換算せず cycles のまま比較するのが一般的 です。CPU周波数変動の影響を受けず、

Plain Text

実装A : 3.2 cycles

実装B : 5.8 cycles

のように直接性能差が分かります。さらに命令単位で評価する場合は、ループ展開して「cycles/iteration」または「cycles/op」を見るのが定番です。