วิศวกรรม GPU เชิงปฏิบัติ: Metal shaders การโปรไฟล์ และการนำไปใช้บนเอดจ์

วิศวกรรม GPU เชิงปฏิบัติครอบคลุมการเขียนโปรแกรมเชดเดอร์ข้ามแพลตฟอร์ม การวินิจฉัยด้วยตัวนับฮาร์ดแวร์ และการนำไปใช้บนอุปกรณ์เอดจ์ ด้านล่างนี้คือการเจาะลึกทั้งสามเวิร์กโฟลว์
1. เชดเดอร์คูณเมทริกซ์แบบไทล์ด้วย Apple Metal (MSL) แบบกำหนดเอง
บน Apple Silicon (M1-M4 / A-series) คอมพิวต์เคอร์เนลเขียนด้วย Metal Shading Language (MSL) และใช้ Threadgroup Memory (เทียบเท่า CUDA Shared Memory ของ Apple) เพื่อหลีกเลี่ยงการอ่านหน่วยความจำกลางที่ช้า
ด้านล่างคือเชดเดอร์คูณเมทริกซ์แบบไทล์ (C = A × B) ใน MSL ที่ใช้ไทล์ threadgroup ขนาด 16 × 16
#include <metal_stdlib>
using namespace metal;
constant uint TILE_SIZE = 16;
struct MatrixDims {
uint M; // Rows of A and C
uint N; // Cols of B and C
uint K; // Cols of A and Rows of B
};
kernel void matmul_tiled(
device const float* A [[buffer(0)]],
device const float* B [[buffer(1)]],
device float* C [[buffer(2)]],
constant MatrixDims& dims [[buffer(3)]],
uint2 gid [[thread_position_in_grid]],
uint2 tid [[thread_position_in_threadgroup]]
) {
// Fast on-chip Threadgroup (SRAM) tiles
threadgroup float tileA[TILE_SIZE][TILE_SIZE];
threadgroup float tileB[TILE_SIZE][TILE_SIZE];
float acc = 0.0f;
uint numTiles = (dims.K + TILE_SIZE - 1) / TILE_SIZE;
for (uint t = 0; t < numTiles; ++t) {
uint tiledCol = t * TILE_SIZE + tid.x;
uint tiledRow = t * TILE_SIZE + tid.y;
// Collaboratively load 16x16 tiles into Threadgroup memory
tileA[tid.y][tid.x] = (gid.y < dims.M && tiledCol < dims.K)
? A[gid.y * dims.K + tiledCol] : 0.0f;
tileB[tid.y][tid.x] = (tiledRow < dims.K && gid.x < dims.N)
? B[tiledRow * dims.N + gid.x] : 0.0f;
// Synchronize all threads in the threadgroup before reading tiles
threadgroup_barrier(mem_flags::mem_threadgroup);
// Compute partial dot product entirely inside registers/SRAM
for (uint k = 0; k < TILE_SIZE; ++k) {
acc += tileA[tid.y][k] * tileB[k][tid.x];
}
// Wait before overwriting tiles in the next loop iteration
threadgroup_barrier(mem_flags::mem_threadgroup);
}
if (gid.y < dims.M && gid.x < dims.N) {
C[gid.y * dims.N + gid.x] = acc;
}
}- การแมปฮาร์ดแวร์สำคัญ: [[thread_position_in_grid]] แมปตรงกับ blockIdx * blockDim + threadIdx ของ CUDA ส่วน threadgroup_barrier(mem_flags::mem_threadgroup) แมปกับ __syncthreads() ของ CUDA สำหรับเวิร์กโหลด FP16 ระดับโปรดักชัน Apple Silicon ยังมี simdgroup_float8x8 hardware intrinsics เพื่อเข้าถึงยูนิตคูณเมทริกซ์ของ Apple โดยตรง
2. แนวทางเพิ่มประสิทธิภาพ Roofline ด้วย ncu ทีละขั้นตอน
สมมติว่าคุณเขียน CUDA หรือ Triton kernel แบบ naive สำหรับ Row-Wise LayerNorm บนเทนเซอร์ FP16 ขนาด (4096, 4096) แล้วมันทำงานช้ากว่าการใช้งานดั้งเดิมของ PyTorch อย่างเห็นได้ชัด
ขั้นตอนที่ 1: บันทึกตัวนับฮาร์ดแวร์
รัน NVIDIA Nsight Compute (ncu) โดยกำหนดเป้าหมายเฉพาะชื่อเคอร์เนลที่คุณเขียนเองเพื่อหลีกเลี่ยงโอเวอร์เฮดการโปรไฟล์บนโค้ดตั้งค่า:
ncu --kernel-name regex:layernorm_naive --metrics \
sm__throughput.avg.pct_of_peak_sustained_elapsed,\
dram__throughput.avg.pct_of_peak_sustained_elapsed,\
l1tex__t_sectors_pipe_lsu_mem_global_op_ld.sum,\
smsp__warp_issue_stalled_long_scoreboard_per_warp_active.pct \
python run_layernorm.pyขั้นตอนที่ 2: วินิจฉัยคอขวดบน Roofline
ตรวจสอบตัวชี้วัดเอาต์พุต:
- Compute (SM) Throughput: 11.4% ของค่าสูงสุด
- Memory (DRAM/HBM) Throughput: 84.2% ของค่าสูงสุด
- Warp Stall Reason (long_scoreboard): 68.5% (warps หยุดรอให้การอ่านหน่วยความจำ HBM กลางส่งผลลัพธ์กลับมา)
- การวินิจฉัย: เคอร์เนลอยู่ใต้เส้น Memory-Bandwidth Roof ที่ลาดเอียงบนแผนภูมิ Roofline อย่างชัดเจน นอกจากนี้ การตรวจสอบ l1tex__t_sectors เผยให้เห็นการอ่านหน่วยความจำแบบ uncoalesced เธรดใน warp เดียวกันก้าวข้ามลงตามคอลัมน์แทนที่จะอ่านที่อยู่แถวที่ต่อเนื่องกัน ทำให้สูญเสีย 75% ของแคชไลน์ HBM ขนาด 128 ไบต์ทุกเส้นที่ดึงมา
ขั้นตอนที่ 3: ใช้การแก้ไขฮาร์ดแวร์แบบเจาะจง
1. แก้ Memory Coalescing: ตรวจสอบให้เธรดที่อยู่ติดกัน (threadIdx.x) อ่านองค์ประกอบที่อยู่ติดกันตามมิติด้านในที่ต่อเนื่อง (n_cols) เพื่อให้การอ่าน FP16 จำนวน 32 ครั้งรวมเป็นธุรกรรมแบบ coalesced ขนาด 64 ไบต์เพียงครั้งเดียว
2. การโหลดแบบเวกเตอร์ (float4 / tl.load block): โหลด 128 บิต (ค่า FP16 จำนวน 8 ค่า) ต่อคำสั่งแทนที่จะเป็น 16 บิต ลดจำนวนคำสั่งหน่วยความจำทั้งหมดลง 8×
3. Warp-Shuffle Reductions: แทนที่การลดรูปแบบ Shared Memory ที่ช้าด้วย warp shuffles แบบรีจิสเตอร์ต่อรีจิสเตอร์ (__shfl_xor_sync ใน CUDA หรือ tl.sum ใน Triton) เพื่อคำนวณค่าเฉลี่ยและความแปรปรวนของแถวโดยไม่ต้องใช้บาเรียการซิงโครไนซ์
ขั้นตอนที่ 4: ตรวจสอบบน Roofline
การรัน ncu อีกครั้งยืนยันว่า:
- Global Load Sectors: ลดลง 4× (การใช้แคชไลน์ 100%)
- Long Scoreboard Stalls: ลดจาก 68.5% เหลือ < 15%
- Wall-Clock Latency: ดีขึ้น 3.8× ดันแบนด์วิดท์ effective ให้สูงกว่า 85% ของขีดจำกัด HBM ทางกายภาพของ H100
3. ไปป์ไลน์การนำไปใช้บนเอดจ์: การควอนไทซ์และรัน LLM บนมือถือ/แล็ปท็อป
การนำ LLM ขนาด 8B พารามิเตอร์ไปใช้บนแล็ปท็อปหรือสมาร์ทโฟน (RAM ร่วม 8 GB-16 GB) ต้องบีบอัดน้ำหนักเป็นจำนวนเต็ม 4 บิตและทำงานผ่านรันไทม์ C++ ที่ไม่มีโอเวอร์เฮดอย่าง llama.cpp หรือ Apple MLX
[HF Safetensors (FP16, 16 GB)]
│ 1. Convert & Apply Calibration Data (Imatrix)
▼
[GGUF Quantized Binary (Q4_K_M, 4.9 GB)]
│ 2. Memory-Map (mmap) into Unified RAM
▼
[Metal / Vulkan Compute Shaders (On-the-Fly Dequant + Matrix Mul)]ขั้นตอนที่ 1: แปลงและสอบเทียบ (Importance Matrix)
การปัดเศษ 4 บิตแบบดิบทำให้ความแม่นยำในการให้เหตุผลและการเขียนโค้ดลดลง ด้วย llama.cpp ให้แปลงน้ำหนัก Hugging Face เป็นไฟล์ GGUF แบบไม่บีบอัดก่อน จากนั้นคำนวณ Importance Matrix (imatrix) บนตัวอย่างข้อความสอบเทียบขนาดเล็กเพื่อวัดว่าช่องน้ำหนักใดมีผลกระทบต่อการกระตุ้นมากที่สุด:
python convert_hf_to_gguf.py ./Llama-3.1-8B --outfile llama-8b-f16.gguf
./llama-imatrix -m llama-8b-f16.gguf -f calibration.txt -o imatrix.datขั้นตอนที่ 2: การควอนไทซ์แบบ Mixed-Bit K-Quantization (Q4_K_M)
ควอนไทซ์โมเดลด้วย Q4_K_M (4-bit K-quant Medium) ซึ่งเก็บเลเยอร์ attention value/output ที่ไวต่อการเปลี่ยนแปลงไว้ที่ 6 บิต (Q6_K) ขณะบีบอัดเลเยอร์ feed-forward หนาแน่นเป็น 4 บิต (Q4_K) ในซูเปอร์บล็อกขนาด 256 น้ำหนัก:
./llama-quantize --imatrix imatrix.dat llama-8b-f16.gguf llama-8b-q4_k_m.gguf Q4_K_Mวิธีนี้ลดขนาดโมเดลจาก 16.0 GB เหลือ ~4.9 GB โดย perplexity แย่ลงน้อยกว่า 1%
ขั้นตอนที่ 3: การทำงานแบบ Zero-Copy Unified Memory บนอุปกรณ์
เมื่อรันบน iPhone, อุปกรณ์ Android หรือ MacBook:
- โหลดทันทีผ่าน mmap: รันไทม์เมมโมรีแมป (mmap) ไฟล์ .gguf ขนาด 4.9 GB จากแฟลชสตอเรจเข้าสู่ Unified Memory โดยตรง ขจัดการทำซ้ำ RAM และโหลดโมเดลในเวลาไม่ถึง 1 วินาที
- Fused Dequantization Shaders: ระหว่างการสร้างโทเคน เชดเดอร์ Metal (ggml-metal.metal) หรือ Vulkan (mul_mat_q4_K.comp) แบบกำหนดเองจะโหลดบล็อกน้ำหนัก 4 บิตที่แพ็กไว้เข้าสู่รีจิสเตอร์ GPU โดยตรง แกะออกด้วยการเลื่อนบิต และคูณกับการกระตุ้น FP16 แบบทันที ทำให้ได้ 40-70+ tokens/sec บน GPU แล็ปท็อปสมัยใหม่ และ 15-25 tokens/sec บนสมาร์ทโฟนเรือธง