Convert MiB to B

A mebibyte is 1,024 kibibytes, or 1,048,576 bytes. Linux tools and memory sizes generally mean this even when they print "MB".

A byte is eight bits, though that was not always fixed — early machines used six, seven or nine. The eight-bit byte won because it holds one character of text and divides neatly in half.

Going this way is a multiplication, and by a whole number: one mebibyte is 1,048,576 bytes, exactly, and 1,048,576 is the definition rather than a measurement that came close.

That makes it one of the few conversions worth doing in your head, and it makes the answer checkable: divide back and you must land on the number you started with, exactly, with no remainder to explain away.

One MiB is 1,024 of the unit below it; one MB is 1,000. On this page that is the difference between 1048576 B and 1000000 B — 4.9 % — and the gap grows at every step up the scale, which is why it is a rounding error on a photograph and a visible chunk of a hard disk.

This is the whole of the missing-storage mystery, and on this page it is worth 4.9 %. A drive sold in MB holds exactly what the label says; Windows divides by 1,024 instead of 1,000, keeps the decimal name, and reports 1000000 B where the box said 1048576. macOS has counted these in the decimal units since 10.6, which is why the same drive can look two sizes on two machines — nothing is missing and nobody is rounding, the same bytes have two names.

Most size conversions exist so a person can picture a quantity. This one usually exists so a machine can enforce one. An upload limit, a heap size, a buffer allocation, a chunk boundary in a multipart transfer — each of these is an integer that something compares against, and a value rounded to look tidy is a value that fails at the edge rather than in the middle where it would be noticed.

So the useful figure here is 1,048,576 and its multiples, not an approximation. Ten MiB is 10,485,760 bytes; 64 MiB is 67,108,864; 512 MiB is 536,870,912. Every one of those is a number somebody has typed into a configuration file this week, and every one of them is a digit away from a value that is quietly 4.86 per cent different.

A surprising amount of software takes a size with a letter on the end and treats that letter as 1,024-based. The nginx k and m suffixes are binary. The JVM heap flags -Xms512m and -Xmx2g are binary. PHP’s upload_max_filesize = 8M is binary. None of these write the i, and none of them say so in the line you are editing.

GNU dd is the instructive case because it accepts both conventions and distinguishes them by length: bs=1M is 1,048,576 bytes and bs=1MB is 1,000,000. That is a defensible design and a reliable trap, because the two spellings look like typing variants of one another. When copying a block size between scripts, copy the suffix exactly or replace it with the byte count.

Kubernetes resource quantities accept both scales explicitly, so memory: 512Mi is 536,870,912 bytes and memory: 512M is 512,000,000. Both are valid, both pass schema validation, and the difference is a single letter in a file that will be applied without anyone reading it again. On a memory limit, the smaller value is the one that gets a container terminated under load that the larger one survives.

The gap widens up the scale, which is where it does real damage. At the mega step it is 4.86 per cent; at giga it is 7.37 per cent, so 4Gi and 4G differ by roughly 295 megabytes. A limit set from a monitoring reading in GiB and typed as G is under-provisioned by that margin from the first deploy, and the symptom is an intermittent restart rather than an error anybody traces back to a manifest.

In code the expression beats the literal. 1024 * 1024 and 1 << 20 both state what the value is and let a reviewer verify it without counting zeros, while 1048576 sitting next to 10485760 in a config table is a diff nobody catches. Languages with digit separators help — 1_048_576 — but the multiplication still says more, because it carries the base along with the number.

The other half of the discipline is naming. A field called maxBytes cannot be handed a mebibyte figure by mistake; a field called maxSize can, and will. Where a value crosses a boundary — a form, an environment variable, an API — the unit belongs in the name, because that is the only place a caller reliably reads it.

The number arriving at this conversion usually came from something that measures in binary units by default. free reports in kibibytes unless told otherwise. /proc/meminfo prints kB and means KiB. top and ps show resident set size in KiB. Container runtimes report limits and usage in bytes, and the dashboards above them display MiB.

That is convenient: multiplying that reading by 1,048,576 gets you back to the exact byte figure the kernel had, with nothing lost but the digits the display dropped. It is only when a decimal-megabyte number from a spec sheet, a contract or a marketing page enters the same field that the two conventions collide, and that number should be converted deliberately rather than typed with an M after it.

A tidy figure in MiB is an untidy one in bytes, and there is no arrangement of the two scales where both look neat. 700 MiB is 734,003,200 bytes. 250 MiB is 262,144,000. 1.5 MiB is 1,572,864. None of those look like numbers anybody chose, and all of them are exact.

The classic worked example is the compact disc: an eighty-minute data disc holds 360,000 sectors of 2,048 bytes, which is 737,280,000 bytes, or 703.125 MiB. The disc has been called a 700 MB disc for thirty years, the figure is neither a decimal 700 MB nor a binary 700 MiB, and it is a good reminder that a familiar capacity is often a rounded label rather than a unit.

One mebibyte is exactly 256 memory pages of 4,096 bytes, 2,048 disk sectors of 512 bytes, or 256 filesystem blocks on a default ext4 volume. Every boundary underneath a mebibyte figure falls on a whole number, which is why buffer sizes, ring buffers, mmap regions and partition offsets are specified in binary units rather than decimal ones.

A decimal megabyte divides into none of them. 1,000,000 bytes is 244.14 pages and 1,953.125 sectors, so a buffer of that size straddles a page boundary at one end and wastes part of a block at the other. The binary unit is not merely traditional here — it is the one that matches the thing being allocated, and that is why this conversion is the one worth having exact.

A limit expressed in mebibytes deserves three test fixtures rather than one, and their sizes come straight out of this conversion. For a 10 MiB cap the interesting bytes are 10,485,759, 10,485,760 and 10,485,761: one below, exactly at, one above. Whether the boundary itself should pass depends on whether the check is a comparison or a strict one, and that is precisely the question a test at the boundary answers and a test at 5 MiB does not.

Generating those fixtures is worth doing by byte count rather than by unit, for the same reason the constant is. A file created with a size argument in a friendly unit inherits whatever base the creating tool used, so a fixture intended to be one byte over a limit can land four per cent under it. Create the file with an explicit byte length, assert its length in the test, and the fixture is then evidence rather than an assumption.