B naar GiB 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 gibibyte is 1.073.741.824 bytes, ongeveer 7 % meer dan een gigabyte. Windows meet in gibibytes maar noemt ze «GB», en daarin zit het hele raadsel van de verdwenen ruimte.

Deze kant op is het een deling, en wel door een heel getal: er gaan er 1.073.741.824 in één gibibyte, 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 GiB is 1.024 van de eenheid eronder; één GB is 1.000. Op deze pagina is dat het verschil tussen 1073741824 B en 1000000000 B — 7,4 % — 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.

Software geeft groottes in bytes met een reden: een bytetelling heeft geen prefix om te interpreteren, geen afronding om ongedaan te maken en geen landinstelling erin, dus een metrics-scrape, een logregel en een API-respons zijn onderling te vergelijken zonder dat iedereen het eerst eens hoeft te worden over wat een G betekent. Precies die eigenschap maakt de getallen onleesbaar: 17.179.869.184 zegt niets totdat het door iets gedeeld is.

De juiste deler is 1.073.741.824 wanneer het omringende systeem binair rekent, wat voor geheugen, pagecache, bestandssysteemgebruik en de meeste besturingssysteemtellers het geval is. Dat cijfer geeft precies 16 GiB. Delen door een miljard in plaats daarvan geeft 17,18 en verbergt dat het getal een schone macht van twee was.

Tel voordat je iets omrekent de cijfers. Tien cijfers plaatst een getal tussen 0,93 en 9,3 GiB, elf tussen 9,3 en 93, twaalf tussen 93 en 931, en dertien cijfers komt uit rond een tebibyte. Die ene blik beantwoordt de meeste vragen die een bytetelling oproept — of een cache megabytes of gigabytes is — zonder enige rekensom.

Die gewoonte betaalt zich vooral uit bij uitvoer die schalen mengt. Een metrics-endpoint dat een dozijn bytetellers teruggeeft, heeft sommige in de miljoenen en andere in de miljarden, en het oog sorteert ze sneller op lengte dan op waarde.

Sommige getallen zijn op het zien af te herkennen omdat ze zichzelf aankondigen. 1.073.741.824 is een gibibyte, 2.147.483.648 zijn er twee, 4.294.967.296 vier, 8.589.934.592 acht. Verschijnt zo’n getal in een uitvoer, dan is het bijna altijd een capaciteit of een limiet in plaats van een meting, want metingen komen zelden exact op een macht van twee uit.

Het omgekeerde geldt evengoed. Een bytetelling die eindigt op een lange reeks nullen — 1.000.000.000, 50.000.000.000 — is getypt door een mens of afgeleid van een decimaal cijfer, en komt niet overeen met iets dat de hardware vanzelf doet.

Talen die alle getallen als double-precision floats opslaan, houden gehele getallen exact tot 9.007.199.254.740.991, ofwel 2⁵³ min één, ongeveer 8 PiB. Onder dat plafond is een bytetelling veilig; erboven rondt de waarde stilzwijgend af, en twee verschillende groottes kunnen als gelijk vergeleken worden zonder dat er een fout gemeld wordt.

De meeste systemen komen daar nooit, en de systemen die dat wel doen, doen het meestal in totalen — een som over een machinepark, een levenslange transferteller — eerder dan per bestand. De bescherming is bytetellingen in 64-bit gehele getallen of strings te bewaren over een serialisatiegrens heen.

De meeste hulpmiddelen hebben een modus die hun leesbare opmaak onderdrukt, en die is de moeite waard telkens wanneer de uitvoer ergens anders naartoe gaat dan een scherm. Schijfruimte-tools accepteren een blokgrootte van één, en object-storage-API’s geven een contentlengte in bytes standaard terug. Al die bronnen zijn verliesloos, iets wat een al opgemaakte 1,4 GiB niet is.

Het verlies is achteraf niet te herstellen. Een als 1,4 GiB getoond cijfer kan van alles zijn tussen 1.449.551.462 en 1.556.925.644 bytes, een spreiding van ruim 100 MB, en geen vermenigvuldiging vernauwt die onzekerheid.

De regel die de meeste discussies vermijdt, is weergeven in de eenheid waarin het gemeten systeem zelf telt. Geheugen, pagecache en bestandssysteemgebruik zijn binair, dus een grafiek daarvan hoort in GiB. Object-storage-totalen en al wat op een factuur staat, zijn decimaal, dus die horen in GB.

Welke eenheid ook gekozen wordt, het aslabel moet zeggen welke het is. Een geheugengrafiek gelabeld als GB terwijl hij deelt door 2³⁰, herhaalt precies de fout die Windows maakt, op een plek waar iemand het ooit vergelijkt met een decimaal cijfer op een rekening.

Twee tools kunnen allebei exacte bytetellingen geven en toch van mening verschillen, omdat ze verschillende dingen tellen. Een bestandslengte is niet de ruimte die het inneemt, een opgeslagen grootte is niet een overgedragen grootte zodra compressie in het spel is. Omzetten naar gibibytes maakt ze visueel vergelijkbaar zonder ze dat echt te maken.

Wat helpt, is bij het cijfer noteren wat het meet. Een metriek genoemd naar zijn eenheid maar niet naar zijn onderwerp — bytes, size, total — wordt vroeg of laat opgeteld bij iets anders dat iets anders betekende.

De goedkoopste controle is de bewerking omkeren. Neem het gibibyte-cijfer, vermenigvuldig met 1.073.741.824 en vergelijk met de oorspronkelijke cijferreeks. Wijkt het resultaat ongeveer zeven procent af, dan was de deler een miljard in plaats van 2³⁰; is het een factor 1.024 verkeerd, dan is er ergens een prefix overgeslagen.

Zit een omzetting ingebakken in code in plaats van met de hand gedaan te worden, dan hoort dezelfde controle in een test met een bekend paar: 5.368.709.120 bytes is 5 GiB, en elke implementatie die 5,37 oplevert, gebruikte de decimale deler.