B naar TiB omrekenen

Een byte is acht bits, en dat stond niet altijd vast: de eerste computers gebruikten er zes, zeven of negen. Acht won omdat er een teken in past en omdat het getal netjes in helften uiteenvalt.

Een tebibyte is 1.024 gibibyte. De afstand tot de terabyte groeit bij elke trede: 2,4 % bij kilo, 4,9 % bij mega, 7,4 % bij giga en 10 % bij tera.

Deze kant op is het een deling, en wel door een heel getal: er gaan er 1.099.511.627.776 in één tebibyte, zonder rest. Het enige lastige is dat de uitkomsten in breuken vallen — een derde, een twaalfde — in plaats van de ronde getallen die de andere richting geeft.

Er gaat toch niets verloren, want de deling is exact. Wil je uitkomst als decimaal niet stil blijven staan — 0,0833… en familie —, dan is dat de breuk die doorschemert, geen fout die binnensluipt.

Eén TiB is 1.024 van de eenheid eronder; één TB is 1.000. Op deze pagina is dat het verschil tussen 1099511627776 B en 1000000000000 B — 10 % — en het gat groeit bij elke stap omhoog: op een foto een verwaarloosbare afronding, op een harde schijf een zichtbaar stuk.

Hierin zit het raadsel van de verdwenen opslag volledig. Een schijf die als terabyte verkocht wordt bevat in decimale eenheden precies wat erop staat; Windows telt hem daarna in binaire eenheden maar houdt de decimale naam aan, en daar krimpt het getal zonder dat er iets weg is. macOS telt deze eenheden sinds 10.6 decimaal, en daarom kan dezelfde schijf op twee computers twee maten lijken.

Machine-interfaces rapporteren opslag in bytes omdat bytes geen conventie nodig hebben. Een objectopslagmetriek, een du -sb, een quotumrapport of een databasegroottefunctie geven allemaal een kaal geheel getal terug, en op deze schaal is dat getal dertien of veertien cijfers lang. Het is precies, het is ondubbelzinnig, en het is onleesbaar: 4.398.046.511.104 en 439.804.651.104 verschillen een factor tien en zien er op het eerste gezicht identiek uit.

Dat is het echte risico bij deze omzetting, en het is een ander risico dan de kleinere data-pagina’s dragen. Niemand verlegt een factor tien bij het omzetten van een bestandsgrootte. Iedereen kan het bij het lezen van een veertien-cijferig totaal uit een JSON-antwoord, wat is waarom de eerste nuttige zet is de cijfers te tellen in plaats van meteen te gaan delen.

Eén tebibyte is 1.099.511.627.776 bytes. De nuttige eigenschap van dat getal is niet zijn exacte waarde maar zijn vorm: het is dertien cijfers beginnend met een een, dus elke bytentelling van dertien cijfers zit ergens tussen zo’n 0,9 en 9 TiB, en een totaal van veertien cijfers zit tussen 9 en 91. Een totaal van twaalf cijfers heeft nog geen tebibyte bereikt.

De machten eronder zijn om dezelfde reden de moeite waard om te hebben. Een gibibyte is 1.073.741.824 — tien cijfers. Een mebibyte is 1.048.576 — zeven. Een kibibyte is 1.024 — vier. Elke stap omhoog voegt drie cijfers en een leidende een toe, wat de hele ladder oogcontroleerbaar maakt en een verplaatste komma in een spreadsheet meteen zichtbaar zodra de cijfertelling niet meer bij het label past.

De bronnen vallen in twee soorten. Bestandssysteem- en blockdevicetools geven exacte tellingen van wat bestaat: du -sb telt schijnbare groottes op, blockdev --getsize64 rapporteert een apparaatcapaciteit, een volumemanager rapporteert een pool. Service- en factuurinterfaces geven tellingen van wat opgeslagen of overgedragen is: objectopslagmetrieken, back-upcatalogustotalen, egressmeters, quotumsystemen.

De twee soorten zijn het op manieren oneens die niets met eenheden te maken hebben, en weten welke soort een getal produceerde is nuttiger dan het omzetten ervan. Toegewezen grootte overschrijdt schijnbare grootte op een boom kleine bestanden. Een back-upcatalogus telt logische data voor deduplicatie. Een objectopslag telt objecten en niet de ruimte die ze na erasure coding innemen. De verkeerde omzetten naar TiB geeft een precies antwoord op de verkeerde vraag.

Op deze schaal zijn de decimale en binaire eenheden zo ver uit elkaar gedreven als ze in gewoon gebruik ooit komen. Delen door 1.000.000.000.000 geeft terabytes; delen door 1.099.511.627.776 geeft tebibytes; de resultaten verschillen 9,95 procent. Een dataset van 50.000.000.000.000 bytes is 50 TB en 45,47 TiB, en beide getallen zijn correcte beschrijvingen van hetzelfde ding.

Omdat beide delers met een een beginnen en beide dertien cijfers hebben, levert de verkeerde deler een plausibel antwoord op in plaats van een duidelijk gebroken. De controle die het opvangt is de omgekeerde: vermenigvuldig het resultaat terug met de deler die je denkt te hebben gebruikt en kijk of het originele gehele getal terugkomt. Het kost een seconde en het is de enige test die een eenheidsfout onderscheidt van een afrondingsfout.

Elk geheel getal tot 9.007.199.254.740.991 — een minder dan twee tot de drieënvijftigste, wat precies 8 PiB is — wordt exact voorgesteld door een double-precision float. Dat dekt elke opslagcijfer die de meeste systemen ooit zullen tegenkomen, wat verklaart waarom bytentellingen zonder afwijking door JSON, spreadsheets en JavaScript reizen, en waarom de conventie om bytes te rapporteren over een API meer dan pietluttigheid is.

Een cijfer afgerond op twee decimalen van TiB heeft al vier of vijf significante cijfers weggegooid voor iemand ze optelt. Tel honderd zulke cijfers op en de opgehoopte afronding is gigabytes; vergelijk het totaal met een uit bytes afgeleide en ze zullen niet kloppen, zonder dat één regel verantwoordelijk is. Bewaar de gehele getallen, doe de rekenkunde erop, en zet pas aan het eind eenmalig om.

Twee decimalen van een tebibyte is een precisie van ongeveer elf gibibyte, wat fijner is dan de meeste capaciteitsvragen gesteld worden en grover dan enige ervan nodig heeft. Drie is overbodig voor een mensgericht cijfer en één is meestal genoeg voor een rapport: 45,5 TiB communiceert alles wat 45,4749 doet, en nodigt niemand uit de laatste cijfers als betekenisvol te behandelen.

De uitzondering is een cijfer dat tegen een ander cijfer wordt vergeleken. Twee capaciteitsgetallen op één decimaal kunnen een vol procent verschillen terwijl ze identiek ogen, dus zou een reconciliatie op de bytentellingen moeten gebeuren en alleen de conclusie in tebibytes uitgedrukt. Precisie hoort waar de vergelijking plaatsvindt, niet waar het getal gelezen wordt.

Een omgezet cijfer zou zijn eenheid expliciet moeten dragen, en op deze schaal doorgaans ook de bytentelling. "45,47 TiB (50.000.000.000.000 bytes)" kan niet verkeerd gelezen worden, kan niet verkeerd herafgeleid worden, en laat de volgende lezer omzetten naar welke schaal hij ook werkt zonder te hoeven vragen welke conventie gebruikt is.

Dat is hier meer waard dan bij elk ander paar in deze categorie, want een cijfer op teraschaal eindigt vaak in een capaciteitsplan, een contract of een bestuursslide en wordt maanden later teruggehaald door iemand die er niet bij was toen het berekend werd. Het gehele getal is het deel dat waar blijft; het eenheidslabel is het deel dat voorkomt dat het verkeerd toegepast wordt.

Eén pebibyte is 1.125.899.906.842.624 bytes — twee tot de vijftigste — tegen een petabyte van 10 tot de vijftiende. De divergentie is weer verbreed, tot 12,59 procent, en een bytentotaal van zestien cijfers is waar de meeste mensen het voor het eerst tegenkomen. Het patroon houdt de hele ladder aan: elke prefixstap vermenigvuldigt de verhouding weer met 1,024, dus is exbi tegen exa 15,3 procent en convergeren de twee schalen nooit.

Op die omvang stoppen de eenheden een weergavevoorkeur te zijn en worden ze een aanschafvraag, want een tiende van een petabyte is een rack. Het is ook het punt waarop de exacte bytentelling het enige cijfer wordt dat de moeite waard is om tussen organisaties uit te wisselen, want een afgerond pebibyte-getal draagt een onzekerheid gemeten in terabytes. De gewoonte het gehele getal te noemen, wat op gibibyteschaal alleen netjes is, is hier onmisbaar.