ข่าวไทย
ล่าสุด
อดีตรัฐมนตรี รจิธา เสนารัตเน เตือนศรีลังกากำลังเข้าสู่ภาวะล้มละลายอีกครั้งอดีตประธานาธิบดีให้ทุนสร้างบ้านให้ครอบครัวผู้ยากไร้ในเมืองธรรมบุตเตกามาเครื่องรักษามะเร็งมูลค่าหลายพันล้านรูปีไม่ได้ใช้งาน เนื่องจากผู้ป่วยต้องเผชิญกับความล่าช้ามากขึ้นสุริยาลุ้นสร้างสถิติภาพยนตร์สามเรื่องทำรายได้เรื่องละ 2 พันล้านรูปีอินเดียในปีเดียวมีรายงานว่ากำแพงกันดินพังถล่มที่โครงการไฟฟ้าพลังน้ำ Tarbela ในปากีสถานรัฐมนตรีกล่าวว่าสถานีโทรทัศน์ระหว่างประเทศให้การสนับสนุนการท่องเที่ยวศรีลังกาตร.จับกุมผู้ต้องสงสัยมีส่วนช่วยฆ่าโนฉิยากามะชาวจีน 4 คนถูกคุมขังระหว่างสอบสวนข้อกล่าวหาเก็บสัตว์ป่าในป่าสิงหราชา
AI และเทคโนโลยี

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

ภาพประกอบมุมมองจากวงโคจรของแสงไฟเมืองทางตะวันตกเฉียงเหนือของอเมริกา ไม่ใช่ระบบคอมพิวเตอร์ AI
ภาพประกอบมุมมองจากวงโคจรของแสงไฟเมืองทางตะวันตกเฉียงเหนือของอเมริกา ไม่ใช่ระบบคอมพิวเตอร์ AI

วิศวกรรม 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 บนสมาร์ทโฟนเรือธง

ข่าวเพิ่มเติม: AI และเทคโนโลยี