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

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.pyPaso 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.datPaso 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_MEsto 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.