69天探索操作系统-第69天：高级进程调度：实时和基于优先级的任务管理技术

1. 介绍

高级进程调度，尤其是实时调度，对于现代操作系统至关重要。本文探讨了进程调度机制的复杂实现，重点关注实时约束、优先级管理和高效任务排队。实时调度确保具有严格截止日期的任务能够及时执行，这对于机器人、汽车系统和多媒体处理等时间敏感型应用至关重要。

2. 调度器架构

调度器架构基于基于优先级的队列 、实时约束 和负载均衡构建。基于优先级的队列确保高优先级任务首先执行，而实时约束保证任务按时限完成。负载均衡将任务分配到各个CPU上，以优化性能和资源利用率。系统支持实时任务和普通任务，并具有抢占和缓存亲和性机制。

核心组件包括：

基于优先级的队列管理：针对不同优先级级别的复杂队列管理。该实现支持实时任务和普通任务调度，并具备适当的抢占机制。
实时约束：处理基于截止时间的调度和保证执行时间的机制。系统实现了最早截止时间优先（EDF）和速率单调调度（RMS）。
负载均衡：在多个CPU之间进行高级负载分配，同时考虑缓存亲和力和电源效率。

c 复制代码

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/sched/rt.h>
#include <linux/cpumask.h>
#include <linux/slab.h>
#include <linux/rbtree.h>
#include <linux/list.h>

#define MAX_PRIO_LEVELS 140
#define RT_PRIO_BASE 100
#define DEFAULT_TIMESLICE (100 * HZ / 1000)  // 100ms

struct rt_task_data {
    struct task_struct *task;
    unsigned long deadline;
    unsigned long period;
    unsigned long execution_time;
    int priority;
    struct rb_node node;
    struct list_head list;
};

struct rt_rq {
    struct rb_root_cached tasks_timeline;
    struct list_head *priority_queues;
    unsigned int nr_running;
    raw_spinlock_t lock;
    struct cpumask cpus_allowed;
    unsigned long total_runtime;
};

struct scheduler_stats {
    atomic64_t schedule_count;
    atomic64_t preemptions;
    atomic64_t migrations;
    struct {
        atomic_t count;
        atomic64_t total_runtime;
    } priority_levels[MAX_PRIO_LEVELS];
};

static struct rt_rq *rt_rq_array;
static struct scheduler_stats stats;

static int init_rt_scheduler(void)
{
    int cpu;
    
    rt_rq_array = kmalloc_array(num_possible_cpus(),
                               sizeof(struct rt_rq),
                               GFP_KERNEL);
    if (!rt_rq_array)
        return -ENOMEM;
        
    for_each_possible_cpu(cpu) {
        struct rt_rq *rt_rq = &rt_rq_array[cpu];
        int i;
        
        rt_rq->tasks_timeline = RB_ROOT_CACHED;
        rt_rq->priority_queues = kmalloc_array(MAX_PRIO_LEVELS,
                                              sizeof(struct list_head),
                                              GFP_KERNEL);
        if (!rt_rq->priority_queues)
            goto cleanup;
            
        for (i = 0; i < MAX_PRIO_LEVELS; i++)
            INIT_LIST_HEAD(&rt_rq->priority_queues[i]);
            
        raw_spin_lock_init(&rt_rq->lock);
        rt_rq->nr_running = 0;
        cpumask_clear(&rt_rq->cpus_allowed);
        rt_rq->total_runtime = 0;
    }
    
    return 0;

cleanup:
    while (--cpu >= 0)
        kfree(rt_rq_array[cpu].priority_queues);
    kfree(rt_rq_array);
    return -ENOMEM;
}

3. 优先级管理

优先级管理对于确保高优先级任务在低优先级任务之前执行至关重要。调度器使用多级优先队列 ，任务按优先级分组。实时任务被分配更高的优先级，确保它们在普通任务之前被调度。系统还支持动态优先级调整，允许根据任务行为或系统负载更新优先级。

4. 任务队列

任务队列实现使用红黑树 和链表进行高效的任务管理。红黑树用于根据任务的截止日期管理任务，而链表用于处理同一优先级内的任务。这种组合确保即使在高负载下也能快速插入、删除和检索任务。系统还支持抢占，允许高优先级任务中断低优先级任务。

5. 实时调度

实时调度确保任务按时完成。调度器实现了最早截止时间优先（EDF） 和速率单调调度（RMS） 算法。EDF首先调度截止时间最早的作业，而RMS则根据作业周期分配优先级。这些算法结合了抢占和上下文切换，以确保实时任务的及时执行。

c 复制代码

static struct rt_task_data *create_rt_task(struct task_struct *task,
                                         unsigned long deadline,
                                         unsigned long period)
{
    struct rt_task_data *rt_task;
    
    rt_task = kmalloc(sizeof(*rt_task), GFP_KERNEL);
    if (!rt_task)
        return NULL;
        
    rt_task->task = task;
    rt_task->deadline = deadline;
    rt_task->period = period;
    rt_task->execution_time = 0;
    rt_task->priority = task->prio;
    RB_CLEAR_NODE(&rt_task->node);
    INIT_LIST_HEAD(&rt_task->list);
    
    return rt_task;
}

static void insert_rt_task(struct rt_rq *rt_rq,
                          struct rt_task_data *rt_task)
{
    struct rb_node **link = &rt_rq->tasks_timeline.rb_root.rb_node;
    struct rb_node *parent = NULL;
    struct rt_task_data *entry;
    unsigned long flags;
    
    raw_spin_lock_irqsave(&rt_rq->lock, flags);
    
    while (*link) {
        parent = *link;
        entry = rb_entry(parent, struct rt_task_data, node);
        
        if (rt_task->deadline < entry->deadline)
            link = &parent->rb_left;
        else
            link = &parent->rb_right;
    }
    
    rb_link_node(&rt_task->node, parent, link);
    rb_insert_color(&rt_task->node, &rt_rq->tasks_timeline.rb_root);
    list_add(&rt_task->list, &rt_rq->priority_queues[rt_task->priority]);
    rt_rq->nr_running++;
    
    raw_spin_unlock_irqrestore(&rt_rq->lock, flags);
}

6. 实施

实现开始于定义rt_task_data结构，该结构表示实时任务。该结构包括任务的截止时间、周期、执行时间和优先级。rt_rq结构管理实时任务的运行队列，使用红黑树和优先队列。init_rt_scheduler函数初始化调度器，为运行队列分配内存并设置数据结构。

c 复制代码

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/sched/rt.h>
#include <linux/cpumask.h>
#include <linux/slab.h>
#include <linux/rbtree.h>
#include <linux/list.h>

#define MAX_PRIO_LEVELS 140
#define RT_PRIO_BASE 100
#define DEFAULT_TIMESLICE (100 * HZ / 1000)  // 100ms

struct rt_task_data {
    struct task_struct *task;
    unsigned long deadline;
    unsigned long period;
    unsigned long execution_time;
    int priority;
    struct rb_node node;
    struct list_head list;
};

struct rt_rq {
    struct rb_root_cached tasks_timeline;
    struct list_head *priority_queues;
    unsigned int nr_running;
    raw_spinlock_t lock;
    struct cpumask cpus_allowed;
    unsigned long total_runtime;
};

struct scheduler_stats {
    atomic64_t schedule_count;
    atomic64_t preemptions;
    atomic64_t migrations;
    struct {
        atomic_t count;
        atomic64_t total_runtime;
    } priority_levels[MAX_PRIO_LEVELS];
};

static struct rt_rq *rt_rq_array;
static struct scheduler_stats stats;

static int init_rt_scheduler(void)
{
    int cpu;
    
    rt_rq_array = kmalloc_array(num_possible_cpus(),
                               sizeof(struct rt_rq),
                               GFP_KERNEL);
    if (!rt_rq_array)
        return -ENOMEM;
        
    for_each_possible_cpu(cpu) {
        struct rt_rq *rt_rq = &rt_rq_array[cpu];
        int i;
        
        rt_rq->tasks_timeline = RB_ROOT_CACHED;
        rt_rq->priority_queues = kmalloc_array(MAX_PRIO_LEVELS,
                                              sizeof(struct list_head),
                                              GFP_KERNEL);
        if (!rt_rq->priority_queues)
            goto cleanup;
            
        for (i = 0; i < MAX_PRIO_LEVELS; i++)
            INIT_LIST_HEAD(&rt_rq->priority_queues[i]);
            
        raw_spin_lock_init(&rt_rq->lock);
        rt_rq->nr_running = 0;
        cpumask_clear(&rt_rq->cpus_allowed);
        rt_rq->total_runtime = 0;
    }
    
    return 0;

cleanup:
    while (--cpu >= 0)
        kfree(rt_rq_array[cpu].priority_queues);
    kfree(rt_rq_array);
    return -ENOMEM;
}

7. 负载均衡

负载均衡确保任务在CPU之间均匀分布。调度器使用工作窃取算法 ，其中空闲的CPU从忙碌的CPU窃取任务。load_balance_rt函数根据负载和优先级在CPU之间迁移任务。这种方法最小化了CPU的空闲时间，并确保了资源的有效利用。

c 复制代码

struct load_balance_info {
    int src_cpu;
    int dst_cpu;
    unsigned long imbalance;
    struct cpumask *cpus;
};

static int load_balance_rt(struct rt_rq *src_rq,
                          struct rt_rq *dst_rq,
                          struct load_balance_info *info)
{
    struct rt_task_data *rt_task, *tmp;
    unsigned long flags;
    int migrated = 0;
    
    if (!spin_trylock_irqsave(&src_rq->lock, flags))
        return 0;
        
    list_for_each_entry_safe(rt_task, tmp,
                            &src_rq->priority_queues[rt_task->priority],
                            list) {
        if (migrated >= info->imbalance)
            break;
            
        if (can_migrate_task(rt_task->task, info->dst_cpu)) {
            deactivate_task(src_rq, rt_task);
            set_task_cpu(rt_task->task, info->dst_cpu);
            activate_task(dst_rq, rt_task);
            migrated++;
        }
    }
    
    spin_unlock_irqrestore(&src_rq->lock, flags);
    return migrated;
}

8. 性能优化

性能优化侧重于最小化上下文切换 和缓存未命中 。调度器使用缓存亲和性 将任务保持在同一CPU上，减少缓存重新加载的开销。它还实现了批处理调度 ，在单个上下文切换中安排多个任务。update_curr_rt函数跟踪任务执行时间，确保准确的调度决策。

c 复制代码

static void update_curr_rt(struct rt_rq *rt_rq)
{
    struct task_struct *curr = current;
    struct rt_task_data *rt_task;
    u64 delta_exec;
    unsigned long flags;
    
    if (!curr || !rt_task_running(curr))
        return;
        
    delta_exec = rq_clock_task(rq_of(curr)) - curr->se.exec_start;
    
    raw_spin_lock_irqsave(&rt_rq->lock, flags);
    rt_task = curr->rt_task_data;
    if (rt_task) {
        rt_task->execution_time += delta_exec;
        rt_rq->total_runtime += delta_exec;
    }
    raw_spin_unlock_irqrestore(&rt_rq->lock, flags);
}

9. 监控与分析

调度器包括一个监控系统 ，用于跟踪性能指标，如截止时间错过 、抢占和迁移。rt_metrics结构存储这些指标，这些指标在任务执行期间更新。这些数据用于分析调度器性能并识别瓶颈。

c 复制代码

struct rt_metrics {
    atomic64_t deadline_misses;
    atomic64_t preemptions;
    atomic64_t migrations;
    struct {
        atomic_t running;
        atomic64_t total_runtime;
        atomic_t deadline_misses;
    } priority_stats[MAX_PRIO_LEVELS];
};

static struct rt_metrics metrics;

static void update_rt_metrics(struct rt_task_data *rt_task,
                            unsigned long runtime)
{
    if (runtime > rt_task->deadline)
        atomic64_inc(&metrics.deadline_misses);
        
    atomic64_add(runtime,
                &metrics.priority_stats[rt_task->priority].total_runtime);
}

10. 结论

高级进程调度需要仔细考虑实时约束、优先级管理和负载平衡。提供的实现展示了构建适用于现代操作系统的健壮调度系统的实用方法。