Краткий ответ: количество доступных адресов равно меньшим из них:

• Размер памяти в байтах
• Наибольшее целое число без знака, которое может быть сохранено в машинное слово процессора

---

Длинный ответ и объяснение вышеизложенного:

Память состоит из байтов (B). Каждый байт состоит из 8 бит (b).

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.
• (и так далее…)
• Для доступа к последнему байту CPU пропускает 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 EB (экзабайт, 1 EB = 2 ^ 30 ГБ). Другими словами, 64-битный ЦП мог бы адресовать весь Интернет … 200 раз;) (по оценкам WolframAlpha ).

Однако в реальных операционных системах 32-разрядные процессоры могут принимать около 3 гигабайт ОЗУ. Это связано с внутренней архитектурой операционной системы – некоторые адреса зарезервированы для других целей. Вы можете узнать больше об этом так называемом барьере 3 ГБ в Википедии . Вы можете снять этот предел с помощью расширения физического адреса .

---

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

Виртуальная память

Как заметил @Daniel R Hicks в другом ответе, операционные системы используют виртуальную память. Это означает, что приложения на самом деле не работают на реальных адресах памяти, а на тех, которые предоставляются ОС.

Этот метод позволяет операционной системе перемещать некоторые данные из ОЗУ в так называемый файл Pagefile (Windows) или Swap (* NIX). HDD немного меньше, чем RAM, но это не является серьезной проблемой для редко доступных данных, и это позволяет ОС предоставлять приложениям больше оперативной памяти, чем вы на самом деле установили.

Paging

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

Пейджинг – это альтернативная схема адресации, которая позволяет адресовать больше памяти, которую вы обычно можете использовать с одним машинным словом в плоской модели.

Представьте себе книгу, наполненную 4-буквенными словами. Предположим, на каждой странице имеется 1024 номера. Чтобы обратиться к номеру, вам нужно знать две вещи:

• Количество страниц, на которых напечатано это слово.
• Какое слово на этой странице является тем, которое вы ищете.

Теперь это точно, как современные процессоры x86 обрабатывают память. Он разделен на 4 страницы KiB (по 1024 машинных слова), и эти страницы имеют номера. (На самом деле страницы также могут быть 4 MiB big или 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 байт).

Что плохо в сегментировании, так это то, что это сложно (но, я думаю, вы уже знаете это;) Хорошо, что вы можете использовать некоторые умные методы для создания модульных программ.

Например, вы можете загрузить некоторый модуль в сегмент, а затем притвориться, что сегмент меньше, чем он есть (достаточно мал, чтобы удерживать модуль), затем выберите первый сегмент, который не перекрывается с этим псевдо-меньшим и загружает следующий модуль , и так далее. В основном то, что вы получаете таким образом, это страницы с переменным размером.

В дополнение к вышесказанному, обратите внимание, что используется виртуальная адресация, а также несколько адресных пространств . Таким образом, хотя у вас всего 1 ГБ оперативной памяти, программа может концептуально использовать до 4 ГБ виртуальной памяти (хотя большинство операционных систем ограничивают ее меньшим, чем это). И вы можете концептуально иметь (почти) бесконечное количество таких адресных пространств 4 ГБ.

Размер RAM не ограничивает (настолько) максимальный размер программы или количество программ, которые вы можете запускать, а скорее ограничивает производительность. Когда реальная память становится «чрезмерной», и система начинает «трэш», поскольку она «свопирует» «страницы» памяти назад и вперед между ОЗУ и диском, производительность падает.

1 ГБ ОЗУ будет занимать 1024 * 1024 * 1024 байта, или 1 073 741 824 байта.

32-разрядный процессор всегда имеет 4 * 1024 * 1024 * 1024 байта или 4 294 967 296 байт адресного пространства. В этом пространстве появляется 1 Гбайт ОЗУ. На процессорах Intel некоторое ОЗУ должно появиться по адресу 0 для векторов прерываний, поэтому физическое ОЗУ начинается с адреса 0 и идет вверх.

В этом адресном пространстве появляются другие вещи, такие как BIOS и дополнительные ПЗУ (в верхних 384 Кбайтах в течение первого 1 Мбайта), устройства ввода / вывода (например, APIC) и видеопамять. Некоторые странные вещи также продолжаются в режиме управления системой «SMRAM», который я еще не совсем понял.

Обратите внимание: это физическое адресное пространство, с точки зрения ядра. MMU может каким-либо образом изменить все это на процесс пользовательского пространства.

32-битный процессор может адресовать не более 2 ^ 32 отдельных байта памяти (около 4 ГБ), но наличие 1 ГБ памяти сделает 1 * 1024 * 1024 * 1024 адресуемых байтов памяти (хотя у вас, вероятно, все еще будет виртуальное адресное пространство 2 ^ 32 ). 64-битный процессор мог адресовать 2 ^ 64 отдельных байта, но я думаю, что большинство систем используют только 48 бит для адресов памяти, делающих верхнюю границу. Адресуемые байты 2 ^ 48.