FerrousPath

Nivel 4 · Experto· Lección 1 de 9 · 35 min

Layout de memoria y representación

Tamaño, alineación y relleno, nichos, punteros gordos, tipos de tamaño dinámico y de tamaño cero, memoria sin inicializar y los atributos repr.

Para escribir y auditar código unsafe necesitas un modelo exacto de cómo se representan los valores. Esta lección es ese modelo.

Tamaño y alineación

Todo tipo tiene un tamaño (los bytes que ocupa) y una alineación (su dirección debe ser múltiplo de esa potencia de dos). El tamaño es siempre múltiplo de la alineación, así que los arrays no necesitan huecos entre elementos. Los campos de un struct se separan con relleno (padding) donde hace falta.

use std::mem::{align_of, size_of};

struct A { a: u8, b: u32, c: u16 }

#[repr(C)]
struct B { a: u8, b: u32, c: u16 }

#[repr(C, packed)]
struct C { a: u8, b: u32, c: u16 }

#[repr(align(64))]
struct CacheLine([u8; 8]);

fn main() {
    println!("default  A: size {:2} align {}", size_of::<A>(), align_of::<A>());
    println!("repr(C)  B: size {:2} align {}", size_of::<B>(), align_of::<B>());
    println!("packed   C: size {:2} align {}", size_of::<C>(), align_of::<C>());
    println!("align(64)  : size {:2} align {}", size_of::<CacheLine>(), align_of::<CacheLine>());
}
  • Por defecto (repr(Rust)): el orden de los campos no está especificado. El compilador los reordena para reducir el relleno (8 bytes para A) y puede cambiar de estrategia entre versiones. Nunca dependas de él.
  • repr(C): orden de declaración y reglas de relleno de C (12 bytes). Necesario para FFI y para cualquier código que razone sobre los desplazamientos de los campos.
  • repr(packed): sin relleno, alineación 1. Los campos pueden quedar mal alineados, y crear una referencia a un campo mal alineado es UB: léelos por valor o con &raw const y read_unaligned.
  • repr(align(N)): aumenta la alineación, por ejemplo para mantener dos atómicos en líneas de caché separadas y evitar el false sharing.
  • repr(transparent): un envoltorio de un solo campo con la garantía de tener el layout y la ABI de su campo: la base de las conversiones seguras entre un newtype y su contenido.
  • repr(u8), repr(i32)… en un enum fijan el tipo del discriminante.

Nichos y layout de los enums

Un nicho es un patrón de bits que no es un valor válido de un tipo. El compilador guarda los discriminantes de los enums en los nichos del contenido cuando puede.

use std::mem::size_of;
use std::num::NonZeroU32;
use std::ptr::NonNull;

enum Three { A, B, C }

fn main() {
    println!("&u8                 {}", size_of::<&u8>());
    println!("Option<&u8>         {}", size_of::<Option<&u8>>());
    println!("Option<Box<u8>>     {}", size_of::<Option<Box<u8>>>());
    println!("Option<NonNull<u8>> {}", size_of::<Option<NonNull<u8>>>());
    println!("u32 / Option<u32>   {} / {}", size_of::<u32>(), size_of::<Option<u32>>());
    println!("Option<NonZeroU32>  {}", size_of::<Option<NonZeroU32>>());
    println!("bool / Option<bool> {} / {}", size_of::<bool>(), size_of::<Option<bool>>());
    println!("Option<Option<bool>> {}", size_of::<Option<Option<bool>>>());
    println!("Three / Option<Three> {} / {}", size_of::<Three>(), size_of::<Option<Three>>());
    println!("Option<Vec<u8>>     {} (same as Vec<u8>: {})", size_of::<Option<Vec<u8>>>(), size_of::<Vec<u8>>());
}

Las referencias y Box nunca son nulos; bool usa 2 de los 256 patrones; char deja libre el rango de los surrogates y todo lo que queda por encima de 0x10FFFF. La optimización del puntero nulo para Option<&T>, Option<Box<T>>, Option<NonNull<T>>, Option<NonZero…> y Option<fn()> está garantizada; los demás usos de nichos son una optimización que puedes observar, pero de la que no puedes depender.

Esta es también la razón de que los valores inválidos sean UB: transmute::<u8, bool>(2) crea un valor que un Option<bool> que lo contenga podría leer como None.

Punteros gordos y tipos de tamaño dinámico

Un tipo de tamaño dinámico (DST, dynamically sized type) tiene un tamaño que solo se conoce en tiempo de ejecución: [T], str y dyn Trait. Los DST solo pueden usarse detrás de un puntero, y ese puntero es gordo (fat pointer): lleva metadatos.

use std::mem::{size_of, size_of_val};

trait Speak { fn speak(&self) -> String; }
impl Speak for u8 { fn speak(&self) -> String { format!("u8 {self}") } }
impl Speak for [u64; 4] { fn speak(&self) -> String { "array".into() } }

fn main() {
    println!("&u8 {}  &[u8] {}  &str {}  &dyn Speak {}",
        size_of::<&u8>(), size_of::<&[u8]>(), size_of::<&str>(), size_of::<&dyn Speak>());

    let slice: &[u16] = &[1, 2, 3];
    let a: &dyn Speak = &7u8;
    let b: &dyn Speak = &[0u64; 4];
    // size_of_val lee los metadatos: la longitud en los slices, la vtable en los trait objects.
    println!("{} {} {}", size_of_val(slice), size_of_val(a), size_of_val(b));
    println!("{} / {}", a.speak(), b.speak());
}

Todo parámetro genérico tiene una restricción implícita T: Sized. T: ?Sized la quita, y así es como Box<T>, &T y Rc<T> aceptan str y dyn Trait. Un struct puede tener un DST como último campo, lo que convierte al propio struct en un DST.

Tipos de tamaño cero

Los tipos de tamaño 0 (ZST, zero-sized types) —(), struct Marker;, [T; 0], PhantomData<T>— son tipos reales con exactamente un valor y sin representación en tiempo de ejecución. El compilador elimina todas las operaciones sobre ellos.

use std::collections::HashMap;
use std::mem::size_of;

struct Token;

fn main() {
    println!("{} {} {}", size_of::<()>(), size_of::<Token>(), size_of::<[u64; 0]>());

    // HashSet<K> es literalmente HashMap<K, ()>: los valores no ocupan nada.
    let mut set: HashMap<&str, ()> = HashMap::new();
    set.insert("a", ());

    // Un Vec de ZST nunca reserva memoria; es solo un contador.
    let mut v = Vec::new();
    for _ in 0..1_000_000 { v.push(Token); }
    println!("len {} capacity {}", v.len(), v.capacity());
}

El código unsafe debe tratar los ZST de forma deliberada: la aritmética de punteros sobre ellos no hace nada, reservar cero bytes no está permitido a través de alloc, y un «puntero a un ZST» es cualquier dirección no nula y alineada: NonNull::dangling().

Memoria sin inicializar

La memoria en la que no se ha escrito no son «bits aleatorios». Es un estado distinto, y leerla con un tipo que exige datos inicializados —enteros, referencias, bool— es comportamiento indefinido. MaybeUninit<T> es el tipo para el almacenamiento que quizá todavía no contiene un T válido:

use std::mem::MaybeUninit;

fn squares<const N: usize>() -> [u64; N] {
    let mut out: [MaybeUninit<u64>; N] = [const { MaybeUninit::uninit() }; N];
    for (i, slot) in out.iter_mut().enumerate() {
        slot.write((i * i) as u64); // write no lee ni libera el contenido anterior
    }
    // SAFETY: el bucle de arriba inicializó todos los elementos.
    out.map(|slot| unsafe { slot.assume_init() })
}

fn main() {
    println!("{:?}", squares::<6>());
}

Reglas: escribe a través de MaybeUninit::write o de un puntero crudo con ptr.write(v), nunca con *ptr = v (la asignación libera el «valor anterior», que es basura). Los bytes de relleno están siempre sin inicializar, y por eso no puedes ver un struct arbitrario como &[u8].

Invariantes de validez frente a invariantes de seguridad

A un tipo se le aplican dos clases distintas de reglas:

  • El invariante de validez debe cumplirse siempre que exista un valor del tipo, aunque sea por un instante dentro de código unsafe. Violarlo es UB inmediato. Ejemplos: un bool es 0 o 1; una referencia es no nula, está alineada y se puede desreferenciar; un Box no es nulo.
  • El invariante de seguridad es lo que el código seguro puede dar por supuesto. El código unsafe puede romperlo temporalmente dentro de un módulo, siempre que el código seguro nunca observe la rotura. Ejemplos: los bytes de un String son UTF-8; el len de un Vec es como máximo su capacidad.

Un Vec con len > capacity es una violación de seguridad que solo se convierte en UB cuando alguna operación posterior actúa sobre él. Un &T nulo es UB en el momento en que se crea.

Transmutación y reinterpretación de tipos

mem::transmute reinterpreta los bits de un tipo como otro del mismo tamaño. Es la función más peligrosa del lenguaje; casi todos sus usos tienen una alternativa mejor:

Objetivo Usa
Bits de entero ↔ flotante f32::to_bits, f32::from_bits
Entero ↔ bytes to_le_bytes, from_be_bytes…
Puntero ↔ entero ptr.addr(), ptr.expose_provenance(), with_addr
Slice de datos simples ↔ bytes los crates bytemuck o zerocopy, que comprueban los requisitos
Envoltorio ↔ tipo interior #[repr(transparent)] y una conversión de punteros

Ejercicios

  1. Sin ejecutarlo, calcula el tamaño y la alineación de #[repr(C)] struct S { a: u8, b: u64, c: u8, d: u32, e: u16 }. Reordena los campos para minimizar el tamaño y compruébalo con size_of.
  2. Diseña un #[repr(u8)] enum para un valor de tres estados y un Option de él. ¿Qué tamaños obtienes? ¿Puedes encontrar el valor del nicho con un transmute a u8? (Imprímelo; no dependas de él.)
  3. Escribe fn as_bytes<T: Copy>(x: &T) -> &[u8]. Explica por qué es incorrecta (unsound) para (u8, u32) y nombra la propiedad que necesitaría T.
  4. Implementa un ArrayVec<T, const N: usize> de capacidad fija respaldado por [MaybeUninit<T>; N], con push, pop y un Drop correcto.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Por qué size_of::<Option<&T>>() es igual a size_of::<&T>()?

  2. 2.¿De qué consta un &[T] en tiempo de ejecución?

  3. 3.¿Es comportamiento indefinido let x: u32 = unsafe { MaybeUninit::uninit().assume_init() };?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?