Commit 5d180232 authored by Peter Zijlstra's avatar Peter Zijlstra Committed by Paul E. McKenney

sched: Fix load avg vs cpu-hotplug

Rabik and Paul reported two different issues related to the same few
lines of code.

Rabik's issue is that the nr_uninterruptible migration code is wrong in
that he sees artifacts due to this (Rabik please do expand in more
detail).

Paul's issue is that this code as it stands relies on us using
stop_machine() for unplug, we all would like to remove this assumption
so that eventually we can remove this stop_machine() usage altogether.

The only reason we'd have to migrate nr_uninterruptible is so that we
could use for_each_online_cpu() loops in favour of
for_each_possible_cpu() loops, however since nr_uninterruptible() is the
only such loop and its using possible lets not bother at all.

The problem Rabik sees is (probably) caused by the fact that by
migrating nr_uninterruptible we screw rq->calc_load_active for both rqs
involved.

So don't bother with fancy migration schemes (meaning we now have to
keep using for_each_possible_cpu()) and instead fold any nr_active delta
after we migrate all tasks away to make sure we don't have any skewed
nr_active accounting.

[ paulmck: Move call to calc_load_migration to CPU_DEAD to avoid
miscounting noted by Rakib. ]
Reported-by: default avatarRakib Mullick <rakib.mullick@gmail.com>
Reported-by: default avatarPaul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: default avatarPeter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: default avatarPaul E. McKenney <paul.mckenney@linaro.org>
parent 0d8ee37e
...@@ -5304,27 +5304,17 @@ void idle_task_exit(void) ...@@ -5304,27 +5304,17 @@ void idle_task_exit(void)
} }
/* /*
* While a dead CPU has no uninterruptible tasks queued at this point, * Since this CPU is going 'away' for a while, fold any nr_active delta
* it might still have a nonzero ->nr_uninterruptible counter, because * we might have. Assumes we're called after migrate_tasks() so that the
* for performance reasons the counter is not stricly tracking tasks to * nr_active count is stable.
* their home CPUs. So we just add the counter to another CPU's counter, *
* to keep the global sum constant after CPU-down: * Also see the comment "Global load-average calculations".
*/
static void migrate_nr_uninterruptible(struct rq *rq_src)
{
struct rq *rq_dest = cpu_rq(cpumask_any(cpu_active_mask));
rq_dest->nr_uninterruptible += rq_src->nr_uninterruptible;
rq_src->nr_uninterruptible = 0;
}
/*
* remove the tasks which were accounted by rq from calc_load_tasks.
*/ */
static void calc_global_load_remove(struct rq *rq) static void calc_load_migrate(struct rq *rq)
{ {
atomic_long_sub(rq->calc_load_active, &calc_load_tasks); long delta = calc_load_fold_active(rq);
rq->calc_load_active = 0; if (delta)
atomic_long_add(delta, &calc_load_tasks);
} }
/* /*
...@@ -5617,9 +5607,18 @@ migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu) ...@@ -5617,9 +5607,18 @@ migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
migrate_tasks(cpu); migrate_tasks(cpu);
BUG_ON(rq->nr_running != 1); /* the migration thread */ BUG_ON(rq->nr_running != 1); /* the migration thread */
raw_spin_unlock_irqrestore(&rq->lock, flags); raw_spin_unlock_irqrestore(&rq->lock, flags);
break;
migrate_nr_uninterruptible(rq); case CPU_DEAD:
calc_global_load_remove(rq); {
struct rq *dest_rq;
local_irq_save(flags);
dest_rq = cpu_rq(smp_processor_id());
raw_spin_lock(&dest_rq->lock);
calc_load_migrate(rq);
raw_spin_unlock_irqrestore(&dest_rq->lock, flags);
}
break; break;
#endif #endif
} }
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment