Convertir GiB a B

Un gibibyte son 1.073.741.824 bytes, alrededor de un 7 % más que un gigabyte. Windows mide en gibibytes pero los etiqueta «GB», y en eso consiste todo el misterio del espacio que desaparece.

Un byte son ocho bits, cosa que no siempre estuvo clara: los primeros ordenadores usaron seis, siete o nueve. Se impuso el ocho porque en él cabe un carácter y porque la cifra se parte en mitades limpias.

En este sentido la cuenta es una multiplicación, y por un número entero: un gibibyte son 1.073.741.824 bytes, exactamente, y 1.073.741.824 es la definición, no una medición que se quedó cerca.

Eso convierte esta en una de las pocas conversiones que merece la pena hacer de cabeza, y hace que el resultado se pueda comprobar: divide de vuelta y tienes que caer en el número de partida, exacto y sin resto que justificar.

Un GiB son 1.024 de la unidad de debajo; un GB, 1.000. En esta página eso es la diferencia entre 1073741824 B y 1000000000 B —un 7,4 %—, y la distancia crece en cada escalón: por eso es un redondeo despreciable en una foto y un trozo visible de un disco duro.

En eso consiste entero el misterio del espacio que falta, y en esta página vale un 7,4 %. Un disco vendido en GB tiene exactamente lo que dice la etiqueta; lo que pasa después es que Windows divide entre 1.024 en vez de entre 1.000, conserva el nombre decimal y muestra 1000000000 B donde la caja ponía 1073741824 B. macOS cuenta estas cifras en unidades decimales desde 10.6, y por eso el mismo disco puede parecer de dos tamaños en dos ordenadores: no falta nada ni redondea nadie, son los mismos bytes con dos nombres.

Un gibibyte son 1.073.741.824 bytes, es decir 2³⁰, y ese es el número entero que espera cualquier ajuste documentado «en bytes»: el tamaño de parte de una subida por trozos, el límite de cuerpo de una petición, el búfer de una base de datos, una cuota en una llamada a la API. La multiplicación es exacta y no redondea nada, porque las dos unidades son recuentos definidos de bytes y no medidas de nada.

Conviene además por una razón que no es de comodidad. Lo que hay debajo de ese límite —páginas de memoria, tamaños de bloque, reservas del asignador, rangos de direcciones— ya está construido sobre potencias de dos, así que un tope de 1.000.000.000 queda encajado entre dos fronteras naturales y uno de 1.073.741.824 cae justo encima de una. Por eso las herramientas que aceptan un sufijo lo expanden de esa manera.

Los valores de tamaño de PHP se escriben con una letra al final y esa letra es binaria: 1K son 1.024 bytes, 1M son 1.048.576 y 1G son 1.073.741.824. De modo que un memory_limit de 512M reserva 536.870.912 bytes y no quinientos doce millones, y un upload_max_filesize de 2M admite 2.097.152. La diferencia es pequeña en esas magnitudes y deja de serlo en cuanto alguien escribe una G.

El fallo clásico de WordPress vive justo ahí. El tamaño máximo que muestra el escritorio no sale de un único ajuste, sino del menor entre upload_max_filesize y post_max_size, y la memoria disponible puede recortarlo todavía más. Subir el primero y olvidar el segundo deja el límite exactamente donde estaba, y el mensaje de error no menciona ninguno de los dos.

El convenio de casi todo el instrumental de sistemas es que una k, una m o una g sueltas valen 1.024, 1.048.576 y 1.073.741.824. Así funcionan las banderas de montículo de la máquina virtual de Java, de modo que -Xmx4g reserva 4.294.967.296 bytes; así funcionan los límites de memoria y de almacenamiento de Docker, y así las directivas de recursos de systemd y los tamaños de nginx. Ninguna lo advierte: la letra parece un prefijo del sistema internacional y se comporta como uno binario.

Las coreutils de GNU aceptan las dos formas con una regla fácil de enunciar y fácil de olvidar: una letra sola es binaria y la forma de dos letras terminada en B es decimal. dd bs=1G copia en bloques de 1.073.741.824 bytes y dd bs=1GB en bloques de mil millones. Las dos órdenes se distinguen por un carácter en el historial del intérprete y difieren un siete por ciento en cada bloque que mueven.

Las cantidades de recursos de Kubernetes llevan la distinción en su propia sintaxis. El sufijo Gi es binario, así que 1Gi son 1.073.741.824 bytes; el sufijo G sin la i es decimal y vale mil millones. Lo mismo ocurre en cada escalón —Ki frente a k, Mi frente a M, Ti frente a T— y el manifiesto significa exactamente lo que dice sin ningún convenio que haya que ir a consultar.

Esa claridad tiene filo. Un límite de memoria escrito 4G en lugar de 4Gi son 294.967.296 bytes menos, alrededor de un siete por ciento, y no hay revisión de código que lo vea. Donde una carga trabaja cerca de su techo, esa letra que falta es la diferencia entre un pod que aguanta y un pod que el nodo termina en el peor momento del día.

Un puñado de recuentos de bytes reaparece una y otra vez en mensajes de error y en campos de límite, y reconocerlos ahorra la conversión. 1.048.576 es un mebibyte; 1.073.741.824, un gibibyte; 2.147.483.648, dos de ellos; y 4.294.967.296 es 2³², el tamaño exacto de un espacio de direcciones de 32 bits y el techo que un proceso de esa anchura no puede pasar por mucha memoria que tenga la máquina.

Uno menos que esas cifras importa tanto como ellas. 2.147.483.647 es el mayor entero con signo de 32 bits, y cualquier recuento de bytes guardado en uno se detiene ahí. Un archivo que sube bien con 1,9 GiB y falla con 2,1 está chocando con esa frontera y no con un límite configurado, y subir el límite no lo va a mover ni un byte.

max_allowed_packet acepta un número sin sufijo cuando se ajusta desde la sesión, y ese número está en bytes: 67108864 son 64 MiB. Es el ajuste con el que se topa quien restaura un volcado grande o guarda un campo de texto largo, y el mensaje que devuelve el servidor nombra el paquete y no el ajuste, de manera que la relación entre el error y la cifra hay que ponerla uno mismo.

La costumbre que evita el rodeo es escribir el límite y comprobarlo en la misma unidad. Consultar la variable después de cambiarla devuelve bytes, compararlo con 1.073.741.824 por el número de gibibytes que se pretendía es una operación de cinco segundos, y descarta de golpe la posibilidad de que se hayan tecleado un cero de más o uno de menos.

Una línea de configuración que dice 8589934592 no le cuenta nada a quien la revise. La misma cifra escrita 8 1024 1024 * 1024 donde el formato admita una expresión, o acompañada de un comentario que diga ocho gibibytes, se comprueba de un vistazo. Toda constante grande de bytes en un repositorio es un número que alguien tendrá que verificar algún día, y las que llevan encima su propio origen son las que sobreviven intactas a la siguiente reorganización.

Donde la sintaxis admita sufijo, es preferible al número desarrollado. Casi cualquier errata en 1Gi es un error de sintaxis, y la única que no lo es —comerse la i— cuesta un siete por ciento; una errata en 1073741824 produce una configuración que arranca perfectamente con un límite diez veces mayor o menor del previsto. Esa asimetría es todo el argumento a favor de los sufijos.

Los fallos ruidosos son el caso afortunado. Un contenedor que rebasa su memoria muere con un estado reconocible; una subida por encima del límite de cuerpo se rechaza con un código que nombra el problema. Los dos señalan el ajuste que los ha causado y se arreglan con una edición en cuanto el recuento de bytes está bien hecho.

Los silenciosos salen más caros. Un montículo dimensionado un siete por ciento por encima de lo que el contenedor va a permitir no falla al arrancar: falla semanas después, con carga, cuando el proceso intenta usar la memoria que le dijeron que tenía. Un límite de caché puesto en la unidad equivocada no da error nunca; simplemente desaloja más a menudo de lo previsto, y el único síntoma es una tasa de aciertos algo peor que la del diseño.