В некоторые дни интересно взглянуть на поверхностный уровень компьютерного опыта, а в другие дни интересно вникать во внутреннюю работу. Сегодня мы рассмотрим структуру компьютерной памяти и то, сколько вещей вы можете упаковать в карту памяти.
Сегодняшняя сессия вопросов и ответов приходит к нам благодаря 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
_____ СЕГ 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? Ознакомьтесь с полной веткой обсуждения здесь.
