Tile Atomics 與最佳化 (Tile Atomics and Optimization)

重點總覽

2.4.10 Atomic Memory Operations（atomic 記憶體運算）

Tile code 有兩種情況需要 memory atomics：

• Cross-block contention：每個 block 算出 partial result，再用 atomic 把它合併到 global memory 的同一位置。
• Intra-block contention：一個 tile 內多個元素寫入記憶體的同一位置。

Python 與 C++ 的呼叫差異

2.4.10.1 Cross-block Contention

不同 block 寫入同一記憶體位置 out。若沒有 atomic，平行執行的 block 會得到錯誤結果。此處必須用 device thread scope（C++ ct::thread_scope_device_t{}；Python thread scope 預設即 device），因為運算結果要對 device 上所有 block 可見。

__tile_global__ void block_sum(int* __restrict__ arr, int* __restrict__ out,
                               std::size_t N) {
  namespace ct = cuda::tiles;
  using namespace ct::literals;
  constexpr auto TILE = 16_ic;
  arr = ct::assume_aligned(arr, 16_ic);
  out = ct::assume_aligned(out, 16_ic);
  auto aView = ct::partition_view{ct::tensor_span{arr, ct::extents{N}},
                                  ct::shape{TILE}};
  int bid = ct::bid().x;
  auto tile    = aView.load_masked(bid);   // partial final tile -> OOB lanes = 0
  auto partial = ct::sum(tile, 0_ic);      // reduce 成 1-element tile
  ct::atomic_add(out, (int)partial,        // 累加到 out[0]
                 ct::memory_order_relaxed_t{},  // accumulator -> relaxed 即可
                 ct::thread_scope_device_t{});  // 對整個 device 可見
}

@ct.kernel
def block_sum(arr, out, TILE: ct.Constant[int]):
    bid = ct.bid(0)
    # partial final tile -> OOB lanes default to 0
    tile = ct.load(arr, index=(bid,), shape=(TILE,),
                   padding_mode=ct.PaddingMode.ZERO)
    partial = ct.sum(tile)                            # reduce 成 scalar
    out.tiled_view((1,)).atomic_add((0,), partial)    # atomically 累加進 out[0]

重點：每個 block 的 partial sum 累加進 out[0] 後即丟棄、不需舊值，故 Python 用 TiledView.atomic_add；累加器用 relaxed order 已足夠。

Block 0 ─ partial0 ─┐
Block 1 ─ partial1 ─┼─ atomic_add ──> out[0]   (device scope：跨 block 可見)
Block 2 ─ partial2 ─┘

2.4.10.2 Intra-block Contention

一個 tile 的所有值都 atomically 加到記憶體同一位置。下例中 ptrs tile 的每個元素都指向同一位置 slot，ct::iota<i32x16>() 產生的每個元素都被 atomically 加進該位置。由於只在單一 block 內競爭，用 block thread scope thread_scope_block_t{} 即可。

using i32x16 = ct::tile<int, ct::shape<16>>;
int* slot = /* pointer to the contended location */;
// 16 lanes 全部瞄準同一位址；加法可交換，故未指定的順序不影響此 sum，
// 競爭限於單一 block，故 block scope 足矣。
auto ptrs = ct::full<ct::tile<int*, ct::shape<16>>>(slot);
ct::atomic_add(ptrs, ct::iota<i32x16>(),
               ct::memory_order_relaxed_t{},
               ct::thread_scope_block_t{});

tile lanes:  iota -> [0][1][2] ... [15]
                       \  \  |  ... /
                        atomic_add ──> *slot   (block scope)
   每元素一次 atomic；順序未指定；加法可交換故結果穩定

2.4.10.3 Supported Atomic Operations

所有運算皆為 element-wise，差別在於「待寫入值」如何與「記憶體現值」結合：

2.4.11 Optimization Hints（最佳化提示）

Optimization hint 是附加在 source construct（tile kernel function、load/store 呼叫點等）上的 metadata，用來引導 compiler 的 code generation。

兩個共通性質：

• Per-construct：hint 只作用於它所附加的那個 kernel function 或那個 call expression，不影響周邊程式碼。
• 可 per-architecture：每個 hint 可對不同 GPU 架構設不同值，或設一個套用到所有目標的單一值。

兩種語言的暴露方式不同：C++ 用放在宣告/敘述上的 C++ attribute；Python 用 kernel decorator 與各記憶體運算呼叫點的 keyword arguments。hint 種類（每個 hint 控制什麼）兩語言共用。

2.4.11.1 C++ — cutile::hint Attribute

[[ cutile::hint(arch, kind1=value1, kind2=value2, ...) ]]

• 第一個引數是目標架構，用 __CUDA_ARCH__ 慣例的整數編碼（例如 900 表示 sm_90、1000 表示 sm_100）。
• 特殊值 0 表示 architecture-agnostic（套用到每個目標架構）。
• 其餘每個引數是一個 kind=value pair。

放置規則：

[[ cutile::hint(900,  num_cta_in_cga=4),    // sm_90:  偏好 4 CTAs/cluster
   cutile::hint(1000, num_cta_in_cga=8) ]]  // sm_100: 偏好 8 CTAs/cluster
__tile_global__ void optimization_hints(float* __restrict__ in,
                                         float* __restrict__ out) {
  // ...
  ct::tile<float, ct::shape<8>> tile;
  [[ cutile::hint(0, latency=8) ]]          // expression-statement hint：此 load 屬高頻寬
  tile = inView.load(bx);
  outView.store(tile, bx);
}

2.4.11.2 Python — Decorator Arguments 與 Call-Site Keywords

• Kernel 級 hints：作為 @ct.kernel(...) decorator 的 keyword arguments。compiled kernel 物件還有 .replace_hints(**hints) 方法，回傳一個 hint 被覆蓋的新 kernel；新 kernel 有自己的 JIT cache，因此 replace_hints 是 autotuning 迴圈的天然構件。
• Per-call hints：放在記憶體運算呼叫點的 keyword arguments：ct.load/ct.store、TiledView.load/TiledView.store、ct.gather/ct.scatter。

per-architecture 值用 cuda.tile.ByTarget(*, default=..., sm_XXX=..., sm_YYY=...) 包起來；架構 key 必須是 "sm_<major><minor>" 形式的字串（如 "sm_100"、"sm_120"）。未用 ByTarget 的純值套用到每個目標，等同 C++ 的 arch=0。

@ct.kernel(num_ctas=ByTarget(sm_90=4, sm_100=8))   # kernel 級、per-arch hint
def optimization_hints(in_, out, TILE: ct.Constant[int]):
    bid = ct.bid(0)
    tile = ct.load(in_, index=(bid,), shape=(TILE,), latency=8)  # per-call hint
    ct.store(out, index=(bid,), tile=tile)

# Autotuning：不改 source 就產生新 kernel（有自己的 JIT cache）
tuned_kernel = optimization_hints.replace_hints(num_ctas=8)

2.4.11.3 Hint Kinds（hint 種類）

兩語言共用同一組 hint；C++ 名與 Python 名只是同一底層 hint 的不同拼法。

Hint 解析優先序（同 kind、同 construct）：
  arch-specific (如 sm_100=8)  ──覆蓋──>  arch-agnostic (arch=0 / 純值)

2.4.12 C++ Performance Tips（C++ 效能技巧）

本指南的 C++ kernel 都用到同一組註記與慣用法，以下說明其作用與重要性。

2.4.12.1 對記憶體陣列使用 __restrict__ Pointers

__restrict__ 告訴 compiler：該 pointer 所存取的記憶體區域，在此 pointer 生命週期內只會透過這個 pointer 存取。在 tile C++ 中，對符合此條件的陣列 pointer 標上 __restrict__ 是良好記憶體運算效能的關鍵。

為何重要——考慮一個 element-wise copy：

非重疊 (__restrict__):   load─┐ load─┐ load─┐   讀寫可交錯、可 pipeline
                         store┘ store┘ store┘

可能重疊 (無 __restrict__): [ 所有 load ] ──barrier──> [ 所有 store ]

2.4.12.2 標記陣列 Pointer 為 16-Byte Aligned

用 ct::assume_aligned 把陣列 pointer 標為 16-byte 對齊：

__tile_global__ void foo(float* __restrict__ in) {
  namespace ct = cuda::tiles;
  using namespace ct::literals;
  in = ct::assume_aligned(in, 16_ic);
  ct::tensor_span t{in, ct::extents{256_ic, 256_ic}};
  ct::partition_view{t, ct::shape{4_ic, 4_ic}};
}

• 此對齊保證是 ct::partition_view 使用 Tensor Memory Accelerator (TMA) 的必要條件。
• 執行期必須真的提供 16-byte 對齊的 pointer，否則行為未定義。
• cudaMalloc 等 CUDA 配置器回傳的 pointer 保證至少 16-byte 對齊。

2.4.12.3 結構化存取優先用 ct::partition_view

對於結構化記憶體存取，優先用 ct::partition_view，而非 gather/scatter 形式的 ct::load/ct::store。view-based 形式可在支援的硬體上 lower 成 TMA，比 per-element gather 快得多。

2.4.12.4 有界迴圈用 ct::irange

迭代固定範圍時用 ct::irange 取代普通 for 迴圈。結構化形式讓 compiler 能做 pipelining 與 vectorization——當迴圈 bound 與 step 是不透明的整數運算式時無法做這些最佳化。

for (auto idx : ct::irange(lowerBound, upperBound, step)) {
  // ...
}

考試/測驗重點

Related Notes

• 02-Programming-GPUs/12-Tile-Operations-and-Primitives
• 02-Programming-GPUs/11-Tile-Load-Store-and-Control-Flow
• 02-Programming-GPUs/10-Tile-Kernels-Structure
• 02-Programming-GPUs/09-SIMT-Atomics-Cooperative-Occupancy
• 02-Programming-GPUs/08-SIMT-Memory-Performance
• 02-Programming-GPUs/04-CUDA-Cpp-Errors-and-Specifiers
• 01-Introduction-to-CUDA/03-Tile-Programming
• 01-Introduction-to-CUDA/04-GPU-Memory-Hierarchy
• 01-Introduction-to-CUDA/05-CUDA-Platform
• 02-Programming-GPUs/Practice-Programming-GPUs
• 00-Dashboard/Exam-Traps