调度器23—EAS
2021/12/27 23:13:15
本文主要是介绍调度器23—EAS，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
基于 Linux-5.10
一、EAS概述
EAS在CPU调度领域，在为任务选核是起作用，目的是保证性能的情况下尽可能节省功耗。其基于的能量模型框架（EnergyModel (EM) framework）是一个通用的接口模块，该模块连接了支持不同 perf level 的驱动模块和系统中的其他想要感知能量消耗的模块。其中这里说的EAS，CPU调度器和CPU驱动模块就是一个典型的例子，调度器希望能够感知底层CPU能量的消耗，从而做出更优的选核策略。对于CPU设备，各个Cluster有各自独立的调频机制，Cluster内的CPU统一工作在一个频率下(Qcom做了更改，使每个CPU频点都可以不同)。因此每个Cluster就会形成一W个性能域（performance domain）。调度器通过 EM framework 接口可以获取CPU在各个 performance level 的能量消耗。
二、相关数据结构
1. struct perf_domain
struct perf_domain {
struct em_perf_domain *em_pd;
struct perf_domain *next; //构成单链表
struct rcu_head rcu; //保护此链表的rcu
};
perf_comain 结构表示一个CPU性能域，每一个性能域都是由 perf_domain 抽象。perf_comain 和 cpufreq policy 是一一对应的，对于一个4+3+1结构的平台，因此系统共计3个perf domain，形成链表，链表头在全局 root_domain 中。root_domain 的其它相关成员一并列出，如下：
struct root_domain {
...
int overload; //该root domain，即系统是否处于overload状态
int overutilized; //该root domain，即系统是否处于overutilized状态
unsigned long max_cpu_capacity; //系统中算力最大的那个cpu的算力
struct perf_domain __rcu *pd; //perf_domain单链表的表头
}
澄清一下 overload 和 overutilized 这两个概念，在单个cpu overload/overutilized 基础上，又定义了 root domain（即整个系统）的overload和overutilized。
(1) 对于一个 CPU 而言，其处于 overload 状态则说明其 rq 上有大于等于2个任务，或者虽然只有一个任务，但是是 misfit task。
(2) 对于一个 CPU 而言，其处于 overutilized 状态说明该 cpu 的 utility 超过其 capacity（缺省预留20%的算力，另外，这里的 capacity 是用于cfs任务的算力）。
(3) 对于 root domain，overload 表示至少有一个 cpu 处于 overload 状态。overutilized 表示至少有一个 cpu 处于 overutilized 状态。
overutilized 状态非常重要，它决定了调度器是否启用EAS，只有在系统没有 overutilized 的情况下EAS才会生效。overload和newidle balance的频次控制相关，当系统在overload的情况下，newidle balance才会启动进行均衡。
2. struct em_perf_domain
struct em_perf_domain {
struct em_perf_state *table; //performance states, 里面的频点必须是升序排列，em_cpu_energy()依赖于此
int nr_perf_states; //table中元素的个数
int milliwatts; //指示功率值的标志,以毫瓦或其他一些标度为单位。
unsigned long cpus[]; //此性能域包含哪些cpu
};
此结构存放在cpu对应的 struct device 结构中，那就是per-cpu的结构了！在 EM framework 中，使用 em_perf_domain 来抽象一个 performance domain。
3. struct em_perf_state
struct em_perf_state {
unsigned long frequency; //单位KHz，与 CPUFreq 保持一致
unsigned long power; //单位毫瓦，此频点下的功率，它可以是总的功耗：静态+动态
unsigned long cost; //与频点下的成本系数，功率计算过程中使用，等于：power * max_frequency / frequency
};
每个性能域都有若干个 perf level，每一个 perf level 对应能耗是不同的，使用用 struct em_perf_state 来表示一个 perf level 下的能耗信息。
三、能量计算
1. 能量计算方法概述
基本计算公式：能量 = 功率 X 时间
对于CPU而言，要计算其能量需要进一步细化公式（省略了CPU处于idle状态的能耗）：CPU在此频点的能量消耗 = CPU在此频点的功率 X CPU在此频点的运行时间。
EM中记录了CPU各个频点的功率，使用 em_perf_state::power 来表示，这是事先Soc供应商计算好的。而运行时间是通过 cpu utility 来表示的。有一个不太方便的地方就是CPU utility 是归一化到 1024 的一个值，失去了在某个频点的运行时间长度的信息，不过可以转换：CPU在此频点运行时间 = cpu_util / cpu_current_capacity。注意计算energy只是为了比较大小，就省略了周期。
CPU在某个 perf-state(即某个频点)下的算力：ps->cap = scale_cpu * (ps->freq / cpu_max_freq) ----(1)。scale_cpu是cpu在最大频点时scale到1024后的算力。
不考虑 idle state 的功耗，CPU在某个 perf-state 的能量估计：cpu_nrg = ps->power * (cpu_util / ps->cap) ------(2)。
把(1)带入(2)得到：cpu_nrg = (ps->power * cpu_max_freq /ps->freq) * (cpu_util / scale_cpu) ----(3)。
上面公式的第一项是一个常量，保存在 em_perf_state 的 cost 成员中，即CPU在某个 perf-state 的能量估计：cpu_nrg = ps->cost * cpu_util / scale_cpu ----(4)。
由于每个 perf domain 中的微架构都是一样的，因此 scale_cpu 的值是一样的，那么 cost 也是一样的，通过提取公因式可以得到整个 perf domain(cpu cluster)的能耗公式：pd_nrg = ps->cost * \Sum cpu_util / scale_cpu ----(5)。
三、能量模型的构建
1. perf domain 的构建
在CPU拓扑初始化的时候，通过 build_perf_domains() 创建各个perf domain，并作为 root domain 的 perf domain 链表。
(1) 函数实现
//kernel/sched/topology.c
static bool build_perf_domains(const struct cpumask *cpu_map)
{
int i, nr_pd = 0, nr_ps = 0, nr_cpus = cpumask_weight(cpu_map);
struct perf_domain *pd = NULL, *tmp;
int cpu = cpumask_first(cpu_map);
struct root_domain *rd = cpu_rq(cpu)->rd;
bool eas_check = false;
if (!sysctl_sched_energy_aware) //若没有使能EAS，直接不build,退出
goto free;
...
for_each_cpu(i, cpu_map) {
/* Skip already covered CPUs. */
if (find_pd(pd, i)) //跳过已经被包含在某个pd中的cpu，这样的话各个cluster的首个cpu才能继续往下执行
continue;
/* Create the new pd and add it to the local list. */
tmp = pd_init(i);
tmp->next = pd; //单链表上元素个数为cpu的个数
pd = tmp; //等同于头插法，后probe的cluster插入在链表头，pd指向链表头
/* Count performance domains and performance states for the complexity check. */
nr_pd++;
//所有pd的ps的数量之和
nr_ps += em_pd_nr_perf_states(pd->em_pd); //return pd->nr_perf_states;
}
/* Bail out if the Energy Model complexity is too high. */
if (nr_pd * (nr_ps + nr_cpus) > EM_MAX_COMPLEXITY) { //2048 能量模型的复杂度不能太高
WARN(1, "rd %*pbl: Failed to start EAS, EM complexity is too high\n", cpumask_pr_args(cpu_map));
goto free;
}
//打印整个pd的信息，debug才会打印
perf_domain_debug(cpu_map, pd);
/* Attach the new list of performance domains to the root domain. */
tmp = rd->pd;
rcu_assign_pointer(rd->pd, pd); //全局变量 root_domain::pd 指向perf_domain链表头
if (tmp)
call_rcu(&tmp->rcu, destroy_perf_domain_rcu); //rcu更新，root_domain::pd指向新的，删除旧的
pr_info("nr_pd = %d\n", nr_pd); //cpu7没有isolate就是3，否则就是2
return !!pd;
free:
free_pd(pd);
tmp = rd->pd;
rcu_assign_pointer(rd->pd, NULL);
if (tmp)
call_rcu(&tmp->rcu, destroy_perf_domain_rcu);
return false;
}
static struct perf_domain *pd_init(int cpu)
{
struct em_perf_domain *obj = em_cpu_get(cpu);
struct perf_domain *pd = kzalloc(sizeof(*pd), GFP_KERNEL);
pd->em_pd = obj; //指针指向
return pd;
}
//kernel/power/energy_model.c
struct em_perf_domain *em_cpu_get(int cpu)
{
struct device *cpu_dev = get_cpu_device(cpu); //return per_cpu(cpu_sys_devices, cpu);
return em_pd_get(cpu_dev); //return dev->em_pd, 直接存放在cpu对应的device结构中的
}
root_domain的pd成员指向的perf-domain链表是头插法，各个pd在链表上的顺序是 root_domain->pd --> cluster2->pd --> --> cluster1->pd --> cluster0->pd。pd是per-cluster的，不是per-cpu的。只有一个cluster 的全部cpu都被isolate了，其pd才会从链表上删除。
(2)调用路径：
init_cpu_capacity_callback //arch_topology.c 初始化时cpu算力更新时执行
schedule_work(&update_topology_flags_work);
init_cpu_capacity_callback //arch_topology.c
update_topology_flags_workfn //arch_topology.c
cpuset_hotplug_workfn //cpuset.c 下面有调用路径
///proc/sys/kernel/sched_energy_aware 的响应函数
sched_energy_aware_handler //topology.c
rebuild_sched_domains //cpuset.c
pause_cpus //cpu.c 执行出错的时候调用
//cpu.c cpuhp_hp_states[]的"sched:active"的.startup.single回调
resume_cpus //cpu.c
sched_cpus_activate //core.c
pause_cpus //cpu.c
sched_cpus_deactivate_nosync //core.c
sched_cpu_activate //core.c
cpuset_cpu_active //core.c
//cpu.c cpuhp_hp_states[]的"sched:active"的.teardown.single回调
resume_cpus //cpu.c
sched_cpus_activate //core.c
sched_cpu_deactivate //core.c
pause_cpus //cpu.c
sched_cpus_deactivate_nosync //core.c
_sched_cpu_deactivate
cpuset_cpu_inactive
cpuset_update_active_cpus //cpuset.c
cpuset_track_online_nodes_nb.notifier_call //cpu.c
cpuset_track_online_nodes //cpuset.c
schedule_work(&cpuset_hotplug_work);
resume_cpus //cpu.c
cpuset_update_active_cpus_affine //cpuset.c
schedule_work_on(cpu, &cpuset_hotplug_work); //调用指定cpu上的
//文件/dev/cpuset/[<group>/]cpus、mems的写回调函数
cpuset_write_resmask //cpuset.c
flush_work(&cpuset_hotplug_work); //执行完工作队列上的任务，只是flush
cpuset_hotplug_workfn //工作队列处理函数
rebuild_sched_domains_locked
partition_sched_domains_locked
build_perf_domains //每次传参都是cpu0-6 或 cpu0-7，不是一个cluster一个cluster传参的
cpuset_hotplug_workfn 下面的部分是加 dump_stack() 打印出来的内容，内核启动、online/offline、isolate/unisolate 调用的路径相同。上面部分是按代码实现上找出的调用路径。
在每个CPU online/offline、isolate/unisolate 都会触发domain的rebuild流程。
cgroup分组中指定对cpus文件的改动不会触发rebuild流程。
em_pd->cpus仅仅表示一个cluster包含哪些cpu，isolate/unisolate和online/offline cpu对其值没影响。
四、EAS全局控制开关
sysctl全局控制变量为 sysctl_sched_energy_aware，对应的控制文件为 /proc/sys/kernel/sched_energy_aware。
//kernel/sched/topology.c
int sched_energy_aware_handler(struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)
{
int ret, state;
if (write && !capable(CAP_SYS_ADMIN))
return -EPERM;
ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
if (!ret && write) {
state = static_branch_unlikely(&sched_energy_present);
if (state != sysctl_sched_energy_aware) {
mutex_lock(&sched_energy_mutex);
sched_energy_update = 1; //partition_sched_domains_locked中唯一使用
rebuild_sched_domains();
sched_energy_update = 0;
mutex_unlock(&sched_energy_mutex);
}
}
return ret;
}
sched_energy_present 的更新：
/*
* kernel/sched/topology.c
* partition_sched_domains_locked --> sched_energy_set
*/
static void sched_energy_set(bool has_eas)
{
if (!has_eas && static_branch_unlikely(&sched_energy_present)) {
static_branch_disable_cpuslocked(&sched_energy_present);
} else if (has_eas && !static_branch_unlikely(&sched_energy_present)) {
static_branch_enable_cpuslocked(&sched_energy_present);
}
}
sched_energy_enabled() 中判断这个static key值。使用位置有2：
(1) 负载均衡路径中，find_busiest_group() 中判断使能了EAS并且系统没有overutilized，就终止此次balance。
(2) 任务选核路径中，select_task_rq_fair() 中判断使能了EAS才会调用find_energy_efficient_cpu()进行EAS路径选核。
五、EAS作用场景——EAS选核
1. 唤醒场景的进入EAS选核的条件
对于阻塞状态的任务，异步事件或者其他线程调用 try_to_wake_up() 会唤醒该线程，唤醒后会进行task placement，也即为唤醒任务选核。如果使能了EAS，那么优先采用EAS选核。当然，只有在轻载（系统没有overutilized）才会启用EAS，重载下（只要有一个cpu处于over utilized状态）还是使用传统内核算法选核。
static int select_task_rq_fair(struct task_struct *p, int prev_cpu, int sd_flag, int wake_flags)
{
int sync = (wake_flags & WF_SYNC) && !(current->flags & PF_EXITING);
...
trace_android_rvh_select_task_rq_fair(p, prev_cpu, sd_flag, wake_flags, &target_cpu);
if (target_cpu >= 0)
return target_cpu;
...
//只有唤醒场景才有可能走EAS选核路径
if (sd_flag & SD_BALANCE_WAKE) {
//sysctl全局使能控制是否开启EAS
if (sched_energy_enabled()) {
new_cpu = find_energy_efficient_cpu(p, prev_cpu, sync);
if (new_cpu >= 0)
return new_cpu; //只要EAS选到核，就使用EAS的选核结果
}
}
...
}
由上面代码可见，EAS只用于wakeup，fork和exec均衡都不走EAS选核算法。find_energy_efficient_cpu()是EAS的主选核路径，使用EAS选核需要满足两个条件：是唤醒路径且使能了EAS特性。EAS选中了适合的CPU就直接返回。如果EAS选核不成功，那么恢复缺省cpu为prev cpu，走传统选核路径重新选核。
2. EAS选核细节
EAS选核细节在 find_energy_efficient_cpu() 中体现，如下：
static int find_energy_efficient_cpu(struct task_struct *p, int prev_cpu, int sync)
{
unsigned long prev_delta = ULONG_MAX, best_delta = ULONG_MAX;
struct root_domain *rd = cpu_rq(smp_processor_id())->rd;
int max_spare_cap_cpu_ls = prev_cpu, best_idle_cpu = -1;
unsigned long max_spare_cap_ls = 0, target_cap;
unsigned long cpu_cap, util, base_energy = 0;
bool boosted, latency_sensitive = false;
unsigned int min_exit_lat = UINT_MAX;
int cpu, best_energy_cpu = prev_cpu;
struct cpuidle_state *idle;
struct sched_domain *sd;
struct perf_domain *pd;
int new_cpu = INT_MAX;
//更新任务负载
sync_entity_load_avg(&p->se);
//Vendor厂商或ODM厂商可能会注册hook从而不使用这个函数
trace_android_rvh_find_energy_efficient_cpu(p, prev_cpu, sync, &new_cpu); //hook
if (new_cpu != INT_MAX)
return new_cpu;
rcu_read_lock();
//从rd中获取 perf_domain 链表
pd = rcu_dereference(rd->pd);
if (!pd || READ_ONCE(rd->overutilized)) //若系统中只要有一个cpu是overutilized，就退出EAS选核
goto fail;
cpu = smp_processor_id(); //当前正在运行的cpu
//若是同步唤醒，且当前cpu只有本任务在运行，且唤醒的任务运行运行在此cpu上，且此cpu的算力能满足被唤醒任务的需求，那就直接选择当前cpu
if (sync && cpu_rq(cpu)->nr_running == 1 && cpumask_test_cpu(cpu, p->cpus_ptr) && task_fits_capacity(p, capacity_of(cpu))) { //uclamp util小于80%的CPU算力
rcu_read_unlock();
return cpu;
}
/* Energy-aware wake-up happens on the lowest sched_domain starting from sd_asym_cpucapacity spanning over this_cpu and prev_cpu. */
sd = rcu_dereference(*this_cpu_ptr(&sd_asym_cpucapacity)); //返回此cpu对应的DIE层级的sd
//若prev_cpu是个有效的cpuid，在手机上，这个判断完全是多于的
while (sd && !cpumask_test_cpu(prev_cpu, sched_domain_span(sd)))
sd = sd->parent;
if (!sd)
goto fail;
//max(util, util_est) 任务p的util为0，goto unlock是直接返回prev_cpu
if (!task_util_est(p))
goto unlock;
//待唤醒任务p所在cgroup的是否设置了cpu.uclamp.latency_sensitive 标志
latency_sensitive = uclamp_latency_sensitive(p);
//受全局和cgroup限制后的任务p的uclamp min是否还大于0
boosted = uclamp_boosted(p);
target_cap = boosted ? 0 : ULONG_MAX; //这个值是根据下面的使用逻辑赋的
//从大核开始遍历，次序为：大核-->中核-->小核。这个遍历次序无关紧要，疑问是所有都遍历完才做的决策
for (; pd; pd = pd->next) {
//循环体中的变量，遍历每个pd时都是新的
unsigned long cur_delta, spare_cap, max_spare_cap = 0;
unsigned long base_energy_pd;
int max_spare_cap_cpu = -1;
/* Compute the 'base' energy of the pd, without @p */
//计算不包括p的情况下此pd的energy,作为基准energy。注意dst_cpu传-1,p的util也会从其之前运行的cpu上被减去
base_energy_pd = compute_energy(p, -1, pd);
//不包括p的情况下系统的总energy
base_energy += base_energy_pd;
/*
* 这里竟然没有判断是否为active的cpu! pd->em_pd->cpus仅表示一个cluster包含哪些cpu, offline的cpu会从sd->span
* 中清除掉，但是isolated的不会。上面'base' energy的计算也可能有问题。
*/
for_each_cpu_and(cpu, perf_domain_span(pd), sched_domain_span(sd)) {
if (!cpumask_test_cpu(cpu, p->cpus_ptr)) //过滤掉p不允许运行的cpu核
continue;
util = cpu_util_next(cpu, p, cpu); //计算p放到此cpu上后此cpu上的util
cpu_cap = capacity_of(cpu);
spare_cap = cpu_cap;
lsub_positive(&spare_cap, util); //计算p放到此cpu上后此cpu还剩余的算力
/*
* Skip CPUs that cannot satisfy the capacity request. IOW, placing the task there would make the CPU
* overutilized. Take uclamp into account to see how much capacity we can get out of the CPU; this is
* aligned with schedutil_cpu_util().
*/
//对util进行一下uclamp，若clmap后cpu算力不满足需求了，就放弃此cpu的继续探测
util = uclamp_rq_util_with(cpu_rq(cpu), util, p);
if (!fits_capacity(util, cpu_cap))
continue;
/* Always use prev_cpu as a candidate. */
if (!latency_sensitive && cpu == prev_cpu) { //若对延迟不敏感，且对比的这个cpu就是任务之前运行的cpu
prev_delta = compute_energy(p, prev_cpu, pd); //计算p放在prev_cpu后整个pd的energy
prev_delta -= base_energy_pd; //计算p放在prev_cpu后整个pd的增加的energy
best_delta = min(best_delta, prev_delta); //这里又取最小值
}
/*
* Find the CPU with the maximum spare capacity in the performance domain
*/
//记录p放上去后剩余算力最大的cpu和其剩余算力
if (spare_cap > max_spare_cap) {
max_spare_cap = spare_cap;
max_spare_cap_cpu = cpu;
}
if (!latency_sensitive) //若对延迟不敏感，取消对此cpu的继续探测
continue;
/*--- 下面就是延迟敏感情况下的才需要执行的 ---*/
if (idle_cpu(cpu)) {
cpu_cap = capacity_orig_of(cpu);
//若是boosted，target_cap 初始化为0。若是boost，尽量往算力大的CPU上选
if (boosted && cpu_cap < target_cap)
continue;
//若是非boosted，target_cap 初始化为ULONG_MAX。若是非boost，尽量往算力小的CPU上选
if (!boosted && cpu_cap > target_cap)
continue;
idle = idle_get_state(cpu_rq(cpu)); //return rq->idle_state;
//CPU算力相等的情况下，选idle退出延迟最小的。若exit_latency上变为">="，有利于从cluster的首个CPU开始选
if (idle && idle->exit_latency > min_exit_lat && cpu_cap == target_cap)
continue;
if (idle) //对idle的判断只是避免程序崩溃而已，记录合适idle cpu的退出延迟，这里不是最小退出延迟的意思。
min_exit_lat = idle->exit_latency;
target_cap = cpu_cap; //保存idle cpu的算力
best_idle_cpu = cpu; //记录认为是最好的idle cpu:
} else if (spare_cap > max_spare_cap_ls) { //延迟敏感，又非idle cpu
max_spare_cap_ls = spare_cap; //记录最大空余算力
max_spare_cap_cpu_ls = cpu; //记录最大空余算力的cpu
}
}
/*---下面就是一个cluster的cpu遍历完后的处理---*/
/* Evaluate the energy impact of using this CPU.*/
if (!latency_sensitive && max_spare_cap_cpu >= 0 && max_spare_cap_cpu != prev_cpu) {
//计算p放在当前cluster的最大空余算力的cpu上后其pd的energy增量，和其它所有cpu对比这个增量，取较小的
cur_delta = compute_energy(p, max_spare_cap_cpu, pd);
cur_delta -= base_energy_pd;
if (cur_delta < best_delta) {
best_delta = cur_delta;
best_energy_cpu = max_spare_cap_cpu;
}
}
}
//下面就是遍历完了：
unlock:
rcu_read_unlock();
if (latency_sensitive)
return best_idle_cpu >= 0 ? best_idle_cpu : max_spare_cap_cpu_ls;
/*
* Pick the best CPU if prev_cpu cannot be used, or if it saves at least 6% of the energy used by prev_cpu.
*/
if (prev_delta == ULONG_MAX)
return best_energy_cpu;
//放在prev_cpu上的energy增量与放在每个cluster空余算力最大的cpu上energy增量的差值，大于把任务p放在prev_cpu上energy消耗的6.25%
if ((prev_delta - best_delta) > ((prev_delta + base_energy) >> 4))
return best_energy_cpu;
return prev_cpu;
fail:
rcu_read_unlock();
return -1;
}
原生逻辑，所有遍历下，只计算了nr_cluster+2次energy，分别是任务p不放在任何cpu上的基准energy、计算放在prev_cpu上的energy、计算放在每个cluster的最大空余算力的cpu时cluster的energy。主要比较的是在非latency_sensitive的情况下，将任务p放置在各个cluster的剩余算力最大的cpu上，然后对比，选一个能量增量最小的具有最大空余算力的cpu作为备选cpu。
总结这个函数选核逻辑如下：
(1) 若任务p是latency_sensitive的，若best_idle_cpu存在就返回best_idle_cpu，若best_idle_cpu不存在就返回空余算力最大的cpu。best_idle_cpu筛选的条件为：
a. 首先需要是idle的cpu.
b. 若任务p被uclamp min值了，就认为是boost的，那么就尽量往算力大的CPU上选，否则尽量往算力小的CPU上选。
c. 若相同算力的CPU选退出延迟短的，也就是休眠深度浅的CPU.
空余算力最大的cpu的筛选条件为：
a. 首先需要是非idle的cpu.
b. 其次需要是任务p放到此cpu上后，空余算力最大的cpu.
(2) 若任务p是非latency_sensitive的，若prev_cpu不可用(任务p的亲和性不允许运行在prev_cpu或prev_cpu剩余的算力容纳不下任务p了)，那么直接返回best_energy_cpu，
best_energy_cpu的筛选条件：
a. 默认是取prev_cpu的
b. 每个cluster的最大空余算力的那个CPU之间进行PK，放置上任务p到其上后，哪个CPU的energy增量小，选哪一个CPU。
(3) 若任务p是非latency_sensitive的，且prev_cpu可用，且放在prev_cpu上的energy增量与放在best_energy_cpu的差值，小于等于把任务p放在prev_cpu上energy消耗的6.25%，那么选prev_cpu. 因为能量节省有限，选prev_cpu可以减少cache miss. 可以增加一个优化，并且在cache_hot()的情况下才选prev_cpu。
此函数用到的 compute_energy 函数：
/*
* 作用：计算任务p迁移到dst_cpu上后，整个pd，也就是此cluster的energy。若dst_cpu传-1，就表示
* 任务p不运行在pd内的任何一个cpu上时，此pd的energy，也即是base energy。
*/
static long compute_energy(struct task_struct *p, int dst_cpu, struct perf_domain *pd)
{
struct cpumask *pd_mask = perf_domain_span(pd);
unsigned long cpu_cap = arch_scale_cpu_capacity(cpumask_first(pd_mask)); //return per_cpu(cpu_scale, cpu); 此cpu的算力
unsigned long max_util = 0, sum_util = 0;
unsigned long energy = 0;
int cpu;
//对此pd中的每一个online cpu都执行
for_each_cpu_and(cpu, pd_mask, cpu_online_mask) {
//计算若p运行在dst_cpu上，此pd下各个cpu变化后的util值
unsigned long cpu_util, util_cfs = cpu_util_next(cpu, p, dst_cpu);
struct task_struct *tsk = cpu == dst_cpu ? p : NULL; //注意传参，这里可能恒为NULL
//返回cfs+irq+rt+dl使用掉的cpu算力之和.注意这里传的是ENERGY_UTIL
sum_util += schedutil_cpu_util(cpu, util_cfs, cpu_cap, ENERGY_UTIL, NULL);
//这次计算util考虑了uclamp，util大概率是往高处clamp的，dl的util计算方式也不同，这里使用的是带宽
cpu_util = schedutil_cpu_util(cpu, util_cfs, cpu_cap, FREQUENCY_UTIL, tsk); //tsk是否为NULL只对clamp区间值有影响
//取此pd中所有cpu的cpu_util的最大值
max_util = max(max_util, cpu_util);
}
energy = em_cpu_energy(pd->em_pd, max_util, sum_util); //返回的是整个pd的energy
return energy;
}
em_cpu_energy 来根据此cluster上所有cpu的util之和计算energy和通过util最大的那个cpu的util 去调频。
/*
* em_cpu_energy() - Estimates the energy consumed by the CPUs of a performance domain
* @pd : performance domain for which energy has to be estimated
* @max_util : highest utilization among CPUs of the domain
* @sum_util : sum of the utilization of all CPUs in the domain
*/
/*
* 作用：计算pd的energy，参数max_util用来为此cluster调频，sum_util用来计算此cluster即pd的energy
*/
static inline unsigned long em_cpu_energy(struct em_perf_domain *pd, unsigned long max_util, unsigned long sum_util)
{
unsigned long freq, scale_cpu;
struct em_perf_state *ps;
int i, cpu;
if (!sum_util)
return 0;
cpu = cpumask_first(to_cpumask(pd->cpus));
scale_cpu = arch_scale_cpu_capacity(cpu); //此pd下cpu的算力
ps = &pd->table[pd->nr_perf_states - 1]; //由于是升序排列，这是最大的perf-state
freq = map_util_freq(max_util, ps->frequency, scale_cpu); //return (freq + (freq >> 2)) * util / cap = 1.25 * (util / cap) * max_freq ;
/*
* Find the lowest performance state of the Energy Model above the requested frequency.
*/
//找一个频点刚好大于等于计算出来的freq的em_perf_state
for (i = 0; i < pd->nr_perf_states; i++) {
ps = &pd->table[i];
if (ps->frequency >= freq)
break;
}
/*
* The capacity of a CPU in the domain at the performance state (ps)
* can be computed as:
*
* ps->freq * scale_cpu
* ps->cap = -------------------- (1)
* cpu_max_freq
*
* So, ignoring the costs of idle states (which are not available in
* the EM), the energy consumed by this CPU at that performance state
* is estimated as:
*
* ps->power * cpu_util
* cpu_nrg = -------------------- (2)
* ps->cap
*
* since 'cpu_util / ps->cap' represents its percentage of busy time.
*
* NOTE: Although the result of this computation actually is in
* units of power, it can be manipulated as an energy value
* over a scheduling period, since it is assumed to be
* constant during that interval.
*
* By injecting (1) in (2), 'cpu_nrg' can be re-expressed as a product
* of two terms:
*
* ps->power * cpu_max_freq cpu_util
* cpu_nrg = ------------------------ * --------- (3)
* ps->freq scale_cpu
*
* The first term is static, and is stored in the em_perf_state struct
* as 'ps->cost'.
*
* Since all CPUs of the domain have the same micro-architecture, they
* share the same 'ps->cost', and the same CPU capacity. Hence, the
* total energy of the domain (which is the simple sum of the energy of
* all of its CPUs) can be factorized as:
*
* ps->cost * \Sum cpu_util
* pd_nrg = ------------------------ (4)
* scale_cpu
*/
return ps->cost * sum_util / scale_cpu; //就是之前计算的，整个pd的功耗
}
cpu_util_next 用来计算若将任务p放置在dst_cpu上后，此pd各个cpu的util。遍历此pd内的每个cpu就可以可以得到此pd内的sum_util，从而计算pd的energy。
/*
* Predicts what cpu_util(@cpu) would return if @p was migrated (and enqueued) to @dst_cpu.
* 作用：预测若任务p迁移到参数dst_cpu上后，参数cpu上的util值
*/
//compute_energy 传参：(cpu, p, -1) cpu为此pd中的某个cpu，注意dst_cpu传的是-1。-1就只可能减，不可能加了
static unsigned long cpu_util_next(int cpu, struct task_struct *p, int dst_cpu)
{
struct cfs_rq *cfs_rq = &cpu_rq(cpu)->cfs;
unsigned long util_est, util = READ_ONCE(cfs_rq->avg.util_avg); //cfs_rq的util值，不会写回。
/*
* If @p migrates from @cpu to another, remove its contribution. Or,
* if @p migrates from another CPU to @cpu, add its contribution. In
* the other cases, @cpu is not impacted by the migration, so the
* util_avg should already be correct.
*/
//若此cpu是任务p之前运行的cpu，但是不是p将要运行的cpu
if (task_cpu(p) == cpu && dst_cpu != cpu)
sub_positive(&util, task_util(p)); //从cfs_rq的util中减去p的util
//若此cpu不是任务p之前运行的cpu，但是是p将要运行的cpu
else if (task_cpu(p) != cpu && dst_cpu == cpu)
util += task_util(p); //cfs_rq的util加上p的util
if (sched_feat(UTIL_EST)) {
util_est = READ_ONCE(cfs_rq->avg.util_est.enqueued);
/*
* During wake-up, the task isn't enqueued yet and doesn't
* appear in the cfs_rq->avg.util_est.enqueued of any rq,
* so just add it (if needed) to "simulate" what will be
* cpu_util() after the task has been enqueued.
*/
//若cpu就是任务p要运行的 cpu
if (dst_cpu == cpu)
util_est += _task_util_est(p);
util = max(util, util_est);
}
//返回判断后cfs_rq的util
return min(util, capacity_orig_of(cpu));
}
/*
* 对于非dst cpu: compute_energy：传参(cpu, util_cfs, cpu_cap, ENERGY_UTIL, NULL) cpu为此pd下的某个cpu,
* util_cfs是这个cpu对应的任务p迁移到dst_cpu后的util, cpu_cap是此pd下单个cpu的算力
*
* 对于dst cpu: compute_energy：传参(cpu, util_cfs, cpu_cap, FREQUENCY_UTIL, tsk)
*
* 为了减少篇幅，下面两个函数都删除了大量注释
*/
/*
* This function computes an effective utilization for the given CPU, to be
* used for frequency selection given the linear relation: f = u * f_max.
*/
//作用：计算cpu上的有效util
unsigned long schedutil_cpu_util(int cpu, unsigned long util_cfs, unsigned long max, enum schedutil_type type, struct task_struct *p)
{
unsigned long dl_util, util, irq;
struct rq *rq = cpu_rq(cpu);
if (!uclamp_is_used() && type == FREQUENCY_UTIL && rt_rq_is_runnable(&rq->rt)) {
return max;
}
irq = cpu_util_irq(rq);
if (unlikely(irq >= max))
return max;
util = util_cfs + cpu_util_rt(rq); //return rq->avg_rt.util_avg
if (type == FREQUENCY_UTIL) //FREQUENCY_UTIL 才会考虑uclamp，EAS的计算不考虑
util = uclamp_rq_util_with(rq, util, p);
dl_util = cpu_util_dl(rq); //return rq->avg_dl.util_avg
if (util + dl_util >= max) //CFS+RT+DL 已经超过cpu的算力了
return max;
/*
* OTOH, for energy computation we need the estimated running time, so
* include util_dl and ignore dl_bw.
*/
if (type == ENERGY_UTIL)
util += dl_util;
util = scale_irq_capacity(util, irq, max);
util += irq; //util = util * (1 - irq/max) + irq
if (type == FREQUENCY_UTIL)
util += cpu_bw_dl(rq);
return min(max, util); //返回cfs+irq+rt+dl后的cpu的算力
}
六、Soc厂商对原生逻辑的修改
注意代码中的HOOK，厂商可能会修改导致不执行原生EAS选核逻辑。
七、相关DEBUG文件
1. DEBUG perf_domain 链表的程序
/* 放到 kernel/sched 下面 */
#define pr_fmt(fmt) "perf_domain_debug: " fmt
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/string.h>
#include <linux/printk.h>
#include <asm/topology.h>
#include <linux/cpumask.h>
#include <linux/sched/topology.h>
#include "sched.h"
struct perf_domain_debug_t {
int cmd;
};
static struct perf_domain_debug_t pdd;
static void perf_domain_debug(struct seq_file *m, struct perf_domain *pd)
{
int i;
struct em_perf_domain *em_pd = pd->em_pd;
seq_printf(m, "em_pd->nr_perf_states=%d, em_pd->milliwatts=%d, em_pd->cpus==%*pbl \n",
em_pd->nr_perf_states, em_pd->milliwatts, cpumask_pr_args(to_cpumask(em_pd->cpus)));
for (i = 0; i < em_pd->nr_perf_states; i++) {
seq_printf(m, "[%d]: frequency=%lu, power=%lu, cost=%ld\n",
i, em_pd->table[i].frequency, em_pd->table[i].power, em_pd->table[i].cost);
}
seq_printf(m, "-------------------------------------------------------------------\n");
}
static int perf_domain_debug_show(struct seq_file *m, void *v)
{
struct root_domain *rd = cpu_rq(0)->rd;
struct perf_domain *pd = rd->pd;
while (pd) {
perf_domain_debug(m, pd);
pd = pd->next;
}
return 0;
}
static int perf_domain_debug_open(struct inode *inode, struct file *file)
{
return single_open(file, perf_domain_debug_show, NULL);
}
static ssize_t perf_domain_debug_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
int ret, cmd_value;
char buffer[32] = {0};
if (count >= sizeof(buffer)) {
count = sizeof(buffer) - 1;
}
if (copy_from_user(buffer, buf, count)) {
pr_info("copy_from_user failed\n");
return -EFAULT;
}
ret = sscanf(buffer, "%d", &cmd_value);
if(ret <= 0){
pr_info("sscanf dec failed\n");
return -EINVAL;
}
pr_info("cmd_value=%d\n", cmd_value);
pdd.cmd = cmd_value;
return count;
}
//Linux5.10 change file_operations to proc_ops
static const struct proc_ops perf_domain_debug_fops = {
.proc_open = perf_domain_debug_open,
.proc_read = seq_read,
.proc_write = perf_domain_debug_write,
.proc_lseek = seq_lseek,
.proc_release = single_release,
};
static int __init perf_domain_debug_init(void)
{
proc_create("perf_domain_debug", S_IRUGO | S_IWUGO, NULL, &perf_domain_debug_fops);
pr_info("domain_topo_debug probed\n");
return 0;
}
fs_initcall(perf_domain_debug_init);
View Code
2. 测试结果
# cat /proc/perf_domain_debug em_pd->nr_perf_states=28, em_pd->milliwatts=1, em_pd->cpus==7 [0]: frequency=1300000, power=308, cost=722615 [1]: frequency=1400000, power=353, cost=769035 [2]: frequency=1500000, power=393, cost=799100 [3]: frequency=1600000, power=444, cost=846375 [4]: frequency=1700000, power=490, cost=879117 [5]: frequency=1800000, power=538, cost=911611 [6]: frequency=1900000, power=588, cost=943894 [7]: frequency=2000000, power=651, cost=992775 [8]: frequency=2050000, power=691, cost=1028073 [9]: frequency=2100000, power=732, cost=1063142 [10]: frequency=2150000, power=785, cost=1113604 [11]: frequency=2200000, power=830, cost=1150681 [12]: frequency=2250000, power=876, cost=1187466 [13]: frequency=2300000, power=922, cost=1222652 [14]: frequency=2350000, power=971, cost=1260234 [15]: frequency=2400000, power=1020, cost=1296250 [16]: frequency=2450000, power=1088, cost=1354448 [17]: frequency=2500000, power=1144, cost=1395680 [18]: frequency=2550000, power=1198, cost=1432901 [19]: frequency=2600000, power=1239, cost=1453442 [20]: frequency=2650000, power=1299, cost=1495075 [21]: frequency=2700000, power=1340, cost=1513703 [22]: frequency=2750000, power=1403, cost=1556054 [23]: frequency=2800000, power=1448, cost=1577285 [24]: frequency=2850000, power=1511, cost=1617035 [25]: frequency=2900000, power=1559, cost=1639637 [26]: frequency=3000000, power=1674, cost=1701900 [27]: frequency=3050000, power=1746, cost=1746000 ------------------------------------------------------------------- em_pd->nr_perf_states=32, em_pd->milliwatts=1, em_pd->cpus==4-6 [0]: frequency=200000, power=21, cost=299250 [1]: frequency=300000, power=31, cost=294500 [2]: frequency=400000, power=41, cost=292125 [3]: frequency=500000, power=55, cost=313500 [4]: frequency=600000, power=70, cost=332500 [5]: frequency=700000, power=87, cost=354214 [6]: frequency=800000, power=104, cost=370500 [7]: frequency=900000, power=125, cost=395833 [8]: frequency=1000000, power=145, cost=413250 [9]: frequency=1100000, power=169, cost=437863 [10]: frequency=1200000, power=192, cost=456000 [11]: frequency=1300000, power=215, cost=471346 [12]: frequency=1400000, power=245, cost=498750 [13]: frequency=1500000, power=272, cost=516800 [14]: frequency=1600000, power=300, cost=534375 [15]: frequency=1700000, power=335, cost=561617 [16]: frequency=1800000, power=379, cost=600083 [17]: frequency=1900000, power=420, cost=630000 [18]: frequency=2000000, power=470, cost=669750 [19]: frequency=2050000, power=496, cost=689560 [20]: frequency=2100000, power=523, cost=709785 [21]: frequency=2150000, power=543, cost=719790 [22]: frequency=2200000, power=572, cost=741000 [23]: frequency=2250000, power=602, cost=762533 [24]: frequency=2300000, power=623, cost=771978 [25]: frequency=2350000, power=645, cost=782234 [26]: frequency=2400000, power=666, cost=790875 [27]: frequency=2450000, power=690, cost=802653 [28]: frequency=2550000, power=736, cost=822588 [29]: frequency=2650000, power=783, cost=842094 [30]: frequency=2750000, power=832, cost=862254 [31]: frequency=2850000, power=880, cost=880000 ------------------------------------------------------------------- em_pd->nr_perf_states=30, em_pd->milliwatts=1, em_pd->cpus==0-3 [0]: frequency=200000, power=14, cost=126000 [1]: frequency=250000, power=19, cost=136800 [2]: frequency=300000, power=23, cost=138000 [3]: frequency=350000, power=28, cost=144000 [4]: frequency=400000, power=32, cost=144000 [5]: frequency=450000, power=37, cost=148000 [6]: frequency=500000, power=43, cost=154800 [7]: frequency=550000, power=47, cost=153818 [8]: frequency=600000, power=53, cost=159000 [9]: frequency=650000, power=59, cost=163384 [10]: frequency=700000, power=63, cost=162000 [11]: frequency=750000, power=70, cost=168000 [12]: frequency=800000, power=76, cost=171000 [13]: frequency=850000, power=81, cost=171529 [14]: frequency=900000, power=87, cost=174000 [15]: frequency=950000, power=94, cost=178105 [16]: frequency=1000000, power=99, cost=178200 [17]: frequency=1050000, power=108, cost=185142 [18]: frequency=1100000, power=115, cost=188181 [19]: frequency=1150000, power=125, cost=195652 [20]: frequency=1200000, power=132, cost=198000 [21]: frequency=1250000, power=140, cost=201600 [22]: frequency=1300000, power=150, cost=207692 [23]: frequency=1350000, power=158, cost=210666 [24]: frequency=1400000, power=166, cost=213428 [25]: frequency=1450000, power=177, cost=219724 [26]: frequency=1500000, power=185, cost=222000 [27]: frequency=1600000, power=205, cost=230625 [28]: frequency=1700000, power=222, cost=235058 [29]: frequency=1800000, power=243, cost=243000 -------------------------------------------------------------------View Code
cpu7被isolate的话cluster3就不会有了，pd单链表次序：cluster3 --> cluster2 --> cluster1。
ps->cost = ps->power * cpu_max_freq / ps->freq，对于小核的第一个频点对应的cost也就是 14 * 1800000 / 200000 = 126，但是dump出来的cost=126000，看来是乘以1000了。
这篇关于调度器23—EAS的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-11-27消息中间件底层原理资料详解
- 2024-11-27RocketMQ底层原理资料详解：新手入门教程
- 2024-11-27MQ底层原理资料详解：新手入门教程
- 2024-11-27MQ项目开发资料入门教程
- 2024-11-27RocketMQ源码资料详解：新手入门教程
- 2024-11-27本地多文件上传简易教程
- 2024-11-26消息中间件源码剖析教程
- 2024-11-26JAVA语音识别项目资料的收集与应用
- 2024-11-26Java语音识别项目资料：入门级教程与实战指南
- 2024-11-26SpringAI：Java 开发的智能新利器
