一、简介：为什么负载概念是Linux调度的"度量衡"？

Linux调度器的核心使命是高效、公平地分配CPU资源。然而，"高效"与"公平"的衡量需要精确的负载度量体系。内核中同时存在三种看似相关实则差异显著的负载概念：

负载类型	核心问题	典型误用场景	后果
权重负载（Weight）	"这个任务/组应该获得多少CPU份额？"	将nice值直接等同于CPU百分比	多任务竞争时份额被稀释，预期不达标
利用率（Utilization）	"这个任务实际用了多少CPU容量？"	用利用率预测未来负载	突发任务导致预测失效，频率调节滞后
可运行负载（Runnable Load）	"这个任务对CPU的真实需求是多少？"	忽略阻塞/唤醒状态转换	负载均衡误判，任务迁移到繁忙CPU

PELT算法是连接这三种概念的数学桥梁。它通过指数衰减窗口，将离散的调度事件（运行、睡眠、唤醒）转化为平滑的负载曲线，为负载均衡决策、CPU频率调节、能耗优化提供实时数据支撑。

掌握这些概念的精确语义与数学实现，意味着能够：

• 诊断"CPU配额已配置但任务仍被节流"的复杂场景

• 优化容器平台的资源预测与自动伸缩

• 开发面向AI训练的下一代异构调度器

---

二、核心概念：三种负载的精确语义与PELT数学原理

2.1 权重负载（Weight Load）：公平分配的" entitlement "

/*
 * kernel/sched/sched.h - 权重定义
 * 权重是"应得份额"的数值表示，而非实际使用
 */

struct load_weight {
    unsigned long weight;      /* 基础权重 */
    u32 inv_weight;            /* 倒数权重，用于除法优化 */
};

/*
 * 优先级nice值到权重的映射（非线性！）
 * nice 0 = 1024, nice -20 = 88761, nice 19 = 15
 * 每级nice差距约1.25倍，-20到19差距约5900倍
 */
const int sched_prio_to_weight[40] = {
 /* -20 */     88761,     71755,     56483,     46273,     36291,
 /* -15 */     29154,     23254,     18705,     14949,     11916,
 /* -10 */      9548,      7620,      6100,      4904,      3906,
 /*  -5 */      3121,      2501,      1991,      1586,      1277,
 /*   0 */      1024,       820,       655,       526,       423,
 /*   5 */       335,       272,       215,       172,       137,
 /*  10 */       110,        87,        70,        56,        45,
 /*  15 */        36,        29,        23,        18,        15,
};

/*
 * 关键理解：
 * - 权重是"相对竞争力"，不是"绝对CPU百分比"
 * - 单任务时，无论权重多少，都可以用100% CPU
 * - 多任务竞争时，按权重比例分配
 */

2.2 利用率（Utilization）：实际使用的" capacity consumed "

/*
 * kernel/sched/pelt.h - 利用率定义
 * 利用率回答：任务实际运行的时间占比
 */

struct sched_avg {
    u64 last_update_time;       /* 上次更新时间戳 */
    u64 load_sum;               /* 可运行负载的衰减和 */
    u64 runnable_sum;           /* 可运行时间的衰减和 */
    u32 load_avg;               /* 平均可运行负载 */
    u32 runnable_avg;           /* 平均可运行时间 */
    u32 util_avg;               /* 平均利用率（核心！） */
    
    /* 组调度相关 */
    u64 runnable_load_sum;
    u32 runnable_load_avg;
    u32 group_util;
};

/*
 * util_avg 的计算：
 * - 任务实际运行的时间（排除睡眠、等待）
 * - 经过PELT指数衰减平滑
 * - 范围：0 ~ SCHED_CAPACITY_SCALE（通常1024）
 * 
 * 与load_avg的区别：
 * - load_avg 考虑权重（nice -20的任务运行1ms = 88761单位）
 * - util_avg 不考虑权重（只看是否在用CPU）
 */

2.3 可运行负载（Runnable Load）：调度器视角的" demand "

/*
 * 可运行负载 = 权重 × 可运行时间比例
 * 
 * 关键状态转换：
 * 
 *  TASK_RUNNING (可运行，在rq上排队或运行)
 *      ↓
 *  TASK_INTERRUPTIBLE/TASK_UNINTERRUPTIBLE (睡眠，等待事件)
 *      ↓
 *  TASK_RUNNING (唤醒，重新可运行)
 * 
 * PELT追踪的是"可运行"状态，而非"运行中"状态
 * 这包括：在CPU上执行 + 在rq上排队等待
 */

/*
 * 三种负载的数学关系：
 * 
 * load_avg = weight × runnable_avg
 * 
 * 其中：
 * - weight: 静态或动态配置的权重
 * - runnable_avg: 可运行时间的PELT衰减平均（0~1）
 * - util_avg: 实际运行时间的PELT衰减平均（0~1）
 * 
 * 因此：util_avg ≤ runnable_avg ≤ 1
 */

2.4 PELT算法：指数衰减的数学实现

/*
 * kernel/sched/pelt.c - PELT核心实现
 * 
 * PELT使用几何级数衰减，半衰期默认32ms（可配置）
 * 
 * 数学原理：
 * 设衰减因子 y = 2^(-1/32ms) ≈ 0.978572
 * 
 * 则n毫秒后的衰减：y^n
 * 
 * 负载更新公式：
 * L' = L × y^Δt + Δload × (1 - y^Δt) / (1 - y)
 * 
 * 其中：
 * - L: 当前负载值
 * - Δt: 经过的时间
 * - Δload: 新增加的负载（运行时为weight，睡眠时为0）
 */

/*
 * 预计算的衰减因子表（优化：避免运行时计算）
 * 索引：时间差（毫秒）>> 10（即除以1024）
 */
static const u32 __accumulated_sum_N32[64] = {
    /* 近似值，实际内核使用更精确的定点数计算 */
    0, 1, 3, 7, 15, 31, 63, 127,  /* 0-8ms范围 */
    255, 511, 1023, 2047, 4095, 8191, 16383, 32767,
    /* ... 扩展到约64ms ... */
};

/*
 * 核心更新函数：__update_load_avg_se
 */
static __always_inline int
__update_load_avg_se(u64 now, struct cfs_rq *cfs_rq, struct sched_entity *se)
{
    struct sched_avg *sa = &se->avg;
    u64 delta, scaled_delta;
    u32 contrib;
    int decayed = 0;
    
    /* 计算时间差 */
    delta = now - sa->last_update_time;
    delta >>= 10;  /* 微秒转毫秒级 */
    
    if (!delta)
        return 0;  /* 无时间流逝，无需更新 */
    
    sa->last_update_time = now;
    
    /* 衰减历史负载 */
    decayed = __decay_load(sa, delta);
    
    /* 计算新贡献 */
    if (entity_is_task(se)) {
        /* 任务级：基于实际运行时间 */
        scaled_delta = sa->period_contrib;
        if (se->on_rq) {
            /* 可运行状态：贡献权重负载 */
            contrib = scale_load_down(se->load.weight);
            sa->load_sum += contrib * scaled_delta;
            sa->runnable_load_sum += contrib * scaled_delta;
        }
        /* 利用率：仅实际运行时间贡献 */
        if (cfs_rq->curr == se) {
            sa->runnable_sum += scaled_delta << SCHED_CAPACITY_SHIFT;
        }
    }
    
    /* 计算平均值：和 >> 历史窗口 */
    sa->load_avg = sa->load_sum / LOAD_AVG_MAX;
    sa->runnable_avg = sa->runnable_sum / LOAD_AVG_MAX;
    sa->util_avg = (sa->runnable_sum >> SCHED_CAPACITY_SHIFT) / LOAD_AVG_MAX;
    
    return decayed;
}

2.5 PELT的三种时间窗口

窗口类型	半衰期	用途	代码体现
短期窗口	32ms	快速响应负载突变	__decay_load 的 decay_period
中期窗口	~1s	负载均衡决策	load_avg 的瞬时值
长期窗口	~5min	容量规划、自动伸缩	util_avg 的累积趋势

/*
 * 窗口长度的配置（通过sysctl可调）
 */
unsigned int sysctl_sched_latency = 6000000ULL;      /* 6ms */
unsigned int sysctl_sched_min_granularity = 750000ULL; /* 0.75ms */
unsigned int sysctl_sched_wakeup_granularity = 1000000ULL; /* 1ms */

/*
 * 这些参数影响PELT的实际半衰期：
 * - 更短的latency = 更快的衰减 = 更敏感的负载跟踪
 * - 更长的latency = 更平滑的曲线 = 更稳定的预测
 */

---

三、环境准备：搭建PELT分析工作台

3.1 硬件与软件环境

组件	最低要求	推荐配置	关键用途
CPU	x86_64, 2核+	8核，支持perf事件	观察跨核负载均衡
内存	4GB	16GB	运行压力测试工具
内核	Linux 5.4+	Linux 5.15 LTS	PELT算法成熟版本
工具	perf, bpftrace	自定义eBPF程序	追踪PELT内部状态

3.2 一键安装分析环境

#!/bin/bash
# file: setup-pelt-analysis.sh
# 功能：安装PELT分析所需的完整环境

set -e

echo "=== 检查内核PELT支持 ==="
if ! grep -q "CONFIG_SMP=y" /boot/config-$(uname -r); then
    echo "警告: 内核未启用SMP，PELT功能受限"
fi

echo "=== 安装分析工具链 ==="
sudo apt update
sudo apt install -y \
    linux-tools-$(uname -r) linux-tools-generic \
    bpfcc-tools libbpfcc-dev \
    trace-cmd kernelshark \
    gnuplot python3-matplotlib python3-numpy \
    rt-tests stress-ng sysstat

echo "=== 获取内核源码（用于分析PELT实现） ==="
mkdir -p ~/kernel-study && cd ~/kernel-study
if [ ! -d linux-5.15 ]; then
    git clone --depth 1 --branch v5.15 \
        https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git \
        linux-5.15
fi

echo "=== 验证PELT相关文件 ==="
ls -la ~/kernel-study/linux-5.15/kernel/sched/pelt.c
ls -la ~/kernel-study/linux-5.15/kernel/sched/pelt.h

echo "=== 启用调度调试接口 ==="
echo 1 | sudo tee /proc/sys/kernel/sched_debug 2>/dev/null || true
echo 1 | sudo tee /proc/sys/kernel/sched_schedstats 2>/dev/null || true

echo "环境就绪！"

3.3 验证PELT数据接口

#!/bin/bash
# file: verify-pelt-interfaces.sh
# 功能：验证系统PELT数据的可访问性

echo "=== 1. /proc/schedstat（全局统计） ==="
head -20 /proc/schedstat 2>/dev/null || echo "未启用CONFIG_SCHEDSTATS"

echo -e "\n=== 2. /proc/<pid>/sched（单任务PELT数据） ==="
cat /proc/self/sched | grep -E "se\.|avg\.|load|util" | head -20

echo -e "\n=== 3. /sys/kernel/debug/sched/debug（调试信息） ==="
sudo cat /sys/kernel/debug/sched/debug 2>/dev/null | grep -E "load_avg|util_avg|runnable_avg" | head -10

echo -e "\n=== 4. 实时追踪PELT更新 ==="
sudo bpftrace -e '
kprobe:update_load_avg {
    printf("PELT update: cpu=%d se=%p\n", cpu, arg1);
}
' -c 'sleep 3' 2>/dev/null || echo "需要bpftrace支持"

---

四、应用场景：PELT在云计算自动伸缩与边缘AI推理中的深度实践

在现代云原生基础设施中，PELT负载数据驱动着从毫秒级调度决策到分钟级容量规划的全栈优化。以AWS EC2 Auto Scaling为例：实例级别的util_avg通过CloudWatch暴露，触发策略在60秒内平均利用率>70%时扩容。然而，PELT的32ms半衰期导致突发负载（如Lambda冷启动）的util_avg滞后5-10秒，造成扩容延迟。优化方案是结合runnable_avg（可运行队列压力）作为领先指标，将响应时间缩短40%。在边缘AI推理场景，NVIDIA Jetson设备的schedutil驱动器直接读取PELT util_avg调节CPU/GPU频率：当YOLOv5推理任务util_avg>800时升频至2GHz，<200时降频至500mW待机，实现每帧能耗降低35%。更复杂的Kubernetes VPA（垂直Pod自动伸缩） 使用PELT历史数据训练预测模型，在每日流量高峰前15分钟预扩容，减少SLA违约。这些实践均要求平台工程师深入理解load_sum的衰减曲线与util_avg的饱和特性。

---

五、实际案例与步骤：PELT机制深度拆解

5.1 PELT数学原理可视化

#!/usr/bin/env python3
# file: pelt-mathematical-model.py
# 功能：可视化PELT的指数衰减数学原理

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import FancyArrowPatch

# PELT参数（内核默认值）
HALF_LIFE_MS = 32  # 半衰期32ms
Y = 2 ** (-1 / HALF_LIFE_MS)  # 衰减因子 ≈ 0.9786

def pelt_decay(t_ms, y=Y):
    """计算t毫秒后的衰减值"""
    return y ** t_ms

def pelt_contribution(delta_t_ms, load, y=Y):
    """计算delta_t时间内的PELT贡献"""
    # 几何级数求和：load * (1 - y^delta_t) / (1 - y)
    return load * (1 - y ** delta_t_ms) / (1 - y)

def simulate_pelt(task_pattern, half_life=32):
    """
    模拟PELT对任务模式的响应
    task_pattern: [(start_ms, end_ms, weight), ...]
    """
    y = 2 ** (-1 / half_life)
    times = np.arange(0, 500, 1)  # 0-500ms，1ms精度
    load_sum = np.zeros_like(times, dtype=float)
    util_sum = np.zeros_like(times, dtype=float)
    
    current_load = 0
    current_util = 0
    
    for i, t in enumerate(times):
        # 衰减
        if i > 0:
            delta = t - times[i-1]
            current_load *= y ** delta
            current_util *= y ** delta
        
        # 添加新贡献
        for start, end, weight in task_pattern:
            if start <= t < end:
                # 可运行：贡献负载
                current_load += weight * (1 - y)
                # 运行中（简化：假设50%时间实际运行）：贡献利用率
                if (t - start) % 2 == 0:
                    current_util += 1024 * (1 - y)  # 假设SCHED_CAPACITY_SCALE=1024
        
        load_sum[i] = current_load
        util_sum[i] = current_util
    
    # 计算平均值（内核中是和除以窗口）
    window = 345  # 约345ms的等效窗口
    load_avg = load_sum / window
    util_avg = util_sum / window
    
    return times, load_sum, load_avg, util_avg

# 场景1：突发任务（100ms突发）
pattern_burst = [(50, 150, 1024)]  # nice 0, 100ms运行
times, load_sum, load_avg, util_avg = simulate_pelt(pattern_burst)

fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# 图1：突发任务的PELT响应
ax = axes[0, 0]
ax.plot(times, load_avg, 'b-', label='load_avg (weight=1024)', linewidth=2)
ax.plot(times, util_avg, 'r--', label='util_avg', linewidth=2)
ax.axvspan(50, 150, alpha=0.2, color='green', label='task running')
ax.set_xlabel('Time (ms)')
ax.set_ylabel('PELT Average')
ax.set_title('PELT Response to 100ms Burst Task')
ax.legend()
ax.grid(True, alpha=0.3)

# 图2：不同半衰期的对比
ax = axes[0, 1]
for hl in [8, 32, 128]:
    _, _, la, ua = simulate_pelt(pattern_burst, half_life=hl)
    ax.plot(times, ua, label=f'half-life={hl}ms')
ax.axvspan(50, 150, alpha=0.2, color='green')
ax.set_xlabel('Time (ms)')
ax.set_ylabel('util_avg')
ax.set_title('Impact of Half-Life Setting')
ax.legend()
ax.grid(True, alpha=0.3)

# 图3：指数衰减曲线
ax = axes[1, 0]
t_decay = np.linspace(0, 200, 500)
y_32 = pelt_decay(t_decay, 2**(-1/32))
y_8 = pelt_decay(t_decay, 2**(-1/8))
y_128 = pelt_decay(t_decay, 2**(-1/128))
ax.semilogy(t_decay, y_32, 'b-', label='half-life=32ms')
ax.semilogy(t_decay, y_8, 'r--', label='half-life=8ms')
ax.semilogy(t_decay, y_128, 'g:', label='half-life=128ms')
ax.set_xlabel('Time (ms)')
ax.set_ylabel('Decay Factor (log scale)')
ax.set_title('PELT Exponential Decay Curves')
ax.legend()
ax.grid(True, alpha=0.3)

# 图4：多任务竞争场景
pattern_multi = [
    (0, 500, 1024),    # 任务A：nice 0，全程运行
    (100, 200, 2048),  # 任务B：nice -5，突发高权重
    (300, 400, 512),   # 任务C：nice 5，低权重突发
]
times, load_sum, load_avg, util_avg = simulate_pelt(pattern_multi)

ax = axes[1, 1]
ax.stackplot(times, 
    [np.where((times >= 0) & (times < 500), 1024, 0),
     np.where((times >= 100) & (times < 200), 2048, 0),
     np.where((times >= 300) & (times < 400), 512, 0)],
    labels=['Task A (nice 0)', 'Task B (nice -5)', 'Task C (nice 5)'],
    alpha=0.5)
ax.plot(times, load_avg * 345, 'k-', linewidth=2, label='Total load_sum')
ax.set_xlabel('Time (ms)')
ax.set_ylabel('Load')
ax.set_title('Multi-Task Competition with Different Weights')
ax.legend(loc='upper left')
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('pelt-mathematical-analysis.png', dpi=150, bbox_inches='tight')
print("数学模型可视化: pelt-mathematical-analysis.png")

5.2 读取系统真实PELT数据

#!/bin/bash
# file: read-system-pelt.sh
# 功能：读取系统中真实的PELT数据

echo "=== 全局CPU PELT数据（/proc/schedstat） ==="
# 格式：cpuN <yld> <act> <bkl> <idle> <iow> <irq> <sirq> <util>
# 其中util即为PELT util_avg的导出
cat /proc/schedstat | head -20

echo -e "\n=== 当前shell任务的PELT数据 ==="
# /proc/<pid>/sched 包含se.avg的详细信息
cat /proc/self/sched | grep -A2 "se.avg"

echo -e "\n=== 使用debugfs读取cfs_rq的PELT ==="
for cpu_path in /sys/kernel/debug/sched/cpu*; do
    echo "CPU: $cpu_path"
    sudo grep -E "cfs_rq|load_avg|util_avg|runnable_avg" $cpu_path 2>/dev/null | head -5
done

echo -e "\n=== 实时采样PELT变化 ==="
echo "启动压力测试后台，采样10秒..."
stress-ng --cpu 1 --quiet &
STRESS_PID=$!

for i in {1..10}; do
    echo "=== Sample $i ==="
    # 读取压力任务的PELT
    cat /proc/$STRESS_PID/sched | grep "se.avg" 2>/dev/null || echo "任务已结束"
    sleep 1
done

kill $STRESS_PID 2>/dev/null

5.3 PELT在内核中的关键应用点

/*
 * 应用点1：负载均衡 - 任务迁移决策
 * kernel/sched/fair.c: should_we_migrate()
 */

static inline bool
should_we_migrate(struct task_struct *p, struct sched_domain *sd,
                int src_cpu, int dst_cpu)
{
    struct sched_avg *sa = &p->se.avg;
    
    /*
     * 使用util_avg判断任务是否"重"
     * 重任务迁移代价高，倾向于留在原CPU
     */
    if (sa->util_avg > sched_asym_capacity(sd, src_cpu, dst_cpu))
        return false;  /* 太重，不迁移 */
    
    /*
     * 使用load_avg比较源和目标CPU的负载
     */
    if (cpu_rq(dst_cpu)->cfs.load_avg < cpu_rq(src_cpu)->cfs.load_avg)
        return true;  /* 目标更轻，迁移 */
    
    return false;
}

/*
 * 应用点2：CPU频率调节 - schedutil驱动
 * kernel/sched/cpufreq_schedutil.c
 */

static void sugov_update_single(struct update_util_data *hook, u64 time,
                               unsigned int flags)
{
    struct sugov_cpu *sg_cpu = container_of(hook, struct sugov_cpu, update_util);
    struct sugov_policy *sg_policy = sg_cpu->sg_policy;
    unsigned int cpu = sg_cpu->cpu;
    
    /*
     * 直接使用PELT util_avg作为频率选择依据
     * util_avg接近容量上限 → 升频
     * util_avg低 → 降频节能
     */
    sg_cpu->util = cpu_util_cfs(cpu);  /* 即se.avg.util_avg */
    sg_cpu->max = arch_scale_cpu_capacity(cpu);
    
    sugov_iowait_boost(sg_cpu, time, flags);
    sg_cpu->flags = flags;
    
    /* 频率调整 */
    sugov_update_commit(sg_policy, time, sg_cpu->util);
}

/*
 * 应用点3：任务唤醒 - 选择最佳CPU
 * kernel/sched/fair.c: select_task_rq_fair()
 */

static int
select_task_rq_fair(struct task_struct *p, int prev_cpu, int wake_flags)
{
    struct sched_domain *tmp, *affine_sd = NULL, *sd = NULL;
    int cpu = smp_processor_id();
    int new_cpu = prev_cpu;
    int want_affine = 0;
    
    /*
     * 使用util_avg判断任务类型
     * 小任务（util_avg低）：倾向于选择idle CPU，节能
     * 大任务（util_avg高）：倾向于选择local CPU，性能
     */
    if (p->se.avg.util_avg < sched_util_small_task(p))
        want_affine = 0;  /* 小任务，不强制本地性 */
    else
        want_affine = 1;  /* 大任务，优先本地性 */
    
    /* ... 遍历调度域，选择最佳CPU ... */
    
    return new_cpu;
}

5.4 自定义PELT半衰期实验

#!/bin/bash
# file: pelt-half-life-experiment.sh
# 功能：实验不同PELT半衰期对负载响应的影响

# 注意：实际半衰期在内核编译时确定，此处通过模拟展示差异
# 真实修改需要重新编译内核：修改kernel/sched/pelt.c中的#define

echo "=== 当前内核PELT参数 ==="
grep -r "HALF" ~/kernel-study/linux-5.15/kernel/sched/pelt.c 2>/dev/null || \
    echo "请检查内核源码中的DECAY_SHIFT等定义"

echo -e "\n=== 创建对比实验：快速响应 vs 平滑稳定 ==="

# 使用cgroup创建两个隔离环境（模拟不同半衰期效果）
sudo mkdir -p /sys/fs/cgroup/pelt-test/{fast,smooth}
echo "+cpu" | sudo tee /sys/fs/cgroup/pelt-test/cpu.subtree_control

# "快速响应"配置：短周期任务，需要快速检测
echo "10000 100000" | sudo tee /sys/fs/cgroup/pelt-test/fast/cpu.max  # 10%配额
echo "1024" | sudo tee /sys/fs/cgroup/pelt-test/fast/cpu.weight

# "平滑稳定"配置：长周期任务，避免抖动
echo "50000 100000" | sudo tee /sys/fs/cgroup/pelt-test/smooth/cpu.max  # 50%配额
echo "1024" | sudo tee /sys/fs/cgroup/pelt-test/smooth/cpu.weight

echo -e "\n=== 启动对比测试 ==="

# 快速响应组：突发短任务
echo $$ | sudo tee /sys/fs/cgroup/pelt-test/fast/cgroup.procs
echo "快速响应组（10%配额）：启动100ms突发任务循环"
for i in {1..5}; do
    stress-ng --cpu 1 --timeout 100ms --quiet
    sleep 200ms
    cat /sys/fs/cgroup/pelt-test/fast/cpu.stat
done

# 平滑稳定组：持续长任务
echo $$ | sudo tee /sys/fs/cgroup/pelt-test/smooth/cgroup.procs
echo "平滑稳定组（50%配额）：启动持续1秒任务"
stress-ng --cpu 1 --timeout 1s --quiet &
sleep 0.5
cat /sys/fs/cgroup/pelt-test/smooth/cpu.stat
wait

# 清理
echo $$ | sudo tee /sys/fs/cgroup/cgroup.procs
sudo rmdir /sys/fs/cgroup/pelt-test/fast /sys/fs/cgroup/pelt-test/smooth 2>/dev/null
sudo rmdir /sys/fs/cgroup/pelt-test 2>/dev/null

5.5 PELT数据导出与长期分析

#!/usr/bin/env python3
# file: pelt-data-exporter.py
# 功能：长期采样PELT数据，用于趋势分析和预测

import os
import time
import json
import argparse
from dataclasses import dataclass, asdict
from typing import List, Dict
import pandas as pd

@dataclass
class PELTSample:
    timestamp: float
    cpu: int
    load_sum: int
    load_avg: int
    util_sum: int
    util_avg: int
    runnable_sum: int
    runnable_avg: int

class PELTMonitor:
    def __init__(self, sample_interval=0.1):
        self.interval = sample_interval
        self.samples: List[PELTSample] = []
    
    def read_cpu_pelt(self, cpu: int) -> Dict:
        """从debugfs读取单个CPU的PELT数据"""
        path = f"/sys/kernel/debug/sched/cpu{cpu}"
        data = {}
        
        try:
            with open(path) as f:
                content = f.read()
                # 解析cfs_rq的PELT数据
                for line in content.split('\n'):
                    if 'cfs_rq[' in line and 'load_avg' in line:
                        parts = line.split()
                        for i, part in enumerate(parts):
                            if 'load_avg' in part:
                                data['load_avg'] = int(parts[i+1])
                            if 'util_avg' in part:
                                data['util_avg'] = int(parts[i+1])
                            if 'runnable_avg' in part:
                                data['runnable_avg'] = int(parts[i+1])
        except (FileNotFoundError, PermissionError):
            # 回退：使用/proc/schedstat近似
            try:
                with open('/proc/schedstat') as f:
                    lines = f.readlines()
                    if cpu + 1 < len(lines):
                        parts = lines[cpu + 1].split()
                        if len(parts) >= 10:
                            data['util_avg'] = int(parts[9])  # 近似值
            except:
                pass
        
        return data
    
    def read_task_pelt(self, pid: int) -> Dict:
        """从/proc/<pid>/sched读取任务PELT"""
        path = f"/proc/{pid}/sched"
        data = {}
        
        try:
            with open(path) as f:
                content = f.read()
                # 解析se.avg行
                for line in content.split('\n'):
                    if 'se.avg' in line or 'avg.' in line:
                        # 格式：se.avg.load_sum : 12345
                        if 'load_sum' in line:
                            data['load_sum'] = int(line.split(':')[1].strip())
                        elif 'load_avg' in line:
                            data['load_avg'] = int(line.split(':')[1].strip())
                        elif 'util_avg' in line:
                            data['util_avg'] = int(line.split(':')[1].strip())
        except (FileNotFoundError, ProcessLookupError):
            pass
        
        return data
    
    def sample_system(self, duration: int, target_pid: int = None):
        """采样系统PELT数据"""
        start_time = time.time()
        cpu_count = os.cpu_count()
        
        print(f"开始采样: {duration}秒, CPU数: {cpu_count}")
        
        while time.time() - start_time < duration:
            timestamp = time.time()
            
            for cpu in range(cpu_count):
                cpu_data = self.read_cpu_pelt(cpu)
                if cpu_data:
                    sample = PELTSample(
                        timestamp=timestamp,
                        cpu=cpu,
                        load_sum=cpu_data.get('load_sum', 0),
                        load_avg=cpu_data.get('load_avg', 0),
                        util_sum=cpu_data.get('util_sum', 0),
                        util_avg=cpu_data.get('util_avg', 0),
                        runnable_sum=cpu_data.get('runnable_sum', 0),
                        runnable_avg=cpu_data.get('runnable_avg', 0)
                    )
                    self.samples.append(sample)
            
            if target_pid:
                task_data = self.read_task_pelt(target_pid)
                # 可扩展为单独存储任务数据
            
            time.sleep(self.interval)
        
        print(f"采样完成: {len(self.samples)}条记录")
    
    def export_json(self, filename: str):
        """导出为JSON"""
        data = [asdict(s) for s in self.samples]
        with open(filename, 'w') as f:
            json.dump(data, f, indent=2)
        print(f"JSON导出: {filename}")
    
    def export_csv(self, filename: str):
        """导出为CSV"""
        if not self.samples:
            print("无数据可导出")
            return
        
        df = pd.DataFrame([asdict(s) for s in self.samples])
        df.to_csv(filename, index=False)
        print(f"CSV导出: {filename}")
        
        # 生成统计摘要
        summary = df.groupby('cpu').agg({
            'load_avg': ['mean', 'std', 'min', 'max'],
            'util_avg': ['mean', 'std', 'min', 'max']
        })
        print("\n统计摘要:")
        print(summary)
        
        return df
    
    def plot_trends(self, output: str = "pelt-trends.png"):
        """绘制趋势图"""
        import matplotlib.pyplot as plt
        
        if not self.samples:
            print("无数据可绘制")
            return
        
        df = pd.DataFrame([asdict(s) for s in self.samples])
        
        fig, axes = plt.subplots(2, 2, figsize=(14, 10))
        
        # 按CPU分组绘制
        for cpu in df['cpu'].unique()[:4]:  # 最多4个CPU
            cpu_data = df[df['cpu'] == cpu]
            
            # load_avg趋势
            axes[0, 0].plot(cpu_data['timestamp'] - df['timestamp'].min(),
                          cpu_data['load_avg'], label=f'CPU{cpu}', alpha=0.7)
            
            # util_avg趋势
            axes[0, 1].plot(cpu_data['timestamp'] - df['timestamp'].min(),
                          cpu_data['util_avg'], label=f'CPU{cpu}', alpha=0.7)
            
            # runnable_avg趋势
            axes[1, 0].plot(cpu_data['timestamp'] - df['timestamp'].min(),
                          cpu_data['runnable_avg'], label=f'CPU{cpu}', alpha=0.7)
            
            # load_avg vs util_avg散点
            axes[1, 1].scatter(cpu_data['util_avg'], cpu_data['load_avg'],
                             label=f'CPU{cpu}', alpha=0.5, s=10)
        
        axes[0, 0].set_title('load_avg Trend')
        axes[0, 0].set_xlabel('Time (s)')
        axes[0, 0].legend()
        
        axes[0, 1].set_title('util_avg Trend')
        axes[0, 1].set_xlabel('Time (s)')
        axes[0, 1].legend()
        
        axes[1, 0].set_title('runnable_avg Trend')
        axes[1, 0].set_xlabel('Time (s)')
        axes[1, 0].legend()
        
        axes[1, 1].set_title('load_avg vs util_avg')
        axes[1, 1].set_xlabel('util_avg')
        axes[1, 1].set_ylabel('load_avg')
        axes[1, 1].legend()
        
        plt.tight_layout()
        plt.savefig(output, dpi=150)
        print(f"趋势图: {output}")

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='PELT数据监控导出工具')
    parser.add_argument('-d', '--duration', type=int, default=60, help='采样时长(秒)')
    parser.add_argument('-i', '--interval', type=float, default=0.1, help='采样间隔(秒)')
    parser.add_argument('-p', '--pid', type=int, help='监控特定PID')
    parser.add_argument('-o', '--output', default='pelt-data', help='输出文件名前缀')
    
    args = parser.parse_args()
    
    monitor = PELTMonitor(sample_interval=args.interval)
    monitor.sample_system(duration=args.duration, target_pid=args.pid)
    monitor.export_json(f"{args.output}.json")
    df = monitor.export_csv(f"{args.output}.csv")
    monitor.plot_trends(f"{args.output}-trends.png")

5.6 负载均衡决策模拟器

#!/usr/bin/env python3
# file: load-balance-simulator.py
# 功能：模拟PELT数据驱动的负载均衡决策

import numpy as np
import matplotlib.pyplot as plt
from dataclasses import dataclass
from typing import List, Tuple

@dataclass
class CPU:
    id: int
    load_avg: float  # PELT load_avg
    util_avg: float  # PELT util_avg
    capacity: int    # CPU容量（考虑频率缩放）

class LoadBalancer:
    """模拟CFS负载均衡器"""
    
    def __init__(self, imbalance_pct=25):
        self.imbalance_pct = imbalance_pct  # 触发均衡的不平衡阈值
    
    def calculate_imbalance(self, cpus: List[CPU]) -> Tuple[int, int, float]:
        """
        计算最不平衡的CPU对
        返回: (src_cpu, dst_cpu, imbalance_value)
        """
        max_load = max(c.load_avg for c in cpus)
        min_load = min(c.load_avg for c in cpus)
        
        # 找到具体CPU
        src = next(c for c in cpus if c.load_avg == max_load)
        dst = next(c for c in cpus if c.load_avg == min_load)
        
        # 计算不平衡度（相对于平均的百分比）
        avg_load = sum(c.load_avg for c in cpus) / len(cpus)
        imbalance = (max_load - min_load) / avg_load * 100 if avg_load > 0 else 0
        
        return src.id, dst.id, imbalance
    
    def should_migrate(self, task_util: float, src: CPU, dst: CPU) -> bool:
        """
        判断是否应该迁移任务
        基于内核的should_we_migrate逻辑
        """
        # 条件1：任务不能太"重"（迁移开销）
        if task_util > src.capacity * 0.8:
            return False  # 太重，迁移代价高
        
        # 条件2：目标必须显著更轻
        load_diff = src.load_avg - dst.load_avg
        if load_diff < src.load_avg * self.imbalance_pct / 100:
            return False  # 不够不平衡
        
        # 条件3：考虑容量差异（异构系统）
        if dst.capacity < src.capacity * 0.9:
            # 小核，需要更高的util容忍度
            if task_util > dst.capacity * 0.7:
                return False
        
        return True
    
    def find_best_task(self, tasks: List[Tuple[float, float]], src: CPU, dst: CPU) -> int:
        """
        在源CPU的任务中找到最佳迁移候选
        tasks: [(load_avg, util_avg), ...]
        返回: 任务索引
        """
        best_idx = -1
        best_score = -1
        
        for i, (load, util) in enumerate(tasks):
            if not self.should_migrate(util, src, dst):
                continue
            
            # 评分：负载贡献大 + 不会太破坏src
            score = load * (1 - util / 1024)  # 高负载、低util优先
            
            if score > best_score:
                best_score = score
                best_idx = i
        
        return best_idx

def simulate_scenario():
    """模拟典型负载场景"""
    
    # 场景：4核系统，突发负载
    np.random.seed(42)
    time_points = 100
    
    # CPU状态随时间变化
    cpu_states = []
    for t in range(time_points):
        # 模拟突发：t=30-50时CPU0负载突增
        base_loads = [200, 300, 250, 280]
        base_utils = [400, 500, 450, 480]
        
        if 30 <= t <= 50:
            base_loads[0] += 800  # CPU0突发
            base_utils[0] += 600
        
        # 添加噪声
        cpus = [
            CPU(i, 
                base_loads[i] + np.random.normal(0, 50),
                min(1024, base_utils[i] + np.random.normal(0, 100)),
                1024)
            for i in range(4)
        ]
        cpu_states.append(cpus)
    
    # 运行负载均衡模拟
    lb = LoadBalancer(imbalance_pct=25)
    migrations = []
    imbalances = []
    
    for t, cpus in enumerate(cpu_states):
        src, dst, imb = lb.calculate_imbalance(cpus)
        imbalances.append(imb)
        
        if imb > 25:  # 触发阈值
            # 模拟找到可迁移任务
            mock_tasks = [(400, 300), (600, 500), (200, 150)]  # (load, util)
            best = lb.find_best_task(mock_tasks, cpus[src], cpus[dst])
            if best >= 0:
                migrations.append((t, src, dst, best))
                # 模拟迁移效果
                cpus[src].load_avg -= mock_tasks[best][0] * 0.8
                cpus[dst].load_avg += mock_tasks[best][0] * 0.8
    
    # 可视化
    fig, axes = plt.subplots(2, 2, figsize=(14, 10))
    
    # 各CPU负载趋势
    ax = axes[0, 0]
    for i in range(4):
        loads = [cpus[i].load_avg for cpus in cpu_states]
        ax.plot(loads, label=f'CPU{i}')
    ax.axhline(y=800, color='r', linestyle='--', label='threshold')
    ax.set_title('CPU Load_avg Over Time')
    ax.set_xlabel('Time')
    ax.set_ylabel('load_avg')
    ax.legend()
    
    # 不平衡度
    ax = axes[0, 1]
    ax.plot(imbalances, 'g-', label='imbalance %')
    ax.axhline(y=25, color='r', linestyle='--', label='migrate threshold')
    ax.set_title('Load Imbalance')
    ax.set_xlabel('Time')
    ax.set_ylabel('Imbalance %')
    ax.legend()
    
    # 迁移事件
    ax = axes[1, 0]
    if migrations:
        times, srcs, dsts, tasks = zip(*migrations)
        ax.scatter(times, srcs, c='red', s=100, label='source CPU', marker='o')
        ax.scatter(times, dsts, c='green', s=100, label='dest CPU', marker='^')
        for t, s, d, task in migrations:
            ax.annotate(f'T{task}', (t, s), fontsize=8)
    ax.set_title('Migration Events')
    ax.set_xlabel('Time')
    ax.set_ylabel('CPU ID')
    ax.legend()
    
    # 负载均衡效果
    ax = axes[1, 1]
    final_loads = [cpus[0].load_avg for cpus in cpu_states[-10:]]
    ax.bar(range(4), [cpu_states[-1][i].load_avg for i in range(4)])
    ax.set_title('Final Load Distribution')
    ax.set_xlabel('CPU')
    ax.set_ylabel('load_avg')
    
    plt.tight_layout()
    plt.savefig('load-balance-simulation.png', dpi=150)
    print(f"模拟完成，迁移次数: {len(migrations)}")
    print(f"可视化结果: load-balance-simulation.png")

if __name__ == '__main__':
    simulate_scenario()

---

六、常见问题与解答

Q1: 为什么load_avg和util_avg数值差异很大？

#!/bin/bash
# file: explain-load-vs-util.sh
# 解释load_avg和util_avg的差异

echo "=== 理论关系 ==="
echo "load_avg = weight × runnable_avg"
echo "util_avg = SCHED_CAPACITY_SCALE × running_avg"
echo ""
echo "对于nice 0的任务（weight=1024）："
echo "  - 如果50%时间可运行，50%时间运行："
echo "    load_avg ≈ 1024 × 0.5 = 512"
echo "    util_avg ≈ 1024 × 0.5 = 512"
echo ""
echo "对于nice -20的任务（weight=88761）："
echo "  - 同样50%时间可运行，50%时间运行："
echo "    load_avg ≈ 88761 × 0.5 = 44380（很高！）"
echo "    util_avg ≈ 1024 × 0.5 = 512（相同！）"
echo ""
echo "关键结论："
echo "  - util_avg反映实际CPU使用，与nice无关"
echo "  - load_avg反映调度权重，nice影响很大"

echo -e "\n=== 实际系统验证 ==="
# 创建高nice任务
nice -n -20 stress-ng --cpu 1 --timeout 2s --quiet &
NICE_PID=$!
sleep 1

echo "高优先级任务 $NICE_PID 的PELT数据："
cat /proc/$NICE_PID/sched | grep -E "load_avg|util_avg|weight"

# 创建普通nice任务
stress-ng --cpu 1 --timeout 2s --quiet &
NORMAL_PID=$!
sleep 1

echo -e "\n普通优先级任务 $NORMAL_PID 的PELT数据："
cat /proc/$NORMAL_PID/sched | grep -E "load_avg|util_avg|weight"

wait

Q2: 如何调试PELT更新异常？

#!/bin/bash
# file: debug-pelt-updates.sh
# 调试PELT更新问题

echo "=== 启用PELT详细追踪 ==="
# 需要内核启用CONFIG_SCHED_DEBUG

sudo bpftrace -e '
#include <linux/sched.h>

/* 追踪PELT更新入口 */
kprobe:update_load_avg {
    $sa = (struct sched_avg *)arg1;
    $now = arg0;
    
    printf("PELT update: now=%llu load_sum=%llu util_sum=%llu\n",
        $now, $sa->load_sum, $sa->util_sum);
}

/* 追踪大的负载突变 */
kprobe:update_load_avg / ((struct sched_avg *)arg1)->load_avg > 10000 / {
    printf("WARNING: Large load_avg detected!\n");
    printf("  load_avg=%u util_avg=%u\n",
        ((struct sched_avg *)arg1)->load_avg,
        ((struct sched_avg *)arg1)->util_avg);
}

/* 追踪衰减计算 */
kprobe:__decay_load {
    printf("Decay: delta=%u decayed_load=%llu\n",
        arg1, arg0);
}
' -c 'sleep 10' 2>/dev/null || echo "需要root权限和bpftrace"

Q3: 如何优化PELT的响应速度？

/*
 * 优化方向1：调整半衰期（需重新编译内核）
 * kernel/sched/pelt.c
 */

/* 原值：32ms，适合通用场景 */
#define PELT_SHIFT 5  /* 2^5 = 32ms half-life */

/* 改为16ms，更快响应（适合实时场景） */
#define PELT_SHIFT 4  /* 2^4 = 16ms half-life */

/* 改为64ms，更平滑（适合批处理场景） */
#define PELT_SHIFT 6  /* 2^6 = 64ms half-life */

/*
 * 优化方向2：运行时调整（部分参数可通过sysctl）
 */
unsigned int sysctl_sched_latency = 6000000ULL;  /* 6ms */
/* 减小此值使调度器更敏感，但增加开销 */

/*
 * 优化方向3：选择性启用（容器场景）
 * 对非关键cgroup禁用详细PELT统计
 */
#ifdef CONFIG_CGROUP_SCHED
/* 在cfs_rq创建时选择简化模式 */
if (tg->flags & TG_FLAG_NO_PELT) {
    cfs_rq->load_avg = 0;  /* 禁用详细追踪 */
}
#endif

Q4: 如何利用PELT进行容量规划？

#!/usr/bin/env python3
# file: capacity-planning-with-pelt.py
# 基于PELT历史数据的容量规划

import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

def analyze_pelt_history(csv_file: str):
    """分析PELT历史数据，预测容量需求"""
    
    # 读取PELT采样数据
    df = pd.read_csv(csv_file)
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='s')
    
    # 按时间聚合（小时级）
    hourly = df.groupby(df['timestamp'].dt.hour).agg({
        'util_avg': ['mean', 'max', 'std'],
        'load_avg': ['mean', 'max']
    }).reset_index()
    
    # 峰值预测：使用P99 util_avg
    p99_util = df['util_avg'].quantile(0.99)
    print(f"历史P99利用率: {p99_util:.1f}")
    
    # 趋势分析
    df['hour'] = (df['timestamp'] - df['timestamp'].min()).dt.total_seconds() / 3600
    X = df[['hour']].values
    y = df['util_avg'].values
    
    model = LinearRegression()
    model.fit(X, y)
    trend = model.coef_[0]  # 每小时变化趋势
    
    print(f"利用率趋势: {trend:+.2f}/小时")
    
    # 容量建议
    current_capacity = 1024  # 假设
    recommended = p99_util * 1.3  # 30% headroom
    
    print(f"\n容量建议:")
    print(f"  当前配置: {current_capacity}")
    print(f"  推荐配置: {recommended:.0f}")
    print(f"  扩容比例: {recommended/current_capacity*100-100:.1f}%")
    
    # 可视化
    fig, axes = plt.subplots(2, 2, figsize=(14, 10))
    
    # 时间序列
    ax = axes[0, 0]
    for cpu in df['cpu'].unique():
        cpu_data = df[df['cpu'] == cpu]
        ax.plot(cpu_data['hour'], cpu_data['util_avg'], 
                label=f'CPU{cpu}', alpha=0.6)
    ax.axhline(y=p99_util, color='r', linestyle='--', label='P99')
    ax.axhline(y=recommended, color='g', linestyle='--', label='Recommended')
    ax.set_title('Utilization Time Series')
    ax.set_xlabel('Hour')
    ax.set_ylabel('util_avg')
    ax.legend()
    
    # 分布直方图
    ax = axes[0, 1]
    ax.hist(df['util_avg'], bins=50, alpha=0.7, edgecolor='black')
    ax.axvline(x=p99_util, color='r', linestyle='--', label='P99')
    ax.set_title('Utilization Distribution')
    ax.set_xlabel('util_avg')
    ax.set_ylabel('Frequency')
    ax.legend()
    
    # 小时模式
    ax = axes[1, 0]
    hourly['util_avg']['mean'].plot(kind='bar', ax=ax)
    ax.set_title('Average Utilization by Hour')
    ax.set_xlabel('Hour of Day')
    ax.set_ylabel('Mean util_avg')
    
    # 负载vs利用率散点
    ax = axes[1, 1]
    ax.scatter(df['util_avg'], df['load_avg'], alpha=0.3, s=5)
    ax.set_title('Load vs Utilization')
    ax.set_xlabel('util_avg')
    ax.set_ylabel('load_avg')
    
    plt.tight_layout()
    plt.savefig('capacity-planning-analysis.png', dpi=150)
    print(f"\n分析图表: capacity-planning-analysis.png")

if __name__ == '__main__':
    import sys
    if len(sys.argv) < 2:
        print(f"用法: {sys.argv[0]} <pelt-data.csv>")
        sys.exit(1)
    
    analyze_pelt_history(sys.argv[1])

---

七、实践建议与最佳实践

7.1 PELT调优决策树

开始
├── 任务延迟敏感？（如实时控制）
│   ├── 是 → 减小PELT_SHIFT（16ms），快速检测负载变化
│   └── 否 → 继续
├── 任务突发性强？（如Web服务）
│   ├── 是 → 保持默认32ms，平衡响应与稳定
│   └── 否 → 继续
├── 追求能效优先？（如移动设备）
│   ├── 是 → 增大PELT_SHIFT（64ms），减少频率抖动
│   └── 否 → 默认配置
└── 需要详细追踪？
    ├── 是 → 启用CONFIG_SCHEDSTATS，使用pelt-data-exporter.py
    └── 否 → 最小化开销，禁用debug

7.2 容器场景的PELT优化

#!/bin/bash
# file: container-pelt-optimization.sh
# 容器平台的PELT优化配置

echo "=== 创建分层PELT策略 ==="

# 层1：系统级，平滑稳定
sudo mkdir -p /sys/fs/cgroup/system.slice
echo "500000 1000000" | sudo tee /sys/fs/cgroup/system.slice/cpu.max  # 50%

# 层2：在线服务，快速响应
sudo mkdir -p /sys/fs/cgroup/online.slice
echo "+cpu" | sudo tee /sys/fs/cgroup/online.slice/cgroup.subtree_control
echo "800000 1000000" | sudo tee /sys/fs/cgroup/online.slice/cpu.max  # 80%
# 子cgroup继承快速响应特性

# 层3：批处理作业，平滑聚合
sudo mkdir -p /sys/fs/cgroup/batch.slice
echo "+cpu" | sudo tee /sys/fs/cgroup/batch.slice/cgroup.subtree_control
echo "300000 1000000" | sudo tee /sys/fs/cgroup/batch.slice/cpu.max  # 30%

echo "=== 验证层级结构 ==="
find /sys/fs/cgroup -name "cpu.stat" -path "*slice*" -exec sh -c '
    echo "=== {} ==="
    head -3 {}
' \;

echo "=== 监控脚本 ==="
cat > monitor-pelt.sh << 'EOF'
#!/bin/bash
while true; do
    echo "$(date) Online: $(cat /sys/fs/cgroup/online.slice/cpu.stat | head -1)"
    echo "$(date) Batch:  $(cat /sys/fs/cgroup/batch.slice/cpu.stat | head -1)"
    sleep 5
done
EOF
chmod +x monitor-pelt.sh
echo "运行 ./monitor-pelt.sh 开始监控"

7.3 学术研究数据收集清单

数据类型	收集方法	研究用途
PELT原始值	pelt-data-exporter.py	算法验证、模型拟合
调度延迟	cyclictest + trace-cmd	实时性分析
频率调节轨迹	cpupower monitor	能效算法评估
任务迁移日志	bpftrace追踪migrate_task	负载均衡策略优化
能耗统计	RAPL接口或perf	绿色计算研究

---

八、总结与应用场景

本文系统解析了Linux调度子系统中的三种核心负载概念——权重负载（Weight）、利用率（Utilization）、可运行负载（Runnable Load），并深度拆解了PELT算法的指数衰减数学原理及其在负载均衡、频率调节中的关键应用。

核心要点回顾：

• 权重负载：静态或动态配置的"应得份额"，通过nice值或cgroup shares调节，影响长期公平性

• 利用率：实际消耗的CPU容量，通过PELT平滑追踪，驱动频率调节和唤醒决策

• 可运行负载：调度器视角的真实需求，权重×可运行时间，是负载均衡的核心输入

• PELT算法：32ms半衰期的指数衰减，将离散事件转化为平滑曲线，支持预测性决策

典型应用场景：

• 云原生自动伸缩：PELT util_avg触发扩容，runnable_avg预测突发，实现领先指标驱动

• 边缘AI推理：schedutil直接读取PELT调节频率，每帧能耗降低35%

• 实时系统优化：调整PELT半衰期，快速检测负载突变，保障控制循环稳定性

• 异构调度：结合util_avg和容量缩放，实现大核/小核的智能任务放置

掌握PELT机制，意味着拥有了理解和优化Linux调度决策的"数学透镜"。建议读者从运行pelt-data-exporter.py采集真实系统数据开始，逐步深入到半衰期调优和自定义负载均衡策略开发，最终贡献于上游内核社区。

---

附录：PELT快速参考

核心公式：
  decay_factor(t) = 2^(-t / half_life_ms)
  load_avg = load_sum / LOAD_AVG_MAX
  util_avg = util_sum / LOAD_AVG_MAX

关键文件：
  kernel/sched/pelt.c      - PELT核心实现
  kernel/sched/pelt.h      - 数据结构与内联函数
  kernel/sched/fair.c      - CFS集成与应用

调优接口：
  /proc/sys/kernel/sched_latency - 调度周期
  /proc/sys/kernel/sched_min_granularity - 最小粒度
  CONFIG_PELT_SHIFT - 半衰期（编译时）

---

本文基于Linux 5.15内核源码，建议配合Elixir Cross Referencer和本文提供的pelt-mathematical-model.py工具使用。