Пирамида хранения -- почему так много уровней

Вы когда-нибудь задумывались, почему у компьютеров есть и «память», и «жёсткий диск»? Почему бы не поместить все данные в самое быстрое место?

Ответ кроется в устройстве компьютерных систем хранения--Пирамида храненияЭта лекция поможет вам глубоко понять самую главную мудрость компромиссов архитектора.


Бытовая аналогия: кухня против склада супермаркета

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

Представьте, что вы готовите.

Соль и соевый соус вы ставите у плиты, под рукой--эторегистриL1-кэш компьютера。

Ингредиенты в холодильнике, до них нужно пройти несколько шагов--это эквивалентнооперативной памяти (RAM)。

Рис, муку и масло, хранящиеся в подвале, за ними приходится идти специально--этотвердотельный накопитель (SSD)。

А запасы на складе супермаркета вы вообще не стали бы держать дома--этожёсткий диск (HDD)и облачное хранилище.

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

Компьютерные системы хранения данных проектируются по этому простому правилу.


Пирамида хранения: компромисс между скоростью и ёмкостью

Внутри компьютера устройства хранения образуют пирамидальную структуру в соответствии с прогрессивным соотношением «скорость — ёмкость — стоимость».

пример: пирамида хранения allocateGraph — спецификация дизайна диаграммы SVG: фон цвета бумаги + emit丝LineDividelayer, ржаво-красный акцент, только markNote верхний layer register
Background halftone dot texture Layer 1: Registers — topmost layer, accent emphasizes (only focus) register ~1 KB · 0.3 nsLayer 2: L1 cache L1 cache ~64 KB · 1 nsLayer 3: L2 cache L2 cache ~256 KB · 4 nsLayer 4: L3 cache L3 cache ~8 MB · 12 nsLayer 5: Memory (RAM) Memory RAM ~16 GB · 100 nsLayer 6: Solid State Drive (SSD) Solid State Drive (SSD) ~1 TB · 100 μsLayer 7: Mechanical Hard Disk (HDD) — bottommost, widest Mechanical Hard Disk (HDD) ~10 TB · 10 msLeft and right side annotations (Geist Mono small text)Faster ↑ Slower ↓ Smaller capacity Larger capacity Всплывающее окно с подробностями при наведении мыши

Схема пирамиды хранения: чем выше, тем быстрее и меньше; чем ниже, тем медленнее и больше. Наведите курсор на трапецию, чтобы увидеть подробности для каждого уровня.

Основные правила

Эта пирамидальная схема раскрывает железное правило в проектировании аппаратного обеспечения:

  • Быстрее, дороже, меньшеРегистры находятся внутри CPU, сделаны из самых быстрых транзисторов, но их размер составляет всего несколько килобайт. Потому что площадь кристалла чрезвычайно дорога.
  • Медленнее, дешевле, большеЖёсткие диски используют магнитные головки и вращающиеся пластины, имеют чрезвычайно низкую стоимость и могут хранить десятки терабайт данных.
  • Цель пирамидальной структурыИспользование комбинации «маленькое и быстрое + большое и медленное» позволяет при разумной стоимости достичь производительности, близкой к самой быстрой памяти.

Если бы компьютер использовал регистры для всего хранения, не только цена была бы астрономической, но и площадь кристалла была бы слишком большой, чтобы его можно было изготовить.

Наоборот, если бы он использовал только жёсткие диски, компьютер был бы слишком медленным для использования -- вам пришлось бы ждать сотни миллисекунд, чтобы открыть любую программу.


Подробное сравнение каждого уровня

Поместите ключевые атрибуты семи уровней хранения в одну таблицу для удобного горизонтального сравнения.

УровеньТипичная ёмкостьЗадержка доступаОтносительная скоростьФизическое расположениеСтоимость производства
регистр~1 KB~0.3 ns1x (базовый уровень)Внутри ядра CPUчрезвычайно высокий
Кэш L1~64 KB~1 ns3x медленнее регистровВнутри ядра CPUчрезвычайно высокий
Кэш L2~256 KB~4 ns13x медленнееВнутри ядра CPUОчень высокий
Кэш L3~8 MB~12 nsв 40 раз медленнееНа кристалле CPU, используется совместно несколькими ядрамиВысокая
Память (RAM)~16 GB~100 nsв 333 раза медленнееНа материнской плате (отдельный чип)Средняя
Твердотельный накопитель (SSD)~1 TB~100 μsв 333,333 раза медленнееВнутри корпуса компьютера (отдельное устройство)Относительно низкая
Жёсткий диск (HDD)~10 TB~10 ms33,333,333x медленнееВнутри корпуса компьютера (отдельное устройство)Низкая

Обратите внимание на скачки на порядки: память в 100 раз медленнее кэша L1, SSD в 1000 раз медленнее памяти, а HDD в 100 раз медленнее SSD. Разрыв в скорости между каждым слоем измеряется порядками величины.

Почему SSD намного быстрее HDD?

Ключевое различие заключается в наличии механических частей.

SSD использует микросхемы флеш-памяти, чтение происходит чисто электронно, без механических частей.

HDD использует вращающиеся пластины и движущуюся головку -- чтобы прочитать часть данных, головка должна сначала переместиться на нужную дорожку (время поиска, около 5-10 ms), затем дождаться, пока пластина повернётся в нужное положение (задержка вращения, около 2-4 ms).

Этот процесс механического движения и есть коренная причина того, что HDD в сотни раз медленнее SSD.


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

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

Пример

"""
Симулятор задержки доступа к пирамиде памяти (демонстрационный пример)
Смоделируйте чтение блоков данных одинакового размера с разных уровней, чтобы наглядно сравнить различия в скорости каждого уровня
"""


class StorageHierarchy:
    """Смоделировать иерархию памяти компьютера"""

    def __init__(self):
        # Смоделированная задержка (в наносекундах) и типичная ёмкость каждого уровня хранения
        self.layers = {
            'Регистр':  {'latency_ns': 0.3,  'capacity': '~1 KB',   'color': 'red'},
            'Кэш L1':  {'latency_ns': 1,    'capacity': '~64 KB',  'color': 'orange'},
            'Кэш L2':  {'latency_ns': 4,    'capacity': '~256 KB', 'color': 'gold'},
            'L3 Cache':  {'latency_ns': 12,   'capacity': '~8 MB',   'color': 'yellow'},
            'RAM':       {'latency_ns': 100,  'capacity': '~16 GB',  'color': 'green'},
            'SSD':       {'latency_ns': 100000, 'capacity': '~1 TB', 'color': 'blue'},
            'HDD':       {'latency_ns': 10000000, 'capacity': '~10 TB', 'color': 'purple'},
        }

    def read(self, layer_name, address):
        """
Симулировать чтение данных из указанного слоя
Вернуть смоделированные значения данных
        """

        value = f"DATA_FROM_{layer_name.upper()}_{address}"
        return value

    def compare_access(self, address, num_accesses=3):
        """Сравнить скорость чтения одного и того же адреса из каждого уровня."""
        print("=" * 65)
        print(f"Сравнение задержки доступа к иерархии памяти (адрес: {address})")
        print("=" * 65)
        print(f{'Уровень':<12} {'Задержка (ns)':>12} {'Емкость':<12} {'Относительно регистра':>12})
        print("-" * 65)

        baseline = self.layers['Register']['latency_ns']

        for name, info in self.layers.items():
            lat_ns = info['latency_ns']
            ratio = lat_ns / baseline
            cap = info['capacity']
            print(f"{name:<12} {lat_ns:>10,.1f} ns {cap:<12} {ratio:>10,.0f}x")


# Запуск демо
print(ПРИМЕР. Учебное руководство по системе хранения: Сравнение задержек доступа к пирамиде хранения)
print()

store = StorageHierarchy()
store.compare_access("0x7FFF1234")

print()
print("=" * 65)
print("Анализ выводов:")
print("=" * 65)

# Вычисление ключевых соотношений
register_lat = 0.3          # ns
ram_lat = 100               # ns
ssd_lat = 100000            # ns
hdd_lat = 10000000          # ns

print(f1. Память (RAM) в {ram_lat / register_lat:,.0f} раз медленнее регистров)
print(f2. SSD в {ssd_lat / ram_lat:,.0f} раз медленнее памяти (RAM))
print(f3. HDD в {hdd_lat / ram_lat:,.0f} раз медленнее памяти (RAM))
print(f4. HDD в {hdd_lat / register_lat:,.0f} раз медленнее регистров)
print()
print("Если обращение к регистру занимает 1 секунду, то:")
print(f- Извлечение из кэша L1 занимает {1/register_lat:.0f} секунд)
print(f" - для получения из памяти требуется {ram_lat/register_lat:,.0f} секунд (около {ram_lat/register_lat/60:.0f} минут)")
print(f" - для получения с HDD требуется {hdd_lat/register_lat:,.0f} секунд (около {hdd_lat/register_lat/3600:,.0f} часов)")

Результат выполнения:

EXAMPLE 存储系统教学: 存储金字塔访问延迟对比

=================================================================
存储层次访问延迟对比(地址: 0x7FFF1234)
=================================================================
层级                 延迟(纳秒) 容量                  相对寄存器
-----------------------------------------------------------------
Register            0.3 ns ~1 KB                 1x
L1 Cache            1.0 ns ~64 KB                3x
L2 Cache            4.0 ns ~256 KB              13x
L3 Cache           12.0 ns ~8 MB                40x
RAM               100.0 ns ~16 GB              333x
SSD           100,000.0 ns ~1 TB           333,333x
HDD          10,000,000.0 ns ~10 TB       33,333,333x

=================================================================
结论分析:
=================================================================
1. 内存(RAM) 比 寄存器 慢 333 倍
2. SSD 比 内存(RAM) 慢 1,000 倍
3. HDD 比 内存(RAM) 慢 100,000 倍
4. HDD 比 寄存器 慢 33,333,333 倍

如果寄存器访问数据需要 1 秒,那么:
  - 从 L1 缓存获取需要 3 秒
  - 从内存获取需要 333 秒(约 6 分钟)
  - 从 HDD 获取需要 33,333,333 秒(约 9,259 小时)

Интерактивная демонстрация: логарифмический график сравнения задержек доступа по уровням

На графике ниже строится столбчатая диаграмма в логарифмическом масштабе; соседние интервалы на горизонтальной оси различаются в 10 раз. Наведите курсор на столбец, чтобы увидеть сведения о ёмкости и задержке.

пример сравнения задержек иерархии памяти — горизонтальная столбчатая диаграмма Plotly с логарифмической координатой (стандартный выбор: использовать Plotly для логарифмической системы координат)

Как работает пирамида: послойная стратегия кэширования

Пирамида не статична — в ней есть механизм автоматического перемещения данных.

Правила потока данных

  1. Когда процессору нужны данныеСначала проверяется самый быстрый кэш L1; если данные не найдены, переходите к L2; если их всё ещё нет, переходите к L3 и так далее вплоть до основной памяти.
  2. После чтения данных из медленного уровняОн не только передаёт данные процессору, но и сохраняет копию в более быстром уровне. Так следующее использование будет быстрым.
  3. Что делать, когда быстрый уровень заполнен?Согласно определённой политике (например, LRU--вытеснение наименее недавно использованных данных), вытеснять редко используемые данные обратно в более медленные уровни, чтобы освободить место для новых данных.

Этот процесс полностью прозрачен для программистов--вам не нужно вручную управлять тем, какой уровень кэша использовать при написании программ; аппаратное обеспечение и операционная система автоматически делают всё это.

Примеры из реальной жизни

Предположим, вы редактируете видеофайл:

  • Видеофайлы находятсяна HDD или SSDвыше (нижний уровень).
  • Когда вы открываете файл, операционная система загружает часть его воперативную память (RAM)В.
  • Когда вы начинаете воспроизведение, CPU копирует данные кадров, обрабатываемых в данный момент, вкэш L3/L2/L1В.
  • Значения пикселей, вычисляемые в данный момент ALU, хранятся врегистреВ.

Когда вы ощущаете «очень плавную работу» в программе для редактирования, это потому, что CPU большую часть времени находит нужные данные в кэше.


Историческая справка: почему пирамида имеет такую форму

Количество уровней пирамиды — исторический результат всё увеличивающегося разрыва в скорости между CPU и памятью.

В 1980-х годах разрыв в скорости между CPU и памятью был невелик. Но по мере развития производства полупроводников скорость CPU росла примерно на 60% в год, тогда как скорость памяти росла лишь примерно на 10% в год.

Этот всё расширяющийся разрыв называется「Memory Wall」(Memory Wall)。

Пирамида хранения — это ответ инженеров на "memory wall" — использование нескольких уровней кэша для сглаживания разрыва в скорости между CPU и основной памятью.

эраЧастота CPUЗадержка памятиРазрыв в скоростиИерархия кэша
1980s~10 MHz~200 nsприблизительно 2xНет или уровень 1
1990s~200 MHz~70 nsПримерно в 14 разL1 + L2
2000s~3 GHz~50 nsПримерно в 150 разL1 + L2 + L3
2020s~5 GHz~80 nsПримерно в 400 разL1 + L2 + L3

Обратите внимание, что задержка памяти по сути почти не изменилась за 40 лет! Дело не в том, что память не улучшалась, а в том, что процессоры улучшались слишком быстро. Физический предел памяти (скорость заряда/разряда конденсатора) делает очень трудным существенное сокращение её задержки.

Другие расширения