Адрес памяти и адресация
Когда вы объявляете переменную в своей программе, как компьютер её «находит»? Почему система 32-bit может поддерживать только 4GB оперативной памяти?
Эта лекция приоткрывает завесу над адресами памяти, помогая вам понять адресное пространство — фундаментальное ограничение, определяющее, сколько памяти может использовать компьютер.
Бытовая аналогия: почтовые ящики в многоквартирном доме
Представьте многоквартирный дом, в котором у каждой квартиры есть собственный почтовый ящик, и каждый ящик помечен уникальным номером квартиры.
Когда курьер доставляет почту, ему достаточно знать номер квартиры (адрес), чтобы точно опустить письмо в нужный почтовый ящик. Способ, которым CPU обращается к памяти, почти точно такой же, как курьер, доставляющий почту:
- Каждая единица памяти (1 byte)= Почтовый ящик
- Адрес памяти= номер ячейки почтового ящика (нумерация начинается с 0)
- Разрядность шины адреса= максимальное количество цифр в номере ячейки (определяет, сколько номеров можно назначить максимум)
Если номер ячейки имеет только 2 цифры (00~99), в здании может быть максимум 100 почтовых ящиков. Аналогично, если шина адреса имеет ширину всего 32 бита, CPU может различать максимум 2^32 различных ячеек памяти.
Суть адресов памяти
Адрес — это просто число
С точки зрения аппаратного обеспечения, память — это длинный ряд физических ячеек, которые могут хранить 0 и 1. Каждая ячейка хранит 1 байт (8 бит), и каждая ячейка имеет уникальный номер — этот номер и естьадрес памяти。
CPU читает и записывает память через систему из трёх шин:
- CPU помещает целевой адрес нашину адресаПо шине адреса — «Я хочу найти почтовый ящик 103»
- CPU находится нашине управленияПо шине управления он посылает сигнал «чтение» или «запись» — «Пожалуйста, дай мне то, что внутри» или «Пожалуйста, положи это сюда».
- Память помещает данные вшину данныхНа шине данных данные помещаются на неё (при чтении) или берутся с неё (при записи).
Почему каждый адрес соответствует 1 байту?
Это проектное решение. Некоторые ранние компьютеры использовали «словную адресацию» (каждый адрес соответствует 2 или 4 байтам), но современные компьютеры почти все используютпобайтовую адресацию— побайтовую адресацию, при которой каждый адрес соответствует 1 байту.
Преимущество: обработка символов (каждый символ ASCII занимает 1 байт) очень естественна, не требуется дополнительная логика выравнивания и разбиения.
内存地址: 0 1 2 3 4 5 6 7
+------+------+------+------+------+------+------+------+
内容: | 0x48 | 0x65 | 0x6C | 0x6C | 0x6F | 0x00 | 0xFF | ... |
+------+------+------+------+------+------+------+------+
'H' 'e' 'l' 'l' 'o' '\0'
一个 32 位整数 0x12345678 在内存中的存储(小端序):
地址: 0 1 2 3
+------+------+------+------+
内容: | 0x78 | 0x56 | 0x34 | 0x12 |
+------+------+------+------+
低字节在低地址——这就是「小端序」(Little Endian)
Почему 32-битная система может использовать не более 4GB памяти
Непосредственная причина: разрядность шины адреса
32-битный адрес — это двоичное число, состоящее из 32 нулей или единиц.
Количество различных значений, которые могут быть представлены 32 двоичными битами, равно:
2^32 = 2 × 2 × 2 × ... (32 раза) =4,294,967,296
Это примерно4GB(GigaBytes)。
Если каждый адрес соответствует 1 байту, то 32-битное адресное пространство может адресовать в общей сложности 4,294,967,296 байт = 4 GB.
Вывод
1 KB = 2^10 字节 = 1,024 字节
1 MB = 2^20 字节 = 1,048,576 字节
1 GB = 2^30 字节 = 1,073,741,824 字节
2^32 = 2^2 × 2^30
= 4 × 1 GB
= 4 GB
Следовательно,32-бит = 4GBЭто не совпадение, а строгая математическая зависимость между количеством разрядов адреса и адресуемым пространством.
Аналогия: количество цифр в телефонном номере
Предположим, телефонные номера в городе состоят из 8 цифр (00000000 ~ 99999999). Какое максимальное количество различных телефонных номеров может быть в этом городе?
10^8 = 100 миллионов. Если население превышает 100 миллионов, 8 цифр уже недостаточно — нужно перейти на 9 цифр.
Та же логика: 32-битный адрес, доведённый до предела, тоже равен 4GB. Когда требования к памяти превышают 4GB, 32-битная система бессильна — именно поэтому индустрия коллективно перешла на 64-битную архитектуру.
Что означает 64-битность?
Теоретический предел 64-битного адресного пространства составляет:
2^64 = 18,446,744,073,709,551,616 байт ≈16 EB(ExaBytes)
Насколько велико это число?
- 1 EB = 1 миллиард GB
- 16 EB — это примерно в несколько сотен раз больше объёма трафика данных, генерируемого глобальным интернетом за один день в 2025 году.
- Если бы каждый байт был песчинкой, 16 EB песка могли бы заполнить около 2,000 стандартных плавательных бассейнов.
В настоящее время ни одна потребительская материнская плата не поддерживает столько памяти. Современные 64-битные процессоры обычно реализуют только 48-битные линии физических адресов (адресация до 256 TB), а Windows 10 Home ограничена 128 GB — но для настоящего и обозримого будущего этого уже «вполне достаточно».
Истинный смысл 64-бит не в том, сколько памяти можно установить, а в следующем:Программному обеспечению и операционным системам больше не нужно придумывать различные обходные пути из-за нехватки адресного пространства.(например, PAE — Physical Address Extension — из эпохи 32-битных систем).
Сравнение адресуемого пространства для разных разрядностей
| Разряды адреса | Количество адресуемых единиц | Адресуемое пространство | Яркая аналогия | Представляет устройство/систему |
|---|---|---|---|---|
| 8 бит | 256 | 256 B | Длина текстового сообщения | Ранние микроконтроллеры |
| 10 бит | 1,024 | 1 KB | Одна страница простого текста | Ранняя EEPROM |
| 16-битный | 65,536 | 64 KB | Короткий рассказ | Intel 8086, 6502 |
| 20-битная | 1,048,576 | 1 MB | Книга средней толщины | Intel 8088 (IBM PC) |
| 24-битная | 16,777,216 | 16 MB | Музыкальный трек без потерь | Ранние рабочие станции |
| 32-битный | 4,294,967,296 | 4 GB | HD-фильм | Pentium, ARMv7 |
| 36 bits | 68,719,476,736 | 64 GB | Все данные на небольшом NAS | Режим x86 PAE |
| 40 bits | 1,099,511,627,776 | 1 TB | Полная ёмкость SSD потребительского класса | Ранний ARMv8 |
| 48 bits | 281,474,976,710,656 | 256 TB | Объём данных в дата-центре среднего размера | Современный x86-64 |
| 64-битный | ~1.84 × 10^19 | 16 EB | Астрономическое число, намного превышающее текущие ограничения физической памяти | Ограничения архитектур x86-64 / ARMv8 |
Примечание: переход с 32-бит на 64-бит — это не «удвоение», а скачок с 4GB до 16EB — увеличение вболее 4 миллиардов раз! Здесь в полной мере демонстрируется сила экспоненциального роста.
Интерактивная демонстрация: калькулятор адресного пространства
Программа ниже систематически показывает адресуемое пространство, соответствующее разной разрядности адреса, и с помощью визуализации позволяет интуитивно почувствовать экспоненциальный рост.
Пример
Калькулятор адресного пространства памяти (пример демонстрации)
Функции:
1. Вычислить адресуемое пространство, соответствующее любому количеству бит адреса
2. Вывести полную сравнительную таблицу от 8 до 64 бит
3. Визуализировать экспоненциальный рост
"""
import math
def address_space_to_str(bytes_val):
"""
Преобразовать количество байтов в удобочитаемый формат
Поддерживаются: B, KB, MB, GB, TB, PB, EB
"""
if bytes_val == 0:
return "0 B"
units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB']
unit_idx = 0
value = float(bytes_val)
# Увеличивайте единицы уровень за уровнем, сохраняя значения в разумных пределах
while value >= 1024 and unit_idx < len(units) - 1:
value /= 1024
unit_idx += 1
if unit_idx == 0:
return f"{int(value):,} {units[unit_idx]}"
elif value >= 100:
return f"{value:,.0f} {units[unit_idx]}"
elif value >= 10:
return f"{value:,.1f} {units[unit_idx]}"
else:
return f"{value:,.2f} {units[unit_idx]}"
def print_address_space_table(start_bits=8, end_bits=64):
"""
Вывести таблицу сравнения адресных пространств
:param start_bits: начальная позиция бита
:param end_bits: конечное количество битов
"""
print("=" * 85)
print(Калькулятор адресного пространства памяти — ПРИМЕР Принципы организации ЭВМ)
print("=" * 85)
print()
print(f"{'Биты адреса':<10} {'количество адресуемых ячеек':>20} {'Адресуемое пространство':>18} {'относительно 32-бит':>15}")
print("-" * 85)
# На основе 32-бит
baseline_32 = 2 ** 32
# Выбрать значащие цифры для отображения
key_bits = [8, 10, 12, 14, 16, 18, 20, 24, 28, 30, 32, 36, 40, 44, 48, 52, 56, 60, 64]
for bits in key_bits:
if bits < start_bits or bits > end_bits:
continue
count = 2 ** bits
space_str = address_space_to_str(count)
# Вычислить соотношение относительно 32 бит
if bits <= 32:
ratio = count / baseline_32
ratio_str = f"1/{int(baseline_32/count)}" if ratio < 1 else "1x"
else:
ratio = count / baseline_32
if ratio >= 1_000_000_000:
ratio_str = f{ratio/1_000_000_000:,.1f} сто миллионов раз
elif ratio >= 1_000_000:
ratio_str = f{ratio/1_000_000:,.0f} миллионов раз
elif ratio >= 1_000:
ratio_str = f"{ratio/1_000:,.0f} тысяч раз"
else:
ratio_str = f"{ratio:,.0f}x"
print(f"{bits} bits{'':<5} {count:>20,} {space_str:>18} {ratio_str:>15}")
print("-" * 85)
print()
def analyze_why_4gb():
"""Подробный анализ процесса вывода для 32-bit = 4GB"""
print("=" * 85)
print("Подробный разбор: почему 2^32 = 4 GB?")
print("=" * 85)
print()
print("Шаги вывода:")
print()
print(" 2^10 = 1,024 → 1 KB")
print(" 2^20 = 1,024 × 1,024 = 1,048,576 → 1 MB")
print(" 2^30 = 1,024 × 1,024 × 1,024 → 1 GB")
print(" = 1,073,741,824 bytes")
print()
print(" 2^32 = 2^2 × 2^30")
print(" = 4 × 1,073,741,824")
print(" = 4,294,967,296 bytes")
print(" = 4 GB (точнее, 4 GiB)")
print()
print("Примечание: строго говоря")
print(" 4 GB (Gigabyte) = 4 × 10^9 = 4,000,000,000 byte(десятичное)")
print(4 GiB (Gibibyte) = 4 × 2^30 = 4,294,967,296 bytes (двоичное))
print(В компьютерной сфере то, что обычно называют '4GB memory', фактически означает 4 GiB.)
print()
def visualize_growth():
"""Отобразить экспоненциальный рост с помощью простой столбчатой диаграммы ASCII"""
print("=" * 85)
print("Визуализация экспоненциального роста (столбчатая диаграмма ASCII, логарифмическая шкала)")
print("=" * 85)
print()
bits_list = [8, 16, 20, 24, 28, 32, 36, 40, 48, 64]
# Использовать логарифм для сжатия диапазона отображения
for bits in bits_list:
count = 2 ** bits
log10 = math.log10(count)
bar = "=" * int(log10 * 3) # Каждая единица log10 = 3 знака равенства
space_str = address_space_to_str(count)
print(f" {bits:>3} бит |{bar:<60} {space_str}")
print()
print(Наблюдение: от 8 до 64 бит длина полосы растёт равномерно (потому что используется логарифмическая шкала))
print(" Но фактическое значение растёт экспоненциально — от 32 до 64 бит оно увеличилось более чем в 4 миллиарда раз!")
print()
def practical_questions():
"""Практические задачи"""
print("=" * 85)
print("Практическое применение: вычислите, сколько памяти может поддерживать ваша система.")
print("=" * 85)
print()
questions = [
("устаревший микроконтроллер с 8-битной адресной шиной", 8),
(процессор 6502 с 16-битной адресной шиной, 16),
("ноутбук с 32-битной операционной системой", 32),
(32-битный сервер с включённым PAE (36-битный физический адрес), 36),
(Современный 64-битный домашний компьютер (48-битный физический адрес), 48),
("Теоретический предел 64-битной архитектуры", 64),
]
for desc, bits in questions:
space = 2 ** bits
print(f" {desc}:")
print(f" 2^{bits} = {space:,} byte = {address_space_to_str(space)}")
print()
# ========== Основная программа ==========
if __name__ == "__main__":
print_address_space_table(8, 64)
analyze_why_4gb()
visualize_growth()
practical_questions()
# Дополнительно: интерактивный запрос
print("=" * 85)
print("Пользовательский запрос")
print("=" * 85)
print()
custom_bits = [1, 4, 8, 16, 32, 64, 128]
for bits in custom_bits:
space = 2 ** bits
print(f{bits:>3} битовых адресов → {space:,} адресов)
if bits >= 128:
print(f" → {address_space_to_str(space)} (Примечание: это количество уже намного превышает общее количество атомов в наблюдаемой Вселенной!)")
Интерактивная демонстрация: калькулятор адресного пространства
Перетащите ползунок, чтобы настроить количество адресных битов (1~64), и используйте KaTeX для рендеринга 2n-формулы в реальном времени, а CSS Grid рисует сетку ячеек памяти (для 8 бит или меньше отрисовываются все 256 ячеек).
Кнопка быстрого пресетаPAE: решение «продления жизни» для 32-битных систем
До широкого распространения 64-битных систем, столкнувшись с ограничением в 4GB, Intel разработала обходное решение —PAE (Physical Address Extension)。
PAE расширяет линии физических адресов с 32 бит до 36 бит, позволяя 32-битным процессорам адресовать до 2^36 = 64 GB физической памяти.
Но здесь есть ключевое ограничение:Виртуальное адресное пространство каждого процесса по-прежнему составляет 32 бита (4GB)Одна программа по-прежнему ограничена максимум 4GB памяти. Преимущество PAE в том, что оно позволяет серверам запускать больше программ одновременно, при этом каждая программа использует свои собственные 4GB.
PAE было лишь переходным решением; настоящим решением был полный переход на 64-битную архитектуру.
Виртуальный адрес против физического адреса
«Адрес», о котором мы говорили ранее, в основном относится кФизическому адресу— реальной нумерации на аппаратном уровне на модулях памяти.
Но в современных операционных системах адрес, который видит ваша программа, — это не физический адрес, авиртуальный адрес。
Зачем нужны виртуальные адреса?
- Изоляция и защитавиртуальный адрес: Программа A не может читать или записывать память программы B (иначе аварийно завершающаяся программа могла бы повредить всю систему).
- Упрощение программированияКаждая программа считает, что единолично владеет всем адресным пространством (например, от 0 до 4GB), и ей не нужно заботиться о том, какие адреса используют другие программы.
- Гибкое управление памятьюОперационная система может временно записывать редко используемую память на диск (swap/paging) и считывать её обратно при необходимости.
Внутри процессора находится аппаратный блок, называемыйMMU (Memory Management Unit), который отвечает за преобразование виртуальных адресов в физические в реальном времени.
程序看到的虚拟地址 → [MMU 翻译] → 物理地址 → [地址总线] → 内存条
程序写: *(0x08048000) = 42
↓
MMU 查表: 虚拟页 0x08048 → 物理页 0x1A3F0
↓
物理地址: 0x1A3F0000 的内存单元被写入 42
Виртуальные адреса — это краеугольный камень стабильности современных операционных систем. Без виртуальных адресов и MMU программа, читающая или записывающая за пределами допустимого, могла бы вызвать синий экран всей системы — кошмар, случавшийся каждый день в эпоху DOS.
Как адреса памяти проявляются в программировании
В C/C++ можно напрямую манипулировать адресами памяти (указателями). Вот наглядный пример:
Пример
Просмотр адресов памяти в Python (демонстрационный пример)
Хотя Python абстрагирует низкоуровневые указатели, функция id() всё же позволяет заглянуть в концепцию адресов.
"""
import sys
# Адреса памяти базовых типов
a = 42
b = 42
c = 999
d = 999
print(ПРИМЕР Исследование адресов памяти: демонстрация Python id())
print("=" * 60)
print()
# Python кэширует небольшие целые числа (-5~256); переменные с одинаковым значением указывают на один и тот же адрес
print("Феномен кэширования небольших целых чисел:")
print(fa = 42, id(a) = {id(a)} (в шестнадцатеричном виде: 0x{id(a):X}))
print(fb = 42, id(b) = {id(b)} (в шестнадцатеричном виде: 0x{id(b):X}))
print(f" a и b ссылаются на один и тот же объект: {a is b}")
print()
print("Большие целые числа не кэшируются:")
print(fc = 999, id(c) = {id(c)} (шестнадцатеричное представление: 0x{id(c):X}))
print(fd = 999, id(d) = {id(d)} (шестнадцатеричное представление: 0x{id(d):X}))
print(fc и d ссылаются на один и тот же объект: {c is d} (обычно False, зависит от реализации Python))
print()
# Адрес строки
text = "Hello EXAMPLE"
print(fid строки 'Hello EXAMPLE': 0x{id(text):X})
# Адрес списка и адреса его элементов
lst = [10, 20, 30]
print(f"\nсписок lst = {lst}")
print(f" id самого списка: 0x{id(lst):X}")
print(fid элемента lst[0]: 0x{id(lst[0]):X})
print(fid элемента lst[1]: 0x{id(lst[1]):X})
print(fid элемента lst[2]: 0x{id(lst[2]):X})
print()
print(Описание:)
print(Хотя Python не раскрывает физические адреса памяти, id() возвращает уникальный идентификатор объекта.)
print("В реализации CPython id() возвращает адрес объекта в виртуальной памяти.")
print(Вы можете видеть, что элементы списка хранятся разрозненно (не непрерывно, как в массивах C).)
print()
# Воплощение 32-бит против 64-бит
print("=" * 60)
print("Информация о разрядности интерпретатора Python:")
print(f" sys.maxsize = {sys.maxsize}")
print(f" 2^31 - 1 = {2**31 - 1}")
print(f" 2^63 - 1 = {2**63 - 1}")
print()
if sys.maxsize > 2**32:
print(fВаш Python — 64-битный (maxsize > 2^32))
else:
print(f" Ваш Python — 32-битный (maxsize <= 2^32)")