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
- Decide qué importa —latencia, caudal, memoria, tamaño del binario, tiempo de compilación— y cómo lo vas a medir.
- 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. - Mide una línea base con un benchmark repetible.
- Haz un perfil para encontrar adónde va el tiempo.
- 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_capacitycuando 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 deVecya recogidos cuando quien llama solo va a iterar. - Evita
.clone()y.to_string()en los caminos críticos;Cowcuando clonar solo hace falta a veces. SmallVec/ArrayVecpara 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 queLinkedList<T>; índices dentro de unVecantes que nodos enBox. - Más pequeño es más rápido. Comprueba
std::mem::size_of. Usa índicesu32en lugar deusizeo de punteros donde los rangos lo permitan; mete en unBoxla 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
Vecmantiene 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-hashoahashson varias veces más rápidos. UnVecordenado 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 usarchunks_exact,zipywindowspermite a LLVM demostrar que los índices están dentro del rango. Recurre aget_uncheckedsolo 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::archexpone las instrucciones intrínsecas detrás de#[target_feature]con detección en tiempo de ejecución (is_x86_feature_detected!);std::simdes la API portable (nightly), y crates comowidefuncionan 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
- Escribe tres versiones de «contar las palabras distintas de un texto grande» —
HashSet<String>,HashSet<&str>y ordenar y deduplicar unVec<&str>— y mídelas con Criterion. - Haz un perfil de tu
minigrepdel nivel 2 sobre un archivo grande concargo flamegraph. ¿Adónde va el tiempo? Elimina una reserva por línea. - 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. - Escribe un producto escalar sobre dos
&[f32]con un bucle con índice y conzip. 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.¿Cuál es el primer paso para hacer más rápido un programa?
2.¿Por qué un
Vec<Struct>suele recorrerse más rápido que unVec<Box<Struct>>?3.¿Por qué un benchmark debe pasar las entradas y las salidas por
std::hint::black_box?