Noticias en español
El último
IA y tecnología

Ingeniería práctica de GPU: shaders Metal, perfilado y despliegue en el borde

Vista orbital ilustrativa de las luces de ciudades del noroeste de Estados Unidos; no es un sistema de cómputo de IA.
Vista orbital ilustrativa de las luces de ciudades del noroeste de Estados Unidos; no es un sistema de cómputo de IA.

La ingeniería práctica de GPU abarca la programación de shaders multiplataforma, el diagnóstico con contadores de hardware y el despliegue en dispositivos edge. A continuación, un análisis a fondo de los tres flujos de trabajo.

1. Shader personalizado de multiplicación de matrices por tiles en Apple Metal (MSL)

En Apple Silicon (M1–M4 / serie A), los kernels de cómputo se escriben en Metal Shading Language (MSL) y aprovechan la Threadgroup Memory (el equivalente de Apple a la memoria compartida de CUDA) para evitar lecturas lentas de memoria global.

A continuación se muestra un shader de multiplicación de matrices por tiles (C = A × B) en MSL con tiles de threadgroup de 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;
    }
}
  • Correspondencia clave de hardware: [[thread_position_in_grid]] equivale directamente a blockIdx * blockDim + threadIdx de CUDA, mientras que threadgroup_barrier(mem_flags::mem_threadgroup) equivale a __syncthreads() de CUDA. Para cargas de trabajo FP16 en producción, Apple Silicon también ofrece los intrínsecos de hardware simdgroup_float8x8 para acceder directamente a las unidades de multiplicación de matrices de Apple.

2. Guía paso a paso de optimización roofline con ncu

Supón que escribes un kernel ingenuo de CUDA o Triton para LayerNorm por filas sobre un tensor FP16 de (4096, 4096), y que se ejecuta claramente más lento que la implementación nativa de PyTorch.

Paso 1: capturar los contadores de hardware

Ejecuta NVIDIA Nsight Compute (ncu) apuntando solo al nombre de tu kernel personalizado, para evitar la sobrecarga de perfilar el código de preparación:

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

Paso 2: diagnosticar el cuello de botella en el roofline

Inspecciona las métricas obtenidas:

  • Rendimiento de cómputo (SM): 11,4 % del pico.
  • Rendimiento de memoria (DRAM/HBM): 84,2 % del pico.
  • Motivo de parada de warps (long_scoreboard): 68,5 % (los warps esperan a que regresen las lecturas de memoria global HBM).
  • Diagnóstico: el kernel se sitúa justo bajo el techo inclinado de ancho de banda de memoria del gráfico Roofline. Además, al revisar l1tex__t_sectors se observan lecturas de memoria no coalescidas: los hilos del mismo warp recorren columnas en lugar de leer direcciones contiguas de una fila, lo que desperdicia el 75 % de cada línea de caché HBM de 128 bytes que se obtiene.

Paso 3: aplicar correcciones de hardware dirigidas

1. Corregir la coalescencia de memoria: asegúrate de que los hilos adyacentes (threadIdx.x) lean elementos adyacentes a lo largo de la dimensión interna contigua (n_cols), de modo que 32 lecturas FP16 se fusionen en una sola transacción coalescida de 64 bytes.

2. Cargas vectorizadas (float4 / bloque tl.load): carga 128 bits (8 valores FP16) por instrucción en lugar de 16 bits, lo que reduce 8 veces el número total de instrucciones de memoria.

3. Reducciones con warp shuffle: sustituye las lentas reducciones en memoria compartida por warp shuffles de registro a registro (__shfl_xor_sync en CUDA o tl.sum en Triton) para calcular la media y la varianza de la fila sin barreras de sincronización.

Paso 4: verificar en el roofline

Al volver a ejecutar ncu se confirma lo siguiente:

  • Sectores de carga global: se reducen 4 veces (100 % de aprovechamiento de la línea de caché).
  • Paradas por long scoreboard: bajan del 68,5 % a menos del 15 % (< 15 %).
  • Latencia de reloj de pared: mejora 3,8 veces, con lo que el ancho de banda efectivo supera el 85 % del límite físico de HBM de la H100.

3. Flujo de despliegue en el borde: cuantizar y ejecutar un LLM en móvil o portátil

Desplegar un LLM de 8B parámetros en un portátil o smartphone (8 GB–16 GB de RAM compartida) exige comprimir los pesos a enteros de 4 bits y ejecutarlo con un entorno C++ sin sobrecarga, como llama.cpp o 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)]

Paso 1: convertir y calibrar (matriz de importancia)

El redondeo directo a 4 bits degrada la precisión en razonamiento y programación. Con llama.cpp, primero convierte los pesos de Hugging Face a un archivo GGUF sin comprimir y después calcula una matriz de importancia (imatrix) sobre una pequeña muestra de texto de calibración, para medir qué canales de pesos tienen mayor impacto en la activación:

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

Paso 2: cuantización K de bits mixtos (Q4_K_M)

Cuantiza el modelo con Q4_K_M (K-quant de 4 bits, Medium), que mantiene en 6 bits (Q6_K) las capas sensibles de valor/salida de la atención, mientras comprime a 4 bits (Q4_K) las capas densas feed-forward, en superbloques de 256 pesos:

./llama-quantize --imatrix imatrix.dat llama-8b-f16.gguf llama-8b-q4_k_m.gguf Q4_K_M

Esto reduce el modelo de 16,0 GB a unos 4,9 GB, con una degradación de la perplejidad inferior al 1 %.

Paso 3: ejecución en el dispositivo con memoria unificada sin copias

Al ejecutar en un iPhone, un dispositivo Android o un MacBook:

  • Carga instantánea con mmap: el entorno de ejecución mapea en memoria (mmap) el archivo .gguf de 4,9 GB directamente desde el almacenamiento flash a la memoria unificada, lo que elimina la duplicación de RAM y carga el modelo en menos de 1 segundo.
  • Shaders de descuantización fusionada: durante la generación de tokens, los compute shaders personalizados de Metal (ggml-metal.metal) o Vulkan (mul_mat_q4_K.comp) cargan los bloques de pesos de 4 bits empaquetados directamente en los registros de la GPU, los desempaquetan con desplazamientos de bits y los multiplican con las activaciones FP16 al vuelo, logrando entre 40 y más de 70 tokens/s en GPU de portátiles modernos y entre 15 y 25 tokens/s en teléfonos móviles de gama alta.

Más noticias: IA y tecnología