De ene dag is het leuk om naar het oppervlakniveau van de computerervaring te kijken, en andere dagen is het leuk om je in de innerlijke werking te verdiepen. Vandaag bekijken we de structuur van het computergeheugen en hoeveel dingen je in een RAM-geheugen kunt stoppen.
De vraag- en antwoordsessie van vandaag komt tot ons dankzij SuperUser - een onderdeel van Stack Exchange, een community-gedreven groepering van Q & A-websites.
De vraag
SuperUser-lezer Johan Smohan worstelt met hoe processortype en geheugengrootte samenwerken om een totaal aantal adressen op te leveren. Hij schrijft:
Hoeveel geheugenadressen kunnen we krijgen met een 32-bits processor en 1 GB werkgeheugen en hoeveel met een 64-bits processor?
Ik denk dat het ongeveer zo is:
1 GB RAM gedeeld door 32 bits 4 bits (?) Om het aantal geheugenadressen te krijgen?
Ik las op Wikipedia dat 1 geheugenadres 32 bits breed is of 4 octetten (1 octet = 8 bits), vergeleken met een 64 bits processor waar 1 geheugenadressen of 1 geheel getal 64 bits breed of 8 octetten is. Maar ik weet niet of ik het ook goed heb begrepen.
Dit zijn het soort vragen dat een nieuwsgierige nerd 's nachts wakker kan houden. Hoeveel adressen zijn beschikbaar onder elk van de hypothetische systemen van Johan?
Het antwoord
SuperUser-bijdrager Gronostaj biedt enig inzicht in hoe de RAM is verdeeld en gebruikt:
Kort antwoord: Het aantal beschikbare adressen is gelijk aan het kleinste aantal:
- Geheugengrootte in bytes
- Grootste geheel getal zonder teken dat kan worden opgeslagen in het computerwoord van de CPU
Lang antwoord en uitleg van het bovenstaande:
Geheugen bestaat uit bytes (B). Elke byte bestaat uit 8 bits (b).
1 B = 8 b1 GB RAM is eigenlijk 1 GiB (gibibyte, niet gigabyte). Het verschil is:
1 GB = 10 ^ 9 B = 1000000000 B 1 GiB = 2 ^ 30 B = 1073741824 BElke geheugenbyte heeft zijn eigen adres, ongeacht hoe groot het woord van de CPU-machine is. Bijv. De Intel 8086 CPU was 16-bits en het adresseerde geheugen in bytes, net als moderne 32-bits en 64-bits CPU's. Dat is de oorzaak van de eerste limiet: u kunt niet meer adressen dan geheugenbytes hebben.
Het geheugenadres is slechts een aantal bytes dat de CPU vanaf het begin van het geheugen moet overslaan om bij het geheugen te komen waarnaar het zoekt.
- Om toegang te krijgen tot de eerste byte moet het 0 bytes overslaan, dus het adres van de eerste byte is 0.
- Om toegang te krijgen tot de tweede byte moet het 1 byte overslaan, dus het adres is 1.
- (enzovoorts…)
- Om toegang te krijgen tot de laatste byte, slaat de CPU 1073741823 bytes over, dus het adres is 1073741823.
Nu moet je weten wat 32-bit eigenlijk betekent. Zoals ik al eerder zei, is het zo groot als een machinewoord.
Machinewoord is de hoeveelheid geheugen die de CPU gebruikt om getallen vast te houden (in RAM, cache of interne registers). 32-bits CPU gebruikt 32 bits (4 bytes) om nummers vast te houden. Geheugenadressen zijn ook nummers, dus op een 32-bits CPU bestaat het geheugenadres uit 32 bits.
Denk hier nu eens over na: als je één bit hebt, kun je er twee waarden op opslaan: 0 of 1. Voeg nog een bit toe en je hebt vier waarden: 0, 1, 2, 3. Op drie bits kun je acht waarden opslaan : 0, 1, 2 ... 6, 7. Dit is eigenlijk een binair systeem en het werkt als volgt:
Binair decimaal 0 0000 1 0001 2 0010 3 0011 4 0100 5 0101 6 0110 7 0111 8 1000 9 1001 10 1010 11 1011 12 1100 13 1101 14 1110 15 1111Het werkt precies zoals normaal optellen, maar het maximale cijfer is 1, niet 9. Decimaal 0 is
0000, dan tel je er 1 bij op en krijg je0001, voeg er nog een toe en je hebt0010. Wat hier is gebeurd, is als het hebben van een decimaal09en er één toevoegen: u verandert 9 in 0 en verhoogt het volgende cijfer.Uit het bovenstaande voorbeeld kun je zien dat er altijd een maximale waarde is die je kunt behouden in een getal met een constant aantal bits - want als alle bits 1 zijn en je probeert de waarde met 1 te verhogen, worden alle bits 0, waardoor de aantal. Het wordt integer overflow genoemd en veroorzaakt veel onaangename problemen, zowel voor gebruikers als voor ontwikkelaars.
11111111 = 255 + 1 ----------- 100000000 = 0 (9 bits hier, dus 1 wordt bijgesneden)
- Voor 1 bit is de grootste waarde 1,
- 2 bits - 3,
- 3 bits - 7,
- 4 bits - 15
Het grootst mogelijke aantal is altijd 2 ^ N-1, waarbij N het aantal bits is. Zoals ik al eerder zei, een geheugenadres is een getal en heeft ook een maximale waarde. Daarom is de grootte van het machinewoord ook een limiet voor het aantal beschikbare geheugenadressen - soms kan je CPU gewoon geen getallen verwerken die groot genoeg zijn om meer geheugen te adresseren.
Dus op 32 bits kun je getallen van 0 tot 2 ^ 32-1 behouden, en dat is 4294967295. Het is meer dan het grootste adres in 1 GB RAM, dus in jouw specifieke geval zal de hoeveelheid RAM de beperkende factor zijn.
De RAM-limiet voor 32-bits CPU is theoretisch 4 GB (2 ^ 32) en voor 64-bits CPU is dit 16 EB (exabytes, 1 EB = 2 ^ 30 GB). Met andere woorden, 64-bit CPU kan het hele internet aanspreken ... 200 keer;) (geschat door Wolfram Alpha ).
In echte besturingssystemen kunnen 32-bits CPU's echter ongeveer 3 GiB RAM adresseren. Dat komt door de interne architectuur van het besturingssysteem: sommige adressen zijn gereserveerd voor andere doeleinden. U kunt hier meer over lezen, zogeheten 3 GB-barrière op Wikipedia . Met deze limiet kun je opheffen Extensie fysiek adres .
Over geheugenadressering gesproken, er zijn een paar dingen die ik moet noemen: virtueel geheugen , segmentatie en paging .
Virtueel geheugen
Zoals @Daniel R Hicks in een ander antwoord opmerkte, gebruiken besturingssystemen virtueel geheugen. Het betekent dat applicaties eigenlijk niet werken op echte geheugenadressen, maar op adressen die worden geleverd door het besturingssysteem.
Met deze techniek kan het besturingssysteem bepaalde gegevens van RAM naar een zogenaamd Pagefile (Windows) of Swap (* NIX) verplaatsen. De harde schijf is enkele magnitudes langzamer dan RAM, maar het is geen serieus probleem voor zelden gebruikte gegevens en het stelt het besturingssysteem in staat om applicaties meer RAM te bieden dan je in werkelijkheid hebt geïnstalleerd.
Oproepen
Waar we het tot nu toe over hadden, wordt een plat adresschema genoemd.
Paging is een alternatief adresschema waarmee u meer geheugen kunt adresseren dan u normaal zou kunnen doen met één machinewoord in een plat model.
Stel je een boek voor dat gevuld is met woorden van 4 letters. Stel dat er op elke pagina 1024 nummers staan. Om een nummer aan te spreken, moet u twee dingen weten:
- Het aantal pagina's waarop dat woord is afgedrukt.
- Welk woord op die pagina is het woord waarnaar u op zoek bent.
Dat is precies hoe moderne x86-CPU's met geheugen omgaan. Het is verdeeld in 4 KiB-pagina's (elk 1024 machinewoorden) en die pagina's hebben nummers. (eigenlijk kunnen pagina's ook 4 MiB groot zijn of 2 MiB met PAE ). Als u een geheugencel wilt adresseren, hebt u het paginanummer en het adres op die pagina nodig. Merk op dat naar elke geheugencel wordt verwezen door precies één paar cijfers, dat is niet het geval bij segmentatie.
Segmentatie
Nou, deze lijkt veel op paging. Het werd gebruikt in Intel 8086, om maar een voorbeeld te noemen. Groepen adressen worden nu geheugensegmenten genoemd, geen pagina's. Het verschil is dat segmenten elkaar kunnen overlappen, en ze overlappen elkaar vaak. Op de 8086 waren bijvoorbeeld de meeste geheugencellen beschikbaar uit 4096 verschillende segmenten.
Een voorbeeld:
Laten we zeggen dat we 8 bytes geheugen hebben, allemaal met nullen, behalve de 4e byte die gelijk is aan 255.
Afbeelding voor model met plat geheugen:
_____ | 0 | | 0 | | 0 | | 255 | | 0 | | 0 | | 0 | | 0 | -----Illustratie voor paginageheugen met 4-byte pagina's:
PAGINA0 _____ | 0 | | 0 | | 0 | PAGINA 1 | 255 | _____ ----- | 0 | | 0 | | 0 | | 0 | -----Illustratie voor gesegmenteerd geheugen met segmenten van 4 bytes verschoven met 1:
SEG 0 _____ SEG 1 | 0 | _____ SEG 2 | 0 | | 0 | _____ SEG 3 | 0 | | 0 | | 0 | _____ SEG 4 | 255 | | 255 | | 255 | | 255 | _____ SEG 5 ----- | 0 | | 0 | | 0 | | 0 | _____ SEG 6 ----- | 0 | | 0 | | 0 | | 0 | _____ SEG 7 ----- | 0 | | 0 | | 0 | | 0 | _____ ----- | 0 | | 0 | | 0 | | 0 | ----- ----- ----- -----Zoals u kunt zien, kan de 4e byte op vier manieren worden geadresseerd: (adressering vanaf 0)
- Segment 0, verschoven 3
- Segment 1, offset 2
- Segment 2, offset 1
- Segment 3, offset 0
Het is altijd dezelfde geheugencel.
In real-life implementaties worden segmenten met meer dan 1 byte verschoven (voor 8086 was dit 16 bytes).
Het slechte aan segmentatie is dat het ingewikkeld is (maar ik denk dat je dat al weet;). Wat goed is, is dat je een aantal slimme technieken kunt gebruiken om modulaire programma's te maken.
U kunt bijvoorbeeld een module in een segment laden en vervolgens doen alsof het segment kleiner is dan het in werkelijkheid is (net klein genoeg om de module vast te houden), vervolgens het eerste segment kiezen dat niet overlapt met dat pseudo-kleinere segment en het volgende laden module, enzovoort. In feite krijgt u op deze manier pagina's met een variabele grootte.
Iets toe te voegen aan de uitleg? Geluid uit in de reacties. Wilt u meer antwoorden lezen van andere technisch onderlegde Stack Exchange-gebruikers? Bekijk hier de volledige discussiethread .
