CUDA Hands-on完全ガイド：GPUコンピューティングのすべて

GPU (GPC - Graphics Processing Cluster)
├── SM (Streaming Multiprocessor) × N個
│   ├── CUDA Core (FP32/INT32) × 128個 (Hopper基準)
│   ├── Tensor Core × 4個 (第4世代、Hopper基準)
│   ├── RT Core (Ray Tracing) × 1個
│   ├── Warp Scheduler × 4個
│   ├── Register File (256 KB)
│   ├── L1 Cache / Shared Memory (共有、最大228 KB)
│   └── SFU (Special Function Unit)
├── L2 Cache (共有)
├── Memory Controller
└── HBM (High Bandwidth Memory)

速度:  Register > Shared/L1 > L2 > Global (HBM)
サイズ:  Global (HBM) > L2 > Shared/L1 > Register

Grid (カーネル実行単位)
├── Block (0,0)          Block (1,0)          Block (2,0)
│   ├── Warp 0           ├── Warp 0           ├── Warp 0
│   │   ├── Thread 0     │   ├── Thread 0     │   ├── Thread 0
│   │   ├── Thread 1     │   ├── Thread 1     │   ├── Thread 1
│   │   ├── ...          │   ├── ...          │   ├── ...
│   │   └── Thread 31    │   └── Thread 31    │   └── Thread 31
│   ├── Warp 1           ├── Warp 1           ├── Warp 1
│   └── ...              └── ...              └── ...
├── Block (0,1)          Block (1,1)          ...
└── ...

# 1. NVIDIAドライバ確認
nvidia-smi

# 2. CUDA Keyring追加（Ubuntu 22.04の例）
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt-get update

# 3. CUDA Toolkitインストール
sudo apt-get install cuda-toolkit-13-1

# 4. 環境変数設定
export PATH=/usr/local/cuda-13.1/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda-13.1/lib64:$LD_LIBRARY_PATH

# 5. インストール確認
nvcc --version

# 1. NVIDIA公式サイトからCUDA Toolkitをダウンロード
# https://developer.nvidia.com/cuda-downloads

# 2. インストール後に環境変数を確認
echo %CUDA_PATH%
# 通常 C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.1

# 3. 確認
nvcc --version
nvidia-smi

# 基本情報出力
nvidia-smi

# 出力例:
# +-----------------------------------------------------------------------------------------+
# | NVIDIA-SMI 560.35.03    Driver Version: 560.35.03    CUDA Version: 13.1                 |
# |-----------------------------------------+------------------------+----------------------|
# | GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
# | Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
# |=========================================+========================+======================|
# |   0  NVIDIA H100 80GB HBM3          On | 00000000:3B:00.0   Off |                    0 |
# | N/A   32C    P0              72W / 700W |    1234MiB / 81559MiB  |      0%      Default |
# +-----------------------------------------+------------------------+----------------------+

# 持続モニタリング（1秒間隔）
nvidia-smi -l 1

# dmon - GPUメトリクスモニタリング
nvidia-smi dmon -s pucvmet -d 1

# 特定GPUの情報
nvidia-smi -i 0 -q

# GPUプロセス確認
nvidia-smi pmon -i 0

# GPUクロック、メモリ情報
nvidia-smi -q -d CLOCK,MEMORY

# CSV形式で出力（スクリプト用）
nvidia-smi --query-gpu=name,temperature.gpu,utilization.gpu,memory.used,memory.total \
  --format=csv,noheader,nounits

# 基本コンパイル
nvcc -o hello hello.cu

# 特定アーキテクチャターゲット
nvcc -arch=sm_90 -o kernel kernel.cu   # Hopper H100
nvcc -arch=sm_80 -o kernel kernel.cu   # Ampere A100

# デバッグモード
nvcc -g -G -o debug_kernel kernel.cu

# 最適化レベル
nvcc -O3 -o optimized kernel.cu

# PTXコード生成（中間表現）
nvcc -ptx kernel.cu

# 複数アーキテクチャ同時サポート（Fat Binary）
nvcc -gencode arch=compute_80,code=sm_80 \
     -gencode arch=compute_90,code=sm_90 \
     -o multi_arch kernel.cu

# ライブラリリンク
nvcc -lcublas -lcurand -o linked_kernel kernel.cu

# 詳細コンパイル情報
nvcc --resource-usage -o kernel kernel.cu

# 1. ドライバサポートCUDAバージョン（Driver API）
nvidia-smi
# 右上に「CUDA Version: 13.1」と表示
# ドライバがサポートする最大CUDAランタイムバージョン

# 2. CUDA Toolkitバージョン（Runtime API）
nvcc --version
# 「release 13.1」と表示
# 実際にインストールされたCUDA Toolkitバージョン

# 3. ランタイムで確認
python3 -c "import torch; print(torch.version.cuda)"

# 1. NVIDIA Container Toolkitインストール（Ubuntu）
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
  sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit

# 2. Dockerランタイム設定
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# 3. GPUコンテナ実行
docker run --rm --gpus all nvidia/cuda:13.1.0-base-ubuntu22.04 nvidia-smi

# 特定GPUのみ使用
docker run --rm --gpus '"device=0,1"' nvidia/cuda:13.1.0-base-ubuntu22.04 nvidia-smi

# docker composeでGPU使用
# docker-compose.yml:

# docker-compose.yml
services:
  gpu-app:
    image: nvidia/cuda:13.1.0-devel-ubuntu22.04
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    command: nvidia-smi

# PyTorch（CUDA 12.4ビルドの例）
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

# condaを使用する場合
conda install pytorch torchvision torchaudio pytorch-cuda=12.4 -c pytorch -c nvidia

# TensorFlow（GPU自動検出）
pip install tensorflow[and-cuda]

# CUDA使用可否確認（Python）
python3 -c "
import torch
print(f'PyTorch version: {torch.__version__}')
print(f'CUDA available: {torch.cuda.is_available()}')
print(f'CUDA version: {torch.version.cuda}')
print(f'GPU count: {torch.cuda.device_count()}')
if torch.cuda.is_available():
    print(f'GPU name: {torch.cuda.get_device_name(0)}')
"

┌─────────────────────────────────────────────────────────┐
│  Host (CPU)                                             │
│  ┌─────────────────────────────────────────────────────┐│
│  │ 1. データ準備 (Host Memory)                        ││
│  │ 2. GPUメモリ確保 (cudaMalloc)                      ││
│  │ 3. データ転送: Host -> Device (cudaMemcpy)         ││
│  │ 4. カーネル実行 (<<<grid, block>>>)                ││
│  │ 5. 結果転送: Device -> Host (cudaMemcpy)           ││
│  │ 6. GPUメモリ解放 (cudaFree)                        ││
│  └─────────────────────────────────────────────────────┘│
│                        ↕ PCIe / NVLink                  │
│  ┌─────────────────────────────────────────────────────┐│
│  │  Device (GPU)                                       ││
│  │  - カーネル関数の並列実行                           ││
│  │  - 数千スレッドが同時処理                           ││
│  └─────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────┘

// __global__: カーネル関数 - Hostから呼び出し、Deviceで実行
__global__ void myKernel(float* data, int n) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n) {
        data[idx] *= 2.0f;
    }
}

// __device__: Device専用ヘルパー関数
__device__ float square(float x) {
    return x * x;
}

// __host__ __device__: CPU/GPU兼用関数
__host__ __device__ float add(float a, float b) {
    return a + b;
}

// カーネル呼び出し構文
// kernel<<<gridDim, blockDim, sharedMemSize, stream>>>(args...);
//
// gridDim:       Grid内のBlock数 (dim3)
// blockDim:      Block内のThread数 (dim3)
// sharedMemSize: 動的Shared Memoryサイズ（バイト、任意）
// stream:        実行ストリーム（任意）

// 1D例: 256スレッド、1ブロック
myKernel<<<1, 256>>>(d_data, n);

// 1D例: N個のデータを256スレッドブロックで処理
int threadsPerBlock = 256;
int blocksPerGrid = (n + threadsPerBlock - 1) / threadsPerBlock;
myKernel<<<blocksPerGrid, threadsPerBlock>>>(d_data, n);

// 2D例: 画像処理
dim3 blockDim(16, 16);       // 16x16 = 256スレッド/ブロック
dim3 gridDim(
    (width + 15) / 16,
    (height + 15) / 16
);
imageKernel<<<gridDim, blockDim>>>(d_image, width, height);

// 組み込み変数（Built-in Variables）
threadIdx.x, threadIdx.y, threadIdx.z  // Block内のThreadインデックス
blockIdx.x,  blockIdx.y,  blockIdx.z   // Grid内のBlockインデックス
blockDim.x,  blockDim.y,  blockDim.z   // Blockの次元サイズ
gridDim.x,   gridDim.y,   gridDim.z    // Gridの次元サイズ

// グローバルThread ID計算（1D）
int globalIdx = blockIdx.x * blockDim.x + threadIdx.x;

// グローバルThread ID計算（2D）
int col = blockIdx.x * blockDim.x + threadIdx.x;
int row = blockIdx.y * blockDim.y + threadIdx.y;
int globalIdx = row * width + col;

// 全スレッド数（Grid-strideループ用）
int totalThreads = gridDim.x * blockDim.x;

// GPUメモリ確保
float* d_data;
cudaMalloc((void**)&d_data, n * sizeof(float));

// Host -> Deviceコピー
cudaMemcpy(d_data, h_data, n * sizeof(float), cudaMemcpyHostToDevice);

// Device -> Hostコピー
cudaMemcpy(h_data, d_data, n * sizeof(float), cudaMemcpyDeviceToHost);

// GPUメモリ解放
cudaFree(d_data);

// GPUメモリ初期化
cudaMemset(d_data, 0, n * sizeof(float));

// エラーチェックマクロ（必須！）
#define CUDA_CHECK(call) \
    do { \
        cudaError_t err = call; \
        if (err != cudaSuccess) { \
            fprintf(stderr, "CUDA Error at %s:%d - %s\n", \
                    __FILE__, __LINE__, cudaGetErrorString(err)); \
            exit(EXIT_FAILURE); \
        } \
    } while(0)

// 使用例
CUDA_CHECK(cudaMalloc((void**)&d_data, n * sizeof(float)));
CUDA_CHECK(cudaMemcpy(d_data, h_data, n * sizeof(float), cudaMemcpyHostToDevice));

// hello_cuda.cu
#include <stdio.h>

__global__ void helloKernel() {
    int tid = blockIdx.x * blockDim.x + threadIdx.x;
    printf("Hello from GPU thread %d (block %d, thread %d)\n",
           tid, blockIdx.x, threadIdx.x);
}

int main() {
    // 2ブロック、各4スレッド = 合計8スレッド
    helloKernel<<<2, 4>>>();

    // GPU作業完了を待機
    cudaDeviceSynchronize();

    printf("Hello from CPU!\n");
    return 0;
}

# コンパイルと実行
nvcc -o hello hello_cuda.cu
./hello