Converter MiB para B

Um mebibyte são 1.024 kibibytes, ou seja 1.048.576 bytes. As ferramentas do Linux e os números de memória quase sempre se referem a isto, mesmo escrevendo «MB».

Um byte são oito bits, o que nem sempre foi claro: os primeiros computadores usaram seis, sete ou nove. O oito se impôs porque nele cabe um caractere e porque o número se parte em metades limpas.

Neste sentido a conta é uma multiplicação, e por um número inteiro: um mebibyte são 1.048.576 bytes, exatamente, e 1.048.576 é a definição, não uma medição que chegou perto.

Isso faz dela uma das poucas conversões que valem de cabeça, e o resultado dá para conferir: divida de volta e você tem que cair no número de partida, exato e sem resto para explicar.

Um MiB são 1.024 da unidade de baixo; um MB, 1.000. Nesta página isso é a diferença entre 1048576 B e 1000000 B — 4,9 % — e a distância cresce a cada degrau: por isso é arredondamento desprezível numa foto e um pedaço visível de um HD.

O mistério do espaço que some é inteiro isso. Um disco vendido como um terabyte tem exatamente o que diz em unidades decimais; o Windows reconta em unidades binárias e mantém o nome decimal, então o número encolhe sem que nada tenha se perdido. O macOS conta em unidades decimais desde o 10.6, e é por isso que o mesmo disco pode aparecer com dois tamanhos em dois computadores.

A maioria das conversões de tamanho existe para uma pessoa conseguir imaginar uma quantidade. Esta normalmente existe para uma máquina conseguir impor um limite. Um limite de upload, um tamanho de heap, uma alocação de buffer, uma fronteira de chunk numa transferência multipart — cada um desses é um inteiro que algo compara, e um valor arredondado para parecer arrumado é um valor que falha na borda em vez de no meio, onde seria notado.

Então a cifra útil aqui é 1.048.576 e seus múltiplos, não uma aproximação. Dez MiB são 10.485.760 bytes; 64 MiB são 67.108.864; 512 MiB são 536.870.912. Cada um desses é um número que alguém digitou num arquivo de configuração nesta semana, e cada um está a um dígito de distância de um valor silenciosamente 4,86% diferente.

Uma quantidade surpreendente de software recebe um tamanho com uma letra no final e trata essa letra como base 1.024. Os sufixos k e m do nginx são binários. As flags de heap da JVM -Xms512m e -Xmx2g são binárias. O upload_max_filesize = 8M do PHP é binário. Nenhum deles escreve o i, e nenhum diz isso na linha que você está editando.

O dd do GNU é o caso instrutivo porque aceita as duas convenções e distingue elas pelo comprimento: bs=1M são 1.048.576 bytes e bs=1MB são 1.000.000. É um design defensável e uma armadilha confiável, porque as duas grafias parecem variantes de digitação uma da outra. Ao copiar um tamanho de bloco entre scripts, copie o sufixo exatamente ou substitua pela contagem de bytes.

Quantidades de recurso do Kubernetes aceitam as duas escalas explicitamente, então memory: 512Mi são 536.870.912 bytes, e memory: 512M são 512.000.000. Os dois são válidos, os dois passam na validação de schema, e a diferença é uma única letra num arquivo que vai ser aplicado sem ninguém ler de novo. Num limite de memória, o valor menor é o que faz um contêiner ser encerrado sob carga que o maior sobreviveria.

A lacuna aumenta subindo na escala, que é onde faz dano de verdade. No degrau mega, são 4,86%; no giga, são 7,37%, então 4Gi e 4G diferem em aproximadamente 295 megabytes. Um limite definido a partir de uma leitura de monitoramento em GiB e digitado como G fica subprovisionado por essa margem já na primeira implantação, e o sintoma é um reinício intermitente, não um erro que alguém consegue rastrear até um manifesto.

No código, a expressão vence o literal. 1024 * 1024 e 1 << 20 os dois declaram o que o valor é e deixam um revisor verificar sem contar zeros, enquanto 1048576 sentado ao lado de 10485760 numa tabela de configuração é um diff que ninguém pega. Linguagens com separador de dígito ajudam — 1_048_576 — mas a multiplicação ainda diz mais, porque carrega a base junto com o número.

A outra metade da disciplina é nomeação. Um campo chamado maxBytes não pode receber uma cifra em mebibyte por engano; um campo chamado maxSize pode, e vai. Onde um valor cruza uma fronteira — um formulário, uma variável de ambiente, uma API — a unidade pertence ao nome, porque esse é o único lugar em que quem chama confiavelmente lê ela.

O número chegando a esta conversão normalmente veio de algo que mede em unidades binárias por padrão. O free do Linux relata em kibibyte a menos que instruído o contrário. O /proc/meminfo imprime kB e quer dizer KiB. O top e o ps mostram tamanho de conjunto residente em KiB. Runtimes de contêiner relatam limites e uso em bytes, e os painéis acima deles exibem MiB.

Isso é conveniente: multiplicar essa leitura por 1.048.576 devolve a cifra exata em byte que o kernel tinha, sem nada perdido além dos dígitos que a exibição descartou. É só quando um número em megabyte decimal de uma ficha técnica, um contrato ou uma página de marketing entra no mesmo campo que as duas convenções colidem, e esse número deveria ser convertido deliberadamente, não digitado com um M depois.

Uma cifra arrumada em MiB é uma desarrumada em byte, e não existe arranjo das duas escalas em que as duas pareçam limpas. 700 MiB são 734.003.200 bytes. 250 MiB são 262.144.000. 1,5 MiB são 1.572.864. Nenhum desses parece um número que alguém escolheu, e todos são exatos.

O exemplo clássico resolvido é o CD: um disco de dados de oitenta minutos guarda 360.000 setores de 2.048 bytes, que dão 737.280.000 bytes, ou 703,125 MiB. O disco tem sido chamado de disco de 700 MB por trinta anos, a cifra não é nem 700 MB decimais nem 700 MiB binários, e é um bom lembrete de que uma capacidade familiar frequentemente é um rótulo arredondado, e não uma unidade.

Um mebibyte são exatamente 256 páginas de memória de 4.096 bytes, 2.048 setores de disco de 512 bytes, ou 256 blocos de sistema de arquivos num volume ext4 padrão. Toda fronteira embaixo de uma cifra em mebibyte cai num número inteiro, o que explica tamanhos de buffer, buffers circulares, regiões de mmap e deslocamentos de partição serem especificados em unidades binárias em vez de decimais.

Um megabyte decimal não divide em nenhum deles. 1.000.000 bytes são 244,14 páginas e 1.953,125 setores, então um buffer desse tamanho atravessa uma fronteira de página numa ponta e desperdiça parte de um bloco na outra. A unidade binária não é meramente tradicional aqui — é a que combina com a coisa sendo alocada, e é por isso que esta conversão é uma que vale a pena ter exata.

Um limite expresso em mebibyte merece três exemplos de teste em vez de um, e os tamanhos deles saem direto desta conversão. Para um teto de 10 MiB, os bytes interessantes são 10.485.759, 10.485.760 e 10.485.761: um abaixo, exatamente no ponto, um acima. Se a própria fronteira deveria passar depende de se a checagem é uma comparação estrita ou não, e essa é precisamente a pergunta que um teste na fronteira responde e um teste em 5 MiB não.

Gerar esses exemplos vale a pena fazer por contagem de byte em vez de por unidade, pelo mesmo motivo que a constante. Um arquivo criado com um argumento de tamanho numa unidade amigável herda qualquer base que a ferramenta criadora usou, então um exemplo pretendido para ficar um byte acima de um limite pode cair quatro por cento abaixo dele. Crie o arquivo com um comprimento explícito em byte, afirme o comprimento dele no teste, e o exemplo então vira evidência em vez de uma suposição.