Скорость любой Linux системы складывается из нескольких слоёв кэшей, спрятанных друг за другом. Сначала данные задерживаются в кэшах процессора, затем в страницах page cache, в структурах dentry и inode, в объектах slab аллокатора. Каждый слой живёт по своим правилам, обслуживается своим кодом ядра и наблюдается своими инструментами. Инженер, понимающий эту лестницу, отличает дефицит L3 от промахов page cache за минуты, а не после долгого перебора гипотез. Статья проходит по всем уровням снизу вверх и показывает, где смотреть, что измерять и какими командами.
Аппаратные кэши процессора и их влияние на скорость выполнения кода
Ближайший к вычислениям слой находится внутри самого процессора. Ядро обычно получает кэш первого уровня, разделённый на память инструкций и данных, объёмом в десятки килобайт и задержкой в единицы тактов. За ним стоит объединённый кэш второго уровня ёмкостью в сотни килобайт, а следом общий для всех ядер кэш третьего уровня размером в мегабайты и десятки мегабайт. Чем дальше уровень, тем больше ёмкость и тем дороже каждый промах.
Данные перемещаются между уровнями строками по 64 байта, и это объясняет половину практических советов по оптимизации. Линейный проход по массиву подхватывается префетчером и даёт почти сплошные попадания, а прыжки по связному списку превращают каждую выборку в отдельную загрузку строки. У многопоточных программ своя беда: два потока, пишущие в соседние поля структуры, непрерывно перетягивают одну строку кэша между ядрами. Явление называется ложным разделением и лечится выравниванием и разнесением горячих полей.
Рядом с кэшами данных работает и кэш трансляций TLB: он буферизует результаты преобразования виртуальных адресов в физические. Каждый промах TLB заставляет процессор проходить таблицы страниц, поэтому приложения с большим объёмом случайных обращений выигрывают от огромных страниц. В Linux их дают прозрачные огромные страницы и madvise, а цена в том, что большие страницы сложнее освобождать и дефрагментировать, и под давлением памяти они порой недоступны.
Размеры кэшей конкретной машины видны штатной утилитой:
lscpu | grep -i cache
Типичный вывод на настольном процессоре выглядит примерно так:
L1d: 48 KiB (2 instances)
L1i: 32 KiB (2 instances)
L2: 2 MiB (2 instances)
L3: 32 MiB (1 instance)
Долю промахов в реальной работе считает perf:
perf stat -e cycles,instructions,cache-references,cache-misses ./workload
Много cache-misses на инструкцию говорит о том, что задача дружит с конвейером, но не с памятью. Для поиска ложного разделения в perf есть отдельная подкоманда c2c, собирающая карту обращений к одним и тем же строкам кэша. На двухпроцессорных машинах у каждого процессора свой кэш L3, и доступ к чужой памяти идёт через NUMA соединение дороже. Утилита numactl показывает топологию, а привязка процесса к узлу с его памятью убирает лишние походы по шине. Для задач с чётким разделением потоков по данным это даёт ощутимые проценты, а для чувствительных к задержке измерений - разницу между укладкой в бюджет и её провалом.
Page cache как буфер между диском и памятью
Следующий уровень держит в оперативной памяти содержимое файлов страницами по 4 килобайта. Первое чтение файла приносит данные с диска и оставляет их в кэше, поэтому повторное чтение обслуживается из памяти без обращения к блочному устройству. Ядро не ждёт запроса приложения, а заранее подтягивает соседние страницы, эта логика называется readahead и поддаётся настройке.
Окно упреждающего чтения видно и правится через blockdev:
blockdev --getra /dev/vda
На каждый запрос файловой системы ядро читает с устройства сразу указанное число секторов. Для последовательных нагрузок вроде копирования больших архивов крупное окно ускоряет работу, а для случайных выборок из базы данных оно расходует полосу устройства впустую.
Запись устроена иначе. Вызову write необязательно сразу дотягиваться до диска: страницы помечаются грязными и накапливаются, а фоновые потоки ядра периодически сбрасывают их на устройство. Пороги запуска фоновой и принудительной записи задают параметры vm.dirty_background_ratio и vm.dirty_ratio, и поведение сервера заметно зависит от этих значений. Система с интенсивной записью выигрывает от ограниченных грязных страниц, иначе всплеск fsync превращается в многосекундную паузу.
Состояние page cache видно в нескольких местах сразу:
free -h
grep -E '^(Cached|Buffers|SReclaimable|Dirty|Writeback)' /proc/meminfo
Колонка buff/cache в free объединяет Cached и Buffers, потому что наблюдателю разница обычно безразлична, но она существует. Cached описывает файловые страницы, Buffers относится к метаданным блочных устройств, Dirty и Writeback показывают объём отложенной записи и страницы в процессе сброса. Показатель available честнее колонки free: ядро расходует почти всю незанятую память под кэш, и это нормальное поведение, а не признак утечки.
Отдельный путь открывает mmap: файл отображается в адресное пространство, и обращения к памяти попадают прямо в те же страницы без копирования через read. Для горячих файлов большого объёма это заметно меняет профиль нагрузки. Ядро даёт приложению и ручные рычаги. Вызов posix_fadvise с флагом POSIX_FADV_DONTNEED просит вытолкнуть диапазон файла из page cache, а флаг POSIX_FADV_WILLNEED заранее подтягивает его с диска; для отображённой памяти аналогичный смысл несёт madvise. Интерфейс O_DIRECT позволяет читать и писать вовсе в обход кэша, что ценят движки баз данных с собственным буферным пулом: в тестах без O_DIRECT замеряется скорее page cache, чем диск.
Dentry cache и inode cache ускоряют поиск путей
Каждый вызов open или stat заставляет ядро разбирать путь по компонентам. Для длинного пути это десятки обращений к файловой системе, и без кэша цена оказалась бы неприемлемой. Dentry cache хранит объекты dentry, связывающие имена с инодами, поэтому повторное прохождение того же пути сводится к нескольким поискам в памяти. Рядом работает inode cache, удерживающий сами описатели файлов.
Кэш запоминает и неудачные результаты: отрицательные dentry позволяют быстро отвечать на поиск несуществующих имён. Обратная сторона в том, что долгий обход огромного дерева, например запуском find по всему диску, набивает dcache мусором и вытесняет рабочий набор реальных сервисов. После такого обхода базы данных и веб серверы ненадолго теряют скорость на файловых операциях.
Интенсивность вытеснения этих кэшей настраивается параметром vm.vfs_cache_pressure. Низкие значения побуждают ядро беречь dentry и inode, высокие наоборот быстрее отдают эту память под страницы файлов и анонимную память. Серверу, постоянно ходящему по большим деревьям каталогов, параметр полезно сдвинуть в сторону сохранения кэша, машине под тяжёлые файловые операции - по ситуации.
Память под dentry и inode учитывается в колонке SReclaimable из /proc/meminfo и входит в available. При нехватке памяти ядро освобождает эти объекты само, отдельной команды для этого обычно не требуется.
Slab аллокатор и наблюдение за объектами ядра через slabtop
Dentry, inode и ещё сотни мелких структур ядра выделяются не постранично, а из slab кэшей объектов. Аллокатор SLUB группирует однотипные объекты в страницы slab и переиспользует освобождённые слоты, благодаря чему выделение под dentry стоит доли микросекунды. Каждый тип объектов образует собственный кэш со счётчиками занятых и свободных слотов.
Снимок самых прожорливых кэшей даёт slabtop:
slabtop -o -s c | head -15
grep -E 'dentry|ext4_inode_cache' /proc/slabinfo
Утилита slabtop читает данные из /proc/slabinfo, где по каждому кэшу видно число активных объектов, их размер и число полных страниц slab. В типичном выводе верх занимают dentry, кэши инодов конкретных файловых систем и kmalloc разного размера. Разница между SReclaimable и SUnreclaim в /proc/meminfo относится именно сюда: первые объекты ядро выбросит под давлением, вторые нужны всегда. Бесконтрольный рост одного кэша подсказывает, где искать утечку памяти внутри ядра.
Диагностика кэшей средствами procfs и vmstat
Отдельного диспетчера кэшей в Linux нет, судьбой страниц управляет подсистема виртуальной памяти. Утилита vmstat в непрерывном режиме показывает характер работы с памятью и диском:
vmstat 1 10
Колонки si и so говорят о свопинге, bi и bo о блочном вводе выводе, а высокая доля wa в блоке cpu означает, что процессы ждут завершения дисковых операций. Если после сброса кэшей тест резко замедлился, а bi подскочил, значит данные действительно читались с устройства, а не из памяти.
Числовая детализация живёт в /proc/vmstat. Счётчики pgscan и pgsteal показывают, сколько страниц просмотрел и освободил алгоритм вытеснения, активность kswapd видна по счётчикам pgscan_kswapd. Постоянный рост этих значений при большом Cached означает, что ядро выбрасывает полезный кэш ради анонимной памяти, и пора разбираться с реальным потребителем. Низкий запас свободных страниц возле водяных знаков заставляет ядро вести себя нервно, поэтому разумное значение vm.min_free_kbytes избавляет от затяжных провалов.
Быструю сводку давления на память даёт файл /proc/pressure/memory из подсистемы PSI: там видно, сколько процентов времени задачи простаивали в ожидании памяти за последние десять секунд, минуту и пять минут. Утилита sar из пакета sysstat добавляет историю: ключи -B и -r показывают активность подсистемы выгрузки страниц и уровень памяти за прошедшие часы, что удобно при сопоставлении с жалобами пользователей.
Практические эксперименты с drop_caches и утилитой vmtouch
Интерфейс drop_caches просит ядро выбросить чистые страницы page cache, объекты dentry и inode либо всё сразу. Значение 1 отвечает за файловые страницы, 2 за slab объекты, 3 за оба типа. Грязные страницы при этом не отбрасываются, они дойдут до диска в обычном порядке, поэтому перед замером выполняют sync. После сброса первое чтение любого файла пойдёт с устройства, что даёт честный холодный замер и одновременно всплеск нагрузки на диск.
sync
echo 3 > /proc/sys/vm/drop_caches
На живом сервере такой сброс оправдан только при диагностике, потому что после него все горячие файлы придётся читать заново. Замер холодного и тёплого времени чтения оформляется в короткую процедуру:
- Прогреть кэш двумя повторными чтениями файла и зафиксировать время второго;
- Выполнить sync и сбросить кэши;
- Прочитать файл ещё раз и измерить время;
- Сравнить результаты и повторить цикл, чтобы отсечь случайные всплески.
Утилита vmtouch отвечает на вопрос, сколько конкретного файла сейчас живёт в page cache, и умеет вмешиваться в его судьбу:
vmtouch /opt/app/hotindex
vmtouch -e /var/tmp/bigfile.bin
vmtouch -l /opt/app/hotindex
Ключ -e выталкивает файл из кэша без сброса всего остального, ключ -l блокирует файл в памяти через mlock и спасает критичные индексы от вытеснения. Для быстрого просмотра набора файлов подходит fincore из состава util-linux:
fincore --bytes /var/log/journal/*
Для холодного чтения в обход кэша есть и другой путь: открыть файл с флагом O_DIRECT и читать крупными блоками. Так поступают тесты дисков, когда важно не поймать страницы, оставшиеся от предыдущего запуска:
dd if=/dev/nvme0n1 of=/dev/null bs=1M iflag=direct
Сравнение обычного и прямого чтения одного и того же устройства наглядно показывает вклад page cache в итоговую скорость. Эти инструменты превращают абстрактный вопрос о прогретости в число, которое можно заносить в отчёт и на график.
Cachestat и оценка попаданий в кэш в продакшене
Мгновенные снимки не отвечают на главный вопрос эксплуатации: какова доля попаданий в page cache у конкретного процесса прямо сейчас. Скрипт cachestat из набора BCC считает события попаданий и промахов по каждому процессу в реальном времени и выводит отношение, близкое к единице у хорошо прогретых задач. Провал этого отношения служит ранним сигналом, что рабочий набор перестал помещаться в память, задолго до жалоб пользователей на скорость.
С ядром 6.5 появился системный вызов cachestat, возвращающий количество резидентных страниц для заданного диапазона файла. Приложения получили возможность самостоятельно оценивать прогретость своих файлов и, например, подогревать данные перед стартом горячей фазы. Для разовых расследований хватает коротких bpftrace сценариев на точках mark_page_accessed и mark_buffer_dirty, показывающих, кто именно активирует и грязнит страницы. Самые горячие файлы помогает найти fatrace, показывающий события открытия и записи с именами процессов: собранная за час статистика сама подсказывает, что держать прогретым или залочить через vmtouch.
Практические выводы по всем уровням получаются сдержанными. Значения vm.dirty_background_ratio и vm.dirty_ratio стоит подбирать под профиль записи конкретной машины. Массовые обходы каталогов разумно отпускать в ночные окна, когда вытеснение dcache обойдётся дешевле. Перед сравнением двух версий кода полезно убедиться в одинаковом состоянии L3 и page cache, иначе тест измерит кэш, а не изменение. Сброс кэшей на работающей системе остаётся диагностическим приёмом, а не регулярной гигиеной памяти.
Linux сводит в одну систему кэши столь разных уровней, и связное понимание этой лестницы отличает быструю диагностику от перебора гипотез вслепую.