Колко адреса памет може да задържи оперативната памет в моя компютър?

Колко адреси от паметта можем да получим с 32-битов процесор и 1 GB овен и колко с 64-битов процесор?

Мисля, че е нещо подобно:

1 GB RAM, разделен или на 32 бита, 4 бита (?), За да получите броя адреси на паметта?

Четох в Уикипедия, че 1 адрес на паметта е 32бита с ширина или 4 октета (1 октет = 8 бита), в сравнение с 64 битов процесор, където 1 адрес памет или 1 цяло число е 64 бита широк или 8 октета. Но не знам дали и аз го разбрах правилно

Кратък отговор: Броят на наличните адреси е равен на по-малкия от тези:

• Размер на паметта в байтове
• Най-голямо неподписано цяло число, което може да бъде записано в машинната дума на процесора

Дълъг отговор и обяснение на горното:

Паметта се състои от байтове (B). Всеки байт се състои от 8 бита (b).

1 B = 8 b

1 GB RAM всъщност е 1 GiB (gibibyte, а не gigabyte). Разликата е:

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

Всеки байт памет има свой адрес, небез значение колко голяма е машинната дума на процесора. Напр. Процесорът на Intel 8086 беше 16-битов и той адресираше паметта чрез байтове, както и съвременните 32-битови и 64-битови процесори. Това е причината за първото ограничение - не можете да имате повече адреси от байтове за памет.

Адресът на паметта е само няколко байта, които процесорът трябва да пропусне от началото на паметта, за да стигне до този, който търси.

• За да получите достъп до първия байт, трябва да пропуснете 0 байта, така че адресът на първия байт е 0.
• За достъп до втория байт трябва да пропусне 1 байт, така че неговият адрес е 1.
• (и така нататък…)
• За достъп до последния байт процесорът пропуска 1073741823 байта, така че неговият адрес е 1073741823.

Сега трябва да знаете какво всъщност означава 32-битов. Както споменах преди, това е размерът на машинна дума.

Машинна дума е количеството памет, която CPU използвадържат номера (в RAM, кеш или вътрешни регистри). 32-битният процесор използва 32 бита (4 байта) за задържане на числа. Адресите на паметта също са числа, така че при 32-битов процесор, паметта се състои от 32 бита.

Сега помислете за това: ако имате един бит, можете да запишете две стойности на него: 0 или 1. Добавете още един бит и имате четири стойности: 0, 1, 2, 3. На три бита можете да запишете осем стойности: 0, 1, 2… 6, 7. Това всъщност е двоична система и работи така:

Binary  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

Работи точно като обикновено допълнение, но максималната цифра е 1, а не 9. Десетичната стойност 0 е 0000, след това добавяте 1 и получавате 0001, добавете още веднъж и имате 0010, Какво се случва тук е да имаш десетична 09 и добавяне на едно: променяте 9 на 0 и увеличавате следващата цифра.

От примера по-горе можете да видите, че имавинаги максимална стойност, която можете да запазите в число с постоянен брой битове - защото, когато всички битове са 1 и се опитате да увеличите стойността с 1, всички битове ще станат 0, като по този начин ще разбиете числото. Нарича се целочислено преливане и създава много неприятни проблеми, както за потребителите, така и за разработчиците.

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

• За 1 бит най-голямата стойност е 1,
• 2 бита - 3,
• 3 бита - 7,
• 4 бита - 15

Най-големият възможен брой винаги е 2 ^ N-1,където N е броят на битовете. Както казах преди, адресът в паметта е номер и той също има максимална стойност. Ето защо размерът на машинната дума също е ограничение за броя на наличните адреси в паметта - понякога вашият процесор просто не може да обработва числа, достатъчно големи, за да адресира повече памет.

Така че на 32 бита можете да запазите числа от 0 до 2 ^ 32-1, а това е 4 294 967 295. Това е повече от най-големия адрес в 1 GB RAM, така че във вашия конкретен случай количеството RAM ще бъде ограничаващият фактор.

Ограничението за RAM за 32-битов процесор теоретично е 4GB (2 ^ 32), а за 64-битов процесор е 16 EB (екзабайти, 1 EB = 2 ^ 30 GB). С други думи, 64-битов процесор може да адресира целия Интернет ... 200 пъти;) (изчислено от WolframAlpha).

Въпреки това, в реалните операционни системи 32-битовиПроцесорите могат да адресират около 3 GiB RAM. Това е заради вътрешната архитектура на операционната система - някои адреси са запазени за други цели. Можете да прочетете повече за тази така наречена бариера от 3 GB в Wikipedia. Можете да вдигнете тази граница с физическо разширение на адреси.

Говорейки за адресирането в паметта, има няколко неща, които трябва да спомена: виртуална памет, сегментиране и пейджинг.

Виртуална памет

Както @Daniel R Hicks посочи в друг отговор, операционните системи използват виртуална памет. Това означава, че приложенията всъщност не работят на реални адреси на паметта, а тези, предоставени от ОС.

Тази техника позволява на операционната система да се движинякои данни от RAM към така наречения Pagefile (Windows) или Swap (* NIX). HDD е с няколко по-бавни размери от RAM, но това не е сериозен проблем за рядко достъпните данни и позволява на OS да предоставя на приложенията повече RAM, отколкото всъщност сте инсталирали.

пейджинг

Това, за което говорихме досега, се нарича плоска схема на адресиране.

Страницата е алтернативна схема за адресиране, която позволява да се адресира повече памет, която обикновено бихте могли да използвате с една машинна дума в плосък модел.

Представете си книга, пълна с думи с 4 букви. Да кажем, че има 1024 номера на всяка страница. За да адресирате номер, трябва да знаете две неща:

• Броят на страницата, на която е отпечатана тази дума.
• Коя дума на тази страница е тази, която търсите.

Точно така се справят съвременните x86 процесорипамет. Той е разделен на 4 KiB страници (1024 машинни думи всяка) и тези страници имат номера. (всъщност страниците могат да бъдат и 4 MiB големи или 2 MiB с PAE). Когато искате да адресирате клетката с памет, имате нужда от номера на страницата и адрес в нея. Обърнете внимание, че всяка клетка от паметта е реферирана от точно една двойка числа, което няма да бъде случаят за сегментиране.

сегментиране

Е, този е доста подобен на пейджинг. Той беше използван в Intel 8086, само за да назовем един пример. Групите адреси се наричат ​​сегменти на паметта, а не страници. Разликата е, че сегментите могат да се припокриват и те се припокриват много. Например в 8086 повечето клетки от паметта бяха налични от 4096 различни сегмента.

Пример:

Да речем, че имаме 8 байта памет, всички държат нули, с изключение на 4-ти байт, който е равен на 255.

Илюстрация за модел с плоска памет:

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

Илюстрация за пейджинирана памет с 4-байтови страници:

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

Илюстрация за сегментирана памет с 4-байтови сегменти, изместени с 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  |
-----   -----   -----   -----

Както можете да видите, 4-ти байт може да бъде адресиран по четири начина: (адресиране от 0)

• Сегмент 0, изместване 3
• Сегмент 1, офсет 2
• Сегмент 2, офсет 1
• Сегмент 3, изместване 0

Винаги е една и съща клетка памет.

В реализациите в реалния живот сегментите се изместват с повече от 1 байт (за 8086 това е 16 байта).

Лошото в сегментацията е, че е сложно (но мисля, че вече знаете това;). Хубавото е, че можете да използвате някои умни техники за създаване на модулни програми.

Например, можете да заредите някакъв модул в aсегмент, след това се преструвайте, че сегментът е по-малък, отколкото всъщност е (достатъчно малък, за да държи модула), след това изберете първия сегмент, който не се припокрива с този псевдо-по-малък и заредете следващия модул и т.н. По принцип това, което получавате по този начин, са страници с променлив размер.