Convertir GiB a kB

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 kilobyte son 1.000 bytes cuando lo define un organismo de normalización y 1.024 cuando lo define un sistema operativo. Esta página calcula con 1.000; la unidad de 1.024 se llama kibibyte.

El factor es 1073741,824, y casi nadie lo lleva encima. Redondeado a 1070000 se desvía un 0,35 %, que pasa desapercibido en cifras pequeñas y se convierte en una unidad entera alrededor de 1000 GiB.

Ese es el dato que interesa antes de redondear: no el error en sí, sino a partir de dónde deja de ser despreciable. Por debajo de ahí el factor corto es el sensato; por encima, usa el campo de arriba, que no redondea hasta el momento de escribir el resultado.

Un GiB son 1.024 de la unidad de debajo; un GB, 1.000. En esta página eso es la diferencia entre 1073741,824 kB y 1000000 kB —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 1000000 kB donde la caja ponía 1073741,824 kB. 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.

/proc/meminfo imprime en cualquier equipo con Linux sus valores con el sufijo «kB», y todos ellos son kibibytes. La etiqueta es muchos años anterior a los nombres de la norma, y cambiarla ahora rompería todos los analizadores, agentes y guiones que han leído ese archivo desde entonces. Así que la fuente de cifras de memoria más consultada de la plataforma informa en una unidad y nombra otra, de manera permanente.

Importa porque ya casi nada lee /proc/meminfo directamente. Lo leen exportadores, agentes y entornos de ejecución de contenedores, que lo escalan y se lo entregan a un panel, y cada capa decide por su cuenta si lo que recibió era decimal o binario. Una cifra de memoria en una gráfica ha atravesado normalmente una unidad mal rotulada antes de que nadie la mire, y el error, cuando lo hay, se introdujo aguas arriba del panel.

Los paneles de supervisión se quedan en gibibytes para memoria y disco porque es la escala a la que las cifras se leen. Aquello contra lo que se comparan es a menudo mucho más pequeño y lo ha escrito una persona: un presupuesto de 200 kB de memoria por petición, un tamaño medio de objeto de 40 kB, el coste de una entrada de caché, una cifra sacada del documento de capacidad de otro equipo. Lo que escribe una persona es decimal casi sin excepción.

De modo que la comparación cruza a la vez un salto de prefijo de un millón y una diferencia de sistema del 7,37 %, y suele cruzarlos en la cabeza de alguien durante un incidente. Es el peor momento disponible para hacerlo, y es todo el argumento a favor de convertir una vez, anotar el resultado con su unidad y dejarlo en el manual de guardia en lugar de volver a deducirlo bajo presión. Un gibibyte son 1.073.741,824 kB, y esa cola decimal no es un redondeo: un gibibyte no es un número entero de kilobytes decimales.

En español la confusión suele empezar un escalón por debajo de esta conversión, porque la publicidad de las operadoras habla en bits y el equipo informa en bytes. Una fibra anunciada como 600 Mb son 600 megabits por segundo, es decir 75 megabytes por segundo, y el indicador de descarga que divide entre 1.024 mostrará alrededor de 71,5. Ninguna de las tres cifras es falsa y las tres describen la misma línea.

La regla que resuelve el noventa por ciento de los casos es mirar la mayúscula y el contexto: b minúscula es bit, B mayúscula es byte, y el factor entre ellas es ocho. Las velocidades de red se cuentan casi siempre en bits por segundo y los tamaños de archivo casi siempre en bytes, así que un cálculo que mezcle las dos sin dividir entre ocho se equivoca por un factor entero antes de que ninguna cuestión de kilo o kibi entre en juego.

La lista de unidades de Grafana contiene bytes en versión decimal y bytes en versión binaria, y la elección se hace panel por panel. Con la primera, 8.589.934.592 bytes se dibujan como 8,59 GB; con la segunda, como 8 GiB. Las dos son la misma medida y las dos están rotuladas con honradez, pero el rótulo es pequeño, la diferencia es del 7,37 % y nadie que compare dos tableros revisa antes la configuración de cada panel.

Donde esto muerde es en un tablero montado con piezas hechas por personas distintas en momentos distintos. Uno enseña la memoria de una máquina en GiB y el de al lado el límite de un contenedor en GB, y los dos quedan juntos aparentando ser comparables. Si dos cifras que deberían coincidir están sistemáticamente a un siete por ciento la una de la otra, la unidad del panel es lo primero que hay que abrir y se comprueba en un clic.

Los exportadores de Prometheus, y la mayoría de los agentes modernos, publican recuentos de bytes en bruto. node_memory_MemAvailable_bytes es un número de bytes sin escala pegada, y el propio nombre lo dice. Ese es el diseño correcto: la métrica lleva la medida y la presentación lleva la presentación, así que la ambigüedad solo puede aparecer donde una persona eligió un formato.

Significa también que cualquier desacuerdo tiene salida. Cuando dos vistas del mismo sistema no cuadran, se consulta la métrica de debajo y se comparan recuentos de bytes, que no pueden estar en la unidad equivocada. Casi todas las discusiones sobre si la memoria va un 7,4 % por encima de lo que se informa terminan ahí, en medio minuto, sin que nadie haya tenido que acertar de antemano.

free informa por defecto en kibibytes y ofrece -m, -g y -h para unidades binarias mayores. ps y top muestran el conjunto residente en kibibytes. vmstat trabaja con bloques de 1.024 bytes y slabtop cuenta en kibibytes. Entre todas cubren casi todo lo que mira alguien mientras diagnostica un problema de memoria, y ninguna escribe una i.

Al menos la coherencia ayuda: en una máquina con Linux, una cifra de memoria pequeña y sin unidad explícita es casi con seguridad kibibytes, y multiplicar por 1.024 lleva a bytes. La trampa no está dentro de la plataforma sino en sus bordes, donde una cifra procedente de una consola de nube, de un documento de un proveedor o de un pliego llega en kilobytes decimales de verdad y tiene exactamente el mismo aspecto que las otras.

Un número que abandona el sistema de supervisión pierde el contexto que lo hacía interpretable. En un ticket, en un informe o en un análisis posterior al incidente, «el proceso estaba usando 1,4 GB» lo leerán unos como 1,4 GiB y otros como 1,4 GB, y a esa escala se llevan cien megabytes de diferencia: suficiente para cambiar el sentido de una discusión sobre si se rebasó un límite.

Escribir el recuento de bytes al lado es la protección más barata que existe y a esta escala cabe en una oración: «1,4 GiB, es decir 1.503.239 kB». Elimina de un golpe la conversión, el convenio y la discusión, y es la misma disciplina que hace que una medida anotada durante un incidente siga valiendo algo un año después.

El límite de memoria de un contenedor y su uso actual viven los dos en el sistema de archivos de grupos de control como enteros de bytes: memory.max y memory.current en la versión 2. Ahí no hay nada escalado, ni etiquetado, ni redondeado. Toda cifra que un panel enseñe de un contenedor se ha leído de uno de esos archivos y la ha formateado algo situado más arriba, que es la capa donde se tomó una decisión de unidades.

Eso da una manera concluyente de cerrar cualquier discusión sobre la memoria de un contenedor. Se leen los archivos, se comparan los enteros, y la pregunta de si el límite son 4 GB o 4 GiB deja de ser interpretable: 4.294.967.296 es uno y 4.000.000.000 es el otro, y el archivo dice cuál. Es el mismo principio que leer el recuento exacto de bytes en una ventana de propiedades, aplicado una capa más abajo y a un número que decide si un proceso muere.