この記事の対象読者

Pythonの基本的な文法を理解している方
「CUDA」という言葉を聞いたことがあるが、詳しくは知らない方
ローカルLLMやStable DiffusionなどGPUを使うツールに興味がある方
GPU開発の全体像を把握したいエンジニア

この記事で得られること

CUDA Toolkitの構成要素と各コンポーネントの役割の理解
nvcc（CUDAコンパイラ）の仕組みとコンパイルフローの把握
CUDA付属ライブラリ（cuBLAS, cuFFT等）の概要と使い分け
開発ツール（Nsight Systems/Compute）によるプロファイリングの基礎
環境構築から動作確認までの実践的な手順

この記事で扱わないこと

CUDAカーネルのゴリゴリな最適化テクニック
マルチGPUプログラミング
CUDA Cによる本格的なカスタムカーネル開発

1. CUDA Toolkitとの出会い

「PyTorchインストールしたのに、なんでCUDA Toolkitも入れなきゃいけないの？」

GPU環境を構築していて、こんな疑問を抱いたことはないだろうか。私は何度もあった。

最初は「とりあえずcondaで入れておけばいい」くらいの認識だった。しかし、ある日Stable Diffusionの推論速度を最適化しようとしたとき、壁にぶつかった。xformersのビルドに失敗し、エラーメッセージには「nvccが見つからない」の文字。

「nvccって何だ...？」

そこから調べ始めて、CUDA Toolkitが単なる「おまけ」ではなく、GPU開発の根幹を支える「工具箱」だと気づいた。

CUDA Toolkitは、NVIDIAが提供するGPU開発の総合パッケージだ。コンパイラ、ライブラリ、デバッグツール、プロファイラ...GPU開発に必要なものが全部入っている。いわば「GPU職人の道具一式」。

ここまでで、CUDA Toolkitがどんな立ち位置なのか、なんとなくイメージできただろうか。次は、この道具箱の中身を一つずつ見ていこう。

2. 前提知識の確認

本題に入る前に、この記事で使う用語を整理しておく。

2.1 CUDA（Compute Unified Device Architecture）とは

NVIDIAが開発した、GPUで汎用計算を行うためのプラットフォーム。2007年にリリースされ、今ではAI/ML分野のデファクトスタンダードになっている。

2.2 GPU（Graphics Processing Unit）とは

もともとは画像処理専用のプロセッサ。数千のコアを持ち、並列処理が得意。CPUが「少数精鋭の専門家チーム」なら、GPUは「大人数の作業員軍団」。

2.3 コンパイラとは

人間が書いたプログラムを、機械が実行できる形式に変換するソフトウェア。C言語ならgcc、Rustならrustc、そしてCUDAならnvcc。

2.4 ライブラリとは

よく使う機能をまとめた「部品集」。自分で一から書かなくても、ライブラリを呼び出すだけで高度な処理ができる。

これらの用語が押さえられたら、次に進もう。

3. CUDA Toolkitが生まれた背景

3.1 GPUプログラミングの黎明期

2000年代初頭、GPUで科学計算をしようとすると、OpenGLやDirectXといったグラフィックスAPIを「騙して」使う必要があった。計算結果をピクセルの色に変換したり、逆変換したり...正直、地獄だった。

3.2 NVIDIAの決断

2006年、NVIDIAは画期的な決断をした。「GPUを汎用計算に開放しよう」と。そして2007年、CUDA 1.0がリリースされた。これにより、GPUプログラミングは「グラフィックスの裏技」から「正式なプログラミングモデル」へと進化した。

3.3 現在の立ち位置

今やCUDAは、深層学習フレームワーク（PyTorch、TensorFlow）、科学計算、金融シミュレーション、医療画像処理など、あらゆる分野で使われている。CUDA Toolkitはその開発基盤として、年々進化を続けている。

背景がわかったところで、抽象的な概念から順に、具体的なコンポーネントを見ていこう。

4. CUDA Toolkitの全体像

CUDA Toolkitは大きく4つのカテゴリに分類できる。

カテゴリ	主なコンポーネント	役割
コンパイラ	nvcc, nvrtc	CUDAコードを実行可能形式に変換
ライブラリ	cuBLAS, cuFFT, cuDNN等	高性能な数学関数を提供
ランタイム	CUDA Runtime API, Driver API	GPUとの通信を抽象化
開発ツール	Nsight Systems/Compute, cuda-gdb	デバッグとプロファイリング

これを「GPU開発の工具箱」に例えると、こうなる。

CUDA Toolkit（工具箱）
├── nvcc（ドライバー）       → コードを組み立てる道具
├── cuBLAS/cuFFT（電動工具） → 重い作業を自動化
├── Runtime API（説明書）    → GPUの使い方ガイド
└── Nsight（測定器）         → 性能を計測・診断

基本概念が理解できたところで、これらの抽象的な概念を具体的なコンポーネントの解説に落とし込んでいこう。

5. nvcc: CUDAコンパイラの仕組み

5.1 nvccとは何か

nvcc（NVIDIA CUDA Compiler）は、CUDAコードをコンパイルするためのドライバプログラム。実際には複数のツールを内部で呼び出し、複雑なコンパイル処理を一手に引き受けてくれる。

5.2 コンパイルの流れ

CUDAプログラムのコンパイルは、以下の流れで進む。

ソースコード (.cu)
    ↓
[前処理] デバイスコードとホストコードを分離
    ↓
[デバイスコンパイル] → PTX（中間表現）→ cubin（バイナリ）
    ↓
[ホストコンパイル] → g++/clang で通常のC++としてコンパイル
    ↓
[リンク] デバイスコードをfatbinaryとしてホストコードに埋め込み
    ↓
実行可能ファイル

5.3 PTX, cubin, fatbinaryって何？

この3つの用語は、CUDAコンパイルを理解する上で重要だ。

形式	説明	例えるなら
PTX	仮想的な中間表現。GPUアーキテクチャに依存しない	設計図
cubin	特定のGPUアーキテクチャ向けのバイナリ	完成品
fatbinary	複数のPTX/cubinをまとめたコンテナ	詰め合わせセット

PTXの利点は「前方互換性」。古いCUDA Toolkitでコンパイルしたコードでも、新しいGPUで実行するときにJIT（Just-In-Time）コンパイルされる。

5.4 アーキテクチャ指定の重要性

nvccでは-archオプションでターゲットアーキテクチャを指定する。

# 仮想アーキテクチャ（PTX生成）
nvcc -arch=compute_89 sample.cu -o sample

# 実アーキテクチャ（cubin生成）
nvcc -arch=sm_89 sample.cu -o sample

# 複数ターゲット（推奨）
nvcc -gencode arch=compute_80,code=sm_80 \
     -gencode arch=compute_89,code=sm_89 \
     -gencode arch=compute_89,code=compute_89 \
     sample.cu -o sample

最後の例では、sm_80とsm_89向けのcubinと、将来のGPU向けのPTXを同時に生成している。

nvccの仕組みがわかったところで、次はCUDA Toolkitに含まれるライブラリ群を見ていこう。

6. CUDAライブラリ: 高性能計算の「電動工具」

CUDA Toolkitには、GPU最適化された数学ライブラリが多数含まれている。これらを使えば、自分でカーネルを書かなくても高性能な処理が可能になる。

6.1 主要ライブラリ一覧

ライブラリ	正式名称	用途	CPU版の相当品
cuBLAS	CUDA Basic Linear Algebra Subroutines	行列演算（GEMM等）	OpenBLAS, MKL
cuFFT	CUDA Fast Fourier Transform	高速フーリエ変換	FFTW
cuSPARSE	CUDA Sparse Matrix	疎行列演算	MKL Sparse
cuSOLVER	CUDA Solver	連立方程式、固有値計算	LAPACK
cuRAND	CUDA Random Number Generation	乱数生成	-
NPP	NVIDIA Performance Primitives	画像・信号処理	Intel IPP
cuDNN	CUDA Deep Neural Network	深層学習の基本演算	-

6.2 cuBLAS: 行列演算の主役

深層学習の計算の大部分は行列演算。cuBLASはその心臓部を担う。

# PyTorchでの行列積（内部でcuBLASが呼ばれる）
import torch

a = torch.randn(1024, 1024, device='cuda')
b = torch.randn(1024, 1024, device='cuda')
c = torch.mm(a, b)  # cuBLASのSGEMM/DGEMMが動く

6.3 cuFFT: 信号処理の定番

音声処理や画像処理でおなじみのFFT。cuFFTを使えばGPUで高速に実行できる。

import torch.fft

signal = torch.randn(1024, device='cuda')
spectrum = torch.fft.fft(signal)  # cuFFTが動く

6.4 cuDNN: 深層学習の縁の下の力持ち

畳み込み、正規化、活性化関数など、深層学習に必要な演算を高度に最適化。PyTorchやTensorFlowは内部でcuDNNを呼び出している。

# cuDNNのベンチマークモード（最適なアルゴリズムを自動選択）
torch.backends.cudnn.benchmark = True

ライブラリの概要が把握できたところで、次はRuntime APIとDriver APIの違いを見ていこう。

7. Runtime API vs Driver API

CUDAには2つのAPIレベルが存在する。これが初心者を混乱させる原因の一つ。

7.1 二つのAPIの違い

項目	Runtime API	Driver API
ヘッダ	`cuda_runtime.h`	`cuda.h`
ライブラリ	`libcudart.so`	`libcuda.so`
提供元	CUDA Toolkit	NVIDIAドライバ
抽象度	高い（使いやすい）	低い（細かい制御可能）
初期化	暗黙的	明示的
用途	一般的なCUDAアプリ	ランタイム開発、JITコンパイル

7.2 どちらを使うべきか

結論から言うと、99%の開発者はRuntime APIで十分。

// Runtime API（簡潔）
cudaMalloc(&d_ptr, size);
cudaMemcpy(d_ptr, h_ptr, size, cudaMemcpyHostToDevice);
myKernel<<<grid, block>>>(d_ptr);

// Driver API（冗長だが細かい制御可能）
cuMemAlloc(&d_ptr, size);
cuMemcpyHtoD(d_ptr, h_ptr, size);
cuLaunchKernel(kernel, gridX, gridY, gridZ, blockX, blockY, blockZ, ...);

Driver APIが必要なケースは、以下のような特殊な状況に限られる。

カスタムランタイムの開発
動的なカーネルロード/アンロード
複数のCUDAコンテキストの細かい制御

7.3 PyTorchユーザーは気にしなくていい

PyTorchやTensorFlowを使う場合、これらのAPIは完全に隠蔽されている。フレームワークが適切なAPIを選択してくれるので、意識する必要はない。

APIの違いが理解できたところで、次は開発ツールによるデバッグとプロファイリングを見ていこう。

8. 開発ツール: Nsightファミリー

8.1 Nsight Systemsとは

システム全体のパフォーマンスを可視化するプロファイラ。CPU/GPU間のデータ転送、カーネル実行のタイムライン、メモリ使用量などを一目で把握できる。

# プロファイル実行
nsys profile --stats=true python train.py

# 出力例
Time (%)  Total Time (ns)  Instances  Avg (ns)   Operation
--------  ---------------  ---------  ---------  --------------------------
   45.2       1,234,567          100    12,345  CUDA Kernel: forward_pass
   30.1         823,456           50    16,469  CUDA memcpy HtoD
   24.7         675,432           50    13,508  CUDA memcpy DtoH

8.2 Nsight Computeとは

個々のCUDAカーネルを詳細に分析するプロファイラ。占有率、メモリスループット、演算スループットなど、カーネルレベルの最適化に必要な情報を提供。

# 特定のカーネルをプロファイル
ncu --set full python inference.py

# roofline analysisを実行
ncu --set roofline python inference.py

8.3 使い分けの指針

パフォーマンス問題の調査フロー:

1. まずNsight Systemsで全体像を把握
   ↓ ボトルネックのカーネルを特定
2. Nsight Computeで詳細分析
   ↓ 最適化ポイントを発見
3. 改善 → 再度Nsight Systemsで効果確認

8.4 cuda-gdb: GPUデバッガ

GDBの拡張版。ブレークポイント設定、変数検査、スレッド状態確認など、CPUデバッグと同じ感覚でGPUコードをデバッグできる。

cuda-gdb ./my_cuda_app
(cuda-gdb) break myKernel
(cuda-gdb) run
(cuda-gdb) cuda thread  # 現在のGPUスレッド情報
(cuda-gdb) info cuda kernels  # 実行中のカーネル一覧

開発ツールの概要を押さえたところで、実際にCUDA Toolkitをインストールして動かしてみよう。

9. 実際に使ってみよう

9.1 環境構築

インストール方法の選択

方法	メリット	デメリット
公式インストーラ	完全なToolkit	システム汚染のリスク
conda	環境分離可能	バージョンが古い場合あり
Docker	完全な分離	オーバーヘッド

9.2 設定ファイルの準備

以下の3種類の環境設定を用意した。用途に応じて選択してほしい。

開発環境用（cuda_env_dev.sh）

#!/bin/bash
# cuda_env_dev.sh - 開発環境用（このままコピーして使える）

# CUDA Toolkit のパス設定
export CUDA_HOME=/usr/local/cuda
export PATH=$CUDA_HOME/bin:$PATH
export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH

# デバッグ用設定
export CUDA_LAUNCH_BLOCKING=1  # 同期実行（デバッグしやすい）
export CUDA_VISIBLE_DEVICES=0  # 使用するGPUを限定

# コンパイラ設定
export NVCC_GENCODE="-gencode arch=compute_89,code=sm_89"

echo "CUDA開発環境を設定しました"
echo "CUDA Version: $(nvcc --version | grep release)"

本番環境用（cuda_env_prod.sh）

#!/bin/bash
# cuda_env_prod.sh - 本番環境用（このままコピーして使える）

# CUDA Toolkit のパス設定
export CUDA_HOME=/usr/local/cuda
export PATH=$CUDA_HOME/bin:$PATH
export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH

# パフォーマンス最適化設定
export CUDA_LAUNCH_BLOCKING=0  # 非同期実行（高速）
export CUDA_AUTO_BOOST=1       # クロック自動ブースト有効

# cuDNN最適化
export CUDNN_BENCHMARK=1       # ベンチマークモード有効

# マルチGPU設定（必要に応じて変更）
# export CUDA_VISIBLE_DEVICES=0,1,2,3

echo "CUDA本番環境を設定しました"

CI/テスト環境用（cuda_env_test.sh）

#!/bin/bash
# cuda_env_test.sh - CI/テスト環境用（このままコピーして使える）

# CUDA Toolkit のパス設定
export CUDA_HOME=/usr/local/cuda
export PATH=$CUDA_HOME/bin:$PATH
export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH

# 再現性重視の設定
export CUDA_LAUNCH_BLOCKING=1
export CUBLAS_WORKSPACE_CONFIG=:4096:8  # 決定論的動作
export CUDNN_DETERMINISTIC=1            # cuDNN決定論的モード

# テスト用に最小リソース
export CUDA_VISIBLE_DEVICES=0

echo "CUDAテスト環境を設定しました（決定論的モード）"

9.3 動作確認コード

"""
cuda_check.py - CUDA Toolkit動作確認スクリプト
使い方: python cuda_check.py
"""
import subprocess
import sys

def check_nvcc():
    """nvccのバージョン確認"""
    try:
        result = subprocess.run(
            ['nvcc', '--version'],
            capture_output=True,
            text=True
        )
        print("=== nvcc (CUDAコンパイラ) ===")
        print(result.stdout)
        return True
    except FileNotFoundError:
        print("ERROR: nvccが見つかりません")
        print("CUDA Toolkitがインストールされているか確認してください")
        return False

def check_pytorch_cuda():
    """PyTorchからのCUDA確認"""
    try:
        import torch
        print("=== PyTorch CUDA情報 ===")
        print(f"PyTorch Version: {torch.__version__}")
        print(f"CUDA Available: {torch.cuda.is_available()}")
        
        if torch.cuda.is_available():
            print(f"CUDA Version: {torch.version.cuda}")
            print(f"cuDNN Version: {torch.backends.cudnn.version()}")
            print(f"GPU Count: {torch.cuda.device_count()}")
            
            for i in range(torch.cuda.device_count()):
                props = torch.cuda.get_device_properties(i)
                print(f"\nGPU {i}: {props.name}")
                print(f"  Compute Capability: {props.major}.{props.minor}")
                print(f"  Total Memory: {props.total_memory / 1024**3:.1f} GB")
                print(f"  SM Count: {props.multi_processor_count}")
        return True
    except ImportError:
        print("PyTorchがインストールされていません")
        return False

def check_cuda_libraries():
    """CUDAライブラリの確認"""
    try:
        import torch
        if not torch.cuda.is_available():
            return False
            
        print("\n=== CUDAライブラリ動作確認 ===")
        
        # cuBLAS確認（行列積）
        a = torch.randn(100, 100, device='cuda')
        b = torch.randn(100, 100, device='cuda')
        c = torch.mm(a, b)
        print("cuBLAS (GEMM): OK")
        
        # cuFFT確認
        signal = torch.randn(1024, device='cuda')
        spectrum = torch.fft.fft(signal)
        print("cuFFT (FFT): OK")
        
        # cuDNN確認（畳み込み）
        conv = torch.nn.Conv2d(3, 64, 3, device='cuda')
        x = torch.randn(1, 3, 224, 224, device='cuda')
        y = conv(x)
        print("cuDNN (Conv2d): OK")
        
        # cuRAND確認
        rand = torch.rand(1000, device='cuda')
        print("cuRAND (Random): OK")
        
        return True
    except Exception as e:
        print(f"ERROR: {e}")
        return False

def main():
    print("=" * 50)
    print("CUDA Toolkit 動作確認")
    print("=" * 50)
    
    results = []
    results.append(("nvcc", check_nvcc()))
    results.append(("PyTorch CUDA", check_pytorch_cuda()))
    results.append(("CUDA Libraries", check_cuda_libraries()))
    
    print("\n" + "=" * 50)
    print("確認結果サマリー")
    print("=" * 50)
    for name, status in results:
        mark = "OK" if status else "NG"
        print(f"  {name}: {mark}")
    
    all_ok = all(status for _, status in results)
    sys.exit(0 if all_ok else 1)

if __name__ == "__main__":
    main()

9.4 実行結果

上記のコードを実行すると、以下のような出力が得られる。

==================================================
CUDA Toolkit 動作確認
==================================================
=== nvcc (CUDAコンパイラ) ===
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2024 NVIDIA Corporation
Built on ...
Cuda compilation tools, release 12.4, V12.4.131

=== PyTorch CUDA情報 ===
PyTorch Version: 2.2.0
CUDA Available: True
CUDA Version: 12.1
cuDNN Version: 8902
GPU Count: 1

GPU 0: NVIDIA GeForce RTX 4090
  Compute Capability: 8.9
  Total Memory: 24.0 GB
  SM Count: 128

=== CUDAライブラリ動作確認 ===
cuBLAS (GEMM): OK
cuFFT (FFT): OK
cuDNN (Conv2d): OK
cuRAND (Random): OK

==================================================
確認結果サマリー
==================================================
  nvcc: OK
  PyTorch CUDA: OK
  CUDA Libraries: OK

9.5 よくあるエラーと対処法

エラー	原因	対処法
`nvcc: command not found`	PATHが通っていない	`export PATH=/usr/local/cuda/bin:$PATH`
`libcudart.so: cannot open`	LD_LIBRARY_PATHの問題	`export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH`
`CUDA driver version is insufficient`	ドライバが古い	NVIDIAドライバを更新
`no kernel image is available`	アーキテクチャ不一致	正しい`-arch`オプションでリビルド
`CUDA out of memory`	VRAM不足	バッチサイズ削減、`torch.cuda.empty_cache()`

基本的な使い方をマスターしたので、次はユースケース別のガイドを見ていこう。

10. ユースケース別ガイド

10.1 ユースケース1: PyTorchでの深層学習

想定読者: 深層学習エンジニア、データサイエンティスト

推奨構成: conda環境 + PyTorch公式バイナリ

サンプルコード:

"""
pytorch_cuda_example.py - PyTorchでのCUDA活用例
"""
import torch
import torch.nn as nn
import time

def benchmark_cuda():
    """CPU vs GPU の性能比較"""
    # モデル定義
    model = nn.Sequential(
        nn.Linear(1024, 2048),
        nn.ReLU(),
        nn.Linear(2048, 2048),
        nn.ReLU(),
        nn.Linear(2048, 1024)
    )
    
    x = torch.randn(256, 1024)
    
    # CPU実行
    model_cpu = model.to('cpu')
    x_cpu = x.to('cpu')
    
    start = time.time()
    for _ in range(100):
        _ = model_cpu(x_cpu)
    cpu_time = time.time() - start
    
    # GPU実行
    if torch.cuda.is_available():
        model_gpu = model.to('cuda')
        x_gpu = x.to('cuda')
        
        # ウォームアップ
        _ = model_gpu(x_gpu)
        torch.cuda.synchronize()
        
        start = time.time()
        for _ in range(100):
            _ = model_gpu(x_gpu)
        torch.cuda.synchronize()
        gpu_time = time.time() - start
        
        print(f"CPU Time: {cpu_time:.3f}s")
        print(f"GPU Time: {gpu_time:.3f}s")
        print(f"Speedup: {cpu_time/gpu_time:.1f}x")
    else:
        print("CUDA is not available")

if __name__ == "__main__":
    benchmark_cuda()

10.2 ユースケース2: カスタムCUDAカーネルのビルド

想定読者: パフォーマンス最適化エンジニア、ライブラリ開発者

推奨構成: 公式CUDA Toolkitフルインストール

サンプルコード:

"""
custom_kernel_build.py - PyTorchでカスタムCUDA拡張をビルド
"""
import torch
from torch.utils.cpp_extension import load_inline

# CUDAカーネルのソースコード
cuda_source = """
__global__ void vector_add_kernel(
    const float* a, const float* b, float* c, int n
) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n) {
        c[idx] = a[idx] + b[idx];
    }
}

torch::Tensor vector_add_cuda(torch::Tensor a, torch::Tensor b) {
    auto c = torch::empty_like(a);
    int n = a.numel();
    
    int threads = 256;
    int blocks = (n + threads - 1) / threads;
    
    vector_add_kernel<<<blocks, threads>>>(
        a.data_ptr<float>(),
        b.data_ptr<float>(),
        c.data_ptr<float>(),
        n
    );
    
    return c;
}
"""

cpp_source = """
torch::Tensor vector_add_cuda(torch::Tensor a, torch::Tensor b);
"""

def build_and_test():
    """カスタムカーネルをビルドしてテスト"""
    # JITコンパイル
    custom_ops = load_inline(
        name='custom_vector_add',
        cpp_sources=cpp_source,
        cuda_sources=cuda_source,
        functions=['vector_add_cuda'],
        verbose=True
    )
    
    # テスト
    a = torch.randn(10000, device='cuda')
    b = torch.randn(10000, device='cuda')
    
    # カスタムカーネルで実行
    c_custom = custom_ops.vector_add_cuda(a, b)
    
    # PyTorch標準で実行（検証用）
    c_pytorch = a + b
    
    # 結果確認
    assert torch.allclose(c_custom, c_pytorch)
    print("Custom CUDA kernel works correctly!")

if __name__ == "__main__":
    build_and_test()

10.3 ユースケース3: プロファイリングによる最適化

想定読者: パフォーマンスチューニングを行うエンジニア

推奨構成: Nsight Systems + Nsight Compute

サンプルコード:

"""
profiling_example.py - Nsightでプロファイリングする例
実行: nsys profile python profiling_example.py
"""
import torch
import torch.nn as nn
import torch.cuda.nvtx as nvtx  # NVIDIAプロファイラ用マーカー

class ProfiledModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 64, 3, padding=1)
        self.conv2 = nn.Conv2d(64, 128, 3, padding=1)
        self.fc = nn.Linear(128 * 56 * 56, 1000)
        
    def forward(self, x):
        # NVTXマーカーで各レイヤーを識別
        with nvtx.range("conv1"):
            x = torch.relu(self.conv1(x))
            x = torch.max_pool2d(x, 2)
        
        with nvtx.range("conv2"):
            x = torch.relu(self.conv2(x))
            x = torch.max_pool2d(x, 2)
        
        with nvtx.range("fc"):
            x = x.view(x.size(0), -1)
            x = self.fc(x)
        
        return x

def main():
    model = ProfiledModel().cuda()
    x = torch.randn(32, 3, 224, 224, device='cuda')
    
    # ウォームアップ
    for _ in range(10):
        _ = model(x)
    torch.cuda.synchronize()
    
    # プロファイリング対象の実行
    with nvtx.range("inference_batch"):
        for i in range(100):
            with nvtx.range(f"iteration_{i}"):
                output = model(x)
    
    torch.cuda.synchronize()
    print("Profiling complete. Check the .nsys-rep file.")

if __name__ == "__main__":
    main()

ユースケースが把握できたところで、この記事を読んだ後の学習パスを確認しよう。

11. 学習ロードマップ

この記事を読んだ後、次のステップとして以下をおすすめする。

初級者向け（まずはここから）

CUDA公式チュートリアルを試す
- CUDA Quick Start Guide
サンプルプロジェクトを動かす
- CUDA Samples (GitHub)

中級者向け（実践に進む）

Nsightツールでプロファイリングを習得
- Nsight Systems User Guide
cuBLAS/cuDNNの直接利用を学ぶ
- cuBLAS Documentation

上級者向け（さらに深く）

CUDAプログラミングガイドを精読
- CUDA C++ Programming Guide
カスタムカーネル最適化に挑戦
- CUDA C++ Best Practices Guide

12. まとめ

この記事では、CUDA Toolkitについて以下を解説した。

全体像: コンパイラ、ライブラリ、ランタイム、開発ツールの4カテゴリ
nvcc: CUDAコードをPTX/cubinにコンパイルする仕組み
ライブラリ群: cuBLAS、cuFFT、cuDNNなどの役割と使い分け
API: Runtime APIとDriver APIの違い
開発ツール: Nsight Systems/Computeによるプロファイリング

私の所感

正直なところ、CUDA Toolkitを「完全に理解した」と言えるエンジニアは少ないと思う。コンポーネントが多すぎて、全部を使いこなすのは不可能に近い。

でも、それでいい。

大事なのは「どこに何があるか」を把握しておくこと。PyTorchが遅いと感じたらNsightで調べる。カスタムカーネルが必要になったらnvccの使い方を調べる。そういう「地図」があれば、必要なときに深掘りできる。

この記事が、あなたのGPU開発の「地図」になれば幸いだ。

参考文献