Convertir GB a B

Un gigabyte son mil millones de bytes, en el sentido decimal que usan los fabricantes de discos, las tarifas de datos y los tamaños de vídeo.

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.

Pasar de gigabytes a bytes desplaza la coma 9 lugares hacia la derecha y no cambia nada más. No hay factor que recordar ni redondeo que decidir: las cifras siguen en el mismo orden y solo cambia su posición.

1234 GB son 1234000000000 B: las mismas cifras, corridas de sitio. Conviene saberlo porque es la única conversión que se comprueba de un vistazo — si las cifras del resultado no son las mismas con las que empezaste, lo que le ha pasado al número no ha sido esta conversión.

El valor que produce esta página son 1.000.000.000 bytes por gigabyte, porque giga es un prefijo del Sistema Internacional que significa diez elevado a nueve y eso es lo que entienden por él la capacidad de almacenamiento, el caudal de red y la facturación en la nube. 4 GB son 4000000000, 32 GB son 32000000000, y la conversión es un desplazamiento de nueve posiciones decimales sin factor ninguno.

El número con el que se confunde es 1.073.741.824, que es 1.024 al cubo y se llama gibibyte. Entre los dos hay un 7,4 %: una diferencia irrelevante en una conversación y decisiva en un campo de límite, porque los límites se aplican al byte. En 4 GB son 294.967.296 bytes de distancia —más o menos una imagen de contenedor— escondidos entre dos valores que en una revisión se leen igual, «cuatro gigas».

La cifra se escribe 1.000.000.000 en un texto español y 1000000000 en cualquier archivo que la vaya a leer. Suena obvio hasta que alguien copia el número desde una nota, una hoja de cálculo o un correo, y entonces el analizador se encuentra con puntos donde esperaba dígitos. Según el formato, eso termina en un error de arranque claro o —peor— en un valor truncado en el primer punto, es decir, un límite de un byte.

La coma decimal tiene el mismo problema por el otro lado. Un «1,5 GB» copiado tal cual se lee como 1 en unos analizadores y como 1,5 en otros según la configuración regional, y ninguno de los dos avisa. Para una cantidad que va dentro de un archivo, la regla es escribirla sin ningún separador y dejar los puntos y las comas para la frase que la explica al lado.

Casi todas las herramientas que aceptan una abreviatura de tamaño a esta escala la leen en potencias de 1.024. Docker interpreta --memory=1g como 1.073.741.824 bytes; la máquina virtual de Java hace lo mismo con -Xmx1g; dd y el resto de utilidades GNU distinguen de forma explícita, con G para 1.024³ y GB para 1.000³; los sufijos de tamaño de nginx y de PHP son binarios de principio a fin. Escribir 1G y escribir 1000000000 en el mismo campo pide dos cantidades separadas por 73.741.824 bytes.

Conviene quedarse con la pauta más que con la lista: una letra suelta suele ser binaria, y un sufijo de dos letras terminado en B suele ser decimal allí donde la herramienta se molesta en diferenciarlos. Cuando la diferencia importa, lo seguro no es fiarse de la pauta sino aplicar el valor, volver a leerlo del sistema en marcha y comparar el número que informa con el que se quiso poner.

Dos elevado a treinta y dos son 4.294.967.296, y ese número es un muro, no un convenio: es la cantidad de valores distintos que caben en un desplazamiento sin signo de 32 bits y, por lo tanto, el primero que ya no cabe en él, así que cualquier cosa que guarde una longitud o una posición en 32 bits se detiene ahí. El caso conocido es FAT32, donde un archivo no puede pasar de 4.294.967.295 bytes —uno menos— y por eso una grabación larga sacada de una cámara no se copia entera a una tarjeta recién comprada.

El techo asoma también en sitios que parecen modernos: formatos de archivo antiguos, algunas rutas de subida, ciertos tipos de columna y una cola larga de controladores y firmware siguen guardando longitudes de 32 bits, y todos fallan entre 4,29 y 4,30 GB en lugar de en una cifra decimal redonda. Cuando un límite resulta ser exactamente 4.294.967.296, no lo eligió nadie y subirlo no es un cambio de configuración.

Las interfaces que actúan sobre el tamaño a escala toman bytes, porque el byte es inequívoco y porque la acción es automática. Una regla de ciclo de vida de un almacén de objetos filtra por tamaño en bytes; un límite de memoria de un cgroup es un valor en bytes; las herramientas de cuota trabajan en bloques o en bytes; un umbral de alerta es una comparación de enteros. En toda esa cadena no hay ningún redondeo, y un valor escrito un 7,4 % por debajo se comporta igual que si se hubiera elegido a propósito.

Además son valores que se escriben una vez y se consultan durante años. Una regla que mueve a almacenamiento frío los objetos de más de 128 GB seguirá haciéndolo mucho después de que se haya ido quien eligió el umbral, y la distancia entre 128000000000 y 137438953472 cambiará en silencio qué objetos entran. Eso no es un argumento para preferir un convenio sobre el otro, sino para dejar escrito de dónde sale el número el día en que se crea la regla.

La misma persona lleva dos convenios en el bolsillo. Los datos móviles se facturan en unidades decimales, así que un bono de 20 GB son veinte mil millones de bytes; una tarjeta microSD de 64 GB se vende también en decimales, pero la memoria RAM del teléfono se dimensiona en potencias de dos, de modo que un módulo de 8 GB contiene 8.589.934.592 bytes y no existe la alternativa decimal.

En un manifiesto de despliegue las dos convenciones aparecen en líneas contiguas: «4 GB de memoria, 100 GB de disco» son cantidades de dos industrias distintas escritas igual. Qué entiende cada plataforma por cada campo es una pregunta para su documentación y no se adivina — los tiempos de ejecución de contenedores y de lenguajes suelen ser binarios para memoria, y el almacenamiento en bloque, el de objetos y el tráfico de red suelen ser decimales.

Un límite de memoria un 7,4 % más pequeño de lo previsto no falla al desplegar. Falla cuando el proceso llega a la parte alta de su rango normal, o sea bajo carga, a una hora concreta o después de que se caliente una caché — y falla como terminación, no como excepción, de modo que el registro se corta a media frase y no hay nada que leer. Esa combinación es la que convierte este error en días de búsqueda en lugar de minutos.

La defensa es comparar la intención contra el sistema en marcha y no contra el archivo. Lee el límite desde la plataforma después de aplicarlo, en bytes, y contrástalo con el número que querías. Un límite informado como 1073741824 donde escribiste 1000000000, o al revés, te ha dicho qué convenio usa ese campo, para siempre y para todos los valores futuros.

Diez dígitos en un archivo de configuración no se verifican de un vistazo, y diez dígitos equivocados tienen exactamente el mismo aspecto que diez correctos. Donde el formato sea un lenguaje de verdad o admita aritmética, escribe 4 1024 3 o 4 10 ** 9 y deja que la expresión lleve a la vez el tamaño y el sistema. Donde solo se admita un literal, un comentario al lado con el tamaño previsto, el convenio y la herramienta con la que tiene que concordar hace el mismo trabajo.

Merece la pena dejar constancia también de por qué el número es ese. Un límite elegido a partir de un perfilado en hora punta y un límite elegido porque era el escalón siguiente de la tarifa se revisan por motivos distintos, y un valor sin origen declarado acaba subido por reflejo o tratado como intocable. Una frase al lado evita las dos cosas.