Branch data Line data Source code
1 : : #ifdef CONFIG_SMP 2 : : #include "sched-pelt.h" 3 : : 4 : : int __update_load_avg_blocked_se(u64 now, struct sched_entity *se); 5 : : int __update_load_avg_se(u64 now, struct cfs_rq *cfs_rq, struct sched_entity *se); 6 : : int __update_load_avg_cfs_rq(u64 now, struct cfs_rq *cfs_rq); 7 : : int update_rt_rq_load_avg(u64 now, struct rq *rq, int running); 8 : : int update_dl_rq_load_avg(u64 now, struct rq *rq, int running); 9 : : 10 : : #ifdef CONFIG_HAVE_SCHED_AVG_IRQ 11 : : int update_irq_load_avg(struct rq *rq, u64 running); 12 : : #else 13 : : static inline int 14 : 1166 : update_irq_load_avg(struct rq *rq, u64 running) 15 : : { 16 [ + - ]: 1166 : return 0; 17 : : } 18 : : #endif 19 : : 20 : : /* 21 : : * When a task is dequeued, its estimated utilization should not be update if 22 : : * its util_avg has not been updated at least once. 23 : : * This flag is used to synchronize util_avg updates with util_est updates. 24 : : * We map this information into the LSB bit of the utilization saved at 25 : : * dequeue time (i.e. util_est.dequeued). 26 : : */ 27 : : #define UTIL_AVG_UNCHANGED 0x1 28 : : 29 : 153617 : static inline void cfs_se_util_change(struct sched_avg *avg) 30 : : { 31 : 153617 : unsigned int enqueued; 32 : : 33 : 153617 : if (!sched_feat(UTIL_EST)) 34 : : return; 35 : : 36 : : /* Avoid store if the flag has been already set */ 37 : 153617 : enqueued = avg->util_est.enqueued; 38 [ + + ]: 153617 : if (!(enqueued & UTIL_AVG_UNCHANGED)) 39 : : return; 40 : : 41 : : /* Reset flag to report util_avg has been updated */ 42 : 27519 : enqueued &= ~UTIL_AVG_UNCHANGED; 43 : 27519 : WRITE_ONCE(avg->util_est.enqueued, enqueued); 44 : : } 45 : : 46 : : /* 47 : : * The clock_pelt scales the time to reflect the effective amount of 48 : : * computation done during the running delta time but then sync back to 49 : : * clock_task when rq is idle. 50 : : * 51 : : * 52 : : * absolute time | 1| 2| 3| 4| 5| 6| 7| 8| 9|10|11|12|13|14|15|16 53 : : * @ max capacity ------******---------------******--------------- 54 : : * @ half capacity ------************---------************--------- 55 : : * clock pelt | 1| 2| 3| 4| 7| 8| 9| 10| 11|14|15|16 56 : : * 57 : : */ 58 : 381988 : static inline void update_rq_clock_pelt(struct rq *rq, s64 delta) 59 : : { 60 [ + + ]: 381988 : if (unlikely(is_idle_task(rq->curr))) { 61 : : /* The rq is idle, we can sync to clock_task */ 62 : 14465 : rq->clock_pelt = rq_clock_task(rq); 63 : 14465 : return; 64 : : } 65 : : 66 : : /* 67 : : * When a rq runs at a lower compute capacity, it will need 68 : : * more time to do the same amount of work than at max 69 : : * capacity. In order to be invariant, we scale the delta to 70 : : * reflect how much work has been really done. 71 : : * Running longer results in stealing idle time that will 72 : : * disturb the load signal compared to max capacity. This 73 : : * stolen idle time will be automatically reflected when the 74 : : * rq will be idle and the clock will be synced with 75 : : * rq_clock_task. 76 : : */ 77 : : 78 : : /* 79 : : * Scale the elapsed time to reflect the real amount of 80 : : * computation 81 : : */ 82 : 367523 : delta = cap_scale(delta, arch_scale_cpu_capacity(cpu_of(rq))); 83 : 367523 : delta = cap_scale(delta, arch_scale_freq_capacity(cpu_of(rq))); 84 : : 85 : 367523 : rq->clock_pelt += delta; 86 : : } 87 : : 88 : : /* 89 : : * When rq becomes idle, we have to check if it has lost idle time 90 : : * because it was fully busy. A rq is fully used when the /Sum util_sum 91 : : * is greater or equal to: 92 : : * (LOAD_AVG_MAX - 1024 + rq->cfs.avg.period_contrib) << SCHED_CAPACITY_SHIFT; 93 : : * For optimization and computing rounding purpose, we don't take into account 94 : : * the position in the current window (period_contrib) and we use the higher 95 : : * bound of util_sum to decide. 96 : : */ 97 : 10419 : static inline void update_idle_rq_clock_pelt(struct rq *rq) 98 : : { 99 : 10419 : u32 divider = ((LOAD_AVG_MAX - 1024) << SCHED_CAPACITY_SHIFT) - LOAD_AVG_MAX; 100 : 10419 : u32 util_sum = rq->cfs.avg.util_sum; 101 : 10419 : util_sum += rq->avg_rt.util_sum; 102 : 10419 : util_sum += rq->avg_dl.util_sum; 103 : : 104 : : /* 105 : : * Reflecting stolen time makes sense only if the idle 106 : : * phase would be present at max capacity. As soon as the 107 : : * utilization of a rq has reached the maximum value, it is 108 : : * considered as an always runnig rq without idle time to 109 : : * steal. This potential idle time is considered as lost in 110 : : * this case. We keep track of this lost idle time compare to 111 : : * rq's clock_task. 112 : : */ 113 [ + + ]: 10419 : if (util_sum >= divider) 114 : 179 : rq->lost_idle_time += rq_clock_task(rq) - rq->clock_pelt; 115 : : } 116 : : 117 : 635548 : static inline u64 rq_clock_pelt(struct rq *rq) 118 : : { 119 : 635548 : lockdep_assert_held(&rq->lock); 120 [ + + ]: 635548 : assert_clock_updated(rq); 121 : : 122 [ + + ]: 635548 : return rq->clock_pelt - rq->lost_idle_time; 123 : : } 124 : : 125 : : #ifdef CONFIG_CFS_BANDWIDTH 126 : : /* rq->task_clock normalized against any time this cfs_rq has spent throttled */ 127 : : static inline u64 cfs_rq_clock_pelt(struct cfs_rq *cfs_rq) 128 : : { 129 : : if (unlikely(cfs_rq->throttle_count)) 130 : : return cfs_rq->throttled_clock_task - cfs_rq->throttled_clock_task_time; 131 : : 132 : : return rq_clock_pelt(rq_of(cfs_rq)) - cfs_rq->throttled_clock_task_time; 133 : : } 134 : : #else 135 : 634382 : static inline u64 cfs_rq_clock_pelt(struct cfs_rq *cfs_rq) 136 : : { 137 [ + + ]: 634382 : return rq_clock_pelt(rq_of(cfs_rq)); 138 : : } 139 : : #endif 140 : : 141 : : #else 142 : : 143 : : static inline int 144 : : update_cfs_rq_load_avg(u64 now, struct cfs_rq *cfs_rq) 145 : : { 146 : : return 0; 147 : : } 148 : : 149 : : static inline int 150 : : update_rt_rq_load_avg(u64 now, struct rq *rq, int running) 151 : : { 152 : : return 0; 153 : : } 154 : : 155 : : static inline int 156 : : update_dl_rq_load_avg(u64 now, struct rq *rq, int running) 157 : : { 158 : : return 0; 159 : : } 160 : : 161 : : static inline int 162 : : update_irq_load_avg(struct rq *rq, u64 running) 163 : : { 164 : : return 0; 165 : : } 166 : : 167 : : static inline u64 rq_clock_pelt(struct rq *rq) 168 : : { 169 : : return rq_clock_task(rq); 170 : : } 171 : : 172 : : static inline void 173 : : update_rq_clock_pelt(struct rq *rq, s64 delta) { } 174 : : 175 : : static inline void 176 : : update_idle_rq_clock_pelt(struct rq *rq) { } 177 : : 178 : : #endif 179 : : 180 : :