GiB naar B omrekenen

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.

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.

Deze kant op is het een vermenigvuldiging, en wel met een heel getal: één gibibyte is 1.073.741.824 bytes, precies, en 1.073.741.824 is de definitie en geen meting die er dichtbij kwam.

Daarmee is het een van de weinige omrekeningen die je uit je hoofd kunt doen, en de uitkomst is controleerbaar: deel terug en je moet precies op je begingetal uitkomen, zonder rest die je moet wegpraten.

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.

Genoeg instellingen nemen een getal zonder eenheid aan, en de documentatie zegt bytes. Een objectopslag-partgrootte, een verzoeklichaamlimiet, een quota in een API-aanroep: allemaal willen ze een geheel getal, en dat getal voor één gibibyte is 1.073.741.824.

De reden om de binaire eenheid te kiezen in plaats van een rond decimaal getal is dat het omringende systeem vrijwel zeker al binair is. Geheugenpagina’s, blokgroottes en adresbereiken zijn machten van twee.

De conventie in operationele tooling is dat een kale k, m of g 1.024, 1.048.576 of 1.073.741.824 betekent. De JVM-heapvlaggen werken zo, dus -Xmx4g reserveert 4.294.967.296 bytes. Docker- en systemd-limieten werken hetzelfde.

De GNU coreutils accepteren beide spellingen: een enkele letter is binair, een tweeletterige vorm eindigend op B is decimaal. dd bs=1G en dd bs=1GB zien er in een shellgeschiedenis bijna identiek uit en verschillen zeven procent per blok.

Resourcehoeveelheden in Kubernetes dragen het onderscheid in hun syntax. Een achtervoegsel Gi is binair, dus 1Gi is 1.073.741.824 bytes; een achtervoegsel G zonder i is decimaal, dus 1G is 1.000.000.000.

Die duidelijkheid heeft een scherpe rand. Een geheugenlimiet geschreven als 4G in plaats van 4Gi is 294.967.296 bytes kleiner, wat ongeveer zeven procent scheelt en volledig onzichtbaar is bij een code review.

Een handvol bytetellingen komt herhaaldelijk voor in foutmeldingen en limietvelden, en ze kennen bespaart een omzetting. 1.048.576 is een mebibyte, 1.073.741.824 is een gibibyte, en 4.294.967.296 is 2³² — precies de grootte van een 32-bit adresruimte.

Eén minder dan die getallen telt net zo zwaar. 2.147.483.647 is het grootste 32-bit gehele getal met teken, en elke bytetelling daarin bewaard stopt daar. Een bestand dat bij 1,9 GiB uploadt en bij 2,1 faalt ontmoet meestal die grens.

Luide fouten zijn het gelukkige geval. Een container die zijn geheugenlimiet overschrijdt wordt beëindigd met een herkenbare status; een upload boven een lichaamsgrootte-limiet wordt geweigerd met een statuscode.

De stille fouten kosten meer. Een heap zeven procent boven wat de container toestaat faalt niet bij het opstarten — hij faalt weken later, onder belasting, wanneer het proces het geheugen probeert te gebruiken dat hem beloofd was.

Een configuratieregel die 8589934592 leest vertelt een reviewer niets over de bedoeling. Dezelfde waarde geschreven als 8 1024 1024 * 1024 waar het formaat een expressie toelaat is in één oogopslag controleerbaar.

Waar de syntax een achtervoegsel toelaat, verdient het de voorkeur boven de uitgeschreven cijfers. Vrijwel elke typfout in 1Gi is een syntaxfout, en de ene die dat niet is — de i vergeten — kost zeven procent.

De reeks gaat door met factoren van 1.024: een tebibyte is 2⁴⁰, ofwel 1.099.511.627.776 bytes, en een pebibyte is 2⁵⁰. Beide verschijnen in limieten eerder dan in metingen — maximale objectgroottes, adresruimteplafonds.

Het plafond dat er in de praktijk het meest toe doet zit boven ze allemaal. Een 64-bit geheel getal zonder teken bereikt 16 EiB, wat geen huidig systeem benadert, dus bytetellingen in moderne code lopen niet over.

Wat er ook geschreven werd, lees de effectieve waarde terug van het systeem in plaats van het bestand te vertrouwen. Containerruntimes tonen het geheugenplafond dat ze toegepast hebben, en de meeste servers melden hun geparste configuratie.

Dit telt het meest waar twee lagen elk een limiet in een andere eenheid opleggen. Een proceslimiet geschreven in gibibyte binnen een container waarvan de limiet in decimale gigabyte staat laat een gat van zeven procent dat niemand plande.