GPU Shared Memory 存储与 Bank Conflict 详解

一、Shared Memory 存储机制

1.1 物理存储结构

Shared Memory 是一维线性地址空间,二维数组只是逻辑表示,物理上按**行优先(Row-Major)**连续存储。

c code block
__shared__ float tile[4][4];  // 4行4列
逻辑表示:              物理存储(行优先):
┌────┬────┬────┬────┐
│0,0 │0,1 │0,2 │0,3 │    地址 0  1  2  3  4  5  6  7  8  9  ...
├────┼────┼────┼────┤    值  [0,0][0,1][0,2][0,3][1,0][1,1][1,2][1,3][2,0]...
│1,0 │1,1 │1,2 │1,3 │
├────┼────┼────┼────┤    地址 = 行号 × 列数 + 列号
│2,0 │2,1 │2,2 │2,3 │
├────┼────┼────┼────┤
│3,0 │3,1 │3,2 │3,3 │
└────┴────┴────┴────┘

1.2 Bank 划分

Shared Memory 被分成 32 个 Bank,每个 Bank 有独立的访问端口:

Shared Memory
┌────────┬────────┬────────┬─────┬────────┐
│ Bank 0 │ Bank 1 │ Bank 2 │ ... │ Bank 31│
│ 地址 0 │ 地址 1 │ 地址 2 │     │ 地址 31│
│ 地址 32│ 地址 33│ 地址 34│     │ 地址 63│
│ 地址 64│ 地址 65│ 地址 66│     │ 地址 95│
│  ...   │  ...   │  ...   │     │  ...   │
└────────┴────────┴────────┴─────┴────────┘

1.3 地址到 Bank 的映射规则

字节地址 = 元素索引 × sizeof(类型)
Bank = 字节地址 / 4 % 32    (4字节类型时)
     = 元素索引 % 32

示例:

c code block
__shared__ float tile[4][4];

元素 [0][0] → 索引 0  → Bank 0
元素 [0][1] → 索引 1  → Bank 1
元素 [1][0] → 索引 4  → Bank 4
元素 [2][0] → 索引 8  → Bank 8

二、Bank Conflict

2.1 定义

Bank Conflict 是指 Warp 内多个线程同时访问 Shared Memory 的同一个 Bank 的不同地址,导致必须串行访问,降低性能。

2.2 三种访问情况

✅ 无冲突 — 每个线程访问不同 Bank

线程 0  → Bank 0
线程 1  → Bank 1
线程 2  → Bank 2
...
线程 31 → Bank 31

→ 32 个 Bank 同时服务,1 个周期完成

✅ 无冲突 — 多线程访问同一 Bank 的同一地址(广播)

线程 0  → Bank 0, 地址 0
线程 1  → Bank 0, 地址 0  ← 同一地址
线程 2  → Bank 0, 地址 0
...

→ 硬件广播机制,1 个周期完成

❌ 有冲突 — 多线程访问同一 Bank 的不同地址

线程 0  → Bank 0, 地址 0
线程 8  → Bank 0, 地址 32  ← 同 Bank 不同地址
线程 16 → Bank 0, 地址 64
线程 24 → Bank 0, 地址 96

→ 4-way Bank Conflict
→ 必须串行访问,需要 4 个周期

2.3 典型冲突场景

按列访问二维数组

c code block
__shared__ float tile[32][32];

// 按列访问 — 容易冲突
float val = tile[threadIdx.x][0];
线程 0  → tile[0][0]  → 索引 0   → Bank 0
线程 1  → tile[1][0]  → 索引 32  → Bank 0
线程 2  → tile[2][0]  → 索引 64  → Bank 0
...
线程 31 → tile[31][0] → 索引 992 → Bank 0

全部映射到 Bank 0 → 32-way 冲突!

三、解决方案:Padding

3.1 原理

通过增加数组列数(Padding),改变每行长度,让不同行的同一列映射到不同 Bank。

3.2 代码示例

c code block
__shared__ float tile[32][33];  // 列数 32 → 33

3.3 效果对比

无 Padding [32][32]

行 0:  [0] [1] [2] ... [31]     → Bank 0~31
行 1:  [32][33][34]... [63]     → Bank 0~31
行 2:  [64][65][66]... [95]     → Bank 0~31
按列访问 [0] → 都是 Bank 0 → 冲突!

有 Padding [32][33]

行 0:  [0] [1] [2] ... [31][跳] → Bank 0~31
行 1:  [33][34][35]... [64][跳] → Bank 1~31,0
行 2:  [66][67][68]... [97][跳] → Bank 2~31,0,1
按列访问 [0] → Bank 0,1,2...31 → 无冲突!

3.4 计算过程

c code block
// 无 Padding
线程 1  → tile[1][0]  → 索引 32  → Bank 32 % 32 = Bank 0

// 有 Padding
线程 1  → tile[1][0]  → 索引 33  → Bank 33 % 32 = Bank 1

四、不同数据类型的影响

4.1 float(4字节)

c code block
__shared__ float arr[32];
// Bank = 地址 / 4 % 32
// 相邻元素间隔 1 个 Bank

4.2 double(8字节)

c code block
__shared__ double arr[32];
// Bank = 地址 / 8 % 32
// 相邻元素间隔 2 个 Bank

4.3 char(1字节)

c code block
__shared__ char arr[32];
// 4 个元素共享 1 个 Bank
// 需要注意对齐

五、Bank Conflict 与合并访存的区别

特性合并访存 (Coalesced)Bank Conflict
作用对象Global MemoryShared Memory
关注点Warp 内线程的地址是否连续Warp 内线程访问的 Bank 是否冲突
优化目标减少内存事务数减少 Bank 访问周期数
影响减少显存带宽浪费减少共享内存延迟

六、检测工具

bash code block
# Nsight Compute 中查看
shared_load_bank_conflict
shared_store_bank_conflict

# nvprof 查看
nvprof --metrics shared_load_bank_conflict ./my_app

# 值越大,冲突越严重

七、总结

关键要点

  1. Shared Memory 按行优先线性存储,Bank 由字节地址决定(地址 % 32)
  2. Bank Conflict 发生在 Shared Memory,不是 Global Memory
  3. Padding 是解决 Bank Conflict 的常用方法:改变每行长度,让不同行的同一列映射到不同 Bank
  4. 广播机制:同一 Bank 的同一地址可被多个线程同时访问(无冲突)

优化原则

1. 优先按行访问 Shared Memory(天然无冲突)
2. 必须按列访问时,使用 Padding
3. 利用广播机制(多线程读同一地址)
4. 使用 Nsight Compute 检测实际冲突情况