Codebase reference: https://android.googlesource.com/kernel/common/+/android-4.9
kernel-4.14 EAS預設是PELT，4.9之前PELT還沒那麼成熟時採用的WALT
EAS關鍵的一環就是整個系統loading tracking了，那WALT是怎麼計算一個CPU的loading呢、或是更基本的一個task(泛指thread/process)的 loading(utilization)?
首先看看task_util是怎麼告訴我們一個task的loading的
|
1 2 3 4 5 6 7 8 9 10 |
static inline unsigned long task_util(struct task_struct *p) { #ifdef CONFIG_SCHED_WALT if (!walt_disabled && sysctl_sched_use_walt_task_util) { unsigned long demand = p->ravg.demand; return (demand << SCHED_CAPACITY_SHIFT) / walt_ravg_window; } #endif return p->se.avg.util_avg; } |
這裡被config包住，在WALT定義中task的loading是要看ravg.demand這個參數
而se.avg.util_avg則是PELT會用的
那接著我們來看看task初始化的時候，ravg.demand會怎樣被定義。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
static void __sched_fork(unsigned long clone_flags, struct task_struct *p) { p->on_rq = 0; p->se.on_rq = 0; p->se.exec_start = 0; p->se.sum_exec_runtime = 0; p->se.prev_sum_exec_runtime = 0; p->se.nr_migrations = 0; p->se.vruntime = 0; #ifdef CONFIG_SCHED_WALT p->last_sleep_ts = 0; #endif INIT_LIST_HEAD(&p->se.group_node); walt_init_new_task_load(p); #ifdef CONFIG_FAIR_GROUP_SCHED p->se.cfs_rq = NULL; #endif #ifdef CONFIG_SCHEDSTATS /* Even if schedstat is disabled, there should not be garbage */ memset(&p->se.statistics, 0, sizeof(p->se.statistics)); #endif RB_CLEAR_NODE(&p->dl.rb_node); init_dl_task_timer(&p->dl); __dl_clear_params(p); INIT_LIST_HEAD(&p->rt.run_list); p->rt.timeout = 0; p->rt.time_slice = sched_rr_timeslice; p->rt.on_rq = 0; p->rt.on_list = 0; #ifdef CONFIG_PREEMPT_NOTIFIERS INIT_HLIST_HEAD(&p->preempt_notifiers); #endif #ifdef CONFIG_NUMA_BALANCING if (p->mm && atomic_read(&p->mm->mm_users) == 1) { p->mm->numa_next_scan = jiffies + msecs_to_jiffies(sysctl_numa_balancing_scan_delay); p->mm->numa_scan_seq = 0; } if (clone_flags & CLONE_VM) p->numa_preferred_nid = current->numa_preferred_nid; else p->numa_preferred_nid = -1; p->node_stamp = 0ULL; p->numa_scan_seq = p->mm ? p->mm->numa_scan_seq : 0; p->numa_scan_period = sysctl_numa_balancing_scan_delay; p->numa_work.next = &p->numa_work; p->numa_faults = NULL; p->last_task_numa_placement = 0; p->last_sum_exec_runtime = 0; p->numa_group = NULL; #endif /* CONFIG_NUMA_BALANCING */ } |
fork的時候會初始化walt估計task的loading
而其實在wake_up_new_task這裡還會再重新做一次，意義不明…
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
void walt_init_new_task_load(struct task_struct *p) { int i; u32 init_load_windows = div64_u64((u64)sysctl_sched_walt_init_task_load_pct * (u64)walt_ravg_window, 100); u32 init_load_pct = current->init_load_pct; p->init_load_pct = 0; memset(&p->ravg, 0, sizeof(struct ravg)); if (init_load_pct) { init_load_windows = div64_u64((u64)init_load_pct * (u64)walt_ravg_window, 100); } p->ravg.demand = init_load_windows; for (i = 0; i < RAVG_HIST_SIZE_MAX; ++i) p->ravg.sum_history[i] = init_load_windows; } |
可以看到這邊p->ravg.demand WALT估計loading會在這裡被assign value為 sysctl_sched_walt_init_task_load_pct * walt_ravg_window / 100;
預設值可以在 kernel/sched/walt.c找到
|
1 |
unsigned int sysctl_sched_walt_init_task_load_pct = 15; |
sysctl_sched_walt_init_task_load_pct 這個參數可以在proc/sys/kernel/sched_walt_init_task_load_pct 做調整
所以以native kernel new task的初始loading: sysctl_sched_walt_init_task_load_pct * 1024 / 100 = 153
初始化之後我們來看看ravg.demand是如何被更新
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
/* 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); update_window_start(rq, wallclock); if (!p->ravg.mark_start) goto done; update_task_demand(p, rq, event, wallclock); update_cpu_busy_time(p, rq, event, wallclock, irqtime); done: trace_walt_update_task_ravg(p, rq, event, wallclock, irqtime); p->ravg.mark_start = wallclock; } |
grep “walt_update_task_ravg” 後可以在kernel/scehed/core.c下 找到幾處有call walt_update_task_ravg
- scheduler_tick (週期性update)
- __schedule (排程要做context switch前會 update task loading)
- try_to_wake_up (喚醒前update)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
static void update_task_demand(struct task_struct *p, struct rq *rq, int event, u64 wallclock) { u64 mark_start = p->ravg.mark_start; u64 delta, window_start = rq->window_start; int new_window, nr_full_windows; u32 window_size = walt_ravg_window; new_window = mark_start < window_start; if (!account_busy_for_task_demand(p, event)) { if (new_window) /* If the time accounted isn't being accounted as * busy time, and a new window started, only the * previous window need be closed out with the * pre-existing demand. Multiple windows may have * elapsed, but since empty windows are dropped, * it is not necessary to account those. */ update_history(rq, p, p->ravg.sum, 1, event); return; } if (!new_window) { /* The simple case - busy time contained within the existing * window. */ add_to_task_demand(rq, p, wallclock - mark_start); return; } /* Busy time spans at least two windows. Temporarily rewind * window_start to first window boundary after 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 */ add_to_task_demand(rq, p, window_start - mark_start); /* Push new sample(s) into task's demand history */ update_history(rq, p, p->ravg.sum, 1, event); if (nr_full_windows) update_history(rq, p, scale_exec_time(window_size, rq), nr_full_windows, event); /* Roll window_start back to current to process any remainder * in current window. */ window_start += (u64)nr_full_windows * (u64)window_size; /* Process (wallclock - window_start) next */ mark_start = window_start; add_to_task_demand(rq, p, wallclock - mark_start); } |
這邊有看到一些windows start、delta的計算，但還是沒有看到ravg.demand如何被更新
|
1 2 3 4 5 |
/* Push new sample(s) into task's demand history */ update_history(rq, p, p->ravg.sum, 1, event); if (nr_full_windows) update_history(rq, p, scale_exec_time(window_size, rq), nr_full_windows, event); |
註解有講到demand所以繼續往下看
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
/* * Called when new window is starting for a task, to record cpu usage over * recently concluded window(s). Normally 'samples' should be 1. It can be > 1 * when, say, a real-time task runs without preemption for several windows at a * stretch. */ static void update_history(struct rq *rq, struct task_struct *p, u32 runtime, int samples, int event) { u32 *hist = &p->ravg.sum_history[0]; int ridx, widx; u32 max = 0, avg, demand; u64 sum = 0; /* Ignore windows where task had no activity */ if (!runtime || is_idle_task(p) || exiting_task(p) || !samples) goto done; /* Push new 'runtime' value onto stack */ widx = walt_ravg_hist_size - 1; ridx = widx - samples; for (; ridx >= 0; --widx, --ridx) { hist[widx] = hist[ridx]; sum += hist[widx]; if (hist[widx] > max) max = hist[widx]; } for (widx = 0; widx < samples && widx < walt_ravg_hist_size; widx++) { hist[widx] = runtime; sum += hist[widx]; if (hist[widx] > max) max = hist[widx]; } p->ravg.sum = 0; if (walt_window_stats_policy == WINDOW_STATS_RECENT) { demand = runtime; } else if (walt_window_stats_policy == WINDOW_STATS_MAX) { demand = max; } else { avg = div64_u64(sum, walt_ravg_hist_size); if (walt_window_stats_policy == WINDOW_STATS_AVG) demand = avg; else demand = max(avg, runtime); } /* * A throttled deadline sched class task gets dequeued without * changing p->on_rq. Since the dequeue decrements hmp stats * avoid decrementing it here again. * * When window is rolled over, the cumulative window demand * is reset to the cumulative runnable average (contribution from * the tasks on the runqueue). If the current task is dequeued * already, it's demand is not included in the cumulative runnable * average. So add the task demand separately to cumulative window * demand. */ if (!task_has_dl_policy(p) || !p->dl.dl_throttled) { if (task_on_rq_queued(p)) fixup_cumulative_runnable_avg(rq, p, demand); else if (rq->curr == p) fixup_cum_window_demand(rq, demand); } p->ravg.demand = demand; done: trace_walt_update_history(rq, p, runtime, samples, event); return; } |
一路往下可以最終在這裡看到
p->ravg.demand = demand;
從上面往下看依序看到 會蒐集 widx – samples 這區間內的windows history demand
繼續往下看可以看到walt_window_stats_policy 來決定demand是採recent max or average的決策，這也是可以調整的
大概是這樣。
之後會再繼續往下寫一篇DVFS相關的。
更多資料、圖像化可以參考這篇:
https://blog.csdn.net/wukongmingjing/article/details/81633225
