Quanti indirizzi di memoria possiamo ottenere con un processore a 32 bit e 1 GB di RAM e quanti con un processore a 64 bit?

Penso che sia qualcosa del genere:

1 GB di RAM divisa per 32 bit o divisa per 4? ottenere il numero di indirizzi di memoria?

Ma non sono sicuro. Ecco perché lo sto chiedendo.

Su wikipedia ho scritto che 1 indirizzo di memoria ha una larghezza di 32 bit o 4 ottetti (1 ottetto = 8 bit), rispetto a un processore a 64 bit in cui 1 indirizzo di memoria o 1 numero intero è largo 64 bit o 8 ottetti. Ma non so se l'ho capito bene neanche io.

Risposta breve: il numero di indirizzi disponibili è uguale al più piccolo di quelli:

• Dimensione della memoria in byte
• Il più grande numero intero senza segno che può essere salvato nella parola macchina della CPU

Risposta lunga e spiegazione di quanto sopra:

La memoria è composta da byte (B). Ogni byte è composto da 8 bit (b).

1 B = 8 b

1 GB di RAM è in realtà 1 GiB (gibibyte, non gigabyte). La differenza è:

1 GB  = 10^9 B = 1 000 000 000 B
1 GiB = 2^30 B = 1 073 741 824 B

Ogni byte di memoria ha il suo indirizzo, indipendentemente dalla grandezza della parola macchina CPU. Per esempio. La CPU Intel 8086 era a 16 bit e indirizzava la memoria per byte, così come le moderne CPU a 32 e 64 bit. Questa è la causa del primo limite: non puoi avere più indirizzi dei byte di memoria.

L'indirizzo di memoria è solo un numero di byte che la CPU deve saltare dall'inizio della memoria per arrivare a quello che sta cercando.

• Per accedere al primo byte deve saltare 0 byte, quindi l'indirizzo del primo byte è 0.
• Per accedere al secondo byte deve saltare 1 byte, quindi il suo indirizzo è 1.
• (e così via...)
• Per accedere all'ultimo byte, la CPU salta 1073741823 byte, quindi il suo indirizzo è 1073741823.

Ora devi sapere cosa significa effettivamente a 32 bit. Come ho detto prima, ha le dimensioni di una parola automatica.

La parola macchina è la quantità di memoria utilizzata dalla CPU per contenere i numeri (nella RAM, nella cache o nei registri interni). La CPU a 32 bit utilizza 32 bit (4 byte) per contenere i numeri. Anche gli indirizzi di memoria sono numeri, quindi su una CPU a 32 bit l'indirizzo di memoria è composto da 32 bit.

Ora pensaci: se hai un bit, puoi salvare due valori su di esso: 0 o 1. Aggiungi un altro bit e hai quattro valori: 0, 1, 2, 3. Su tre bit, puoi salvare otto valori : 0, 1, 2 ... 6, 7. Questo è in realtà un sistema binario e funziona così:

Decimal Binary
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

Funziona esattamente come la solita aggiunta, ma la cifra massima è 1, non 9. Decimale 0 è 0000, quindi aggiungi 1 e ottieni 0001, aggiungi ancora una volta e hai 0010. Quello che succede qui è avere il decimale 09e aggiungerne uno: cambi da 9 a 0 e incrementi la cifra successiva.

Dall'esempio sopra puoi vedere che c'è sempre un valore massimo che puoi tenere in un numero con un numero costante di bit - perché quando tutti i bit sono 1 e provi ad aumentare il valore di 1, tutti i bit diventeranno 0, interrompendo così il numero. Si chiama overflow dei numeri interi e causa molti problemi spiacevoli, sia per gli utenti che per gli sviluppatori.

   11111111    = 255
+         1
-----------
  100000000    = 0   (9 bits here, so 1 is trimmed)

• Per 1 bit il valore più grande è 1,
• 2 bit - 3,
• 3 bit - 7,
• 4 bit - 15

Il numero più grande possibile è sempre 2 ^ N-1, dove N è il numero di bit. Come ho detto prima, un indirizzo di memoria è un numero e ha anche un valore massimo. Ecco perché la dimensione della parola macchina è anche un limite per il numero di indirizzi di memoria disponibili - a volte la tua CPU non è in grado di elaborare numeri abbastanza grandi da indirizzare più memoria.

Quindi su 32 bit puoi mantenere numeri da 0 a 2 ^ 32-1, e questo è 4 294 967 295. È più dell'indirizzo più grande nella RAM da 1 GB, quindi nel tuo caso specifico la quantità di RAM sarà il fattore limitante.

Il limite di RAM per CPU a 32 bit è teoricamente 4 GB (2 ^ 32) e per CPU a 64 bit è 16 EB (exabyte, 1 EB = 2 ^ 30 GB). In altre parole, la CPU a 64 bit potrebbe indirizzare l'intera Internet ... 200 volte;) (stimata da WolframAlpha ).

Tuttavia, nei sistemi operativi reali le CPU a 32 bit possono indirizzare circa 3 GiB di RAM. Ciò è dovuto all'architettura interna del sistema operativo: alcuni indirizzi sono riservati per altri scopi. Puoi leggere di più su questa cosiddetta barriera da 3 GB su Wikipedia . È possibile aumentare questo limite con l'estensione dell'indirizzo fisico .

Parlando di indirizzamento della memoria, ci sono alcune cose che dovrei menzionare: memoria virtuale , segmentazione e paging .

Memoria virtuale

Come ha sottolineato @Daniel R Hicks in un'altra risposta, i sistemi operativi utilizzano la memoria virtuale. Ciò significa che le applicazioni in realtà non funzionano su indirizzi di memoria reali, ma su quelli forniti dal sistema operativo.

Questa tecnica consente al sistema operativo di spostare alcuni dati dalla RAM a un cosiddetto Pagefile (Windows) o Swap (* NIX). L'HDD è di alcune dimensioni più lento della RAM, ma non è un problema serio per i dati a cui si accede raramente e consente al sistema operativo di fornire alle applicazioni più RAM di quelle effettivamente installate.

paging

Ciò di cui stavamo parlando finora si chiama schema di indirizzamento piatto.

Il paging è uno schema di indirizzamento alternativo che consente di indirizzare più memoria di quella normalmente possibile con una parola macchina in un modello piatto.

Immagina un libro pieno di parole di 4 lettere. Diciamo che ci sono 1024 numeri su ogni pagina. Per indirizzare un numero, devi sapere due cose:

• Il numero di pagina su cui è stampata quella parola.
• Quale parola su quella pagina è quella che stai cercando.

Questo è esattamente il modo in cui le moderne CPU x86 gestiscono la memoria. È diviso in 4 pagine KiB (1024 parole macchina ciascuna) e quelle pagine hanno numeri. (in realtà le pagine possono anche essere 4 MiB grandi o 2 MiB con PAE ). Quando si desidera indirizzare la cella di memoria, è necessario il numero di pagina e l'indirizzo in quella pagina. Si noti che ogni cella di memoria è referenziata da esattamente una coppia di numeri, che non sarà il caso della segmentazione.

Segmentazione

Bene, questo è abbastanza simile al paging. È stato utilizzato in Intel 8086, solo per citarne un esempio. I gruppi di indirizzi sono ora chiamati segmenti di memoria, non pagine. La differenza è che i segmenti possono sovrapporsi e si sovrappongono molto. Ad esempio, su 8086 la maggior parte delle celle di memoria erano disponibili da 4096 diversi segmenti.

Un esempio:

Diciamo che abbiamo 8 byte di memoria, tutti con zeri eccetto il 4 ° byte che è uguale a 255.

Illustrazione per modello di memoria piatta:

 _____
|  0  |
|  0  |
|  0  |
| 255 |
|  0  |
|  0  |
|  0  |
|  0  |
 -----

Illustrazione per memoria paginata con pagine a 4 byte:

 PAGE0
 _____
|  0  |
|  0  |
|  0  |  PAGE1
| 255 |  _____
 -----  |  0  |
        |  0  |
        |  0  |
        |  0  |
         -----

Illustrazione per memoria segmentata con segmenti di 4 byte spostati di 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  |
                                 -----   -----   -----   -----

Come puoi vedere, il 4 ° byte può essere indirizzato in quattro modi: (indirizzando da 0)

• Segmento 0, offset 3
• Segmento 1, offset 2
• Segmento 2, offset 1
• Segmento 3, offset 0

È sempre la stessa cella di memoria.

Nelle implementazioni nella vita reale i segmenti sono spostati di più di 1 byte (per 8086 erano 16 byte).

La cosa negativa della segmentazione è che è complicato (ma penso che tu già lo sappia;) Il bello è che puoi usare alcune tecniche intelligenti per creare programmi modulari.

Ad esempio puoi caricare un modulo in un segmento, quindi far finta che il segmento sia più piccolo di quello che è realmente (appena abbastanza piccolo da contenere il modulo), quindi scegliere il primo segmento che non si sovrappone a quello pseudo-piccolo e caricare il modulo successivo , e così via. Fondamentalmente ciò che ottieni in questo modo sono le pagine di dimensioni variabili.

Oltre a quanto sopra, si noti che viene utilizzato l'indirizzamento virtuale , insieme a più spazi indirizzo . Quindi, anche se hai solo 1 GB di RAM, un programma potrebbe concettualmente utilizzare fino a 4 GB di memoria virtuale (anche se la maggior parte del sistema operativo lo limiterà a meno di questo). E concettualmente puoi avere un numero (quasi) infinito di tali spazi di indirizzi da 4 GB.

La dimensione della RAM non limita (così tanto) la dimensione massima di un programma o il numero di programmi che è possibile eseguire, ma limita piuttosto le prestazioni. Quando la memoria reale diventa "impegnata" e il sistema inizia a "bloccarsi" mentre "scambia" "pagine" di memoria avanti e indietro tra RAM e disco, le prestazioni crollano.

Il 1GByte di RAM occuperebbe 1024 * 1024 * 1024 byte, o 1.073.741.824 byte.

Un processore a 32 bit ha sempre 4 * 1024 * 1024 * 1024 byte o 4.294.967.296 byte di spazio di indirizzi Il 1Gbyte di RAM appare all'interno di questo spazio. Sui processori Intel, una parte della RAM deve apparire all'indirizzo 0 per i vettori di interruzione, quindi la RAM fisica inizia all'indirizzo 0 e sale.

Altre cose compaiono in quello spazio degli indirizzi, come BIOS e ROM opzionali (nei 384 KBbyte superiori entro il primo 1 MByte), dispositivi I / O (come l'APIC) e la RAM video. Alcune cose strane continuano anche con la modalità di gestione del sistema "SMRAM" che non capisco ancora del tutto.

Nota che questo è lo spazio degli indirizzi fisici, dal punto di vista del kernel. La MMU può riorganizzare tutto ciò in qualsiasi modo in un processo di spazio utente.

Un processore a 32 bit può indirizzare al massimo 2 ^ 32 singoli byte di memoria (circa 4 GB), ma avere 1 GB di memoria renderebbe 1 * 1024 * 1024 * 1024 byte indirizzabili di memoria (anche se probabilmente avresti ancora uno spazio di indirizzi virtuali 2 ^ 32 ). Una CPU a 64 bit potrebbe indirizzare 2 ^ 64 singoli byte, ma penso che la maggior parte dei sistemi utilizzi solo 48 bit per gli indirizzi di memoria rendendo il limite superiore. byte indirizzabili 2 ^ 48.

La risposta accettata fornisce una buona spiegazione. Ma non penso che sia la risposta. Non contiene nulla sull'indirizzo bus . E le sue dimensioni sono in realtà la ragione principale dei vincoli di memoria. Ad esempio 8080 è un processore a 8 bit (la dimensione del suo bus dati è 8 bit), ma ha un bus indirizzo a 16 bit. Può indirizzare 2 ^ 16 = (2 ^ 6) * (2 ^ 10) = 64 * 1024 byte = 64 KB.

Puoi trovare ulteriori informazioni qui (32 bit) nella sezione "Cronologia tecnica".

Credo che le informazioni più elementari siano perse in questa conversazione, quindi ecco la mia risposta:

Dire "Questo è un processore a 32 bit" significa che la dimensione dell'istruzione, o dimensione del comando, che la cpu può capire e lavorare contemporaneamente è di 32 bit. Allo stesso modo con processori a 64 bit: possono gestire le istruzioni al massimo a 64 bit.

Pensa a questo come a un vecchio calcolatore meccanico: hai solo così tante cifre, quindi semplicemente non puoi inserire un numero più lungo.

Ora, anche un indirizzo che una CPU può utilizzare deve inserirsi nello stesso spazio, quindi per un processore a 32 bit, l'indirizzo che utilizza può anche essere al massimo di 32 bit. Quindi, da qui possiamo semplicemente calcolare il numero massimo di indirizzi (ovvero la quantità massima di RAM utilizzabile dalla CPU):

2 ^ 32 = 4294967296 (= 4 GB)

o

2 ^ 64 = 18446744073709551616 (= molto di più;)

Oppure, come esempio divertente, il mio vecchio Commodore 64 aveva una CPU a 16 bit, quindi era in grado di gestire una memoria di:

2 ^ 16 = 65536 byte (= 64 KB)

Questa è la logica di base, ma, come affermato in precedenza, ci sono modi per aggirare questa limitazione, come spazi di indirizzi virtuali, mapping di memoria ecc.