Convertir MiB a B

Un mebibyte son 1.024 kibibytes, es decir 1.048.576 bytes. Las herramientas de Linux y las cifras de memoria se refieren casi siempre a esto, aunque escriban «MB».

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 mebibyte son 1.048.576 bytes, exactamente, y 1.048.576 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 MiB son 1.024 de la unidad de debajo; un MB, 1.000. En esta página eso es la diferencia entre 1048576 B y 1000000 B —un 4,9 %—, 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 4,9 %. Un disco vendido en MB 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 B donde la caja ponía 1048576 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.

Casi todas las conversiones de tamaño existen para que una persona se haga una idea. Esta suele existir para que una máquina imponga un tope. Un límite de subida, un tamaño de montículo, la reserva de un búfer, la frontera de un fragmento en una transferencia por partes: cada uno de ellos es un entero contra el que algo compara, y un valor redondeado para que quede bonito es un valor que falla en el borde y no en el centro, que es donde se habría visto.

Así que la cifra que importa aquí es 1.048.576 y sus múltiplos, no una aproximación. Diez MiB son 10.485.760 bytes; 64 MiB son 67.108.864; 512 MiB son 536.870.912. Los tres son números que alguien ha escrito esta semana en un fichero de configuración, y los tres están a un dígito de un valor que difiere en un 4,86 % sin avisar.

Una cantidad sorprendente de software acepta un tamaño con una letra detrás y trata esa letra como base 1.024. Los sufijos k y m de nginx son binarios. Las opciones de montículo de la máquina virtual de Java, -Xms512m y -Xmx2g, son binarias. La notación abreviada de PHP también. Ninguna escribe la i y ninguna lo aclara en la línea que usted está editando.

GNU dd es el caso didáctico porque acepta los dos convenios y los distingue por la longitud del sufijo: bs=1M son 1.048.576 bytes y bs=1MB son 1.000.000. Es un diseño defendible y una trampa fiable, porque las dos formas parecen variantes tipográficas de la misma. Al copiar un tamaño de bloque de un guion a otro, copie el sufijo entero o sustitúyalo directamente por el recuento de bytes.

En el código gana la expresión sobre el literal. Tanto 1024 * 1024 como 1 << 20 dicen qué es el valor y dejan que quien revise lo verifique sin contar ceros, mientras que 1048576 al lado de 10485760 en una tabla de configuración es una diferencia que no ve nadie. Los lenguajes con separador de dígitos ayudan —1_048_576—, pero la multiplicación dice más, porque lleva la base pegada al número.

La otra mitad de la disciplina está en el nombre. A un campo llamado maxBytes no se le puede pasar una cifra en mebibytes por descuido; a uno llamado maxSize sí, y ocurrirá. Cuando el valor cruza una frontera —un formulario, una variable de entorno, una interfaz—, la unidad pertenece al nombre, porque es el único sitio donde quien llama la lee de verdad.

El número que entra en esta conversión suele proceder de algo que mide en unidades binarias por defecto. Las herramientas clásicas de memoria informan en kibibytes salvo que se les diga otra cosa, /proc/meminfo imprime kB y significa KiB, y las utilidades que listan procesos muestran la memoria residente en KiB. Los entornos de contenedores informan de límites y consumo en bytes, y los paneles que se apoyan en ellos los presentan en MiB.

Eso es cómodo: multiplicar esa lectura por 1.048.576 devuelve exactamente el entero de bytes que tenía el núcleo, sin perder más que los dígitos que la pantalla recortó. El choque solo aparece cuando en el mismo campo entra una cifra en megabytes decimales sacada de una ficha técnica, de un contrato o de una página comercial, y ese número hay que convertirlo a conciencia en lugar de teclearlo con una M detrás.

Una cifra limpia en MiB es una cifra sucia en bytes, y no hay ninguna disposición de las dos escalas en la que las dos queden bien. 700 MiB son 734.003.200 bytes. 250 MiB son 262.144.000. 1,5 MiB son 1.572.864. Ninguno parece un número elegido por nadie y todos son exactos, así que un recuento de bytes de aspecto arbitrario no es indicio de error.

El ejemplo clásico es el disco compacto: un CD de datos de ochenta minutos guarda 360.000 sectores de 2.048 bytes, es decir 737.280.000 bytes, o 703,125 MiB. Se lleva treinta años llamándolo «disco de 700 MB» y la cifra no es ni 700 MB decimales ni 700 MiB binarios. Es un buen recordatorio de que una capacidad familiar suele ser una etiqueta redondeada y no una unidad.

Un mebibyte son exactamente 256 páginas de memoria de 4.096 bytes, 2.048 sectores de 512 bytes o 256 bloques de un volumen ext4 con la configuración habitual. Cualquier frontera por debajo de una cifra en mebibytes cae sobre un número entero, y de ahí que los tamaños de búfer, los búferes circulares, las regiones proyectadas en memoria y los desplazamientos de partición se especifiquen en unidades binarias y no decimales.

Un megabyte decimal no divide ninguno de esos objetos. 1.000.000 de bytes son 244,14 páginas y 1.953,125 sectores, así que un búfer de ese tamaño se sale de una página por un extremo y desperdicia parte de un bloque por el otro. Aquí la unidad binaria no es tradición: es la que encaja con lo que se está reservando, y por eso esta conversión merece hacerse exacta.

Un límite expresado en mebibytes merece tres ficheros de prueba y no uno, y sus tamaños salen directamente de esta conversión. Para un tope de 10 MiB los bytes interesantes son 10.485.759, 10.485.760 y 10.485.761: uno por debajo, el valor exacto y uno por encima. Que la frontera misma deba pasar o no depende de si la comprobación es estricta, y eso es justo lo que responde una prueba en el borde y no una prueba con 5 MiB.

Esos ficheros conviene generarlos por recuento de bytes y no por unidad, por la misma razón que la constante. Un archivo creado con un tamaño expresado en una unidad amable hereda la base que usara la herramienta que lo creó, así que una prueba pensada para quedar un byte por encima del límite puede acabar un cuatro por ciento por debajo. Cree el fichero con una longitud explícita en bytes y compruebe esa longitud dentro de la prueba: entonces el fichero es una evidencia y no una suposición.