コンピュータアーキテクチャ完全ガイド: ISAからGPU並列アーキテクチャまで

アプリケーションソフトウェア
       ↓
オペレーティングシステム
       ↓
ISA (命令セットアーキテクチャ)  ← ハードウェア/ソフトウェア境界
       ↓
マイクロアーキテクチャ
       ↓
論理ゲート
       ↓
トランジスタ

CPU時間 = 命令数 × CPI × クロック周期
        = 命令数 × CPI / クロック周波数

スピードアップ = 1 / ((1 - f) + f/s)

R形式 (レジスタ演算):
[funct7 | rs2 | rs1 | funct3 | rd | opcode]
  7ビット 5ビット 5ビット 3ビット 5ビット 7ビット

I形式 (即値/ロード):
[imm[11:0] | rs1 | funct3 | rd | opcode]
  12ビット   5ビット 3ビット 5ビット 7ビット

S形式 (ストア):
[imm[11:5] | rs2 | rs1 | funct3 | imm[4:0] | opcode]

B形式 (分岐):
[imm[12|10:5] | rs2 | rs1 | funct3 | imm[4:1|11] | opcode]

U形式 (上位即値):
[imm[31:12] | rd | opcode]

J形式 (JAL):
[imm[20|10:1|11|19:12] | rd | opcode]

# RISC-V アセンブリ例
# 基本的な算術演算
add  a0, a0, a1      # a0 = a0 + a1
sub  t0, t1, t2      # t0 = t1 - t2
addi t0, t0, 10      # t0 = t0 + 10 (即値)
mul  a0, a1, a2      # a0 = a1 * a2

# メモリアクセス (ロード/ストア)
lw   t0, 0(a0)       # t0 = Memory[a0 + 0]   (ワードロード)
lh   t1, 2(a0)       # t1 = Memory[a0 + 2]   (ハーフワードロード)
lb   t2, 1(a0)       # t2 = Memory[a0 + 1]   (バイトロード)
sw   t0, 4(a0)       # Memory[a0 + 4] = t0   (ワードストア)

# 論理演算
and  t0, t1, t2      # t0 = t1 & t2
or   t0, t1, t2      # t0 = t1 | t2
xor  t0, t1, t2      # t0 = t1 ^ t2
sll  t0, t1, t2      # t0 = t1 << t2 (論理左シフト)
srl  t0, t1, t2      # t0 = t1 >> t2 (論理右シフト)

# 分岐とジャンプ
beq  t0, t1, label   # t0 == t1 なら label へ
bne  t0, t1, label   # t0 != t1 なら label へ
blt  t0, t1, label   # t0 < t1  なら label へ
bge  t0, t1, label   # t0 >= t1 なら label へ
jal  ra, func        # ra = PC+4; func へジャンプ
jalr ra, 0(t0)       # ra = PC+4; t0+0 へジャンプ

# RISC-V レジスタ規約
# x0  (zero): 常に0
# x1  (ra):   リターンアドレス
# x2  (sp):   スタックポインタ
# x10-x17 (a0-a7): 関数引数/戻り値
# x5-x7, x28-x31 (t0-t6): 一時レジスタ
# x8-x9, x18-x27 (s0-s11): 保存レジスタ

// Cコード
int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

# RISC-V アセンブリ (再帰的階乗)
factorial:
    addi sp, sp, -16     # スタックフレーム確保
    sw   ra, 12(sp)      # リターンアドレス保存
    sw   a0, 8(sp)       # n 保存

    addi t0, zero, 1
    bgt  a0, t0, recurse # n > 1 なら再帰
    addi a0, zero, 1     # return 1
    j    done

recurse:
    addi a0, a0, -1      # n - 1
    jal  ra, factorial   # 再帰呼び出し
    lw   t0, 8(sp)       # n 復元
    mul  a0, t0, a0      # n * factorial(n-1)

done:
    lw   ra, 12(sp)      # リターンアドレス復元
    addi sp, sp, 16      # スタックフレーム解放
    jalr zero, 0(ra)     # リターン

ADD:  結果 = A + B
SUB:  結果 = A + (~B + 1) = A - B  (2の補数)
AND:  結果 = A AND B
OR:   結果 = A OR B
XOR:  結果 = A XOR B
SLT:  結果 = (A < B) ? 1 : 0  (Set Less Than)
SLL:  結果 = A << B

FA0: S0 = A0 XOR B0 XOR Cin;  C1 = キャリーアウト
FA1: S1 = A1 XOR B1 XOR C1;  C2 = キャリーアウト
...

Gi = Ai AND Bi       (キャリー生成)
Pi = Ai XOR Bi       (キャリー伝播)
Ci+1 = Gi OR (Pi AND Ci)

命令の流れ (R形式 ADD):
1. IF:  PC → 命令メモリ → 命令フェッチ
2. ID:  レジスタファイルからrs1, rs2を読み出し、制御信号生成
3. EX:  ALUでrs1 + rs2を計算
4. MEM: (R形式はメモリアクセスなし)
5. WB:  ALU結果をrdに書き込み

ステージ  略称  役割
--------+------+--------------------------------------------
フェッチ  IF   PCからメモリの命令を取得
デコード  ID   命令デコード、レジスタ読み出し、制御信号生成
実行      EX   ALU演算実行
メモリ   MEM   データメモリの読み書き
書き込み  WB   レジスタファイルへ結果を書き込み

サイクル: 1    2    3    4    5    6    7    8
命令 1:  IF   ID   EX  MEM   WB
命令 2:       IF   ID   EX  MEM   WB
命令 3:            IF   ID   EX  MEM   WB
命令 4:                 IF   ID   EX  MEM   WB

add t0, t1, t2    # t0 書き込み (WB: 5サイクル目)
sub t3, t0, t4    # t0 読み出し (ID: 3サイクル目) → RAW ハザード!

# ロード・ユースハザード (1サイクルストール不可避)
lw  t0, 0(a0)      # メモリからロード
add t1, t0, t2     # t0 をすぐ使用 → MEM→EXフォワーディング不可
# 解決策: コンパイラが独立命令を挿入
lw  t0, 0(a0)
add t3, t4, t5     # 独立した命令を挿入
add t1, t0, t2     # t0 が準備完了

beq t0, t1, label  # 分岐判定はEXステージで完了
# その間にIF/IDでフェッチされた命令は正しいか?

Intel Core: 6-way アウトオブオーダー実行 (OoO)
AMD Zen 4:  4-way デコード + OoO実行
ARM Cortex-X4: 5-way デコード

レジスタ
  容量: ~1KB  |  レイテンシ: 1サイクル    |  コスト: 非常に高

L1キャッシュ (オンチップ)
  容量: 32-64KB  |  レイテンシ: 4-5サイクル  |  コスト: 高

L2キャッシュ (オンチップ)
  容量: 256KB-1MB  |  レイテンシ: 12-15サイクル  |  コスト: 中

L3キャッシュ (オンチップ, 共有)
  容量: 8-64MB  |  レイテンシ: 30-40サイクル  |  コスト: 低

DRAM (主記憶)
  容量: 8-256GB  |  レイテンシ: 200-300サイクル  |  コスト: 非常に低

SSD / NVMe
  容量: 1-4TB  |  レイテンシ: 10,000+サイクル  |  コスト: 極めて低

// 空間的局所性の最適化例
// 悪い例: 列優先アクセス (キャッシュミスが多発)
for (int j = 0; j < N; j++)
    for (int i = 0; i < N; i++)
        sum += A[i][j];  // A[0][0], A[1][0], A[2][0]... (行を飛び越す)

// 良い例: 行優先アクセス (キャッシュフレンドリー)
for (int i = 0; i < N; i++)
    for (int j = 0; j < N; j++)
        sum += A[i][j];  // A[0][0], A[0][1], A[0][2]... (連続メモリ)

[タグ (20ビット) | インデックス (6ビット) | オフセット (6ビット)]

仮想アドレス (VA): プロセスが使用するアドレス (0x0000 〜 0xFFFFFFFF)
物理アドレス (PA): 実際のDRAMのアドレス
ページ:           仮想/物理メモリの固定サイズブロック (通常 4KB)

仮想アドレス [VPN | ページオフセット]
                 ↓
            ページテーブル参照
                 ↓
物理アドレス [PFN | ページオフセット]

[PML4 (9ビット) | PDPT (9ビット) | PD (9ビット) | PT (9ビット) | オフセット (12ビット)]

TLBヒット:  仮想アドレス → TLB参照 → 物理アドレス (1-2サイクル)
TLBミス:    仮想アドレス → ページテーブルウォーク → 物理アドレス (100+サイクル)

PCIe 5.0:   x16 スロット = 128 GB/s 双方向
NVMe (PCIe): 最大 7 GB/s 順次読み取り (Gen4)
USB 4.0:    最大 40 Gbps
DDR5-6400:  最大 51.2 GB/s (チャネル当たり)

Modified (M):  このコアのみが変更済みの最新コピーを保有
Exclusive (E): このコアのみが保有し、メモリと一致
Shared (S):    複数コアが読み取り専用コピーを保有
Invalid (I):   無効 (別のコアが変更した)

#include <omp.h>
#include <stdio.h>
#include <stdlib.h>

// 並列配列合計
int main() {
    int n = 1000000;
    long long sum = 0;
    int *arr = malloc(n * sizeof(int));

    for (int i = 0; i < n; i++)
        arr[i] = i + 1;

    // reduction句でスレッドセーフな並列合計
    #pragma omp parallel for reduction(+:sum) schedule(static)
    for (int i = 0; i < n; i++) {
        sum += arr[i];
    }

    printf("Sum = %lld\n", sum);  // 期待値: 500000500000

    // スレッドID表示
    #pragma omp parallel
    {
        int tid = omp_get_thread_num();
        int nthreads = omp_get_num_threads();
        printf("Thread %d of %d\n", tid, nthreads);
    }

    free(arr);
    return 0;
}

// キャッシュフレンドリーな並列行列積
void matmul(float *A, float *B, float *C, int N) {
    #pragma omp parallel for collapse(2) schedule(dynamic, 64)
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            float sum = 0.0f;
            for (int k = 0; k < N; k++) {
                sum += A[i*N + k] * B[k*N + j];
            }
            C[i*N + j] = sum;
        }
    }
}

ソケット0 (コア0-15)  ←→ ローカルDRAM (64GB)  [~80ns]
      ↕ QPI / Infinity Fabric
ソケット1 (コア16-31) ←→ ローカルDRAM (64GB) [~80ns]

ソケット0からソケット1のメモリへのアクセス: ~160ns (2倍のレイテンシ)

ワープ (Warp): 32スレッドのグループ (NVIDIA)
→ 32スレッドが同一命令を同時実行
→ 各スレッドは異なるデータに対して処理

ワープスケジューラ: メモリアクセス等で遅延発生時に即座に別ワープへ切り替え
→ 数千のワープを高速に切り替えることでレイテンシを隠蔽

GPU
├── GPC (Graphics Processing Cluster) x 8
│   └── SM (Streaming Multiprocessor) x 7-12
│       ├── CUDAコア x 128 (FP32演算)
│       ├── テンソルコア x 4 (行列演算、AI)
│       ├── RTコア x 1 (レイトレーシング)
│       ├── ワープスケジューラ x 4
│       ├── レジスタファイル (256KB)
│       └── 共有メモリ / L1キャッシュ (128-256KB)
└── L2キャッシュ (共有、数十MB)

#include <cuda_runtime.h>
#include <stdio.h>

// GPUカーネル: ベクトル加算
__global__ void vectorAdd(float *a, float *b, float *c, int n) {
    // グローバルスレッドインデックスの計算
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n) {
        c[idx] = a[idx] + b[idx];
    }
}

int main() {
    int n = 1 << 20;  // 100万要素
    size_t size = n * sizeof(float);

    // ホスト (CPU) メモリ
    float *h_a = (float*)malloc(size);
    float *h_b = (float*)malloc(size);
    float *h_c = (float*)malloc(size);

    // デバイス (GPU) メモリ
    float *d_a, *d_b, *d_c;
    cudaMalloc(&d_a, size);
    cudaMalloc(&d_b, size);
    cudaMalloc(&d_c, size);

    // ホスト → デバイスへ転送
    cudaMemcpy(d_a, h_a, size, cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, h_b, size, cudaMemcpyHostToDevice);

    // カーネル実行: 1ブロックあたり256スレッド
    int threadsPerBlock = 256;
    int blocksPerGrid = (n + threadsPerBlock - 1) / threadsPerBlock;
    vectorAdd<<<blocksPerGrid, threadsPerBlock>>>(d_a, d_b, d_c, n);

    // デバイス → ホストへ転送
    cudaMemcpy(h_c, d_c, size, cudaMemcpyDeviceToHost);

    cudaFree(d_a); cudaFree(d_b); cudaFree(d_c);
    free(h_a); free(h_b); free(h_c);
    return 0;
}

// タイリングを使った行列積の最適化
#define TILE_SIZE 16

__global__ void matmulShared(float *A, float *B, float *C, int N) {
    __shared__ float tileA[TILE_SIZE][TILE_SIZE];
    __shared__ float tileB[TILE_SIZE][TILE_SIZE];

    int row = blockIdx.y * TILE_SIZE + threadIdx.y;
    int col = blockIdx.x * TILE_SIZE + threadIdx.x;
    float sum = 0.0f;

    for (int t = 0; t < N / TILE_SIZE; t++) {
        // タイルを共有メモリへロード
        tileA[threadIdx.y][threadIdx.x] = A[row * N + t * TILE_SIZE + threadIdx.x];
        tileB[threadIdx.y][threadIdx.x] = B[(t * TILE_SIZE + threadIdx.y) * N + col];
        __syncthreads();  // 全スレッドのロード完了を待機

        for (int k = 0; k < TILE_SIZE; k++)
            sum += tileA[threadIdx.y][k] * tileB[k][threadIdx.x];
        __syncthreads();
    }

    if (row < N && col < N)
        C[row * N + col] = sum;
}

通常のCUDAコア: 1サイクルあたり1 FP32 MAC
第4世代テンソルコア: 16x16x16の行列積 = 1サイクルあたり4096 FP16 MAC

HBM3E (2024): 9.6 Gbps/ピン、8スタック = パッケージ当たり 1.2 TB/s
GDDR6X (RTX 4090): 21 Gbps/ピン、384ビット = 1 TB/s
DDR5-6400: チャネル当たり 51.2 GB/s (CPU)

#include <stdlib.h>

#define N 4096

float A[N][N], B[N][N], C[N][N];

// 非効率: 列優先アクセス (キャッシュミスが多発)
void matmul_naive() {
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            for (int k = 0; k < N; k++)
                C[i][j] += A[i][k] * B[k][j];  // B[k][j]が非連続アクセス
}

// 効率的: ブロックタイリング (キャッシュを再利用)
#define BLOCK 64
void matmul_tiled() {
    for (int ii = 0; ii < N; ii += BLOCK)
        for (int jj = 0; jj < N; jj += BLOCK)
            for (int kk = 0; kk < N; kk += BLOCK)
                for (int i = ii; i < ii+BLOCK && i < N; i++)
                    for (int j = jj; j < jj+BLOCK && j < N; j++)
                        for (int k = kk; k < kk+BLOCK && k < N; k++)
                            C[i][j] += A[i][k] * B[k][j];
}

#include <immintrin.h>  // AVX2

// AVX2で8つのfloatを同時に加算
void vector_add_avx2(float *a, float *b, float *c, int n) {
    int i;
    for (i = 0; i <= n - 8; i += 8) {
        __m256 va = _mm256_loadu_ps(&a[i]);   // 8個のfloatをロード
        __m256 vb = _mm256_loadu_ps(&b[i]);
        __m256 vc = _mm256_add_ps(va, vb);    // 8個を同時加算
        _mm256_storeu_ps(&c[i], vc);          // 8個のfloatをストア
    }
    // 残りの要素を処理
    for (; i < n; i++)
        c[i] = a[i] + b[i];
}