Converter GB para MiB

Um gigabyte é um bilhão de bytes, no sentido decimal usado pelos fabricantes de disco, pelos planos de dados e pelos tamanhos de vídeo.

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».

O fator é 953,674316, e quase ninguém carrega isso na cabeça. Arredondado para 950 ele erra 0,39 % — invisível em números pequenos, e já uma unidade inteira por volta de 1.000 GB.

É esse o número que interessa antes de arredondar: não o erro em si, mas a partir de onde ele deixa de ser desprezível. Abaixo disso o fator curto é o sensato; acima, use o campo lá em cima, que só arredonda na hora de escrever.

Um MiB são 1.024 da unidade de baixo; um MB, 1.000. Nesta página isso é a diferença entre 0,001 GB e 0,001 GB — 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.

Um gigabyte é um bilhão de bytes. Um mebibyte é 1.048.576. Divida um pelo outro e você recebe 953,67431640625, exatamente e sem arredondamento — um número que ninguém adivinha e todo mundo precisa procurar. O instinto é usar 1.000, que é o MB num GB, ou 1.024, que é o MiB num GiB, e os dois estão errados aqui porque o par atravessa entre os dois sistemas.

O tamanho do erro depende de qual número errado você escolhe. Usar 1.000 superestima em 4,9 por cento; usar 1.024 superestima em 7,4. Num painel isso é uma linha levemente errada. Num limiar de alerta é um alarme disparando numa porcentagem que você não escolheu, e num planejamento de capacidade é a diferença entre provisionar o suficiente e ficar sete por cento aquém no momento em que a previsão dizia que estaria tranquilo.

Limiares costumam significar frações de alguma coisa: alerte em oitenta por cento do disco, avise em noventa por cento do limite de memória. Essa intenção só sobrevive se a fração for tirada da alocação na própria unidade da alocação e convertida uma vez só, no final. Oitenta por cento de um gigabyte são 762,9 MiB e noventa por cento são 858,3 MiB, e nenhum dos dois é um número que alguém digita por escolha.

O que as pessoas digitam em vez disso é 800 e 900, números redondos que não são as frações pretendidas — 800 MiB são 84 por cento de um gigabyte e 900 MiB são 94. O alerta continua funcionando, só dispara mais tarde do que o manual diz que dispara, e a discrepância é invisível porque tanto a regra quanto a documentação carregam números redondos plausíveis.

O Prometheus não toma posição nenhuma sobre isso: a convenção entre os exportadores é registrar byte bruto com um sufixo indicando isso e deixar a camada de apresentação escolher uma unidade. É o desenho certo, e move a decisão para o painel, onde é feita por campo, muitas vezes por quem construiu o painel, e raramente anotada em algum lugar que quem lê o gráfico vai ver.

O efeito prático é que dois painéis no mesmo painel de controle podem mostrar a mesma série sete por cento distante um do outro e os dois estarem configurados corretamente. Uma consulta devolve byte; um painel formata no sentido decimal e o outro no sentido binário. Quando um número num painel precisa ser comparado com um número de qualquer outro lugar, confira o ajuste de unidade do campo primeiro, não o rótulo do eixo.

Recurso de contêiner é onde essa conversão é feita com mais frequência e conferida com menos cuidado. O Kubernetes aceita os dois sistemas e distingue direito: um sufixo indica a quantidade binária, outro a decimal. Um limite escrito na forma decimal são um bilhão de bytes; na forma binária são pouco mais de um bilhão de bytes também, mas um valor diferente. Os dois são válidos, os dois se aplicam sem aviso, e diferem em 7,4 por cento.

A armadilha é uma cadeia em que a unidade muda a cada elo. Capacidade é comprada em GB decimal, um nó é descrito em unidade binária, um limite é escrito noutra unidade ainda, e um painel exibe o que quer que tenha sido configurado. Toda conversão nessa cadeia é factível; a falha é fazer três delas de olho. Converta tudo para byte uma vez, no ponto em que os números são comparados, e deixe as unidades amigáveis só para exibição.

Existe uma regra prática, e vale tratar como regra prática, não certeza. Número que descreve algo comprado — um plano, uma cota, uma fatura, uma franquia de transferência — quase sempre é decimal, porque é a unidade em que capacidade é vendida. Número que vem de dentro de uma máquina rodando — memória usada, cache de página, espaço livre de sistema de arquivo no Linux — quase sempre é binário, porque é o que o núcleo do sistema conta.

Onde a regra prática se esgota, há um teste que não se esgota. Ache uma quantidade que você consegue medir em byte de forma independente, passe pelo console, e veja qual divisão reproduz o número exibido. Leva uma observação e resolve a questão para aquele console de forma permanente, um uso melhor de cinco minutos do que ler documentação que talvez nem diga.

Não aparece de jeito nenhum, e essa é a dificuldade. Uma linha 5 por cento acima de onde deveria estar tem a mesma forma, a mesma tendência e a mesma taxa de mudança que a correta; nada nela convida a suspeita. O erro só fica visível onde o gráfico é comparado com um número externo — uma fatura, uma cota, uma segunda ferramenta.

A única pista visual que vale conhecer é uma linha de folga que nunca alinha direito. Se uma série de uso é plotada contra uma linha de capacidade vinda de outro lugar, e o uso platôa em 93 ou 107 por cento da capacidade em vez de 100, essa proporção é a lacuna de unidade, não um artefato de medição.

O conserto duradouro não é acertar essa conversão uma vez, é torná-la desnecessária da próxima vez. Nomeie variável e métrica pelo que ela guarda — um limiar em byte é um limiar em byte, seja lá como é exibido — e coloque a derivação ao lado de qualquer literal convertido à mão, para quem revisar conferir sem precisar procurar de novo.

Onde um sistema precisa conversar com outro, combine bytes na fronteira e converta só nas bordas. É a mesma disciplina usada para fuso horário e moeda, e pelo mesmo motivo: a ambiguidade não está na conta, que é trivial, mas em quantos lugares alguém precisa lembrar qual convenção estava valendo. Reduzir isso a um lugar só é o conserto inteiro.