实时调度类及SMP

2023-12-04 08:31:46

实时调度类源码分析

Linux 实时进程与普通进程的根本不同之处，系统中有一个实时进程且可运行，调度器总是会选择它，除非另有一个优先级更高的实时进程。
SCHED_FIFO：没有时间片，在调度器被选择之后，可以运行任意长时间；
SCHED_RR：有时间片，其值在进程运行时会减少。

实时调度实体sched_rt_entity数据结构及操作

进程的插入、选择、删除三种基本操作。

//实体
struct sched_rt_entity {
	struct list_head run_list;
	unsigned long timeout; // watchdog计数器 主要用于判断当前进程时间是否超过RLIMIT_RTIME
	unsigned long watchdog_stamp;
	unsigned int time_slice; // 针对RR调度策略的调度时隙

	struct sched_rt_entity *back; // dequeue_rt_stack() 中作为临时变量 
#ifdef CONFIG_RT_GROUP_SCHED
	struct sched_rt_entity	*parent;  // 指向上层调度实体 
	/* rq on which this entity is (to be) queued: */
	struct rt_rq		*rt_rq;  //当前实时调度实体所在的就绪队列 
	/* rq "owned" by this entity/group: */
	struct rt_rq		*my_q; //当前实时调度实体的子调度实体所在的就绪队列 
#endif
};
//类
const struct sched_class rt_sched_class = {
	.next			= &fair_sched_class, 
	.enqueue_task		= enqueue_task_rt,  //将一个task放入到就绪队列头部或者尾部
	.dequeue_task		= dequeue_task_rt,  // 将一个task从就绪队列末尾删除
	.yield_task		= yield_task_rt,  //主动放弃执行 

	.check_preempt_curr	= check_preempt_curr_rt,

	.pick_next_task		= pick_next_task_rt, // 核心调度器 选择就绪队列的某个任务将被调度 
	.put_prev_task		= put_prev_task_rt,  // 当一个任务将要被调度的时候执行 

#ifdef CONFIG_SMP
	.select_task_rq		= select_task_rq_rt, //核心调度器给任务选定CPU 将任务分发到不同的CPU上执行 

	.set_cpus_allowed       = set_cpus_allowed_common,
	.rq_online              = rq_online_rt,
	.rq_offline             = rq_offline_rt,
	.task_woken		= task_woken_rt,
	.switched_from		= switched_from_rt,
#endif

	.set_curr_task          = set_curr_task_rt,  // 当任务修改其调度类或修改其它任务组时，将调用这个函数 
	.task_tick		= task_tick_rt,  // 当时钟中断触发时将被调用，主要更新新进程运行统计信息及是否需要调度 

	.get_rr_interval	= get_rr_interval_rt,

	.prio_changed		= prio_changed_rt,
	.switched_to		= switched_to_rt,

	.update_curr		= update_curr_rt,
};
//进程插入操作
/*
 * Adding/removing a task to/from a priority array:
 */
// 更新调度信息，将调度实体插入到对应优先级队列末尾
static void
enqueue_task_rt(struct rq *rq, struct task_struct *p, int flags)
{
	struct sched_rt_entity *rt_se = &p->rt;

	if (flags & ENQUEUE_WAKEUP)
		rt_se->timeout = 0;
        // 实际工作 
        // 将当前实时调度实体添加到对应优先级链表上面，添加到头部还是尾部取决于flags是否包含ENQUEUE_HEAD来判断
	enqueue_rt_entity(rt_se, flags & ENQUEUE_HEAD);

	if (!task_current(rq, p) && p->nr_cpus_allowed > 1)
		enqueue_pushable_task(rq, p); //添加到hash表中 
}
// 进程选择操作
// 实时调度会选择最高优先级的实时进程来运行。
static struct task_struct *_pick_next_task_rt(struct rq *rq)
{
	struct sched_rt_entity *rt_se;
	struct task_struct *p;
	struct rt_rq *rt_rq  = &rq->rt;

	do {  //遍历组调度中的每一个进程 
		rt_se = pick_next_rt_entity(rq, rt_rq);
		BUG_ON(!rt_se);
		rt_rq = group_rt_rq(rt_se);
	} while (rt_rq);

	p = rt_task_of(rt_se);
	// 更新执行域
	p->se.exec_start = rq_clock_task(rq);

	return p;
}
static struct sched_rt_entity *pick_next_rt_entity(struct rq *rq,
						   struct rt_rq *rt_rq)
{
	struct rt_prio_array *array = &rt_rq->active;
	struct sched_rt_entity *next = NULL;
	struct list_head *queue;
	int idx;
	// 找到一个可用实体 
	idx = sched_find_first_bit(array->bitmap);
	BUG_ON(idx >= MAX_RT_PRIO);
	// 从链表组中找到对应的链表 
	queue = array->queue + idx;
	next = list_entry(queue->next, struct sched_rt_entity, run_list);
	// 返回找到运行实体
	return next;
}
// 进程删除操作
// 从优先级队列中删除实时进程，并更新调度信息，然后把这个进程添加到队尾。
static void dequeue_task_rt(struct rq *rq, struct task_struct *p, int flags)
{
	struct sched_rt_entity *rt_se = &p->rt;
	// 更新调度数据信息
	update_curr_rt(rq);
	// 实际工作，将rt_se从运行队列中删除，然后添加到队尾
	dequeue_rt_entity(rt_se);
	// 从hash表中删除
	dequeue_pushable_task(rq, p);
}
/*
 * Update the current task's runtime statistics. Skip current tasks that
 * are not in our scheduling class.
 */
static void update_curr_rt(struct rq *rq)
{
	struct task_struct *curr = rq->curr;
	struct sched_rt_entity *rt_se = &curr->rt;
	u64 delta_exec;
	// 判断是否有实时调度进程 
	if (curr->sched_class != &rt_sched_class)
		return;
	// 执行时间 
	delta_exec = rq_clock_task(rq) - curr->se.exec_start;
	if (unlikely((s64)delta_exec <= 0))
		return;

	schedstat_set(curr->se.statistics.exec_max,
		      max(curr->se.statistics.exec_max, delta_exec));
	// 更新当前进程总执行时间
	curr->se.sum_exec_runtime += delta_exec;
	account_group_exec_runtime(curr, delta_exec);
	// 更新执行的开始时间
	curr->se.exec_start = rq_clock_task(rq);
	cpuacct_charge(curr, delta_exec);

	sched_rt_avg_update(rq, delta_exec);

	if (!rt_bandwidth_enabled())
		return;

	for_each_sched_rt_entity(rt_se) {
		struct rt_rq *rt_rq = rt_rq_of_se(rt_se);

		if (sched_rt_runtime(rt_rq) != RUNTIME_INF) {
			raw_spin_lock(&rt_rq->rt_runtime_lock);
			rt_rq->rt_time += delta_exec;
			if (sched_rt_runtime_exceeded(rt_rq))
				resched_curr(rq);
			raw_spin_unlock(&rt_rq->rt_runtime_lock);
		}
	}
}
static void dequeue_rt_entity(struct sched_rt_entity *rt_se)
{
	struct rq *rq = rq_of_rt_se(rt_se);

	dequeue_rt_stack(rt_se); // 从运行队列中删除

	for_each_sched_rt_entity(rt_se) {
		struct rt_rq *rt_rq = group_rt_rq(rt_se);

		if (rt_rq && rt_rq->rt_nr_running)
			__enqueue_rt_entity(rt_se, false);
	}
	enqueue_top_rt_rq(&rq->rt);
}

对称多处理器SMP

多处理器系统的工作方式分为非对称多处理（asym-metrical mulit-processing）和对称多处理（symmetrical mulit-processing，SMP）两种。
在对称多处理器系统中，所有处理器的地位都是相同的，所有的资源，特别是存储器、中断及I/O空间，都具有相同的可访问性，消除结构上的障碍。
多处理器系统上，内核必须考虑几个额外的问题，以确保良好的调度。

CPU负荷必须尽可能公平地在所有的处理器上共享。
进程与系统中某些处理器的亲合性（affinity）必须是可设置的。
内核必须能够将进程从一个CPU迁移到另一个。
linux SMP调度就是将进程安排/迁移到合适的CPU中去，保持各CPU负载均衡的过程。

SMP优点

增加吞吐时的一种划算方法；
由于操作系统由所有处理器共享，它们提供了一个单独的系统映像（容易管理）；
对一个单独的问题应用多处理器（并行编程）；
负载均衡由操作系统实现；
单处理器(UP)编程模型可用于一个SMP中；
对于共享数据来说，可伸缩；
所有数据可由所有处理器寻址，并且由硬件监视逻辑保持连续性；
由于通信经由全局共享内存执行，在处理器之间通信不必使用消息传送库；

SMP局限性

由于告诉缓存相关性、锁定机制、共享对象和其它问题，可伸缩性受限制；
需要新技术来利用多处理器，例如：线程编程和设备驱动程序编程等。

CPU域初始化

Linux内核中有一个数据结构struct sched_domain_topology_level用来描述CPU的层次关系。
内核对CPU的管理是通过bitmap来管理，并且定义possible、present、online、active这4种状态。

struct sched_domain_topology_level {
	sched_domain_mask_f mask;  //函数指针 用于指定某个SDTL层级的cpumask位置
	sched_domain_flags_f sd_flags; //函数指针  用于指定某个SDTL层级的标志位
	int		    flags;
	int		    numa_level;
	struct sd_data      data;
#ifdef CONFIG_SCHED_DEBUG
	char                *name;
#endif
};
// 表示系统中有多少个可以运行的CPU核心
const struct cpumask *const cpu_possible_mask = to_cpumask(cpu_possible_bits);
EXPORT_SYMBOL(cpu_possible_mask);
// 表示系统中有多少个正处于运行状态的CPU核心
static DECLARE_BITMAP(cpu_online_bits, CONFIG_NR_CPUS) __read_mostly;
const struct cpumask *const cpu_online_mask = to_cpumask(cpu_online_bits);
EXPORT_SYMBOL(cpu_online_mask);
// 表示系统中有多少个具备online条件的CPU核心，它们不一定都处于online状态，有的CPU核心可能被热插拔。
static DECLARE_BITMAP(cpu_present_bits, CONFIG_NR_CPUS) __read_mostly;
const struct cpumask *const cpu_present_mask = to_cpumask(cpu_present_bits);
EXPORT_SYMBOL(cpu_present_mask);
//表示系统中有多少个活跃的CPU核心
static DECLARE_BITMAP(cpu_active_bits, CONFIG_NR_CPUS) __read_mostly;
const struct cpumask *const cpu_active_mask = to_cpumask(cpu_active_bits);
EXPORT_SYMBOL(cpu_active_mask);
//以上4个变量都是bitmap类型变量。

SMP负载均衡

SMP负载均衡机制从注册软中断开始，每次系统处理调度tick时会检查当前是否需要处理SMP负载均衡。

负载均衡时机

周期性调用进程调度程序scheduler_tick()->trigger_load_balance()中，通过软中断触发负载均衡。
某个CPU上无可运行进程，__schedule()准备调度idle进程前，会尝试从其它CPU上拉一批进程过来。

两路4核8核心CPU，CPU调度域逻辑关系

分层角度分析

所有CPU一共分成撒个层次：SMT、MC、NUMA，每层都包含所有CPU，但是划分粒度不同。根据Cache和内存的相关性划分调度域，调度域内的CPU又划分一次调度组。越往下层调度域越小，越往上层调度域越大。进程负载均衡会尽可以在底层调度域内部解决，这样Cache利用率最优。
周期性负载均衡：CPU对应的运行队列数据结构记录下一次周期性负载均衡时间，当超过这个时间点后，将触发SCHED_SOFIRQ软中断来进行负载均衡。
用到SMP负载均衡模型的时机
内核运行中，还有部分情况需要用掉SMP负载均衡模型来确定最佳运行CPU：

进程A唤醒进程B时，try_to_wake_up()中会考虑进程B将在哪个CPU上运行；
进程调用execve()系统调用时；
fork出子进程，子进程第一次被调度运行。

Linux运行时调优：

Linux引入重要sysctls来在运行时对调度程序进行调优（单位ns）
sched_child_runs_first: child在fork之后进行调度，为默认设备。如果设置为0，则先调度parent。
sched_min_granularity_ns:针对CPU密集型任务执行最低级别抢占粒度。
sched_latency_ns:针对CPU密集型任务进行目标抢占延迟。
sched_stat_granularity_ns:收集调度程序统计信息的粒度。

总结

本文主要介绍了实时调度类源码分析，包括实时调度数据结构及其相关操作（插入、选择、删除等）；SMP的优缺点，负载均衡机制，CPU分层角度分析，linux运行时调优等相关参数介绍等。

技术参考

https://ke.qq.com/webcourse/3294666/103425320#taid=11144559668118986&vid=5285890815288776379

码农公寓