Optimización de Latencia y Throughput

Tipo de lección: Video

Concepto clave

En sistemas de trading de baja latencia, la optimización de latencia se refiere a minimizar el tiempo entre la recepción de datos de mercado y la ejecución de órdenes, mientras que el throughput es la cantidad de operaciones procesadas por unidad de tiempo. Piensa en un sistema de semáforos inteligentes: la latencia es el tiempo que tarda en cambiar de rojo a verde tras detectar un coche, y el throughput es cuántos coches pasan por hora. En trading, latencias de microsegundos determinan ganancias o pérdidas.

Rust es ideal para esto porque su sistema de ownership elimina garbage collection (fuente de latencia impredecible), y su compilador optimiza agresivamente. La seguridad de memoria previa vulnerabilidades críticas en sistemas financieros.

En HFT (High-Frequency Trading), reducir 1 microsegundo de latencia puede valer millones anuales.

Cómo funciona en la práctica

Vamos a optimizar un componente de procesamiento de ticks de mercado. Paso 1: Medir latencia base con herramientas como criterion o mediciones hardware. Paso 2: Identificar cuellos de botella con perfiles como perf o flamegraph. Paso 3: Aplicar técnicas específicas.

// Ejemplo: Procesamiento de ticks con zero-copy
struct Tick {
    symbol: [u8; 8],
    price: f64,
    volume: u32,
}

fn process_ticks(ticks: &[Tick]) -> Vec {
    ticks.iter()
        .filter(|t| t.volume > 1000)
        .map(|t| Order::new(t.symbol, t.price))
        .collect()
}
// Optimización: Usar iteradores sin allocations intermedias

Tabla de técnicas comunes:

Técnica	Impacto latencia	Impacto throughput
Zero-copy deserialization	Alto	Medio
Lock-free estructuras de datos	Alto	Alto
SIMD con std::simd	Medio	Alto
Memory pooling	Medio	Alto

Caso de estudio

Un sistema de trading procesa 100,000 ticks/segundo con latencia p95 de 50 microsegundos. Objetivo: reducir a 20 microsegundos manteniendo throughput. Análisis mostró:

1. Deserialización JSON consumía 30 microsegundos por tick.
2. Colas de mensajes usaban mutexes con contención.

Solución en Rust:

• Reemplazar JSON con binary protocol (Protocol Buffers) y zero-copy parsing.
• Implementar ring buffer lock-free con crossbeam.
• Resultado: latencia p95 de 18 microsegundos, throughput aumentó a 150,000 ticks/segundo.

Errores comunes

1. Premature optimization: Optimizar sin medir primero. Usa benchmarks realistas con datos de producción.
2. Ignorar cache locality: Estructuras de datos mal alineadas causan cache misses. Usa #[repr(C)] o #[repr(align(64))] para alineación.
3. Abuso de allocations: Crear Vec o String en loops críticos. Reutiliza buffers con clear() o pools.
4. Blocking en async code: Llamadas bloqueantes en runtimes async como Tokio. Usa spawn_blocking para CPU-bound.
5. No considerar NUMA: En servidores multi-socket, memoria asignada en socket incorrecto añade latencia. Usa numa-rs para afinidad.

Checklist de dominio

• Medir latencia y throughput con herramientas como criterion, perf, o hardware counters.
• Implementar zero-copy deserialization con serde o custom parsers.
• Usar estructuras lock-free (ej., crossbeam::queue) para datos compartidos.
• Aplicar SIMD a operaciones batch con std::simd o packed_simd.
• Configurar afinidad de hilos y memoria para NUMA.
• Validar seguridad sin overhead (ej., bounds checks elided por el compilador).
• Documentar trade-offs entre latencia y throughput en decisiones de diseño.

Optimizar un procesador de ticks con lock-free ring buffer

Implementa un sistema que procese ticks de mercado desde múltiples hilos productores a un consumidor, minimizando latencia.

1. Crea una estructura Tick con symbol (String), price (f64), timestamp (u64).
2. Implementa un ring buffer lock-free usando crossbeam::queue::ArrayQueue con capacidad para 1024 ticks.
3. Escribe un productor que genere 10,000 ticks aleatorios y los pushee al buffer desde 2 hilos concurrentes.
4. Escribe un consumidor que popee ticks y calcule el precio promedio, registrando latencia (timestamp actual - tick.timestamp).
5. Mide la latencia p95 y throughput (ticks/segundo) con std::time::Instant.
6. Optimiza: reemplaza String en Tick con [u8; 8] para symbol, y usa memory pool para reutilizar structs.
7. Compara métricas antes y después, documenta resultados.

Pistas

• Usa crossbeam::queue::ArrayQueue para el buffer lock-free.
• Para medir latencia p95, almacena mediciones en un Vec y ordena.
• Considera usar #[repr(C)] para alinear Tick a 64 bytes y mejorar cache locality.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.