HN 日本語サマリー

← 一覧へ戻る
プログラミング

コンパイラを信頼する: モダンC++

Trust your compiler: Modern C++ (categorica.io)

51 pointsby foxhill30 コメント

要約

この記事は、現代のC++プログラマーがパフォーマンス最適化のために古い「トリック」に頼るのではなく、コンパイラの能力を信頼すべきだと主張しています。昔は有効だった手法(例: 高速逆平方根、ビット操作)が、現代のハードウェアとコンパイラの進化により、必ずしも最適ではなくなっていることを、ベンチマーク結果を交えて解説しています。コンパイラに任せることで、より読みやすく、保守しやすいコードが得られると結論付けています。

全文翻訳

コンパイラを信頼する

C++プログラマーは、経験を通じて多くのパフォーマンスに関する知恵を吸収します。高速逆平方根[1]、XORスワップ[2]、手動アンロールループ[3]、ダフのデバイス[4]、例外は遅い、仮想呼び出しは遅い、除算は遅い、ルックアップテーブルはしばしば数学よりも優れている、などです。たとえかつて真実であったとしても、ハードウェア、ソフトウェア、コンパイラの進歩は状況を劇的に変化させ、その多くは現在では当てはまりません。

John CarmackのDEC AlphaやPentium Proは、現代のZen 5 x86_64コアとはほとんど似ていません。そのブランチ予測子だけでも、当時のiDのオフィスにあった全ワークステーションよりも多くのトランジスタを含んでいる可能性があります。さらに、LLVMのClangとGNUのGCCは、単純な入力から最適なコードを書くのに十分に進んでいます。例えば、両方のコンパイラは、コードセグメントが実際にはpopcountの変形に過ぎないかどうかをチェックする最適化パスを持っています[5]。実際、「巧妙な」コードを書くことは、「悪い」コードである可能性があります。それはオプティマイザから意図を不明瞭にし、ベクトル化、インライン化、ターゲット固有のローリングを犠牲にする可能性があります。

この記事では、いくつかの古いトリックを検証し、それらを明白なバージョンと比較して、どのように動作するかを見ていきます。以下の数値は、以下の環境で生成されました。

  • Ubuntu 24.04 LTS (更新されたLinuxカーネル 6.18.1)
  • AMD Ryzen 9 9950X, 16コア / 32スレッド
  • 128 GB DDR5/3600メモリ
  • Clang 21.1.1, -O3 -ffast-math -mtune=native

この投稿にはベンチマークコードが付属しています。すべてのベンチマークはGoogle Benchmarkを使用しています。[6]

内容

  1. パート1:新しい犬、古いトリック

  2. パート2:ライブラリ

  3. ベンチマークの使い方

  4. 結びの言葉

パート1:新しい犬、古いトリック

高速逆平方根

Quake IIIのQ_rsqrt[7]をここに再現します。

float Q_rsqrt( float number )
{
	long i;
	float x2, y;
	const float threehalfs = 1.5F;

	x2 = number * 0.5F;
	y  = number;
	i  = * ( long * ) &y;
	i  = 0x5f3759df - ( i >> 1 );
	y  = * ( float * ) &i;
	y  = y * ( threehalfs - ( x2 * y * y ) );
  return y;
}

この仕組みを説明する記事は数多くあります[1]。ここでは省略します。要するに、90年代後半のCPUの浮動小数点ユニットは今日のものとは全く異なっていました。Quake 3 Arenaの開発中、iDの開発者は、新しいライティングモデルに使用される頂点法線(vertex normals)の計算に多くの時間が費やされていることを発見しました。この時間の多くは、1つの操作、すなわち逆平方根の計算に費やされていました。彼らのアプローチは、精度を犠牲にし、この1つの操作に対して「推定と改善」のアプローチを取ることでした。これは、単純な1.0f / sqrtf(x)を大幅に上回ることができました。8087 FPUではFSQRTとFDIVは500サイクル以上かかることがありましたが、iDの方法は安価な整数演算と1回のニュートン反復[8]を使用しました。

現代のCPU

IntelはSSE[9]でx86ファミリーにrsqrtssとrsqrtpsを導入しました。AVXは後に、より広いSIMD幅のためにvrsqrtssとvrsqrtpsの形式を追加しました。これらの命令は、近似的な逆平方根を直接計算し、文書化された誤差範囲を持ち、x87 fsqrt[10]よりも大幅に低いレイテンシを持ちます。ARMv8/AArch64には、同等の逆平方根推定命令[11]があります。

ISAスカラーパック幅
x86-64 SSErsqrtssrsqrtps4 x f32
x86-64 AVXvrsqrtssvrsqrtps8 x f32
ARMv8 NEONfrsqrte (スカラー)frsqrte4 x f32
なぜこれが重要なのか?

これを現代のC++で書くと、以下のようになるかもしれません。

constexpr float Q_rsqrt(float number) noexcept {
  static_assert(sizeof(float) == sizeof(std::uint32_t));
  auto i = std::bit_cast<std::uint32_t>(number);
  auto magic = 0x5f3759dfu - (i >> 1);
  auto y = std::bit_cast<float>(magic);
  return y * (1.5f - (number * 0.5f * y * y));
}

これを単純なバージョンと比較してください。

constexpr float naive_rsqrt(float x) noexcept {
    return 1.0f / std::sqrt(x);
}

次に、Compiler Explorer (Clang 21.1.0)で-std=c++23 -O3 -ffast-math -march=znver4を使用して生成された関連アセンブリを比較します。ベンチマーク実行では-march=nativeを使用しました。アセンブリ抜粋ではznver4を使用しているため、ターゲットは明示的です。-ffast-mathの部分が重要です。これは、コンパイラが積極的で、潜在的に損失のある浮動小数点演算の仮定を可能にするため[12][13]、この例では正の有限入力のみを想定し、すべての厳密なIEEE浮動小数点エッジケースを保持しません。

Q_rsqrt(float):
        movd    eax, xmm0
        sar     eax
        mov     ecx, 1597463007
        sub     ecx, eax
        mulss   xmm0, dword ptr [rip + .LCPI0_0]
        movd    xmm1, ecx
        movdqa  xmm2, xmm1
        mulss   xmm2, xmm1
        mulss   xmm0, xmm2
        addss   xmm0, dword ptr [rip + .LCPI0_1]
        mulss   xmm0, xmm1
        ret

naive_rsqrt(float):
        vrsqrtss        xmm1, xmm0, xmm0
        vmulss  xmm0, xmm0, xmm1
        vfmadd213ss     xmm0, xmm1, dword ptr [rip + .LCPI1_0]
        vmulss  xmm1, xmm1, dword ptr [rip + .LCPI1_1]
        vmulss  xmm0, xmm1, xmm0
        ret
ベンチマーク

理論的には理にかなっていますが、現時点でも真実でしょうか?

ベンチマーク時間 (スカラー)時間 (n=1024)時間 (n=65536)
Q_sqrt380 ns24.5 ns1865 ns
naive_rsqrt373 ns25.0 ns2161 ns

スカラーケースは実質的に引き分けで、明白なバージョンがわずかに先行しています。配列カーネルでは、Quakeバージョンはこの特定の実行ではいくらか高速ですが、トリックをデフォルトとして正当化するほどではありません。ソースは不明瞭で、有用なドメインが狭く、コンパイラとCPUがすでに大変な作業を行っているからこそ競争力があるのです。さらに、単純な方法では誤差の明示的な境界が提供されます。

まとめ

コンパイラに作業を任せましょう。同等のパフォーマンス、より明確なコード、そして意味を伝える実装が得られます。

Popcountとビット操作

C++20は<bit>を提供しました:std::popcount、std::countl_zero、std::countr_zero、std::bit_width、std::has_single_bitなど[14]。x86では、関連するターゲット機能が有効になっている場合、これらの多くは単一の命令にマッピングされます。

関数x86-64 (BMI/POPCNT)ARMv8
std::popcountpopcntcnt + addv
std::countl_zerolzcntclz
std::countr_zerotzcntrbit + clz

比較してください。

constexpr int modern(std::uint64_t x) noexcept {
  return std::popcount(x);
}

constexpr int kernighan(std::uint64_t x) noexcept {
  int c = 0;
  while (x != 0U) {
    x &= x - 1U;
    ++c;
  }
  return c;
}

constexpr int swar(std::uint64_t x) noexcept {
  x = x - ((x >> 1) & 0x5555'5555'5555'5555ULL);
  x = (x & 0x3333'3333'3333'3333ULL) + ((x >> 2) & 0x3333'3333'3333'3333ULL);
  x = (x + (x >> 4)) & 0x0f0f'0f0f'0f0f'0f0fULL;
  return static_cast<int>((x * 0x0101'0101'0101'0101ULL) >> 56);
}

-march=nativeとpopcntが利用可能な場合、pop_modernは1つの命令になります。さらに興味深いのは、最新のコンパイラが古いトリックをpopcountとして認識する可能性があることです。このベンチマーク構成では、KernighanループとSWARバージョンもpopcntに収束します。ターゲット命令がない場合、違いが再び現れます。Kernighanはデータ依存ループですが、SWARは短いシフトとマスクのシーケンスです。標準のスペルは、どちらの場合も意図を明示します。

C++20より前は、GCC/Clangで__builtin_popcountll、MSVCで__popcnt64を使用できました。std::popcountはポータブルなスペル[15]であり、ハードウェアpopcntを持たないターゲットでは、実装が効率的なソフトウェアフォールバックを提供することもできます。

ベンチマーク
ベンチマーク時間
BM_popcount_modern94.5 ns
BM_popcount_kernighan94.5 ns
BM_popcount_swar94.5 ns
まとめ

<bit>を使用してください。ただし、それを含まないスタンドアロンの組み込み環境をターゲットにしている場合を除きます。

数値計算レシピと行ポインタ

受け継がれた知恵の一部は、行列への行ポインタアクセスがインデックス計算よりも高速であるということです。これは、乗算が高価で、アドレス生成ハードウェアが能力が低く、コンパイラがインデックス計算を簡略化する余地が少なかった頃は信じやすかったでしょう。

『Numerical Recipes in C』(Pressらによる有名な赤い本)もこのスタイルを普及させるのに役立ちました。そのdmatrix/nrutilヘルパーは行の間接参照を使用するため、アルゴリズムは[i][j]アドレス指定で記述でき、数学的表記を維持し、Fortranからの転記をより直接的にします。それは妥当なインターフェースの選択肢になり得ますが、それ自体がパフォーマンスの向上ではありません。

興味のある読者のために、ベンチマークコードには3つの行列クラスの実装が含まれています。

  • flat_matrix(アクセスは乗算で行われ、データは連続しています)
  • nr_matrix(アクセスは行ポインタの逆参照で行われ、データは連続しています)
  • scattered_matrix(nr_matrixと同じですが、データは連続して格納されていません。行間にいくつかのジャンクが割り当てられています)

nr_matrixとscattered_matrixはoperator[]を定義し、float *を返します。どちらもポインタの配列を格納します。これは行を指しており、operator[]はインデックスされた行ポインタを返します。

ベンチマーク

これらの行列に対して2つのカーネルを実行します。行メジャー順の合計と列メジャー順の合計です。主な結果は「乗算は無料」でも「行ポインタは常に悪い」でもありません。レイアウトとトラバーサル順序が支配的であるということです。連続したフラットレイアウトとNumerical Recipesスタイルのレイアウトは互いに近いです。意図的に散らばったレイアウトは、特にワーキングセットが大きくなると、崩壊します。

ベンチマーク時間 (400 x 400)時間 (4000 x 4000)
flat_matrix 行メジャーカーネル6062 ns987614 ns
nr_matrix 行メジャーカーネル6065 ns987632 ns
scattered_matrix 行メジャーカーネル6171 ns2323394 ns
flat_matrix 列メジャーカーネル33148 ns11258036 ns
nr_matrix 列メジャーカーネル36418 ns11450827 ns
scattered_matrix 列メジャーカーネル39054 ns14800609 ns
まとめ

巧妙に見える、または歴史的に馴染みがあるという理由だけで間接参照を避けてください。連続したストレージとそれに一致するトラバーサルパターンを優先してください。可能であれば、独自の線形代数カーネルを書くことは避けてください。Eigen、BLAS/LAPACK、GLM、またはベンダーチューニングされたライブラリが通常はより良い出発点になります。

const&の多用 vs 意図の転送

多くの人が受け継いだもう一つの習慣は、「常にconst&で渡す。コピーは高価だ」というものです。

関数が引数を単に観察するだけであれば、これは依然として良いルールです。

double norm(std::vector<double> const& xs);

しかし、ラッパーコードにとっては間違った抽象化です。関数の仕事が引数を他のものに渡すことである場合、const&は情報を破壊します。rvalueはconst lvalueになり、ムーブ構築が無効になります。オーバーロード解決が変更され、呼び出し元の意図が失われます。

emplaceスタイルのラッパーの古いバージョンを考えてみましょう。

template <class T>
class bag {
public:
  template <class... Args>
  T& emplace(Args const&... args) {
    return xs_.emplace_back(args...);
  }

private:
  std::vector<T> xs_;
};

これは無害に見えますが、微妙にパフォーマンスを低下させます。呼び出し元が次のように書いても:

b.emplace(std::string(1024, 'x'));

emplace_bad内では、引数はstd::string const&になります。ベクトルはそこから移動できません。コピーする必要があります。

最新バージョンは呼び出し元の値カテゴリを保持します。

template <class T>
class bag {
public:
  template <class... Args>
  T& emplace(Args&&... args) {
    return xs_.emplace_back(std::forward<Args>(args)...);
  }

private:
  std::vector<T> xs_;
};

これで、lvalueはlvalueのままで、rvalueはrvalueのままで、オーバーロード解決は呼び出し元が実際に書いたものを見ることができます。

同じ区別は、現代のC++ API全体に現れます。

// 観察:const&はOK
void draw(widget const& w);

// 消費/保存:値渡しは素晴らしい場合がある
void set_name(std::string name) {
  name_ = std::move(name);
}

// コンストラクタ転送:転送参照が適切なツール
template <class... Args>
auto make_widget(Args&&... args) {
  return widget(std::forward<Args>(args)...);
}
ベンチマーク
ベンチマーク時間 (n=64)時間 (n=1024)時間 (n=4096)
const &を使用12.2 ns18.6 ns72.1 ns
パーフェクトフォワーディングを使用6.55 ns8.74 ns31.0 ns

この例では、パーフェクトフォワーディングがconst参照引数よりも優れていることがわかります。これは、内部のベクトルに文字列を配置する際にコピーを省略できるためです。

まとめ

これは「決してconst&を使用しない」という意味ではありません。より正確には:

  • 既存のオブジェクトを観察する場合はT const&を使用します。
  • 独自のコピーが必要で、内部で移動する場合は値渡しTを使用します。
  • 明示的なシンクにはT&&を使用します。
  • 汎用転送ラッパーには転送参照を使用します。

古いC++は、意味を伝える方法が少なかったため、const&が普遍的な反射神経になりました。現代のC++は、より良い語彙を提供します。型システムを使用して意図を保持してください。

パート2:ライブラリ

現代のC++標準ライブラリは大幅に改善されました。STLが推奨されない、ラップされている、あるいは完全に禁止されている場所で働くエンジニアにほとんどの人が会ったことがあります。再考する時期かもしれません。標準アルゴリズムとコンテナは、より読みやすく、よりテストされ、ますます最適化されています。

Rangesとアルゴリズム

簡単なタスクを考えてみましょう。

生の電圧サンプルが与えられた場合、ミリボルトに校正し、ターゲットからの残差を計算し、それを二乗し、重みを適用し、コストを合計する

inline double raw_loop(std::span<double const> xs) noexcept {
  double sum = 0.0;

  for (double volts : xs) {
    auto mv  = calibrated_mv(volts);
    auto err = residual(mv);
    sum += weighted_square(err);
  }

  return sum;
}

inline double algorithm_call(std::span<double const> xs) noexcept {
  return std::accumulate(
    xs.begin(),
    xs.end(),
    0.0,
    [](double acc, double volts) {
      auto mv  = calibrated_mv(volts);
      auto err = residual(mv);
      return weighted_square(err) + acc;
    });
}

inline double ranges_pipeline(std::span<double const> xs) noexcept {
  auto costs = xs
    | std::views::transform(calibrated_mv)
    | std::views::transform(residual)
    | std::views::transform(weighted_square);

  return std::ranges::fold_left(costs, 0.0, std::plus<double>{});
}

これは意図的に小さくされています。また、オプティマイザにとって良いケースとして意図的に作られています。変換は単純で、可視的で、インライン化可能です。std::ranges::fold_leftはビューパイプライン[16]上の左折り畳みです。これはf(f(f(f(init, x1), x2), ...), xn)に相当します。その設定では、抽象化はほとんど消えます。

ベンチマーク
ベンチマーク時間 (n=1024)時間 (n=65536)
生ループ36.0 ns2400 ns
<algorithm>を使用36.0 ns2395 ns
<ranges>を使用37.9 ns2417 ns

ベンチマークは同じ話をしています。3つのバージョンすべてが実質的に同等です。Rangesパイプラインは小さいケースではわずかに遅れ、大きいサイズではノイズの範囲内です。それがポイントです。より表現力豊かなバージョンは、ここでは劇的な抽象化のペナルティを払っていません。

まとめ

最新のライブラリアルゴリズムを使用してください。手書きループよりも常に優れているとは限りませんが、多くの場合、それらに匹敵し、プログラムがコンパイラにとって推論しやすくなります(そして私の目には、読みやすくなります)。

注:Clang 21.1.0とGCC 13.2時代のlibstdc++(GLIBCXX_3.4.32)でstd::views::filterを使用した際にパフォーマンスの低下が観測されました。概念的にはfilterに問題はありません。これは標準ライブラリが改善を続けている実装の詳細の1つです。

例外 vs std::expected vs エラーコード

C++23のstd::expected<T, E>は、失敗する可能性のある操作のための和型(sum type)を提供します[17]。受け継がれた知恵は、「例外は遅い、エラーコードを使え」と言います。現実はよりニュアンスがあります。

3つの実装を見てみましょう。

// ケース1:例外をエラー処理メカニズムとして使用
int parse_throws(std::string_view s) {
  int v{};
  auto const* end = s.data() + s.size();
  auto [ptr, ec] = std::from_chars(s.data(), end, v);
  if (ec != std::errc{} || ptr != end) {
      throw std::runtime_error("bad parse");
  }
  return v;
}

// ケース2:成功または失敗をエンコードするstd::expectedを返す
std::expected<int, std::errc> parse_expected(std::string_view s) noexcept {
  int v{};
  auto const* end = s.data() + s.size();
  auto [ptr, ec] = std::from_chars(s.data(), end, v);
  if (ec != std::errc{}) return std::unexpected(ec);
  if (ptr != end) return std::unexpected(std::errc::invalid_argument);
  return v;
}

// ケース3:アウトパラメータでエラーコードを返す
int parse_errc(std::string_view s, std::errc& err) noexcept {
  int v{};
  auto const* end = s.data() + s.size();
  auto [ptr, ec] = std::from_chars(s.data(), end, v);
  if (ec != std::errc{}) {
    err = ec;
  }
  else if (ptr != end) {
    err = std::errc::invalid_argument;
  } else {
    err = std::errc{};
  }
  return (err != std::errc{}) ? 0 : v;
}
分析
  • 例外:現代のItanium ABIスタイルの例外処理は、しばしば「何もスローされない場合はゼロコスト」[18]と説明されます。アンワインドテーブルはオフラインで保存されるため、一般的なパスはスタックアンワインドのコストを支払いません。ホットループにインライン化された成功したparse_throws呼び出しは、呼び出し元、オプティマイザ、および例外処理領域に応じて、parse_errcと非常によく似て見えることがあります。ただし、呼び出しが例外処理領域内に入ったり、コンパイラが透過できない最適化境界を越えたりすると、生成されるコードはランディングパッドとアンワインドメタデータを増やす可能性があります。これはインライン化やその他の最適化を妨げる可能性があります。
  • std::expected:
    • 戻り値は{値、has_valueフラグ}のペアと考えることができます。重要なのは、std::expectedはnoexceptフレンドリーであり、インライナーは境界を越えるパスが容易であることです。has_value()での分岐も、分岐予測や投機的実行と相性が良いです。
  • エラーコード:
    • std::expectedに似ていますが、より醜いです。また、アウトパラメータがエイリアス解析に参加するため、オプティマイザへの要求も多くなります。さらに重要なのは、コードには結果を検査することを呼び出し元に強制するセマンティックな制約がないことです。
コールドパスが重要

エラーが一般的である場合(例えば、HTTPリクエストの解析)、例外は問題になります。各スローはスタックをアンワインドします。std::expectedは通常の制御フローのままです。タグ付きユニオンのチェックと分岐です。3つの解析関数のすべてで、ソースはecとptr == endの両方をチェックします。std::from_charsは有効なプレフィックスの後に停止することが許可されているため、ecのみをチェックすると"123abc"のような文字列を受け入れてしまいます[19]。

ベンチマーク

ベンチマークは上記のparse_関数を実行します。各関数について、3セットの入力が提供されます。範囲外/無効なコンテンツが0%、5%、30%の入力です。

ベンチマーク時間 (0%)時間 (5%)時間 (30%)
例外3770 ns26971 ns154762 ns
std::expected3553 ns3403 ns2338 ns
std::errc アウトパラメータ3608 ns3430 ns2347 ns

このベンチマークでは、非スローのエラーパスは失敗時にあまり有用な作業を行わないため、失敗率が上がるにつれてexpectedとerrcのケースが速くなる理由を説明しています。それをベンチマークのアーティファクトとして扱ってください。例外ケースは重要な点を示しています。スローはコールドパスのメカニズムであり、コールドでなくなる場合に高価になります。実際、std::expectedとstd::errcはどちらもオーバーヘッドが非常に少ないため、解析する入力が少なくなる(早期終了のため)効果が実際に現れています。

まとめ

5%の例外率でも、実行時間は約1桁増加します。

  • 期待される失敗(解析、ルックアップ、変換、検証)にはstd::expectedを使用します。
  • 例外的な失敗(メモリ不足、起動時の回復不能な設定エラーなど)には例外を使用します。

現代のC++には、通常の失敗可能性のためのファーストクラスの型があり、たとえ低い失敗率のシナリオでも例外を上回る能力があることが明らかです。

仮想 vs 静的ポリモーフィズム

仮想ディスパッチがパフォーマンスのペナルティを発生させる理由は数多くあります。通常の関数呼び出しは数命令(またはインライン化されていればゼロ)で済むかもしれませんが、仮想ディスパッチの場合、以下のすべてまたは一部を行う必要があるかもしれません。

  1. オブジェクトからvptrをロードする(1回のロード、通常はL1キャッシュ常駐)
  2. vtableから関数ポインタをロードする(1回のロード、通常はL1キャッシュ常駐)
  3. 間接呼び出し(分岐予測により1〜20+サイクル)

これらの各ステップは、キャッシュミス(さらに悪いことに、TLBミス)のサイコロを転がします。さらに、デ・バーチャライゼーションの機会がない限り、インライン化は発生しません。これは、他の多くの最適化を排除する可能性もあります。

代替アプローチは、キュリアス・テンプ​​レート・パターン(CRTP)でしょう。これは、ある種のポリモーフィズム(しばしば静的ポリモーフィズムと呼ばれる)を提供しますが、std::vectorのような基底型では常に機能するわけではありません。しかし、std::variant(C++17の和型)を使用して、これらのケースでのディスパッチを処理できます。std::variant<A, B, C>に対するstd::visitは、アクティブな代替のスイッチに低下します。各分岐はオプティマイザから見えるようになります。実際、ディスパッチは通常の関数呼び出しになり、したがってすべての通常の最適化が適用できます。

例

個々の構造体の実装を削減しました(ベンチマークソースコードを参照)。

struct shape {
  virtual ~shape() = default;
  virtual double area() const = 0;
};

struct circle final : shape { ... };

struct square final : shape { ... };

struct circle_v { ... };
struct square_v { ... };

struct shape_v : std::variant<circle_v, square_v> {
  using variant::variant;

  double area() const {
    return std::visit([](auto &&x) {return x.area();}, *this);
  }
};
ベンチマーク

ベンチマークは、std::vectorのstd::unique_ptr<shape>とstd::vector<shape_v>をそれぞれインスタンス化します。次に、各ベンチマークは、すべての要素に対して->area()または.area()を呼び出します。

ベンチマーク時間 (n=1024)時間 (n=1000000)
ポインタのvector3824 ns4330980 ns
バリアントのvector142 ns149928 ns

このベンチマークはディスパッチコストを分離していません。これを「仮想呼び出し対std::visit」として読むのは誤解を招きます。測定しているのは、より一般的な本番パターン、つまりホットループ内のstd::vector<std::unique_ptr<base>>と、同じ閉じた型のセットの値ベースの表現との比較です。

仮想バージョンは所有ポインタを格納し、それらをヒープ経由で追跡します。バリアントバージョンは値を連続して格納し、キャッシュとプリフェッチャーの作業を大幅に容易にします。したがって、ベンチマークは設計全体の形状を測定します。割り当て戦略、レイアウト、ローカリティ、インライン化の機会、およびディスパッチです。この場合、レイアウトはおそらくディスパッチメカニズム自体よりも多くの作業を行っています。

それは例の欠陥ではありません。それがポイントです。「仮想呼び出しは遅い」ということは、クリーンで孤立したディスパッチ問題として遭遇することはめったにありません。日常的なC++では、ポインタを多用する所有権、ヒープ割り当て、および不透明な呼び出し境界として現れることがよくあります。セットが閉じている場合、std::vector<std::unique_ptr<base>>をstd::vector<std::variant<...>>に置き換えることで、カスタムアロケータやより洗練されたオブジェクトプールスキームに手を伸ばすことなく、ローカリティをすぐに改善できます。

まとめ

ディスパッチメカニズムは、(a)データレイアウトと(b)オプティマイザが呼び出しを透過できるかどうかに比べて、ほとんどノイズです。仮想ディスパッチは、翻訳単位境界を越える粗粒度のポリモーフィズムには適しています(例:dlopen経由でロードされるプラグイン)。閉じたセットの同様にサイズの型に対する細粒度のホットループポリモーフィズムの場合、std::variantはしばしばより良い現代C++の選択肢です。開いた拡張ポイント、ABI境界、およびプラグインシステムの場合、仮想ディスパッチは依然として適切なツールです。

ベンチマークの使い方

これらのテストを自分で実行したい場合は、次を実行することで再現できます(ただし、結果は異なる場合があります)。

git clone https://github.com/Categorica/blog_artefacts.git
cd 20260626_trust_your_compiler
cmake -B build -DCMAKE_BUILD_TYPE=Release 
  -DCMAKE_CXX_FLAGS="-Wno-nan-infinity-disabled -O3 -ffast-math -funsafe-math-optimizations -march=native -mtune=native"
cmake --build build -j

注:nan-infinity-disabled警告は、fast-mathフラグでビルドする際のGoogle BenchmarkのJSONレポーターから発生します。

テストを実行する際は、一貫した結果を得るためにCPU周波数スケーリングを無効にすることが理想的です(ただし、これは著しいパフォーマンス低下を招きます)。さらに、ベンチマークプロセスを特定のコアにアフィニする(理想的には通常のカーネルスケジューリングから分離されたコアに)ためにtasksetのようなものを使用すると、最も再現性の高い結果が得られます。

結びの言葉

これらの例すべてに共通するパターンがあります。オプティマイザは意図を報酬し、不明瞭さを罰します。-ffast-mathのような寛容な浮動小数点フラグを使用すると、1.0f / std::sqrt(x)は逆平方根推定と洗練に変わる可能性があります。std::popcountはpopcntになる可能性があります。単純なレンジ変換の連鎖は、タイトなベクトルループになる可能性があります。コードが意味を伝えるほど、コンパイラとライブラリが支援する余地が大きくなります。

その対偶は、最初の最適化はしばしば巧妙なコードを削除して明白なことを書くことであるということです。プロファイルを取り、次に重要な部分を最適化します。std::expected、std::variant、<bit>、std::bit_cast、ranges、および標準アルゴリズムのようなツールを検討してください。コンパイラは過去20年間で大幅に改善されており、現代のC++と標準ライブラリを使用すると、望ましい意図を直接表現することが容易になります。

現在C++23(C++26のプレビルド)でコーディングしている場合、おそらくこれらのいずれもあなたにとって驚きではないでしょう。長年C++から離れていて戻ってきた場合、または古いバージョンに慣れている場合は、単純なコードで現代のC++で良いパフォーマンスを得るのは驚くほど簡単です。

要するに:コンパイラを信頼してください!

さらに読む
注釈

  1. https://betterexplained.com/articles/understanding-quakes-fast-inverse-square-root/↩
  2. https://en.wikipedia.org/wiki/XOR_swap_algorithm↩
  3. https://en.wikipedia.org/wiki/Loop_unrolling↩
  4. https://en.wikipedia.org/wiki/Duff%27s_device↩
  5. https://lemire.me/blog/2016/05/23/the-surprising-cleverness-of-modern-compilers/↩
  6. ご自身のハードウェアで実行してください:ここでのサンプル数値は参考であり、決定的なものではありません。特に断りのない限り、以下の表は、このマシンでの1回の実行からのGoogle Benchmark CPU時間を示しています。周波数スケーリングがマシンで有効になっており、これらの数値にある程度のばらつきが生じています。↩
  7. Quake III Arena q_math.c: https://github.com/id-Software/Quake-III-Arena/blob/master/code/game/q_math.c↩
  8. 過去のx86タイミングテーブル:https://kluge.in-chemnitz.de/docs/notes/asm_timing.php↩
  9. RSQRTSS/VRSQRTSS命令リファレンス:https://www.felixcloutier.com/x86/rsqrtss↩
  10. Agner Fogの命令テーブル:https://www.agner.org/optimize/instruction_tables.pdf↩
  11. Arm A64 FRSQRTE: https://developer.arm.com/documentation/ddi0487/latest↩
  12. Clangユーザーマニュアル、fast-mathモード:https://clang.llvm.org/docs/UsersManual.html↩
  13. GCC最適化オプション、-ffast-math:https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html↩
  14. C++ <bit>ヘッダー:https://en.cppreference.com/w/cpp/header/bit↩
  15. std::popcount: https://en.cppreference.com/w/cpp/numeric/popcount↩
  16. std::ranges::fold_left: https://en.cppreference.com/w/cpp/algorithm/ranges/fold_left↩
  17. std::expected: https://en.cppreference.com/w/cpp/utility/expected↩
  18. LLVM例外処理ドキュメント:https://llvm.org/docs/ExceptionHandling.html↩
  19. std::from_chars: https://en.cppreference.com/w/cpp/utility/from_chars↩