# CPUとGPUは何が違うのか — パイプライン・アウトオブオーダー実行・SIMT・Rooflineを数式と実測で読み解く

> CPUは分岐予測やアウトオブオーダー実行で少数の処理を速く終わらせ、GPUは大量のwarpを切り替えて待ち時間を隠します。SIMT・warp divergence・メモリ合体・Rooflineを数式で解説し、PCIe転送込みでGPUに移して得かを理論値で試算します。

- 公開日: 2026-11-17
- 著者: 友田 陽大
- タグ: アーキテクチャ設計, パフォーマンス, インフラ, AI, 技術選定
- URL: https://tomodahinata.com/blog/cpu-vs-gpu-architecture-pipeline-simt-roofline-explained
- カテゴリ: NVIDIA・GPU・AI半導体
- 総合ガイド: https://tomodahinata.com/blog/nvidia-gpu-ai-tensor-core-fp8-hbm-nvlink-explained

## 要点

- CPUはレイテンシ重視の設計で、分岐予測・投機実行・アウトオブオーダー実行に回路を使い、1本の命令列をできるだけ早く進める。
- GPUはスループット重視の設計で、命令を順番どおりに発行し、分岐予測も投機実行もしない。代わりに32スレッドのwarpを大量に切り替えて待ち時間を隠す。warpの中で分岐が割れると両方の経路を順に実行し、隣り合うスレッドが離れた番地を読むと、メモリの転送量が必要な量の最大8倍になる。
- Xeon Platinum 8480+（1ソケット）とH100 SXM5の非Tensor Core演算のRidge Pointは同じ桁にある。CPUの周波数の基準しだいで、「ほぼ同じ」（基本2.0 GHzで23.3対20.0 FLOP/byte）から「CPUが約2倍右」（最大ターボ3.8 GHzで44.3）まで動く（理論値）。
- データがホストにある場合、SAXPYはPCIe転送だけでCPUの計算時間の約4.8倍かかり、GPUに移すと損をする。行列積は、一辺が約750〜1,600（CPUの周波数の仮定による）を超えると転送込みでも得になる（理論値）。
- 「GPUはCPUの100倍速い」という主張の多くは、最適化していないCPUコードとの比較だった。両方を最適化したLeeらの2010年の測定では、差は平均2.5倍だった（転送時間を除いた上限値）。

---

「GPUはCPUより速い」とよく言われます。では、なぜ速いのでしょうか。そして、なぜいつも速いわけではないのでしょうか。

「CPUのコアは数十個、GPUのコアは数千個だから」という説明は半分だけ正しく、残りの半分は誤解を生みます。CPUのコアとGPUのCUDAコアは、数えている単位が違うからです。この記事では、**CPUとGPUがそれぞれ何のために回路を使っているか**から違いを説明します。

**結論から言うと**、CPUは「少数の命令列を、1本ずつできるだけ早く終わらせる」ために回路を使います。分岐の行き先を予想して先に進め（分岐予測・投機実行）、命令の順番を入れ替えて空いている演算器を埋めます（アウトオブオーダー実行）。GPUはそうした仕組みを持ちません。代わりに数千のスレッドを用意し、あるスレッドがメモリを待っている間に別のスレッドを動かして、待ち時間そのものを隠します。前者を**レイテンシ重視**、後者を**スループット重視**と呼びます。

| 用語 | 一言で | 詳しくは |
|---|---|---|
| アウトオブオーダー実行 | 依存のない命令を、プログラムの順番を入れ替えて先に実行するCPUの仕組み | 3節 |
| 分岐予測・投機実行 | 分岐の結果を予想し、結果が出る前に先の命令を実行しておく仕組み | 4節 |
| warp / SIMT | GPUが32スレッドを1組にして、同じ命令を一斉に実行する方式 | 7・8節 |
| Roofline | 演算性能とメモリ帯域のどちらが速さの上限を決めるかを示すモデル | 11節 |

後半では、Rooflineモデル、Amdahlの法則、PCIeの転送時間を組み合わせて、「この処理をGPUに移すと得か」を理論値で試算します。

この記事の数値は、メーカーの公称値か、そこから筆者が計算した**理論値**です。筆者の手元（Apple M4 Pro）で実際に動かしたのは、CPUの分岐予測と命令レベル並列性を確かめるC++のプログラムだけです。GPUのコードは書いただけで、まだ実行していません。筆者のGPUの実務経験は、Tesla T4 1枚でvLLMとQwen3-8B-AWQを動かす推論基盤の規模です。

経営・発注の立場の方は、結論と11・12・15節を先にお読みください。要点は3つです。①コア数の比較で機材を選ばない（11節）。②データがCPU側にある軽い処理は、GPUに移すと遅くなることがある（12節）。③「GPUで100倍」という提案は、比較の条件を確かめる（13節）。

GPUがAIに強い理由のうち、Tensor Core・低精度の数値形式・HBMとLLM推論の関係・NVLinkについては、[NVIDIAのGPUはなぜAIに強いのか](/blog/nvidia-gpu-ai-tensor-core-fp8-hbm-nvlink-explained)で扱いました。この記事はその手前にある、CPUとGPUの基本設計の違いに絞ります。

## 1. 実行時間の基本式：T = IC × CPI / f

最初に用語を1つ分けておきます。**ISA**（命令セットアーキテクチャ）は、どんな命令があり、実行すると何が起きるかというソフトウェアとの約束ごとで、x86-64やArmv8/Armv9がこれにあたります。**マイクロアーキテクチャ**は、そのISAを回路でどう実現するかです。Intelの最適化マニュアルは、同じIntel 64のISAを実装するGolden CoveやRedwood Coveといった複数のマイクロアーキテクチャを説明しており、同じプログラムが世代の違うCPUで速さだけ変わって動くのはこのためです。以降の話のほとんどは、マイクロアーキテクチャの話です。

プログラムの実行時間は、3つの数の掛け算で表せます。

$$
T = \frac{IC \times CPI}{f}
$$

- $T$：実行時間 [秒]
- $IC$：実行した命令の数（Instruction Count）[命令]
- $CPI$：1命令あたりにかかる平均のクロックサイクル数（Cycles Per Instruction）[サイクル/命令]
- $f$：クロック周波数 [サイクル/秒＝Hz]

たとえば10億命令のプログラムを、CPI 0.5（1サイクルに平均2命令）、4 GHzのCPUで実行すると、次のようになります（数値は説明用の仮定です）。

$$
T = \frac{10^9 \times 0.5}{4 \times 10^9} = 0.125\ \mathrm{s}
$$

速くする方法は3つしかありません。命令を減らす（アルゴリズムやSIMD命令）、CPIを下げる（1サイクルに多くの命令を処理する）、周波数を上げる、のどれかです。

周波数は消費電力と発熱の制約で頭打ちになりやすく、それだけには頼れません。CPUとGPUは、**CPIを下げる工夫**と**コアやスレッドを増やす工夫**に、異なる比重で回路を配分した結果だと考えると見通しがよくなります。

## 2. パイプライン：命令を流れ作業にする

### 3段の流れ作業

CPUは1つの命令を、いくつかの段階に分けて処理します。最も単純に分けると次の3段です。

1. **フェッチ**（fetch）：メモリ（実際には命令キャッシュ）から次の命令を読む
2. **デコード**（decode）：命令を解読し、何をすべきか、どのレジスタを使うかを決める
3. **実行**（execute）：演算器で計算する

命令1が「実行」に進んだら、同時に命令2を「デコード」し、命令3を「フェッチ」します。洗濯機と乾燥機を1台ずつ持つ家で、1回目の洗濯物を乾燥機に入れたらすぐ2回目を洗濯機に入れるのと同じです。これを**パイプライン**と呼びます。理想的には、1サイクルに1命令が完了し、CPIは1に近づきます。

### パイプラインを止める3種類のハザード

流れ作業は、前後の命令が独立しているときにしかうまく回りません。流れを止める原因を**ハザード**と呼び、3種類あります。

- **構造ハザード**：同じ演算器やメモリの口を、2つの命令が同時に使おうとする
- **データハザード**：ある命令が、前の命令の結果を必要とする
- **制御ハザード**：分岐命令の結果が出るまで、次にどの命令をフェッチすべきか決まらない

データハザードは、さらに3つに分類されます。次の命令列で考えます（`r1` などはレジスタです）。

```text
(1) r1 = r2 + r3
(2) r4 = r1 * 2      ← (1) の r1 を読む
(3) r2 = r5 - 1      ← (1) が読む r2 を上書きする
(4) r1 = r6 + r7     ← (1) が書く r1 を上書きする
```

| 種類 | 例 | 意味 | 本当の依存か |
|---|---|---|---|
| RAW（Read After Write） | (1)→(2) | 書かれた値を後で読む | 本当の依存。値が出るまで待つしかない |
| WAR（Write After Read） | (1)→(3) | 読まれる前に上書きしてはいけない | 名前の衝突にすぎない |
| WAW（Write After Write） | (1)→(4) | 書く順番を守らないと最終値が変わる | 名前の衝突にすぎない |

ここが後の話の鍵になります。**RAWは計算の中身そのものの依存ですが、WARとWAWは「同じレジスタ名を使い回した」ために生まれる見かけの依存です。** レジスタの名前を付け替えれば、WARとWAWは消せます。

## 3. スーパースカラとアウトオブオーダー実行

### スーパースカラ：1サイクルに複数の命令を

CPIを1より下げるには、1サイクルに複数の命令をフェッチ・デコード・実行すればよいはずです。演算器を複数並べ、同時に複数の命令を流す設計を**スーパースカラ**と呼びます。

具体例として、Intelの最適化マニュアルは、Golden Coveマイクロアーキテクチャ（Sapphire Rapidsなどのコア）の前世代からの変更点として、デコーダを4個から6個に増やして1サイクルに最大6命令をデコードできるようにしたこと、実行ポートを10から12に、命令の確定（retire）の幅を4から8に広げたことを挙げています。これは上限で、実際に何命令を同時に進められるかは命令どうしの依存関係で決まります。1本の命令列の中で、同時に実行できる命令がどれだけあるかを**命令レベル並列性**（ILP、Instruction-Level Parallelism）と呼びます。

### レジスタリネーミング：見かけの依存を消す

ILPを引き出す最大の障害は、2節で見たWARとWAWです。プログラムが使えるレジスタの名前（アーキテクチャレジスタ）の数はISAで決まっていて、コンパイラは少ない名前を使い回します。

そこでCPUは、内部にアーキテクチャレジスタよりずっと多い物理レジスタを持ち、命令をデコードするたびに、書き込み先に新しい物理レジスタを割り当てます。先の例で (4) の `r1` に別の物理レジスタを割り当てれば、(1) と (4) は互いを待つ必要がなくなります。これを**レジスタリネーミング**と呼びます。

### Tomasuloのアルゴリズム：1967年の原型

この考え方の原型が、IBMのR. M. Tomasuloが1967年に発表した論文 "An Efficient Algorithm for Exploiting Multiple Arithmetic Units" です。IBM System/360 Model 91の浮動小数点演算部の設計を説明したもので、要点は3つです。

1. **リザベーションステーション**：演算器の手前で、命令を入力がそろうまで待たせる。
2. **タグ**：計算中の値を「どの演算器が作る値か」を示すタグで表す。
3. **共通データバス**（CDB）：演算器は結果をタグと一緒にバスへ流し、そのタグを待つ全員が同時に受け取る。

論文の要約は、この仕組みが、命令の流れに本来ある順序関係を守りながら、独立した命令を同時に実行できるようにすると述べています。タグによる名付け直しは、現代のレジスタリネーミングと同じ働きです。

### リオーダーバッファ：順番に確定させる

順番を入れ替えて実行すると、途中で例外（ゼロ除算など）が起きたときに「どの命令までが完了したか」がはっきりしません。投機実行（4節）が外れたときは、間違った経路の結果を取り消す必要もあります。そのために、現代のCPUは**リオーダーバッファ**（ROB、Reorder Buffer）を持ちます。命令はプログラムの順番どおりにROBへ入り、実行は順不同で進みますが、結果の確定（retire）はROBの先頭から順番どおりに行います。こうすると、例外が起きた時点で「それより前の命令はすべて完了し、後の命令は何も確定していない」という状態（precise exception、正確な例外）を保てます。この考え方は、1988年のSmithとPleszkunの論文などで整理されました。

```text
フェッチ → デコード → リネーミング（物理レジスタを割り当て、ROBに順番に登録）
  → リザベーションステーションで入力待ち（順不同で発行）
  → 実行（順不同）
  → ROBの先頭から順番に確定（retire）
```

Golden Coveで「確定の幅を4から8に広げた」とあったのは、この最後の段です。

### ILPの限界とSMT

ILPには限界があります。RAWの依存の鎖があれば、どれだけ演算器を並べても、鎖の長さより速くは終わりません。そこでCPUは、複数のコアで別々の命令列（スレッド）を進めるスレッドレベル並列性（TLP）も使います。1つのコアで2本のスレッドを同時に動かす**SMT**（Intelの実装名はHyper-Threading）では、Intelのマニュアルによれば、2つの論理プロセッサがアーキテクチャレジスタを一式ずつ持ち、演算器やキャッシュを共有します。一方がキャッシュミスで止まっても、もう一方が進めます。「別のスレッドで待ち時間を埋める」発想は7節のGPUと同じで、違いは桁です。CPUのSMTは2スレッド程度、GPUは1つのSMに数十のwarp（数千スレッド）を載せます。

## 4. 分岐予測と投機実行

### 分岐のたびに止まるわけにはいかない

分岐命令の結果が出るのは実行段なので、それまで次の命令をフェッチできないとすると、その間パイプラインは空になります。パイプラインが深く幅が広いCPUほど、失う仕事は増えます。

そこでCPUは、分岐の結果を**予測**し、予測した側の命令を先にフェッチして実行してしまいます。これが**投機実行**（speculative execution）です。予測が当たれば、待ち時間はゼロです。外れたら、間違った経路の命令をすべて捨て（ROBのおかげで、確定前の結果は取り消せます）、正しい経路からやり直します。このやり直しのコストが**分岐予測ミスのペナルティ**です。

分岐予測器は過去の履歴から次を予想するので、ループの終了判定のような規則的な分岐はほぼ当たり、データによって結果がランダムに変わる分岐は外れます。

### 分岐をなくすという選択肢

Intelのマニュアルは、分岐予測の最適化として「可能な限り分岐をなくす」ことを最初に挙げ、条件付き転送命令（CMOV）やSETCCで分岐を置き換える方法を示しています。ただし、その使いどころには明確な条件を付けています。

- 予測しにくい分岐にだけ使う。予測しやすい分岐には使わない。
- CMOVは両方の経路を計算するので、その分の実行コストがかかる。
- 分岐をCMOVに変えると、制御の依存がデータの依存に変わり、アウトオブオーダー実行の自由度を狭める。
- Intelのプロセッサの分岐予測率は通常とても高く、一貫して外れる分岐はまれである。

つまり、分岐をなくすのは「予測ミスのコストが、両方を計算するコストより大きいとき」に限る、ということです。この判断はコンパイラも自動で行います。5節の実験で、それが実際に起きる様子を見ます。

### GPUはこの仕組みを持たない

ここで、GPUとの最初の大きな違いが出てきます。CUDA Programming Guideは、GPUの演算ブロック（SM）について次のように書いています。

> Unlike CPU cores, SMs issue instructions in order and do not perform branch prediction or speculative execution.

GPUのSMは命令を順番どおりに発行し、分岐予測も投機実行もしません。CPUが3節と本節で説明した複雑な回路に使う面積と電力を、GPUは別のことに使っています。それが何かは7節で扱います。

## 5. 手元で確かめる：分岐予測ミスとILPのコスト

次のC++20のプログラムは2つの実験をします。

- **実験A（分岐予測）**：0〜255の乱数の配列から128以上の値だけを足し、ソート済みとソートなしで速さを比べる。ソート済みなら分岐の結果は「前半はずっと偽、後半はずっと真」になり、予測はほぼ当たる。
- **実験B（ILP）**：16 KiBの配列（L1キャッシュに収まる）を何度も足し合わせ、累積用の変数を1・2・4・8個に分けて速さを比べる。

前提は次のとおりです。

- 言語：C++20。依存は標準ライブラリだけ。
- コンパイラ：Clang または GCC（分岐を残すために、GCC/Clang の拡張である `asm volatile` を1か所使っています。MSVCではビルドできません）。
- 実行環境：筆者は Apple M4 Pro（arm64、macOS 27.0.1、Apple clang 21.0.0）で実行しました（x86-64 の Linux では未検証です）。
- ビルドと実行：`clang++ -std=c++20 -O2 cpu_pipeline_demo.cpp -o cpu_pipeline_demo && ./cpu_pipeline_demo`

```cpp
// cpu_pipeline_demo.cpp — 分岐予測と命令レベル並列性（ILP）を体感する C++20 プログラム
// ビルド: clang++ -std=c++20 -O2 cpu_pipeline_demo.cpp -o cpu_pipeline_demo
// 実行:   ./cpu_pipeline_demo
// 注意:   asm volatile は GCC/Clang の拡張です（MSVC では使えません）。
#include <algorithm>
#include <chrono>
#include <cstdint>
#include <cstdio>
#include <random>
#include <vector>

namespace {

using Clock = std::chrono::steady_clock;

// f を reps 回測り、1要素あたりのナノ秒の中央値を返す
template <class F>
double median_ns_per_elem(F&& f, std::size_t elems, int reps = 7) {
  std::vector<double> t;
  for (int r = 0; r < reps; ++r) {
    const auto t0 = Clock::now();
    f();
    const auto t1 = Clock::now();
    t.push_back(std::chrono::duration<double, std::nano>(t1 - t0).count() / elems);
  }
  std::sort(t.begin(), t.end());
  return t[t.size() / 2];
}

// (A1) 素直な書き方。-O2 の Clang はこれをベクトル化し、分岐を消してしまう
long long sum_naive(const std::vector<std::uint8_t>& d) {
  long long s = 0;
  for (std::uint8_t v : d)
    if (v >= 128) s += v;
  return s;
}

// (A2) 分岐を残した版。中身の空の asm volatile は投機的に実行できないため、
//      コンパイラは if を条件選択（csel/cmov）やベクトル化に置き換えられない
long long sum_branchy(const std::vector<std::uint8_t>& d) {
  long long s = 0;
  for (std::uint8_t v : d) {
    if (v >= 128) {
      asm volatile("" ::: "memory");
      s += v;
    }
  }
  return s;
}

// (B) 浮動小数点の総和を K 本の独立した累積変数で計算する。
//     -ffast-math なしでは、コンパイラは加算の順序を勝手に変えられない
template <int K>
double sum_k_accumulators(const std::vector<double>& a, int repeat) {
  double acc[K] = {};
  for (int r = 0; r < repeat; ++r)
    for (std::size_t i = 0; i < a.size(); i += K)
      for (int k = 0; k < K; ++k) acc[k] += a[i + k];
  double s = 0.0;
  for (int k = 0; k < K; ++k) s += acc[k];
  return s;
}

}  // namespace

int main() {
  // ---- (A) 分岐予測 ----
  constexpr std::size_t N = 1u << 24;  // 16,777,216 要素（16 MiB）
  std::mt19937 rng(42);
  std::uniform_int_distribution<int> dist(0, 255);
  std::vector<std::uint8_t> unsorted(N);
  for (auto& v : unsorted) v = static_cast<std::uint8_t>(dist(rng));
  std::vector<std::uint8_t> sorted = unsorted;
  std::sort(sorted.begin(), sorted.end());

  long long check = 0;
  std::printf("[A] branch prediction: N = %zu bytes, values uniform in [0,255]\n", N);
  struct Case { const char* name; long long (*fn)(const std::vector<std::uint8_t>&); };
  const Case cases[] = {{"naive  (compiler removed branch)", sum_naive},
                        {"branchy (branch kept)           ", sum_branchy}};
  for (const auto& c : cases) {
    long long r1 = 0, r2 = 0;
    const double tu = median_ns_per_elem([&] { r1 = c.fn(unsorted); }, N);
    const double ts = median_ns_per_elem([&] { r2 = c.fn(sorted); }, N);
    if (r1 != r2) { std::printf("result mismatch!\n"); return 1; }
    check += r1;
    std::printf("  %s unsorted %.3f ns/elem | sorted %.3f ns/elem | ratio %.1fx\n",
                c.name, tu, ts, tu / ts);
  }

  // ---- (B) 命令レベル並列性 ----
  constexpr std::size_t M = 2048;  // 2048 doubles = 16 KiB（L1 データキャッシュに収まる）
  constexpr int R = 20000;         // 合計 40,960,000 回の加算
  std::vector<double> a(M);
  for (std::size_t i = 0; i < M; ++i) a[i] = 1.0 / static_cast<double>(i + 1);
  const std::size_t adds = M * static_cast<std::size_t>(R);

  std::printf("[B] ILP: %zu FP64 adds over a 16 KiB array\n", adds);
  double s1 = 0, s2 = 0, s4 = 0, s8 = 0;
  const double t1 = median_ns_per_elem([&] { s1 = sum_k_accumulators<1>(a, R); }, adds, 5);
  const double t2 = median_ns_per_elem([&] { s2 = sum_k_accumulators<2>(a, R); }, adds, 5);
  const double t4 = median_ns_per_elem([&] { s4 = sum_k_accumulators<4>(a, R); }, adds, 5);
  const double t8 = median_ns_per_elem([&] { s8 = sum_k_accumulators<8>(a, R); }, adds, 5);
  std::printf("  1 accumulator : %.3f ns/add (1.0x)\n", t1);
  std::printf("  2 accumulators: %.3f ns/add (%.1fx)\n", t2, t1 / t2);
  std::printf("  4 accumulators: %.3f ns/add (%.1fx)\n", t4, t1 / t4);
  std::printf("  8 accumulators: %.3f ns/add (%.1fx)\n", t8, t1 / t8);
  // 加算の順序が違うので末尾の桁は一致しない（浮動小数点の加算は結合法則を満たさない）
  std::printf("  sums: %.12f %.12f %.12f %.12f\n", s1, s2, s4, s8);
  std::printf("checksum %lld\n", check);
  return 0;
}
```

筆者の環境（Apple M4 Pro、14コア＝高性能10＋高効率4、メモリ48 GB）で実行した出力の1つです。

```text
[A] branch prediction: N = 16777216 bytes, values uniform in [0,255]
  naive  (compiler removed branch) unsorted 0.053 ns/elem | sorted 0.053 ns/elem | ratio 1.0x
  branchy (branch kept)            unsorted 3.025 ns/elem | sorted 0.276 ns/elem | ratio 11.0x
[B] ILP: 40960000 FP64 adds over a 16 KiB array
  1 accumulator : 0.554 ns/add (1.0x)
  2 accumulators: 0.301 ns/add (1.8x)
  4 accumulators: 0.154 ns/add (3.6x)
  8 accumulators: 0.067 ns/add (8.2x)
  sums: 164041.575438243395 164041.575436810090 164041.575437169959 164041.575436713174
checksum 3212822356
```

同じプログラムを計6回実行したときの範囲は、分岐を残した版のソートなし／ソート済みの比が10.4〜11.0倍、累積変数8個の速度向上が6.5〜8.3倍でした。`sums` と `checksum` の行は毎回同じです。

### 結果の読み方

**実験A。** 素直に書いた `sum_naive` では、ソートの有無で速さが変わりませんでした。生成されたアセンブリを確認すると、Clangはこのループをベクトル化し、データによる条件分岐を消していました。4節で見た「予測しにくい分岐はなくす」をコンパイラが自動でやったわけです。ただし、出力の「compiler removed branch」というラベルは、筆者の環境（Apple clang、arm64）で確認したことです。別のコンパイラやx86-64では、分岐を残したり、CMOVに置き換えたりする可能性があります。分岐を消せないようにした `sum_branchy` では、ソートしないデータが約11倍遅くなりました。アセンブリには、1要素ごとの条件分岐命令（`tbz`）が残っています。

差は1要素あたり約2.7 nsです（3.025 − 0.276）。値は0〜255に一様に散らばっているので、ソートしないデータでは分岐の結果がほぼコイン投げになり、予測器がどう工夫しても半分程度は外れると考えられます。そう仮定すると、予測ミス1回あたり約5.5 ns（2.749 ÷ 0.5）のコストと見積もれます。これはあくまで仮定に基づく推定です。Appleは分岐予測ミスのペナルティのサイクル数も、負荷時のクロック周波数も公表していないので、サイクル数には換算しません。

**実験B。** 累積変数が1個だと、`acc += a[i]` の加算が前の加算の結果を待つRAWの鎖になり、加算器のレイテンシで速さが決まります。変数を分けると独立した鎖が増えます。加算器はパイプライン化されて複数あるので、独立した鎖を並行して流せます（アウトオブオーダー実行はそれを実行時に後押しします）。実際、コンパイラは独立した `fadd` 命令を交互に並べており、速さはほぼ鎖の数に比例して上がりました。4つの版はいずれもスカラーの `fadd` 命令（NEONのベクトル命令ではない）を使っていたので、速くなった理由はSIMDではなく、ILPです。

`sums` の末尾の桁が版ごとに違うのは、浮動小数点の加算が結合法則を満たさないからです。コンパイラが勝手に累積変数を分けないのも、結果が変わってしまうためです（`-ffast-math` のようなオプションで許可すれば変わります）。

### この実験の限界

- 筆者のマシンは約10のセッションが同時に動く共有の環境で、測定時のロードアベレージは約20でした。数値は傾向を見るためのもので、M4 Proの性能を代表する値ではありません。高性能コアと高効率コアのどちらで動いたかも制御していません。
- `asm volatile` で分岐を残すのは、実験のための人工的な操作です。

## 6. SIMD：1命令で複数のデータを処理する

ILPとTLPに加えて、CPUはデータレベル並列性（同じ演算を多数のデータに適用する並列性）も引き出します。そのための命令が**SIMD**（Single Instruction, Multiple Data）です。1つの命令で、幅の広いレジスタに詰めた複数の値をまとめて処理します。

- **x86のAVX系**：AVX/AVX2は256ビット、AVX-512は512ビットのレジスタを使う。512ビットのレジスタには、FP64なら8個、FP32なら16個の値が入る。
- **ArmのNeon**（Advanced SIMD）：ArmのACLE（Arm C Language Extensions）は、Armアーキテクチャの一部として定義された64ビット/128ビットのSIMD命令セットだと説明している。128ビットのレジスタには、FP32の値が4個入る（型名 `float32x4_t`）。

SIMDはCPUの理論ピーク性能を大きく左右します。CPUのFP64の理論ピークは、次のように数えられます。

$$
P_{\mathrm{peak}} = (\text{cores}) \times f \times (\text{FMA units}) \times (\text{lanes}) \times 2
$$

最後の2は、FMA（掛け算と足し算を1命令で行う）を2 FLOPと数えるためです。

具体例として、Intel Xeon Platinum 8480+（Sapphire Rapids、2023年第1四半期発売）を使います。Intelの製品仕様ページによれば、56コア、基本周波数2.00 GHz、最大ターボ周波数3.80 GHz、AVX-512のFMAユニットが2基です。Intelの最適化マニュアルも、このコア（Golden Cove）のサーバー向け製品では512ビットのFMAを2つのポートで実行できると説明しています。AVX-512のFP64は8レーンなので、基本周波数で計算した1ソケットの理論ピークは次のとおりです。

$$
56 \times 2.0 \times 10^9 \times 2 \times 8 \times 2 \approx 3.58 \times 10^{12}\ \mathrm{FLOP/s}
$$

最大ターボ周波数で計算すると約6.81 TFLOP/sです。FP32は1レーンが半分の幅なので、それぞれ2倍の約7.17 TFLOP/sと約13.62 TFLOP/sになります。

ここで、**周波数の基準**に注意が必要です。H100のホワイトペーパーは、FP32やFP64の理論ピークをGPU Boost Clock（1,980 MHz）で計算しており、注記で、データセンター向けGPUではピーククロックとブーストクロックは同じものだと説明しています。つまりGPUの値は「ピークの周波数での値」です。CPUの基本周波数で計算した値はそれより低い基準で、性質が同じ数字ではありません。

では、CPUも最大ターボで計算すればよいかというと、全コアがAVX-512を使いながら動くときの周波数は製品仕様ページに載っていません。Intelのマニュアルは、Skylake Server世代などについて、AVX-512を多用すると通常より低い周波数の上限で動く場合があると説明しています（Sapphire Rapidsについての記述ではありません）。そこでこの記事では、基本周波数と最大ターボ周波数の**2つの仮定で幅を持たせて**計算します。

なお、8480+は行列演算用のAMXも持っています（製品仕様ページで「Yes」）が、GPU側のTensor Coreと同様に比較には含めません。

## 7. GPUの設計思想：待ち時間を「隠す」

### CPUは待ち時間を「減らす」、GPUは「隠す」

ここまでのCPUの工夫は、すべて**1本の命令列の待ち時間を減らす**ためのものでした。分岐を予測して待たない、順番を入れ替えて空き時間を埋める、大きなキャッシュでメモリを待たない。GPUは逆の発想を取ります。待ち時間は減らさなくてよい。その代わり、**待っている間に別の仕事をする**。

CUDA C++ Best Practices Guideによれば、CPUのスレッドは「重く」、OSによるスレッドの入れ替え（コンテキストスイッチ）は遅くコストが高い一方、GPUのスレッドは非常に軽く、動いているすべてのスレッドに別々のレジスタがあるので切り替えにレジスタの退避が要りません。同ガイドは、CPUのコアは少数のスレッドのレイテンシを最小にし、GPUは大量の軽いスレッドでスループットを最大にするように設計されているとまとめています。

同ガイドの例では、32コアのCPUを2つ載せたサーバーが同時に実行できるスレッドは64本（SMTがあればその数倍）で、最近のNVIDIAのGPUは1つのSMで最大2,048スレッドを保持でき、SMが80個なら16万スレッドを超えます。同ガイドは、良い性能のためには一般に数千から数万の並行するスレッドが必要だとも書いています。

### SMとwarpスケジューラ

GPUの演算の基本単位が**SM**（Streaming Multiprocessor）です。H100 SXM5は132個のSMを持ちます（NVIDIAのホワイトペーパーより）。

GPUは、プログラムが起動したスレッドを32本ずつの組にまとめます。これを**warp**と呼びます。SMの中の**warpスケジューラ**は、毎サイクル、次の命令を実行できる状態にあるwarpを1つ選び、その命令を発行します。CUDA Programming Guideは、各warpの実行状態（プログラムカウンタやレジスタ）はwarpが終わるまでSMの中に置かれたままなので、warpの切り替えにはコストがかからないと説明しています。Volta世代（V100）のホワイトペーパーによれば、SMは4つの処理ブロックに分かれ、それぞれがwarpスケジューラを1つずつ持ちます。

## 8. SIMTとwarp divergence

### SIMT：1スレッドぶんのコードを書けばよい

GPUの実行方式を、NVIDIAは**SIMT**（Single Instruction, Multiple Threads）と呼びます。CUDA Programming Guideによれば、warpは一度に1つの共通の命令を実行します。SIMDとの違いは、SIMDではベクトルの幅がソフトウェアから見えるのに対し、SIMTの命令は1つのスレッドの振る舞いを指定する点です。正しさのためにはSIMTの振る舞いをほぼ無視してよいものの、warpの中でスレッドの経路が分かれないようにすると性能は大きく上がります。

SIMDでは、プログラマ（またはコンパイラ）が「8個のデータをまとめて処理する」コードを書き、条件分岐もマスクを使って自分で処理する必要があります。SIMTでは1スレッドぶんのコードを書けばよく、32本まとめて動かすのはハードウェアの仕事です。

### warp divergence：分岐が割れると両方を実行する

では、warpの中のスレッドが別々の経路に進むと何が起きるでしょうか。CUDA Programming Guideによれば、データに依存する分岐でwarpのスレッドが分かれると、warpは**通った経路を1つずつ順に実行し、その経路にいないスレッドを止めておきます**。これを**warp divergence**と呼びます。分岐が割れるのはwarpの中だけで、別のwarpどうしは独立に動きます。

```text
if (threadIdx.x % 2 == 0) { A(); } else { B(); }

warp 内の 32 スレッド:  偶数 → A、奇数 → B
実行の様子:  [A を実行、奇数スレッドは停止] → [B を実行、偶数スレッドは停止]
所要時間 ≈ A の時間 + B の時間
```

偶数・奇数で分けるとすべてのwarpが割れますが、warpの番号で分ければ（`(threadIdx.x / 32) % 2`）、各warpの中は全員が同じ経路に進み、warp divergenceは起きません。全体の仕事量は同じでも、分け方だけで速さが変わります。

CPUの分岐とは、コストの性質が違うことに注意してください。CPUでは予測が当たれば分岐はほぼタダで、外れるとパイプラインのやり直しのコストがかかりました。GPUでは予測はなく、warpの中で経路が割れるかどうかがコストを決めます。

### Independent Thread Scheduling（Volta以降）

compute capability 7.0（Volta）より前のGPUでは、warpの32スレッドが1つのプログラムカウンタを共有していたため、warpの中のスレッドどうしがロックで待ち合わせる処理はデッドロックすることがありました。Volta以降は**Independent Thread Scheduling**により、スレッドごとにプログラムカウンタと呼び出しスタックを持ち、warpより細かい単位で分岐・合流できます。代わりに、「同じwarpのスレッドは常に足並みをそろえて動く」ことを前提にした古いコードは壊れる可能性があり、`__syncwarp()` で明示的に同期する必要があります。

ここでよくある誤解があります。Independent Thread Schedulingは、**warp divergenceのコストを消すものではありません**。Voltaのホワイトペーパーは、この方式でも実行はSIMTのままで、ある瞬間には、warpの中の動いているスレッド全員に同じ命令を実行すると明記しています。経路が割れれば、両方を順に実行する点は変わりません。変わったのは、正しく書けるプログラムの範囲です。

## 9. occupancyとレジスタの奪い合い

### occupancy：SMにどれだけwarpを載せられるか

CUDA Programming Guideは**occupancy**（占有率）を「SMで動いているwarpの数と、SMがサポートする最大のwarp数の比」と定義しています。H100（compute capability 9.0）では、SMあたり最大64 warp（2,048スレッド）です。

occupancyを決めるのは、スレッドが使う資源です。SMには32ビットのレジスタが64K個（65,536個）あり、それを動いているスレッドで分け合います。単純化して計算すると次のようになります（レジスタの割り当て単位などの細かい制約を無視した理論値です）。

| 1スレッドあたりのレジスタ数 | SMに載るスレッド数 | occupancy |
|---|---|---|
| 32 | 65,536 / 32 = 2,048 | 100% |
| 64 | 65,536 / 64 = 1,024 | 50% |
| 128 | 65,536 / 128 = 512 | 25% |

レジスタだけでなく、共有メモリ（10節）の使用量や、1ブロックあたりのスレッド数も制約になります。

ここに、GPUの設計の特徴が表れています。H100 SXM5のレジスタファイルは、SMあたり256 KB、GPU全体で33,792 KBです（ホワイトペーパーより）。L2キャッシュの50 MBと比べても、桁が同じです。**GPUは、大量のスレッドの状態を同時に保持するために、チップ上の記憶を大量にレジスタに割いています。** CPUがチップの面積を大きなキャッシュや分岐予測器に割くのと対照的です。

### レジスタスピル

1つのスレッドが使えるレジスタは最大255個です。それを超える変数が必要になったり、`-maxrregcount` オプションでレジスタ数を制限したりすると、コンパイラは一部の値をローカルメモリへ追い出します。これを**レジスタスピル**と呼びます。

名前に反して、ローカルメモリはチップの外のデバイスメモリにあり、グローバルメモリと同じレイテンシと帯域です。nvccの `--resource-usage` オプションで、カーネルが使うレジスタ数を確認できます。

### occupancyは高ければよいわけではない

Best Practices Guideは、occupancyを66%から100%に上げても、一般にそれに見合うほど速くはならないと書いています。occupancyを下げれば1スレッドが使えるレジスタが増え、スピルが減ります。また、命令レベル並列性が十分にあれば、低いoccupancyでも待ち時間を隠せる場合があります。

つまりGPUでも、ILP（1スレッドの中の並列性）とwarpの数はトレードオフの関係にあり、レジスタを奪い合います。5節の実験Bで見た「独立した累積変数を増やす」工夫は、GPUのカーネルでも効きます。

## 10. メモリ階層：キャッシュ、HBM、メモリ合体、バンク競合

### CPUとGPUのメモリ階層

どちらのプロセッサも、速くて小さい記憶から、遅くて大きい記憶まで、階層を持ちます。

| 階層 | CPU（例） | GPU（H100 SXM5） |
|---|---|---|
| 1次キャッシュ | コアごと（M4 Proの高性能コアのL1データキャッシュは128 KiB、筆者のマシンのsysctl） | SMごとにL1と共有メモリを合わせて256 KB（共有メモリは最大228 KB） |
| 2次・3次キャッシュ | Xeon 8480+は製品仕様で「Cache 105 MB」、別に各コアに2 MBの2次キャッシュ（Intelのマニュアル） | L2 50 MB |
| メインメモリ | DDR5（8480+は8チャネル、DDR5-4800） | HBM3、3,352 GB/s |

CPUのメモリ帯域は、チャネル数×転送速度×8バイトで理論値を計算できます。8480+の1ソケットなら次のとおりです（理論値）。

$$
8 \times 4800 \times 10^6 \times 8 = 307.2 \times 10^9\ \mathrm{byte/s}
$$

Apple M4 Proのメモリ帯域は、Appleの発表で273 GB/sです。H100 SXM5のHBM3の3,352 GB/sは、ホワイトペーパーの表の値です（表には「Not Finalized for H100」という注記がありますが、NVIDIAの現在の製品ページも3.35 TB/sと記載しています）。8480+の1ソケットの約10.9倍になります（理論値どうしの比）。HBMがなぜこれほど広い帯域を持てるのか、LLM推論でそれがどう効くのかは、[NVIDIAのGPUはなぜAIに強いのか](/blog/nvidia-gpu-ai-tensor-core-fp8-hbm-nvlink-explained)の6節で扱っています。

### メモリ合体（coalescing）：warp単位でまとめて読む

CUDA Programming Guideによれば、グローバルメモリは32バイト単位のトランザクションで読み書きされます。warpの32スレッドが連続する4バイトずつを読むと、合計128バイトを4回のトランザクションで読め、効率は100%です。隣り合うスレッドが32バイト以上離れた番地を読むと、スレッドごとに32バイトのトランザクションが必要になり、1024バイトを転送して128バイトしか使いません。転送量は必要な量の8倍、効率は12.5%（87.5%が無駄）です。

これを**メモリ合体**（coalescing）と呼びます。CPUのキャッシュライン（M4 Proでは128バイト）を意識したデータ配置と考え方は似ていますが、GPUでは**同じ瞬間に32スレッドが読む番地の並び**が問題になります。

次の短いカーネルは、隣り合うスレッドが `stride` 要素ずつ離れた場所をコピーします。`stride` が1なら合体し、2なら転送の半分が無駄になり、8（4バイト×8＝32バイト）以上ならスレッドごとに別のトランザクションになります。Best Practices Guideも、同じ形の例で、ストライド2では読み書きの効率が50%になると説明しています。

```cpp
// 未実行（筆者の環境には NVIDIA GPU と nvcc がない）。
// 添字は size_t で計算する（int だと要素数 × stride が 2^31 を超えたときに溢れる）
__global__ void stride_copy(float* out, const float* in, int stride, size_t n) {
  const size_t i = (static_cast<size_t>(blockIdx.x) * blockDim.x + threadIdx.x) * stride;
  if (i < n) out[i] = in[i];
}
```

このカーネルと、warp divergenceを測るカーネルは、筆者の環境にNVIDIA GPUがないため**まだ実行していません**。この記事にはGPUの測定値を載せていません。

### 共有メモリとバンク競合

SMの中には、プログラマが明示的に管理する高速なキャッシュである**共有メモリ**（shared memory）があります。

CUDA Programming Guideによれば、共有メモリは32個の**バンク**に分かれ、連続する32ビットの語が順に別のバンクに割り当てられます。各バンクは1サイクルに32ビットを返せます。同じwarpの複数のスレッドが、同じバンクの**別の語**を読もうとすると、読み出しが順番待ちになります。これを**バンク競合**（bank conflict）と呼びます。同じ語を読む場合は、1回の読み出しを全員に配る（ブロードキャスト）ので競合しません。

```text
バンク番号 = (32ビット語の番号) mod 32

ストライド1（語0,1,2,...,31）    → 32個のバンクに1つずつ：競合なし
ストライド2（語0,2,4,...,62）    → 偶数のバンクに2つずつ：2-way の競合
ストライド32（32×32の配列の列）  → 全員がバンク0：32-way の競合
```

Best Practices Guideは、32×32の配列を `[32][33]` のように1列ぶん余分に確保（パディング）する対策を示しています。列方向に読むときのストライドが33になり、32で割った余りが1なので競合が消えます。

## 11. Rooflineで比べる：CPUとH100のRidge Point（独自分析）

### Rooflineモデル

ここまでの話を、1つの図式にまとめる道具が**Rooflineモデル**です。Williams、Waterman、Pattersonが提案したもので、達成できる性能 $P$ の上限を、演算の理論ピーク $P_{\mathrm{peak}}$、メモリ帯域 $B$、演算強度 $I$（DRAMとの通信1バイトあたりの演算数）で表します。

$$
P \le \min\left(P_{\mathrm{peak}},\ B \times I\right)
$$

2つの上限が交わる点が**Ridge Point** $I^{*} = P_{\mathrm{peak}} / B$ で、これより演算強度が低い処理は帯域律速、高い処理は演算律速になります。定義の詳細は[ピラー記事の6節](/blog/nvidia-gpu-ai-tensor-core-fp8-hbm-nvlink-explained)で扱っています。

数値例として、SAXPY（$y \leftarrow ax + y$、FP32）を考えます。1要素あたり2 FLOPで、$x$ と $y$ を読んで $y$ を書くので12バイトです。

$$
I_{\mathrm{SAXPY}} = \frac{2}{12} \approx 0.167\ \mathrm{FLOP/byte}
$$

上限は、8480+の1ソケットで約51.2 GFLOP/s（307.2 GB/s × 0.167）で、FP32の理論ピークの1%にも届きません。H100 SXM5でも約559 GFLOP/s（3,352 GB/s × 0.167）です。どちらも、演算器ではなくメモリ帯域が速さを決めます。

### CPUとH100のRidge Pointを並べる

筆者が、8480+（1ソケット）とH100 SXM5の公称値から計算したRidge Pointが次の表です（すべて理論値）。H100はホワイトペーパーの**非Tensor Core**の値（ピーククロック1,980 MHzでの値）を使い、Tensor Coreの値は混ぜていません。CPUは6節で述べた2つの周波数の仮定で計算しました。

| | FP32ピーク | FP64ピーク | メモリ帯域 | Ridge Point（FP32） | Ridge Point（FP64） |
|---|---|---|---|---|---|
| Xeon 8480+（1ソケット、基本2.0 GHz） | 7.17 TFLOP/s | 3.58 TFLOP/s | 307.2 GB/s | 23.3 FLOP/byte | 11.7 FLOP/byte |
| Xeon 8480+（1ソケット、最大ターボ3.8 GHz） | 13.62 TFLOP/s | 6.81 TFLOP/s | 307.2 GB/s | 44.3 FLOP/byte | 22.2 FLOP/byte |
| H100 SXM5（非Tensor Core） | 66.9 TFLOP/s | 33.5 TFLOP/s | 3,352 GB/s | 20.0 FLOP/byte | 10.0 FLOP/byte |

この表から言えるのは、**CPUとH100の非Tensor Core演算のRidge Pointは同じ桁にある**ということです。周波数の基準しだいで、「ほぼ同じ」（基本周波数）から「CPUが約2倍右」（最大ターボ）まで動きます。両者の違いは主に規模で、メモリ帯域は約10.9倍、演算ピークは約4.9〜9.3倍（CPUの周波数の仮定による）です。

この表には、ほかにも前提があります。

- **2ソケットのサーバー**なら、CPU側の数値は2倍になる。
- 消費電力の公称値は、8480+のTDPが350 W、H100 SXM5のTDPが700 Wで、同じではない。
- **Tensor Coreを使うと、話は大きく変わる。** H100のFP16 Tensor Core（密）のRidge Pointは約295 FLOP/byteです（ピラー記事の6節）。行列積の形にできる処理では、GPUの演算性能の上限はさらに一桁上がります。その代わり、その性能を引き出すには、1バイトあたり約300回もの演算が必要になります。

そして大事な点です。**この比較のどこにも、CPUのコア数（56）とCUDAコア数（16,896）の比は出てきません。** 16,896を56で割った約300という数字は、どちらの性能比にもなりません。性能を比べるときは、同じ精度・同じ周波数の基準の理論ピークとメモリ帯域を、処理の演算強度に照らして比べてください。

## 12. Amdahlの法則とPCIe転送：GPUに移して得か（独自分析）

### Amdahlの法則

処理の一部だけを速くしたとき、全体がどれだけ速くなるかを表すのが**Amdahlの法則**です。CUDA C++ Best Practices Guideは、次の形で紹介しています。

$$
S = \frac{1}{(1 - P) + \dfrac{P}{N}}
$$

- $S$：全体の速度向上率 [倍]
- $P$：並列化できる部分が、元の実行時間に占める割合（0〜1）
- $N$：並列化した部分の速度向上率（プロセッサ数など）[倍]

$N$ を無限大にすると $S = 1/(1-P)$ になります。同ガイドの例では、実行時間の3/4を並列化できる場合、どれだけ速くしても全体は最大4倍です。$P = 0.95$ でも上限は20倍です。

### PCIe転送を加える

GPUでは、もう1つの項が加わります。CPUとGPUは別々のメモリを持つので、データをPCIeで送り、結果を戻す時間がかかります。Best Practices Guideは、この転送はコストが高く最小にすべきで、行列の足し算のように転送した要素あたりの演算が少ない処理はGPUに移しても得にならないと書いています。

H100のPCIe Gen5 x16は、ホワイトペーパーによれば双方向合計128 GB/s、片方向64 GB/sです。これは理論値で、実際には下回ります。同ガイドは古い世代の例として、PCIe Gen3 x16の理論値16 GB/sに対し、ページロック（pinned）メモリで約12 GB/sと書いています（約75%）。

転送の時間を、元の実行時間に対する割合 $x$ で表すと、Amdahlの法則は次のように拡張できます。

$$
S = \frac{1}{(1 - p) + \dfrac{p}{s} + x}
$$

### Pythonで試算する

以上を組み合わせて、「GPUに移すと得か」を計算するスクリプトです。計算はすべて**理論値**で、次の前提を置いています。

- 演算もメモリも理論ピークの100%で動く（実際にはどちらも下回る）
- CPUの周波数は、基本2.0 GHzと最大ターボ3.8 GHzの2通り
- カーネルの起動や同期のオーバーヘッドは無視する
- 転送と計算は重ねない（直列に足す）
- 特に断らない限り、データは最初と最後にCPU側のメモリにある
- 行列積のDRAM通信量は、理想的なブロッキングを仮定した下限（3つの行列を1回ずつ）

実行環境は Python 3.9 以降（標準ライブラリのみ）で、`python3 offload_model.py` で実行します。

```python
# offload_model.py — Roofline + PCIe 転送で「GPUに移して得か」を見積もる（すべて理論値）
# 実行: python3 offload_model.py   （標準ライブラリのみ、Python 3.9+）
from dataclasses import dataclass

G = 1e9
T = 1e12


@dataclass(frozen=True)
class Machine:
    name: str
    peak_fp32: float  # FLOP/s（理論ピーク）
    peak_fp64: float  # FLOP/s（理論ピーク）
    mem_bw: float     # byte/s（理論ピーク）


def xeon_8480(clock_hz: float, label: str) -> Machine:
    """Xeon Platinum 8480+（1ソケット）: 56コア × AVX-512 FMA 2基。
    FP64 は 1基あたり 8レーン × 2 FLOP（FMA）、FP32 はレーンが2倍。"""
    cores, fma_units = 56, 2
    return Machine(
        f"Xeon 8480+ @{label}",
        peak_fp32=cores * clock_hz * fma_units * 16 * 2,
        peak_fp64=cores * clock_hz * fma_units * 8 * 2,
        mem_bw=8 * 4800e6 * 8,  # 8チャネル × 4800 MT/s × 8 byte
    )


# 周波数の仮定を2通り置く。基本 2.0 GHz（下限側）と最大ターボ 3.8 GHz（上限側。
# 全コアが AVX-512 を使いながらこの周波数で動く保証はない）
XEON_BASE = xeon_8480(2.0 * G, "2.0GHz base")
XEON_TURBO = xeon_8480(3.8 * G, "3.8GHz max turbo")
# H100 SXM5: ホワイトペーパー Table 3 の非Tensor Core 値（Tensor Core とは混ぜない）。
# この値はブースト（＝ピーク）クロック 1980 MHz で計算されている
h100 = Machine("H100 SXM5 (non-Tensor)", peak_fp32=66.9 * T, peak_fp64=33.5 * T,
               mem_bw=3352 * G)
PCIE_PER_DIR = 64 * G  # PCIe Gen5 x16、片方向（双方向合計 128 GB/s の半分）


def roofline_time(flops: float, dram_bytes: float, peak: float, bw: float) -> float:
    """Roofline の下限時間: 演算と帯域のうち遅いほうで決まる。"""
    return max(flops / peak, dram_bytes / bw)


def report_ridge() -> None:
    print("== Ridge point I* = P_peak / B  [FLOP/byte] ==")
    for m in (XEON_BASE, XEON_TURBO, h100):
        print(f"{m.name:28s} FP32 peak {m.peak_fp32 / T:6.2f} TFLOP/s, "
              f"FP64 peak {m.peak_fp64 / T:6.2f} TFLOP/s, B {m.mem_bw / G:7.1f} GB/s | "
              f"I*(FP32) {m.peak_fp32 / m.mem_bw:5.1f}, I*(FP64) {m.peak_fp64 / m.mem_bw:5.1f}")


def compare(name: str, cpu: Machine, flops: float, dram_bytes: float, h2d: float,
            d2h: float, resident: bool = False, pcie: float = PCIE_PER_DIR) -> None:
    t_cpu = roofline_time(flops, dram_bytes, cpu.peak_fp32, cpu.mem_bw)
    t_kernel = roofline_time(flops, dram_bytes, h100.peak_fp32, h100.mem_bw)
    t_xfer = 0.0 if resident else (h2d + d2h) / pcie
    t_gpu = t_xfer + t_kernel
    print(f"{name:31s} CPU {t_cpu * 1e3:8.3f} ms | GPU kernel {t_kernel * 1e3:7.3f} ms "
          f"+ PCIe {t_xfer * 1e3:7.3f} ms = {t_gpu * 1e3:8.3f} ms | "
          f"speedup {t_cpu / t_gpu:5.2f}x")


def main() -> None:
    report_ridge()
    print("\n== FP32 workloads (theoretical lower bounds; no launch/sync overhead) ==")
    n = 100_000_000  # SAXPY: y = a*x + y, 2 FLOP/要素、12 byte/要素（帯域律速なので周波数に依存しない）
    compare("SAXPY n=1e8, data on host", XEON_BASE, 2 * n, 12 * n, h2d=8 * n, d2h=4 * n)
    compare("SAXPY n=1e8, data on GPU", XEON_BASE, 2 * n, 12 * n, 0, 0, resident=True)
    m = 4096    # SGEMM: C = A*B、2m^3 FLOP、DRAM は理想的なブロッキングで 3*4*m^2 byte
    for cpu, tag in ((XEON_BASE, "base"), (XEON_TURBO, "turbo")):
        compare(f"SGEMM m=4096, host, CPU {tag}", cpu, 2 * m**3, 12 * m**2,
                h2d=8 * m**2, d2h=4 * m**2)
        compare(f"SGEMM m=4096, on GPU, CPU {tag}", cpu, 2 * m**3, 12 * m**2, 0, 0,
                resident=True)

    # 損益分岐 1: SGEMM はどの大きさから転送込みで得か
    #   2m^3/P_cpu = 12m^2/B_pcie + 2m^3/P_gpu  を m について解く
    print()
    for cpu in (XEON_BASE, XEON_TURBO):
        inv = 1 / cpu.peak_fp32 - 1 / h100.peak_fp32
        print(f"SGEMM break-even vs {cpu.name}: m > {6 / (PCIE_PER_DIR * inv):.0f}")

    # 損益分岐 2: SAXPY を GPU に置いたまま k 回繰り返すと、何回目から得か
    #   12n/B_pcie + k*12n/B_gpu = k*12n/B_cpu  を k について解く（n は消える）
    print("SAXPY iterations needed on resident data (PCIe efficiency sensitivity):")
    for eff in (1.0, 0.75, 0.5):
        k = (1 / (PCIE_PER_DIR * eff)) / (1 / XEON_BASE.mem_bw - 1 / h100.mem_bw)
        print(f"  PCIe at {eff:4.0%} of 64 GB/s -> k > {k:4.1f}")

    # Amdahl: 全体の 90% を占める部分だけを GPU 化。転送は全体の時間に対する比で与える
    print("\nAmdahl with transfer overhead: S = 1 / ((1-p) + p/s + x)")
    p = 0.9
    for s in (2.0, 10.0, 100.0):
        for x in (0.0, 0.05, 0.2):
            print(f"  p={p:.1f} s={s:5.0f}x transfer={x:4.0%} -> S = "
                  f"{1 / ((1 - p) + p / s + x):5.2f}x")


if __name__ == "__main__":
    main()
```

出力（Python 3.13.7）です。

```text
== Ridge point I* = P_peak / B  [FLOP/byte] ==
Xeon 8480+ @2.0GHz base      FP32 peak   7.17 TFLOP/s, FP64 peak   3.58 TFLOP/s, B   307.2 GB/s | I*(FP32)  23.3, I*(FP64)  11.7
Xeon 8480+ @3.8GHz max turbo FP32 peak  13.62 TFLOP/s, FP64 peak   6.81 TFLOP/s, B   307.2 GB/s | I*(FP32)  44.3, I*(FP64)  22.2
H100 SXM5 (non-Tensor)       FP32 peak  66.90 TFLOP/s, FP64 peak  33.50 TFLOP/s, B  3352.0 GB/s | I*(FP32)  20.0, I*(FP64)  10.0

== FP32 workloads (theoretical lower bounds; no launch/sync overhead) ==
SAXPY n=1e8, data on host       CPU    3.906 ms | GPU kernel   0.358 ms + PCIe  18.750 ms =   19.108 ms | speedup  0.20x
SAXPY n=1e8, data on GPU        CPU    3.906 ms | GPU kernel   0.358 ms + PCIe   0.000 ms =    0.358 ms | speedup 10.91x
SGEMM m=4096, host, CPU base    CPU   19.174 ms | GPU kernel   2.054 ms + PCIe   3.146 ms =    5.200 ms | speedup  3.69x
SGEMM m=4096, on GPU, CPU base  CPU   19.174 ms | GPU kernel   2.054 ms + PCIe   0.000 ms =    2.054 ms | speedup  9.33x
SGEMM m=4096, host, CPU turbo   CPU   10.092 ms | GPU kernel   2.054 ms + PCIe   3.146 ms =    5.200 ms | speedup  1.94x
SGEMM m=4096, on GPU, CPU turbo CPU   10.092 ms | GPU kernel   2.054 ms + PCIe   0.000 ms =    2.054 ms | speedup  4.91x

SGEMM break-even vs Xeon 8480+ @2.0GHz base: m > 753
SGEMM break-even vs Xeon 8480+ @3.8GHz max turbo: m > 1603
SAXPY iterations needed on resident data (PCIe efficiency sensitivity):
  PCIe at 100% of 64 GB/s -> k >  5.3
  PCIe at  75% of 64 GB/s -> k >  7.0
  PCIe at  50% of 64 GB/s -> k > 10.6

Amdahl with transfer overhead: S = 1 / ((1-p) + p/s + x)
  p=0.9 s=    2x transfer=  0% -> S =  1.82x
  p=0.9 s=    2x transfer=  5% -> S =  1.67x
  p=0.9 s=    2x transfer= 20% -> S =  1.33x
  p=0.9 s=   10x transfer=  0% -> S =  5.26x
  p=0.9 s=   10x transfer=  5% -> S =  4.17x
  p=0.9 s=   10x transfer= 20% -> S =  2.56x
  p=0.9 s=  100x transfer=  0% -> S =  9.17x
  p=0.9 s=  100x transfer=  5% -> S =  6.29x
  p=0.9 s=  100x transfer= 20% -> S =  3.24x
```

### 試算から分かること

**SAXPYは、データがCPU側にあるとGPUに移すと損をします。** GPUのカーネル自体はCPUの約11倍速いのですが、PCIeの転送に18.75 msかかり、全体ではCPUの約5倍の時間になります（速度向上率0.20倍）。転送だけで、CPUの計算時間の約4.8倍です。PCIeの帯域（64 GB/s）がCPUのメモリ帯域（307.2 GB/s）より狭いことが、そのまま効きます（帯域律速なので、CPUの周波数の仮定には左右されません）。

**データをGPUに置いたまま繰り返すなら、話は変わります。** 転送のコストを回数で割れるので、PCIeが理論値どおりなら6回目以降、実効75%なら8回目以降、実効50%なら11回目以降に得になります。Best Practices Guideが、ある計算ステップ単体ではホストのほうが速くても、データをデバイスに置いたままにすべきと書いているのはこのためです。

**行列積は、転送込みでも得になりますが、どれだけ得かはCPUの周波数の仮定で大きく変わります。** SGEMM（$m = 4096$）では、転送に3.1 msかかっても、CPUが基本周波数なら全体で約3.7倍、最大ターボなら約1.9倍速くなります。行列積の演算量は $2m^3$、転送量は $12m^2$ バイトなので、行列が大きくなるほど演算が転送を圧倒します。損益分岐を式で解くと次のとおりです。

$$
m^{*} = \frac{6}{B_{\mathrm{PCIe}} \left( \dfrac{1}{P_{\mathrm{CPU}}} - \dfrac{1}{P_{\mathrm{GPU}}} \right)}
$$

この前提では、一辺が約753（CPUが基本周波数）〜約1,603（最大ターボ）より大きいFP32の行列積は、転送込みでもGPUのほうが速いことになります（理論値）。

**Amdahlの法則は、転送のコストでさらに厳しくなります。** 全体の90%をGPUに移せる処理で、その部分を100倍速くしても、転送が元の時間の20%を占めれば、全体は3.24倍にしかなりません。転送がなければ9.17倍でした。速度向上の上限を決めるのは、GPUの速さよりも、GPUに移せない部分と転送の割合です。

### この試算の限界

- 演算とメモリを理論ピークの100%で計算しているので、実際の時間はどちらも長くなります。CPUとGPUで効率が違えば、損益分岐の位置は動きます。
- CPUの周波数は2つの仮定の幅で示しました。全コアでAVX-512を使うときの周波数は製品仕様ページになく、基本周波数を下回る可能性もあります。
- 転送と計算を重ねれば転送の一部を隠せます。この試算はそれを考慮しない、GPUに不利な側の見積もりです。
- GPUの値は非Tensor Coreです。Tensor Coreを使える行列積なら、GPUのカーネル時間はさらに短くなります。
- カーネルの起動のオーバーヘッドを無視しています。小さな処理を何度も起動すると無視できなくなります。

## 13. 理論性能と実測：「GPUは100倍速い」は本当か

### Leeらの2010年の論文

「GPUでCPUの100倍速くなった」という報告に正面から取り組んだのが、Leeらが2010年のISCA（コンピュータアーキテクチャの主要な国際会議）で発表した論文 "Debunking the 100X GPU vs. CPU Myth" です。論文が実際に主張していることを、条件とあわせて整理します。

- **比較した製品**：Intel Core i7-960（4コア、3.2 GHz、メモリ帯域32 GB/s）と、NVIDIA GeForce GTX 280（30個のSM、1.3 GHz、メモリ帯域141 GB/s）。いずれも当時の製品。
- **処理**：行列積（SGEMM）、モンテカルロ法、畳み込み、FFT、SAXPY、格子ボルツマン法（LBM）、ソートなど14種類。
- **結論**：過去の研究は、GPUがマルチコアCPUより10倍〜1000倍速いと主張していた。CPUとGPUの両方に適切な最適化をすると、差は**平均2.5倍**に縮まった。
- **個別の結果**：10倍を超えたのは、GPUのテクスチャ処理用の回路を使えた衝突判定（GJK）だけだった。ソートと拘束ソルバーは、むしろCPUのほうが速かった。過去に114倍と報告されたLBMは、CPU側を丁寧にマルチスレッド化し、メモリアクセスを整理し、SIMD化すると、両方ともメモリ帯域で律速され、差は5倍になった。
- **差が大きく報告された理由**：比べたCPUとGPUの組み合わせ（高性能なGPUとモバイル向けのCPUなど）と、最適化の度合い。最適化したGPUのコードを、最適化していないCPUのコードと比べた研究が多かった。CPU側で効いたのはマルチスレッド化・キャッシュブロッキング・SIMD化のためのデータの並べ替え、GPU側はグローバルな同期を減らすことと共有メモリの活用だった。

補足として、論文の細部を3点挙げます。表3（各処理の測定値）から筆者が処理ごとのGPU/CPU比を計算すると、幾何平均は約2.55倍、算術平均は約3.64倍で、「平均2.5倍」は幾何平均と一致します（論文自体はどちらの平均かを明記していません）。GJKの比は本文では14.9倍、表3の値からは約15.2倍と、論文の中で小さな食い違いがあります。また、論文はGTX 280とi7-960のピークのメモリ帯域の比を約4.7倍としていますが、表2の141 GB/sと32 GB/sから計算すると約4.4倍です。

### この論文を読むときの条件

この論文を「GPUは2.5倍しか速くない」という一般論として引用するのは誤りです。次の条件を外せないからです。

1. **GPUへのデータ転送時間を含めていない。** 論文は、データがすでにGPUのメモリにある状況を想定し、GPUの結果を「実際のアプリケーションで見られる値の上限」と明記しています。
2. **2010年の製品どうしの比較である。** 現在のGPUはTensor CoreやHBMを持ち、Rooflineの形そのものが変わりました。2.5倍をH100と現在のCPUに当てはめることはできません。
3. **著者は全員Intelの所属である。** 測定と最適化の説明は検証可能ですが、CPUメーカーの研究者による評価だという点は知っておくべきです。

論文が今も読む価値を持つのは、両方を同じだけ最適化する、同じ立ち位置の製品を比べる、転送を含めるかを明記する、という**比較の作法**を示しているからです。

### 理論ピークと実測の間にあるもの

理論ピークと実測の間には、いつも差があります。Leeらの論文は、Volkovらの先行研究を引いて、計算律速で知られるSGEMMでもGPUはピークの約66%しか出ないと述べ、自分たちの結果もそれと一致したとしています。Best Practices Guideは、理論帯域と実効帯域の両方を計算し、実効帯域が大きく下回るならそこを最初の最適化の対象にするよう勧めています。これにPCIeの実効値（12節）と周波数の基準（6節）が加わります。スペック表を比べるだけでは実際の速さは分からないので、Rooflineで上限を見積もり、そのうえで自分の処理を小さく測るのが確実な順番です。

## 14. 限界と反例：CPUが勝つ場面、GPUが勝つ場面

ここまでを、GPUが不利になる条件として裏返してみます。

- **分岐が多く、データごとに経路が違う処理**：warp divergenceで両方の経路を実行することになる。CPUなら分岐予測が当たる限りほぼタダだが、GPUにはその仕組みがない（Leeらの論文でも、拘束ソルバーとソートはCPUが速かった）。
- **並列度が低い処理**：数千のスレッドを用意できなければ、GPUは待ち時間を隠せない。逐次的な処理や、小さなデータの処理はCPUに向く。
- **データがCPU側にあり、演算強度が低い処理**：転送だけでCPUの計算時間を超える（12節のSAXPY）。
- **細かい同期が多い処理**：Leeらの論文は、CPUは高速な同期を備えるのに対しGPUでは効率よく実装されていないと指摘し、ヒストグラムや拘束ソルバーで同期のコストが支配的になったと報告している。

逆に、GPUが本領を発揮するのは、**独立した計算が大量にあり、データをGPUに置いたまま繰り返し処理でき、メモリアクセスがwarp単位でそろっている**処理です。行列積、畳み込み、画像の画素ごとの処理、そしてニューラルネットワークの学習と推論がその典型です。CPU・GPU・TPUを、AI推論の1トークンあたりの原価まで含めて比べる方法は、[CPU・GPU・TPUの違いと選び方](/blog/cpu-gpu-tpu-comparison-ai-workload-tco-selection-guide)で扱っています。

反例も挙げておきます。この記事は「CPUはレイテンシ、GPUはスループット」と対比しましたが、境界は年々あいまいになっています。CPUもAVX-512やAMXで幅の広い演算を取り込み、GPUもIndependent Thread Schedulingのように、CPUに近い柔軟さを取り入れています。対比は設計の比重の違いであって、白黒の区別ではありません。

## 15. 判断基準：処理をCPUとGPUのどちらに置くか

最後に、処理をGPUに移すかどうかを判断する手順をまとめます。

1. **並列度を確かめる。** 同時に処理できる独立な単位が、数千以上あるか。なければCPUのままがよい可能性が高い。
2. **演算強度を見積もる。** 1バイトのデータあたり何回の演算をするか。Ridge Point（非Tensor Coreなら10〜45 FLOP/byte程度、Tensor Coreなら数百）と比べて、帯域律速か演算律速かを判断する。
3. **データの置き場所を確かめる。** データは最初にどこにあり、結果はどこで使うか。CPU側にあるなら、PCIeの転送時間を必ず足す。何回の処理で転送を回収できるかを計算する（12節）。
4. **分岐とメモリアクセスの形を確かめる。** warpの中で分岐が割れないか、隣り合うスレッドが隣り合うデータを読むか。そろわないなら、データの並べ方から設計し直す。
5. **Amdahlの法則で上限を出す。** GPUに移せない部分と転送が全体の何割か。それで速度向上の上限が決まる。
6. **小さく測る。** ここまでは理論の上限です。最後は、実際の処理で、CPU側も同じだけ最適化したうえで測る。Leeらの論文が示したとおり、片方だけを最適化した比較は大きく誤ります。

筆者の実務は、Tesla T4 1枚の上でvLLMとAWQ量子化のQwen3-8Bを動かす規模の推論基盤で（[AI動画ローカライズのGPUパイプライン](/blog/production-ai-video-localization-lipsync-gpu-pipeline)）、H100のクラスタやCUDAカーネルの開発の経験はありません。それでもこの規模で、「データをGPUに置いたまま処理を続ける」「GPUに向かない前処理はCPUに残す」という判断が設計の出発点になりました。

この手順をLLM推論に当てはめると、1トークンずつ生成するデコードは演算強度が低く帯域律速になるため、機材選びはVRAMの容量と帯域で決まります。自社GPUとAPIのどちらが得かは、[量子化とVRAM予算の記事](/blog/llm-quantization-serving-economics-awq-fp8-kv-cache-vram-budget)と[CPU・GPU・TPUの1Mトークン原価の試算](/blog/cpu-gpu-tpu-comparison-ai-workload-tco-selection-guide)で扱っています。

## まとめ

- **CPUはレイテンシ重視**です。スーパースカラ、レジスタリネーミング、アウトオブオーダー実行、リオーダーバッファ、分岐予測と投機実行で、$T = IC \times CPI / f$ のCPIを下げ、1本の命令列をできるだけ早く進めます。
- **GPUはスループット重視**です。命令を順番どおりに発行し、分岐予測も投機実行もせず、大量のwarpを切り替えて待ち時間を隠します。
- GPUの性能は、**warp divergence**（分岐が割れると両方を実行する）、**occupancy**とレジスタの奪い合い、**メモリ合体**と**バンク競合**で大きく変わります。Independent Thread Schedulingは正しく書けるプログラムを広げましたが、warp divergenceのコストは消しません。
- Rooflineで比べると、Xeon 8480+（1ソケット）とH100 SXM5の非Tensor Core演算のRidge Pointは同じ桁にあり、CPUの周波数の基準しだいで「ほぼ同じ」から「CPUが約2倍右」まで動きます。Tensor Coreを使うとGPUの上限はさらに一桁上がります（いずれも理論値）。
- **GPUに移して得かは、転送とAmdahlの法則で決まります。** データがCPU側にあるSAXPYは転送だけで損をし、大きな行列積は転送込みでも得になります（理論値）。
- 「GPUは100倍速い」の多くは、最適化していないCPUとの比較でした。Leeらの平均2.5倍も、転送を除いた2010年の製品での上限値です。比べるときは周波数を含めて条件をそろえ、自分の処理で測ってください。

ここで見たSIMTの実行モデルを、実際にカーネルを書く側から扱ったのが[CUDAの仕組みとGPUプログラミング入門](/blog/cuda-programming-model-ptx-memory-hierarchy-guide)です。
