Краткий ответ: Количество доступных адресов равно меньшему из них:
- Объем памяти в байтах
- Наибольшее целое число без знака, которое можно сохранить в машинном слове процессора
Длинный ответ и объяснение вышесказанного:
Память состоит из байтов (B). Каждый байт состоит из 8 бит (б).
1 B = 8 b
1 ГБ ОЗУ на самом деле составляет 1 ГБ (гибибайт, а не гигабайт). Разница в том, что:
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-разрядный. Как я уже говорил, это размер машинного слова.
Машинное слово - это объем памяти, используемый ЦП для хранения чисел (в ОЗУ, в кеше или во внутренних регистрах). 32-битный процессор использует 32 бита (4 байта) для хранения чисел. Адреса памяти тоже являются числами, поэтому на 32-битном процессоре адрес памяти состоит из 32 бит.
Теперь подумайте об этом: если у вас есть один бит, вы можете сохранить на нем два значения: 0 или 1. Добавьте еще один бит, и вы получите четыре значения: 0, 1, 2, 3. На трех битах вы можете сохранить восемь значений: 0, 1, 2 ... 6, 7. На самом деле это двоичная система, и она работает так:
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
Он работает точно так же, как обычное сложение, но максимальная цифра - 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 ГБ ОЗУ, поэтому в вашем конкретном случае объем ОЗУ будет ограничивающим фактором.
Предел оперативной памяти для 32-разрядного ЦП теоретически составляет 4 ГБ (2 ^ 32), а для 64-разрядного ЦП - 16 ЭБ (эксабайт, 1 ЭБ = 2 ^ 30 ГБ). Другими словами, 64-битный процессор может адресовать весь Интернет ... 200 раз;) (по оценкам WolframAlpha).
Однако в реальных операционных системах 32-разрядные процессоры могут обрабатывать около 3 ГБ ОЗУ. Это из-за внутренней архитектуры операционной системы - некоторые адреса зарезервированы для других целей. Вы можете прочитать больше об этом так называемом барьере 3 ГБ в Википедии. Вы можете снять этот предел с помощью расширения физического адреса.
Говоря об адресации памяти, я должен упомянуть несколько вещей: виртуальную память, сегментацию и разбиение на страницы.
Виртуальная память
Как отметил @Daniel R Hicks в другом ответе, операционные системы используют виртуальную память. Это означает, что приложения на самом деле работают не с реальными адресами памяти, а с ОС.
Этот метод позволяет операционной системе перемещать некоторые данные из ОЗУ в так называемый Pagefile (Windows) или Swap (* NIX). Жесткий диск на несколько порядков медленнее, чем ОЗУ, но это не является серьезной проблемой для редко используемых данных и позволяет ОС предоставлять приложениям больше оперативной памяти, чем вы фактически установили.
Paging
То, о чем мы говорили до сих пор, называется плоской схемой адресации.
Пейджинг - это альтернативная схема адресации, которая позволяет адресовать больше памяти, чем обычно, одним машинным словом в плоской модели.
Представьте себе книгу, заполненную 4-буквенными словами. Допустим, на каждой странице 1024 номера. Чтобы обратиться к номеру, нужно знать две вещи:
- Номер страницы, на которой напечатано это слово.
- Какое слово на этой странице является тем, которое вы ищете.
Теперь именно так современные процессоры x86 обрабатывают память. Он разделен на 4 страницы по КиБ (1024 машинных слова каждая), и эти страницы имеют номера. (на самом деле страницы также могут иметь размер 4 МБ или 2 МБ с 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 байт).
Что плохо в сегментации, так это то, что она сложная (но я думаю, вы уже это знаете;) Что хорошо, вы можете использовать некоторые умные методы для создания модульных программ.
Например, вы можете загрузить какой-либо модуль в сегмент, а затем сделать вид, что сегмент меньше, чем он есть на самом деле (достаточно мал, чтобы вместить модуль), затем выбрать первый сегмент, который не перекрывается с этим псевдо-меньшим, и загрузить следующий модуль. , и так далее. По сути, вы получаете страницы переменного размера.
