CPU负载均衡之WALT学习

前言

本文继续整理CPU调度WALT相关内容，主要整理如下内容：

1. WALT是什么？
2. WALT 计算？
3. WALT 计算数据如何使用？

1. WALT是什么？

WALT：Windows-Assist Load Tracing的缩写：
- 从字面意思来看，是以window作为辅助项来跟踪CPU LOAD；
- 实质上是一种计算方法，用数据来表现CPU当前的loading情况，用于后续任务调度、迁移、负载均衡等功能；

1.1 为什么需要WALT ？

对于一项技术的发展，尤其是一种计算方式的引入，一定是伴随着过去的技术不在适用于当前事务发展的需要，或者这项技术可以让人更懒；

1.1.1 PELT的计算方式的不足？

PELT的引进的时候，linux的主流还在于服务器使用，更多关注设备性能的体现，彼时功耗还不是考虑的重点，而随着移动设备的发展，功耗和响应速度成为被人们直接感知到的因素，成为当前技术发展主要考虑的因素：

1. 对于当前的移动设备，在界面处理的应用场景，需要尽快响应，否则user会明显感觉到卡顿；
2. 对于当前移动设备，功耗更是一个必须面对的因素，手机需要频繁充电，那销量一定好不了；
3. 根据用户场景决定task是否heavy的要求，比如显示的内容不同，其task重要程度也不同，即同一个类别的TASK也需要根据具体情况动态改变；

而基于当前PELT的调度情况（衰减的计算思路），更能体现连续的趋势情况，而对于快速的突变性质的情况，不是很友好：

1. 对于快速上升和快速下降的情况响应速度较慢，由于衰减的计算过程，所以实际的Loading上升和下降需要一定周期后才能在数据上反馈出来，导致响应速度慢；
2. PELT基于其衰减机制，所以对于一个task sleep 一段时间后，则其负载计算减小，但是如果此时该Task为网络传输这种，周期性的需要cpu和freq的能力，则不能快速响应（因为该计算方式更能体现趋向性、平均效果）

1.2 WALT如何处理

根据上述的原因，我们了解到，当前需要在PELT的基础上（保持其好处），实现一种更能适用于当前需求的计算方式：

1. 数据上报更加及时；
2. 数据直接体现现状；
3. 对算力的消耗不会增加（算力）；

1.2.1 WALT 处理

我这里总结了WALT所能（需要）做到的效果：

1. 继续保持对于所有Task-entity的跟踪 ；
2. 在此前usage（load）的基础上，添加对于demand的记录，用于之后预测；
3. 每个CPU上runqueue 的整体负载仍为所有Task统计的sum；
4. 核心在于计算差异，由之前的衰减的方式变更为划分window的方式：数据采集更能快速体现实际变化（对比与PELT的趋势），如下为Linux官方的一些资料：
   1. A task’s demand is the maximum of its contribution to the most recently completed window and its average demand over the past N windows.
   2. WALT “forgets” blocked time entirely：即只统计runable和running time，可以对于Task的实际耗时有更准确的统计，可以通过demand预测；
   3. CPU busy time - The sum of execution times of all tasks in the most recently completed window；
   4. WALT “forgets” cpu utilization as soon as tasks are taken off of the runqueue；

1.2.2 应用补充

1. task分配前各个CPU和task负载的统计；
2. task migration 迁移
3. 大小核的分配；
4. EAS 分配；

1.3 版本导入

1. linux 4.8.2 之后导入（但是在bootlin查看code，最新5.8仍没有对应文件）
2. android 4.4之后导入（android kernel 4.9 中是有这部分的）

2. Kernel如何启用WALT

android kernel code中已经集成了这部分内容，不过根据厂商的差异，可能存在没有启用的情况：

1. 打开宏测试：
   1. menuconfig ==》Genernal setup ==》CPU/Task time and stats accounting ==》support window based load tracking
   2. 图示：
2. 直接修改
   1. kernel/arch/arm64/config/defconfig中添加CONFIG_SCHED_WALT=y
3. build image 验证修改是否生效：
   demo:/sys/kernel/tracing # zcat /proc/config.gz | grep WALT

   CONFIG_SCHED_WALT=y
   CONFIG_HID_WALTOP=y

4. 测试
   当前只是在ftrace中可以看到确实有统计walt的数据，但是没有实际的应用来确认具体是否有改善或者其他数据（当然Linux的资料中有一些数据，但是并非本地测试）；

3. WALT计算

本小节从原理和code 来说明，WALT采用的计算方式：

1. windows 是如何划分的？
2. 对于Task如何分类，分别做怎样的处理？
3. WALT部分数据如何更新？
4. WALT更新的数据如何被调度、EAS使用？

3.1 Windows划分

首先来看辅助计算项window是如何划分的？
简单理解，就是将系统自启动开始以一定时间作为一个周期，分别统计不同周期内Task的Loading情况，并将其更新到Runqueue中；

则还有哪些内容需要考虑？

1. 一个周期即window设置为多久比较合适？这个根据实际项目不同调试不同的值，目前Kernel中是设置的标准是20ms；
2. 具体统计多少个window内的Loading情况？根据实际项目需要调整，目前Kernel中设置为5个window；

所以对于一个Task和window，可能存在如下几种情况：

ps：ms = mark_start（Task开始），ws = window_start（当前window开始）， wc = wallclock（当前系统时间）

1. Task在这个window内启动，且做统计时仍在这个window内，即Task在一个window内；
2. Task在前一个window内启动，做统计时在当前window内，即Task跨过两个window；
3. Task在前边某一个window内启动，做统计时在当前window内，即Task跨过多个完整window；
   
   即Task在Window的划分只有上述三种情况，所有的计算都是基于上述划分的；

3.2 Task 分类

可以想到的是，对于不同类别的Task或者不同状态的Task计算公式都是不同的，WALT将Task划分为如下几个类别：

上图中有将各个Task event的调用函数列出来；

3.2.1 更新demand判断

在更新demand时，会首先根据Task event判断此时是否需要更新：

对应function：

static int account_busy_for_task_demand(struct task_struct *p, int event)
{
   
	/* No need to bother updating task demand for exiting tasks
	 * or the idle task. */
	 //task 已退出或者为IDLE，则不需要计算
	if (exiting_task(p) || is_idle_task(p))
		return 0;

	/* When a task is waking up it is completing a segment of non-busy
	 * time. Likewise, if wait time is not treated as busy time, then
	 * when a task begins to run or is migrated, it is not running and
	 * is completing a segment of non-busy time. */
	// 默认 walt_account_wait_time是1，则只有TASK_WAKE 
	if (event == TASK_WAKE || (!walt_account_wait_time &&
			 (event == PICK_NEXT_TASK || event == TASK_MIGRATE)))
		return 0;

	return 1;
}

3.2.2 更新CPU busy time判断

在更新CPU busy time时，会首先根据Task event判断此时是否需要更新：

对应function：

static int account_busy_for_cpu_time(struct rq *rq, struct task_struct *p,
				     u64 irqtime, int event)
{
   
//是否为idle task or other task？	
	if (is_idle_task(p)) {
   
		/* TASK_WAKE && TASK_MIGRATE is not possible on idle task! */
		// 是schedule 触发的下一个task为idle task
		if (event == PICK_NEXT_TASK)
			return 0;
	
		/* PUT_PREV_TASK, TASK_UPDATE && IRQ_UPDATE are left */
		// 如果是中断或者等待IO的IDLE TASK，是要计算busy time的；
		return irqtime || cpu_is_waiting_on_io(rq);
	}

	//wake 唤醒操作不需要计算；
	if (event == TASK_WAKE)
		return 0;

	//不是IDLE TASK则以下几个类型需要计算
	if (event == PUT_PREV_TASK || event == IRQ_UPDATE ||
					 event == TASK_UPDATE)
		return 1;

	/* Only TASK_MIGRATE && PICK_NEXT_TASK left */
	//默认是0
	return walt_freq_account_wait_time;
}

3.3 数据如何更新？（调用逻辑）

前边两个小结已经介绍了Task在window上统计逻辑和不同Task统计不同数据判断，这里具体来看核心调用逻辑，首先上一张图：

这个图是在xmind导出来的结构图，不清楚是否可以放大查看，这里具体介绍流程：

1. 入口函数walt_update_task_ravg
2. demand更新函数
3. cpu busy time 更新函数

3.3.1 入口函数介绍

对应function：

/* Reflect task activity on its demand and cpu's busy time statistics */
void walt_update_task_ravg(struct task_struct *p, struct rq *rq,
		 int event, u64 wallclock, u64 irqtime)
{
   
	//判断返回
	if (walt_disabled || !rq->window_start)
		return;
	lockdep_assert_held(&rq->lock);
	//更新window_start和cum_window_demand
	update_window_start(rq, wallclock);

	if (!p->ravg.mark_start)
		goto done;
	//更新数据：demand和busy_time
	update_task_demand(p, rq, event, wallclock);
	update_cpu_busy_time(p, rq, event, wallclock, irqtime);

done:
	// trace
	trace_walt_update_task_ravg(p, rq, event, wallclock, irqtime);
	// 更新mark_start	
	p->ravg.mark_start = wallclock;
}

函数主要做三件事情：

1. 更新当前 window start时间为之后数据更新做准备；
2. 更新对应task的demand数值，需要注意这里也会对应更新RQ中的数据；
3. 更新对应task的cpu busy time占用；

这个函数是WALT计算的主要入口，可以看到调用它的位置有很多，即上图最左侧内容，简单来说就是在中断、唤醒、迁移、调度这些case下都会更新Loading情况，这里不一一详细说明了；

1. task awakend
2. task start execute
3. task stop execute
4. task exit

5. window rollover
6. interrupt
7. scheduler_tick

8. task migration
9. freq change

3.3.2 更新window start

这里主要是在计算之前更新window_start确保rq 窗口起始值准确：

对应function：

static void
update_window_start(struct rq *rq, u64 wallclock)
{
   
	s64 delta;
	int nr_windows;
	//计算时间
	delta = wallclock - rq->window_start;
	/* If the MPM global timer is cleared, set delta as 0 to avoid kernel BUG happening */
	if (delta < 0) {
   
		delta = 0;
		/*
		 * WARN_ONCE(1,
		 * "WALT wallclock appears to have gone backwards or reset\n");
		 */
	}

	if (delta < walt_ravg_window) // 不足一个window周期，则直接返回；
		return;

	nr_windows = div64_u64(delta, walt_ravg_window);//计算window数量
	rq->window_start +