一、WALT简介
1. WALT(Windows-Assist Load Tracing)，从字面意思来看，是以window作为辅助项来跟踪cpu load，用来表现cpu当前的loading情况，用于后续任务调度、迁移、负载均衡等功能。在 load 的基础上，添加对于demand的记录用于之后的预测。只统计runable和running time。
2. WALT由Qcom研发，主要用于移动设备对性能功耗要求比较高的场景，在与用户交互时需要尽快响应，要能及时反应负载的增加和减少以驱动频点及时的变化。当前的PELT负载跟踪算法更主要的是体现负载的连续性，对于突变性质的负载的反应不是很友好，负载上升慢，下降也慢。
3. 打开 CONFIG_SCHED_WALT 使能此feature。
4. 辅助计算项 window 的划分方法是将系统自启动开始以一定时间作为一个周期，分别统计不同周期内 Task 的 Loading 情况，并将其更新到Runqueue中；目前 Kernel 中是设置的一个 window 的大小是20ms，统计 5 个window内的Loading情况，当然，这也可以根据具体的项目需求进行配置。
二、相关数据结构
(1) 嵌入在 task_struct 中的 walt_task_struct
/* * 'mark_start' 标记窗口内事件的开始（任务唤醒、任务开始执行、任务被抢占） * 'sum' 表示任务在当前窗口内的可运行程度。它包含运行时间和等待时间，并按频率进行缩放。//就是在当前窗口的运行时间吧 * 'sum_history' 跟踪在之前的 RAVG_HIST_SIZE 窗口中看到的 'sum' 的历史记录。任务完全休眠的窗口将被忽略。 * 'demand' 表示在以前的 sysctl_sched_ravg_hist_size 窗口中看到的最大总和(根据window_policy选的)。 'demand'可以为任务驱动频率的改变。####### * 'curr_window_cpu' 代表任务对当前窗口各CPU上cpu繁忙时间的贡献 * 'prev_window_cpu' 表示任务对前一个窗口中各个 CPU 上的 cpu 繁忙时间的贡献 * 'curr_window' 表示 curr_window_cpu 中所有条目的总和 * 'prev_window' 代表 prev_window_cpu 中所有条目的总和 * 'pred_demand' 代表任务当前预测的cpu繁忙时间 * 'busy_buckets' 将历史繁忙时间分组到用于预测的不同桶中 * 'demand_scaled' 表示任务的需求缩放到 1024 //就是上面demand成员缩放到1024 */ struct walt_task_struct { u64 mark_start; u32 sum, demand; //sum在 add_to_task_demand 中更新 u32 coloc_demand; //存的是5个历史窗口的平均值 u32 sum_history[RAVG_HIST_SIZE_MAX]; u32 *curr_window_cpu, *prev_window_cpu; //这个是per-cpu的 u32 curr_window, prev_window; u32 pred_demand; u8 busy_buckets[NUM_BUSY_BUCKETS]; //10个 u16 demand_scaled; u16 pred_demand_scaled; u64 active_time; //is_new_task中判断此值是小于100ms就认为是新任务，rollover_task_window是唯一更新位置 u32 unfilter; //update_history中对其进行赋值，colocate中选核时，是否需要跳过小核判断了它 u64 cpu_cycles; ... }
(2) 嵌入在 rq 中的 walt_rq
struct walt_rq { ... struct walt_sched_stats walt_stats; u64 window_start; u32 prev_window_size; u64 task_exec_scale; //walt_sched_init_rq中初始化为1024 u64 curr_runnable_sum; u64 prev_runnable_sum; u64 nt_curr_runnable_sum; u64 nt_prev_runnable_sum; //nt 应该是walt认为的new task的意思 u64 cum_window_demand_scaled; struct group_cpu_time grp_time; /* * #define DECLARE_BITMAP_ARRAY(name, nr, bits) unsigned long name[nr][BITS_TO_LONGS(bits)] * unsigned long top_tasks_bitmap[2][BITS_TO_LONGS(1000)]; //只跟踪curr和prev两个窗口的情况。 */ DECLARE_BITMAP_ARRAY(top_tasks_bitmap, NUM_TRACKED_WINDOWS, NUM_LOAD_INDICES); u8 *top_tasks[NUM_TRACKED_WINDOWS]; //2 指针数组 u8 curr_table; //只使用两个window进行跟踪，标识哪个是curr的，curr和prev构成一个环形数组，不停翻转 int prev_top; //应该是rq->wrq.top_tasks[]中前一个窗最大值的下标 int curr_top; //是rq->wrq.top_tasks[]中当前窗最大值的下标 u64 cycles; ... }; struct walt_sched_stats { int nr_big_tasks; u64 cumulative_runnable_avg_scaled; //只统计runnable任务的，在update_window_start中赋值给rq->wrq.cum_window_demand_scaled u64 pred_demands_sum_scaled; unsigned int nr_rtg_high_prio_tasks; };
三、负载计算函数
1. walt算法负载计算入口函数
/* event 取 TASK_UPDATE 等，由于每个tick中断中都会调度，一般两次执行统计的 wc-ms 一般不会超过4ms */ void walt_update_task_ravg(struct task_struct *p, struct rq *rq, int event, u64 wallclock, u64 irqtime) //walt.c { u64 old_window_start; /* 还没初始化或时间没更新，直接返回 */ if (!rq->wrq.window_start || p->wts.mark_start == wallclock) return; lockdep_assert_held(&rq->lock); /* 更新ws，返回最新的ws */ old_window_start = update_window_start(rq, wallclock, event); /* 对应还没初始化的情况, ws是per-rq的，ms是per-task的，wc是全局的 */ if (!p->wts.mark_start) { update_task_cpu_cycles(p, cpu_of(rq), wallclock); goto done; } /*更新 rq->wrq.task_exec_scale 和 p->wts.cpu_cycles = cur_cycles; */ update_task_rq_cpu_cycles(p, rq, event, wallclock, irqtime); /*更新任务的负载和历史记录，返回 wc-ms 的差值，也就是距离上次统计任务运行的时间值 */ update_task_demand(p, rq, event, wallclock); /*更新任务和rq的window相关统计信息，记录per-rq的prev和curr两个窗口内任务负载分布情况 */ update_cpu_busy_time(p, rq, event, wallclock, irqtime); /*更新预测需求*/ update_task_pred_demand(rq, p, event); if (event == PUT_PREV_TASK && p->state) { p->wts.iowaited = p->in_iowait; } trace_sched_update_task_ravg(p, rq, event, wallclock, irqtime, &rq->wrq.grp_time); trace_sched_update_task_ravg_mini(p, rq, event, wallclock, irqtime, &rq->wrq.grp_time); done: /* 更新per-task的 ms，ms是在动态变化的 */ p->wts.mark_start = wallclock; /*构成一个内核线程，每个窗口执行一次*/ run_walt_irq_work(old_window_start, rq); }
此函数中的两个trace解析：
(1) trace_sched_update_task_ravg(p, rq, event, wallclock, irqtime, &rq->wrq.grp_time);
参数原型：
(struct task_struct *p, struct rq *rq, enum task_event evt, u64 wallclock, u64 irqtime, struct group_cpu_time *cpu_time)
打印内容：
<idle>-0 [004] d..2 50167.767150: sched_update_task_ravg: wc 50167994699141 ws 50167988000001 delta 6699140 event PICK_NEXT_TASK cpu 4 cur_freq 434 cur_pid 0 task 17043 (kworker/u16:5) ms 50167994687631 delta 11510 demand 3340045 coloc_demand: 1315008 sum 1235016 irqtime 0 pred_demand 3340045 rq_cs 1112353 rq_ps 4085339 cur_window 930130 (0 136431 573963 0 219736 0 0 0 ) prev_window 2138941 (222138 156646 973556 0 219811 566790 0 0 ) nt_cs 2513 nt_ps 20395 active_time 100000000 grp_cs 0 grp_ps 1691783, grp_nt_cs 0, grp_nt_ps: 0 curr_top 58 prev_top 133
字段解析：
wc：为参数4 wallclock; ws: 为 window_start，取自 rq->wrq.window_start; delta：取自 wallclock - rq->wrq.window_start 的差值。 event：task_event_names[参数3], 字符串表示的事件类型 cpu：取自 rq->cpu cur_freq：取自 rq->wrq.task_exec_scale，update_task_rq_cpu_cycles()中，若不使用 use_cycle_counter，赋值为 cpu_capaticy * (freq / maxfreq) cur_pid: 取自 rq->curr->pid task：取自参数1 p 的 p->pid kworker/u16:5：取自参数1 p 的 p->comm ms：是 mark_start 取自 p->wts.mark_start delta：打印中有两个同名的delta，这是第二个，取自 wallclock - p->wts.mark_start demand：取自 p->wts.demand，单位是ns，就是根据 p->wts.sum 取平均或和最近窗口两者之间的最大值 coloc_demand：取自 p->wts.coloc_demand sum：取自 p->wts.sum，表示最近一个窗口运行时间之和，单位ns，在将其更新到history数组后，清0. irqtime：取自参数4 pred_demand：取自 p->wts.pred_demand rq_cs：取自 rq->wrq.curr_runnable_sum 表示 rq_ps：取自 rq->wrq.prev_runnable_sum 表示 cur_window：取自 p->wts.curr_window，表示任务在当前窗口中所有cpu上的运行时间之和，是后面数组的累加。 (0 136431 573963 0 219736 0 0 0 )：取自 p->wts.curr_window_cpu per-cpu的，表示任务在当前窗口中在每个cpu上运行的时间 prev_window：取自 p->wts.prev_window (222138 156646 973556 0 219811 566790 0 0 )：取自 p->wts.prev_window_cpu 也是per-cpu的，表示任务在前一个窗口中在每个cpu上运行的时间 nt_cs：取自 rq->wrq.nt_curr_runnable_sum nt应该表示的是new task的缩写 nt_ps：取自 rq->wrq.nt_prev_runnable_sum active_time：取自 p->wts.active_time is_new_task()中判断它，唯一更新位置rollover_task_window()中调用is_new_task()判断是新任务时 p->wts.active_time += task_rq(p)->wrq.prev_window_size; grp_cs：取自 cpu_time ? cpu_time->curr_runnable_sum : 0 根据最后一个参数来判断是更新rq的还是更新rtg group的 grp_ps：取自 cpu_time ? cpu_time->prev_runnable_sum : 0 grp_nt_cs：取自 cpu_time ? cpu_time->nt_curr_runnable_sum : 0 grp_nt_ps：取自 cpu_time ? cpu_time->nt_prev_runnable_sum : 0 curr_top：取自 rq->wrq.curr_top 记录的是当前窗口中 rq->wrq.top_tasks[]中最大值的下标 prev_top：取自 rq->wrq.prev_top 记录的是前一个窗口中 rq->wrq.top_tasks[]中最大值的下标
(2) trace_sched_update_task_ravg_mini(p, rq, event, wallclock, irqtime, &rq->wrq.grp_time);
参数原型：
(struct task_struct *p, struct rq *rq, enum task_event evt, u64 wallclock, u64 irqtime, struct group_cpu_time *cpu_time)
打印内容：
<idle>-0 [005] d..2 280546.887141: sched_update_task_ravg_mini: wc 112233604355205 ws 112233596000001 delta 8355204 event PUT_PREV_TASK cpu 5 task 0 (swapper/5) ms 112233604337548 delta 17657 demand 2400000 rq_cs 1374618 rq_ps 1237818 cur_window 0 prev_window 0 grp_cs 0 grp_ps 0
字段解析：
wc：取自参数 wallclock ws：取自 rq->wrq.window_start delta：取自 wallclock - rq->wrq.window_start event：取自 task_event_names[evt] cpu：取自 rq->cpu task：取自 p->pid swapper/5：取自 p->comm ms：取自 p->wts.mark_start delta：两个同名，这是第二个，取自 wallclock - p->wts.mark_start demand：取自 p->wts.demand rq_cs：取自 rq->wrq.curr_runnable_sum rq_ps：取自 rq->wrq.prev_runnable_sum cur_window：取自 p->wts.curr_window prev_window：取自 p->wts.prev_window grp_cs：取自 cpu_time ? cpu_time->curr_runnable_sum : 0 grp_ps：取自 cpu_time ? cpu_time->prev_runnable_sum : 0
2. walt_update_task_ravg 的调用路径
tick_setup_sched_timer //tick_sched.c timer到期回调函数中指定 tick_sched_timer update_process_times //time.c tick中断中调用 scheduler_tick //core.c 周期定时器中断，传参(rq->curr, rq, TASK_UPDATE, wallclock, 0) //任务显式阻塞或设置 TIF_NEED_RESCHED 并且在中断或返回用户空间调度点或preempt_enable() __schedule //core.c 在这个主调度器函数中调用了三次，若选出的prev != next，调用两次，分别传参(prev, rq, PUT_PREV_TASK, wallclock, 0)和(next, rq, PICK_NEXT_TASK, wallclock, 0)，若选出的prev == next，传参(prev, rq, TASK_UPDATE, wallclock, 0) __irq_enter //hardirq.h __handle_domain_irq()中调用，中断入口：handle_arch_irq=gic_handle_irq-->handle_domain_irq __do_softirq //softirq.c account_irq_enter_time //vtime.h account_irq_exit_time //vtime.h irqtime_account_irq //cputime.c 若curr是idle task，并且是在硬中断或软中断上下文则调用，否则调用walt_sched_account_irqstart walt_sched_account_irqend //walt.c，传参(curr, rq, IRQ_UPDATE, wallclock, delta); move_queued_task __migrate_swap_task try_to_wake_up //core.c 当新选出的cpu和任务之前运行的不是同一个cpu调用 dl_task_offline_migration push_dl_task pull_dl_task detach_task push_rt_task pull_rt_task set_task_cpu //core.c 若新选出的cpu和任务之前的cpu不是同一个cpu，对任务进行迁移，然后调用，此时task->on_rq = TASK_ON_RQ_MIGRATING fixup_busy_time //walt.c 连续调用三次，分别传参 (task_rq(p)->curr, task_rq(p), TASK_UPDATE, wallclock, 0)和(dest_rq->curr, dest_rq, TASK_UPDATE, wallclock, 0)和(p, task_rq(p), TASK_MIGRATE, wallclock, 0) cpufreq_freq_transition_end //cpufreq.c set_cpu_freq()中在设置频点前调用cpufreq_freq_transition_begin，设置后调用这个函数 cpufreq_notify_post_transition //cpufreq.c 相同参数调用两次 notifier_trans_block.notifier_call //回调，对应val=CPUFREQ_POSTCHANGE时通知 cpufreq_notifier_trans //walt.c 两层循环，对freq_domain_cpumask中的每一个cpu，对cluster中的每一个cpu，都调用，传参(rq->curr, rq, TASK_UPDATE, wallclock, 0) sync_cgroup_colocation //walt.c cpu_cgrp_subsys.attach=cpu_cgroup_attach-->walt_schedgp_attach中对每一个cpuset都调用 sched_group_id_write //qc_vas.c 对应/proc/<pid>/sched_group_id __sched_set_group_id //传参group_id=0才调用 remove_task_from_group //walt.c 传参(rq, p->wts.grp, p, REM_TASK) __sched_set_group_id //传参group_id非0才调用 add_task_to_group //walt.c 传参(rq, grp, p, ADD_TASK) transfer_busy_time //walt.c 连续调用两次，分别传参(rq->curr, rq, TASK_UPDATE, wallclock, 0)和(p, rq, TASK_UPDATE, wallclock, 0) fixup_busy_time //当task的cpu和参数cpu不是同一个时调用 walt_proc_user_hint_handler //walt.c /proc/sys/kernel/sched_user_hint作用load = load * (sched_user_hint / 100) 维持1s后清0 walt_migration_irq_work.func //walt.c irq_work 结构的回调 walt_update_task_ravg //又回来了，work的响应函数中queue work，构成一个"内核线程不"停执行 run_walt_irq_work //walt.c 若新的window_start和旧的不是同一个就调用 walt_cpufreq_irq_work.func //walt.c irq_work 结构的回调 walt_irq_work //walt.c 对每个cluster的每个cpu都调用，传参(rq->curr, rq, TASK_UPDATE, wallclock, 0) wake_up_q wake_up_process wake_up_state default_wake_function try_to_wake_up walt_try_to_wake_up //walt.h 连续调用两次，分别传参(rq->curr, rq, TASK_UPDATE, wallclock, 0)和(p, rq, TASK_WAKE, wallclock, 0) walt_update_task_ravg
walt_update_task_ravg 通过参数 event 可以控制哪些事件不更新负载。
3. update_window_start 函数
/* 唯一调用路径：walt_update_task_ravg --> this */ static u64 update_window_start(struct rq *rq, u64 wallclock, int event) //walt.c { s64 delta; int nr_windows; u64 old_window_start = rq->wrq.window_start; delta = wallclock - rq->wrq.window_start; if (delta < 0) { printk_deferred("WALT-BUG CPU%d; wallclock=%llu is lesser than window_start=%llu", rq->cpu, wallclock, rq->wrq.window_start); SCHED_BUG_ON(1); } /* sched_ravg_window 默认是20ms, 不足一个窗口就不更新，直接退出*/ if (delta < sched_ravg_window) return old_window_start; /* 下面是delta大于一个window的，计算历经的整窗的个数 */ nr_windows = div64_u64(delta, sched_ravg_window); rq->wrq.window_start += (u64)nr_windows * (u64)sched_ravg_window; /* 更新ws */ rq->wrq.cum_window_demand_scaled = rq->wrq.walt_stats.cumulative_runnable_avg_scaled; rq->wrq.prev_window_size = sched_ravg_window; return old_window_start; }
可以看到，rq->wrq.window_start、rq->wrq.cum_window_demand_scaled 是最先更新的。然后返回旧的 window_start，
4. update_task_cpu_cycles 函数
static void update_task_cpu_cycles(struct task_struct *p, int cpu, u64 wallclock) //walt.c { if (use_cycle_counter) p->wts.cpu_cycles = read_cycle_counter(cpu, wallclock); }
在 p->wts.mark_start 为0的时候，调用这个函数，应该是做初始化的。
5. update_task_rq_cpu_cycles 函数
/* 唯一调用路径 walt_update_task_ravg --> this */ static void update_task_rq_cpu_cycles(struct task_struct *p, struct rq *rq, int event, u64 wallclock, u64 irqtime) //walt.c { u64 cur_cycles; u64 cycles_delta; u64 time_delta; int cpu = cpu_of(rq); lockdep_assert_held(&rq->lock); if (!use_cycle_counter) { /* freq / maxfreq * cpu_capacity, arch_scale_cpu_capacity 为函数 topology_get_cpu_scale */ rq->wrq.task_exec_scale = DIV64_U64_ROUNDUP(cpu_cur_freq(cpu) * arch_scale_cpu_capacity(cpu), rq->wrq.cluster->max_possible_freq); return; } cur_cycles = read_cycle_counter(cpu, wallclock); /*return rq->wrq.cycles;*/ /* * 如果当前任务是空闲任务并且 irqtime == 0，CPU 确实空闲并且它的循环计数器可能没有增加。 * 我们仍然需要估计的 CPU 频率来计算 IO 等待时间。 在这种情况下使用先前计算的频率。 */ if (!is_idle_task(rq->curr) || irqtime) { if (unlikely(cur_cycles < p->wts.cpu_cycles)) //这应该是溢出了 cycles_delta = cur_cycles + (U64_MAX - p->wts.cpu_cycles); else cycles_delta = cur_cycles - p->wts.cpu_cycles; cycles_delta = cycles_delta * NSEC_PER_MSEC; if (event == IRQ_UPDATE && is_idle_task(p)) /* * 在空闲任务的 mark_start 和 IRQ 处理程序进入时间之间的时间是 CPU 周期计数器停止时间段。 * 在 IRQ 处理程序进入 walt_sched_account_irqstart() 时，补充空闲任务的 cpu 周期计数器，因 * 此cycles_delta 现在表示 IRQ 处理程序期间增加的周期，而不是从进入空闲到 IRQ 退出之间的时间段。 * 因此使用 irqtime 作为时间增量。 */ time_delta = irqtime; else time_delta = wallclock - p->wts.mark_start; SCHED_BUG_ON((s64)time_delta < 0); /* (cycles_delta * cpu_capacity) / (time_delta * max_freq) = cycles_delta/time_delta * cpu_capacity/max_freq*/ rq->wrq.task_exec_scale = DIV64_U64_ROUNDUP(cycles_delta * arch_scale_cpu_capacity(cpu), time_delta * rq->wrq.cluster->max_possible_freq); trace_sched_get_task_cpu_cycles(cpu, event, cycles_delta, time_delta, p); } p->wts.cpu_cycles = cur_cycles; }
其中Trace:
trace_sched_get_task_cpu_cycles(cpu, event, cycles_delta, time_delta, p);
参数原型：
(int cpu, int event, u64 cycles, u64 exec_time, struct task_struct *p)
打印内容：
shell svc 7920-7921 [006] d..4 53723.502493: sched_get_task_cpu_cycles: cpu=6 event=2 cycles=105682000000 exec_time=78229 freq=1350931 legacy_freq=2035200 max_freq=2035200 task=19304 (kworker/u16:5)
字段解析：
前4个字段直接来自参数， freq：取自 cycles/exec_time, 其中 cycles 是乘以了 NSEC_PER_MSEC 的，exec_time 的单位是ns。 legacy_freq：取自 cpu_rq(cpu)->wrq.cluster->max_possible_freq，单位KHz max_freq：取自 cpu_rq(cpu)->wrq.cluster->max_possible_freq * cpu_rq(cpu)->cpu_capacity_orig / SCHED_CAPACITY_SCALE task：取自 p->pid kworker/u16:5：取自 p->comm
6. update_history 解析
update_task_demand 中若判断不需要更新 task 的 p->wts.sum, 但是又有新窗口产生时，调用这个函数更新历史负载。
/* * 当一个任务的新窗口开始时调用，记录最近结束的窗口的 CPU 使用率。 通常'samples'应该是1。 * 比如说，当一个实时任务同时运行而不抢占几个窗口时，它可以 > 1，也就是说连续运行3个窗口才 * 更新的话，samples就传3。 * * update_task_demand()调用传参：(rq, p, p->wts.sum, 1, event) sum 是几5个窗口的 */ static void update_history(struct rq *rq, struct task_struct *p, u32 runtime, int samples, int event) //walt.c { u32 *hist = &p->wts.sum_history[0]; int ridx, widx; u32 max = 0, avg, demand, pred_demand; u64 sum = 0; u16 demand_scaled, pred_demand_scaled; /* Ignore windows where task had no activity */ if (!runtime || is_idle_task(p) || !samples) goto done; /* Push new 'runtime' value onto stack */ /* hist[5]中的元素向后移动samples个位置，runtime值插入到hist[0]中，hist[0]是最新的时间 */ widx = sched_ravg_hist_size - 1; /* 5-1=4 */ ridx = widx - samples; //widx=4, samples=1, ridx=3; samples=2, ridx=2 for (; ridx >= 0; --widx, --ridx) { hist[widx] = hist[ridx]; sum += hist[widx]; //此循环 sum = hist[4] + hist[3] + hist[2] + hist[1] if (hist[widx] > max) max = hist[widx]; //max保存最近4个窗中的最大值 } /* * 若samples=1, hist[0] = runtime * 若samples=2, hist[0] = runtime, hist[1] = runtime * ... */ for (widx = 0; widx < samples && widx < sched_ravg_hist_size; widx++) { hist[widx] = runtime; //hist[0]中存放的是最近的一个窗中运行的时间 sum += hist[widx]; //sum再加上hist[0] if (hist[widx] > max) max = hist[widx]; //max保存的是最近5个窗中最大的值了 } /* 将p->wts.sum放入history数组后就清0了, 也说明这个sum是一个窗的sum值 */ p->wts.sum = 0; /*可以通过 sched_window_stats_policy 文件进行配置下面4种window policy */ if (sysctl_sched_window_stats_policy == WINDOW_STATS_RECENT) { //为0，返回最近一个窗口的运行时间值 demand = runtime; } else if (sysctl_sched_window_stats_policy == WINDOW_STATS_MAX) { //为1，返回最近5个窗口运行时间的最大值 demand = max; } else { avg = div64_u64(sum, sched_ravg_hist_size); //求最近5个窗口运行时间的平均值 if (sysctl_sched_window_stats_policy == WINDOW_STATS_AVG) //为3，返回最近5个窗口平均运行时间值 demand = avg; else demand = max(avg, runtime); //为2，默认配置，返回最近5个窗口平均运行时间值 与 最近1个窗口运行时间值中的较大的那个 } pred_demand = predict_and_update_buckets(p, runtime); /* demand_scaled = demand/(window_size/1024) == (demand / window_size) * 1024 * 传参demand可以认为是p的负载了 */ demand_scaled = scale_demand(demand); /* pred_demand_scaled = pred_demand/(window_size/1024) == (pred_demand / window_size) * 1024 */ pred_demand_scaled = scale_demand(pred_demand); /* * 限流的deadline调度类任务出队列时不改变p->on_rq。 由于出队递减 walt stats 避免再次递减它。 * 当窗口滚动时，累积窗口需求被重置为累积可运行平均值（来自运行队列上的任务的贡献）。如果当前任务已经出队， * 则它的需求不包括在累积可运行平均值中。所以将任务需求单独添加到累积窗口需求中。 */ /*这里增加的是rq上的统计值，不是per-entity的了*/ if (!task_has_dl_policy(p) || !p->dl.dl_throttled) { if (task_on_rq_queued(p)) { fixup_walt_sched_stats_common(rq, p, demand_scaled, pred_demand_scaled); /*这里加的是demand_scaled的差值*/ } else if (rq->curr == p) { walt_fixup_cum_window_demand(rq, demand_scaled); } } /*赋值给per-entiry上的统计值，demand_scaled 对 p->wts.demand_scaled 的赋值一定要保证，这是walt负载跟踪算法重要的部分*/ p->wts.demand = demand; /* 对应一个窗中运行的时间(根据window policy不同而有差异) */ p->wts.demand_scaled = demand_scaled; /* 对应一个窗中运行的时间(根据window policy不同而有差异)缩放到1024 */ ############# p->wts.coloc_demand = div64_u64(sum, sched_ravg_hist_size); /*5个窗口运行时间之和除以5，即5个窗口的平均运行时间*/ p->wts.pred_demand = pred_demand; p->wts.pred_demand_scaled = pred_demand_scaled; /* demand_scaled 大于指定的阈值时，会做一些事情 */ if (demand_scaled > sysctl_sched_min_task_util_for_colocation) { p->wts.unfilter = sysctl_sched_task_unfilter_period; /*单位是ns，默认值是100ms*/ } else { if (p->wts.unfilter) p->wts.unfilter = max_t(int, 0, p->wts.unfilter - rq->wrq.prev_window_size); //相当于衰减一个窗口的大小 } done: trace_sched_update_history(rq, p, runtime, samples, event); }
其中Trace:
trace_sched_update_history(rq, p, runtime, samples, event);
参数原型：
(struct rq *rq, struct task_struct *p, u32 runtime, int samples, enum task_event evt)
打印内容：
sched_update_history: 24647 (kworker/u16:15): runtime 279389 samples 1 event TASK_WAKE demand 717323 coloc_demand 717323 pred_demand 279389 (hist: 279389 88058 520130 1182596 1516443) cpu 1 nr_big 0
字段解析：
24647：取自 p->pid kworker/u16:15：取自 p->comm runtime：来自参数3，表示最近一个窗口中的运行时间，也是 p->wts.sum 的值 samples：来自参数4，表示更新几个窗的历史 event：取自 task_event_names[event] demand：取自 p->wts.demand，是scale之前的根据不同window policy计算出来的负载值 coloc_demand：取自 p->wts.coloc_demand，即5个窗口的平均值 pred_demand：取自 p->wts.pred_demand，表示预测的负载需求 (hist: 279389 88058 520130 1182596 1516443)：取自 p->wts.sum_history[5]，是任务在最近5个窗口中分别运行的时间 cpu：取自 rq->cpu nr_big：取自 rq->wrq.walt_stats.nr_big_tasks
用于预测任务的 demand 的 bucket 相关更新：
static inline u32 predict_and_update_buckets(struct task_struct *p, u32 runtime) //walt.c { int bidx; u32 pred_demand; if (!sched_predl) //为1 return 0; /* 根据传入的时间值获得一个桶的下标，桶一共有10个成员 */ bidx = busy_to_bucket(runtime); /* 使用 p->wts.busy_buckets 用于计算 */ pred_demand = get_pred_busy(p, bidx, runtime); /* 更新 p->wts.busy_buckets */ bucket_increase(p->wts.busy_buckets, bidx); return pred_demand; } static inline int busy_to_bucket(u32 normalized_rt) { int bidx; bidx = mult_frac(normalized_rt, NUM_BUSY_BUCKETS, max_task_load()); /*args1*10/16; arg1*arg2/arg3*/ bidx = min(bidx, NUM_BUSY_BUCKETS - 1); //min(p->wts.sum * 10 / 16, 9) 运行一个满窗是桶10，运行1ms-2ms返回1 /* 合并最低的两个桶。 最低频率落入第二桶，因此继续预测最低桶是没有用的。*/ if (!bidx) bidx++; return bidx; } /* * get_pred_busy - 计算运行队列上的任务的预测需求 * * @p：正在更新预测的任务 * @start: 起始桶。 返回的预测不应低于此桶。 * @runtime：任务的运行时间。 返回的预测不应低于此运行时。 * 注意：@start 可以从@runtime 派生。 传入它只是为了在某些情况下避免重复计算。 * * 根据传入的@runtime 为任务@p 返回一个新的预测繁忙时间。该函数搜索表示繁忙时间等于或大于@runtime * 的桶，并尝试找到用于预测的桶。 一旦找到，它会搜索历史繁忙时间并返回落入桶中的最新时间。 如果不 * 存在这样的繁忙时间，则返回该桶的中间值。 */ /*假设传参是p->wts.sum=8ms,那么传参就是(p, 5, 8)，*/ static u32 get_pred_busy(struct task_struct *p, int start, u32 runtime) { int i; u8 *buckets = p->wts.busy_buckets; //10个元素 u32 *hist = p->wts.sum_history; //5个元素 u32 dmin, dmax; u64 cur_freq_runtime = 0; int first = NUM_BUSY_BUCKETS, final; //从最大值10开始找 u32 ret = runtime; /* skip prediction for new tasks due to lack of history */ /* 由于累积运行时间小于100ms的新任务缺少历史运行时间，不对其进行预测 */ if (unlikely(is_new_task(p))) goto out; /* find minimal bucket index to pick */ /* 找到最小的桶下标进行pick, 只要桶中有数据就选择 */ for (i = start; i < NUM_BUSY_BUCKETS; i++) { if (buckets[i]) { first = i; break; } } /* 若没找到桶下标，就直接返回 runtime，注意 runtime 可能大于10 */ if (first >= NUM_BUSY_BUCKETS) goto out; /* 计算用于预测的桶 */ final = first; /* 确定预测桶的需求范围 */ if (final < 2) { /* 最低的两个桶合并 */ dmin = 0; final = 1; } else { dmin = mult_frac(final, max_task_load(), NUM_BUSY_BUCKETS); //final * 20 / 10, max_task_load返回一个满窗 } dmax = mult_frac(final + 1, max_task_load(), NUM_BUSY_BUCKETS); //(final + 1) * 20 / 10 /* * search through runtime history and return first runtime that falls * into the range of predicted bucket. * 搜索运行历史并返回落在预测桶范围内的第一个运行。在最近的5个窗口中查找 */ for (i = 0; i < sched_ravg_hist_size; i++) { if (hist[i] >= dmin && hist[i] < dmax) { ret = hist[i]; break; } } /* no historical runtime within bucket found, use average of the bin * 若找不到存储桶内的历史运行时间，就使用垃圾桶的平均值 */ if (ret < dmin) ret = (dmin + dmax) / 2; /* * 在窗口中间更新时，运行时间可能高于所有记录的历史记录。 始终至少预测运行时间。 */ ret = max(runtime, ret); out: /* 由于 cur_freq_runtime 是0，所以 pct 恒为0 */ trace_sched_update_pred_demand(p, runtime, mult_frac((unsigned int)cur_freq_runtime, 100, sched_ravg_window), ret); return ret; } /* * bucket_increase - 更新所有桶的计数 * * @buckets：跟踪任务繁忙时间的桶数组 * @idx: 要被递增的桶的索引 * * 每次完成一个完整的窗口时，运行时间落入 (@idx) 的桶计数增加。 所有其他桶的计数都会衰减。 * 根据桶中的当前计数，增加和衰减的速率可能不同。 */ /*传参： (p->wts.busy_buckets, bidx)*/ static inline void bucket_increase(u8 *buckets, int idx) { int i, step; for (i = 0; i < NUM_BUSY_BUCKETS; i++) { //10 if (idx != i) { //不相等就衰减 if (buckets[i] > DEC_STEP) //2 buckets[i] -= DEC_STEP; //2 else buckets[i] = 0; } else { //相等 step = buckets[i] >= CONSISTENT_THRES ? INC_STEP_BIG : INC_STEP; //16 16 8 if (buckets[i] > U8_MAX - step) //255-step buckets[i] = U8_MAX; //255 else buckets[i] += step; //就是加step，上面判断是为了不要溢出 } } }
其中Trace:
trace_sched_update_pred_demand(p, runtime, mult_frac((unsigned int)cur_freq_runtime, 100, sched_ravg_window), ret);
参数原型：
(struct task_struct *p, u32 runtime, int pct, unsigned int pred_demand)
打印内容：
sched_update_pred_demand: 1174 (Binder:1061_2): runtime 556361 pct 0 cpu 1 pred_demand 556361 (buckets: 0 255 0 0 0 0 0 0 0 0)
字段解析：
1174：取自 p->pid Binder:1061_2：取自 p->comm runtime：取自参数2 pct：取自参数3 cpu：取自task_cpu(p) pred_demand：取自参数4 (buckets: 0 255 0 0 0 0 0 0 0 0)：取自 p->wts.busy_buckets[10]
/* * update_history --> this，如果task在rq上才会调用传参: (rq, p, demand_scaled, pred_demand_scaled)，参数是缩放到0--1024后的 * 也就是说这个函数里面计算的包含 runnable 的 */ static void fixup_walt_sched_stats_common(struct rq *rq, struct task_struct *p, u16 updated_demand_scaled, u16 updated_pred_demand_scaled) { /* p->wts.demand_scaled 约是由 p->wts.sum scale后得来的(window plicy策略影响), 后者是一个窗口中任务运行的时长。新的减旧的，结果处于[-1024,1024] */ s64 task_load_delta = (s64)updated_demand_scaled - p->wts.demand_scaled; /* p->wts.pred_demand_scaled 是由桶算法预测得来的 */ s64 pred_demand_delta = (s64)updated_pred_demand_scaled - p->wts.pred_demand_scaled; /* 直接加上传入的增量，注意增量可能是负数，一个进程的负载变低了，差值就是负数了*/ fixup_cumulative_runnable_avg(&rq->wrq.walt_stats, task_load_delta, pred_demand_delta); /*累加demand_scaled的增量*/ walt_fixup_cum_window_demand(rq, task_load_delta); /*上下两个函数都是对rq->wrq.中的成员赋值*/ } /* * 如果task在rq上调用路径：update_history --> fixup_cumulative_runnable_avg 传参：(&rq->wrq.walt_stats, task_load_delta, pred_demand_delta) * 传参为时间差值。 */ static inline void fixup_cumulative_runnable_avg(struct walt_sched_stats *stats, s64 demand_scaled_delta, s64 pred_demand_scaled_delta) { /* * 增量差值可正可负，rq 的 cumulative_runnable_avg_scaled 初始化后就只有在这里有赋值了。 * 这里根据根据当前窗口负载值快速变化。 */ stats->cumulative_runnable_avg_scaled += demand_scaled_delta; BUG_ON((s64)stats->cumulative_runnable_avg_scaled < 0); stats->pred_demands_sum_scaled += pred_demand_scaled_delta; BUG_ON((s64)stats->pred_demands_sum_scaled < 0); }
说明 rq->wrq.walt_stats.cumulative_runnable_avg_scaled 和 rq->wrq.walt_stats.pred_demands_sum_scaled 统计的只是 runnable 状态的负载值。这里加上有符号的delta值，可以快速的反应runnable状态的负载的变化。
/* * 如果task在rq上调用路径：update_history --> fixup_walt_sched_stats_common --> this 传参：(rq, task_load_delta) * 如果rq->curr == p 时调用路径：update_history --> this 传参：(rq, demand_scaled) * 说明这里面更新的成员统计的级包括 runnable 的分量，也保留 running 的分量 */ static inline void walt_fixup_cum_window_demand(struct rq *rq, s64 scaled_delta) { rq->wrq.cum_window_demand_scaled += scaled_delta; if (unlikely((s64)rq->wrq.cum_window_demand_scaled < 0)) rq->wrq.cum_window_demand_scaled = 0; }
rq->wrq.cum_window_demand_scaled 统计的既包括 runnable 的又包括 running 的。runnable 的累加的是差值，而 running 的累加的直接是 demand_scaled 的值，若是一部分 runnable 的任务变成 running 了，前者减少，后者增加，体现在结果上可能是不变的。
7. update_task_demand 函数
/* * 计算任务的cpu需求和/或更新任务的cpu需求历史 * * ms = p->wts.mark_start * wc = wallclock * ws = rq->wrq.window_start * * 三种可能： * a) 任务事件包含在一个窗口中。 16ms per-window, window_start < mark_start < wallclock * ws ms wc * | | | * V V V * |---------------| * * 在这种情况下，如果事件是合适的 p->wts.sum 被更新（例如：event == PUT_PREV_TASK） * * b) 任务事件跨越两个窗口。mark_start < window_start < wallclock * * ms ws wc * | | | * V V V * ------|------------------- * * 在这种情况下，如果事件是合适的 p->wts.sum 更新为 (ws - ms) ，然后记录一个新的窗口的采样，如果事件是合 * 适的然后将 p->wts.sum 设置为 (wc - ws) 。 * * c) 任务事件跨越两个以上的窗口。 * * ms ws_tmp ws wc * | | | | * V V V V * ---|-------|-------|-------|-------|------ * | | * |<------ nr_full_windows ------>| * * 在这种情况下，如果事件是合适的，首先 p->wts.sum 更新为 (ws_tmp - ms) ，p->wts.sum 被记录，然后，如果 * event 是合适的 window_size 的 'nr_full_window' 样本也被记录，最后如果 event 是合适的，p->wts.sum 更新 * 到 (wc - ws)。 * * 重要提示：保持 p->wts.mark_start 不变，因为 update_cpu_busy_time() 依赖它！ * */ /* walt_update_task_ravg-->this 唯一调用位置 */ static u64 update_task_demand(struct task_struct *p, struct rq *rq, int event, u64 wallclock) //walt.c { u64 mark_start = p->wts.mark_start; //进来时还没更新 u64 delta, window_start = rq->wrq.window_start; //进来时已经更新了 int new_window, nr_full_windows; u32 window_size = sched_ravg_window; //20ms u64 runtime; new_window = mark_start < window_start; //若为真说明经历了新窗口 /* 若判断不需要更新负载，直接更新历史 p->wts.sum_history[]，而没有更新 p->wts.sum */ if (!account_busy_for_task_demand(rq, p, event)) { if (new_window) { /* * 如果计入的时间没有计入繁忙时间，并且新的窗口开始， * 则只需要关闭前一个窗口与预先存在的需求。 多个窗口 * 可能已经过去，但由于空窗口被丢弃，因此没有必要考虑这些。 * * 如果被累积的时间没有被计入繁忙时间，并且有新的窗口开始， * 则只需要与预先存在需求的前一个窗口被关闭。 虽然可能有多 * 个窗口已经流逝了，但由于WALT算法是空窗口会被丢弃掉，因 * 此没有必要考虑这些。 */ update_history(rq, p, p->wts.sum, 1, event); } return 0; } /* 下面是需要更新的情况了 */ /* (1) 还是同一个窗口，对应上面的情况a */ if (!new_window) { /* 简单的情况 - 包含在现有窗口中的繁忙时间。*/ return add_to_task_demand(rq, p, wallclock - mark_start); } /* (2) 下面就是跨越了窗口，先求情况b */ /* 繁忙时间至少跨越两个窗口。 暂时将 window_start 倒回到 mark_start 之后的第一个窗口边界。*/ delta = window_start - mark_start; nr_full_windows = div64_u64(delta, window_size); window_start -= (u64)nr_full_windows * (u64)window_size; /* Process (window_start - mark_start) first */ /* 这里累加的是 情况b/情况c 中ws_tmp-ms这段的delta值 */ runtime = add_to_task_demand(rq, p, window_start - mark_start); /* Push new sample(s) into task's demand history */ /* 将最开始的不足一个window窗口大小的delta计算出来的p->wts.sum放入历史数组中 */ update_history(rq, p, p->wts.sum, 1, event); /* (3) 下面就对应情况c了，由于c和b都有最开始不足一个窗口的一段，在上面计算b时一并计算了 */ if (nr_full_windows) { u64 scaled_window = scale_exec_time(window_size, rq); //等于直接return window_size /* 一下子更新 nr_full_windows 个窗口的负载到历史窗口负载中，每个窗口都是满窗 */ update_history(rq, p, scaled_window, nr_full_windows, event); /* runtime 累积运行时间进行累加 ==>只要搞清什么时候标记ms和什么时候调用这个函数计算负载，就可以知道计算的是哪段的 ######## */ runtime += nr_full_windows * scaled_window; } /* 将 window_start 滚回当前以处理当前窗口，以便于计算当前窗口中的剩余部分。*/ window_start += (u64)nr_full_windows * (u64)window_size; /* 这里是计算情况b和情况c的wc-ws段 */ mark_start = window_start; runtime += add_to_task_demand(rq, p, wallclock - mark_start); //runtime 继续累加 /* 返回值表示此次 update_task_demand 更新的时间值，是 wc-ms 的差值 */ return runtime; }
此函数中始终没有更新回去 p->wts.mark_start，其是在 walt_update_task_ravg 函数最后更新的。rq->wrq.window_start 在上面第一个函数中就更新了。
/* update_task_demand --> this */ static int account_busy_for_task_demand(struct rq *rq, struct task_struct *p, int event) //walt.c { /* (1) 不需要统计 idle task 的 demand，直接返回*/ if (is_idle_task(p)) return 0; /* * 当一个任务被唤醒时，它正在完成一段非繁忙时间。 同样，如果等待时间 * 不被视为繁忙时间，那么当任务开始运行或迁移时，它并未运行并且正在完成 * 一段非繁忙时间。 */ /*就是这些情况跳过统计，!SCHED_ACCOUNT_WAIT_TIME 恒为假，所以是只判断了 TASK_WAKE */ /* (2) 是唤醒事件 或 不需要计算walit事件并且事件是pick和migrate, 不需要更新 */ if (event == TASK_WAKE || (!SCHED_ACCOUNT_WAIT_TIME && (event == PICK_NEXT_TASK || event == TASK_MIGRATE))) return 0; /* (3) idle进程退出的时候也不需要统计 */ if (event == PICK_NEXT_TASK && rq->curr == rq->idle) return 0; /* * TASK_UPDATE can be called on sleeping task, when its moved between related groups */ /*context_switch()的时候更改的rq->curr*/ /* (4) 若是update事件，且p是curr任务，需要更新。否则若p在队列上需要更新，不在队列上不需要更新 */ if (event == TASK_UPDATE) { if (rq->curr == p) return 1; return p->on_rq ? SCHED_ACCOUNT_WAIT_TIME : 0; //这里可调整是否记录任务在rq上的等待的时间 } /* (5) 都不满足，默认是需要更新 */ return 1; }
p是idle task，或 事件是 TASK_WAKE，或idle任务退出时的 PICK_NEXT_TASK 事件，或事件是 TASK_UPDATE 但是 p 不是curr任务也没有在rq上，就不需要计算busy time。只有事件是 TASK_UPDATE，且任务p是 rq->curr 任务或者 p是在rq 上等待，则需要更新。若不需要更新的话，又产生了新的窗口，那就调用 update_history()更新负载历史就退出了。
/* update_task_demand --> this 唯一调用路径也是在 walt_update_task_ravg 中 */ static u64 add_to_task_demand(struct rq *rq, struct task_struct *p, u64 delta) //walt.c { /* delta = (delta * rq->wrq.task_exec_scale) >> 10, 由于 rq->wrq.task_exec_scale 初始化为1024，所以还是delta*/ delta = scale_exec_time(delta, rq); /* 这里更新了 p->wts.sum，并将最大值钳位在一个窗口大小*/ p->wts.sum += delta; if (unlikely(p->wts.sum > sched_ravg_window)) p->wts.sum = sched_ravg_window; return delta; }
更新 p->wts.sum 值，并且返回 delta 值。这也是 sum 的唯一更新位置，唯一调用路径也是从 walt_update_task_ravg 函数调用下来的。
8. update_cpu_busy_time 函数
/* walt_update_task_ravg --> this 这是唯一调用路径，传参(p, rq, event, wallclock, irqtime)*/ static void update_cpu_busy_time(struct task_struct *p, struct rq *rq, int event, u64 wallclock, u64 irqtime) { int new_window, full_window = 0; int p_is_curr_task = (p == rq->curr); u64 mark_start = p->wts.mark_start; u64 window_start = rq->wrq.window_start; //walt_update_task_ravg-->update_window_start 最先更新的rq->wrq.window_start u32 window_size = rq->wrq.prev_window_size; u64 delta; u64 *curr_runnable_sum = &rq->wrq.curr_runnable_sum; u64 *prev_runnable_sum = &rq->wrq.prev_runnable_sum; u64 *nt_curr_runnable_sum = &rq->wrq.nt_curr_runnable_sum; u64 *nt_prev_runnable_sum = &rq->wrq.nt_prev_runnable_sum; bool new_task; struct walt_related_thread_group *grp; int cpu = rq->cpu; u32 old_curr_window = p->wts.curr_window; new_window = mark_start < window_start; if (new_window) full_window = (window_start - mark_start) >= window_size; /* 处理每个任务的窗口翻转。 我们不关心空闲任务。*/ if (!is_idle_task(p)) { if (new_window) /* 将 p->wts 的 curr_window 赋值给 prev_window，然后将 curr_window 清0 */ rollover_task_window(p, full_window); } new_task = is_new_task(p); //运行时间小于5个窗口的任务 /* p是curr任务并且有了个新窗口才执行 */ if (p_is_curr_task && new_window) { /* rq的一些成员，prev_*_sum=curr_*_sum, 然后将 curr_*_sum 赋值为0 */ rollover_cpu_window(rq, full_window); rollover_top_tasks(rq, full_window); //这里面已经更新了rq->wrq.curr_table ############ } /* 判断是否需要记录 */ if (!account_busy_for_cpu_time(rq, p, irqtime, event)) goto done; /*----下面就是需要计算的了----*/ grp = p->wts.grp; if (grp) { struct group_cpu_time *cpu_time = &rq->wrq.grp_time; /* 注意：指向更改了! */ curr_runnable_sum = &cpu_time->curr_runnable_sum; prev_runnable_sum = &cpu_time->prev_runnable_sum; nt_curr_runnable_sum = &cpu_time->nt_curr_runnable_sum; nt_prev_runnable_sum = &cpu_time->nt_prev_runnable_sum; } if (!new_window) { /* * account_busy_for_cpu_time() = 1 所以忙时间需要计入当前窗口。 * 没有翻转，因为我们没有启动一个新窗口。 这方面的一个例子是当 * 任务开始执行然后在同一窗口内休眠时。 */ if (!irqtime || !is_idle_task(p) || cpu_is_waiting_on_io(rq)) delta = wallclock - mark_start; else delta = irqtime; delta = scale_exec_time(delta, rq); //等于直接return delta *curr_runnable_sum += delta; if (new_task) *nt_curr_runnable_sum += delta; if (!is_idle_task(p)) { p->wts.curr_window += delta; p->wts.curr_window_cpu[cpu] += delta; } goto done; } /*----下面就是有一个新窗口的情况了----*/ if (!p_is_curr_task) { /* * account_busy_for_cpu_time() = 1 所以忙时间需要计入当前窗口。 * 一个新窗口也已启动，但 p 不是当前任务，因此窗口不会翻转 * - 只需拆分并根据需要将计数分为 curr 和 prev。 仅在为当前任 * 务处理新窗口时才会翻转窗口。 * * irqtime 不能由不是当前正在运行的任务的任务计算。 */ if (!full_window) { /* 一个完整的窗口还没有过去，计算对上一个完成的窗口的部分贡献。*/ delta = scale_exec_time(window_start - mark_start, rq); p->wts.prev_window += delta; p->wts.prev_window_cpu[cpu] += delta; } else { /* 由于至少一个完整的窗口已经过去，对前一个窗口的贡献是一个完整的窗口(window_size) */ delta = scale_exec_time(window_size, rq); p->wts.prev_window = delta; p->wts.prev_window_cpu[cpu] = delta; } *prev_runnable_sum += delta; if (new_task) *nt_prev_runnable_sum += delta; /* 只占当前窗口的一部分繁忙时间 */ delta = scale_exec_time(wallclock - window_start, rq); *curr_runnable_sum += delta; if (new_task) *nt_curr_runnable_sum += delta; p->wts.curr_window = delta; /*对当前窗的贡献直接复制给当前窗*/ p->wts.curr_window_cpu[cpu] = delta; goto done; } /*----下面p是当前任务的情况了----*/ if (!irqtime || !is_idle_task(p) || cpu_is_waiting_on_io(rq)) { /* * account_busy_for_cpu_time() = 1 所以忙时间需要计入当前窗口。 一个新窗口已经启动， * p 是当前任务，因此需要翻转。 如果以上三个条件中的任何一个为真，那么这个繁忙的时 * 间就不能算作 irqtime。 * * 空闲任务的繁忙时间不需要计算。 * * 一个例子是一个任务开始执行，然后在新窗口开始后休眠。 */ if (!full_window) { /* 一个完整的窗口还没有过去，计算对上一个完整的窗口的部分贡献。*/ delta = scale_exec_time(window_start - mark_start, rq); //等效直接返回window_start - mark_start if (!is_idle_task(p)) { p->wts.prev_window += delta; p->wts.prev_window_cpu[cpu] += delta; } } else { /* 由于至少一个完整的窗口已经过去，对前一个窗口的贡献是完整的窗口（window_size）*/ delta = scale_exec_time(window_size, rq); if (!is_idle_task(p)) { p->wts.prev_window = delta; p->wts.prev_window_cpu[cpu] = delta; } } /* 在这里通过覆盖 prev_runnable_sum 和 curr_runnable_sum 中的值来完成翻转。*/ *prev_runnable_sum += delta; if (new_task) *nt_prev_runnable_sum += delta; /* 计算在当前窗口忙时的一片时间 */ delta = scale_exec_time(wallclock - window_start, rq); *curr_runnable_sum += delta; if (new_task) *nt_curr_runnable_sum += delta; if (!is_idle_task(p)) { p->wts.curr_window = delta; p->wts.curr_window_cpu[cpu] = delta; } goto done; } /*---- 下面就对应 irqtime && is_idle_task(p) && ！cpu_is_waiting_on_io(rq) 的情况了，并且累积上面的条件 ----*/ if (irqtime) { /* * account_busy_for_cpu_time() = 1 所以忙时间需要计入当前窗口。 * 一个新窗口已经启动，p 是当前任务，因此需要翻转。 当前任务必 * 须是空闲任务，因为不为其他任何任务计算irqtime。 * * 空闲一段时间后，每次我们处理 IRQ 活动时都会计算 Irqtime，因 * 此我们知道 IRQ 繁忙时间为 wallclock - irqtime。 */ SCHED_BUG_ON(!is_idle_task(p)); mark_start = wallclock - irqtime; /* * 滚动窗口。 如果 IRQ 繁忙时间只是在当前窗口中，那么这就是所有需要计算的。 */ if (mark_start > window_start) { *curr_runnable_sum = scale_exec_time(irqtime, rq); //等效于直接返回irqtime，因为是idle线程，之前应该是0的 return; } /*---下面是ms<=ws---*/ /* * IRQ 繁忙时间跨越多个窗口。 先处理当前窗口开始前的忙时间。 */ delta = window_start - mark_start; if (delta > window_size) delta = window_size; delta = scale_exec_time(delta, rq); *prev_runnable_sum += delta; //这直接加不会超过一个窗的大小吗？ /* Process the remaining IRQ busy time in the current window. 处理当前窗口中剩余的 IRQ 忙时间。*/ delta = wallclock - window_start; rq->wrq.curr_runnable_sum = scale_exec_time(delta, rq); return; } done: if (!is_idle_task(p)) update_top_tasks(p, rq, old_curr_window, new_window, full_window); }
值更新当前窗口和前一个窗口的busy时间，主要用于更新任务的： p->wts.curr_window、p->wts.curr_window_cpu[cpu]，更新rq 的 rq->wrq.curr_runnable_sum、rq->wrq.prev_runnable_sum，若是一个walt认为的新任务，还更新 rq->wrq.nt_curr_runnable_sum、rq->wrq.nt_prev_runnable_sum。然后是更新 top-task 的一些成员
下面分别是对 task、cpu、top_tasks 维护的 window 进行更新。有一个新的窗口到来时更新，若更新时已经经历了一个或多个完整的window，那么对prev和curr window 相关的描述结构进行清理备用。
static u32 empty_windows[NR_CPUS]; /* 将 p->wts 的 curr_window 赋值给 prev_window，然后将 curr_window 清0 */ static void rollover_task_window(struct task_struct *p, bool full_window) { u32 *curr_cpu_windows = empty_windows; //数组，每个cpu一个 u32 curr_window; int i; /* Rollover the sum */ curr_window = 0; /* 若经历了一个full_window, prev和curr window都清理待用 */ if (!full_window) { curr_window = p->wts.curr_window; curr_cpu_windows = p->wts.curr_window_cpu; } p->wts.prev_window = curr_window; p->wts.curr_window = 0; /* Roll over individual CPU contributions 滚动每个 CPU 的贡献 */ for (i = 0; i < nr_cpu_ids; i++) { p->wts.prev_window_cpu[i] = curr_cpu_windows[i]; p->wts.curr_window_cpu[i] = 0; } if (is_new_task(p)) p->wts.active_time += task_rq(p)->wrq.prev_window_size; //active_time 的唯一更新位置, walt认为的新任务 }
清理的是任务的 p->wts.prev_window_cpu、p->wts.curr_window、p->wts.prev_window_cpu[]、p->wts.curr_window_cpu[]
/* * rq的一些成员，prev_*_sum=curr_*_sum, 然后将 curr_*_sum 赋值为0，将curr赋值给prev, * 若是有经历了多个窗口curr和prev窗口都需要清理待用。 */ static void rollover_cpu_window(struct rq *rq, bool full_window) { u64 curr_sum = rq->wrq.curr_runnable_sum; u64 nt_curr_sum = rq->wrq.nt_curr_runnable_sum; u64 grp_curr_sum = rq->wrq.grp_time.curr_runnable_sum; u64 grp_nt_curr_sum = rq->wrq.grp_time.nt_curr_runnable_sum; if (unlikely(full_window)) { curr_sum = 0; nt_curr_sum = 0; grp_curr_sum = 0; grp_nt_curr_sum = 0; } rq->wrq.prev_runnable_sum = curr_sum; rq->wrq.nt_prev_runnable_sum = nt_curr_sum; rq->wrq.grp_time.prev_runnable_sum = grp_curr_sum; rq->wrq.grp_time.nt_prev_runnable_sum = grp_nt_curr_sum; rq->wrq.curr_runnable_sum = 0; rq->wrq.nt_curr_runnable_sum = 0; rq->wrq.grp_time.curr_runnable_sum = 0; rq->wrq.grp_time.nt_curr_runnable_sum = 0; }
清理的是 rq->wrq 的 和 rq->wrq.grp_time 的 prev_runnable_sum、curr_runnable_sum、nt_prev_runnable_sum、nt_curr_runnable_sum
static void rollover_top_tasks(struct rq *rq, bool full_window) { /* 跟踪的是2个，构成一个环形数组 */ u8 curr_table = rq->wrq.curr_table; u8 prev_table = 1 - curr_table; int curr_top = rq->wrq.curr_top; /*将prev window的数据结构清理后待用*/ clear_top_tasks_table(rq->wrq.top_tasks[prev_table]); //memset(arg, 0, NUM_LOAD_INDICES * sizeof(u8)); clear_top_tasks_bitmap(rq->wrq.top_tasks_bitmap[prev_table]);//将bit数组的内容清0,然后将 NUM_LOAD_INDICES bit设置为1 /*若是已经经历了多个window,那么之前标记的curr window也是旧窗口了，需要清理待用*/ if (full_window) { curr_top = 0; clear_top_tasks_table(rq->wrq.top_tasks[curr_table]); clear_top_tasks_bitmap(rq->wrq.top_tasks_bitmap[curr_table]); } /*两个window的下标进行翻转，curr-->prev,prev-->curr*/ rq->wrq.curr_table = prev_table; rq->wrq.prev_top = curr_top; rq->wrq.curr_top = 0; }
清理的是 rq->wrq 的 top_task 相关的成员。
然后调用 account_busy_for_cpu_time 判断清理后任务的和cpu的是否还需要更新上去
/* update_cpu_busy_time-->this, 传参(rq, p, irqtime, event) */ static int account_busy_for_cpu_time(struct rq *rq, struct task_struct *p, u64 irqtime, int event) { if (is_idle_task(p)) { /* TASK_WAKE && TASK_MIGRATE is not possible on idle task! idle task不可能出现唤醒和迁移 */ if (event == PICK_NEXT_TASK) return 0; /* PUT_PREV_TASK, TASK_UPDATE && IRQ_UPDATE are left */ return irqtime || cpu_is_waiting_on_io(rq); } if (event == TASK_WAKE) return 0; if (event == PUT_PREV_TASK || event == IRQ_UPDATE) return 1; /* * TASK_UPDATE can be called on sleeping task, when its moved between related groups * TASK_UPDATE 当它在相关组之间移动时可能在睡眠的任务上调用， */ if (event == TASK_UPDATE) { if (rq->curr == p) return 1; return p->on_rq ? SCHED_FREQ_ACCOUNT_WAIT_TIME : 0; //在rq上和或正在迁移是1，但是冒号前后都是0 } /* TASK_MIGRATE, PICK_NEXT_TASK left */ return SCHED_FREQ_ACCOUNT_WAIT_TIME; //0 }
top_task 维护的窗口更新：
/* * update_cpu_busy_time-->this 若p不是idle任务，就调用，传参(p, rq, old_curr_window, new_window, full_window) * @ old_curr_window：取自 p->wts.curr_window，表示p在窗口翻转前在当前窗口的运行时间 * @ new_window：bool值，若ms<ws为真 * @ full_window：bool值，若ws-ms>window_size为真 */ static void update_top_tasks(struct task_struct *p, struct rq *rq, u32 old_curr_window, int new_window, bool full_window) { /* 只使用两个窗口进行跟踪，当前是0，perv就是1，当前是1，prev就是0，两个数据结构构成一个环形缓存区 */ u8 curr = rq->wrq.curr_table; u8 prev = 1 - curr; u8 *curr_table = rq->wrq.top_tasks[curr]; u8 *prev_table = rq->wrq.top_tasks[prev]; int old_index, new_index, update_index; u32 curr_window = p->wts.curr_window; u32 prev_window = p->wts.prev_window; bool zero_index_update; /* 两个窗的运行时间相等或新窗口还没有到来 */ if (old_curr_window == curr_window && !new_window) return; /* 在一个窗中运行的时间越长，index就越大, 参数是一个窗口中的运行时长*/ old_index = load_to_index(old_curr_window); new_index = load_to_index(curr_window); if (!new_window) { zero_index_update = !old_curr_window && curr_window; if (old_index != new_index || zero_index_update) { if (old_curr_window) curr_table[old_index] -= 1; //上一个窗口的累计值衰减 if (curr_window) curr_table[new_index] += 1; //新窗口的累计值增加 if (new_index > rq->wrq.curr_top) rq->wrq.curr_top = new_index; //更新rq->wrq.curr_top成员 } if (!curr_table[old_index]) __clear_bit(NUM_LOAD_INDICES - old_index - 1, rq->wrq.top_tasks_bitmap[curr]); //这个bit数组表示此运行时间下有没有计数值 if (curr_table[new_index] == 1) __set_bit(NUM_LOAD_INDICES - new_index - 1, rq->wrq.top_tasks_bitmap[curr]); return; } /*---下面是new_window!=0的情况了---*/ /* * 对于此任务来说窗口已经翻转。 当我们到达这里时，curr/prev 交换已经发生。 * 所以我们需要对新索引使用 prev_window 。 */ update_index = load_to_index(prev_window); if (full_window) { //至少有一个满窗 /* * 这里有两个案例。 要么'p' 运行了整个窗口，要么根本不运行。 在任何一种情况下， * prev 表中都没有条目。 如果 'p' 运行整个窗口，我们只需要在 prev 表中创建一个 * 新条目。 在这种情况下，update_index 将对应于 sched_ravg_window，因此我们可 * 以无条件地更新顶部索引。 */ if (prev_window) { prev_table[update_index] += 1; rq->wrq.prev_top = update_index; } if (prev_table[update_index] == 1) __set_bit(NUM_LOAD_INDICES - update_index - 1, rq->wrq.top_tasks_bitmap[prev]); } else { //产生了新窗口，但是还没达到一个满窗 zero_index_update = !old_curr_window && prev_window; if (old_index != update_index || zero_index_update) { if (old_curr_window) prev_table[old_index] -= 1; prev_table[update_index] += 1; if (update_index > rq->wrq.prev_top) rq->wrq.prev_top = update_index; /* 减为0是清理对应bit，首次设置为1时设置相应bit。top_tasks_bitmap[]在任务迁移时有使用 */ if (!prev_table[old_index]) __clear_bit(NUM_LOAD_INDICES - old_index - 1, rq->wrq.top_tasks_bitmap[prev]); if (prev_table[update_index] == 1) __set_bit(NUM_LOAD_INDICES - update_index - 1, rq->wrq.top_tasks_bitmap[prev]); } } if (curr_window) { curr_table[new_index] += 1; if (new_index > rq->wrq.curr_top) rq->wrq.curr_top = new_index; if (curr_table[new_index] == 1) __set_bit(NUM_LOAD_INDICES - new_index - 1, rq->wrq.top_tasks_bitmap[curr]); } }
top_tasks 的维护中也使用到了桶，新窗运行时间对应的 curr_table[]成员加1，之前窗口运行时间对应的 prev_table[] 成员减1。
9. update_task_pred_demand 函数
/* * 在窗口翻转时计算任务的预测需求。如果任务当前窗口繁忙时间超过预测需求，则在此处更新以反映任务需求。 */ void update_task_pred_demand(struct rq *rq, struct task_struct *p, int event) { u32 new, old; u16 new_scaled; if (!sched_predl) //1 return; if (is_idle_task(p)) return; if (event != PUT_PREV_TASK && event != TASK_UPDATE && (!SCHED_FREQ_ACCOUNT_WAIT_TIME || (event != TASK_MIGRATE && event != PICK_NEXT_TASK))) return; /* * 当它在相关组之间移动时，TASK_UPDATE 可以在睡眠任务上调用。 */ if (event == TASK_UPDATE) { if (!p->on_rq && !SCHED_FREQ_ACCOUNT_WAIT_TIME) return; } new = calc_pred_demand(p); old = p->wts.pred_demand; if (old >= new) return; /*---下面就是 new > old 的情况---*/ new_scaled = scale_demand(new); //new/window_size*1024 /* p是on rq的状态并且不是已经被throttle的deadline任务 */ if (task_on_rq_queued(p) && (!task_has_dl_policy(p) || !p->dl.dl_throttled)) fixup_walt_sched_stats_common(rq, p, p->wts.demand_scaled, new_scaled); p->wts.pred_demand = new; p->wts.pred_demand_scaled = new_scaled; }
注意，这里再次调用了 fixup_walt_sched_stats_common，在 walt_update_task_ravg 函数中，在 update_history 中已经调用过一次，进入条件也相同，也是p在队列上。
static inline u32 calc_pred_demand(struct task_struct *p) { /* 预测的需求比当前窗口的大，就返回预测的需求 */ if (p->wts.pred_demand >= p->wts.curr_window) return p->wts.pred_demand; return get_pred_busy(p, busy_to_bucket(p->wts.curr_window), p->wts.curr_window); }
get_pred_busy 和 busy_to_bucket 两个函数上面都有列出。
10. run_walt_irq_work 函数
static inline void run_walt_irq_work(u64 old_window_start, struct rq *rq) //walt.c { u64 result; /*若是还是同一个窗，直接退出*/ if (old_window_start == rq->wrq.window_start) return; /* * atomic64_cmpxchg(*ptr, old, new) 函数功能是：将old和ptr指向的内容比较，如果相等， * 则将new写入到ptr指向的内存中，并返回old，如果不相等，则返回ptr指向的内容。 */ result = atomic64_cmpxchg(&walt_irq_work_lastq_ws, old_window_start, rq->wrq.window_start); if (result == old_window_start) { walt_irq_work_queue(&walt_cpufreq_irq_work); //触发回调 walt_irq_work()，构成一个"内核线程"，循环往复执行 trace_walt_window_rollover(rq->wrq.window_start); } }
walt_irq_work_queue 会触发 walt_irq_work() 被调用，这个函数中又会调用 walt_update_task_ravg，walt_update_task_ravg 函数会在每个tick中调用，这里这样实现可能是针对没有tick的场景使用。
其中Trace:
trace_walt_window_rollover(rq->wrq.window_start);
参数原型：
(u64 window_start)
打印内容：
//20ms间隔执行一次 <idle>-0 [002] d..2 48262.320451: walt_window_rollover: window_start=48262548000001 <idle>-0 [001] d.h2 48262.340457: walt_window_rollover: window_start=48262568000001
字段解析：
window_start 就是打印 rq->wrq.window_start 的记录的时间值，单位是ns.
四、总结
1. WALT负载计算算法是基于窗口的，对window有一个rollover的操作，只跟踪curr和prev两个窗口，curr窗口的下标由 wrq.curr_table 指向，两个窗口构成一个唤醒缓冲区，prev和curr进行不断切换。
2. walt_update_task_ravg 函数通过其 event 成员决定对哪些事件计算负载，再根据其调用路径和其调用函数对是否是在rq上，是否是p=rq->curr可以判断统计的是哪部分的负载。
3. 预测负载这块，对于任务和CPU都使用了桶，任务是10个桶，对于cpu的curr和prev两个窗口分别是1000个成员，命中累加，不命中衰减。
4. walt_update_task_ravg 在tick的调用路径中有调用，应该是为了无tick情况下walt仍然能正常工作，使用irq_work构成一个内核线程以一个窗口的周期来更新窗口。
五、补充
1. task util的获取：task_util() WALT: p->wts.demand_scaled；PELT: p->se.avg.util_avg
2. cpu util的获取：cpu_util_cum() WALT: rq->wrq.cum_window_demand_scaled；PELT: rq->cfs.avg.util_avg
3. task_util() 函数
static inline unsigned long task_util(struct task_struct *p) { #ifdef CONFIG_SCHED_WALT if (likely(!walt_disabled && sysctl_sched_use_walt_task_util)) return p->wts.demand_scaled; #endif return READ_ONCE(p->se.avg.util_avg); }
本文参考链接：https://www.cnblogs.com/hellokitty2/p/15376806.html
