当前位置：首页 > news >正文

第23天：实时进程调度：SCHED_FIFO/SCHED_RR 的嵌入式实时应用

news 2026/6/30 17:08:56

开篇导语

想象一下这样的场景：一架正在飞行的民航客机，发动机控制系统需要在毫秒级时间内响应传感器数据；一台正在执行手术的医疗机器人，任何微小的调度延迟都可能关乎生命安全；一套工业自动化生产线，要求精确到微秒级的运动控制同步。在这些对时间响应有着严苛要求的嵌入式系统中，普通Linux内核那套"尽力而为"的调度策略显然无法满足需求。

好消息是，Linux内核早已为这些场景准备好了解决方案——实时调度类（Real-Time Scheduling Classes）。今天，我们将深入探索Linux实时调度的两大核心武器：SCHED_FIFO和SCHED_RR，看看它们是如何在嵌入式实时系统中发挥关键作用的。别眨眼，因为这可能是你理解Linux实时调度最重要的一课。

一、为什么需要实时调度？

1.1 普通调度器的局限

在探讨实时调度之前，我们先回顾一下普通进程的调度方式。Linux默认的**完全公平调度器（CFS）**的核心思想是"公平"，它会尽可能均匀地分配CPU时间片给每一个运行中的进程。但这种"公平"在实时场景下反而成了问题——你无法保证某个关键任务能够优先获得CPU资源。

/* * 模拟一个需要精确时间响应的控制系统 * 如果使用普通调度器，这个循环的延迟是不可预测的 */ void control_loop(void) { while (running) { /* 读取传感器数据 */ read_sensor_data(); /* 计算控制输出 */ compute_control_output(); /* 发送控制指令 - 这个操作必须尽快执行 */ send_control_command(); /* 延迟1ms */ usleep(1000); // 问题：这个sleep的精确性完全取决于系统负载 } }

1.2 实时调度的核心目标

实时调度追求的是确定性（Determinism），而不是公平性。它的核心目标是：保证高优先级任务能够在确定的时间内获得CPU。在实时系统中，"慢"不一定是指绝对速度慢，而是指响应时间可预测。

实时系统通常分为两类：

类型	特点	例子
硬实时（Hard Real-Time）	超过截止时间必定导致系统失败	飞机自动驾驶、汽车安全气囊
软实时（Soft Real-Time）	偶尔超过截止时间可接受	音视频播放、网络视频流

Linux的SCHED_FIFO和SCHED_RR属于软实时范畴，它们能提供确定性的调度延迟，但无法提供硬实时系统的绝对保证。

二、SCHED_FIFO 深度剖析

2.1 基本概念

SCHED_FIFO是最简单的实时调度策略，它遵循以下核心规则：

优先级抢占：高优先级的SCHED_FIFO或SCHED_RR进程可以抢占低优先级进程
先来先服务：同等优先级下，先进入运行队列的进程先执行
执行直到阻塞：进程一旦获得CPU，会一直运行直到主动放弃（阻塞、调用sched_yield()）或被更高优先级进程抢占
无时间片：SCHED_FIFO进程没有时间片概念，只要它能运行，就可以一直运行

2.2 优先级范围

/* * Linux实时进程优先级范围 * 查看当前系统配置 */ #include <sched.h> #include <stdio.h> int main(void) { /* 获取最小和最大优先级 */ int min_priority = sched_get_priority_min(SCHED_FIFO); int max_priority = sched_get_priority_max(SCHED_FIFO); printf("SCHED_FIFO 优先级范围: %d ~ %d\n", min_priority, max_priority); printf("通常实时优先级范围是 1~99，数字越大优先级越高\n"); return 0; }

在Linux系统中，实时进程优先级范围通常是：

最小优先级：1
最大优先级：99
优先级0：保留给非实时进程（SCHED_NORMAL/SCHED_OTHER）

2.3 代码实战：创建SCHED_FIFO进程

/* * realtime_fifo_test.c - SCHED_FIFO实时进程示例 * 编译：gcc -o realtime_fifo_test realtime_fifo_test.c -Wall */ #define _GNU_SOURCE #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sched.h> #include <unistd.h> #include <sys/types.h> #include <sys/resource.h> #include <errno.h> /* * 设置进程调度策略和优先级 * @param policy: 调度策略（SCHED_FIFO, SCHED_RR, SCHED_OTHER等） * @param priority: 实时优先级（1-99） * @return: 成功返回0，失败返回-1 */ int set_realtime_scheduler(int policy, int priority) { struct sched_param param; /* 验证优先级范围 */ int min_prio = sched_get_priority_min(policy); int max_prio = sched_get_priority_max(policy); if (priority < min_prio || priority > max_prio) { fprintf(stderr, "优先级必须在 %d ~ %d 之间\n", min_prio, max_prio); return -1; } memset(&param, 0, sizeof(param)); param.sched_priority = priority; /* 设置调度策略和优先级 * 注意：通常需要root权限才能设置实时调度策略 */ if (sched_setscheduler(0, policy, &param) == -1) { perror("sched_setscheduler"); return -1; } return 0; } /* * 获取当前进程的调度信息 */ void show_scheduling_info(void) { int policy = sched_getscheduler(0); struct sched_param param; sched_getparam(0, &param); const char *policy_name; switch (policy) { case SCHED_FIFO: policy_name = "SCHED_FIFO"; break; case SCHED_RR: policy_name = "SCHED_RR"; break; case SCHED_OTHER: policy_name = "SCHED_OTHER"; break; case SCHED_BATCH: policy_name = "SCHED_BATCH"; break; case SCHED_IDLE: policy_name = "SCHED_IDLE"; break; default: policy_name = "UNKNOWN"; break; } printf("当前进程 PID=%d\n", getpid()); printf(" 调度策略: %s\n", policy_name); printf(" 实时优先级: %d\n", param.sched_priority); printf(" 优先级范围: %d ~ %d\n", sched_get_priority_min(policy), sched_get_priority_max(policy)); } int main(int argc, char *argv[]) { printf("=== SCHED_FIFO 实时进程示例 ===\n\n"); /* 显示当前调度信息 */ printf("[1] 原始调度信息:\n"); show_scheduling_info(); /* 尝试设置为SCHED_FIFO，优先级50 */ printf("\n[2] 尝试设置为 SCHED_FIFO，优先级50...\n"); if (set_realtime_scheduler(SCHED_FIFO, 50) == 0) { printf("设置成功！\n"); show_scheduling_info(); } else { printf("设置失败: %s\n", strerror(errno)); printf("提示: 请使用root权限运行或检查/etc/security/limits.conf配置\n"); } printf("\n[3] 实时进程运行测试（5秒）...\n"); for (int i = 0; i < 5; i++) { printf(" [%d] 我正在以SCHED_FIFO策略运行，优先级50\n", i + 1); sleep(1); } printf("\n测试完成。\n"); return 0; }

2.4 命令行操作SCHED_FIFO

# 使用chrt命令设置实时调度策略 # chrt -f [优先级] [命令] - 设置为SCHED_FIFO # chrt -r [优先级] [命令] - 设置为SCHED_RR # 示例：将以SCHED_FIFO策略运行top命令，优先级30 sudo chrt -f 30 top # 示例：查看进程实时调度信息 sudo chrt -p 1234 # 查看PID 1234的调度策略 # 示例：将以SCHED_RR策略运行采集程序，优先级40 sudo chrt -r 40 ./data_collection # 查看当前所有实时进程 ps -eo pid,rtprio,sched,cmd | grep -E "^[0-9]|RTPRIO" # 设置已有进程的调度策略 sudo chrt -f 50 -p 1234 # 将PID 1234设为SCHED_FIFO，优先级50

三、SCHED_RR 深度剖析

3.1 基本概念

SCHED_RR（Round Robin）与SCHED_FIFO非常相似，核心区别在于：同等优先级的进程会采用时间片轮转调度。

SCHED_RR的核心规则：

优先级抢占：与SCHED_FIFO相同，高优先级进程可以抢占低优先级进程
时间片轮转：同等优先级下，所有进程共享CPU时间片，轮流执行
时间片耗尽：进程时间片用完后，会被放到同优先级队列的末尾
优先级继承：支持优先级继承协议（用于解决优先级反转问题）

3.2 SCHED_RR的时间片

/* * SCHED_RR时间片查询 * 时间片大小与进程优先级相关 */ #include <stdio.h> #include <sched.h> #include <unistd.h> int main(void) { /* 在SCHED_RR下，时间片计算较为复杂 * 可以通过 /proc/sys/kernel/sched_rr_timeslice_ms 查看或设置 */ /* 读取系统配置的时间片 */ FILE *f = fopen("/proc/sys/kernel/sched_rr_timeslice_ms", "r"); if (f) { int timeslice_ms; fscanf(f, "%d", &timeslice_ms); printf("SCHED_RR 时间片大小: %d ms\n", timeslice_ms); fclose(f); } /* 查看系统调度相关配置 */ printf("\n系统调度配置:\n"); system("cat /proc/sys/kernel/sched_rt_runtime_us 2>/dev/null && echo ' (RT运行时限制)'"); system("cat /proc/sys/kernel/sched_rt_period_us 2>/dev/null && echo ' (RT周期)'"); system("cat /proc/sys/kernel/sched_latency_ns 2>/dev/null && echo ' (调度延迟)'"); system("cat /proc/sys/kernel/sched_min_granularity_ns 2>/dev/null && echo ' (最小时间粒度)'"); return 0; }

3.3 代码实战：SCHED_RR与SCHED_FIFO对比

/* * realtime_rr_test.c - SCHED_RR实时进程示例 * 对比SCHED_FIFO和SCHED_RR的行为差异 */ #define _GNU_SOURCE #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sched.h> #include <unistd.h> #include <pthread.h> #include <time.h> #include <errno.h> #define HIGH_PRIORITY 50 #define LOW_PRIORITY 30 /* * 线程参数结构体 * @param thread_id: 线程ID编号 * @param policy: 调度策略 * @param priority: 实时优先级 * @param runtime_us: 运行时间（微秒） */ typedef struct { int thread_id; int policy; int priority; long runtime_us; } thread_arg_t; pthread_barrier_t start_barrier; /* 函数声明 */ long get_timestamp_us(void); /* * 线程工作函数 */ void *thread_work(void *arg) { thread_arg_t *targ = (thread_arg_t *)arg; struct sched_param param; /* 设置线程调度策略和优先级 */ memset(&param, 0, sizeof(param)); param.sched_priority = targ->priority; if (pthread_setschedparam(pthread_self(), targ->policy, &param) != 0) { fprintf(stderr, "线程%d: 设置调度策略失败\n", targ->thread_id); return NULL; } printf("线程%d: 启动 (策略=%s, 优先级=%d)\n", targ->thread_id, targ->policy == SCHED_FIFO ? "SCHED_FIFO" : "SCHED_RR", targ->priority); /* 同步开始 */ pthread_barrier_wait(&start_barrier); /* 执行计算任务 */ volatile long counter = 0; long end_time = get_timestamp_us() + targ->runtime_us; while (get_timestamp_us() < end_time) { counter++; } printf("线程%d: 完成 (运行%ld us, counter=%ld)\n", targ->thread_id, targ->runtime_us, counter); return NULL; } /* * 获取当前时间戳（微秒） */ long get_timestamp_us(void) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return ts.tv_sec * 1000000 + ts.tv_nsec / 1000; } /* * 设置线程调度策略 */ int set_thread_realtime(pthread_t thread, int policy, int priority) { struct sched_param param; memset(&param, 0, sizeof(param)); param.sched_priority = priority; return pthread_setschedparam(thread, policy, &param); } int main(void) { printf("=== SCHED_FIFO vs SCHED_RR 对比测试 ===\n\n"); /* * 测试1：SCHED_FIFO - 同优先级按顺序执行 */ printf("【测试1】SCHED_FIFO同优先级测试\n"); printf("预期行为：线程按启动顺序串行执行\n\n"); pthread_t fifo_threads[3]; thread_arg_t fifo_args[3]; pthread_barrier_init(&start_barrier, NULL, 3); for (int i = 0; i < 3; i++) { fifo_args[i] = (thread_arg_t){ .thread_id = i + 1, .policy = SCHED_FIFO, .priority = HIGH_PRIORITY, .runtime_us = 1000000 /* 1秒 */ }; pthread_create(&fifo_threads[i], NULL, thread_work, &fifo_args[i]); } for (int i = 0; i < 3; i++) { pthread_join(fifo_threads[i], NULL); } pthread_barrier_destroy(&start_barrier); sleep(1); /* * 测试2：SCHED_RR - 同优先级时间片轮转 */ printf("\n【测试2】SCHED_RR同优先级测试\n"); printf("预期行为：线程按时间片轮转执行\n\n"); pthread_t rr_threads[3]; thread_arg_t rr_args[3]; pthread_barrier_init(&start_barrier, NULL, 3); for (int i = 0; i < 3; i++) { rr_args[i] = (thread_arg_t){ .thread_id = i + 10, .policy = SCHED_RR, .priority = HIGH_PRIORITY, .runtime_us = 1000000 /* 1秒 */ }; pthread_create(&rr_threads[i], NULL, thread_work, &rr_args[i]); } for (int i = 0; i < 3; i++) { pthread_join(rr_threads[i], NULL); } pthread_barrier_destroy(&start_barrier); printf("\n=== 测试完成 ===\n"); printf("结论：SCHED_FIFO会一直运行直到主动放弃，SCHED_RR会时间片轮转\n"); return 0; }

四、SCHED_FIFO与SCHED_RR的深度对比

4.1 核心差异一览

特性	SCHED_FIFO	SCHED_RR
调度策略	先入先出，无时间片	时间片轮转，有时间片
同等优先级	顺序执行，直到阻塞	轮流执行，时间片耗尽到队尾
时间片	无（一直运行）	有（默认100ms）
优先级继承	通过pthread mutex支持	通过pthread mutex支持
实时性	更高（无切换开销）	略低（有定时器中断）
适用场景	紧急/独占式任务	需要公平共享的任务

4.2 优先级反转问题与解决

/* * 优先级反转问题示意 * * 场景：低优先级进程(L)持有资源，高优先级进程(H)等待该资源， * 而中等优先级进程(M)运行导致低优先级进程无法释放资源 * * 时间线： * T1: L获得资源，开始执行 * T2: H就绪，抢占L，开始执行 * T3: H需要资源，但L持有，M就绪 * T4: M抢占L，导致L无法释放资源 * T5: H一直等待M执行完毕 * T6: L释放资源，H继续执行 * * 这个问题可能导致H的截止时间错过！ */ /* * 解决方案1：优先级继承（需要内核配置CONFIG_RT_GROUP_SCHED或使用Mutex） */ /* * 解决方案2：使用SCHED_RR替代（更好的优先级继承支持） */ /* * 解决方案3：使用Mutex并启用优先级继承属性 */ #include <pthread.h> pthread_mutex_t shared_mutex; pthread_mutexattr_t mutex_attr; /* 设置Mutex为优先级继承协议 */ pthread_mutexattr_init(&mutex_attr); pthread_mutexattr_setprotocol(&mutex_attr, PTHREAD_PRIO_INHERIT); pthread_mutex_init(&shared_mutex, &mutex_attr); /* * 推荐做法：使用实时安全的pthread mutex * #include <pthread.h> * pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; * pthread_mutexattr_t attr; * pthread_mutexattr_init(&attr); * pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_PROTECT); * pthread_mutexattr_setprioceiling(&attr, 50); */

五、嵌入式实时应用实战

5.1 典型嵌入式实时架构

/* * 嵌入式实时系统典型架构 * 以工业控制系统为例 */ /* * 系统架构设计 * * 实时任务分层： * - 硬件中断层（最高优先级） * - 紧急实时任务层（SCHED_FIFO, 优先级90-99） * - 普通实时任务层（SCHED_FIFO/SCHED_RR, 优先级50-89） * - 非实时任务层（SCHED_OTHER/SCHED_BATCH） */ /* * 紧急控制任务 - 使用SCHED_FIFO，最高优先级 */ void *emergency_control_task(void *arg) { /* 紧急控制任务：必须在确定时间内响应 */ struct sched_param param = {.sched_priority = 95}; pthread_setschedparam(pthread_self(), SCHED_FIFO, &param); while (1) { /* 读取急停按钮状态 */ if (read_emergency_stop()) { /* 立即触发急停 - 不能有任何延迟 */ emergency_stop(); } /* 最小延迟，避免CPU全占 */ usleep(100); /* 100微秒检查一次 */ } } /* * 运动控制任务 - 使用SCHED_FIFO，高优先级 */ void *motion_control_task(void *arg) { struct sched_param param = {.sched_priority = 85}; pthread_setschedparam(pthread_self(), SCHED_FIFO, &param); /* 1ms控制周期 */ struct timespec next_time; clock_gettime(CLOCK_MONOTONIC, &next_time); while (1) { /* 读取编码器位置 */ read_encoder(); /* 计算PID控制输出 */ compute_pid_control(); /* 发送PWM控制指令 */ set_pwm_output(); /* 计算下次唤醒时间（精确的1ms周期） */ next_time.tv_nsec += 1000000; /* 1ms = 1000000ns */ if (next_time.tv_nsec >= 1000000000) { next_time.tv_nsec -= 1000000000; next_time.tv_sec++; } clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next_time, NULL); } } /* * 数据采集任务 - 使用SCHED_RR，中等优先级 * 多个传感器采集任务可以公平共享CPU */ void *sensor_acquisition_task(void *arg) { int sensor_id = *(int *)arg; struct sched_param param = {.sched_priority = 60}; pthread_setschedparam(pthread_self(), SCHED_RR, &param); while (1) { /* 采集传感器数据 */ acquire_sensor_data(sensor_id); /* 存储数据 */ store_data(sensor_id); /* 10ms采集周期 */ usleep(10000); } }

5.2 实时系统配置脚本

#!/bin/bash # realtime_setup.sh - 嵌入式实时系统配置脚本 # 使用前请阅读并根据实际情况修改 set -e echo "=== 嵌入式Linux实时系统配置 ===" # 1. 检查并设置实时调度权限 echo "[1/6] 配置实时调度权限..." if [ -f /etc/security/limits.conf ]; then # 添加实时调度限制（需要root权限） # 这允许普通用户运行实时进程 cat >> /etc/security/limits.conf << 'EOF' # 实时调度配置 * - rtprio 99 * - nice -20 * - memlock unlimited EOF echo " 已配置 /etc/security/limits.conf" else echo " 警告: limits.conf不存在，跳过" fi # 2. 配置内核参数 echo "[2/6] 配置内核实时参数..." echo " # 实时调度相关内核参数 kernel.sched_rt_runtime_us = 950000 # RT进程每周期可运行时间（950ms） kernel.sched_rt_period_us = 1000000 # RT调度周期（1秒） kernel.sched_latency_ns = 10000000 # 调度延迟目标（10ms） kernel.sched_min_granularity_ns = 1000000 # 最小时间粒度（1ms） " >> /etc/sysctl.conf 2>/dev/null || true sysctl -w kernel.sched_rt_runtime_us=950000 2>/dev/null || true sysctl -w kernel.sched_rt_period_us=1000000 2>/dev/null || true # 3. 禁用不必要的系统服务 echo "[3/6] 优化系统服务..." systemctl stop unnecessary_service 2>/dev/null || true # 4. 设置CPU_affinity（可选，针对多核系统） echo "[4/6] 配置CPU亲和性..." if [ -f /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor ]; then for cpu in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor; do echo performance > $cpu 2>/dev/null || true done echo " 已将CPU频率策略设为performance" fi # 5. 锁定内存（防止换页） echo "[5/6] 锁定内存防止换页..." mlockall() { python3 -c " import ctypes libc = ctypes.CDLL('libc.so.6', use_errno=True) MCL_CURRENT = 1 MCL_FUTURE = 2 MCL_ONFAULT = 4 result = libc.mlockall(MCL_CURRENT | MCL_FUTURE) if result != 0: import os print(f' 警告: mlockall失败 ({os.strerror(ctypes.get_errno())})') " } mlockall # 6. 运行测试 echo "[6/6] 运行延迟测试..." if command -v cyclictest &> /dev/null; then # 使用cyclictest测试调度延迟 sudo cyclictest -p 90 -t 5 -n -q -l 1000 else echo " 提示: cyclictest未安装，请手动测试调度延迟" fi echo "" echo "=== 配置完成 ===" echo "请重新登录以使limits.conf生效"

5.3 实时性测试工具

/* * latency_test.c - 简单的调度延迟测试工具 * 用于测量进程调度延迟 */ #define _GNU_SOURCE #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sched.h> #include <sys/time.h> #include <time.h> #include <math.h> #define TEST_DURATION_SEC 10 #define PERIOD_US 1000 /* 1ms周期 */ #define NUM_SAMPLES (TEST_DURATION_SEC * 1000) typedef struct { long min_latency_ns; long max_latency_ns; long avg_latency_ns; long stddev_latency_ns; long samples[NUM_SAMPLES]; int sample_count; } latency_stats_t; /* * 测量调度延迟 * @return: 实际睡眠时间与期望睡眠时间的差值（纳秒） */ long measure_latency(struct timespec *next_time) { struct timespec before, after; clock_gettime(CLOCK_MONOTONIC, &before); /* 执行短暂的忙等待 */ volatile int dummy = 0; for (int i = 0; i < 100; i++) dummy++; clock_gettime(CLOCK_MONOTONIC, &after); /* 计算实际睡眠时间 */ long actual_ns = (after.tv_sec - before.tv_sec) * 1000000000L + (after.tv_nsec - before.tv_nsec); /* 计算期望睡眠时间（1000us = 1000000ns） */ long expected_ns = PERIOD_US * 1000; /* 延迟 = 实际 - 期望（负值表示提前，正值表示延迟） */ return actual_ns - expected_ns; } /* * 计算统计数据 */ void calculate_stats(latency_stats_t *stats) { long sum = 0; long sum_sq = 0; stats->min_latency_ns = stats->samples[0]; stats->max_latency_ns = stats->samples[0]; for (int i = 0; i < stats->sample_count; i++) { long val = stats->samples[i]; sum += val; sum_sq += val * val; if (val < stats->min_latency_ns) stats->min_latency_ns = val; if (val > stats->max_latency_ns) stats->max_latency_ns = val; } stats->avg_latency_ns = sum / stats->sample_count; /* 计算标准差 */ double mean = (double)sum / stats->sample_count; double variance = (double)sum_sq / stats->sample_count - mean * mean; stats->stddev_latency_ns = (long)sqrt(variance); } /* * 打印统计结果 */ void print_stats(const latency_stats_t *stats) { printf("\n调度延迟统计（%d个样本）:\n", stats->sample_count); printf(" 最小延迟: %8.3f ms\n", stats->min_latency_ns / 1000000.0); printf(" 最大延迟: %8.3f ms\n", stats->max_latency_ns / 1000000.0); printf(" 平均延迟: %8.3f ms\n", stats->avg_latency_ns / 1000000.0); printf(" 标准差: %8.3f ms\n", stats->stddev_latency_ns / 1000000.0); printf("\n延迟分布直方图（单位：ms）:\n"); /* 简单的直方图 */ int bins[10] = {0}; double bin_size = (stats->max_latency_ns - stats->min_latency_ns) / 10.0; for (int i = 0; i < stats->sample_count; i++) { int bin = (int)((stats->samples[i] - stats->min_latency_ns) / bin_size); if (bin >= 10) bin = 9; if (bin < 0) bin = 0; bins[bin]++; } for (int i = 0; i < 10; i++) { double start = stats->min_latency_ns / 1000000.0 + i * bin_size / 1000000.0; double end = start + bin_size / 1000000.0; printf(" [%5.2f~%5.2f] ms: ", start, end); int bar_len = bins[i] * 50 / stats->sample_count; for (int j = 0; j < bar_len; j++) printf("*"); printf(" %d\n", bins[i]); } } int main(int argc, char *argv[]) { printf("=== Linux调度延迟测试工具 ===\n"); printf("测试参数: 周期=%d us, 持续时间=%d秒\n", PERIOD_US, TEST_DURATION_SEC); /* 解析命令行参数 */ int priority = 90; int policy = SCHED_FIFO; int opt; while ((opt = getopt(argc, argv, "p:r:")) != -1) { switch (opt) { case 'p': priority = atoi(optarg); break; case 'r': if (strcmp(optarg, "FIFO") == 0) policy = SCHED_FIFO; else if (strcmp(optarg, "RR") == 0) policy = SCHED_RR; else { fprintf(stderr, "未知策略: %s (使用FIFO)\n", optarg); } break; default: fprintf(stderr, "用法: %s [-p 优先级] [-r FIFO|RR]\n", argv[0]); return 1; } } /* 设置实时调度 */ struct sched_param param = {.sched_priority = priority}; if (sched_setscheduler(0, policy, &param) == -1) { perror("sched_setscheduler"); printf("提示: 请使用sudo运行或配置实时调度权限\n"); return 1; } printf("调度策略: %s, 优先级: %d\n", policy == SCHED_FIFO ? "SCHED_FIFO" : "SCHED_RR", priority); /* 初始化统计结构 */ latency_stats_t stats = { .min_latency_ns = 0, .max_latency_ns = 0, .avg_latency_ns = 0, .stddev_latency_ns = 0, .sample_count = 0 }; /* 设置初始唤醒时间 */ struct timespec next_time; clock_gettime(CLOCK_MONOTONIC, &next_time); printf("\n开始测试...\n"); /* 主循环：周期性测量延迟 */ for (int i = 0; i < NUM_SAMPLES && stats.sample_count < NUM_SAMPLES; i++) { /* 计算下次唤醒时间 */ next_time.tv_nsec += PERIOD_US * 1000; if (next_time.tv_nsec >= 1000000000) { next_time.tv_nsec -= 1000000000; next_time.tv_sec++; } /* 睡眠到下次唤醒时间 */ clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next_time, NULL); /* 测量延迟 */ long latency = measure_latency(&next_time); if (stats.sample_count < NUM_SAMPLES) { stats.samples[stats.sample_count++] = latency; } /* 定期输出进度 */ if ((i + 1) % 1000 == 0) { printf(" 进度: %d/%d (%.1f%%)\n", i + 1, NUM_SAMPLES, (i + 1) * 100.0 / NUM_SAMPLES); } } /* 计算并显示统计结果 */ calculate_stats(&stats); print_stats(&stats); printf("\n测试完成。\n"); return 0; }

六、SCHED_FIFO/SCHED_RR使用注意事项

6.1 常见陷阱与解决方案

/* * 实时调度使用中的常见问题 */ /* 问题1：优先级设置不当导致饥饿 */ void starvation_problem(void) { /* * 陷阱：一个高优先级进程永不阻塞，会导致低优先级进程永远得不到CPU * * 错误示例： * while(1) { do_something(); } // 永不阻塞！ * * 解决方案：定期调用sched_yield()让出CPU */ while (1) { do_realtime_work(); sched_yield(); // 让出CPU给同优先级其他进程 } } /* 问题2：忘记设置优先级继承导致优先级反转 */ void priority_inversion_problem(void) { /* * 问题：多个进程竞争同一个资源时，低优先级进程持有资源 * 可能被中等优先级进程阻塞，导致高优先级进程等待 * * 解决方案：使用优先级继承的Mutex */ pthread_mutex_t mutex; pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT); pthread_mutex_init(&mutex, &attr); } /* 问题3：在多核系统上实时性能反而变差 */ void smp_affinity_problem(void) { /* * 问题：实时任务在多核间迁移导致缓存失效 * * 解决方案：使用CPU亲和性绑定 */ cpu_set_t cpuset; CPU_ZERO(&cpuset); CPU_SET(0, &cpuset); /* 绑定到CPU0 */ pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset); } /* 问题4：实时进程占用太多CPU时间 */ void cpu_overrun_problem(void) { /* * 问题：实时进程占满CPU，导致系统无法处理其他事务 * * 解决方案：使用cgroup限制实时进程的CPU使用 * 或设置sched_rt_runtime_us限制 */ /* * 检查当前RT runtime配置 * cat /proc/sys/kernel/sched_rt_runtime_us * 默认通常是950000（95%），表示每1000ms周期内 * RT进程最多运行950ms */ }

6.2 安全最佳实践

# 1. 使用cgroup限制实时进程资源 # /sys/fs/cgroup/cpu/rt_processes/cpu.rt_runtime_us # 2. 配置/etc/security/limits.conf限制普通用户的实时优先级 # * - rtprio 50 # 限制普通用户最高实时优先级为50 # 3. 使用watchdog监控实时任务 # 确保实时任务没有死锁或无限循环 # 4. 分离RT和非RT任务的CPU核心 # 将RT任务绑定到特定CPU核心，避免干扰系统服务

七、实时调度进阶话题

7.1 SCHED_DEADLINE简介

/* * SCHED_DEADLINE - 最强的实时调度策略 * 基于Earliest Deadline First (EDF)算法 * * 需要内核配置 CONFIG_SCHED_DEADLINE */ /* * 设置SCHED_DEADLINE调度 * @param runtime: 每次运行需要的CPU时间 * @param deadline: 必须在此时间内完成 * @param period: 任务周期 * * 示例：每10ms需要运行2ms的任务 * sched_setattr(0, { * .size = sizeof(struct sched_attr), * .sched_policy = SCHED_DEADLINE, * .sched_runtime = 2 * 1000 * 1000, // 2ms * .sched_deadline = 10 * 1000 * 1000, // 10ms * .sched_period = 10 * 1000 * 1000, // 10ms * }, 0); */ /* * SCHED_DEADLINE特性： * - 真正满足硬实时需求（有理论保证） * - 自动拒绝无法满足截止时间的任务 * - 适合周期性实时任务 */

7.2 实时内核配置

# 编译实时Linux内核（PREEMPT_RT）的主要配置选项 # # CONFIG_PREEMPT=y # 基础抢占支持 # CONFIG_PREEMPT_VOLUNTARY=y # 自愿抢占（不太实时） # CONFIG_PREEMPT_DYNAMIC=y # 动态抢占（需要模块） # # CONFIG_PREEMPT_RT=y # 完全实时抢占（PREEMPT_RT补丁） # # CONFIG_HZ=1000 # 提高时钟中断频率，减少调度延迟 # CONFIG_NO_HZ=y # 动态空时钟 # CONFIG_HIGH_RES_TIMERS=y # 高分辨率定时器 # # CONFIG_IRQ_TIME_ACCOUNTING=n # 禁用IRQ时间统计（减少开销）

总结

今天我们深入探索了Linux实时调度的两大核心武器——SCHED_FIFO和SCHED_RR。让我们来回顾一下关键知识点：

调度策略	核心特点	最佳使用场景
SCHED_FIFO	无时间片，高优先级独占	紧急处理任务、独占式处理
SCHED_RR	有时间片，轮转执行	需要公平共享CPU的多个任务
SCHED_DEADLINE	EDF算法，满足截止时间保证	硬实时周期性任务

在实际嵌入式系统中，合理运用这些实时调度策略，能够让你的系统获得毫秒级甚至微秒级的确定响应。但请记住：实时不等于快，真正的实时是确定性和可预测性。