اخبار فارسی
آخرین
هوش مصنوعی و فناوری

مهندسی عملی GPU: شیدرهای Metal، پروفایل‌گیری و استقرار روی لبه

نمایی مداری، صرفاً برای تصویرسازی، از نورهای شهرهای شمال‌غربی آمریکا؛ نه یک سامانهٔ محاسباتی هوش مصنوعی.
نمایی مداری، صرفاً برای تصویرسازی، از نورهای شهرهای شمال‌غربی آمریکا؛ نه یک سامانهٔ محاسباتی هوش مصنوعی.

مهندسی عملی GPU شامل برنامه‌نویسی شیدر چندسکویی، عیب‌یابی با شمارنده‌های سخت‌افزار و استقرار روی دستگاه در لبه است. در ادامه بررسی عمیق هر سه جریان کاری آمده است.

1. شیدر سفارشی Apple Metal (MSL) برای ضرب ماتریس کاشی‌بندی‌شده

روی Apple Silicon (M1–M4 / A-series)، کرنل‌های محاسباتی به زبان Metal Shading Language (MSL) نوشته می‌شوند و از Threadgroup Memory (معادل Shared Memory در CUDA برای اپل) بهره می‌برند تا از خواندن‌های کند حافظهٔ سراسری جلوگیری شود.

در ادامه یک شیدر ضرب ماتریس کاشی‌بندی‌شده (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 را ارائه می‌دهد تا مستقیماً به واحدهای ضرب ماتریس اپل دسترسی یابید.

2. راهنمای گام‌به‌گام بهینه‌سازی Roofline با ncu

فرض کنید یک کرنل ساده CUDA یا Triton برای 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

معیارهای خروجی را بررسی کنید:

  • توان عملیاتی محاسبه (SM): 11.4% از اوج.
  • توان عملیاتی حافظه (DRAM/HBM): 84.2% از اوج.
  • دلیل توقف Warp (long_scoreboard): 68.5% (warpها منتظر بازگشت خواندن‌های حافظهٔ سراسری HBM متوقف مانده‌اند).
  • تشخیص: کرنل دقیقاً زیر سقف شیب‌دار پهنای باند حافظه در نمودار Roofline قرار دارد. افزون بر این، بررسی l1tex__t_sectors خواندن‌های حافظهٔ غیرادغام‌شده (uncoalesced) را نشان می‌دهد — نخ‌های یک warp به‌جای خواندن آدرس‌های پیوستهٔ سطر، در امتداد ستون‌ها پیش می‌روند و 75% از هر خط کش 128 بایتی HBM که واکشی می‌شود هدر می‌رود.

گام 3: اعمال اصلاحات سخت‌افزاری هدفمند

1. اصلاح ادغام حافظه (Memory Coalescing): مطمئن شوید نخ‌های مجاور (threadIdx.x) عناصر مجاور را در امتداد بُعد داخلی پیوسته (n_cols) می‌خوانند تا 32 خواندن FP16 در یک تراکنش ادغام‌شدهٔ 64 بایتی ترکیب شوند.

2. بارگذاری‌های برداری (float4 / tl.load block): به‌جای 16 بیت، 128 بیت (8 مقدار FP16) را در هر دستور بارگذاری کنید و تعداد کل دستورهای حافظه را 8 برابر کاهش دهید.

3. کاهش‌های Warp-Shuffle: کاهش‌های کند Shared Memory را با warp shuffleهای ثبات‌به‌ثبات (__shfl_xor_sync در CUDA یا tl.sum در Triton) جایگزین کنید تا میانگین و واریانس سطر بدون سدهای همگام‌سازی محاسبه شود.

گام 4: راستی‌آزمایی روی Roofline

اجرای دوبارهٔ ncu تأیید می‌کند:

  • سکتورهای بارگذاری سراسری (Global Load Sectors): 4 برابر کاهش می‌یابد (بهره‌وری 100% از خط کش).
  • توقف‌های Long Scoreboard: از 68.5% به < 15% کاهش می‌یابد.
  • تأخیر زمان واقعی (Wall-Clock Latency): 3.8 برابر بهبود می‌یابد و پهنای باند مؤثر را به بالاتر از 85% از حد فیزیکی HBM در H100 می‌رساند.

3. خط لولهٔ استقرار روی لبه: کوانتیزه کردن و اجرای یک LLM روی موبایل/لپ‌تاپ

استقرار یک LLM با 8 میلیارد پارامتر روی لپ‌تاپ یا گوشی هوشمند (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: کوانتیزاسیون K چندبیتی ترکیبی (Q4_K_M)

مدل را با Q4_K_M (کوانتیزاسیون K چهاربیتی از نوع Medium) کوانتیزه کنید؛ این روش لایه‌های حساس value/output در attention را در 6 بیت (Q6_K) نگه می‌دارد و لایه‌های feed-forward متراکم را در ابربلوک‌های 256 وزنی به 4 بیت (Q4_K) فشرده می‌کند:

./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: اجرای بدون کپی روی حافظهٔ یکپارچه در دستگاه

هنگام اجرا روی iPhone، دستگاه Android یا MacBook:

  • بارگذاری آنی با mmap: محیط اجرا فایل .gguf با حجم 4.9 GB را مستقیماً از حافظهٔ فلش در حافظهٔ یکپارچه نگاشت (mmap) می‌کند — تکرار RAM را از بین می‌برد و مدل را در کمتر از 1 ثانیه بارگذاری می‌کند.
  • شیدرهای دکوانتیزاسیون ادغام‌شده: در تولید توکن، شیدرهای محاسباتی سفارشی Metal (ggml-metal.metal) یا Vulkan (mul_mat_q4_K.comp) بلوک‌های وزن فشردهٔ 4 بیتی را مستقیماً در ثبات‌های GPU بارگذاری می‌کنند، با شیفت‌های بیتی آن‌ها را باز می‌کنند و در لحظه در فعال‌سازی‌های FP16 ضرب می‌کنند — و به 40–70+ توکن بر ثانیه روی GPUهای لپ‌تاپ مدرن و 15–25 توکن بر ثانیه روی گوشی‌های موبایل پرچم‌دار می‌رسند.

اخبار بیشتر: هوش مصنوعی و فناوری