hoeveel geheugenadressen kunnen de ram in mijn computer te houden?

Somedays het is leuk om te kijken naar de oppervlakte niveau van het computergebruik, en andere dagen is het leuk om zich te verdiepen recht in de innerlijke werking. Vandaag nemen we een kijkje bij de structuur van computergeheugen, en hoe veel dingen die je kunt verpakken in een stok van RAM.

Today’s Vraag & antwoord-sessie tot ons komt beleefdheid van SuperUser-een onderverdeling van Stack Exchange, een community-gedreven groepering van Q & A websites.

SuperUser lezer Johan Smohan worstelt met de manier waarop het type processor en geheugen werken samen om een ​​totaal aantal adressen opleveren. Hij schrijft

Hoeveel geheugenadressen kunnen we met een 32-bit processor en 1GB ram en hoeveel met een 64-bit processor?

Ik denk dat het iets als dit

1 GB RAM gedeeld door een 32-bits 4 bits (?) Het aantal geheugenadressen krijgen?

Ik las op Wikipedia dat 1 geheugenadressen is 32 bits breed of 4 bytes (1 byte = 8 bits), vergeleken met een 64-bits processor, waar 1 geheugenadressen of 1 integer is 64 bits breed of 8 bytes. Maar weet niet of ik het goed ofwel begrepen.

Dit zijn het soort vragen dat een nieuwsgierige geek ‘s nachts kan bijbenen. Hoeveel adressen zijn beschikbaar onder elk van hypothetische systemen Johan’s?

SuperUser inzender Gronostaj biedt enig inzicht in hoe het RAM-geheugen is verdeeld en benut

Kort antwoord: Het aantal beschikbare adressen gelijk aan de kleinste van deze

Lang antwoord en uitleg van de bovenstaande

Geheugen bestaat uit bytes (B). Elke byte bestaat uit 8 bits (b).

1 GB RAM-geheugen is eigenlijk 1 GiB (gibibyte, niet gigabyte). Het verschil is

Elke byte van het geheugen heeft zijn eigen adres, ongeacht hoe groot de CPU machine woord is. Bijv. Intel 8086 CPU was 16-bit en het werd de aanpak van het geheugen door bytes, dus doe moderne 32-bit en 64-bit CPU’s. Dat is de oorzaak van de eerste grens – je kunt niet meer adressen dan geheugen bytes.

Memory-adres is slechts een aantal bytes de CPU heeft om over te slaan vanaf het begin van de herinnering aan de ene het is op zoek naar te krijgen.

Nu moet je weten wat 32-bit eigenlijk betekent. Zoals ik al zei, het is de grootte van een machine woord.

Machine woord is de hoeveelheid geheugen CPU gebruikt om nummers te houden (in het RAM, cache of interne registers). 32-bit CPU maakt gebruik van 32 bits (4 bytes) om nummers te houden. Geheugenadressen zijn getallen ook, dus op een 32-bit CPU geheugen adres bestaat uit 32 bits.

Nu denken over dit: als je er een beetje, kunt u twee waarden op te slaan op het: 0 of 1. Voeg nog een beetje en je hebt vier waarden: 0, 1, 2, 3. Op drie bits, kunt u acht waarden op te slaan : 0, 1, 2 … 6, 7. Dit is eigenlijk een binair systeem werkt zo

Het werkt precies zoals gewoonlijk toevoeging, maar de maximale cijfer 1, niet 9. decimale 0 0000, dan moet je voeg 1 en stap 0001, voeg een weer en je hebt 0010 Wat hier gebeurde is net als met het hebben van decimaal 09 en het toevoegen één: je 9-0 en increment volgende cijfer te wijzigen.

Uit het bovenstaande voorbeeld kun je zien dat er altijd een maximale waarde kunt u in een aantal met een constant aantal bits te houden – want als alle bits 1 en je probeert om de waarde met 1 te verhogen, zullen alle bits worden 0, waardoor het breken van de aantal. Het heet integer overflow en veroorzaakt veel vervelende problemen, zowel voor de gebruikers en ontwikkelaars.

Zoveel mogelijk altijd 2 ^ N-1, waarbij N het aantal bits. Zoals ik al eerder zei, een geheugen adres is een nummer en het heeft ook een maximale waarde. Dat is de reden waarom de grootte machine woord is ook een limiet voor het aantal beschikbare geheugen adressen – soms je CPU kan het gewoon niet aantallen groot genoeg om meer geheugen te pakken te verwerken.

Etc. 32 bits juiste cijfer houden van 0 tot 2 ^ 32-1, en dat is 4 294 967 295. Het is meer dan de grootste adres 1 GB RAM, dus in het specifieke geval hoeveelheid RAM de beperkende factor wordt.

Het RAM-geheugen limiet voor 32-bit CPU is theoretisch 4 GB (2 ^ 32) en voor 64-bit CPU is het 16 EB (exabytes, 1 EB = 2 ^ 30 GB). (Geschat door WolframAlpha), met andere woorden, 64-bit CPU hele internet … 200 keer pakken.

Echter, in real-life besturingssystemen 32-bit CPU’s kan aanpakken ongeveer 3 GiB RAM-geheugen. Dat komt door interne architectuur van het besturingssysteem – sommige adressen worden gereserveerd voor andere doeleinden. U kunt meer informatie over deze zogenaamde 3 GB barrière op Wikipedia lezen. U kunt deze grens met Physical Address Extension tillen.

Sprekend over het geheugen te pakken, zijn er weinig dingen die ik moet zeggen: virtueel geheugen, segmentatie en paging.

Virtueel geheugen

Zoals @Daniel R Hicks opgemerkt in een ander antwoord, besturingssystemen gebruiken virtueel geheugen. Wat het betekent is dat de toepassingen eigenlijk niet werken op echte geheugenadressen, maar degenen die door OS.

Deze techniek maakt het besturingssysteem om gegevens uit geheugen naar een zogenaamd Pagefile (Windows) of ruilen (* NIX). HDD is enkele grootheden langzamer dan RAM-geheugen, maar het is niet een ernstig probleem voor zelden gebruikte gegevens en het laat OS toepassingen meer RAM dan je eigenlijk hebt geïnstalleerd.

paging

Wat hadden we het over zo ver is plat genoemd richten regeling.

Paging is een alternatief voor het aanpakken van de regeling die het mogelijk maakt om meer geheugen aan te pakken die je normaal zou kunnen met één machine woord in flat model.

Stel je een boek vol met 4-letterwoorden. Laten we zeggen dat er 1024 nummers op elke pagina. Als u een nummer aan te pakken, moet je twee dingen weten

Nu dat is precies hoe modern x86 CPU’s verwerken geheugen. Het is verdeeld over 4 KiB pagina’s (1024 machine woorden per stuk) en die pagina’s nummers. (Eigenlijk pagina’s kunnen ook 4 MiB groot of 2 MiB met PAE). Wanneer u wilt geheugencel te pakken, moet u het paginanummer en het adres in die pagina. Merk op dat elke geheugencel wordt verwezen met exact één paar nummers, die niet voor segmentatie zal zijn.

Segmentatie

Nou, dit is vrij gelijkaardig aan bladeren. Het werd gebruikt in Intel 8086, om maar een voorbeeld te noemen. Groepen van adressen worden nu genoemd geheugen segmenten, geen pagina’s. Het verschil is segmenten kunnen elkaar overlappen, en ze doen overlappen veel. Bijvoorbeeld over 8086 de meeste geheugencellen waren beschikbaar vanaf 4096 verschillende segmenten.

Een voorbeeld

Laten we zeggen dat we hebben 8 bytes van het geheugen, alle met nullen, behalve voor 4 byte die gelijk is aan 255 is.

Illustratie voor platte geheugenmodel

Illustratie voor wisselbare geheugen met 4-byte pagina’s

Illustratie voor gesegmenteerde geheugen met 4-byte segmenten verschoven met 1

Zoals u kunt zien, kan 4 byte op vier manieren worden aangepakt: (adressering van 0)

Het is altijd hetzelfde geheugencel.

In reële implementaties segmenten worden verschoven met meer dan 1 byte (voor 8086 was 16 bytes).

Wat is er slecht over segmentering is dat het is ingewikkeld (maar ik denk dat je al weet dat, wat goed is, is dat je een aantal slimme technieken kunnen gebruiken om modulaire programma’s te maken.

Bijvoorbeeld, kunt u een aantal module in een segment te laden, dan doen alsof het segment kleiner is dan het werkelijk is (net klein genoeg om de module te houden), kies dan eerste segment dat niet overlapt met die pseudo-kleinere en laadt de volgende module, enzovoorts. Kortom, wat u op deze manier krijgt is pagina’s van variabele grootte.

Hebben iets toe te voegen aan de verklaring? Geluid uit in de commentaren. Wil je meer antwoorden van andere tech-savvy Stack Exchange-gebruikers te lezen? Bekijk de volledige bespreking draad hier.

Ik ben een beetje in de war van het aantal 255. Hoe het te krijgen?

In binaire de volgorde 1111 1111 gelijk aan 255. Er zijn echt 256 nummers omdat 0000 0000 is het eerste nummer.

In decimale, de waarden van de cijfers zijn als dit

Dus, als je zegt 255, je bent eigenlijk zeggen 200 + 50 + 5.

Evenzo worden de waarden cijfers in binaire ook afgebroken

Dus, als je zegt 11111111 (binair), je eigenlijk zeggen 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 – die gelijk is aan 255 is.

Is het mogelijk om “scrabble” (porties combineren van code een verkorte ruimtegebruik) in segmentatie? Ik begrijp dat op dit punt kan het niet praktisch zijn (er is een overvloed aan geheugen en we hoeven geen zorgen te maken over de manier waarop we gebruik maken van de ruimte) of redelijk (waarom geef me nog een ding te denken als een programmeur !?) . Ik ben gewoon te vragen als de vraag of het mogelijk is.

Ondanks de wijdverbreide opvatting dat het Engels is de officiële taal van de Verenigde Staten, is er geen officieel taal.