GiB naar MiB omrekenen

GiB
1024MiB

1 GiB = 1024 MiB

Tik een waarde in en de omrekening van gibibyte naar mebibyte loopt mee terwijl je typt. De factor is precies 1024: zoveel MiB komt er op 1 GiB. De berekening gebeurt op je eigen apparaat; na het laden vraagt deze pagina geen server meer iets.

  • Waar het draait In je browser. Het getal dat je intikt komt nooit in een verzoek terecht.
  • Exact per definitie 1 GiB is precies 1024 MiB — een definitie, geen afgeronde factor.
  • Antwoordt terwijl je typt Geen knop, geen wachten. Het antwoord staat al op de pagina voordat er een script draait.

gibibyte naar mebibyte in de praktijk

  • 16 GiB is 16380 MiB

    — het geheugen van een middenklasse laptop.

  • 931 GiB is 953300 MiB

    — wat Windows toont bij een schijf van een terabyte.

  • 0,6836 GiB is 700 MiB

    — een audio-cd, waar dat getal vandaan komt.

  • 0,007813 GiB is 8 MiB

    — een geheugenblok zoals een programma dat reserveert.

gibibyte en mebibyte in één oogopslag

Elk getal in deze tabel is berekend uit dezelfde definitie als de rekenmachine gebruikt, dus de tabel kan niet afwijken van het antwoord hierboven.
GiBMiB
11024
22048
55120
1010240
5051200
100102400
500512000
10001024000

gibibyte en mebibyte

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 mebibyte is 1.024 kibibyte, oftewel 1.048.576 bytes. De hulpmiddelen van Linux en de geheugengetallen bedoelen vrijwel altijd dit, ook als er «MB» staat.

Eén gibibyte is precies 1.024 mebibytes

Deze kant op is het een vermenigvuldiging, en wel met een heel getal: één gibibyte is 1.024 mebibytes, 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.

GiB is de binaire eenheid

Eén GiB is 1.024 van de eenheid eronder; één GB is 1.000. Op deze pagina is dat het verschil tussen 1024 MiB en 953,6743 MiB — 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.

Hypervisors willen mebibytes, catalogi noemen gibibytes

QEMU’s -m is een kaal aantal mebibytes. virt-install neemt --memory in mebibytes. De meeste cloud- en hypervisor-API’s van vóór de IEC-voorvoegsels gebruiken een veld genaamd memoryMB, en de waarde is binair ongeacht het label. Ondertussen is elke instantiecatalogus in gibibytes geschreven, dus de omzetting gebeurt precies op het punt waar een maat ophoudt een beslissing te zijn en een configuratie wordt.

libvirt is de uitzondering om te kennen, want zijn domain-XML zet het memory-element standaard op kibibytes in plaats van mebibytes. Een gast van 8 GiB is <memory unit='KiB'>8388608</memory>, en een waarde die op een typefout lijkt, is meestal de andere eenheid. Het element accepteert een expliciet unit-attribuut, en unit='GiB' schrijven in een sjabloon dat mensen bewerken, verwijdert de vraag permanent.

De host geeft meer op dan het getal dat je typte

Een gast toegewezen 8.192 MiB kost de host dat bedrag voor de eigen pagina’s van de gast plus een reeks structuren die alleen bestaan omdat de machine virtueel is. Geneste paginatabellen brengen gast-fysiek naar host-fysiek in kaart en groeien met de adresruimte van de gast. Het apparaatmodel draait als hostproces met een eigen heap. Geëmuleerd videogeheugen is een echte toewijzing.

Het totaal is meestal een klein percentage in plaats van een vast getal, wat verklaart waarom een host die probleemloos acht gasten van 8 GiB draaide, mogelijk geen vier gasten van 16 GiB aankan ondanks identiek rekenwerk. Een host dimensioneren door de toegewezen mebibytes op te tellen en te vergelijken met geïnstalleerd geheugen laat niets over voor de hypervisor zelf.

Toegewezen, aangeraakt, en wat ballooning ertussen verplaatst

Gastgeheugen wordt doorgaans pas bij eerste gebruik toegewezen, dus een net opgestarte gast met 16.384 MiB toegewezen verbruikt op de host mogelijk een tiende daarvan. De balloon-driver laat de hypervisor meer terugvorderen: hij zwelt op binnen de gast, de gastkernel geeft pagina’s vrij om eraan te voldoen, en de hypervisor neemt ze terug.

Het gevolg voor capaciteitsberekeningen is dat er drie getallen per gast zijn en er maar één in het configuratiebestand staat. Toegewezen is wat je typte; het balloon-doel is wat de hypervisor momenteel toestaat; resident is wat de host daadwerkelijk heeft vastgelegd.

Huge pages maken het mebibyte-cijfer minder onderhandelbaar

Een gast met huge pages ondersteunen verwijdert een niveau paginatabel-doorloop en levert een meetbare winst op bij geheugenintensieve workloads, maar verandert het rekenwerk. Pagina’s worden 2 MiB in plaats van 4 KiB, dus de toewijzing moet een veelvoud van 2 MiB zijn; de pool moet vooraf op de host gereserveerd worden en is niet beschikbaar voor iets anders.

Dat maakt van 8.192 MiB een verplichting van 4.096 huge pages, en het betekent dat overcommit voor die gast uit staat. Het betekent ook dat de pool van de host in dezelfde eenheden gedimensioneerd moet worden: 65.536 huge pages reserveren is 128 GiB, en een host die meer reserveert dan zijn gasten gebruiken, heeft dat geheugen aan al het andere onttrokken.

NUMA, en waarom het totaal netjes moet delen

Op een host met meer dan één geheugennode moet een gast groter dan een node gesplitst worden, en die splitsing is veel beter bewust gemaakt dan aan de scheduler overgelaten. Een gast van 12.288 MiB over twee nodes is 6.144 elk, wat netjes is; dezelfde gast op 12.000 MiB is 6.000 elk, wat rekenkundig prima is en lastig tegen huge pages en elke reservering per node.

De faalmodus wanneer het impliciet blijft, is remote geheugentoegang: een virtuele cpu vastgepind op één node die pagina’s leest die op de andere leven, betaalt een latentiestraf bij elke toegang. virsh numatune en de eigen NUMA-topologie van de gast worden allebei geconfigureerd in mebibytes per node.

Overcommit-rekenwerk, en waar het ophoudt gratis te zijn

De toegewezen mebibytes over gasten optellen en delen door het geheugen van de host geeft een overcommit-ratio, en ratio’s tot ongeveer 1,5 zijn gangbaar bij workloads met inactieve gasten. De reden dat het werkt, is dat toegewezen een plafond is en de meeste gasten er nooit tegenaan komen. De reden dat het faalt, is dat gasten die dat wel doen, dat vaak tegelijk doen.

Het getal om naast de ratio te volgen, is het vrije geheugen van de host in mebibytes op piekmoment in plaats van gemiddeld, en wat te vermijden is dat de host naar swap grijpt. Een gast wiens pagina’s door de host geswapt worden, ervaart dat als geheugen dat duizend keer trager is geworden zonder enige indicatie waarom.

Een gast van formaat veranderen, en het blok waarin hotplug werkt

Geheugen-hotplug voegt geen willekeurige hoeveelheden toe. De gast toont een blokgrootte — vaak 128 MiB op x86-64 — en geheugen komt binnen in hele blokken, dus een verzoek om 1.000 MiB wordt acht blokken en 1.024 MiB. Verwijderen is lastiger dan toevoegen, want de gastkernel moet het blok eerst leegmaken.

De praktische aanpak is dimensioneren op de werkende set met de speling die de workload verdient, en het naar beneden aanpassen van formaat behandelen als een herstart in plaats van een online bewerking. Waar een gast echt moet variëren, is de balloon het mechanisme dat het goed afhandelt en hotplug degene die groei boven het oorspronkelijke plafond afhandelt.

GiB naar MiB omrekenen: veelgestelde vragen

Hoeveel is 1 GiB in MiB?

1 GiB is 1024 MiB. De waarde is exact en niet afgerond: de verhouding tussen gibibyte en mebibyte ligt per definitie vast.

Wordt wat ik intik ergens heen gestuurd?

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.

Waarom toont mijn schijf minder ruimte dan erop staat?

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.

Andersom: mebibyte naar gibibyte

Eén MiB is 0,000976563 GiB. 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.

Waar deze cijfers vandaan komen

Wat deze pagina over informatie-eenheden beweert, is na te gaan, en dit zijn de documenten die de zaak beslechten.

Hoe deze pagina werkt

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.