Сколько адресов памяти мы можем получить с 32-разрядным процессором и оперативной памятью 1 ГБ и сколько с 64-разрядным процессором?

Я думаю, что это что-то вроде этого:

1 ГБ оперативной памяти делится на 32 бита или делится на 4? узнать количество адресов памяти?

Но я не уверен. Вот почему я спрашиваю.

Я прочитал в википедии, что 1 адрес памяти имеет ширину 32 бита или 4 октета (1 октет = 8 бит) по сравнению с 64-битным процессором, где 1 адрес памяти или 1 целое число имеют ширину 64 бита или 8 октетов. Но не знаю, правильно ли я это понял.

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

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

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

Память состоит из байтов (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 байт).

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

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

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

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

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.

Принятый ответ дает хорошее объяснение. Но я не думаю, что это ответ. Он не содержит ничего о адресной шине . И его размер на самом деле является основной причиной ограничения памяти. Например, 8080 - это 8-битный процессор (размер его шины данных составляет 8 бит), но он имеет 16-битную адресную шину. Он может адресовать 2 ^ 16 = (2 ^ 6) * (2 ^ 10) = 64 * 1024 байта = 64 КБ.

Вы можете найти больше здесь (32-бит) в разделе «Техническая история».

Я верю, что самая основная информация теряется в этом разговоре, поэтому вот мой ответ:

Выражение «Это 32-битный процессор» означает, что размер команды или размер команды, которую процессор может понять и работать за один раз, составляет 32 бита. Аналогично с 64-разрядными процессорами: они могут обрабатывать команды максимум из 64-разрядных.

Думайте об этом как о старом механическом калькуляторе: у вас есть только столько цифр, что вы просто не можете вводить более длинные числа.

Теперь адрес, который может использовать процессор, также должен вписываться в это же пространство, поэтому для 32-разрядного процессора адрес, который он использует, также может быть максимум 32-разрядным. Таким образом, отсюда мы можем просто рассчитать максимальное количество адресов (т. Е. Максимальное количество оперативной памяти, используемой ЦП):

2 ^ 32 = 4294967296 (= 4 ГБ)

или

2 ^ 64 = 18446744073709551616 (= намного больше;)

Или, как забавный пример, мой старый Commodore 64 имел 16-битный процессор, поэтому он мог управлять памятью:

2 ^ 16 = 65536 байт (= 64 КБ)

Это основная логика, но, как уже было сказано, существуют способы обойти это ограничение, такие как виртуальные адресные пространства, отображение памяти и т. Д.