static void
place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
{
	u64 vruntime = cfs_rq->min_vruntime;

	/*
	 * The 'current' period is already promised to the current tasks,
	 * however the extra weight of the new task will slow them down a
	 * little, place the new task so that it fits in the slot that
	 * stays open at the end.
	 */
	if (initial && sched_feat(START_DEBIT))
		vruntime += sched_vslice(cfs_rq, se);

	/* sleeps up to a single latency don't count. */
	if (!initial) {
		unsigned long thresh = sysctl_sched_latency;

		/*
		 * Halve their sleep time's effect, to allow
		 * for a gentler effect of sleepers:
		 */
		if (sched_feat(GENTLE_FAIR_SLEEPERS))
			thresh >>= 1;

		vruntime -= thresh;
	}

	/* ensure we never gain time by being placed backwards. */
	se->vruntime = max_vruntime(se->vruntime, vruntime);
}

static void task_numa_find_cpu(struct task_numa_env *env,
			       long taskimp, long groupimp)
{
	long src_load, dst_load, load;
	bool maymove = false;
	int cpu;

	load = task_h_load(env->p);
	dst_load = env->dst_stats.load + load;
	src_load = env->src_stats.load - load;

	/*
	 * If the improvement from just moving env->p direction is better
	 * than swapping tasks around, check if a move is possible.
	 */
	maymove = !load_too_imbalanced(src_load, dst_load, env);

	for_each_cpu(cpu, cpumask_of_node(env->dst_nid)) {
		if (!cpumask_test_cpu(cpu, env->p->cpus_ptr))
			continue;

		env->dst_cpu = cpu;
		task_numa_compare(env, taskimp, groupimp, maymove);
	}
}

# 使用numactl绑定业务进程到Node 0
numactl --cpunodebind=0 --membind=0 ./business_service

# 或通过cgroup cpuset绑定CPU和内存节点
mkdir /sys/fs/cgroup/cpuset/business
echo 0-15 > /sys/fs/cgroup/cpuset/business/cpuset.cpus  # Node 0的CPU
echo 0 > /sys/fs/cgroup/cpuset/business/cpuset.mems     # Node 0的内存
echo $business_pid > /sys/fs/cgroup/cpuset/business/tasks

# 禁用内核NUMA自动迁移（0=关闭，1=开启）
echo 0 > /proc/sys/kernel/numa_balancing

# 或通过sysctl
sysctl -w kernel.numa_balancing=0

# NUMA 扫描周期与扫描量（真实存在的参数，而非网传的 sched_numa_migrate_rate_limit）
sysctl -w kernel.numa_balancing_scan_size_mb=256
sysctl -w kernel.numa_balancing_scan_period_min_ms=1000
sysctl -w kernel.numa_balancing_scan_period_max_ms=60000
sysctl -w kernel.numa_balancing_scan_delay_ms=1000

pidstat -w 1

Linux 5.4.0 (srv-pay-01) 	08/04/26 	_x86_64_	(8 CPU)

02:00:01      UID       PID   cswch/s nvcswch/s  Command
02:00:02        0      3947      0.10      0.00   rsyslogd
02:00:02        0      5678    120.00    300.00   java

grep -E "se.vruntime|sum_exec_runtime|nr_switches|nr_voluntary_switches|nr_involuntary_switches|se.load.weight" /proc/5678/sched

se.vruntime                          :      62005.058327
se.sum_exec_runtime                  :       8765.432100
nr_switches                          :               812345
nr_voluntary_switches                :               740000
nr_involuntary_switches              :                72345
se.load.weight                       :              3435520

grep -A14 "cfs_rq\[" /proc/sched_debug

cfs_rq[0]:/
  .exec_clock                   : 12345.678901
  .MIN_vruntime                 : 62005.010000
  .min_vruntime                 : 62005.058327
  .max_vruntime                 : 62006.123456
  .spread                       : 1.113456
  .spread0                      : 0.000000
  .nr_spread_over               : 12
  .nr_running                   : 3
  .load                         : 3072
  .runnable_weight              : 3072
  .throttled                    : 0
  .throttle_count               : 0

runnable tasks:
 S           task   PID         tree-key  switches  prio     wait-time             sum-exec        sum-sleep
-----------------------------------------------------------------------------------------------------------------
>R          java    5678   62005.058327    812345    75    0.345678   8765.432100  12345.678901 0 0 /business
 S      rsyslogd    3947   62004.010000     12345    20    0.123456   3456.789012  67890.123456 0 0 /system.slice

cat /proc/schedstat

version 15
timestamp 623456789012
cpu0 2456723 0 456789 345678 1234567 900000 234567 123456 987654

perf sched record sleep 10
perf sched latency

  Task                  |   Runtime ms  | Switches | Average delay ms | Maximum delay ms | Maximum delay at       |
------------------------------------------------------------------------------------------------------------------
  java:5678             |   4567.890 ms |    81234 | avg:    0.03 ms  | max:    1.20 ms  | max at: 623456.789012 s |
  rsyslogd:3947         |    123.456 ms |    56789 | avg:    0.20 ms  | max:    0.45 ms  | max at: 623456.789012 s |

# 将日志Agent等后台IO进程设为SCHED_IDLE（idle调度类，优先级低于所有SCHED_NORMAL）
chrt -i 0 -p $agent_pid

# 或启动时指定
chrt -i 0 rsyslogd

# 默认1ms（按核数缩放），调大到2-4ms可显著降低唤醒线程打断正在运行任务的概率
sysctl -w kernel.sched_wakeup_granularity_ns=3000000

# 提高单次连续执行下限，减少碎片化（详见6.3节）
sysctl -w kernel.sched_min_granularity_ns=1000000

static void set_load_weight(struct task_struct *p, bool update_load)
{
	int prio = p->static_prio - MAX_RT_PRIO;
	struct load_weight *load = &p->se.load;

	/*
	 * SCHED_IDLE tasks get minimal weight:
	 */
	if (task_has_idle_policy(p)) {
		load->weight = scale_load(WEIGHT_IDLEPRIO);
		load->inv_weight = WMULT_IDLEPRIO;
		p->se.runnable_weight = load->weight;
		return;
	}

	/*
	 * SCHED_OTHER tasks have to update their load when changing their
	 * weight
	 */
	if (update_load && p->sched_class == &fair_sched_class) {
		reweight_task(p, prio);
	} else {
		load->weight = scale_load(sched_prio_to_weight[prio]);
		load->inv_weight = sched_prio_to_wmult[prio];
		p->se.runnable_weight = load->weight;
	}
}

int sched_group_set_shares(struct task_group *tg, unsigned long shares)
{
	int i;

	/*
	 * We can't change the weight of the root cgroup.
	 */
	if (!tg->se[0])
		return -EINVAL;

	shares = clamp(shares, scale_load(MIN_SHARES), scale_load(MAX_SHARES));
	if (tg->shares == shares)
		return 0;

	tg->shares = shares;
	for_each_possible_cpu(i)
		reweight_entity(cfs_rq_of(tg->se[i]), tg->se[i], shares, tg->cfs_rq[i]->load.weight);

	return 0;
}

static u64 __sched_period(unsigned long nr_running)
{
	if (unlikely(nr_running > sched_nr_latency))
		return nr_running * sysctl_sched_min_granularity;
	else
		return sysctl_sched_latency;
}

static int
wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se)
{
	s64 gran, vdiff = curr->vruntime - se->vruntime;

	if (vdiff <= 0)
		return -1;

	gran = wakeup_gran(se);
	if (vdiff > gran)
		return 1;

	return 0;
}

static void
check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
{
	unsigned long ideal_runtime, delta_exec;
	struct sched_entity *se;
	s64 delta;

	ideal_runtime = sched_slice(cfs_rq, curr);
	delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
	if (delta_exec > ideal_runtime) {
		resched_curr(rq_of(cfs_rq));
		/*
		 * The current task ran long enough, ensure it doesn't get
		 * re-elected due to buddy favours.
		 */
		clear_buddies(cfs_rq, curr);
		return;
	}

	/*
	 * Ensure that a task that missed wakeup preemption by a
	 * narrow margin doesn't have to wait for a full slice.
	 */
	if (delta_exec < sysctl_sched_min_granularity)
		return;

	se = __pick_first_entity(cfs_rq);
	delta = curr->vruntime - se->vruntime;

	if (delta < 0)
		return;

	if (delta > ideal_runtime)
		resched_curr(rq_of(cfs_rq));
}

# 创建业务分组和IO分组
mkdir /sys/fs/cgroup/cpu/business
mkdir /sys/fs/cgroup/cpu/io_background

# 业务分组高权重（2048，相对默认1024提升2倍）
echo 2048 > /sys/fs/cgroup/cpu/business/cpu.shares

# IO分组低权重（512，相对默认1024降低一半）
echo 512 > /sys/fs/cgroup/cpu/io_background/cpu.shares

# IO分组CPU带宽硬限制（最多使用30% CPU）
echo 30000 > /sys/fs/cgroup/cpu/io_background/cpu.cfs_quota_us
echo 100000 > /sys/fs/cgroup/cpu/io_background/cpu.cfs_period_us

# 将进程移入分组
echo $business_pid > /sys/fs/cgroup/cpu/business/tasks
echo $io_pid > /sys/fs/cgroup/cpu/io_background/tasks

# 创建统一层级分组
mkdir /sys/fs/cgroup/business
mkdir /sys/fs/cgroup/io_background

# 业务分组高权重（8000，范围1-10000）
echo 8000 > /sys/fs/cgroup/business/cpu.weight

# IO分组低权重（1000）
echo 1000 > /sys/fs/cgroup/io_background/cpu.weight

# IO分组CPU带宽硬限制（最多使用30% CPU）
echo "30000 100000" > /sys/fs/cgroup/io_background/cpu.max

# 将进程移入分组（v2使用cgroup.procs接口）
echo $business_pid > /sys/fs/cgroup/business/cgroup.procs
echo $io_pid > /sys/fs/cgroup/io_background/cgroup.procs

static void throttle_cfs_rq(struct cfs_rq *cfs_rq)
{
	struct rq *rq = rq_of(cfs_rq);
	struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg);
	struct sched_entity *se;
	long task_delta, idle_task_delta, dequeue = 1;
	bool empty;

	se = cfs_rq->tg->se[cpu_of(rq_of(cfs_rq))];

	/* freeze hierarchy runnable averages while throttled */
	rcu_read_lock();
	walk_tg_tree_from(cfs_rq->tg, tg_throttle_down, tg_nop, (void *)rq);
	rcu_read_unlock();

	task_delta = cfs_rq->h_nr_running;
	idle_task_delta = cfs_rq->idle_h_nr_running;
	for_each_sched_entity(se) {
		struct cfs_rq *qcfs_rq = cfs_rq_of(se);
		/* throttled entity or throttle-on-deactivate */
		if (!se->on_rq)
			break;

		if (dequeue)
			dequeue_entity(qcfs_rq, se, DEQUEUE_SLEEP);
		qcfs_rq->h_nr_running -= task_delta;
		qcfs_rq->idle_h_nr_running -= idle_task_delta;

		if (qcfs_rq->load.weight)
			dequeue = 0;
	}

	if (!se)
		sub_nr_running(rq, task_delta);

	cfs_rq->throttled = 1;
	cfs_rq->throttled_clock = rq_clock(rq);
	raw_spin_lock(&cfs_b->lock);
	empty = list_empty(&cfs_b->throttled_cfs_rq);
	...
	raw_spin_unlock(&cfs_b->lock);
}

static void update_min_vruntime(struct cfs_rq *cfs_rq)
{
	struct sched_entity *curr = cfs_rq->curr;
	struct rb_node *leftmost = rb_first_cached(&cfs_rq->tasks_timeline);

	u64 vruntime = cfs_rq->min_vruntime;

	if (curr) {
		if (curr->on_rq)
			vruntime = curr->vruntime;
		else
			curr = NULL;
	}

	if (leftmost) { /* non-empty tree */
		struct sched_entity *se;
		se = rb_entry(leftmost, struct sched_entity, run_node);

		if (!curr)
			vruntime = se->vruntime;
		else
			vruntime = min_vruntime(vruntime, se->vruntime);
	}

	/* ensure we never gain time by being placed backwards. */
	cfs_rq->min_vruntime = max_vruntime(cfs_rq->min_vruntime, vruntime);
}