Cookies voor statistiek en advertenties
We gebruiken cookies voor statistiek en voor advertenties, allebei naar Google. Weigeren verandert niets aan wat je te zien krijgt.Lees de privacypagina
1 GB = 1000000000 B
Tik een waarde in en de omrekening van gigabyte naar byte loopt mee terwijl je typt. De factor is precies 1000000000: zoveel B komt er op 1 GB. De berekening gebeurt op je eigen apparaat; na het laden vraagt deze pagina geen server meer iets.
64 GB is 64000000000 B
— een eenvoudige telefoon.
1000 GB is 1000000000000 B
— een schijf die als een terabyte verkocht wordt.
0,005 GB is 5000000 B
— een foto die met de telefoon is gemaakt.
0,000001024 GB is 1024 B
— een kibibyte, en daar begint de verwarring.
| GB | B |
|---|---|
| 1 | 1000000000 |
| 2 | 2000000000 |
| 5 | 5000000000 |
| 10 | 10000000000 |
| 50 | 50000000000 |
| 100 | 100000000000 |
| 500 | 500000000000 |
| 1000 | 1000000000000 |
GB naar B omrekenen
Een gigabyte is een miljard bytes, in de decimale betekenis die schijffabrikanten, databundels en videogroottes hanteren.
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.
Van gigabytes naar bytes schuift de komma 9 plaatsen naar rechts, en verder verandert er niets. Geen factor om te onthouden en niets om af te ronden: de cijfers blijven in dezelfde volgorde staan, alleen hun plek verandert.
1.234 GB is 1234000000000 B — dezelfde cijfers, een stuk opgeschoven. Dat is het waard om te weten, want dit is de enige omrekening die je in één oogopslag controleert: staan er in de uitkomst andere cijfers dan waarmee je begon, dan heeft niet deze omrekening ze veranderd.
Genoeg instellingen nemen een getal aan zonder eenheid, en de documentatie zegt bytes. Een objectopslag-partgrootte, een verzoeklichaamlimiet, een buffergrootte in een databaseconfiguratie: allemaal willen ze een geheel getal, en dat getal voor één gigabyte is 1.000.000.000.
De reden om naar de binaire eenheid te grijpen in plaats van naar een rond decimaal getal is dat het omringende systeem vrijwel zeker al binair is. Geheugenpagina’s, blokgroottes en bufferoewijzingen 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-geheugen- en opslaglimieten werken zo.
De GNU coreutils gaan een stap verder en accepteren beide spellingen: een enkele letter is binair en een tweeletterige vorm eindigend op B is decimaal. dd bs=1G kopieert in blokken van 1.073.741.824 bytes en dd bs=1GB in blokken van 1.000.000.000.
Twee tot de macht tweeëndertig is 4.294.967.296, en dat getal is een muur in plaats van een conventie. Het is de grootste waarde die een 32-bit geheel getal zonder teken kan bevatten, dus alles dat een lengte in 32 bits opslaat stopt daar.
De grens duikt nog op waar het modern lijkt. Oudere archiefformaten, bepaalde uploadpaden en een lange staart aan drivers dragen 32-bit lengtes, en elk daarvan faalt ergens tussen 4,29 GB en 4,30 GB in plaats van bij een rond decimaal getal.
Interfaces die op grootte schaal werken nemen bytes aan, omdat bytes ondubbelzinnig zijn en de actie geautomatiseerd is. Objectopslag-levenscyclusregels filteren op een objectgrootte in bytes; cgroup-geheugenlimieten zijn bytewaarden.
Deze waarden worden ook vaak eenmaal geschreven en jarenlang geraadpleegd. Een levenscyclusregel die objecten boven 128 GB naar koudere opslag verplaatst blijft dat doen lang nadat iedereen die de drempel koos verder is gegaan.
Een deploymentmanifest specificeert routinematig geheugen en opslag naast elkaar, en de twee sectoren erachter gebruiken het voorvoegsel verschillend. Geheugen wordt geadresseerd in machten van twee, dus een module verkocht als 16 GB bevat 17.179.869.184 bytes.
Welke een platform bedoelt voor een bepaald veld is een documentatievraag en geen giswerk. Containerruntimes bedoelen doorgaans binaire eenheden voor geheugen; blokopslag en objectopslag zijn doorgaans decimaal.
Een geheugenlimiet die 7,4 procent kleiner is dan bedoeld faalt niet bij het uitrollen. Ze faalt zodra het proces de bovenkant van zijn normale werkbereik bereikt, wat onder belasting gebeurt — en ze faalt als een beëindiging in plaats van een foutmelding.
De verdediging is het bedoelde vergelijken met het draaiende systeem in plaats van met het bestand. Lees de limiet terug van het platform, in bytes, en vergelijk die met het bedoelde getal.
Tien cijfers in een configuratiebestand zijn op het eerste gezicht niet te verifiëren, en tien verkeerde cijfers zien er precies zo uit als tien juiste. Waar het formaat een echte taal is of rekenkunde ondersteunt, schrijf dan 4 1024 * 3.
Het is ook de moeite waard vast te leggen waarom het getal is wat het is. Een geheugenlimiet gekozen uit een profiel onder piekbelasting en een limiet gekozen omdat het de volgende tier was worden om totaal verschillende redenen herzien.
1 GB is 1000000000 B. De waarde is exact en niet afgerond: de verhouding tussen gigabyte en byte ligt per definitie vast.
Nee. De berekening gebeurt in je browser. Je kunt de verbinding verbreken en gewoon doorrekenen, en dat is meteen de eenvoudigste manier om het na te gaan.
Omdat twee verschillende eenheden dezelfde naam dragen. Fabrikanten rekenen 1 GB = 1.000.000.000 bytes; Windows toont gibibytes, dus 1.073.741.824 bytes, maar noemt ze «GB». Dezelfde schijf lijkt daardoor zeven procent kleiner. Er is niets verdwenen.
Eén B is 1e-9 GB. Het is dezelfde verhouding achterstevoren gelezen, dus een uitkomst van de ene pagina die je door de andere haalt, moet weer uitkomen waar hij begon.
Wat deze pagina over informatie-eenheden beweert, is na te gaan, en dit zijn de documenten die de zaak beslechten.
De factor is een constante op de pagina en de som is vier bewerkingen, dus er gaat niets ergens heen en er hoeft ook niets heen. Het getal dat je intikt verlaat de browser niet — er is geen verzoek waarin het zou kunnen meereizen.