KiB naar B 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 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 kibibyte is 1.024 bytes, precies, en 1.024 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 KiB is 1.024 van de eenheid eronder; één kB is 1.000. Op deze pagina is dat het verschil tussen 1024 B en 1000 B — 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 rekenkunde is het minste ervan: vermenigvuldig met 1.024 en de bytentelling is exact. Wat deze pagina de moeite waard maakt, is dat het broncijfer onder een half dozijn verschillende labels aankomt. Kernelinterfaces drukken kB af en bedoelen kibibytes. Gereedschappen aangeroepen met een k-vlag rapporteren in kibibytes en zeggen niets. Documentatie geschreven na 1998 zegt KiB en bedoelt het. Alle drie beschrijven dezelfde eenheid van 1.024 bytes.

Dat laat de lezer een identificatiestap doen voor de vermenigvuldiging. De betrouwbare test is het gereedschap eerder dan het label: alles dat geheugen- of blokgebruik op een Unix-achtig systeem rapporteert, telt in eenheden van 1.024 tenzij het expliciet om SI-eenheden gevraagd is. Alles dat een bestandsgrootte aan een mens opgeeft — een downloadpagina, een uploadlimiet, een netwerkoverdrachtscijfer — bedoelt eerder duizend.

Het opgeslagen blokaantal van een bestand wordt uitgedrukt in eenheden van 512 bytes, en dat is zo sinds de interface gedefinieerd werd, ongeacht wat het filesystem eronder daadwerkelijk toewijst. Een bestand dat één blok van 4.096 bytes inneemt, rapporteert dus acht blokken. Hetzelfde bestand onder du -k rapporteert 4, want dat gereedschap telt in kibibytes. Geen van beide cijfers is fout en geen kan tegen het andere vergeleken worden zonder te weten welk blok elk bedoelt.

De praktische regel is alles naar bytes om te zetten voor je iets vergelijkt. Acht blokken van 512 bytes en vier kibibytes zijn beide 4.096 bytes, en die overeenkomst is onzichtbaar tot beide zo uitgedrukt worden. Scripts die een opgeslagen blokaantal tegen een kibibyte-totaal vergelijken zonder te normaliseren zitten er een factor twee naast, en de fout is stabiel genoeg om als een echte discrepantie te ogen in plaats van een bug.

Twee verschillende vragen verbergen zich achter het woord grootte. De lengte van een bestand is het aantal bytes dat het bevat; de ruimte die het inneemt is het aantal toegewezen blokken vermenigvuldigd met de blokgrootte. Voor een configuratiebestand van 100 bytes is dat 100 bytes en 4.096 bytes, een verschil van veertig keer, en elk is het juiste antwoord op een andere vraag.

De kloof loopt beide kanten op. Een sparse bestand — een met ongeschreven gedeelten die nooit toegewezen zijn — rapporteert een lengte veel groter dan de blokken die het bevat, wat waarom een virtuele-schijfimage als 40 GiB kan staan en 3 kan innemen. Een kibibyte-blokaantal naar bytes omzetten vertelt je wat de opslag draagt; een lengte omzetten vertelt je wat een kopie van het bestand oplevert. Back-upschattingen die het verkeerde gebruiken zijn zo fout als de spaarzaamheid toevallig is.

Shell-resourcelimieten mengen hun eenheden en de mix is niet duidelijk uit de uitvoer. De stackgrootte-limiet en de virtuele-geheugenlimiet zijn in kibibytes, dus betekent een stacklimiet van 8192 8.388.608 bytes. De bestandsgroottelimiet is standaard in blokken van 512 bytes in bash. Een set limieten lezen alsof ze een eenheid delen, levert een geheugenplafond op dat een factor twee de verkeerde kant op zit.

De reden om ze überhaupt om te zetten is meestal dat iets anders in bytes is uitgedrukt. Een proces dat faalt met een geheugenfout rapporteert de toewijzing die het probeerde in bytes; dat vergelijken met een limiet gerapporteerd in kibibytes kost één vermenigvuldiging en verandert een gok in een antwoord. Blijkt de limiet nergens in de buurt van de falende toewijzing te liggen, dan zit de oorzaak elders, en dat snel weten is de rekenkunde waard.

Onder een bepaalde granulariteit stopt de bytentelling het nuttige getal te zijn. Geheugen wordt in pagina’s uitgedeeld, en op de meeste systemen is een pagina 4.096 bytes. Filesystemen wijzen toe in blokken, en de gangbare standaard is hetzelfde cijfer. Schijven met de nieuwere sectorindeling presenteren sectoren van 4.096 bytes. De lagen sluiten netjes op elkaar aan omdat ze allemaal dezelfde macht van twee kozen, en een grootte die er een veelvoud van is, gaat er zonder verspilling doorheen.

Die uitlijning is waarom buffergroottes, cache-items en recordlengtes zich rond veelvouden van 4.096 verzamelen. Een lezing van 4.000 bytes raakt dezelfde pagina als een lezing van 4.096 en kost hetzelfde; een record van 4.100 bytes overspant twee blokken en kost het dubbele van de schrijfacties die het lijkt te vragen. Een kibibyte-cijfer naar bytes omzetten is vaak de eerste stap om te controleren of een grootte op die grens ligt of er net voorbij.

Op deze schaal is het verschil tussen een kilobyte en een kibibyte 24 bytes, en voor de meeste doeleinden verdwijnt dat in afronding. Een paginagewicht opgegeven als 500 kB verschilt niet betekenisvol van 500 KiB, en over het onderscheid discussiëren op één bestand is slecht bestede tijd.

Het wordt materieel als het vermenigvuldigd wordt. Een miljoen records van 4 KiB elk is 4.096.000.000 bytes, geen 4.000.000.000, en een capaciteitsplan gebouwd op het tweede cijfer is 96 MB tekort voor er iets onverwachts gebeurt. Hetzelfde geldt voor per-verzoekboekhouding, quotumberekeningen en al het andere waar een kleine eenheid een groot aantal keren geteld wordt: de kloof groeit niet, maar het aantal waarmee hij vermenigvuldigd wordt wel.

Niet elke k is 1.024, en het tegendeel aannemen is een eigen fout. Netwerkdoorvoer, overdrachtstoelagen, opslagcapaciteiten en alles op verpakkingen zijn decimaal, dus is een kilobyte in die contexten 1.000 bytes en overschat vermenigvuldigen met 1.024 het resultaat met 2,4 procent. Dezelfde lezer die geleerd heeft een k in shell-uitvoer te wantrouwen, moet onthouden hem op een factuur te vertrouwen.

De regel die beide dekt zonder veel nadenken: beschrijft het getal wat een machine intern doet, dan is het binair; beschrijft het wat verkocht, overgedragen of geadverteerd wordt, dan is het decimaal. Die vuistregel is niet perfect, maar de uitzonderingen kondigen zich aan — een gereedschap dat 1.000 bedoelt heeft meestal een vlag die dat zegt, en een dat 1.024 bedoelt heeft meestal documentatie die het toegeeft.

Bytentellingen blijven exact in elk geheeltallig type breed genoeg om ze te bevatten, en een kibibyte-cijfer vermenigvuldigd met 1.024 blijft ook exact. Problemen beginnen als een waarde al is afgerond voor weergave: een gereedschap dat 1,4 KiB afdrukt heeft de bytentelling weggegooid, en het afgeronde cijfer terug vermenigvuldigen geeft iets tussen 1.382 en 1.485. Het origineel herstellen is niet mogelijk, dus neem de bytentelling van de bron in plaats van van de samenvatting waar beide bestaan.

De meeste gereedschappen leveren op verzoek ruwe bytes, en die uitvoer is degene om in iets geautomatiseerds te voeren. Mensvriendelijke opmaak is een weergavekeuze gemaakt op het laatste moment, en die als data behandelen is hoe een monitoringpijplijn eindigt met groottes die zonder verklaarbare reden een paar procent driften.