# CUDAの仕組みとGPUプログラミング入門 — カーネル・PTX/SASS・メモリ階層・同期を完全なコードで理解する

> CUDAの仕組みを、ホストとデバイス、grid・block・thread・warp、NVCC→PTX→SASSのコンパイル、メモリ階層、__syncthreadsとwarpシャッフルの順に解説。リダクション・scan・タイル化行列積・ストリームの完全なCUDA C++コードと、T4とH100の理論占有率の計算つき。

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

## 要点

- CUDAは、CPU（ホスト）がGPU（デバイス）に大量のスレッドを起動させるプログラミングモデルと、コンパイラ・ドライバ・ライブラリの集まり。カーネルの起動は非同期で、CPUとGPUのメモリは基本的に別物として扱う。
- CUDA C++はNVCCがNVVM（LLVMベース）でPTXという仮想ISAに変換し、ptxasがGPU世代ごとの機械語SASSにする。実行ファイルにPTXを入れておけば、ドライバが新しいGPU向けにJITコンパイルできる。
- CUDAのスレッドは論理的な単位で、演算器の数とは一致しない。T4は2,560個のFP32演算器に対して最大40,960スレッドを同時に載せられ、32スレッドのwarp単位で切り替えて待ち時間を隠す。
- 同期の範囲は階層的で、__syncthreads()はブロック内だけ、warpシャッフルはwarp内だけを同期する。グリッド全体のバリアは通常のカーネルにはなく、ブロック間はアトミック操作かカーネルの境界でつなぐ。
- 公開されているSMの上限値から計算すると、256スレッドのブロックで理論占有率100%を保てるのは、T4では1スレッドあたり64レジスタ以下、H100では32レジスタ以下。同じ64Kレジスタを2倍のwarpで分け合うため。

---

「CUDAでGPUプログラミングをする」と聞くと、特別な言語や難しい数学を想像するかもしれません。実際に書くのは、少しの拡張が加わったC++です。難しいのは文法ではなく、**数万のスレッドが同時に動き、メモリが何層にも分かれ、同期の範囲が限られている**という前提で考えることです。

**短い答えを先に書きます。** CUDAは、CPU（ホスト）がGPU（デバイス）に「同じ関数を大量のスレッドで実行せよ」と指示するためのプログラミングモデルと、それを支えるコンパイラ・ドライバ・ライブラリの集まりです。GPUで動かす関数（カーネル）には `__global__` を付け、ホストから `vecAdd<<<ブロック数, 1ブロックのスレッド数>>>(a, b, c, n)` の形で起動します。各スレッドは `blockIdx.x * blockDim.x + threadIdx.x` で自分の担当する要素の番号を計算します。メモリは大きく3層で、スレッドごとの速くて小さい**レジスタ**、ブロック内で共有する**共有メモリ**、全スレッドから見えるが遠い**グローバルメモリ**（GPUのDRAM）です。書いたCUDA C++は、NVCCによってPTXという仮想的な命令セットに変換され、さらにGPU世代ごとの機械語（SASS）になります。速さを決めるのは、多くの場合、演算そのものよりも**データをどのメモリに置き、どう読み、どこで同期するか**です。

前半（1〜7節）で、ホストとデバイス、スレッドの階層、コンパイルの流れ、メモリ階層、同期を説明します。後半（8〜14節）では、リダクション・scan・タイル化行列積・ストリームを完全なコードで書き、T4とH100の理論占有率を計算し、プロファイラとPyTorchとの関係を整理します。最後の15節は、限界と判断基準です。

**検証の範囲。** 各プログラムは単独でコンパイルできる完全なもので（そのため `CHECK` マクロは毎回定義しています）、CPUで計算した参照値と比べてPASSかFAILを表示します。筆者の環境（Apple M4 Pro）にはNVIDIAのGPUがないため、ロジックは、CUDAのスレッドを `std::thread` で模擬した環境で、境界値（scanは要素数1、31、32、33、1,024、1,025、5,000、70,001、行列積は37〜64の小さな行列など）と故意のバグで確かめ、浮動小数点の誤差と占有率はCPUで計算しました。GPU上の実行時間は載せていません。対象のGPUはT4（`sm_75`）です。筆者の実務はTesla T4 1枚でvLLMとAWQ量子化のQwen3-8Bを動かす推論基盤までで、CUDAカーネルを業務で開発した経験はありません。コードはNVIDIAの公式ドキュメントに沿って書いた学習用のものです。

Tensor Core・数値形式・HBM・NVLinkについては、[NVIDIAのGPUはなぜAIに強いのか](/blog/nvidia-gpu-ai-tensor-core-fp8-hbm-nvlink-explained)で扱ったので、ここでは繰り返しません。

## 1. CUDAとは何か：言語ではなく「モデルと道具の集まり」

CUDAという名前は、いくつかのものをまとめて指します。

- **プログラミングモデル**：GPUを「多数のスレッドを実行する装置」として扱うための考え方。スレッドの階層、メモリの種類、同期のルールを定める。
- **CUDA C++**：C++にいくつかの拡張（`__global__` などの指定子、カーネル起動の `<<< >>>` 構文、組み込み変数）を加えたもの。NVCCはC++03からC++23までの言語規格に対応している。
- **CUDA Runtime APIとDriver API**：メモリの確保やコピー、カーネルの起動を行うAPI。この記事で使うRuntime API（`cuda` で始まる関数）は、より低レベルなDriver API（`cu` で始まる関数）の上に作られていて、同じ機能はDriver APIだけでも実現できる。Driver APIはコンテキスト（`CUcontext`）やモジュール（`CUmodule`）を明示的に扱い、PTXやcubinをモジュールとして読み込んでからカーネルを起動する。仮想メモリ管理のようにDriver APIにしかない機能もあるが、多くのアプリケーションはRuntime APIだけで十分な性能が出る。
- **NVCCとPTX**：コンパイラと、その出力先になる仮想命令セット。5節で詳しく扱う。
- **NVIDIAドライバ**：CUDA Programming Guideの表現では「GPUのオペレーティングシステム」のようなもの。CUDA Toolkitとは別の製品として配布される。
- **ライブラリとツール**：cuBLAS（行列演算）、cuDNN（ニューラルネットワーク）、Nsight Systems・Nsight Compute（プロファイラ）、Compute Sanitizer（正しさの検査）など。

最初に押さえておきたい制約が一つあります。**NVIDIAのCUDAは、通常、Apple Silicon搭載のMacでは動きません。** Apple SiliconのMacにはNVIDIAのGPUが載っていないからです。また、CUDA 10.2のリリースノートには「CUDA 10.2がmacOSでCUDAアプリケーションを開発・実行できる最後のリリース」と書かれています。Mac上のPyTorchは `mps` デバイスでAppleのMetalを使いますが、これはCUDAとは別の仕組みです。この記事のコードを動かすには、Google ColabやクラウドのNVIDIA GPUを使ってください。

## 2. ホストとデバイス：CPUが指示し、GPUが大量のスレッドで実行する

### 2つの計算機、2つのメモリ

CUDAは**ヘテロジニアス**（異種混在）な計算機を前提にしています。CUDA Programming Guideの定義では、CPUとそれに直結したメモリを**ホスト**と**ホストメモリ**、GPUとそれに直結したメモリを**デバイス**と**デバイスメモリ**と呼びます。

プログラムは必ずCPUから始まります。CPUで動くコード（ホストコード）は、CUDAのAPIで次の3つを行います。

1. ホストメモリとデバイスメモリの間でデータをコピーする
2. GPUでコードを動かし始める（**カーネルの起動**）
3. コピーやカーネルの完了を待つ

GPUで動く関数は、歴史的な理由から**カーネル**と呼ばれます。カーネルを起動すると、GPU上で多数のスレッドが同じカーネルのコードを並列に実行し始めます。

例えるなら、ホストは現場監督、デバイスは何千人もの作業員がいる工場です。監督は材料（データ）を工場に運び込み、「全員でこの作業をせよ」と一つの指示書（カーネル）を渡し、終わったら製品を引き取ります。作業員は全員同じ指示書を持っていますが、自分の番号を見て、どの材料を担当するかを決めます。

### カーネルの起動は非同期

ここで一つ、CPUのプログラムとの大きな違いがあります。**カーネルの起動は、ホストのスレッドから見て非同期です。** 起動の命令は、GPUがカーネルを実行し終えるのを待たずに（実行を始める前でさえ）戻ってきます。結果を使う前には、`cudaDeviceSynchronize()`（GPUへのすべての作業の完了を待つ）や、12節で扱うストリーム・イベントで同期する必要があります。

メモリも基本的に別物です。`cudaMalloc` で確保したデバイスメモリは、CPUのコードからは直接読めません。CPUとGPUの両方からアクセスできる**ユニファイドメモリ**（`cudaMallocManaged`）もありますが、CUDA Programming Guideは、それでも最高の性能を得るにはデータの移動を最小限にし、データのある側のプロセッサから読むようにすべきだと書いています。この記事では、何がいつ動くかが見えやすい、明示的なコピーを使います。

## 3. スレッドの階層：grid・block・thread と warp

### 3段の階層

カーネルを起動するとき、スレッドは次の3段にまとめられます。

- **スレッド（thread）**：カーネルのコードを実行する最小の単位
- **スレッドブロック（block）**（以下、ブロック）：スレッドの集まり。現在のGPUでは1ブロックに最大1,024スレッド
- **グリッド（grid）**：ブロックの集まり。1回のカーネル起動が1つのグリッドになる

ブロックもグリッドも1〜3次元で並べられます。各スレッドは組み込み変数で自分の位置を知ります。

| 組み込み変数 | 意味 |
|---|---|
| `threadIdx.x/y/z` | ブロック内でのスレッドの番号（0始まり） |
| `blockIdx.x/y/z` | グリッド内でのブロックの番号（0始まり） |
| `blockDim.x/y/z` | ブロックの大きさ（スレッド数） |
| `gridDim.x/y/z` | グリッドの大きさ（ブロック数） |

1次元なら、スレッドが担当する要素の番号は次の式で計算するのが定番です。

$$
i = \mathtt{blockIdx.x} \times \mathtt{blockDim.x} + \mathtt{threadIdx.x}
$$

グリッドのx方向には最大 $2^{31}-1$ 個のブロックを並べられます。

### ブロック同士は独立している

この階層で最も重要な性質は、**ブロック同士が独立している**ことです。1つのブロックのスレッドはすべて同じSM（Streaming Multiprocessor、GPUの演算ブロック）で実行されます。一方、ブロックがどのSMにどの順で割り当てられるかは保証されません。そのため、あるブロックが同じグリッドの別のブロックの結果を当てにすることは、原則としてできません。

この制約と引き換えに、同じプログラムがSMを1つしか持たないGPUでも、数百持つGPUでも動きます。ブロックは、空いたSMに次々と配られるだけだからです。

なお、compute capability（CC、GPUの機能の世代を表す番号）9.0以降には、ブロックをまとめる**クラスター**という任意の階層があり、同じクラスターのブロックは同時にスケジュールされます。この記事のコードは使いません。

### warp：32スレッドが同じ命令を実行する

ブロックの中のスレッドは、32本ずつの**warp**にまとめられ、**SIMT**（Single Instruction, Multiple Threads）の方式で同じ命令を実行します。warp内での各スレッドの位置（0〜31）を**レーン**と呼びます。分岐でレーンの進む道が分かれると両方の道を順に実行する（**warp divergence**）ので、ブロックのスレッド数は32の倍数にし、warp内の分岐は少なくするのが基本です。SIMTとdivergenceの仕組みは、[CPUとGPUのアーキテクチャの違い](/blog/cpu-vs-gpu-architecture-pipeline-simt-roofline-explained)の8節で詳しく扱いました。

### 論理スレッドと物理的な演算器を混同しない

ここで、よくある誤解を正しておきます。**CUDAのスレッドは論理的な実行単位であり、演算器の数とは一致しません。**

T4を例に、公称値から計算してみます（Turingのホワイトペーパーと、CUDA Programming Guideのcompute capabilityの表より）。

| | T4（CC 7.5） | H100 SXM5（CC 9.0） |
|---|---|---|
| SM数 | 40 | 132 |
| SMあたりのFP32演算器（CUDAコア） | 64 | 128 |
| GPU全体のFP32演算器 | 2,560 | 16,896 |
| SMに同時に載るスレッドの上限 | 1,024 | 2,048 |
| GPU全体に同時に載るスレッドの上限（理論値） | 40,960 | 270,336 |

T4は2,560個の演算器に対して、最大40,960スレッドを同時に「載せて」おけます。比はちょうど16対1です（H100も同じ比になります）。載せたスレッドが全部同時に計算しているわけではありません。SMの**warpスケジューラ**は、毎サイクル、次の命令を実行できるwarpを選んで命令を発行します。メモリの読み込みを待っているwarpがあれば、別のwarpに切り替えます。warpの実行状態（プログラムカウンタやレジスタ）は生きている間ずっとチップ上に保持されるため、**warpの切り替えにコストはかかりません**。

さらに、グリッド全体では数百万のスレッドを起動できます。同時に載りきらない分は、先に載ったブロックが終わるのを待ってから実行されます。「CUDAコアが2,560個だから2,560スレッドまで」ではなく、「多くのスレッドを載せておき、待ち時間をほかのwarpの計算で隠す」のがGPUの基本的な考え方です。

CPUとの違いも、ここに表れます。CUDA Programming Guideは「CPUのコアとは異なり、SMは命令を順番通りに発行し、分岐予測や投機実行を行わない」と書いています。CPUが1つのスレッドを速く進める仕組みにチップの面積を割くのに対し、GPUは多数のwarpを切り替えることで待ち時間を隠します。

## 4. 最小のカーネル：ベクトル加算を完全なプログラムで

ここまでの概念を、最小の完全なプログラムで確かめます。2つの配列を要素ごとに足すだけのプログラムです。

- 対象：CUDA Toolkit（`nvcc`）とNVIDIAのGPU。ターゲットはT4（`sm_75`）
- ビルド：`nvcc -arch=sm_75 -O3 -o vector_add vector_add.cu`
- 実行：`./vector_add`

```cpp
// vector_add.cu — 最小の CUDA プログラム（c[i] = a[i] + b[i]）
// ビルド: nvcc -arch=sm_75 -O3 -o vector_add vector_add.cu
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cuda_runtime.h>

// すべての CUDA API の戻り値を確かめ、失敗したら場所とエラー名を出して終了する
#define CHECK(call)                                                       \
    do {                                                                  \
        cudaError_t err_ = (call);                                        \
        if (err_ != cudaSuccess) {                                        \
            std::fprintf(stderr, "CUDA error %s at %s:%d: %s\n",          \
                         cudaGetErrorName(err_), __FILE__, __LINE__,      \
                         cudaGetErrorString(err_));                       \
            std::exit(EXIT_FAILURE);                                      \
        }                                                                 \
    } while (0)

// 再現性のための簡単な疑似乱数（[0, 1) の float）
static float lcg01(unsigned& state) {
    state = state * 1664525u + 1013904223u;
    return (state >> 8) * (1.0f / 16777216.0f);
}

// __global__ = ホストから起動され、GPU 上で多数のスレッドが同じコードを実行する関数
__global__ void vecAdd(const float* a, const float* b, float* c, int n) {
    // このスレッドが担当する要素の番号（グリッド全体で一意）
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) {  // 端数ブロックの余ったスレッドは何もしない
        c[i] = a[i] + b[i];
    }
}

int main() {
    const int n = (1 << 20) + 3;  // わざとブロックサイズの倍数にしない
    const size_t bytes = static_cast<size_t>(n) * sizeof(float);

    std::vector<float> ha(n), hb(n), hc(n);
    unsigned seed = 12345u;
    for (int i = 0; i < n; ++i) {
        ha[i] = lcg01(seed);
        hb[i] = lcg01(seed);
    }

    float *da = nullptr, *db = nullptr, *dc = nullptr;
    CHECK(cudaMalloc(&da, bytes));
    CHECK(cudaMalloc(&db, bytes));
    CHECK(cudaMalloc(&dc, bytes));
    CHECK(cudaMemcpy(da, ha.data(), bytes, cudaMemcpyHostToDevice));
    CHECK(cudaMemcpy(db, hb.data(), bytes, cudaMemcpyHostToDevice));

    const int threads = 256;
    const int blocks = (n + threads - 1) / threads;  // 切り上げ除算
    vecAdd<<<blocks, threads>>>(da, db, dc, n);
    CHECK(cudaGetLastError());       // 起動設定の誤りをここで検出
    CHECK(cudaDeviceSynchronize());  // カーネル実行中のエラーをここで検出

    CHECK(cudaMemcpy(hc.data(), dc, bytes, cudaMemcpyDeviceToHost));

    // CPU で同じ計算をして比べる（1 回の加算なので誤差 0 が期待値）
    double maxErr = 0.0;
    for (int i = 0; i < n; ++i) {
        const float ref = ha[i] + hb[i];
        maxErr = std::fmax(maxErr, std::fabs(static_cast<double>(hc[i]) - ref));
    }
    const bool ok = maxErr <= 1e-6;
    std::printf("n=%d blocks=%d threads/block=%d\n", n, blocks, threads);
    std::printf("max abs error = %.3e (tolerance 1e-6)\n", maxErr);
    std::printf("%s\n", ok ? "PASS" : "FAIL");

    CHECK(cudaFree(da));
    CHECK(cudaFree(db));
    CHECK(cudaFree(dc));
    return ok ? EXIT_SUCCESS : EXIT_FAILURE;
}
```

**期待される出力**（GPUでの実行結果は未掲載）。プログラムは要素数、ブロック数、1ブロックのスレッド数を表示したあと、`max abs error = ...` の行で、GPUの結果とCPUで計算した値の差の最大値を表示し、最後に `PASS` または `FAIL` を表示します。1回の足し算なので、差は0になるはずです。

コードのポイントを確認します。

- **`__global__`**：ホストから起動されるカーネルであることを示す。戻り値は `void` でなければならない。結果は、グローバルメモリ（デバイスメモリ）に書いて返すしかない。
- **`__device__`**：GPUのコードからだけ呼べる関数を示す（8節の `warpReduceSum` で使う）。`__host__ __device__` と両方を付けると、CPU用とGPU用の両方が生成される。
- **`vecAdd<<<blocks, threads>>>(...)`**：カーネルの起動。最初の引数がグリッドの大きさ、2つ目がブロックの大きさ。
- **境界チェック `if (i < n)`**：要素数がブロックの大きさの倍数でないと、最後のブロックに余ったスレッドが出る。このプログラムでは、わざと要素数を $2^{20}+3$ にしている。
- **`CHECK` マクロ**：すべてのCUDA APIは `cudaError_t` を返す。CUDA Programming Guideも、本番ではすべての戻り値を確かめるのが最善だとしている。

エラー処理には、非同期ならではの落とし穴があります。`<<< >>>` での起動は `cudaError_t` を返さず、起動直後の `cudaGetLastError()` で分かるのは起動の設定の誤りまでです。カーネルの実行中のエラー（不正なメモリアクセスなど）は、その後に状態を確かめたときに初めて報告されます。そのため、`cudaGetLastError()` と `cudaDeviceSynchronize()` の戻り値の**両方**を確かめています。

## 5. コンパイルの流れ：CUDA C++ → NVVM → PTX → SASS

### NVCCは「コンパイラの指揮者」

`nvcc` は1つのコンパイラというより、複数のツールを順に呼び出すドライバです。流れは次の通りです。

1. `.cu` ファイルをホストコードとデバイスコードに分ける
2. ホストコードは、ホストのC++コンパイラ（gccなど）でコンパイルする
3. デバイスコードは、仮想アーキテクチャ（例：`compute_75`）ごとに**PTX**へ変換する
4. PTXを `ptxas` が、実際のGPU（例：`sm_75`）の機械語を含む**cubin**に変換する
5. PTXやcubinを**fatbin**という入れ物にまとめ、ホストの実行ファイルに埋め込む

```text
vector_add.cu
 ├─ ホストコード ──────── gcc などでコンパイル ─────────────┐
 └─ デバイスコード ─ NVVM(LLVMベース) ─→ PTX(compute_75) ─┤
                                    └─ ptxas ─→ cubin/SASS(sm_75)
                                                          ↓
                         実行ファイル = CPUの機械語 + fatbin(PTX と cubin)
```

3番目の段階には**NVVM**が使われています。NVIDIAのNVVM IR仕様は、NVVM IRを「LLVM IRに基づく」中間表現とし、「NVVMコンパイラ（LLVMベース）がNVVM IRからPTXを生成する」と書いています。NVIDIAの開発者向けページも、NVCCがオープンソースのLLVMの基盤に基づいていると説明しています。CUDA以外の言語やコンパイラも、PTXを出力すればNVIDIAのGPUで動かせます。`-v` を付けると各段階で呼ばれるツールが表示され、`-keep` を付けると中間ファイルが残ります。

### PTXとSASSの違い

| | PTX | SASS（cubinの中身） |
|---|---|---|
| 正体 | 仮想的な命令セット（「NVIDIAのGPU向けの高水準なアセンブリ言語」） | 実際のGPUが実行する機械語 |
| 形式 | テキスト | バイナリ（`cuobjdump` や `nvdisasm` で逆アセンブルできる） |
| 世代との関係 | `compute_75` のように、それが要求する機能の世代を表す | `sm_75` のように、特定の世代のGPU向け |
| 互換性 | 同じかそれより新しい世代のGPUで、ドライバがJITコンパイルして動かせる | メジャー番号が同じで、マイナー番号がGPU以下の場合だけ動く |
| 仕様 | PTX ISAとして公開（現在の版は9.5） | 命令の一覧は公開されているが、PTXのような詳細な仕様書ではない |

PTX ISAの文書は、PTXの目的として「複数のGPU世代にまたがる安定したISAを提供する」ことを挙げています。PTXでは、スレッドブロックを**CTA**（Cooperative Thread Array）と呼びます。データを置く場所は**状態空間**として区別され、`.reg`（レジスタ）、`.shared`、`.global`、`.local`、`.const`、`.param` などがあります。`threadIdx.x` は `%tid.x` という特殊レジスタになります。

### compute capabilityとバイナリ互換性

`-arch=sm_75` の意味を、互換性のルールとあわせて整理します。

- **cubinの互換性**：compute capabilityのメジャー番号が同じで、GPUのマイナー番号がcubin以上なら動く。たとえば `sm_86` のcubinはCC 8.6と8.9のGPUで動くが、8.0では動かない。メジャー番号が違うGPU（例：9.0）では動かない。ただし、`sm_90a` のようなアーキテクチャ固有のターゲットで作ったコードはそのCCのGPUでしか動かず、CC 10.0以降にはファミリー単位の互換性という別の規則もある（CUDA Programming Guideの1.3.4節と5.1.2節）。
- **PTXの互換性**：`compute_80` のPTXは、それ以上の任意のCCのGPU向けに、実行時にJITコンパイルできる。アプリケーションを作り直さずに、将来のGPUで動かせる。
- **`-arch=sm_75`**：`compute_75` のPTXと `sm_75` のcubinの両方を生成する。T4ではcubinがそのまま使われ、より新しいGPUではPTXがJITコンパイルされる。
- **`-arch=native`**：手元のGPU向けのcubinだけを作る。PTXは含まないので、将来のGPUへの前方互換性はない。

なお、2026-11-17時点で公開されているNVCCの文書（CUDA Toolkit v13.5）では、`-arch` を省略したときの既定値が `sm_75` で、対応するGPUの一覧もTuring（`sm_75`）から始まっています。T4は、この版のCUDAでもまだ対象に含まれる、最も古い世代ということになります。

### JITコンパイルとcompute cache

PTXしか含まないプログラムを新しいGPUで動かすと、ドライバが読み込み時にPTXを機械語にコンパイルします。これが**JIT（Just-In-Time）コンパイル**です。JITは読み込み時間を増やす代わりに、プログラムの作成時に存在しなかったGPUでも動かせます。ドライバは生成した機械語を**compute cache**に保存し、ドライバを更新するとこのキャッシュは無効になります。

T4では `sm_75` のcubinがそのまま使われるので、JITは起きません。それでも最初の呼び出しには、コンテキスト（GPUごとの実行環境）の作成がかかります。さらにCUDA 12.3以降は、モジュールを実際に必要になったときに読み込む**Lazy Loading**がすべてのプラットフォームで既定になっているので、カーネルの初回の起動にも読み込みの時間が乗りえます。この記事のプログラムが、時間を測る前に1回「ウォームアップ」を実行しているのはそのためです。

### PTXとSASSを自分の目で見る

次のコマンドで、PTXとSASSを確かめられます（筆者は未実行）。

```bash
# PTX（テキスト）を出力する
nvcc -arch=sm_75 -ptx vector_add.cu -o vector_add.ptx
grep -E "ld\.global|add(\.rn)?\.f32|st\.global" vector_add.ptx

# 実行ファイルの fatbin に入っている cubin と PTX の一覧
cuobjdump -lelf -lptx vector_add

# SASS（T4 の機械語）を逆アセンブルする
cuobjdump -sass vector_add | grep -E "LDG|FADD|STG"

# カーネルごとのレジスタ数・共有メモリ量を表示する
nvcc -arch=sm_75 -O3 -res-usage -c vector_add.cu
```

PTXには、`ld.global`（グローバルメモリからの読み込み）、`add.f32`（FP32の加算）、`st.global`（書き込み）にあたる命令が含まれると考えられます。CUDAのバイナリユーティリティの文書にある「Turingの命令セット（CC 7.5）」の表では、対応するSASSの命令は `LDG`（Load from Global Memory）、`FADD`（FP32 Add）、`STG`（Store to Global Memory）です。実際の出力は、コンパイラの版によって変わります。

## 6. メモリ階層：レジスタ・共有・グローバル・ローカル・定数

### 5種類のメモリ

GPUのカーネルが使うメモリは、見える範囲（スコープ）と寿命と置き場所が違います。CUDA Programming Guideの表に、T4とH100の容量を加えて整理します（容量はcompute capabilityの表とTuringのホワイトペーパーより）。

| 種類 | 見える範囲 | 寿命 | 置き場所 | T4（CC 7.5） | H100（CC 9.0） |
|---|---|---|---|---|---|
| レジスタ | スレッド | カーネル | SM | SMあたり64K個（1スレッド最大255個） | 同左 |
| 共有メモリ | ブロック | カーネル | SM | SMあたり最大64 KB | SMあたり最大228 KB |
| ローカルメモリ | スレッド | カーネル | デバイスメモリ | 1スレッド最大512 KB | 同左 |
| 定数メモリ | グリッド | アプリケーション | デバイスメモリ | 64 KB | 64 KB |
| グローバルメモリ | グリッド | アプリケーション | デバイスメモリ | 16 GB（GDDR6） | 80 GB（SXM5、HBM3） |

いくつか補足します。

- **共有メモリ**は、ブロック内のスレッドで共有する、プログラマが管理する作業領域です。物理的にはL1キャッシュと同じ資源（unified data cache）を使います。T4のunified data cacheは96 KBで、共有メモリとL1の配分を変えられます。グローバルメモリより帯域が広く、待ち時間が短いと説明されていますが、CUDA Programming Guideは具体的な待ち時間の数値を示していません。
- **ローカルメモリ**は、名前に反してチップの外のデバイスメモリにあります。「ローカル」は見える範囲（そのスレッドだけ）を表す言葉で、置き場所ではありません。添字が定数でない配列、大きな構造体、レジスタに入りきらない変数（**レジスタスピル**）がここに置かれ、グローバルメモリと同じ待ち時間と帯域になります。
- **静的に確保する共有メモリは1ブロック48 KBまで**です。それを超えるには、動的な共有メモリと明示的な設定（`cudaFuncSetAttribute`）が必要です。

### メモリ合体とバンク競合：プログラマができる対策

グローバルメモリはwarp単位でまとめて読み書きされるので、**連続するスレッドが連続する番地を読む**（メモリ合体、coalescing）と効率がよく、隣り合うスレッドが離れた番地を読むと、運んだデータの大半が無駄になります。CUDA Programming Guideの例では、利用率は最良で100%、最悪で12.5%です。共有メモリは32個のバンクに分かれていて、同じwarpの複数のスレッドが同じバンクの異なる番地にアクセスすると直列化されます（バンク競合）。仕組みの詳細は[CPUとGPUのアーキテクチャの違い](/blog/cpu-vs-gpu-architecture-pipeline-simt-roofline-explained)の10節で扱いました。

プログラマがとれる定番の対策は2つです。

- **共有メモリでタイルを並べ替える。** 行列の転置のように書き込み先が列方向に飛ぶ処理は、いったん共有メモリにタイルを読み込み、並べ替えてから書き出すと、読みも書きも合体する。4節の `vecAdd` は、もともと連続するスレッドが連続する要素を読むので、そのままで理想的な合体になる。
- **パディングでバンクをずらす。** `__shared__ float smem[32][32]` を列方向に読むと、32スレッドがすべて同じバンクに当たる。宣言を `[32][33]` にして1列分の詰め物を入れると、競合が消える。

## 7. 同期と競合状態：CPUとGPUで何が違うか

### ブロック内のバリア：`__syncthreads()`

ブロックのスレッドが共有メモリでデータをやり取りするときは、**書き込みが終わる前に読まない**ように同期が必要です。`__syncthreads()` は、ブロック内の（終了していない）すべてのスレッドが同じ `__syncthreads()` に到達するまで待ちます。さらに、それ以前の書き込みが、待ちを抜けたあとのスレッドから見えることも保証します。

使い方には厳しい条件があります。`__syncthreads()` を条件分岐の中で呼べるのは、その条件がブロック全体で同じ値になる場合だけです。一部のスレッドだけが通る分岐の中で呼ぶと、ハングや意図しない結果を招きます。

### グリッド全体のバリアはない

`__syncthreads()` が同期するのはブロック内だけです。3節で見たように、ブロックの実行順は保証されないので、通常のカーネルには**グリッド全体を同期する手段がありません**。ブロックをまたいで結果を集めるには、次のどちらかを使います。

1. **アトミック操作**：`atomicAdd` などで、読み・変更・書きを不可分に行う。CUDA Programming Guideは、アトミック操作はスレッド間の同期を強制して性能に影響するので、控えめに使うべきだとしている。
2. **カーネルを分ける**：1つ目のカーネルでブロックごとの部分結果を書き、2つ目のカーネルでそれを集計する。同じストリームのカーネルは順番に実行されるので、カーネルの境界が事実上のグリッド全体の同期になる。

（Cooperative Groupsを使えばブロックをまたぐ同期も書けますが、制約と性能上の影響があります。この記事では扱いません。）

### 弱いメモリモデルとデータ競合

CUDA Programming Guideは、CUDAのプログラミングモデルが**弱く順序付けられたメモリモデル**を前提にしていると明記しています。あるスレッドがメモリに書いた順番と、別のスレッドがそれを観測する順番は一致するとは限りません。同じ番地をフェンスや同期なしに読み書きすると（**データ競合**）、動作は未定義です。

### warpも勝手には揃わない

古い資料には、「warp内の命令はSIMDとして同期しているので `__syncthreads()` はいらない」という前提のコードがあります（NVIDIAのMark Harrisの有名なリダクションのスライドの「最後のwarpを展開する」段階など）。この前提は、CC 7.0以降では成り立ちません。**Independent Thread Scheduling**により、GPUがスレッドごとにプログラムカウンタを持ち、warpより細かい単位で分岐・合流するからです。CUDA Programming Guideは、こうしたコードを見直し、`__syncwarp()` で明示的に同期するよう求めています。マスク引数のない古いwarp命令は、CUDA 9で非推奨になりました。

### CPUとGPUの同期の違いを整理する

ここまでの違いを表にまとめます。

| 観点 | CPUのマルチスレッド（標準C++） | CUDA |
|---|---|---|
| スレッドの管理 | OSがスケジュールする | 数万本をSMに同時に載せ、warpの切り替えにコストがかからない |
| 同期のコスト | CUDAの文書の表現では、標準C++は同期のコストを「一様で安い」ものとして扱う | 近いスレッドほど安く、遠いほど高い |
| 同期の範囲 | どのスレッドとも、ミューテックスやアトミック変数で同期できる | warp（`__syncwarp`、シャッフル）→ ブロック（`__syncthreads`）→ デバイス（アトミック、カーネル境界）→ システム、という階層 |
| 全体のバリア | `std::barrier` で全スレッドを待てる | 通常のカーネルにグリッド全体のバリアはない |
| メモリの見え方 | `std::atomic` とメモリオーダーで規定 | 弱いメモリモデル。`cuda::atomic` などでスコープ（block・device・system）を指定する |
| CPUとGPUの間 | — | カーネル起動もコピーも非同期。ストリーム、イベント、`cudaDeviceSynchronize` で待つ |

CUDAのスコープは、ブロック（PTXでは `.cta`）、デバイス（`.gpu`）、システム（`.sys`、CPUや他のGPUを含む）の順に広がり、広いほど同期のコストが大きくなります。

## 8. リダクション：共有メモリの木構造とwarpシャッフル

### なぜ総和が難しいのか

配列の総和（**リダクション**）は、CPUなら1行のループです。GPUでは、数万のスレッドが1つの値に向かって結果を集めるので、7節の同期の問題が全部出てきます。

方針は**木構造**です。まずブロックの中で部分和を作り、ブロックごとの部分和を2回目のカーネルで足します。ブロックの中の部分和の作り方を2通り比べます。

1. **共有メモリの木構造**：全スレッドの値を共有メモリに置き、半分ずつ足していく。段ごとに `__syncthreads()` が必要。
2. **warpシャッフル**：`__shfl_down_sync` で、共有メモリを使わずにwarp内のレジスタ同士で値をやり取りする。共有メモリに置くのはwarpごとの部分和（8個）だけ。

`__shfl_down_sync(mask, v, offset)` は、自分より `offset` 番大きいレーンの `v` を受け取ります。offsetを16、8、4、2、1と半分にしながら足すと、5回でレーン0に32個の合計が集まります。`mask` は参加するレーンを示すビット列で、呼び出すスレッドは全員マスクに含まれ、同じマスクで呼ぶ必要があります。CC 8.0以降には `__reduce_add_sync` という専用の命令もありますが、対象は整数（int / unsigned）だけで、floatの総和には使えません（T4のCC 7.5ではそもそも使えません）。そこでシャッフルで書きます。

比較のために、正しいが遅い**atomicAdd**版と、同期をしない**データ競合**版も入れました。データ競合版は未定義動作の見本で、PASSとFAILの判定には使いません。

- ビルド：`nvcc -arch=sm_75 -O3 -o reduce reduce.cu`
- 実行：`./reduce`（要素数を引数で変えられる。既定は $2^{24}$）

```cpp
// reduce.cu — 総和（リダクション）を 4 通りで書いて比べる
//   1) 共有メモリの木構造 + __syncthreads
//   2) warp シャッフル（__shfl_down_sync）+ 共有メモリは warp ごとの部分和だけ
//   3) atomicAdd（正しいが遅く、足す順序が毎回変わる）
//   4) 同期なしの *out += x（データ競合。未定義動作の見本で、判定には使わない）
// ビルド: nvcc -arch=sm_75 -O3 -o reduce reduce.cu
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cuda_runtime.h>

#define CHECK(call)                                                       \
    do {                                                                  \
        cudaError_t err_ = (call);                                        \
        if (err_ != cudaSuccess) {                                        \
            std::fprintf(stderr, "CUDA error %s at %s:%d: %s\n",          \
                         cudaGetErrorName(err_), __FILE__, __LINE__,      \
                         cudaGetErrorString(err_));                       \
            std::exit(EXIT_FAILURE);                                      \
        }                                                                 \
    } while (0)

constexpr int kThreads = 256;           // 1 ブロック = 8 warp（2 のべき乗であること）
constexpr int kWarps = kThreads / 32;

static float lcg01(unsigned& state) {
    state = state * 1664525u + 1013904223u;
    return (state >> 8) * (1.0f / 16777216.0f);
}

// 1) 共有メモリでの木構造リダクション
__global__ void reduceSmem(const float* in, float* out, int n) {
    __shared__ float s[kThreads];
    float sum = 0.0f;
    // grid-stride ループ：スレッド数より要素が多くても全要素を拾う
    for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < n;
         i += blockDim.x * gridDim.x) {
        sum += in[i];
    }
    s[threadIdx.x] = sum;
    __syncthreads();  // 全員が s[] に書き終えるまで待つ
    for (unsigned int stride = blockDim.x / 2; stride > 0; stride /= 2) {
        if (threadIdx.x < stride) {
            s[threadIdx.x] += s[threadIdx.x + stride];
        }
#ifndef OMIT_SYNC  // -DOMIT_SYNC でこの同期を外すと共有メモリの競合になる
        __syncthreads();  // 次の段で読む値が書き終わるまで待つ
#endif
    }
    if (threadIdx.x == 0) out[blockIdx.x] = s[0];
}

// warp 内の 32 個の値を、共有メモリを使わずレジスタ間で足し合わせる
__device__ float warpReduceSum(float v) {
    for (int offset = warpSize / 2; offset > 0; offset /= 2) {
        // 自分より offset 番大きい lane の v を受け取る（32 lane 全員が参加）
        v += __shfl_down_sync(0xffffffffu, v, offset);
    }
    return v;  // lane 0 が warp の合計を持つ
}

// 2) warp シャッフル版
__global__ void reduceShfl(const float* in, float* out, int n) {
    __shared__ float warpSums[kWarps];
    float sum = 0.0f;
    for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < n;
         i += blockDim.x * gridDim.x) {
        sum += in[i];
    }
    const int lane = threadIdx.x % warpSize;
    const int warp = threadIdx.x / warpSize;
    sum = warpReduceSum(sum);
    if (lane == 0) warpSums[warp] = sum;
    __syncthreads();  // 全 warp の部分和がそろうまで待つ
    if (warp == 0) {  // warp 0 の 32 スレッドがそろって次の段を担当する
        sum = (lane < kWarps) ? warpSums[lane] : 0.0f;
        sum = warpReduceSum(sum);
        if (lane == 0) out[blockIdx.x] = sum;
    }
}

// 3) atomicAdd 版：読み・足し・書きを不可分に行う
__global__ void reduceAtomic(const float* in, float* out, int n) {
    for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < n;
         i += blockDim.x * gridDim.x) {
        atomicAdd(out, in[i]);
    }
}

// 4) 同期なし：複数スレッドが同じ番地を読み書きする（データ競合 = 未定義動作）
__global__ void reduceRacy(const float* in, float* out, int n) {
    for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < n;
         i += blockDim.x * gridDim.x) {
        *out += in[i];
    }
}

using Kernel = void (*)(const float*, float*, int);

// カーネルを起動するだけ（結果の取り出しは別）。twoPass=true なら
// blocks 個の部分和 → 1 ブロックで最終和、の 2 段階で求める
static void launch(Kernel k, bool twoPass, const float* d_in, float* d_partial,
                   float* d_out, int n, int blocks) {
    if (twoPass) {
        k<<<blocks, kThreads>>>(d_in, d_partial, n);
        CHECK(cudaGetLastError());
        k<<<1, kThreads>>>(d_partial, d_out, blocks);
        CHECK(cudaGetLastError());
    } else {
        CHECK(cudaMemsetAsync(d_out, 0, sizeof(float)));  // 足し込み先を 0 にする
        k<<<blocks, kThreads>>>(d_in, d_out, n);
        CHECK(cudaGetLastError());
    }
}

template <typename F>
static void printOccupancy(const char* name, F func, int maxThreadsPerSM) {
    cudaFuncAttributes attr{};
    CHECK(cudaFuncGetAttributes(&attr, func));
    int activeBlocks = 0;
    CHECK(cudaOccupancyMaxActiveBlocksPerMultiprocessor(&activeBlocks, func, kThreads, 0));
    std::printf("  %-12s regs/thread=%d static smem=%zu B local=%zu B -> %d blocks/SM, "
                "theoretical occupancy %.0f%%\n",
                name, attr.numRegs, attr.sharedSizeBytes, attr.localSizeBytes, activeBlocks,
                100.0 * activeBlocks * kThreads / maxThreadsPerSM);
}

int main(int argc, char** argv) {
    const int n = (argc > 1) ? std::atoi(argv[1]) : (1 << 24);
    if (n <= 0) {
        std::fprintf(stderr, "n must be a positive integer\n");
        return EXIT_FAILURE;
    }
    const int blocks = 1024;  // 1 段目のブロック数（= 部分和の個数）
    const size_t bytes = static_cast<size_t>(n) * sizeof(float);

    cudaDeviceProp prop{};
    CHECK(cudaGetDeviceProperties(&prop, 0));
    std::printf("device: %s (CC %d.%d, %d SMs)\n", prop.name, prop.major, prop.minor,
                prop.multiProcessorCount);

    std::vector<float> h(n);
    unsigned seed = 2026u;
    double ref = 0.0;  // 参照値は double で逐次に足す
    for (int i = 0; i < n; ++i) {
        h[i] = lcg01(seed);
        ref += h[i];
    }

    float *d_in = nullptr, *d_partial = nullptr, *d_out = nullptr;
    CHECK(cudaMalloc(&d_in, bytes));
    CHECK(cudaMalloc(&d_partial, blocks * sizeof(float)));
    CHECK(cudaMalloc(&d_out, sizeof(float)));
    CHECK(cudaMemcpy(d_in, h.data(), bytes, cudaMemcpyHostToDevice));

    cudaEvent_t start, stop;
    CHECK(cudaEventCreate(&start));
    CHECK(cudaEventCreate(&stop));

    struct Case { const char* name; Kernel k; bool twoPassMode; bool judged; };
    const Case cases[] = {
        {"smem-tree", reduceSmem, true, true},
        {"warp-shfl", reduceShfl, true, true},
        {"atomicAdd", reduceAtomic, false, false},
        {"racy", reduceRacy, false, false},
    };

    const double tol = 1e-5;  // 相対誤差の許容値
    bool allOk = true;
    std::printf("n=%d, reference (double) = %.6f\n", n, ref);
    for (const Case& c : cases) {
        // 1 回目はウォームアップ（初回の遅延を測らない）
        launch(c.k, c.twoPassMode, d_in, d_partial, d_out, n, blocks);
        CHECK(cudaDeviceSynchronize());

        CHECK(cudaEventRecord(start));
        launch(c.k, c.twoPassMode, d_in, d_partial, d_out, n, blocks);
        CHECK(cudaEventRecord(stop));
        CHECK(cudaEventSynchronize(stop));  // stop まで GPU が進むのを待つ
        float ms = 0.0f;
        CHECK(cudaEventElapsedTime(&ms, start, stop));

        float got = 0.0f;
        CHECK(cudaMemcpy(&got, d_out, sizeof(float), cudaMemcpyDeviceToHost));
        const double relErr = std::fabs(got - ref) / std::fabs(ref);
        const char* verdict = "(reference only)";
        if (c.judged) {
            const bool ok = relErr <= tol;
            allOk = allOk && ok;
            verdict = ok ? "PASS" : "FAIL";
        }
        std::printf("%-10s sum=%.6f rel.err=%.3e time=%.3f ms %s\n", c.name, got, relErr,
                    ms, verdict);
    }

    std::printf("occupancy (block = %d threads):\n", kThreads);
    printOccupancy("reduceSmem", reduceSmem, prop.maxThreadsPerMultiProcessor);
    printOccupancy("reduceShfl", reduceShfl, prop.maxThreadsPerMultiProcessor);

    std::printf("overall: %s (judged: smem-tree, warp-shfl; tolerance %.0e)\n",
                allOk ? "PASS" : "FAIL", tol);

    CHECK(cudaEventDestroy(start));
    CHECK(cudaEventDestroy(stop));
    CHECK(cudaFree(d_in));
    CHECK(cudaFree(d_partial));
    CHECK(cudaFree(d_out));
    return allOk ? EXIT_SUCCESS : EXIT_FAILURE;
}
```

**期待される出力**（GPUでの実行結果は未掲載）。プログラムは、double型で計算した参照値を表示したあと、4つの方式それぞれについて、合計値、参照値に対する相対誤差、実行時間を表示します。共有メモリの木構造とwarpシャッフルの2つは、相対誤差が $10^{-5}$ 以下ならPASSです。atomicAddと競合版は「(reference only)」と表示されます。最後に、各カーネルのレジスタ数、静的な共有メモリ量と、`cudaOccupancyMaxActiveBlocksPerMultiprocessor` が返すSMあたりのブロック数から求めた理論占有率を表示します。

競合版の `*out += in[i]` は、複数のスレッドが同じ番地を「読む→足す→書く」ので、ほかのスレッドの書き込みを上書きして消してしまいます。CUDA Programming Guideにも、アトミックでない加算では結果が正しい値より小さくなり、実行のたびに変わりうるという例があります。どんな値になるかは保証されません。

### 足す順番で誤差が変わる

浮動小数点の足し算は、順番を変えると結果が変わります。GPUで総和をとると、足す順番がCPUの単純なループとは変わります。そこで、許容誤差の根拠として、このプログラムと同じ入力（$2^{24}$ 個、同じ疑似乱数）と同じ足し方を、NumPyのfloat32でCPU上に再現しました。GPUで実行したのではなく、足す順番をCPUで模擬した結果です。

```text
reference (float64) = 8388079.921875
warp-shfl order      sum = 8388080.000000  rel.err = 9.314e-09
smem-tree order      sum = 8388080.000000  rel.err = 9.314e-09
sequential float32   sum = 8388031.000000  rel.err = 5.832e-06
```

木構造の足し方では相対誤差が約 $9\times10^{-9}$ で、先頭から順にfloat32で足していく場合（約 $5.8\times10^{-6}$）より約600倍小さくなりました。合計が大きくなってから小さな値を足すと、丸めで下の桁が失われやすいからです。許容誤差 $10^{-5}$ は、木構造の誤差に対して十分な余裕があります。

atomicAddは足す順番が実行のたびに変わるので、結果のビット列が毎回同じになるとは限りません。学習の再現性が求められる場面では、この点が問題になることがあります。

## 9. プレフィックス和（scan）：3段階で全体をつなぐ

### scanとは

**プレフィックス和**（**scan**）は、配列の先頭からの累積和を求める処理です。各要素に「自分までの合計」を入れるのが**inclusive scan**、「自分の手前までの合計」を入れるのが**exclusive scan**です。

$$
y_i = \sum_{j=0}^{i} x_j \quad (\text{inclusive}), \qquad y_i = \sum_{j=0}^{i-1} x_j \quad (\text{exclusive})
$$

一見すると前の結果に依存する逐次的な処理ですが、並列に計算できます。ストリーム圧縮（条件を満たす要素だけを詰める）、基数ソート、ヒストグラムなど、多くの並列アルゴリズムの部品になります。

### warp内のscanとブロック間のつなぎ方

GPU Gems 3のHarrisらの章は、各段で $2^d$ 離れた要素を足すHillisとSteeleの方式を紹介しつつ、それが $O(n \log n)$ 回の足し算をする「work-efficientでない」方式だと指摘しています。このプログラムでは、32要素しかないwarpの中でだけこの方式を使います（`__shfl_up_sync` で5段）。warpの中なら、仕事量の多さより段数の少なさが効くからです。

全体は3段階です。

1. 各ブロックが自分の範囲をscanし、ブロックの合計を書き出す
2. ブロックの合計の列を、1つのブロックでscanする
3. 各ブロックの要素に、自分より前のブロックの合計を足す

ブロック内は、warpごとのscan → warpの合計のscan → 前のwarpまでの合計を足す、という同じ形の2段構えです。

- ビルド：`nvcc -arch=sm_75 -O3 -o scan scan.cu`
- 実行：`./scan`（既定の要素数は $2^{20}-5$。ブロックの大きさの倍数でない値にしている）

```cpp
// scan.cu — 包含的プレフィックス和（inclusive scan）を 3 段階で求める
//   段階 1: 各ブロックが自分の担当範囲を scan し、ブロック合計を書き出す
//   段階 2: ブロック合計の列を 1 ブロックで scan する
//   段階 3: 各ブロックに「自分より前のブロックの合計」を足す
// ビルド: nvcc -arch=sm_75 -O3 -o scan scan.cu
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cuda_runtime.h>

#define CHECK(call)                                                       \
    do {                                                                  \
        cudaError_t err_ = (call);                                        \
        if (err_ != cudaSuccess) {                                        \
            std::fprintf(stderr, "CUDA error %s at %s:%d: %s\n",          \
                         cudaGetErrorName(err_), __FILE__, __LINE__,      \
                         cudaGetErrorString(err_));                       \
            std::exit(EXIT_FAILURE);                                      \
        }                                                                 \
    } while (0)

constexpr int kBlock = 1024;  // 1 ブロック = 32 warp。この実装はこの値を前提にする

// warp 内の inclusive scan（Hillis-Steele 型、5 段）
__device__ int warpInclusiveScan(int v) {
    const int lane = threadIdx.x % warpSize;
    for (int offset = 1; offset < warpSize; offset *= 2) {
        const int up = __shfl_up_sync(0xffffffffu, v, offset);  // offset 番下の lane の値
        if (lane >= offset) v += up;
    }
    return v;
}

// 段階 1（と段階 2）：ブロック内 scan。blockSums が nullptr でなければブロック合計を書く
__global__ void scanBlock(const int* in, int* out, int* blockSums, int n) {
    __shared__ int warpTotals[32];
    const int i = blockIdx.x * blockDim.x + threadIdx.x;
    const int lane = threadIdx.x % warpSize;
    const int warp = threadIdx.x / warpSize;

    int v = (i < n) ? in[i] : 0;  // 範囲外は 0 として扱う（合計に影響しない）
    v = warpInclusiveScan(v);
    if (lane == warpSize - 1) warpTotals[warp] = v;  // 各 warp の合計
    __syncthreads();

    if (warp == 0) {  // warp 合計の列（32 個）を scan する
        warpTotals[lane] = warpInclusiveScan(warpTotals[lane]);
    }
    __syncthreads();

    if (warp > 0) v += warpTotals[warp - 1];  // 自分より前の warp の合計を足す
    if (i < n) out[i] = v;
    if (blockSums != nullptr && threadIdx.x == blockDim.x - 1) {
        blockSums[blockIdx.x] = v;  // ブロックの最後のスレッドがブロック合計を持つ
    }
}

// 段階 3：前のブロックまでの合計を足す
__global__ void addOffsets(int* out, const int* scannedSums, int n) {
    const int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (blockIdx.x > 0 && i < n) out[i] += scannedSums[blockIdx.x - 1];
}

int main(int argc, char** argv) {
    const int n = (argc > 1) ? std::atoi(argv[1]) : (1 << 20) - 5;
    if (n <= 0) {
        std::fprintf(stderr, "n must be a positive integer\n");
        return EXIT_FAILURE;
    }
    const int numBlocks = (n + kBlock - 1) / kBlock;
    if (numBlocks > kBlock) {
        // 段階 2 を 1 ブロックで済ませるため、ブロック数は kBlock 以下に制限する
        std::fprintf(stderr, "n too large for this 3-phase demo (max %d)\n", kBlock * kBlock);
        return EXIT_FAILURE;
    }

    std::vector<int> h(n), got(n);
    unsigned state = 7u;
    for (int i = 0; i < n; ++i) {
        state = state * 1664525u + 1013904223u;
        h[i] = static_cast<int>((state >> 16) % 10u);  // 0〜9 の整数（和が int に収まる）
    }

    int *d_in = nullptr, *d_out = nullptr, *d_sums = nullptr, *d_scannedSums = nullptr;
    CHECK(cudaMalloc(&d_in, n * sizeof(int)));
    CHECK(cudaMalloc(&d_out, n * sizeof(int)));
    CHECK(cudaMalloc(&d_sums, numBlocks * sizeof(int)));
    CHECK(cudaMalloc(&d_scannedSums, numBlocks * sizeof(int)));
    CHECK(cudaMemcpy(d_in, h.data(), n * sizeof(int), cudaMemcpyHostToDevice));

    cudaEvent_t start, stop;
    CHECK(cudaEventCreate(&start));
    CHECK(cudaEventCreate(&stop));

    // 3 つのカーネルを順に起動する（同じストリームなので入れた順に実行される）
    auto runScan = [&]() {
        scanBlock<<<numBlocks, kBlock>>>(d_in, d_out, d_sums, n);
        CHECK(cudaGetLastError());
        scanBlock<<<1, kBlock>>>(d_sums, d_scannedSums, nullptr, numBlocks);
        CHECK(cudaGetLastError());
        addOffsets<<<numBlocks, kBlock>>>(d_out, d_scannedSums, n);
        CHECK(cudaGetLastError());
    };
    runScan();  // ウォームアップ（初回の起動にかかる時間を測らない）
    CHECK(cudaDeviceSynchronize());

    CHECK(cudaEventRecord(start));
    runScan();  // 何度実行しても同じ結果になる（段階 1 が d_out を全部書き直す）
    CHECK(cudaEventRecord(stop));
    CHECK(cudaEventSynchronize(stop));
    float ms = 0.0f;
    CHECK(cudaEventElapsedTime(&ms, start, stop));

    CHECK(cudaMemcpy(got.data(), d_out, n * sizeof(int), cudaMemcpyDeviceToHost));

    // CPU の逐次 scan と 1 要素ずつ完全一致を確かめる（整数なので誤差は許さない）
    std::vector<long long> ref(n);
    long long running = 0;
    for (int i = 0; i < n; ++i) {
        running += h[i];
        ref[i] = running;
    }
    long long firstBad = -1;
    for (int i = 0; i < n; ++i) {
        if (got[i] != ref[i]) {
            firstBad = i;
            break;
        }
    }
    std::printf("n=%d blocks=%d threads/block=%d\n", n, numBlocks, kBlock);
    std::printf("last element: gpu=%d cpu=%lld\n", got[n - 1], ref[n - 1]);
    if (firstBad >= 0) {
        std::printf("first mismatch at index %lld: gpu=%d cpu=%lld\n", firstBad,
                    got[firstBad], ref[firstBad]);
    }
    std::printf("time (3 kernels) = %.3f ms\n", ms);
    std::printf("%s\n", firstBad < 0 ? "PASS" : "FAIL");

    CHECK(cudaEventDestroy(start));
    CHECK(cudaEventDestroy(stop));
    CHECK(cudaFree(d_in));
    CHECK(cudaFree(d_out));
    CHECK(cudaFree(d_sums));
    CHECK(cudaFree(d_scannedSums));
    return firstBad < 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
```

**期待される出力**（GPUでの実行結果は未掲載）。プログラムは要素数とブロック数、最後の要素のGPUとCPUの値、ウォームアップ後に測った3つのカーネルの合計時間を表示し、全要素がCPUの逐次scanと完全に一致すれば `PASS` を表示します。入力は0〜9の整数なので、浮動小数点の誤差はなく、1つでも違えばFAILです。

冒頭の「検証の範囲」で書いた模擬環境では、上の要素数ですべてPASSになり、添字を1つずらす（`warpTotals[warp - 1]` を `warpTotals[warp]` にする）とFAILになりました。確かめられたのは添字と同期の位置という**ロジック**だけで、GPU上の速度、実際のwarpの動き、nvccがこのコードを受け付けるかは確かめられていません。

## 10. タイル化行列積：共有メモリでデータを再利用する

### 素朴な行列積の問題

$N \times N$ の行列積 $C = AB$ の演算量は $2N^3$ FLOPです。素朴なカーネルでは、1スレッドが $C$ の1要素を担当し、$A$ の1行と $B$ の1列を、グローバルメモリから直接読みます。

$A$ の各要素は $N$ 個のスレッドに、$B$ の各要素も $N$ 個のスレッドに読まれます。キャッシュが一切効かないと仮定すると、1回の掛け算と足し算（2 FLOP）のために4バイトの値を2つ、計8バイトを読むことになります。

### タイル化：共有メモリに載せて使い回す

**タイル化**では、ブロックが $T \times T$ の小さなタイルを共有メモリに読み込み、ブロック内の $T^2$ スレッドでそのタイルを使い回します。各スレッドは1要素ずつ運ぶだけで、その値はブロック内で $T$ 回使われます。グローバルメモリから読む量は、素朴な方式の $1/T$ になります。

グローバルメモリとのデータのやり取り1バイトあたりの演算数を**演算強度**（arithmetic intensity, AI）と呼びます。$A$・$B$ の読み込みと $C$ の書き込みを数えると、次のようになります（キャッシュによる再利用を無視したモデル）。

$$
\mathrm{AI}(T) = \frac{2N^3}{4\left(\dfrac{2N^3}{T} + N^2\right)} \ \ [\mathrm{FLOP/byte}]
$$

$N = 1024$ では、素朴な方式（$T = 1$）が約0.25、$T = 16$ が約3.97、$T = 32$ が約7.88 FLOP/byteです（11節の計算スクリプトの出力）。

- ビルド：`nvcc -arch=sm_75 -O3 -o matmul matmul.cu -lcublas`
- 実行：`./matmul`（時間を測る行列の大きさを引数で変えられる。既定は1,024）

```cpp
// matmul.cu — 行列積 C = A * B（FP32、行優先）を 3 通りで比べる
//   naive : 1 スレッドが C の 1 要素を、グローバルメモリから直接読んで計算
//   tiled : TILE x TILE のタイルを共有メモリに載せて再利用
//   cuBLAS: NVIDIA のライブラリ（PyTorch の torch.matmul も既定では cuBLAS を呼ぶ）
// ビルド: nvcc -arch=sm_75 -O3 -o matmul matmul.cu -lcublas
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cublas_v2.h>
#include <cuda_runtime.h>

#define CHECK(call)                                                       \
    do {                                                                  \
        cudaError_t err_ = (call);                                        \
        if (err_ != cudaSuccess) {                                        \
            std::fprintf(stderr, "CUDA error %s at %s:%d: %s\n",          \
                         cudaGetErrorName(err_), __FILE__, __LINE__,      \
                         cudaGetErrorString(err_));                       \
            std::exit(EXIT_FAILURE);                                      \
        }                                                                 \
    } while (0)

#define CHECK_CUBLAS(call)                                                \
    do {                                                                  \
        cublasStatus_t st_ = (call);                                      \
        if (st_ != CUBLAS_STATUS_SUCCESS) {                               \
            std::fprintf(stderr, "cuBLAS error %d at %s:%d\n",            \
                         static_cast<int>(st_), __FILE__, __LINE__);      \
            std::exit(EXIT_FAILURE);                                      \
        }                                                                 \
    } while (0)

constexpr int TILE = 16;  // 1 ブロック = 16 x 16 = 256 スレッド

static float lcgSym(unsigned& state) {  // [-1, 1) の疑似乱数
    state = state * 1664525u + 1013904223u;
    return (state >> 8) * (2.0f / 16777216.0f) - 1.0f;
}

__global__ void matmulNaive(const float* A, const float* B, float* C, int n) {
    const int row = blockIdx.y * blockDim.y + threadIdx.y;
    const int col = blockIdx.x * blockDim.x + threadIdx.x;
    if (row < n && col < n) {
        float acc = 0.0f;
        for (int k = 0; k < n; ++k) {
            acc += A[row * n + k] * B[k * n + col];  // 毎回グローバルメモリから読む
        }
        C[row * n + col] = acc;
    }
}

__global__ void matmulTiled(const float* A, const float* B, float* C, int n) {
    __shared__ float As[TILE][TILE];
    __shared__ float Bs[TILE][TILE];
    const int tx = threadIdx.x, ty = threadIdx.y;
    const int row = blockIdx.y * TILE + ty;
    const int col = blockIdx.x * TILE + tx;
    float acc = 0.0f;
    for (int t = 0; t < (n + TILE - 1) / TILE; ++t) {
        const int aCol = t * TILE + tx;
        const int bRow = t * TILE + ty;
        // 各スレッドが A と B のタイルを 1 要素ずつ運ぶ（はみ出す部分は 0）
        As[ty][tx] = (row < n && aCol < n) ? A[row * n + aCol] : 0.0f;
        Bs[ty][tx] = (bRow < n && col < n) ? B[bRow * n + col] : 0.0f;
        __syncthreads();  // タイルが全部そろうまで待つ
        for (int k = 0; k < TILE; ++k) {
            acc += As[ty][k] * Bs[k][tx];  // 共有メモリ上の値を TILE 回再利用
        }
        __syncthreads();  // 全員が読み終えるまで、次のタイルで上書きしない
    }
    if (row < n && col < n) C[row * n + col] = acc;
}

// CPU 参照：double で計算し、誤差の上限に使う sum|a*b| も同時に求める
static void cpuReference(const std::vector<float>& A, const std::vector<float>& B,
                         std::vector<double>& ref, std::vector<double>& absRef, int n) {
    ref.assign(static_cast<size_t>(n) * n, 0.0);
    absRef.assign(static_cast<size_t>(n) * n, 0.0);
    for (int i = 0; i < n; ++i) {
        for (int k = 0; k < n; ++k) {
            const double a = A[static_cast<size_t>(i) * n + k];
            for (int j = 0; j < n; ++j) {
                const double p = a * B[static_cast<size_t>(k) * n + j];
                ref[static_cast<size_t>(i) * n + j] += p;
                absRef[static_cast<size_t>(i) * n + j] += std::fabs(p);
            }
        }
    }
}

// FP32 の内積の丸め誤差は最悪でも約 n * 2^-24 * sum|a*b|。その 2 倍を許容値にする
static bool verify(const char* name, const std::vector<float>& got,
                   const std::vector<double>& ref, const std::vector<double>& absRef, int n) {
    const double unit = std::ldexp(1.0, -23);  // 2 * 2^-24
    double maxAbsErr = 0.0, worstRatio = 0.0;
    for (size_t i = 0; i < got.size(); ++i) {
        const double err = std::fabs(got[i] - ref[i]);
        const double bound = n * unit * absRef[i] + 1e-30;
        maxAbsErr = std::fmax(maxAbsErr, err);
        worstRatio = std::fmax(worstRatio, err / bound);
    }
    const bool ok = worstRatio <= 1.0;
    std::printf("  %-7s max abs error = %.3e, worst err/bound = %.3f -> %s\n", name,
                maxAbsErr, worstRatio, ok ? "PASS" : "FAIL");
    return ok;
}

template <typename F>
static void printOccupancy(const char* name, F func, int threadsPerBlock, int maxThreadsPerSM) {
    cudaFuncAttributes attr{};
    CHECK(cudaFuncGetAttributes(&attr, func));
    int activeBlocks = 0;
    CHECK(cudaOccupancyMaxActiveBlocksPerMultiprocessor(&activeBlocks, func, threadsPerBlock, 0));
    std::printf("  %-12s regs/thread=%d static smem=%zu B -> %d blocks/SM, "
                "theoretical occupancy %.0f%%\n",
                name, attr.numRegs, attr.sharedSizeBytes, activeBlocks,
                100.0 * activeBlocks * threadsPerBlock / maxThreadsPerSM);
}

// n x n の行列で 3 方式を実行する。timed=true なら CUDA イベントで時間を測る
static bool runCase(int n, bool timed, cublasHandle_t handle) {
    const size_t elems = static_cast<size_t>(n) * n;
    const size_t bytes = elems * sizeof(float);
    std::vector<float> hA(elems), hB(elems), hC(elems);
    unsigned seed = 42u + static_cast<unsigned>(n);
    for (size_t i = 0; i < elems; ++i) hA[i] = lcgSym(seed);
    for (size_t i = 0; i < elems; ++i) hB[i] = lcgSym(seed);

    float *dA = nullptr, *dB = nullptr, *dC = nullptr;
    CHECK(cudaMalloc(&dA, bytes));
    CHECK(cudaMalloc(&dB, bytes));
    CHECK(cudaMalloc(&dC, bytes));
    CHECK(cudaMemcpy(dA, hA.data(), bytes, cudaMemcpyHostToDevice));
    CHECK(cudaMemcpy(dB, hB.data(), bytes, cudaMemcpyHostToDevice));

    std::vector<double> ref, absRef;
    cpuReference(hA, hB, ref, absRef, n);

    const dim3 block(TILE, TILE);
    const dim3 grid((n + TILE - 1) / TILE, (n + TILE - 1) / TILE);
    const float alpha = 1.0f, beta = 0.0f;
    const int reps = timed ? 10 : 1;
    const double flops = 2.0 * n * static_cast<double>(n) * n;

    cudaEvent_t start, stop;
    CHECK(cudaEventCreate(&start));
    CHECK(cudaEventCreate(&stop));

    bool allOk = true;
    for (int method = 0; method < 3; ++method) {
        const char* name = (method == 0) ? "naive" : (method == 1) ? "tiled" : "cuBLAS";
        auto run = [&]() {
            if (method == 0) {
                matmulNaive<<<grid, block>>>(dA, dB, dC, n);
                CHECK(cudaGetLastError());
            } else if (method == 1) {
                matmulTiled<<<grid, block>>>(dA, dB, dC, n);
                CHECK(cudaGetLastError());
            } else {
                // cuBLAS は列優先。行優先の C = A*B は、列優先で見ると C^T = B^T * A^T
                CHECK_CUBLAS(cublasSgemm(handle, CUBLAS_OP_N, CUBLAS_OP_N, n, n, n, &alpha,
                                         dB, n, dA, n, &beta, dC, n));
            }
        };
        run();  // ウォームアップ兼、検証用の結果
        CHECK(cudaDeviceSynchronize());
        CHECK(cudaMemcpy(hC.data(), dC, bytes, cudaMemcpyDeviceToHost));
        allOk = verify(name, hC, ref, absRef, n) && allOk;

        if (timed) {
            CHECK(cudaEventRecord(start));
            for (int r = 0; r < reps; ++r) run();
            CHECK(cudaEventRecord(stop));
            CHECK(cudaEventSynchronize(stop));
            float ms = 0.0f;
            CHECK(cudaEventElapsedTime(&ms, start, stop));
            const double perRun = ms / reps;
            std::printf("  %-7s %.3f ms/run, %.1f GFLOP/s\n", name, perRun,
                        flops / (perRun * 1e-3) / 1e9);
        }
    }

    CHECK(cudaEventDestroy(start));
    CHECK(cudaEventDestroy(stop));
    CHECK(cudaFree(dA));
    CHECK(cudaFree(dB));
    CHECK(cudaFree(dC));
    return allOk;
}

int main(int argc, char** argv) {
    const int n = (argc > 1) ? std::atoi(argv[1]) : 1024;
    cudaDeviceProp prop{};
    CHECK(cudaGetDeviceProperties(&prop, 0));
    std::printf("device: %s (CC %d.%d, %d SMs)\n", prop.name, prop.major, prop.minor,
                prop.multiProcessorCount);

    cublasHandle_t handle;
    CHECK_CUBLAS(cublasCreate(&handle));

    // 1) タイルの倍数でない大きさで、境界処理の正しさだけを確かめる
    std::printf("[correctness] n=%d (not a multiple of TILE=%d)\n", 1000, TILE);
    bool ok = runCase(1000, false, handle);
    // 2) 時間を測る
    std::printf("[timing] n=%d, 10 runs each (after 1 warm-up)\n", n);
    ok = runCase(n, true, handle) && ok;

    std::printf("occupancy (block = %d threads):\n", TILE * TILE);
    printOccupancy("matmulNaive", matmulNaive, TILE * TILE, prop.maxThreadsPerMultiProcessor);
    printOccupancy("matmulTiled", matmulTiled, TILE * TILE, prop.maxThreadsPerMultiProcessor);

    CHECK_CUBLAS(cublasDestroy(handle));
    std::printf("overall: %s\n", ok ? "PASS" : "FAIL");
    return ok ? EXIT_SUCCESS : EXIT_FAILURE;
}
```

**期待される出力**（GPUでの実行結果は未掲載）。プログラムは2つの段階を実行します。最初に、タイルの倍数でない $N = 1000$ で、3つの方式の結果をCPUの参照値と比べ、境界の処理が正しいかを確かめます。次に、$N = 1024$（既定）で各方式を10回ずつ実行し、1回あたりの時間とGFLOP/sを表示します。各方式について `max abs error` と `worst err/bound` を表示し、`worst err/bound` が1以下ならPASSです。最後に、2つのカーネルのレジスタ数と理論占有率を表示します。

### 許容誤差の決め方

行列積の結果は、足す順番が方式ごとに違うので、CPUの値とビット単位では一致しません。そこで、FP32の内積の丸め誤差の上限を使って、要素ごとに許容誤差を決めています。$u = 2^{-24}$ をFP32の単位丸め誤差とすると、$N$ 項の内積の誤差は、おおよそ次の値で抑えられます。

$$
\left| \hat{c}_{ij} - c_{ij} \right| \lesssim N u \sum_{k} \left| a_{ik} b_{kj} \right|
$$

プログラムは、この右辺の2倍を要素ごとの許容値にしています。どの順番で足しても、FMA（掛け算と足し算を1回の丸めで行う命令）を使っても、正しい実装ならこの範囲に入ります。逆に、添字を間違えた実装はこの範囲を大きく外れます。実際に、模擬環境で `Bs[k][tx]` を `Bs[tx][k]` に変えると、`worst err/bound` が15万を超えてFAILになりました。

### cuBLASとの比較が意味すること

3つ目の方式は、NVIDIAのcuBLASライブラリの `cublasSgemm` です。cuBLASは列優先（Fortranと同じ並び）で行列を扱うので、行優先の $C = AB$ を、列優先で見た $C^T = B^T A^T$ として計算させています。

自作のタイル化カーネルは、教科書的な最初の一歩にすぎません。高速な実装は、各スレッドが複数の要素を計算してレジスタでもデータを使い回す（レジスタタイル化）、Tensor Coreを使う（[NVIDIAのGPUはなぜAIに強いのか](/blog/nvidia-gpu-ai-tensor-core-fp8-hbm-nvlink-explained)を参照）、といった工夫を重ねています。T4で `cublasSgemm` がどの実装を選ぶかは、筆者は確かめていません。

## 11. 独自分析：T4とH100で理論占有率を計算する

**占有率**（occupancy）は、SMに載っているwarpの数と、載せられる最大数の比です（定義と、高いほど速いとは限らないという注意は[CPUとGPUのアーキテクチャの違い](/blog/cpu-vs-gpu-architecture-pipeline-simt-roofline-explained)の9節で扱いました）。ここでは、T4とH100の違いを計算で確かめます。

1つのSMに載るブロックの数は、次の4つの上限の最小値で決まります。

1. SMに載るスレッド数の上限
2. SMに載るブロック数の上限
3. レジスタの数（1スレッドあたりのレジスタ数 × スレッド数が、SMの64K個に収まるか）
4. 共有メモリの量

CUDA C++ Best Practices Guideによれば、レジスタはwarpごとに256個単位で切り上げて割り当てられます。H100では、CUDAがブロックごとに共有メモリを1 KB予約します（Hopper Tuning Guide）。これらを使って、この記事のカーネルの理論占有率を、T4とH100について計算しました。レジスタ数はコンパイルするまで分からないので、32〜128の範囲で変えています。

- 対象：Python 3.9以降（標準ライブラリのみ）
- 実行：`python3 occupancy.py`

```python
"""理論占有率（occupancy）と GEMM の演算強度を、公開されている SM の上限値から計算する。

- 上限値: CUDA Programming Guide「Compute Capabilities」Table 33/34、
  Hopper Tuning Guide（ブロックごとに共有メモリ 1 KB を CUDA が予約）
- レジスタの割り当ては warp ごとに 256 個単位で切り上げ（CUDA C++ Best Practices Guide）
- すべて理論値。実際の値は cudaOccupancyMaxActiveBlocksPerMultiprocessor や
  Nsight Compute で確かめること。
Python 3.9 以降、標準ライブラリのみ。
"""
from dataclasses import dataclass
import math


@dataclass(frozen=True)
class SM:
    name: str
    max_threads: int        # 1 SM に同時に載るスレッド数の上限
    max_blocks: int         # 1 SM に同時に載るブロック数の上限
    regs: int               # 1 SM の 32 ビットレジスタ数
    smem: int               # 1 SM の共有メモリ（バイト）
    smem_reserved: int = 0  # ブロックごとに CUDA が予約する共有メモリ（バイト）


T4 = SM("T4 (CC 7.5)", 1024, 16, 65536, 64 * 1024)
H100 = SM("H100 (CC 9.0)", 2048, 32, 65536, 228 * 1024, smem_reserved=1024)
CC70 = SM("CC 7.0", 2048, 32, 65536, 96 * 1024)  # Best Practices Guide の例の検算用


def blocks_per_sm(sm, threads, regs_per_thread, smem_per_block, warp_granularity=1):
    warps = math.ceil(threads / 32)
    regs_per_warp = math.ceil(regs_per_thread * 32 / 256) * 256  # 256 個単位で切り上げ
    by_threads = sm.max_threads // (warps * 32)
    # レジスタで決まる warp 数（warp_granularity の倍数に切り下げる場合あり）
    warps_by_regs = (sm.regs // regs_per_warp) // warp_granularity * warp_granularity
    by_regs = warps_by_regs // warps
    by_smem = sm.smem // (smem_per_block + sm.smem_reserved) if smem_per_block else sm.max_blocks
    return min(sm.max_blocks, by_threads, by_regs, by_smem)


def occupancy(sm, threads, regs, smem, warp_granularity=1):
    b = blocks_per_sm(sm, threads, regs, smem, warp_granularity)
    return b, b * threads / sm.max_threads


print("== Check against the Best Practices Guide example (CC 7.0, 37 regs/thread) ==")
for threads, doc in ((128, "75%"), (320, "63%")):
    b1, o1 = occupancy(CC70, threads, 37, 0)
    b4, o4 = occupancy(CC70, threads, 37, 0, warp_granularity=4)
    print(f"{threads:4d} threads: 256-rule only -> {b1} blocks ({o1:.1%}), "
          f"warps floored to x4 -> {b4} blocks ({o4:.1%}), guide says {doc}")

kernels = [  # (名前, スレッド/ブロック, 静的共有メモリ/ブロック)
    ("reduceShfl 256thr", 256, 8 * 4),
    ("tiled GEMM TILE=16", 256, 2 * 16 * 16 * 4),
    ("tiled GEMM TILE=32", 1024, 2 * 32 * 32 * 4),
    ("smem 48KB 256thr", 256, 48 * 1024),
]
print("\n== Theoretical occupancy (blocks/SM, occupancy) ==")
print(f"{'kernel':20s} {'regs':>4s} | {'T4 (CC 7.5)':>16s} | {'H100 (CC 9.0)':>16s}")
for name, threads, smem in kernels:
    for regs in (32, 64, 96, 128):
        cells = []
        for sm in (T4, H100):
            b, occ = occupancy(sm, threads, regs, smem)
            cells.append("launch fails" if b == 0 else f"{b:2d} blk {occ:6.1%}")
        print(f"{name:20s} {regs:4d} | {cells[0]:>16s} | {cells[1]:>16s}")

print("\n== Max registers/thread for 100% occupancy (256-thread blocks) ==")
for sm in (T4, H100):
    best = max(r for r in range(1, 256) if occupancy(sm, 256, r, 0)[1] == 1.0)
    print(f"{sm.name}: <= {best} regs/thread")

print("\n== N x N FP32 GEMM: arithmetic intensity and bandwidth-bound ceiling (theoretical) ==")
N = 1024
devices = {  # (FP32 CUDA コアの理論ピーク FLOP/s, メモリ帯域 byte/s)
    "T4 (320 GB/s)": (8.1e12, 320e9),
    "T4 (300 GB/s)": (8.1e12, 300e9),
    "H100 SXM5": (66.9e12, 3352e9),
}
for dev, (peak, bw) in devices.items():
    print(f"{dev}: ridge point = {peak / bw:.1f} FLOP/byte")
for label, tile in (("naive (no reuse)", 1), ("tiled TILE=16", 16), ("tiled TILE=32", 32)):
    flops = 2 * N**3
    traffic = 4 * (2 * N**3 / tile + N**2)  # A,B の読み込み + C の書き込み（バイト）
    ai = flops / traffic
    bounds = ", ".join(f"{dev} {min(p, b * ai) / 1e12:.2f}" for dev, (p, b) in devices.items())
    print(f"{label:18s} AI = {ai:5.2f} FLOP/byte -> ceiling TFLOP/s: {bounds}")
```

筆者の環境（Apple M4 Pro、Python 3.13.7）での出力です。

```text
== Check against the Best Practices Guide example (CC 7.0, 37 regs/thread) ==
 128 threads: 256-rule only -> 12 blocks (75.0%), warps floored to x4 -> 12 blocks (75.0%), guide says 75%
 320 threads: 256-rule only -> 5 blocks (78.1%), warps floored to x4 -> 4 blocks (62.5%), guide says 63%

== Theoretical occupancy (blocks/SM, occupancy) ==
kernel               regs |      T4 (CC 7.5) |    H100 (CC 9.0)
reduceShfl 256thr      32 |     4 blk 100.0% |     8 blk 100.0%
reduceShfl 256thr      64 |     4 blk 100.0% |     4 blk  50.0%
reduceShfl 256thr      96 |     2 blk  50.0% |     2 blk  25.0%
reduceShfl 256thr     128 |     2 blk  50.0% |     2 blk  25.0%
tiled GEMM TILE=16     32 |     4 blk 100.0% |     8 blk 100.0%
tiled GEMM TILE=16     64 |     4 blk 100.0% |     4 blk  50.0%
tiled GEMM TILE=16     96 |     2 blk  50.0% |     2 blk  25.0%
tiled GEMM TILE=16    128 |     2 blk  50.0% |     2 blk  25.0%
tiled GEMM TILE=32     32 |     1 blk 100.0% |     2 blk 100.0%
tiled GEMM TILE=32     64 |     1 blk 100.0% |     1 blk  50.0%
tiled GEMM TILE=32     96 |     launch fails |     launch fails
tiled GEMM TILE=32    128 |     launch fails |     launch fails
smem 48KB 256thr       32 |     1 blk  25.0% |     4 blk  50.0%
smem 48KB 256thr       64 |     1 blk  25.0% |     4 blk  50.0%
smem 48KB 256thr       96 |     1 blk  25.0% |     2 blk  25.0%
smem 48KB 256thr      128 |     1 blk  25.0% |     2 blk  25.0%

== Max registers/thread for 100% occupancy (256-thread blocks) ==
T4 (CC 7.5): <= 64 regs/thread
H100 (CC 9.0): <= 32 regs/thread

== N x N FP32 GEMM: arithmetic intensity and bandwidth-bound ceiling (theoretical) ==
T4 (320 GB/s): ridge point = 25.3 FLOP/byte
T4 (300 GB/s): ridge point = 27.0 FLOP/byte
H100 SXM5: ridge point = 20.0 FLOP/byte
naive (no reuse)   AI =  0.25 FLOP/byte -> ceiling TFLOP/s: T4 (320 GB/s) 0.08, T4 (300 GB/s) 0.07, H100 SXM5 0.84
tiled TILE=16      AI =  3.97 FLOP/byte -> ceiling TFLOP/s: T4 (320 GB/s) 1.27, T4 (300 GB/s) 1.19, H100 SXM5 13.30
tiled TILE=32      AI =  7.88 FLOP/byte -> ceiling TFLOP/s: T4 (320 GB/s) 2.52, T4 (300 GB/s) 2.36, H100 SXM5 26.40
```

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

**1. H100のほうが、レジスタの制約が先に効く。** 256スレッドのブロックで理論占有率100%を保てるのは、T4では1スレッドあたり64レジスタ以下、H100では32レジスタ以下です。どちらもSMのレジスタは64K個ですが、H100はSMあたり2倍のwarp（64 warp）を載せられるので、1 warpあたりに割けるレジスタが半分になります。同じカーネルでも、64レジスタを使うとT4では100%、H100では50%になります。

**2. 1,024スレッドのブロックは、65レジスタ以上で起動できない。** 1,024スレッド（32 warp）でレジスタを65個使うと、warpあたり $65 \times 32 = 2080$ 個が256単位で2,304個に切り上げられ、ブロック全体で73,728個になります。SMの65,536個を超えるので、そのカーネルは起動できません。CUDA Programming Guideは、カーネルを起動する最大のブロックの大きさを `__launch_bounds__(maxThreadsPerBlock)` でコンパイラに伝えないと、「too many resources requested for launch」というエラーになりうると書いています。

**3. 共有メモリを多く使うカーネルでは、差が逆転する。** 1ブロック48 KBの共有メモリを使うと、T4（SMあたり64 KB）には1ブロックしか載らず、占有率は25%です。H100（228 KB、ブロックごとに1 KB予約）には4ブロック載り、50%になります。

**4. 公開されている規則だけでは、Best Practices Guideの例を再現できない。** ガイドは、CC 7.0で1スレッド37レジスタのとき、128スレッドのブロックなら12ブロック（75%）、320スレッドなら4ブロック（63%）と書いています。256個単位の切り上げだけで計算すると、1つ目は一致しますが、2つ目は5ブロック（78.1%）になります。レジスタで決まるwarp数を4の倍数に切り下げると、2つの例が両方とも再現できました。ただし、この「4の倍数」はガイドに書かれておらず、**筆者の推定**です。Nsight ComputeのPythonの占有率計算APIには `warps_allocation_granularity` という項目がありますが、その値は文書に書かれていません。

このため、上の表は**理論上の上限**として読んでください（共有メモリの割り当て単位も無視しています）。実際の値は、8節と10節のプログラムが表示する `cudaOccupancyMaxActiveBlocksPerMultiprocessor` の結果か、Nsight Computeで確かめられます。

### 演算強度から見た性能の上限

スクリプトの後半は、10節の演算強度を、FP32の理論ピークとメモリ帯域の比である**Ridge Point**（演算律速と帯域律速の境目。考え方は[NVIDIAのGPUはなぜAIに強いのか](/blog/nvidia-gpu-ai-tensor-core-fp8-hbm-nvlink-explained)の6節）と比べています。T4は約25.3 FLOP/byte（ホワイトペーパーの320 GB/sで計算。データシートは300 GB/sと書いており、NVIDIAの資料の間で食い違っている。その場合は約27.0）、H100 SXM5は約20.0です。$T = 32$ でも演算強度は約7.9なので、このモデルの上では、タイル化した行列積もまだ帯域律速です。ただし、このモデルはキャッシュによる再利用を無視した「すべての読み込みがDRAMに行く」場合の見積もりで、実際の素朴なカーネルはL1・L2キャッシュのおかげでこの上限より速く動く可能性があります。

## 12. ストリームとイベント：転送と計算を重ねる

### ストリームは順番待ちの列

**CUDAストリーム**は、GPUへの作業（コピーやカーネル）を順番に並べる列です。同じストリームの作業は入れた順に実行され、追い越しはありません。**別のストリームの作業は同時に実行されうる**ので、データを分割して「送る→計算する→戻す」をストリームごとに流すと、あるチャンクの計算中に次のチャンクを送れます。

### 重ねるための3つの条件

CUDA Programming GuideとBest Practices Guideによれば、転送と計算を重ねるには、次の条件が必要です。

1. **ホストメモリをピン留めする。** 通常のメモリ（`malloc` や `std::vector`）を渡すと、`cudaMemcpyAsync` は同期的な動作に戻り、ほかの処理と重なりません。`cudaMallocHost` で**ピン留め（page-locked）メモリ**を確保します。ただし希少な資源なので、使いすぎるとシステム全体の性能を下げることがあります。
2. **既定以外の、別々のストリームを使う。** Best Practices Guideによれば、既定のストリームの操作は、ほかのすべてのストリームの先行する操作が終わるまで始まらないため、重ね合わせには既定以外のストリームが必要です。`cudaStreamNonBlocking` が効くのは、legacy default streamとの暗黙の同期に対してです。このプログラムは既定のストリームを使いませんが、念のため付けています。
3. **コピーエンジンの数を確かめる。** 1つなら「1方向の転送」と「カーネル」、2つなら「送る」「戻す」「カーネル」の3つを同時に行えます。数は `asyncEngineCount` で分かります。T4での値は、筆者は確かめていません（プログラムが表示します）。

### 重ね合わせの効果を見積もる

チャンクに分けたときの所要時間を、理論的に見積もってみます。全データの「送る」「計算」「戻す」にかかる時間を $H$、$K$、$D$ とし、$n$ 個のチャンクに等分します（チャンクあたり $h = H/n$ など）。コピーエンジンが2つあり、3つの段階が完全に並行できると仮定すると、3段の流れ作業の所要時間は次のようになります。

$$
T_{\mathrm{overlap}} \approx h + k + d + (n - 1)\max(h, k, d)
$$

直列に実行した場合は $H + K + D$ です。仮に $H = K = D$ とすると、$n = 4$ では $1.5H$ となり、直列の $3H$ の半分になります。$n$ を大きくしても $\max(H, K, D)$ より短くはならないので、この場合の上限は3倍です。これは、チャンクごとの起動のオーバーヘッドやPCIeの帯域の取り合いを無視した理論値です。コピーエンジンが1つなら、送ると戻すが直列になり、効果は小さくなります。

- ビルド：`nvcc -arch=sm_75 -O3 -o streams streams.cu`
- 実行：`./streams [反復回数]`（カーネルの計算量を反復回数で調整できる。既定は500）

```cpp
// streams.cu — 転送と計算を CUDA ストリームで重ねる
//   A) 1 本のストリームで「全部送る → 全部計算 → 全部戻す」
//   B) データを kStreams 個に分け、ストリームごとに「送る → 計算 → 戻す」を流す
// どちらもピン留め（page-locked）ホストメモリを使う。非同期コピーの前提条件だから。
// ビルド: nvcc -arch=sm_75 -O3 -o streams streams.cu
// 実行:   ./streams [カーネル内の反復回数（既定 500）]
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cuda_runtime.h>

#define CHECK(call)                                                       \
    do {                                                                  \
        cudaError_t err_ = (call);                                        \
        if (err_ != cudaSuccess) {                                        \
            std::fprintf(stderr, "CUDA error %s at %s:%d: %s\n",          \
                         cudaGetErrorName(err_), __FILE__, __LINE__,      \
                         cudaGetErrorString(err_));                       \
            std::exit(EXIT_FAILURE);                                      \
        }                                                                 \
    } while (0)

constexpr int kStreams = 4;
constexpr int kThreads = 256;

// 計算量を反復回数で調整できるカーネル（v を 1.0 に近づける縮小写像）
__global__ void heavy(const float* in, float* out, int n, int iters) {
    const int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) {
        float v = in[i];
        for (int k = 0; k < iters; ++k) v = v * 0.999f + 0.001f;
        out[i] = v;
    }
}

int main(int argc, char** argv) {
    const int iters = (argc > 1) ? std::atoi(argv[1]) : 500;
    const int n = 1 << 24;                 // 16M 要素 = 64 MiB
    const int chunk = n / kStreams;        // n は kStreams で割り切れる
    const size_t bytes = static_cast<size_t>(n) * sizeof(float);
    const size_t chunkBytes = static_cast<size_t>(chunk) * sizeof(float);

    cudaDeviceProp prop{};
    CHECK(cudaGetDeviceProperties(&prop, 0));
    std::printf("device: %s, asyncEngineCount=%d (copy engines)\n", prop.name,
                prop.asyncEngineCount);

    float *hIn = nullptr, *hOut = nullptr;
    CHECK(cudaMallocHost(&hIn, bytes));   // ピン留めメモリ
    CHECK(cudaMallocHost(&hOut, bytes));
    for (int i = 0; i < n; ++i) hIn[i] = static_cast<float>(i % 1000) / 1000.0f;

    // CPU 参照。入力は 1000 種類の値しかないので、その 1000 個だけ計算して表引きする
    // （GPU は乗算と加算を FMA にまとめることがあるので、小さな差を許す）
    std::vector<float> table(1000);
    for (int r = 0; r < 1000; ++r) {
        float v = static_cast<float>(r) / 1000.0f;
        for (int k = 0; k < iters; ++k) v = v * 0.999f + 0.001f;
        table[r] = v;
    }
    auto check = [&](const char* name) {
        double maxErr = 0.0;
        for (int i = 0; i < n; ++i) {
            const double err = std::fabs(static_cast<double>(hOut[i]) - table[i % 1000]);
            maxErr = std::fmax(maxErr, err);
        }
        const bool ok = maxErr <= 1e-4;
        std::printf("  %-8s max abs error = %.3e (tolerance 1e-4) %s\n", name, maxErr,
                    ok ? "PASS" : "FAIL");
        return ok;
    };

    float *dIn = nullptr, *dOut = nullptr;
    CHECK(cudaMalloc(&dIn, bytes));
    CHECK(cudaMalloc(&dOut, bytes));

    cudaStream_t streams[kStreams];
    cudaEvent_t done[kStreams];
    for (int s = 0; s < kStreams; ++s) {
        CHECK(cudaStreamCreateWithFlags(&streams[s], cudaStreamNonBlocking));
        CHECK(cudaEventCreateWithFlags(&done[s], cudaEventDisableTiming));
    }
    cudaEvent_t start, stop;
    CHECK(cudaEventCreate(&start));
    CHECK(cudaEventCreate(&stop));

    // A) 1 本のストリームで直列に実行
    auto runSerial = [&]() {
        cudaStream_t s0 = streams[0];
        CHECK(cudaEventRecord(start, s0));
        CHECK(cudaMemcpyAsync(dIn, hIn, bytes, cudaMemcpyHostToDevice, s0));
        heavy<<<(n + kThreads - 1) / kThreads, kThreads, 0, s0>>>(dIn, dOut, n, iters);
        CHECK(cudaGetLastError());
        CHECK(cudaMemcpyAsync(hOut, dOut, bytes, cudaMemcpyDeviceToHost, s0));
        CHECK(cudaEventRecord(stop, s0));
        CHECK(cudaEventSynchronize(stop));
    };

    // B) kStreams 本に分けて実行。start/stop との依存はイベントで明示する
    auto runOverlapped = [&]() {
        CHECK(cudaEventRecord(start, streams[0]));
        for (int s = 1; s < kStreams; ++s) {
            CHECK(cudaStreamWaitEvent(streams[s], start, 0));  // start より後に始める
        }
        for (int s = 0; s < kStreams; ++s) {
            const size_t off = static_cast<size_t>(s) * chunk;
            CHECK(cudaMemcpyAsync(dIn + off, hIn + off, chunkBytes, cudaMemcpyHostToDevice,
                                  streams[s]));
            heavy<<<(chunk + kThreads - 1) / kThreads, kThreads, 0, streams[s]>>>(
                dIn + off, dOut + off, chunk, iters);
            CHECK(cudaGetLastError());
            CHECK(cudaMemcpyAsync(hOut + off, dOut + off, chunkBytes, cudaMemcpyDeviceToHost,
                                  streams[s]));
            CHECK(cudaEventRecord(done[s], streams[s]));
        }
        for (int s = 1; s < kStreams; ++s) {
            CHECK(cudaStreamWaitEvent(streams[0], done[s], 0));  // 全ストリームの完了を待つ
        }
        CHECK(cudaEventRecord(stop, streams[0]));
        CHECK(cudaEventSynchronize(stop));
    };

    bool ok = true;
    float ms = 0.0f;
    std::printf("n=%d floats (%.0f MiB), iters=%d, streams=%d\n", n, bytes / 1048576.0, iters,
                kStreams);

    runSerial();  // ウォームアップ
    for (int i = 0; i < n; ++i) hOut[i] = 0.0f;  // 測る回の出力だけを検証するために消す
    runSerial();
    CHECK(cudaEventElapsedTime(&ms, start, stop));
    std::printf("A) serial (1 stream)     : %.3f ms\n", ms);
    ok = check("serial") && ok;

    runOverlapped();  // ウォームアップ
    for (int i = 0; i < n; ++i) hOut[i] = 0.0f;  // 測る回の出力だけを検証するために消す
    runOverlapped();
    CHECK(cudaEventElapsedTime(&ms, start, stop));
    std::printf("B) overlapped (%d streams): %.3f ms\n", kStreams, ms);
    ok = check("overlap") && ok;

    for (int s = 0; s < kStreams; ++s) {
        CHECK(cudaStreamDestroy(streams[s]));
        CHECK(cudaEventDestroy(done[s]));
    }
    CHECK(cudaEventDestroy(start));
    CHECK(cudaEventDestroy(stop));
    CHECK(cudaFree(dIn));
    CHECK(cudaFree(dOut));
    CHECK(cudaFreeHost(hIn));
    CHECK(cudaFreeHost(hOut));
    std::printf("overall: %s\n", ok ? "PASS" : "FAIL");
    return ok ? EXIT_SUCCESS : EXIT_FAILURE;
}
```

**期待される出力**（GPUでの実行結果は未掲載）。プログラムはGPUの名前と `asyncEngineCount` を表示したあと、A（1本のストリームで直列）とB（4本のストリームに分割）の所要時間をミリ秒で表示し、それぞれの結果（ウォームアップの後に出力を消してから測った回のもの）をCPUの参照値と比べてPASSかFAILを表示します。カーネルの時間とコピーの時間が同程度のときに、重ね合わせの効果が最も見えやすくなります。どちらかが極端に長い場合は、引数の反復回数を変えて調整してください。

いくつか注意があります。

- GPUは `v * 0.999f + 0.001f` をFMAにまとめることがあります。NVCCの文書によれば、`--fmad` は既定で有効です。CPUの参照値はFMAを使わずに計算するので、結果がわずかにずれます。筆者がMac上で、FMAありとなしの差を1,000個の入力で計算したところ、500回の反復で最大 $6.3\times10^{-6}$、反復を10万回にしても最大 $1.3\times10^{-5}$ でした。許容誤差 $10^{-4}$ はこれに余裕を持たせた値です。
- Bでは、開始と終了の依存関係を `cudaStreamWaitEvent` で明示しています。既定のストリームの暗黙の同期に頼らないためです。
- CUDA Runtime APIの文書によれば、既定以外のストリームでイベントを記録すると、ほかの作業が間に入り、測った時間が実際より長く出ることがあります。正確な重なり方は、13節のNsight Systemsのタイムラインで確かめてください。

### カーネルの中の非同期コピー：cp.asyncとTMA

ストリームによる重ね合わせは、CPUとGPUの間の転送の話でした。これとは別に、**カーネルの中で**グローバルメモリから共有メモリへの転送を非同期にする仕組みもあります。

- **cp.async（LDGSTS）**：CC 8.0（Ampere）以降。スレッドがグローバルメモリから共有メモリへのコピーを開始し、完了を待たずに別の計算を進められる。PTX ISAの文書には「sm_80以上が必要」とある。
- **TMA（Tensor Memory Accelerator）**：CC 9.0（Hopper）以降。大きなブロックや最大5次元のテンソルを、グローバルメモリと共有メモリの間でまとめて非同期に転送する。

どちらもT4（CC 7.5）では使えません。この記事のタイル化行列積は、読み込み→`__syncthreads()`→計算→`__syncthreads()` という同期的な形のままです。

## 13. Nsight Systems と Nsight Compute：どちらを先に使うか

NVIDIAには性能を調べるツールが2つあり、役割がまったく違います。

| | Nsight Systems | Nsight Compute |
|---|---|---|
| 見るもの | アプリケーション全体のタイムライン（CPUのスレッド、CUDA APIの呼び出し、カーネル、コピー、ストリーム） | 1つのカーネルの中身（演算器・メモリの使用率、占有率、メモリの階層ごとの流量） |
| 公式の位置づけ | システム全体の性能分析ツール | 対話的なカーネルプロファイラ |
| 答える問い | 「GPUが遊んでいるのはどこか」「転送と計算は重なっているか」 | 「このカーネルは演算律速か帯域律速か」「なぜ遅いのか」 |
| 測り方 | 1回の実行を記録する。クロックは固定しない | カーネルを複数回再実行（リプレイ）して指標を集める。既定でSMのクロックを固定し、リプレイの間にキャッシュを消す |
| CLIの例 | `nsys profile -o report ./streams` | `ncu --section SpeedOfLight --section Occupancy -k regex:matmul ./matmul` |

順番は、**まずNsight Systems、次にNsight Compute**です。全体のタイムラインを見ないうちに1つのカーネルを細かく調べても、そのカーネルがボトルネックだとは限りません。CPU側の前処理やデータ転送でGPUが待っていることもよくあります。Nsight Systemsのタイムラインでカーネルを右クリックすると、そのカーネルをNsight Computeで調べるための操作が出てきます。

Nsight Computeの文書は、2つのツールで同じカーネルの時間が違って見える理由として、クロックの固定とキャッシュの消去を挙げています。比べるときは、`nvidia-smi` でクロックを外部から固定し、`ncu` に `--clock-control none` を付けることを勧めています。

正しさの検査には**Compute Sanitizer**を使います。`memcheck`（範囲外アクセス）、`racecheck`（共有メモリの競合）、`initcheck`（未初期化の読み込み）、`synccheck`（同期の誤り）があります。8節の `reduce.cu` を `-DOMIT_SYNC` 付きでビルドすると、共有メモリの木構造の `__syncthreads()` が外れるので、`compute-sanitizer --tool racecheck` で競合として検出されるはずです（筆者は未実行）。なお、`racecheck` が見るのは共有メモリの競合で、グローバルメモリへの競合版（`reduceRacy`）は対象外です。

## 14. PyTorchとの関係：torch.matmul からカーネルまで

普段PyTorchを使っている人にとって、ここまでの話はどこに現れているのでしょうか。

- **非同期実行**：PyTorchの文書は「既定では、GPUの操作は非同期」と書いています。演算はGPUのキューに積まれるだけで、すぐには実行されません。そのため、`time.time()` で囲んだだけの計測は正確ではなく、`torch.cuda.synchronize()` か `torch.cuda.Event(enable_timing=True)` を使う必要があります。これは、この記事のプログラムで `cudaEventRecord` を使ったのと同じ理由です。エラーの発生場所を特定したいときは、環境変数 `CUDA_LAUNCH_BLOCKING=1` で同期実行にできます。
- **行列積はcuBLAS**：`torch.backends.cuda.preferred_blas_library` の説明によれば、PyTorchはCUDAのBLAS演算で、cuBLASとcuBLASLtの両方が使える場合でも、既定ではcuBLASを使います。10節で `cublasSgemm` と比べたのは、`torch.matmul` が裏で呼んでいるものと比べたことになります。
- **畳み込みなどはcuDNN**：`torch.backends.cudnn` の設定で、cuDNNの使用を制御できます。
- **ストリームとピン留めメモリ**：`torch.cuda.Stream` でストリームを作れます。`DataLoader(pin_memory=True)` と `.to(device, non_blocking=True)` の組み合わせは、12節の「ピン留めメモリ＋非同期コピー」そのものです。
- **自作のカーネル**：`torch.utils.cpp_extension.load_inline` で、文字列に書いたC++とCUDAのコードを実行時にビルドして読み込めます。PyTorchのチュートリアルは、`TORCH_LIBRARY` で演算子を登録し、`TORCH_LIBRARY_IMPL(..., CUDA, m)` でCUDA版の実装を登録する方法を案内しています。
- **torch.compile**：既定のコンパイラであるTorchInductorは、PyTorchの文書によれば、NVIDIAのGPUではOpenAIのTritonを中心的な部品として使い、カーネルを生成します。CUDA C++を書かずに、複数の演算を1つのカーネルにまとめる（融合する）手段です。

つまり、PyTorchのコードの1行は、最終的にcuBLAS・cuDNNのカーネル、PyTorch自身のCUDAカーネル、Tritonが生成したカーネルのどれかとしてGPUで実行されます。どれが実行されているかは、Nsight Systemsのタイムラインで確かめられます。

## 15. CUDAで書くべきか：限界と判断基準

### CUDAが期待通りに働かない条件

ここまでの内容を裏返すと、CUDAが期待通りに働かない条件が見えてきます。

- **並列にできる仕事が少ない。** 数千要素の配列の処理では、カーネルの起動やデータ転送のコストのほうが大きくなりえます。Best Practices Guideは、デバイスメモリの帯域（V100の例で898 GB/s）とPCIe x16 Gen3（16 GB/s）の差を挙げ、転送を最小限にすべきだとしています。
- **ブロック間の依存が強い。** グリッド全体のバリアがないので、全要素が前の段の全結果に依存する処理は、カーネルを何度も分けることになります。
- **分岐が多く、warpの中で道が割れる。** divergenceが多いと、warpは両方の道を実行し、演算器の多くが遊びます。
- **浮動小数点の再現性が必要。** 8節で見たように、足す順番で結果が変わります。atomicAddを使う集計は、結果のビット列が実行ごとに変わりえます。
- **移植性が必要。** CUDAのコードはNVIDIAのGPUでしか動きません。Macでも動きません。
- **保守のコスト。** 自前のカーネルは、GPUの世代が変わるたびに性能を確かめ直す必要があります。cuBLASやcuDNNは、NVIDIAが新しい世代に合わせて更新します。

### どの順で手段を選ぶか

GPUで処理を速くしたいときに、どの順で手段を選ぶかを整理します。

| 状況 | まず使うもの | 自作カーネルを考える条件 |
|---|---|---|
| 行列積、畳み込み、注意機構など、定番の演算 | cuBLAS・cuDNN、フレームワークの既存の演算 | ほぼない |
| 小さな演算が多数つながっている | `torch.compile`（Tritonによる融合） | 融合しても、メモリの往復が支配的なまま残る |
| ライブラリにない独自の演算 | Triton、CuPyなどの高水準の手段 | 細かい共有メモリの制御やwarpレベルの操作が必要 |
| どこが遅いか分からない | Nsight Systemsで全体を見る | ボトルネックが特定の1つのカーネルだと分かってから |

自作するときは、①CPUの参照実装と根拠のある許容誤差を先に作り、②Nsight Systemsでボトルネックを確かめ、③演算強度から律速を見積もり（帯域律速なら、タイル化や融合で読み書きを減らすのが先）、④占有率は低すぎないかの確認に使い、⑤Nsight ComputeとCompute Sanitizerで性能と正しさの両方を確かめる、という順で進めてください。

筆者が扱ってきたT4 1枚の推論基盤では、自分でCUDAカーネルを書く必要はありませんでした（[AI動画ローカライズのGPUパイプライン](/blog/production-ai-video-localization-lipsync-gpu-pipeline)）。それでも、カーネルの起動が非同期であること、GPUのメモリが限られていてデータの置き場所が性能を決めることは、vLLMの設定やジョブの直列化を考えるうえで、そのまま判断材料になりました。CUDAの仕組みを知る価値は、カーネルを書くかどうかに関係なく、GPUの上で何が起きているかを推測できるようになることにあります。

実務で先に効くのは、カーネルを書くかどうかより、どのGPUを何枚使うかです。VRAMに重みとKVキャッシュが収まるか、API課金と比べて採算が取れるかは、[量子化とVRAM予算](/blog/llm-quantization-serving-economics-awq-fp8-kv-cache-vram-budget)と[APIか自社ホストか](/blog/generative-ai-cost-api-vs-self-hosting-decision-guide)で試算しています。

## まとめ

- **CUDAは、ホスト（CPU）がデバイス（GPU）に大量のスレッドを起動させるモデルと道具の集まり**です。起動は非同期で、メモリは基本的に別物です。通常、Apple Silicon搭載のMacでは動きません。
- **スレッドはgrid・block・threadの3段**で、32スレッドのwarpが同じ命令を実行します。T4は2,560個の演算器に対して最大40,960スレッドを載せ、warpを切り替えて待ち時間を隠します。
- **CUDA C++は、NVCCがNVVM（LLVMベース）でPTXにし、ptxasがSASSにします。** PTXは世代をまたぐ仮想ISAで、実行ファイルに入れておけばドライバがJITコンパイルできます。SASSは世代ごとの機械語です。
- **メモリはレジスタ・共有・ローカル・定数・グローバルの5種類**で、グローバルメモリはwarp単位の合体、共有メモリはバンク競合が性能を左右します。
- **同期の範囲は階層的**です。`__syncthreads()` はブロック内、シャッフルはwarp内だけで、グリッド全体のバリアはありません。メモリモデルは弱く、CC 7.0以降はwarpも自動では揃いません。
- **独自分析**：公開されているSMの上限から計算すると、256スレッドのブロックで理論占有率100%を保てるのは、T4で64レジスタ以下、H100で32レジスタ以下です。ただし、Best Practices Guideの例は文書化された規則だけでは再現できず、表は理論上の上限として扱う必要があります。
- 実務では、まずcuBLAS・cuDNN・`torch.compile` を使い、Nsight Systemsでボトルネックを確かめてから自作カーネルを検討します。
