Быстрый сервер начинается не с закупки железа, а с подсчёта тактов процессора на один пакет. Ядро Linux способно прокачивать гигабиты через обычный сокетный интерфейс, но на десятках гигабит в секунду стандартный путь кадра упирается в лишние копирования памяти, прерывания и переключения контекста. Статья разбирает стек настроек сетевой производительности снизу вверх: socket буферы и sysctl, очереди приёма и backlog, привязку прерываний, RPS, RFS, XPS, аппаратные offload и, наконец, DPDK с poll mode drivers, когда ядро целиком выводят из плоскости данных. Каждый шаг снабжён командами, применимыми на живой машине.
Путь пакета через ядро и цена каждого переключения контекста
Сетевая карта принимает кадр, по DMA кладёт его в кольцевой буфер приёма и поднимает прерывание. Обработчик IRQ будит механизм NAPI: ядро запрещает прерывания от этой очереди и начинает опрашивать кольцо в контексте softirq. Дальше пакеты проходят IP и TCP и попадают в приёмную очередь сокета, и лишь после этого приложение просыпается и копирует байты из ядра в собственную память. Передача идёт зеркально, но с добавкой qdisc, планировщика пакетов, и кольца передачи.
Каждый вход в ядро и выход из него стоит тысячи тактов, каждое копирование - ещё столько же. Одно ядро на полном стеке TCP обычно тянет единицы гигабит и порядка миллиона мелких пакетов в секунду. Линия 10GbE на кадрах 64 байта требует почти 15 миллионов пакетов в секунду, то есть 67 наносекунд на пакет на всю машину. Разрыв на порядок объясняет и кратный выигрыш от настройки очередей, и то, зачем в конце пути бывает нужен обход ядра.
Планировщик пакетов тоже входит в путь передачи: связка qdisc fq с алгоритмом bbr выравнивает отдачу сегментов и снижает буферизацию на передающей стороне. Внутри стека TCP каждый сокет защищён блокировками, а поиск соединений идёт по хеш-таблицам, поэтому рост числа активных сессий добавляет нагрузки даже при неизменной полосе.
Режим busy_poll предлагает компромисс: приложение само опрашивает сокет короткими интервалами без ухода в сон, задержка падает ценой постоянно занятого ядра. Включается параметрами net.core.busy_poll и busy_read в микросекундах и оправдан на паре выделенных ядер для latency-критичных сервисов, но не на общем сервере под смешанной нагрузкой.
Первый симптом исчерпания бюджета - рост третьего столбца в /proc/net/softnet_stat: счётчик time_squeeze растёт всякий раз, когда обработчик упирается в лимит netdev_budget или отведённого времени раньше, чем опустошит кольцо. Пакеты, отброшенные из-за переполнения приёмного буфера, считает второй столбец. Нагрузка по ядрам видна в /proc/softirqs и в выводе mpstat.
cat /proc/net/softnet_stat
watch -n1 'cat /proc/softirqs | grep -E "NET_(RX|TX)"'
mpstat -P ALL 1
Буферы TCP и настройка sysctl для пропускной способности
Толстый канал с большой задержкой требует большого окна. Произведение полосы и времени обхода, BDP, для 10GbE при RTT 50 миллисекунд составляет 62,5 МБ, а лимиты по умолчанию на порядок меньше: net.core.rmem_max и net.core.wmem_max равны 212992 байт, потолок автотюнинга tcp_rmem - 6 МБ. Ядро само растит окно, но только до заданных потолков, поэтому медленный старт упирается не в сеть, а в sysctl.
sysctl -w net.core.rmem_max=33554432
sysctl -w net.core.wmem_max=33554432
sysctl -w net.ipv4.tcp_rmem="4096 131072 33554432"
sysctl -w net.ipv4.tcp_wmem="4096 65536 33554432"
sysctl -w net.core.somaxconn=4096
sysctl -w net.ipv4.tcp_max_syn_backlog=8192
sysctl -w net.ipv4.tcp_congestion_control=bbr
sysctl -w net.core.default_qdisc=fq
Алгоритм bbr строит оценку доступной полосы и RTT вместо реакции на потерю пакетов, на дальних линиях нередко выигрывает у cubic в разы и просит пару из qdisc fq. Значения somaxconn и tcp_max_syn_backlog закрывают всплески установления соединений: без них очередь accept переполняется, и клиенты видят сбросы ещё до первого байта.
Жирные буферы не бесплатны: каждый сокет способен отъесть до 32 МБ, и на сервере с десятками тысяч соединений сумма превращается в давление на tcp_mem и в риск OOM. Размеры задают под реальный BDP обслуживаемого трафика, а не по максимуму. Для интерактивных сервисов полезен tcp_notsent_lowat, ограничивающий объём байт в очереди на передачу: очередь короче, задержка ниже. Долгие соединения после паузы заново проходят медленный старт при включённом tcp_slow_start_after_idle, поэтому для постоянных каналов между дата-центрами его отключают. При проблемах с MTU на пути выручает tcp_mtu_probing, ищущий реальный предел через ICMP-сообщения о запрете фрагментации, а глобальные потолки tcp_mem защищают машину от выедания всей памяти разросшимися сокетами.
Очереди приёма, backlog и распределение прерываний по ядрам
Между картой и сокетом есть ещё две очереди. Первая - аппаратные кольца, их число задаётся через ethtool -L и должно соответствовать числу ядер, занятых приёмом. Вторая - per-CPU backlog размером netdev_max_backlog, по умолчанию всего 1000 кадров: на потоке мелких пакетов он заполняется за миллисекунды, и трафик начинает теряться до IP-слоя. Один проход softirq ограничен параметрами netdev_budget, по умолчанию 300 пакетов, и netdev_budget_usecs.
Число очередей и заполнение колец видны через ethtool, а распределение прерываний - в /proc/interrupts. Каждый IRQ очереди стоит привязать к ядру на той же NUMA-ноде, где сидит карта; при ручной привязке через /proc/irq/*/smp_affinity службу irqbalance придётся остановить, иначе он перемешает раскладку. Отдельные потоки ведут принудительно ntuple-фильтрами через ethtool -N: трафик по портам и подсетям уходит в конкретные очереди, что удобно, когда сервису выделяют свою группу ядер.
Хеш RSS распределяет потоки по очередям, причём симметричный хеш кладёт пакет и его ответ в очереди одной ноде, что экономит межсокетный трафик. Если очередей больше, чем ядер, часть прерываний дублируют на соседние ядра, но чаще поступают наоборот: число combined-очередей подгоняют под число физических ядер, а hyper-потоки оставляют под приложение. Для виртуальных машин число очередей vhost выравнивают с настройкой гостевой системы, иначе лишние кольца простаивают, а активные перегружаются.
ethtool -l eth0
ethtool -L eth0 combined 8
ethtool -x eth0
grep eth0 /proc/interrupts
echo 250000 > /proc/sys/net/core/netdev_max_backlog
Аппаратные offload сегментации GSO GRO и их ловушки
TSO и GSO снимают с ядра сегментацию: стек отдаёт карте буфер до 64 КБ, и NIC сам режет его на сегменты размером с MSS. GRO работает на приёме и склеивает сегменты одного потока обратно в крупный пакет до передачи в стек. Меньше пакетов означает меньше прерываний, меньше проходов по сетевым уровням и заметно меньше CPU на гигабит трафика. Offload контрольных сумм дополнительно освобождает ядро от пересчёта CRC на каждый кадр.
ethtool -k eth0 | grep -E "offload|segmentation"
ethtool -K eth0 tso on gso on gro on rx on tx on
Ловушки у GRO две. Он копит соседей по потоку, прежде чем склеить пакет, и добавляет джиттер, что бьёт по интерактивным сервисам, чувствительным к задержке. Вторая - анализ: tcpdump и eBPF-зонды у интерфейса видят уже склеенные кадры, и диагностика MTU или фрагментации идёт по не тем размерам. На UDP-трафике выигрыш GRO почти нулевой, а в конфигурациях с XDP на интерфейсе его выключают сознательно, потому что generic-путь XDP не дружит со склейкой. С туннелями аккуратнее: внешние UDP-заголовки VXLAN и Geneve считаются отдельно, и двойной offload иногда даёт ошибки контрольных сумм, которые проявляются только на чужих машинах. LRO, старший собрат GRO, склеивает пакеты на уровне драйвера, но ломает маршрутизацию: склеенный кадр нельзя корректно переразбить при пересылке, поэтому на шлюзах и в контейнерных хостах его держат выключенным, ограничиваясь GRO.
RPS, RFS и XPS для масштабирования обработки трафика
Когда у карты одна очередь, как у virtio на виртуалке, или все прерывания уже собраны на одном ядре, масштабировать приём помогает RPS: ядро само раскидывает пакеты по маске rps_cpus на другие CPU. RFS работает точнее: он доставляет пакет на ядро, где спит потребитель сокета, экономя кэш и межпроцессорные пересылки. Обе настройки описываются двумя числами: глобальным rps_sock_flow_entries и rps_flow_cnt на каждую очередь, причём сумма последних равна глобальному значению. XPS решает симметричную задачу на передаче: маска xps_cpus фиксирует, какой CPU пользуется какой очередью tx, что убирает конкуренцию за блокировки и сохраняет порядок пакетов внутри потока.
echo 32768 > /proc/sys/net/core/rps_sock_flow_entries
for f in /sys/class/net/eth0/queues/rx-*/rps_flow_cnt; do echo 4096 > "$f"; done
echo f > /sys/class/net/eth0/queues/rx-0/rps_cpus
echo f > /sys/class/net/eth0/queues/tx-0/xps_cpus
Маска f охватывает четыре младших ядра, для восьми ядер пишут ff, а для раскладки по NUMA-нодам берут старшие биты. Менять маски можно на лету, но резкая смена перекидывает потоки между ядрами и на секунды просаживает полосу, поэтому изменения вкатывают по одной очереди. Если карта поддерживает aRFS, аппаратная таблица потоков делает ту же работу без программной пересылки, а софтверные маски остаются страховкой. На виртуальных машинах с одной очередью связка RPS и RFS нередко даёт двукратный прирост за счёт переноса softirq с ядра приложения на соседние ядра. veth-пары в контейнерах тоже имеют одну очередь, поэтому на хосте эта связка остаётся главным способом разнести нагрузку по ядрам.
DPDK и poll mode drivers в обходе стека ядра
Когда sysctl и очереди выжаты, остаётся третий путь - вынуть NIC из-под ядра. DPDK отображает кольца карты прямо в память процесса через VFIO, mempools живут в hugepages, а потоки приложения опрашивают очереди в бесконечном цикле poll mode drivers: ни прерываний, ни syscall, ни копирований. Одно выделенное ядро закрывает полную линию 10GbE даже на мелких пакетах, десятки ядер дают сотни миллионов пакетов в секунду на сервер.
echo 4096 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
mkdir -p /dev/hugepages
mount -t hugetlbfs nodev /dev/hugepages
modprobe vfio-pci
usertools/dpdk-devbind.py -s
usertools/dpdk-devbind.py -b vfio-pci 0000:03:00.0
dpdk-testpmd -l 2-5 -n 4 -- -i --rxq=4 --txq=4 --stats-period=1
Плата существенна. Ядра PMD грузятся на 100% постоянно, поэтому их изолируют от планировщика параметрами isolcpus и nohz_full и следят за NUMA: память и кольца очереди должны лежать на той же ноде, что и опрашивающее ядро. Socket API исчезает, tcpdump и ss ничего не видят, карта целиком уходит из стека ядра, а приложение переписывают под библиотеку rte или переносят на готовый фреймворк вроде VPP. Страницы под mempools выделяют только из hugepages: обычная память множит промахи TLB на каждом пакете, а крупные страницы 1G сокращают проходы по таблицам страниц на линиях 100G.
Драйвер PMD забирает из кольца сразу десятки дескрипторов, прогревает кэш префетчем и отдаёт приложению массивом, поэтому пер-ядерные mempools, выравнивание структур и отказ от разделения содержимого между ядрами важнее любого другого тюнинга внутри приложения. Размеры колец приёма и передачи задают при запуске: кольцо на 4096 дескрипторов сглаживает всплески, но съедает память hugepages, поэтому бюджет страниц на каждую очередь считают заранее. Статистику колец и дропов снимают через rte_eth_stats или testpmd, а на продакшене поверх DPDK ставят собственную телеметрию, потому что привычные netstat и ifconfig о новых интерфейсах ничего не знают.
Промежуточная ступень - AF_XDP: кадры остаются в драйвере ядра, но через umem-кольца отдаются в userspace, а eBPF-программа на карте направляет трафик в нужную очередь. Схема даёт значительную долю выигрыша DPDK без потери kernel-инструментов и подходит, когда переписывать весь сервис слишком дорого.
Hugepages и честные замеры производительности через iperf3
iperf3 однопоточен: одна TCP-сессия упирается в одно ядро и в один сокетный буфер, поэтому на 25G и выше одной сессией весь канал не занять. Нужны параллельные потоки, окно на обеих сторонах и привязка процесса к свободному ядру. UDP-режим проверяет пакетную, а не битовую производительность и сразу показывает потери. Перед прогоном стоит перевести governor в performance, иначе частотное масштабирование исказит всю картину.
iperf3 -s
iperf3 -c 10.0.0.2 -P 8 -t 60 -w 32M -A 2
iperf3 -c 10.0.0.2 -u -b 25G -l 1470 -P 4 -t 60
netstat -s | grep -iE "retrans|drop"
cpupower frequency-set -g performance
Полезно разделять цели замера: полосу дают параллельные TCP-потоки, предел ядра по пакетам проверяют UDP с мелкими кадрами и счётчиком потерь, эффект offload сравнивают прогонами с включённым и выключенным GRO. Ещё одна ловушка - замер по локальной петле или виртуальной сети гипервизора: цифры выходят красивые, но к реальному пути пакета отношения не имеют. Трафик гоняют между двумя физическими машинами через коммутатор, повторяют прогон в обратную сторону параметром -R и смотрят не только полосу, но и хвосты задержки, если цель не полоса, а отклик. Каждый прогон фиксируют вместе с числом дропов и retrans, иначе сравнение настроек теряет смысл.
Рабочий цикл настройки живого сервера выглядит так:
1. снимите базу по iperf3, softnet_stat, счётчикам дропов и загрузке softirq по ядрам;
2. поднимите буферы сокетов, netdev_max_backlog и лимиты автотюнинга через /etc/sysctl.d;
3. распределите прерывания и очереди по NUMA, задайте маски RPS, RFS и XPS;
4. включите TSO, GSO, GRO и убедитесь, что дропы ушли, а полоса выросла;
5. повторяйте замеры, меняя один параметр за прогон, и фиксируйте каждую цифру.
DPDK нужен не всем: большинству сервисов хватает sysctl, очередей и offload, а bypass оправдан для маршрутизаторов, балансировщиков L4, DDoS-фильтров и хранилищ с жёстким SLA, где счёт идёт на миллионы мелких пакетов. Цифры после каждого шага остаются единственным судьёй, потому что настройка сетевой производительности сводится к измерениям, а не к списку рецептов.