Re: [RFC PATCH v2] sched: reflect sched_entity movement into task_group's utilization

[Peter Zijlstra]

On Tue, May 24, 2016 at 10:57:32AM +0200, Vincent Guittot wrote:

> +/*
> + * Save how much utilization has just been added/removed on cfs rq so we can
> + * propagate it across the whole tg tree
> + */
> +static void set_tg_cfs_rq_util(struct cfs_rq *cfs_rq, int delta)
> +{
> +	if (cfs_rq->tg == &root_task_group)
> +		return;
> +
> +	cfs_rq->diff_util_avg += delta;
> +}

function name doesn't really reflect its purpose..

> +
> +/* Take into account the change of the utilization of a child task group */

This comment could be so much better... :-)

> +static void update_tg_cfs_util(struct sched_entity *se, int blocked)
> +{
> +	int delta;
> +	struct cfs_rq *cfs_rq;
> +	long update_util_avg;
> +	long last_update_time;
> +	long old_util_avg;
> +
> +
> +	/*
> +	 * update_blocked_average will call this function for root cfs_rq
> +	 * whose se is null. In this case just return
> +	 */
> +	if (!se)
> +		return;
> +
> +	if (entity_is_task(se))
> +		return 0;
> +
> +	/* Get sched_entity of cfs rq */
> +	cfs_rq = group_cfs_rq(se);
> +
> +	update_util_avg = cfs_rq->diff_util_avg;
> +
> +	if (!update_util_avg)
> +		return 0;
> +
> +	/* Clear pending changes */
> +	cfs_rq->diff_util_avg = 0;
> +
> +	/* Add changes in sched_entity utilizaton */
> +	old_util_avg = se->avg.util_avg;
> +	se->avg.util_avg = max_t(long, se->avg.util_avg + update_util_avg, 0);
> +	se->avg.util_sum = se->avg.util_avg * LOAD_AVG_MAX;
> +
> +	/* Get parent cfs_rq */
> +	cfs_rq = cfs_rq_of(se);
> +
> +	if (blocked) {
> +		/*
> +		 * blocked utilization has to be synchronized with its parent
> +		 * cfs_rq's timestamp
> +		 */
> +		last_update_time = cfs_rq_last_update_time(cfs_rq);
> +
> +		__update_load_avg(last_update_time, cpu_of(rq_of(cfs_rq)),
> +			  &se->avg,
> +			  se->on_rq * scale_load_down(se->load.weight),
> +			  cfs_rq->curr == se, NULL);
> +	}
> +
> +	delta = se->avg.util_avg - old_util_avg;
> +
> +	cfs_rq->avg.util_avg =  max_t(long, cfs_rq->avg.util_avg + delta, 0);
> +	cfs_rq->avg.util_sum = cfs_rq->avg.util_avg * LOAD_AVG_MAX;
> +
> +	set_tg_cfs_rq_util(cfs_rq, delta);
> +}

So if I read this right it computes the utilization delta for group se's
and propagates it into the corresponding parent group cfs_rq ?

> @@ -6276,6 +6368,8 @@ static void update_blocked_averages(int cpu)
>  
>  		if (update_cfs_rq_load_avg(cfs_rq_clock_task(cfs_rq), cfs_rq, true))
>  			update_tg_load_avg(cfs_rq, 0);
> +		/* Propagate pending util changes to the parent */
> +		update_tg_cfs_util(cfs_rq->tg->se[cpu], true);

And this is why you need the strict bottom-up thing fixed..

> @@ -8370,6 +8464,20 @@ static void detach_task_cfs_rq(struct task_struct *p)
>  
>  	/* Catch up with the cfs_rq and remove our load when we leave */
>  	detach_entity_load_avg(cfs_rq, se);
> +
> +	/*
> +	 * Propagate the detach across the tg tree to ake it visible to the
> +	 * root
> +	 */
> +	for_each_sched_entity(se) {
> +		cfs_rq = cfs_rq_of(se);
> +
> +		if (cfs_rq_throttled(cfs_rq))
> +			break;
> +
> +		update_load_avg(se, 1);
> +		update_tg_cfs_util(se, false);
> +	}
>  }
>  
>  static void attach_task_cfs_rq(struct task_struct *p)
> @@ -8399,8 +8507,21 @@ static void switched_from_fair(struct rq *rq, struct task_struct *p)
>  
>  static void switched_to_fair(struct rq *rq, struct task_struct *p)
>  {
> +	struct sched_entity *se = &p->se;
> +	struct cfs_rq *cfs_rq;
> +
>  	attach_task_cfs_rq(p);
>  
> +	for_each_sched_entity(se) {
> +		cfs_rq = cfs_rq_of(se);
> +
> +		if (cfs_rq_throttled(cfs_rq))
> +			break;
> +
> +		update_load_avg(se, 1);
> +		update_tg_cfs_util(se, false);
> +	}
> +
>  	if (task_on_rq_queued(p)) {
>  		/*
>  		 * We were most likely switched from sched_rt, so

So I would expect this to be in attach_task_cfs_rq() to mirror the
detach_task_cfs_rq().

Also, this change is somewhat independent but required for the 'flat'
util measure, right?