Políticas de asignación NUMA: local, bind e interleave

Saber que la memoria remota es lenta (26.1) no sirve de nada si el kernel asigna páginas al azar. La estrategia por defecto es sencilla y potente: dar a cada quien memoria de su propio nodo. Pero no siempre es lo óptimo —una tabla enorme leída por todos los núcleos rinde mejor repartida— así que Linux ofrece un menú de políticas de asignación NUMA, y además un motor que corrige errores en caliente migrando páginas hacia el nodo que de verdad las toca.

El menú de políticas

Una política de memoria (struct mempolicy, en mm/mempolicy.c) responde a una pregunta: cuando haga falta una página, ¿de qué nodo la saco? Linux define varias, aplicables por proceso, por hilo o por rango de direcciones:

• MPOL_DEFAULT: asigna en el nodo local del núcleo que ejecuta la falta de página. Es la política por defecto y casi siempre la correcta.
• MPOL_BIND: restringe la asignación a un conjunto de nodos concreto; si no hay memoria allí, se recupera o falla, pero no se sale del conjunto.
• MPOL_INTERLEAVE: reparte las páginas en round-robin entre un conjunto de nodos, página a página. Sacrifica localidad por ancho de banda agregado y latencia predecible.
• MPOL_PREFERRED: prefiere un nodo pero cae a otros si hace falta (una preferencia blanda, no una restricción).
• MPOL_PREFERRED_MANY: prefiere un conjunto de nodos con caída elegante al resto.
• MPOL_WEIGHTED_INTERLEAVE: interleave ponderado, reparte más páginas a los nodos con más ancho de banda. Clave para memoria por niveles.

Desde el espacio de usuario se fijan con las syscalls set_mempolicy, mbind (por rango) y get_mempolicy, o cómodamente con numactl y libnuma:

# Repartir la memoria de un proceso entre todos los nodos
numactl --interleave=all ./mi_servidor

# Anclar CPU y memoria al nodo 1: maxima localidad
numactl --cpunodebind=1 --membind=1 ./trabajo_hpc

/* Equivalente con libnuma dentro de un programa */
#include <numa.h>
#include <numaif.h>

struct bitmask *nodos = numa_allocate_nodemask();
numa_bitmask_setall(nodos);                    /* todos los nodos */
set_mempolicy(MPOL_INTERLEAVE, nodos->maskp, nodos->size + 1);

Asignar consciente del nodo desde el kernel

Dentro del kernel, el asignador de páginas consulta la política de la tarea de forma transparente: alloc_pages(gfp, order) mira current y sirve del nodo que la política indique. Cuando quieres control explícito, pides un nodo concreto:

#include <linux/gfp.h>
#include <linux/slab.h>

/* Asigna en el nodo del nucleo actual: el patron local por defecto */
struct page *p = alloc_pages_node(numa_node_id(), GFP_KERNEL, 0);

/* Estructura pegada al hardware que la usara: cerca del dispositivo */
struct ctx *c = kmalloc_node(sizeof(*c), GFP_KERNEL, dev_to_node(dev));

/* Una slab-cache sirviendo del nodo pedido */
void *obj = kmem_cache_alloc_node(cache, GFP_KERNEL, cpu_to_node(cpu));

La familia *_node (alloc_pages_node, kmalloc_node, vmalloc_node, kmem_cache_alloc_node) es la manera del kernel de decir “quiero esta memoria aquí”. Un driver la usa para colocar sus estructuras en el nodo del dispositivo PCIe; el planificador, para poner la pila de un hilo en su nodo. El flag __GFP_THISNODE endurece la petición: exige ese nodo sin caer a la zonelist de respaldo, fallando antes que asignar remoto.

flowchart TD
A[Falta de pagina] --> B{Politica vigente de la tarea}
B -->|local| L[Asigna en el nodo del nucleo actual]
B -->|bind| K[Restringe al conjunto de nodos fijado]
B -->|interleave| R[Reparte pagina a pagina entre nodos]
B -->|preferred| P[Prefiere un nodo y cae a vecinos]
style L fill:#a6e3a1,color:#11111b
style R fill:#89b4fa,color:#11111b

AutoNUMA: corregir la colocación en caliente

Las políticas estáticas fallan cuando el patrón de acceso cambia o cuando el planificador migra un hilo a otro nodo, dejando sus datos lejos. Para eso existe el balanceo automático de NUMA (AutoNUMA), gobernado por CONFIG_NUMA_BALANCING:

# 1 = activo. El kernel muestrea, detecta accesos remotos y migra
sysctl kernel.numa_balancing
cat /proc/sys/kernel/numa_balancing_scan_period_min_ms

El mecanismo es astuto: periódicamente el kernel desmapea páginas del proceso marcándolas como PROT_NONE (un “hint fault”). Cuando el hilo las vuelve a tocar, la falta de página revela qué núcleo, en qué nodo, accede a cada página. Con esa telemetría, task_numa_fault decide dos cosas: migrar la página hacia el nodo del hilo, o migrar el hilo hacia el nodo de sus páginas, buscando que datos y cómputo converjan. Es un lazo de realimentación que persigue la localidad sin que el programador anote nada.

Memoria por niveles: el interleave ponderado

En 2026 la topología ya no es solo “sockets con DRAM”. Con CXL, una máquina tiene niveles de memoria: DRAM rápida cerca de la CPU y memoria CXL más lenta pero abundante, cada nivel como un nodo NUMA. El kernel modela esto en mm/memory-tiers.c y aplica promoción (subir páginas calientes a DRAM) y democión (bajar frías a CXL). Ahí brilla MPOL_WEIGHTED_INTERLEAVE: repartir proporcional al ancho de banda de cada nivel, no a partes iguales.

# Pesos de interleave por nodo, para memoria por niveles
cat /sys/kernel/mm/mempolicy/weighted_interleave/node0
echo 3 > /sys/kernel/mm/mempolicy/weighted_interleave/node0
echo 1 > /sys/kernel/mm/mempolicy/weighted_interleave/node1