Convert TiB to B

A tebibyte is 1,024 gibibytes. The gap against the terabyte has grown with each step: 2.4% at kilo, 4.9% at mega, 7.4% at giga, 10% at tera.

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 tebibyte is 1,099,511,627,776 bytes, exactly, and 1,099,511,627,776 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 TiB is 1,024 of the unit below it; one TB is 1,000. On this page that is the difference between 1099511627776 B and 1000000000000 B — 10 % — 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 10 %. A drive sold in TB holds exactly what the label says; Windows divides by 1,024 instead of 1,000, keeps the decimal name, and reports 1000000000000 B where the box said 1099511627776. 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.

A tebibyte is 2 to the fortieth power. Written out it is 1,099,511,627,776, twelve digits with no repetition to hang on to, which makes it exactly the kind of constant that gets mistyped by one digit and then passes review because nobody reads it. It is also the kind that fails silently: a limit that is off by a factor of ten still looks like a plausible number in a config file.

The defence is to never write it as a bare literal where the surrounding language can compute it. 1024 * 4 or 1024 1024 1024 1024 is legible, self-checking and impossible to fat-finger into something that still parses. Where the format takes only a number, put the derivation in a comment on the same line, so the next person can verify the constant without counting digits.

Twelve digits is comfortably inside a 64-bit integer and comfortably outside a 32-bit signed one, which tops out at 2,147,483,647, a shade under 2 GiB. That ceiling is the reason so much older software could not handle large files at all, and it still surfaces in file formats, database columns declared as INT rather than BIGINT, and APIs that quietly narrow a size on the way through.

The subtler ceiling is floating point. A double represents integers exactly up to 2 to the 53rd, which is 9,007,199,254,740,991 bytes, or 8,192 TiB. A tebibyte figure is far below that and entirely safe; a petabyte-scale total in a JSON document parsed by JavaScript is close enough to be worth thinking about, because the failure is not an error but a number whose last digits have changed.

Because the factor is a power of two, every whole multiple is exact and easy to derive. 2 TiB is 2,199,023,255,552 bytes, 4 TiB is 4,398,046,511,104, 10 TiB is 10,995,116,277,760. Halves and quarters are exact too: 0.5 TiB is 549,755,813,888 and 0.25 TiB is 274,877,906,944, which is one reason quotas tend to be set in halving steps rather than in tens.

A third of a tebibyte, by contrast, is not an integer number of bytes, and neither is a tenth of a gibibyte. If a quota needs to be a round decimal fraction, it will land between block boundaries and the number written into the config will be a rounded one. That is usually harmless and always worth knowing, because it is the difference between a limit you can reason about exactly and one that is approximately what you meant.

A terabyte is 1,000,000,000,000 bytes and a tebibyte is 1,099,511,627,776, so writing one where the other was intended puts the limit about 9 percent away from where it should be. Nothing complains. The quota applies, the rule runs, and the discrepancy shows up as an alert that fires early, a bucket that fills sooner than forecast, or a bill that does not reconcile with the dashboard.

This is why the byte count is the value worth putting in the file and the unit is worth putting in the comment beside it. A field containing 1099511627776 with a note saying "1 TiB" can be checked by anyone; a field containing "1TB" cannot, because you first have to establish what the software reading it thinks TB means, and the answer differs between the tools on a single machine.

Anything that verifies an object usually records its length beside its digest, and that length has to be the exact byte count for the verification to mean anything. A manifest that stores "1.1 TB" has recorded a display string, not a measurement, and a restore that checks against it can only confirm the file is roughly the right size — which is precisely the check that would miss a truncated transfer at the last block.

Lifecycle and retention rules have the same requirement for a different reason: they are evaluated by machines that do not round the way a dashboard does. A rule that transitions objects above a size threshold compares raw lengths, so a threshold entered as a friendly figure and converted somewhere in the middle will select a slightly different set of objects than intended, and the difference will only be visible in the storage bill a month later.

A byte count survives a pipeline only if every stage treats it as an integer. The stages that break it are the ones that format for readability — a logger that prints 1.1e12, an aggregation that averages, a spreadsheet that imports the column as a float. Each is individually reasonable and the composition loses the low digits, after which no downstream check can tell an exact match from a near one.

Two habits prevent almost all of it. Carry the raw count in its own field and let the human-readable version be a separate, clearly derived one, so nothing is ever parsed back out of a label. And where a document format has no integer type large enough to promise exactness, carry the number as a string — it is a byte count, it is never arithmetic in transit, and a string cannot be silently widened or narrowed.

A byte count in the tebibyte range should have thirteen digits for a single-figure TiB value, and that digit count alone catches most order-of-magnitude errors at a glance. The other quick test is the leading digits: any exact multiple of a tebibyte begins with 1099, 2199, 3298, 4398 and so on, because it is the same 1.0995 repeatedly, so a number starting with a clean 1,000 has almost certainly been derived from a terabyte instead.

For anything automated, the assertion worth writing is that the constant equals 1024 to the fourth rather than that it equals a hard-coded twelve-digit literal. The first cannot be wrong; the second is a copy of the thing it is checking, and a test that copies the value it verifies will pass on the day the value is mistyped in both places. The same applies to fixtures: a fixture holding a byte count should derive it from the same expression the production code uses, so that the two cannot drift apart silently.