Процессорное время - самый дефицитный ресурс системы. Память можно добавить, диски заменить, сеть разогнать, а ядер ровно столько, сколько есть. Планировщик ядра решает этот спор тысячи раз в секунду, и от его решений зависит, заикнётся ли аудиопоток под нагрузкой, ответит база за десять миллисекунд или за полсекунды. Ниже - внутренняя кухня планирования: виртуальное время и веса nice, real-time классы, sysctl-ключи, EEVDF в свежих ядрах, cgroups и приёмы диагностики, которые экономят часы при разборе загадочных лагов.

От одного списка задач к честному виртуальному времени

История началась с наивного списка. В ядрах 2.4 очередь просматривалась целиком при каждом переключении, и на загруженном сервере цена росла линейно. Ответом стал планировщик O(1) в линейке 2.6: две параллельные очереди на 140 уровней приоритета, битовая карта для мгновенного поиска, обмен активной и истёкшей очередей без пересчёта срезов. Быстро и предсказуемо. Проблема переехала в эвристику: интерактивность угадывалась по времени сна, угадывалась плохо, и под тяжёлой компиляцией звуковой поток заикался, а правка коэффициентов превращалась в слепую подгонку.

В 2007 году Ingo Molnar переписал fair-часть заново, и в ядре 2.6.23 появился CFS. Модель проста: представим идеальный процессор, делящий время строго поровну, по 1/n каждому. Физически такое устройство не собрать, зато можно вести учёт долга. Задачам назначается виртуальное время vruntime, и у кого оно меньше, тот недополучил своё - ему процессор. Идея не свалилась с неба: патчи Con Kolivas (staircase, RSDL) середины 2000-х показали, что строгая пропорциональная очередь выправляет интерактивность лучше эвристик, и часть этих находок легла в CFS.

Виртуальное время, веса nice и красно-чёрное дерево

Внутри fair-класса задача представлена структурой sched_entity. Сущности очереди cfs_rq лежат в красно-чёрном дереве, упорядоченном по vruntime; самый левый узел кэшируется, поэтому выбор следующего процесса стоит O(1), и лишь вставка с удалением тянут на O(log n). Приращение виртуального времени выражается одной строкой:

se->vruntime += delta_exec * NICE_0_LOAD / se->load.weight; /* NICE_0_LOAD = 1024 */

Два процесса с равными весами растут синхронно, и ядро перемежает их почти идеально по очереди. Возьмём пару nice 0 и nice 5, то есть веса 1024 и 335: на долю первого приходится около 75 процентов процессора, второй довольствуется четвертью. Один уровень nice даёт разницу порядка 10 процентов - это следствие коэффициента 1.25 между соседними весами таблицы sched_prio_to_weight. Крайние значения те же: nice -20 весит 88761, nice 19 - всего 15.

Учёт долга хитрый. Засыпающая задача копит vruntime только пока работает; проснувшись, она не должна мгновенно обгонять всех, но и не должна ждать вечно. CFS выставляет ей vruntime не ниже min_vruntime минус половина окна планирования: короткий сон прощается, длинный - нет. Потомку при fork добавляется штраф (kernel.sched_child_runs_first по умолчанию 0), иначе волна форков из сборщика выдавила бы родителя. Посмотреть учёт можно прямо в /proc:

# se.vruntime у лёгких задач растёт быстрее, чем у тяжёлых
grep -E 'se\.vruntime|nr_migrations' /proc/4321/sched

Переключение контекста обходится в единицы микросекунд, но косвенная плата за остывшие кэши и TLB в разы больше, поэтому квант не нарезают слишком мелко.

Классы планирования и реальное время в ядре

Планировщики выстроены в ядре цепочкой классов, и pick_next_task() опрашивает их сверху вниз: stop (потоки migration/N), dl, rt, fair, idle. Класс выше всегда обходит класс ниже, поэтому один процесс SCHED_FIFO с приоритетом 99 способен забрать все ядра у fair-мира. Это не дефект, а договор: real-time означает обещание, и обещание нужно подкреплять бюджетом.

POSIX-политики задаются через sched_setscheduler(2) или утилиту chrt:

struct sched_param sp = { .sched_priority = 80 };
if (sched_setscheduler(0, SCHED_FIFO, &sp))
    perror("sched_setscheduler");
chrt -f 80 ./frame_worker     # SCHED_FIFO, приоритет 80
chrt -r 50 -p $$              # SCHED_RR для текущего шелла
ps -eLo pid,cls,rtprio,ni,comm | grep ' FF '

SCHED_FIFO работает до блокировки, у SCHED_RR квант кончается, и процесс встаёт в конец очереди своего приоритета; размер кванта держит kernel.sched_rr_timeslice_ms, по умолчанию 100 мс.

У класса есть предохранитель: реальному времени отдаётся не более 950 мс из каждой секунды (kernel.sched_rt_period_us = 1000000, kernel.sched_rt_runtime_us = 950000). Оставшиеся 50 мс гарантированно достаются прочим задачам, поэтому убежавший цикл с приоритетом 99 не превращает сервер в кирпич мгновенно. Отключают ограничитель значением -1, и делать это стоит осознанно: зацикленный real-time процесс без лимита подвешивает машину наглухо.

Для задач с жёсткими сроками в ядре 3.14 появился класс SCHED_DEADLINE: EDF с сервером CBS поверх. Параметров три: sched_runtime, sched_deadline, sched_period. На входе работает admission control, ядро проверяет бюджет: заявку, где runtime больше deadline, просто не примут.

struct sched_attr attr = {
    .size   = sizeof(attr),
    .sched_policy = SCHED_DEADLINE,
    .sched_runtime  = 10 * 1000 * 1000ULL,  /* 10 мс бюджета каждые 30 мс */
    .sched_deadline = 30 * 1000 * 1000ULL,
    .sched_period   = 30 * 1000 * 1000ULL,
};
syscall(SYS_sched_setattr, 0, &attr, 0);  /* сборка с _GNU_SOURCE */
chrt -d -T 10000000 -D 30000000 -P 30000000 0 ./grabber

Утилизация 10/30 равна примерно трети ядра; сумма таких дробей на одном процессоре не должна переваливать за единицу, иначе ядро отвергнет регистрацию. Рядом живут SCHED_BATCH (честный fair без послаблений) и SCHED_IDLE (вес ниже всех, на подхвате у простаивающего ядра): индексаторам и фоновым перекодировкам самое место там, chrt -i 0 ./indexer.

Настройка задержек и квантов через sysctl

Тюнинг fair-класса в ядрах до 6.6 сводился к горстке ключей:

sysctl -a | grep 'kernel.sched'

Главный - kernel.sched_latency_ns, окно планирования. Базовое значение 6 мс; внутри окна каждый runnable-процесс получает хотя бы kernel.sched_min_granularity_ns, то есть 0.75 мс. Если задач много, окно растягивается: минимум восемь процессов, дальше пропорционально их числу. Сто runnable-процессов на ядре означают окно около 75 мс и срезы по 0.75 мс - чувствительная интерактивность этого не любит.

Дальше по списку: kernel.sched_wakeup_granularity_ns (1 мс) - насколько проснувшейся задаче нужно просрочить vruntime, чтобы перебить текущую; kernel.sched_migration_cost_ns (0.5 мс) - "горячую" по кэшу задачу не трогают при балансировке; kernel.sched_tunable_scaling (1, логарифмическая шкала).

Масштабирование - самое недооценённое место. Значения в sysctl базовые, для одного ядра, а в очередь применяется множитель 1 + ilog(ncpus). Итог: 4 ядра - окно 18 мс, 8 ядер - 24 мс, 16 ядер - 30 мс. Типичная ошибка из старых гайдов - скопировать sysctl.conf с однопроцессорной виртуалки на 64-ядерный NUMA-хост и удивляться латентностям. Фактические значения читаются там же:

sysctl kernel.sched_latency_ns kernel.sched_min_granularity_ns

И честно говоря, менять эти цифры без измерений не стоит: perf sched покажет, где время теряется на самом деле.

EEVDF в ядре 6.6 и его отличия от CFS

Осенью 2023 года в ядре 6.6 Peter Zijlstra заменил механику fair-класса на алгоритм EEVDF, известный по академической работе середины 1990-х. Аббревиатура расшифровывается как earliest eligible virtual deadline first. CFS был честным в долгосрочном среднем, но задержку отдельной задачи держал на эвристиках: бонусах спящим, штрафах потомкам, порогах пробуждения. EEVDF делает латентность полноправной частью модели.

Ключевых понятий два. Первое - лаг: разница между тем, сколько задаче положено по идеальной модели, и сколько она реально отработала. Отрицательный лаг - процесс взял больше своей доли, положительный - недобрал. Второе - виртуальный дедлайн: vruntime плюс виртуальный срез, который растёт с весом задачи и не бывает меньше базового среза kernel.sched_base_slice_ns. Планировщик выбирает среди eligible-задач (лаг не меньше нуля) ту, у которой дедлайн раньше. Короткоиграющий процесс получает ранний дедлайн и сам, без бонусов, вытесняет длинного потребителя процессора - короткий всплеск от аудиопотока отбивает такты у перекодировщика видео.

И что, всё это изменило повседневность? Для sysctl - да: kernel.sched_latency_ns и kernel.sched_wakeup_granularity_ns из ядра ушли, базовый срез переехал в kernel.sched_base_slice_ns, и по умолчанию там три миллиона наносекунд, то есть 3 мс. Семантика nice и весов не тронута, renice и /proc/PID/sched работают как раньше, а rbtree научился искать ближайшую eligible-сущность по поддереву. Проверить, что стоит под капотом, можно одним вызовом:

sysctl kernel.sched_base_slice_ns 2>/dev/null || sysctl kernel.sched_latency_ns

Балансировка нагрузки между ядрами, affinity и cgroups

На многоядерной машине per-CPU очередей много, и их надо держать занятыми равномерно, но не ценой холодных кэшей. Иерархия доменов планирования строится от SMT-уровня (гипертреды одного ядра) через MC (ядра одного сокета) до NUMA-узлов. Балансировка переносит задачи с осторожным порогом: перекос существенен при разнице порядка 25 процентов, и из-за пары процентов ничего не поедет. Переносом заняты отдельные stop-потоки migration/N.

Право голоса даёт PELT, per-entity load tracking: у сущностей и очередей считаются load_avg и util_avg с экспоненциальным затуханием (полураспад около 32 мс). Эти оценки кормят балансировку, выбор частоты и энергосберегающие решения. Горячая задача, отработавшая менее kernel.sched_migration_cost_ns назад, с ядра не сгоняется: перезаполнение кэша дороже простоя соседа.

Иногда равномерность вредна, и арбитра заставляют слушаться руками. Жёсткая привязка через taskset или sched_setaffinity:

cpu_set_t set;
CPU_ZERO(&set);
CPU_SET(2, &set);
sched_setaffinity(0, sizeof(set), &set);
taskset -pc 2-3 4321                  # разрешить ядра 2 и 3
grep Cpus_allowed_list /proc/4321/status

Дальше по стеку - контрольные группы. В cgroups v2 cpu-контроллер задаёт и доли, и потолки:

mkdir /sys/fs/cgroup/analytics
echo 300 > /sys/fs/cgroup/analytics/cpu.weight         # доля втрое выше базовой
echo "200000 100000" > /sys/fs/cgroup/analytics/cpu.max # не больше 2 CPU
echo 4321 > /sys/fs/cgroup/analytics/cgroup.procs

Квотная модель внутри периодов по 100 мс порождает классическую проблему: многопоточная группа выбирает квот 200 мс к середине периода и замирает до следующего, а хвостовая латентность взлетает. Диагноз лежит в cpu.stat:

grep -E 'nr_throttled|throttled_usec' /sys/fs/cgroup/analytics/cpu.stat

С ядра 5.14 есть cpu.max.burst, разрешающий отыграть запас недоиспользованного квота, и это часто снимает проблему без расширения лимита. Доли (cpu.weight от 1 до 10000, база 100) согласованы со шкалой nice, есть и cpu.weight.nice. Для полной изоляции узких ядер пригодятся cpuset.cpus с партициями.

Отдельная история - автогруппы, приехавшие в 2.6.38. Каждая сессия терминала получает собственную группу, поэтому make -j в одном окне больше не душит соседнее. Управляет этим kernel.sched_autogroup_enabled; ловушка в том, что renice на сессионном лидере двигает вес всей группы сразу.

Диагностика планировщика и куда он движется дальше

Хороший разбор начинается с данных, а не с догадок. perf записывает события планирования и сворачивает их в таблицы:

perf sched record -- sleep 10
perf sched timehist              # построчная история: ожидание, задержка запуска, рантайм
perf sched latency --sort max
perf sched map

Быстрые показания снимаются и без perf. /proc/PID/schedstat выдаёт три числа: наносекунды на процессоре, наносекунды ожидания в очереди и число срезов. Счётчик nonvoluntary_ctxt_switches из /proc/PID/status показывает, что процесс дерётся за процессор. /proc/pressure/cpu (PSI с ядра 4.20) отражает долю времени, когда задачи стояли в очереди к CPU:

cat /proc/pressure/cpu
vmstat 1                         # колонка cs - частота переключений

Когда жалоб накоплено достаточно, порядок действий такой:

  1. Снять perf sched record на 10-30 секунд под воспроизводимой нагрузкой и найти строки с большим wait time;
  2. Сверить /proc/PID/schedstat и счётчик nonvoluntary_ctxt_switches у страдающего процесса;
  3. Проверить cpu.stat его групп на nr_throttled и большие throttled_usec;
  4. Посмотреть классы и приоритеты через ps -eLo pid,cls,rtprio,ni,comm, строка с FF или DLN сразу объяснит, кто перебивает остальных;
  5. Сравнить load_avg и util_avg доменов в /sys/kernel/debug/sched (нужен CONFIG_SCHED_DEBUG) на предмет перекоса.

Дальше кейсы из практики. Бэкап-скрипт в cgroup с лимитом однажды начал ронять латентность всего веб-приложения. Логи бесполезны, метрики ровные, а cpu.stat показывает тысячи nr_throttled с копившимися секундами throttled_usec. Лимит не расширяли - включили burst и подняли вес группы, и хвостовые квантили вернулись в норму. Второй узнаваемый сюжет: прерывистый звук при стопроцентной загрузке. Виновник почти всегда real-time поток с FF в выводе ps, ведь ядро честно отдаёт ему 95 процентов каждой секунды. Перевод в fair-класс дешевле, чем отключение rt-троттлинга.

Ядро не стоит на месте. В 6.12 появился sched_ext: класс, реализуемый BPF-программой, от scx_simple до экспериментальных scx_lavd и scx_layered; при сбое программы задачи возвращаются обычному fair-планировщику. На гибридных CPU с ядрами разной производительности работает EAS, выбирающий энергоэффективные ядра для лёгких задач по модели энергии. Меняются алгоритмы и интерфейсы, вопрос остаётся тем же: кому отдать такт и сколько он будет стоить остальным. Теперь на него вы отвечаете не наощупь, а с vruntime, lag и дедлайнами в руках.