KiB naar GB omrekenen

Een kibibyte is precies 1.024 bytes. De naam is in 1998 ingevoerd zodat «kilobyte» weer 1.000 kon betekenen, al is de gewoonte nooit helemaal aangeslagen.

Een gigabyte is een miljard bytes, in de decimale betekenis die schijffabrikanten, databundels en videogroottes hanteren.

De factor is 0,000001, en die draagt vrijwel niemand met zich mee. Afgerond op 0,000001 zit hij er 0,39 % naast — bij kleine getallen onzichtbaar, en rond 1.000 KiB een hele eenheid.

Dat is het getal dat je vóór het afronden wilt weten: niet de fout zelf, maar vanaf waar hij ophoudt verwaarloosbaar te zijn. Daaronder is de korte factor de verstandige; daarboven gebruik je het veld hierboven, dat pas afrondt op het moment van afdrukken.

Eén KiB is 1.024 van de eenheid eronder; één kB is 1.000. Op deze pagina is dat het verschil tussen 0 GB en 0 GB — 2,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.

De meetkant van een websysteem telt in binaire eenheden omdat de tools die het produceren dat doen. Een gemiddelde objectgrootte komt uit een bestandslijst, een buildrapport of een opslag­bucket-samenvatting, en die delen allemaal door 1.024.

De commerciële kant telt in decimale gigabyte, want zo wordt overdracht al verkocht sinds lang voor iemand de twee moest onderscheiden. Eén object merkt het verschil niet en een maand verkeer wel: een miljoen verzoeken van gemiddeld 250 KiB is 256.000.000.000 bytes, ofwel 256 GB.

De betrouwbare volgorde is zo lang mogelijk in bytes blijven. Neem de grootte per object in kibibyte, vermenigvuldig met 1.024 voor bytes, vermenigvuldig met het aantal, en deel pas dan door een miljard. Elke stap voor de laatste is een geheel getal en exact.

Het andersom doen — elk object naar gigabyte omzetten en de resultaten optellen — voert per item een afrondingsfout in, en het aantal items is precies de grootheid die het totaal groot maakt.

Toegangslogs registreren bytes, geen kibibyte, wat het enige goede nieuws in deze berekening is. Het bytes-sent-veld is een ruwe telling per verzoek, dus de kolom optellen en door een miljard delen geeft decimale gigabyte zonder enige eenheidsvraag.

Wat een log je ook vertelt dat een gemiddelde niet kan is de vorm van de verdeling. Een gemiddelde objectgrootte van 250 KiB kan tienduizend kleine antwoorden zijn en een handvol zeer grote, en een voorspelling gebouwd op het gemiddelde is in totaal correct en fout over elke operationele consequentie.

De payload is niet de overdracht. Responsheaders voegen bij elk verzoek honderden bytes toe, protocolonderhandeling kost bytes bij elke nieuwe verbinding, en doorverwijzingen versturen tweemaal. Op een vloot kleine objecten kan die overhead een serieus deel van het geheel zijn.

Dit is het vermelden waard naast de eenhedencorrectie, want de twee trekken dezelfde kant op. Meldt een provider meer gebruik dan de berekening voorspelde, dan verklaart het eenhedengat 2,4 procent daarvan en niet meer.

Neem de gemiddelde objectgrootte in kibibyte, vermenigvuldig met 1.024 voor bytes, vermenigvuldig met het verwachte aantal verzoeken, en deel door een miljard. Tien miljoen verzoeken van 100 KiB is 1.024.000.000.000 bytes, dat is 1.024 GB, ofwel 1,024 TB.

Pas dan de onzekerheid eerlijk toe. Een voorspelling die tot vier significante cijfers precies is over de eenheden en vaag met een factor twee over het aantal verzoeken is niet nauwkeuriger geworden door de omzetting.

Reconciliatie werkt het beste in bytes aan beide kanten. Zet de gefactureerde gigabytes van de provider terug om naar bytes door te vermenigvuldigen met een miljard, tel je eigen gelogde bytetellingen op, en vergelijk de twee gehele getallen.

Een verschil van ongeveer 2,4 procent wijst naar het kibibyte-tegenover-kilobyte-gat ergens in de keten, meestal in een samenvatting geproduceerd door een binaire tool en decimaal gelezen. Een verschil van 7,4 procent wijst naar dezelfde fout één voorvoegsel hoger.

Twee verschillende meters draaien op dezelfde objecten. Opslag wordt gefactureerd per capaciteit over tijd, meestal als gigabyte-maanden naar rato van het uur. Overdracht wordt per verplaatste gigabyte gefactureerd.

Beide meters tellen decimale gigabyte, wat betekent dat één omzetting beide dekt. Wat verschilt is waarmee het kibibyte-getal vermenigvuldigd moet worden: aantal objecten voor opslag, aantal verzoeken voor overdracht.

Postvakquota en API-antwoordlimieten worden vaak in binaire eenheden gedefinieerd door de software die ze handhaaft, en in decimale termen aan gebruikers gecommuniceerd, of andersom. Een toelage van 15 GB gehandhaafd als 15 GiB geeft elke gebruiker 1,11 GB meer dan beloofd.

De versie die wel klachten oplevert is het omgekeerde. Een toelage geadverteerd als 15 GB en gehandhaafd als 15.000.000.000 bytes lijkt krap voor elke gebruiker wiens client in gibibyte meldt. De oplossing is niet meer capaciteit; het is de eenheid noemen op dezelfde plek als het getal.