Convertir B a GiB

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.

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.

En este sentido la cuenta es una división, y por un número entero: 1.073.741.824 de estas caben en un gibibyte sin que sobre nada. Lo incómodo es solo que los resultados salen en fracciones —un tercio de gibibyte, un doceavo— en lugar de las cifras redondas que da el sentido contrario.

Aun así no se pierde nada al redondear, porque la división es exacta. Si el resultado no se queda quieto en decimales —0,0833… y parecidos—, eso es la fracción asomando, no un error colándose.

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.

Los sistemas informan de tamaños en bytes a propósito. Un recuento de bytes no lleva prefijo que interpretar, ni redondeo que deshacer, ni configuración regional dentro, así que una métrica, una línea de registro y una respuesta de API se pueden comparar sin ponerse antes de acuerdo sobre qué significa una G. Esa misma virtud es lo que las vuelve ilegibles: 17.179.869.184 no dice nada hasta que se divide por algo.

El divisor es 1.073.741.824 cuando el sistema de alrededor cuenta en binario, y la memoria, la caché de páginas, el uso de un sistema de archivos y casi todos los contadores del núcleo lo hacen. Esa cifra son 16 GiB exactos. Dividir en cambio entre mil millones da 17,18 y esconde que el número era una potencia de dos limpia, que suele ser lo más informativo que tenía.

Diez dígitos sitúan una cifra entre 0,93 y 9,3 GiB; once, entre 9,3 y 93; doce, entre 93 y 931; y con trece estás alrededor de un tebibyte. Ese vistazo resuelve la mayoría de las preguntas que plantea un recuento de bytes —si una caché está en megas o en gigas, si el tamaño de una transferencia es verosímil— sin hacer ninguna cuenta.

La costumbre se paga sola en salidas que mezclan escalas. Un punto de métricas que devuelve una docena de contadores tendrá algunos en los miles y otros en los miles de millones, y el ojo los ordena por longitud mucho más rápido de lo que los interpreta por valor. Convertir solo los que resultan importar es bastante más rápido que convertirlos todos.

Conviene tener unas cuantas memorizadas porque delatan su propio origen: 1.073.741.824 es un gibibyte, 2.147.483.648 son dos, 4.294.967.296 son cuatro, 8.589.934.592 son ocho y 17.179.869.184 son dieciséis. Cuando una de ellas aparece en una salida, casi siempre es una capacidad o un límite y no una medición, porque las mediciones rara vez caen sobre una potencia de dos exacta.

Lo contrario sirve igual de bien. Un recuento que termina en una fila larga de ceros —1.000.000.000, 50.000.000.000— lo ha escrito una persona o sale de una cifra decimal, y no se corresponde con nada que el hardware haga por su cuenta. Reconocerlo en un volcado de configuración explica muchas veces por qué un límite se queda justo por debajo del borde de asignación con el que pretendía alinearse.

En los manifiestos de Kubernetes las cantidades de memoria admiten los dos sufijos, y no son sinónimos: Gi son 2³⁰ bytes y G son 10⁹. Un límite escrito como 2G reserva 2.000.000.000 de bytes y uno escrito como 2Gi reserva 2.147.483.648, un siete por ciento más. La letra sobrante es toda la diferencia y no hay nada en la sintaxis que avise de que se ha escrito la otra.

De ahí que valga la pena convertir el recuento observado a la misma unidad en que está escrito el límite antes de compararlos. Un proceso que la herramienta de monitorización ve consumir 2,0 GiB contra un límite de 2G ya está por encima aunque los dos números parezcan iguales, y el reinicio que llega después parece caprichoso hasta que las dos cifras se ponen en la misma unidad.

Los lenguajes que guardan todos los números como coma flotante de doble precisión mantienen los enteros exactos hasta 9.007.199.254.740.991, que es 2⁵³ menos uno, o alrededor de 8 PiB contados en bytes. Por debajo de ese techo un recuento de bytes se puede llevar, comparar y sumar sin cuidado. Por encima, los valores se redondean en silencio y dos tamaños distintos pueden dar iguales al compararlos sin que salte ningún error.

La mayoría de los sistemas no llegan nunca, y los que llegan lo hacen en un agregado y no en un objeto suelto: un total de una flota, un contador acumulado de transferencia, una suma sobre una tabla grande. Las dos defensas son llevar los bytes en enteros de 64 bits o en cadenas al cruzar una serialización, y hacer la suma donde vive el tipo ancho en lugar de después de pasar por una capa que lo convierte todo a coma flotante.

Casi toda utilidad tiene un modo que apaga su formato legible, y conviene usarlo siempre que la salida vaya a cualquier sitio que no sea una pantalla: un tamaño de bloque de uno en las herramientas de ocupación, la consulta de metadatos que imprime la longitud exacta, la cabecera de longitud que devuelve cualquier API de almacenamiento. Todas ellas no pierden nada, cosa que un «1,4 GiB» sí hace.

Y lo perdido no se recupera después. Una cifra mostrada como 1,4 GiB puede ser cualquier cosa entre 1.449.551.462 y 1.556.925.644 bytes, más de 100 MB de horquilla, y ninguna multiplicación la estrecha. Un proceso que raspa salida formateada y la vuelve a convertir está metiendo esa incertidumbre en todos los números que vienen detrás, y solo se hace visible cuando se comparan dos procesos así.

La regla que evita más discusiones es mostrar en la unidad en la que cuenta el sistema medido. La memoria, la caché de páginas, el uso de un sistema de archivos y los grupos de búferes son binarios, así que su gráfica va en GiB. Los totales de un almacenamiento de objetos, el volumen de salida y cualquier cifra que acabe en una factura son decimales, y van en GB. Convertir de una a otra camino de la pantalla añade un paso en el que alguien pierde la cuenta de qué está mirando.

Se elija la que se elija, el rótulo del eje tiene que decir cuál es. Una gráfica de memoria etiquetada GB mientras divide entre 2³⁰ traslada a un panel el mismo error de etiquetado que ya sufre el escritorio, y a un sitio donde alguien acabará comparándola con una cifra decimal salida de una factura. Una letra de más en el eje elimina toda esa clase de confusión.

La verificación más barata es deshacer la operación. Coge la cifra en gibibytes, multiplícala por 1.073.741.824 y compárala con la ristra de dígitos original. Si el resultado se desvía alrededor de un siete por ciento, el divisor fue mil millones y no 2³⁰; si se desvía por un factor de 1.024, se ha saltado un prefijo por el camino. Los dos errores parecen razonables en un panel y ninguno de los dos sobrevive a la multiplicación.

Cuando la conversión está metida en código y no se hace a mano, esa misma comprobación tiene su sitio en una prueba con un par conocido: 5.368.709.120 bytes son 5 GiB, y cualquier implementación que devuelva 5,37 ha usado el divisor decimal. Una sola aserción de esa forma caza el error para siempre y ocupa una línea.