Linux CPU 隔离与 NUMA 调优：给关键业务独占算力的实战指南

NUMA Node 0 (CPU 0-31, 内存 0-128GB)
  └── 本地内存访问延迟: ~80ns

NUMA Node 1 (CPU 32-63, 内存 128-256GB)
  └── 本地内存访问延迟: ~80ns

跨节点访问延迟: ~140ns  ← 差了将近一倍

$ numactl --hardware
available: 2 nodes (0-1)
node 0 cpus: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
node 0 size: 128768 MB
node 0 free: 89012 MB
node 1 cpus: 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
node 1 size: 129020 MB
node 1 free: 91045 MB
node distances:
node   0   1
  0:  10  21
  1:  21  10

$ numastat
                           node 0           node 1
numa_hit              89342156         67823451
numa_miss               234561          123456
numa_foreign             12345           23456
interleave_hit          456789          345678
local_node            89012345         67012345
other_node             345611           823456

# 编辑 /etc/default/grub
sudo vim /etc/default/grub

# 在 GRUB_CMDLINE_LINUX 中添加 isolcpus 参数
# 例如隔离 CPU 4-7（4个核）
GRUB_CMDLINE_LINUX="isolcpus=4-7"

# 更新 GRUB
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
# Ubuntu 用这个：
# sudo update-grub

# 重启生效
sudo reboot

$ cat /proc/cmdline | grep isolcpus
BOOT_IMAGE=/boot/vmlinuz-5.15.0-91-generic root=... isolcpus=4-7

# 完整配置示例
GRUB_CMDLINE_LINUX="isolcpus=4-7 nohz_full=4-7 rcu_nocbs=4-7"

# 挂载 cpuset 子系统（如果尚未挂载）
sudo mount -t cgroup -o cpuset cpuset /sys/fs/cgroup/cpuset

# 创建一个隔离组
sudo mkdir /sys/fs/cgroup/cpuset/critical_app

# 分配 CPU 核 4-5 给这个组
sudo echo "4-5" > /sys/fs/cgroup/cpuset/critical_app/cpuset.cpus

# 分配 NUMA 节点 0 的内存
sudo echo "0" > /sys/fs/cgroup/cpuset/critical_app/cpuset.mems

# 开启独占模式（关键！其他 cpuset 不能使用这些 CPU）
sudo echo "1" > /sys/fs/cgroup/cpuset/critical_app/cpuset.cpu_exclusive

# 把进程加入这个 cpuset
sudo echo <PID> > /sys/fs/cgroup/cpuset/critical_app/tasks

# 启用 cpuset 控制器
sudo echo "+cpuset" > /sys/fs/cgroup/cgroup.subtree_control

# 创建子组
sudo mkdir /sys/fs/cgroup/critical_app

# 分配 CPU 核
sudo echo "4-5" > /sys/fs/cgroup/critical_app/cpuset.cpus

# 分配 NUMA 节点
sudo echo "0" > /sys/fs/cgroup/critical_app/cpuset.mems

# 把进程加入
sudo echo <PID> > /sys/fs/cgroup/critical_app/cgroup.procs

# /etc/systemd/system/critical-app.service
[Unit]
Description=Critical Low-Latency Application
After=network.target

[Service]
ExecStart=/opt/critical-app/bin/server
# 绑定到 CPU 4-5
CPUAffinity=4,5
# 设置 NUMA 亲和性
NUMAPolicy=bind
NUMAMask=0
# 限制内存节点
AllowedCPUs=4-5
# 重启策略
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl start critical-app

# 启动时绑定到 CPU 4
taskset -c 4 ./my_application

# 绑定到 CPU 4 和 5
taskset -c 4,5 ./my_application

# 查看运行中进程的 CPU 亲和性
taskset -cp <PID>

# 修改运行中进程的 CPU 亲和性
taskset -cp 4 <PID>

#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <pthread.h>

int main() {
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(4, &cpuset);  // 绑定到 CPU 4

    // 绑定当前线程
    if (sched_setaffinity(0, sizeof(cpu_set_t), &cpuset) != 0) {
        perror("sched_setaffinity failed");
        return 1;
    }

    printf("Pinned to CPU 4\n");
    // 你的业务逻辑...
    while (1) { /* work */ }
    return 0;
}

void* worker_thread(void* arg) {
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(5, &cpuset);  // 这个线程绑到 CPU 5

    pthread_t current = pthread_self();
    if (pthread_setaffinity_np(current, sizeof(cpu_set_t), &cpuset) != 0) {
        perror("pthread_setaffinity_np failed");
    }

    // 线程业务逻辑...
    while (1) { /* work */ }
    return NULL;
}

# 查看进程所有线程当前跑在哪个 CPU
ps -eLo pid,tid,psr,comm | grep my_application

# psr 列就是当前处理器编号

# 查看 NUMA 拓扑
numactl --hardware

# 查看 NUMA 统计
numastat

# 在 NUMA 节点 0 上运行程序（CPU 和内存都绑定到节点 0）
numactl --cpunodebind=0 --membind=0 ./my_application

# 简写
numactl -N 0 -m 0 ./my_application

# 只绑定 CPU 节点，内存自由分配
numactl --cpunodebind=0 ./my_application

# 内存交错分配（跨节点均衡）
numactl --interleave=all ./my_application

# 启动 MySQL 时绑定到 NUMA 节点 0
numactl --interleave=all mysqld_safe &

# 或者用 numactl 绑定到特定节点
numactl --cpunodebind=0 --membind=0 mysqld_safe &

# 在 postgresql.conf 中设置
# 使用 huge pages 减少 TLB miss
huge_pages = on

# 启动时绑定
numactl --interleave=all pg_ctl start

# 停止 irqbalance 服务
sudo systemctl stop irqbalance
sudo systemctl disable irqbalance

# 查看网卡中断号
$ cat /proc/interrupts | grep eth0
  28:   123456   234567   345678   456789   0   0   0   0   PCI-MSI 1572864-edge   eth0-TxRx-0
  29:   234567   345678   456789   567890   0   0   0   0   PCI-MSI 1572865-edge   eth0-TxRx-1
  30:   345678   456789   567890   678901   0   0   0   0   PCI-MSI 1572866-edge   eth0-TxRx-2
  31:   456789   567890   678901   789012   0   0   0   0   PCI-MSI 1572867-edge   eth0-TxRx-3

# 查看当前中断亲和性（位掩码）
$ cat /proc/irq/28/smp_affinity
00000000,00000000,00000000,000000ff
# ff 表示 CPU 0-7 处理这个中断

# 把中断 28 绑定到 CPU 0（掩码 01 = CPU 0）
$ sudo echo 1 > /proc/irq/28/smp_affinity

# 把中断 28-31 分别绑定到 CPU 0-3
for i in 28 29 30 31; do
    cpu=$(($i - 28))
    mask=$(printf "%x" $((1 << $cpu)))
    echo $mask | sudo tee /proc/irq/$i/smp_affinity
done

#!/bin/bash
# set_irq_affinity.sh
# 用法: ./set_irq_affinity.sh eth0 "0-3"

IFACE=$1
CPUS=$2

# 获取网卡 IRQ 列表
IRQS=$(grep "$IFACE" /proc/interrupts | cut -d: -f1 | tr -d ' ')

# 将 CPU 范围转换为掩码
CPU_MASK=$(cset shield --cpu $CPUS --print 2>/dev/null | head -1)

i=0
for IRQ in $IRQS; do
    # 为每个队列分配一个 CPU
    CPU=$(echo $CPUS | awk -F'[-,]' "{print \$$((i % $(echo $CPUS | tr ',' '\n' | wc -l) + 1))}")
    printf "%x\n" $((1 << $CPU)) > /proc/irq/$IRQ/smp_affinity
    echo "IRQ $IRQ -> CPU $CPU"
    i=$((i + 1))
done

NUMA Node 0 (CPU 0-27, 物理核 0-13, 超线程 28-41)
  ├── CPU 0-1: 系统服务 + 中断处理
  ├── CPU 2-13, 28-39: 交易引擎（隔离）
  └── CPU 40-41: 备用

NUMA Node 1 (CPU 14-27, 物理核 56-83, 超线程 84-111)
  ├── CPU 56-69, 84-97: MySQL（NUMA bind）
  └── CPU 70-71, 98-111: 系统服务和监控

#!/bin/bash
# cpu-isolation-setup.sh
# 生产环境 CPU 隔离与 NUMA 调优脚本
# 在 Ubuntu 22.04 (内核 5.15) 上测试通过

set -euo pipefail

echo "=== 1. 配置 GRUB 启动参数 ==="

# 检查是否已配置
if grep -q "isolcpus" /proc/cmdline; then
    echo "isolcpus 已在启动参数中，跳过 GRUB 配置"
else
    echo "请手动编辑 /etc/default/grub，添加以下参数："
    echo 'GRUB_CMDLINE_LINUX="... isolcpus=2-13,28-39 nohz_full=2-13,28-39 rcu_nocbs=2-13,28-39"'
    echo "然后执行: sudo update-grub && sudo reboot"
    exit 1
fi

echo "=== 2. 关闭 irqbalance ==="
sudo systemctl stop irqbalance 2>/dev/null || true
sudo systemctl disable irqbalance 2>/dev/null || true
echo "irqbalance 已关闭"

echo "=== 3. 绑定网卡中断到 CPU 0-1 ==="
# 获取网卡中断号
NIC_IRQS=$(grep -E "eth0|ens192|enp" /proc/interrupts | awk -F: '{print $1}' | tr -d ' ')
i=0
for IRQ in $NIC_IRQS; do
    # 轮流分配到 CPU 0 和 1
    CPU=$((i % 2))
    MASK=$(printf "%x" $((1 << CPU)))
    echo $MASK > /proc/irq/$IRQ/smp_affinity 2>/dev/null || true
    echo "IRQ $IRQ -> CPU $CPU"
    i=$((i + 1))
done

echo "=== 4. 迁移隔离核上的内核线程 ==="
# 查找在隔离核上运行的内核线程
ISOLATED_CPUS="2-13,28-39"
for pid in $(pgrep -f "rcu\|kworker\|ksoftirqd\|migration\|watchdog"); do
    CURRENT_AFFINITY=$(taskset -pc $pid 2>/dev/null | grep -oP 'list: \K.*' || echo "")
    if [ -n "$CURRENT_AFFINITY" ]; then
        # 检查是否在隔离核上
        if taskset -pc $pid 2>/dev/null | grep -qP "[2-9]|1[0-3]|2[8-9]|3[0-9]"; then
            # 迁移到 CPU 0
            taskset -pc 0 $pid 2>/dev/null || true
            echo "Migrated kernel thread $pid to CPU 0"
        fi
    fi
done

echo "=== 5. 配置 MySQL NUMA 亲和性 ==="
# 使用 systemd 管理 MySQL 的 NUMA 配置
# 确认 MySQL 服务存在
if systemctl list-unit-files | grep -q mysql; then
    echo "建议在 MySQL systemd 服务中添加:"
    echo "  NUMAPolicy=bind"
    echo "  NUMAMask=1"
    echo "  CPUAffinity=56-69,84-97"
fi

echo "=== 6. 验证隔离效果 ==="
echo "--- 隔离核上的进程（应该只有手动绑定的）---"
for cpu in 2 3 4 5; do
    PROCS=$(ps -eLo pid,psr,comm | awk -v c=$cpu '$2==c {print $1, $3}')
    if [ -n "$PROCS" ]; then
        echo "CPU $cpu: $PROCS"
    fi
done

echo "--- NUMA 统计 ---"
numastat

echo "=== 配置完成 ==="

# 1. 确认 isolcpus 生效
cat /proc/cmdline | grep isolcpus

# 2. 查看隔离核上是否有非预期进程
# 正常情况下，隔离核上应该空闲或只有你绑定的进程
mpstat -P 2-5 1 5
# 关注 %idle 列，隔离核如果没绑进程应该接近 100%

# 3. 检查 NUMA 内存分配
numastat -p <PID>
# 关注 Total 列，确认内存在正确节点上

# 4. 测量延迟改善效果
# 用 cyclictest 测量调度延迟
cyclictest -p 80 -t 1 -a 4 -d 0 -i 1000 -l 100000
# -a 4: 绑定到 CPU 4
# 比较隔离前后的最大延迟值

# kubelet 配置（/var/lib/kubelet/config.yaml）
kind: KubeletConfiguration
cpuManagerPolicy: static
reservedSystemCPUs: "0,1"

apiVersion: v1
kind: Pod
metadata:
  name: critical-app
spec:
  containers:
  - name: app
    image: critical-app:latest
    resources:
      requests:
        cpu: "4"       # 必须是整数，才会触发独占分配
        memory: "8Gi"
      limits:
        cpu: "4"
        memory: "8Gi"
  # 指定 NUMA 亲和性（需要 Topology Manager）
  topologySpreadConstraints:
  - maxSkew: 1
    topologyKey: kubernetes.io/hostname

# 使用 --cpuset-cpus 绑定容器到特定 CPU
docker run -d \
    --name critical-app \
    --cpuset-cpus="4-7" \
    --memory="16g" \
    --memory-swappiness=0 \
    critical-app:latest

# 查看隔离核上的内核线程
ps -eLo pid,psr,comm | awk '$2 >= 2 && $2 <= 13 {print}'
# 可能看到 kworker、ksoftirqd、migration、watchdog 等

# 手动迁移这些线程到非隔离核
for pid in $(pgrep kworker); do
    taskset -pc 0 $pid 2>/dev/null
done
for pid in $(pgrep ksoftirqd); do
    taskset -pc 0 $pid 2>/dev/null
done

# 错误：只绑定了内存节点，但节点内存不够
$ numactl --membind=1 ./app
# 结果：Node 1 内存用完，程序 OOM 退出

# 正确：先检查节点可用内存
$ numactl --hardware | grep "node 1 free"
node 1 free: 89012 MB

# 如果内存不够，用 interleave 模式
$ numactl --interleave=all ./app

# 检查 cpuset 是否可用
cat /sys/fs/cgroup/cgroup.controllers
# 如果输出中没有 cpuset，需要在根 cgroup 启用

# 启用 cpuset 控制器
echo +cpuset > /sys/fs/cgroup/cgroup.subtree_control

# 宿主机配置了 isolcpus=4-7
# 容器配置了 --cpuset-cpus="4-7"

# 这种情况下，容器可以正常使用 CPU 4-7
# 因为 isolcpus 阻止的是"普通调度"，taskset/cpuset 是"显式分配"
# 两者不冲突

# 未隔离
$ cyclictest -p 80 -t 1 -a 0 -i 1000 -l 100000
T:0 ( 1234) P:80 I:1000 C:100000 Min: 3 Act: 5 Avg: 8 Max: 47

# isolcpus 隔离 + nohz_full
$ cyclictest -p 80 -t 1 -a 4 -i 1000 -l 100000
T:0 ( 1234) P:80 I:1000 C:100000 Min: 2 Act: 3 Avg: 4 Max: 12