当 n→∞ 时，利用率上限趋近于 ln(2) ≈ 0.693
对于 3 个任务：U ≤ 3 × (2^(1/3) - 1) ≈ 0.780

示例：
任务A: 周期 10ms, 执行 2ms → U_A = 0.2
任务B: 周期 20ms, 执行 4ms → U_B = 0.2
任务C: 周期 50ms, 执行 5ms → U_C = 0.1
总 U = 0.5 ≤ 0.780 → 可调度 ✓

#include <sched.h>
#include <pthread.h>

// 设置 SCHED_FIFO 实时优先级
struct sched_param param;
param.sched_priority = 50;  // 优先级 1-99

// 设置当前线程
int ret = pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m);
if (ret != 0) {
    perror("pthread_setschedparam");
    return -1;
}

// 或使用 sched_setscheduler 设置进程
struct sched_param param = { .sched_priority = 50 };
sched_setscheduler(0, SCHED_FIFO, ¶m);

// 获取优先级范围
int min_prio = sched_get_priority_min(SCHED_FIFO);  // 1
int max_prio = sched_get_priority_max(SCHED_FIFO);  // 99
printf("SCHED_FIFO priority range: %d - %d\n", min_prio, max_prio);

// 设置 SCHED_RR 实时优先级
struct sched_param param;
param.sched_priority = 60;
pthread_setschedparam(pthread_self(), SCHED_RR, ¶m);

// 查询 RR 时间片长度
struct timespec ts;
sched_rr_get_interval(0, &ts);
printf("RR timeslice: %ld ms\n", ts.tv_sec * 1000 + ts.tv_nsec / 1000000);

#define _GNU_SOURCE
#include <sched.h>

struct sched_attr {
    uint32_t size;              // 结构体大小
    uint32_t sched_policy;      // SCHED_DEADLINE
    uint64_t sched_flags;       // 0
    int32_t  sched_nice;        // 不使用
    uint32_t sched_priority;    // 不使用（EDF 不依赖静态优先级）
    uint64_t sched_runtime;     // 运行时长 (ns)
    uint64_t sched_deadline;    // 截止时间 (ns)
    uint64_t sched_period;      // 周期 (ns)
};

// 声明一个实时任务：每 10ms 周期内最多运行 3ms
struct sched_attr attr = {
    .size = sizeof(attr),
    .sched_policy = SCHED_DEADLINE,
    .sched_runtime  = 3 * 1000 * 1000,   // 3ms
    .sched_deadline = 10 * 1000 * 1000,  // 10ms
    .sched_period   = 10 * 1000 * 1000,  // 10ms
};

// 通过 sched_setattr 设置 (Linux 3.14+)
int ret = sched_setattr(0, &attr, 0);
if (ret < 0) {
    perror("sched_setattr");
}

// 传统中断注册 - 硬中断上下文
request_irq(irq_num, my_hard_handler, IRQF_SHARED, "mydev", devid);

// PREEMPT_RT 推荐方式 - 自动线程化中断
request_threaded_irq(irq_num,
    my_hard_handler,    // 可为 NULL → 默认硬中断处理
    my_thread_handler,  // 线程化中断处理（作为 SCHED_FIFO 任务运行）
    IRQF_ONESHOT | IRQF_SHARED,
    "mydev_rt", devid);

// 线程化中断默认以 SCHED_FIFO 优先级 50 运行
// 可通过 /proc/irq/N/smp_affinity 绑定 CPU
// 可通过 /proc/irq/N/affinity_hint 优化缓存

// PREEMPT_RT 下的锁行为变化：
// 普通 spinlock → rt_mutex（可睡眠，优先级继承）

DEFINE_SPINLOCK(my_lock);  // 实际为 rt_mutex

spin_lock(&my_lock);        // 可能睡眠！不能再硬中断上下文使用
/* 临界区 */
spin_unlock(&my_lock);

// 硬中断上下文仍需使用原始自旋锁
DEFINE_RAW_SPINLOCK(hard_lock);
unsigned long flags;

raw_spin_lock_irqsave(&hard_lock, flags);
/* 硬中断临界区 */
raw_spin_unlock_irqrestore(&hard_lock, flags);

#include <time.h>

// 高精度睡眠（替代 usleep/nanosleep）
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
ts.tv_nsec += 100000;  // 100us
if (ts.tv_nsec >= 1000000000) {
    ts.tv_sec++;
    ts.tv_nsec -= 1000000000;
}
clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &ts, NULL);

// 使用 SCHED_DEADLINE 周期性任务替代定时器
// 更适合硬实时场景

#include <pthread.h>

// 创建支持优先级继承的互斥锁
pthread_mutex_t mutex;
pthread_mutexattr_t attr;

pthread_mutexattr_init(&attr);
pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);  // 关键！
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);   // 可选：支持递归
pthread_mutex_init(&mutex, &attr);

// 使用方式与普通互斥锁相同
pthread_mutex_lock(&mutex);
/* 临界区操作 */
pthread_mutex_unlock(&mutex);

// Linux 内核中的 rt_mutex 自动实现 PI
// 用户态通过 PTHREAD_PRIO_INHERIT 属性启用

# 下载与主线版本对应的 PREEMPT_RT 补丁
# 例如 Linux 6.12.x
wget https://cdn.kernel.org/pub/linux/kernel/projects/rt/6.12/patch-6.12.x-rtxx.patch.xz

# 应用补丁
cd linux-6.12.x
xzcat ../patch-6.12.x-rtxx.patch.xz | patch -p1

# 配置内核选项
make menuconfig

# 关键配置路径：
# General Setup  --->
#   Preemption Model (Fully Preemptible Kernel (Real-Time))  -#>
#     [*] Fully Preemptible Kernel (Real-Time)

# 或选择以下模式（按实时程度递增）：
# - Preemptible Kernel (Low-Latency Desktop): 延迟 ~1-5ms
# - Voluntary Kernel Preemption (Desktop): 延迟 ~5-20ms
# - Preemptible Kernel (Basic RT): 延迟 ~0.5-2ms
# - Fully Preemptible Kernel (Real-Time): 延迟 ~10-100μs

# Processor type and features  --->
#   [*] Timer frequency (1000 HZ)  # 更高频率 = 更精细调度粒度
#   [*] High-resolution timer support  # hrtimer 必须启用

# 编译与安装
make -j$(nproc)
make modules_install
make install

# 验证内核是否支持 RT
uname -a  # 输出应包含 "PREEMPT_RT"
uname -v  # 查看版本是否包含 -rt 后缀
zcat /proc/config.gz | grep PREEMPT_RT
# CONFIG_PREEMPT_RT=y

# 编译 rt-tests（包含 cyclictest）
git clone git://git.kernel.org/pub/scm/utils/rt-tests/rt-tests.git
cd rt-tests
make

# 基本延迟测试（运行 100 万个周期）
sudo ./cyclictest -l 1000000 -m -n -p 99

# 参数说明：
# -l N    : 循环次数（1M = 百万次）
# -m      : mlockall 锁定内存，避免缺页
# -n      : 使用 clock_nanosleep（非 POSIX 定时器）
# -p 99   : SCHED_FIFO 优先级 99
# -a      : 指定 CPU 亲和性
# -t      : 多线程模式（同时测试所有 CPU）
# -h      : 直方图模式

# 多线程 + 直方图模式（最全面测试）
sudo ./cyclictest -a -t -n -p 99 -l 1000000 -h 400 -i 200 -D 1h

# -i 200   : 周期 200μs
# -D 1h    : 运行 1 小时
# -h 400   : 直方图最大 400μs

# 典型输出（PREEMPT_RT，Intel i7）：
# T: 0 ( 1234) P: 99 I: 200 C: 1000000 Min: 3 Act: 5 Avg: 6 Max: 18
#                          Min最小 / Avg平均 / Max最大（微秒）
#
# 未补丁的通用内核：Min: 8 Avg: 15 Max: 150+（偶有秒级尖峰）
# PREEMPT_RT：Min: 2 Avg: 5 Max: 20（几乎无尖峰）

# 1. 使用 irqlat tracer 追踪中断关闭时间
echo irqlat > /sys/kernel/debug/tracing/current_tracer
echo 1 > /sys/kernel/debug/tracing/tracing_on
sleep 30
echo 0 > /sys/kernel/debug/tracing/tracing_on
cat /sys/kernel/debug/tracing/trace

# 2. 使用 wakeup_dl tracer 追踪实时任务调度延迟
echo wakeup_dl > /sys/kernel/debug/tracing/current_tracer
cat /sys/kernel/debug/tracing/trace

# 3. perf sched 可视化调度行为
perf sched record -- sleep 10
perf sched latency    # 调度延迟直方图
perf sched map        # CPU 利用率热力图
perf sched script     # 原始时间线

# 4. 追踪最大延迟事件
echo "function_graph" > /sys/kernel/debug/tracing/current_tracer
echo "schedule" > /sys/kernel/debug/tracing/set_ftrace_filter
echo "max_latency" > /sys/kernel/debug/tracing/trace_options
cat /sys/kernel/debug/tracing/trace

# 方法 1: boot 参数隔离（GRUB_CMDLINE_LINUX）
# isolcpus=2,3,4,5 : 隔离 CPU 2-5
# nohz_full=2,3,4,5 : 在隔离 CPU 上禁用 tick
# rcu_nocbs=2,3,4,5 : 将 RCU 回调移出隔离 CPU

# 方法 2: cgroup cpuset 动态隔离
mkdir /sys/fs/cgroup/cpuset/rt_tasks
echo "2-5" > /sys/fs/cgroup/cpuset/rt_tasks/cpuset.cpus
echo "0" > /sys/fs/cgroup/cpuset/rt_tasks/cpuset.mems
echo 1 > /sys/fs/cgroup/cpuset/rt_tasks/cpuset.cpu_exclusive

# 方法 3: taskset 将实时进程绑定到指定 CPU
taskset -c 2 ./realtime_task -p 99

# 验证隔离效果
taskset -cp $$   # 查看当前进程 CPU 亲和性
cat /proc/irq/default_smp_affinity  # 默认中断路由

# 将所有中断路由到非实时 CPU（如 CPU 0-1）
# 将实时任务的 CPU（2-5）从中断中"隔离"

# 查看当前中断分布
cat /proc/interrupts
cat /proc/irq/42/smp_affinity  # 显示十六进制 CPU 掩码

# 将特定中断绑定到 CPU 0
echo 1 > /proc/irq/42/smp_affinity   # CPU 0（0b0001）
echo 2 > /proc/irq/43/smp_affinity   # CPU 1（0b0010）

# 使用 irqbalance 动态调整
systemctl stop irqbalance  # 实时系统中通常关闭 irqbalance
# irqbalance 会动态优化中断分布，可能干扰实时性

#include <sys/mman.h>

// 1. 锁定所有内存（禁止交换）
if (mlockall(MCL_CURRENT | MCL_FUTURE) == -1) {
    perror("mlockall");
}

// 2. 预分配栈空间并锁定
#define STACK_SIZE (512 * 1024)  // 512KB
void *stack = mmap(NULL, STACK_SIZE,
                   PROT_READ | PROT_WRITE,
                   MAP_PRIVATE | MAP_ANONYMOUS | MAP_LOCKED,
                   -1, 0);
mlock(stack, STACK_SIZE);

// 3. 禁用地址空间随机化（ASLR）- 启动前设置
// setarch `uname -m` -R ./realtime_app
// 或 sysctl -w kernel.randomize_va_space=0

// 4. 使用 Hugepages 减少 TLB Miss
// 配置 /etc/sysctl.conf: vm.nr_hugepages = 512
// mmap(..., MAP_HUGETLB | MAP_HUGE_2MB, ...)

// 5. NUMA 本地内存分配
#include <numa.h>
numa_set_preferred(numa_node_of_cpu(target_cpu));

# 实时任务带宽限制（全局）
echo 950000 > /proc/sys/kernel/sched_rt_runtime_us  # 每 1s 内实时任务最多占 950ms
echo -1 > /proc/sys/kernel/sched_rt_runtime_us     # 无限制（危险但实时性强）

# 查看当前限制
cat /proc/sys/kernel/sched_rt_runtime_us
cat /proc/sys/kernel/sched_rt_period_us  # 默认 1000000 (1s)

# 按 cgroup 组限制
echo 800000 > /sys/fs/cgroup/cpu/rt_group/cpu.rt_runtime_us

┌─────────────────────────────────────────────────────────┐
│                PREEMPT_RT Linux 6.12                     │
├──────────┬──────────┬───────────────────────────────────┤
│ CPU 0-1  │ CPU 2-3  │ CPU 4-7                           │
│ 系统任务 │ 网络+显示│ 实时控制任务                       │
│ OS 中断  │ EtherCAT │ 运动的 10kHz 控制循环               │
│ 非实时   │ 协议栈   │ 传感器读取 + 执行器控制              │
│ chrt 不  │ SCHED_RR │ SCHED_FIFO + mlockall              │
└──────────┴──────────┴───────────────────────────────────┘

#include <pthread.h>
#include <sched.h>
#include <time.h>
#include <sys/mman.h>
#include <stdio.h>
#include <stdint.h>

#define CONTROL_PERIOD_NS (100 * 1000)  // 100μs 控制周期
#define RT_PRIO           (98)          // 高优先级略低于 cyclictest
#define RT_CPU            (4)           // 运行在隔离 CPU 4

typedef struct {
    double position;
    double velocity;
    double torque;
} AxisState;

static volatile int keep_running = 1;

void* control_loop(void *arg) {
    AxisState *axis = (AxisState *)arg;
    struct timespec next_wakeup;
    long jitter_sum = 0, jitter_max = 0;
    long cycle_count = 0;

    // 1. 锁定内存
    mlockall(MCL_CURRENT | MCL_FUTURE);

    // 2. 设置实时优先级
    struct sched_param param = { .sched_priority = RT_PRIO };
    pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m);

    // 3. CPU 亲和性绑定
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(RT_CPU, &cpuset);
    pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);

    // 4. 初始化首个唤醒时间
    clock_gettime(CLOCK_MONOTONIC, &next_wakeup);

    while (keep_running) {
        // 5. 计算下一个周期
        next_wakeup.tv_nsec += CONTROL_PERIOD_NS;
        if (next_wakeup.tv_nsec >= 1000000000L) {
            next_wakeup.tv_sec++;
            next_wakeup.tv_nsec -= 1000000000L;
        }

        // 6. 控制算法（PID + 前馈）
        read_sensors(axis);                 // ~15μs
        compute_pid(axis);                  // ~20μs
        apply_torque(axis);                 // ~10μs
        check_watchdog(axis);               // ~5μs

        // 7. 精确等待下一个周期
        int ret = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME,
                                  &next_wakeup, NULL);
        if (ret != 0) {
            // 错过周期 → 触发错误处理
            handle_cycle_miss(cycle_count);
        }

        cycle_count++;
    }
    return NULL;
}

# 工业控制器实测数据（PREEMPT_RT 6.12, Xeon E-2378）
$ sudo cyclictest -a -t -n -p 99 -l 10000000 -h 200 -i 100 -D 4h

# 结果：
# Min latency:  2 μs
# Avg latency:  5 μs
# Max latency:  17 μs  （远低于 30μs 要求）
# 总周期数：10,000,000（4 小时）
# 超过 30μs 的周期：0 个
# 超过 50μs 的周期：0 个

# 系统在 7×24 运行中保持 jitter < 20μs
# EtherCAT 同步误差 < 100ns

# 方式 1: sudo（开发环境）
sudo chrt -f -p 50 PID

# 方式 2: setcap（生产环境）
setcap cap_sys_nice+ep /opt/rt_app/bin/controller

# 方式 3: systemd 单元文件
# /etc/systemd/system/rt-controller.service
[Service]
Type=simple
ExecStart=/opt/rt_app/bin/controller
CPUSchedulingPolicy=fifo
CPUSchedulingPriority=50
CPUSchedulingCPUAffinity=4 5
MemoryLock=yes
LimitMEMLOCK=infinity
AmbientCapabilities=CAP_SYS_NICE