El kernel de Linux 7.4 incorporará una función, cmpxchg_emu_u16(), que emula la operación atómica de comparar e intercambiar sobre dos bytes en las arquitecturas que no la tienen como instrucción nativa. El cambio lo ha enviado Paul E. McKenney, uno de los desarrolladores veteranos del kernel, y afecta a cuatro arquitecturas minoritarias: SH, ARC, C-SKY y Xtensa. En el mismo mensaje, McKenney deja caer que algunos sistemas que Linux todavía soporta podrían dejar de estarlo pronto.
Las claves de la emulación de cmpxchg de dos bytes en Linux 7.4 en 30 segundos
- Linux 7.4 añade
cmpxchg_emu_u16(), que resuelve uncmpxchg()de dos bytes usando uno de cuatro. - Se aplica a SH, ARC, C-SKY y Xtensa, que no tienen instrucción nativa para esa operación.
- Así, el código común del kernel podrá dar por hecho que el cmpxchg de dos bytes funciona en todas las arquitecturas.
- Amplía la emulación de un byte que el propio McKenney introdujo en 2024.
- McKenney cree que algunos sistemas sin almacenamiento nativo de dos bytes pronto dejarán de tener soporte en Linux.
Es un cambio de fontanería, de los que no notan los administradores en el día a día, pero ilustra cómo se mantiene un kernel que corre en decenas de arquitecturas distintas: o se emula en software lo que el hardware no ofrece, o se deja de dar soporte a ese hardware. Linux 7.4 hace lo primero y anticipa lo segundo.
Qué es cmpxchg y por qué importa el tamaño
cmpxchg() (compare and exchange) es una de las operaciones atómicas básicas del kernel. Compara el valor de una posición de memoria con uno esperado y, solo si coinciden, lo sustituye por otro, todo en un único paso que ningún otro procesador puede interrumpir. Sobre ella se construyen cerrojos, contadores y estructuras de datos sin bloqueos, así que está presente en buena parte del código que gestiona la concurrencia.
La mayoría de las arquitecturas modernas ofrecen esta operación para varios tamaños: uno, dos, cuatro y ocho bytes. Algunas solo la tienen para cuatro bytes o más. En esos casos, el código común del kernel no puede usar un cmpxchg de dos bytes sin que el programador compruebe antes en qué arquitectura se va a ejecutar, algo que complica el mantenimiento y provoca errores difíciles de detectar.
Cómo funciona la emulación
La técnica ya existe para un byte. En 2024, McKenney añadió al kernel cmpxchg_emu_u8(), en el archivo lib/cmpxchg-emu.c, para que el código común pudiera usar cmpxchg de un byte en arquitecturas sin soporte nativo. El método consiste en localizar la palabra de cuatro bytes alineada que contiene el byte de interés, leerla, construir una nueva palabra con solo ese byte cambiado e intentar un cmpxchg de cuatro bytes sobre ella. Si otro procesador ha modificado la palabra entretanto, el intento falla y se repite con el valor nuevo.
cmpxchg_emu_u16() aplica la misma idea a valores de dos bytes. En palabras de McKenney, los cambios emulan el cmpxchg de dos bytes «en términos del cmpxchg de cuatro bytes» en las arquitecturas que no tienen instrucciones nativas para ello. El precio es algo de rendimiento: una operación que en otras CPU es una sola instrucción se convierte aquí en un pequeño bucle. Como afecta a arquitecturas poco usadas en servidores, el coste práctico es limitado.
La consecuencia más relevante es para los desarrolladores. Con esta emulación, el código común del kernel puede asumir que el cmpxchg de dos bytes es seguro en todas partes, sin ramas especiales por arquitectura. Es el mismo enfoque que se siguió con el de un byte.
Las arquitecturas afectadas y el aviso de McKenney
SH (SuperH), ARC, C-SKY y Xtensa son arquitecturas que hoy se usan sobre todo en sistemas embebidos y microcontroladores, con poca o ninguna presencia en servidores. C-SKY, una arquitectura china de 32 bits, entró en el kernel en 2018. Entonces algunos desarrolladores comentaron que, con la convergencia hacia RISC-V, podría ser la última vez que hiciera falta incorporar una arquitectura nueva, una previsión que no se cumplió del todo: LoongArch llegó en 2022.
El matiz más llamativo del envío está al final. McKenney señala que algunos sistemas que Linux todavía soporta ni siquiera tienen instrucciones nativas para almacenar dos bytes, y que «hay motivos para creer que estos sistemas pronto dejarán de tener soporte en Linux». No concreta cuáles son ni cuándo ocurriría, así que de momento es una previsión, no una decisión. Encaja, eso sí, con la tendencia de los últimos años a retirar del kernel arquitecturas y procesadores antiguos que casi nadie usa y que complican el mantenimiento del código común. Quien siga la evolución del kernel puede ver también propuestas como Multikernel, que quiere ejecutar varios kernels de Linux en un servidor sin hipervisor.
Preguntas frecuentes
¿Qué es cmpxchg_emu_u16 en Linux 7.4?
Es una función que emula la operación atómica cmpxchg de dos bytes usando un cmpxchg de cuatro bytes en arquitecturas que no la soportan de forma nativa.
¿Qué arquitecturas usan la emulación de dos bytes?
SH, ARC, C-SKY y Xtensa, según el envío de Paul E. McKenney recogido por Phoronix.
¿Afecta al rendimiento de servidores x86 o Arm?
No. Esas arquitecturas tienen instrucciones nativas para el cmpxchg de dos bytes; la emulación solo se usa donde no existen.
¿Qué sistemas dejará de soportar Linux?
McKenney cree que algunos sistemas sin almacenamiento nativo de dos bytes dejarán de tener soporte pronto, pero no los ha concretado ni hay una decisión tomada.
Fuentes:
