필사 모드: 计算机体系结构完全指南：从 ISA 到 GPU 并行架构

应用程序（Application）
       ↓
操作系统（Operating System）
       ↓
ISA（指令集架构，Instruction Set Architecture）  ← 硬件/软件边界
       ↓
微架构（Microarchitecture）
       ↓
逻辑门（Logic Gates）
       ↓
晶体管（Transistors）

CPU Time = Instruction Count × CPI × Clock Cycle Time
         = Instruction Count × CPI / Clock Rate

Speedup = 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

# 内存访问（Load/Store）
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   # if t0 == t1, jump to label
bne  t0, t1, label   # if t0 != t1, jump to label
blt  t0, t1, label   # if t0 < t1,  jump to label
bge  t0, t1, label   # if t0 >= t1, jump to label
jal  ra, func        # ra = PC+4; jump to func
jalr ra, 0(t0)       # ra = PC+4; jump to t0+0

# RISC-V 寄存器约定
# x0 (zero): 恒为 0
# x1 (ra):   返回地址（Return Address）
# x2 (sp):   栈指针（Stack Pointer）
# 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 = (A0 AND B0) OR ...
FA1: S1 = A1 XOR B1 XOR C1;  C2 = ...
...
FAn: Sn = An XOR Bn XOR Cn;  Cout = ...

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 路乱序执行（Out-of-Order Execution）
AMD Zen 4:  4 路译码 + OoO 执行
ARM Cortex-X4: 5 路译码

寄存器（Register）
  容量：~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 的地址
页（Page）：       虚拟/物理内存的固定大小块（通常为 4KB）

虚拟地址 [VPN | Page Offset]
              ↓
         查找页表
              ↓
物理地址 [PFN | Page Offset]

[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

    // 并行 for + 任务分配
    #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;
}

// 矩阵乘法并行化（缓存友好 + OpenMP）
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 个线程同时执行同一条指令
→ 每个线程作用于不同的数据

线程束调度器：发生延迟（如内存访问）时立即切换到另一个线程束
→ 通过在数千个线程束之间快速切换来隐藏延迟（Latency Hiding）

GPU
├── GPC（图形处理集群，Graphics Processing Cluster）x 8
│   └── SM（流多处理器，Streaming Multiprocessor）x 7-12
│       ├── CUDA Core x 128 （FP32 运算）
│       ├── Tensor Core x 4 （矩阵运算，AI）
│       ├── RT Core x 1 （光线追踪）
│       ├── Warp Scheduler 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;  // 1M 元素
    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);

    // 内核执行：每个块 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++) {
        // 将 tile 加载到共享内存
        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 Core：每周期 1 个 FP32 MAC
Tensor Core（第 4 代）：16x16x16 矩阵乘 = 每周期 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 <time.h>
#include <stdio.h>
#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] 的访问不连续
}

// 高效：分块（Tiling），实现缓存复用
#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];
}