Мой дэйли дайджест

одно техническое понятие в день

Своп (swap)

17 июня 2026 · ~15 мин чтения

операционные-системы память концепция производительность

Своп (swap)

Своп — это место на диске, которое операционная система использует как «продолжение» оперативной памяти: туда вытесняются страницы памяти, которые сейчас не нужны, чтобы освободить место активным.

История

Идея простая, но появилась она не сразу. До конца 1950-х в компьютерах
программа целиком помещалась в основную память — и если не помещалась,
программисту приходилось вручную делить её на «оверлеи» и подгружать куски
с барабана. Это было больно, и каждый делал это по-своему.

Перелом — Atlas Computer (Манчестерский университет, 1962 год). Это был
один из первых компьютеров с виртуальной памятью и пейджингом.
Главный инженер — Том Килбёрн (Tom Kilburn), тот же человек, который раньше
построил Manchester Baby (первый в мире компьютер с хранимой программой,
1948 год). Идея Atlas была революционной: программа видит «непрерывное
адресное пространство», а ОС сама перебрасывает блоки между быстрой
магнитной сердечной памятью (16 тысяч слов) и медленным барабаном
(96 тысяч слов). Программист о существовании барабана даже не подозревает.

С тех пор все универсальные ОС эту идею переняли. Несколько вех:

В 2010-х появился zram/zswap в Linux: сжатый своп прямо в RAM. Идея
красивая: лучше пожать страницу в 3 раза, чем гнать её на медленный диск.
Сегодня zram включён по умолчанию во всех Android-устройствах — у
телефонов мало RAM, и сжатие выигрывает у физического свопа.

Что это такое

Когда говорят «своп», обычно подразумевают одно из трёх:

  1. Swap space — место на диске (отдельный раздел или файл), куда ОС
    вытесняет страницы памяти. На Linux это обычно /swapfile или раздел
    с типом linux-swap. На macOS — файлы в /private/var/vm/. На Windows
    — pagefile.sys в корне системного диска.
  2. Swapping (в широком смысле) — сам процесс вытеснения и подгрузки
    страниц. Технически правильнее называть это paging, но в обиходе
    «своп» прижилось.
  3. Swapping (в узком, историческом смысле) — вытеснение целиком
    процесса, как в Unix v6. Сейчас почти не встречается.

Что важно понять: своп — это не дополнительная память. Своп — это
иллюзия дополнительной памяти. Программам показывают, что памяти
хватает, но как только ОС начнёт реально читать и писать страницы с диска,
скорость работы упадёт в 1000–10000 раз. RAM отвечает за наносекунды,
NVMe SSD — за десятки микросекунд, обычный SATA SSD — за сотню микросекунд,
HDD — за миллисекунды. Между «всё помещается в RAM» и «активная работа
ушла в своп» — пропасть, которая мгновенно ощущается пользователем как
«система зависла».

Своп vs виртуальная память. Виртуальная память — более широкое понятие:
это сам механизм, при котором у каждого процесса своё виртуальное адресное
пространство, а ядро через таблицу страниц проецирует его на физическую
память. Своп — это расширение виртуальной памяти на диск. Виртуальная
память работает и без свопа (на встроенных системах часто так); своп без
виртуальной памяти невозможен.

Своп vs кэш. Иногда путают. Кэш файловой системы — это когда ОС держит
в RAM копии содержимого диска, чтобы повторное чтение было быстрым.
Своп — наоборот: ОС держит на диске копии содержимого RAM, чтобы
освободить место. Кэш — дополнительная скорость; своп — расплата за
нехватку памяти.

Аналогии из жизни

Стол и шкаф. Представь, что ты редактор: на столе лежат бумаги, с
которыми сейчас работаешь (RAM), а в шкафу — папки, которые могут
понадобиться (своп). Когда стол переполнен, ты убираешь самую старую папку
в шкаф, чтобы новая поместилась. Если кто-то спросит про эту старую — встал,
дошёл до шкафа, нашёл, принёс. Дольше, но влезло.

Где ломается: в реальности шкаф стоит рядом со столом, дорога занимает
секунды. Своп же медленнее RAM в тысячи раз — как если бы шкаф был
в соседнем здании на другом этаже, и за каждой папкой надо идти лично.

Холодильник и морозилка. Текущая еда лежит в холодильнике (RAM) — её
быстро достал и съел. Заготовки на потом — в морозилке (своп). Хранится
бесконечно, но прежде чем использовать, надо разморозить.

Где ломается: морозилка реально сохраняет еду и делает её более
компактной; своп ничего не «сжимает» в обычном смысле, он просто меняет
место (хотя есть исключение — zram/zswap, там как раз есть компрессия).

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

Где ломается: в реальной жизни поездка за машиной в гараж — это часы.
Своп всё-таки секунды, а не часы. Зато выбор «какую машину держать
ближе» делается тобой осознанно, а ОС решает это по алгоритму —
и иногда ошибается.

Как это работает

Чтобы понять своп, надо сначала понять три вещи: страницы, таблица страниц
и page fault.

Страница. Память делится на блоки фиксированного размера, обычно
4 КБ (на x86; на новых ARM — 16 КБ). Это атом памяти: всё, что ОС
вытесняет или возвращает в RAM, — это страницы целиком, никогда отдельные
байты.

Таблица страниц (page table). Для каждого процесса ядро ведёт таблицу:
«виртуальный адрес X → физический адрес Y». Таблица многоуровневая
(обычно 4 уровня на современных x86-64) — чтобы не хранить полную карту
для адресного пространства в десятки терабайт. У каждой записи есть флаги:
present (страница в RAM или нет?), dirty (была ли изменена?), accessed
(была ли прочитана недавно?), права доступа и т.д.

MMU и TLB. За проекцию виртуального адреса в физический отвечает
аппаратный блок процессора — MMU (Memory Management Unit). У MMU есть
встроенный кэш — TLB (Translation Lookaside Buffer), потому что
прохождение по 4-уровневой таблице страниц на каждый доступ к памяти
было бы слишком медленным.

Теперь — что происходит при свопе.

Шаг 1. Памяти стало мало. Допустим, у тебя 16 ГБ RAM, и активные
процессы хотят 17 ГБ. ОС запускает алгоритм выбора «жертвы» — какую
страницу выгнать. Самые известные алгоритмы:

Шаг 2. Запись на диск. Выбранную страницу ОС пишет в своп-область.
Если страница clean (содержимое совпадает с тем, что уже есть на диске,
например — код программы или mmap-нутый файл), записывать не надо — просто
пометить «отсутствует». Если dirty (была изменена) — записать.

Шаг 3. Освобождение. Запись в таблице страниц обновляется: флаг
present сбрасывается, в саму запись пишется номер блока в свопе.
Физическая страница в RAM теперь свободна.

Шаг 4. Page fault. Когда процесс обращается к этой странице, MMU видит
present=0 и вызывает прерывание — page fault. Управление переходит в
ядро. Ядро по записи в таблице понимает: страница в свопе. Находит
свободную страницу в RAM (возможно, выгоняя кого-то ещё), читает с диска,
обновляет таблицу, передаёт управление обратно процессу. Процесс об этом
не знал — он просто заметил, что одна инструкция выполнилась подозрительно
долго (миллисекунды вместо наносекунд).

Threshing (буксование). Самый неприятный режим. Если активный
working set всех процессов больше объёма RAM, ОС начинает выгонять
страницу, которая через секунду снова понадобится, потом возвращать её,
выгоняя соседнюю, и т.д. В итоге диск загружен на 100%, процессор простаивает,
полезной работы — ноль. Это и есть та самая «всё зависло, мышка дёргается
рывками». В Linux от threshing спасает OOM-killer: ядро решает, что лучше
прибить самый прожорливый процесс, чем продолжать буксовать.

Swappiness. В Linux есть параметр vm.swappiness (0–100, по умолчанию 60).
Это не процент памяти, который пойдёт в своп, как часто думают. Это
склонность ядра выгонять анонимные страницы (heap процессов) вместо
выкидывания страниц файлового кэша. 0 — «трогай своп в последнюю очередь»,
100 — «своп и file cache равнозначны». На серверах БД часто ставят 10
(потому что file cache важнее), на десктопах оставляют 60.

ASCII-схема цикла:

   процесс                        ядро                     диск
     |                              |                        |
     | mov eax, [0x7f00]            |                        |
     | (виртуальный адрес)          |                        |
     |--> MMU ищет страницу         |                        |
     |    в таблице страниц         |                        |
     |    present=0! ---------------|                        |
     |    page fault -------------> |                        |
     |                              | находит запись         |
     |                              | "в свопе, блок 1234"   |
     |                              | читает 4КБ --------->  |
     |                              | <--- 4КБ через ~10мкс  |
     |                              | кладёт в физ. RAM      |
     |                              | обновляет MMU          |
     | <----------------------------|                        |
     | продолжает с той инструкции  |                        |

Где встречается в обычной жизни

Где встречается в IT и бизнесе

Кто пользуется

Цифры (примерные, по разным источникам):
- На типичном Android-телефоне (Pixel 8, 8 ГБ RAM) zram даёт эквивалент
ещё ~4 ГБ «памяти».
- На MacBook Air M2 с 8 ГБ свопфайл обычно держится 5–15 ГБ при средней
нагрузке.
- На прод-сервере PostgreSQL с 128 ГБ RAM swap часто 4 ГБ — символический,
«на всякий случай», и здоровая система к нему не прикасается.

Альтернативы и конкуренты

Когда НЕ стоит использовать

Самая частая ошибка

«Накину swap побольше — пусть памяти будет много». Своп не делает память больше, он позволяет не упасть при её нехватке. Программа, которая активно работает с 32 ГБ на 16-гиговой машине, будет работать в 1000 раз медленнее, а не «как бы с 32 ГБ».

Связанные понятия

Литература и источники

Где встретилось у меня

Вчера на Mac mini (16 ГБ) поднял Ollama с моделью Gemma 12B — пошло
хорошо. Когда попробовал прикинуть Gemma 26B, выяснилось, что она не
помещается в видеопамять (11.8 ГБ) и даже в общую (16 ГБ): либо не
загрузится, либо уйдёт в своп — и инференс упадёт с 13 токенов/сек
до примерно одного. Параллельно на VPS обнаружил, что справочник ЖК
ест 1.7 ГБ RSS, и хост сидит на 1.7 ГБ свопа — тонкий запас, любая
ещё одна утечка начнёт замедлять соседние сервисы.

Главный вывод дня

Своп — это не «дополнительная память», а способ не упасть, замедлившись в тысячу раз. Если приложение должно держать N гигабайт active set, у него должно быть N гигабайт RAM. Точка. Своп — страховка, не план.

Краткое резюме