B naar KiB 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 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.

Deze kant op is het een deling, en wel door een heel getal: er gaan er 1.024 in één kibibyte, 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 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.

Draai ls -l en je krijgt een exact aantal bytes, wat het bestandssysteem vastlegt en wat elke API die een grootte rapporteert teruggeeft. Draai ls -lh op hetzelfde bestand en je krijgt iets als 24K. Er is niets aan het bestand veranderd tussen de twee commando’s — het tweede deelde door 1.024, rondde af, en plakte een letter erachter die niet zegt welke schaal gebruikt is.

Dat is de reden om bytes met de hand om te zetten naar KiB. Het exacte getal is degene dat moet overeenkomen met een header, een hashgrens of een quotum; het afgeronde getal is wat een collega je terugzegt vanuit een terminal. Kunnen schakelen tussen beide zonder te gokken welke basis het gereedschap gebruikte, is de hele vaardigheid hier.

GNU coreutils gebruikt hoofdletter K, M en G voor machten van 1.024 en kleine letter k voor 1.000, een conventie die bijna niemand kent en geen enkel gereedschap aankondigt. du -h rapporteert binair. du --si rapporteert decimaal op dezelfde map en verschilt 2,4 procent op de kilo-stap. df zonder opties drukt blokken van 1 KiB af; df -h is binair; df -H is decimaal.

Het praktische gevolg is dat "hoe groot is deze map" twee correcte antwoorden heeft van hetzelfde commando, en welk je krijgt hangt af van een vlag die iemand een week geleden in een script typte. Gaat een getal een ticket of een capaciteitsplan in, noteer dan de vlag erbij, of zet eerst om naar bytes en laat de lezer zelf een schaal kiezen.

Geheugen wordt geadresseerd via lijnen die hoog of laag zijn, dus de hoeveelheden die een machine van nature aangrijpt zijn machten van twee. Tien adreslijnen bereiken 1.024 locaties, dicht genoeg bij duizend om het kilo-prefix te lenen, en de lening is nooit teruggedraaid. Dat is het historische ongeluk waar de hele binair-versus-decimaal-discussie uit voortkomt.

Het is niet alleen historisch. Bestandssystemen wijzen blokken toe die machten van twee zijn, geheugenpagina’s zijn 4.096 bytes op gewone hardware, en schijven gingen van sectoren van 512 bytes naar sectoren van 4.096 bytes. Bytes omzetten naar kibibytes komt daarom uit op echte grenzen; bytes omzetten naar decimale kilobytes geeft een netter getal waar niets eronder op gebouwd is.

Elk getal op deze pagina telt bytes. Content-Length, bestandsgroottes, buffergroottes en schijfgebruik zijn allemaal bytentellingen, en een byte is al acht bits sinds de conventie zich vestigde — vroege machines gebruikten zes, zeven of negen, en de byte van acht bits won mede omdat hij één teken bevat en netjes halveert.

Bitrates zijn de uitzondering die bijt. Verbindingssnelheden, bandbreedtelimieten en encoderinstellingen worden in bits per seconde opgegeven, dus verplaatst een verbinding van 100 Mbit/s hoogstens 12,5 MB per seconde, en de twee cijfers zonder na te denken door elkaar delen geeft een antwoord dat een factor acht fout is. De letterkast is het enige signaal: Mb is megabit, MB is megabyte.

Een bestand van 900 bytes is 900 bytes lang en neemt 4.096 bytes van het volume in, want opslag wordt in hele blokken uitgedeeld. ls -l rapporteert het eerste getal en du het tweede, wat verklaart waarom een map kleine bestanden meerdere keren kan innemen wat de inhoud optelt. du --apparent-size zet du om naar de bytentelling en laat de twee weer overeenkomen.

Dat doet er het meest toe aan de kleine kant, precies waar een bytes-naar-KiB-omzetting leeft. Tienduizend configuratiebestanden van 200 bytes elk zijn 2 MB aan inhoud en ruwweg 40 MiB aan schijf. Kwam het getal van een quotumtool, dan is het waarschijnlijk toegewezen grootte; kwam het van een length-header, dan is het inhoud.

Coreutils rondt zijn leesbare groottes naar boven af in plaats van naar het dichtstbijzijnde, dus drukt een bestand van 1.025 bytes zich af als 1,1K ook al zou 1,0 dichterbij liggen. De regel is dat de weergave nooit minder mag beweren dan er is. Andere gereedschappen ronden naar het dichtstbijzijnde af, en bestandsbeheerders knippen vaak simpelweg af, wat verklaart hoe drie programma’s drie groottes voor één bestand produceren die allemaal verdedigbaar ogen.

Je kunt dit bewust gebruiken. Maak een bestand van precies 1.025 bytes, list het, en lees het antwoord: 1,1K betekent afronding in coreutils-stijl op een basis van 1.024, 1,0K betekent afronden naar het dichtstbijzijnde, 1,0k of 1,1k betekent de decimale schaal. Dat kost tien seconden en beslecht een discussie die anders een middag duurt.

Sommige getallen overleven geen omzetting. Een Content-Length moet de exacte bytentelling zijn of het antwoord is misvormd. Een Range-header adresseert byte-offsets. Een multipart-upload heeft een minimum onderdeelgrootte in bytes. Een geheugentoewijzing is een geheel aantal bytes, en het afronden naar een vriendelijke eenheid is hoe een off-by-one-block-bug ontstaat.

Zet dus om voor de mens en bewaar het geheel getal voor de machine. De nuttige discipline is overal bytes op te slaan in code en logs, en pas op het moment van weergave om te zetten, met KiB als label in plaats van KB, zodat de volgende persoon niet hoeft uit te zoeken welk duizendtal je bedoelde.

Een sparse bestand is er een waarvan de ongeschreven gedeelten als gaten worden vastgelegd in plaats van als nullen opgeslagen, en het breekt de relatie tussen een bytentelling en een hoeveelheid schijf in de tegenovergestelde richting van blokafronding. Een virtuele-machine-image aangemaakt op 40 GB kan enkele honderden kibibytes innemen tot iets erin schrijft. ls -l rapporteert de volledige logische lengte, want dat beweert het bestand te zijn; du rapporteert het kleine toegewezen getal, want dat bestaat er echt.

Dit is de moeite waard om te weten voor je een bytentelling omzet, want de twee gereedschappen beantwoorden verschillende vragen en maar een daarvan is de vraag die jij hebt. Gaat het getal een capaciteitsplan in, dan is het toegewezen cijfer het eerlijke en zal het groeien. Gaat het getal een overdrachtsschatting in, dan is het logische cijfer wat een naïeve kopie daadwerkelijk zal schrijven, en heeft de bestemming alles nodig tenzij het kopieergereedschap gaten begrijpt.