తెలుగు వార్తలు
తాజా
శ్రీలంక మళ్లీ దివాళా దిశగా వెళుతోందని మాజీ మంత్రి రజిత సేనారత్న హెచ్చరికతంబుట్టేగామలో అవసరంలో ఉన్న కుటుంబానికి ఇంటి నిర్మాణానికి మాజీ అధ్యక్షురాలి నిధులురోగులకు మరిన్ని జాప్యాలు: బిలియన్ రూపాయల క్యాన్సర్ చికిత్స యంత్రాలు వినియోగం లేకుండా నిలిచిపోయాయిసూర్యకు ఒకే ఏడాదిలో ఒక్కొక్కటి 2 బిలియన్ భారతీయ రూపాయలు వసూలు చేసే మూడు చిత్రాల అవకాశంపాకిస్థాన్‌లోని టార్బెలా జలవిద్యుత్ ప్రాజెక్టు వద్ద రిటైనింగ్ వాల్ కూలినట్లు సమాచారంశ్రీలంక టూరిజానికి అంతర్జాతీయ ప్రసార సంస్థలు మద్దతునిస్తాయని మంత్రి చెప్పారునొచ్చియాగమ హత్యకు సహకరించాడన్న ఆరోపణలపై ఓ వ్యక్తిని పోలీసులు అరెస్ట్ చేశారుసింహరాజలో వన్యప్రాణుల సేకరణ ఆరోపణలపై నలుగురు చైనా పౌరులు రిమాండ్‌కు గురయ్యారు
AI & టెక్నాలజీ

ఆచరణాత్మక GPU ఇంజినీరింగ్: Metal షేడర్లు, ప్రొఫైలింగ్, ఎడ్జ్ డిప్లాయ్‌మెంట్

దృశ్య వివరణ కోసం వాయవ్య అమెరికా నగర దీపాల కక్ష్య దృశ్యం; AI గణన వ్యవస్థ కాదు.
దృశ్య వివరణ కోసం వాయవ్య అమెరికా నగర దీపాల కక్ష్య దృశ్యం; AI గణన వ్యవస్థ కాదు.

ఆచరణాత్మక GPU ఇంజినీరింగ్‌లో వివిధ ప్లాట్‌ఫారమ్‌లకు షేడర్ ప్రోగ్రామింగ్, హార్డ్‌వేర్ కౌంటర్ నిర్ధారణ, పరికరంపైనే ఎడ్జ్ డిప్లాయ్‌మెంట్ ఉంటాయి. ఈ మూడు వర్క్‌ఫ్లోలను కింద వివరంగా పరిశీలిస్తాం.

1. కస్టమ్ Apple Metal (MSL) టైల్డ్ మ్యాట్రిక్స్ గుణకార షేడర్

Apple Silicon (M1–M4 / A-series)పై కంప్యూట్ కర్నల్‌లను Metal Shading Language (MSL)లో రాస్తారు. నెమ్మదైన గ్లోబల్ మెమరీ రీడ్‌లను తప్పించడానికి Threadgroup Memoryను (CUDA Shared Memoryకు Apple సమానమైనది) ఉపయోగిస్తారు.

16 × 16 థ్రెడ్‌గ్రూప్ టైల్స్‌ను ఉపయోగించే MSL టైల్డ్ మ్యాట్రిక్స్ గుణకార (C = A × B) షేడర్ కింద ఉంది.

#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]] నేరుగా CUDA యొక్క blockIdx * blockDim + threadIdxకు మ్యాప్ అవుతుంది. threadgroup_barrier(mem_flags::mem_threadgroup), CUDA యొక్క __syncthreads()కు మ్యాప్ అవుతుంది. ఉత్పత్తి స్థాయి FP16 వర్క్‌లోడ్‌ల కోసం Apple Silicon, Apple మ్యాట్రిక్స్ గుణకార యూనిట్లను నేరుగా ఉపయోగించడానికి simdgroup_float8x8 హార్డ్‌వేర్ ఇంట్రిన్సిక్‌లను కూడా అందిస్తుంది.

2. దశలవారీ ncu Roofline ఆప్టిమైజేషన్ వివరణ

మీరు (4096, 4096) FP16 టెన్సర్‌పై వరుసల వారీ LayerNorm కోసం సరళమైన CUDA లేదా Triton కర్నల్ రాశారని, అది 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%.
  • వార్ప్ నిలిచిపోవడానికి కారణం (long_scoreboard): 68.5% (గ్లోబల్ HBM మెమరీ రీడ్‌లు తిరిగి రావడానికి వేచి వార్ప్‌లు ఆగిపోయాయి).
  • నిర్ధారణ: Roofline చార్ట్‌లోని ఏటవాలు మెమరీ-బ్యాండ్‌విడ్త్ పైకప్పు కిందే కర్నల్ ఉంది. అదనంగా, l1tex__t_sectorsను పరిశీలిస్తే కలిపి జరగని మెమరీ రీడ్‌లు కనిపిస్తాయి. ఒకే వార్ప్‌లోని థ్రెడ్‌లు వరుసలోని పక్కపక్క అడ్రస్‌లను చదవకుండా కాలమ్‌లలో దూకుతూ చదువుతాయి. అందువల్ల తెచ్చిన ప్రతి 128-బైట్ HBM క్యాష్ లైన్‌లో 75% వృథా అవుతుంది.

దశ 3: లక్ష్యిత హార్డ్‌వేర్ పరిష్కారాలను అమలు చేయండి

1. మెమరీ కోఅలెసింగ్‌ను సరిచేయండి: పక్కపక్కన ఉన్న థ్రెడ్‌లు (threadIdx.x) నిరంతర అంతర్గత డైమెన్షన్ (n_cols) వెంట పక్కపక్క మూలకాలను చదివేలా చూడండి. అప్పుడు 32 FP16 రీడ్‌లు ఒకే 64-బైట్ కలిపిన ట్రాన్సాక్షన్‌గా విలీనమవుతాయి.

2. వెక్టరైజ్డ్ లోడ్‌లు (float4 / tl.load బ్లాక్): ఒక్కో సూచనకు 16 బిట్‌లకు బదులుగా 128 బిట్‌లు (8 FP16 విలువలు) లోడ్ చేయండి. దీనితో మొత్తం మెమరీ సూచనల సంఖ్య 8× తగ్గుతుంది.

3. వార్ప్-షఫుల్ రిడక్షన్‌లు: సింక్రనైజేషన్ బారియర్లు లేకుండా వరుస సగటు, వేరియన్స్ లెక్కించడానికి నెమ్మదైన Shared Memory రిడక్షన్‌ల స్థానంలో రిజిస్టర్ నుంచి రిజిస్టర్‌కు వార్ప్ షఫుల్‌లను (CUDAలో __shfl_xor_sync లేదా Tritonలో tl.sum) ఉపయోగించండి.

దశ 4: Rooflineపై ధృవీకరించండి

ncuను మళ్లీ నడిపితే ఇవి నిర్ధారణ అవుతాయి:

  • గ్లోబల్ లోడ్ సెక్టర్లు: 4× తగ్గుతాయి (100% క్యాష్-లైన్ వినియోగం).
  • లాంగ్ స్కోర్‌బోర్డ్ స్టాల్‌లు: 68.5% నుంచి < 15%కు తగ్గుతాయి.
  • వాల్-క్లాక్ లేటెన్సీ: 3.8× మెరుగవుతుంది. దీనితో ప్రభావవంతమైన బ్యాండ్‌విడ్త్ H100 భౌతిక HBM పరిమితిలో 85% కంటే పైకి వెళ్తుంది.

3. ఎడ్జ్ డిప్లాయ్‌మెంట్ పైప్‌లైన్: మొబైల్/ల్యాప్‌టాప్‌పై LLMను క్వాంటైజ్ చేసి నడపడం

ల్యాప్‌టాప్ లేదా స్మార్ట్‌ఫోన్‌పై (8 GB–16 GB షేర్డ్ RAM) 8B-పారామీటర్ LLMను డిప్లాయ్ చేయాలంటే వెయిట్‌లను 4-బిట్ పూర్ణాంకాలుగా కుదించి, llama.cpp లేదా Apple MLX వంటి అదనపు భారం లేని C++ రన్‌టైమ్ ద్వారా అమలు చేయాలి.

[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: మార్చండి & కాలిబ్రేట్ చేయండి (ఇంపార్టెన్స్ మ్యాట్రిక్స్)

నేరుగా 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 (4-బిట్ K-quant Medium)తో మోడల్‌ను క్వాంటైజ్ చేయండి. ఇది సున్నితమైన అటెన్షన్ వాల్యూ/అవుట్‌పుట్ లేయర్‌లను 6-బిట్ (Q6_K)గా ఉంచి, డెన్స్ ఫీడ్-ఫార్వర్డ్ లేయర్‌లను 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కు కుదిస్తుంది. పెర్ప్లెక్సిటీ క్షీణత 1% కంటే తక్కువగా ఉంటుంది.

దశ 3: పరికరంపై జీరో-కాపీ యూనిఫైడ్ మెమరీ అమలు

iPhone, Android పరికరం లేదా MacBookపై నడిపేటప్పుడు:

  • mmap ద్వారా తక్షణ లోడ్: రన్‌టైమ్ 4.9 GB .gguf ఫైల్‌ను ఫ్లాష్ స్టోరేజ్ నుంచి నేరుగా Unified Memoryలోకి మెమరీ-మ్యాప్ (mmap) చేస్తుంది. RAM నకళ్లను తొలగించి మోడల్‌ను 1 సెకను లోపే లోడ్ చేస్తుంది.
  • కలిపిన డీక్వాంటైజేషన్ షేడర్లు: టోకెన్ ఉత్పత్తి సమయంలో కస్టమ్ Metal (ggml-metal.metal) లేదా Vulkan (mul_mat_q4_K.comp) కంప్యూట్ షేడర్లు ప్యాక్ చేసిన 4-బిట్ వెయిట్ బ్లాక్‌లను నేరుగా GPU రిజిస్టర్‌లలో లోడ్ చేసి, బిట్‌వైజ్ షిఫ్ట్‌లతో అన్‌ప్యాక్ చేసి, అప్పటికప్పుడే FP16 యాక్టివేషన్‌లతో గుణిస్తాయి. దీనితో ఆధునిక ల్యాప్‌టాప్ GPUలపై 40–70+ టోకెన్లు/సెకను, ఫ్లాగ్‌షిప్ మొబైల్ ఫోన్‌లపై 15–25 టోకెన్లు/సెకను సాధిస్తాయి.

మరిన్ని వార్తలు: AI & టెక్నాలజీ