Hvor mange minneadresser kan RAM-en i min datamaskin holde?

Noen ganger er det morsomt å se på overflatenivået av databehandling, og i andre dager er det morsomt å dykke rett inn i det indre arbeidet. I dag tar vi en titt på strukturen i dataminnet og hvor mye du kan pakke inn i en pinne med RAM.

Dagens Spørsmål & Svar-sesjon kommer til oss med høflighet av SuperUser-en underavdeling av Stack Exchange, en fellesskapsdrevet gruppering av Q & A-nettsteder.

Spørsmålet

SuperUser leser Johan Smohan bryter med hvordan prosessortypen og minnestørrelsen jobber sammen for å gi totalt antall adresser. Han skriver:

Hvor mange minneadresser kan vi få med en 32-bits prosessor og 1 GB ram og hvor mange med en 64-bits prosessor?

Jeg tror at det er noe slikt:

1 GB ram delt med enten 32 bits 4 bits (?) For å få antall minneadresser?

Jeg leser på Wikipedia at 1 minneadresser er 32 bits brede eller 4 oktetter (1 octet = 8 bits), sammenlignet med en 64 bits prosessor hvor 1 minnesadresser eller 1 heltall er 64 bits bredt eller 8 oktetter. Men vet ikke om jeg forstod det riktig heller.

Dette er de slags spørsmål som kan holde en nysgjerrig geek om natten. Hvor mange adresser er tilgjengelige under hvert av Johans hypotetiske systemer?

Svaret

SuperUser bidragsyter Gronostaj gir litt innsikt i hvordan RAM er delt og utnyttet:

Kort svar: Antall tilgjengelige adresser er lik de mindre av disse:

Minnestørrelse i byte

Største usignerte heltall som kan lagres i CPUs maskinord

Langt svar og forklaring av ovenstående:

Minne består av byte (B). Hver byte består av 8 biter (b).
1 B = 8 b 
1 GB RAM er faktisk 1 GiB (gibibyte, ikke gigabyte). Forskjellen er:
1 GB = 10 ^ 9 B = 1 000 000 000 B 1 GiB = 2 ^ 30 B = 1 073 741 824 B 
Hver byte av minne har sin egen adresse, uansett hvor stor CPU-maskinordet er. Eg. Intel 8086 CPU var 16-bit, og det var å adressere minne ved byte, så gjør moderne 32-biters og 64-biters CPUer. Det er årsaken til den første grensen - du kan ikke ha flere adresser enn minnebiter.

Minneadresse er bare et antall byter CPUen har å hoppe over fra begynnelsen av minnet for å komme til den det leter etter.

For å få tilgang til den første byten må den hoppe over 0 byte, så første bytes adresse er 0.

For å få tilgang til den andre byten må den hoppe over 1 byte, så adressen er 1.

(og så videre… )

For å få tilgang til den siste byten, hopper CPU 1073741823 bytes, så adressen er 1073741823.

Nå må du vite hva 32-bit betyr egentlig. Som jeg nevnte tidligere, er det størrelsen på et maskinord.

Maskinord er mengden minne CPU bruker til å holde tall (i RAM, cache eller interne registre). 32-biters CPU bruker 32 bits (4 bytes) for å holde tall. Minneadresser er tall også, så på en 32-biters CPU, lagrer minnesadressen 32 bits.

Nå tenk på dette: Hvis du har en bit, kan du lagre to verdier på den: 0 eller 1. Legg til en bit og du har fire verdier: 0, 1, 2, 3. På tre biter kan du lagre åtte verdier : 0, 1, 2 ... 6, 7. Dette er faktisk et binært system, og det virker slik:
Binær Decimal 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 1111 
Det fungerer akkurat som vanlig tillegg, men maksimumsifferet er 1, ikke 9. Desimal 0 er 0000, så legger du til 1 og får 0001, legg til en gang igjen og du har 0010. Det som skjer her er som å ha desimal 09 og legge til en: du endrer 9 til 0 og øker neste siffer.

Fra eksemplet ovenfor kan du se at det alltid er en maksimumsverdi du kan beholde i et tall med konstant antall biter - fordi når alle biter er 1 og du prøver å øke verdien med 1, blir alle biter 0, og dermed bryter du Nummer. Det kalles heltall overløp og forårsaker mange ubehagelige problemer, både for brukere og utviklere.
 11111111 = 255 + 1 ----------- 100000000 = 0 (9 biter her, så 1 er trimmet) 
For 1 bit er den største verdien 1,

2 bits - 3,

3 bits - 7,

4 biter - 15

Det største mulige tallet er alltid 2 ^ N-1, hvor N er antall biter. Som jeg sa før, er en minneadresse et tall, og det har også en maksimumsverdi. Derfor er maskinordets størrelse også en grense for antall tilgjengelige minneadresser - noen ganger kan CPUen ikke bare behandle tall som er store nok til å adressere mer minne.

Så på 32 biter kan du holde tall fra 0 til 2 ^ 32-1, og det er 4 294 967 295. Det er mer enn den største adressen i 1 GB RAM, så i ditt spesifikke tilfelle vil mengden RAM være den begrensende faktoren.

RAM-grensen for 32-bits CPU er teoretisk 4 GB (2 ^ 32) og for 64-biters CPU er det 16 EB (exabytes, 1 EB = 2 ^ 30 GB). Med andre ord, 64-biters CPU kunne adressere hele Internett ... 200 ganger;) (estimert av WolframAlpha).

I virkelige operativsystemer kan 32-bits CPUer imidlertid adressere om 3 GiB RAM. Det skyldes operativsystemets interne arkitektur - noen adresser er reservert til andre formål. Du kan lese mer om denne såkalte 3 GB-barrieren på Wikipedia. Du kan løfte denne grensen med Fysisk adresseutvidelse.

Snakker om minneadressering, det er få ting jeg bør nevne: virtuell hukommelse, segmentering og personsøker.

Virtuell hukommelse

Som @Daniel R Hicks pekte på i et annet svar, bruker OSes virtuelt minne. Hva det betyr er at applikasjoner faktisk ikke opererer på ekte minneadresser, men de som leveres av OS.

Denne teknikken tillater operativsystemet å flytte noen data fra RAM til en såkalt Pagefile (Windows) eller Bytte (* NIX). HDD er få størrelser langsommere enn RAM, men det er ikke et alvorlig problem for sjelden tilgjengelige data, og det tillater at OS gir applikasjoner mer RAM enn du faktisk har installert.

personsøker

Det vi snakket om så langt kalles flat adressering.

Personsøker er et alternativ adresseringssystem som gjør det mulig å adressere mer minne som du normalt kunne med ett maskinord i flat modell.

Tenk deg en bok fylt med ord med 4 bokstaver. La oss si at det er 1024 numre på hver side. For å adressere et nummer må du kjenne to ting:

Antall sider som det ordet skrives ut på.

Hvilket ord på den siden er den du leter etter.

Nå er det akkurat hvordan moderne x86-CPUer håndterer minne. Den er delt inn i 4 KiB sider (1024 maskinord hver) og disse sidene har tall. (faktisk sider kan også være 4 MiB store eller 2 MiB med PAE). Når du vil adressere minnecelle, trenger du sidenummer og adresse på den siden. Vær oppmerksom på at hver minnecelle refereres til med nøyaktig ett par tall, det vil ikke være tilfelle for segmentering.

segmentering

Vel, dette er ganske lik paging. Den ble brukt i Intel 8086, bare for å nevne et eksempel. Grupper av adresser kalles nå minnesegmenter, ikke sider. Forskjellen er at segmentene kan overlappe, og de overlapper mye. For eksempel i 8086 var de fleste minneceller tilgjengelige fra 4096 forskjellige segmenter.

Et eksempel:

La oss si at vi har 8 byte minne, alle holder nuller unntatt fjerde byte som er lik 255.

Illustrasjon for flat minnemodell:
 _____ | 0 | | 0 | | 0 | | 255 | | 0 | | 0 | | 0 | | 0 | ----- 
Illustrasjon for paged minne med 4-byte sider:
 PAGE0 _____ | 0 | | 0 | | 0 | SIDE1 | 255 | _____ ----- | 0 | | 0 | | 0 | | 0 | ----- 
Illustrasjon for segmentert minne med 4-bytesegmenter skiftet med 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 | ----- ----- ----- ----- 
Som du kan se, kan fjerde byte adresseres på fire måter: (adressering fra 0)

Segment 0, offset 3

Segment 1, forskyvning 2

Segment 2, forskyvning 1

Segment 3, offset 0

Det er alltid den samme minnecellen.

I virkeligheten implementeres segmentene med mer enn 1 byte (for 8086 var det 16 byte).

Det som er dårlig om segmentering er at det er komplisert (men jeg tror du allerede vet det;) Det er bra at du kan bruke noen smarte teknikker for å lage modulære programmer.

Du kan for eksempel laste inn noen moduler i et segment, og la som om segmentet er mindre enn det egentlig er (bare lite nok til å holde modulen), og velg deretter det første segmentet som ikke overlapper den pseudo-mindre en og legg neste modul, og så videre. I utgangspunktet, hva du får denne måten er sider med variabel størrelse.

Har du noe å legge til forklaringen? Lyde av i kommentarene. Vil du lese flere svar fra andre tech-savvy Stack Exchange-brukere? Sjekk ut hele diskusjonstråden her.