Адрес памяти и адресация

Когда вы объявляете переменную в своей программе, как компьютер её «находит»? Почему система 32-bit может поддерживать только 4GB оперативной памяти?

Эта лекция приоткрывает завесу над адресами памяти, помогая вам понять адресное пространство — фундаментальное ограничение, определяющее, сколько памяти может использовать компьютер.


Бытовая аналогия: почтовые ящики в многоквартирном доме

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

Когда курьер доставляет почту, ему достаточно знать номер квартиры (адрес), чтобы точно опустить письмо в нужный почтовый ящик. Способ, которым CPU обращается к памяти, почти точно такой же, как курьер, доставляющий почту:

  • Каждая единица памяти (1 byte)= Почтовый ящик
  • Адрес памяти= номер ячейки почтового ящика (нумерация начинается с 0)
  • Разрядность шины адреса= максимальное количество цифр в номере ячейки (определяет, сколько номеров можно назначить максимум)

Если номер ячейки имеет только 2 цифры (00~99), в здании может быть максимум 100 почтовых ящиков. Аналогично, если шина адреса имеет ширину всего 32 бита, CPU может различать максимум 2^32 различных ячеек памяти.


Суть адресов памяти

Адрес — это просто число

С точки зрения аппаратного обеспечения, память — это длинный ряд физических ячеек, которые могут хранить 0 и 1. Каждая ячейка хранит 1 байт (8 бит), и каждая ячейка имеет уникальный номер — этот номер и естьадрес памяти。

CPU читает и записывает память через систему из трёх шин:

  1. CPU помещает целевой адрес нашину адресаПо шине адреса — «Я хочу найти почтовый ящик 103»
  2. CPU находится нашине управленияПо шине управления он посылает сигнал «чтение» или «запись» — «Пожалуйста, дай мне то, что внутри» или «Пожалуйста, положи это сюда».
  3. Память помещает данные вшину данныхНа шине данных данные помещаются на неё (при чтении) или берутся с неё (при записи).

Почему каждый адрес соответствует 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 бит256256 BДлина текстового сообщенияРанние микроконтроллеры
10 бит1,0241 KBОдна страница простого текстаРанняя EEPROM
16-битный65,53664 KBКороткий рассказIntel 8086, 6502
20-битная1,048,5761 MBКнига средней толщиныIntel 8088 (IBM PC)
24-битная16,777,21616 MBМузыкальный трек без потерьРанние рабочие станции
32-битный4,294,967,2964 GBHD-фильмPentium, ARMv7
36 bits68,719,476,73664 GBВсе данные на небольшом NASРежим x86 PAE
40 bits1,099,511,627,7761 TBПолная ёмкость SSD потребительского классаРанний ARMv8
48 bits281,474,976,710,656256 TBОбъём данных в дата-центре среднего размераСовременный x86-64
64-битный~1.84 × 10^1916 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)} (Примечание: это количество уже намного превышает общее количество атомов в наблюдаемой Вселенной!)")
пример AddressSpaceComputedevice — блок-слайдер + рендеринг формул KaTeX + визуализация CSS Grid transform

Интерактивная демонстрация: калькулятор адресного пространства

Перетащите ползунок, чтобы настроить количество адресных битов (1~64), и используйте KaTeX для рендеринга 2n-формулы в реальном времени, а CSS Grid рисует сетку ячеек памяти (для 8 бит или меньше отрисовываются все 256 ячеек).

Кнопка быстрого пресета
Ползунок адресных битов
8
Область рендеринга формул KaTeX
Общее количество адресуемых единиц
Область визуализации CSS Grid
Визуализация сетки ячеек памяти (каждая ячейка представляет 1 байт)

PAE: решение «продления жизни» для 32-битных систем

До широкого распространения 64-битных систем, столкнувшись с ограничением в 4GB, Intel разработала обходное решение —PAE (Physical Address Extension)。

PAE расширяет линии физических адресов с 32 бит до 36 бит, позволяя 32-битным процессорам адресовать до 2^36 = 64 GB физической памяти.

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

PAE было лишь переходным решением; настоящим решением был полный переход на 64-битную архитектуру.


Виртуальный адрес против физического адреса

«Адрес», о котором мы говорили ранее, в основном относится кФизическому адресу— реальной нумерации на аппаратном уровне на модулях памяти.

Но в современных операционных системах адрес, который видит ваша программа, — это не физический адрес, авиртуальный адрес。

Зачем нужны виртуальные адреса?

  1. Изоляция и защитавиртуальный адрес: Программа A не может читать или записывать память программы B (иначе аварийно завершающаяся программа могла бы повредить всю систему).
  2. Упрощение программированияКаждая программа считает, что единолично владеет всем адресным пространством (например, от 0 до 4GB), и ей не нужно заботиться о том, какие адреса используют другие программы.
  3. Гибкое управление памятьюОперационная система может временно записывать редко используемую память на диск (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)")
Другие расширения