PELT负载计算

PELT负载计算 （Per-Entity Load Tracking）

简介

什么是负载，负载实际上表示的是进程运行对系统的“压力”情况，它和进程消耗CPU时间是两个概念，比如：
10个进程在运行队列runqueue中，和1个进程在runqueue中，虽然在runquque中的进程并没有正在消耗CPU时间，实际上这两种情况下，系统的压力是不同的，此时这些进程并没有在消耗CPU时间，而是在等待，但是依然对负载产生影响。

PELT 是用于CPU负载计算的算法，那么计算这种CPU负载有什么用呢？
（1）首先这种算法把CPU负载计算细化到每个调度实体（schedule entity），这样可以更加精确的进行CPU之间的负载均衡处理；
（2）根据per entity的负载值推测未来需要的CPU算力，以此作为CPU调频调压的依据，这涉及到cpufreq子系统；
（3）开发人员可以根据系统负载情况做其他子系统的优化…

算法原理

内核计算在一段周期period时间内，一个进程处于runnable状态的时间来表示该进程对负载的贡献值。为了统计的精确性，需要计算一个average值作为负载贡献值。可以把过去多个period周期的负载贡献值取一个平均，但是这就带来一个问题，把很久之前的负载贡献加入到当前负载贡献平均值计算中，可能会引起很大的误差，因此该算法引入了一个衰减因子来计算该平均值，距离当前时间越久的period周期，对当前的平均负载贡献计算影响越小。
PELT把时间分成了1024us的序列，在每个1024us的周期中，一个调度实体（进程或者进程组）对系统负载的贡献可以根据该实体处于runnable状态（正在CPU上运行或者在队列中等待cpu调度运行）的时间进行计算。对于过去的负载，我们在计算的时候需要乘一个衰减因子。如果定义Li表示在周期Pi中该调度实体的对系统负载贡献，那么一个调度实体对系统负荷的总贡献可以表示为：

L = L0 + L1*y + L2*y^2 + L3*y^3 + ...

通过这个公式来看，由于我们是累加各个周期中的负载贡献值，所以一个实体在一个计算周期内的负载可能会超过1024us。使用这样序列的让计算非常简单，我们不需要使用数组来记录过去的负荷贡献，只要把上次计算得到的总贡献值乘以y再加上新的L0负荷值就得到了新的贡献值了。内核中通过这种公式计算出runnable_avg_sum和runnable_avg_period，然后两者runnable_avg_sum/runnable_avg_period可以作为对系统平均负载贡献的描述。

实现

static inline void __update_task_entity_contrib(struct sched_entity *se)
{
    u32 contrib;

    /* avoid overflowing a 32-bit type w/ SCHED_LOAD_SCALE */
    contrib = se->avg.runnable_avg_sum * scale_load_down(se->load.weight);
    contrib /= (se->avg.runnable_avg_period + 1);
    se->avg.load_avg_contrib = scale_load(contrib);
}

从代码中来看，最终代表调度实体负载的是load_avg_contrib，一个runqueue中所有进程负载贡献值相加最后就得到该runqueue的负载，也就是该CPU上的负载。从上面的代码来看，load_avg_contrib的计算，简单的来说就是通过

runnable_avg_sum  * weight / (runnable_avg_period + 1)

其中

weight:是进程的权重
runnable_avg_sum:通过衰减因子计算得到的进程runnable时间
runnable_avg_period:通过衰减因子计算得到的总的period时间

从这个计算公式来看，一个进程的最大负载也不会超过该进程的权重值weight。

接下来我们来看如何更新时间，通过下图来看：

|    P0      |      P1   |                  N*Period             | 
|------------|----|------|---------------------------------------|---|
             T0   T1    T2                                      T3  T4
                  |                                                  |
                  last_time                                          current_time

时间更新包含了几个部分，比如一个典型的时间更新问题：假如当前从last_time更新到current_time，我们需要更新对应的runnable_avg_sum和runnable_avg_period的时间值。那么可以分成三部分：
（1）上次更新负载未满一个period的时间[T2-T1]
（2）补齐上次更新的period时间后，剩余的完整period时间[T3-T2]
（3）本次更新除去完整peirod时间后剩余的时间[T4-T3]

我们需要在代码中使用算法计算出来上述3段对应的衰减时间，从而计算出current_time时间点的负载。代码如下：

 static __always_inline int __update_entity_runnable_avg(u64 now,
                             struct sched_avg *sa,
                             int runnable)
 {
     u64 delta, periods;
     u32 runnable_contrib;
     int delta_w, decayed = 0;
 
     delta = now - sa->last_runnable_update;                           //now距离上次更新的时间，单位ns
     /*
      * This should only happen when time goes backwards, which it
      * unfortunately does during sched clock init when we swap over to TSC.
      */
     if ((s64)delta < 0) {
         sa->last_runnable_update = now;
         return 0;
     }
 
     /*
      * Use 1024ns as the unit of measurement since it's a reasonable
      * approximation of 1us and fast to compute.
      */
     delta >>= 10;                                                    //ns转换为us
     if (!delta)
         return 0;
     sa->last_runnable_update = now;
 
     /* delta_w is the amount already accumulated against our next period */
     delta_w = sa->runnable_avg_period % 1024;                            //上次时间超过一个period剩余的时间，以us为单位
     if (delta + delta_w >= 1024) {
         /* period roll-over */
         decayed = 1;
 
         /*
          * Now that we know we're crossing a period boundary, figure
          * out how much from delta we need to complete the current
          * period and accrue it.
          */
         delta_w = 1024 - delta_w;
         if (runnable)
             sa->runnable_avg_sum += delta_w;                                //补齐操作
         sa->runnable_avg_period += delta_w;                                 //补齐操作
 
         delta -= delta_w;
 
         /* Figure out how many additional periods this update spans */
         periods = delta / 1024;
         delta %= 1024;
 
         sa->runnable_avg_sum = decay_load(sa->runnable_avg_sum,              //补齐上次剩余未满一个Period时间后，相对于现在已经属于旧周期，需要乘以衰减因子重新计算对应的衰减值
                           periods + 1);
         sa->runnable_avg_period = decay_load(sa->runnable_avg_period,        //同上
                              periods + 1);
 
         /* Efficiently calculate \sum (1..n_period) 1024*y^i */
         runnable_contrib = __compute_runnable_contrib(periods);              //本次更新带入的多个完整Period时间计算出来的衰减值
         if (runnable)
             sa->runnable_avg_sum += runnable_contrib;
         sa->runnable_avg_period += runnable_contrib;
     }
 
     /* Remainder of delta accrued against u_0` */
     if (runnable)
         sa->runnable_avg_sum += delta;                                       //本次更新剩余未满一个Period的值，直接相加，不必做衰减，前面介绍原理时已经说了
     sa->runnable_avg_period += delta;
 
     return decayed;
 }