Сколько адресов памяти может вместить ОЗУ в моем компьютере?

Иногда бывает интересно взглянуть на поверхностный уровень компьютерного опыта, а в другие дни интересно вникать во внутреннюю работу. Сегодня мы рассмотрим структуру памяти компьютера и то, сколько вещей вы можете упаковать в карту памяти..

Сегодняшняя сессия вопросов и ответов пришла к нам благодаря SuperUser - подразделению Stack Exchange, группе веб-сайтов вопросов и ответов, управляемой сообществом..

Вопрос

Читатель SuperUser Йохан Смохан (Johan Smohan) изучает, как тип процессора и объем памяти работают вместе, чтобы получить общее количество адресов. Он пишет:

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

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

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

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

Это те вопросы, которые могут держать любопытного подонка ночью. Сколько адресов доступно в каждой из гипотетических систем Йохана?

Ответ

Участник SuperUser Gronostaj предлагает некоторое представление о том, как ОЗУ делится и используется:

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

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

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

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

1 B = 8 b 

1 ГБ ОЗУ на самом деле составляет 1 ГБ (гибибайт, а не гигабайт). Разница в том, что:

1 ГБ = 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. На самом деле это двоичная система, и она работает так:

Двоичный десятичный 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 бит, поэтому 1 обрезается) 

• Для 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 | СТРАНИЦА1 | 255 | _____ ----- | 0 | | 0 | | 0 | | 0 | ----- 

Иллюстрация для сегментированной памяти с 4-байтовыми сегментами, сдвинутыми на 1:

 SEG 0 _____ SEG 1 | 0 | _____ SEG 2 | 0 | | 0 | _____ СЕГ 3 | 0 | | 0 | | 0 | _____ СЕГ 4 | 255 | | 255 | | 255 | | 255 | _____ СЕГ 5 ----- | 0 | | 0 | | 0 | | 0 | _____ СЕГ 6 ----- | 0 | | 0 | | 0 | | 0 | _____ СЕГ 7 ----- | 0 | | 0 | | 0 | | 0 | _____ ----- | 0 | | 0 | | 0 | | 0 | ----- ----- ----- ----- 

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

• Сегмент 0, смещение 3
• Сегмент 1, смещение 2
• Сегмент 2, смещение 1
• Сегмент 3, смещение 0

Это всегда одна и та же ячейка памяти.

В реальных реализациях сегменты смещены более чем на 1 байт (для 8086 это было 16 байт).

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

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

Есть что добавить к объяснению? Звук выключен в комментариях. Хотите узнать больше ответов от других технически подкованных пользователей Stack Exchange? Ознакомьтесь с полным обсуждением здесь.