FerrousPath

Nivel 3 · Sistemas· Lección 9 de 11 · 30 min

Ingeniería del rendimiento

Mide primero — benchmarks, perfiles, reservas de memoria, disposición de los datos, comprobaciones de límites, inlining, SIMD y configuración de la compilación.

El método

  1. Decide qué importa —latencia, caudal, memoria, tamaño del binario, tiempo de compilación— y cómo lo vas a medir.
  2. Compila en modo release. Las compilaciones debug pueden ser de 10 a 100 veces más lentas y no dicen nada sobre producción. cargo run --release.
  3. Mide una línea base con un benchmark repetible.
  4. Haz un perfil para encontrar adónde va el tiempo.
  5. Cambia una sola cosa. Mide otra vez. Consérvala solo si ayudó.

Rust es rápido por defecto; la mayoría de los programas de Rust lentos lo son por razones algorítmicas o por reservas y copias accidentales, no por el lenguaje.

Benchmarks

Usa Criterion para microbenchmarks estadísticamente significativos, e hyperfine para cronometrar comandos completos.

// benches/sum.rs  — con `criterion` como dependencia de desarrollo y `harness = false`
use criterion::{criterion_group, criterion_main, Criterion};
use std::hint::black_box;

fn sum_loop(xs: &[u64]) -> u64 {
    let mut total = 0;
    for i in 0..xs.len() {
        total += xs[i];
    }
    total
}

fn sum_iter(xs: &[u64]) -> u64 {
    xs.iter().sum()
}

fn bench(c: &mut Criterion) {
    let data: Vec<u64> = (0..100_000).collect();
    c.bench_function("indexed loop", |b| b.iter(|| sum_loop(black_box(&data))));
    c.bench_function("iterator", |b| b.iter(|| sum_iter(black_box(&data))));
}

criterion_group!(benches, bench);
criterion_main!(benches);

black_box oculta un valor al optimizador para que el trabajo no desaparezca por plegado.

Perfiles

Herramienta Plataforma Qué muestra
cargo flamegraph Linux, macOS, Windows El tiempo de CPU como un flame graph
samply todas Profiler por muestreo con la interfaz del Firefox Profiler
perf Linux Muestreo, contadores de hardware (fallos de caché, predicciones de salto erróneas)
Instruments, VTune, Windows Performance Analyzer según el SO Profilers de cada fabricante
dhat, heaptrack, bytehound varias Número, tamaño y lugar de las reservas de memoria
cargo bloat, cargo llvm-lines todas Qué ocupa espacio en el binario; el abultamiento por genéricos
cargo build --timings todas Adónde va el tiempo de compilación

Haz los perfiles con optimizaciones y con información de depuración para tener símbolos:

[profile.release]
debug = true

Reservas de memoria

El heap es el primer sospechoso habitual.

use std::time::Instant;

fn main() {
    let n = 200_000;

    let t = Instant::now();
    let mut slow = Vec::new();
    for i in 0..n {
        slow.push(format!("item-{i}")); // una reserva por elemento, más los recrecimientos
    }
    let a = t.elapsed();

    let t = Instant::now();
    let mut buf = String::with_capacity(n * 12); // una sola reserva, por adelantado
    let mut spans = Vec::with_capacity(n);
    for i in 0..n {
        use std::fmt::Write;
        let start = buf.len();
        write!(buf, "item-{i}").unwrap();
        spans.push(start..buf.len()); // índices dentro de un único búfer compartido
    }
    let b = t.elapsed();

    println!("{} strings: {a:?}", slow.len());
    println!("one buffer + {} spans: {b:?}", spans.len());
    println!("check: {} == {}", slow[77], &buf[spans[77].clone()]);
}

Hábitos que eliminan reservas:

  • with_capacity cuando se conoce el tamaño; clear() y reutilizar los búferes en los bucles en lugar de crear otros nuevos.
  • Recibe &str / &[T]; devuelve iteradores en lugar de Vec ya recogidos cuando quien llama solo va a iterar.
  • Evita .clone() y .to_string() en los caminos críticos; Cow cuando clonar solo hace falta a veces.
  • SmallVec / ArrayVec para colecciones que casi siempre son diminutas; Box<str> / Arc<str> para cadenas inmutables; arenas (bumpalo) para muchos objetos de vida corta.
  • Un asignador global distinto (mimalloc, jemalloc) puede ayudar a los programas multihilo con muchas reservas.

Disposición de los datos

El cuello de botella suele ser la memoria, no la aritmética. Un fallo de caché cuesta del orden de cien instrucciones simples.

  • Lo contiguo gana a lo enlazado. Vec<T> antes que LinkedList<T>; índices dentro de un Vec antes que nodos en Box.
  • Más pequeño es más rápido. Comprueba std::mem::size_of. Usa índices u32 en lugar de usize o de punteros donde los rangos lo permitan; mete en un Box la variante grande y poco frecuente de un enum para que las habituales sigan siendo pequeñas.
  • Struct de arrays. Si un bucle toca un solo campo de muchos registros, guardar cada campo en su propio Vec mantiene la caché llena de datos útiles.
  • Mapas hash. La función hash por defecto (SipHash) resiste los ataques por colisiones y es lenta con claves pequeñas. Cuando las claves no las controla un atacante, rustc-hash o ahash son varias veces más rápidos. Un Vec ordenado más búsqueda binaria suele ganar a un mapa en conjuntos pequeños que casi solo se leen.
use std::mem::size_of;

enum Wasteful { Small(u8), Huge([u64; 32]) }
enum Lean { Small(u8), Huge(Box<[u64; 32]>) }

fn main() {
    println!("Wasteful: {} bytes per value", size_of::<Wasteful>());
    println!("Lean:     {} bytes per value", size_of::<Lean>());
    println!("Option<Box<u8>>: {} (niche optimisation: no extra tag)", size_of::<Option<Box<u8>>>());
}

Ayudar al optimizador

  • Comprobaciones de límites. Los iteradores no tienen ninguna. En los bucles con índice, tomar una sola vez un slice de longitud conocida (let xs = &xs[..n];) o usar chunks_exact, zip y windows permite a LLVM demostrar que los índices están dentro del rango. Recurre a get_unchecked solo con un perfil en la mano.
  • Inlining. Las funciones pequeñas se expanden en línea automáticamente dentro de un crate. Entre crates, las funciones genéricas siempre son candidatas; las no genéricas necesitan #[inline] o LTO. #[inline(never)] y #[cold] en los caminos de error mantienen compacto el código crítico.
  • Monomorfización frente a despacho. Los genéricos son lo más rápido pero duplican código; un envoltorio genérico fino alrededor de una función interna no genérica da ergonomía sin abultar.
  • Autovectorización. Los bucles simples sobre slices, sin salidas anticipadas ni comprobaciones de límites, se vectorizan. Inspecciona el resultado en Compiler Explorer o con cargo asm.
  • SIMD explícito. std::arch expone las instrucciones intrínsecas detrás de #[target_feature] con detección en tiempo de ejecución (is_x86_feature_detected!); std::simd es la API portable (nightly), y crates como wide funcionan en estable.

Configuración de la compilación

[profile.release]
opt-level = 3        # "s" o "z" para optimizar el tamaño
lto = "fat"          # optimización de todo el programa; "thin" es casi igual de buena y compila más rápido
codegen-units = 1    # mejor optimización, compilación más lenta
panic = "abort"      # binario más pequeño, sin tablas para deshacer la pila
strip = true

Poner RUSTFLAGS="-C target-cpu=native" permite al compilador usar todas las instrucciones que tiene tu máquina, al precio de un binario que puede no ejecutarse en otra. La optimización guiada por perfiles (cargo pgo) devuelve al compilador perfiles de ejecución reales, y en programas grandes suele valer un 10–20 %.

Ejercicios

  1. Escribe tres versiones de «contar las palabras distintas de un texto grande» —HashSet<String>, HashSet<&str> y ordenar y deduplicar un Vec<&str>— y mídelas con Criterion.
  2. Haz un perfil de tu minigrep del nivel 2 sobre un archivo grande con cargo flamegraph. ¿Adónde va el tiempo? Elimina una reserva por línea.
  3. Toma un struct con los campos (u8, u64, u8, u32, u16). Predice su tamaño con y sin #[repr(C)], y después compruébalo.
  4. Escribe un producto escalar sobre dos &[f32] con un bucle con índice y con zip. Compara el ensamblador en cuanto a comprobaciones de límites y vectorización.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Cuál es el primer paso para hacer más rápido un programa?

  2. 2.¿Por qué un Vec<Struct> suele recorrerse más rápido que un Vec<Box<Struct>>?

  3. 3.¿Por qué un benchmark debe pasar las entradas y las salidas por std::hint::black_box?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?