Especialización: cómo el compilador convierte un genérico en código concreto

Un genérico de Swift no es una plantilla que se expande siempre ni una función que siempre indirecciona: es las dos cosas según lo que el compilador pueda demostrar. Entender cuándo genera una copia concreta para cada tipo —y cuándo no puede— es la diferencia entre escribir abstracciones que cuestan cero y escribir abstracciones que cuestan una llamada indirecta por operación en el camino caliente.

Dos maneras de ejecutar un genérico

Sin especializar, una función genérica se compila una sola vez y funciona con cualquier tipo mediante indirección. El valor se maneja a través de su dirección, con un tamaño y una alineación desconocidos en compilación, y cada operación pasa por dos estructuras de metadatos.

La especialización elimina las dos tablas. El optimizador clona el cuerpo sustituyendo el parámetro por el tipo real, y a partir de ahí todo el arsenal habitual se vuelve aplicable: propagación de constantes, desenrollado, vectorización, eliminación de retención y liberación. El resultado suele ser idéntico al de haber escrito la función a mano para ese tipo.

func sumar<T: Numeric>(_ xs: [T]) -> T {
    var acc = T.zero
    for x in xs { acc += x }
    return acc
}

let total = sumar([1, 2, 3])   // el optimizador genera sumar especializada para Int

flowchart LR
A[Funcion generica en el fuente] --> B[El optimizador ve el cuerpo y el tipo concreto]
B -->|si| C[Clon especializado por tipo]
B -->|no| D[Version generica con tablas de testigos]
C --> E[Inlining, registros, sin indireccion]
D --> F[Indireccion por puntero y salto por tabla]
style C fill:#a6e3a1,color:#11111b
style D fill:#f9e2af,color:#11111b

Cuándo especializa y cuándo no puede

La regla operativa es simple: el optimizador necesita ver el cuerpo de la función genérica y conocer el tipo concreto en el punto de llamada, a la vez, dentro de la misma unidad de optimización.

• Dentro del mismo módulo con optimización de módulo completo, es lo normal. El compilador ve todo y especializa con agresividad.
• Con compilación incremental por archivo y sin optimización, no. En modo de depuración casi nada se especializa, y por eso las mediciones en debug no dicen nada útil.
• Cruzando el límite de módulo, el cuerpo no viaja con la interfaz. La solución es marcar la función como inlinable, lo que serializa su cuerpo en el módulo y permite que el consumidor la especialice, a cambio de congelar la implementación como parte del contrato público.

@inlinable
public func sumar<T: Numeric>(_ xs: [T]) -> T {
    var acc = T.zero
    for x in xs { acc += x }
    return acc
}

Si el cuerpo llama a algo interno, ese algo debe exponerse con la anotación correspondiente para que siga siendo visible desde fuera. Existen además directivas para pedir versiones especializadas concretas por adelantado, útiles cuando conoces de antemano los tipos que van a dominar en tus consumidores.

Hay un tercer factor que suele pasarse por alto: la forma del genérico. El optimizador especializa con más facilidad cuerpos pequeños y sin recursión sobre el propio parámetro, y se rinde antes ante funciones enormes o cadenas de llamadas profundas cuyo coste de clonado no compensa su heurística. Partir un genérico gigante en varias funciones pequeñas suele habilitar la especialización que el monolito bloqueaba.

Qué se gana y cómo medirlo

Los números dependen del cuerpo, del tipo y de la carga, así que la única respuesta honesta es medir. Tres herramientas bastan para tener certeza en lugar de fe.

1. Inspeccionar el binario. Buscar en la tabla de símbolos los nombres decorados de las especializaciones te dice si el clon existe. Un nombre desdecodificado que menciona el tipo concreto es la prueba de que ocurrió.
2. Leer la representación intermedia. Emitir el código intermedio optimizado muestra si la llamada quedó como salto directo o como acceso a tabla de testigos.
3. Medir con un banco de pruebas honesto. Compilando en modo de publicación, con datos que no puedan constantizarse y con un consumo del resultado que impida que el optimizador borre el bucle entero.

# Compilar con optimizacion de modulo completo
swiftc -O -whole-module-optimization Fuente.swift -o binario

# Buscar la especializacion en la tabla de simbolos y desdecodificar el nombre
nm binario | swift demangle | grep -i "specialized"

# Ver la representacion intermedia optimizada
swiftc -O -emit-sil Fuente.swift | grep -A5 "sumar"

El patrón de ganancia habitual: en operaciones aritméticas o de acceso a memoria sobre tipos de valor pequeños, la versión especializada elimina retenciones, permite mantener el acumulador en un registro y abre la puerta a la vectorización. En operaciones que ya son caras por sí mismas —red, cadenas complejas, asignación de memoria— la indirección se diluye y la diferencia deja de ser medible.

El precio de la copia

La especialización no es gratis y por eso el compilador aplica heurísticas en lugar de clonarlo todo.

• Tamaño de binario. Cada instanciación es código nuevo. Un genérico usado con veinte tipos concretos puede multiplicar por veinte su contribución al ejecutable, con el efecto colateral de más presión sobre la caché de instrucciones.
• Tiempo de compilación. Clonar y optimizar cada variante cuesta, y la optimización de módulo completo sacrifica la compilación incremental.
• Estabilidad de la interfaz. Marcar una función como inlinable convierte su cuerpo en parte del contrato: cambiarlo afecta a binarios ya compilados contra la versión anterior.

La lectura de diseño es clara. Escribe genéricos con naturalidad y deja que el optimizador decida; interviene solo con datos delante, en las funciones que el perfilado señale, y prefiere reducir el trabajo algorítmico antes que forzar clones.

Hay además una jerarquía de decisiones que conviene tener ordenada antes de tocar una sola anotación:

1. Confirma que el punto importa. Un perfilado real, no una corazonada. La mayoría de los genéricos de una app nunca aparecen en el perfil.
2. Comprueba si ya está especializado. Muy a menudo el optimizador ya hizo el trabajo y la anotación no cambiaría nada salvo el tamaño del binario.
3. Revisa la forma antes que la representación. Un existencial en un bucle caliente, una conversión repetida o una asignación por iteración cuestan más que la indirección genérica.
4. Solo entonces expón el cuerpo. Y asume conscientemente el compromiso de estabilidad que implica hacerlo en una interfaz pública.