License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
|
|
|
* Completely Fair Scheduling (CFS) Class (SCHED_NORMAL/SCHED_BATCH)
|
|
|
|
*
|
|
|
|
* Copyright (C) 2007 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
|
|
|
|
*
|
|
|
|
* Interactivity improvements by Mike Galbraith
|
|
|
|
* (C) 2007 Mike Galbraith <efault@gmx.de>
|
|
|
|
*
|
|
|
|
* Various enhancements by Dmitry Adamushko.
|
|
|
|
* (C) 2007 Dmitry Adamushko <dmitry.adamushko@gmail.com>
|
|
|
|
*
|
|
|
|
* Group scheduling enhancements by Srivatsa Vaddagiri
|
|
|
|
* Copyright IBM Corporation, 2007
|
|
|
|
* Author: Srivatsa Vaddagiri <vatsa@linux.vnet.ibm.com>
|
|
|
|
*
|
|
|
|
* Scaled math optimizations by Thomas Gleixner
|
|
|
|
* Copyright (C) 2007, Thomas Gleixner <tglx@linutronix.de>
|
2007-08-25 16:41:53 +00:00
|
|
|
*
|
|
|
|
* Adaptive scheduling granularity, math enhancements by Peter Zijlstra
|
2015-11-16 10:08:45 +00:00
|
|
|
* Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra
|
2007-07-09 16:51:58 +00:00
|
|
|
*/
|
|
|
|
|
2017-02-03 23:16:44 +00:00
|
|
|
#include <linux/sched/mm.h>
|
2017-02-01 15:36:40 +00:00
|
|
|
#include <linux/sched/topology.h>
|
|
|
|
|
2016-02-05 09:08:36 +00:00
|
|
|
#include <linux/latencytop.h>
|
2011-03-26 12:52:55 +00:00
|
|
|
#include <linux/cpumask.h>
|
2014-09-04 15:32:10 +00:00
|
|
|
#include <linux/cpuidle.h>
|
2011-10-25 08:00:11 +00:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/profile.h>
|
|
|
|
#include <linux/interrupt.h>
|
2012-10-25 12:16:43 +00:00
|
|
|
#include <linux/mempolicy.h>
|
2012-11-19 10:59:15 +00:00
|
|
|
#include <linux/migrate.h>
|
2012-10-25 12:16:43 +00:00
|
|
|
#include <linux/task_work.h>
|
2017-10-27 02:42:28 +00:00
|
|
|
#include <linux/sched/isolation.h>
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
#include <trace/events/sched.h>
|
|
|
|
|
|
|
|
#include "sched.h"
|
2008-01-25 20:08:34 +00:00
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
2007-08-25 16:41:53 +00:00
|
|
|
* Targeted preemption latency for CPU-bound tasks:
|
2007-07-09 16:51:58 +00:00
|
|
|
*
|
2007-08-25 16:41:53 +00:00
|
|
|
* NOTE: this latency value is not the same as the concept of
|
2007-10-15 15:00:14 +00:00
|
|
|
* 'timeslice length' - timeslices in CFS are of variable length
|
|
|
|
* and have no persistent notion like in traditional, time-slice
|
|
|
|
* based scheduling concepts.
|
2007-07-09 16:51:58 +00:00
|
|
|
*
|
2007-10-15 15:00:14 +00:00
|
|
|
* (to see the precise effective timeslice length of your workload,
|
|
|
|
* run vmstat and monitor the context-switches (cs) field)
|
2016-11-23 06:37:00 +00:00
|
|
|
*
|
|
|
|
* (default: 6ms * (1 + ilog(ncpus)), units: nanoseconds)
|
2007-07-09 16:51:58 +00:00
|
|
|
*/
|
2016-11-23 06:37:00 +00:00
|
|
|
unsigned int sysctl_sched_latency = 6000000ULL;
|
|
|
|
unsigned int normalized_sysctl_sched_latency = 6000000ULL;
|
2007-10-15 15:00:02 +00:00
|
|
|
|
2009-11-30 11:16:47 +00:00
|
|
|
/*
|
|
|
|
* The initial- and re-scaling of tunables is configurable
|
|
|
|
*
|
|
|
|
* Options are:
|
2016-11-23 06:37:00 +00:00
|
|
|
*
|
|
|
|
* SCHED_TUNABLESCALING_NONE - unscaled, always *1
|
|
|
|
* SCHED_TUNABLESCALING_LOG - scaled logarithmical, *1+ilog(ncpus)
|
|
|
|
* SCHED_TUNABLESCALING_LINEAR - scaled linear, *ncpus
|
|
|
|
*
|
|
|
|
* (default SCHED_TUNABLESCALING_LOG = *(1+ilog(ncpus))
|
2009-11-30 11:16:47 +00:00
|
|
|
*/
|
2016-11-23 06:37:00 +00:00
|
|
|
enum sched_tunable_scaling sysctl_sched_tunable_scaling = SCHED_TUNABLESCALING_LOG;
|
2009-11-30 11:16:47 +00:00
|
|
|
|
2007-10-15 15:00:02 +00:00
|
|
|
/*
|
2007-11-09 21:39:37 +00:00
|
|
|
* Minimal preemption granularity for CPU-bound tasks:
|
2016-11-23 06:37:00 +00:00
|
|
|
*
|
2010-10-14 07:09:13 +00:00
|
|
|
* (default: 0.75 msec * (1 + ilog(ncpus)), units: nanoseconds)
|
2007-10-15 15:00:02 +00:00
|
|
|
*/
|
2016-11-23 06:37:00 +00:00
|
|
|
unsigned int sysctl_sched_min_granularity = 750000ULL;
|
|
|
|
unsigned int normalized_sysctl_sched_min_granularity = 750000ULL;
|
2007-08-25 16:41:53 +00:00
|
|
|
|
|
|
|
/*
|
2016-11-23 06:37:00 +00:00
|
|
|
* This value is kept at sysctl_sched_latency/sysctl_sched_min_granularity
|
2007-11-09 21:39:37 +00:00
|
|
|
*/
|
2010-09-12 06:14:52 +00:00
|
|
|
static unsigned int sched_nr_latency = 8;
|
2007-11-09 21:39:37 +00:00
|
|
|
|
|
|
|
/*
|
2009-09-09 13:41:37 +00:00
|
|
|
* After fork, child runs first. If set to 0 (default) then
|
2007-11-09 21:39:37 +00:00
|
|
|
* parent will (try to) run first.
|
2007-08-25 16:41:53 +00:00
|
|
|
*/
|
2009-09-09 13:41:37 +00:00
|
|
|
unsigned int sysctl_sched_child_runs_first __read_mostly;
|
2007-07-09 16:51:58 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* SCHED_OTHER wake-up granularity.
|
|
|
|
*
|
|
|
|
* This option delays the preemption effects of decoupled workloads
|
|
|
|
* and reduces their over-scheduling. Synchronous workloads will still
|
|
|
|
* have immediate wakeup/sleep latencies.
|
2016-11-23 06:37:00 +00:00
|
|
|
*
|
|
|
|
* (default: 1 msec * (1 + ilog(ncpus)), units: nanoseconds)
|
2007-07-09 16:51:58 +00:00
|
|
|
*/
|
2016-11-23 06:37:00 +00:00
|
|
|
unsigned int sysctl_sched_wakeup_granularity = 1000000UL;
|
|
|
|
unsigned int normalized_sysctl_sched_wakeup_granularity = 1000000UL;
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2016-11-23 06:37:00 +00:00
|
|
|
const_debug unsigned int sysctl_sched_migration_cost = 500000UL;
|
2007-10-15 15:00:18 +00:00
|
|
|
|
2016-11-22 20:23:53 +00:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/*
|
|
|
|
* For asym packing, by default the lower numbered cpu has higher priority.
|
|
|
|
*/
|
|
|
|
int __weak arch_asym_cpu_priority(int cpu)
|
|
|
|
{
|
|
|
|
return -cpu;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-07-21 16:43:30 +00:00
|
|
|
#ifdef CONFIG_CFS_BANDWIDTH
|
|
|
|
/*
|
|
|
|
* Amount of runtime to allocate from global (tg) to local (per-cfs_rq) pool
|
|
|
|
* each time a cfs_rq requests quota.
|
|
|
|
*
|
|
|
|
* Note: in the case that the slice exceeds the runtime remaining (either due
|
|
|
|
* to consumption or the quota being specified to be smaller than the slice)
|
|
|
|
* we will always only issue the remaining available time.
|
|
|
|
*
|
2016-11-23 06:37:00 +00:00
|
|
|
* (default: 5 msec, units: microseconds)
|
|
|
|
*/
|
|
|
|
unsigned int sysctl_sched_cfs_bandwidth_slice = 5000UL;
|
2011-07-21 16:43:30 +00:00
|
|
|
#endif
|
|
|
|
|
2016-07-25 13:34:26 +00:00
|
|
|
/*
|
|
|
|
* The margin used when comparing utilization with CPU capacity:
|
2016-10-14 13:41:12 +00:00
|
|
|
* util * margin < capacity * 1024
|
2016-11-23 06:37:00 +00:00
|
|
|
*
|
|
|
|
* (default: ~20%)
|
2016-07-25 13:34:26 +00:00
|
|
|
*/
|
2016-11-23 06:37:00 +00:00
|
|
|
unsigned int capacity_margin = 1280;
|
2016-07-25 13:34:26 +00:00
|
|
|
|
2013-04-19 19:10:50 +00:00
|
|
|
static inline void update_load_add(struct load_weight *lw, unsigned long inc)
|
|
|
|
{
|
|
|
|
lw->weight += inc;
|
|
|
|
lw->inv_weight = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void update_load_sub(struct load_weight *lw, unsigned long dec)
|
|
|
|
{
|
|
|
|
lw->weight -= dec;
|
|
|
|
lw->inv_weight = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void update_load_set(struct load_weight *lw, unsigned long w)
|
|
|
|
{
|
|
|
|
lw->weight = w;
|
|
|
|
lw->inv_weight = 0;
|
|
|
|
}
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
/*
|
|
|
|
* Increase the granularity value when there are more CPUs,
|
|
|
|
* because with more CPUs the 'effective latency' as visible
|
|
|
|
* to users decreases. But the relationship is not linear,
|
|
|
|
* so pick a second-best guess by going with the log2 of the
|
|
|
|
* number of CPUs.
|
|
|
|
*
|
|
|
|
* This idea comes from the SD scheduler of Con Kolivas:
|
|
|
|
*/
|
2015-05-15 19:05:42 +00:00
|
|
|
static unsigned int get_update_sysctl_factor(void)
|
2011-10-25 08:00:11 +00:00
|
|
|
{
|
2015-05-15 19:05:42 +00:00
|
|
|
unsigned int cpus = min_t(unsigned int, num_online_cpus(), 8);
|
2011-10-25 08:00:11 +00:00
|
|
|
unsigned int factor;
|
|
|
|
|
|
|
|
switch (sysctl_sched_tunable_scaling) {
|
|
|
|
case SCHED_TUNABLESCALING_NONE:
|
|
|
|
factor = 1;
|
|
|
|
break;
|
|
|
|
case SCHED_TUNABLESCALING_LINEAR:
|
|
|
|
factor = cpus;
|
|
|
|
break;
|
|
|
|
case SCHED_TUNABLESCALING_LOG:
|
|
|
|
default:
|
|
|
|
factor = 1 + ilog2(cpus);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return factor;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void update_sysctl(void)
|
|
|
|
{
|
|
|
|
unsigned int factor = get_update_sysctl_factor();
|
|
|
|
|
|
|
|
#define SET_SYSCTL(name) \
|
|
|
|
(sysctl_##name = (factor) * normalized_sysctl_##name)
|
|
|
|
SET_SYSCTL(sched_min_granularity);
|
|
|
|
SET_SYSCTL(sched_latency);
|
|
|
|
SET_SYSCTL(sched_wakeup_granularity);
|
|
|
|
#undef SET_SYSCTL
|
|
|
|
}
|
|
|
|
|
|
|
|
void sched_init_granularity(void)
|
|
|
|
{
|
|
|
|
update_sysctl();
|
|
|
|
}
|
|
|
|
|
2013-11-18 17:27:06 +00:00
|
|
|
#define WMULT_CONST (~0U)
|
2011-10-25 08:00:11 +00:00
|
|
|
#define WMULT_SHIFT 32
|
|
|
|
|
2013-11-18 17:27:06 +00:00
|
|
|
static void __update_inv_weight(struct load_weight *lw)
|
|
|
|
{
|
|
|
|
unsigned long w;
|
|
|
|
|
|
|
|
if (likely(lw->inv_weight))
|
|
|
|
return;
|
|
|
|
|
|
|
|
w = scale_load_down(lw->weight);
|
|
|
|
|
|
|
|
if (BITS_PER_LONG > 32 && unlikely(w >= WMULT_CONST))
|
|
|
|
lw->inv_weight = 1;
|
|
|
|
else if (unlikely(!w))
|
|
|
|
lw->inv_weight = WMULT_CONST;
|
|
|
|
else
|
|
|
|
lw->inv_weight = WMULT_CONST / w;
|
|
|
|
}
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
/*
|
2013-11-18 17:27:06 +00:00
|
|
|
* delta_exec * weight / lw.weight
|
|
|
|
* OR
|
|
|
|
* (delta_exec * (weight * lw->inv_weight)) >> WMULT_SHIFT
|
|
|
|
*
|
2016-03-29 23:07:51 +00:00
|
|
|
* Either weight := NICE_0_LOAD and lw \e sched_prio_to_wmult[], in which case
|
2013-11-18 17:27:06 +00:00
|
|
|
* we're guaranteed shift stays positive because inv_weight is guaranteed to
|
|
|
|
* fit 32 bits, and NICE_0_LOAD gives another 10 bits; therefore shift >= 22.
|
|
|
|
*
|
|
|
|
* Or, weight =< lw.weight (because lw.weight is the runqueue weight), thus
|
|
|
|
* weight/lw.weight <= 1, and therefore our shift will also be positive.
|
2011-10-25 08:00:11 +00:00
|
|
|
*/
|
2013-11-18 17:27:06 +00:00
|
|
|
static u64 __calc_delta(u64 delta_exec, unsigned long weight, struct load_weight *lw)
|
2011-10-25 08:00:11 +00:00
|
|
|
{
|
2013-11-18 17:27:06 +00:00
|
|
|
u64 fact = scale_load_down(weight);
|
|
|
|
int shift = WMULT_SHIFT;
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2013-11-18 17:27:06 +00:00
|
|
|
__update_inv_weight(lw);
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2013-11-18 17:27:06 +00:00
|
|
|
if (unlikely(fact >> 32)) {
|
|
|
|
while (fact >> 32) {
|
|
|
|
fact >>= 1;
|
|
|
|
shift--;
|
|
|
|
}
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
2013-11-18 17:27:06 +00:00
|
|
|
/* hint to use a 32x32->64 mul */
|
|
|
|
fact = (u64)(u32)fact * lw->inv_weight;
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2013-11-18 17:27:06 +00:00
|
|
|
while (fact >> 32) {
|
|
|
|
fact >>= 1;
|
|
|
|
shift--;
|
|
|
|
}
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2013-11-18 17:27:06 +00:00
|
|
|
return mul_u64_u32_shr(delta_exec, fact, shift);
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const struct sched_class fair_sched_class;
|
2008-10-17 17:27:03 +00:00
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/**************************************************************
|
|
|
|
* CFS operations on generic schedulable entities:
|
|
|
|
*/
|
|
|
|
|
2007-10-15 15:00:03 +00:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2007-10-15 15:00:03 +00:00
|
|
|
/* cpu runqueue to which this cfs_rq is attached */
|
2007-07-09 16:51:58 +00:00
|
|
|
static inline struct rq *rq_of(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
2007-10-15 15:00:03 +00:00
|
|
|
return cfs_rq->rq;
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2007-10-15 15:00:03 +00:00
|
|
|
/* An entity is a task if it doesn't "own" a runqueue */
|
|
|
|
#define entity_is_task(se) (!se->my_q)
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2009-07-24 10:25:30 +00:00
|
|
|
static inline struct task_struct *task_of(struct sched_entity *se)
|
|
|
|
{
|
2016-09-20 20:34:51 +00:00
|
|
|
SCHED_WARN_ON(!entity_is_task(se));
|
2009-07-24 10:25:30 +00:00
|
|
|
return container_of(se, struct task_struct, se);
|
|
|
|
}
|
|
|
|
|
2008-04-19 17:45:00 +00:00
|
|
|
/* Walk up scheduling entities hierarchy */
|
|
|
|
#define for_each_sched_entity(se) \
|
|
|
|
for (; se; se = se->parent)
|
|
|
|
|
|
|
|
static inline struct cfs_rq *task_cfs_rq(struct task_struct *p)
|
|
|
|
{
|
|
|
|
return p->se.cfs_rq;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* runqueue on which this entity is (to be) queued */
|
|
|
|
static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
return se->cfs_rq;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* runqueue "owned" by this group */
|
|
|
|
static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)
|
|
|
|
{
|
|
|
|
return grp->my_q;
|
|
|
|
}
|
|
|
|
|
2010-11-15 23:47:01 +00:00
|
|
|
static inline void list_add_leaf_cfs_rq(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
|
|
|
if (!cfs_rq->on_list) {
|
2016-11-08 09:53:43 +00:00
|
|
|
struct rq *rq = rq_of(cfs_rq);
|
|
|
|
int cpu = cpu_of(rq);
|
2010-11-15 23:47:05 +00:00
|
|
|
/*
|
|
|
|
* Ensure we either appear before our parent (if already
|
|
|
|
* enqueued) or force our parent to appear after us when it is
|
2016-11-08 09:53:43 +00:00
|
|
|
* enqueued. The fact that we always enqueue bottom-up
|
|
|
|
* reduces this to two cases and a special case for the root
|
|
|
|
* cfs_rq. Furthermore, it also means that we will always reset
|
|
|
|
* tmp_alone_branch either when the branch is connected
|
|
|
|
* to a tree or when we reach the beg of the tree
|
2010-11-15 23:47:05 +00:00
|
|
|
*/
|
|
|
|
if (cfs_rq->tg->parent &&
|
2016-11-08 09:53:43 +00:00
|
|
|
cfs_rq->tg->parent->cfs_rq[cpu]->on_list) {
|
|
|
|
/*
|
|
|
|
* If parent is already on the list, we add the child
|
|
|
|
* just before. Thanks to circular linked property of
|
|
|
|
* the list, this means to put the child at the tail
|
|
|
|
* of the list that starts by parent.
|
|
|
|
*/
|
|
|
|
list_add_tail_rcu(&cfs_rq->leaf_cfs_rq_list,
|
|
|
|
&(cfs_rq->tg->parent->cfs_rq[cpu]->leaf_cfs_rq_list));
|
|
|
|
/*
|
|
|
|
* The branch is now connected to its tree so we can
|
|
|
|
* reset tmp_alone_branch to the beginning of the
|
|
|
|
* list.
|
|
|
|
*/
|
|
|
|
rq->tmp_alone_branch = &rq->leaf_cfs_rq_list;
|
|
|
|
} else if (!cfs_rq->tg->parent) {
|
|
|
|
/*
|
|
|
|
* cfs rq without parent should be put
|
|
|
|
* at the tail of the list.
|
|
|
|
*/
|
2010-11-15 23:47:05 +00:00
|
|
|
list_add_tail_rcu(&cfs_rq->leaf_cfs_rq_list,
|
2016-11-08 09:53:43 +00:00
|
|
|
&rq->leaf_cfs_rq_list);
|
|
|
|
/*
|
|
|
|
* We have reach the beg of a tree so we can reset
|
|
|
|
* tmp_alone_branch to the beginning of the list.
|
|
|
|
*/
|
|
|
|
rq->tmp_alone_branch = &rq->leaf_cfs_rq_list;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* The parent has not already been added so we want to
|
|
|
|
* make sure that it will be put after us.
|
|
|
|
* tmp_alone_branch points to the beg of the branch
|
|
|
|
* where we will add parent.
|
|
|
|
*/
|
|
|
|
list_add_rcu(&cfs_rq->leaf_cfs_rq_list,
|
|
|
|
rq->tmp_alone_branch);
|
|
|
|
/*
|
|
|
|
* update tmp_alone_branch to points to the new beg
|
|
|
|
* of the branch
|
|
|
|
*/
|
|
|
|
rq->tmp_alone_branch = &cfs_rq->leaf_cfs_rq_list;
|
2010-11-15 23:47:05 +00:00
|
|
|
}
|
2010-11-15 23:47:01 +00:00
|
|
|
|
|
|
|
cfs_rq->on_list = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void list_del_leaf_cfs_rq(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
|
|
|
if (cfs_rq->on_list) {
|
|
|
|
list_del_rcu(&cfs_rq->leaf_cfs_rq_list);
|
|
|
|
cfs_rq->on_list = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-19 17:45:00 +00:00
|
|
|
/* Iterate thr' all leaf cfs_rq's on a runqueue */
|
2017-04-26 00:43:50 +00:00
|
|
|
#define for_each_leaf_cfs_rq_safe(rq, cfs_rq, pos) \
|
|
|
|
list_for_each_entry_safe(cfs_rq, pos, &rq->leaf_cfs_rq_list, \
|
|
|
|
leaf_cfs_rq_list)
|
2008-04-19 17:45:00 +00:00
|
|
|
|
|
|
|
/* Do the two (enqueued) entities belong to the same group ? */
|
2012-02-11 05:05:00 +00:00
|
|
|
static inline struct cfs_rq *
|
2008-04-19 17:45:00 +00:00
|
|
|
is_same_group(struct sched_entity *se, struct sched_entity *pse)
|
|
|
|
{
|
|
|
|
if (se->cfs_rq == pse->cfs_rq)
|
2012-02-11 05:05:00 +00:00
|
|
|
return se->cfs_rq;
|
2008-04-19 17:45:00 +00:00
|
|
|
|
2012-02-11 05:05:00 +00:00
|
|
|
return NULL;
|
2008-04-19 17:45:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct sched_entity *parent_entity(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
return se->parent;
|
|
|
|
}
|
|
|
|
|
2008-10-24 09:06:15 +00:00
|
|
|
static void
|
|
|
|
find_matching_se(struct sched_entity **se, struct sched_entity **pse)
|
|
|
|
{
|
|
|
|
int se_depth, pse_depth;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* preemption test can be made between sibling entities who are in the
|
|
|
|
* same cfs_rq i.e who have a common parent. Walk up the hierarchy of
|
|
|
|
* both tasks until we find their ancestors who are siblings of common
|
|
|
|
* parent.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* First walk up until both entities are at same depth */
|
2012-02-11 05:05:00 +00:00
|
|
|
se_depth = (*se)->depth;
|
|
|
|
pse_depth = (*pse)->depth;
|
2008-10-24 09:06:15 +00:00
|
|
|
|
|
|
|
while (se_depth > pse_depth) {
|
|
|
|
se_depth--;
|
|
|
|
*se = parent_entity(*se);
|
|
|
|
}
|
|
|
|
|
|
|
|
while (pse_depth > se_depth) {
|
|
|
|
pse_depth--;
|
|
|
|
*pse = parent_entity(*pse);
|
|
|
|
}
|
|
|
|
|
|
|
|
while (!is_same_group(*se, *pse)) {
|
|
|
|
*se = parent_entity(*se);
|
|
|
|
*pse = parent_entity(*pse);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-24 10:25:30 +00:00
|
|
|
#else /* !CONFIG_FAIR_GROUP_SCHED */
|
|
|
|
|
|
|
|
static inline struct task_struct *task_of(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
return container_of(se, struct task_struct, se);
|
|
|
|
}
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2007-10-15 15:00:03 +00:00
|
|
|
static inline struct rq *rq_of(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
|
|
|
return container_of(cfs_rq, struct rq, cfs);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define entity_is_task(se) 1
|
|
|
|
|
2008-04-19 17:45:00 +00:00
|
|
|
#define for_each_sched_entity(se) \
|
|
|
|
for (; se; se = NULL)
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2008-04-19 17:45:00 +00:00
|
|
|
static inline struct cfs_rq *task_cfs_rq(struct task_struct *p)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2008-04-19 17:45:00 +00:00
|
|
|
return &task_rq(p)->cfs;
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2008-04-19 17:45:00 +00:00
|
|
|
static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
struct task_struct *p = task_of(se);
|
|
|
|
struct rq *rq = task_rq(p);
|
|
|
|
|
|
|
|
return &rq->cfs;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* runqueue "owned" by this group */
|
|
|
|
static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-11-15 23:47:01 +00:00
|
|
|
static inline void list_add_leaf_cfs_rq(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void list_del_leaf_cfs_rq(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-04-26 00:43:50 +00:00
|
|
|
#define for_each_leaf_cfs_rq_safe(rq, cfs_rq, pos) \
|
|
|
|
for (cfs_rq = &rq->cfs, pos = NULL; cfs_rq; cfs_rq = pos)
|
2008-04-19 17:45:00 +00:00
|
|
|
|
|
|
|
static inline struct sched_entity *parent_entity(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-10-24 09:06:15 +00:00
|
|
|
static inline void
|
|
|
|
find_matching_se(struct sched_entity **se, struct sched_entity **pse)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2008-04-19 17:45:00 +00:00
|
|
|
#endif /* CONFIG_FAIR_GROUP_SCHED */
|
|
|
|
|
2012-03-21 20:07:16 +00:00
|
|
|
static __always_inline
|
2013-11-18 17:27:06 +00:00
|
|
|
void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec);
|
2007-07-09 16:51:58 +00:00
|
|
|
|
|
|
|
/**************************************************************
|
|
|
|
* Scheduling class tree data structure manipulation methods:
|
|
|
|
*/
|
|
|
|
|
2013-03-12 19:12:24 +00:00
|
|
|
static inline u64 max_vruntime(u64 max_vruntime, u64 vruntime)
|
2007-10-15 15:00:07 +00:00
|
|
|
{
|
2013-03-12 19:12:24 +00:00
|
|
|
s64 delta = (s64)(vruntime - max_vruntime);
|
2007-10-15 15:00:11 +00:00
|
|
|
if (delta > 0)
|
2013-03-12 19:12:24 +00:00
|
|
|
max_vruntime = vruntime;
|
2007-10-15 15:00:07 +00:00
|
|
|
|
2013-03-12 19:12:24 +00:00
|
|
|
return max_vruntime;
|
2007-10-15 15:00:07 +00:00
|
|
|
}
|
|
|
|
|
2007-10-15 15:00:14 +00:00
|
|
|
static inline u64 min_vruntime(u64 min_vruntime, u64 vruntime)
|
2007-10-15 15:00:12 +00:00
|
|
|
{
|
|
|
|
s64 delta = (s64)(vruntime - min_vruntime);
|
|
|
|
if (delta < 0)
|
|
|
|
min_vruntime = vruntime;
|
|
|
|
|
|
|
|
return min_vruntime;
|
|
|
|
}
|
|
|
|
|
2009-07-16 10:32:27 +00:00
|
|
|
static inline int entity_before(struct sched_entity *a,
|
|
|
|
struct sched_entity *b)
|
|
|
|
{
|
|
|
|
return (s64)(a->vruntime - b->vruntime) < 0;
|
|
|
|
}
|
|
|
|
|
2008-10-24 09:06:13 +00:00
|
|
|
static void update_min_vruntime(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
2016-09-20 19:58:12 +00:00
|
|
|
struct sched_entity *curr = cfs_rq->curr;
|
2017-09-08 23:14:55 +00:00
|
|
|
struct rb_node *leftmost = rb_first_cached(&cfs_rq->tasks_timeline);
|
2016-09-20 19:58:12 +00:00
|
|
|
|
2008-10-24 09:06:13 +00:00
|
|
|
u64 vruntime = cfs_rq->min_vruntime;
|
|
|
|
|
2016-09-20 19:58:12 +00:00
|
|
|
if (curr) {
|
|
|
|
if (curr->on_rq)
|
|
|
|
vruntime = curr->vruntime;
|
|
|
|
else
|
|
|
|
curr = NULL;
|
|
|
|
}
|
2008-10-24 09:06:13 +00:00
|
|
|
|
2017-09-08 23:14:55 +00:00
|
|
|
if (leftmost) { /* non-empty tree */
|
|
|
|
struct sched_entity *se;
|
|
|
|
se = rb_entry(leftmost, struct sched_entity, run_node);
|
2008-10-24 09:06:13 +00:00
|
|
|
|
2016-09-20 19:58:12 +00:00
|
|
|
if (!curr)
|
2008-10-24 09:06:13 +00:00
|
|
|
vruntime = se->vruntime;
|
|
|
|
else
|
|
|
|
vruntime = min_vruntime(vruntime, se->vruntime);
|
|
|
|
}
|
|
|
|
|
2013-03-12 19:12:24 +00:00
|
|
|
/* ensure we never gain time by being placed backwards. */
|
2008-10-24 09:06:13 +00:00
|
|
|
cfs_rq->min_vruntime = max_vruntime(cfs_rq->min_vruntime, vruntime);
|
2011-04-05 15:23:48 +00:00
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
smp_wmb();
|
|
|
|
cfs_rq->min_vruntime_copy = cfs_rq->min_vruntime;
|
|
|
|
#endif
|
2008-10-24 09:06:13 +00:00
|
|
|
}
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
|
|
|
* Enqueue an entity into the rb-tree:
|
|
|
|
*/
|
2007-10-15 15:00:14 +00:00
|
|
|
static void __enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2017-09-08 23:14:55 +00:00
|
|
|
struct rb_node **link = &cfs_rq->tasks_timeline.rb_root.rb_node;
|
2007-07-09 16:51:58 +00:00
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct sched_entity *entry;
|
2017-09-08 23:14:55 +00:00
|
|
|
bool leftmost = true;
|
2007-07-09 16:51:58 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the right place in the rbtree:
|
|
|
|
*/
|
|
|
|
while (*link) {
|
|
|
|
parent = *link;
|
|
|
|
entry = rb_entry(parent, struct sched_entity, run_node);
|
|
|
|
/*
|
|
|
|
* We dont care about collisions. Nodes with
|
|
|
|
* the same key stay together.
|
|
|
|
*/
|
2011-07-20 12:46:59 +00:00
|
|
|
if (entity_before(se, entry)) {
|
2007-07-09 16:51:58 +00:00
|
|
|
link = &parent->rb_left;
|
|
|
|
} else {
|
|
|
|
link = &parent->rb_right;
|
2017-09-08 23:14:55 +00:00
|
|
|
leftmost = false;
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(&se->run_node, parent, link);
|
2017-09-08 23:14:55 +00:00
|
|
|
rb_insert_color_cached(&se->run_node,
|
|
|
|
&cfs_rq->tasks_timeline, leftmost);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2007-10-15 15:00:14 +00:00
|
|
|
static void __dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2017-09-08 23:14:55 +00:00
|
|
|
rb_erase_cached(&se->run_node, &cfs_rq->tasks_timeline);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
struct sched_entity *__pick_first_entity(struct cfs_rq *cfs_rq)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2017-09-08 23:14:55 +00:00
|
|
|
struct rb_node *left = rb_first_cached(&cfs_rq->tasks_timeline);
|
2008-11-04 20:25:07 +00:00
|
|
|
|
|
|
|
if (!left)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return rb_entry(left, struct sched_entity, run_node);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2011-02-01 14:51:03 +00:00
|
|
|
static struct sched_entity *__pick_next_entity(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
struct rb_node *next = rb_next(&se->run_node);
|
|
|
|
|
|
|
|
if (!next)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return rb_entry(next, struct sched_entity, run_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
2011-10-25 08:00:11 +00:00
|
|
|
struct sched_entity *__pick_last_entity(struct cfs_rq *cfs_rq)
|
2007-10-15 15:00:05 +00:00
|
|
|
{
|
2017-09-08 23:14:55 +00:00
|
|
|
struct rb_node *last = rb_last(&cfs_rq->tasks_timeline.rb_root);
|
2007-10-15 15:00:05 +00:00
|
|
|
|
2008-02-22 07:55:53 +00:00
|
|
|
if (!last)
|
|
|
|
return NULL;
|
2008-02-22 09:32:21 +00:00
|
|
|
|
|
|
|
return rb_entry(last, struct sched_entity, run_node);
|
2007-10-15 15:00:05 +00:00
|
|
|
}
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/**************************************************************
|
|
|
|
* Scheduling class statistics methods:
|
|
|
|
*/
|
|
|
|
|
2009-11-30 11:16:48 +00:00
|
|
|
int sched_proc_update_handler(struct ctl_table *table, int write,
|
2009-09-23 22:57:19 +00:00
|
|
|
void __user *buffer, size_t *lenp,
|
2007-11-09 21:39:37 +00:00
|
|
|
loff_t *ppos)
|
|
|
|
{
|
2009-09-23 22:57:19 +00:00
|
|
|
int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
|
2015-05-15 19:05:42 +00:00
|
|
|
unsigned int factor = get_update_sysctl_factor();
|
2007-11-09 21:39:37 +00:00
|
|
|
|
|
|
|
if (ret || !write)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
sched_nr_latency = DIV_ROUND_UP(sysctl_sched_latency,
|
|
|
|
sysctl_sched_min_granularity);
|
|
|
|
|
2009-11-30 11:16:48 +00:00
|
|
|
#define WRT_SYSCTL(name) \
|
|
|
|
(normalized_sysctl_##name = sysctl_##name / (factor))
|
|
|
|
WRT_SYSCTL(sched_min_granularity);
|
|
|
|
WRT_SYSCTL(sched_latency);
|
|
|
|
WRT_SYSCTL(sched_wakeup_granularity);
|
|
|
|
#undef WRT_SYSCTL
|
|
|
|
|
2007-11-09 21:39:37 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
2007-10-15 15:00:13 +00:00
|
|
|
|
2008-06-27 11:41:11 +00:00
|
|
|
/*
|
2008-10-17 17:27:04 +00:00
|
|
|
* delta /= w
|
2008-06-27 11:41:11 +00:00
|
|
|
*/
|
2013-11-18 17:27:06 +00:00
|
|
|
static inline u64 calc_delta_fair(u64 delta, struct sched_entity *se)
|
2008-06-27 11:41:11 +00:00
|
|
|
{
|
2008-10-17 17:27:04 +00:00
|
|
|
if (unlikely(se->load.weight != NICE_0_LOAD))
|
2013-11-18 17:27:06 +00:00
|
|
|
delta = __calc_delta(delta, NICE_0_LOAD, &se->load);
|
2008-06-27 11:41:11 +00:00
|
|
|
|
|
|
|
return delta;
|
|
|
|
}
|
|
|
|
|
2007-10-15 15:00:13 +00:00
|
|
|
/*
|
|
|
|
* The idea is to set a period in which each task runs once.
|
|
|
|
*
|
2012-08-08 14:16:04 +00:00
|
|
|
* When there are too many tasks (sched_nr_latency) we have to stretch
|
2007-10-15 15:00:13 +00:00
|
|
|
* this period because otherwise the slices get too small.
|
|
|
|
*
|
|
|
|
* p = (nr <= nl) ? l : l*nr/nl
|
|
|
|
*/
|
2007-10-15 15:00:04 +00:00
|
|
|
static u64 __sched_period(unsigned long nr_running)
|
|
|
|
{
|
2015-07-02 14:25:52 +00:00
|
|
|
if (unlikely(nr_running > sched_nr_latency))
|
|
|
|
return nr_running * sysctl_sched_min_granularity;
|
|
|
|
else
|
|
|
|
return sysctl_sched_latency;
|
2007-10-15 15:00:04 +00:00
|
|
|
}
|
|
|
|
|
2007-10-15 15:00:13 +00:00
|
|
|
/*
|
|
|
|
* We calculate the wall-time slice from the period by taking a part
|
|
|
|
* proportional to the weight.
|
|
|
|
*
|
2008-10-17 17:27:04 +00:00
|
|
|
* s = p*P[w/rw]
|
2007-10-15 15:00:13 +00:00
|
|
|
*/
|
2007-10-15 15:00:05 +00:00
|
|
|
static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
2007-08-25 16:41:53 +00:00
|
|
|
{
|
2009-01-02 11:16:42 +00:00
|
|
|
u64 slice = __sched_period(cfs_rq->nr_running + !se->on_rq);
|
2008-10-17 17:27:04 +00:00
|
|
|
|
2009-01-02 11:16:42 +00:00
|
|
|
for_each_sched_entity(se) {
|
2009-01-15 16:17:15 +00:00
|
|
|
struct load_weight *load;
|
2009-06-16 08:35:12 +00:00
|
|
|
struct load_weight lw;
|
2009-01-15 16:17:15 +00:00
|
|
|
|
|
|
|
cfs_rq = cfs_rq_of(se);
|
|
|
|
load = &cfs_rq->load;
|
2008-10-17 17:27:04 +00:00
|
|
|
|
2009-01-02 11:16:42 +00:00
|
|
|
if (unlikely(!se->on_rq)) {
|
2009-06-16 08:35:12 +00:00
|
|
|
lw = cfs_rq->load;
|
2009-01-02 11:16:42 +00:00
|
|
|
|
|
|
|
update_load_add(&lw, se->load.weight);
|
|
|
|
load = &lw;
|
|
|
|
}
|
2013-11-18 17:27:06 +00:00
|
|
|
slice = __calc_delta(slice, se->load.weight, load);
|
2009-01-02 11:16:42 +00:00
|
|
|
}
|
|
|
|
return slice;
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2007-10-15 15:00:13 +00:00
|
|
|
/*
|
2013-03-11 10:03:20 +00:00
|
|
|
* We calculate the vruntime slice of a to-be-inserted task.
|
2007-10-15 15:00:13 +00:00
|
|
|
*
|
2008-10-17 17:27:04 +00:00
|
|
|
* vs = s/w
|
2007-10-15 15:00:13 +00:00
|
|
|
*/
|
2008-10-17 17:27:04 +00:00
|
|
|
static u64 sched_vslice(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
2007-10-15 15:00:10 +00:00
|
|
|
{
|
2008-10-17 17:27:04 +00:00
|
|
|
return calc_delta_fair(sched_slice(cfs_rq, se), se);
|
2008-06-27 11:41:11 +00:00
|
|
|
}
|
|
|
|
|
2013-06-20 02:18:47 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2017-04-11 09:08:42 +00:00
|
|
|
|
|
|
|
#include "sched-pelt.h"
|
|
|
|
|
2016-06-22 17:03:13 +00:00
|
|
|
static int select_idle_sibling(struct task_struct *p, int prev_cpu, int cpu);
|
2013-10-07 10:29:17 +00:00
|
|
|
static unsigned long task_h_load(struct task_struct *p);
|
|
|
|
|
2015-07-15 00:04:39 +00:00
|
|
|
/* Give new sched_entity start runnable values to heavy its load in infant time */
|
|
|
|
void init_entity_runnable_average(struct sched_entity *se)
|
2013-06-20 02:18:47 +00:00
|
|
|
{
|
2015-07-15 00:04:39 +00:00
|
|
|
struct sched_avg *sa = &se->avg;
|
2013-06-20 02:18:47 +00:00
|
|
|
|
sched/fair: Align PELT windows between cfs_rq and its se
The PELT _sum values are a saw-tooth function, dropping on the decay
edge and then growing back up again during the window.
When these window-edges are not aligned between cfs_rq and se, we can
have the situation where, for example, on dequeue, the se decays
first.
Its _sum values will be small(er), while the cfs_rq _sum values will
still be on their way up. Because of this, the subtraction:
cfs_rq->avg._sum -= se->avg._sum will result in a positive value. This
will then, once the cfs_rq reaches an edge, translate into its _avg
value jumping up.
This is especially visible with the runnable_load bits, since they get
added/subtracted a lot.
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-05-12 12:16:30 +00:00
|
|
|
memset(sa, 0, sizeof(*sa));
|
|
|
|
|
2016-10-19 12:45:23 +00:00
|
|
|
/*
|
|
|
|
* Tasks are intialized with full load to be seen as heavy tasks until
|
|
|
|
* they get a chance to stabilize to their real load level.
|
|
|
|
* Group entities are intialized with zero load to reflect the fact that
|
|
|
|
* nothing has been attached to the task group yet.
|
|
|
|
*/
|
|
|
|
if (entity_is_task(se))
|
2017-05-06 13:59:54 +00:00
|
|
|
sa->runnable_load_avg = sa->load_avg = scale_load_down(se->load.weight);
|
|
|
|
|
sched/fair: Align PELT windows between cfs_rq and its se
The PELT _sum values are a saw-tooth function, dropping on the decay
edge and then growing back up again during the window.
When these window-edges are not aligned between cfs_rq and se, we can
have the situation where, for example, on dequeue, the se decays
first.
Its _sum values will be small(er), while the cfs_rq _sum values will
still be on their way up. Because of this, the subtraction:
cfs_rq->avg._sum -= se->avg._sum will result in a positive value. This
will then, once the cfs_rq reaches an edge, translate into its _avg
value jumping up.
This is especially visible with the runnable_load bits, since they get
added/subtracted a lot.
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-05-12 12:16:30 +00:00
|
|
|
se->runnable_weight = se->load.weight;
|
|
|
|
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
/* when this task enqueue'ed, it will contribute to its cfs_rq's load_avg */
|
2013-06-20 02:18:47 +00:00
|
|
|
}
|
2015-07-15 00:04:42 +00:00
|
|
|
|
2016-06-16 11:29:28 +00:00
|
|
|
static inline u64 cfs_rq_clock_task(struct cfs_rq *cfs_rq);
|
2016-11-08 09:53:42 +00:00
|
|
|
static void attach_entity_cfs_rq(struct sched_entity *se);
|
2016-06-16 11:29:28 +00:00
|
|
|
|
2016-03-29 20:30:56 +00:00
|
|
|
/*
|
|
|
|
* With new tasks being created, their initial util_avgs are extrapolated
|
|
|
|
* based on the cfs_rq's current util_avg:
|
|
|
|
*
|
|
|
|
* util_avg = cfs_rq->util_avg / (cfs_rq->load_avg + 1) * se.load.weight
|
|
|
|
*
|
|
|
|
* However, in many cases, the above util_avg does not give a desired
|
|
|
|
* value. Moreover, the sum of the util_avgs may be divergent, such
|
|
|
|
* as when the series is a harmonic series.
|
|
|
|
*
|
|
|
|
* To solve this problem, we also cap the util_avg of successive tasks to
|
|
|
|
* only 1/2 of the left utilization budget:
|
|
|
|
*
|
|
|
|
* util_avg_cap = (1024 - cfs_rq->avg.util_avg) / 2^n
|
|
|
|
*
|
|
|
|
* where n denotes the nth task.
|
|
|
|
*
|
|
|
|
* For example, a simplest series from the beginning would be like:
|
|
|
|
*
|
|
|
|
* task util_avg: 512, 256, 128, 64, 32, 16, 8, ...
|
|
|
|
* cfs_rq util_avg: 512, 768, 896, 960, 992, 1008, 1016, ...
|
|
|
|
*
|
|
|
|
* Finally, that extrapolated util_avg is clamped to the cap (util_avg_cap)
|
|
|
|
* if util_avg > util_avg_cap.
|
|
|
|
*/
|
|
|
|
void post_init_entity_util_avg(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
|
|
|
struct sched_avg *sa = &se->avg;
|
2016-04-05 04:12:27 +00:00
|
|
|
long cap = (long)(SCHED_CAPACITY_SCALE - cfs_rq->avg.util_avg) / 2;
|
2016-03-29 20:30:56 +00:00
|
|
|
|
|
|
|
if (cap > 0) {
|
|
|
|
if (cfs_rq->avg.util_avg != 0) {
|
|
|
|
sa->util_avg = cfs_rq->avg.util_avg * se->load.weight;
|
|
|
|
sa->util_avg /= (cfs_rq->avg.load_avg + 1);
|
|
|
|
|
|
|
|
if (sa->util_avg > cap)
|
|
|
|
sa->util_avg = cap;
|
|
|
|
} else {
|
|
|
|
sa->util_avg = cap;
|
|
|
|
}
|
|
|
|
}
|
2016-06-16 11:29:28 +00:00
|
|
|
|
|
|
|
if (entity_is_task(se)) {
|
|
|
|
struct task_struct *p = task_of(se);
|
|
|
|
if (p->sched_class != &fair_sched_class) {
|
|
|
|
/*
|
|
|
|
* For !fair tasks do:
|
|
|
|
*
|
2017-05-24 05:29:56 +00:00
|
|
|
update_cfs_rq_load_avg(now, cfs_rq);
|
2016-06-16 11:29:28 +00:00
|
|
|
attach_entity_load_avg(cfs_rq, se);
|
|
|
|
switched_from_fair(rq, p);
|
|
|
|
*
|
|
|
|
* such that the next switched_to_fair() has the
|
|
|
|
* expected state.
|
|
|
|
*/
|
2016-11-08 09:53:42 +00:00
|
|
|
se->avg.last_update_time = cfs_rq_clock_task(cfs_rq);
|
2016-06-16 11:29:28 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-08 09:53:42 +00:00
|
|
|
attach_entity_cfs_rq(se);
|
2016-03-29 20:30:56 +00:00
|
|
|
}
|
|
|
|
|
2016-06-16 11:29:28 +00:00
|
|
|
#else /* !CONFIG_SMP */
|
2015-07-15 00:04:39 +00:00
|
|
|
void init_entity_runnable_average(struct sched_entity *se)
|
2013-06-20 02:18:47 +00:00
|
|
|
{
|
|
|
|
}
|
2016-03-29 20:30:56 +00:00
|
|
|
void post_init_entity_util_avg(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
}
|
2016-06-21 12:27:50 +00:00
|
|
|
static void update_tg_load_avg(struct cfs_rq *cfs_rq, int force)
|
|
|
|
{
|
|
|
|
}
|
2016-06-16 11:29:28 +00:00
|
|
|
#endif /* CONFIG_SMP */
|
2013-06-20 02:18:47 +00:00
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
2013-11-18 17:27:06 +00:00
|
|
|
* Update the current task's runtime statistics.
|
2007-07-09 16:51:58 +00:00
|
|
|
*/
|
2007-08-09 09:16:47 +00:00
|
|
|
static void update_curr(struct cfs_rq *cfs_rq)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2007-10-15 15:00:03 +00:00
|
|
|
struct sched_entity *curr = cfs_rq->curr;
|
2013-04-11 23:51:02 +00:00
|
|
|
u64 now = rq_clock_task(rq_of(cfs_rq));
|
2013-11-18 17:27:06 +00:00
|
|
|
u64 delta_exec;
|
2007-07-09 16:51:58 +00:00
|
|
|
|
|
|
|
if (unlikely(!curr))
|
|
|
|
return;
|
|
|
|
|
2013-11-18 17:27:06 +00:00
|
|
|
delta_exec = now - curr->exec_start;
|
|
|
|
if (unlikely((s64)delta_exec <= 0))
|
2008-12-16 07:45:31 +00:00
|
|
|
return;
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2007-10-15 15:00:03 +00:00
|
|
|
curr->exec_start = now;
|
2007-12-02 19:04:49 +00:00
|
|
|
|
2013-11-18 17:27:06 +00:00
|
|
|
schedstat_set(curr->statistics.exec_max,
|
|
|
|
max(delta_exec, curr->statistics.exec_max));
|
|
|
|
|
|
|
|
curr->sum_exec_runtime += delta_exec;
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_add(cfs_rq->exec_clock, delta_exec);
|
2013-11-18 17:27:06 +00:00
|
|
|
|
|
|
|
curr->vruntime += calc_delta_fair(delta_exec, curr);
|
|
|
|
update_min_vruntime(cfs_rq);
|
|
|
|
|
2007-12-02 19:04:49 +00:00
|
|
|
if (entity_is_task(curr)) {
|
|
|
|
struct task_struct *curtask = task_of(curr);
|
|
|
|
|
2009-09-13 16:15:54 +00:00
|
|
|
trace_sched_stat_runtime(curtask, delta_exec, curr->vruntime);
|
2017-09-25 15:12:04 +00:00
|
|
|
cgroup_account_cputime(curtask, delta_exec);
|
timers: fix itimer/many thread hang
Overview
This patch reworks the handling of POSIX CPU timers, including the
ITIMER_PROF, ITIMER_VIRT timers and rlimit handling. It was put together
with the help of Roland McGrath, the owner and original writer of this code.
The problem we ran into, and the reason for this rework, has to do with using
a profiling timer in a process with a large number of threads. It appears
that the performance of the old implementation of run_posix_cpu_timers() was
at least O(n*3) (where "n" is the number of threads in a process) or worse.
Everything is fine with an increasing number of threads until the time taken
for that routine to run becomes the same as or greater than the tick time, at
which point things degrade rather quickly.
This patch fixes bug 9906, "Weird hang with NPTL and SIGPROF."
Code Changes
This rework corrects the implementation of run_posix_cpu_timers() to make it
run in constant time for a particular machine. (Performance may vary between
one machine and another depending upon whether the kernel is built as single-
or multiprocessor and, in the latter case, depending upon the number of
running processors.) To do this, at each tick we now update fields in
signal_struct as well as task_struct. The run_posix_cpu_timers() function
uses those fields to make its decisions.
We define a new structure, "task_cputime," to contain user, system and
scheduler times and use these in appropriate places:
struct task_cputime {
cputime_t utime;
cputime_t stime;
unsigned long long sum_exec_runtime;
};
This is included in the structure "thread_group_cputime," which is a new
substructure of signal_struct and which varies for uniprocessor versus
multiprocessor kernels. For uniprocessor kernels, it uses "task_cputime" as
a simple substructure, while for multiprocessor kernels it is a pointer:
struct thread_group_cputime {
struct task_cputime totals;
};
struct thread_group_cputime {
struct task_cputime *totals;
};
We also add a new task_cputime substructure directly to signal_struct, to
cache the earliest expiration of process-wide timers, and task_cputime also
replaces the it_*_expires fields of task_struct (used for earliest expiration
of thread timers). The "thread_group_cputime" structure contains process-wide
timers that are updated via account_user_time() and friends. In the non-SMP
case the structure is a simple aggregator; unfortunately in the SMP case that
simplicity was not achievable due to cache-line contention between CPUs (in
one measured case performance was actually _worse_ on a 16-cpu system than
the same test on a 4-cpu system, due to this contention). For SMP, the
thread_group_cputime counters are maintained as a per-cpu structure allocated
using alloc_percpu(). The timer functions update only the timer field in
the structure corresponding to the running CPU, obtained using per_cpu_ptr().
We define a set of inline functions in sched.h that we use to maintain the
thread_group_cputime structure and hide the differences between UP and SMP
implementations from the rest of the kernel. The thread_group_cputime_init()
function initializes the thread_group_cputime structure for the given task.
The thread_group_cputime_alloc() is a no-op for UP; for SMP it calls the
out-of-line function thread_group_cputime_alloc_smp() to allocate and fill
in the per-cpu structures and fields. The thread_group_cputime_free()
function, also a no-op for UP, in SMP frees the per-cpu structures. The
thread_group_cputime_clone_thread() function (also a UP no-op) for SMP calls
thread_group_cputime_alloc() if the per-cpu structures haven't yet been
allocated. The thread_group_cputime() function fills the task_cputime
structure it is passed with the contents of the thread_group_cputime fields;
in UP it's that simple but in SMP it must also safely check that tsk->signal
is non-NULL (if it is it just uses the appropriate fields of task_struct) and,
if so, sums the per-cpu values for each online CPU. Finally, the three
functions account_group_user_time(), account_group_system_time() and
account_group_exec_runtime() are used by timer functions to update the
respective fields of the thread_group_cputime structure.
Non-SMP operation is trivial and will not be mentioned further.
The per-cpu structure is always allocated when a task creates its first new
thread, via a call to thread_group_cputime_clone_thread() from copy_signal().
It is freed at process exit via a call to thread_group_cputime_free() from
cleanup_signal().
All functions that formerly summed utime/stime/sum_sched_runtime values from
from all threads in the thread group now use thread_group_cputime() to
snapshot the values in the thread_group_cputime structure or the values in
the task structure itself if the per-cpu structure hasn't been allocated.
Finally, the code in kernel/posix-cpu-timers.c has changed quite a bit.
The run_posix_cpu_timers() function has been split into a fast path and a
slow path; the former safely checks whether there are any expired thread
timers and, if not, just returns, while the slow path does the heavy lifting.
With the dedicated thread group fields, timers are no longer "rebalanced" and
the process_timer_rebalance() function and related code has gone away. All
summing loops are gone and all code that used them now uses the
thread_group_cputime() inline. When process-wide timers are set, the new
task_cputime structure in signal_struct is used to cache the earliest
expiration; this is checked in the fast path.
Performance
The fix appears not to add significant overhead to existing operations. It
generally performs the same as the current code except in two cases, one in
which it performs slightly worse (Case 5 below) and one in which it performs
very significantly better (Case 2 below). Overall it's a wash except in those
two cases.
I've since done somewhat more involved testing on a dual-core Opteron system.
Case 1: With no itimer running, for a test with 100,000 threads, the fixed
kernel took 1428.5 seconds, 513 seconds more than the unfixed system,
all of which was spent in the system. There were twice as many
voluntary context switches with the fix as without it.
Case 2: With an itimer running at .01 second ticks and 4000 threads (the most
an unmodified kernel can handle), the fixed kernel ran the test in
eight percent of the time (5.8 seconds as opposed to 70 seconds) and
had better tick accuracy (.012 seconds per tick as opposed to .023
seconds per tick).
Case 3: A 4000-thread test with an initial timer tick of .01 second and an
interval of 10,000 seconds (i.e. a timer that ticks only once) had
very nearly the same performance in both cases: 6.3 seconds elapsed
for the fixed kernel versus 5.5 seconds for the unfixed kernel.
With fewer threads (eight in these tests), the Case 1 test ran in essentially
the same time on both the modified and unmodified kernels (5.2 seconds versus
5.8 seconds). The Case 2 test ran in about the same time as well, 5.9 seconds
versus 5.4 seconds but again with much better tick accuracy, .013 seconds per
tick versus .025 seconds per tick for the unmodified kernel.
Since the fix affected the rlimit code, I also tested soft and hard CPU limits.
Case 4: With a hard CPU limit of 20 seconds and eight threads (and an itimer
running), the modified kernel was very slightly favored in that while
it killed the process in 19.997 seconds of CPU time (5.002 seconds of
wall time), only .003 seconds of that was system time, the rest was
user time. The unmodified kernel killed the process in 20.001 seconds
of CPU (5.014 seconds of wall time) of which .016 seconds was system
time. Really, though, the results were too close to call. The results
were essentially the same with no itimer running.
Case 5: With a soft limit of 20 seconds and a hard limit of 2000 seconds
(where the hard limit would never be reached) and an itimer running,
the modified kernel exhibited worse tick accuracy than the unmodified
kernel: .050 seconds/tick versus .028 seconds/tick. Otherwise,
performance was almost indistinguishable. With no itimer running this
test exhibited virtually identical behavior and times in both cases.
In times past I did some limited performance testing. those results are below.
On a four-cpu Opteron system without this fix, a sixteen-thread test executed
in 3569.991 seconds, of which user was 3568.435s and system was 1.556s. On
the same system with the fix, user and elapsed time were about the same, but
system time dropped to 0.007 seconds. Performance with eight, four and one
thread were comparable. Interestingly, the timer ticks with the fix seemed
more accurate: The sixteen-thread test with the fix received 149543 ticks
for 0.024 seconds per tick, while the same test without the fix received 58720
for 0.061 seconds per tick. Both cases were configured for an interval of
0.01 seconds. Again, the other tests were comparable. Each thread in this
test computed the primes up to 25,000,000.
I also did a test with a large number of threads, 100,000 threads, which is
impossible without the fix. In this case each thread computed the primes only
up to 10,000 (to make the runtime manageable). System time dominated, at
1546.968 seconds out of a total 2176.906 seconds (giving a user time of
629.938s). It received 147651 ticks for 0.015 seconds per tick, still quite
accurate. There is obviously no comparable test without the fix.
Signed-off-by: Frank Mayhar <fmayhar@google.com>
Cc: Roland McGrath <roland@redhat.com>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-09-12 16:54:39 +00:00
|
|
|
account_group_exec_runtime(curtask, delta_exec);
|
2007-12-02 19:04:49 +00:00
|
|
|
}
|
2011-07-21 16:43:30 +00:00
|
|
|
|
|
|
|
account_cfs_rq_runtime(cfs_rq, delta_exec);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
sched/cputime: Fix clock_nanosleep()/clock_gettime() inconsistency
Commit d670ec13178d0 "posix-cpu-timers: Cure SMP wobbles" fixes one glibc
test case in cost of breaking another one. After that commit, calling
clock_nanosleep(TIMER_ABSTIME, X) and then clock_gettime(&Y) can result
of Y time being smaller than X time.
Reproducer/tester can be found further below, it can be compiled and ran by:
gcc -o tst-cpuclock2 tst-cpuclock2.c -pthread
while ./tst-cpuclock2 ; do : ; done
This reproducer, when running on a buggy kernel, will complain
about "clock_gettime difference too small".
Issue happens because on start in thread_group_cputimer() we initialize
sum_exec_runtime of cputimer with threads runtime not yet accounted and
then add the threads runtime to running cputimer again on scheduler
tick, making it's sum_exec_runtime bigger than actual threads runtime.
KOSAKI Motohiro posted a fix for this problem, but that patch was never
applied: https://lkml.org/lkml/2013/5/26/191 .
This patch takes different approach to cure the problem. It calls
update_curr() when cputimer starts, that assure we will have updated
stats of running threads and on the next schedule tick we will account
only the runtime that elapsed from cputimer start. That also assure we
have consistent state between cpu times of individual threads and cpu
time of the process consisted by those threads.
Full reproducer (tst-cpuclock2.c):
#define _GNU_SOURCE
#include <unistd.h>
#include <sys/syscall.h>
#include <stdio.h>
#include <time.h>
#include <pthread.h>
#include <stdint.h>
#include <inttypes.h>
/* Parameters for the Linux kernel ABI for CPU clocks. */
#define CPUCLOCK_SCHED 2
#define MAKE_PROCESS_CPUCLOCK(pid, clock) \
((~(clockid_t) (pid) << 3) | (clockid_t) (clock))
static pthread_barrier_t barrier;
/* Help advance the clock. */
static void *chew_cpu(void *arg)
{
pthread_barrier_wait(&barrier);
while (1) ;
return NULL;
}
/* Don't use the glibc wrapper. */
static int do_nanosleep(int flags, const struct timespec *req)
{
clockid_t clock_id = MAKE_PROCESS_CPUCLOCK(0, CPUCLOCK_SCHED);
return syscall(SYS_clock_nanosleep, clock_id, flags, req, NULL);
}
static int64_t tsdiff(const struct timespec *before, const struct timespec *after)
{
int64_t before_i = before->tv_sec * 1000000000ULL + before->tv_nsec;
int64_t after_i = after->tv_sec * 1000000000ULL + after->tv_nsec;
return after_i - before_i;
}
int main(void)
{
int result = 0;
pthread_t th;
pthread_barrier_init(&barrier, NULL, 2);
if (pthread_create(&th, NULL, chew_cpu, NULL) != 0) {
perror("pthread_create");
return 1;
}
pthread_barrier_wait(&barrier);
/* The test. */
struct timespec before, after, sleeptimeabs;
int64_t sleepdiff, diffabs;
const struct timespec sleeptime = {.tv_sec = 0,.tv_nsec = 100000000 };
/* The relative nanosleep. Not sure why this is needed, but its presence
seems to make it easier to reproduce the problem. */
if (do_nanosleep(0, &sleeptime) != 0) {
perror("clock_nanosleep");
return 1;
}
/* Get the current time. */
if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &before) < 0) {
perror("clock_gettime[2]");
return 1;
}
/* Compute the absolute sleep time based on the current time. */
uint64_t nsec = before.tv_nsec + sleeptime.tv_nsec;
sleeptimeabs.tv_sec = before.tv_sec + nsec / 1000000000;
sleeptimeabs.tv_nsec = nsec % 1000000000;
/* Sleep for the computed time. */
if (do_nanosleep(TIMER_ABSTIME, &sleeptimeabs) != 0) {
perror("absolute clock_nanosleep");
return 1;
}
/* Get the time after the sleep. */
if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &after) < 0) {
perror("clock_gettime[3]");
return 1;
}
/* The time after sleep should always be equal to or after the absolute sleep
time passed to clock_nanosleep. */
sleepdiff = tsdiff(&sleeptimeabs, &after);
if (sleepdiff < 0) {
printf("absolute clock_nanosleep woke too early: %" PRId64 "\n", sleepdiff);
result = 1;
printf("Before %llu.%09llu\n", before.tv_sec, before.tv_nsec);
printf("After %llu.%09llu\n", after.tv_sec, after.tv_nsec);
printf("Sleep %llu.%09llu\n", sleeptimeabs.tv_sec, sleeptimeabs.tv_nsec);
}
/* The difference between the timestamps taken before and after the
clock_nanosleep call should be equal to or more than the duration of the
sleep. */
diffabs = tsdiff(&before, &after);
if (diffabs < sleeptime.tv_nsec) {
printf("clock_gettime difference too small: %" PRId64 "\n", diffabs);
result = 1;
}
pthread_cancel(th);
return result;
}
Signed-off-by: Stanislaw Gruszka <sgruszka@redhat.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Rik van Riel <riel@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Link: http://lkml.kernel.org/r/20141112155843.GA24803@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-11-12 15:58:44 +00:00
|
|
|
static void update_curr_fair(struct rq *rq)
|
|
|
|
{
|
|
|
|
update_curr(cfs_rq_of(&rq->curr->se));
|
|
|
|
}
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
static inline void
|
2007-08-09 09:16:47 +00:00
|
|
|
update_stats_wait_start(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2016-06-17 17:43:26 +00:00
|
|
|
u64 wait_start, prev_wait_start;
|
|
|
|
|
|
|
|
if (!schedstat_enabled())
|
|
|
|
return;
|
|
|
|
|
|
|
|
wait_start = rq_clock(rq_of(cfs_rq));
|
|
|
|
prev_wait_start = schedstat_val(se->statistics.wait_start);
|
2015-11-13 03:38:54 +00:00
|
|
|
|
|
|
|
if (entity_is_task(se) && task_on_rq_migrating(task_of(se)) &&
|
2016-06-17 17:43:26 +00:00
|
|
|
likely(wait_start > prev_wait_start))
|
|
|
|
wait_start -= prev_wait_start;
|
2015-11-13 03:38:54 +00:00
|
|
|
|
2018-01-23 19:34:30 +00:00
|
|
|
__schedstat_set(se->statistics.wait_start, wait_start);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2016-06-17 17:43:26 +00:00
|
|
|
static inline void
|
2015-11-13 03:38:54 +00:00
|
|
|
update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|
|
|
{
|
|
|
|
struct task_struct *p;
|
2016-02-05 09:08:36 +00:00
|
|
|
u64 delta;
|
|
|
|
|
2016-06-17 17:43:26 +00:00
|
|
|
if (!schedstat_enabled())
|
|
|
|
return;
|
|
|
|
|
|
|
|
delta = rq_clock(rq_of(cfs_rq)) - schedstat_val(se->statistics.wait_start);
|
2015-11-13 03:38:54 +00:00
|
|
|
|
|
|
|
if (entity_is_task(se)) {
|
|
|
|
p = task_of(se);
|
|
|
|
if (task_on_rq_migrating(p)) {
|
|
|
|
/*
|
|
|
|
* Preserve migrating task's wait time so wait_start
|
|
|
|
* time stamp can be adjusted to accumulate wait time
|
|
|
|
* prior to migration.
|
|
|
|
*/
|
2018-01-23 19:34:30 +00:00
|
|
|
__schedstat_set(se->statistics.wait_start, delta);
|
2015-11-13 03:38:54 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
trace_sched_stat_wait(p, delta);
|
|
|
|
}
|
|
|
|
|
2018-01-23 19:34:30 +00:00
|
|
|
__schedstat_set(se->statistics.wait_max,
|
2016-06-17 17:43:26 +00:00
|
|
|
max(schedstat_val(se->statistics.wait_max), delta));
|
2018-01-23 19:34:30 +00:00
|
|
|
__schedstat_inc(se->statistics.wait_count);
|
|
|
|
__schedstat_add(se->statistics.wait_sum, delta);
|
|
|
|
__schedstat_set(se->statistics.wait_start, 0);
|
2015-11-13 03:38:54 +00:00
|
|
|
}
|
|
|
|
|
2016-06-17 17:43:26 +00:00
|
|
|
static inline void
|
2016-06-17 17:43:23 +00:00
|
|
|
update_stats_enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|
|
|
{
|
|
|
|
struct task_struct *tsk = NULL;
|
2016-06-17 17:43:26 +00:00
|
|
|
u64 sleep_start, block_start;
|
|
|
|
|
|
|
|
if (!schedstat_enabled())
|
|
|
|
return;
|
|
|
|
|
|
|
|
sleep_start = schedstat_val(se->statistics.sleep_start);
|
|
|
|
block_start = schedstat_val(se->statistics.block_start);
|
2016-06-17 17:43:23 +00:00
|
|
|
|
|
|
|
if (entity_is_task(se))
|
|
|
|
tsk = task_of(se);
|
|
|
|
|
2016-06-17 17:43:26 +00:00
|
|
|
if (sleep_start) {
|
|
|
|
u64 delta = rq_clock(rq_of(cfs_rq)) - sleep_start;
|
2016-06-17 17:43:23 +00:00
|
|
|
|
|
|
|
if ((s64)delta < 0)
|
|
|
|
delta = 0;
|
|
|
|
|
2016-06-17 17:43:26 +00:00
|
|
|
if (unlikely(delta > schedstat_val(se->statistics.sleep_max)))
|
2018-01-23 19:34:30 +00:00
|
|
|
__schedstat_set(se->statistics.sleep_max, delta);
|
2016-06-17 17:43:23 +00:00
|
|
|
|
2018-01-23 19:34:30 +00:00
|
|
|
__schedstat_set(se->statistics.sleep_start, 0);
|
|
|
|
__schedstat_add(se->statistics.sum_sleep_runtime, delta);
|
2016-06-17 17:43:23 +00:00
|
|
|
|
|
|
|
if (tsk) {
|
|
|
|
account_scheduler_latency(tsk, delta >> 10, 1);
|
|
|
|
trace_sched_stat_sleep(tsk, delta);
|
|
|
|
}
|
|
|
|
}
|
2016-06-17 17:43:26 +00:00
|
|
|
if (block_start) {
|
|
|
|
u64 delta = rq_clock(rq_of(cfs_rq)) - block_start;
|
2016-06-17 17:43:23 +00:00
|
|
|
|
|
|
|
if ((s64)delta < 0)
|
|
|
|
delta = 0;
|
|
|
|
|
2016-06-17 17:43:26 +00:00
|
|
|
if (unlikely(delta > schedstat_val(se->statistics.block_max)))
|
2018-01-23 19:34:30 +00:00
|
|
|
__schedstat_set(se->statistics.block_max, delta);
|
2016-06-17 17:43:23 +00:00
|
|
|
|
2018-01-23 19:34:30 +00:00
|
|
|
__schedstat_set(se->statistics.block_start, 0);
|
|
|
|
__schedstat_add(se->statistics.sum_sleep_runtime, delta);
|
2016-06-17 17:43:23 +00:00
|
|
|
|
|
|
|
if (tsk) {
|
|
|
|
if (tsk->in_iowait) {
|
2018-01-23 19:34:30 +00:00
|
|
|
__schedstat_add(se->statistics.iowait_sum, delta);
|
|
|
|
__schedstat_inc(se->statistics.iowait_count);
|
2016-06-17 17:43:23 +00:00
|
|
|
trace_sched_stat_iowait(tsk, delta);
|
|
|
|
}
|
|
|
|
|
|
|
|
trace_sched_stat_blocked(tsk, delta);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Blocking time is in units of nanosecs, so shift by
|
|
|
|
* 20 to get a milliseconds-range estimation of the
|
|
|
|
* amount of time that the task spent sleeping:
|
|
|
|
*/
|
|
|
|
if (unlikely(prof_on == SLEEP_PROFILING)) {
|
|
|
|
profile_hits(SLEEP_PROFILING,
|
|
|
|
(void *)get_wchan(tsk),
|
|
|
|
delta >> 20);
|
|
|
|
}
|
|
|
|
account_scheduler_latency(tsk, delta >> 10, 0);
|
|
|
|
}
|
|
|
|
}
|
2015-11-13 03:38:54 +00:00
|
|
|
}
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
|
|
|
* Task is being enqueued - update stats:
|
|
|
|
*/
|
2016-02-05 09:08:36 +00:00
|
|
|
static inline void
|
2016-06-17 17:43:23 +00:00
|
|
|
update_stats_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2016-06-17 17:43:26 +00:00
|
|
|
if (!schedstat_enabled())
|
|
|
|
return;
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
|
|
|
* Are we enqueueing a waiting task? (for current tasks
|
|
|
|
* a dequeue/enqueue event is a NOP)
|
|
|
|
*/
|
2007-10-15 15:00:03 +00:00
|
|
|
if (se != cfs_rq->curr)
|
2007-08-09 09:16:47 +00:00
|
|
|
update_stats_wait_start(cfs_rq, se);
|
2016-06-17 17:43:23 +00:00
|
|
|
|
|
|
|
if (flags & ENQUEUE_WAKEUP)
|
|
|
|
update_stats_enqueue_sleeper(cfs_rq, se);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
2016-02-05 09:08:36 +00:00
|
|
|
update_stats_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2016-06-17 17:43:26 +00:00
|
|
|
|
|
|
|
if (!schedstat_enabled())
|
|
|
|
return;
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
|
|
|
* Mark the end of the wait period if dequeueing a
|
|
|
|
* waiting task:
|
|
|
|
*/
|
2007-10-15 15:00:03 +00:00
|
|
|
if (se != cfs_rq->curr)
|
2007-08-09 09:16:47 +00:00
|
|
|
update_stats_wait_end(cfs_rq, se);
|
2016-02-05 09:08:36 +00:00
|
|
|
|
2016-06-17 17:43:26 +00:00
|
|
|
if ((flags & DEQUEUE_SLEEP) && entity_is_task(se)) {
|
|
|
|
struct task_struct *tsk = task_of(se);
|
2016-02-05 09:08:36 +00:00
|
|
|
|
2016-06-17 17:43:26 +00:00
|
|
|
if (tsk->state & TASK_INTERRUPTIBLE)
|
2018-01-23 19:34:30 +00:00
|
|
|
__schedstat_set(se->statistics.sleep_start,
|
2016-06-17 17:43:26 +00:00
|
|
|
rq_clock(rq_of(cfs_rq)));
|
|
|
|
if (tsk->state & TASK_UNINTERRUPTIBLE)
|
2018-01-23 19:34:30 +00:00
|
|
|
__schedstat_set(se->statistics.block_start,
|
2016-06-17 17:43:26 +00:00
|
|
|
rq_clock(rq_of(cfs_rq)));
|
2016-02-05 09:08:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
|
|
|
* We are picking a new current task - update its stats:
|
|
|
|
*/
|
|
|
|
static inline void
|
2007-08-09 09:16:47 +00:00
|
|
|
update_stats_curr_start(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We are starting a new run period:
|
|
|
|
*/
|
2013-04-11 23:51:02 +00:00
|
|
|
se->exec_start = rq_clock_task(rq_of(cfs_rq));
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**************************************************
|
|
|
|
* Scheduling class queueing methods:
|
|
|
|
*/
|
|
|
|
|
2012-10-25 12:16:43 +00:00
|
|
|
#ifdef CONFIG_NUMA_BALANCING
|
|
|
|
/*
|
2013-10-07 10:28:55 +00:00
|
|
|
* Approximate time to scan a full NUMA task in ms. The task scan period is
|
|
|
|
* calculated based on the tasks virtual memory size and
|
|
|
|
* numa_balancing_scan_size.
|
2012-10-25 12:16:43 +00:00
|
|
|
*/
|
2013-10-07 10:28:55 +00:00
|
|
|
unsigned int sysctl_numa_balancing_scan_period_min = 1000;
|
|
|
|
unsigned int sysctl_numa_balancing_scan_period_max = 60000;
|
mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate
Previously, to probe the working set of a task, we'd use
a very simple and crude method: mark all of its address
space PROT_NONE.
That method has various (obvious) disadvantages:
- it samples the working set at dissimilar rates,
giving some tasks a sampling quality advantage
over others.
- creates performance problems for tasks with very
large working sets
- over-samples processes with large address spaces but
which only very rarely execute
Improve that method by keeping a rotating offset into the
address space that marks the current position of the scan,
and advance it by a constant rate (in a CPU cycles execution
proportional manner). If the offset reaches the last mapped
address of the mm then it then it starts over at the first
address.
The per-task nature of the working set sampling functionality in this tree
allows such constant rate, per task, execution-weight proportional sampling
of the working set, with an adaptive sampling interval/frequency that
goes from once per 100ms up to just once per 8 seconds. The current
sampling volume is 256 MB per interval.
As tasks mature and converge their working set, so does the
sampling rate slow down to just a trickle, 256 MB per 8
seconds of CPU time executed.
This, beyond being adaptive, also rate-limits rarely
executing systems and does not over-sample on overloaded
systems.
[ In AutoNUMA speak, this patch deals with the effective sampling
rate of the 'hinting page fault'. AutoNUMA's scanning is
currently rate-limited, but it is also fundamentally
single-threaded, executing in the knuma_scand kernel thread,
so the limit in AutoNUMA is global and does not scale up with
the number of CPUs, nor does it scan tasks in an execution
proportional manner.
So the idea of rate-limiting the scanning was first implemented
in the AutoNUMA tree via a global rate limit. This patch goes
beyond that by implementing an execution rate proportional
working set sampling rate that is not implemented via a single
global scanning daemon. ]
[ Dan Carpenter pointed out a possible NULL pointer dereference in the
first version of this patch. ]
Based-on-idea-by: Andrea Arcangeli <aarcange@redhat.com>
Bug-Found-By: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Rik van Riel <riel@redhat.com>
[ Wrote changelog and fixed bug. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
2012-10-25 12:16:45 +00:00
|
|
|
|
|
|
|
/* Portion of address space to scan in MB */
|
|
|
|
unsigned int sysctl_numa_balancing_scan_size = 256;
|
2012-10-25 12:16:43 +00:00
|
|
|
|
2012-10-25 12:16:47 +00:00
|
|
|
/* Scan @scan_size MB every @scan_period after an initial @scan_delay in ms */
|
|
|
|
unsigned int sysctl_numa_balancing_scan_delay = 1000;
|
|
|
|
|
2017-07-31 19:28:47 +00:00
|
|
|
struct numa_group {
|
|
|
|
atomic_t refcount;
|
|
|
|
|
|
|
|
spinlock_t lock; /* nr_tasks, tasks */
|
|
|
|
int nr_tasks;
|
|
|
|
pid_t gid;
|
|
|
|
int active_nodes;
|
|
|
|
|
|
|
|
struct rcu_head rcu;
|
|
|
|
unsigned long total_faults;
|
|
|
|
unsigned long max_faults_cpu;
|
|
|
|
/*
|
|
|
|
* Faults_cpu is used to decide whether memory should move
|
|
|
|
* towards the CPU. As a consequence, these stats are weighted
|
|
|
|
* more by CPU use than by memory faults.
|
|
|
|
*/
|
|
|
|
unsigned long *faults_cpu;
|
|
|
|
unsigned long faults[0];
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline unsigned long group_faults_priv(struct numa_group *ng);
|
|
|
|
static inline unsigned long group_faults_shared(struct numa_group *ng);
|
|
|
|
|
2013-10-07 10:28:55 +00:00
|
|
|
static unsigned int task_nr_scan_windows(struct task_struct *p)
|
|
|
|
{
|
|
|
|
unsigned long rss = 0;
|
|
|
|
unsigned long nr_scan_pages;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculations based on RSS as non-present and empty pages are skipped
|
|
|
|
* by the PTE scanner and NUMA hinting faults should be trapped based
|
|
|
|
* on resident pages
|
|
|
|
*/
|
|
|
|
nr_scan_pages = sysctl_numa_balancing_scan_size << (20 - PAGE_SHIFT);
|
|
|
|
rss = get_mm_rss(p->mm);
|
|
|
|
if (!rss)
|
|
|
|
rss = nr_scan_pages;
|
|
|
|
|
|
|
|
rss = round_up(rss, nr_scan_pages);
|
|
|
|
return rss / nr_scan_pages;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* For sanitys sake, never scan more PTEs than MAX_SCAN_WINDOW MB/sec. */
|
|
|
|
#define MAX_SCAN_WINDOW 2560
|
|
|
|
|
|
|
|
static unsigned int task_scan_min(struct task_struct *p)
|
|
|
|
{
|
2015-04-28 20:00:20 +00:00
|
|
|
unsigned int scan_size = READ_ONCE(sysctl_numa_balancing_scan_size);
|
2013-10-07 10:28:55 +00:00
|
|
|
unsigned int scan, floor;
|
|
|
|
unsigned int windows = 1;
|
|
|
|
|
2014-10-16 10:39:37 +00:00
|
|
|
if (scan_size < MAX_SCAN_WINDOW)
|
|
|
|
windows = MAX_SCAN_WINDOW / scan_size;
|
2013-10-07 10:28:55 +00:00
|
|
|
floor = 1000 / windows;
|
|
|
|
|
|
|
|
scan = sysctl_numa_balancing_scan_period_min / task_nr_scan_windows(p);
|
|
|
|
return max_t(unsigned int, floor, scan);
|
|
|
|
}
|
|
|
|
|
2017-07-31 19:28:47 +00:00
|
|
|
static unsigned int task_scan_start(struct task_struct *p)
|
|
|
|
{
|
|
|
|
unsigned long smin = task_scan_min(p);
|
|
|
|
unsigned long period = smin;
|
|
|
|
|
|
|
|
/* Scale the maximum scan period with the amount of shared memory. */
|
|
|
|
if (p->numa_group) {
|
|
|
|
struct numa_group *ng = p->numa_group;
|
|
|
|
unsigned long shared = group_faults_shared(ng);
|
|
|
|
unsigned long private = group_faults_priv(ng);
|
|
|
|
|
|
|
|
period *= atomic_read(&ng->refcount);
|
|
|
|
period *= shared + 1;
|
|
|
|
period /= private + shared + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return max(smin, period);
|
|
|
|
}
|
|
|
|
|
2013-10-07 10:28:55 +00:00
|
|
|
static unsigned int task_scan_max(struct task_struct *p)
|
|
|
|
{
|
2017-07-31 19:28:47 +00:00
|
|
|
unsigned long smin = task_scan_min(p);
|
|
|
|
unsigned long smax;
|
2013-10-07 10:28:55 +00:00
|
|
|
|
|
|
|
/* Watch for min being lower than max due to floor calculations */
|
|
|
|
smax = sysctl_numa_balancing_scan_period_max / task_nr_scan_windows(p);
|
2017-07-31 19:28:47 +00:00
|
|
|
|
|
|
|
/* Scale the maximum scan period with the amount of shared memory. */
|
|
|
|
if (p->numa_group) {
|
|
|
|
struct numa_group *ng = p->numa_group;
|
|
|
|
unsigned long shared = group_faults_shared(ng);
|
|
|
|
unsigned long private = group_faults_priv(ng);
|
|
|
|
unsigned long period = smax;
|
|
|
|
|
|
|
|
period *= atomic_read(&ng->refcount);
|
|
|
|
period *= shared + 1;
|
|
|
|
period /= private + shared + 1;
|
|
|
|
|
|
|
|
smax = max(smax, period);
|
|
|
|
}
|
|
|
|
|
2013-10-07 10:28:55 +00:00
|
|
|
return max(smin, smax);
|
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:33 +00:00
|
|
|
static void account_numa_enqueue(struct rq *rq, struct task_struct *p)
|
|
|
|
{
|
|
|
|
rq->nr_numa_running += (p->numa_preferred_nid != -1);
|
|
|
|
rq->nr_preferred_running += (p->numa_preferred_nid == task_node(p));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void account_numa_dequeue(struct rq *rq, struct task_struct *p)
|
|
|
|
{
|
|
|
|
rq->nr_numa_running -= (p->numa_preferred_nid != -1);
|
|
|
|
rq->nr_preferred_running -= (p->numa_preferred_nid == task_node(p));
|
|
|
|
}
|
|
|
|
|
2014-01-27 22:03:48 +00:00
|
|
|
/* Shared or private faults. */
|
|
|
|
#define NR_NUMA_HINT_FAULT_TYPES 2
|
|
|
|
|
|
|
|
/* Memory and CPU locality */
|
|
|
|
#define NR_NUMA_HINT_FAULT_STATS (NR_NUMA_HINT_FAULT_TYPES * 2)
|
|
|
|
|
|
|
|
/* Averaged statistics, and temporary buffers. */
|
|
|
|
#define NR_NUMA_HINT_FAULT_BUCKETS (NR_NUMA_HINT_FAULT_STATS * 2)
|
|
|
|
|
2013-10-07 10:29:22 +00:00
|
|
|
pid_t task_numa_group_id(struct task_struct *p)
|
|
|
|
{
|
|
|
|
return p->numa_group ? p->numa_group->gid : 0;
|
|
|
|
}
|
|
|
|
|
2014-10-31 00:13:31 +00:00
|
|
|
/*
|
|
|
|
* The averaged statistics, shared & private, memory & cpu,
|
|
|
|
* occupy the first half of the array. The second half of the
|
|
|
|
* array is for current counters, which are averaged into the
|
|
|
|
* first set by task_numa_placement.
|
|
|
|
*/
|
|
|
|
static inline int task_faults_idx(enum numa_faults_stats s, int nid, int priv)
|
2013-10-07 10:29:03 +00:00
|
|
|
{
|
2014-10-31 00:13:31 +00:00
|
|
|
return NR_NUMA_HINT_FAULT_TYPES * (s * nr_node_ids + nid) + priv;
|
2013-10-07 10:29:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long task_faults(struct task_struct *p, int nid)
|
|
|
|
{
|
2014-10-31 00:13:31 +00:00
|
|
|
if (!p->numa_faults)
|
2013-10-07 10:29:03 +00:00
|
|
|
return 0;
|
|
|
|
|
2014-10-31 00:13:31 +00:00
|
|
|
return p->numa_faults[task_faults_idx(NUMA_MEM, nid, 0)] +
|
|
|
|
p->numa_faults[task_faults_idx(NUMA_MEM, nid, 1)];
|
2013-10-07 10:29:03 +00:00
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:27 +00:00
|
|
|
static inline unsigned long group_faults(struct task_struct *p, int nid)
|
|
|
|
{
|
|
|
|
if (!p->numa_group)
|
|
|
|
return 0;
|
|
|
|
|
2014-10-31 00:13:31 +00:00
|
|
|
return p->numa_group->faults[task_faults_idx(NUMA_MEM, nid, 0)] +
|
|
|
|
p->numa_group->faults[task_faults_idx(NUMA_MEM, nid, 1)];
|
2013-10-07 10:29:27 +00:00
|
|
|
}
|
|
|
|
|
2014-01-27 22:03:43 +00:00
|
|
|
static inline unsigned long group_faults_cpu(struct numa_group *group, int nid)
|
|
|
|
{
|
2014-10-31 00:13:31 +00:00
|
|
|
return group->faults_cpu[task_faults_idx(NUMA_MEM, nid, 0)] +
|
|
|
|
group->faults_cpu[task_faults_idx(NUMA_MEM, nid, 1)];
|
2014-01-27 22:03:43 +00:00
|
|
|
}
|
|
|
|
|
2017-07-31 19:28:47 +00:00
|
|
|
static inline unsigned long group_faults_priv(struct numa_group *ng)
|
|
|
|
{
|
|
|
|
unsigned long faults = 0;
|
|
|
|
int node;
|
|
|
|
|
|
|
|
for_each_online_node(node) {
|
|
|
|
faults += ng->faults[task_faults_idx(NUMA_MEM, node, 1)];
|
|
|
|
}
|
|
|
|
|
|
|
|
return faults;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long group_faults_shared(struct numa_group *ng)
|
|
|
|
{
|
|
|
|
unsigned long faults = 0;
|
|
|
|
int node;
|
|
|
|
|
|
|
|
for_each_online_node(node) {
|
|
|
|
faults += ng->faults[task_faults_idx(NUMA_MEM, node, 0)];
|
|
|
|
}
|
|
|
|
|
|
|
|
return faults;
|
|
|
|
}
|
|
|
|
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
/*
|
|
|
|
* A node triggering more than 1/3 as many NUMA faults as the maximum is
|
|
|
|
* considered part of a numa group's pseudo-interleaving set. Migrations
|
|
|
|
* between these nodes are slowed down, to allow things to settle down.
|
|
|
|
*/
|
|
|
|
#define ACTIVE_NODE_FRACTION 3
|
|
|
|
|
|
|
|
static bool numa_is_active_node(int nid, struct numa_group *ng)
|
|
|
|
{
|
|
|
|
return group_faults_cpu(ng, nid) * ACTIVE_NODE_FRACTION > ng->max_faults_cpu;
|
|
|
|
}
|
|
|
|
|
2014-10-17 07:29:52 +00:00
|
|
|
/* Handle placement on systems where not all nodes are directly connected. */
|
|
|
|
static unsigned long score_nearby_nodes(struct task_struct *p, int nid,
|
|
|
|
int maxdist, bool task)
|
|
|
|
{
|
|
|
|
unsigned long score = 0;
|
|
|
|
int node;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* All nodes are directly connected, and the same distance
|
|
|
|
* from each other. No need for fancy placement algorithms.
|
|
|
|
*/
|
|
|
|
if (sched_numa_topology_type == NUMA_DIRECT)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This code is called for each node, introducing N^2 complexity,
|
|
|
|
* which should be ok given the number of nodes rarely exceeds 8.
|
|
|
|
*/
|
|
|
|
for_each_online_node(node) {
|
|
|
|
unsigned long faults;
|
|
|
|
int dist = node_distance(nid, node);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The furthest away nodes in the system are not interesting
|
|
|
|
* for placement; nid was already counted.
|
|
|
|
*/
|
|
|
|
if (dist == sched_max_numa_distance || node == nid)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* On systems with a backplane NUMA topology, compare groups
|
|
|
|
* of nodes, and move tasks towards the group with the most
|
|
|
|
* memory accesses. When comparing two nodes at distance
|
|
|
|
* "hoplimit", only nodes closer by than "hoplimit" are part
|
|
|
|
* of each group. Skip other nodes.
|
|
|
|
*/
|
|
|
|
if (sched_numa_topology_type == NUMA_BACKPLANE &&
|
|
|
|
dist > maxdist)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Add up the faults from nearby nodes. */
|
|
|
|
if (task)
|
|
|
|
faults = task_faults(p, node);
|
|
|
|
else
|
|
|
|
faults = group_faults(p, node);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* On systems with a glueless mesh NUMA topology, there are
|
|
|
|
* no fixed "groups of nodes". Instead, nodes that are not
|
|
|
|
* directly connected bounce traffic through intermediate
|
|
|
|
* nodes; a numa_group can occupy any set of nodes.
|
|
|
|
* The further away a node is, the less the faults count.
|
|
|
|
* This seems to result in good task placement.
|
|
|
|
*/
|
|
|
|
if (sched_numa_topology_type == NUMA_GLUELESS_MESH) {
|
|
|
|
faults *= (sched_max_numa_distance - dist);
|
|
|
|
faults /= (sched_max_numa_distance - LOCAL_DISTANCE);
|
|
|
|
}
|
|
|
|
|
|
|
|
score += faults;
|
|
|
|
}
|
|
|
|
|
|
|
|
return score;
|
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:27 +00:00
|
|
|
/*
|
|
|
|
* These return the fraction of accesses done by a particular task, or
|
|
|
|
* task group, on a particular numa node. The group weight is given a
|
|
|
|
* larger multiplier, in order to group tasks together that are almost
|
|
|
|
* evenly spread out between numa nodes.
|
|
|
|
*/
|
2014-10-17 07:29:51 +00:00
|
|
|
static inline unsigned long task_weight(struct task_struct *p, int nid,
|
|
|
|
int dist)
|
2013-10-07 10:29:27 +00:00
|
|
|
{
|
2014-10-17 07:29:51 +00:00
|
|
|
unsigned long faults, total_faults;
|
2013-10-07 10:29:27 +00:00
|
|
|
|
2014-10-31 00:13:31 +00:00
|
|
|
if (!p->numa_faults)
|
2013-10-07 10:29:27 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
total_faults = p->total_numa_faults;
|
|
|
|
|
|
|
|
if (!total_faults)
|
|
|
|
return 0;
|
|
|
|
|
2014-10-17 07:29:51 +00:00
|
|
|
faults = task_faults(p, nid);
|
2014-10-17 07:29:52 +00:00
|
|
|
faults += score_nearby_nodes(p, nid, dist, true);
|
|
|
|
|
2014-10-17 07:29:51 +00:00
|
|
|
return 1000 * faults / total_faults;
|
2013-10-07 10:29:27 +00:00
|
|
|
}
|
|
|
|
|
2014-10-17 07:29:51 +00:00
|
|
|
static inline unsigned long group_weight(struct task_struct *p, int nid,
|
|
|
|
int dist)
|
2013-10-07 10:29:27 +00:00
|
|
|
{
|
2014-10-17 07:29:51 +00:00
|
|
|
unsigned long faults, total_faults;
|
|
|
|
|
|
|
|
if (!p->numa_group)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
total_faults = p->numa_group->total_faults;
|
|
|
|
|
|
|
|
if (!total_faults)
|
2013-10-07 10:29:27 +00:00
|
|
|
return 0;
|
|
|
|
|
2014-10-17 07:29:51 +00:00
|
|
|
faults = group_faults(p, nid);
|
2014-10-17 07:29:52 +00:00
|
|
|
faults += score_nearby_nodes(p, nid, dist, false);
|
|
|
|
|
2014-10-17 07:29:51 +00:00
|
|
|
return 1000 * faults / total_faults;
|
2013-10-07 10:29:27 +00:00
|
|
|
}
|
|
|
|
|
2014-01-27 22:03:44 +00:00
|
|
|
bool should_numa_migrate_memory(struct task_struct *p, struct page * page,
|
|
|
|
int src_nid, int dst_cpu)
|
|
|
|
{
|
|
|
|
struct numa_group *ng = p->numa_group;
|
|
|
|
int dst_nid = cpu_to_node(dst_cpu);
|
|
|
|
int last_cpupid, this_cpupid;
|
|
|
|
|
|
|
|
this_cpupid = cpu_pid_to_cpupid(dst_cpu, current->pid);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Multi-stage node selection is used in conjunction with a periodic
|
|
|
|
* migration fault to build a temporal task<->page relation. By using
|
|
|
|
* a two-stage filter we remove short/unlikely relations.
|
|
|
|
*
|
|
|
|
* Using P(p) ~ n_p / n_t as per frequentist probability, we can equate
|
|
|
|
* a task's usage of a particular page (n_p) per total usage of this
|
|
|
|
* page (n_t) (in a given time-span) to a probability.
|
|
|
|
*
|
|
|
|
* Our periodic faults will sample this probability and getting the
|
|
|
|
* same result twice in a row, given these samples are fully
|
|
|
|
* independent, is then given by P(n)^2, provided our sample period
|
|
|
|
* is sufficiently short compared to the usage pattern.
|
|
|
|
*
|
|
|
|
* This quadric squishes small probabilities, making it less likely we
|
|
|
|
* act on an unlikely task<->page relation.
|
|
|
|
*/
|
|
|
|
last_cpupid = page_cpupid_xchg_last(page, this_cpupid);
|
|
|
|
if (!cpupid_pid_unset(last_cpupid) &&
|
|
|
|
cpupid_to_nid(last_cpupid) != dst_nid)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Always allow migrate on private faults */
|
|
|
|
if (cpupid_match_pid(p, last_cpupid))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* A shared fault, but p->numa_group has not been set up yet. */
|
|
|
|
if (!ng)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/*
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
* Destination node is much more heavily used than the source
|
|
|
|
* node? Allow migration.
|
2014-01-27 22:03:44 +00:00
|
|
|
*/
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
if (group_faults_cpu(ng, dst_nid) > group_faults_cpu(ng, src_nid) *
|
|
|
|
ACTIVE_NODE_FRACTION)
|
2014-01-27 22:03:44 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
/*
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
* Distribute memory according to CPU & memory use on each node,
|
|
|
|
* with 3/4 hysteresis to avoid unnecessary memory migrations:
|
|
|
|
*
|
|
|
|
* faults_cpu(dst) 3 faults_cpu(src)
|
|
|
|
* --------------- * - > ---------------
|
|
|
|
* faults_mem(dst) 4 faults_mem(src)
|
2014-01-27 22:03:44 +00:00
|
|
|
*/
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
return group_faults_cpu(ng, dst_nid) * group_faults(p, src_nid) * 3 >
|
|
|
|
group_faults_cpu(ng, src_nid) * group_faults(p, dst_nid) * 4;
|
2014-01-27 22:03:44 +00:00
|
|
|
}
|
|
|
|
|
2017-05-24 05:29:54 +00:00
|
|
|
static unsigned long weighted_cpuload(struct rq *rq);
|
2013-10-07 10:29:10 +00:00
|
|
|
static unsigned long source_load(int cpu, int type);
|
|
|
|
static unsigned long target_load(int cpu, int type);
|
2014-05-26 22:19:38 +00:00
|
|
|
static unsigned long capacity_of(int cpu);
|
2013-10-07 10:29:10 +00:00
|
|
|
|
2013-10-07 10:29:17 +00:00
|
|
|
/* Cached statistics for all CPUs within a node */
|
2013-10-07 10:29:10 +00:00
|
|
|
struct numa_stats {
|
2013-10-07 10:29:17 +00:00
|
|
|
unsigned long nr_running;
|
2013-10-07 10:29:10 +00:00
|
|
|
unsigned long load;
|
2013-10-07 10:29:17 +00:00
|
|
|
|
|
|
|
/* Total compute capacity of CPUs on a node */
|
2014-05-26 22:19:34 +00:00
|
|
|
unsigned long compute_capacity;
|
2013-10-07 10:29:17 +00:00
|
|
|
|
|
|
|
/* Approximate capacity in terms of runnable tasks on a node */
|
2014-05-26 22:19:34 +00:00
|
|
|
unsigned long task_capacity;
|
2014-05-26 22:19:35 +00:00
|
|
|
int has_free_capacity;
|
2013-10-07 10:29:10 +00:00
|
|
|
};
|
2013-10-07 10:29:02 +00:00
|
|
|
|
2013-10-07 10:29:17 +00:00
|
|
|
/*
|
|
|
|
* XXX borrowed from update_sg_lb_stats
|
|
|
|
*/
|
|
|
|
static void update_numa_stats(struct numa_stats *ns, int nid)
|
|
|
|
{
|
2014-08-04 17:23:28 +00:00
|
|
|
int smt, cpu, cpus = 0;
|
|
|
|
unsigned long capacity;
|
2013-10-07 10:29:17 +00:00
|
|
|
|
|
|
|
memset(ns, 0, sizeof(*ns));
|
|
|
|
for_each_cpu(cpu, cpumask_of_node(nid)) {
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
|
|
|
|
|
|
|
ns->nr_running += rq->nr_running;
|
2017-05-24 05:29:54 +00:00
|
|
|
ns->load += weighted_cpuload(rq);
|
2014-05-26 22:19:38 +00:00
|
|
|
ns->compute_capacity += capacity_of(cpu);
|
2013-11-06 17:47:57 +00:00
|
|
|
|
|
|
|
cpus++;
|
2013-10-07 10:29:17 +00:00
|
|
|
}
|
|
|
|
|
2013-11-06 17:47:57 +00:00
|
|
|
/*
|
|
|
|
* If we raced with hotplug and there are no CPUs left in our mask
|
|
|
|
* the @ns structure is NULL'ed and task_numa_compare() will
|
|
|
|
* not find this node attractive.
|
|
|
|
*
|
2014-05-26 22:19:35 +00:00
|
|
|
* We'll either bail at !has_free_capacity, or we'll detect a huge
|
|
|
|
* imbalance and bail there.
|
2013-11-06 17:47:57 +00:00
|
|
|
*/
|
|
|
|
if (!cpus)
|
|
|
|
return;
|
|
|
|
|
2014-08-04 17:23:28 +00:00
|
|
|
/* smt := ceil(cpus / capacity), assumes: 1 < smt_power < 2 */
|
|
|
|
smt = DIV_ROUND_UP(SCHED_CAPACITY_SCALE * cpus, ns->compute_capacity);
|
|
|
|
capacity = cpus / smt; /* cores */
|
|
|
|
|
|
|
|
ns->task_capacity = min_t(unsigned, capacity,
|
|
|
|
DIV_ROUND_CLOSEST(ns->compute_capacity, SCHED_CAPACITY_SCALE));
|
2014-05-26 22:19:35 +00:00
|
|
|
ns->has_free_capacity = (ns->nr_running < ns->task_capacity);
|
2013-10-07 10:29:17 +00:00
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:10 +00:00
|
|
|
struct task_numa_env {
|
|
|
|
struct task_struct *p;
|
2013-10-07 10:29:02 +00:00
|
|
|
|
2013-10-07 10:29:10 +00:00
|
|
|
int src_cpu, src_nid;
|
|
|
|
int dst_cpu, dst_nid;
|
2013-10-07 10:29:02 +00:00
|
|
|
|
2013-10-07 10:29:10 +00:00
|
|
|
struct numa_stats src_stats, dst_stats;
|
2013-10-07 10:29:02 +00:00
|
|
|
|
2013-12-05 11:10:17 +00:00
|
|
|
int imbalance_pct;
|
2014-10-17 07:29:51 +00:00
|
|
|
int dist;
|
2013-10-07 10:29:17 +00:00
|
|
|
|
|
|
|
struct task_struct *best_task;
|
|
|
|
long best_imp;
|
2013-10-07 10:29:10 +00:00
|
|
|
int best_cpu;
|
|
|
|
};
|
|
|
|
|
2013-10-07 10:29:17 +00:00
|
|
|
static void task_numa_assign(struct task_numa_env *env,
|
|
|
|
struct task_struct *p, long imp)
|
|
|
|
{
|
|
|
|
if (env->best_task)
|
|
|
|
put_task_struct(env->best_task);
|
2016-05-18 19:57:33 +00:00
|
|
|
if (p)
|
|
|
|
get_task_struct(p);
|
2013-10-07 10:29:17 +00:00
|
|
|
|
|
|
|
env->best_task = p;
|
|
|
|
env->best_imp = imp;
|
|
|
|
env->best_cpu = env->dst_cpu;
|
|
|
|
}
|
|
|
|
|
2014-06-23 15:46:13 +00:00
|
|
|
static bool load_too_imbalanced(long src_load, long dst_load,
|
2014-05-14 17:22:21 +00:00
|
|
|
struct task_numa_env *env)
|
|
|
|
{
|
2015-05-27 19:04:27 +00:00
|
|
|
long imb, old_imb;
|
|
|
|
long orig_src_load, orig_dst_load;
|
2014-06-23 15:46:13 +00:00
|
|
|
long src_capacity, dst_capacity;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The load is corrected for the CPU capacity available on each node.
|
|
|
|
*
|
|
|
|
* src_load dst_load
|
|
|
|
* ------------ vs ---------
|
|
|
|
* src_capacity dst_capacity
|
|
|
|
*/
|
|
|
|
src_capacity = env->src_stats.compute_capacity;
|
|
|
|
dst_capacity = env->dst_stats.compute_capacity;
|
2014-05-14 17:22:21 +00:00
|
|
|
|
|
|
|
/* We care about the slope of the imbalance, not the direction. */
|
2015-05-27 19:04:27 +00:00
|
|
|
if (dst_load < src_load)
|
|
|
|
swap(dst_load, src_load);
|
2014-05-14 17:22:21 +00:00
|
|
|
|
|
|
|
/* Is the difference below the threshold? */
|
2015-05-27 19:04:27 +00:00
|
|
|
imb = dst_load * src_capacity * 100 -
|
|
|
|
src_load * dst_capacity * env->imbalance_pct;
|
2014-05-14 17:22:21 +00:00
|
|
|
if (imb <= 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The imbalance is above the allowed threshold.
|
2015-05-27 19:04:27 +00:00
|
|
|
* Compare it with the old imbalance.
|
2014-05-14 17:22:21 +00:00
|
|
|
*/
|
2014-06-23 15:46:13 +00:00
|
|
|
orig_src_load = env->src_stats.load;
|
2015-05-27 19:04:27 +00:00
|
|
|
orig_dst_load = env->dst_stats.load;
|
2014-06-23 15:46:13 +00:00
|
|
|
|
2015-05-27 19:04:27 +00:00
|
|
|
if (orig_dst_load < orig_src_load)
|
|
|
|
swap(orig_dst_load, orig_src_load);
|
2014-05-14 17:22:21 +00:00
|
|
|
|
2015-05-27 19:04:27 +00:00
|
|
|
old_imb = orig_dst_load * src_capacity * 100 -
|
|
|
|
orig_src_load * dst_capacity * env->imbalance_pct;
|
|
|
|
|
|
|
|
/* Would this change make things worse? */
|
|
|
|
return (imb > old_imb);
|
2014-05-14 17:22:21 +00:00
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:17 +00:00
|
|
|
/*
|
|
|
|
* This checks if the overall compute and NUMA accesses of the system would
|
|
|
|
* be improved if the source tasks was migrated to the target dst_cpu taking
|
|
|
|
* into account that it might be best if task running on the dst_cpu should
|
|
|
|
* be exchanged with the source task
|
|
|
|
*/
|
2013-10-07 10:29:31 +00:00
|
|
|
static void task_numa_compare(struct task_numa_env *env,
|
|
|
|
long taskimp, long groupimp)
|
2013-10-07 10:29:17 +00:00
|
|
|
{
|
|
|
|
struct rq *src_rq = cpu_rq(env->src_cpu);
|
|
|
|
struct rq *dst_rq = cpu_rq(env->dst_cpu);
|
|
|
|
struct task_struct *cur;
|
2014-06-23 15:46:13 +00:00
|
|
|
long src_load, dst_load;
|
2013-10-07 10:29:17 +00:00
|
|
|
long load;
|
2014-06-23 15:46:15 +00:00
|
|
|
long imp = env->p->numa_group ? groupimp : taskimp;
|
sched/numa: Examine a task move when examining a task swap
Running "perf bench numa mem -0 -m -P 1000 -p 8 -t 20" on a 4
node system results in 160 runnable threads on a system with 80
CPU threads.
Once a process has nearly converged, with 39 threads on one node
and 1 thread on another node, the remaining thread will be unable
to migrate to its preferred node through a task swap.
However, a simple task move would make the workload converge,
witout causing an imbalance.
Test for this unlikely occurrence, and attempt a task move to
the preferred nid when it happens.
# Running main, "perf bench numa mem -p 8 -t 20 -0 -m -P 1000"
###
# 160 tasks will execute (on 4 nodes, 80 CPUs):
# -1x 0MB global shared mem operations
# -1x 1000MB process shared mem operations
# -1x 0MB thread local mem operations
###
###
#
# 0.0% [0.2 mins] 0/0 1/1 36/2 0/0 [36/3 ] l: 0-0 ( 0) {0-2}
# 0.0% [0.3 mins] 43/3 37/2 39/2 41/3 [ 6/10] l: 0-1 ( 1) {1-2}
# 0.0% [0.4 mins] 42/3 38/2 40/2 40/2 [ 4/9 ] l: 1-2 ( 1) [50.0%] {1-2}
# 0.0% [0.6 mins] 41/3 39/2 40/2 40/2 [ 2/9 ] l: 2-4 ( 2) [50.0%] {1-2}
# 0.0% [0.7 mins] 40/2 40/2 40/2 40/2 [ 0/8 ] l: 3-5 ( 2) [40.0%] ( 41.8s converged)
Without this patch, this same perf bench numa mem run had to
rely on the scheduler load balancer to first balance out the
load (moving a random task), before a task swap could complete
the NUMA convergence.
The load balancer does not normally take action unless the load
difference exceeds 25%. Convergence times of over half an hour
have been observed without this patch.
With this patch, the NUMA balancing code will simply migrate the
task, if that does not cause an imbalance.
Also skip examining a CPU in detail if the improvement on that CPU
is no more than the best we already have.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: chegu_vinod@hp.com
Cc: mgorman@suse.de
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/n/tip-ggthh0rnh0yua6o5o3p6cr1o@git.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-06-23 15:46:16 +00:00
|
|
|
long moveimp = imp;
|
2014-10-17 07:29:51 +00:00
|
|
|
int dist = env->dist;
|
2013-10-07 10:29:17 +00:00
|
|
|
|
|
|
|
rcu_read_lock();
|
2016-05-18 19:57:33 +00:00
|
|
|
cur = task_rcu_dereference(&dst_rq->curr);
|
|
|
|
if (cur && ((cur->flags & PF_EXITING) || is_idle_task(cur)))
|
2013-10-07 10:29:17 +00:00
|
|
|
cur = NULL;
|
|
|
|
|
2014-11-10 09:54:35 +00:00
|
|
|
/*
|
|
|
|
* Because we have preemption enabled we can get migrated around and
|
|
|
|
* end try selecting ourselves (current == env->p) as a swap candidate.
|
|
|
|
*/
|
|
|
|
if (cur == env->p)
|
|
|
|
goto unlock;
|
|
|
|
|
2013-10-07 10:29:17 +00:00
|
|
|
/*
|
|
|
|
* "imp" is the fault differential for the source task between the
|
|
|
|
* source and destination node. Calculate the total differential for
|
|
|
|
* the source task and potential destination task. The more negative
|
|
|
|
* the value is, the more rmeote accesses that would be expected to
|
|
|
|
* be incurred if the tasks were swapped.
|
|
|
|
*/
|
|
|
|
if (cur) {
|
|
|
|
/* Skip this swap candidate if cannot move to the source cpu */
|
2017-02-05 14:38:10 +00:00
|
|
|
if (!cpumask_test_cpu(env->src_cpu, &cur->cpus_allowed))
|
2013-10-07 10:29:17 +00:00
|
|
|
goto unlock;
|
|
|
|
|
2013-10-07 10:29:31 +00:00
|
|
|
/*
|
|
|
|
* If dst and source tasks are in the same NUMA group, or not
|
2013-10-07 10:29:32 +00:00
|
|
|
* in any group then look only at task weights.
|
2013-10-07 10:29:31 +00:00
|
|
|
*/
|
2013-10-07 10:29:32 +00:00
|
|
|
if (cur->numa_group == env->p->numa_group) {
|
2014-10-17 07:29:51 +00:00
|
|
|
imp = taskimp + task_weight(cur, env->src_nid, dist) -
|
|
|
|
task_weight(cur, env->dst_nid, dist);
|
2013-10-07 10:29:32 +00:00
|
|
|
/*
|
|
|
|
* Add some hysteresis to prevent swapping the
|
|
|
|
* tasks within a group over tiny differences.
|
|
|
|
*/
|
|
|
|
if (cur->numa_group)
|
|
|
|
imp -= imp/16;
|
2013-10-07 10:29:31 +00:00
|
|
|
} else {
|
2013-10-07 10:29:32 +00:00
|
|
|
/*
|
|
|
|
* Compare the group weights. If a task is all by
|
|
|
|
* itself (not part of a group), use the task weight
|
|
|
|
* instead.
|
|
|
|
*/
|
|
|
|
if (cur->numa_group)
|
2014-10-17 07:29:51 +00:00
|
|
|
imp += group_weight(cur, env->src_nid, dist) -
|
|
|
|
group_weight(cur, env->dst_nid, dist);
|
2013-10-07 10:29:32 +00:00
|
|
|
else
|
2014-10-17 07:29:51 +00:00
|
|
|
imp += task_weight(cur, env->src_nid, dist) -
|
|
|
|
task_weight(cur, env->dst_nid, dist);
|
2013-10-07 10:29:31 +00:00
|
|
|
}
|
2013-10-07 10:29:17 +00:00
|
|
|
}
|
|
|
|
|
sched/numa: Examine a task move when examining a task swap
Running "perf bench numa mem -0 -m -P 1000 -p 8 -t 20" on a 4
node system results in 160 runnable threads on a system with 80
CPU threads.
Once a process has nearly converged, with 39 threads on one node
and 1 thread on another node, the remaining thread will be unable
to migrate to its preferred node through a task swap.
However, a simple task move would make the workload converge,
witout causing an imbalance.
Test for this unlikely occurrence, and attempt a task move to
the preferred nid when it happens.
# Running main, "perf bench numa mem -p 8 -t 20 -0 -m -P 1000"
###
# 160 tasks will execute (on 4 nodes, 80 CPUs):
# -1x 0MB global shared mem operations
# -1x 1000MB process shared mem operations
# -1x 0MB thread local mem operations
###
###
#
# 0.0% [0.2 mins] 0/0 1/1 36/2 0/0 [36/3 ] l: 0-0 ( 0) {0-2}
# 0.0% [0.3 mins] 43/3 37/2 39/2 41/3 [ 6/10] l: 0-1 ( 1) {1-2}
# 0.0% [0.4 mins] 42/3 38/2 40/2 40/2 [ 4/9 ] l: 1-2 ( 1) [50.0%] {1-2}
# 0.0% [0.6 mins] 41/3 39/2 40/2 40/2 [ 2/9 ] l: 2-4 ( 2) [50.0%] {1-2}
# 0.0% [0.7 mins] 40/2 40/2 40/2 40/2 [ 0/8 ] l: 3-5 ( 2) [40.0%] ( 41.8s converged)
Without this patch, this same perf bench numa mem run had to
rely on the scheduler load balancer to first balance out the
load (moving a random task), before a task swap could complete
the NUMA convergence.
The load balancer does not normally take action unless the load
difference exceeds 25%. Convergence times of over half an hour
have been observed without this patch.
With this patch, the NUMA balancing code will simply migrate the
task, if that does not cause an imbalance.
Also skip examining a CPU in detail if the improvement on that CPU
is no more than the best we already have.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: chegu_vinod@hp.com
Cc: mgorman@suse.de
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/n/tip-ggthh0rnh0yua6o5o3p6cr1o@git.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-06-23 15:46:16 +00:00
|
|
|
if (imp <= env->best_imp && moveimp <= env->best_imp)
|
2013-10-07 10:29:17 +00:00
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
if (!cur) {
|
|
|
|
/* Is there capacity at our destination? */
|
2014-08-04 17:23:27 +00:00
|
|
|
if (env->src_stats.nr_running <= env->src_stats.task_capacity &&
|
2014-05-26 22:19:35 +00:00
|
|
|
!env->dst_stats.has_free_capacity)
|
2013-10-07 10:29:17 +00:00
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
goto balance;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Balance doesn't matter much if we're running a task per cpu */
|
sched/numa: Examine a task move when examining a task swap
Running "perf bench numa mem -0 -m -P 1000 -p 8 -t 20" on a 4
node system results in 160 runnable threads on a system with 80
CPU threads.
Once a process has nearly converged, with 39 threads on one node
and 1 thread on another node, the remaining thread will be unable
to migrate to its preferred node through a task swap.
However, a simple task move would make the workload converge,
witout causing an imbalance.
Test for this unlikely occurrence, and attempt a task move to
the preferred nid when it happens.
# Running main, "perf bench numa mem -p 8 -t 20 -0 -m -P 1000"
###
# 160 tasks will execute (on 4 nodes, 80 CPUs):
# -1x 0MB global shared mem operations
# -1x 1000MB process shared mem operations
# -1x 0MB thread local mem operations
###
###
#
# 0.0% [0.2 mins] 0/0 1/1 36/2 0/0 [36/3 ] l: 0-0 ( 0) {0-2}
# 0.0% [0.3 mins] 43/3 37/2 39/2 41/3 [ 6/10] l: 0-1 ( 1) {1-2}
# 0.0% [0.4 mins] 42/3 38/2 40/2 40/2 [ 4/9 ] l: 1-2 ( 1) [50.0%] {1-2}
# 0.0% [0.6 mins] 41/3 39/2 40/2 40/2 [ 2/9 ] l: 2-4 ( 2) [50.0%] {1-2}
# 0.0% [0.7 mins] 40/2 40/2 40/2 40/2 [ 0/8 ] l: 3-5 ( 2) [40.0%] ( 41.8s converged)
Without this patch, this same perf bench numa mem run had to
rely on the scheduler load balancer to first balance out the
load (moving a random task), before a task swap could complete
the NUMA convergence.
The load balancer does not normally take action unless the load
difference exceeds 25%. Convergence times of over half an hour
have been observed without this patch.
With this patch, the NUMA balancing code will simply migrate the
task, if that does not cause an imbalance.
Also skip examining a CPU in detail if the improvement on that CPU
is no more than the best we already have.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: chegu_vinod@hp.com
Cc: mgorman@suse.de
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/n/tip-ggthh0rnh0yua6o5o3p6cr1o@git.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-06-23 15:46:16 +00:00
|
|
|
if (imp > env->best_imp && src_rq->nr_running == 1 &&
|
|
|
|
dst_rq->nr_running == 1)
|
2013-10-07 10:29:17 +00:00
|
|
|
goto assign;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In the overloaded case, try and keep the load balanced.
|
|
|
|
*/
|
|
|
|
balance:
|
2014-07-11 14:01:53 +00:00
|
|
|
load = task_h_load(env->p);
|
|
|
|
dst_load = env->dst_stats.load + load;
|
|
|
|
src_load = env->src_stats.load - load;
|
2013-10-07 10:29:17 +00:00
|
|
|
|
sched/numa: Examine a task move when examining a task swap
Running "perf bench numa mem -0 -m -P 1000 -p 8 -t 20" on a 4
node system results in 160 runnable threads on a system with 80
CPU threads.
Once a process has nearly converged, with 39 threads on one node
and 1 thread on another node, the remaining thread will be unable
to migrate to its preferred node through a task swap.
However, a simple task move would make the workload converge,
witout causing an imbalance.
Test for this unlikely occurrence, and attempt a task move to
the preferred nid when it happens.
# Running main, "perf bench numa mem -p 8 -t 20 -0 -m -P 1000"
###
# 160 tasks will execute (on 4 nodes, 80 CPUs):
# -1x 0MB global shared mem operations
# -1x 1000MB process shared mem operations
# -1x 0MB thread local mem operations
###
###
#
# 0.0% [0.2 mins] 0/0 1/1 36/2 0/0 [36/3 ] l: 0-0 ( 0) {0-2}
# 0.0% [0.3 mins] 43/3 37/2 39/2 41/3 [ 6/10] l: 0-1 ( 1) {1-2}
# 0.0% [0.4 mins] 42/3 38/2 40/2 40/2 [ 4/9 ] l: 1-2 ( 1) [50.0%] {1-2}
# 0.0% [0.6 mins] 41/3 39/2 40/2 40/2 [ 2/9 ] l: 2-4 ( 2) [50.0%] {1-2}
# 0.0% [0.7 mins] 40/2 40/2 40/2 40/2 [ 0/8 ] l: 3-5 ( 2) [40.0%] ( 41.8s converged)
Without this patch, this same perf bench numa mem run had to
rely on the scheduler load balancer to first balance out the
load (moving a random task), before a task swap could complete
the NUMA convergence.
The load balancer does not normally take action unless the load
difference exceeds 25%. Convergence times of over half an hour
have been observed without this patch.
With this patch, the NUMA balancing code will simply migrate the
task, if that does not cause an imbalance.
Also skip examining a CPU in detail if the improvement on that CPU
is no more than the best we already have.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: chegu_vinod@hp.com
Cc: mgorman@suse.de
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/n/tip-ggthh0rnh0yua6o5o3p6cr1o@git.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-06-23 15:46:16 +00:00
|
|
|
if (moveimp > imp && moveimp > env->best_imp) {
|
|
|
|
/*
|
|
|
|
* If the improvement from just moving env->p direction is
|
|
|
|
* better than swapping tasks around, check if a move is
|
|
|
|
* possible. Store a slightly smaller score than moveimp,
|
|
|
|
* so an actually idle CPU will win.
|
|
|
|
*/
|
|
|
|
if (!load_too_imbalanced(src_load, dst_load, env)) {
|
|
|
|
imp = moveimp - 1;
|
|
|
|
cur = NULL;
|
|
|
|
goto assign;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (imp <= env->best_imp)
|
|
|
|
goto unlock;
|
|
|
|
|
2013-10-07 10:29:17 +00:00
|
|
|
if (cur) {
|
2014-07-11 14:01:53 +00:00
|
|
|
load = task_h_load(cur);
|
|
|
|
dst_load -= load;
|
|
|
|
src_load += load;
|
2013-10-07 10:29:17 +00:00
|
|
|
}
|
|
|
|
|
2014-06-23 15:46:13 +00:00
|
|
|
if (load_too_imbalanced(src_load, dst_load, env))
|
2013-10-07 10:29:17 +00:00
|
|
|
goto unlock;
|
|
|
|
|
2014-09-04 20:35:30 +00:00
|
|
|
/*
|
|
|
|
* One idle CPU per node is evaluated for a task numa move.
|
|
|
|
* Call select_idle_sibling to maybe find a better one.
|
|
|
|
*/
|
2016-05-09 08:38:05 +00:00
|
|
|
if (!cur) {
|
|
|
|
/*
|
|
|
|
* select_idle_siblings() uses an per-cpu cpumask that
|
|
|
|
* can be used from IRQ context.
|
|
|
|
*/
|
|
|
|
local_irq_disable();
|
2016-06-22 17:03:13 +00:00
|
|
|
env->dst_cpu = select_idle_sibling(env->p, env->src_cpu,
|
|
|
|
env->dst_cpu);
|
2016-05-09 08:38:05 +00:00
|
|
|
local_irq_enable();
|
|
|
|
}
|
2014-09-04 20:35:30 +00:00
|
|
|
|
2013-10-07 10:29:17 +00:00
|
|
|
assign:
|
|
|
|
task_numa_assign(env, cur, imp);
|
|
|
|
unlock:
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:31 +00:00
|
|
|
static void task_numa_find_cpu(struct task_numa_env *env,
|
|
|
|
long taskimp, long groupimp)
|
2013-10-07 10:29:18 +00:00
|
|
|
{
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
for_each_cpu(cpu, cpumask_of_node(env->dst_nid)) {
|
|
|
|
/* Skip this CPU if the source task cannot migrate */
|
2017-02-05 14:38:10 +00:00
|
|
|
if (!cpumask_test_cpu(cpu, &env->p->cpus_allowed))
|
2013-10-07 10:29:18 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
env->dst_cpu = cpu;
|
2013-10-07 10:29:31 +00:00
|
|
|
task_numa_compare(env, taskimp, groupimp);
|
2013-10-07 10:29:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
sched/numa: Only consider less busy nodes as numa balancing destinations
Changeset a43455a1d572 ("sched/numa: Ensure task_numa_migrate() checks
the preferred node") fixes an issue where workloads would never
converge on a fully loaded (or overloaded) system.
However, it introduces a regression on less than fully loaded systems,
where workloads converge on a few NUMA nodes, instead of properly
staying spread out across the whole system. This leads to a reduction
in available memory bandwidth, and usable CPU cache, with predictable
performance problems.
The root cause appears to be an interaction between the load balancer
and NUMA balancing, where the short term load represented by the load
balancer differs from the long term load the NUMA balancing code would
like to base its decisions on.
Simply reverting a43455a1d572 would re-introduce the non-convergence
of workloads on fully loaded systems, so that is not a good option. As
an aside, the check done before a43455a1d572 only applied to a task's
preferred node, not to other candidate nodes in the system, so the
converge-on-too-few-nodes problem still happens, just to a lesser
degree.
Instead, try to compensate for the impedance mismatch between the load
balancer and NUMA balancing by only ever considering a lesser loaded
node as a destination for NUMA balancing, regardless of whether the
task is trying to move to the preferred node, or to another node.
This patch also addresses the issue that a system with a single
runnable thread would never migrate that thread to near its memory,
introduced by 095bebf61a46 ("sched/numa: Do not move past the balance
point if unbalanced").
A test where the main thread creates a large memory area, and spawns a
worker thread to iterate over the memory (placed on another node by
select_task_rq_fair), after which the main thread goes to sleep and
waits for the worker thread to loop over all the memory now sees the
worker thread migrated to where the memory is, instead of having all
the memory migrated over like before.
Jirka has run a number of performance tests on several systems: single
instance SpecJBB 2005 performance is 7-15% higher on a 4 node system,
with higher gains on systems with more cores per socket.
Multi-instance SpecJBB 2005 (one per node), linpack, and stream see
little or no changes with the revert of 095bebf61a46 and this patch.
Reported-by: Artem Bityutski <dedekind1@gmail.com>
Reported-by: Jirka Hladky <jhladky@redhat.com>
Tested-by: Jirka Hladky <jhladky@redhat.com>
Tested-by: Artem Bityutskiy <dedekind1@gmail.com>
Signed-off-by: Rik van Riel <riel@redhat.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20150528095249.3083ade0@annuminas.surriel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-05-28 13:52:49 +00:00
|
|
|
/* Only move tasks to a NUMA node less busy than the current node. */
|
|
|
|
static bool numa_has_capacity(struct task_numa_env *env)
|
|
|
|
{
|
|
|
|
struct numa_stats *src = &env->src_stats;
|
|
|
|
struct numa_stats *dst = &env->dst_stats;
|
|
|
|
|
|
|
|
if (src->has_free_capacity && !dst->has_free_capacity)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Only consider a task move if the source has a higher load
|
|
|
|
* than the destination, corrected for CPU capacity on each node.
|
|
|
|
*
|
|
|
|
* src->load dst->load
|
|
|
|
* --------------------- vs ---------------------
|
|
|
|
* src->compute_capacity dst->compute_capacity
|
|
|
|
*/
|
2015-06-16 11:56:00 +00:00
|
|
|
if (src->load * dst->compute_capacity * env->imbalance_pct >
|
|
|
|
|
|
|
|
dst->load * src->compute_capacity * 100)
|
sched/numa: Only consider less busy nodes as numa balancing destinations
Changeset a43455a1d572 ("sched/numa: Ensure task_numa_migrate() checks
the preferred node") fixes an issue where workloads would never
converge on a fully loaded (or overloaded) system.
However, it introduces a regression on less than fully loaded systems,
where workloads converge on a few NUMA nodes, instead of properly
staying spread out across the whole system. This leads to a reduction
in available memory bandwidth, and usable CPU cache, with predictable
performance problems.
The root cause appears to be an interaction between the load balancer
and NUMA balancing, where the short term load represented by the load
balancer differs from the long term load the NUMA balancing code would
like to base its decisions on.
Simply reverting a43455a1d572 would re-introduce the non-convergence
of workloads on fully loaded systems, so that is not a good option. As
an aside, the check done before a43455a1d572 only applied to a task's
preferred node, not to other candidate nodes in the system, so the
converge-on-too-few-nodes problem still happens, just to a lesser
degree.
Instead, try to compensate for the impedance mismatch between the load
balancer and NUMA balancing by only ever considering a lesser loaded
node as a destination for NUMA balancing, regardless of whether the
task is trying to move to the preferred node, or to another node.
This patch also addresses the issue that a system with a single
runnable thread would never migrate that thread to near its memory,
introduced by 095bebf61a46 ("sched/numa: Do not move past the balance
point if unbalanced").
A test where the main thread creates a large memory area, and spawns a
worker thread to iterate over the memory (placed on another node by
select_task_rq_fair), after which the main thread goes to sleep and
waits for the worker thread to loop over all the memory now sees the
worker thread migrated to where the memory is, instead of having all
the memory migrated over like before.
Jirka has run a number of performance tests on several systems: single
instance SpecJBB 2005 performance is 7-15% higher on a 4 node system,
with higher gains on systems with more cores per socket.
Multi-instance SpecJBB 2005 (one per node), linpack, and stream see
little or no changes with the revert of 095bebf61a46 and this patch.
Reported-by: Artem Bityutski <dedekind1@gmail.com>
Reported-by: Jirka Hladky <jhladky@redhat.com>
Tested-by: Jirka Hladky <jhladky@redhat.com>
Tested-by: Artem Bityutskiy <dedekind1@gmail.com>
Signed-off-by: Rik van Riel <riel@redhat.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20150528095249.3083ade0@annuminas.surriel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-05-28 13:52:49 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:10 +00:00
|
|
|
static int task_numa_migrate(struct task_struct *p)
|
|
|
|
{
|
|
|
|
struct task_numa_env env = {
|
|
|
|
.p = p,
|
2013-10-07 10:29:17 +00:00
|
|
|
|
2013-10-07 10:29:10 +00:00
|
|
|
.src_cpu = task_cpu(p),
|
2013-10-07 10:29:30 +00:00
|
|
|
.src_nid = task_node(p),
|
2013-10-07 10:29:17 +00:00
|
|
|
|
|
|
|
.imbalance_pct = 112,
|
|
|
|
|
|
|
|
.best_task = NULL,
|
|
|
|
.best_imp = 0,
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
.best_cpu = -1,
|
2013-10-07 10:29:10 +00:00
|
|
|
};
|
|
|
|
struct sched_domain *sd;
|
2013-10-07 10:29:31 +00:00
|
|
|
unsigned long taskweight, groupweight;
|
2014-10-17 07:29:51 +00:00
|
|
|
int nid, ret, dist;
|
2013-10-07 10:29:31 +00:00
|
|
|
long taskimp, groupimp;
|
2013-10-07 10:29:02 +00:00
|
|
|
|
2013-10-07 10:29:10 +00:00
|
|
|
/*
|
2013-10-07 10:29:17 +00:00
|
|
|
* Pick the lowest SD_NUMA domain, as that would have the smallest
|
|
|
|
* imbalance and would be the first to start moving tasks about.
|
|
|
|
*
|
|
|
|
* And we want to avoid any moving of tasks about, as that would create
|
|
|
|
* random movement of tasks -- counter the numa conditions we're trying
|
|
|
|
* to satisfy here.
|
2013-10-07 10:29:10 +00:00
|
|
|
*/
|
|
|
|
rcu_read_lock();
|
2013-10-07 10:29:17 +00:00
|
|
|
sd = rcu_dereference(per_cpu(sd_numa, env.src_cpu));
|
2013-11-12 00:29:25 +00:00
|
|
|
if (sd)
|
|
|
|
env.imbalance_pct = 100 + (sd->imbalance_pct - 100) / 2;
|
2013-10-07 10:29:02 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
2013-11-12 00:29:25 +00:00
|
|
|
/*
|
|
|
|
* Cpusets can break the scheduler domain tree into smaller
|
|
|
|
* balance domains, some of which do not cross NUMA boundaries.
|
|
|
|
* Tasks that are "trapped" in such domains cannot be migrated
|
|
|
|
* elsewhere, so there is no point in (re)trying.
|
|
|
|
*/
|
|
|
|
if (unlikely(!sd)) {
|
2013-12-12 07:23:24 +00:00
|
|
|
p->numa_preferred_nid = task_node(p);
|
2013-11-12 00:29:25 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:18 +00:00
|
|
|
env.dst_nid = p->numa_preferred_nid;
|
2014-10-17 07:29:51 +00:00
|
|
|
dist = env.dist = node_distance(env.src_nid, env.dst_nid);
|
|
|
|
taskweight = task_weight(p, env.src_nid, dist);
|
|
|
|
groupweight = group_weight(p, env.src_nid, dist);
|
|
|
|
update_numa_stats(&env.src_stats, env.src_nid);
|
|
|
|
taskimp = task_weight(p, env.dst_nid, dist) - taskweight;
|
|
|
|
groupimp = group_weight(p, env.dst_nid, dist) - groupweight;
|
2013-10-07 10:29:18 +00:00
|
|
|
update_numa_stats(&env.dst_stats, env.dst_nid);
|
2013-10-07 10:29:10 +00:00
|
|
|
|
2014-06-04 20:09:42 +00:00
|
|
|
/* Try to find a spot on the preferred nid. */
|
sched/numa: Only consider less busy nodes as numa balancing destinations
Changeset a43455a1d572 ("sched/numa: Ensure task_numa_migrate() checks
the preferred node") fixes an issue where workloads would never
converge on a fully loaded (or overloaded) system.
However, it introduces a regression on less than fully loaded systems,
where workloads converge on a few NUMA nodes, instead of properly
staying spread out across the whole system. This leads to a reduction
in available memory bandwidth, and usable CPU cache, with predictable
performance problems.
The root cause appears to be an interaction between the load balancer
and NUMA balancing, where the short term load represented by the load
balancer differs from the long term load the NUMA balancing code would
like to base its decisions on.
Simply reverting a43455a1d572 would re-introduce the non-convergence
of workloads on fully loaded systems, so that is not a good option. As
an aside, the check done before a43455a1d572 only applied to a task's
preferred node, not to other candidate nodes in the system, so the
converge-on-too-few-nodes problem still happens, just to a lesser
degree.
Instead, try to compensate for the impedance mismatch between the load
balancer and NUMA balancing by only ever considering a lesser loaded
node as a destination for NUMA balancing, regardless of whether the
task is trying to move to the preferred node, or to another node.
This patch also addresses the issue that a system with a single
runnable thread would never migrate that thread to near its memory,
introduced by 095bebf61a46 ("sched/numa: Do not move past the balance
point if unbalanced").
A test where the main thread creates a large memory area, and spawns a
worker thread to iterate over the memory (placed on another node by
select_task_rq_fair), after which the main thread goes to sleep and
waits for the worker thread to loop over all the memory now sees the
worker thread migrated to where the memory is, instead of having all
the memory migrated over like before.
Jirka has run a number of performance tests on several systems: single
instance SpecJBB 2005 performance is 7-15% higher on a 4 node system,
with higher gains on systems with more cores per socket.
Multi-instance SpecJBB 2005 (one per node), linpack, and stream see
little or no changes with the revert of 095bebf61a46 and this patch.
Reported-by: Artem Bityutski <dedekind1@gmail.com>
Reported-by: Jirka Hladky <jhladky@redhat.com>
Tested-by: Jirka Hladky <jhladky@redhat.com>
Tested-by: Artem Bityutskiy <dedekind1@gmail.com>
Signed-off-by: Rik van Riel <riel@redhat.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20150528095249.3083ade0@annuminas.surriel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-05-28 13:52:49 +00:00
|
|
|
if (numa_has_capacity(&env))
|
|
|
|
task_numa_find_cpu(&env, taskimp, groupimp);
|
2013-10-07 10:29:19 +00:00
|
|
|
|
2014-10-09 21:27:47 +00:00
|
|
|
/*
|
|
|
|
* Look at other nodes in these cases:
|
|
|
|
* - there is no space available on the preferred_nid
|
|
|
|
* - the task is part of a numa_group that is interleaved across
|
|
|
|
* multiple NUMA nodes; in order to better consolidate the group,
|
|
|
|
* we need to check other locations.
|
|
|
|
*/
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
if (env.best_cpu == -1 || (p->numa_group && p->numa_group->active_nodes > 1)) {
|
2013-10-07 10:29:18 +00:00
|
|
|
for_each_online_node(nid) {
|
|
|
|
if (nid == env.src_nid || nid == p->numa_preferred_nid)
|
|
|
|
continue;
|
2013-10-07 10:29:10 +00:00
|
|
|
|
2014-10-17 07:29:51 +00:00
|
|
|
dist = node_distance(env.src_nid, env.dst_nid);
|
2014-10-17 07:29:52 +00:00
|
|
|
if (sched_numa_topology_type == NUMA_BACKPLANE &&
|
|
|
|
dist != env.dist) {
|
|
|
|
taskweight = task_weight(p, env.src_nid, dist);
|
|
|
|
groupweight = group_weight(p, env.src_nid, dist);
|
|
|
|
}
|
2014-10-17 07:29:51 +00:00
|
|
|
|
2013-10-07 10:29:27 +00:00
|
|
|
/* Only consider nodes where both task and groups benefit */
|
2014-10-17 07:29:51 +00:00
|
|
|
taskimp = task_weight(p, nid, dist) - taskweight;
|
|
|
|
groupimp = group_weight(p, nid, dist) - groupweight;
|
2013-10-07 10:29:31 +00:00
|
|
|
if (taskimp < 0 && groupimp < 0)
|
2013-10-07 10:29:17 +00:00
|
|
|
continue;
|
|
|
|
|
2014-10-17 07:29:51 +00:00
|
|
|
env.dist = dist;
|
2013-10-07 10:29:18 +00:00
|
|
|
env.dst_nid = nid;
|
|
|
|
update_numa_stats(&env.dst_stats, env.dst_nid);
|
sched/numa: Only consider less busy nodes as numa balancing destinations
Changeset a43455a1d572 ("sched/numa: Ensure task_numa_migrate() checks
the preferred node") fixes an issue where workloads would never
converge on a fully loaded (or overloaded) system.
However, it introduces a regression on less than fully loaded systems,
where workloads converge on a few NUMA nodes, instead of properly
staying spread out across the whole system. This leads to a reduction
in available memory bandwidth, and usable CPU cache, with predictable
performance problems.
The root cause appears to be an interaction between the load balancer
and NUMA balancing, where the short term load represented by the load
balancer differs from the long term load the NUMA balancing code would
like to base its decisions on.
Simply reverting a43455a1d572 would re-introduce the non-convergence
of workloads on fully loaded systems, so that is not a good option. As
an aside, the check done before a43455a1d572 only applied to a task's
preferred node, not to other candidate nodes in the system, so the
converge-on-too-few-nodes problem still happens, just to a lesser
degree.
Instead, try to compensate for the impedance mismatch between the load
balancer and NUMA balancing by only ever considering a lesser loaded
node as a destination for NUMA balancing, regardless of whether the
task is trying to move to the preferred node, or to another node.
This patch also addresses the issue that a system with a single
runnable thread would never migrate that thread to near its memory,
introduced by 095bebf61a46 ("sched/numa: Do not move past the balance
point if unbalanced").
A test where the main thread creates a large memory area, and spawns a
worker thread to iterate over the memory (placed on another node by
select_task_rq_fair), after which the main thread goes to sleep and
waits for the worker thread to loop over all the memory now sees the
worker thread migrated to where the memory is, instead of having all
the memory migrated over like before.
Jirka has run a number of performance tests on several systems: single
instance SpecJBB 2005 performance is 7-15% higher on a 4 node system,
with higher gains on systems with more cores per socket.
Multi-instance SpecJBB 2005 (one per node), linpack, and stream see
little or no changes with the revert of 095bebf61a46 and this patch.
Reported-by: Artem Bityutski <dedekind1@gmail.com>
Reported-by: Jirka Hladky <jhladky@redhat.com>
Tested-by: Jirka Hladky <jhladky@redhat.com>
Tested-by: Artem Bityutskiy <dedekind1@gmail.com>
Signed-off-by: Rik van Riel <riel@redhat.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20150528095249.3083ade0@annuminas.surriel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-05-28 13:52:49 +00:00
|
|
|
if (numa_has_capacity(&env))
|
|
|
|
task_numa_find_cpu(&env, taskimp, groupimp);
|
2013-10-07 10:29:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-11 17:00:29 +00:00
|
|
|
/*
|
|
|
|
* If the task is part of a workload that spans multiple NUMA nodes,
|
|
|
|
* and is migrating into one of the workload's active nodes, remember
|
|
|
|
* this node as the task's preferred numa node, so the workload can
|
|
|
|
* settle down.
|
|
|
|
* A task that migrated to a second choice node will be better off
|
|
|
|
* trying for a better one later. Do not set the preferred node here.
|
|
|
|
*/
|
2014-06-23 15:41:34 +00:00
|
|
|
if (p->numa_group) {
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
struct numa_group *ng = p->numa_group;
|
|
|
|
|
2014-06-23 15:41:34 +00:00
|
|
|
if (env.best_cpu == -1)
|
|
|
|
nid = env.src_nid;
|
|
|
|
else
|
|
|
|
nid = env.dst_nid;
|
|
|
|
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
if (ng->active_nodes > 1 && numa_is_active_node(env.dst_nid, ng))
|
2014-06-23 15:41:34 +00:00
|
|
|
sched_setnuma(p, env.dst_nid);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No better CPU than the current one was found. */
|
|
|
|
if (env.best_cpu == -1)
|
|
|
|
return -EAGAIN;
|
2013-10-07 10:29:33 +00:00
|
|
|
|
2013-10-07 10:29:36 +00:00
|
|
|
/*
|
|
|
|
* Reset the scan period if the task is being rescheduled on an
|
|
|
|
* alternative node to recheck if the tasks is now properly placed.
|
|
|
|
*/
|
2017-07-31 19:28:47 +00:00
|
|
|
p->numa_scan_period = task_scan_start(p);
|
2013-10-07 10:29:36 +00:00
|
|
|
|
2013-10-07 10:29:17 +00:00
|
|
|
if (env.best_task == NULL) {
|
2014-01-21 23:51:03 +00:00
|
|
|
ret = migrate_task_to(p, env.best_cpu);
|
|
|
|
if (ret != 0)
|
|
|
|
trace_sched_stick_numa(p, env.src_cpu, env.best_cpu);
|
2013-10-07 10:29:17 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = migrate_swap(p, env.best_task);
|
2014-01-21 23:51:03 +00:00
|
|
|
if (ret != 0)
|
|
|
|
trace_sched_stick_numa(p, env.src_cpu, task_cpu(env.best_task));
|
2013-10-07 10:29:17 +00:00
|
|
|
put_task_struct(env.best_task);
|
|
|
|
return ret;
|
2013-10-07 10:29:02 +00:00
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:11 +00:00
|
|
|
/* Attempt to migrate a task to a CPU on the preferred node. */
|
|
|
|
static void numa_migrate_preferred(struct task_struct *p)
|
|
|
|
{
|
2014-04-11 17:00:28 +00:00
|
|
|
unsigned long interval = HZ;
|
|
|
|
|
2013-10-07 10:29:41 +00:00
|
|
|
/* This task has no NUMA fault statistics yet */
|
2014-10-31 00:13:31 +00:00
|
|
|
if (unlikely(p->numa_preferred_nid == -1 || !p->numa_faults))
|
2013-10-07 10:29:11 +00:00
|
|
|
return;
|
|
|
|
|
2013-10-07 10:29:41 +00:00
|
|
|
/* Periodically retry migrating the task to the preferred node */
|
2014-04-11 17:00:28 +00:00
|
|
|
interval = min(interval, msecs_to_jiffies(p->numa_scan_period) / 16);
|
|
|
|
p->numa_migrate_retry = jiffies + interval;
|
2013-10-07 10:29:41 +00:00
|
|
|
|
|
|
|
/* Success if task is already running on preferred CPU */
|
2013-12-12 07:23:24 +00:00
|
|
|
if (task_node(p) == p->numa_preferred_nid)
|
2013-10-07 10:29:11 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* Otherwise, try migrate to a CPU on the preferred node */
|
2013-10-07 10:29:41 +00:00
|
|
|
task_numa_migrate(p);
|
2013-10-07 10:29:11 +00:00
|
|
|
}
|
|
|
|
|
2014-01-27 22:03:43 +00:00
|
|
|
/*
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
* Find out how many nodes on the workload is actively running on. Do this by
|
2014-01-27 22:03:43 +00:00
|
|
|
* tracking the nodes from which NUMA hinting faults are triggered. This can
|
|
|
|
* be different from the set of nodes where the workload's memory is currently
|
|
|
|
* located.
|
|
|
|
*/
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
static void numa_group_count_active_nodes(struct numa_group *numa_group)
|
2014-01-27 22:03:43 +00:00
|
|
|
{
|
|
|
|
unsigned long faults, max_faults = 0;
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
int nid, active_nodes = 0;
|
2014-01-27 22:03:43 +00:00
|
|
|
|
|
|
|
for_each_online_node(nid) {
|
|
|
|
faults = group_faults_cpu(numa_group, nid);
|
|
|
|
if (faults > max_faults)
|
|
|
|
max_faults = faults;
|
|
|
|
}
|
|
|
|
|
|
|
|
for_each_online_node(nid) {
|
|
|
|
faults = group_faults_cpu(numa_group, nid);
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
if (faults * ACTIVE_NODE_FRACTION > max_faults)
|
|
|
|
active_nodes++;
|
2014-01-27 22:03:43 +00:00
|
|
|
}
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
|
|
|
|
numa_group->max_faults_cpu = max_faults;
|
|
|
|
numa_group->active_nodes = active_nodes;
|
2014-01-27 22:03:43 +00:00
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:36 +00:00
|
|
|
/*
|
|
|
|
* When adapting the scan rate, the period is divided into NUMA_PERIOD_SLOTS
|
|
|
|
* increments. The more local the fault statistics are, the higher the scan
|
2014-06-23 15:41:35 +00:00
|
|
|
* period will be for the next scan window. If local/(local+remote) ratio is
|
|
|
|
* below NUMA_PERIOD_THRESHOLD (where range of ratio is 1..NUMA_PERIOD_SLOTS)
|
|
|
|
* the scan period will decrease. Aim for 70% local accesses.
|
2013-10-07 10:29:36 +00:00
|
|
|
*/
|
|
|
|
#define NUMA_PERIOD_SLOTS 10
|
2014-06-23 15:41:35 +00:00
|
|
|
#define NUMA_PERIOD_THRESHOLD 7
|
2013-10-07 10:29:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Increase the scan period (slow down scanning) if the majority of
|
|
|
|
* our memory is already on our local node, or if the majority of
|
|
|
|
* the page accesses are shared with other processes.
|
|
|
|
* Otherwise, decrease the scan period.
|
|
|
|
*/
|
|
|
|
static void update_task_scan_period(struct task_struct *p,
|
|
|
|
unsigned long shared, unsigned long private)
|
|
|
|
{
|
|
|
|
unsigned int period_slot;
|
2017-07-31 19:28:46 +00:00
|
|
|
int lr_ratio, ps_ratio;
|
2013-10-07 10:29:36 +00:00
|
|
|
int diff;
|
|
|
|
|
|
|
|
unsigned long remote = p->numa_faults_locality[0];
|
|
|
|
unsigned long local = p->numa_faults_locality[1];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there were no record hinting faults then either the task is
|
|
|
|
* completely idle or all activity is areas that are not of interest
|
2015-03-25 22:55:42 +00:00
|
|
|
* to automatic numa balancing. Related to that, if there were failed
|
|
|
|
* migration then it implies we are migrating too quickly or the local
|
|
|
|
* node is overloaded. In either case, scan slower
|
2013-10-07 10:29:36 +00:00
|
|
|
*/
|
2015-03-25 22:55:42 +00:00
|
|
|
if (local + shared == 0 || p->numa_faults_locality[2]) {
|
2013-10-07 10:29:36 +00:00
|
|
|
p->numa_scan_period = min(p->numa_scan_period_max,
|
|
|
|
p->numa_scan_period << 1);
|
|
|
|
|
|
|
|
p->mm->numa_next_scan = jiffies +
|
|
|
|
msecs_to_jiffies(p->numa_scan_period);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prepare to scale scan period relative to the current period.
|
|
|
|
* == NUMA_PERIOD_THRESHOLD scan period stays the same
|
|
|
|
* < NUMA_PERIOD_THRESHOLD scan period decreases (scan faster)
|
|
|
|
* >= NUMA_PERIOD_THRESHOLD scan period increases (scan slower)
|
|
|
|
*/
|
|
|
|
period_slot = DIV_ROUND_UP(p->numa_scan_period, NUMA_PERIOD_SLOTS);
|
2017-07-31 19:28:46 +00:00
|
|
|
lr_ratio = (local * NUMA_PERIOD_SLOTS) / (local + remote);
|
|
|
|
ps_ratio = (private * NUMA_PERIOD_SLOTS) / (private + shared);
|
|
|
|
|
|
|
|
if (ps_ratio >= NUMA_PERIOD_THRESHOLD) {
|
|
|
|
/*
|
|
|
|
* Most memory accesses are local. There is no need to
|
|
|
|
* do fast NUMA scanning, since memory is already local.
|
|
|
|
*/
|
|
|
|
int slot = ps_ratio - NUMA_PERIOD_THRESHOLD;
|
|
|
|
if (!slot)
|
|
|
|
slot = 1;
|
|
|
|
diff = slot * period_slot;
|
|
|
|
} else if (lr_ratio >= NUMA_PERIOD_THRESHOLD) {
|
|
|
|
/*
|
|
|
|
* Most memory accesses are shared with other tasks.
|
|
|
|
* There is no point in continuing fast NUMA scanning,
|
|
|
|
* since other tasks may just move the memory elsewhere.
|
|
|
|
*/
|
|
|
|
int slot = lr_ratio - NUMA_PERIOD_THRESHOLD;
|
2013-10-07 10:29:36 +00:00
|
|
|
if (!slot)
|
|
|
|
slot = 1;
|
|
|
|
diff = slot * period_slot;
|
|
|
|
} else {
|
|
|
|
/*
|
2017-07-31 19:28:46 +00:00
|
|
|
* Private memory faults exceed (SLOTS-THRESHOLD)/SLOTS,
|
|
|
|
* yet they are not on the local NUMA node. Speed up
|
|
|
|
* NUMA scanning to get the memory moved over.
|
2013-10-07 10:29:36 +00:00
|
|
|
*/
|
2017-07-31 19:28:46 +00:00
|
|
|
int ratio = max(lr_ratio, ps_ratio);
|
|
|
|
diff = -(NUMA_PERIOD_THRESHOLD - ratio) * period_slot;
|
2013-10-07 10:29:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
p->numa_scan_period = clamp(p->numa_scan_period + diff,
|
|
|
|
task_scan_min(p), task_scan_max(p));
|
|
|
|
memset(p->numa_faults_locality, 0, sizeof(p->numa_faults_locality));
|
|
|
|
}
|
|
|
|
|
sched/numa: Normalize faults_cpu stats and weigh by CPU use
Tracing the code that decides the active nodes has made it abundantly clear
that the naive implementation of the faults_from code has issues.
Specifically, the garbage collector in some workloads will access orders
of magnitudes more memory than the threads that do all the active work.
This resulted in the node with the garbage collector being marked the only
active node in the group.
This issue is avoided if we weigh the statistics by CPU use of each task in
the numa group, instead of by how many faults each thread has occurred.
To achieve this, we normalize the number of faults to the fraction of faults
that occurred on each node, and then multiply that fraction by the fraction
of CPU time the task has used since the last time task_numa_placement was
invoked.
This way the nodes in the active node mask will be the ones where the tasks
from the numa group are most actively running, and the influence of eg. the
garbage collector and other do-little threads is properly minimized.
On a 4 node system, using CPU use statistics calculated over a longer interval
results in about 1% fewer page migrations with two 32-warehouse specjbb runs
on a 4 node system, and about 5% fewer page migrations, as well as 1% better
throughput, with two 8-warehouse specjbb runs, as compared with the shorter
term statistics kept by the scheduler.
Signed-off-by: Rik van Riel <riel@redhat.com>
Acked-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: Chegu Vinod <chegu_vinod@hp.com>
Link: http://lkml.kernel.org/r/1390860228-21539-7-git-send-email-riel@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-27 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* Get the fraction of time the task has been running since the last
|
|
|
|
* NUMA placement cycle. The scheduler keeps similar statistics, but
|
|
|
|
* decays those on a 32ms period, which is orders of magnitude off
|
|
|
|
* from the dozens-of-seconds NUMA balancing period. Use the scheduler
|
|
|
|
* stats only if the task is so new there are no NUMA statistics yet.
|
|
|
|
*/
|
|
|
|
static u64 numa_get_avg_runtime(struct task_struct *p, u64 *period)
|
|
|
|
{
|
|
|
|
u64 runtime, delta, now;
|
|
|
|
/* Use the start of this time slice to avoid calculations. */
|
|
|
|
now = p->se.exec_start;
|
|
|
|
runtime = p->se.sum_exec_runtime;
|
|
|
|
|
|
|
|
if (p->last_task_numa_placement) {
|
|
|
|
delta = runtime - p->last_sum_exec_runtime;
|
|
|
|
*period = now - p->last_task_numa_placement;
|
|
|
|
} else {
|
2017-05-06 14:42:08 +00:00
|
|
|
delta = p->se.avg.load_sum;
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
*period = LOAD_AVG_MAX;
|
sched/numa: Normalize faults_cpu stats and weigh by CPU use
Tracing the code that decides the active nodes has made it abundantly clear
that the naive implementation of the faults_from code has issues.
Specifically, the garbage collector in some workloads will access orders
of magnitudes more memory than the threads that do all the active work.
This resulted in the node with the garbage collector being marked the only
active node in the group.
This issue is avoided if we weigh the statistics by CPU use of each task in
the numa group, instead of by how many faults each thread has occurred.
To achieve this, we normalize the number of faults to the fraction of faults
that occurred on each node, and then multiply that fraction by the fraction
of CPU time the task has used since the last time task_numa_placement was
invoked.
This way the nodes in the active node mask will be the ones where the tasks
from the numa group are most actively running, and the influence of eg. the
garbage collector and other do-little threads is properly minimized.
On a 4 node system, using CPU use statistics calculated over a longer interval
results in about 1% fewer page migrations with two 32-warehouse specjbb runs
on a 4 node system, and about 5% fewer page migrations, as well as 1% better
throughput, with two 8-warehouse specjbb runs, as compared with the shorter
term statistics kept by the scheduler.
Signed-off-by: Rik van Riel <riel@redhat.com>
Acked-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: Chegu Vinod <chegu_vinod@hp.com>
Link: http://lkml.kernel.org/r/1390860228-21539-7-git-send-email-riel@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-27 22:03:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
p->last_sum_exec_runtime = runtime;
|
|
|
|
p->last_task_numa_placement = now;
|
|
|
|
|
|
|
|
return delta;
|
|
|
|
}
|
|
|
|
|
2014-10-17 07:29:53 +00:00
|
|
|
/*
|
|
|
|
* Determine the preferred nid for a task in a numa_group. This needs to
|
|
|
|
* be done in a way that produces consistent results with group_weight,
|
|
|
|
* otherwise workloads might not converge.
|
|
|
|
*/
|
|
|
|
static int preferred_group_nid(struct task_struct *p, int nid)
|
|
|
|
{
|
|
|
|
nodemask_t nodes;
|
|
|
|
int dist;
|
|
|
|
|
|
|
|
/* Direct connections between all NUMA nodes. */
|
|
|
|
if (sched_numa_topology_type == NUMA_DIRECT)
|
|
|
|
return nid;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* On a system with glueless mesh NUMA topology, group_weight
|
|
|
|
* scores nodes according to the number of NUMA hinting faults on
|
|
|
|
* both the node itself, and on nearby nodes.
|
|
|
|
*/
|
|
|
|
if (sched_numa_topology_type == NUMA_GLUELESS_MESH) {
|
|
|
|
unsigned long score, max_score = 0;
|
|
|
|
int node, max_node = nid;
|
|
|
|
|
|
|
|
dist = sched_max_numa_distance;
|
|
|
|
|
|
|
|
for_each_online_node(node) {
|
|
|
|
score = group_weight(p, node, dist);
|
|
|
|
if (score > max_score) {
|
|
|
|
max_score = score;
|
|
|
|
max_node = node;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return max_node;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Finding the preferred nid in a system with NUMA backplane
|
|
|
|
* interconnect topology is more involved. The goal is to locate
|
|
|
|
* tasks from numa_groups near each other in the system, and
|
|
|
|
* untangle workloads from different sides of the system. This requires
|
|
|
|
* searching down the hierarchy of node groups, recursively searching
|
|
|
|
* inside the highest scoring group of nodes. The nodemask tricks
|
|
|
|
* keep the complexity of the search down.
|
|
|
|
*/
|
|
|
|
nodes = node_online_map;
|
|
|
|
for (dist = sched_max_numa_distance; dist > LOCAL_DISTANCE; dist--) {
|
|
|
|
unsigned long max_faults = 0;
|
sched/fair: Avoid using uninitialized variable in preferred_group_nid()
At least some gcc versions - validly afaict - warn about potentially
using max_group uninitialized: There's no way the compiler can prove
that the body of the conditional where it and max_faults get set/
updated gets executed; in fact, without knowing all the details of
other scheduler code, I can't prove this either.
Generally the necessary change would appear to be to clear max_group
prior to entering the inner loop, and break out of the outer loop when
it ends up being all clear after the inner one. This, however, seems
inefficient, and afaict the same effect can be achieved by exiting the
outer loop when max_faults is still zero after the inner loop.
[ mingo: changed the solution to zero initialization: uninitialized_var()
needs to die, as it's an actively dangerous construct: if in the future
a known-proven-good piece of code is changed to have a true, buggy
uninitialized variable, the compiler warning is then supressed...
The better long term solution is to clean up the code flow, so that
even simple minded compilers (and humans!) are able to read it without
getting a headache. ]
Signed-off-by: Jan Beulich <jbeulich@suse.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Link: http://lkml.kernel.org/r/54C2139202000078000588F7@mail.emea.novell.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-01-23 08:25:38 +00:00
|
|
|
nodemask_t max_group = NODE_MASK_NONE;
|
2014-10-17 07:29:53 +00:00
|
|
|
int a, b;
|
|
|
|
|
|
|
|
/* Are there nodes at this distance from each other? */
|
|
|
|
if (!find_numa_distance(dist))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for_each_node_mask(a, nodes) {
|
|
|
|
unsigned long faults = 0;
|
|
|
|
nodemask_t this_group;
|
|
|
|
nodes_clear(this_group);
|
|
|
|
|
|
|
|
/* Sum group's NUMA faults; includes a==b case. */
|
|
|
|
for_each_node_mask(b, nodes) {
|
|
|
|
if (node_distance(a, b) < dist) {
|
|
|
|
faults += group_faults(p, b);
|
|
|
|
node_set(b, this_group);
|
|
|
|
node_clear(b, nodes);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remember the top group. */
|
|
|
|
if (faults > max_faults) {
|
|
|
|
max_faults = faults;
|
|
|
|
max_group = this_group;
|
|
|
|
/*
|
|
|
|
* subtle: at the smallest distance there is
|
|
|
|
* just one node left in each "group", the
|
|
|
|
* winner is the preferred nid.
|
|
|
|
*/
|
|
|
|
nid = a;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Next round, evaluate the nodes within max_group. */
|
2015-02-09 11:30:00 +00:00
|
|
|
if (!max_faults)
|
|
|
|
break;
|
2014-10-17 07:29:53 +00:00
|
|
|
nodes = max_group;
|
|
|
|
}
|
|
|
|
return nid;
|
|
|
|
}
|
|
|
|
|
2012-10-25 12:16:43 +00:00
|
|
|
static void task_numa_placement(struct task_struct *p)
|
|
|
|
{
|
2013-10-07 10:29:27 +00:00
|
|
|
int seq, nid, max_nid = -1, max_group_nid = -1;
|
|
|
|
unsigned long max_faults = 0, max_group_faults = 0;
|
2013-10-07 10:29:36 +00:00
|
|
|
unsigned long fault_types[2] = { 0, 0 };
|
sched/numa: Normalize faults_cpu stats and weigh by CPU use
Tracing the code that decides the active nodes has made it abundantly clear
that the naive implementation of the faults_from code has issues.
Specifically, the garbage collector in some workloads will access orders
of magnitudes more memory than the threads that do all the active work.
This resulted in the node with the garbage collector being marked the only
active node in the group.
This issue is avoided if we weigh the statistics by CPU use of each task in
the numa group, instead of by how many faults each thread has occurred.
To achieve this, we normalize the number of faults to the fraction of faults
that occurred on each node, and then multiply that fraction by the fraction
of CPU time the task has used since the last time task_numa_placement was
invoked.
This way the nodes in the active node mask will be the ones where the tasks
from the numa group are most actively running, and the influence of eg. the
garbage collector and other do-little threads is properly minimized.
On a 4 node system, using CPU use statistics calculated over a longer interval
results in about 1% fewer page migrations with two 32-warehouse specjbb runs
on a 4 node system, and about 5% fewer page migrations, as well as 1% better
throughput, with two 8-warehouse specjbb runs, as compared with the shorter
term statistics kept by the scheduler.
Signed-off-by: Rik van Riel <riel@redhat.com>
Acked-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: Chegu Vinod <chegu_vinod@hp.com>
Link: http://lkml.kernel.org/r/1390860228-21539-7-git-send-email-riel@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-27 22:03:45 +00:00
|
|
|
unsigned long total_faults;
|
|
|
|
u64 runtime, period;
|
2013-10-07 10:29:29 +00:00
|
|
|
spinlock_t *group_lock = NULL;
|
2012-10-25 12:16:43 +00:00
|
|
|
|
2015-05-01 00:28:14 +00:00
|
|
|
/*
|
|
|
|
* The p->mm->numa_scan_seq field gets updated without
|
|
|
|
* exclusive access. Use READ_ONCE() here to ensure
|
|
|
|
* that the field is read in a single access:
|
|
|
|
*/
|
2015-04-28 20:00:20 +00:00
|
|
|
seq = READ_ONCE(p->mm->numa_scan_seq);
|
2012-10-25 12:16:43 +00:00
|
|
|
if (p->numa_scan_seq == seq)
|
|
|
|
return;
|
|
|
|
p->numa_scan_seq = seq;
|
2013-10-07 10:28:55 +00:00
|
|
|
p->numa_scan_period_max = task_scan_max(p);
|
2012-10-25 12:16:43 +00:00
|
|
|
|
sched/numa: Normalize faults_cpu stats and weigh by CPU use
Tracing the code that decides the active nodes has made it abundantly clear
that the naive implementation of the faults_from code has issues.
Specifically, the garbage collector in some workloads will access orders
of magnitudes more memory than the threads that do all the active work.
This resulted in the node with the garbage collector being marked the only
active node in the group.
This issue is avoided if we weigh the statistics by CPU use of each task in
the numa group, instead of by how many faults each thread has occurred.
To achieve this, we normalize the number of faults to the fraction of faults
that occurred on each node, and then multiply that fraction by the fraction
of CPU time the task has used since the last time task_numa_placement was
invoked.
This way the nodes in the active node mask will be the ones where the tasks
from the numa group are most actively running, and the influence of eg. the
garbage collector and other do-little threads is properly minimized.
On a 4 node system, using CPU use statistics calculated over a longer interval
results in about 1% fewer page migrations with two 32-warehouse specjbb runs
on a 4 node system, and about 5% fewer page migrations, as well as 1% better
throughput, with two 8-warehouse specjbb runs, as compared with the shorter
term statistics kept by the scheduler.
Signed-off-by: Rik van Riel <riel@redhat.com>
Acked-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: Chegu Vinod <chegu_vinod@hp.com>
Link: http://lkml.kernel.org/r/1390860228-21539-7-git-send-email-riel@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-27 22:03:45 +00:00
|
|
|
total_faults = p->numa_faults_locality[0] +
|
|
|
|
p->numa_faults_locality[1];
|
|
|
|
runtime = numa_get_avg_runtime(p, &period);
|
|
|
|
|
2013-10-07 10:29:29 +00:00
|
|
|
/* If the task is part of a group prevent parallel updates to group stats */
|
|
|
|
if (p->numa_group) {
|
|
|
|
group_lock = &p->numa_group->lock;
|
2014-04-07 08:55:15 +00:00
|
|
|
spin_lock_irq(group_lock);
|
2013-10-07 10:29:29 +00:00
|
|
|
}
|
|
|
|
|
2013-10-07 10:28:58 +00:00
|
|
|
/* Find the node with the highest number of faults */
|
|
|
|
for_each_online_node(nid) {
|
2014-10-31 00:13:31 +00:00
|
|
|
/* Keep track of the offsets in numa_faults array */
|
|
|
|
int mem_idx, membuf_idx, cpu_idx, cpubuf_idx;
|
2013-10-07 10:29:27 +00:00
|
|
|
unsigned long faults = 0, group_faults = 0;
|
2014-10-31 00:13:31 +00:00
|
|
|
int priv;
|
2013-10-07 10:28:59 +00:00
|
|
|
|
2014-01-27 22:03:48 +00:00
|
|
|
for (priv = 0; priv < NR_NUMA_HINT_FAULT_TYPES; priv++) {
|
sched/numa: Normalize faults_cpu stats and weigh by CPU use
Tracing the code that decides the active nodes has made it abundantly clear
that the naive implementation of the faults_from code has issues.
Specifically, the garbage collector in some workloads will access orders
of magnitudes more memory than the threads that do all the active work.
This resulted in the node with the garbage collector being marked the only
active node in the group.
This issue is avoided if we weigh the statistics by CPU use of each task in
the numa group, instead of by how many faults each thread has occurred.
To achieve this, we normalize the number of faults to the fraction of faults
that occurred on each node, and then multiply that fraction by the fraction
of CPU time the task has used since the last time task_numa_placement was
invoked.
This way the nodes in the active node mask will be the ones where the tasks
from the numa group are most actively running, and the influence of eg. the
garbage collector and other do-little threads is properly minimized.
On a 4 node system, using CPU use statistics calculated over a longer interval
results in about 1% fewer page migrations with two 32-warehouse specjbb runs
on a 4 node system, and about 5% fewer page migrations, as well as 1% better
throughput, with two 8-warehouse specjbb runs, as compared with the shorter
term statistics kept by the scheduler.
Signed-off-by: Rik van Riel <riel@redhat.com>
Acked-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: Chegu Vinod <chegu_vinod@hp.com>
Link: http://lkml.kernel.org/r/1390860228-21539-7-git-send-email-riel@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-27 22:03:45 +00:00
|
|
|
long diff, f_diff, f_weight;
|
2013-10-07 10:29:21 +00:00
|
|
|
|
2014-10-31 00:13:31 +00:00
|
|
|
mem_idx = task_faults_idx(NUMA_MEM, nid, priv);
|
|
|
|
membuf_idx = task_faults_idx(NUMA_MEMBUF, nid, priv);
|
|
|
|
cpu_idx = task_faults_idx(NUMA_CPU, nid, priv);
|
|
|
|
cpubuf_idx = task_faults_idx(NUMA_CPUBUF, nid, priv);
|
2013-10-07 10:28:59 +00:00
|
|
|
|
2013-10-07 10:29:03 +00:00
|
|
|
/* Decay existing window, copy faults since last scan */
|
2014-10-31 00:13:31 +00:00
|
|
|
diff = p->numa_faults[membuf_idx] - p->numa_faults[mem_idx] / 2;
|
|
|
|
fault_types[priv] += p->numa_faults[membuf_idx];
|
|
|
|
p->numa_faults[membuf_idx] = 0;
|
2013-10-07 10:29:17 +00:00
|
|
|
|
sched/numa: Normalize faults_cpu stats and weigh by CPU use
Tracing the code that decides the active nodes has made it abundantly clear
that the naive implementation of the faults_from code has issues.
Specifically, the garbage collector in some workloads will access orders
of magnitudes more memory than the threads that do all the active work.
This resulted in the node with the garbage collector being marked the only
active node in the group.
This issue is avoided if we weigh the statistics by CPU use of each task in
the numa group, instead of by how many faults each thread has occurred.
To achieve this, we normalize the number of faults to the fraction of faults
that occurred on each node, and then multiply that fraction by the fraction
of CPU time the task has used since the last time task_numa_placement was
invoked.
This way the nodes in the active node mask will be the ones where the tasks
from the numa group are most actively running, and the influence of eg. the
garbage collector and other do-little threads is properly minimized.
On a 4 node system, using CPU use statistics calculated over a longer interval
results in about 1% fewer page migrations with two 32-warehouse specjbb runs
on a 4 node system, and about 5% fewer page migrations, as well as 1% better
throughput, with two 8-warehouse specjbb runs, as compared with the shorter
term statistics kept by the scheduler.
Signed-off-by: Rik van Riel <riel@redhat.com>
Acked-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: Chegu Vinod <chegu_vinod@hp.com>
Link: http://lkml.kernel.org/r/1390860228-21539-7-git-send-email-riel@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-27 22:03:45 +00:00
|
|
|
/*
|
|
|
|
* Normalize the faults_from, so all tasks in a group
|
|
|
|
* count according to CPU use, instead of by the raw
|
|
|
|
* number of faults. Tasks with little runtime have
|
|
|
|
* little over-all impact on throughput, and thus their
|
|
|
|
* faults are less important.
|
|
|
|
*/
|
|
|
|
f_weight = div64_u64(runtime << 16, period + 1);
|
2014-10-31 00:13:31 +00:00
|
|
|
f_weight = (f_weight * p->numa_faults[cpubuf_idx]) /
|
sched/numa: Normalize faults_cpu stats and weigh by CPU use
Tracing the code that decides the active nodes has made it abundantly clear
that the naive implementation of the faults_from code has issues.
Specifically, the garbage collector in some workloads will access orders
of magnitudes more memory than the threads that do all the active work.
This resulted in the node with the garbage collector being marked the only
active node in the group.
This issue is avoided if we weigh the statistics by CPU use of each task in
the numa group, instead of by how many faults each thread has occurred.
To achieve this, we normalize the number of faults to the fraction of faults
that occurred on each node, and then multiply that fraction by the fraction
of CPU time the task has used since the last time task_numa_placement was
invoked.
This way the nodes in the active node mask will be the ones where the tasks
from the numa group are most actively running, and the influence of eg. the
garbage collector and other do-little threads is properly minimized.
On a 4 node system, using CPU use statistics calculated over a longer interval
results in about 1% fewer page migrations with two 32-warehouse specjbb runs
on a 4 node system, and about 5% fewer page migrations, as well as 1% better
throughput, with two 8-warehouse specjbb runs, as compared with the shorter
term statistics kept by the scheduler.
Signed-off-by: Rik van Riel <riel@redhat.com>
Acked-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: Chegu Vinod <chegu_vinod@hp.com>
Link: http://lkml.kernel.org/r/1390860228-21539-7-git-send-email-riel@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-27 22:03:45 +00:00
|
|
|
(total_faults + 1);
|
2014-10-31 00:13:31 +00:00
|
|
|
f_diff = f_weight - p->numa_faults[cpu_idx] / 2;
|
|
|
|
p->numa_faults[cpubuf_idx] = 0;
|
2014-01-27 22:03:42 +00:00
|
|
|
|
2014-10-31 00:13:31 +00:00
|
|
|
p->numa_faults[mem_idx] += diff;
|
|
|
|
p->numa_faults[cpu_idx] += f_diff;
|
|
|
|
faults += p->numa_faults[mem_idx];
|
2013-10-07 10:29:27 +00:00
|
|
|
p->total_numa_faults += diff;
|
2013-10-07 10:29:21 +00:00
|
|
|
if (p->numa_group) {
|
2014-10-31 00:13:31 +00:00
|
|
|
/*
|
|
|
|
* safe because we can only change our own group
|
|
|
|
*
|
|
|
|
* mem_idx represents the offset for a given
|
|
|
|
* nid and priv in a specific region because it
|
|
|
|
* is at the beginning of the numa_faults array.
|
|
|
|
*/
|
|
|
|
p->numa_group->faults[mem_idx] += diff;
|
|
|
|
p->numa_group->faults_cpu[mem_idx] += f_diff;
|
2013-10-07 10:29:40 +00:00
|
|
|
p->numa_group->total_faults += diff;
|
2014-10-31 00:13:31 +00:00
|
|
|
group_faults += p->numa_group->faults[mem_idx];
|
2013-10-07 10:29:21 +00:00
|
|
|
}
|
2013-10-07 10:29:03 +00:00
|
|
|
}
|
|
|
|
|
2013-10-07 10:28:58 +00:00
|
|
|
if (faults > max_faults) {
|
|
|
|
max_faults = faults;
|
|
|
|
max_nid = nid;
|
|
|
|
}
|
2013-10-07 10:29:27 +00:00
|
|
|
|
|
|
|
if (group_faults > max_group_faults) {
|
|
|
|
max_group_faults = group_faults;
|
|
|
|
max_group_nid = nid;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:36 +00:00
|
|
|
update_task_scan_period(p, fault_types[0], fault_types[1]);
|
|
|
|
|
2013-10-07 10:29:29 +00:00
|
|
|
if (p->numa_group) {
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
numa_group_count_active_nodes(p->numa_group);
|
2014-04-07 08:55:15 +00:00
|
|
|
spin_unlock_irq(group_lock);
|
2014-10-17 07:29:53 +00:00
|
|
|
max_nid = preferred_group_nid(p, max_group_nid);
|
2013-10-07 10:28:58 +00:00
|
|
|
}
|
|
|
|
|
2014-06-04 20:33:15 +00:00
|
|
|
if (max_faults) {
|
|
|
|
/* Set the new preferred node */
|
|
|
|
if (max_nid != p->numa_preferred_nid)
|
|
|
|
sched_setnuma(p, max_nid);
|
|
|
|
|
|
|
|
if (task_node(p) != p->numa_preferred_nid)
|
|
|
|
numa_migrate_preferred(p);
|
2013-10-07 10:29:00 +00:00
|
|
|
}
|
2012-10-25 12:16:43 +00:00
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:21 +00:00
|
|
|
static inline int get_numa_group(struct numa_group *grp)
|
|
|
|
{
|
|
|
|
return atomic_inc_not_zero(&grp->refcount);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void put_numa_group(struct numa_group *grp)
|
|
|
|
{
|
|
|
|
if (atomic_dec_and_test(&grp->refcount))
|
|
|
|
kfree_rcu(grp, rcu);
|
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:35 +00:00
|
|
|
static void task_numa_group(struct task_struct *p, int cpupid, int flags,
|
|
|
|
int *priv)
|
2013-10-07 10:29:21 +00:00
|
|
|
{
|
|
|
|
struct numa_group *grp, *my_grp;
|
|
|
|
struct task_struct *tsk;
|
|
|
|
bool join = false;
|
|
|
|
int cpu = cpupid_to_cpu(cpupid);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (unlikely(!p->numa_group)) {
|
|
|
|
unsigned int size = sizeof(struct numa_group) +
|
2014-01-27 22:03:42 +00:00
|
|
|
4*nr_node_ids*sizeof(unsigned long);
|
2013-10-07 10:29:21 +00:00
|
|
|
|
|
|
|
grp = kzalloc(size, GFP_KERNEL | __GFP_NOWARN);
|
|
|
|
if (!grp)
|
|
|
|
return;
|
|
|
|
|
|
|
|
atomic_set(&grp->refcount, 1);
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
grp->active_nodes = 1;
|
|
|
|
grp->max_faults_cpu = 0;
|
2013-10-07 10:29:21 +00:00
|
|
|
spin_lock_init(&grp->lock);
|
2013-10-07 10:29:22 +00:00
|
|
|
grp->gid = p->pid;
|
2014-01-27 22:03:42 +00:00
|
|
|
/* Second half of the array tracks nids where faults happen */
|
2014-01-27 22:03:48 +00:00
|
|
|
grp->faults_cpu = grp->faults + NR_NUMA_HINT_FAULT_TYPES *
|
|
|
|
nr_node_ids;
|
2013-10-07 10:29:21 +00:00
|
|
|
|
2014-01-27 22:03:48 +00:00
|
|
|
for (i = 0; i < NR_NUMA_HINT_FAULT_STATS * nr_node_ids; i++)
|
2014-10-31 00:13:31 +00:00
|
|
|
grp->faults[i] = p->numa_faults[i];
|
2013-10-07 10:29:21 +00:00
|
|
|
|
2013-10-07 10:29:40 +00:00
|
|
|
grp->total_faults = p->total_numa_faults;
|
2013-10-07 10:29:27 +00:00
|
|
|
|
2013-10-07 10:29:21 +00:00
|
|
|
grp->nr_tasks++;
|
|
|
|
rcu_assign_pointer(p->numa_group, grp);
|
|
|
|
}
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2015-04-28 20:00:20 +00:00
|
|
|
tsk = READ_ONCE(cpu_rq(cpu)->curr);
|
2013-10-07 10:29:21 +00:00
|
|
|
|
|
|
|
if (!cpupid_match_pid(tsk, cpupid))
|
2013-10-09 08:24:48 +00:00
|
|
|
goto no_join;
|
2013-10-07 10:29:21 +00:00
|
|
|
|
|
|
|
grp = rcu_dereference(tsk->numa_group);
|
|
|
|
if (!grp)
|
2013-10-09 08:24:48 +00:00
|
|
|
goto no_join;
|
2013-10-07 10:29:21 +00:00
|
|
|
|
|
|
|
my_grp = p->numa_group;
|
|
|
|
if (grp == my_grp)
|
2013-10-09 08:24:48 +00:00
|
|
|
goto no_join;
|
2013-10-07 10:29:21 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Only join the other group if its bigger; if we're the bigger group,
|
|
|
|
* the other task will join us.
|
|
|
|
*/
|
|
|
|
if (my_grp->nr_tasks > grp->nr_tasks)
|
2013-10-09 08:24:48 +00:00
|
|
|
goto no_join;
|
2013-10-07 10:29:21 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Tie-break on the grp address.
|
|
|
|
*/
|
|
|
|
if (my_grp->nr_tasks == grp->nr_tasks && my_grp > grp)
|
2013-10-09 08:24:48 +00:00
|
|
|
goto no_join;
|
2013-10-07 10:29:21 +00:00
|
|
|
|
2013-10-07 10:29:34 +00:00
|
|
|
/* Always join threads in the same process. */
|
|
|
|
if (tsk->mm == current->mm)
|
|
|
|
join = true;
|
|
|
|
|
|
|
|
/* Simple filter to avoid false positives due to PID collisions */
|
|
|
|
if (flags & TNF_SHARED)
|
|
|
|
join = true;
|
2013-10-07 10:29:21 +00:00
|
|
|
|
2013-10-07 10:29:35 +00:00
|
|
|
/* Update priv based on whether false sharing was detected */
|
|
|
|
*priv = !join;
|
|
|
|
|
2013-10-07 10:29:34 +00:00
|
|
|
if (join && !get_numa_group(grp))
|
2013-10-09 08:24:48 +00:00
|
|
|
goto no_join;
|
2013-10-07 10:29:21 +00:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
if (!join)
|
|
|
|
return;
|
|
|
|
|
2014-04-07 08:55:15 +00:00
|
|
|
BUG_ON(irqs_disabled());
|
|
|
|
double_lock_irq(&my_grp->lock, &grp->lock);
|
2013-10-07 10:29:40 +00:00
|
|
|
|
2014-01-27 22:03:48 +00:00
|
|
|
for (i = 0; i < NR_NUMA_HINT_FAULT_STATS * nr_node_ids; i++) {
|
2014-10-31 00:13:31 +00:00
|
|
|
my_grp->faults[i] -= p->numa_faults[i];
|
|
|
|
grp->faults[i] += p->numa_faults[i];
|
2013-10-07 10:29:21 +00:00
|
|
|
}
|
2013-10-07 10:29:40 +00:00
|
|
|
my_grp->total_faults -= p->total_numa_faults;
|
|
|
|
grp->total_faults += p->total_numa_faults;
|
2013-10-07 10:29:21 +00:00
|
|
|
|
|
|
|
my_grp->nr_tasks--;
|
|
|
|
grp->nr_tasks++;
|
|
|
|
|
|
|
|
spin_unlock(&my_grp->lock);
|
2014-04-07 08:55:15 +00:00
|
|
|
spin_unlock_irq(&grp->lock);
|
2013-10-07 10:29:21 +00:00
|
|
|
|
|
|
|
rcu_assign_pointer(p->numa_group, grp);
|
|
|
|
|
|
|
|
put_numa_group(my_grp);
|
2013-10-09 08:24:48 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
no_join:
|
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
2013-10-07 10:29:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void task_numa_free(struct task_struct *p)
|
|
|
|
{
|
|
|
|
struct numa_group *grp = p->numa_group;
|
2014-10-31 00:13:31 +00:00
|
|
|
void *numa_faults = p->numa_faults;
|
2014-05-27 21:02:04 +00:00
|
|
|
unsigned long flags;
|
|
|
|
int i;
|
2013-10-07 10:29:21 +00:00
|
|
|
|
|
|
|
if (grp) {
|
2014-05-27 21:02:04 +00:00
|
|
|
spin_lock_irqsave(&grp->lock, flags);
|
2014-01-27 22:03:48 +00:00
|
|
|
for (i = 0; i < NR_NUMA_HINT_FAULT_STATS * nr_node_ids; i++)
|
2014-10-31 00:13:31 +00:00
|
|
|
grp->faults[i] -= p->numa_faults[i];
|
2013-10-07 10:29:40 +00:00
|
|
|
grp->total_faults -= p->total_numa_faults;
|
2013-10-07 10:29:27 +00:00
|
|
|
|
2013-10-07 10:29:21 +00:00
|
|
|
grp->nr_tasks--;
|
2014-05-27 21:02:04 +00:00
|
|
|
spin_unlock_irqrestore(&grp->lock, flags);
|
2014-08-22 14:50:43 +00:00
|
|
|
RCU_INIT_POINTER(p->numa_group, NULL);
|
2013-10-07 10:29:21 +00:00
|
|
|
put_numa_group(grp);
|
|
|
|
}
|
|
|
|
|
2014-10-31 00:13:31 +00:00
|
|
|
p->numa_faults = NULL;
|
2013-10-07 10:29:28 +00:00
|
|
|
kfree(numa_faults);
|
2013-10-07 10:29:21 +00:00
|
|
|
}
|
|
|
|
|
2012-10-25 12:16:43 +00:00
|
|
|
/*
|
|
|
|
* Got a PROT_NONE fault for a page on @node.
|
|
|
|
*/
|
2014-01-27 22:03:47 +00:00
|
|
|
void task_numa_fault(int last_cpupid, int mem_node, int pages, int flags)
|
2012-10-25 12:16:43 +00:00
|
|
|
{
|
|
|
|
struct task_struct *p = current;
|
2013-10-07 10:29:24 +00:00
|
|
|
bool migrated = flags & TNF_MIGRATED;
|
2014-01-27 22:03:47 +00:00
|
|
|
int cpu_node = task_node(current);
|
2014-04-11 17:00:27 +00:00
|
|
|
int local = !!(flags & TNF_FAULT_LOCAL);
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
struct numa_group *ng;
|
2013-10-07 10:29:03 +00:00
|
|
|
int priv;
|
2012-10-25 12:16:43 +00:00
|
|
|
|
2015-08-11 16:24:21 +00:00
|
|
|
if (!static_branch_likely(&sched_numa_balancing))
|
2012-11-22 11:16:36 +00:00
|
|
|
return;
|
|
|
|
|
2013-10-07 10:29:04 +00:00
|
|
|
/* for example, ksmd faulting in a user's mm */
|
|
|
|
if (!p->mm)
|
|
|
|
return;
|
|
|
|
|
2013-10-07 10:28:57 +00:00
|
|
|
/* Allocate buffer to track faults on a per-node basis */
|
2014-10-31 00:13:31 +00:00
|
|
|
if (unlikely(!p->numa_faults)) {
|
|
|
|
int size = sizeof(*p->numa_faults) *
|
2014-01-27 22:03:48 +00:00
|
|
|
NR_NUMA_HINT_FAULT_BUCKETS * nr_node_ids;
|
2013-10-07 10:28:57 +00:00
|
|
|
|
2014-10-31 00:13:31 +00:00
|
|
|
p->numa_faults = kzalloc(size, GFP_KERNEL|__GFP_NOWARN);
|
|
|
|
if (!p->numa_faults)
|
2013-10-07 10:28:57 +00:00
|
|
|
return;
|
2013-10-07 10:28:59 +00:00
|
|
|
|
2013-10-07 10:29:27 +00:00
|
|
|
p->total_numa_faults = 0;
|
2013-10-07 10:29:36 +00:00
|
|
|
memset(p->numa_faults_locality, 0, sizeof(p->numa_faults_locality));
|
2013-10-07 10:28:57 +00:00
|
|
|
}
|
2012-10-25 12:16:43 +00:00
|
|
|
|
2013-10-07 10:29:21 +00:00
|
|
|
/*
|
|
|
|
* First accesses are treated as private, otherwise consider accesses
|
|
|
|
* to be private if the accessing pid has not changed
|
|
|
|
*/
|
|
|
|
if (unlikely(last_cpupid == (-1 & LAST_CPUPID_MASK))) {
|
|
|
|
priv = 1;
|
|
|
|
} else {
|
|
|
|
priv = cpupid_match_pid(p, last_cpupid);
|
2013-10-07 10:29:24 +00:00
|
|
|
if (!priv && !(flags & TNF_NO_GROUP))
|
2013-10-07 10:29:35 +00:00
|
|
|
task_numa_group(p, last_cpupid, flags, &priv);
|
2013-10-07 10:29:21 +00:00
|
|
|
}
|
|
|
|
|
2014-04-11 17:00:27 +00:00
|
|
|
/*
|
|
|
|
* If a workload spans multiple NUMA nodes, a shared fault that
|
|
|
|
* occurs wholly within the set of nodes that the workload is
|
|
|
|
* actively using should be counted as local. This allows the
|
|
|
|
* scan rate to slow down when a workload has settled down.
|
|
|
|
*/
|
sched/numa: Spread memory according to CPU and memory use
The pseudo-interleaving in NUMA placement has a fundamental problem:
using hard usage thresholds to spread memory equally between nodes
can prevent workloads from converging, or keep memory "trapped" on
nodes where the workload is barely running any more.
In order for workloads to properly converge, the memory migration
should not be stopped when nodes reach parity, but instead be
distributed according to how heavily memory is used from each node.
This way memory migration and task migration reinforce each other,
instead of one putting the brakes on the other.
Remove the hard thresholds from the pseudo-interleaving code, and
instead use a more gradual policy on memory placement. This also
seems to improve convergence of workloads that do not run flat out,
but sleep in between bursts of activity.
We still want to slow down NUMA scanning and migration once a workload
has settled on a few actively used nodes, so keep the 3/4 hysteresis
in place. Keep track of whether a workload is actively running on
multiple nodes, so task_numa_migrate does a full scan of the system
for better task placement.
In the case of running 3 SPECjbb2005 instances on a 4 node system,
this code seems to result in fairer distribution of memory between
nodes, with more memory bandwidth for each instance.
Signed-off-by: Rik van Riel <riel@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/20160125170739.2fc9a641@annuminas.surriel.com
[ Minor readability tweaks. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-25 22:07:39 +00:00
|
|
|
ng = p->numa_group;
|
|
|
|
if (!priv && !local && ng && ng->active_nodes > 1 &&
|
|
|
|
numa_is_active_node(cpu_node, ng) &&
|
|
|
|
numa_is_active_node(mem_node, ng))
|
2014-04-11 17:00:27 +00:00
|
|
|
local = 1;
|
|
|
|
|
2012-10-25 12:16:43 +00:00
|
|
|
task_numa_placement(p);
|
2013-10-07 10:28:57 +00:00
|
|
|
|
2013-10-07 10:29:41 +00:00
|
|
|
/*
|
|
|
|
* Retry task to preferred node migration periodically, in case it
|
|
|
|
* case it previously failed, or the scheduler moved us.
|
|
|
|
*/
|
|
|
|
if (time_after(jiffies, p->numa_migrate_retry))
|
2013-10-07 10:29:11 +00:00
|
|
|
numa_migrate_preferred(p);
|
|
|
|
|
2013-10-07 10:29:30 +00:00
|
|
|
if (migrated)
|
|
|
|
p->numa_pages_migrated += pages;
|
2015-03-25 22:55:42 +00:00
|
|
|
if (flags & TNF_MIGRATE_FAIL)
|
|
|
|
p->numa_faults_locality[2] += pages;
|
2013-10-07 10:29:30 +00:00
|
|
|
|
2014-10-31 00:13:31 +00:00
|
|
|
p->numa_faults[task_faults_idx(NUMA_MEMBUF, mem_node, priv)] += pages;
|
|
|
|
p->numa_faults[task_faults_idx(NUMA_CPUBUF, cpu_node, priv)] += pages;
|
2014-04-11 17:00:27 +00:00
|
|
|
p->numa_faults_locality[local] += pages;
|
2012-10-25 12:16:43 +00:00
|
|
|
}
|
|
|
|
|
mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate
Previously, to probe the working set of a task, we'd use
a very simple and crude method: mark all of its address
space PROT_NONE.
That method has various (obvious) disadvantages:
- it samples the working set at dissimilar rates,
giving some tasks a sampling quality advantage
over others.
- creates performance problems for tasks with very
large working sets
- over-samples processes with large address spaces but
which only very rarely execute
Improve that method by keeping a rotating offset into the
address space that marks the current position of the scan,
and advance it by a constant rate (in a CPU cycles execution
proportional manner). If the offset reaches the last mapped
address of the mm then it then it starts over at the first
address.
The per-task nature of the working set sampling functionality in this tree
allows such constant rate, per task, execution-weight proportional sampling
of the working set, with an adaptive sampling interval/frequency that
goes from once per 100ms up to just once per 8 seconds. The current
sampling volume is 256 MB per interval.
As tasks mature and converge their working set, so does the
sampling rate slow down to just a trickle, 256 MB per 8
seconds of CPU time executed.
This, beyond being adaptive, also rate-limits rarely
executing systems and does not over-sample on overloaded
systems.
[ In AutoNUMA speak, this patch deals with the effective sampling
rate of the 'hinting page fault'. AutoNUMA's scanning is
currently rate-limited, but it is also fundamentally
single-threaded, executing in the knuma_scand kernel thread,
so the limit in AutoNUMA is global and does not scale up with
the number of CPUs, nor does it scan tasks in an execution
proportional manner.
So the idea of rate-limiting the scanning was first implemented
in the AutoNUMA tree via a global rate limit. This patch goes
beyond that by implementing an execution rate proportional
working set sampling rate that is not implemented via a single
global scanning daemon. ]
[ Dan Carpenter pointed out a possible NULL pointer dereference in the
first version of this patch. ]
Based-on-idea-by: Andrea Arcangeli <aarcange@redhat.com>
Bug-Found-By: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Rik van Riel <riel@redhat.com>
[ Wrote changelog and fixed bug. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
2012-10-25 12:16:45 +00:00
|
|
|
static void reset_ptenuma_scan(struct task_struct *p)
|
|
|
|
{
|
2015-05-01 00:28:14 +00:00
|
|
|
/*
|
|
|
|
* We only did a read acquisition of the mmap sem, so
|
|
|
|
* p->mm->numa_scan_seq is written to without exclusive access
|
|
|
|
* and the update is not guaranteed to be atomic. That's not
|
|
|
|
* much of an issue though, since this is just used for
|
|
|
|
* statistical sampling. Use READ_ONCE/WRITE_ONCE, which are not
|
|
|
|
* expensive, to avoid any form of compiler optimizations:
|
|
|
|
*/
|
2015-04-28 20:00:20 +00:00
|
|
|
WRITE_ONCE(p->mm->numa_scan_seq, READ_ONCE(p->mm->numa_scan_seq) + 1);
|
mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate
Previously, to probe the working set of a task, we'd use
a very simple and crude method: mark all of its address
space PROT_NONE.
That method has various (obvious) disadvantages:
- it samples the working set at dissimilar rates,
giving some tasks a sampling quality advantage
over others.
- creates performance problems for tasks with very
large working sets
- over-samples processes with large address spaces but
which only very rarely execute
Improve that method by keeping a rotating offset into the
address space that marks the current position of the scan,
and advance it by a constant rate (in a CPU cycles execution
proportional manner). If the offset reaches the last mapped
address of the mm then it then it starts over at the first
address.
The per-task nature of the working set sampling functionality in this tree
allows such constant rate, per task, execution-weight proportional sampling
of the working set, with an adaptive sampling interval/frequency that
goes from once per 100ms up to just once per 8 seconds. The current
sampling volume is 256 MB per interval.
As tasks mature and converge their working set, so does the
sampling rate slow down to just a trickle, 256 MB per 8
seconds of CPU time executed.
This, beyond being adaptive, also rate-limits rarely
executing systems and does not over-sample on overloaded
systems.
[ In AutoNUMA speak, this patch deals with the effective sampling
rate of the 'hinting page fault'. AutoNUMA's scanning is
currently rate-limited, but it is also fundamentally
single-threaded, executing in the knuma_scand kernel thread,
so the limit in AutoNUMA is global and does not scale up with
the number of CPUs, nor does it scan tasks in an execution
proportional manner.
So the idea of rate-limiting the scanning was first implemented
in the AutoNUMA tree via a global rate limit. This patch goes
beyond that by implementing an execution rate proportional
working set sampling rate that is not implemented via a single
global scanning daemon. ]
[ Dan Carpenter pointed out a possible NULL pointer dereference in the
first version of this patch. ]
Based-on-idea-by: Andrea Arcangeli <aarcange@redhat.com>
Bug-Found-By: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Rik van Riel <riel@redhat.com>
[ Wrote changelog and fixed bug. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
2012-10-25 12:16:45 +00:00
|
|
|
p->mm->numa_scan_offset = 0;
|
|
|
|
}
|
|
|
|
|
2012-10-25 12:16:43 +00:00
|
|
|
/*
|
|
|
|
* The expensive part of numa migration is done from task_work context.
|
|
|
|
* Triggered from task_tick_numa().
|
|
|
|
*/
|
|
|
|
void task_numa_work(struct callback_head *work)
|
|
|
|
{
|
|
|
|
unsigned long migrate, next_scan, now = jiffies;
|
|
|
|
struct task_struct *p = current;
|
|
|
|
struct mm_struct *mm = p->mm;
|
sched/numa: Cap PTE scanning overhead to 3% of run time
There is a fundamental mismatch between the runtime based NUMA scanning
at the task level, and the wall clock time NUMA scanning at the mm level.
On a severely overloaded system, with very large processes, this mismatch
can cause the system to spend all of its time in change_prot_numa().
This can happen if the task spends at least two ticks in change_prot_numa(),
and only gets two ticks of CPU time in the real time between two scan
intervals of the mm.
This patch ensures that a task never spends more than 3% of run
time scanning PTEs. It does that by ensuring that in-between
task_numa_work() runs, the task spends at least 32x as much time on
other things than it did on task_numa_work().
This is done stochastically: if a timer tick happens, or the task
gets rescheduled during task_numa_work(), we delay a future run of
task_numa_work() until the task has spent at least 32x the amount of
CPU time doing something else, as it spent inside task_numa_work().
The longer task_numa_work() takes, the more likely it is this happens.
If task_numa_work() takes very little time, chances are low that that
code will do anything, but we will not care.
Reported-and-tested-by: Jan Stancek <jstancek@redhat.com>
Signed-off-by: Rik van Riel <riel@redhat.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/1446756983-28173-3-git-send-email-riel@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-11-05 20:56:23 +00:00
|
|
|
u64 runtime = p->se.sum_exec_runtime;
|
mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate
Previously, to probe the working set of a task, we'd use
a very simple and crude method: mark all of its address
space PROT_NONE.
That method has various (obvious) disadvantages:
- it samples the working set at dissimilar rates,
giving some tasks a sampling quality advantage
over others.
- creates performance problems for tasks with very
large working sets
- over-samples processes with large address spaces but
which only very rarely execute
Improve that method by keeping a rotating offset into the
address space that marks the current position of the scan,
and advance it by a constant rate (in a CPU cycles execution
proportional manner). If the offset reaches the last mapped
address of the mm then it then it starts over at the first
address.
The per-task nature of the working set sampling functionality in this tree
allows such constant rate, per task, execution-weight proportional sampling
of the working set, with an adaptive sampling interval/frequency that
goes from once per 100ms up to just once per 8 seconds. The current
sampling volume is 256 MB per interval.
As tasks mature and converge their working set, so does the
sampling rate slow down to just a trickle, 256 MB per 8
seconds of CPU time executed.
This, beyond being adaptive, also rate-limits rarely
executing systems and does not over-sample on overloaded
systems.
[ In AutoNUMA speak, this patch deals with the effective sampling
rate of the 'hinting page fault'. AutoNUMA's scanning is
currently rate-limited, but it is also fundamentally
single-threaded, executing in the knuma_scand kernel thread,
so the limit in AutoNUMA is global and does not scale up with
the number of CPUs, nor does it scan tasks in an execution
proportional manner.
So the idea of rate-limiting the scanning was first implemented
in the AutoNUMA tree via a global rate limit. This patch goes
beyond that by implementing an execution rate proportional
working set sampling rate that is not implemented via a single
global scanning daemon. ]
[ Dan Carpenter pointed out a possible NULL pointer dereference in the
first version of this patch. ]
Based-on-idea-by: Andrea Arcangeli <aarcange@redhat.com>
Bug-Found-By: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Rik van Riel <riel@redhat.com>
[ Wrote changelog and fixed bug. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
2012-10-25 12:16:45 +00:00
|
|
|
struct vm_area_struct *vma;
|
2012-11-14 18:34:32 +00:00
|
|
|
unsigned long start, end;
|
2013-10-07 10:28:55 +00:00
|
|
|
unsigned long nr_pte_updates = 0;
|
2015-09-11 13:00:27 +00:00
|
|
|
long pages, virtpages;
|
2012-10-25 12:16:43 +00:00
|
|
|
|
2016-09-20 20:34:51 +00:00
|
|
|
SCHED_WARN_ON(p != container_of(work, struct task_struct, numa_work));
|
2012-10-25 12:16:43 +00:00
|
|
|
|
|
|
|
work->next = work; /* protect against double add */
|
|
|
|
/*
|
|
|
|
* Who cares about NUMA placement when they're dying.
|
|
|
|
*
|
|
|
|
* NOTE: make sure not to dereference p->mm before this check,
|
|
|
|
* exit_task_work() happens _after_ exit_mm() so we could be called
|
|
|
|
* without p->mm even though we still had it when we enqueued this
|
|
|
|
* work.
|
|
|
|
*/
|
|
|
|
if (p->flags & PF_EXITING)
|
|
|
|
return;
|
|
|
|
|
2013-10-07 10:29:37 +00:00
|
|
|
if (!mm->numa_next_scan) {
|
2013-10-07 10:28:54 +00:00
|
|
|
mm->numa_next_scan = now +
|
|
|
|
msecs_to_jiffies(sysctl_numa_balancing_scan_delay);
|
2012-11-21 01:18:23 +00:00
|
|
|
}
|
|
|
|
|
2012-10-25 12:16:43 +00:00
|
|
|
/*
|
|
|
|
* Enforce maximal scan/migration frequency..
|
|
|
|
*/
|
|
|
|
migrate = mm->numa_next_scan;
|
|
|
|
if (time_before(now, migrate))
|
|
|
|
return;
|
|
|
|
|
2013-10-07 10:28:55 +00:00
|
|
|
if (p->numa_scan_period == 0) {
|
|
|
|
p->numa_scan_period_max = task_scan_max(p);
|
2017-07-31 19:28:47 +00:00
|
|
|
p->numa_scan_period = task_scan_start(p);
|
2013-10-07 10:28:55 +00:00
|
|
|
}
|
2012-10-25 12:16:43 +00:00
|
|
|
|
2012-11-15 09:01:14 +00:00
|
|
|
next_scan = now + msecs_to_jiffies(p->numa_scan_period);
|
2012-10-25 12:16:43 +00:00
|
|
|
if (cmpxchg(&mm->numa_next_scan, migrate, next_scan) != migrate)
|
|
|
|
return;
|
|
|
|
|
2013-10-07 10:28:51 +00:00
|
|
|
/*
|
|
|
|
* Delay this task enough that another task of this mm will likely win
|
|
|
|
* the next time around.
|
|
|
|
*/
|
|
|
|
p->node_stamp += 2 * TICK_NSEC;
|
|
|
|
|
2012-11-14 18:34:32 +00:00
|
|
|
start = mm->numa_scan_offset;
|
|
|
|
pages = sysctl_numa_balancing_scan_size;
|
|
|
|
pages <<= 20 - PAGE_SHIFT; /* MB in pages */
|
2015-09-11 13:00:27 +00:00
|
|
|
virtpages = pages * 8; /* Scan up to this much virtual space */
|
2012-11-14 18:34:32 +00:00
|
|
|
if (!pages)
|
|
|
|
return;
|
2012-10-25 12:16:43 +00:00
|
|
|
|
2015-09-11 13:00:27 +00:00
|
|
|
|
2017-05-15 13:13:16 +00:00
|
|
|
if (!down_read_trylock(&mm->mmap_sem))
|
|
|
|
return;
|
2012-11-14 18:34:32 +00:00
|
|
|
vma = find_vma(mm, start);
|
mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate
Previously, to probe the working set of a task, we'd use
a very simple and crude method: mark all of its address
space PROT_NONE.
That method has various (obvious) disadvantages:
- it samples the working set at dissimilar rates,
giving some tasks a sampling quality advantage
over others.
- creates performance problems for tasks with very
large working sets
- over-samples processes with large address spaces but
which only very rarely execute
Improve that method by keeping a rotating offset into the
address space that marks the current position of the scan,
and advance it by a constant rate (in a CPU cycles execution
proportional manner). If the offset reaches the last mapped
address of the mm then it then it starts over at the first
address.
The per-task nature of the working set sampling functionality in this tree
allows such constant rate, per task, execution-weight proportional sampling
of the working set, with an adaptive sampling interval/frequency that
goes from once per 100ms up to just once per 8 seconds. The current
sampling volume is 256 MB per interval.
As tasks mature and converge their working set, so does the
sampling rate slow down to just a trickle, 256 MB per 8
seconds of CPU time executed.
This, beyond being adaptive, also rate-limits rarely
executing systems and does not over-sample on overloaded
systems.
[ In AutoNUMA speak, this patch deals with the effective sampling
rate of the 'hinting page fault'. AutoNUMA's scanning is
currently rate-limited, but it is also fundamentally
single-threaded, executing in the knuma_scand kernel thread,
so the limit in AutoNUMA is global and does not scale up with
the number of CPUs, nor does it scan tasks in an execution
proportional manner.
So the idea of rate-limiting the scanning was first implemented
in the AutoNUMA tree via a global rate limit. This patch goes
beyond that by implementing an execution rate proportional
working set sampling rate that is not implemented via a single
global scanning daemon. ]
[ Dan Carpenter pointed out a possible NULL pointer dereference in the
first version of this patch. ]
Based-on-idea-by: Andrea Arcangeli <aarcange@redhat.com>
Bug-Found-By: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Rik van Riel <riel@redhat.com>
[ Wrote changelog and fixed bug. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
2012-10-25 12:16:45 +00:00
|
|
|
if (!vma) {
|
|
|
|
reset_ptenuma_scan(p);
|
2012-11-14 18:34:32 +00:00
|
|
|
start = 0;
|
mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate
Previously, to probe the working set of a task, we'd use
a very simple and crude method: mark all of its address
space PROT_NONE.
That method has various (obvious) disadvantages:
- it samples the working set at dissimilar rates,
giving some tasks a sampling quality advantage
over others.
- creates performance problems for tasks with very
large working sets
- over-samples processes with large address spaces but
which only very rarely execute
Improve that method by keeping a rotating offset into the
address space that marks the current position of the scan,
and advance it by a constant rate (in a CPU cycles execution
proportional manner). If the offset reaches the last mapped
address of the mm then it then it starts over at the first
address.
The per-task nature of the working set sampling functionality in this tree
allows such constant rate, per task, execution-weight proportional sampling
of the working set, with an adaptive sampling interval/frequency that
goes from once per 100ms up to just once per 8 seconds. The current
sampling volume is 256 MB per interval.
As tasks mature and converge their working set, so does the
sampling rate slow down to just a trickle, 256 MB per 8
seconds of CPU time executed.
This, beyond being adaptive, also rate-limits rarely
executing systems and does not over-sample on overloaded
systems.
[ In AutoNUMA speak, this patch deals with the effective sampling
rate of the 'hinting page fault'. AutoNUMA's scanning is
currently rate-limited, but it is also fundamentally
single-threaded, executing in the knuma_scand kernel thread,
so the limit in AutoNUMA is global and does not scale up with
the number of CPUs, nor does it scan tasks in an execution
proportional manner.
So the idea of rate-limiting the scanning was first implemented
in the AutoNUMA tree via a global rate limit. This patch goes
beyond that by implementing an execution rate proportional
working set sampling rate that is not implemented via a single
global scanning daemon. ]
[ Dan Carpenter pointed out a possible NULL pointer dereference in the
first version of this patch. ]
Based-on-idea-by: Andrea Arcangeli <aarcange@redhat.com>
Bug-Found-By: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Rik van Riel <riel@redhat.com>
[ Wrote changelog and fixed bug. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
2012-10-25 12:16:45 +00:00
|
|
|
vma = mm->mmap;
|
|
|
|
}
|
2012-11-14 18:34:32 +00:00
|
|
|
for (; vma; vma = vma->vm_next) {
|
2015-04-07 21:26:47 +00:00
|
|
|
if (!vma_migratable(vma) || !vma_policy_mof(vma) ||
|
2015-06-10 18:15:00 +00:00
|
|
|
is_vm_hugetlb_page(vma) || (vma->vm_flags & VM_MIXEDMAP)) {
|
mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate
Previously, to probe the working set of a task, we'd use
a very simple and crude method: mark all of its address
space PROT_NONE.
That method has various (obvious) disadvantages:
- it samples the working set at dissimilar rates,
giving some tasks a sampling quality advantage
over others.
- creates performance problems for tasks with very
large working sets
- over-samples processes with large address spaces but
which only very rarely execute
Improve that method by keeping a rotating offset into the
address space that marks the current position of the scan,
and advance it by a constant rate (in a CPU cycles execution
proportional manner). If the offset reaches the last mapped
address of the mm then it then it starts over at the first
address.
The per-task nature of the working set sampling functionality in this tree
allows such constant rate, per task, execution-weight proportional sampling
of the working set, with an adaptive sampling interval/frequency that
goes from once per 100ms up to just once per 8 seconds. The current
sampling volume is 256 MB per interval.
As tasks mature and converge their working set, so does the
sampling rate slow down to just a trickle, 256 MB per 8
seconds of CPU time executed.
This, beyond being adaptive, also rate-limits rarely
executing systems and does not over-sample on overloaded
systems.
[ In AutoNUMA speak, this patch deals with the effective sampling
rate of the 'hinting page fault'. AutoNUMA's scanning is
currently rate-limited, but it is also fundamentally
single-threaded, executing in the knuma_scand kernel thread,
so the limit in AutoNUMA is global and does not scale up with
the number of CPUs, nor does it scan tasks in an execution
proportional manner.
So the idea of rate-limiting the scanning was first implemented
in the AutoNUMA tree via a global rate limit. This patch goes
beyond that by implementing an execution rate proportional
working set sampling rate that is not implemented via a single
global scanning daemon. ]
[ Dan Carpenter pointed out a possible NULL pointer dereference in the
first version of this patch. ]
Based-on-idea-by: Andrea Arcangeli <aarcange@redhat.com>
Bug-Found-By: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Rik van Riel <riel@redhat.com>
[ Wrote changelog and fixed bug. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
2012-10-25 12:16:45 +00:00
|
|
|
continue;
|
2015-04-07 21:26:47 +00:00
|
|
|
}
|
mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate
Previously, to probe the working set of a task, we'd use
a very simple and crude method: mark all of its address
space PROT_NONE.
That method has various (obvious) disadvantages:
- it samples the working set at dissimilar rates,
giving some tasks a sampling quality advantage
over others.
- creates performance problems for tasks with very
large working sets
- over-samples processes with large address spaces but
which only very rarely execute
Improve that method by keeping a rotating offset into the
address space that marks the current position of the scan,
and advance it by a constant rate (in a CPU cycles execution
proportional manner). If the offset reaches the last mapped
address of the mm then it then it starts over at the first
address.
The per-task nature of the working set sampling functionality in this tree
allows such constant rate, per task, execution-weight proportional sampling
of the working set, with an adaptive sampling interval/frequency that
goes from once per 100ms up to just once per 8 seconds. The current
sampling volume is 256 MB per interval.
As tasks mature and converge their working set, so does the
sampling rate slow down to just a trickle, 256 MB per 8
seconds of CPU time executed.
This, beyond being adaptive, also rate-limits rarely
executing systems and does not over-sample on overloaded
systems.
[ In AutoNUMA speak, this patch deals with the effective sampling
rate of the 'hinting page fault'. AutoNUMA's scanning is
currently rate-limited, but it is also fundamentally
single-threaded, executing in the knuma_scand kernel thread,
so the limit in AutoNUMA is global and does not scale up with
the number of CPUs, nor does it scan tasks in an execution
proportional manner.
So the idea of rate-limiting the scanning was first implemented
in the AutoNUMA tree via a global rate limit. This patch goes
beyond that by implementing an execution rate proportional
working set sampling rate that is not implemented via a single
global scanning daemon. ]
[ Dan Carpenter pointed out a possible NULL pointer dereference in the
first version of this patch. ]
Based-on-idea-by: Andrea Arcangeli <aarcange@redhat.com>
Bug-Found-By: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Rik van Riel <riel@redhat.com>
[ Wrote changelog and fixed bug. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
2012-10-25 12:16:45 +00:00
|
|
|
|
2013-10-07 10:29:13 +00:00
|
|
|
/*
|
|
|
|
* Shared library pages mapped by multiple processes are not
|
|
|
|
* migrated as it is expected they are cache replicated. Avoid
|
|
|
|
* hinting faults in read-only file-backed mappings or the vdso
|
|
|
|
* as migrating the pages will be of marginal benefit.
|
|
|
|
*/
|
|
|
|
if (!vma->vm_mm ||
|
|
|
|
(vma->vm_file && (vma->vm_flags & (VM_READ|VM_WRITE)) == (VM_READ)))
|
|
|
|
continue;
|
|
|
|
|
2013-12-19 01:08:40 +00:00
|
|
|
/*
|
|
|
|
* Skip inaccessible VMAs to avoid any confusion between
|
|
|
|
* PROT_NONE and NUMA hinting ptes
|
|
|
|
*/
|
|
|
|
if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
|
|
|
|
continue;
|
2013-10-07 10:29:13 +00:00
|
|
|
|
2012-11-14 18:34:32 +00:00
|
|
|
do {
|
|
|
|
start = max(start, vma->vm_start);
|
|
|
|
end = ALIGN(start + (pages << PAGE_SHIFT), HPAGE_SIZE);
|
|
|
|
end = min(end, vma->vm_end);
|
2015-09-11 13:00:27 +00:00
|
|
|
nr_pte_updates = change_prot_numa(vma, start, end);
|
2013-10-07 10:28:55 +00:00
|
|
|
|
|
|
|
/*
|
2015-09-11 13:00:27 +00:00
|
|
|
* Try to scan sysctl_numa_balancing_size worth of
|
|
|
|
* hpages that have at least one present PTE that
|
|
|
|
* is not already pte-numa. If the VMA contains
|
|
|
|
* areas that are unused or already full of prot_numa
|
|
|
|
* PTEs, scan up to virtpages, to skip through those
|
|
|
|
* areas faster.
|
2013-10-07 10:28:55 +00:00
|
|
|
*/
|
|
|
|
if (nr_pte_updates)
|
|
|
|
pages -= (end - start) >> PAGE_SHIFT;
|
2015-09-11 13:00:27 +00:00
|
|
|
virtpages -= (end - start) >> PAGE_SHIFT;
|
mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate
Previously, to probe the working set of a task, we'd use
a very simple and crude method: mark all of its address
space PROT_NONE.
That method has various (obvious) disadvantages:
- it samples the working set at dissimilar rates,
giving some tasks a sampling quality advantage
over others.
- creates performance problems for tasks with very
large working sets
- over-samples processes with large address spaces but
which only very rarely execute
Improve that method by keeping a rotating offset into the
address space that marks the current position of the scan,
and advance it by a constant rate (in a CPU cycles execution
proportional manner). If the offset reaches the last mapped
address of the mm then it then it starts over at the first
address.
The per-task nature of the working set sampling functionality in this tree
allows such constant rate, per task, execution-weight proportional sampling
of the working set, with an adaptive sampling interval/frequency that
goes from once per 100ms up to just once per 8 seconds. The current
sampling volume is 256 MB per interval.
As tasks mature and converge their working set, so does the
sampling rate slow down to just a trickle, 256 MB per 8
seconds of CPU time executed.
This, beyond being adaptive, also rate-limits rarely
executing systems and does not over-sample on overloaded
systems.
[ In AutoNUMA speak, this patch deals with the effective sampling
rate of the 'hinting page fault'. AutoNUMA's scanning is
currently rate-limited, but it is also fundamentally
single-threaded, executing in the knuma_scand kernel thread,
so the limit in AutoNUMA is global and does not scale up with
the number of CPUs, nor does it scan tasks in an execution
proportional manner.
So the idea of rate-limiting the scanning was first implemented
in the AutoNUMA tree via a global rate limit. This patch goes
beyond that by implementing an execution rate proportional
working set sampling rate that is not implemented via a single
global scanning daemon. ]
[ Dan Carpenter pointed out a possible NULL pointer dereference in the
first version of this patch. ]
Based-on-idea-by: Andrea Arcangeli <aarcange@redhat.com>
Bug-Found-By: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Rik van Riel <riel@redhat.com>
[ Wrote changelog and fixed bug. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
2012-10-25 12:16:45 +00:00
|
|
|
|
2012-11-14 18:34:32 +00:00
|
|
|
start = end;
|
2015-09-11 13:00:27 +00:00
|
|
|
if (pages <= 0 || virtpages <= 0)
|
2012-11-14 18:34:32 +00:00
|
|
|
goto out;
|
2014-02-18 22:12:44 +00:00
|
|
|
|
|
|
|
cond_resched();
|
2012-11-14 18:34:32 +00:00
|
|
|
} while (end != vma->vm_end);
|
2012-10-25 12:16:43 +00:00
|
|
|
}
|
mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate
Previously, to probe the working set of a task, we'd use
a very simple and crude method: mark all of its address
space PROT_NONE.
That method has various (obvious) disadvantages:
- it samples the working set at dissimilar rates,
giving some tasks a sampling quality advantage
over others.
- creates performance problems for tasks with very
large working sets
- over-samples processes with large address spaces but
which only very rarely execute
Improve that method by keeping a rotating offset into the
address space that marks the current position of the scan,
and advance it by a constant rate (in a CPU cycles execution
proportional manner). If the offset reaches the last mapped
address of the mm then it then it starts over at the first
address.
The per-task nature of the working set sampling functionality in this tree
allows such constant rate, per task, execution-weight proportional sampling
of the working set, with an adaptive sampling interval/frequency that
goes from once per 100ms up to just once per 8 seconds. The current
sampling volume is 256 MB per interval.
As tasks mature and converge their working set, so does the
sampling rate slow down to just a trickle, 256 MB per 8
seconds of CPU time executed.
This, beyond being adaptive, also rate-limits rarely
executing systems and does not over-sample on overloaded
systems.
[ In AutoNUMA speak, this patch deals with the effective sampling
rate of the 'hinting page fault'. AutoNUMA's scanning is
currently rate-limited, but it is also fundamentally
single-threaded, executing in the knuma_scand kernel thread,
so the limit in AutoNUMA is global and does not scale up with
the number of CPUs, nor does it scan tasks in an execution
proportional manner.
So the idea of rate-limiting the scanning was first implemented
in the AutoNUMA tree via a global rate limit. This patch goes
beyond that by implementing an execution rate proportional
working set sampling rate that is not implemented via a single
global scanning daemon. ]
[ Dan Carpenter pointed out a possible NULL pointer dereference in the
first version of this patch. ]
Based-on-idea-by: Andrea Arcangeli <aarcange@redhat.com>
Bug-Found-By: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Rik van Riel <riel@redhat.com>
[ Wrote changelog and fixed bug. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
2012-10-25 12:16:45 +00:00
|
|
|
|
2012-11-14 18:34:32 +00:00
|
|
|
out:
|
mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate
Previously, to probe the working set of a task, we'd use
a very simple and crude method: mark all of its address
space PROT_NONE.
That method has various (obvious) disadvantages:
- it samples the working set at dissimilar rates,
giving some tasks a sampling quality advantage
over others.
- creates performance problems for tasks with very
large working sets
- over-samples processes with large address spaces but
which only very rarely execute
Improve that method by keeping a rotating offset into the
address space that marks the current position of the scan,
and advance it by a constant rate (in a CPU cycles execution
proportional manner). If the offset reaches the last mapped
address of the mm then it then it starts over at the first
address.
The per-task nature of the working set sampling functionality in this tree
allows such constant rate, per task, execution-weight proportional sampling
of the working set, with an adaptive sampling interval/frequency that
goes from once per 100ms up to just once per 8 seconds. The current
sampling volume is 256 MB per interval.
As tasks mature and converge their working set, so does the
sampling rate slow down to just a trickle, 256 MB per 8
seconds of CPU time executed.
This, beyond being adaptive, also rate-limits rarely
executing systems and does not over-sample on overloaded
systems.
[ In AutoNUMA speak, this patch deals with the effective sampling
rate of the 'hinting page fault'. AutoNUMA's scanning is
currently rate-limited, but it is also fundamentally
single-threaded, executing in the knuma_scand kernel thread,
so the limit in AutoNUMA is global and does not scale up with
the number of CPUs, nor does it scan tasks in an execution
proportional manner.
So the idea of rate-limiting the scanning was first implemented
in the AutoNUMA tree via a global rate limit. This patch goes
beyond that by implementing an execution rate proportional
working set sampling rate that is not implemented via a single
global scanning daemon. ]
[ Dan Carpenter pointed out a possible NULL pointer dereference in the
first version of this patch. ]
Based-on-idea-by: Andrea Arcangeli <aarcange@redhat.com>
Bug-Found-By: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Rik van Riel <riel@redhat.com>
[ Wrote changelog and fixed bug. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
2012-10-25 12:16:45 +00:00
|
|
|
/*
|
2013-10-07 10:28:41 +00:00
|
|
|
* It is possible to reach the end of the VMA list but the last few
|
|
|
|
* VMAs are not guaranteed to the vma_migratable. If they are not, we
|
|
|
|
* would find the !migratable VMA on the next scan but not reset the
|
|
|
|
* scanner to the start so check it now.
|
mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate
Previously, to probe the working set of a task, we'd use
a very simple and crude method: mark all of its address
space PROT_NONE.
That method has various (obvious) disadvantages:
- it samples the working set at dissimilar rates,
giving some tasks a sampling quality advantage
over others.
- creates performance problems for tasks with very
large working sets
- over-samples processes with large address spaces but
which only very rarely execute
Improve that method by keeping a rotating offset into the
address space that marks the current position of the scan,
and advance it by a constant rate (in a CPU cycles execution
proportional manner). If the offset reaches the last mapped
address of the mm then it then it starts over at the first
address.
The per-task nature of the working set sampling functionality in this tree
allows such constant rate, per task, execution-weight proportional sampling
of the working set, with an adaptive sampling interval/frequency that
goes from once per 100ms up to just once per 8 seconds. The current
sampling volume is 256 MB per interval.
As tasks mature and converge their working set, so does the
sampling rate slow down to just a trickle, 256 MB per 8
seconds of CPU time executed.
This, beyond being adaptive, also rate-limits rarely
executing systems and does not over-sample on overloaded
systems.
[ In AutoNUMA speak, this patch deals with the effective sampling
rate of the 'hinting page fault'. AutoNUMA's scanning is
currently rate-limited, but it is also fundamentally
single-threaded, executing in the knuma_scand kernel thread,
so the limit in AutoNUMA is global and does not scale up with
the number of CPUs, nor does it scan tasks in an execution
proportional manner.
So the idea of rate-limiting the scanning was first implemented
in the AutoNUMA tree via a global rate limit. This patch goes
beyond that by implementing an execution rate proportional
working set sampling rate that is not implemented via a single
global scanning daemon. ]
[ Dan Carpenter pointed out a possible NULL pointer dereference in the
first version of this patch. ]
Based-on-idea-by: Andrea Arcangeli <aarcange@redhat.com>
Bug-Found-By: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Rik van Riel <riel@redhat.com>
[ Wrote changelog and fixed bug. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
2012-10-25 12:16:45 +00:00
|
|
|
*/
|
|
|
|
if (vma)
|
2012-11-14 18:34:32 +00:00
|
|
|
mm->numa_scan_offset = start;
|
mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate
Previously, to probe the working set of a task, we'd use
a very simple and crude method: mark all of its address
space PROT_NONE.
That method has various (obvious) disadvantages:
- it samples the working set at dissimilar rates,
giving some tasks a sampling quality advantage
over others.
- creates performance problems for tasks with very
large working sets
- over-samples processes with large address spaces but
which only very rarely execute
Improve that method by keeping a rotating offset into the
address space that marks the current position of the scan,
and advance it by a constant rate (in a CPU cycles execution
proportional manner). If the offset reaches the last mapped
address of the mm then it then it starts over at the first
address.
The per-task nature of the working set sampling functionality in this tree
allows such constant rate, per task, execution-weight proportional sampling
of the working set, with an adaptive sampling interval/frequency that
goes from once per 100ms up to just once per 8 seconds. The current
sampling volume is 256 MB per interval.
As tasks mature and converge their working set, so does the
sampling rate slow down to just a trickle, 256 MB per 8
seconds of CPU time executed.
This, beyond being adaptive, also rate-limits rarely
executing systems and does not over-sample on overloaded
systems.
[ In AutoNUMA speak, this patch deals with the effective sampling
rate of the 'hinting page fault'. AutoNUMA's scanning is
currently rate-limited, but it is also fundamentally
single-threaded, executing in the knuma_scand kernel thread,
so the limit in AutoNUMA is global and does not scale up with
the number of CPUs, nor does it scan tasks in an execution
proportional manner.
So the idea of rate-limiting the scanning was first implemented
in the AutoNUMA tree via a global rate limit. This patch goes
beyond that by implementing an execution rate proportional
working set sampling rate that is not implemented via a single
global scanning daemon. ]
[ Dan Carpenter pointed out a possible NULL pointer dereference in the
first version of this patch. ]
Based-on-idea-by: Andrea Arcangeli <aarcange@redhat.com>
Bug-Found-By: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Rik van Riel <riel@redhat.com>
[ Wrote changelog and fixed bug. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
2012-10-25 12:16:45 +00:00
|
|
|
else
|
|
|
|
reset_ptenuma_scan(p);
|
|
|
|
up_read(&mm->mmap_sem);
|
sched/numa: Cap PTE scanning overhead to 3% of run time
There is a fundamental mismatch between the runtime based NUMA scanning
at the task level, and the wall clock time NUMA scanning at the mm level.
On a severely overloaded system, with very large processes, this mismatch
can cause the system to spend all of its time in change_prot_numa().
This can happen if the task spends at least two ticks in change_prot_numa(),
and only gets two ticks of CPU time in the real time between two scan
intervals of the mm.
This patch ensures that a task never spends more than 3% of run
time scanning PTEs. It does that by ensuring that in-between
task_numa_work() runs, the task spends at least 32x as much time on
other things than it did on task_numa_work().
This is done stochastically: if a timer tick happens, or the task
gets rescheduled during task_numa_work(), we delay a future run of
task_numa_work() until the task has spent at least 32x the amount of
CPU time doing something else, as it spent inside task_numa_work().
The longer task_numa_work() takes, the more likely it is this happens.
If task_numa_work() takes very little time, chances are low that that
code will do anything, but we will not care.
Reported-and-tested-by: Jan Stancek <jstancek@redhat.com>
Signed-off-by: Rik van Riel <riel@redhat.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: mgorman@suse.de
Link: http://lkml.kernel.org/r/1446756983-28173-3-git-send-email-riel@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-11-05 20:56:23 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure tasks use at least 32x as much time to run other code
|
|
|
|
* than they used here, to limit NUMA PTE scanning overhead to 3% max.
|
|
|
|
* Usually update_task_scan_period slows down scanning enough; on an
|
|
|
|
* overloaded system we need to limit overhead on a per task basis.
|
|
|
|
*/
|
|
|
|
if (unlikely(p->se.sum_exec_runtime != runtime)) {
|
|
|
|
u64 diff = p->se.sum_exec_runtime - runtime;
|
|
|
|
p->node_stamp += 32 * diff;
|
|
|
|
}
|
2012-10-25 12:16:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Drive the periodic memory faults..
|
|
|
|
*/
|
|
|
|
void task_tick_numa(struct rq *rq, struct task_struct *curr)
|
|
|
|
{
|
|
|
|
struct callback_head *work = &curr->numa_work;
|
|
|
|
u64 period, now;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't care about NUMA placement if we don't have memory.
|
|
|
|
*/
|
|
|
|
if (!curr->mm || (curr->flags & PF_EXITING) || work->next != work)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Using runtime rather than walltime has the dual advantage that
|
|
|
|
* we (mostly) drive the selection from busy threads and that the
|
|
|
|
* task needs to have done some actual work before we bother with
|
|
|
|
* NUMA placement.
|
|
|
|
*/
|
|
|
|
now = curr->se.sum_exec_runtime;
|
|
|
|
period = (u64)curr->numa_scan_period * NSEC_PER_MSEC;
|
|
|
|
|
2015-11-05 20:56:22 +00:00
|
|
|
if (now > curr->node_stamp + period) {
|
2012-10-25 12:16:47 +00:00
|
|
|
if (!curr->node_stamp)
|
2017-07-31 19:28:47 +00:00
|
|
|
curr->numa_scan_period = task_scan_start(curr);
|
2013-10-07 10:28:51 +00:00
|
|
|
curr->node_stamp += period;
|
2012-10-25 12:16:43 +00:00
|
|
|
|
|
|
|
if (!time_before(jiffies, curr->mm->numa_next_scan)) {
|
|
|
|
init_task_work(work, task_numa_work); /* TODO: move this into sched_fork() */
|
|
|
|
task_work_add(curr, work, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-06-23 16:55:29 +00:00
|
|
|
|
2012-10-25 12:16:43 +00:00
|
|
|
#else
|
|
|
|
static void task_tick_numa(struct rq *rq, struct task_struct *curr)
|
|
|
|
{
|
|
|
|
}
|
2013-10-07 10:29:33 +00:00
|
|
|
|
|
|
|
static inline void account_numa_enqueue(struct rq *rq, struct task_struct *p)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void account_numa_dequeue(struct rq *rq, struct task_struct *p)
|
|
|
|
{
|
|
|
|
}
|
2017-06-23 16:55:29 +00:00
|
|
|
|
2012-10-25 12:16:43 +00:00
|
|
|
#endif /* CONFIG_NUMA_BALANCING */
|
|
|
|
|
2007-10-15 15:00:07 +00:00
|
|
|
static void
|
|
|
|
account_entity_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|
|
|
{
|
|
|
|
update_load_add(&cfs_rq->load, se->load.weight);
|
2008-06-27 11:41:14 +00:00
|
|
|
if (!parent_entity(se))
|
2011-10-25 08:00:11 +00:00
|
|
|
update_load_add(&rq_of(cfs_rq)->load, se->load.weight);
|
2012-02-20 20:49:09 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2013-10-07 10:29:33 +00:00
|
|
|
if (entity_is_task(se)) {
|
|
|
|
struct rq *rq = rq_of(cfs_rq);
|
|
|
|
|
|
|
|
account_numa_enqueue(rq, task_of(se));
|
|
|
|
list_add(&se->group_node, &rq->cfs_tasks);
|
|
|
|
}
|
2012-02-20 20:49:09 +00:00
|
|
|
#endif
|
2007-10-15 15:00:07 +00:00
|
|
|
cfs_rq->nr_running++;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
account_entity_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|
|
|
{
|
|
|
|
update_load_sub(&cfs_rq->load, se->load.weight);
|
2008-06-27 11:41:14 +00:00
|
|
|
if (!parent_entity(se))
|
2011-10-25 08:00:11 +00:00
|
|
|
update_load_sub(&rq_of(cfs_rq)->load, se->load.weight);
|
2016-02-01 22:47:59 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2013-10-07 10:29:33 +00:00
|
|
|
if (entity_is_task(se)) {
|
|
|
|
account_numa_dequeue(rq_of(cfs_rq), task_of(se));
|
2008-09-25 04:23:54 +00:00
|
|
|
list_del_init(&se->group_node);
|
2013-10-07 10:29:33 +00:00
|
|
|
}
|
2016-02-01 22:47:59 +00:00
|
|
|
#endif
|
2007-10-15 15:00:07 +00:00
|
|
|
cfs_rq->nr_running--;
|
|
|
|
}
|
|
|
|
|
2017-08-24 15:45:35 +00:00
|
|
|
/*
|
|
|
|
* Signed add and clamp on underflow.
|
|
|
|
*
|
|
|
|
* Explicitly do a load-store to ensure the intermediate value never hits
|
|
|
|
* memory. This allows lockless observations without ever seeing the negative
|
|
|
|
* values.
|
|
|
|
*/
|
|
|
|
#define add_positive(_ptr, _val) do { \
|
|
|
|
typeof(_ptr) ptr = (_ptr); \
|
|
|
|
typeof(_val) val = (_val); \
|
|
|
|
typeof(*ptr) res, var = READ_ONCE(*ptr); \
|
|
|
|
\
|
|
|
|
res = var + val; \
|
|
|
|
\
|
|
|
|
if (val < 0 && res > var) \
|
|
|
|
res = 0; \
|
|
|
|
\
|
|
|
|
WRITE_ONCE(*ptr, res); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unsigned subtract and clamp on underflow.
|
|
|
|
*
|
|
|
|
* Explicitly do a load-store to ensure the intermediate value never hits
|
|
|
|
* memory. This allows lockless observations without ever seeing the negative
|
|
|
|
* values.
|
|
|
|
*/
|
|
|
|
#define sub_positive(_ptr, _val) do { \
|
|
|
|
typeof(_ptr) ptr = (_ptr); \
|
|
|
|
typeof(*ptr) val = (_val); \
|
|
|
|
typeof(*ptr) res, var = READ_ONCE(*ptr); \
|
|
|
|
res = var - val; \
|
|
|
|
if (res > var) \
|
|
|
|
res = 0; \
|
|
|
|
WRITE_ONCE(*ptr, res); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/*
|
2017-05-06 13:59:54 +00:00
|
|
|
* XXX we want to get rid of these helpers and use the full load resolution.
|
2017-08-24 15:45:35 +00:00
|
|
|
*/
|
|
|
|
static inline long se_weight(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
return scale_load_down(se->load.weight);
|
|
|
|
}
|
|
|
|
|
2017-05-06 13:59:54 +00:00
|
|
|
static inline long se_runnable(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
return scale_load_down(se->runnable_weight);
|
|
|
|
}
|
|
|
|
|
2017-08-24 15:45:35 +00:00
|
|
|
static inline void
|
|
|
|
enqueue_runnable_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|
|
|
{
|
2017-05-06 13:59:54 +00:00
|
|
|
cfs_rq->runnable_weight += se->runnable_weight;
|
|
|
|
|
|
|
|
cfs_rq->avg.runnable_load_avg += se->avg.runnable_load_avg;
|
|
|
|
cfs_rq->avg.runnable_load_sum += se_runnable(se) * se->avg.runnable_load_sum;
|
2017-08-24 15:45:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
dequeue_runnable_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|
|
|
{
|
2017-05-06 13:59:54 +00:00
|
|
|
cfs_rq->runnable_weight -= se->runnable_weight;
|
|
|
|
|
|
|
|
sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg);
|
|
|
|
sub_positive(&cfs_rq->avg.runnable_load_sum,
|
|
|
|
se_runnable(se) * se->avg.runnable_load_sum);
|
2017-08-24 15:45:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
enqueue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|
|
|
{
|
|
|
|
cfs_rq->avg.load_avg += se->avg.load_avg;
|
|
|
|
cfs_rq->avg.load_sum += se_weight(se) * se->avg.load_sum;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
dequeue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|
|
|
{
|
|
|
|
sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg);
|
|
|
|
sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void
|
|
|
|
enqueue_runnable_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) { }
|
|
|
|
static inline void
|
|
|
|
dequeue_runnable_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) { }
|
|
|
|
static inline void
|
|
|
|
enqueue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) { }
|
|
|
|
static inline void
|
|
|
|
dequeue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) { }
|
|
|
|
#endif
|
|
|
|
|
2017-05-17 09:50:45 +00:00
|
|
|
static void reweight_entity(struct cfs_rq *cfs_rq, struct sched_entity *se,
|
2017-05-06 13:59:54 +00:00
|
|
|
unsigned long weight, unsigned long runnable)
|
2017-05-17 09:50:45 +00:00
|
|
|
{
|
|
|
|
if (se->on_rq) {
|
|
|
|
/* commit outstanding execution time */
|
|
|
|
if (cfs_rq->curr == se)
|
|
|
|
update_curr(cfs_rq);
|
|
|
|
account_entity_dequeue(cfs_rq, se);
|
|
|
|
dequeue_runnable_load_avg(cfs_rq, se);
|
|
|
|
}
|
|
|
|
dequeue_load_avg(cfs_rq, se);
|
|
|
|
|
2017-05-06 13:59:54 +00:00
|
|
|
se->runnable_weight = runnable;
|
2017-05-17 09:50:45 +00:00
|
|
|
update_load_set(&se->load, weight);
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2017-05-06 13:59:54 +00:00
|
|
|
do {
|
|
|
|
u32 divider = LOAD_AVG_MAX - 1024 + se->avg.period_contrib;
|
|
|
|
|
|
|
|
se->avg.load_avg = div_u64(se_weight(se) * se->avg.load_sum, divider);
|
|
|
|
se->avg.runnable_load_avg =
|
|
|
|
div_u64(se_runnable(se) * se->avg.runnable_load_sum, divider);
|
|
|
|
} while (0);
|
2017-05-17 09:50:45 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
enqueue_load_avg(cfs_rq, se);
|
|
|
|
if (se->on_rq) {
|
|
|
|
account_entity_enqueue(cfs_rq, se);
|
|
|
|
enqueue_runnable_load_avg(cfs_rq, se);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void reweight_task(struct task_struct *p, int prio)
|
|
|
|
{
|
|
|
|
struct sched_entity *se = &p->se;
|
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
|
|
|
struct load_weight *load = &se->load;
|
|
|
|
unsigned long weight = scale_load(sched_prio_to_weight[prio]);
|
|
|
|
|
2017-05-06 13:59:54 +00:00
|
|
|
reweight_entity(cfs_rq, se, weight, weight);
|
2017-05-17 09:50:45 +00:00
|
|
|
load->inv_weight = sched_prio_to_wmult[prio];
|
|
|
|
}
|
|
|
|
|
2011-01-24 07:33:52 +00:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2018-02-13 08:59:42 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2017-05-09 09:04:07 +00:00
|
|
|
/*
|
|
|
|
* All this does is approximate the hierarchical proportion which includes that
|
|
|
|
* global sum we all love to hate.
|
|
|
|
*
|
|
|
|
* That is, the weight of a group entity, is the proportional share of the
|
|
|
|
* group weight based on the group runqueue weights. That is:
|
|
|
|
*
|
|
|
|
* tg->weight * grq->load.weight
|
|
|
|
* ge->load.weight = ----------------------------- (1)
|
|
|
|
* \Sum grq->load.weight
|
|
|
|
*
|
|
|
|
* Now, because computing that sum is prohibitively expensive to compute (been
|
|
|
|
* there, done that) we approximate it with this average stuff. The average
|
|
|
|
* moves slower and therefore the approximation is cheaper and more stable.
|
|
|
|
*
|
|
|
|
* So instead of the above, we substitute:
|
|
|
|
*
|
|
|
|
* grq->load.weight -> grq->avg.load_avg (2)
|
|
|
|
*
|
|
|
|
* which yields the following:
|
|
|
|
*
|
|
|
|
* tg->weight * grq->avg.load_avg
|
|
|
|
* ge->load.weight = ------------------------------ (3)
|
|
|
|
* tg->load_avg
|
|
|
|
*
|
|
|
|
* Where: tg->load_avg ~= \Sum grq->avg.load_avg
|
|
|
|
*
|
|
|
|
* That is shares_avg, and it is right (given the approximation (2)).
|
|
|
|
*
|
|
|
|
* The problem with it is that because the average is slow -- it was designed
|
|
|
|
* to be exactly that of course -- this leads to transients in boundary
|
|
|
|
* conditions. In specific, the case where the group was idle and we start the
|
|
|
|
* one task. It takes time for our CPU's grq->avg.load_avg to build up,
|
|
|
|
* yielding bad latency etc..
|
|
|
|
*
|
|
|
|
* Now, in that special case (1) reduces to:
|
|
|
|
*
|
|
|
|
* tg->weight * grq->load.weight
|
2017-08-24 11:06:35 +00:00
|
|
|
* ge->load.weight = ----------------------------- = tg->weight (4)
|
2017-05-09 09:04:07 +00:00
|
|
|
* grp->load.weight
|
|
|
|
*
|
|
|
|
* That is, the sum collapses because all other CPUs are idle; the UP scenario.
|
|
|
|
*
|
|
|
|
* So what we do is modify our approximation (3) to approach (4) in the (near)
|
|
|
|
* UP case, like:
|
|
|
|
*
|
|
|
|
* ge->load.weight =
|
|
|
|
*
|
|
|
|
* tg->weight * grq->load.weight
|
|
|
|
* --------------------------------------------------- (5)
|
|
|
|
* tg->load_avg - grq->avg.load_avg + grq->load.weight
|
|
|
|
*
|
2017-08-24 11:06:35 +00:00
|
|
|
* But because grq->load.weight can drop to 0, resulting in a divide by zero,
|
|
|
|
* we need to use grq->avg.load_avg as its lower bound, which then gives:
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* tg->weight * grq->load.weight
|
|
|
|
* ge->load.weight = ----------------------------- (6)
|
|
|
|
* tg_load_avg'
|
|
|
|
*
|
|
|
|
* Where:
|
|
|
|
*
|
|
|
|
* tg_load_avg' = tg->load_avg - grq->avg.load_avg +
|
|
|
|
* max(grq->load.weight, grq->avg.load_avg)
|
2017-05-09 09:04:07 +00:00
|
|
|
*
|
|
|
|
* And that is shares_weight and is icky. In the (near) UP case it approaches
|
|
|
|
* (4) while in the normal case it approaches (3). It consistently
|
|
|
|
* overestimates the ge->load.weight and therefore:
|
|
|
|
*
|
|
|
|
* \Sum ge->load.weight >= tg->weight
|
|
|
|
*
|
|
|
|
* hence icky!
|
|
|
|
*/
|
2017-08-03 15:13:39 +00:00
|
|
|
static long calc_group_shares(struct cfs_rq *cfs_rq)
|
2011-10-13 14:52:28 +00:00
|
|
|
{
|
2017-05-06 14:03:17 +00:00
|
|
|
long tg_weight, tg_shares, load, shares;
|
|
|
|
struct task_group *tg = cfs_rq->tg;
|
|
|
|
|
|
|
|
tg_shares = READ_ONCE(tg->shares);
|
2011-10-13 14:52:28 +00:00
|
|
|
|
2017-05-11 16:16:06 +00:00
|
|
|
load = max(scale_load_down(cfs_rq->load.weight), cfs_rq->avg.load_avg);
|
2011-10-13 14:52:28 +00:00
|
|
|
|
2016-06-24 14:11:02 +00:00
|
|
|
tg_weight = atomic_long_read(&tg->load_avg);
|
2011-01-24 07:33:52 +00:00
|
|
|
|
2016-06-24 14:11:02 +00:00
|
|
|
/* Ensure tg_weight >= load */
|
|
|
|
tg_weight -= cfs_rq->tg_load_avg_contrib;
|
|
|
|
tg_weight += load;
|
2011-01-24 07:33:52 +00:00
|
|
|
|
2017-05-06 14:03:17 +00:00
|
|
|
shares = (tg_shares * load);
|
2011-10-13 14:52:28 +00:00
|
|
|
if (tg_weight)
|
|
|
|
shares /= tg_weight;
|
2011-01-24 07:33:52 +00:00
|
|
|
|
2017-01-11 11:29:47 +00:00
|
|
|
/*
|
|
|
|
* MIN_SHARES has to be unscaled here to support per-CPU partitioning
|
|
|
|
* of a group with small tg->shares value. It is a floor value which is
|
|
|
|
* assigned as a minimum load.weight to the sched_entity representing
|
|
|
|
* the group on a CPU.
|
|
|
|
*
|
|
|
|
* E.g. on 64-bit for a group with tg->shares of scale_load(15)=15*1024
|
|
|
|
* on an 8-core system with 8 tasks each runnable on one CPU shares has
|
|
|
|
* to be 15*1024*1/8=1920 instead of scale_load(MIN_SHARES)=2*1024. In
|
|
|
|
* case no task is runnable on a CPU MIN_SHARES=2 should be returned
|
|
|
|
* instead of 0.
|
|
|
|
*/
|
2017-05-06 14:03:17 +00:00
|
|
|
return clamp_t(long, shares, MIN_SHARES, tg_shares);
|
2011-01-24 07:33:52 +00:00
|
|
|
}
|
2017-08-03 15:13:39 +00:00
|
|
|
|
|
|
|
/*
|
2017-08-24 11:06:35 +00:00
|
|
|
* This calculates the effective runnable weight for a group entity based on
|
|
|
|
* the group entity weight calculated above.
|
|
|
|
*
|
|
|
|
* Because of the above approximation (2), our group entity weight is
|
|
|
|
* an load_avg based ratio (3). This means that it includes blocked load and
|
|
|
|
* does not represent the runnable weight.
|
|
|
|
*
|
|
|
|
* Approximate the group entity's runnable weight per ratio from the group
|
|
|
|
* runqueue:
|
|
|
|
*
|
|
|
|
* grq->avg.runnable_load_avg
|
|
|
|
* ge->runnable_weight = ge->load.weight * -------------------------- (7)
|
|
|
|
* grq->avg.load_avg
|
|
|
|
*
|
|
|
|
* However, analogous to above, since the avg numbers are slow, this leads to
|
|
|
|
* transients in the from-idle case. Instead we use:
|
|
|
|
*
|
|
|
|
* ge->runnable_weight = ge->load.weight *
|
|
|
|
*
|
|
|
|
* max(grq->avg.runnable_load_avg, grq->runnable_weight)
|
|
|
|
* ----------------------------------------------------- (8)
|
|
|
|
* max(grq->avg.load_avg, grq->load.weight)
|
|
|
|
*
|
|
|
|
* Where these max() serve both to use the 'instant' values to fix the slow
|
|
|
|
* from-idle and avoid the /0 on to-idle, similar to (6).
|
2017-08-03 15:13:39 +00:00
|
|
|
*/
|
|
|
|
static long calc_group_runnable(struct cfs_rq *cfs_rq, long shares)
|
|
|
|
{
|
2017-08-24 11:06:35 +00:00
|
|
|
long runnable, load_avg;
|
|
|
|
|
|
|
|
load_avg = max(cfs_rq->avg.load_avg,
|
|
|
|
scale_load_down(cfs_rq->load.weight));
|
|
|
|
|
|
|
|
runnable = max(cfs_rq->avg.runnable_load_avg,
|
|
|
|
scale_load_down(cfs_rq->runnable_weight));
|
2017-08-03 15:13:39 +00:00
|
|
|
|
|
|
|
runnable *= shares;
|
|
|
|
if (load_avg)
|
|
|
|
runnable /= load_avg;
|
2017-08-24 11:06:35 +00:00
|
|
|
|
2017-08-03 15:13:39 +00:00
|
|
|
return clamp_t(long, runnable, MIN_SHARES, shares);
|
|
|
|
}
|
2018-02-13 08:59:42 +00:00
|
|
|
#endif /* CONFIG_SMP */
|
2016-06-24 14:11:02 +00:00
|
|
|
|
2012-10-04 11:18:31 +00:00
|
|
|
static inline int throttled_hierarchy(struct cfs_rq *cfs_rq);
|
|
|
|
|
2017-05-06 13:59:54 +00:00
|
|
|
/*
|
|
|
|
* Recomputes the group entity based on the current state of its group
|
|
|
|
* runqueue.
|
|
|
|
*/
|
|
|
|
static void update_cfs_group(struct sched_entity *se)
|
2010-11-15 23:47:00 +00:00
|
|
|
{
|
2017-05-06 13:59:54 +00:00
|
|
|
struct cfs_rq *gcfs_rq = group_cfs_rq(se);
|
|
|
|
long shares, runnable;
|
2010-11-15 23:47:00 +00:00
|
|
|
|
2017-05-06 13:59:54 +00:00
|
|
|
if (!gcfs_rq)
|
2016-12-21 15:50:26 +00:00
|
|
|
return;
|
|
|
|
|
2017-05-06 13:59:54 +00:00
|
|
|
if (throttled_hierarchy(gcfs_rq))
|
2010-11-15 23:47:00 +00:00
|
|
|
return;
|
2016-12-21 15:50:26 +00:00
|
|
|
|
2011-01-24 07:33:52 +00:00
|
|
|
#ifndef CONFIG_SMP
|
2017-05-06 13:59:54 +00:00
|
|
|
runnable = shares = READ_ONCE(gcfs_rq->tg->shares);
|
2017-05-06 14:03:17 +00:00
|
|
|
|
|
|
|
if (likely(se->load.weight == shares))
|
2011-01-24 07:33:52 +00:00
|
|
|
return;
|
2017-05-06 14:03:17 +00:00
|
|
|
#else
|
2017-08-03 15:13:39 +00:00
|
|
|
shares = calc_group_shares(gcfs_rq);
|
|
|
|
runnable = calc_group_runnable(gcfs_rq, shares);
|
2011-01-24 07:33:52 +00:00
|
|
|
#endif
|
2010-11-15 23:47:00 +00:00
|
|
|
|
2017-05-06 13:59:54 +00:00
|
|
|
reweight_entity(cfs_rq_of(se), se, shares, runnable);
|
2010-11-15 23:47:00 +00:00
|
|
|
}
|
2016-12-21 15:50:26 +00:00
|
|
|
|
2010-11-15 23:47:00 +00:00
|
|
|
#else /* CONFIG_FAIR_GROUP_SCHED */
|
2017-05-06 13:59:54 +00:00
|
|
|
static inline void update_cfs_group(struct sched_entity *se)
|
2010-11-15 23:47:00 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_FAIR_GROUP_SCHED */
|
|
|
|
|
2017-05-24 05:29:52 +00:00
|
|
|
static inline void cfs_rq_util_change(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
Power management updates for v4.14-rc1
- Drop the P-state selection algorithm based on a PID controller
from intel_pstate and make it use the same P-state selection
method (based on the CPU load) for all types of systems in the
active mode (Rafael Wysocki, Srinivas Pandruvada).
- Rework the cpufreq core and governors to make it possible to
take cross-CPU utilization updates into account and modify the
schedutil governor to actually do so (Viresh Kumar).
- Clean up the handling of transition latency information in the
cpufreq core and untangle it from the information on which drivers
cannot do dynamic frequency switching (Viresh Kumar).
- Add support for new SoCs (MT2701/MT7623 and MT7622) to the
mediatek cpufreq driver and update its DT bindings (Sean Wang).
- Modify the cpufreq dt-platdev driver to autimatically create
cpufreq devices for the new (v2) Operating Performance Points
(OPP) DT bindings and update its whitelist of supported systems
(Viresh Kumar, Shubhrajyoti Datta, Marc Gonzalez, Khiem Nguyen,
Finley Xiao).
- Add support for Ux500 to the cpufreq-dt driver and drop the
obsolete dbx500 cpufreq driver (Linus Walleij, Arnd Bergmann).
- Add new SoC (R8A7795) support to the cpufreq rcar driver (Khiem
Nguyen).
- Fix and clean up assorted issues in the cpufreq drivers and core
(Arvind Yadav, Christophe Jaillet, Colin Ian King, Gustavo Silva,
Julia Lawall, Leonard Crestez, Rob Herring, Sudeep Holla).
- Update the IO-wait boost handling in the schedutil governor to
make it less aggressive (Joel Fernandes).
- Rework system suspend diagnostics to make it print fewer messages
to the kernel log by default, add a sysfs knob to allow more
suspend-related messages to be printed and add Low Power S0 Idle
constraints checks to the ACPI suspend-to-idle code (Rafael
Wysocki, Srinivas Pandruvada).
- Prefer suspend-to-idle over S3 on ACPI-based systems with the
ACPI_FADT_LOW_POWER_S0 flag set and the Low Power Idle S0 _DSM
interface present in the ACPI tables (Rafael Wysocki).
- Update documentation related to system sleep and rename a number
of items in the code to make it cleare that they are related to
suspend-to-idle (Rafael Wysocki).
- Export a variable allowing device drivers to check the target
system sleep state from the core system suspend code (Florian
Fainelli).
- Clean up the cpuidle subsystem to handle the polling state on
x86 in a more straightforward way and to use %pOF instead of
full_name (Rafael Wysocki, Rob Herring).
- Update the devfreq framework to fix and clean up a few minor
issues (Chanwoo Choi, Rob Herring).
- Extend diagnostics in the generic power domains (genpd) framework
and clean it up slightly (Thara Gopinath, Rob Herring).
- Fix and clean up a couple of issues in the operating performance
points (OPP) framework (Viresh Kumar, Waldemar Rymarkiewicz).
- Add support for RV1108 to the rockchip-io Adaptive Voltage Scaling
(AVS) driver (David Wu).
- Fix the usage of notifiers in CPU power management on some
platforms (Alex Shi).
- Update the pm-graph system suspend/hibernation and boot profiling
utility (Todd Brandt).
- Make it possible to run the cpupower utility without CPU0 (Prarit
Bhargava).
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
iQIcBAABCAAGBQJZrcDJAAoJEILEb/54YlRx9FUQAIUKvWBAARc61ZIZXjbqZF1v
aEMOBuksFns0CMekdptSic6n4wc81E/XYMS8yDhOOMpyDzfAZsTWjmu+gKwN7w3l
E/yf/NVlhob9JZ7MqGgqD4EUFfFIaKBXPlWFdDi2rdCUXE2L8xJ7rla8i7zyZlc5
pYHfAppBbF4qUcEY4OoOVOOGRZCfMdiLXj0iZOhMX8Y6yLBRk/AjnVADYsF33hoj
gBEfomU+H0K5V8nQEp0ZFKDArPwL+oElHQj6i+nxBpGfPM5evvLXhHOyR6AsldJ5
J4YI1kMuQNSCmvHMqOTxTYyJf8Jcf3Fj4wcjwaVMVGceY1lz6McAKknnFnCqCvz+
mskn84gFCBCM8EoJDqRf0b9MQHcuRyQKM+yw4tjnR9r8yd32erb85ZWFHcPWYhCT
fZatNOwFFv2MU+2vo5J3yeUNSWIKT+uBjy+tKPbrDkUwpKZVRj3Oj+hP3Mq9NE8U
YBqltsj7tmrdA634zI8C7jfS6wF221S0fId/iPszwmPJaVn/lq8Ror7pWL5YI8U7
SCJFjiqDiGmAcQEkuWwFAQnscZkyHpO+Y3A+jfXl/izoaZETaI5+ceIHBaocm3+5
XrOOpHS3ik8EHf9ji0KFCKZ/pYDwllday3cBQPWo3sMIzpQ2lrjbqdnE1cVnBrld
OtHZAeD/jLUXuY6XW2jN
=mAiV
-----END PGP SIGNATURE-----
Merge tag 'pm-4.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
Pull power management updates from Rafael Wysocki:
"This time (again) cpufreq gets the majority of changes which mostly
are driver updates (including a major consolidation of intel_pstate),
some schedutil governor modifications and core cleanups.
There also are some changes in the system suspend area, mostly related
to diagnostics and debug messages plus some renames of things related
to suspend-to-idle. One major change here is that suspend-to-idle is
now going to be preferred over S3 on systems where the ACPI tables
indicate to do so and provide requsite support (the Low Power Idle S0
_DSM in particular). The system sleep documentation and the tools
related to it are updated too.
The rest is a few cpuidle changes (nothing major), devfreq updates,
generic power domains (genpd) framework updates and a few assorted
modifications elsewhere.
Specifics:
- Drop the P-state selection algorithm based on a PID controller from
intel_pstate and make it use the same P-state selection method
(based on the CPU load) for all types of systems in the active mode
(Rafael Wysocki, Srinivas Pandruvada).
- Rework the cpufreq core and governors to make it possible to take
cross-CPU utilization updates into account and modify the schedutil
governor to actually do so (Viresh Kumar).
- Clean up the handling of transition latency information in the
cpufreq core and untangle it from the information on which drivers
cannot do dynamic frequency switching (Viresh Kumar).
- Add support for new SoCs (MT2701/MT7623 and MT7622) to the mediatek
cpufreq driver and update its DT bindings (Sean Wang).
- Modify the cpufreq dt-platdev driver to autimatically create
cpufreq devices for the new (v2) Operating Performance Points (OPP)
DT bindings and update its whitelist of supported systems (Viresh
Kumar, Shubhrajyoti Datta, Marc Gonzalez, Khiem Nguyen, Finley
Xiao).
- Add support for Ux500 to the cpufreq-dt driver and drop the
obsolete dbx500 cpufreq driver (Linus Walleij, Arnd Bergmann).
- Add new SoC (R8A7795) support to the cpufreq rcar driver (Khiem
Nguyen).
- Fix and clean up assorted issues in the cpufreq drivers and core
(Arvind Yadav, Christophe Jaillet, Colin Ian King, Gustavo Silva,
Julia Lawall, Leonard Crestez, Rob Herring, Sudeep Holla).
- Update the IO-wait boost handling in the schedutil governor to make
it less aggressive (Joel Fernandes).
- Rework system suspend diagnostics to make it print fewer messages
to the kernel log by default, add a sysfs knob to allow more
suspend-related messages to be printed and add Low Power S0 Idle
constraints checks to the ACPI suspend-to-idle code (Rafael
Wysocki, Srinivas Pandruvada).
- Prefer suspend-to-idle over S3 on ACPI-based systems with the
ACPI_FADT_LOW_POWER_S0 flag set and the Low Power Idle S0 _DSM
interface present in the ACPI tables (Rafael Wysocki).
- Update documentation related to system sleep and rename a number of
items in the code to make it cleare that they are related to
suspend-to-idle (Rafael Wysocki).
- Export a variable allowing device drivers to check the target
system sleep state from the core system suspend code (Florian
Fainelli).
- Clean up the cpuidle subsystem to handle the polling state on x86
in a more straightforward way and to use %pOF instead of full_name
(Rafael Wysocki, Rob Herring).
- Update the devfreq framework to fix and clean up a few minor issues
(Chanwoo Choi, Rob Herring).
- Extend diagnostics in the generic power domains (genpd) framework
and clean it up slightly (Thara Gopinath, Rob Herring).
- Fix and clean up a couple of issues in the operating performance
points (OPP) framework (Viresh Kumar, Waldemar Rymarkiewicz).
- Add support for RV1108 to the rockchip-io Adaptive Voltage Scaling
(AVS) driver (David Wu).
- Fix the usage of notifiers in CPU power management on some
platforms (Alex Shi).
- Update the pm-graph system suspend/hibernation and boot profiling
utility (Todd Brandt).
- Make it possible to run the cpupower utility without CPU0 (Prarit
Bhargava)"
* tag 'pm-4.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (87 commits)
cpuidle: Make drivers initialize polling state
cpuidle: Move polling state initialization code to separate file
cpuidle: Eliminate the CPUIDLE_DRIVER_STATE_START symbol
cpufreq: imx6q: Fix imx6sx low frequency support
cpufreq: speedstep-lib: make several arrays static, makes code smaller
PM: docs: Delete the obsolete states.txt document
PM: docs: Describe high-level PM strategies and sleep states
PM / devfreq: Fix memory leak when fail to register device
PM / devfreq: Add dependency on PM_OPP
PM / devfreq: Move private devfreq_update_stats() into devfreq
PM / devfreq: Convert to using %pOF instead of full_name
PM / AVS: rockchip-io: add io selectors and supplies for RV1108
cpufreq: ti: Fix 'of_node_put' being called twice in error handling path
cpufreq: dt-platdev: Drop few entries from whitelist
cpufreq: dt-platdev: Automatically create cpufreq device with OPP v2
ARM: ux500: don't select CPUFREQ_DT
cpuidle: Convert to using %pOF instead of full_name
cpufreq: Convert to using %pOF instead of full_name
PM / Domains: Convert to using %pOF instead of full_name
cpufreq: Cap the default transition delay value to 10 ms
...
2017-09-05 19:19:08 +00:00
|
|
|
struct rq *rq = rq_of(cfs_rq);
|
|
|
|
|
|
|
|
if (&rq->cfs == cfs_rq) {
|
2017-05-24 05:29:52 +00:00
|
|
|
/*
|
|
|
|
* There are a few boundary cases this might miss but it should
|
|
|
|
* get called often enough that that should (hopefully) not be
|
2017-12-15 15:39:43 +00:00
|
|
|
* a real problem.
|
2017-05-24 05:29:52 +00:00
|
|
|
*
|
|
|
|
* It will not get called when we go idle, because the idle
|
|
|
|
* thread is a different class (!fair), nor will the utilization
|
|
|
|
* number include things like RT tasks.
|
|
|
|
*
|
|
|
|
* As is, the util number is not freq-invariant (we'd have to
|
|
|
|
* implement arch_scale_freq_capacity() for that).
|
|
|
|
*
|
|
|
|
* See cpu_util().
|
|
|
|
*/
|
Power management updates for v4.14-rc1
- Drop the P-state selection algorithm based on a PID controller
from intel_pstate and make it use the same P-state selection
method (based on the CPU load) for all types of systems in the
active mode (Rafael Wysocki, Srinivas Pandruvada).
- Rework the cpufreq core and governors to make it possible to
take cross-CPU utilization updates into account and modify the
schedutil governor to actually do so (Viresh Kumar).
- Clean up the handling of transition latency information in the
cpufreq core and untangle it from the information on which drivers
cannot do dynamic frequency switching (Viresh Kumar).
- Add support for new SoCs (MT2701/MT7623 and MT7622) to the
mediatek cpufreq driver and update its DT bindings (Sean Wang).
- Modify the cpufreq dt-platdev driver to autimatically create
cpufreq devices for the new (v2) Operating Performance Points
(OPP) DT bindings and update its whitelist of supported systems
(Viresh Kumar, Shubhrajyoti Datta, Marc Gonzalez, Khiem Nguyen,
Finley Xiao).
- Add support for Ux500 to the cpufreq-dt driver and drop the
obsolete dbx500 cpufreq driver (Linus Walleij, Arnd Bergmann).
- Add new SoC (R8A7795) support to the cpufreq rcar driver (Khiem
Nguyen).
- Fix and clean up assorted issues in the cpufreq drivers and core
(Arvind Yadav, Christophe Jaillet, Colin Ian King, Gustavo Silva,
Julia Lawall, Leonard Crestez, Rob Herring, Sudeep Holla).
- Update the IO-wait boost handling in the schedutil governor to
make it less aggressive (Joel Fernandes).
- Rework system suspend diagnostics to make it print fewer messages
to the kernel log by default, add a sysfs knob to allow more
suspend-related messages to be printed and add Low Power S0 Idle
constraints checks to the ACPI suspend-to-idle code (Rafael
Wysocki, Srinivas Pandruvada).
- Prefer suspend-to-idle over S3 on ACPI-based systems with the
ACPI_FADT_LOW_POWER_S0 flag set and the Low Power Idle S0 _DSM
interface present in the ACPI tables (Rafael Wysocki).
- Update documentation related to system sleep and rename a number
of items in the code to make it cleare that they are related to
suspend-to-idle (Rafael Wysocki).
- Export a variable allowing device drivers to check the target
system sleep state from the core system suspend code (Florian
Fainelli).
- Clean up the cpuidle subsystem to handle the polling state on
x86 in a more straightforward way and to use %pOF instead of
full_name (Rafael Wysocki, Rob Herring).
- Update the devfreq framework to fix and clean up a few minor
issues (Chanwoo Choi, Rob Herring).
- Extend diagnostics in the generic power domains (genpd) framework
and clean it up slightly (Thara Gopinath, Rob Herring).
- Fix and clean up a couple of issues in the operating performance
points (OPP) framework (Viresh Kumar, Waldemar Rymarkiewicz).
- Add support for RV1108 to the rockchip-io Adaptive Voltage Scaling
(AVS) driver (David Wu).
- Fix the usage of notifiers in CPU power management on some
platforms (Alex Shi).
- Update the pm-graph system suspend/hibernation and boot profiling
utility (Todd Brandt).
- Make it possible to run the cpupower utility without CPU0 (Prarit
Bhargava).
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
iQIcBAABCAAGBQJZrcDJAAoJEILEb/54YlRx9FUQAIUKvWBAARc61ZIZXjbqZF1v
aEMOBuksFns0CMekdptSic6n4wc81E/XYMS8yDhOOMpyDzfAZsTWjmu+gKwN7w3l
E/yf/NVlhob9JZ7MqGgqD4EUFfFIaKBXPlWFdDi2rdCUXE2L8xJ7rla8i7zyZlc5
pYHfAppBbF4qUcEY4OoOVOOGRZCfMdiLXj0iZOhMX8Y6yLBRk/AjnVADYsF33hoj
gBEfomU+H0K5V8nQEp0ZFKDArPwL+oElHQj6i+nxBpGfPM5evvLXhHOyR6AsldJ5
J4YI1kMuQNSCmvHMqOTxTYyJf8Jcf3Fj4wcjwaVMVGceY1lz6McAKknnFnCqCvz+
mskn84gFCBCM8EoJDqRf0b9MQHcuRyQKM+yw4tjnR9r8yd32erb85ZWFHcPWYhCT
fZatNOwFFv2MU+2vo5J3yeUNSWIKT+uBjy+tKPbrDkUwpKZVRj3Oj+hP3Mq9NE8U
YBqltsj7tmrdA634zI8C7jfS6wF221S0fId/iPszwmPJaVn/lq8Ror7pWL5YI8U7
SCJFjiqDiGmAcQEkuWwFAQnscZkyHpO+Y3A+jfXl/izoaZETaI5+ceIHBaocm3+5
XrOOpHS3ik8EHf9ji0KFCKZ/pYDwllday3cBQPWo3sMIzpQ2lrjbqdnE1cVnBrld
OtHZAeD/jLUXuY6XW2jN
=mAiV
-----END PGP SIGNATURE-----
Merge tag 'pm-4.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
Pull power management updates from Rafael Wysocki:
"This time (again) cpufreq gets the majority of changes which mostly
are driver updates (including a major consolidation of intel_pstate),
some schedutil governor modifications and core cleanups.
There also are some changes in the system suspend area, mostly related
to diagnostics and debug messages plus some renames of things related
to suspend-to-idle. One major change here is that suspend-to-idle is
now going to be preferred over S3 on systems where the ACPI tables
indicate to do so and provide requsite support (the Low Power Idle S0
_DSM in particular). The system sleep documentation and the tools
related to it are updated too.
The rest is a few cpuidle changes (nothing major), devfreq updates,
generic power domains (genpd) framework updates and a few assorted
modifications elsewhere.
Specifics:
- Drop the P-state selection algorithm based on a PID controller from
intel_pstate and make it use the same P-state selection method
(based on the CPU load) for all types of systems in the active mode
(Rafael Wysocki, Srinivas Pandruvada).
- Rework the cpufreq core and governors to make it possible to take
cross-CPU utilization updates into account and modify the schedutil
governor to actually do so (Viresh Kumar).
- Clean up the handling of transition latency information in the
cpufreq core and untangle it from the information on which drivers
cannot do dynamic frequency switching (Viresh Kumar).
- Add support for new SoCs (MT2701/MT7623 and MT7622) to the mediatek
cpufreq driver and update its DT bindings (Sean Wang).
- Modify the cpufreq dt-platdev driver to autimatically create
cpufreq devices for the new (v2) Operating Performance Points (OPP)
DT bindings and update its whitelist of supported systems (Viresh
Kumar, Shubhrajyoti Datta, Marc Gonzalez, Khiem Nguyen, Finley
Xiao).
- Add support for Ux500 to the cpufreq-dt driver and drop the
obsolete dbx500 cpufreq driver (Linus Walleij, Arnd Bergmann).
- Add new SoC (R8A7795) support to the cpufreq rcar driver (Khiem
Nguyen).
- Fix and clean up assorted issues in the cpufreq drivers and core
(Arvind Yadav, Christophe Jaillet, Colin Ian King, Gustavo Silva,
Julia Lawall, Leonard Crestez, Rob Herring, Sudeep Holla).
- Update the IO-wait boost handling in the schedutil governor to make
it less aggressive (Joel Fernandes).
- Rework system suspend diagnostics to make it print fewer messages
to the kernel log by default, add a sysfs knob to allow more
suspend-related messages to be printed and add Low Power S0 Idle
constraints checks to the ACPI suspend-to-idle code (Rafael
Wysocki, Srinivas Pandruvada).
- Prefer suspend-to-idle over S3 on ACPI-based systems with the
ACPI_FADT_LOW_POWER_S0 flag set and the Low Power Idle S0 _DSM
interface present in the ACPI tables (Rafael Wysocki).
- Update documentation related to system sleep and rename a number of
items in the code to make it cleare that they are related to
suspend-to-idle (Rafael Wysocki).
- Export a variable allowing device drivers to check the target
system sleep state from the core system suspend code (Florian
Fainelli).
- Clean up the cpuidle subsystem to handle the polling state on x86
in a more straightforward way and to use %pOF instead of full_name
(Rafael Wysocki, Rob Herring).
- Update the devfreq framework to fix and clean up a few minor issues
(Chanwoo Choi, Rob Herring).
- Extend diagnostics in the generic power domains (genpd) framework
and clean it up slightly (Thara Gopinath, Rob Herring).
- Fix and clean up a couple of issues in the operating performance
points (OPP) framework (Viresh Kumar, Waldemar Rymarkiewicz).
- Add support for RV1108 to the rockchip-io Adaptive Voltage Scaling
(AVS) driver (David Wu).
- Fix the usage of notifiers in CPU power management on some
platforms (Alex Shi).
- Update the pm-graph system suspend/hibernation and boot profiling
utility (Todd Brandt).
- Make it possible to run the cpupower utility without CPU0 (Prarit
Bhargava)"
* tag 'pm-4.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (87 commits)
cpuidle: Make drivers initialize polling state
cpuidle: Move polling state initialization code to separate file
cpuidle: Eliminate the CPUIDLE_DRIVER_STATE_START symbol
cpufreq: imx6q: Fix imx6sx low frequency support
cpufreq: speedstep-lib: make several arrays static, makes code smaller
PM: docs: Delete the obsolete states.txt document
PM: docs: Describe high-level PM strategies and sleep states
PM / devfreq: Fix memory leak when fail to register device
PM / devfreq: Add dependency on PM_OPP
PM / devfreq: Move private devfreq_update_stats() into devfreq
PM / devfreq: Convert to using %pOF instead of full_name
PM / AVS: rockchip-io: add io selectors and supplies for RV1108
cpufreq: ti: Fix 'of_node_put' being called twice in error handling path
cpufreq: dt-platdev: Drop few entries from whitelist
cpufreq: dt-platdev: Automatically create cpufreq device with OPP v2
ARM: ux500: don't select CPUFREQ_DT
cpuidle: Convert to using %pOF instead of full_name
cpufreq: Convert to using %pOF instead of full_name
PM / Domains: Convert to using %pOF instead of full_name
cpufreq: Cap the default transition delay value to 10 ms
...
2017-09-05 19:19:08 +00:00
|
|
|
cpufreq_update_util(rq, 0);
|
2017-05-24 05:29:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-26 05:05:39 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2012-10-04 11:18:29 +00:00
|
|
|
/*
|
|
|
|
* Approximate:
|
|
|
|
* val * y^n, where y^32 ~= 0.5 (~1 scheduling period)
|
|
|
|
*/
|
2017-02-12 21:44:23 +00:00
|
|
|
static u64 decay_load(u64 val, u64 n)
|
2012-10-04 11:18:29 +00:00
|
|
|
{
|
sched: Make __update_entity_runnable_avg() fast
__update_entity_runnable_avg forms the core of maintaining an entity's runnable
load average. In this function we charge the accumulated run-time since last
update and handle appropriate decay. In some cases, e.g. a waking task, this
time interval may be much larger than our period unit.
Fortunately we can exploit some properties of our series to perform decay for a
blocked update in constant time and account the contribution for a running
update in essentially-constant* time.
[*]: For any running entity they should be performing updates at the tick which
gives us a soft limit of 1 jiffy between updates, and we can compute up to a
32 jiffy update in a single pass.
C program to generate the magic constants in the arrays:
#include <math.h>
#include <stdio.h>
#define N 32
#define WMULT_SHIFT 32
const long WMULT_CONST = ((1UL << N) - 1);
double y;
long runnable_avg_yN_inv[N];
void calc_mult_inv() {
int i;
double yn = 0;
printf("inverses\n");
for (i = 0; i < N; i++) {
yn = (double)WMULT_CONST * pow(y, i);
runnable_avg_yN_inv[i] = yn;
printf("%2d: 0x%8lx\n", i, runnable_avg_yN_inv[i]);
}
printf("\n");
}
long mult_inv(long c, int n) {
return (c * runnable_avg_yN_inv[n]) >> WMULT_SHIFT;
}
void calc_yn_sum(int n)
{
int i;
double sum = 0, sum_fl = 0, diff = 0;
/*
* We take the floored sum to ensure the sum of partial sums is never
* larger than the actual sum.
*/
printf("sum y^n\n");
printf(" %8s %8s %8s\n", "exact", "floor", "error");
for (i = 1; i <= n; i++) {
sum = (y * sum + y * 1024);
sum_fl = floor(y * sum_fl+ y * 1024);
printf("%2d: %8.0f %8.0f %8.0f\n", i, sum, sum_fl,
sum_fl - sum);
}
printf("\n");
}
void calc_conv(long n) {
long old_n;
int i = -1;
printf("convergence (LOAD_AVG_MAX, LOAD_AVG_MAX_N)\n");
do {
old_n = n;
n = mult_inv(n, 1) + 1024;
i++;
} while (n != old_n);
printf("%d> %ld\n", i - 1, n);
printf("\n");
}
void main() {
y = pow(0.5, 1/(double)N);
calc_mult_inv();
calc_conv(1024);
calc_yn_sum(N);
}
[ Compile with -lm ]
Signed-off-by: Paul Turner <pjt@google.com>
Reviewed-by: Ben Segall <bsegall@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20120823141507.277808946@google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2012-10-04 11:18:32 +00:00
|
|
|
unsigned int local_n;
|
|
|
|
|
2017-03-31 08:51:41 +00:00
|
|
|
if (unlikely(n > LOAD_AVG_PERIOD * 63))
|
sched: Make __update_entity_runnable_avg() fast
__update_entity_runnable_avg forms the core of maintaining an entity's runnable
load average. In this function we charge the accumulated run-time since last
update and handle appropriate decay. In some cases, e.g. a waking task, this
time interval may be much larger than our period unit.
Fortunately we can exploit some properties of our series to perform decay for a
blocked update in constant time and account the contribution for a running
update in essentially-constant* time.
[*]: For any running entity they should be performing updates at the tick which
gives us a soft limit of 1 jiffy between updates, and we can compute up to a
32 jiffy update in a single pass.
C program to generate the magic constants in the arrays:
#include <math.h>
#include <stdio.h>
#define N 32
#define WMULT_SHIFT 32
const long WMULT_CONST = ((1UL << N) - 1);
double y;
long runnable_avg_yN_inv[N];
void calc_mult_inv() {
int i;
double yn = 0;
printf("inverses\n");
for (i = 0; i < N; i++) {
yn = (double)WMULT_CONST * pow(y, i);
runnable_avg_yN_inv[i] = yn;
printf("%2d: 0x%8lx\n", i, runnable_avg_yN_inv[i]);
}
printf("\n");
}
long mult_inv(long c, int n) {
return (c * runnable_avg_yN_inv[n]) >> WMULT_SHIFT;
}
void calc_yn_sum(int n)
{
int i;
double sum = 0, sum_fl = 0, diff = 0;
/*
* We take the floored sum to ensure the sum of partial sums is never
* larger than the actual sum.
*/
printf("sum y^n\n");
printf(" %8s %8s %8s\n", "exact", "floor", "error");
for (i = 1; i <= n; i++) {
sum = (y * sum + y * 1024);
sum_fl = floor(y * sum_fl+ y * 1024);
printf("%2d: %8.0f %8.0f %8.0f\n", i, sum, sum_fl,
sum_fl - sum);
}
printf("\n");
}
void calc_conv(long n) {
long old_n;
int i = -1;
printf("convergence (LOAD_AVG_MAX, LOAD_AVG_MAX_N)\n");
do {
old_n = n;
n = mult_inv(n, 1) + 1024;
i++;
} while (n != old_n);
printf("%d> %ld\n", i - 1, n);
printf("\n");
}
void main() {
y = pow(0.5, 1/(double)N);
calc_mult_inv();
calc_conv(1024);
calc_yn_sum(N);
}
[ Compile with -lm ]
Signed-off-by: Paul Turner <pjt@google.com>
Reviewed-by: Ben Segall <bsegall@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20120823141507.277808946@google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2012-10-04 11:18:32 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* after bounds checking we can collapse to 32-bit */
|
|
|
|
local_n = n;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* As y^PERIOD = 1/2, we can combine
|
2014-09-21 01:24:36 +00:00
|
|
|
* y^n = 1/2^(n/PERIOD) * y^(n%PERIOD)
|
|
|
|
* With a look-up table which covers y^n (n<PERIOD)
|
sched: Make __update_entity_runnable_avg() fast
__update_entity_runnable_avg forms the core of maintaining an entity's runnable
load average. In this function we charge the accumulated run-time since last
update and handle appropriate decay. In some cases, e.g. a waking task, this
time interval may be much larger than our period unit.
Fortunately we can exploit some properties of our series to perform decay for a
blocked update in constant time and account the contribution for a running
update in essentially-constant* time.
[*]: For any running entity they should be performing updates at the tick which
gives us a soft limit of 1 jiffy between updates, and we can compute up to a
32 jiffy update in a single pass.
C program to generate the magic constants in the arrays:
#include <math.h>
#include <stdio.h>
#define N 32
#define WMULT_SHIFT 32
const long WMULT_CONST = ((1UL << N) - 1);
double y;
long runnable_avg_yN_inv[N];
void calc_mult_inv() {
int i;
double yn = 0;
printf("inverses\n");
for (i = 0; i < N; i++) {
yn = (double)WMULT_CONST * pow(y, i);
runnable_avg_yN_inv[i] = yn;
printf("%2d: 0x%8lx\n", i, runnable_avg_yN_inv[i]);
}
printf("\n");
}
long mult_inv(long c, int n) {
return (c * runnable_avg_yN_inv[n]) >> WMULT_SHIFT;
}
void calc_yn_sum(int n)
{
int i;
double sum = 0, sum_fl = 0, diff = 0;
/*
* We take the floored sum to ensure the sum of partial sums is never
* larger than the actual sum.
*/
printf("sum y^n\n");
printf(" %8s %8s %8s\n", "exact", "floor", "error");
for (i = 1; i <= n; i++) {
sum = (y * sum + y * 1024);
sum_fl = floor(y * sum_fl+ y * 1024);
printf("%2d: %8.0f %8.0f %8.0f\n", i, sum, sum_fl,
sum_fl - sum);
}
printf("\n");
}
void calc_conv(long n) {
long old_n;
int i = -1;
printf("convergence (LOAD_AVG_MAX, LOAD_AVG_MAX_N)\n");
do {
old_n = n;
n = mult_inv(n, 1) + 1024;
i++;
} while (n != old_n);
printf("%d> %ld\n", i - 1, n);
printf("\n");
}
void main() {
y = pow(0.5, 1/(double)N);
calc_mult_inv();
calc_conv(1024);
calc_yn_sum(N);
}
[ Compile with -lm ]
Signed-off-by: Paul Turner <pjt@google.com>
Reviewed-by: Ben Segall <bsegall@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20120823141507.277808946@google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2012-10-04 11:18:32 +00:00
|
|
|
*
|
|
|
|
* To achieve constant time decay_load.
|
|
|
|
*/
|
|
|
|
if (unlikely(local_n >= LOAD_AVG_PERIOD)) {
|
|
|
|
val >>= local_n / LOAD_AVG_PERIOD;
|
|
|
|
local_n %= LOAD_AVG_PERIOD;
|
2012-10-04 11:18:29 +00:00
|
|
|
}
|
|
|
|
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
val = mul_u64_u32_shr(val, runnable_avg_yN_inv[local_n], 32);
|
|
|
|
return val;
|
sched: Make __update_entity_runnable_avg() fast
__update_entity_runnable_avg forms the core of maintaining an entity's runnable
load average. In this function we charge the accumulated run-time since last
update and handle appropriate decay. In some cases, e.g. a waking task, this
time interval may be much larger than our period unit.
Fortunately we can exploit some properties of our series to perform decay for a
blocked update in constant time and account the contribution for a running
update in essentially-constant* time.
[*]: For any running entity they should be performing updates at the tick which
gives us a soft limit of 1 jiffy between updates, and we can compute up to a
32 jiffy update in a single pass.
C program to generate the magic constants in the arrays:
#include <math.h>
#include <stdio.h>
#define N 32
#define WMULT_SHIFT 32
const long WMULT_CONST = ((1UL << N) - 1);
double y;
long runnable_avg_yN_inv[N];
void calc_mult_inv() {
int i;
double yn = 0;
printf("inverses\n");
for (i = 0; i < N; i++) {
yn = (double)WMULT_CONST * pow(y, i);
runnable_avg_yN_inv[i] = yn;
printf("%2d: 0x%8lx\n", i, runnable_avg_yN_inv[i]);
}
printf("\n");
}
long mult_inv(long c, int n) {
return (c * runnable_avg_yN_inv[n]) >> WMULT_SHIFT;
}
void calc_yn_sum(int n)
{
int i;
double sum = 0, sum_fl = 0, diff = 0;
/*
* We take the floored sum to ensure the sum of partial sums is never
* larger than the actual sum.
*/
printf("sum y^n\n");
printf(" %8s %8s %8s\n", "exact", "floor", "error");
for (i = 1; i <= n; i++) {
sum = (y * sum + y * 1024);
sum_fl = floor(y * sum_fl+ y * 1024);
printf("%2d: %8.0f %8.0f %8.0f\n", i, sum, sum_fl,
sum_fl - sum);
}
printf("\n");
}
void calc_conv(long n) {
long old_n;
int i = -1;
printf("convergence (LOAD_AVG_MAX, LOAD_AVG_MAX_N)\n");
do {
old_n = n;
n = mult_inv(n, 1) + 1024;
i++;
} while (n != old_n);
printf("%d> %ld\n", i - 1, n);
printf("\n");
}
void main() {
y = pow(0.5, 1/(double)N);
calc_mult_inv();
calc_conv(1024);
calc_yn_sum(N);
}
[ Compile with -lm ]
Signed-off-by: Paul Turner <pjt@google.com>
Reviewed-by: Ben Segall <bsegall@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20120823141507.277808946@google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2012-10-04 11:18:32 +00:00
|
|
|
}
|
|
|
|
|
2017-03-31 08:51:41 +00:00
|
|
|
static u32 __accumulate_pelt_segments(u64 periods, u32 d1, u32 d3)
|
sched: Make __update_entity_runnable_avg() fast
__update_entity_runnable_avg forms the core of maintaining an entity's runnable
load average. In this function we charge the accumulated run-time since last
update and handle appropriate decay. In some cases, e.g. a waking task, this
time interval may be much larger than our period unit.
Fortunately we can exploit some properties of our series to perform decay for a
blocked update in constant time and account the contribution for a running
update in essentially-constant* time.
[*]: For any running entity they should be performing updates at the tick which
gives us a soft limit of 1 jiffy between updates, and we can compute up to a
32 jiffy update in a single pass.
C program to generate the magic constants in the arrays:
#include <math.h>
#include <stdio.h>
#define N 32
#define WMULT_SHIFT 32
const long WMULT_CONST = ((1UL << N) - 1);
double y;
long runnable_avg_yN_inv[N];
void calc_mult_inv() {
int i;
double yn = 0;
printf("inverses\n");
for (i = 0; i < N; i++) {
yn = (double)WMULT_CONST * pow(y, i);
runnable_avg_yN_inv[i] = yn;
printf("%2d: 0x%8lx\n", i, runnable_avg_yN_inv[i]);
}
printf("\n");
}
long mult_inv(long c, int n) {
return (c * runnable_avg_yN_inv[n]) >> WMULT_SHIFT;
}
void calc_yn_sum(int n)
{
int i;
double sum = 0, sum_fl = 0, diff = 0;
/*
* We take the floored sum to ensure the sum of partial sums is never
* larger than the actual sum.
*/
printf("sum y^n\n");
printf(" %8s %8s %8s\n", "exact", "floor", "error");
for (i = 1; i <= n; i++) {
sum = (y * sum + y * 1024);
sum_fl = floor(y * sum_fl+ y * 1024);
printf("%2d: %8.0f %8.0f %8.0f\n", i, sum, sum_fl,
sum_fl - sum);
}
printf("\n");
}
void calc_conv(long n) {
long old_n;
int i = -1;
printf("convergence (LOAD_AVG_MAX, LOAD_AVG_MAX_N)\n");
do {
old_n = n;
n = mult_inv(n, 1) + 1024;
i++;
} while (n != old_n);
printf("%d> %ld\n", i - 1, n);
printf("\n");
}
void main() {
y = pow(0.5, 1/(double)N);
calc_mult_inv();
calc_conv(1024);
calc_yn_sum(N);
}
[ Compile with -lm ]
Signed-off-by: Paul Turner <pjt@google.com>
Reviewed-by: Ben Segall <bsegall@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20120823141507.277808946@google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2012-10-04 11:18:32 +00:00
|
|
|
{
|
2017-03-31 08:51:41 +00:00
|
|
|
u32 c1, c2, c3 = d3; /* y^0 == 1 */
|
sched: Make __update_entity_runnable_avg() fast
__update_entity_runnable_avg forms the core of maintaining an entity's runnable
load average. In this function we charge the accumulated run-time since last
update and handle appropriate decay. In some cases, e.g. a waking task, this
time interval may be much larger than our period unit.
Fortunately we can exploit some properties of our series to perform decay for a
blocked update in constant time and account the contribution for a running
update in essentially-constant* time.
[*]: For any running entity they should be performing updates at the tick which
gives us a soft limit of 1 jiffy between updates, and we can compute up to a
32 jiffy update in a single pass.
C program to generate the magic constants in the arrays:
#include <math.h>
#include <stdio.h>
#define N 32
#define WMULT_SHIFT 32
const long WMULT_CONST = ((1UL << N) - 1);
double y;
long runnable_avg_yN_inv[N];
void calc_mult_inv() {
int i;
double yn = 0;
printf("inverses\n");
for (i = 0; i < N; i++) {
yn = (double)WMULT_CONST * pow(y, i);
runnable_avg_yN_inv[i] = yn;
printf("%2d: 0x%8lx\n", i, runnable_avg_yN_inv[i]);
}
printf("\n");
}
long mult_inv(long c, int n) {
return (c * runnable_avg_yN_inv[n]) >> WMULT_SHIFT;
}
void calc_yn_sum(int n)
{
int i;
double sum = 0, sum_fl = 0, diff = 0;
/*
* We take the floored sum to ensure the sum of partial sums is never
* larger than the actual sum.
*/
printf("sum y^n\n");
printf(" %8s %8s %8s\n", "exact", "floor", "error");
for (i = 1; i <= n; i++) {
sum = (y * sum + y * 1024);
sum_fl = floor(y * sum_fl+ y * 1024);
printf("%2d: %8.0f %8.0f %8.0f\n", i, sum, sum_fl,
sum_fl - sum);
}
printf("\n");
}
void calc_conv(long n) {
long old_n;
int i = -1;
printf("convergence (LOAD_AVG_MAX, LOAD_AVG_MAX_N)\n");
do {
old_n = n;
n = mult_inv(n, 1) + 1024;
i++;
} while (n != old_n);
printf("%d> %ld\n", i - 1, n);
printf("\n");
}
void main() {
y = pow(0.5, 1/(double)N);
calc_mult_inv();
calc_conv(1024);
calc_yn_sum(N);
}
[ Compile with -lm ]
Signed-off-by: Paul Turner <pjt@google.com>
Reviewed-by: Ben Segall <bsegall@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20120823141507.277808946@google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2012-10-04 11:18:32 +00:00
|
|
|
|
2017-02-12 21:44:23 +00:00
|
|
|
/*
|
2017-04-10 10:47:33 +00:00
|
|
|
* c1 = d1 y^p
|
2017-02-12 21:44:23 +00:00
|
|
|
*/
|
2017-03-31 08:51:41 +00:00
|
|
|
c1 = decay_load((u64)d1, periods);
|
2017-02-12 21:44:23 +00:00
|
|
|
|
|
|
|
/*
|
2017-04-10 10:47:33 +00:00
|
|
|
* p-1
|
2017-03-31 08:51:41 +00:00
|
|
|
* c2 = 1024 \Sum y^n
|
|
|
|
* n=1
|
2017-02-12 21:44:23 +00:00
|
|
|
*
|
2017-03-31 08:51:41 +00:00
|
|
|
* inf inf
|
|
|
|
* = 1024 ( \Sum y^n - \Sum y^n - y^0 )
|
2017-04-10 10:47:33 +00:00
|
|
|
* n=0 n=p
|
2017-02-12 21:44:23 +00:00
|
|
|
*/
|
2017-03-31 08:51:41 +00:00
|
|
|
c2 = LOAD_AVG_MAX - decay_load(LOAD_AVG_MAX, periods) - 1024;
|
2017-02-12 21:44:23 +00:00
|
|
|
|
|
|
|
return c1 + c2 + c3;
|
2012-10-04 11:18:29 +00:00
|
|
|
}
|
|
|
|
|
2017-02-12 21:44:23 +00:00
|
|
|
/*
|
|
|
|
* Accumulate the three separate parts of the sum; d1 the remainder
|
|
|
|
* of the last (incomplete) period, d2 the span of full periods and d3
|
|
|
|
* the remainder of the (incomplete) current period.
|
|
|
|
*
|
|
|
|
* d1 d2 d3
|
|
|
|
* ^ ^ ^
|
|
|
|
* | | |
|
|
|
|
* |<->|<----------------->|<--->|
|
|
|
|
* ... |---x---|------| ... |------|-----x (now)
|
|
|
|
*
|
2017-04-10 10:47:33 +00:00
|
|
|
* p-1
|
|
|
|
* u' = (u + d1) y^p + 1024 \Sum y^n + d3 y^0
|
|
|
|
* n=1
|
2017-02-12 21:44:23 +00:00
|
|
|
*
|
2017-04-10 10:47:33 +00:00
|
|
|
* = u y^p + (Step 1)
|
2017-02-12 21:44:23 +00:00
|
|
|
*
|
2017-04-10 10:47:33 +00:00
|
|
|
* p-1
|
|
|
|
* d1 y^p + 1024 \Sum y^n + d3 y^0 (Step 2)
|
|
|
|
* n=1
|
2017-02-12 21:44:23 +00:00
|
|
|
*/
|
|
|
|
static __always_inline u32
|
|
|
|
accumulate_sum(u64 delta, int cpu, struct sched_avg *sa,
|
2017-05-06 13:59:54 +00:00
|
|
|
unsigned long load, unsigned long runnable, int running)
|
2017-02-12 21:44:23 +00:00
|
|
|
{
|
|
|
|
unsigned long scale_freq, scale_cpu;
|
2017-03-31 08:51:41 +00:00
|
|
|
u32 contrib = (u32)delta; /* p == 0 -> delta < 1024 */
|
2017-02-12 21:44:23 +00:00
|
|
|
u64 periods;
|
|
|
|
|
2017-12-04 10:23:23 +00:00
|
|
|
scale_freq = arch_scale_freq_capacity(cpu);
|
2017-02-12 21:44:23 +00:00
|
|
|
scale_cpu = arch_scale_cpu_capacity(NULL, cpu);
|
|
|
|
|
|
|
|
delta += sa->period_contrib;
|
|
|
|
periods = delta / 1024; /* A period is 1024us (~1ms) */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Step 1: decay old *_sum if we crossed period boundaries.
|
|
|
|
*/
|
|
|
|
if (periods) {
|
|
|
|
sa->load_sum = decay_load(sa->load_sum, periods);
|
2017-05-06 13:59:54 +00:00
|
|
|
sa->runnable_load_sum =
|
|
|
|
decay_load(sa->runnable_load_sum, periods);
|
2017-02-12 21:44:23 +00:00
|
|
|
sa->util_sum = decay_load((u64)(sa->util_sum), periods);
|
|
|
|
|
2017-03-31 08:51:41 +00:00
|
|
|
/*
|
|
|
|
* Step 2
|
|
|
|
*/
|
|
|
|
delta %= 1024;
|
|
|
|
contrib = __accumulate_pelt_segments(periods,
|
|
|
|
1024 - sa->period_contrib, delta);
|
|
|
|
}
|
2017-02-12 21:44:23 +00:00
|
|
|
sa->period_contrib = delta;
|
|
|
|
|
|
|
|
contrib = cap_scale(contrib, scale_freq);
|
2017-05-06 13:59:54 +00:00
|
|
|
if (load)
|
|
|
|
sa->load_sum += load * contrib;
|
|
|
|
if (runnable)
|
|
|
|
sa->runnable_load_sum += runnable * contrib;
|
2017-02-12 21:44:23 +00:00
|
|
|
if (running)
|
|
|
|
sa->util_sum += contrib * scale_cpu;
|
|
|
|
|
|
|
|
return periods;
|
|
|
|
}
|
|
|
|
|
2012-10-04 11:18:29 +00:00
|
|
|
/*
|
|
|
|
* We can represent the historical contribution to runnable average as the
|
|
|
|
* coefficients of a geometric series. To do this we sub-divide our runnable
|
|
|
|
* history into segments of approximately 1ms (1024us); label the segment that
|
|
|
|
* occurred N-ms ago p_N, with p_0 corresponding to the current period, e.g.
|
|
|
|
*
|
|
|
|
* [<- 1024us ->|<- 1024us ->|<- 1024us ->| ...
|
|
|
|
* p0 p1 p2
|
|
|
|
* (now) (~1ms ago) (~2ms ago)
|
|
|
|
*
|
|
|
|
* Let u_i denote the fraction of p_i that the entity was runnable.
|
|
|
|
*
|
|
|
|
* We then designate the fractions u_i as our co-efficients, yielding the
|
|
|
|
* following representation of historical load:
|
|
|
|
* u_0 + u_1*y + u_2*y^2 + u_3*y^3 + ...
|
|
|
|
*
|
|
|
|
* We choose y based on the with of a reasonably scheduling period, fixing:
|
|
|
|
* y^32 = 0.5
|
|
|
|
*
|
|
|
|
* This means that the contribution to load ~32ms ago (u_32) will be weighted
|
|
|
|
* approximately half as much as the contribution to load within the last ms
|
|
|
|
* (u_0).
|
|
|
|
*
|
|
|
|
* When a period "rolls over" and we have new u_0`, multiplying the previous
|
|
|
|
* sum again by y is sufficient to update:
|
|
|
|
* load_avg = u_0` + y*(u_0 + u_1*y + u_2*y^2 + ... )
|
|
|
|
* = u_0 + u_1*y + u_2*y^2 + ... [re-labeling u_i --> u_{i+1}]
|
|
|
|
*/
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
static __always_inline int
|
2017-05-06 14:42:08 +00:00
|
|
|
___update_load_sum(u64 now, int cpu, struct sched_avg *sa,
|
2017-05-06 13:59:54 +00:00
|
|
|
unsigned long load, unsigned long runnable, int running)
|
2012-10-04 11:18:29 +00:00
|
|
|
{
|
2017-02-12 21:44:23 +00:00
|
|
|
u64 delta;
|
2012-10-04 11:18:29 +00:00
|
|
|
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
delta = now - sa->last_update_time;
|
2012-10-04 11:18:29 +00:00
|
|
|
/*
|
|
|
|
* 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) {
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
sa->last_update_time = now;
|
2012-10-04 11:18:29 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Use 1024ns as the unit of measurement since it's a reasonable
|
|
|
|
* approximation of 1us and fast to compute.
|
|
|
|
*/
|
|
|
|
delta >>= 10;
|
|
|
|
if (!delta)
|
|
|
|
return 0;
|
2017-04-10 11:20:45 +00:00
|
|
|
|
|
|
|
sa->last_update_time += delta << 10;
|
2012-10-04 11:18:29 +00:00
|
|
|
|
2017-07-01 05:06:13 +00:00
|
|
|
/*
|
|
|
|
* running is a subset of runnable (weight) so running can't be set if
|
|
|
|
* runnable is clear. But there are some corner cases where the current
|
|
|
|
* se has been already dequeued but cfs_rq->curr still points to it.
|
|
|
|
* This means that weight will be 0 but not running for a sched_entity
|
|
|
|
* but also for a cfs_rq if the latter becomes idle. As an example,
|
|
|
|
* this happens during idle_balance() which calls
|
|
|
|
* update_blocked_averages()
|
|
|
|
*/
|
2017-05-06 13:59:54 +00:00
|
|
|
if (!load)
|
|
|
|
runnable = running = 0;
|
2017-07-01 05:06:13 +00:00
|
|
|
|
2017-02-12 21:44:23 +00:00
|
|
|
/*
|
|
|
|
* Now we know we crossed measurement unit boundaries. The *_avg
|
|
|
|
* accrues by two steps:
|
|
|
|
*
|
|
|
|
* Step 1: accumulate *_sum since last_update_time. If we haven't
|
|
|
|
* crossed period boundaries, finish.
|
|
|
|
*/
|
2017-05-06 13:59:54 +00:00
|
|
|
if (!accumulate_sum(delta, cpu, sa, load, runnable, running))
|
2017-02-12 21:44:23 +00:00
|
|
|
return 0;
|
2012-10-04 11:18:30 +00:00
|
|
|
|
2017-05-06 14:42:08 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __always_inline void
|
2017-05-06 13:59:54 +00:00
|
|
|
___update_load_avg(struct sched_avg *sa, unsigned long load, unsigned long runnable)
|
2017-05-06 14:42:08 +00:00
|
|
|
{
|
|
|
|
u32 divider = LOAD_AVG_MAX - 1024 + sa->period_contrib;
|
|
|
|
|
2017-02-12 21:44:23 +00:00
|
|
|
/*
|
|
|
|
* Step 2: update *_avg.
|
|
|
|
*/
|
2017-05-06 13:59:54 +00:00
|
|
|
sa->load_avg = div_u64(load * sa->load_sum, divider);
|
|
|
|
sa->runnable_load_avg = div_u64(runnable * sa->runnable_load_sum, divider);
|
2017-05-06 14:42:08 +00:00
|
|
|
sa->util_avg = sa->util_sum / divider;
|
|
|
|
}
|
2012-10-04 11:18:30 +00:00
|
|
|
|
2017-05-06 14:42:08 +00:00
|
|
|
/*
|
|
|
|
* sched_entity:
|
|
|
|
*
|
2017-05-06 13:59:54 +00:00
|
|
|
* task:
|
|
|
|
* se_runnable() == se_weight()
|
|
|
|
*
|
|
|
|
* group: [ see update_cfs_group() ]
|
|
|
|
* se_weight() = tg->weight * grq->load_avg / tg->load_avg
|
|
|
|
* se_runnable() = se_weight(se) * grq->runnable_load_avg / grq->load_avg
|
|
|
|
*
|
2017-05-06 14:42:08 +00:00
|
|
|
* load_sum := runnable_sum
|
|
|
|
* load_avg = se_weight(se) * runnable_avg
|
|
|
|
*
|
2017-05-06 13:59:54 +00:00
|
|
|
* runnable_load_sum := runnable_sum
|
|
|
|
* runnable_load_avg = se_runnable(se) * runnable_avg
|
|
|
|
*
|
|
|
|
* XXX collapse load_sum and runnable_load_sum
|
|
|
|
*
|
2017-05-06 14:42:08 +00:00
|
|
|
* cfq_rs:
|
|
|
|
*
|
|
|
|
* load_sum = \Sum se_weight(se) * se->avg.load_sum
|
|
|
|
* load_avg = \Sum se->avg.load_avg
|
2017-05-06 13:59:54 +00:00
|
|
|
*
|
|
|
|
* runnable_load_sum = \Sum se_runnable(se) * se->avg.runnable_load_sum
|
|
|
|
* runnable_load_avg = \Sum se->avg.runable_load_avg
|
2017-05-06 14:42:08 +00:00
|
|
|
*/
|
|
|
|
|
2017-03-28 09:08:20 +00:00
|
|
|
static int
|
|
|
|
__update_load_avg_blocked_se(u64 now, int cpu, struct sched_entity *se)
|
|
|
|
{
|
2017-05-06 13:59:54 +00:00
|
|
|
if (entity_is_task(se))
|
|
|
|
se->runnable_weight = se->load.weight;
|
|
|
|
|
|
|
|
if (___update_load_sum(now, cpu, &se->avg, 0, 0, 0)) {
|
|
|
|
___update_load_avg(&se->avg, se_weight(se), se_runnable(se));
|
2017-05-06 14:42:08 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2017-03-28 09:08:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
__update_load_avg_se(u64 now, int cpu, struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|
|
|
{
|
2017-05-06 13:59:54 +00:00
|
|
|
if (entity_is_task(se))
|
|
|
|
se->runnable_weight = se->load.weight;
|
|
|
|
|
|
|
|
if (___update_load_sum(now, cpu, &se->avg, !!se->on_rq, !!se->on_rq,
|
|
|
|
cfs_rq->curr == se)) {
|
2017-05-06 14:42:08 +00:00
|
|
|
|
2017-05-06 13:59:54 +00:00
|
|
|
___update_load_avg(&se->avg, se_weight(se), se_runnable(se));
|
2017-05-06 14:42:08 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2017-03-28 09:08:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
__update_load_avg_cfs_rq(u64 now, int cpu, struct cfs_rq *cfs_rq)
|
|
|
|
{
|
2017-05-06 14:42:08 +00:00
|
|
|
if (___update_load_sum(now, cpu, &cfs_rq->avg,
|
|
|
|
scale_load_down(cfs_rq->load.weight),
|
2017-05-06 13:59:54 +00:00
|
|
|
scale_load_down(cfs_rq->runnable_weight),
|
|
|
|
cfs_rq->curr != NULL)) {
|
|
|
|
|
|
|
|
___update_load_avg(&cfs_rq->avg, 1, 1);
|
2017-05-06 14:42:08 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2017-03-28 09:08:20 +00:00
|
|
|
}
|
|
|
|
|
2012-10-04 11:18:30 +00:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2016-07-13 08:56:25 +00:00
|
|
|
/**
|
|
|
|
* update_tg_load_avg - update the tg's load avg
|
|
|
|
* @cfs_rq: the cfs_rq whose avg changed
|
|
|
|
* @force: update regardless of how small the difference
|
|
|
|
*
|
|
|
|
* This function 'ensures': tg->load_avg := \Sum tg->cfs_rq[]->avg.load.
|
|
|
|
* However, because tg->load_avg is a global value there are performance
|
|
|
|
* considerations.
|
|
|
|
*
|
|
|
|
* In order to avoid having to look at the other cfs_rq's, we use a
|
|
|
|
* differential update where we store the last value we propagated. This in
|
|
|
|
* turn allows skipping updates if the differential is 'small'.
|
|
|
|
*
|
2017-06-23 16:55:30 +00:00
|
|
|
* Updating tg's load_avg is necessary before update_cfs_share().
|
2012-10-04 11:18:31 +00:00
|
|
|
*/
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
static inline void update_tg_load_avg(struct cfs_rq *cfs_rq, int force)
|
2012-10-04 11:18:31 +00:00
|
|
|
{
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
long delta = cfs_rq->avg.load_avg - cfs_rq->tg_load_avg_contrib;
|
2012-10-04 11:18:31 +00:00
|
|
|
|
2015-12-02 18:41:50 +00:00
|
|
|
/*
|
|
|
|
* No need to update load_avg for root_task_group as it is not used.
|
|
|
|
*/
|
|
|
|
if (cfs_rq->tg == &root_task_group)
|
|
|
|
return;
|
|
|
|
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
if (force || abs(delta) > cfs_rq->tg_load_avg_contrib / 64) {
|
|
|
|
atomic_long_add(delta, &cfs_rq->tg->load_avg);
|
|
|
|
cfs_rq->tg_load_avg_contrib = cfs_rq->avg.load_avg;
|
2012-10-04 11:18:31 +00:00
|
|
|
}
|
2012-10-04 11:18:31 +00:00
|
|
|
}
|
2014-02-26 11:19:33 +00:00
|
|
|
|
2015-10-23 16:16:19 +00:00
|
|
|
/*
|
|
|
|
* Called within set_task_rq() right before setting a task's cpu. The
|
|
|
|
* caller only guarantees p->pi_lock is held; no other assumptions,
|
|
|
|
* including the state of rq->lock, should be made.
|
|
|
|
*/
|
|
|
|
void set_task_rq_fair(struct sched_entity *se,
|
|
|
|
struct cfs_rq *prev, struct cfs_rq *next)
|
|
|
|
{
|
2017-03-28 09:08:20 +00:00
|
|
|
u64 p_last_update_time;
|
|
|
|
u64 n_last_update_time;
|
|
|
|
|
2015-10-23 16:16:19 +00:00
|
|
|
if (!sched_feat(ATTACH_AGE_LOAD))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We are supposed to update the task to "current" time, then its up to
|
|
|
|
* date and ready to go to new CPU/cfs_rq. But we have difficulty in
|
|
|
|
* getting what current time is, so simply throw away the out-of-date
|
|
|
|
* time. This will result in the wakee task is less decayed, but giving
|
|
|
|
* the wakee more load sounds not bad.
|
|
|
|
*/
|
2017-03-28 09:08:20 +00:00
|
|
|
if (!(se->avg.last_update_time && prev))
|
|
|
|
return;
|
2015-10-23 16:16:19 +00:00
|
|
|
|
|
|
|
#ifndef CONFIG_64BIT
|
2017-03-28 09:08:20 +00:00
|
|
|
{
|
2015-10-23 16:16:19 +00:00
|
|
|
u64 p_last_update_time_copy;
|
|
|
|
u64 n_last_update_time_copy;
|
|
|
|
|
|
|
|
do {
|
|
|
|
p_last_update_time_copy = prev->load_last_update_time_copy;
|
|
|
|
n_last_update_time_copy = next->load_last_update_time_copy;
|
|
|
|
|
|
|
|
smp_rmb();
|
|
|
|
|
|
|
|
p_last_update_time = prev->avg.last_update_time;
|
|
|
|
n_last_update_time = next->avg.last_update_time;
|
|
|
|
|
|
|
|
} while (p_last_update_time != p_last_update_time_copy ||
|
|
|
|
n_last_update_time != n_last_update_time_copy);
|
2017-03-28 09:08:20 +00:00
|
|
|
}
|
2015-10-23 16:16:19 +00:00
|
|
|
#else
|
2017-03-28 09:08:20 +00:00
|
|
|
p_last_update_time = prev->avg.last_update_time;
|
|
|
|
n_last_update_time = next->avg.last_update_time;
|
2015-10-23 16:16:19 +00:00
|
|
|
#endif
|
2017-03-28 09:08:20 +00:00
|
|
|
__update_load_avg_blocked_se(p_last_update_time, cpu_of(rq_of(prev)), se);
|
|
|
|
se->avg.last_update_time = n_last_update_time;
|
2015-10-23 16:16:19 +00:00
|
|
|
}
|
2016-11-08 09:53:45 +00:00
|
|
|
|
2017-05-08 15:30:46 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* When on migration a sched_entity joins/leaves the PELT hierarchy, we need to
|
|
|
|
* propagate its contribution. The key to this propagation is the invariant
|
|
|
|
* that for each group:
|
|
|
|
*
|
|
|
|
* ge->avg == grq->avg (1)
|
|
|
|
*
|
|
|
|
* _IFF_ we look at the pure running and runnable sums. Because they
|
|
|
|
* represent the very same entity, just at different points in the hierarchy.
|
|
|
|
*
|
2017-11-16 14:21:52 +00:00
|
|
|
* Per the above update_tg_cfs_util() is trivial and simply copies the running
|
|
|
|
* sum over (but still wrong, because the group entity and group rq do not have
|
|
|
|
* their PELT windows aligned).
|
2017-05-08 15:30:46 +00:00
|
|
|
*
|
|
|
|
* However, update_tg_cfs_runnable() is more complex. So we have:
|
|
|
|
*
|
|
|
|
* ge->avg.load_avg = ge->load.weight * ge->avg.runnable_avg (2)
|
|
|
|
*
|
|
|
|
* And since, like util, the runnable part should be directly transferable,
|
|
|
|
* the following would _appear_ to be the straight forward approach:
|
|
|
|
*
|
2017-11-16 14:21:52 +00:00
|
|
|
* grq->avg.load_avg = grq->load.weight * grq->avg.runnable_avg (3)
|
2017-05-08 15:30:46 +00:00
|
|
|
*
|
|
|
|
* And per (1) we have:
|
|
|
|
*
|
2017-11-16 14:21:52 +00:00
|
|
|
* ge->avg.runnable_avg == grq->avg.runnable_avg
|
2017-05-08 15:30:46 +00:00
|
|
|
*
|
|
|
|
* Which gives:
|
|
|
|
*
|
|
|
|
* ge->load.weight * grq->avg.load_avg
|
|
|
|
* ge->avg.load_avg = ----------------------------------- (4)
|
|
|
|
* grq->load.weight
|
|
|
|
*
|
|
|
|
* Except that is wrong!
|
|
|
|
*
|
|
|
|
* Because while for entities historical weight is not important and we
|
|
|
|
* really only care about our future and therefore can consider a pure
|
|
|
|
* runnable sum, runqueues can NOT do this.
|
|
|
|
*
|
|
|
|
* We specifically want runqueues to have a load_avg that includes
|
|
|
|
* historical weights. Those represent the blocked load, the load we expect
|
|
|
|
* to (shortly) return to us. This only works by keeping the weights as
|
|
|
|
* integral part of the sum. We therefore cannot decompose as per (3).
|
|
|
|
*
|
2017-11-16 14:21:52 +00:00
|
|
|
* Another reason this doesn't work is that runnable isn't a 0-sum entity.
|
|
|
|
* Imagine a rq with 2 tasks that each are runnable 2/3 of the time. Then the
|
|
|
|
* rq itself is runnable anywhere between 2/3 and 1 depending on how the
|
|
|
|
* runnable section of these tasks overlap (or not). If they were to perfectly
|
|
|
|
* align the rq as a whole would be runnable 2/3 of the time. If however we
|
|
|
|
* always have at least 1 runnable task, the rq as a whole is always runnable.
|
2017-05-08 15:30:46 +00:00
|
|
|
*
|
2017-11-16 14:21:52 +00:00
|
|
|
* So we'll have to approximate.. :/
|
2017-05-08 15:30:46 +00:00
|
|
|
*
|
2017-11-16 14:21:52 +00:00
|
|
|
* Given the constraint:
|
2017-05-08 15:30:46 +00:00
|
|
|
*
|
2017-11-16 14:21:52 +00:00
|
|
|
* ge->avg.running_sum <= ge->avg.runnable_sum <= LOAD_AVG_MAX
|
2017-05-08 15:30:46 +00:00
|
|
|
*
|
2017-11-16 14:21:52 +00:00
|
|
|
* We can construct a rule that adds runnable to a rq by assuming minimal
|
|
|
|
* overlap.
|
2017-05-08 15:30:46 +00:00
|
|
|
*
|
2017-11-16 14:21:52 +00:00
|
|
|
* On removal, we'll assume each task is equally runnable; which yields:
|
2017-05-08 15:30:46 +00:00
|
|
|
*
|
2017-11-16 14:21:52 +00:00
|
|
|
* grq->avg.runnable_sum = grq->avg.load_sum / grq->load.weight
|
2017-05-08 15:30:46 +00:00
|
|
|
*
|
2017-11-16 14:21:52 +00:00
|
|
|
* XXX: only do this for the part of runnable > running ?
|
2017-05-08 15:30:46 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-11-08 09:53:45 +00:00
|
|
|
static inline void
|
2017-05-08 15:30:46 +00:00
|
|
|
update_tg_cfs_util(struct cfs_rq *cfs_rq, struct sched_entity *se, struct cfs_rq *gcfs_rq)
|
2016-11-08 09:53:45 +00:00
|
|
|
{
|
|
|
|
long delta = gcfs_rq->avg.util_avg - se->avg.util_avg;
|
|
|
|
|
|
|
|
/* Nothing to update */
|
|
|
|
if (!delta)
|
|
|
|
return;
|
|
|
|
|
2017-11-16 14:21:52 +00:00
|
|
|
/*
|
|
|
|
* The relation between sum and avg is:
|
|
|
|
*
|
|
|
|
* LOAD_AVG_MAX - 1024 + sa->period_contrib
|
|
|
|
*
|
|
|
|
* however, the PELT windows are not aligned between grq and gse.
|
|
|
|
*/
|
|
|
|
|
2016-11-08 09:53:45 +00:00
|
|
|
/* Set new sched_entity's utilization */
|
|
|
|
se->avg.util_avg = gcfs_rq->avg.util_avg;
|
|
|
|
se->avg.util_sum = se->avg.util_avg * LOAD_AVG_MAX;
|
|
|
|
|
|
|
|
/* Update parent cfs_rq utilization */
|
|
|
|
add_positive(&cfs_rq->avg.util_avg, delta);
|
|
|
|
cfs_rq->avg.util_sum = cfs_rq->avg.util_avg * LOAD_AVG_MAX;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
2017-05-08 15:30:46 +00:00
|
|
|
update_tg_cfs_runnable(struct cfs_rq *cfs_rq, struct sched_entity *se, struct cfs_rq *gcfs_rq)
|
2016-11-08 09:53:45 +00:00
|
|
|
{
|
2017-11-16 14:21:52 +00:00
|
|
|
long delta_avg, running_sum, runnable_sum = gcfs_rq->prop_runnable_sum;
|
|
|
|
unsigned long runnable_load_avg, load_avg;
|
|
|
|
u64 runnable_load_sum, load_sum = 0;
|
|
|
|
s64 delta_sum;
|
2016-11-08 09:53:45 +00:00
|
|
|
|
2017-05-08 15:30:46 +00:00
|
|
|
if (!runnable_sum)
|
|
|
|
return;
|
2016-11-08 09:53:45 +00:00
|
|
|
|
2017-05-08 15:30:46 +00:00
|
|
|
gcfs_rq->prop_runnable_sum = 0;
|
2016-11-08 09:53:45 +00:00
|
|
|
|
2017-11-16 14:21:52 +00:00
|
|
|
if (runnable_sum >= 0) {
|
|
|
|
/*
|
|
|
|
* Add runnable; clip at LOAD_AVG_MAX. Reflects that until
|
|
|
|
* the CPU is saturated running == runnable.
|
|
|
|
*/
|
|
|
|
runnable_sum += se->avg.load_sum;
|
|
|
|
runnable_sum = min(runnable_sum, (long)LOAD_AVG_MAX);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Estimate the new unweighted runnable_sum of the gcfs_rq by
|
|
|
|
* assuming all tasks are equally runnable.
|
|
|
|
*/
|
|
|
|
if (scale_load_down(gcfs_rq->load.weight)) {
|
|
|
|
load_sum = div_s64(gcfs_rq->avg.load_sum,
|
|
|
|
scale_load_down(gcfs_rq->load.weight));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* But make sure to not inflate se's runnable */
|
|
|
|
runnable_sum = min(se->avg.load_sum, load_sum);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* runnable_sum can't be lower than running_sum
|
|
|
|
* As running sum is scale with cpu capacity wehreas the runnable sum
|
|
|
|
* is not we rescale running_sum 1st
|
|
|
|
*/
|
|
|
|
running_sum = se->avg.util_sum /
|
|
|
|
arch_scale_cpu_capacity(NULL, cpu_of(rq_of(cfs_rq)));
|
|
|
|
runnable_sum = max(runnable_sum, running_sum);
|
|
|
|
|
2017-05-08 15:30:46 +00:00
|
|
|
load_sum = (s64)se_weight(se) * runnable_sum;
|
|
|
|
load_avg = div_s64(load_sum, LOAD_AVG_MAX);
|
2016-11-08 09:53:45 +00:00
|
|
|
|
2017-11-16 14:21:52 +00:00
|
|
|
delta_sum = load_sum - (s64)se_weight(se) * se->avg.load_sum;
|
|
|
|
delta_avg = load_avg - se->avg.load_avg;
|
2016-11-08 09:53:45 +00:00
|
|
|
|
2017-11-16 14:21:52 +00:00
|
|
|
se->avg.load_sum = runnable_sum;
|
|
|
|
se->avg.load_avg = load_avg;
|
|
|
|
add_positive(&cfs_rq->avg.load_avg, delta_avg);
|
|
|
|
add_positive(&cfs_rq->avg.load_sum, delta_sum);
|
2016-11-08 09:53:45 +00:00
|
|
|
|
2017-05-06 13:59:54 +00:00
|
|
|
runnable_load_sum = (s64)se_runnable(se) * runnable_sum;
|
|
|
|
runnable_load_avg = div_s64(runnable_load_sum, LOAD_AVG_MAX);
|
2017-11-16 14:21:52 +00:00
|
|
|
delta_sum = runnable_load_sum - se_weight(se) * se->avg.runnable_load_sum;
|
|
|
|
delta_avg = runnable_load_avg - se->avg.runnable_load_avg;
|
2017-05-06 13:59:54 +00:00
|
|
|
|
2017-11-16 14:21:52 +00:00
|
|
|
se->avg.runnable_load_sum = runnable_sum;
|
|
|
|
se->avg.runnable_load_avg = runnable_load_avg;
|
2017-05-06 13:59:54 +00:00
|
|
|
|
2016-11-08 09:53:45 +00:00
|
|
|
if (se->on_rq) {
|
2017-11-16 14:21:52 +00:00
|
|
|
add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg);
|
|
|
|
add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum);
|
2016-11-08 09:53:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-08 15:30:46 +00:00
|
|
|
static inline void add_tg_cfs_propagate(struct cfs_rq *cfs_rq, long runnable_sum)
|
2016-11-08 09:53:45 +00:00
|
|
|
{
|
2017-05-08 15:30:46 +00:00
|
|
|
cfs_rq->propagate = 1;
|
|
|
|
cfs_rq->prop_runnable_sum += runnable_sum;
|
2016-11-08 09:53:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Update task and its cfs_rq load average */
|
|
|
|
static inline int propagate_entity_load_avg(struct sched_entity *se)
|
|
|
|
{
|
2017-05-08 15:30:46 +00:00
|
|
|
struct cfs_rq *cfs_rq, *gcfs_rq;
|
2016-11-08 09:53:45 +00:00
|
|
|
|
|
|
|
if (entity_is_task(se))
|
|
|
|
return 0;
|
|
|
|
|
2017-05-08 15:30:46 +00:00
|
|
|
gcfs_rq = group_cfs_rq(se);
|
|
|
|
if (!gcfs_rq->propagate)
|
2016-11-08 09:53:45 +00:00
|
|
|
return 0;
|
|
|
|
|
2017-05-08 15:30:46 +00:00
|
|
|
gcfs_rq->propagate = 0;
|
|
|
|
|
2016-11-08 09:53:45 +00:00
|
|
|
cfs_rq = cfs_rq_of(se);
|
|
|
|
|
2017-05-08 15:30:46 +00:00
|
|
|
add_tg_cfs_propagate(cfs_rq, gcfs_rq->prop_runnable_sum);
|
2016-11-08 09:53:45 +00:00
|
|
|
|
2017-05-08 15:30:46 +00:00
|
|
|
update_tg_cfs_util(cfs_rq, se, gcfs_rq);
|
|
|
|
update_tg_cfs_runnable(cfs_rq, se, gcfs_rq);
|
2016-11-08 09:53:45 +00:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-03-17 13:47:22 +00:00
|
|
|
/*
|
|
|
|
* Check if we need to update the load and the utilization of a blocked
|
|
|
|
* group_entity:
|
|
|
|
*/
|
|
|
|
static inline bool skip_blocked_update(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
struct cfs_rq *gcfs_rq = group_cfs_rq(se);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If sched_entity still have not zero load or utilization, we have to
|
|
|
|
* decay it:
|
|
|
|
*/
|
|
|
|
if (se->avg.load_avg || se->avg.util_avg)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is a pending propagation, we have to update the load and
|
|
|
|
* the utilization of the sched_entity:
|
|
|
|
*/
|
2017-05-08 15:30:46 +00:00
|
|
|
if (gcfs_rq->propagate)
|
2017-03-17 13:47:22 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Otherwise, the load and the utilization of the sched_entity is
|
|
|
|
* already zero and there is no pending propagation, so it will be a
|
|
|
|
* waste of time to try to decay it:
|
|
|
|
*/
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-02-11 15:11:48 +00:00
|
|
|
#else /* CONFIG_FAIR_GROUP_SCHED */
|
2016-11-08 09:53:45 +00:00
|
|
|
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
static inline void update_tg_load_avg(struct cfs_rq *cfs_rq, int force) {}
|
2016-11-08 09:53:45 +00:00
|
|
|
|
|
|
|
static inline int propagate_entity_load_avg(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-08 15:30:46 +00:00
|
|
|
static inline void add_tg_cfs_propagate(struct cfs_rq *cfs_rq, long runnable_sum) {}
|
2016-11-08 09:53:45 +00:00
|
|
|
|
2014-02-11 15:11:48 +00:00
|
|
|
#endif /* CONFIG_FAIR_GROUP_SCHED */
|
2012-10-04 11:18:30 +00:00
|
|
|
|
2016-06-21 12:27:50 +00:00
|
|
|
/**
|
|
|
|
* update_cfs_rq_load_avg - update the cfs_rq's load/util averages
|
|
|
|
* @now: current time, as per cfs_rq_clock_task()
|
|
|
|
* @cfs_rq: cfs_rq to update
|
|
|
|
*
|
|
|
|
* The cfs_rq avg is the direct sum of all its entities (blocked and runnable)
|
|
|
|
* avg. The immediate corollary is that all (fair) tasks must be attached, see
|
|
|
|
* post_init_entity_util_avg().
|
|
|
|
*
|
|
|
|
* cfs_rq->avg is used for task_h_load() and update_cfs_share() for example.
|
|
|
|
*
|
2016-07-13 08:56:25 +00:00
|
|
|
* Returns true if the load decayed or we removed load.
|
|
|
|
*
|
|
|
|
* Since both these conditions indicate a changed cfs_rq->avg.load we should
|
|
|
|
* call update_tg_load_avg() when this function returns true.
|
2016-06-21 12:27:50 +00:00
|
|
|
*/
|
2016-03-24 22:26:07 +00:00
|
|
|
static inline int
|
2017-05-24 05:29:56 +00:00
|
|
|
update_cfs_rq_load_avg(u64 now, struct cfs_rq *cfs_rq)
|
2012-10-04 11:18:30 +00:00
|
|
|
{
|
2017-05-08 15:30:46 +00:00
|
|
|
unsigned long removed_load = 0, removed_util = 0, removed_runnable_sum = 0;
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
struct sched_avg *sa = &cfs_rq->avg;
|
2017-05-08 14:51:41 +00:00
|
|
|
int decayed = 0;
|
2012-10-04 11:18:30 +00:00
|
|
|
|
2017-05-08 14:51:41 +00:00
|
|
|
if (cfs_rq->removed.nr) {
|
|
|
|
unsigned long r;
|
2017-05-12 12:18:10 +00:00
|
|
|
u32 divider = LOAD_AVG_MAX - 1024 + sa->period_contrib;
|
2017-05-08 14:51:41 +00:00
|
|
|
|
|
|
|
raw_spin_lock(&cfs_rq->removed.lock);
|
|
|
|
swap(cfs_rq->removed.util_avg, removed_util);
|
|
|
|
swap(cfs_rq->removed.load_avg, removed_load);
|
2017-05-08 15:30:46 +00:00
|
|
|
swap(cfs_rq->removed.runnable_sum, removed_runnable_sum);
|
2017-05-08 14:51:41 +00:00
|
|
|
cfs_rq->removed.nr = 0;
|
|
|
|
raw_spin_unlock(&cfs_rq->removed.lock);
|
|
|
|
|
|
|
|
r = removed_load;
|
sched/fair: Fix cfs_rq avg tracking underflow
As per commit:
b7fa30c9cc48 ("sched/fair: Fix post_init_entity_util_avg() serialization")
> the code generated from update_cfs_rq_load_avg():
>
> if (atomic_long_read(&cfs_rq->removed_load_avg)) {
> s64 r = atomic_long_xchg(&cfs_rq->removed_load_avg, 0);
> sa->load_avg = max_t(long, sa->load_avg - r, 0);
> sa->load_sum = max_t(s64, sa->load_sum - r * LOAD_AVG_MAX, 0);
> removed_load = 1;
> }
>
> turns into:
>
> ffffffff81087064: 49 8b 85 98 00 00 00 mov 0x98(%r13),%rax
> ffffffff8108706b: 48 85 c0 test %rax,%rax
> ffffffff8108706e: 74 40 je ffffffff810870b0 <update_blocked_averages+0xc0>
> ffffffff81087070: 4c 89 f8 mov %r15,%rax
> ffffffff81087073: 49 87 85 98 00 00 00 xchg %rax,0x98(%r13)
> ffffffff8108707a: 49 29 45 70 sub %rax,0x70(%r13)
> ffffffff8108707e: 4c 89 f9 mov %r15,%rcx
> ffffffff81087081: bb 01 00 00 00 mov $0x1,%ebx
> ffffffff81087086: 49 83 7d 70 00 cmpq $0x0,0x70(%r13)
> ffffffff8108708b: 49 0f 49 4d 70 cmovns 0x70(%r13),%rcx
>
> Which you'll note ends up with sa->load_avg -= r in memory at
> ffffffff8108707a.
So I _should_ have looked at other unserialized users of ->load_avg,
but alas. Luckily nikbor reported a similar /0 from task_h_load() which
instantly triggered recollection of this here problem.
Aside from the intermediate value hitting memory and causing problems,
there's another problem: the underflow detection relies on the signed
bit. This reduces the effective width of the variables, IOW its
effectively the same as having these variables be of signed type.
This patch changes to a different means of unsigned underflow
detection to not rely on the signed bit. This allows the variables to
use the 'full' unsigned range. And it does so with explicit LOAD -
STORE to ensure any intermediate value will never be visible in
memory, allowing these unserialized loads.
Note: GCC generates crap code for this, might warrant a look later.
Note2: I say 'full' above, if we end up at U*_MAX we'll still explode;
maybe we should do clamping on add too.
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Andrey Ryabinin <aryabinin@virtuozzo.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Yuyang Du <yuyang.du@intel.com>
Cc: bsegall@google.com
Cc: kernel@kyup.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: steve.muckle@linaro.org
Fixes: 9d89c257dfb9 ("sched/fair: Rewrite runnable load and utilization average tracking")
Link: http://lkml.kernel.org/r/20160617091948.GJ30927@twins.programming.kicks-ass.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-06-16 08:50:40 +00:00
|
|
|
sub_positive(&sa->load_avg, r);
|
2017-05-12 12:18:10 +00:00
|
|
|
sub_positive(&sa->load_sum, r * divider);
|
2012-10-04 11:18:30 +00:00
|
|
|
|
2017-05-08 14:51:41 +00:00
|
|
|
r = removed_util;
|
sched/fair: Fix cfs_rq avg tracking underflow
As per commit:
b7fa30c9cc48 ("sched/fair: Fix post_init_entity_util_avg() serialization")
> the code generated from update_cfs_rq_load_avg():
>
> if (atomic_long_read(&cfs_rq->removed_load_avg)) {
> s64 r = atomic_long_xchg(&cfs_rq->removed_load_avg, 0);
> sa->load_avg = max_t(long, sa->load_avg - r, 0);
> sa->load_sum = max_t(s64, sa->load_sum - r * LOAD_AVG_MAX, 0);
> removed_load = 1;
> }
>
> turns into:
>
> ffffffff81087064: 49 8b 85 98 00 00 00 mov 0x98(%r13),%rax
> ffffffff8108706b: 48 85 c0 test %rax,%rax
> ffffffff8108706e: 74 40 je ffffffff810870b0 <update_blocked_averages+0xc0>
> ffffffff81087070: 4c 89 f8 mov %r15,%rax
> ffffffff81087073: 49 87 85 98 00 00 00 xchg %rax,0x98(%r13)
> ffffffff8108707a: 49 29 45 70 sub %rax,0x70(%r13)
> ffffffff8108707e: 4c 89 f9 mov %r15,%rcx
> ffffffff81087081: bb 01 00 00 00 mov $0x1,%ebx
> ffffffff81087086: 49 83 7d 70 00 cmpq $0x0,0x70(%r13)
> ffffffff8108708b: 49 0f 49 4d 70 cmovns 0x70(%r13),%rcx
>
> Which you'll note ends up with sa->load_avg -= r in memory at
> ffffffff8108707a.
So I _should_ have looked at other unserialized users of ->load_avg,
but alas. Luckily nikbor reported a similar /0 from task_h_load() which
instantly triggered recollection of this here problem.
Aside from the intermediate value hitting memory and causing problems,
there's another problem: the underflow detection relies on the signed
bit. This reduces the effective width of the variables, IOW its
effectively the same as having these variables be of signed type.
This patch changes to a different means of unsigned underflow
detection to not rely on the signed bit. This allows the variables to
use the 'full' unsigned range. And it does so with explicit LOAD -
STORE to ensure any intermediate value will never be visible in
memory, allowing these unserialized loads.
Note: GCC generates crap code for this, might warrant a look later.
Note2: I say 'full' above, if we end up at U*_MAX we'll still explode;
maybe we should do clamping on add too.
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Andrey Ryabinin <aryabinin@virtuozzo.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Yuyang Du <yuyang.du@intel.com>
Cc: bsegall@google.com
Cc: kernel@kyup.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: steve.muckle@linaro.org
Fixes: 9d89c257dfb9 ("sched/fair: Rewrite runnable load and utilization average tracking")
Link: http://lkml.kernel.org/r/20160617091948.GJ30927@twins.programming.kicks-ass.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-06-16 08:50:40 +00:00
|
|
|
sub_positive(&sa->util_avg, r);
|
2017-05-12 12:18:10 +00:00
|
|
|
sub_positive(&sa->util_sum, r * divider);
|
2017-05-08 14:51:41 +00:00
|
|
|
|
2017-05-08 15:30:46 +00:00
|
|
|
add_tg_cfs_propagate(cfs_rq, -(long)removed_runnable_sum);
|
2017-05-08 14:51:41 +00:00
|
|
|
|
|
|
|
decayed = 1;
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
}
|
2015-02-27 15:54:04 +00:00
|
|
|
|
2017-05-08 14:51:41 +00:00
|
|
|
decayed |= __update_load_avg_cfs_rq(now, cpu_of(rq_of(cfs_rq)), cfs_rq);
|
2015-02-27 15:54:04 +00:00
|
|
|
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
smp_wmb();
|
|
|
|
cfs_rq->load_last_update_time_copy = sa->last_update_time;
|
|
|
|
#endif
|
2015-02-27 15:54:04 +00:00
|
|
|
|
2017-05-08 14:51:41 +00:00
|
|
|
if (decayed)
|
2016-03-24 22:26:07 +00:00
|
|
|
cfs_rq_util_change(cfs_rq);
|
2016-03-22 00:21:07 +00:00
|
|
|
|
2017-05-08 14:51:41 +00:00
|
|
|
return decayed;
|
2016-03-22 00:21:07 +00:00
|
|
|
}
|
|
|
|
|
2016-06-21 12:27:50 +00:00
|
|
|
/**
|
|
|
|
* attach_entity_load_avg - attach this entity to its cfs_rq load avg
|
|
|
|
* @cfs_rq: cfs_rq to attach to
|
|
|
|
* @se: sched_entity to attach
|
|
|
|
*
|
|
|
|
* Must call update_cfs_rq_load_avg() before this, since we rely on
|
|
|
|
* cfs_rq->avg.last_update_time being current.
|
|
|
|
*/
|
2015-08-20 11:21:56 +00:00
|
|
|
static void attach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|
|
|
{
|
sched/fair: Align PELT windows between cfs_rq and its se
The PELT _sum values are a saw-tooth function, dropping on the decay
edge and then growing back up again during the window.
When these window-edges are not aligned between cfs_rq and se, we can
have the situation where, for example, on dequeue, the se decays
first.
Its _sum values will be small(er), while the cfs_rq _sum values will
still be on their way up. Because of this, the subtraction:
cfs_rq->avg._sum -= se->avg._sum will result in a positive value. This
will then, once the cfs_rq reaches an edge, translate into its _avg
value jumping up.
This is especially visible with the runnable_load bits, since they get
added/subtracted a lot.
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-05-12 12:16:30 +00:00
|
|
|
u32 divider = LOAD_AVG_MAX - 1024 + cfs_rq->avg.period_contrib;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When we attach the @se to the @cfs_rq, we must align the decay
|
|
|
|
* window because without that, really weird and wonderful things can
|
|
|
|
* happen.
|
|
|
|
*
|
|
|
|
* XXX illustrate
|
|
|
|
*/
|
2015-08-20 11:21:56 +00:00
|
|
|
se->avg.last_update_time = cfs_rq->avg.last_update_time;
|
sched/fair: Align PELT windows between cfs_rq and its se
The PELT _sum values are a saw-tooth function, dropping on the decay
edge and then growing back up again during the window.
When these window-edges are not aligned between cfs_rq and se, we can
have the situation where, for example, on dequeue, the se decays
first.
Its _sum values will be small(er), while the cfs_rq _sum values will
still be on their way up. Because of this, the subtraction:
cfs_rq->avg._sum -= se->avg._sum will result in a positive value. This
will then, once the cfs_rq reaches an edge, translate into its _avg
value jumping up.
This is especially visible with the runnable_load bits, since they get
added/subtracted a lot.
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-05-12 12:16:30 +00:00
|
|
|
se->avg.period_contrib = cfs_rq->avg.period_contrib;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Hell(o) Nasty stuff.. we need to recompute _sum based on the new
|
|
|
|
* period_contrib. This isn't strictly correct, but since we're
|
|
|
|
* entirely outside of the PELT hierarchy, nobody cares if we truncate
|
|
|
|
* _sum a little.
|
|
|
|
*/
|
|
|
|
se->avg.util_sum = se->avg.util_avg * divider;
|
|
|
|
|
|
|
|
se->avg.load_sum = divider;
|
|
|
|
if (se_weight(se)) {
|
|
|
|
se->avg.load_sum =
|
|
|
|
div_u64(se->avg.load_avg * se->avg.load_sum, se_weight(se));
|
|
|
|
}
|
|
|
|
|
|
|
|
se->avg.runnable_load_sum = se->avg.load_sum;
|
|
|
|
|
2017-08-24 15:45:35 +00:00
|
|
|
enqueue_load_avg(cfs_rq, se);
|
2015-08-20 11:21:56 +00:00
|
|
|
cfs_rq->avg.util_avg += se->avg.util_avg;
|
|
|
|
cfs_rq->avg.util_sum += se->avg.util_sum;
|
2017-05-08 15:30:46 +00:00
|
|
|
|
|
|
|
add_tg_cfs_propagate(cfs_rq, se->avg.load_sum);
|
2016-03-24 22:26:07 +00:00
|
|
|
|
|
|
|
cfs_rq_util_change(cfs_rq);
|
2015-08-20 11:21:56 +00:00
|
|
|
}
|
|
|
|
|
2016-06-21 12:27:50 +00:00
|
|
|
/**
|
|
|
|
* detach_entity_load_avg - detach this entity from its cfs_rq load avg
|
|
|
|
* @cfs_rq: cfs_rq to detach from
|
|
|
|
* @se: sched_entity to detach
|
|
|
|
*
|
|
|
|
* Must call update_cfs_rq_load_avg() before this, since we rely on
|
|
|
|
* cfs_rq->avg.last_update_time being current.
|
|
|
|
*/
|
2015-08-20 11:21:56 +00:00
|
|
|
static void detach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|
|
|
{
|
2017-08-24 15:45:35 +00:00
|
|
|
dequeue_load_avg(cfs_rq, se);
|
sched/fair: Fix cfs_rq avg tracking underflow
As per commit:
b7fa30c9cc48 ("sched/fair: Fix post_init_entity_util_avg() serialization")
> the code generated from update_cfs_rq_load_avg():
>
> if (atomic_long_read(&cfs_rq->removed_load_avg)) {
> s64 r = atomic_long_xchg(&cfs_rq->removed_load_avg, 0);
> sa->load_avg = max_t(long, sa->load_avg - r, 0);
> sa->load_sum = max_t(s64, sa->load_sum - r * LOAD_AVG_MAX, 0);
> removed_load = 1;
> }
>
> turns into:
>
> ffffffff81087064: 49 8b 85 98 00 00 00 mov 0x98(%r13),%rax
> ffffffff8108706b: 48 85 c0 test %rax,%rax
> ffffffff8108706e: 74 40 je ffffffff810870b0 <update_blocked_averages+0xc0>
> ffffffff81087070: 4c 89 f8 mov %r15,%rax
> ffffffff81087073: 49 87 85 98 00 00 00 xchg %rax,0x98(%r13)
> ffffffff8108707a: 49 29 45 70 sub %rax,0x70(%r13)
> ffffffff8108707e: 4c 89 f9 mov %r15,%rcx
> ffffffff81087081: bb 01 00 00 00 mov $0x1,%ebx
> ffffffff81087086: 49 83 7d 70 00 cmpq $0x0,0x70(%r13)
> ffffffff8108708b: 49 0f 49 4d 70 cmovns 0x70(%r13),%rcx
>
> Which you'll note ends up with sa->load_avg -= r in memory at
> ffffffff8108707a.
So I _should_ have looked at other unserialized users of ->load_avg,
but alas. Luckily nikbor reported a similar /0 from task_h_load() which
instantly triggered recollection of this here problem.
Aside from the intermediate value hitting memory and causing problems,
there's another problem: the underflow detection relies on the signed
bit. This reduces the effective width of the variables, IOW its
effectively the same as having these variables be of signed type.
This patch changes to a different means of unsigned underflow
detection to not rely on the signed bit. This allows the variables to
use the 'full' unsigned range. And it does so with explicit LOAD -
STORE to ensure any intermediate value will never be visible in
memory, allowing these unserialized loads.
Note: GCC generates crap code for this, might warrant a look later.
Note2: I say 'full' above, if we end up at U*_MAX we'll still explode;
maybe we should do clamping on add too.
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Andrey Ryabinin <aryabinin@virtuozzo.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Yuyang Du <yuyang.du@intel.com>
Cc: bsegall@google.com
Cc: kernel@kyup.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: steve.muckle@linaro.org
Fixes: 9d89c257dfb9 ("sched/fair: Rewrite runnable load and utilization average tracking")
Link: http://lkml.kernel.org/r/20160617091948.GJ30927@twins.programming.kicks-ass.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-06-16 08:50:40 +00:00
|
|
|
sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg);
|
|
|
|
sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum);
|
2017-05-08 15:30:46 +00:00
|
|
|
|
|
|
|
add_tg_cfs_propagate(cfs_rq, -se->avg.load_sum);
|
2016-03-24 22:26:07 +00:00
|
|
|
|
|
|
|
cfs_rq_util_change(cfs_rq);
|
2015-08-20 11:21:56 +00:00
|
|
|
}
|
|
|
|
|
2017-05-06 15:37:03 +00:00
|
|
|
/*
|
|
|
|
* Optional action to be done while updating the load average
|
|
|
|
*/
|
|
|
|
#define UPDATE_TG 0x1
|
|
|
|
#define SKIP_AGE_LOAD 0x2
|
|
|
|
#define DO_ATTACH 0x4
|
|
|
|
|
|
|
|
/* Update task and its cfs_rq load average */
|
|
|
|
static inline void update_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
|
|
|
|
{
|
|
|
|
u64 now = cfs_rq_clock_task(cfs_rq);
|
|
|
|
struct rq *rq = rq_of(cfs_rq);
|
|
|
|
int cpu = cpu_of(rq);
|
|
|
|
int decayed;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Track task load average for carrying it to new CPU after migrated, and
|
|
|
|
* track group sched_entity load average for task_h_load calc in migration
|
|
|
|
*/
|
|
|
|
if (se->avg.last_update_time && !(flags & SKIP_AGE_LOAD))
|
|
|
|
__update_load_avg_se(now, cpu, cfs_rq, se);
|
|
|
|
|
|
|
|
decayed = update_cfs_rq_load_avg(now, cfs_rq);
|
|
|
|
decayed |= propagate_entity_load_avg(se);
|
|
|
|
|
|
|
|
if (!se->avg.last_update_time && (flags & DO_ATTACH)) {
|
|
|
|
|
|
|
|
attach_entity_load_avg(cfs_rq, se);
|
|
|
|
update_tg_load_avg(cfs_rq, 0);
|
|
|
|
|
|
|
|
} else if (decayed && (flags & UPDATE_TG))
|
|
|
|
update_tg_load_avg(cfs_rq, 0);
|
|
|
|
}
|
|
|
|
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
#ifndef CONFIG_64BIT
|
2015-12-16 23:34:27 +00:00
|
|
|
static inline u64 cfs_rq_last_update_time(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
u64 last_update_time_copy;
|
2015-12-16 23:34:27 +00:00
|
|
|
u64 last_update_time;
|
2012-10-04 11:18:30 +00:00
|
|
|
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
do {
|
|
|
|
last_update_time_copy = cfs_rq->load_last_update_time_copy;
|
|
|
|
smp_rmb();
|
|
|
|
last_update_time = cfs_rq->avg.last_update_time;
|
|
|
|
} while (last_update_time != last_update_time_copy);
|
2015-12-16 23:34:27 +00:00
|
|
|
|
|
|
|
return last_update_time;
|
|
|
|
}
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
#else
|
2015-12-16 23:34:27 +00:00
|
|
|
static inline u64 cfs_rq_last_update_time(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
|
|
|
return cfs_rq->avg.last_update_time;
|
|
|
|
}
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
#endif
|
|
|
|
|
2016-10-14 13:41:07 +00:00
|
|
|
/*
|
|
|
|
* Synchronize entity load avg of dequeued entity without locking
|
|
|
|
* the previous rq.
|
|
|
|
*/
|
|
|
|
void sync_entity_load_avg(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
|
|
|
u64 last_update_time;
|
|
|
|
|
|
|
|
last_update_time = cfs_rq_last_update_time(cfs_rq);
|
2017-03-28 09:08:20 +00:00
|
|
|
__update_load_avg_blocked_se(last_update_time, cpu_of(rq_of(cfs_rq)), se);
|
2016-10-14 13:41:07 +00:00
|
|
|
}
|
|
|
|
|
2015-12-16 23:34:27 +00:00
|
|
|
/*
|
|
|
|
* Task first catches up with cfs_rq, and then subtract
|
|
|
|
* itself from the cfs_rq (task must be off the queue now).
|
|
|
|
*/
|
|
|
|
void remove_entity_load_avg(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
2017-05-08 14:51:41 +00:00
|
|
|
unsigned long flags;
|
2015-12-16 23:34:27 +00:00
|
|
|
|
|
|
|
/*
|
2016-06-16 11:29:28 +00:00
|
|
|
* tasks cannot exit without having gone through wake_up_new_task() ->
|
|
|
|
* post_init_entity_util_avg() which will have added things to the
|
|
|
|
* cfs_rq, so we can remove unconditionally.
|
|
|
|
*
|
|
|
|
* Similarly for groups, they will have passed through
|
|
|
|
* post_init_entity_util_avg() before unregister_sched_fair_group()
|
|
|
|
* calls this.
|
2015-12-16 23:34:27 +00:00
|
|
|
*/
|
|
|
|
|
2016-10-14 13:41:07 +00:00
|
|
|
sync_entity_load_avg(se);
|
2017-05-08 14:51:41 +00:00
|
|
|
|
|
|
|
raw_spin_lock_irqsave(&cfs_rq->removed.lock, flags);
|
|
|
|
++cfs_rq->removed.nr;
|
|
|
|
cfs_rq->removed.util_avg += se->avg.util_avg;
|
|
|
|
cfs_rq->removed.load_avg += se->avg.load_avg;
|
2017-05-08 15:30:46 +00:00
|
|
|
cfs_rq->removed.runnable_sum += se->avg.load_sum; /* == runnable_sum */
|
2017-05-08 14:51:41 +00:00
|
|
|
raw_spin_unlock_irqrestore(&cfs_rq->removed.lock, flags);
|
2012-10-04 11:18:30 +00:00
|
|
|
}
|
sched: Fix wrong rq's runnable_avg update with rt tasks
The current update of the rq's load can be erroneous when RT
tasks are involved.
The update of the load of a rq that becomes idle, is done only
if the avg_idle is less than sysctl_sched_migration_cost. If RT
tasks and short idle duration alternate, the runnable_avg will
not be updated correctly and the time will be accounted as idle
time when a CFS task wakes up.
A new idle_enter function is called when the next task is the
idle function so the elapsed time will be accounted as run time
in the load of the rq, whatever the average idle time is. The
function update_rq_runnable_avg is removed from idle_balance.
When a RT task is scheduled on an idle CPU, the update of the
rq's load is not done when the rq exit idle state because CFS's
functions are not called. Then, the idle_balance, which is
called just before entering the idle function, updates the rq's
load and makes the assumption that the elapsed time since the
last update, was only running time.
As a consequence, the rq's load of a CPU that only runs a
periodic RT task, is close to LOAD_AVG_MAX whatever the running
duration of the RT task is.
A new idle_exit function is called when the prev task is the
idle function so the elapsed time will be accounted as idle time
in the rq's load.
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Cc: linaro-kernel@lists.linaro.org
Cc: peterz@infradead.org
Cc: pjt@google.com
Cc: fweisbec@gmail.com
Cc: efault@gmx.de
Link: http://lkml.kernel.org/r/1366302867-5055-1-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-04-18 16:34:26 +00:00
|
|
|
|
2015-07-15 00:04:42 +00:00
|
|
|
static inline unsigned long cfs_rq_runnable_load_avg(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
2017-05-06 13:59:54 +00:00
|
|
|
return cfs_rq->avg.runnable_load_avg;
|
2015-07-15 00:04:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long cfs_rq_load_avg(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
|
|
|
return cfs_rq->avg.load_avg;
|
|
|
|
}
|
|
|
|
|
2016-09-21 13:38:12 +00:00
|
|
|
static int idle_balance(struct rq *this_rq, struct rq_flags *rf);
|
2014-02-11 15:11:48 +00:00
|
|
|
|
2014-01-23 19:32:21 +00:00
|
|
|
#else /* CONFIG_SMP */
|
|
|
|
|
2016-06-17 09:20:46 +00:00
|
|
|
static inline int
|
2017-05-24 05:29:56 +00:00
|
|
|
update_cfs_rq_load_avg(u64 now, struct cfs_rq *cfs_rq)
|
2016-06-17 09:20:46 +00:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-11-08 09:53:44 +00:00
|
|
|
#define UPDATE_TG 0x0
|
|
|
|
#define SKIP_AGE_LOAD 0x0
|
2017-05-06 15:37:03 +00:00
|
|
|
#define DO_ATTACH 0x0
|
2016-11-08 09:53:44 +00:00
|
|
|
|
2017-05-06 15:32:43 +00:00
|
|
|
static inline void update_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se, int not_used1)
|
2016-05-06 12:58:43 +00:00
|
|
|
{
|
2017-05-06 15:32:43 +00:00
|
|
|
cfs_rq_util_change(cfs_rq);
|
2016-05-06 12:58:43 +00:00
|
|
|
}
|
|
|
|
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
static inline void remove_entity_load_avg(struct sched_entity *se) {}
|
2014-02-11 15:11:48 +00:00
|
|
|
|
2015-08-20 11:21:56 +00:00
|
|
|
static inline void
|
|
|
|
attach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) {}
|
|
|
|
static inline void
|
|
|
|
detach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) {}
|
|
|
|
|
2016-09-21 13:38:12 +00:00
|
|
|
static inline int idle_balance(struct rq *rq, struct rq_flags *rf)
|
2014-02-11 15:11:48 +00:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-01-23 19:32:21 +00:00
|
|
|
#endif /* CONFIG_SMP */
|
2012-10-04 11:18:29 +00:00
|
|
|
|
2007-10-15 15:00:10 +00:00
|
|
|
static void check_spread(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
|
|
|
s64 d = se->vruntime - cfs_rq->min_vruntime;
|
|
|
|
|
|
|
|
if (d < 0)
|
|
|
|
d = -d;
|
|
|
|
|
|
|
|
if (d > 3*sysctl_sched_latency)
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(cfs_rq->nr_spread_over);
|
2007-10-15 15:00:10 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-10-15 15:00:05 +00:00
|
|
|
static void
|
|
|
|
place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
|
|
|
|
{
|
2008-10-24 09:06:13 +00:00
|
|
|
u64 vruntime = cfs_rq->min_vruntime;
|
2007-10-15 15:00:05 +00:00
|
|
|
|
2007-11-09 21:39:37 +00:00
|
|
|
/*
|
|
|
|
* The 'current' period is already promised to the current tasks,
|
|
|
|
* however the extra weight of the new task will slow them down a
|
|
|
|
* little, place the new task so that it fits in the slot that
|
|
|
|
* stays open at the end.
|
|
|
|
*/
|
2007-10-15 15:00:05 +00:00
|
|
|
if (initial && sched_feat(START_DEBIT))
|
2008-10-17 17:27:04 +00:00
|
|
|
vruntime += sched_vslice(cfs_rq, se);
|
2007-10-15 15:00:05 +00:00
|
|
|
|
2009-09-18 07:19:25 +00:00
|
|
|
/* sleeps up to a single latency don't count. */
|
2010-03-11 16:17:17 +00:00
|
|
|
if (!initial) {
|
2009-09-18 07:19:25 +00:00
|
|
|
unsigned long thresh = sysctl_sched_latency;
|
2008-06-27 11:41:11 +00:00
|
|
|
|
2009-09-18 07:19:25 +00:00
|
|
|
/*
|
|
|
|
* Halve their sleep time's effect, to allow
|
|
|
|
* for a gentler effect of sleepers:
|
|
|
|
*/
|
|
|
|
if (sched_feat(GENTLE_FAIR_SLEEPERS))
|
|
|
|
thresh >>= 1;
|
2009-09-16 06:54:45 +00:00
|
|
|
|
2009-09-18 07:19:25 +00:00
|
|
|
vruntime -= thresh;
|
2007-10-15 15:00:05 +00:00
|
|
|
}
|
|
|
|
|
sched: Ensure that a child can't gain time over it's parent after fork()
A fork/exec load is usually "pass the baton", so the child
should never be placed behind the parent. With START_DEBIT we
make room for the new task, but with child_runs_first, that
room comes out of the _parent's_ hide. There's nothing to say
that the parent wasn't ahead of min_vruntime at fork() time,
which means that the "baton carrier", who is essentially the
parent in drag, can gain time and increase scheduling latencies
for waiters.
With NEW_FAIR_SLEEPERS + START_DEBIT + child_runs_first
enabled, we essentially pass the sleeper fairness off to the
child, which is fine, but if we don't base placement on the
parent's updated vruntime, we can end up compounding latency
woes if the child itself then does fork/exec. The debit
incurred at fork doesn't hurt the parent who is then going to
sleep and maybe exit, but the child who acquires the error
harms all comers.
This improves latencies of make -j<n> kernel build workloads.
Reported-by: Jens Axboe <jens.axboe@oracle.com>
Signed-off-by: Mike Galbraith <efault@gmx.de>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-09-08 09:12:28 +00:00
|
|
|
/* ensure we never gain time by being placed backwards. */
|
2012-11-08 08:03:46 +00:00
|
|
|
se->vruntime = max_vruntime(se->vruntime, vruntime);
|
2007-10-15 15:00:05 +00:00
|
|
|
}
|
|
|
|
|
2011-07-21 16:43:39 +00:00
|
|
|
static void check_enqueue_throttle(struct cfs_rq *cfs_rq);
|
|
|
|
|
2016-02-05 09:08:36 +00:00
|
|
|
static inline void check_schedstat_required(void)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SCHEDSTATS
|
|
|
|
if (schedstat_enabled())
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Force schedstat enabled if a dependent tracepoint is active */
|
|
|
|
if (trace_sched_stat_wait_enabled() ||
|
|
|
|
trace_sched_stat_sleep_enabled() ||
|
|
|
|
trace_sched_stat_iowait_enabled() ||
|
|
|
|
trace_sched_stat_blocked_enabled() ||
|
|
|
|
trace_sched_stat_runtime_enabled()) {
|
2016-06-13 07:32:09 +00:00
|
|
|
printk_deferred_once("Scheduler tracepoints stat_sleep, stat_iowait, "
|
2016-02-05 09:08:36 +00:00
|
|
|
"stat_blocked and stat_runtime require the "
|
2017-06-09 08:00:29 +00:00
|
|
|
"kernel parameter schedstats=enable or "
|
2016-02-05 09:08:36 +00:00
|
|
|
"kernel.sched_schedstats=1\n");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-05-11 14:10:34 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* MIGRATION
|
|
|
|
*
|
|
|
|
* dequeue
|
|
|
|
* update_curr()
|
|
|
|
* update_min_vruntime()
|
|
|
|
* vruntime -= min_vruntime
|
|
|
|
*
|
|
|
|
* enqueue
|
|
|
|
* update_curr()
|
|
|
|
* update_min_vruntime()
|
|
|
|
* vruntime += min_vruntime
|
|
|
|
*
|
|
|
|
* this way the vruntime transition between RQs is done when both
|
|
|
|
* min_vruntime are up-to-date.
|
|
|
|
*
|
|
|
|
* WAKEUP (remote)
|
|
|
|
*
|
2016-05-10 16:24:37 +00:00
|
|
|
* ->migrate_task_rq_fair() (p->state == TASK_WAKING)
|
2016-05-11 14:10:34 +00:00
|
|
|
* vruntime -= min_vruntime
|
|
|
|
*
|
|
|
|
* enqueue
|
|
|
|
* update_curr()
|
|
|
|
* update_min_vruntime()
|
|
|
|
* vruntime += min_vruntime
|
|
|
|
*
|
|
|
|
* this way we don't have the most up-to-date min_vruntime on the originating
|
|
|
|
* CPU and an up-to-date min_vruntime on the destination CPU.
|
|
|
|
*/
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
static void
|
sched: Remove the cfs_rq dependency from set_task_cpu()
In order to remove the cfs_rq dependency from set_task_cpu() we
need to ensure the task is cfs_rq invariant for all callsites.
The simple approach is to substract cfs_rq->min_vruntime from
se->vruntime on dequeue, and add cfs_rq->min_vruntime on
enqueue.
However, this has the downside of breaking FAIR_SLEEPERS since
we loose the old vruntime as we only maintain the relative
position.
To solve this, we observe that we only migrate runnable tasks,
we do this using deactivate_task(.sleep=0) and
activate_task(.wakeup=0), therefore we can restrain the
min_vruntime invariance to that state.
The only other case is wakeup balancing, since we want to
maintain the old vruntime we cannot make it relative on dequeue,
but since we don't migrate inactive tasks, we can do so right
before we activate it again.
This is where we need the new pre-wakeup hook, we need to call
this while still holding the old rq->lock. We could fold it into
->select_task_rq(), but since that has multiple callsites and
would obfuscate the locking requirements, that seems like a
fudge.
This leaves the fork() case, simply make sure that ->task_fork()
leaves the ->vruntime in a relative state.
This covers all cases where set_task_cpu() gets called, and
ensures it sees a relative vruntime.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20091216170518.191697025@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 17:04:41 +00:00
|
|
|
enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2016-05-11 17:27:56 +00:00
|
|
|
bool renorm = !(flags & ENQUEUE_WAKEUP) || (flags & ENQUEUE_MIGRATED);
|
|
|
|
bool curr = cfs_rq->curr == se;
|
|
|
|
|
sched: Remove the cfs_rq dependency from set_task_cpu()
In order to remove the cfs_rq dependency from set_task_cpu() we
need to ensure the task is cfs_rq invariant for all callsites.
The simple approach is to substract cfs_rq->min_vruntime from
se->vruntime on dequeue, and add cfs_rq->min_vruntime on
enqueue.
However, this has the downside of breaking FAIR_SLEEPERS since
we loose the old vruntime as we only maintain the relative
position.
To solve this, we observe that we only migrate runnable tasks,
we do this using deactivate_task(.sleep=0) and
activate_task(.wakeup=0), therefore we can restrain the
min_vruntime invariance to that state.
The only other case is wakeup balancing, since we want to
maintain the old vruntime we cannot make it relative on dequeue,
but since we don't migrate inactive tasks, we can do so right
before we activate it again.
This is where we need the new pre-wakeup hook, we need to call
this while still holding the old rq->lock. We could fold it into
->select_task_rq(), but since that has multiple callsites and
would obfuscate the locking requirements, that seems like a
fudge.
This leaves the fork() case, simply make sure that ->task_fork()
leaves the ->vruntime in a relative state.
This covers all cases where set_task_cpu() gets called, and
ensures it sees a relative vruntime.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20091216170518.191697025@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 17:04:41 +00:00
|
|
|
/*
|
2016-05-11 17:27:56 +00:00
|
|
|
* If we're the current task, we must renormalise before calling
|
|
|
|
* update_curr().
|
sched: Remove the cfs_rq dependency from set_task_cpu()
In order to remove the cfs_rq dependency from set_task_cpu() we
need to ensure the task is cfs_rq invariant for all callsites.
The simple approach is to substract cfs_rq->min_vruntime from
se->vruntime on dequeue, and add cfs_rq->min_vruntime on
enqueue.
However, this has the downside of breaking FAIR_SLEEPERS since
we loose the old vruntime as we only maintain the relative
position.
To solve this, we observe that we only migrate runnable tasks,
we do this using deactivate_task(.sleep=0) and
activate_task(.wakeup=0), therefore we can restrain the
min_vruntime invariance to that state.
The only other case is wakeup balancing, since we want to
maintain the old vruntime we cannot make it relative on dequeue,
but since we don't migrate inactive tasks, we can do so right
before we activate it again.
This is where we need the new pre-wakeup hook, we need to call
this while still holding the old rq->lock. We could fold it into
->select_task_rq(), but since that has multiple callsites and
would obfuscate the locking requirements, that seems like a
fudge.
This leaves the fork() case, simply make sure that ->task_fork()
leaves the ->vruntime in a relative state.
This covers all cases where set_task_cpu() gets called, and
ensures it sees a relative vruntime.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20091216170518.191697025@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 17:04:41 +00:00
|
|
|
*/
|
2016-05-11 17:27:56 +00:00
|
|
|
if (renorm && curr)
|
sched: Remove the cfs_rq dependency from set_task_cpu()
In order to remove the cfs_rq dependency from set_task_cpu() we
need to ensure the task is cfs_rq invariant for all callsites.
The simple approach is to substract cfs_rq->min_vruntime from
se->vruntime on dequeue, and add cfs_rq->min_vruntime on
enqueue.
However, this has the downside of breaking FAIR_SLEEPERS since
we loose the old vruntime as we only maintain the relative
position.
To solve this, we observe that we only migrate runnable tasks,
we do this using deactivate_task(.sleep=0) and
activate_task(.wakeup=0), therefore we can restrain the
min_vruntime invariance to that state.
The only other case is wakeup balancing, since we want to
maintain the old vruntime we cannot make it relative on dequeue,
but since we don't migrate inactive tasks, we can do so right
before we activate it again.
This is where we need the new pre-wakeup hook, we need to call
this while still holding the old rq->lock. We could fold it into
->select_task_rq(), but since that has multiple callsites and
would obfuscate the locking requirements, that seems like a
fudge.
This leaves the fork() case, simply make sure that ->task_fork()
leaves the ->vruntime in a relative state.
This covers all cases where set_task_cpu() gets called, and
ensures it sees a relative vruntime.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20091216170518.191697025@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 17:04:41 +00:00
|
|
|
se->vruntime += cfs_rq->min_vruntime;
|
|
|
|
|
2016-05-11 17:27:56 +00:00
|
|
|
update_curr(cfs_rq);
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
2016-05-11 17:27:56 +00:00
|
|
|
* Otherwise, renormalise after, such that we're placed at the current
|
|
|
|
* moment in time, instead of some random moment in the past. Being
|
|
|
|
* placed in the past could significantly boost this task to the
|
|
|
|
* fairness detriment of existing tasks.
|
2007-07-09 16:51:58 +00:00
|
|
|
*/
|
2016-05-11 17:27:56 +00:00
|
|
|
if (renorm && !curr)
|
|
|
|
se->vruntime += cfs_rq->min_vruntime;
|
|
|
|
|
2016-12-21 15:50:26 +00:00
|
|
|
/*
|
|
|
|
* When enqueuing a sched_entity, we must:
|
|
|
|
* - Update loads to have both entity and cfs_rq synced with now.
|
|
|
|
* - Add its load to cfs_rq->runnable_avg
|
|
|
|
* - For group_entity, update its weight to reflect the new share of
|
|
|
|
* its group cfs_rq
|
|
|
|
* - Add its new weight to cfs_rq->load.weight
|
|
|
|
*/
|
2017-05-06 15:37:03 +00:00
|
|
|
update_load_avg(cfs_rq, se, UPDATE_TG | DO_ATTACH);
|
2017-05-06 13:59:54 +00:00
|
|
|
update_cfs_group(se);
|
2017-08-24 15:38:30 +00:00
|
|
|
enqueue_runnable_load_avg(cfs_rq, se);
|
2012-12-14 15:20:43 +00:00
|
|
|
account_entity_enqueue(cfs_rq, se);
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2016-06-17 17:43:23 +00:00
|
|
|
if (flags & ENQUEUE_WAKEUP)
|
2007-10-15 15:00:05 +00:00
|
|
|
place_entity(cfs_rq, se, 0);
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2016-02-05 09:08:36 +00:00
|
|
|
check_schedstat_required();
|
2016-06-17 17:43:26 +00:00
|
|
|
update_stats_enqueue(cfs_rq, se, flags);
|
|
|
|
check_spread(cfs_rq, se);
|
2016-05-11 17:27:56 +00:00
|
|
|
if (!curr)
|
2007-10-15 15:00:08 +00:00
|
|
|
__enqueue_entity(cfs_rq, se);
|
2010-11-15 23:47:00 +00:00
|
|
|
se->on_rq = 1;
|
2010-11-15 23:47:01 +00:00
|
|
|
|
2011-07-21 16:43:39 +00:00
|
|
|
if (cfs_rq->nr_running == 1) {
|
2010-11-15 23:47:01 +00:00
|
|
|
list_add_leaf_cfs_rq(cfs_rq);
|
2011-07-21 16:43:39 +00:00
|
|
|
check_enqueue_throttle(cfs_rq);
|
|
|
|
}
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2011-02-01 14:48:37 +00:00
|
|
|
static void __clear_buddies_last(struct sched_entity *se)
|
2008-11-11 10:52:33 +00:00
|
|
|
{
|
2011-02-01 14:48:37 +00:00
|
|
|
for_each_sched_entity(se) {
|
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
2012-02-11 05:05:00 +00:00
|
|
|
if (cfs_rq->last != se)
|
2011-02-01 14:48:37 +00:00
|
|
|
break;
|
2012-02-11 05:05:00 +00:00
|
|
|
|
|
|
|
cfs_rq->last = NULL;
|
2011-02-01 14:48:37 +00:00
|
|
|
}
|
|
|
|
}
|
2008-11-11 10:52:33 +00:00
|
|
|
|
2011-02-01 14:48:37 +00:00
|
|
|
static void __clear_buddies_next(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
for_each_sched_entity(se) {
|
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
2012-02-11 05:05:00 +00:00
|
|
|
if (cfs_rq->next != se)
|
2011-02-01 14:48:37 +00:00
|
|
|
break;
|
2012-02-11 05:05:00 +00:00
|
|
|
|
|
|
|
cfs_rq->next = NULL;
|
2011-02-01 14:48:37 +00:00
|
|
|
}
|
2008-11-11 10:52:33 +00:00
|
|
|
}
|
|
|
|
|
2011-02-01 14:51:03 +00:00
|
|
|
static void __clear_buddies_skip(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
for_each_sched_entity(se) {
|
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
2012-02-11 05:05:00 +00:00
|
|
|
if (cfs_rq->skip != se)
|
2011-02-01 14:51:03 +00:00
|
|
|
break;
|
2012-02-11 05:05:00 +00:00
|
|
|
|
|
|
|
cfs_rq->skip = NULL;
|
2011-02-01 14:51:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-28 13:51:40 +00:00
|
|
|
static void clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
|
|
|
{
|
2011-02-01 14:48:37 +00:00
|
|
|
if (cfs_rq->last == se)
|
|
|
|
__clear_buddies_last(se);
|
|
|
|
|
|
|
|
if (cfs_rq->next == se)
|
|
|
|
__clear_buddies_next(se);
|
2011-02-01 14:51:03 +00:00
|
|
|
|
|
|
|
if (cfs_rq->skip == se)
|
|
|
|
__clear_buddies_skip(se);
|
2009-01-28 13:51:40 +00:00
|
|
|
}
|
|
|
|
|
2012-03-21 20:07:16 +00:00
|
|
|
static __always_inline void return_cfs_rq_runtime(struct cfs_rq *cfs_rq);
|
2011-07-21 16:43:41 +00:00
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
static void
|
2010-03-24 15:38:48 +00:00
|
|
|
dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2007-10-15 15:00:13 +00:00
|
|
|
/*
|
|
|
|
* Update run-time statistics of the 'current'.
|
|
|
|
*/
|
|
|
|
update_curr(cfs_rq);
|
2016-12-21 15:50:26 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* When dequeuing a sched_entity, we must:
|
|
|
|
* - Update loads to have both entity and cfs_rq synced with now.
|
|
|
|
* - Substract its load from the cfs_rq->runnable_avg.
|
|
|
|
* - Substract its previous weight from cfs_rq->load.weight.
|
|
|
|
* - For group entity, update its weight to reflect the new share
|
|
|
|
* of its group cfs_rq.
|
|
|
|
*/
|
2017-05-06 15:32:43 +00:00
|
|
|
update_load_avg(cfs_rq, se, UPDATE_TG);
|
2017-08-24 15:38:30 +00:00
|
|
|
dequeue_runnable_load_avg(cfs_rq, se);
|
2007-10-15 15:00:13 +00:00
|
|
|
|
2016-06-17 17:43:26 +00:00
|
|
|
update_stats_dequeue(cfs_rq, se, flags);
|
2007-10-15 15:00:10 +00:00
|
|
|
|
2008-11-11 10:52:33 +00:00
|
|
|
clear_buddies(cfs_rq, se);
|
sched: backward looking buddy
Impact: improve/change/fix wakeup-buddy scheduling
Currently we only have a forward looking buddy, that is, we prefer to
schedule to the task we last woke up, under the presumption that its
going to consume the data we just produced, and therefore will have
cache hot benefits.
This allows co-waking producer/consumer task pairs to run ahead of the
pack for a little while, keeping their cache warm. Without this, we
would interleave all pairs, utterly trashing the cache.
This patch introduces a backward looking buddy, that is, suppose that
in the above scenario, the consumer preempts the producer before it
can go to sleep, we will therefore miss the wakeup from consumer to
producer (its already running, after all), breaking the cycle and
reverting to the cache-trashing interleaved schedule pattern.
The backward buddy will try to schedule back to the task that woke us
up in case the forward buddy is not available, under the assumption
that the last task will be the one with the most cache hot task around
barring current.
This will basically allow a task to continue after it got preempted.
In order to avoid starvation, we allow either buddy to get wakeup_gran
ahead of the pack.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Acked-by: Mike Galbraith <efault@gmx.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-04 20:25:09 +00:00
|
|
|
|
2007-10-15 15:00:08 +00:00
|
|
|
if (se != cfs_rq->curr)
|
2007-10-15 15:00:07 +00:00
|
|
|
__dequeue_entity(cfs_rq, se);
|
2012-12-14 15:20:43 +00:00
|
|
|
se->on_rq = 0;
|
2007-10-15 15:00:07 +00:00
|
|
|
account_entity_dequeue(cfs_rq, se);
|
sched: Remove the cfs_rq dependency from set_task_cpu()
In order to remove the cfs_rq dependency from set_task_cpu() we
need to ensure the task is cfs_rq invariant for all callsites.
The simple approach is to substract cfs_rq->min_vruntime from
se->vruntime on dequeue, and add cfs_rq->min_vruntime on
enqueue.
However, this has the downside of breaking FAIR_SLEEPERS since
we loose the old vruntime as we only maintain the relative
position.
To solve this, we observe that we only migrate runnable tasks,
we do this using deactivate_task(.sleep=0) and
activate_task(.wakeup=0), therefore we can restrain the
min_vruntime invariance to that state.
The only other case is wakeup balancing, since we want to
maintain the old vruntime we cannot make it relative on dequeue,
but since we don't migrate inactive tasks, we can do so right
before we activate it again.
This is where we need the new pre-wakeup hook, we need to call
this while still holding the old rq->lock. We could fold it into
->select_task_rq(), but since that has multiple callsites and
would obfuscate the locking requirements, that seems like a
fudge.
This leaves the fork() case, simply make sure that ->task_fork()
leaves the ->vruntime in a relative state.
This covers all cases where set_task_cpu() gets called, and
ensures it sees a relative vruntime.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20091216170518.191697025@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 17:04:41 +00:00
|
|
|
|
|
|
|
/*
|
2016-09-20 19:58:12 +00:00
|
|
|
* Normalize after update_curr(); which will also have moved
|
|
|
|
* min_vruntime if @se is the one holding it back. But before doing
|
|
|
|
* update_min_vruntime() again, which will discount @se's position and
|
|
|
|
* can move min_vruntime forward still more.
|
sched: Remove the cfs_rq dependency from set_task_cpu()
In order to remove the cfs_rq dependency from set_task_cpu() we
need to ensure the task is cfs_rq invariant for all callsites.
The simple approach is to substract cfs_rq->min_vruntime from
se->vruntime on dequeue, and add cfs_rq->min_vruntime on
enqueue.
However, this has the downside of breaking FAIR_SLEEPERS since
we loose the old vruntime as we only maintain the relative
position.
To solve this, we observe that we only migrate runnable tasks,
we do this using deactivate_task(.sleep=0) and
activate_task(.wakeup=0), therefore we can restrain the
min_vruntime invariance to that state.
The only other case is wakeup balancing, since we want to
maintain the old vruntime we cannot make it relative on dequeue,
but since we don't migrate inactive tasks, we can do so right
before we activate it again.
This is where we need the new pre-wakeup hook, we need to call
this while still holding the old rq->lock. We could fold it into
->select_task_rq(), but since that has multiple callsites and
would obfuscate the locking requirements, that seems like a
fudge.
This leaves the fork() case, simply make sure that ->task_fork()
leaves the ->vruntime in a relative state.
This covers all cases where set_task_cpu() gets called, and
ensures it sees a relative vruntime.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20091216170518.191697025@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 17:04:41 +00:00
|
|
|
*/
|
2010-03-24 15:38:48 +00:00
|
|
|
if (!(flags & DEQUEUE_SLEEP))
|
sched: Remove the cfs_rq dependency from set_task_cpu()
In order to remove the cfs_rq dependency from set_task_cpu() we
need to ensure the task is cfs_rq invariant for all callsites.
The simple approach is to substract cfs_rq->min_vruntime from
se->vruntime on dequeue, and add cfs_rq->min_vruntime on
enqueue.
However, this has the downside of breaking FAIR_SLEEPERS since
we loose the old vruntime as we only maintain the relative
position.
To solve this, we observe that we only migrate runnable tasks,
we do this using deactivate_task(.sleep=0) and
activate_task(.wakeup=0), therefore we can restrain the
min_vruntime invariance to that state.
The only other case is wakeup balancing, since we want to
maintain the old vruntime we cannot make it relative on dequeue,
but since we don't migrate inactive tasks, we can do so right
before we activate it again.
This is where we need the new pre-wakeup hook, we need to call
this while still holding the old rq->lock. We could fold it into
->select_task_rq(), but since that has multiple callsites and
would obfuscate the locking requirements, that seems like a
fudge.
This leaves the fork() case, simply make sure that ->task_fork()
leaves the ->vruntime in a relative state.
This covers all cases where set_task_cpu() gets called, and
ensures it sees a relative vruntime.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20091216170518.191697025@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 17:04:41 +00:00
|
|
|
se->vruntime -= cfs_rq->min_vruntime;
|
2011-05-17 23:21:10 +00:00
|
|
|
|
2011-07-21 16:43:41 +00:00
|
|
|
/* return excess runtime on last dequeue */
|
|
|
|
return_cfs_rq_runtime(cfs_rq);
|
|
|
|
|
2017-05-06 13:59:54 +00:00
|
|
|
update_cfs_group(se);
|
2016-09-20 19:58:12 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Now advance min_vruntime if @se was the entity holding it back,
|
|
|
|
* except when: DEQUEUE_SAVE && !DEQUEUE_MOVE, in this case we'll be
|
|
|
|
* put back on, and if we advance min_vruntime, we'll be placed back
|
|
|
|
* further than we started -- ie. we'll be penalized.
|
|
|
|
*/
|
|
|
|
if ((flags & (DEQUEUE_SAVE | DEQUEUE_MOVE)) == DEQUEUE_SAVE)
|
|
|
|
update_min_vruntime(cfs_rq);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Preempt the current task with a newly woken task if needed:
|
|
|
|
*/
|
2007-09-05 12:32:49 +00:00
|
|
|
static void
|
2007-10-15 15:00:05 +00:00
|
|
|
check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2007-09-05 12:32:49 +00:00
|
|
|
unsigned long ideal_runtime, delta_exec;
|
2011-09-16 17:35:52 +00:00
|
|
|
struct sched_entity *se;
|
|
|
|
s64 delta;
|
2007-09-05 12:32:49 +00:00
|
|
|
|
2007-10-15 15:00:05 +00:00
|
|
|
ideal_runtime = sched_slice(cfs_rq, curr);
|
2007-09-05 12:32:49 +00:00
|
|
|
delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
|
2009-01-28 13:51:39 +00:00
|
|
|
if (delta_exec > ideal_runtime) {
|
2014-06-28 20:03:57 +00:00
|
|
|
resched_curr(rq_of(cfs_rq));
|
2009-01-28 13:51:39 +00:00
|
|
|
/*
|
|
|
|
* The current task ran long enough, ensure it doesn't get
|
|
|
|
* re-elected due to buddy favours.
|
|
|
|
*/
|
|
|
|
clear_buddies(cfs_rq, curr);
|
sched: Strengthen buddies and mitigate buddy induced latencies
This patch restores the effectiveness of LAST_BUDDY in preventing
pgsql+oltp from collapsing due to wakeup preemption. It also
switches LAST_BUDDY to exclusively do what it does best, namely
mitigate the effects of aggressive wakeup preemption, which
improves vmark throughput markedly, and restores mysql+oltp
scalability.
Since buddies are about scalability, enable them beginning at the
point where we begin expanding sched_latency, namely
sched_nr_latency. Previously, buddies were cleared aggressively,
which seriously reduced their effectiveness. Not clearing
aggressively however, produces a small drop in mysql+oltp
throughput immediately after peak, indicating that LAST_BUDDY is
actually doing some harm. This is right at the point where X on the
desktop in competition with another load wants low latency service.
Ergo, do not enable until we need to scale.
To mitigate latency induced by buddies, or by a task just missing
wakeup preemption, check latency at tick time.
Last hunk prevents buddies from stymieing BALANCE_NEWIDLE via
CACHE_HOT_BUDDY.
Supporting performance tests:
tip = v2.6.32-rc5-1497-ga525b32
tipx = NO_GENTLE_FAIR_SLEEPERS NEXT_BUDDY granularity knobs = 31 knobs + 31 buddies
tip+x = NO_GENTLE_FAIR_SLEEPERS granularity knobs = 31 knobs
(Three run averages except where noted.)
vmark:
------
tip 108466 messages per second
tip+ 125307 messages per second
tip+x 125335 messages per second
tipx 117781 messages per second
2.6.31.3 122729 messages per second
mysql+oltp:
-----------
clients 1 2 4 8 16 32 64 128 256
..........................................................................................
tip 9949.89 18690.20 34801.24 34460.04 32682.88 30765.97 28305.27 25059.64 19548.08
tip+ 10013.90 18526.84 34900.38 34420.14 33069.83 32083.40 30578.30 28010.71 25605.47
tipx 9698.71 18002.70 34477.56 33420.01 32634.30 31657.27 29932.67 26827.52 21487.18
2.6.31.3 8243.11 18784.20 34404.83 33148.38 31900.32 31161.90 29663.81 25995.94 18058.86
pgsql+oltp:
-----------
clients 1 2 4 8 16 32 64 128 256
..........................................................................................
tip 13686.37 26609.25 51934.28 51347.81 49479.51 45312.65 36691.91 26851.57 24145.35
tip+ (1x) 13907.85 27135.87 52951.98 52514.04 51742.52 50705.43 49947.97 48374.19 46227.94
tip+x 13906.78 27065.81 52951.19 52542.59 52176.11 51815.94 50838.90 49439.46 46891.00
tipx 13742.46 26769.81 52351.99 51891.73 51320.79 50938.98 50248.65 48908.70 46553.84
2.6.31.3 13815.35 26906.46 52683.34 52061.31 51937.10 51376.80 50474.28 49394.47 47003.25
Signed-off-by: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-23 21:09:22 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ensure that a task that missed wakeup preemption by a
|
|
|
|
* narrow margin doesn't have to wait for a full slice.
|
|
|
|
* This also mitigates buddy induced latencies under load.
|
|
|
|
*/
|
|
|
|
if (delta_exec < sysctl_sched_min_granularity)
|
|
|
|
return;
|
|
|
|
|
2011-09-16 17:35:52 +00:00
|
|
|
se = __pick_first_entity(cfs_rq);
|
|
|
|
delta = curr->vruntime - se->vruntime;
|
sched: Strengthen buddies and mitigate buddy induced latencies
This patch restores the effectiveness of LAST_BUDDY in preventing
pgsql+oltp from collapsing due to wakeup preemption. It also
switches LAST_BUDDY to exclusively do what it does best, namely
mitigate the effects of aggressive wakeup preemption, which
improves vmark throughput markedly, and restores mysql+oltp
scalability.
Since buddies are about scalability, enable them beginning at the
point where we begin expanding sched_latency, namely
sched_nr_latency. Previously, buddies were cleared aggressively,
which seriously reduced their effectiveness. Not clearing
aggressively however, produces a small drop in mysql+oltp
throughput immediately after peak, indicating that LAST_BUDDY is
actually doing some harm. This is right at the point where X on the
desktop in competition with another load wants low latency service.
Ergo, do not enable until we need to scale.
To mitigate latency induced by buddies, or by a task just missing
wakeup preemption, check latency at tick time.
Last hunk prevents buddies from stymieing BALANCE_NEWIDLE via
CACHE_HOT_BUDDY.
Supporting performance tests:
tip = v2.6.32-rc5-1497-ga525b32
tipx = NO_GENTLE_FAIR_SLEEPERS NEXT_BUDDY granularity knobs = 31 knobs + 31 buddies
tip+x = NO_GENTLE_FAIR_SLEEPERS granularity knobs = 31 knobs
(Three run averages except where noted.)
vmark:
------
tip 108466 messages per second
tip+ 125307 messages per second
tip+x 125335 messages per second
tipx 117781 messages per second
2.6.31.3 122729 messages per second
mysql+oltp:
-----------
clients 1 2 4 8 16 32 64 128 256
..........................................................................................
tip 9949.89 18690.20 34801.24 34460.04 32682.88 30765.97 28305.27 25059.64 19548.08
tip+ 10013.90 18526.84 34900.38 34420.14 33069.83 32083.40 30578.30 28010.71 25605.47
tipx 9698.71 18002.70 34477.56 33420.01 32634.30 31657.27 29932.67 26827.52 21487.18
2.6.31.3 8243.11 18784.20 34404.83 33148.38 31900.32 31161.90 29663.81 25995.94 18058.86
pgsql+oltp:
-----------
clients 1 2 4 8 16 32 64 128 256
..........................................................................................
tip 13686.37 26609.25 51934.28 51347.81 49479.51 45312.65 36691.91 26851.57 24145.35
tip+ (1x) 13907.85 27135.87 52951.98 52514.04 51742.52 50705.43 49947.97 48374.19 46227.94
tip+x 13906.78 27065.81 52951.19 52542.59 52176.11 51815.94 50838.90 49439.46 46891.00
tipx 13742.46 26769.81 52351.99 51891.73 51320.79 50938.98 50248.65 48908.70 46553.84
2.6.31.3 13815.35 26906.46 52683.34 52061.31 51937.10 51376.80 50474.28 49394.47 47003.25
Signed-off-by: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-23 21:09:22 +00:00
|
|
|
|
2011-09-16 17:35:52 +00:00
|
|
|
if (delta < 0)
|
|
|
|
return;
|
2011-01-05 04:41:17 +00:00
|
|
|
|
2011-09-16 17:35:52 +00:00
|
|
|
if (delta > ideal_runtime)
|
2014-06-28 20:03:57 +00:00
|
|
|
resched_curr(rq_of(cfs_rq));
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2007-10-15 15:00:08 +00:00
|
|
|
static void
|
2007-08-09 09:16:48 +00:00
|
|
|
set_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2007-10-15 15:00:08 +00:00
|
|
|
/* 'current' is not kept within the tree. */
|
|
|
|
if (se->on_rq) {
|
|
|
|
/*
|
|
|
|
* Any task has to be enqueued before it get to execute on
|
|
|
|
* a CPU. So account for the time it spent waiting on the
|
|
|
|
* runqueue.
|
|
|
|
*/
|
2016-06-17 17:43:26 +00:00
|
|
|
update_stats_wait_end(cfs_rq, se);
|
2007-10-15 15:00:08 +00:00
|
|
|
__dequeue_entity(cfs_rq, se);
|
2017-05-06 15:32:43 +00:00
|
|
|
update_load_avg(cfs_rq, se, UPDATE_TG);
|
2007-10-15 15:00:08 +00:00
|
|
|
}
|
|
|
|
|
2007-08-09 09:16:47 +00:00
|
|
|
update_stats_curr_start(cfs_rq, se);
|
2007-10-15 15:00:03 +00:00
|
|
|
cfs_rq->curr = se;
|
2016-06-17 17:43:26 +00:00
|
|
|
|
2007-10-15 15:00:02 +00:00
|
|
|
/*
|
|
|
|
* Track our maximum slice length, if the CPU's load is at
|
|
|
|
* least twice that of our own weight (i.e. dont track it
|
|
|
|
* when there are only lesser-weight tasks around):
|
|
|
|
*/
|
2016-02-05 09:08:36 +00:00
|
|
|
if (schedstat_enabled() && rq_of(cfs_rq)->load.weight >= 2*se->load.weight) {
|
2016-06-17 17:43:26 +00:00
|
|
|
schedstat_set(se->statistics.slice_max,
|
|
|
|
max((u64)schedstat_val(se->statistics.slice_max),
|
|
|
|
se->sum_exec_runtime - se->prev_sum_exec_runtime));
|
2007-10-15 15:00:02 +00:00
|
|
|
}
|
2016-06-17 17:43:26 +00:00
|
|
|
|
2007-09-05 12:32:49 +00:00
|
|
|
se->prev_sum_exec_runtime = se->sum_exec_runtime;
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2008-10-24 09:06:16 +00:00
|
|
|
static int
|
|
|
|
wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se);
|
|
|
|
|
2011-02-01 14:51:03 +00:00
|
|
|
/*
|
|
|
|
* Pick the next process, keeping these things in mind, in this order:
|
|
|
|
* 1) keep things fair between processes/task groups
|
|
|
|
* 2) pick the "next" process, since someone really wants that to run
|
|
|
|
* 3) pick the "last" process, for cache locality
|
|
|
|
* 4) do not run the "skip" process, if something else is available
|
|
|
|
*/
|
2012-02-11 05:05:00 +00:00
|
|
|
static struct sched_entity *
|
|
|
|
pick_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *curr)
|
2008-03-14 20:12:12 +00:00
|
|
|
{
|
2012-02-11 05:05:00 +00:00
|
|
|
struct sched_entity *left = __pick_first_entity(cfs_rq);
|
|
|
|
struct sched_entity *se;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If curr is set we have to see if its left of the leftmost entity
|
|
|
|
* still in the tree, provided there was anything in the tree at all.
|
|
|
|
*/
|
|
|
|
if (!left || (curr && entity_before(curr, left)))
|
|
|
|
left = curr;
|
|
|
|
|
|
|
|
se = left; /* ideally we run the leftmost entity */
|
2008-11-04 20:25:07 +00:00
|
|
|
|
2011-02-01 14:51:03 +00:00
|
|
|
/*
|
|
|
|
* Avoid running the skip buddy, if running something else can
|
|
|
|
* be done without getting too unfair.
|
|
|
|
*/
|
|
|
|
if (cfs_rq->skip == se) {
|
2012-02-11 05:05:00 +00:00
|
|
|
struct sched_entity *second;
|
|
|
|
|
|
|
|
if (se == curr) {
|
|
|
|
second = __pick_first_entity(cfs_rq);
|
|
|
|
} else {
|
|
|
|
second = __pick_next_entity(se);
|
|
|
|
if (!second || (curr && entity_before(curr, second)))
|
|
|
|
second = curr;
|
|
|
|
}
|
|
|
|
|
2011-02-01 14:51:03 +00:00
|
|
|
if (second && wakeup_preempt_entity(second, left) < 1)
|
|
|
|
se = second;
|
|
|
|
}
|
2008-03-14 20:12:12 +00:00
|
|
|
|
sched: Strengthen buddies and mitigate buddy induced latencies
This patch restores the effectiveness of LAST_BUDDY in preventing
pgsql+oltp from collapsing due to wakeup preemption. It also
switches LAST_BUDDY to exclusively do what it does best, namely
mitigate the effects of aggressive wakeup preemption, which
improves vmark throughput markedly, and restores mysql+oltp
scalability.
Since buddies are about scalability, enable them beginning at the
point where we begin expanding sched_latency, namely
sched_nr_latency. Previously, buddies were cleared aggressively,
which seriously reduced their effectiveness. Not clearing
aggressively however, produces a small drop in mysql+oltp
throughput immediately after peak, indicating that LAST_BUDDY is
actually doing some harm. This is right at the point where X on the
desktop in competition with another load wants low latency service.
Ergo, do not enable until we need to scale.
To mitigate latency induced by buddies, or by a task just missing
wakeup preemption, check latency at tick time.
Last hunk prevents buddies from stymieing BALANCE_NEWIDLE via
CACHE_HOT_BUDDY.
Supporting performance tests:
tip = v2.6.32-rc5-1497-ga525b32
tipx = NO_GENTLE_FAIR_SLEEPERS NEXT_BUDDY granularity knobs = 31 knobs + 31 buddies
tip+x = NO_GENTLE_FAIR_SLEEPERS granularity knobs = 31 knobs
(Three run averages except where noted.)
vmark:
------
tip 108466 messages per second
tip+ 125307 messages per second
tip+x 125335 messages per second
tipx 117781 messages per second
2.6.31.3 122729 messages per second
mysql+oltp:
-----------
clients 1 2 4 8 16 32 64 128 256
..........................................................................................
tip 9949.89 18690.20 34801.24 34460.04 32682.88 30765.97 28305.27 25059.64 19548.08
tip+ 10013.90 18526.84 34900.38 34420.14 33069.83 32083.40 30578.30 28010.71 25605.47
tipx 9698.71 18002.70 34477.56 33420.01 32634.30 31657.27 29932.67 26827.52 21487.18
2.6.31.3 8243.11 18784.20 34404.83 33148.38 31900.32 31161.90 29663.81 25995.94 18058.86
pgsql+oltp:
-----------
clients 1 2 4 8 16 32 64 128 256
..........................................................................................
tip 13686.37 26609.25 51934.28 51347.81 49479.51 45312.65 36691.91 26851.57 24145.35
tip+ (1x) 13907.85 27135.87 52951.98 52514.04 51742.52 50705.43 49947.97 48374.19 46227.94
tip+x 13906.78 27065.81 52951.19 52542.59 52176.11 51815.94 50838.90 49439.46 46891.00
tipx 13742.46 26769.81 52351.99 51891.73 51320.79 50938.98 50248.65 48908.70 46553.84
2.6.31.3 13815.35 26906.46 52683.34 52061.31 51937.10 51376.80 50474.28 49394.47 47003.25
Signed-off-by: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-23 21:09:22 +00:00
|
|
|
/*
|
|
|
|
* Prefer last buddy, try to return the CPU to a preempted task.
|
|
|
|
*/
|
|
|
|
if (cfs_rq->last && wakeup_preempt_entity(cfs_rq->last, left) < 1)
|
|
|
|
se = cfs_rq->last;
|
|
|
|
|
2011-02-01 14:51:03 +00:00
|
|
|
/*
|
|
|
|
* Someone really wants this to run. If it's not unfair, run it.
|
|
|
|
*/
|
|
|
|
if (cfs_rq->next && wakeup_preempt_entity(cfs_rq->next, left) < 1)
|
|
|
|
se = cfs_rq->next;
|
|
|
|
|
sched: Strengthen buddies and mitigate buddy induced latencies
This patch restores the effectiveness of LAST_BUDDY in preventing
pgsql+oltp from collapsing due to wakeup preemption. It also
switches LAST_BUDDY to exclusively do what it does best, namely
mitigate the effects of aggressive wakeup preemption, which
improves vmark throughput markedly, and restores mysql+oltp
scalability.
Since buddies are about scalability, enable them beginning at the
point where we begin expanding sched_latency, namely
sched_nr_latency. Previously, buddies were cleared aggressively,
which seriously reduced their effectiveness. Not clearing
aggressively however, produces a small drop in mysql+oltp
throughput immediately after peak, indicating that LAST_BUDDY is
actually doing some harm. This is right at the point where X on the
desktop in competition with another load wants low latency service.
Ergo, do not enable until we need to scale.
To mitigate latency induced by buddies, or by a task just missing
wakeup preemption, check latency at tick time.
Last hunk prevents buddies from stymieing BALANCE_NEWIDLE via
CACHE_HOT_BUDDY.
Supporting performance tests:
tip = v2.6.32-rc5-1497-ga525b32
tipx = NO_GENTLE_FAIR_SLEEPERS NEXT_BUDDY granularity knobs = 31 knobs + 31 buddies
tip+x = NO_GENTLE_FAIR_SLEEPERS granularity knobs = 31 knobs
(Three run averages except where noted.)
vmark:
------
tip 108466 messages per second
tip+ 125307 messages per second
tip+x 125335 messages per second
tipx 117781 messages per second
2.6.31.3 122729 messages per second
mysql+oltp:
-----------
clients 1 2 4 8 16 32 64 128 256
..........................................................................................
tip 9949.89 18690.20 34801.24 34460.04 32682.88 30765.97 28305.27 25059.64 19548.08
tip+ 10013.90 18526.84 34900.38 34420.14 33069.83 32083.40 30578.30 28010.71 25605.47
tipx 9698.71 18002.70 34477.56 33420.01 32634.30 31657.27 29932.67 26827.52 21487.18
2.6.31.3 8243.11 18784.20 34404.83 33148.38 31900.32 31161.90 29663.81 25995.94 18058.86
pgsql+oltp:
-----------
clients 1 2 4 8 16 32 64 128 256
..........................................................................................
tip 13686.37 26609.25 51934.28 51347.81 49479.51 45312.65 36691.91 26851.57 24145.35
tip+ (1x) 13907.85 27135.87 52951.98 52514.04 51742.52 50705.43 49947.97 48374.19 46227.94
tip+x 13906.78 27065.81 52951.19 52542.59 52176.11 51815.94 50838.90 49439.46 46891.00
tipx 13742.46 26769.81 52351.99 51891.73 51320.79 50938.98 50248.65 48908.70 46553.84
2.6.31.3 13815.35 26906.46 52683.34 52061.31 51937.10 51376.80 50474.28 49394.47 47003.25
Signed-off-by: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-23 21:09:22 +00:00
|
|
|
clear_buddies(cfs_rq, se);
|
sched: backward looking buddy
Impact: improve/change/fix wakeup-buddy scheduling
Currently we only have a forward looking buddy, that is, we prefer to
schedule to the task we last woke up, under the presumption that its
going to consume the data we just produced, and therefore will have
cache hot benefits.
This allows co-waking producer/consumer task pairs to run ahead of the
pack for a little while, keeping their cache warm. Without this, we
would interleave all pairs, utterly trashing the cache.
This patch introduces a backward looking buddy, that is, suppose that
in the above scenario, the consumer preempts the producer before it
can go to sleep, we will therefore miss the wakeup from consumer to
producer (its already running, after all), breaking the cycle and
reverting to the cache-trashing interleaved schedule pattern.
The backward buddy will try to schedule back to the task that woke us
up in case the forward buddy is not available, under the assumption
that the last task will be the one with the most cache hot task around
barring current.
This will basically allow a task to continue after it got preempted.
In order to avoid starvation, we allow either buddy to get wakeup_gran
ahead of the pack.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Acked-by: Mike Galbraith <efault@gmx.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-04 20:25:09 +00:00
|
|
|
|
|
|
|
return se;
|
2008-03-14 20:12:12 +00:00
|
|
|
}
|
|
|
|
|
2012-02-11 05:05:00 +00:00
|
|
|
static bool check_cfs_rq_runtime(struct cfs_rq *cfs_rq);
|
2011-07-21 16:43:39 +00:00
|
|
|
|
2007-08-09 09:16:48 +00:00
|
|
|
static void put_prev_entity(struct cfs_rq *cfs_rq, struct sched_entity *prev)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* If still on the runqueue then deactivate_task()
|
|
|
|
* was not called and update_curr() has to be done:
|
|
|
|
*/
|
|
|
|
if (prev->on_rq)
|
2007-08-09 09:16:47 +00:00
|
|
|
update_curr(cfs_rq);
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2011-07-21 16:43:39 +00:00
|
|
|
/* throttle cfs_rqs exceeding runtime */
|
|
|
|
check_cfs_rq_runtime(cfs_rq);
|
|
|
|
|
2016-06-17 17:43:26 +00:00
|
|
|
check_spread(cfs_rq, prev);
|
2016-02-05 09:08:36 +00:00
|
|
|
|
2007-10-15 15:00:07 +00:00
|
|
|
if (prev->on_rq) {
|
2016-06-17 17:43:26 +00:00
|
|
|
update_stats_wait_start(cfs_rq, prev);
|
2007-10-15 15:00:07 +00:00
|
|
|
/* Put 'current' back into the tree. */
|
|
|
|
__enqueue_entity(cfs_rq, prev);
|
2012-10-04 11:18:29 +00:00
|
|
|
/* in !on_rq case, update occurred at dequeue */
|
2017-05-06 15:32:43 +00:00
|
|
|
update_load_avg(cfs_rq, prev, 0);
|
2007-10-15 15:00:07 +00:00
|
|
|
}
|
2007-10-15 15:00:03 +00:00
|
|
|
cfs_rq->curr = NULL;
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2008-01-25 20:08:29 +00:00
|
|
|
static void
|
|
|
|
entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr, int queued)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
|
|
|
/*
|
2007-10-15 15:00:07 +00:00
|
|
|
* Update run-time statistics of the 'current'.
|
2007-07-09 16:51:58 +00:00
|
|
|
*/
|
2007-10-15 15:00:07 +00:00
|
|
|
update_curr(cfs_rq);
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2012-10-04 11:18:29 +00:00
|
|
|
/*
|
|
|
|
* Ensure that runnable average is periodically updated.
|
|
|
|
*/
|
2017-05-06 15:32:43 +00:00
|
|
|
update_load_avg(cfs_rq, curr, UPDATE_TG);
|
2017-05-06 13:59:54 +00:00
|
|
|
update_cfs_group(curr);
|
2012-10-04 11:18:29 +00:00
|
|
|
|
2008-01-25 20:08:29 +00:00
|
|
|
#ifdef CONFIG_SCHED_HRTICK
|
|
|
|
/*
|
|
|
|
* queued ticks are scheduled to match the slice, so don't bother
|
|
|
|
* validating it and just reschedule.
|
|
|
|
*/
|
2008-04-25 01:17:55 +00:00
|
|
|
if (queued) {
|
2014-06-28 20:03:57 +00:00
|
|
|
resched_curr(rq_of(cfs_rq));
|
2008-04-25 01:17:55 +00:00
|
|
|
return;
|
|
|
|
}
|
2008-01-25 20:08:29 +00:00
|
|
|
/*
|
|
|
|
* don't let the period tick interfere with the hrtick preemption
|
|
|
|
*/
|
|
|
|
if (!sched_feat(DOUBLE_TICK) &&
|
|
|
|
hrtimer_active(&rq_of(cfs_rq)->hrtick_timer))
|
|
|
|
return;
|
|
|
|
#endif
|
|
|
|
|
2011-07-29 08:20:33 +00:00
|
|
|
if (cfs_rq->nr_running > 1)
|
2007-10-15 15:00:05 +00:00
|
|
|
check_preempt_tick(cfs_rq, curr);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2011-07-21 16:43:28 +00:00
|
|
|
|
|
|
|
/**************************************************
|
|
|
|
* CFS bandwidth control machinery
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef CONFIG_CFS_BANDWIDTH
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_JUMP_LABEL
|
2012-02-24 07:31:31 +00:00
|
|
|
static struct static_key __cfs_bandwidth_used;
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
static inline bool cfs_bandwidth_used(void)
|
|
|
|
{
|
2012-02-24 07:31:31 +00:00
|
|
|
return static_key_false(&__cfs_bandwidth_used);
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
2013-10-16 18:16:12 +00:00
|
|
|
void cfs_bandwidth_usage_inc(void)
|
2011-10-25 08:00:11 +00:00
|
|
|
{
|
2018-01-22 21:53:28 +00:00
|
|
|
static_key_slow_inc_cpuslocked(&__cfs_bandwidth_used);
|
2013-10-16 18:16:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void cfs_bandwidth_usage_dec(void)
|
|
|
|
{
|
2018-01-22 21:53:28 +00:00
|
|
|
static_key_slow_dec_cpuslocked(&__cfs_bandwidth_used);
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
#else /* HAVE_JUMP_LABEL */
|
|
|
|
static bool cfs_bandwidth_used(void)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-10-16 18:16:12 +00:00
|
|
|
void cfs_bandwidth_usage_inc(void) {}
|
|
|
|
void cfs_bandwidth_usage_dec(void) {}
|
2011-10-25 08:00:11 +00:00
|
|
|
#endif /* HAVE_JUMP_LABEL */
|
|
|
|
|
2011-07-21 16:43:28 +00:00
|
|
|
/*
|
|
|
|
* default period for cfs group bandwidth.
|
|
|
|
* default: 0.1s, units: nanoseconds
|
|
|
|
*/
|
|
|
|
static inline u64 default_cfs_period(void)
|
|
|
|
{
|
|
|
|
return 100000000ULL;
|
|
|
|
}
|
2011-07-21 16:43:30 +00:00
|
|
|
|
|
|
|
static inline u64 sched_cfs_bandwidth_slice(void)
|
|
|
|
{
|
|
|
|
return (u64)sysctl_sched_cfs_bandwidth_slice * NSEC_PER_USEC;
|
|
|
|
}
|
|
|
|
|
2011-07-21 16:43:32 +00:00
|
|
|
/*
|
|
|
|
* Replenish runtime according to assigned quota and update expiration time.
|
|
|
|
* We use sched_clock_cpu directly instead of rq->clock to avoid adding
|
|
|
|
* additional synchronization around rq->lock.
|
|
|
|
*
|
|
|
|
* requires cfs_b->lock
|
|
|
|
*/
|
2011-10-25 08:00:11 +00:00
|
|
|
void __refill_cfs_bandwidth_runtime(struct cfs_bandwidth *cfs_b)
|
2011-07-21 16:43:32 +00:00
|
|
|
{
|
|
|
|
u64 now;
|
|
|
|
|
|
|
|
if (cfs_b->quota == RUNTIME_INF)
|
|
|
|
return;
|
|
|
|
|
|
|
|
now = sched_clock_cpu(smp_processor_id());
|
|
|
|
cfs_b->runtime = cfs_b->quota;
|
|
|
|
cfs_b->runtime_expires = now + ktime_to_ns(cfs_b->period);
|
|
|
|
}
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
static inline struct cfs_bandwidth *tg_cfs_bandwidth(struct task_group *tg)
|
|
|
|
{
|
|
|
|
return &tg->cfs_bandwidth;
|
|
|
|
}
|
|
|
|
|
2012-10-04 11:18:31 +00:00
|
|
|
/* rq->task_clock normalized against any time this cfs_rq has spent throttled */
|
|
|
|
static inline u64 cfs_rq_clock_task(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
|
|
|
if (unlikely(cfs_rq->throttle_count))
|
2016-05-10 13:03:18 +00:00
|
|
|
return cfs_rq->throttled_clock_task - cfs_rq->throttled_clock_task_time;
|
2012-10-04 11:18:31 +00:00
|
|
|
|
2013-04-11 23:51:02 +00:00
|
|
|
return rq_clock_task(rq_of(cfs_rq)) - cfs_rq->throttled_clock_task_time;
|
2012-10-04 11:18:31 +00:00
|
|
|
}
|
|
|
|
|
2011-07-21 16:43:33 +00:00
|
|
|
/* returns 0 on failure to allocate runtime */
|
|
|
|
static int assign_cfs_rq_runtime(struct cfs_rq *cfs_rq)
|
2011-07-21 16:43:30 +00:00
|
|
|
{
|
|
|
|
struct task_group *tg = cfs_rq->tg;
|
|
|
|
struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(tg);
|
2011-07-21 16:43:32 +00:00
|
|
|
u64 amount = 0, min_amount, expires;
|
2011-07-21 16:43:30 +00:00
|
|
|
|
|
|
|
/* note: this is a positive sum as runtime_remaining <= 0 */
|
|
|
|
min_amount = sched_cfs_bandwidth_slice() - cfs_rq->runtime_remaining;
|
|
|
|
|
|
|
|
raw_spin_lock(&cfs_b->lock);
|
|
|
|
if (cfs_b->quota == RUNTIME_INF)
|
|
|
|
amount = min_amount;
|
2011-07-21 16:43:31 +00:00
|
|
|
else {
|
sched: Cleanup bandwidth timers
Roman reported a 3 cpu lockup scenario involving __start_cfs_bandwidth().
The more I look at that code the more I'm convinced its crack, that
entire __start_cfs_bandwidth() thing is brain melting, we don't need to
cancel a timer before starting it, *hrtimer_start*() will happily remove
the timer for you if its still enqueued.
Removing that, removes a big part of the problem, no more ugly cancel
loop to get stuck in.
So now, if I understand things right, the entire reason you have this
cfs_b->lock guarded ->timer_active nonsense is to make sure we don't
accidentally lose the timer.
It appears to me that it should be possible to guarantee that same by
unconditionally (re)starting the timer when !queued. Because regardless
what hrtimer::function will return, if we beat it to (re)enqueue the
timer, it doesn't matter.
Now, because hrtimers don't come with any serialization guarantees we
must ensure both handler and (re)start loop serialize their access to
the hrtimer to avoid both trying to forward the timer at the same
time.
Update the rt bandwidth timer to match.
This effectively reverts: 09dc4ab03936 ("sched/fair: Fix
tg_set_cfs_bandwidth() deadlock on rq->lock").
Reported-by: Roman Gushchin <klamm@yandex-team.ru>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Ben Segall <bsegall@google.com>
Cc: Paul Turner <pjt@google.com>
Link: http://lkml.kernel.org/r/20150415095011.804589208@infradead.org
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-04-15 09:41:57 +00:00
|
|
|
start_cfs_bandwidth(cfs_b);
|
2011-07-21 16:43:31 +00:00
|
|
|
|
|
|
|
if (cfs_b->runtime > 0) {
|
|
|
|
amount = min(cfs_b->runtime, min_amount);
|
|
|
|
cfs_b->runtime -= amount;
|
|
|
|
cfs_b->idle = 0;
|
|
|
|
}
|
2011-07-21 16:43:30 +00:00
|
|
|
}
|
2011-07-21 16:43:32 +00:00
|
|
|
expires = cfs_b->runtime_expires;
|
2011-07-21 16:43:30 +00:00
|
|
|
raw_spin_unlock(&cfs_b->lock);
|
|
|
|
|
|
|
|
cfs_rq->runtime_remaining += amount;
|
2011-07-21 16:43:32 +00:00
|
|
|
/*
|
|
|
|
* we may have advanced our local expiration to account for allowed
|
|
|
|
* spread between our sched_clock and the one on which runtime was
|
|
|
|
* issued.
|
|
|
|
*/
|
|
|
|
if ((s64)(expires - cfs_rq->runtime_expires) > 0)
|
|
|
|
cfs_rq->runtime_expires = expires;
|
2011-07-21 16:43:33 +00:00
|
|
|
|
|
|
|
return cfs_rq->runtime_remaining > 0;
|
2011-07-21 16:43:30 +00:00
|
|
|
}
|
|
|
|
|
2011-07-21 16:43:32 +00:00
|
|
|
/*
|
|
|
|
* Note: This depends on the synchronization provided by sched_clock and the
|
|
|
|
* fact that rq->clock snapshots this value.
|
|
|
|
*/
|
|
|
|
static void expire_cfs_rq_runtime(struct cfs_rq *cfs_rq)
|
2011-07-21 16:43:30 +00:00
|
|
|
{
|
2011-07-21 16:43:32 +00:00
|
|
|
struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg);
|
|
|
|
|
|
|
|
/* if the deadline is ahead of our clock, nothing to do */
|
2013-04-11 23:51:02 +00:00
|
|
|
if (likely((s64)(rq_clock(rq_of(cfs_rq)) - cfs_rq->runtime_expires) < 0))
|
2011-07-21 16:43:30 +00:00
|
|
|
return;
|
|
|
|
|
2011-07-21 16:43:32 +00:00
|
|
|
if (cfs_rq->runtime_remaining < 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the local deadline has passed we have to consider the
|
|
|
|
* possibility that our sched_clock is 'fast' and the global deadline
|
|
|
|
* has not truly expired.
|
|
|
|
*
|
|
|
|
* Fortunately we can check determine whether this the case by checking
|
2014-05-19 22:49:45 +00:00
|
|
|
* whether the global deadline has advanced. It is valid to compare
|
|
|
|
* cfs_b->runtime_expires without any locks since we only care about
|
|
|
|
* exact equality, so a partial write will still work.
|
2011-07-21 16:43:32 +00:00
|
|
|
*/
|
|
|
|
|
2014-05-19 22:49:45 +00:00
|
|
|
if (cfs_rq->runtime_expires != cfs_b->runtime_expires) {
|
2011-07-21 16:43:32 +00:00
|
|
|
/* extend local deadline, drift is bounded above by 2 ticks */
|
|
|
|
cfs_rq->runtime_expires += TICK_NSEC;
|
|
|
|
} else {
|
|
|
|
/* global deadline is ahead, expiration has passed */
|
|
|
|
cfs_rq->runtime_remaining = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-18 17:27:06 +00:00
|
|
|
static void __account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec)
|
2011-07-21 16:43:32 +00:00
|
|
|
{
|
|
|
|
/* dock delta_exec before expiring quota (as it could span periods) */
|
2011-07-21 16:43:30 +00:00
|
|
|
cfs_rq->runtime_remaining -= delta_exec;
|
2011-07-21 16:43:32 +00:00
|
|
|
expire_cfs_rq_runtime(cfs_rq);
|
|
|
|
|
|
|
|
if (likely(cfs_rq->runtime_remaining > 0))
|
2011-07-21 16:43:30 +00:00
|
|
|
return;
|
|
|
|
|
2011-07-21 16:43:33 +00:00
|
|
|
/*
|
|
|
|
* if we're unable to extend our runtime we resched so that the active
|
|
|
|
* hierarchy can be throttled
|
|
|
|
*/
|
|
|
|
if (!assign_cfs_rq_runtime(cfs_rq) && likely(cfs_rq->curr))
|
2014-06-28 20:03:57 +00:00
|
|
|
resched_curr(rq_of(cfs_rq));
|
2011-07-21 16:43:30 +00:00
|
|
|
}
|
|
|
|
|
2012-03-21 20:07:16 +00:00
|
|
|
static __always_inline
|
2013-11-18 17:27:06 +00:00
|
|
|
void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec)
|
2011-07-21 16:43:30 +00:00
|
|
|
{
|
2011-11-08 04:26:33 +00:00
|
|
|
if (!cfs_bandwidth_used() || !cfs_rq->runtime_enabled)
|
2011-07-21 16:43:30 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
__account_cfs_rq_runtime(cfs_rq, delta_exec);
|
|
|
|
}
|
|
|
|
|
2011-07-21 16:43:33 +00:00
|
|
|
static inline int cfs_rq_throttled(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
2011-11-08 04:26:33 +00:00
|
|
|
return cfs_bandwidth_used() && cfs_rq->throttled;
|
2011-07-21 16:43:33 +00:00
|
|
|
}
|
|
|
|
|
2011-07-21 16:43:36 +00:00
|
|
|
/* check whether cfs_rq, or any parent, is throttled */
|
|
|
|
static inline int throttled_hierarchy(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
2011-11-08 04:26:33 +00:00
|
|
|
return cfs_bandwidth_used() && cfs_rq->throttle_count;
|
2011-07-21 16:43:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ensure that neither of the group entities corresponding to src_cpu or
|
|
|
|
* dest_cpu are members of a throttled hierarchy when performing group
|
|
|
|
* load-balance operations.
|
|
|
|
*/
|
|
|
|
static inline int throttled_lb_pair(struct task_group *tg,
|
|
|
|
int src_cpu, int dest_cpu)
|
|
|
|
{
|
|
|
|
struct cfs_rq *src_cfs_rq, *dest_cfs_rq;
|
|
|
|
|
|
|
|
src_cfs_rq = tg->cfs_rq[src_cpu];
|
|
|
|
dest_cfs_rq = tg->cfs_rq[dest_cpu];
|
|
|
|
|
|
|
|
return throttled_hierarchy(src_cfs_rq) ||
|
|
|
|
throttled_hierarchy(dest_cfs_rq);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* updated child weight may affect parent so we have to do this bottom up */
|
|
|
|
static int tg_unthrottle_up(struct task_group *tg, void *data)
|
|
|
|
{
|
|
|
|
struct rq *rq = data;
|
|
|
|
struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)];
|
|
|
|
|
|
|
|
cfs_rq->throttle_count--;
|
|
|
|
if (!cfs_rq->throttle_count) {
|
2012-10-04 11:18:31 +00:00
|
|
|
/* adjust cfs_rq_clock_task() */
|
2013-04-11 23:51:02 +00:00
|
|
|
cfs_rq->throttled_clock_task_time += rq_clock_task(rq) -
|
2012-10-04 11:18:31 +00:00
|
|
|
cfs_rq->throttled_clock_task;
|
2011-07-21 16:43:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tg_throttle_down(struct task_group *tg, void *data)
|
|
|
|
{
|
|
|
|
struct rq *rq = data;
|
|
|
|
struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)];
|
|
|
|
|
2012-10-04 11:18:31 +00:00
|
|
|
/* group is entering throttled state, stop time */
|
|
|
|
if (!cfs_rq->throttle_count)
|
2013-04-11 23:51:02 +00:00
|
|
|
cfs_rq->throttled_clock_task = rq_clock_task(rq);
|
2011-07-21 16:43:36 +00:00
|
|
|
cfs_rq->throttle_count++;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-21 16:43:39 +00:00
|
|
|
static void throttle_cfs_rq(struct cfs_rq *cfs_rq)
|
2011-07-21 16:43:33 +00:00
|
|
|
{
|
|
|
|
struct rq *rq = rq_of(cfs_rq);
|
|
|
|
struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg);
|
|
|
|
struct sched_entity *se;
|
|
|
|
long task_delta, dequeue = 1;
|
sched: Cleanup bandwidth timers
Roman reported a 3 cpu lockup scenario involving __start_cfs_bandwidth().
The more I look at that code the more I'm convinced its crack, that
entire __start_cfs_bandwidth() thing is brain melting, we don't need to
cancel a timer before starting it, *hrtimer_start*() will happily remove
the timer for you if its still enqueued.
Removing that, removes a big part of the problem, no more ugly cancel
loop to get stuck in.
So now, if I understand things right, the entire reason you have this
cfs_b->lock guarded ->timer_active nonsense is to make sure we don't
accidentally lose the timer.
It appears to me that it should be possible to guarantee that same by
unconditionally (re)starting the timer when !queued. Because regardless
what hrtimer::function will return, if we beat it to (re)enqueue the
timer, it doesn't matter.
Now, because hrtimers don't come with any serialization guarantees we
must ensure both handler and (re)start loop serialize their access to
the hrtimer to avoid both trying to forward the timer at the same
time.
Update the rt bandwidth timer to match.
This effectively reverts: 09dc4ab03936 ("sched/fair: Fix
tg_set_cfs_bandwidth() deadlock on rq->lock").
Reported-by: Roman Gushchin <klamm@yandex-team.ru>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Ben Segall <bsegall@google.com>
Cc: Paul Turner <pjt@google.com>
Link: http://lkml.kernel.org/r/20150415095011.804589208@infradead.org
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-04-15 09:41:57 +00:00
|
|
|
bool empty;
|
2011-07-21 16:43:33 +00:00
|
|
|
|
|
|
|
se = cfs_rq->tg->se[cpu_of(rq_of(cfs_rq))];
|
|
|
|
|
2012-10-04 11:18:31 +00:00
|
|
|
/* freeze hierarchy runnable averages while throttled */
|
2011-07-21 16:43:36 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
walk_tg_tree_from(cfs_rq->tg, tg_throttle_down, tg_nop, (void *)rq);
|
|
|
|
rcu_read_unlock();
|
2011-07-21 16:43:33 +00:00
|
|
|
|
|
|
|
task_delta = cfs_rq->h_nr_running;
|
|
|
|
for_each_sched_entity(se) {
|
|
|
|
struct cfs_rq *qcfs_rq = cfs_rq_of(se);
|
|
|
|
/* throttled entity or throttle-on-deactivate */
|
|
|
|
if (!se->on_rq)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (dequeue)
|
|
|
|
dequeue_entity(qcfs_rq, se, DEQUEUE_SLEEP);
|
|
|
|
qcfs_rq->h_nr_running -= task_delta;
|
|
|
|
|
|
|
|
if (qcfs_rq->load.weight)
|
|
|
|
dequeue = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!se)
|
2014-05-08 23:00:14 +00:00
|
|
|
sub_nr_running(rq, task_delta);
|
2011-07-21 16:43:33 +00:00
|
|
|
|
|
|
|
cfs_rq->throttled = 1;
|
2013-04-11 23:51:02 +00:00
|
|
|
cfs_rq->throttled_clock = rq_clock(rq);
|
2011-07-21 16:43:33 +00:00
|
|
|
raw_spin_lock(&cfs_b->lock);
|
2015-06-24 19:41:47 +00:00
|
|
|
empty = list_empty(&cfs_b->throttled_cfs_rq);
|
sched: Cleanup bandwidth timers
Roman reported a 3 cpu lockup scenario involving __start_cfs_bandwidth().
The more I look at that code the more I'm convinced its crack, that
entire __start_cfs_bandwidth() thing is brain melting, we don't need to
cancel a timer before starting it, *hrtimer_start*() will happily remove
the timer for you if its still enqueued.
Removing that, removes a big part of the problem, no more ugly cancel
loop to get stuck in.
So now, if I understand things right, the entire reason you have this
cfs_b->lock guarded ->timer_active nonsense is to make sure we don't
accidentally lose the timer.
It appears to me that it should be possible to guarantee that same by
unconditionally (re)starting the timer when !queued. Because regardless
what hrtimer::function will return, if we beat it to (re)enqueue the
timer, it doesn't matter.
Now, because hrtimers don't come with any serialization guarantees we
must ensure both handler and (re)start loop serialize their access to
the hrtimer to avoid both trying to forward the timer at the same
time.
Update the rt bandwidth timer to match.
This effectively reverts: 09dc4ab03936 ("sched/fair: Fix
tg_set_cfs_bandwidth() deadlock on rq->lock").
Reported-by: Roman Gushchin <klamm@yandex-team.ru>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Ben Segall <bsegall@google.com>
Cc: Paul Turner <pjt@google.com>
Link: http://lkml.kernel.org/r/20150415095011.804589208@infradead.org
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-04-15 09:41:57 +00:00
|
|
|
|
sched: Fix potential near-infinite distribute_cfs_runtime() loop
distribute_cfs_runtime() intentionally only hands out enough runtime to
bring each cfs_rq to 1 ns of runtime, expecting the cfs_rqs to then take
the runtime they need only once they actually get to run. However, if
they get to run sufficiently quickly, the period timer is still in
distribute_cfs_runtime() and no runtime is available, causing them to
throttle. Then distribute has to handle them again, and this can go on
until distribute has handed out all of the runtime 1ns at a time, which
takes far too long.
Instead allow access to the same runtime that distribute is handing out,
accepting that corner cases with very low quota may be able to spend the
entire cfs_b->runtime during distribute_cfs_runtime, meaning that the
runtime directly handed out by distribute_cfs_runtime was over quota. In
addition, if a cfs_rq does manage to throttle like this, make sure the
existing distribute_cfs_runtime no longer loops over it again.
Signed-off-by: Ben Segall <bsegall@google.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20140620222120.13814.21652.stgit@sword-of-the-dawn.mtv.corp.google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-06-20 22:21:20 +00:00
|
|
|
/*
|
|
|
|
* Add to the _head_ of the list, so that an already-started
|
|
|
|
* distribute_cfs_runtime will not see us
|
|
|
|
*/
|
|
|
|
list_add_rcu(&cfs_rq->throttled_list, &cfs_b->throttled_cfs_rq);
|
sched: Cleanup bandwidth timers
Roman reported a 3 cpu lockup scenario involving __start_cfs_bandwidth().
The more I look at that code the more I'm convinced its crack, that
entire __start_cfs_bandwidth() thing is brain melting, we don't need to
cancel a timer before starting it, *hrtimer_start*() will happily remove
the timer for you if its still enqueued.
Removing that, removes a big part of the problem, no more ugly cancel
loop to get stuck in.
So now, if I understand things right, the entire reason you have this
cfs_b->lock guarded ->timer_active nonsense is to make sure we don't
accidentally lose the timer.
It appears to me that it should be possible to guarantee that same by
unconditionally (re)starting the timer when !queued. Because regardless
what hrtimer::function will return, if we beat it to (re)enqueue the
timer, it doesn't matter.
Now, because hrtimers don't come with any serialization guarantees we
must ensure both handler and (re)start loop serialize their access to
the hrtimer to avoid both trying to forward the timer at the same
time.
Update the rt bandwidth timer to match.
This effectively reverts: 09dc4ab03936 ("sched/fair: Fix
tg_set_cfs_bandwidth() deadlock on rq->lock").
Reported-by: Roman Gushchin <klamm@yandex-team.ru>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Ben Segall <bsegall@google.com>
Cc: Paul Turner <pjt@google.com>
Link: http://lkml.kernel.org/r/20150415095011.804589208@infradead.org
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-04-15 09:41:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we're the first throttled task, make sure the bandwidth
|
|
|
|
* timer is running.
|
|
|
|
*/
|
|
|
|
if (empty)
|
|
|
|
start_cfs_bandwidth(cfs_b);
|
|
|
|
|
2011-07-21 16:43:33 +00:00
|
|
|
raw_spin_unlock(&cfs_b->lock);
|
|
|
|
}
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
void unthrottle_cfs_rq(struct cfs_rq *cfs_rq)
|
2011-07-21 16:43:34 +00:00
|
|
|
{
|
|
|
|
struct rq *rq = rq_of(cfs_rq);
|
|
|
|
struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg);
|
|
|
|
struct sched_entity *se;
|
|
|
|
int enqueue = 1;
|
|
|
|
long task_delta;
|
|
|
|
|
2013-06-04 06:23:39 +00:00
|
|
|
se = cfs_rq->tg->se[cpu_of(rq)];
|
2011-07-21 16:43:34 +00:00
|
|
|
|
|
|
|
cfs_rq->throttled = 0;
|
2013-04-11 23:51:01 +00:00
|
|
|
|
|
|
|
update_rq_clock(rq);
|
|
|
|
|
2011-07-21 16:43:34 +00:00
|
|
|
raw_spin_lock(&cfs_b->lock);
|
2013-04-11 23:51:02 +00:00
|
|
|
cfs_b->throttled_time += rq_clock(rq) - cfs_rq->throttled_clock;
|
2011-07-21 16:43:34 +00:00
|
|
|
list_del_rcu(&cfs_rq->throttled_list);
|
|
|
|
raw_spin_unlock(&cfs_b->lock);
|
|
|
|
|
2011-07-21 16:43:36 +00:00
|
|
|
/* update hierarchical throttle state */
|
|
|
|
walk_tg_tree_from(cfs_rq->tg, tg_nop, tg_unthrottle_up, (void *)rq);
|
|
|
|
|
2011-07-21 16:43:34 +00:00
|
|
|
if (!cfs_rq->load.weight)
|
|
|
|
return;
|
|
|
|
|
|
|
|
task_delta = cfs_rq->h_nr_running;
|
|
|
|
for_each_sched_entity(se) {
|
|
|
|
if (se->on_rq)
|
|
|
|
enqueue = 0;
|
|
|
|
|
|
|
|
cfs_rq = cfs_rq_of(se);
|
|
|
|
if (enqueue)
|
|
|
|
enqueue_entity(cfs_rq, se, ENQUEUE_WAKEUP);
|
|
|
|
cfs_rq->h_nr_running += task_delta;
|
|
|
|
|
|
|
|
if (cfs_rq_throttled(cfs_rq))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!se)
|
2014-05-08 23:00:14 +00:00
|
|
|
add_nr_running(rq, task_delta);
|
2011-07-21 16:43:34 +00:00
|
|
|
|
|
|
|
/* determine whether we need to wake up potentially idle cpu */
|
|
|
|
if (rq->curr == rq->idle && rq->cfs.nr_running)
|
2014-06-28 20:03:57 +00:00
|
|
|
resched_curr(rq);
|
2011-07-21 16:43:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static u64 distribute_cfs_runtime(struct cfs_bandwidth *cfs_b,
|
|
|
|
u64 remaining, u64 expires)
|
|
|
|
{
|
|
|
|
struct cfs_rq *cfs_rq;
|
sched: Fix potential near-infinite distribute_cfs_runtime() loop
distribute_cfs_runtime() intentionally only hands out enough runtime to
bring each cfs_rq to 1 ns of runtime, expecting the cfs_rqs to then take
the runtime they need only once they actually get to run. However, if
they get to run sufficiently quickly, the period timer is still in
distribute_cfs_runtime() and no runtime is available, causing them to
throttle. Then distribute has to handle them again, and this can go on
until distribute has handed out all of the runtime 1ns at a time, which
takes far too long.
Instead allow access to the same runtime that distribute is handing out,
accepting that corner cases with very low quota may be able to spend the
entire cfs_b->runtime during distribute_cfs_runtime, meaning that the
runtime directly handed out by distribute_cfs_runtime was over quota. In
addition, if a cfs_rq does manage to throttle like this, make sure the
existing distribute_cfs_runtime no longer loops over it again.
Signed-off-by: Ben Segall <bsegall@google.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20140620222120.13814.21652.stgit@sword-of-the-dawn.mtv.corp.google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-06-20 22:21:20 +00:00
|
|
|
u64 runtime;
|
|
|
|
u64 starting_runtime = remaining;
|
2011-07-21 16:43:34 +00:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(cfs_rq, &cfs_b->throttled_cfs_rq,
|
|
|
|
throttled_list) {
|
|
|
|
struct rq *rq = rq_of(cfs_rq);
|
2016-10-04 14:04:35 +00:00
|
|
|
struct rq_flags rf;
|
2011-07-21 16:43:34 +00:00
|
|
|
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_lock(rq, &rf);
|
2011-07-21 16:43:34 +00:00
|
|
|
if (!cfs_rq_throttled(cfs_rq))
|
|
|
|
goto next;
|
|
|
|
|
|
|
|
runtime = -cfs_rq->runtime_remaining + 1;
|
|
|
|
if (runtime > remaining)
|
|
|
|
runtime = remaining;
|
|
|
|
remaining -= runtime;
|
|
|
|
|
|
|
|
cfs_rq->runtime_remaining += runtime;
|
|
|
|
cfs_rq->runtime_expires = expires;
|
|
|
|
|
|
|
|
/* we check whether we're throttled above */
|
|
|
|
if (cfs_rq->runtime_remaining > 0)
|
|
|
|
unthrottle_cfs_rq(cfs_rq);
|
|
|
|
|
|
|
|
next:
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_unlock(rq, &rf);
|
2011-07-21 16:43:34 +00:00
|
|
|
|
|
|
|
if (!remaining)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
sched: Fix potential near-infinite distribute_cfs_runtime() loop
distribute_cfs_runtime() intentionally only hands out enough runtime to
bring each cfs_rq to 1 ns of runtime, expecting the cfs_rqs to then take
the runtime they need only once they actually get to run. However, if
they get to run sufficiently quickly, the period timer is still in
distribute_cfs_runtime() and no runtime is available, causing them to
throttle. Then distribute has to handle them again, and this can go on
until distribute has handed out all of the runtime 1ns at a time, which
takes far too long.
Instead allow access to the same runtime that distribute is handing out,
accepting that corner cases with very low quota may be able to spend the
entire cfs_b->runtime during distribute_cfs_runtime, meaning that the
runtime directly handed out by distribute_cfs_runtime was over quota. In
addition, if a cfs_rq does manage to throttle like this, make sure the
existing distribute_cfs_runtime no longer loops over it again.
Signed-off-by: Ben Segall <bsegall@google.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20140620222120.13814.21652.stgit@sword-of-the-dawn.mtv.corp.google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-06-20 22:21:20 +00:00
|
|
|
return starting_runtime - remaining;
|
2011-07-21 16:43:34 +00:00
|
|
|
}
|
|
|
|
|
2011-07-21 16:43:31 +00:00
|
|
|
/*
|
|
|
|
* Responsible for refilling a task_group's bandwidth and unthrottling its
|
|
|
|
* cfs_rqs as appropriate. If there has been no activity within the last
|
|
|
|
* period the timer is deactivated until scheduling resumes; cfs_b->idle is
|
|
|
|
* used to track this state.
|
|
|
|
*/
|
|
|
|
static int do_sched_cfs_period_timer(struct cfs_bandwidth *cfs_b, int overrun)
|
|
|
|
{
|
2011-07-21 16:43:34 +00:00
|
|
|
u64 runtime, runtime_expires;
|
2014-05-19 22:49:45 +00:00
|
|
|
int throttled;
|
2011-07-21 16:43:31 +00:00
|
|
|
|
|
|
|
/* no need to continue the timer with no bandwidth constraint */
|
|
|
|
if (cfs_b->quota == RUNTIME_INF)
|
2014-05-19 22:49:45 +00:00
|
|
|
goto out_deactivate;
|
2011-07-21 16:43:31 +00:00
|
|
|
|
2011-07-21 16:43:34 +00:00
|
|
|
throttled = !list_empty(&cfs_b->throttled_cfs_rq);
|
2011-07-21 16:43:40 +00:00
|
|
|
cfs_b->nr_periods += overrun;
|
2011-07-21 16:43:34 +00:00
|
|
|
|
2014-05-19 22:49:45 +00:00
|
|
|
/*
|
|
|
|
* idle depends on !throttled (for the case of a large deficit), and if
|
|
|
|
* we're going inactive then everything else can be deferred
|
|
|
|
*/
|
|
|
|
if (cfs_b->idle && !throttled)
|
|
|
|
goto out_deactivate;
|
2011-07-21 16:43:32 +00:00
|
|
|
|
|
|
|
__refill_cfs_bandwidth_runtime(cfs_b);
|
|
|
|
|
2011-07-21 16:43:34 +00:00
|
|
|
if (!throttled) {
|
|
|
|
/* mark as potentially idle for the upcoming period */
|
|
|
|
cfs_b->idle = 1;
|
2014-05-19 22:49:45 +00:00
|
|
|
return 0;
|
2011-07-21 16:43:34 +00:00
|
|
|
}
|
|
|
|
|
2011-07-21 16:43:40 +00:00
|
|
|
/* account preceding periods in which throttling occurred */
|
|
|
|
cfs_b->nr_throttled += overrun;
|
|
|
|
|
2011-07-21 16:43:34 +00:00
|
|
|
runtime_expires = cfs_b->runtime_expires;
|
|
|
|
|
|
|
|
/*
|
sched: Fix potential near-infinite distribute_cfs_runtime() loop
distribute_cfs_runtime() intentionally only hands out enough runtime to
bring each cfs_rq to 1 ns of runtime, expecting the cfs_rqs to then take
the runtime they need only once they actually get to run. However, if
they get to run sufficiently quickly, the period timer is still in
distribute_cfs_runtime() and no runtime is available, causing them to
throttle. Then distribute has to handle them again, and this can go on
until distribute has handed out all of the runtime 1ns at a time, which
takes far too long.
Instead allow access to the same runtime that distribute is handing out,
accepting that corner cases with very low quota may be able to spend the
entire cfs_b->runtime during distribute_cfs_runtime, meaning that the
runtime directly handed out by distribute_cfs_runtime was over quota. In
addition, if a cfs_rq does manage to throttle like this, make sure the
existing distribute_cfs_runtime no longer loops over it again.
Signed-off-by: Ben Segall <bsegall@google.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20140620222120.13814.21652.stgit@sword-of-the-dawn.mtv.corp.google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-06-20 22:21:20 +00:00
|
|
|
* This check is repeated as we are holding onto the new bandwidth while
|
|
|
|
* we unthrottle. This can potentially race with an unthrottled group
|
|
|
|
* trying to acquire new bandwidth from the global pool. This can result
|
|
|
|
* in us over-using our runtime if it is all used during this loop, but
|
|
|
|
* only by limited amounts in that extreme case.
|
2011-07-21 16:43:34 +00:00
|
|
|
*/
|
sched: Fix potential near-infinite distribute_cfs_runtime() loop
distribute_cfs_runtime() intentionally only hands out enough runtime to
bring each cfs_rq to 1 ns of runtime, expecting the cfs_rqs to then take
the runtime they need only once they actually get to run. However, if
they get to run sufficiently quickly, the period timer is still in
distribute_cfs_runtime() and no runtime is available, causing them to
throttle. Then distribute has to handle them again, and this can go on
until distribute has handed out all of the runtime 1ns at a time, which
takes far too long.
Instead allow access to the same runtime that distribute is handing out,
accepting that corner cases with very low quota may be able to spend the
entire cfs_b->runtime during distribute_cfs_runtime, meaning that the
runtime directly handed out by distribute_cfs_runtime was over quota. In
addition, if a cfs_rq does manage to throttle like this, make sure the
existing distribute_cfs_runtime no longer loops over it again.
Signed-off-by: Ben Segall <bsegall@google.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20140620222120.13814.21652.stgit@sword-of-the-dawn.mtv.corp.google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-06-20 22:21:20 +00:00
|
|
|
while (throttled && cfs_b->runtime > 0) {
|
|
|
|
runtime = cfs_b->runtime;
|
2011-07-21 16:43:34 +00:00
|
|
|
raw_spin_unlock(&cfs_b->lock);
|
|
|
|
/* we can't nest cfs_b->lock while distributing bandwidth */
|
|
|
|
runtime = distribute_cfs_runtime(cfs_b, runtime,
|
|
|
|
runtime_expires);
|
|
|
|
raw_spin_lock(&cfs_b->lock);
|
|
|
|
|
|
|
|
throttled = !list_empty(&cfs_b->throttled_cfs_rq);
|
sched: Fix potential near-infinite distribute_cfs_runtime() loop
distribute_cfs_runtime() intentionally only hands out enough runtime to
bring each cfs_rq to 1 ns of runtime, expecting the cfs_rqs to then take
the runtime they need only once they actually get to run. However, if
they get to run sufficiently quickly, the period timer is still in
distribute_cfs_runtime() and no runtime is available, causing them to
throttle. Then distribute has to handle them again, and this can go on
until distribute has handed out all of the runtime 1ns at a time, which
takes far too long.
Instead allow access to the same runtime that distribute is handing out,
accepting that corner cases with very low quota may be able to spend the
entire cfs_b->runtime during distribute_cfs_runtime, meaning that the
runtime directly handed out by distribute_cfs_runtime was over quota. In
addition, if a cfs_rq does manage to throttle like this, make sure the
existing distribute_cfs_runtime no longer loops over it again.
Signed-off-by: Ben Segall <bsegall@google.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20140620222120.13814.21652.stgit@sword-of-the-dawn.mtv.corp.google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-06-20 22:21:20 +00:00
|
|
|
|
|
|
|
cfs_b->runtime -= min(runtime, cfs_b->runtime);
|
2011-07-21 16:43:34 +00:00
|
|
|
}
|
2011-07-21 16:43:31 +00:00
|
|
|
|
2011-07-21 16:43:34 +00:00
|
|
|
/*
|
|
|
|
* While we are ensured activity in the period following an
|
|
|
|
* unthrottle, this also covers the case in which the new bandwidth is
|
|
|
|
* insufficient to cover the existing bandwidth deficit. (Forcing the
|
|
|
|
* timer to remain active while there are any throttled entities.)
|
|
|
|
*/
|
|
|
|
cfs_b->idle = 0;
|
2011-07-21 16:43:31 +00:00
|
|
|
|
2014-05-19 22:49:45 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_deactivate:
|
|
|
|
return 1;
|
2011-07-21 16:43:31 +00:00
|
|
|
}
|
2011-07-21 16:43:39 +00:00
|
|
|
|
2011-07-21 16:43:41 +00:00
|
|
|
/* a cfs_rq won't donate quota below this amount */
|
|
|
|
static const u64 min_cfs_rq_runtime = 1 * NSEC_PER_MSEC;
|
|
|
|
/* minimum remaining period time to redistribute slack quota */
|
|
|
|
static const u64 min_bandwidth_expiration = 2 * NSEC_PER_MSEC;
|
|
|
|
/* how long we wait to gather additional slack before distributing */
|
|
|
|
static const u64 cfs_bandwidth_slack_period = 5 * NSEC_PER_MSEC;
|
|
|
|
|
2013-10-16 18:16:17 +00:00
|
|
|
/*
|
|
|
|
* Are we near the end of the current quota period?
|
|
|
|
*
|
|
|
|
* Requires cfs_b->lock for hrtimer_expires_remaining to be safe against the
|
2015-04-14 21:09:05 +00:00
|
|
|
* hrtimer base being cleared by hrtimer_start. In the case of
|
2013-10-16 18:16:17 +00:00
|
|
|
* migrate_hrtimers, base is never cleared, so we are fine.
|
|
|
|
*/
|
2011-07-21 16:43:41 +00:00
|
|
|
static int runtime_refresh_within(struct cfs_bandwidth *cfs_b, u64 min_expire)
|
|
|
|
{
|
|
|
|
struct hrtimer *refresh_timer = &cfs_b->period_timer;
|
|
|
|
u64 remaining;
|
|
|
|
|
|
|
|
/* if the call-back is running a quota refresh is already occurring */
|
|
|
|
if (hrtimer_callback_running(refresh_timer))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* is a quota refresh about to occur? */
|
|
|
|
remaining = ktime_to_ns(hrtimer_expires_remaining(refresh_timer));
|
|
|
|
if (remaining < min_expire)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void start_cfs_slack_bandwidth(struct cfs_bandwidth *cfs_b)
|
|
|
|
{
|
|
|
|
u64 min_left = cfs_bandwidth_slack_period + min_bandwidth_expiration;
|
|
|
|
|
|
|
|
/* if there's a quota refresh soon don't bother with slack */
|
|
|
|
if (runtime_refresh_within(cfs_b, min_left))
|
|
|
|
return;
|
|
|
|
|
sched,perf: Fix periodic timers
In the below two commits (see Fixes) we have periodic timers that can
stop themselves when they're no longer required, but need to be
(re)-started when their idle condition changes.
Further complications is that we want the timer handler to always do
the forward such that it will always correctly deal with the overruns,
and we do not want to race such that the handler has already decided
to stop, but the (external) restart sees the timer still active and we
end up with a 'lost' timer.
The problem with the current code is that the re-start can come before
the callback does the forward, at which point the forward from the
callback will WARN about forwarding an enqueued timer.
Now, conceptually its easy to detect if you're before or after the fwd
by comparing the expiration time against the current time. Of course,
that's expensive (and racy) because we don't have the current time.
Alternatively one could cache this state inside the timer, but then
everybody pays the overhead of maintaining this extra state, and that
is undesired.
The only other option that I could see is the external timer_active
variable, which I tried to kill before. I would love a nicer interface
for this seemingly simple 'problem' but alas.
Fixes: 272325c4821f ("perf: Fix mux_interval hrtimer wreckage")
Fixes: 77a4d1a1b9a1 ("sched: Cleanup bandwidth timers")
Cc: pjt@google.com
Cc: tglx@linutronix.de
Cc: klamm@yandex-team.ru
Cc: mingo@kernel.org
Cc: bsegall@google.com
Cc: hpa@zytor.com
Cc: Sasha Levin <sasha.levin@oracle.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150514102311.GX21418@twins.programming.kicks-ass.net
2015-05-14 10:23:11 +00:00
|
|
|
hrtimer_start(&cfs_b->slack_timer,
|
|
|
|
ns_to_ktime(cfs_bandwidth_slack_period),
|
|
|
|
HRTIMER_MODE_REL);
|
2011-07-21 16:43:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* we know any runtime found here is valid as update_curr() precedes return */
|
|
|
|
static void __return_cfs_rq_runtime(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
|
|
|
struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg);
|
|
|
|
s64 slack_runtime = cfs_rq->runtime_remaining - min_cfs_rq_runtime;
|
|
|
|
|
|
|
|
if (slack_runtime <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
raw_spin_lock(&cfs_b->lock);
|
|
|
|
if (cfs_b->quota != RUNTIME_INF &&
|
|
|
|
cfs_rq->runtime_expires == cfs_b->runtime_expires) {
|
|
|
|
cfs_b->runtime += slack_runtime;
|
|
|
|
|
|
|
|
/* we are under rq->lock, defer unthrottling using a timer */
|
|
|
|
if (cfs_b->runtime > sched_cfs_bandwidth_slice() &&
|
|
|
|
!list_empty(&cfs_b->throttled_cfs_rq))
|
|
|
|
start_cfs_slack_bandwidth(cfs_b);
|
|
|
|
}
|
|
|
|
raw_spin_unlock(&cfs_b->lock);
|
|
|
|
|
|
|
|
/* even if it's not valid for return we don't want to try again */
|
|
|
|
cfs_rq->runtime_remaining -= slack_runtime;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __always_inline void return_cfs_rq_runtime(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
2011-11-08 04:26:33 +00:00
|
|
|
if (!cfs_bandwidth_used())
|
|
|
|
return;
|
|
|
|
|
2011-11-08 04:26:34 +00:00
|
|
|
if (!cfs_rq->runtime_enabled || cfs_rq->nr_running)
|
2011-07-21 16:43:41 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
__return_cfs_rq_runtime(cfs_rq);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is done with a timer (instead of inline with bandwidth return) since
|
|
|
|
* it's necessary to juggle rq->locks to unthrottle their respective cfs_rqs.
|
|
|
|
*/
|
|
|
|
static void do_sched_cfs_slack_timer(struct cfs_bandwidth *cfs_b)
|
|
|
|
{
|
|
|
|
u64 runtime = 0, slice = sched_cfs_bandwidth_slice();
|
|
|
|
u64 expires;
|
|
|
|
|
|
|
|
/* confirm we're still not at a refresh boundary */
|
2013-10-16 18:16:17 +00:00
|
|
|
raw_spin_lock(&cfs_b->lock);
|
|
|
|
if (runtime_refresh_within(cfs_b, min_bandwidth_expiration)) {
|
|
|
|
raw_spin_unlock(&cfs_b->lock);
|
2011-07-21 16:43:41 +00:00
|
|
|
return;
|
2013-10-16 18:16:17 +00:00
|
|
|
}
|
2011-07-21 16:43:41 +00:00
|
|
|
|
sched: Fix potential near-infinite distribute_cfs_runtime() loop
distribute_cfs_runtime() intentionally only hands out enough runtime to
bring each cfs_rq to 1 ns of runtime, expecting the cfs_rqs to then take
the runtime they need only once they actually get to run. However, if
they get to run sufficiently quickly, the period timer is still in
distribute_cfs_runtime() and no runtime is available, causing them to
throttle. Then distribute has to handle them again, and this can go on
until distribute has handed out all of the runtime 1ns at a time, which
takes far too long.
Instead allow access to the same runtime that distribute is handing out,
accepting that corner cases with very low quota may be able to spend the
entire cfs_b->runtime during distribute_cfs_runtime, meaning that the
runtime directly handed out by distribute_cfs_runtime was over quota. In
addition, if a cfs_rq does manage to throttle like this, make sure the
existing distribute_cfs_runtime no longer loops over it again.
Signed-off-by: Ben Segall <bsegall@google.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20140620222120.13814.21652.stgit@sword-of-the-dawn.mtv.corp.google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-06-20 22:21:20 +00:00
|
|
|
if (cfs_b->quota != RUNTIME_INF && cfs_b->runtime > slice)
|
2011-07-21 16:43:41 +00:00
|
|
|
runtime = cfs_b->runtime;
|
sched: Fix potential near-infinite distribute_cfs_runtime() loop
distribute_cfs_runtime() intentionally only hands out enough runtime to
bring each cfs_rq to 1 ns of runtime, expecting the cfs_rqs to then take
the runtime they need only once they actually get to run. However, if
they get to run sufficiently quickly, the period timer is still in
distribute_cfs_runtime() and no runtime is available, causing them to
throttle. Then distribute has to handle them again, and this can go on
until distribute has handed out all of the runtime 1ns at a time, which
takes far too long.
Instead allow access to the same runtime that distribute is handing out,
accepting that corner cases with very low quota may be able to spend the
entire cfs_b->runtime during distribute_cfs_runtime, meaning that the
runtime directly handed out by distribute_cfs_runtime was over quota. In
addition, if a cfs_rq does manage to throttle like this, make sure the
existing distribute_cfs_runtime no longer loops over it again.
Signed-off-by: Ben Segall <bsegall@google.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20140620222120.13814.21652.stgit@sword-of-the-dawn.mtv.corp.google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-06-20 22:21:20 +00:00
|
|
|
|
2011-07-21 16:43:41 +00:00
|
|
|
expires = cfs_b->runtime_expires;
|
|
|
|
raw_spin_unlock(&cfs_b->lock);
|
|
|
|
|
|
|
|
if (!runtime)
|
|
|
|
return;
|
|
|
|
|
|
|
|
runtime = distribute_cfs_runtime(cfs_b, runtime, expires);
|
|
|
|
|
|
|
|
raw_spin_lock(&cfs_b->lock);
|
|
|
|
if (expires == cfs_b->runtime_expires)
|
sched: Fix potential near-infinite distribute_cfs_runtime() loop
distribute_cfs_runtime() intentionally only hands out enough runtime to
bring each cfs_rq to 1 ns of runtime, expecting the cfs_rqs to then take
the runtime they need only once they actually get to run. However, if
they get to run sufficiently quickly, the period timer is still in
distribute_cfs_runtime() and no runtime is available, causing them to
throttle. Then distribute has to handle them again, and this can go on
until distribute has handed out all of the runtime 1ns at a time, which
takes far too long.
Instead allow access to the same runtime that distribute is handing out,
accepting that corner cases with very low quota may be able to spend the
entire cfs_b->runtime during distribute_cfs_runtime, meaning that the
runtime directly handed out by distribute_cfs_runtime was over quota. In
addition, if a cfs_rq does manage to throttle like this, make sure the
existing distribute_cfs_runtime no longer loops over it again.
Signed-off-by: Ben Segall <bsegall@google.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20140620222120.13814.21652.stgit@sword-of-the-dawn.mtv.corp.google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-06-20 22:21:20 +00:00
|
|
|
cfs_b->runtime -= min(runtime, cfs_b->runtime);
|
2011-07-21 16:43:41 +00:00
|
|
|
raw_spin_unlock(&cfs_b->lock);
|
|
|
|
}
|
|
|
|
|
2011-07-21 16:43:39 +00:00
|
|
|
/*
|
|
|
|
* When a group wakes up we want to make sure that its quota is not already
|
|
|
|
* expired/exceeded, otherwise it may be allowed to steal additional ticks of
|
|
|
|
* runtime as update_curr() throttling can not not trigger until it's on-rq.
|
|
|
|
*/
|
|
|
|
static void check_enqueue_throttle(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
2011-11-08 04:26:33 +00:00
|
|
|
if (!cfs_bandwidth_used())
|
|
|
|
return;
|
|
|
|
|
2011-07-21 16:43:39 +00:00
|
|
|
/* an active group must be handled by the update_curr()->put() path */
|
|
|
|
if (!cfs_rq->runtime_enabled || cfs_rq->curr)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* ensure the group is not already throttled */
|
|
|
|
if (cfs_rq_throttled(cfs_rq))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* update runtime allocation */
|
|
|
|
account_cfs_rq_runtime(cfs_rq, 0);
|
|
|
|
if (cfs_rq->runtime_remaining <= 0)
|
|
|
|
throttle_cfs_rq(cfs_rq);
|
|
|
|
}
|
|
|
|
|
2016-06-22 13:14:26 +00:00
|
|
|
static void sync_throttle(struct task_group *tg, int cpu)
|
|
|
|
{
|
|
|
|
struct cfs_rq *pcfs_rq, *cfs_rq;
|
|
|
|
|
|
|
|
if (!cfs_bandwidth_used())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!tg->parent)
|
|
|
|
return;
|
|
|
|
|
|
|
|
cfs_rq = tg->cfs_rq[cpu];
|
|
|
|
pcfs_rq = tg->parent->cfs_rq[cpu];
|
|
|
|
|
|
|
|
cfs_rq->throttle_count = pcfs_rq->throttle_count;
|
2016-07-09 07:54:22 +00:00
|
|
|
cfs_rq->throttled_clock_task = rq_clock_task(cpu_rq(cpu));
|
2016-06-22 13:14:26 +00:00
|
|
|
}
|
|
|
|
|
2011-07-21 16:43:39 +00:00
|
|
|
/* conditionally throttle active cfs_rq's from put_prev_entity() */
|
2012-02-11 05:05:00 +00:00
|
|
|
static bool check_cfs_rq_runtime(struct cfs_rq *cfs_rq)
|
2011-07-21 16:43:39 +00:00
|
|
|
{
|
2011-11-08 04:26:33 +00:00
|
|
|
if (!cfs_bandwidth_used())
|
2012-02-11 05:05:00 +00:00
|
|
|
return false;
|
2011-11-08 04:26:33 +00:00
|
|
|
|
2011-07-21 16:43:39 +00:00
|
|
|
if (likely(!cfs_rq->runtime_enabled || cfs_rq->runtime_remaining > 0))
|
2012-02-11 05:05:00 +00:00
|
|
|
return false;
|
2011-07-21 16:43:39 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* it's possible for a throttled entity to be forced into a running
|
|
|
|
* state (e.g. set_curr_task), in this case we're finished.
|
|
|
|
*/
|
|
|
|
if (cfs_rq_throttled(cfs_rq))
|
2012-02-11 05:05:00 +00:00
|
|
|
return true;
|
2011-07-21 16:43:39 +00:00
|
|
|
|
|
|
|
throttle_cfs_rq(cfs_rq);
|
2012-02-11 05:05:00 +00:00
|
|
|
return true;
|
2011-07-21 16:43:39 +00:00
|
|
|
}
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
static enum hrtimer_restart sched_cfs_slack_timer(struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
struct cfs_bandwidth *cfs_b =
|
|
|
|
container_of(timer, struct cfs_bandwidth, slack_timer);
|
sched: Cleanup bandwidth timers
Roman reported a 3 cpu lockup scenario involving __start_cfs_bandwidth().
The more I look at that code the more I'm convinced its crack, that
entire __start_cfs_bandwidth() thing is brain melting, we don't need to
cancel a timer before starting it, *hrtimer_start*() will happily remove
the timer for you if its still enqueued.
Removing that, removes a big part of the problem, no more ugly cancel
loop to get stuck in.
So now, if I understand things right, the entire reason you have this
cfs_b->lock guarded ->timer_active nonsense is to make sure we don't
accidentally lose the timer.
It appears to me that it should be possible to guarantee that same by
unconditionally (re)starting the timer when !queued. Because regardless
what hrtimer::function will return, if we beat it to (re)enqueue the
timer, it doesn't matter.
Now, because hrtimers don't come with any serialization guarantees we
must ensure both handler and (re)start loop serialize their access to
the hrtimer to avoid both trying to forward the timer at the same
time.
Update the rt bandwidth timer to match.
This effectively reverts: 09dc4ab03936 ("sched/fair: Fix
tg_set_cfs_bandwidth() deadlock on rq->lock").
Reported-by: Roman Gushchin <klamm@yandex-team.ru>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Ben Segall <bsegall@google.com>
Cc: Paul Turner <pjt@google.com>
Link: http://lkml.kernel.org/r/20150415095011.804589208@infradead.org
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-04-15 09:41:57 +00:00
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
do_sched_cfs_slack_timer(cfs_b);
|
|
|
|
|
|
|
|
return HRTIMER_NORESTART;
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
struct cfs_bandwidth *cfs_b =
|
|
|
|
container_of(timer, struct cfs_bandwidth, period_timer);
|
|
|
|
int overrun;
|
|
|
|
int idle = 0;
|
|
|
|
|
2014-05-19 22:49:45 +00:00
|
|
|
raw_spin_lock(&cfs_b->lock);
|
2011-10-25 08:00:11 +00:00
|
|
|
for (;;) {
|
sched: Cleanup bandwidth timers
Roman reported a 3 cpu lockup scenario involving __start_cfs_bandwidth().
The more I look at that code the more I'm convinced its crack, that
entire __start_cfs_bandwidth() thing is brain melting, we don't need to
cancel a timer before starting it, *hrtimer_start*() will happily remove
the timer for you if its still enqueued.
Removing that, removes a big part of the problem, no more ugly cancel
loop to get stuck in.
So now, if I understand things right, the entire reason you have this
cfs_b->lock guarded ->timer_active nonsense is to make sure we don't
accidentally lose the timer.
It appears to me that it should be possible to guarantee that same by
unconditionally (re)starting the timer when !queued. Because regardless
what hrtimer::function will return, if we beat it to (re)enqueue the
timer, it doesn't matter.
Now, because hrtimers don't come with any serialization guarantees we
must ensure both handler and (re)start loop serialize their access to
the hrtimer to avoid both trying to forward the timer at the same
time.
Update the rt bandwidth timer to match.
This effectively reverts: 09dc4ab03936 ("sched/fair: Fix
tg_set_cfs_bandwidth() deadlock on rq->lock").
Reported-by: Roman Gushchin <klamm@yandex-team.ru>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Ben Segall <bsegall@google.com>
Cc: Paul Turner <pjt@google.com>
Link: http://lkml.kernel.org/r/20150415095011.804589208@infradead.org
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-04-15 09:41:57 +00:00
|
|
|
overrun = hrtimer_forward_now(timer, cfs_b->period);
|
2011-10-25 08:00:11 +00:00
|
|
|
if (!overrun)
|
|
|
|
break;
|
|
|
|
|
|
|
|
idle = do_sched_cfs_period_timer(cfs_b, overrun);
|
|
|
|
}
|
sched,perf: Fix periodic timers
In the below two commits (see Fixes) we have periodic timers that can
stop themselves when they're no longer required, but need to be
(re)-started when their idle condition changes.
Further complications is that we want the timer handler to always do
the forward such that it will always correctly deal with the overruns,
and we do not want to race such that the handler has already decided
to stop, but the (external) restart sees the timer still active and we
end up with a 'lost' timer.
The problem with the current code is that the re-start can come before
the callback does the forward, at which point the forward from the
callback will WARN about forwarding an enqueued timer.
Now, conceptually its easy to detect if you're before or after the fwd
by comparing the expiration time against the current time. Of course,
that's expensive (and racy) because we don't have the current time.
Alternatively one could cache this state inside the timer, but then
everybody pays the overhead of maintaining this extra state, and that
is undesired.
The only other option that I could see is the external timer_active
variable, which I tried to kill before. I would love a nicer interface
for this seemingly simple 'problem' but alas.
Fixes: 272325c4821f ("perf: Fix mux_interval hrtimer wreckage")
Fixes: 77a4d1a1b9a1 ("sched: Cleanup bandwidth timers")
Cc: pjt@google.com
Cc: tglx@linutronix.de
Cc: klamm@yandex-team.ru
Cc: mingo@kernel.org
Cc: bsegall@google.com
Cc: hpa@zytor.com
Cc: Sasha Levin <sasha.levin@oracle.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150514102311.GX21418@twins.programming.kicks-ass.net
2015-05-14 10:23:11 +00:00
|
|
|
if (idle)
|
|
|
|
cfs_b->period_active = 0;
|
2014-05-19 22:49:45 +00:00
|
|
|
raw_spin_unlock(&cfs_b->lock);
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
return idle ? HRTIMER_NORESTART : HRTIMER_RESTART;
|
|
|
|
}
|
|
|
|
|
|
|
|
void init_cfs_bandwidth(struct cfs_bandwidth *cfs_b)
|
|
|
|
{
|
|
|
|
raw_spin_lock_init(&cfs_b->lock);
|
|
|
|
cfs_b->runtime = 0;
|
|
|
|
cfs_b->quota = RUNTIME_INF;
|
|
|
|
cfs_b->period = ns_to_ktime(default_cfs_period());
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&cfs_b->throttled_cfs_rq);
|
sched,perf: Fix periodic timers
In the below two commits (see Fixes) we have periodic timers that can
stop themselves when they're no longer required, but need to be
(re)-started when their idle condition changes.
Further complications is that we want the timer handler to always do
the forward such that it will always correctly deal with the overruns,
and we do not want to race such that the handler has already decided
to stop, but the (external) restart sees the timer still active and we
end up with a 'lost' timer.
The problem with the current code is that the re-start can come before
the callback does the forward, at which point the forward from the
callback will WARN about forwarding an enqueued timer.
Now, conceptually its easy to detect if you're before or after the fwd
by comparing the expiration time against the current time. Of course,
that's expensive (and racy) because we don't have the current time.
Alternatively one could cache this state inside the timer, but then
everybody pays the overhead of maintaining this extra state, and that
is undesired.
The only other option that I could see is the external timer_active
variable, which I tried to kill before. I would love a nicer interface
for this seemingly simple 'problem' but alas.
Fixes: 272325c4821f ("perf: Fix mux_interval hrtimer wreckage")
Fixes: 77a4d1a1b9a1 ("sched: Cleanup bandwidth timers")
Cc: pjt@google.com
Cc: tglx@linutronix.de
Cc: klamm@yandex-team.ru
Cc: mingo@kernel.org
Cc: bsegall@google.com
Cc: hpa@zytor.com
Cc: Sasha Levin <sasha.levin@oracle.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150514102311.GX21418@twins.programming.kicks-ass.net
2015-05-14 10:23:11 +00:00
|
|
|
hrtimer_init(&cfs_b->period_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);
|
2011-10-25 08:00:11 +00:00
|
|
|
cfs_b->period_timer.function = sched_cfs_period_timer;
|
|
|
|
hrtimer_init(&cfs_b->slack_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
|
|
|
|
cfs_b->slack_timer.function = sched_cfs_slack_timer;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void init_cfs_rq_runtime(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
|
|
|
cfs_rq->runtime_enabled = 0;
|
|
|
|
INIT_LIST_HEAD(&cfs_rq->throttled_list);
|
|
|
|
}
|
|
|
|
|
sched: Cleanup bandwidth timers
Roman reported a 3 cpu lockup scenario involving __start_cfs_bandwidth().
The more I look at that code the more I'm convinced its crack, that
entire __start_cfs_bandwidth() thing is brain melting, we don't need to
cancel a timer before starting it, *hrtimer_start*() will happily remove
the timer for you if its still enqueued.
Removing that, removes a big part of the problem, no more ugly cancel
loop to get stuck in.
So now, if I understand things right, the entire reason you have this
cfs_b->lock guarded ->timer_active nonsense is to make sure we don't
accidentally lose the timer.
It appears to me that it should be possible to guarantee that same by
unconditionally (re)starting the timer when !queued. Because regardless
what hrtimer::function will return, if we beat it to (re)enqueue the
timer, it doesn't matter.
Now, because hrtimers don't come with any serialization guarantees we
must ensure both handler and (re)start loop serialize their access to
the hrtimer to avoid both trying to forward the timer at the same
time.
Update the rt bandwidth timer to match.
This effectively reverts: 09dc4ab03936 ("sched/fair: Fix
tg_set_cfs_bandwidth() deadlock on rq->lock").
Reported-by: Roman Gushchin <klamm@yandex-team.ru>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Ben Segall <bsegall@google.com>
Cc: Paul Turner <pjt@google.com>
Link: http://lkml.kernel.org/r/20150415095011.804589208@infradead.org
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-04-15 09:41:57 +00:00
|
|
|
void start_cfs_bandwidth(struct cfs_bandwidth *cfs_b)
|
2011-10-25 08:00:11 +00:00
|
|
|
{
|
sched,perf: Fix periodic timers
In the below two commits (see Fixes) we have periodic timers that can
stop themselves when they're no longer required, but need to be
(re)-started when their idle condition changes.
Further complications is that we want the timer handler to always do
the forward such that it will always correctly deal with the overruns,
and we do not want to race such that the handler has already decided
to stop, but the (external) restart sees the timer still active and we
end up with a 'lost' timer.
The problem with the current code is that the re-start can come before
the callback does the forward, at which point the forward from the
callback will WARN about forwarding an enqueued timer.
Now, conceptually its easy to detect if you're before or after the fwd
by comparing the expiration time against the current time. Of course,
that's expensive (and racy) because we don't have the current time.
Alternatively one could cache this state inside the timer, but then
everybody pays the overhead of maintaining this extra state, and that
is undesired.
The only other option that I could see is the external timer_active
variable, which I tried to kill before. I would love a nicer interface
for this seemingly simple 'problem' but alas.
Fixes: 272325c4821f ("perf: Fix mux_interval hrtimer wreckage")
Fixes: 77a4d1a1b9a1 ("sched: Cleanup bandwidth timers")
Cc: pjt@google.com
Cc: tglx@linutronix.de
Cc: klamm@yandex-team.ru
Cc: mingo@kernel.org
Cc: bsegall@google.com
Cc: hpa@zytor.com
Cc: Sasha Levin <sasha.levin@oracle.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150514102311.GX21418@twins.programming.kicks-ass.net
2015-05-14 10:23:11 +00:00
|
|
|
lockdep_assert_held(&cfs_b->lock);
|
2011-10-25 08:00:11 +00:00
|
|
|
|
sched,perf: Fix periodic timers
In the below two commits (see Fixes) we have periodic timers that can
stop themselves when they're no longer required, but need to be
(re)-started when their idle condition changes.
Further complications is that we want the timer handler to always do
the forward such that it will always correctly deal with the overruns,
and we do not want to race such that the handler has already decided
to stop, but the (external) restart sees the timer still active and we
end up with a 'lost' timer.
The problem with the current code is that the re-start can come before
the callback does the forward, at which point the forward from the
callback will WARN about forwarding an enqueued timer.
Now, conceptually its easy to detect if you're before or after the fwd
by comparing the expiration time against the current time. Of course,
that's expensive (and racy) because we don't have the current time.
Alternatively one could cache this state inside the timer, but then
everybody pays the overhead of maintaining this extra state, and that
is undesired.
The only other option that I could see is the external timer_active
variable, which I tried to kill before. I would love a nicer interface
for this seemingly simple 'problem' but alas.
Fixes: 272325c4821f ("perf: Fix mux_interval hrtimer wreckage")
Fixes: 77a4d1a1b9a1 ("sched: Cleanup bandwidth timers")
Cc: pjt@google.com
Cc: tglx@linutronix.de
Cc: klamm@yandex-team.ru
Cc: mingo@kernel.org
Cc: bsegall@google.com
Cc: hpa@zytor.com
Cc: Sasha Levin <sasha.levin@oracle.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20150514102311.GX21418@twins.programming.kicks-ass.net
2015-05-14 10:23:11 +00:00
|
|
|
if (!cfs_b->period_active) {
|
|
|
|
cfs_b->period_active = 1;
|
|
|
|
hrtimer_forward_now(&cfs_b->period_timer, cfs_b->period);
|
|
|
|
hrtimer_start_expires(&cfs_b->period_timer, HRTIMER_MODE_ABS_PINNED);
|
|
|
|
}
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void destroy_cfs_bandwidth(struct cfs_bandwidth *cfs_b)
|
|
|
|
{
|
2014-12-25 06:51:21 +00:00
|
|
|
/* init_cfs_bandwidth() was not called */
|
|
|
|
if (!cfs_b->throttled_cfs_rq.next)
|
|
|
|
return;
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
hrtimer_cancel(&cfs_b->period_timer);
|
|
|
|
hrtimer_cancel(&cfs_b->slack_timer);
|
|
|
|
}
|
|
|
|
|
2017-05-04 13:31:22 +00:00
|
|
|
/*
|
|
|
|
* Both these cpu hotplug callbacks race against unregister_fair_sched_group()
|
|
|
|
*
|
|
|
|
* The race is harmless, since modifying bandwidth settings of unhooked group
|
|
|
|
* bits doesn't do much.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* cpu online calback */
|
2014-06-25 08:19:42 +00:00
|
|
|
static void __maybe_unused update_runtime_enabled(struct rq *rq)
|
|
|
|
{
|
2017-05-04 13:31:22 +00:00
|
|
|
struct task_group *tg;
|
2014-06-25 08:19:42 +00:00
|
|
|
|
2017-05-04 13:31:22 +00:00
|
|
|
lockdep_assert_held(&rq->lock);
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(tg, &task_groups, list) {
|
|
|
|
struct cfs_bandwidth *cfs_b = &tg->cfs_bandwidth;
|
|
|
|
struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)];
|
2014-06-25 08:19:42 +00:00
|
|
|
|
|
|
|
raw_spin_lock(&cfs_b->lock);
|
|
|
|
cfs_rq->runtime_enabled = cfs_b->quota != RUNTIME_INF;
|
|
|
|
raw_spin_unlock(&cfs_b->lock);
|
|
|
|
}
|
2017-05-04 13:31:22 +00:00
|
|
|
rcu_read_unlock();
|
2014-06-25 08:19:42 +00:00
|
|
|
}
|
|
|
|
|
2017-05-04 13:31:22 +00:00
|
|
|
/* cpu offline callback */
|
2013-01-25 14:14:22 +00:00
|
|
|
static void __maybe_unused unthrottle_offline_cfs_rqs(struct rq *rq)
|
2011-10-25 08:00:11 +00:00
|
|
|
{
|
2017-05-04 13:31:22 +00:00
|
|
|
struct task_group *tg;
|
|
|
|
|
|
|
|
lockdep_assert_held(&rq->lock);
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(tg, &task_groups, list) {
|
|
|
|
struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)];
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
if (!cfs_rq->runtime_enabled)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* clock_task is not advancing so we just need to make sure
|
|
|
|
* there's some valid quota amount
|
|
|
|
*/
|
2014-05-19 22:49:45 +00:00
|
|
|
cfs_rq->runtime_remaining = 1;
|
2014-06-25 08:19:42 +00:00
|
|
|
/*
|
|
|
|
* Offline rq is schedulable till cpu is completely disabled
|
|
|
|
* in take_cpu_down(), so we prevent new cfs throttling here.
|
|
|
|
*/
|
|
|
|
cfs_rq->runtime_enabled = 0;
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
if (cfs_rq_throttled(cfs_rq))
|
|
|
|
unthrottle_cfs_rq(cfs_rq);
|
|
|
|
}
|
2017-05-04 13:31:22 +00:00
|
|
|
rcu_read_unlock();
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#else /* CONFIG_CFS_BANDWIDTH */
|
2012-10-04 11:18:31 +00:00
|
|
|
static inline u64 cfs_rq_clock_task(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
2013-04-11 23:51:02 +00:00
|
|
|
return rq_clock_task(rq_of(cfs_rq));
|
2012-10-04 11:18:31 +00:00
|
|
|
}
|
|
|
|
|
2013-11-18 17:27:06 +00:00
|
|
|
static void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec) {}
|
2012-02-11 05:05:00 +00:00
|
|
|
static bool check_cfs_rq_runtime(struct cfs_rq *cfs_rq) { return false; }
|
2011-07-21 16:43:39 +00:00
|
|
|
static void check_enqueue_throttle(struct cfs_rq *cfs_rq) {}
|
2016-06-22 13:14:26 +00:00
|
|
|
static inline void sync_throttle(struct task_group *tg, int cpu) {}
|
2012-03-21 20:07:16 +00:00
|
|
|
static __always_inline void return_cfs_rq_runtime(struct cfs_rq *cfs_rq) {}
|
2011-07-21 16:43:33 +00:00
|
|
|
|
|
|
|
static inline int cfs_rq_throttled(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2011-07-21 16:43:36 +00:00
|
|
|
|
|
|
|
static inline int throttled_hierarchy(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int throttled_lb_pair(struct task_group *tg,
|
|
|
|
int src_cpu, int dest_cpu)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
void init_cfs_bandwidth(struct cfs_bandwidth *cfs_b) {}
|
|
|
|
|
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
static void init_cfs_rq_runtime(struct cfs_rq *cfs_rq) {}
|
2011-07-21 16:43:28 +00:00
|
|
|
#endif
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
static inline struct cfs_bandwidth *tg_cfs_bandwidth(struct task_group *tg)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
static inline void destroy_cfs_bandwidth(struct cfs_bandwidth *cfs_b) {}
|
2014-06-25 08:19:42 +00:00
|
|
|
static inline void update_runtime_enabled(struct rq *rq) {}
|
2012-08-09 22:34:47 +00:00
|
|
|
static inline void unthrottle_offline_cfs_rqs(struct rq *rq) {}
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
#endif /* CONFIG_CFS_BANDWIDTH */
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/**************************************************
|
|
|
|
* CFS operations on tasks:
|
|
|
|
*/
|
|
|
|
|
2008-01-25 20:08:29 +00:00
|
|
|
#ifdef CONFIG_SCHED_HRTICK
|
|
|
|
static void hrtick_start_fair(struct rq *rq, struct task_struct *p)
|
|
|
|
{
|
|
|
|
struct sched_entity *se = &p->se;
|
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
|
|
|
|
2016-09-20 20:34:51 +00:00
|
|
|
SCHED_WARN_ON(task_rq(p) != rq);
|
2008-01-25 20:08:29 +00:00
|
|
|
|
2016-09-17 01:28:51 +00:00
|
|
|
if (rq->cfs.h_nr_running > 1) {
|
2008-01-25 20:08:29 +00:00
|
|
|
u64 slice = sched_slice(cfs_rq, se);
|
|
|
|
u64 ran = se->sum_exec_runtime - se->prev_sum_exec_runtime;
|
|
|
|
s64 delta = slice - ran;
|
|
|
|
|
|
|
|
if (delta < 0) {
|
|
|
|
if (rq->curr == p)
|
2014-06-28 20:03:57 +00:00
|
|
|
resched_curr(rq);
|
2008-01-25 20:08:29 +00:00
|
|
|
return;
|
|
|
|
}
|
2008-07-18 16:01:23 +00:00
|
|
|
hrtick_start(rq, delta);
|
2008-01-25 20:08:29 +00:00
|
|
|
}
|
|
|
|
}
|
2008-10-17 17:27:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* called from enqueue/dequeue and updates the hrtick when the
|
|
|
|
* current task is from our class and nr_running is low enough
|
|
|
|
* to matter.
|
|
|
|
*/
|
|
|
|
static void hrtick_update(struct rq *rq)
|
|
|
|
{
|
|
|
|
struct task_struct *curr = rq->curr;
|
|
|
|
|
2011-11-22 14:20:07 +00:00
|
|
|
if (!hrtick_enabled(rq) || curr->sched_class != &fair_sched_class)
|
2008-10-17 17:27:03 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (cfs_rq_of(&curr->se)->nr_running < sched_nr_latency)
|
|
|
|
hrtick_start_fair(rq, curr);
|
|
|
|
}
|
2008-06-24 18:09:43 +00:00
|
|
|
#else /* !CONFIG_SCHED_HRTICK */
|
2008-01-25 20:08:29 +00:00
|
|
|
static inline void
|
|
|
|
hrtick_start_fair(struct rq *rq, struct task_struct *p)
|
|
|
|
{
|
|
|
|
}
|
2008-10-17 17:27:03 +00:00
|
|
|
|
|
|
|
static inline void hrtick_update(struct rq *rq)
|
|
|
|
{
|
|
|
|
}
|
2008-01-25 20:08:29 +00:00
|
|
|
#endif
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
|
|
|
* The enqueue_task method is called before nr_running is
|
|
|
|
* increased. Here we update the fair scheduling stats and
|
|
|
|
* then put the task into the rbtree:
|
|
|
|
*/
|
2010-01-20 20:58:57 +00:00
|
|
|
static void
|
2010-03-24 15:38:48 +00:00
|
|
|
enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
|
|
|
struct cfs_rq *cfs_rq;
|
2008-02-25 16:34:02 +00:00
|
|
|
struct sched_entity *se = &p->se;
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2016-09-09 21:59:33 +00:00
|
|
|
/*
|
|
|
|
* If in_iowait is set, the code below may not trigger any cpufreq
|
|
|
|
* utilization updates, so do it here explicitly with the IOWAIT flag
|
|
|
|
* passed.
|
|
|
|
*/
|
|
|
|
if (p->in_iowait)
|
sched: cpufreq: Allow remote cpufreq callbacks
With Android UI and benchmarks the latency of cpufreq response to
certain scheduling events can become very critical. Currently, callbacks
into cpufreq governors are only made from the scheduler if the target
CPU of the event is the same as the current CPU. This means there are
certain situations where a target CPU may not run the cpufreq governor
for some time.
One testcase to show this behavior is where a task starts running on
CPU0, then a new task is also spawned on CPU0 by a task on CPU1. If the
system is configured such that the new tasks should receive maximum
demand initially, this should result in CPU0 increasing frequency
immediately. But because of the above mentioned limitation though, this
does not occur.
This patch updates the scheduler core to call the cpufreq callbacks for
remote CPUs as well.
The schedutil, ondemand and conservative governors are updated to
process cpufreq utilization update hooks called for remote CPUs where
the remote CPU is managed by the cpufreq policy of the local CPU.
The intel_pstate driver is updated to always reject remote callbacks.
This is tested with couple of usecases (Android: hackbench, recentfling,
galleryfling, vellamo, Ubuntu: hackbench) on ARM hikey board (64 bit
octa-core, single policy). Only galleryfling showed minor improvements,
while others didn't had much deviation.
The reason being that this patch only targets a corner case, where
following are required to be true to improve performance and that
doesn't happen too often with these tests:
- Task is migrated to another CPU.
- The task has high demand, and should take the target CPU to higher
OPPs.
- And the target CPU doesn't call into the cpufreq governor until the
next tick.
Based on initial work from Steve Muckle.
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Acked-by: Saravana Kannan <skannan@codeaurora.org>
Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2017-07-28 06:46:38 +00:00
|
|
|
cpufreq_update_util(rq, SCHED_CPUFREQ_IOWAIT);
|
2016-09-09 21:59:33 +00:00
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
for_each_sched_entity(se) {
|
2008-02-25 16:34:02 +00:00
|
|
|
if (se->on_rq)
|
2007-07-09 16:51:58 +00:00
|
|
|
break;
|
|
|
|
cfs_rq = cfs_rq_of(se);
|
sched: Remove the cfs_rq dependency from set_task_cpu()
In order to remove the cfs_rq dependency from set_task_cpu() we
need to ensure the task is cfs_rq invariant for all callsites.
The simple approach is to substract cfs_rq->min_vruntime from
se->vruntime on dequeue, and add cfs_rq->min_vruntime on
enqueue.
However, this has the downside of breaking FAIR_SLEEPERS since
we loose the old vruntime as we only maintain the relative
position.
To solve this, we observe that we only migrate runnable tasks,
we do this using deactivate_task(.sleep=0) and
activate_task(.wakeup=0), therefore we can restrain the
min_vruntime invariance to that state.
The only other case is wakeup balancing, since we want to
maintain the old vruntime we cannot make it relative on dequeue,
but since we don't migrate inactive tasks, we can do so right
before we activate it again.
This is where we need the new pre-wakeup hook, we need to call
this while still holding the old rq->lock. We could fold it into
->select_task_rq(), but since that has multiple callsites and
would obfuscate the locking requirements, that seems like a
fudge.
This leaves the fork() case, simply make sure that ->task_fork()
leaves the ->vruntime in a relative state.
This covers all cases where set_task_cpu() gets called, and
ensures it sees a relative vruntime.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20091216170518.191697025@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 17:04:41 +00:00
|
|
|
enqueue_entity(cfs_rq, se, flags);
|
2011-07-21 16:43:33 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* end evaluation on encountering a throttled cfs_rq
|
|
|
|
*
|
|
|
|
* note: in the case of encountering a throttled cfs_rq we will
|
|
|
|
* post the final h_nr_running increment below.
|
2016-06-16 16:51:48 +00:00
|
|
|
*/
|
2011-07-21 16:43:33 +00:00
|
|
|
if (cfs_rq_throttled(cfs_rq))
|
|
|
|
break;
|
2011-07-21 16:43:27 +00:00
|
|
|
cfs_rq->h_nr_running++;
|
2011-07-21 16:43:33 +00:00
|
|
|
|
sched: Remove the cfs_rq dependency from set_task_cpu()
In order to remove the cfs_rq dependency from set_task_cpu() we
need to ensure the task is cfs_rq invariant for all callsites.
The simple approach is to substract cfs_rq->min_vruntime from
se->vruntime on dequeue, and add cfs_rq->min_vruntime on
enqueue.
However, this has the downside of breaking FAIR_SLEEPERS since
we loose the old vruntime as we only maintain the relative
position.
To solve this, we observe that we only migrate runnable tasks,
we do this using deactivate_task(.sleep=0) and
activate_task(.wakeup=0), therefore we can restrain the
min_vruntime invariance to that state.
The only other case is wakeup balancing, since we want to
maintain the old vruntime we cannot make it relative on dequeue,
but since we don't migrate inactive tasks, we can do so right
before we activate it again.
This is where we need the new pre-wakeup hook, we need to call
this while still holding the old rq->lock. We could fold it into
->select_task_rq(), but since that has multiple callsites and
would obfuscate the locking requirements, that seems like a
fudge.
This leaves the fork() case, simply make sure that ->task_fork()
leaves the ->vruntime in a relative state.
This covers all cases where set_task_cpu() gets called, and
ensures it sees a relative vruntime.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20091216170518.191697025@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 17:04:41 +00:00
|
|
|
flags = ENQUEUE_WAKEUP;
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
2008-01-25 20:08:29 +00:00
|
|
|
|
2010-11-15 23:47:00 +00:00
|
|
|
for_each_sched_entity(se) {
|
2011-07-22 01:14:31 +00:00
|
|
|
cfs_rq = cfs_rq_of(se);
|
2011-07-21 16:43:27 +00:00
|
|
|
cfs_rq->h_nr_running++;
|
2010-11-15 23:47:00 +00:00
|
|
|
|
2011-07-21 16:43:33 +00:00
|
|
|
if (cfs_rq_throttled(cfs_rq))
|
|
|
|
break;
|
|
|
|
|
2017-05-06 15:32:43 +00:00
|
|
|
update_load_avg(cfs_rq, se, UPDATE_TG);
|
2017-05-06 13:59:54 +00:00
|
|
|
update_cfs_group(se);
|
2010-11-15 23:47:00 +00:00
|
|
|
}
|
|
|
|
|
2015-07-15 00:04:36 +00:00
|
|
|
if (!se)
|
2014-05-08 23:00:14 +00:00
|
|
|
add_nr_running(rq, 1);
|
2015-07-15 00:04:36 +00:00
|
|
|
|
2008-10-17 17:27:03 +00:00
|
|
|
hrtick_update(rq);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2011-04-14 17:30:53 +00:00
|
|
|
static void set_next_buddy(struct sched_entity *se);
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
|
|
|
* The dequeue_task method is called before nr_running is
|
|
|
|
* decreased. We remove the task from the rbtree and
|
|
|
|
* update the fair scheduling stats:
|
|
|
|
*/
|
2010-03-24 15:38:48 +00:00
|
|
|
static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
|
|
|
struct cfs_rq *cfs_rq;
|
2008-02-25 16:34:02 +00:00
|
|
|
struct sched_entity *se = &p->se;
|
2011-04-14 17:30:53 +00:00
|
|
|
int task_sleep = flags & DEQUEUE_SLEEP;
|
2007-07-09 16:51:58 +00:00
|
|
|
|
|
|
|
for_each_sched_entity(se) {
|
|
|
|
cfs_rq = cfs_rq_of(se);
|
2010-03-24 15:38:48 +00:00
|
|
|
dequeue_entity(cfs_rq, se, flags);
|
2011-07-21 16:43:33 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* end evaluation on encountering a throttled cfs_rq
|
|
|
|
*
|
|
|
|
* note: in the case of encountering a throttled cfs_rq we will
|
|
|
|
* post the final h_nr_running decrement below.
|
|
|
|
*/
|
|
|
|
if (cfs_rq_throttled(cfs_rq))
|
|
|
|
break;
|
2011-07-21 16:43:27 +00:00
|
|
|
cfs_rq->h_nr_running--;
|
2010-11-15 23:47:00 +00:00
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/* Don't dequeue parent if it has other entities besides us */
|
2011-04-14 17:30:53 +00:00
|
|
|
if (cfs_rq->load.weight) {
|
2016-06-16 12:57:15 +00:00
|
|
|
/* Avoid re-evaluating load for this entity: */
|
|
|
|
se = parent_entity(se);
|
2011-04-14 17:30:53 +00:00
|
|
|
/*
|
|
|
|
* Bias pick_next to pick a task from this cfs_rq, as
|
|
|
|
* p is sleeping when it is within its sched_slice.
|
|
|
|
*/
|
2016-06-16 12:57:15 +00:00
|
|
|
if (task_sleep && se && !throttled_hierarchy(cfs_rq))
|
|
|
|
set_next_buddy(se);
|
2007-07-09 16:51:58 +00:00
|
|
|
break;
|
2011-04-14 17:30:53 +00:00
|
|
|
}
|
2010-03-24 15:38:48 +00:00
|
|
|
flags |= DEQUEUE_SLEEP;
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
2008-01-25 20:08:29 +00:00
|
|
|
|
2010-11-15 23:47:00 +00:00
|
|
|
for_each_sched_entity(se) {
|
2011-07-22 01:14:31 +00:00
|
|
|
cfs_rq = cfs_rq_of(se);
|
2011-07-21 16:43:27 +00:00
|
|
|
cfs_rq->h_nr_running--;
|
2010-11-15 23:47:00 +00:00
|
|
|
|
2011-07-21 16:43:33 +00:00
|
|
|
if (cfs_rq_throttled(cfs_rq))
|
|
|
|
break;
|
|
|
|
|
2017-05-06 15:32:43 +00:00
|
|
|
update_load_avg(cfs_rq, se, UPDATE_TG);
|
2017-05-06 13:59:54 +00:00
|
|
|
update_cfs_group(se);
|
2010-11-15 23:47:00 +00:00
|
|
|
}
|
|
|
|
|
2015-07-15 00:04:36 +00:00
|
|
|
if (!se)
|
2014-05-08 23:00:14 +00:00
|
|
|
sub_nr_running(rq, 1);
|
2015-07-15 00:04:36 +00:00
|
|
|
|
2008-10-17 17:27:03 +00:00
|
|
|
hrtick_update(rq);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2008-01-25 20:08:09 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2016-05-09 08:38:05 +00:00
|
|
|
|
|
|
|
/* Working cpumask for: load_balance, load_balance_newidle. */
|
|
|
|
DEFINE_PER_CPU(cpumask_var_t, load_balance_mask);
|
|
|
|
DEFINE_PER_CPU(cpumask_var_t, select_idle_mask);
|
|
|
|
|
2016-04-19 15:36:51 +00:00
|
|
|
#ifdef CONFIG_NO_HZ_COMMON
|
2015-04-14 11:19:42 +00:00
|
|
|
/*
|
|
|
|
* per rq 'load' arrray crap; XXX kill this.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2015-10-19 11:49:30 +00:00
|
|
|
* The exact cpuload calculated at every tick would be:
|
2015-04-14 11:19:42 +00:00
|
|
|
*
|
2015-10-19 11:49:30 +00:00
|
|
|
* load' = (1 - 1/2^i) * load + (1/2^i) * cur_load
|
|
|
|
*
|
|
|
|
* If a cpu misses updates for n ticks (as it was idle) and update gets
|
|
|
|
* called on the n+1-th tick when cpu may be busy, then we have:
|
|
|
|
*
|
|
|
|
* load_n = (1 - 1/2^i)^n * load_0
|
|
|
|
* load_n+1 = (1 - 1/2^i) * load_n + (1/2^i) * cur_load
|
2015-04-14 11:19:42 +00:00
|
|
|
*
|
|
|
|
* decay_load_missed() below does efficient calculation of
|
|
|
|
*
|
2015-10-19 11:49:30 +00:00
|
|
|
* load' = (1 - 1/2^i)^n * load
|
|
|
|
*
|
|
|
|
* Because x^(n+m) := x^n * x^m we can decompose any x^n in power-of-2 factors.
|
|
|
|
* This allows us to precompute the above in said factors, thereby allowing the
|
|
|
|
* reduction of an arbitrary n in O(log_2 n) steps. (See also
|
|
|
|
* fixed_power_int())
|
2015-04-14 11:19:42 +00:00
|
|
|
*
|
2015-10-19 11:49:30 +00:00
|
|
|
* The calculation is approximated on a 128 point scale.
|
2015-04-14 11:19:42 +00:00
|
|
|
*/
|
|
|
|
#define DEGRADE_SHIFT 7
|
2015-10-19 11:49:30 +00:00
|
|
|
|
|
|
|
static const u8 degrade_zero_ticks[CPU_LOAD_IDX_MAX] = {0, 8, 32, 64, 128};
|
|
|
|
static const u8 degrade_factor[CPU_LOAD_IDX_MAX][DEGRADE_SHIFT + 1] = {
|
|
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0 },
|
|
|
|
{ 64, 32, 8, 0, 0, 0, 0, 0 },
|
|
|
|
{ 96, 72, 40, 12, 1, 0, 0, 0 },
|
|
|
|
{ 112, 98, 75, 43, 15, 1, 0, 0 },
|
|
|
|
{ 120, 112, 98, 76, 45, 16, 2, 0 }
|
|
|
|
};
|
2015-04-14 11:19:42 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Update cpu_load for any missed ticks, due to tickless idle. The backlog
|
|
|
|
* would be when CPU is idle and so we just decay the old load without
|
|
|
|
* adding any new load.
|
|
|
|
*/
|
|
|
|
static unsigned long
|
|
|
|
decay_load_missed(unsigned long load, unsigned long missed_updates, int idx)
|
|
|
|
{
|
|
|
|
int j = 0;
|
|
|
|
|
|
|
|
if (!missed_updates)
|
|
|
|
return load;
|
|
|
|
|
|
|
|
if (missed_updates >= degrade_zero_ticks[idx])
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (idx == 1)
|
|
|
|
return load >> missed_updates;
|
|
|
|
|
|
|
|
while (missed_updates) {
|
|
|
|
if (missed_updates % 2)
|
|
|
|
load = (load * degrade_factor[idx][j]) >> DEGRADE_SHIFT;
|
|
|
|
|
|
|
|
missed_updates >>= 1;
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
return load;
|
|
|
|
}
|
2016-04-19 15:36:51 +00:00
|
|
|
#endif /* CONFIG_NO_HZ_COMMON */
|
2015-04-14 11:19:42 +00:00
|
|
|
|
2015-10-14 09:47:35 +00:00
|
|
|
/**
|
2016-04-13 13:56:50 +00:00
|
|
|
* __cpu_load_update - update the rq->cpu_load[] statistics
|
2015-10-14 09:47:35 +00:00
|
|
|
* @this_rq: The rq to update statistics for
|
|
|
|
* @this_load: The current load
|
|
|
|
* @pending_updates: The number of missed updates
|
|
|
|
*
|
2015-04-14 11:19:42 +00:00
|
|
|
* Update rq->cpu_load[] statistics. This function is usually called every
|
2015-10-14 09:47:35 +00:00
|
|
|
* scheduler tick (TICK_NSEC).
|
|
|
|
*
|
|
|
|
* This function computes a decaying average:
|
|
|
|
*
|
|
|
|
* load[i]' = (1 - 1/2^i) * load[i] + (1/2^i) * load
|
|
|
|
*
|
|
|
|
* Because of NOHZ it might not get called on every tick which gives need for
|
|
|
|
* the @pending_updates argument.
|
|
|
|
*
|
|
|
|
* load[i]_n = (1 - 1/2^i) * load[i]_n-1 + (1/2^i) * load_n-1
|
|
|
|
* = A * load[i]_n-1 + B ; A := (1 - 1/2^i), B := (1/2^i) * load
|
|
|
|
* = A * (A * load[i]_n-2 + B) + B
|
|
|
|
* = A * (A * (A * load[i]_n-3 + B) + B) + B
|
|
|
|
* = A^3 * load[i]_n-3 + (A^2 + A + 1) * B
|
|
|
|
* = A^n * load[i]_0 + (A^(n-1) + A^(n-2) + ... + 1) * B
|
|
|
|
* = A^n * load[i]_0 + ((1 - A^n) / (1 - A)) * B
|
|
|
|
* = (1 - 1/2^i)^n * (load[i]_0 - load) + load
|
|
|
|
*
|
|
|
|
* In the above we've assumed load_n := load, which is true for NOHZ_FULL as
|
|
|
|
* any change in load would have resulted in the tick being turned back on.
|
|
|
|
*
|
|
|
|
* For regular NOHZ, this reduces to:
|
|
|
|
*
|
|
|
|
* load[i]_n = (1 - 1/2^i)^n * load[i]_0
|
|
|
|
*
|
|
|
|
* see decay_load_misses(). For NOHZ_FULL we get to subtract and add the extra
|
2016-04-13 13:56:51 +00:00
|
|
|
* term.
|
2015-04-14 11:19:42 +00:00
|
|
|
*/
|
2016-04-13 13:56:51 +00:00
|
|
|
static void cpu_load_update(struct rq *this_rq, unsigned long this_load,
|
|
|
|
unsigned long pending_updates)
|
2015-04-14 11:19:42 +00:00
|
|
|
{
|
2016-04-19 15:36:51 +00:00
|
|
|
unsigned long __maybe_unused tickless_load = this_rq->cpu_load[0];
|
2015-04-14 11:19:42 +00:00
|
|
|
int i, scale;
|
|
|
|
|
|
|
|
this_rq->nr_load_updates++;
|
|
|
|
|
|
|
|
/* Update our load: */
|
|
|
|
this_rq->cpu_load[0] = this_load; /* Fasttrack for idx 0 */
|
|
|
|
for (i = 1, scale = 2; i < CPU_LOAD_IDX_MAX; i++, scale += scale) {
|
|
|
|
unsigned long old_load, new_load;
|
|
|
|
|
|
|
|
/* scale is effectively 1 << i now, and >> i divides by scale */
|
|
|
|
|
2016-01-15 07:07:49 +00:00
|
|
|
old_load = this_rq->cpu_load[i];
|
2016-04-19 15:36:51 +00:00
|
|
|
#ifdef CONFIG_NO_HZ_COMMON
|
2015-04-14 11:19:42 +00:00
|
|
|
old_load = decay_load_missed(old_load, pending_updates - 1, i);
|
2016-01-15 07:07:49 +00:00
|
|
|
if (tickless_load) {
|
|
|
|
old_load -= decay_load_missed(tickless_load, pending_updates - 1, i);
|
|
|
|
/*
|
|
|
|
* old_load can never be a negative value because a
|
|
|
|
* decayed tickless_load cannot be greater than the
|
|
|
|
* original tickless_load.
|
|
|
|
*/
|
|
|
|
old_load += tickless_load;
|
|
|
|
}
|
2016-04-19 15:36:51 +00:00
|
|
|
#endif
|
2015-04-14 11:19:42 +00:00
|
|
|
new_load = this_load;
|
|
|
|
/*
|
|
|
|
* Round up the averaging division if load is increasing. This
|
|
|
|
* prevents us from getting stuck on 9 if the load is 10, for
|
|
|
|
* example.
|
|
|
|
*/
|
|
|
|
if (new_load > old_load)
|
|
|
|
new_load += scale - 1;
|
|
|
|
|
|
|
|
this_rq->cpu_load[i] = (old_load * (scale - 1) + new_load) >> i;
|
|
|
|
}
|
|
|
|
|
|
|
|
sched_avg_update(this_rq);
|
|
|
|
}
|
|
|
|
|
2015-07-15 00:04:42 +00:00
|
|
|
/* Used instead of source_load when we know the type == 0 */
|
2017-05-24 05:29:54 +00:00
|
|
|
static unsigned long weighted_cpuload(struct rq *rq)
|
2015-07-15 00:04:42 +00:00
|
|
|
{
|
2017-05-24 05:29:54 +00:00
|
|
|
return cfs_rq_runnable_load_avg(&rq->cfs);
|
2015-07-15 00:04:42 +00:00
|
|
|
}
|
|
|
|
|
2015-04-14 11:19:42 +00:00
|
|
|
#ifdef CONFIG_NO_HZ_COMMON
|
2016-04-13 13:56:51 +00:00
|
|
|
/*
|
|
|
|
* There is no sane way to deal with nohz on smp when using jiffies because the
|
|
|
|
* cpu doing the jiffies update might drift wrt the cpu doing the jiffy reading
|
|
|
|
* causing off-by-one errors in observed deltas; {0,2} instead of {1,1}.
|
|
|
|
*
|
|
|
|
* Therefore we need to avoid the delta approach from the regular tick when
|
|
|
|
* possible since that would seriously skew the load calculation. This is why we
|
|
|
|
* use cpu_load_update_periodic() for CPUs out of nohz. However we'll rely on
|
|
|
|
* jiffies deltas for updates happening while in nohz mode (idle ticks, idle
|
|
|
|
* loop exit, nohz_idle_balance, nohz full exit...)
|
|
|
|
*
|
|
|
|
* This means we might still be one tick off for nohz periods.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void cpu_load_update_nohz(struct rq *this_rq,
|
|
|
|
unsigned long curr_jiffies,
|
|
|
|
unsigned long load)
|
2016-01-13 16:01:29 +00:00
|
|
|
{
|
|
|
|
unsigned long pending_updates;
|
|
|
|
|
|
|
|
pending_updates = curr_jiffies - this_rq->last_load_update_tick;
|
|
|
|
if (pending_updates) {
|
|
|
|
this_rq->last_load_update_tick = curr_jiffies;
|
|
|
|
/*
|
|
|
|
* In the regular NOHZ case, we were idle, this means load 0.
|
|
|
|
* In the NOHZ_FULL case, we were non-idle, we should consider
|
|
|
|
* its weighted load.
|
|
|
|
*/
|
2016-04-13 13:56:51 +00:00
|
|
|
cpu_load_update(this_rq, load, pending_updates);
|
2016-01-13 16:01:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-14 11:19:42 +00:00
|
|
|
/*
|
|
|
|
* Called from nohz_idle_balance() to update the load ratings before doing the
|
|
|
|
* idle balance.
|
|
|
|
*/
|
2016-04-13 13:56:50 +00:00
|
|
|
static void cpu_load_update_idle(struct rq *this_rq)
|
2015-04-14 11:19:42 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* bail if there's load or we're actually up-to-date.
|
|
|
|
*/
|
2017-05-24 05:29:54 +00:00
|
|
|
if (weighted_cpuload(this_rq))
|
2015-04-14 11:19:42 +00:00
|
|
|
return;
|
|
|
|
|
2016-04-13 13:56:51 +00:00
|
|
|
cpu_load_update_nohz(this_rq, READ_ONCE(jiffies), 0);
|
2015-04-14 11:19:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-04-13 13:56:51 +00:00
|
|
|
* Record CPU load on nohz entry so we know the tickless load to account
|
|
|
|
* on nohz exit. cpu_load[0] happens then to be updated more frequently
|
|
|
|
* than other cpu_load[idx] but it should be fine as cpu_load readers
|
|
|
|
* shouldn't rely into synchronized cpu_load[*] updates.
|
2015-04-14 11:19:42 +00:00
|
|
|
*/
|
2016-04-13 13:56:51 +00:00
|
|
|
void cpu_load_update_nohz_start(void)
|
2015-04-14 11:19:42 +00:00
|
|
|
{
|
|
|
|
struct rq *this_rq = this_rq();
|
2016-04-13 13:56:51 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This is all lockless but should be fine. If weighted_cpuload changes
|
|
|
|
* concurrently we'll exit nohz. And cpu_load write can race with
|
|
|
|
* cpu_load_update_idle() but both updater would be writing the same.
|
|
|
|
*/
|
2017-05-24 05:29:54 +00:00
|
|
|
this_rq->cpu_load[0] = weighted_cpuload(this_rq);
|
2016-04-13 13:56:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Account the tickless load in the end of a nohz frame.
|
|
|
|
*/
|
|
|
|
void cpu_load_update_nohz_stop(void)
|
|
|
|
{
|
2015-04-28 20:00:20 +00:00
|
|
|
unsigned long curr_jiffies = READ_ONCE(jiffies);
|
2016-04-13 13:56:51 +00:00
|
|
|
struct rq *this_rq = this_rq();
|
|
|
|
unsigned long load;
|
2016-10-04 14:04:35 +00:00
|
|
|
struct rq_flags rf;
|
2015-04-14 11:19:42 +00:00
|
|
|
|
|
|
|
if (curr_jiffies == this_rq->last_load_update_tick)
|
|
|
|
return;
|
|
|
|
|
2017-05-24 05:29:54 +00:00
|
|
|
load = weighted_cpuload(this_rq);
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_lock(this_rq, &rf);
|
2016-05-03 19:46:54 +00:00
|
|
|
update_rq_clock(this_rq);
|
2016-04-13 13:56:51 +00:00
|
|
|
cpu_load_update_nohz(this_rq, curr_jiffies, load);
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_unlock(this_rq, &rf);
|
2015-04-14 11:19:42 +00:00
|
|
|
}
|
2016-04-13 13:56:51 +00:00
|
|
|
#else /* !CONFIG_NO_HZ_COMMON */
|
|
|
|
static inline void cpu_load_update_nohz(struct rq *this_rq,
|
|
|
|
unsigned long curr_jiffies,
|
|
|
|
unsigned long load) { }
|
|
|
|
#endif /* CONFIG_NO_HZ_COMMON */
|
|
|
|
|
|
|
|
static void cpu_load_update_periodic(struct rq *this_rq, unsigned long load)
|
|
|
|
{
|
2016-04-19 15:36:51 +00:00
|
|
|
#ifdef CONFIG_NO_HZ_COMMON
|
2016-04-13 13:56:51 +00:00
|
|
|
/* See the mess around cpu_load_update_nohz(). */
|
|
|
|
this_rq->last_load_update_tick = READ_ONCE(jiffies);
|
2016-04-19 15:36:51 +00:00
|
|
|
#endif
|
2016-04-13 13:56:51 +00:00
|
|
|
cpu_load_update(this_rq, load, 1);
|
|
|
|
}
|
2015-04-14 11:19:42 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Called from scheduler_tick()
|
|
|
|
*/
|
2016-04-13 13:56:50 +00:00
|
|
|
void cpu_load_update_active(struct rq *this_rq)
|
2015-04-14 11:19:42 +00:00
|
|
|
{
|
2017-05-24 05:29:54 +00:00
|
|
|
unsigned long load = weighted_cpuload(this_rq);
|
2016-04-13 13:56:51 +00:00
|
|
|
|
|
|
|
if (tick_nohz_tick_stopped())
|
|
|
|
cpu_load_update_nohz(this_rq, READ_ONCE(jiffies), load);
|
|
|
|
else
|
|
|
|
cpu_load_update_periodic(this_rq, load);
|
2015-04-14 11:19:42 +00:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
/*
|
|
|
|
* Return a low guess at the load of a migration-source cpu weighted
|
|
|
|
* according to the scheduling class and "nice" value.
|
|
|
|
*
|
|
|
|
* We want to under-estimate the load of migration sources, to
|
|
|
|
* balance conservatively.
|
|
|
|
*/
|
|
|
|
static unsigned long source_load(int cpu, int type)
|
|
|
|
{
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
2017-05-24 05:29:54 +00:00
|
|
|
unsigned long total = weighted_cpuload(rq);
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
if (type == 0 || !sched_feat(LB_BIAS))
|
|
|
|
return total;
|
|
|
|
|
|
|
|
return min(rq->cpu_load[type-1], total);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return a high guess at the load of a migration-target cpu weighted
|
|
|
|
* according to the scheduling class and "nice" value.
|
|
|
|
*/
|
|
|
|
static unsigned long target_load(int cpu, int type)
|
|
|
|
{
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
2017-05-24 05:29:54 +00:00
|
|
|
unsigned long total = weighted_cpuload(rq);
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
if (type == 0 || !sched_feat(LB_BIAS))
|
|
|
|
return total;
|
|
|
|
|
|
|
|
return max(rq->cpu_load[type-1], total);
|
|
|
|
}
|
|
|
|
|
2014-05-26 22:19:38 +00:00
|
|
|
static unsigned long capacity_of(int cpu)
|
2011-10-25 08:00:11 +00:00
|
|
|
{
|
2014-05-26 22:19:38 +00:00
|
|
|
return cpu_rq(cpu)->cpu_capacity;
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
2015-02-27 15:54:09 +00:00
|
|
|
static unsigned long capacity_orig_of(int cpu)
|
|
|
|
{
|
|
|
|
return cpu_rq(cpu)->cpu_capacity_orig;
|
|
|
|
}
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
static unsigned long cpu_avg_load_per_task(int cpu)
|
|
|
|
{
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
2015-04-28 20:00:20 +00:00
|
|
|
unsigned long nr_running = READ_ONCE(rq->cfs.h_nr_running);
|
2017-05-24 05:29:54 +00:00
|
|
|
unsigned long load_avg = weighted_cpuload(rq);
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
if (nr_running)
|
2013-06-20 02:18:50 +00:00
|
|
|
return load_avg / nr_running;
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-05-12 07:19:59 +00:00
|
|
|
static void record_wakee(struct task_struct *p)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Only decay a single time; tasks that have less then 1 wakeup per
|
|
|
|
* jiffy will not have built up many flips.
|
|
|
|
*/
|
|
|
|
if (time_after(jiffies, current->wakee_flip_decay_ts + HZ)) {
|
|
|
|
current->wakee_flips >>= 1;
|
|
|
|
current->wakee_flip_decay_ts = jiffies;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (current->last_wakee != p) {
|
|
|
|
current->last_wakee = p;
|
|
|
|
current->wakee_flips++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-14 15:39:50 +00:00
|
|
|
/*
|
|
|
|
* Detect M:N waker/wakee relationships via a switching-frequency heuristic.
|
2016-05-12 07:19:59 +00:00
|
|
|
*
|
2015-07-14 15:39:50 +00:00
|
|
|
* A waker of many should wake a different task than the one last awakened
|
2016-05-12 07:19:59 +00:00
|
|
|
* at a frequency roughly N times higher than one of its wakees.
|
|
|
|
*
|
|
|
|
* In order to determine whether we should let the load spread vs consolidating
|
|
|
|
* to shared cache, we look for a minimum 'flip' frequency of llc_size in one
|
|
|
|
* partner, and a factor of lls_size higher frequency in the other.
|
|
|
|
*
|
|
|
|
* With both conditions met, we can be relatively sure that the relationship is
|
|
|
|
* non-monogamous, with partner count exceeding socket size.
|
|
|
|
*
|
|
|
|
* Waker/wakee being client/server, worker/dispatcher, interrupt source or
|
|
|
|
* whatever is irrelevant, spread criteria is apparent partner count exceeds
|
|
|
|
* socket size.
|
2015-07-14 15:39:50 +00:00
|
|
|
*/
|
sched: Implement smarter wake-affine logic
The wake-affine scheduler feature is currently always trying to pull
the wakee close to the waker. In theory this should be beneficial if
the waker's CPU caches hot data for the wakee, and it's also beneficial
in the extreme ping-pong high context switch rate case.
Testing shows it can benefit hackbench up to 15%.
However, the feature is somewhat blind, from which some workloads
such as pgbench suffer. It's also time-consuming algorithmically.
Testing shows it can damage pgbench up to 50% - far more than the
benefit it brings in the best case.
So wake-affine should be smarter and it should realize when to
stop its thankless effort at trying to find a suitable CPU to wake on.
This patch introduces 'wakee_flips', which will be increased each
time the task flips (switches) its wakee target.
So a high 'wakee_flips' value means the task has more than one
wakee, and the bigger the number, the higher the wakeup frequency.
Now when making the decision on whether to pull or not, pay attention to
the wakee with a high 'wakee_flips', pulling such a task may benefit
the wakee. Also imply that the waker will face cruel competition later,
it could be very cruel or very fast depends on the story behind
'wakee_flips', waker therefore suffers.
Furthermore, if waker also has a high 'wakee_flips', that implies that
multiple tasks rely on it, then waker's higher latency will damage all
of them, so pulling wakee seems to be a bad deal.
Thus, when 'waker->wakee_flips / wakee->wakee_flips' becomes
higher and higher, the cost of pulling seems to be worse and worse.
The patch therefore helps the wake-affine feature to stop its pulling
work when:
wakee->wakee_flips > factor &&
waker->wakee_flips > (factor * wakee->wakee_flips)
The 'factor' here is the number of CPUs in the current CPU's NUMA node,
so a bigger node will lead to more pulling since the trial becomes more
severe.
After applying the patch, pgbench shows up to 40% improvements and no regressions.
Tested with 12 cpu x86 server and tip 3.10.0-rc7.
The percentages in the final column highlight the areas with the biggest wins,
all other areas improved as well:
pgbench base smart
| db_size | clients | tps | | tps |
+---------+---------+-------+ +-------+
| 22 MB | 1 | 10598 | | 10796 |
| 22 MB | 2 | 21257 | | 21336 |
| 22 MB | 4 | 41386 | | 41622 |
| 22 MB | 8 | 51253 | | 57932 |
| 22 MB | 12 | 48570 | | 54000 |
| 22 MB | 16 | 46748 | | 55982 | +19.75%
| 22 MB | 24 | 44346 | | 55847 | +25.93%
| 22 MB | 32 | 43460 | | 54614 | +25.66%
| 7484 MB | 1 | 8951 | | 9193 |
| 7484 MB | 2 | 19233 | | 19240 |
| 7484 MB | 4 | 37239 | | 37302 |
| 7484 MB | 8 | 46087 | | 50018 |
| 7484 MB | 12 | 42054 | | 48763 |
| 7484 MB | 16 | 40765 | | 51633 | +26.66%
| 7484 MB | 24 | 37651 | | 52377 | +39.11%
| 7484 MB | 32 | 37056 | | 51108 | +37.92%
| 15 GB | 1 | 8845 | | 9104 |
| 15 GB | 2 | 19094 | | 19162 |
| 15 GB | 4 | 36979 | | 36983 |
| 15 GB | 8 | 46087 | | 49977 |
| 15 GB | 12 | 41901 | | 48591 |
| 15 GB | 16 | 40147 | | 50651 | +26.16%
| 15 GB | 24 | 37250 | | 52365 | +40.58%
| 15 GB | 32 | 36470 | | 50015 | +37.14%
Signed-off-by: Michael Wang <wangyun@linux.vnet.ibm.com>
Cc: Mike Galbraith <efault@gmx.de>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/51D50057.9000809@linux.vnet.ibm.com
[ Improved the changelog. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-04 04:55:51 +00:00
|
|
|
static int wake_wide(struct task_struct *p)
|
|
|
|
{
|
2015-07-14 15:39:50 +00:00
|
|
|
unsigned int master = current->wakee_flips;
|
|
|
|
unsigned int slave = p->wakee_flips;
|
2013-07-04 04:56:46 +00:00
|
|
|
int factor = this_cpu_read(sd_llc_size);
|
sched: Implement smarter wake-affine logic
The wake-affine scheduler feature is currently always trying to pull
the wakee close to the waker. In theory this should be beneficial if
the waker's CPU caches hot data for the wakee, and it's also beneficial
in the extreme ping-pong high context switch rate case.
Testing shows it can benefit hackbench up to 15%.
However, the feature is somewhat blind, from which some workloads
such as pgbench suffer. It's also time-consuming algorithmically.
Testing shows it can damage pgbench up to 50% - far more than the
benefit it brings in the best case.
So wake-affine should be smarter and it should realize when to
stop its thankless effort at trying to find a suitable CPU to wake on.
This patch introduces 'wakee_flips', which will be increased each
time the task flips (switches) its wakee target.
So a high 'wakee_flips' value means the task has more than one
wakee, and the bigger the number, the higher the wakeup frequency.
Now when making the decision on whether to pull or not, pay attention to
the wakee with a high 'wakee_flips', pulling such a task may benefit
the wakee. Also imply that the waker will face cruel competition later,
it could be very cruel or very fast depends on the story behind
'wakee_flips', waker therefore suffers.
Furthermore, if waker also has a high 'wakee_flips', that implies that
multiple tasks rely on it, then waker's higher latency will damage all
of them, so pulling wakee seems to be a bad deal.
Thus, when 'waker->wakee_flips / wakee->wakee_flips' becomes
higher and higher, the cost of pulling seems to be worse and worse.
The patch therefore helps the wake-affine feature to stop its pulling
work when:
wakee->wakee_flips > factor &&
waker->wakee_flips > (factor * wakee->wakee_flips)
The 'factor' here is the number of CPUs in the current CPU's NUMA node,
so a bigger node will lead to more pulling since the trial becomes more
severe.
After applying the patch, pgbench shows up to 40% improvements and no regressions.
Tested with 12 cpu x86 server and tip 3.10.0-rc7.
The percentages in the final column highlight the areas with the biggest wins,
all other areas improved as well:
pgbench base smart
| db_size | clients | tps | | tps |
+---------+---------+-------+ +-------+
| 22 MB | 1 | 10598 | | 10796 |
| 22 MB | 2 | 21257 | | 21336 |
| 22 MB | 4 | 41386 | | 41622 |
| 22 MB | 8 | 51253 | | 57932 |
| 22 MB | 12 | 48570 | | 54000 |
| 22 MB | 16 | 46748 | | 55982 | +19.75%
| 22 MB | 24 | 44346 | | 55847 | +25.93%
| 22 MB | 32 | 43460 | | 54614 | +25.66%
| 7484 MB | 1 | 8951 | | 9193 |
| 7484 MB | 2 | 19233 | | 19240 |
| 7484 MB | 4 | 37239 | | 37302 |
| 7484 MB | 8 | 46087 | | 50018 |
| 7484 MB | 12 | 42054 | | 48763 |
| 7484 MB | 16 | 40765 | | 51633 | +26.66%
| 7484 MB | 24 | 37651 | | 52377 | +39.11%
| 7484 MB | 32 | 37056 | | 51108 | +37.92%
| 15 GB | 1 | 8845 | | 9104 |
| 15 GB | 2 | 19094 | | 19162 |
| 15 GB | 4 | 36979 | | 36983 |
| 15 GB | 8 | 46087 | | 49977 |
| 15 GB | 12 | 41901 | | 48591 |
| 15 GB | 16 | 40147 | | 50651 | +26.16%
| 15 GB | 24 | 37250 | | 52365 | +40.58%
| 15 GB | 32 | 36470 | | 50015 | +37.14%
Signed-off-by: Michael Wang <wangyun@linux.vnet.ibm.com>
Cc: Mike Galbraith <efault@gmx.de>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/51D50057.9000809@linux.vnet.ibm.com
[ Improved the changelog. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-04 04:55:51 +00:00
|
|
|
|
2015-07-14 15:39:50 +00:00
|
|
|
if (master < slave)
|
|
|
|
swap(master, slave);
|
|
|
|
if (slave < factor || master < slave * factor)
|
|
|
|
return 0;
|
|
|
|
return 1;
|
sched: Implement smarter wake-affine logic
The wake-affine scheduler feature is currently always trying to pull
the wakee close to the waker. In theory this should be beneficial if
the waker's CPU caches hot data for the wakee, and it's also beneficial
in the extreme ping-pong high context switch rate case.
Testing shows it can benefit hackbench up to 15%.
However, the feature is somewhat blind, from which some workloads
such as pgbench suffer. It's also time-consuming algorithmically.
Testing shows it can damage pgbench up to 50% - far more than the
benefit it brings in the best case.
So wake-affine should be smarter and it should realize when to
stop its thankless effort at trying to find a suitable CPU to wake on.
This patch introduces 'wakee_flips', which will be increased each
time the task flips (switches) its wakee target.
So a high 'wakee_flips' value means the task has more than one
wakee, and the bigger the number, the higher the wakeup frequency.
Now when making the decision on whether to pull or not, pay attention to
the wakee with a high 'wakee_flips', pulling such a task may benefit
the wakee. Also imply that the waker will face cruel competition later,
it could be very cruel or very fast depends on the story behind
'wakee_flips', waker therefore suffers.
Furthermore, if waker also has a high 'wakee_flips', that implies that
multiple tasks rely on it, then waker's higher latency will damage all
of them, so pulling wakee seems to be a bad deal.
Thus, when 'waker->wakee_flips / wakee->wakee_flips' becomes
higher and higher, the cost of pulling seems to be worse and worse.
The patch therefore helps the wake-affine feature to stop its pulling
work when:
wakee->wakee_flips > factor &&
waker->wakee_flips > (factor * wakee->wakee_flips)
The 'factor' here is the number of CPUs in the current CPU's NUMA node,
so a bigger node will lead to more pulling since the trial becomes more
severe.
After applying the patch, pgbench shows up to 40% improvements and no regressions.
Tested with 12 cpu x86 server and tip 3.10.0-rc7.
The percentages in the final column highlight the areas with the biggest wins,
all other areas improved as well:
pgbench base smart
| db_size | clients | tps | | tps |
+---------+---------+-------+ +-------+
| 22 MB | 1 | 10598 | | 10796 |
| 22 MB | 2 | 21257 | | 21336 |
| 22 MB | 4 | 41386 | | 41622 |
| 22 MB | 8 | 51253 | | 57932 |
| 22 MB | 12 | 48570 | | 54000 |
| 22 MB | 16 | 46748 | | 55982 | +19.75%
| 22 MB | 24 | 44346 | | 55847 | +25.93%
| 22 MB | 32 | 43460 | | 54614 | +25.66%
| 7484 MB | 1 | 8951 | | 9193 |
| 7484 MB | 2 | 19233 | | 19240 |
| 7484 MB | 4 | 37239 | | 37302 |
| 7484 MB | 8 | 46087 | | 50018 |
| 7484 MB | 12 | 42054 | | 48763 |
| 7484 MB | 16 | 40765 | | 51633 | +26.66%
| 7484 MB | 24 | 37651 | | 52377 | +39.11%
| 7484 MB | 32 | 37056 | | 51108 | +37.92%
| 15 GB | 1 | 8845 | | 9104 |
| 15 GB | 2 | 19094 | | 19162 |
| 15 GB | 4 | 36979 | | 36983 |
| 15 GB | 8 | 46087 | | 49977 |
| 15 GB | 12 | 41901 | | 48591 |
| 15 GB | 16 | 40147 | | 50651 | +26.16%
| 15 GB | 24 | 37250 | | 52365 | +40.58%
| 15 GB | 32 | 36470 | | 50015 | +37.14%
Signed-off-by: Michael Wang <wangyun@linux.vnet.ibm.com>
Cc: Mike Galbraith <efault@gmx.de>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/51D50057.9000809@linux.vnet.ibm.com
[ Improved the changelog. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-04 04:55:51 +00:00
|
|
|
}
|
|
|
|
|
2017-07-31 15:50:05 +00:00
|
|
|
/*
|
2017-09-27 09:35:30 +00:00
|
|
|
* The purpose of wake_affine() is to quickly determine on which CPU we can run
|
|
|
|
* soonest. For the purpose of speed we only consider the waking and previous
|
|
|
|
* CPU.
|
2017-07-31 15:50:05 +00:00
|
|
|
*
|
sched/fair: Only immediately migrate tasks due to interrupts if prev and target CPUs share cache
If waking from an idle CPU due to an interrupt then it's possible that
the waker task will be pulled to wake on the current CPU. Unfortunately,
depending on the type of interrupt and IRQ configuration, there may not
be a strong relationship between the CPU an interrupt was delivered on
and the CPU a task was running on. For example, the interrupts could all
be delivered to CPUs on one particular node due to the machine topology
or IRQ affinity configuration. Another example is an interrupt for an IO
completion which can be delivered to any CPU where there is no guarantee
the data is either cache hot or even local.
This patch was motivated by the observation that an IO workload was
being pulled cross-node on a frequent basis when IO completed. From a
wakeup latency perspective, it's still useful to know that an idle CPU is
immediately available for use but lets only consider an automatic migration
if the CPUs share cache to limit damage due to NUMA migrations. Migrations
may still occur if wake_affine_weight determines it's appropriate.
These are the throughput results for dbench running on ext4 comparing
4.15-rc3 and this patch on a 2-socket machine where interrupts due to IO
completions can happen on any CPU.
4.15.0-rc3 4.15.0-rc3
vanilla lessmigrate
Hmean 1 854.64 ( 0.00%) 865.01 ( 1.21%)
Hmean 2 1229.60 ( 0.00%) 1274.44 ( 3.65%)
Hmean 4 1591.81 ( 0.00%) 1628.08 ( 2.28%)
Hmean 8 1845.04 ( 0.00%) 1831.80 ( -0.72%)
Hmean 16 2038.61 ( 0.00%) 2091.44 ( 2.59%)
Hmean 32 2327.19 ( 0.00%) 2430.29 ( 4.43%)
Hmean 64 2570.61 ( 0.00%) 2568.54 ( -0.08%)
Hmean 128 2481.89 ( 0.00%) 2499.28 ( 0.70%)
Stddev 1 14.31 ( 0.00%) 5.35 ( 62.65%)
Stddev 2 21.29 ( 0.00%) 11.09 ( 47.92%)
Stddev 4 7.22 ( 0.00%) 6.80 ( 5.92%)
Stddev 8 26.70 ( 0.00%) 9.41 ( 64.76%)
Stddev 16 22.40 ( 0.00%) 20.01 ( 10.70%)
Stddev 32 45.13 ( 0.00%) 44.74 ( 0.85%)
Stddev 64 93.10 ( 0.00%) 93.18 ( -0.09%)
Stddev 128 184.28 ( 0.00%) 177.85 ( 3.49%)
Note the small increase in throughput for low thread counts but also
note that the standard deviation for each sample during the test run is
lower. The throughput figures for dbench can be misleading so the benchmark
is actually modified to time the latency of the processing of one load
file with many samples taken. The difference in latency is
4.15.0-rc3 4.15.0-rc3
vanilla lessmigrate
Amean 1 21.71 ( 0.00%) 21.47 ( 1.08%)
Amean 2 30.89 ( 0.00%) 29.58 ( 4.26%)
Amean 4 47.54 ( 0.00%) 46.61 ( 1.97%)
Amean 8 82.71 ( 0.00%) 82.81 ( -0.12%)
Amean 16 149.45 ( 0.00%) 145.01 ( 2.97%)
Amean 32 265.49 ( 0.00%) 248.43 ( 6.42%)
Amean 64 463.23 ( 0.00%) 463.55 ( -0.07%)
Amean 128 933.97 ( 0.00%) 935.50 ( -0.16%)
Stddev 1 1.58 ( 0.00%) 1.54 ( 2.26%)
Stddev 2 2.84 ( 0.00%) 2.95 ( -4.15%)
Stddev 4 6.78 ( 0.00%) 6.85 ( -0.99%)
Stddev 8 16.85 ( 0.00%) 16.37 ( 2.85%)
Stddev 16 41.59 ( 0.00%) 41.04 ( 1.32%)
Stddev 32 111.05 ( 0.00%) 105.11 ( 5.35%)
Stddev 64 285.94 ( 0.00%) 288.01 ( -0.72%)
Stddev 128 803.39 ( 0.00%) 809.73 ( -0.79%)
It's a small improvement which is not surprising given that migrations that
migrate to a different node as not that common. However, it is noticeable
in the CPU migration statistics which are reduced by 24%.
There was a query for v1 of this patch about NAS so here are the results
for C-class using MPI for parallelisation on the same machine
nas-mpi
4.15.0-rc3 4.15.0-rc3
vanilla noirq
Time cg.C 24.25 ( 0.00%) 23.17 ( 4.45%)
Time ep.C 8.22 ( 0.00%) 8.29 ( -0.85%)
Time ft.C 22.67 ( 0.00%) 20.34 ( 10.28%)
Time is.C 1.42 ( 0.00%) 1.47 ( -3.52%)
Time lu.C 55.62 ( 0.00%) 54.81 ( 1.46%)
Time mg.C 7.93 ( 0.00%) 7.91 ( 0.25%)
4.15.0-rc3 4.15.0-rc3
vanilla noirq-v1r1
User 3799.96 3748.34
System 672.10 626.15
Elapsed 91.91 79.49
lu.C sees a small gain, ft.C a large gain and ep.C and is.C see small
regressions but in terms of absolute time, the difference is small and
likely within run-to-run variance. System CPU usage is slightly reduced.
schbench from Facebook was also requested. This is a bit of a mixed bag but
it's important to note that this workload should not be heavily impacted
by wakeups from interrupt context.
4.15.0-rc3 4.15.0-rc3
vanilla noirq-v1r1
Lat 50.00th-qrtle-1 41.00 ( 0.00%) 41.00 ( 0.00%)
Lat 75.00th-qrtle-1 42.00 ( 0.00%) 42.00 ( 0.00%)
Lat 90.00th-qrtle-1 43.00 ( 0.00%) 44.00 ( -2.33%)
Lat 95.00th-qrtle-1 44.00 ( 0.00%) 46.00 ( -4.55%)
Lat 99.00th-qrtle-1 57.00 ( 0.00%) 58.00 ( -1.75%)
Lat 99.50th-qrtle-1 59.00 ( 0.00%) 59.00 ( 0.00%)
Lat 99.90th-qrtle-1 67.00 ( 0.00%) 78.00 ( -16.42%)
Lat 50.00th-qrtle-2 40.00 ( 0.00%) 51.00 ( -27.50%)
Lat 75.00th-qrtle-2 45.00 ( 0.00%) 56.00 ( -24.44%)
Lat 90.00th-qrtle-2 53.00 ( 0.00%) 59.00 ( -11.32%)
Lat 95.00th-qrtle-2 57.00 ( 0.00%) 61.00 ( -7.02%)
Lat 99.00th-qrtle-2 67.00 ( 0.00%) 71.00 ( -5.97%)
Lat 99.50th-qrtle-2 69.00 ( 0.00%) 74.00 ( -7.25%)
Lat 99.90th-qrtle-2 83.00 ( 0.00%) 77.00 ( 7.23%)
Lat 50.00th-qrtle-4 51.00 ( 0.00%) 51.00 ( 0.00%)
Lat 75.00th-qrtle-4 57.00 ( 0.00%) 56.00 ( 1.75%)
Lat 90.00th-qrtle-4 60.00 ( 0.00%) 59.00 ( 1.67%)
Lat 95.00th-qrtle-4 62.00 ( 0.00%) 62.00 ( 0.00%)
Lat 99.00th-qrtle-4 73.00 ( 0.00%) 72.00 ( 1.37%)
Lat 99.50th-qrtle-4 76.00 ( 0.00%) 74.00 ( 2.63%)
Lat 99.90th-qrtle-4 85.00 ( 0.00%) 78.00 ( 8.24%)
Lat 50.00th-qrtle-8 54.00 ( 0.00%) 58.00 ( -7.41%)
Lat 75.00th-qrtle-8 59.00 ( 0.00%) 62.00 ( -5.08%)
Lat 90.00th-qrtle-8 65.00 ( 0.00%) 66.00 ( -1.54%)
Lat 95.00th-qrtle-8 67.00 ( 0.00%) 70.00 ( -4.48%)
Lat 99.00th-qrtle-8 78.00 ( 0.00%) 79.00 ( -1.28%)
Lat 99.50th-qrtle-8 81.00 ( 0.00%) 80.00 ( 1.23%)
Lat 99.90th-qrtle-8 116.00 ( 0.00%) 83.00 ( 28.45%)
Lat 50.00th-qrtle-16 65.00 ( 0.00%) 64.00 ( 1.54%)
Lat 75.00th-qrtle-16 77.00 ( 0.00%) 71.00 ( 7.79%)
Lat 90.00th-qrtle-16 83.00 ( 0.00%) 82.00 ( 1.20%)
Lat 95.00th-qrtle-16 87.00 ( 0.00%) 87.00 ( 0.00%)
Lat 99.00th-qrtle-16 95.00 ( 0.00%) 96.00 ( -1.05%)
Lat 99.50th-qrtle-16 99.00 ( 0.00%) 103.00 ( -4.04%)
Lat 99.90th-qrtle-16 104.00 ( 0.00%) 122.00 ( -17.31%)
Lat 50.00th-qrtle-32 71.00 ( 0.00%) 73.00 ( -2.82%)
Lat 75.00th-qrtle-32 91.00 ( 0.00%) 92.00 ( -1.10%)
Lat 90.00th-qrtle-32 108.00 ( 0.00%) 107.00 ( 0.93%)
Lat 95.00th-qrtle-32 118.00 ( 0.00%) 115.00 ( 2.54%)
Lat 99.00th-qrtle-32 134.00 ( 0.00%) 129.00 ( 3.73%)
Lat 99.50th-qrtle-32 138.00 ( 0.00%) 133.00 ( 3.62%)
Lat 99.90th-qrtle-32 149.00 ( 0.00%) 146.00 ( 2.01%)
Lat 50.00th-qrtle-39 83.00 ( 0.00%) 81.00 ( 2.41%)
Lat 75.00th-qrtle-39 105.00 ( 0.00%) 102.00 ( 2.86%)
Lat 90.00th-qrtle-39 120.00 ( 0.00%) 119.00 ( 0.83%)
Lat 95.00th-qrtle-39 129.00 ( 0.00%) 128.00 ( 0.78%)
Lat 99.00th-qrtle-39 153.00 ( 0.00%) 149.00 ( 2.61%)
Lat 99.50th-qrtle-39 166.00 ( 0.00%) 156.00 ( 6.02%)
Lat 99.90th-qrtle-39 12304.00 ( 0.00%) 12848.00 ( -4.42%)
When heavily loaded (e.g. 99.50th-qrtle-39 indicates 39 threads), there
are small gains in many cases. Otherwise it depends on the quartile used
where it can be bad -- e.g. 75.00th-qrtle-2. However, even these results
are probably a co-incidence. For this workload, much depends on what node
the threads get placed on and their relative locality and not wakeups from
interrupt context. A larger component on how it behaves would be automatic
NUMA balancing where a fault incurred to measure locality would be a much
larger contributer to latency than the wakeup path.
This is the results from an almost identical machine that happened to run
the same test. They only differ in terms of storage which is irrelevant
for this test.
4.15.0-rc3 4.15.0-rc3
vanilla noirq-v1r1
Lat 50.00th-qrtle-1 41.00 ( 0.00%) 41.00 ( 0.00%)
Lat 75.00th-qrtle-1 42.00 ( 0.00%) 42.00 ( 0.00%)
Lat 90.00th-qrtle-1 44.00 ( 0.00%) 43.00 ( 2.27%)
Lat 95.00th-qrtle-1 53.00 ( 0.00%) 45.00 ( 15.09%)
Lat 99.00th-qrtle-1 59.00 ( 0.00%) 58.00 ( 1.69%)
Lat 99.50th-qrtle-1 60.00 ( 0.00%) 59.00 ( 1.67%)
Lat 99.90th-qrtle-1 86.00 ( 0.00%) 61.00 ( 29.07%)
Lat 50.00th-qrtle-2 52.00 ( 0.00%) 41.00 ( 21.15%)
Lat 75.00th-qrtle-2 57.00 ( 0.00%) 46.00 ( 19.30%)
Lat 90.00th-qrtle-2 60.00 ( 0.00%) 53.00 ( 11.67%)
Lat 95.00th-qrtle-2 62.00 ( 0.00%) 57.00 ( 8.06%)
Lat 99.00th-qrtle-2 73.00 ( 0.00%) 68.00 ( 6.85%)
Lat 99.50th-qrtle-2 74.00 ( 0.00%) 71.00 ( 4.05%)
Lat 99.90th-qrtle-2 90.00 ( 0.00%) 75.00 ( 16.67%)
Lat 50.00th-qrtle-4 57.00 ( 0.00%) 52.00 ( 8.77%)
Lat 75.00th-qrtle-4 60.00 ( 0.00%) 58.00 ( 3.33%)
Lat 90.00th-qrtle-4 62.00 ( 0.00%) 62.00 ( 0.00%)
Lat 95.00th-qrtle-4 65.00 ( 0.00%) 65.00 ( 0.00%)
Lat 99.00th-qrtle-4 76.00 ( 0.00%) 75.00 ( 1.32%)
Lat 99.50th-qrtle-4 77.00 ( 0.00%) 77.00 ( 0.00%)
Lat 99.90th-qrtle-4 87.00 ( 0.00%) 81.00 ( 6.90%)
Lat 50.00th-qrtle-8 59.00 ( 0.00%) 57.00 ( 3.39%)
Lat 75.00th-qrtle-8 63.00 ( 0.00%) 62.00 ( 1.59%)
Lat 90.00th-qrtle-8 66.00 ( 0.00%) 67.00 ( -1.52%)
Lat 95.00th-qrtle-8 68.00 ( 0.00%) 70.00 ( -2.94%)
Lat 99.00th-qrtle-8 79.00 ( 0.00%) 80.00 ( -1.27%)
Lat 99.50th-qrtle-8 80.00 ( 0.00%) 84.00 ( -5.00%)
Lat 99.90th-qrtle-8 84.00 ( 0.00%) 90.00 ( -7.14%)
Lat 50.00th-qrtle-16 65.00 ( 0.00%) 65.00 ( 0.00%)
Lat 75.00th-qrtle-16 77.00 ( 0.00%) 75.00 ( 2.60%)
Lat 90.00th-qrtle-16 84.00 ( 0.00%) 83.00 ( 1.19%)
Lat 95.00th-qrtle-16 88.00 ( 0.00%) 87.00 ( 1.14%)
Lat 99.00th-qrtle-16 97.00 ( 0.00%) 96.00 ( 1.03%)
Lat 99.50th-qrtle-16 100.00 ( 0.00%) 104.00 ( -4.00%)
Lat 99.90th-qrtle-16 110.00 ( 0.00%) 126.00 ( -14.55%)
Lat 50.00th-qrtle-32 70.00 ( 0.00%) 71.00 ( -1.43%)
Lat 75.00th-qrtle-32 92.00 ( 0.00%) 94.00 ( -2.17%)
Lat 90.00th-qrtle-32 110.00 ( 0.00%) 110.00 ( 0.00%)
Lat 95.00th-qrtle-32 121.00 ( 0.00%) 118.00 ( 2.48%)
Lat 99.00th-qrtle-32 135.00 ( 0.00%) 137.00 ( -1.48%)
Lat 99.50th-qrtle-32 140.00 ( 0.00%) 146.00 ( -4.29%)
Lat 99.90th-qrtle-32 150.00 ( 0.00%) 160.00 ( -6.67%)
Lat 50.00th-qrtle-39 80.00 ( 0.00%) 71.00 ( 11.25%)
Lat 75.00th-qrtle-39 102.00 ( 0.00%) 91.00 ( 10.78%)
Lat 90.00th-qrtle-39 118.00 ( 0.00%) 108.00 ( 8.47%)
Lat 95.00th-qrtle-39 128.00 ( 0.00%) 117.00 ( 8.59%)
Lat 99.00th-qrtle-39 149.00 ( 0.00%) 133.00 ( 10.74%)
Lat 99.50th-qrtle-39 160.00 ( 0.00%) 139.00 ( 13.12%)
Lat 99.90th-qrtle-39 13808.00 ( 0.00%) 4920.00 ( 64.37%)
Despite being nearly identical, it showed a variety of major gains so
I'm not convinced that heavy emphasis should be placed on this particular
workload in terms of evaluating this particular patch. Further evidence of
this is the fact that testing on a UMA machine showed small gains/losses
even though the patch should be a no-op on UMA.
Signed-off-by: Mel Gorman <mgorman@techsingularity.net>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20171219085947.13136-2-mgorman@techsingularity.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-12-19 08:59:47 +00:00
|
|
|
* wake_affine_idle() - only considers 'now', it check if the waking CPU is
|
|
|
|
* cache-affine and is (or will be) idle.
|
2017-10-06 07:23:24 +00:00
|
|
|
*
|
|
|
|
* wake_affine_weight() - considers the weight to reflect the average
|
|
|
|
* scheduling latency of the CPUs. This seems to work
|
|
|
|
* for the overloaded case.
|
2017-07-31 15:50:05 +00:00
|
|
|
*/
|
2018-01-30 10:45:53 +00:00
|
|
|
static int
|
2018-01-30 10:45:52 +00:00
|
|
|
wake_affine_idle(int this_cpu, int prev_cpu, int sync)
|
2017-07-31 15:50:05 +00:00
|
|
|
{
|
sched/fair: Only immediately migrate tasks due to interrupts if prev and target CPUs share cache
If waking from an idle CPU due to an interrupt then it's possible that
the waker task will be pulled to wake on the current CPU. Unfortunately,
depending on the type of interrupt and IRQ configuration, there may not
be a strong relationship between the CPU an interrupt was delivered on
and the CPU a task was running on. For example, the interrupts could all
be delivered to CPUs on one particular node due to the machine topology
or IRQ affinity configuration. Another example is an interrupt for an IO
completion which can be delivered to any CPU where there is no guarantee
the data is either cache hot or even local.
This patch was motivated by the observation that an IO workload was
being pulled cross-node on a frequent basis when IO completed. From a
wakeup latency perspective, it's still useful to know that an idle CPU is
immediately available for use but lets only consider an automatic migration
if the CPUs share cache to limit damage due to NUMA migrations. Migrations
may still occur if wake_affine_weight determines it's appropriate.
These are the throughput results for dbench running on ext4 comparing
4.15-rc3 and this patch on a 2-socket machine where interrupts due to IO
completions can happen on any CPU.
4.15.0-rc3 4.15.0-rc3
vanilla lessmigrate
Hmean 1 854.64 ( 0.00%) 865.01 ( 1.21%)
Hmean 2 1229.60 ( 0.00%) 1274.44 ( 3.65%)
Hmean 4 1591.81 ( 0.00%) 1628.08 ( 2.28%)
Hmean 8 1845.04 ( 0.00%) 1831.80 ( -0.72%)
Hmean 16 2038.61 ( 0.00%) 2091.44 ( 2.59%)
Hmean 32 2327.19 ( 0.00%) 2430.29 ( 4.43%)
Hmean 64 2570.61 ( 0.00%) 2568.54 ( -0.08%)
Hmean 128 2481.89 ( 0.00%) 2499.28 ( 0.70%)
Stddev 1 14.31 ( 0.00%) 5.35 ( 62.65%)
Stddev 2 21.29 ( 0.00%) 11.09 ( 47.92%)
Stddev 4 7.22 ( 0.00%) 6.80 ( 5.92%)
Stddev 8 26.70 ( 0.00%) 9.41 ( 64.76%)
Stddev 16 22.40 ( 0.00%) 20.01 ( 10.70%)
Stddev 32 45.13 ( 0.00%) 44.74 ( 0.85%)
Stddev 64 93.10 ( 0.00%) 93.18 ( -0.09%)
Stddev 128 184.28 ( 0.00%) 177.85 ( 3.49%)
Note the small increase in throughput for low thread counts but also
note that the standard deviation for each sample during the test run is
lower. The throughput figures for dbench can be misleading so the benchmark
is actually modified to time the latency of the processing of one load
file with many samples taken. The difference in latency is
4.15.0-rc3 4.15.0-rc3
vanilla lessmigrate
Amean 1 21.71 ( 0.00%) 21.47 ( 1.08%)
Amean 2 30.89 ( 0.00%) 29.58 ( 4.26%)
Amean 4 47.54 ( 0.00%) 46.61 ( 1.97%)
Amean 8 82.71 ( 0.00%) 82.81 ( -0.12%)
Amean 16 149.45 ( 0.00%) 145.01 ( 2.97%)
Amean 32 265.49 ( 0.00%) 248.43 ( 6.42%)
Amean 64 463.23 ( 0.00%) 463.55 ( -0.07%)
Amean 128 933.97 ( 0.00%) 935.50 ( -0.16%)
Stddev 1 1.58 ( 0.00%) 1.54 ( 2.26%)
Stddev 2 2.84 ( 0.00%) 2.95 ( -4.15%)
Stddev 4 6.78 ( 0.00%) 6.85 ( -0.99%)
Stddev 8 16.85 ( 0.00%) 16.37 ( 2.85%)
Stddev 16 41.59 ( 0.00%) 41.04 ( 1.32%)
Stddev 32 111.05 ( 0.00%) 105.11 ( 5.35%)
Stddev 64 285.94 ( 0.00%) 288.01 ( -0.72%)
Stddev 128 803.39 ( 0.00%) 809.73 ( -0.79%)
It's a small improvement which is not surprising given that migrations that
migrate to a different node as not that common. However, it is noticeable
in the CPU migration statistics which are reduced by 24%.
There was a query for v1 of this patch about NAS so here are the results
for C-class using MPI for parallelisation on the same machine
nas-mpi
4.15.0-rc3 4.15.0-rc3
vanilla noirq
Time cg.C 24.25 ( 0.00%) 23.17 ( 4.45%)
Time ep.C 8.22 ( 0.00%) 8.29 ( -0.85%)
Time ft.C 22.67 ( 0.00%) 20.34 ( 10.28%)
Time is.C 1.42 ( 0.00%) 1.47 ( -3.52%)
Time lu.C 55.62 ( 0.00%) 54.81 ( 1.46%)
Time mg.C 7.93 ( 0.00%) 7.91 ( 0.25%)
4.15.0-rc3 4.15.0-rc3
vanilla noirq-v1r1
User 3799.96 3748.34
System 672.10 626.15
Elapsed 91.91 79.49
lu.C sees a small gain, ft.C a large gain and ep.C and is.C see small
regressions but in terms of absolute time, the difference is small and
likely within run-to-run variance. System CPU usage is slightly reduced.
schbench from Facebook was also requested. This is a bit of a mixed bag but
it's important to note that this workload should not be heavily impacted
by wakeups from interrupt context.
4.15.0-rc3 4.15.0-rc3
vanilla noirq-v1r1
Lat 50.00th-qrtle-1 41.00 ( 0.00%) 41.00 ( 0.00%)
Lat 75.00th-qrtle-1 42.00 ( 0.00%) 42.00 ( 0.00%)
Lat 90.00th-qrtle-1 43.00 ( 0.00%) 44.00 ( -2.33%)
Lat 95.00th-qrtle-1 44.00 ( 0.00%) 46.00 ( -4.55%)
Lat 99.00th-qrtle-1 57.00 ( 0.00%) 58.00 ( -1.75%)
Lat 99.50th-qrtle-1 59.00 ( 0.00%) 59.00 ( 0.00%)
Lat 99.90th-qrtle-1 67.00 ( 0.00%) 78.00 ( -16.42%)
Lat 50.00th-qrtle-2 40.00 ( 0.00%) 51.00 ( -27.50%)
Lat 75.00th-qrtle-2 45.00 ( 0.00%) 56.00 ( -24.44%)
Lat 90.00th-qrtle-2 53.00 ( 0.00%) 59.00 ( -11.32%)
Lat 95.00th-qrtle-2 57.00 ( 0.00%) 61.00 ( -7.02%)
Lat 99.00th-qrtle-2 67.00 ( 0.00%) 71.00 ( -5.97%)
Lat 99.50th-qrtle-2 69.00 ( 0.00%) 74.00 ( -7.25%)
Lat 99.90th-qrtle-2 83.00 ( 0.00%) 77.00 ( 7.23%)
Lat 50.00th-qrtle-4 51.00 ( 0.00%) 51.00 ( 0.00%)
Lat 75.00th-qrtle-4 57.00 ( 0.00%) 56.00 ( 1.75%)
Lat 90.00th-qrtle-4 60.00 ( 0.00%) 59.00 ( 1.67%)
Lat 95.00th-qrtle-4 62.00 ( 0.00%) 62.00 ( 0.00%)
Lat 99.00th-qrtle-4 73.00 ( 0.00%) 72.00 ( 1.37%)
Lat 99.50th-qrtle-4 76.00 ( 0.00%) 74.00 ( 2.63%)
Lat 99.90th-qrtle-4 85.00 ( 0.00%) 78.00 ( 8.24%)
Lat 50.00th-qrtle-8 54.00 ( 0.00%) 58.00 ( -7.41%)
Lat 75.00th-qrtle-8 59.00 ( 0.00%) 62.00 ( -5.08%)
Lat 90.00th-qrtle-8 65.00 ( 0.00%) 66.00 ( -1.54%)
Lat 95.00th-qrtle-8 67.00 ( 0.00%) 70.00 ( -4.48%)
Lat 99.00th-qrtle-8 78.00 ( 0.00%) 79.00 ( -1.28%)
Lat 99.50th-qrtle-8 81.00 ( 0.00%) 80.00 ( 1.23%)
Lat 99.90th-qrtle-8 116.00 ( 0.00%) 83.00 ( 28.45%)
Lat 50.00th-qrtle-16 65.00 ( 0.00%) 64.00 ( 1.54%)
Lat 75.00th-qrtle-16 77.00 ( 0.00%) 71.00 ( 7.79%)
Lat 90.00th-qrtle-16 83.00 ( 0.00%) 82.00 ( 1.20%)
Lat 95.00th-qrtle-16 87.00 ( 0.00%) 87.00 ( 0.00%)
Lat 99.00th-qrtle-16 95.00 ( 0.00%) 96.00 ( -1.05%)
Lat 99.50th-qrtle-16 99.00 ( 0.00%) 103.00 ( -4.04%)
Lat 99.90th-qrtle-16 104.00 ( 0.00%) 122.00 ( -17.31%)
Lat 50.00th-qrtle-32 71.00 ( 0.00%) 73.00 ( -2.82%)
Lat 75.00th-qrtle-32 91.00 ( 0.00%) 92.00 ( -1.10%)
Lat 90.00th-qrtle-32 108.00 ( 0.00%) 107.00 ( 0.93%)
Lat 95.00th-qrtle-32 118.00 ( 0.00%) 115.00 ( 2.54%)
Lat 99.00th-qrtle-32 134.00 ( 0.00%) 129.00 ( 3.73%)
Lat 99.50th-qrtle-32 138.00 ( 0.00%) 133.00 ( 3.62%)
Lat 99.90th-qrtle-32 149.00 ( 0.00%) 146.00 ( 2.01%)
Lat 50.00th-qrtle-39 83.00 ( 0.00%) 81.00 ( 2.41%)
Lat 75.00th-qrtle-39 105.00 ( 0.00%) 102.00 ( 2.86%)
Lat 90.00th-qrtle-39 120.00 ( 0.00%) 119.00 ( 0.83%)
Lat 95.00th-qrtle-39 129.00 ( 0.00%) 128.00 ( 0.78%)
Lat 99.00th-qrtle-39 153.00 ( 0.00%) 149.00 ( 2.61%)
Lat 99.50th-qrtle-39 166.00 ( 0.00%) 156.00 ( 6.02%)
Lat 99.90th-qrtle-39 12304.00 ( 0.00%) 12848.00 ( -4.42%)
When heavily loaded (e.g. 99.50th-qrtle-39 indicates 39 threads), there
are small gains in many cases. Otherwise it depends on the quartile used
where it can be bad -- e.g. 75.00th-qrtle-2. However, even these results
are probably a co-incidence. For this workload, much depends on what node
the threads get placed on and their relative locality and not wakeups from
interrupt context. A larger component on how it behaves would be automatic
NUMA balancing where a fault incurred to measure locality would be a much
larger contributer to latency than the wakeup path.
This is the results from an almost identical machine that happened to run
the same test. They only differ in terms of storage which is irrelevant
for this test.
4.15.0-rc3 4.15.0-rc3
vanilla noirq-v1r1
Lat 50.00th-qrtle-1 41.00 ( 0.00%) 41.00 ( 0.00%)
Lat 75.00th-qrtle-1 42.00 ( 0.00%) 42.00 ( 0.00%)
Lat 90.00th-qrtle-1 44.00 ( 0.00%) 43.00 ( 2.27%)
Lat 95.00th-qrtle-1 53.00 ( 0.00%) 45.00 ( 15.09%)
Lat 99.00th-qrtle-1 59.00 ( 0.00%) 58.00 ( 1.69%)
Lat 99.50th-qrtle-1 60.00 ( 0.00%) 59.00 ( 1.67%)
Lat 99.90th-qrtle-1 86.00 ( 0.00%) 61.00 ( 29.07%)
Lat 50.00th-qrtle-2 52.00 ( 0.00%) 41.00 ( 21.15%)
Lat 75.00th-qrtle-2 57.00 ( 0.00%) 46.00 ( 19.30%)
Lat 90.00th-qrtle-2 60.00 ( 0.00%) 53.00 ( 11.67%)
Lat 95.00th-qrtle-2 62.00 ( 0.00%) 57.00 ( 8.06%)
Lat 99.00th-qrtle-2 73.00 ( 0.00%) 68.00 ( 6.85%)
Lat 99.50th-qrtle-2 74.00 ( 0.00%) 71.00 ( 4.05%)
Lat 99.90th-qrtle-2 90.00 ( 0.00%) 75.00 ( 16.67%)
Lat 50.00th-qrtle-4 57.00 ( 0.00%) 52.00 ( 8.77%)
Lat 75.00th-qrtle-4 60.00 ( 0.00%) 58.00 ( 3.33%)
Lat 90.00th-qrtle-4 62.00 ( 0.00%) 62.00 ( 0.00%)
Lat 95.00th-qrtle-4 65.00 ( 0.00%) 65.00 ( 0.00%)
Lat 99.00th-qrtle-4 76.00 ( 0.00%) 75.00 ( 1.32%)
Lat 99.50th-qrtle-4 77.00 ( 0.00%) 77.00 ( 0.00%)
Lat 99.90th-qrtle-4 87.00 ( 0.00%) 81.00 ( 6.90%)
Lat 50.00th-qrtle-8 59.00 ( 0.00%) 57.00 ( 3.39%)
Lat 75.00th-qrtle-8 63.00 ( 0.00%) 62.00 ( 1.59%)
Lat 90.00th-qrtle-8 66.00 ( 0.00%) 67.00 ( -1.52%)
Lat 95.00th-qrtle-8 68.00 ( 0.00%) 70.00 ( -2.94%)
Lat 99.00th-qrtle-8 79.00 ( 0.00%) 80.00 ( -1.27%)
Lat 99.50th-qrtle-8 80.00 ( 0.00%) 84.00 ( -5.00%)
Lat 99.90th-qrtle-8 84.00 ( 0.00%) 90.00 ( -7.14%)
Lat 50.00th-qrtle-16 65.00 ( 0.00%) 65.00 ( 0.00%)
Lat 75.00th-qrtle-16 77.00 ( 0.00%) 75.00 ( 2.60%)
Lat 90.00th-qrtle-16 84.00 ( 0.00%) 83.00 ( 1.19%)
Lat 95.00th-qrtle-16 88.00 ( 0.00%) 87.00 ( 1.14%)
Lat 99.00th-qrtle-16 97.00 ( 0.00%) 96.00 ( 1.03%)
Lat 99.50th-qrtle-16 100.00 ( 0.00%) 104.00 ( -4.00%)
Lat 99.90th-qrtle-16 110.00 ( 0.00%) 126.00 ( -14.55%)
Lat 50.00th-qrtle-32 70.00 ( 0.00%) 71.00 ( -1.43%)
Lat 75.00th-qrtle-32 92.00 ( 0.00%) 94.00 ( -2.17%)
Lat 90.00th-qrtle-32 110.00 ( 0.00%) 110.00 ( 0.00%)
Lat 95.00th-qrtle-32 121.00 ( 0.00%) 118.00 ( 2.48%)
Lat 99.00th-qrtle-32 135.00 ( 0.00%) 137.00 ( -1.48%)
Lat 99.50th-qrtle-32 140.00 ( 0.00%) 146.00 ( -4.29%)
Lat 99.90th-qrtle-32 150.00 ( 0.00%) 160.00 ( -6.67%)
Lat 50.00th-qrtle-39 80.00 ( 0.00%) 71.00 ( 11.25%)
Lat 75.00th-qrtle-39 102.00 ( 0.00%) 91.00 ( 10.78%)
Lat 90.00th-qrtle-39 118.00 ( 0.00%) 108.00 ( 8.47%)
Lat 95.00th-qrtle-39 128.00 ( 0.00%) 117.00 ( 8.59%)
Lat 99.00th-qrtle-39 149.00 ( 0.00%) 133.00 ( 10.74%)
Lat 99.50th-qrtle-39 160.00 ( 0.00%) 139.00 ( 13.12%)
Lat 99.90th-qrtle-39 13808.00 ( 0.00%) 4920.00 ( 64.37%)
Despite being nearly identical, it showed a variety of major gains so
I'm not convinced that heavy emphasis should be placed on this particular
workload in terms of evaluating this particular patch. Further evidence of
this is the fact that testing on a UMA machine showed small gains/losses
even though the patch should be a no-op on UMA.
Signed-off-by: Mel Gorman <mgorman@techsingularity.net>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20171219085947.13136-2-mgorman@techsingularity.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-12-19 08:59:47 +00:00
|
|
|
/*
|
|
|
|
* If this_cpu is idle, it implies the wakeup is from interrupt
|
|
|
|
* context. Only allow the move if cache is shared. Otherwise an
|
|
|
|
* interrupt intensive workload could force all tasks onto one
|
|
|
|
* node depending on the IO topology or IRQ affinity settings.
|
2018-01-30 10:45:54 +00:00
|
|
|
*
|
|
|
|
* If the prev_cpu is idle and cache affine then avoid a migration.
|
|
|
|
* There is no guarantee that the cache hot data from an interrupt
|
|
|
|
* is more important than cache hot data on the prev_cpu and from
|
|
|
|
* a cpufreq perspective, it's better to have higher utilisation
|
|
|
|
* on one CPU.
|
sched/fair: Only immediately migrate tasks due to interrupts if prev and target CPUs share cache
If waking from an idle CPU due to an interrupt then it's possible that
the waker task will be pulled to wake on the current CPU. Unfortunately,
depending on the type of interrupt and IRQ configuration, there may not
be a strong relationship between the CPU an interrupt was delivered on
and the CPU a task was running on. For example, the interrupts could all
be delivered to CPUs on one particular node due to the machine topology
or IRQ affinity configuration. Another example is an interrupt for an IO
completion which can be delivered to any CPU where there is no guarantee
the data is either cache hot or even local.
This patch was motivated by the observation that an IO workload was
being pulled cross-node on a frequent basis when IO completed. From a
wakeup latency perspective, it's still useful to know that an idle CPU is
immediately available for use but lets only consider an automatic migration
if the CPUs share cache to limit damage due to NUMA migrations. Migrations
may still occur if wake_affine_weight determines it's appropriate.
These are the throughput results for dbench running on ext4 comparing
4.15-rc3 and this patch on a 2-socket machine where interrupts due to IO
completions can happen on any CPU.
4.15.0-rc3 4.15.0-rc3
vanilla lessmigrate
Hmean 1 854.64 ( 0.00%) 865.01 ( 1.21%)
Hmean 2 1229.60 ( 0.00%) 1274.44 ( 3.65%)
Hmean 4 1591.81 ( 0.00%) 1628.08 ( 2.28%)
Hmean 8 1845.04 ( 0.00%) 1831.80 ( -0.72%)
Hmean 16 2038.61 ( 0.00%) 2091.44 ( 2.59%)
Hmean 32 2327.19 ( 0.00%) 2430.29 ( 4.43%)
Hmean 64 2570.61 ( 0.00%) 2568.54 ( -0.08%)
Hmean 128 2481.89 ( 0.00%) 2499.28 ( 0.70%)
Stddev 1 14.31 ( 0.00%) 5.35 ( 62.65%)
Stddev 2 21.29 ( 0.00%) 11.09 ( 47.92%)
Stddev 4 7.22 ( 0.00%) 6.80 ( 5.92%)
Stddev 8 26.70 ( 0.00%) 9.41 ( 64.76%)
Stddev 16 22.40 ( 0.00%) 20.01 ( 10.70%)
Stddev 32 45.13 ( 0.00%) 44.74 ( 0.85%)
Stddev 64 93.10 ( 0.00%) 93.18 ( -0.09%)
Stddev 128 184.28 ( 0.00%) 177.85 ( 3.49%)
Note the small increase in throughput for low thread counts but also
note that the standard deviation for each sample during the test run is
lower. The throughput figures for dbench can be misleading so the benchmark
is actually modified to time the latency of the processing of one load
file with many samples taken. The difference in latency is
4.15.0-rc3 4.15.0-rc3
vanilla lessmigrate
Amean 1 21.71 ( 0.00%) 21.47 ( 1.08%)
Amean 2 30.89 ( 0.00%) 29.58 ( 4.26%)
Amean 4 47.54 ( 0.00%) 46.61 ( 1.97%)
Amean 8 82.71 ( 0.00%) 82.81 ( -0.12%)
Amean 16 149.45 ( 0.00%) 145.01 ( 2.97%)
Amean 32 265.49 ( 0.00%) 248.43 ( 6.42%)
Amean 64 463.23 ( 0.00%) 463.55 ( -0.07%)
Amean 128 933.97 ( 0.00%) 935.50 ( -0.16%)
Stddev 1 1.58 ( 0.00%) 1.54 ( 2.26%)
Stddev 2 2.84 ( 0.00%) 2.95 ( -4.15%)
Stddev 4 6.78 ( 0.00%) 6.85 ( -0.99%)
Stddev 8 16.85 ( 0.00%) 16.37 ( 2.85%)
Stddev 16 41.59 ( 0.00%) 41.04 ( 1.32%)
Stddev 32 111.05 ( 0.00%) 105.11 ( 5.35%)
Stddev 64 285.94 ( 0.00%) 288.01 ( -0.72%)
Stddev 128 803.39 ( 0.00%) 809.73 ( -0.79%)
It's a small improvement which is not surprising given that migrations that
migrate to a different node as not that common. However, it is noticeable
in the CPU migration statistics which are reduced by 24%.
There was a query for v1 of this patch about NAS so here are the results
for C-class using MPI for parallelisation on the same machine
nas-mpi
4.15.0-rc3 4.15.0-rc3
vanilla noirq
Time cg.C 24.25 ( 0.00%) 23.17 ( 4.45%)
Time ep.C 8.22 ( 0.00%) 8.29 ( -0.85%)
Time ft.C 22.67 ( 0.00%) 20.34 ( 10.28%)
Time is.C 1.42 ( 0.00%) 1.47 ( -3.52%)
Time lu.C 55.62 ( 0.00%) 54.81 ( 1.46%)
Time mg.C 7.93 ( 0.00%) 7.91 ( 0.25%)
4.15.0-rc3 4.15.0-rc3
vanilla noirq-v1r1
User 3799.96 3748.34
System 672.10 626.15
Elapsed 91.91 79.49
lu.C sees a small gain, ft.C a large gain and ep.C and is.C see small
regressions but in terms of absolute time, the difference is small and
likely within run-to-run variance. System CPU usage is slightly reduced.
schbench from Facebook was also requested. This is a bit of a mixed bag but
it's important to note that this workload should not be heavily impacted
by wakeups from interrupt context.
4.15.0-rc3 4.15.0-rc3
vanilla noirq-v1r1
Lat 50.00th-qrtle-1 41.00 ( 0.00%) 41.00 ( 0.00%)
Lat 75.00th-qrtle-1 42.00 ( 0.00%) 42.00 ( 0.00%)
Lat 90.00th-qrtle-1 43.00 ( 0.00%) 44.00 ( -2.33%)
Lat 95.00th-qrtle-1 44.00 ( 0.00%) 46.00 ( -4.55%)
Lat 99.00th-qrtle-1 57.00 ( 0.00%) 58.00 ( -1.75%)
Lat 99.50th-qrtle-1 59.00 ( 0.00%) 59.00 ( 0.00%)
Lat 99.90th-qrtle-1 67.00 ( 0.00%) 78.00 ( -16.42%)
Lat 50.00th-qrtle-2 40.00 ( 0.00%) 51.00 ( -27.50%)
Lat 75.00th-qrtle-2 45.00 ( 0.00%) 56.00 ( -24.44%)
Lat 90.00th-qrtle-2 53.00 ( 0.00%) 59.00 ( -11.32%)
Lat 95.00th-qrtle-2 57.00 ( 0.00%) 61.00 ( -7.02%)
Lat 99.00th-qrtle-2 67.00 ( 0.00%) 71.00 ( -5.97%)
Lat 99.50th-qrtle-2 69.00 ( 0.00%) 74.00 ( -7.25%)
Lat 99.90th-qrtle-2 83.00 ( 0.00%) 77.00 ( 7.23%)
Lat 50.00th-qrtle-4 51.00 ( 0.00%) 51.00 ( 0.00%)
Lat 75.00th-qrtle-4 57.00 ( 0.00%) 56.00 ( 1.75%)
Lat 90.00th-qrtle-4 60.00 ( 0.00%) 59.00 ( 1.67%)
Lat 95.00th-qrtle-4 62.00 ( 0.00%) 62.00 ( 0.00%)
Lat 99.00th-qrtle-4 73.00 ( 0.00%) 72.00 ( 1.37%)
Lat 99.50th-qrtle-4 76.00 ( 0.00%) 74.00 ( 2.63%)
Lat 99.90th-qrtle-4 85.00 ( 0.00%) 78.00 ( 8.24%)
Lat 50.00th-qrtle-8 54.00 ( 0.00%) 58.00 ( -7.41%)
Lat 75.00th-qrtle-8 59.00 ( 0.00%) 62.00 ( -5.08%)
Lat 90.00th-qrtle-8 65.00 ( 0.00%) 66.00 ( -1.54%)
Lat 95.00th-qrtle-8 67.00 ( 0.00%) 70.00 ( -4.48%)
Lat 99.00th-qrtle-8 78.00 ( 0.00%) 79.00 ( -1.28%)
Lat 99.50th-qrtle-8 81.00 ( 0.00%) 80.00 ( 1.23%)
Lat 99.90th-qrtle-8 116.00 ( 0.00%) 83.00 ( 28.45%)
Lat 50.00th-qrtle-16 65.00 ( 0.00%) 64.00 ( 1.54%)
Lat 75.00th-qrtle-16 77.00 ( 0.00%) 71.00 ( 7.79%)
Lat 90.00th-qrtle-16 83.00 ( 0.00%) 82.00 ( 1.20%)
Lat 95.00th-qrtle-16 87.00 ( 0.00%) 87.00 ( 0.00%)
Lat 99.00th-qrtle-16 95.00 ( 0.00%) 96.00 ( -1.05%)
Lat 99.50th-qrtle-16 99.00 ( 0.00%) 103.00 ( -4.04%)
Lat 99.90th-qrtle-16 104.00 ( 0.00%) 122.00 ( -17.31%)
Lat 50.00th-qrtle-32 71.00 ( 0.00%) 73.00 ( -2.82%)
Lat 75.00th-qrtle-32 91.00 ( 0.00%) 92.00 ( -1.10%)
Lat 90.00th-qrtle-32 108.00 ( 0.00%) 107.00 ( 0.93%)
Lat 95.00th-qrtle-32 118.00 ( 0.00%) 115.00 ( 2.54%)
Lat 99.00th-qrtle-32 134.00 ( 0.00%) 129.00 ( 3.73%)
Lat 99.50th-qrtle-32 138.00 ( 0.00%) 133.00 ( 3.62%)
Lat 99.90th-qrtle-32 149.00 ( 0.00%) 146.00 ( 2.01%)
Lat 50.00th-qrtle-39 83.00 ( 0.00%) 81.00 ( 2.41%)
Lat 75.00th-qrtle-39 105.00 ( 0.00%) 102.00 ( 2.86%)
Lat 90.00th-qrtle-39 120.00 ( 0.00%) 119.00 ( 0.83%)
Lat 95.00th-qrtle-39 129.00 ( 0.00%) 128.00 ( 0.78%)
Lat 99.00th-qrtle-39 153.00 ( 0.00%) 149.00 ( 2.61%)
Lat 99.50th-qrtle-39 166.00 ( 0.00%) 156.00 ( 6.02%)
Lat 99.90th-qrtle-39 12304.00 ( 0.00%) 12848.00 ( -4.42%)
When heavily loaded (e.g. 99.50th-qrtle-39 indicates 39 threads), there
are small gains in many cases. Otherwise it depends on the quartile used
where it can be bad -- e.g. 75.00th-qrtle-2. However, even these results
are probably a co-incidence. For this workload, much depends on what node
the threads get placed on and their relative locality and not wakeups from
interrupt context. A larger component on how it behaves would be automatic
NUMA balancing where a fault incurred to measure locality would be a much
larger contributer to latency than the wakeup path.
This is the results from an almost identical machine that happened to run
the same test. They only differ in terms of storage which is irrelevant
for this test.
4.15.0-rc3 4.15.0-rc3
vanilla noirq-v1r1
Lat 50.00th-qrtle-1 41.00 ( 0.00%) 41.00 ( 0.00%)
Lat 75.00th-qrtle-1 42.00 ( 0.00%) 42.00 ( 0.00%)
Lat 90.00th-qrtle-1 44.00 ( 0.00%) 43.00 ( 2.27%)
Lat 95.00th-qrtle-1 53.00 ( 0.00%) 45.00 ( 15.09%)
Lat 99.00th-qrtle-1 59.00 ( 0.00%) 58.00 ( 1.69%)
Lat 99.50th-qrtle-1 60.00 ( 0.00%) 59.00 ( 1.67%)
Lat 99.90th-qrtle-1 86.00 ( 0.00%) 61.00 ( 29.07%)
Lat 50.00th-qrtle-2 52.00 ( 0.00%) 41.00 ( 21.15%)
Lat 75.00th-qrtle-2 57.00 ( 0.00%) 46.00 ( 19.30%)
Lat 90.00th-qrtle-2 60.00 ( 0.00%) 53.00 ( 11.67%)
Lat 95.00th-qrtle-2 62.00 ( 0.00%) 57.00 ( 8.06%)
Lat 99.00th-qrtle-2 73.00 ( 0.00%) 68.00 ( 6.85%)
Lat 99.50th-qrtle-2 74.00 ( 0.00%) 71.00 ( 4.05%)
Lat 99.90th-qrtle-2 90.00 ( 0.00%) 75.00 ( 16.67%)
Lat 50.00th-qrtle-4 57.00 ( 0.00%) 52.00 ( 8.77%)
Lat 75.00th-qrtle-4 60.00 ( 0.00%) 58.00 ( 3.33%)
Lat 90.00th-qrtle-4 62.00 ( 0.00%) 62.00 ( 0.00%)
Lat 95.00th-qrtle-4 65.00 ( 0.00%) 65.00 ( 0.00%)
Lat 99.00th-qrtle-4 76.00 ( 0.00%) 75.00 ( 1.32%)
Lat 99.50th-qrtle-4 77.00 ( 0.00%) 77.00 ( 0.00%)
Lat 99.90th-qrtle-4 87.00 ( 0.00%) 81.00 ( 6.90%)
Lat 50.00th-qrtle-8 59.00 ( 0.00%) 57.00 ( 3.39%)
Lat 75.00th-qrtle-8 63.00 ( 0.00%) 62.00 ( 1.59%)
Lat 90.00th-qrtle-8 66.00 ( 0.00%) 67.00 ( -1.52%)
Lat 95.00th-qrtle-8 68.00 ( 0.00%) 70.00 ( -2.94%)
Lat 99.00th-qrtle-8 79.00 ( 0.00%) 80.00 ( -1.27%)
Lat 99.50th-qrtle-8 80.00 ( 0.00%) 84.00 ( -5.00%)
Lat 99.90th-qrtle-8 84.00 ( 0.00%) 90.00 ( -7.14%)
Lat 50.00th-qrtle-16 65.00 ( 0.00%) 65.00 ( 0.00%)
Lat 75.00th-qrtle-16 77.00 ( 0.00%) 75.00 ( 2.60%)
Lat 90.00th-qrtle-16 84.00 ( 0.00%) 83.00 ( 1.19%)
Lat 95.00th-qrtle-16 88.00 ( 0.00%) 87.00 ( 1.14%)
Lat 99.00th-qrtle-16 97.00 ( 0.00%) 96.00 ( 1.03%)
Lat 99.50th-qrtle-16 100.00 ( 0.00%) 104.00 ( -4.00%)
Lat 99.90th-qrtle-16 110.00 ( 0.00%) 126.00 ( -14.55%)
Lat 50.00th-qrtle-32 70.00 ( 0.00%) 71.00 ( -1.43%)
Lat 75.00th-qrtle-32 92.00 ( 0.00%) 94.00 ( -2.17%)
Lat 90.00th-qrtle-32 110.00 ( 0.00%) 110.00 ( 0.00%)
Lat 95.00th-qrtle-32 121.00 ( 0.00%) 118.00 ( 2.48%)
Lat 99.00th-qrtle-32 135.00 ( 0.00%) 137.00 ( -1.48%)
Lat 99.50th-qrtle-32 140.00 ( 0.00%) 146.00 ( -4.29%)
Lat 99.90th-qrtle-32 150.00 ( 0.00%) 160.00 ( -6.67%)
Lat 50.00th-qrtle-39 80.00 ( 0.00%) 71.00 ( 11.25%)
Lat 75.00th-qrtle-39 102.00 ( 0.00%) 91.00 ( 10.78%)
Lat 90.00th-qrtle-39 118.00 ( 0.00%) 108.00 ( 8.47%)
Lat 95.00th-qrtle-39 128.00 ( 0.00%) 117.00 ( 8.59%)
Lat 99.00th-qrtle-39 149.00 ( 0.00%) 133.00 ( 10.74%)
Lat 99.50th-qrtle-39 160.00 ( 0.00%) 139.00 ( 13.12%)
Lat 99.90th-qrtle-39 13808.00 ( 0.00%) 4920.00 ( 64.37%)
Despite being nearly identical, it showed a variety of major gains so
I'm not convinced that heavy emphasis should be placed on this particular
workload in terms of evaluating this particular patch. Further evidence of
this is the fact that testing on a UMA machine showed small gains/losses
even though the patch should be a no-op on UMA.
Signed-off-by: Mel Gorman <mgorman@techsingularity.net>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20171219085947.13136-2-mgorman@techsingularity.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-12-19 08:59:47 +00:00
|
|
|
*/
|
|
|
|
if (idle_cpu(this_cpu) && cpus_share_cache(this_cpu, prev_cpu))
|
2018-01-30 10:45:54 +00:00
|
|
|
return idle_cpu(prev_cpu) ? prev_cpu : this_cpu;
|
2017-07-31 15:50:05 +00:00
|
|
|
|
2017-09-27 09:35:30 +00:00
|
|
|
if (sync && cpu_rq(this_cpu)->nr_running == 1)
|
2018-01-30 10:45:53 +00:00
|
|
|
return this_cpu;
|
2017-07-31 15:50:05 +00:00
|
|
|
|
2018-01-30 10:45:53 +00:00
|
|
|
return nr_cpumask_bits;
|
2017-07-31 15:50:05 +00:00
|
|
|
}
|
|
|
|
|
2018-01-30 10:45:53 +00:00
|
|
|
static int
|
2017-10-06 07:23:24 +00:00
|
|
|
wake_affine_weight(struct sched_domain *sd, struct task_struct *p,
|
|
|
|
int this_cpu, int prev_cpu, int sync)
|
2017-07-31 15:50:05 +00:00
|
|
|
{
|
|
|
|
s64 this_eff_load, prev_eff_load;
|
|
|
|
unsigned long task_load;
|
|
|
|
|
2017-10-06 07:23:24 +00:00
|
|
|
this_eff_load = target_load(this_cpu, sd->wake_idx);
|
|
|
|
prev_eff_load = source_load(prev_cpu, sd->wake_idx);
|
2017-07-31 15:50:05 +00:00
|
|
|
|
|
|
|
if (sync) {
|
|
|
|
unsigned long current_load = task_h_load(current);
|
|
|
|
|
2017-10-06 07:23:24 +00:00
|
|
|
if (current_load > this_eff_load)
|
2018-01-30 10:45:53 +00:00
|
|
|
return this_cpu;
|
2017-07-31 15:50:05 +00:00
|
|
|
|
2017-10-06 07:23:24 +00:00
|
|
|
this_eff_load -= current_load;
|
2017-07-31 15:50:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
task_load = task_h_load(p);
|
|
|
|
|
2017-10-06 07:23:24 +00:00
|
|
|
this_eff_load += task_load;
|
|
|
|
if (sched_feat(WA_BIAS))
|
|
|
|
this_eff_load *= 100;
|
|
|
|
this_eff_load *= capacity_of(prev_cpu);
|
2017-07-31 15:50:05 +00:00
|
|
|
|
2017-10-06 07:23:24 +00:00
|
|
|
prev_eff_load -= task_load;
|
|
|
|
if (sched_feat(WA_BIAS))
|
|
|
|
prev_eff_load *= 100 + (sd->imbalance_pct - 100) / 2;
|
|
|
|
prev_eff_load *= capacity_of(this_cpu);
|
2017-07-31 15:50:05 +00:00
|
|
|
|
2018-01-30 10:45:53 +00:00
|
|
|
return this_eff_load <= prev_eff_load ? this_cpu : nr_cpumask_bits;
|
2017-07-31 15:50:05 +00:00
|
|
|
}
|
|
|
|
|
2016-06-22 17:03:13 +00:00
|
|
|
static int wake_affine(struct sched_domain *sd, struct task_struct *p,
|
|
|
|
int prev_cpu, int sync)
|
2008-03-16 19:36:10 +00:00
|
|
|
{
|
2017-06-23 16:55:29 +00:00
|
|
|
int this_cpu = smp_processor_id();
|
2018-01-30 10:45:53 +00:00
|
|
|
int target = nr_cpumask_bits;
|
2008-03-16 19:36:10 +00:00
|
|
|
|
2018-01-30 10:45:52 +00:00
|
|
|
if (sched_feat(WA_IDLE))
|
2018-01-30 10:45:53 +00:00
|
|
|
target = wake_affine_idle(this_cpu, prev_cpu, sync);
|
2017-07-31 15:50:05 +00:00
|
|
|
|
2018-01-30 10:45:53 +00:00
|
|
|
if (sched_feat(WA_WEIGHT) && target == nr_cpumask_bits)
|
|
|
|
target = wake_affine_weight(sd, p, this_cpu, prev_cpu, sync);
|
2008-03-16 19:36:10 +00:00
|
|
|
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(p->se.statistics.nr_wakeups_affine_attempts);
|
2018-01-30 10:45:53 +00:00
|
|
|
if (target == nr_cpumask_bits)
|
|
|
|
return prev_cpu;
|
2008-03-16 19:36:10 +00:00
|
|
|
|
2018-01-30 10:45:53 +00:00
|
|
|
schedstat_inc(sd->ttwu_move_affine);
|
|
|
|
schedstat_inc(p->se.statistics.nr_wakeups_affine);
|
|
|
|
return target;
|
2008-03-16 19:36:10 +00:00
|
|
|
}
|
|
|
|
|
2017-12-05 17:10:15 +00:00
|
|
|
static inline unsigned long task_util(struct task_struct *p);
|
|
|
|
static unsigned long cpu_util_wake(int cpu, struct task_struct *p);
|
2016-10-14 13:41:08 +00:00
|
|
|
|
|
|
|
static unsigned long capacity_spare_wake(int cpu, struct task_struct *p)
|
|
|
|
{
|
2017-12-14 21:21:58 +00:00
|
|
|
return max_t(long, capacity_of(cpu) - cpu_util_wake(cpu, p), 0);
|
2016-10-14 13:41:08 +00:00
|
|
|
}
|
|
|
|
|
2009-09-10 11:36:25 +00:00
|
|
|
/*
|
|
|
|
* find_idlest_group finds and returns the least busy CPU group within the
|
|
|
|
* domain.
|
2017-10-05 11:45:15 +00:00
|
|
|
*
|
|
|
|
* Assumes p is allowed on at least one CPU in sd.
|
2009-09-10 11:36:25 +00:00
|
|
|
*/
|
|
|
|
static struct sched_group *
|
2009-09-03 11:16:51 +00:00
|
|
|
find_idlest_group(struct sched_domain *sd, struct task_struct *p,
|
2013-10-18 11:52:21 +00:00
|
|
|
int this_cpu, int sd_flag)
|
2008-01-25 20:08:09 +00:00
|
|
|
{
|
2010-08-10 21:17:51 +00:00
|
|
|
struct sched_group *idlest = NULL, *group = sd->groups;
|
2016-10-14 13:41:08 +00:00
|
|
|
struct sched_group *most_spare_sg = NULL;
|
2017-10-05 11:45:14 +00:00
|
|
|
unsigned long min_runnable_load = ULONG_MAX;
|
|
|
|
unsigned long this_runnable_load = ULONG_MAX;
|
|
|
|
unsigned long min_avg_load = ULONG_MAX, this_avg_load = ULONG_MAX;
|
2016-10-14 13:41:08 +00:00
|
|
|
unsigned long most_spare = 0, this_spare = 0;
|
2013-10-18 11:52:21 +00:00
|
|
|
int load_idx = sd->forkexec_idx;
|
sched/core: Use load_avg for selecting idlest group
find_idlest_group() only compares the runnable_load_avg when looking
for the least loaded group. But on fork intensive use case like
hackbench where tasks blocked quickly after the fork, this can lead to
selecting the same CPU instead of other CPUs, which have similar
runnable load but a lower load_avg.
When the runnable_load_avg of 2 CPUs are close, we now take into
account the amount of blocked load as a 2nd selection factor. There is
now 3 zones for the runnable_load of the rq:
- [0 .. (runnable_load - imbalance)]:
Select the new rq which has significantly less runnable_load
- [(runnable_load - imbalance) .. (runnable_load + imbalance)]:
The runnable loads are close so we use load_avg to chose
between the 2 rq
- [(runnable_load + imbalance) .. ULONG_MAX]:
Keep the current rq which has significantly less runnable_load
The scale factor that is currently used for comparing runnable_load,
doesn't work well with small value. As an example, the use of a
scaling factor fails as soon as this_runnable_load == 0 because we
always select local rq even if min_runnable_load is only 1, which
doesn't really make sense because they are just the same. So instead
of scaling factor, we use an absolute margin for runnable_load to
detect CPUs with similar runnable_load and we keep using scaling
factor for blocked load.
For use case like hackbench, this enable the scheduler to select
different CPUs during the fork sequence and to spread tasks across the
system.
Tests have been done on a Hikey board (ARM based octo cores) for
several kernel. The result below gives min, max, avg and stdev values
of 18 runs with each configuration.
The patches depend on the "no missing update_rq_clock()" work.
hackbench -P -g 1
ea86cb4b7621 7dc603c9028e v4.8 v4.8+patches
min 0.049 0.050 0.051 0,048
avg 0.057 0.057(0%) 0.057(0%) 0,055(+5%)
max 0.066 0.068 0.070 0,063
stdev +/-9% +/-9% +/-8% +/-9%
More performance numbers here:
https://lkml.kernel.org/r/20161203214707.GI20785@codeblueprint.co.uk
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Morten.Rasmussen@arm.com
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-3-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:54 +00:00
|
|
|
int imbalance_scale = 100 + (sd->imbalance_pct-100)/2;
|
|
|
|
unsigned long imbalance = scale_load_down(NICE_0_LOAD) *
|
|
|
|
(sd->imbalance_pct-100) / 100;
|
2008-01-25 20:08:09 +00:00
|
|
|
|
2013-10-18 11:52:21 +00:00
|
|
|
if (sd_flag & SD_BALANCE_WAKE)
|
|
|
|
load_idx = sd->wake_idx;
|
|
|
|
|
2009-09-10 11:36:25 +00:00
|
|
|
do {
|
sched/core: Use load_avg for selecting idlest group
find_idlest_group() only compares the runnable_load_avg when looking
for the least loaded group. But on fork intensive use case like
hackbench where tasks blocked quickly after the fork, this can lead to
selecting the same CPU instead of other CPUs, which have similar
runnable load but a lower load_avg.
When the runnable_load_avg of 2 CPUs are close, we now take into
account the amount of blocked load as a 2nd selection factor. There is
now 3 zones for the runnable_load of the rq:
- [0 .. (runnable_load - imbalance)]:
Select the new rq which has significantly less runnable_load
- [(runnable_load - imbalance) .. (runnable_load + imbalance)]:
The runnable loads are close so we use load_avg to chose
between the 2 rq
- [(runnable_load + imbalance) .. ULONG_MAX]:
Keep the current rq which has significantly less runnable_load
The scale factor that is currently used for comparing runnable_load,
doesn't work well with small value. As an example, the use of a
scaling factor fails as soon as this_runnable_load == 0 because we
always select local rq even if min_runnable_load is only 1, which
doesn't really make sense because they are just the same. So instead
of scaling factor, we use an absolute margin for runnable_load to
detect CPUs with similar runnable_load and we keep using scaling
factor for blocked load.
For use case like hackbench, this enable the scheduler to select
different CPUs during the fork sequence and to spread tasks across the
system.
Tests have been done on a Hikey board (ARM based octo cores) for
several kernel. The result below gives min, max, avg and stdev values
of 18 runs with each configuration.
The patches depend on the "no missing update_rq_clock()" work.
hackbench -P -g 1
ea86cb4b7621 7dc603c9028e v4.8 v4.8+patches
min 0.049 0.050 0.051 0,048
avg 0.057 0.057(0%) 0.057(0%) 0,055(+5%)
max 0.066 0.068 0.070 0,063
stdev +/-9% +/-9% +/-8% +/-9%
More performance numbers here:
https://lkml.kernel.org/r/20161203214707.GI20785@codeblueprint.co.uk
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Morten.Rasmussen@arm.com
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-3-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:54 +00:00
|
|
|
unsigned long load, avg_load, runnable_load;
|
|
|
|
unsigned long spare_cap, max_spare_cap;
|
2009-09-10 11:36:25 +00:00
|
|
|
int local_group;
|
|
|
|
int i;
|
2008-01-25 20:08:09 +00:00
|
|
|
|
2009-09-10 11:36:25 +00:00
|
|
|
/* Skip over this group if it has no CPUs allowed */
|
2017-05-01 09:03:12 +00:00
|
|
|
if (!cpumask_intersects(sched_group_span(group),
|
2017-02-05 14:38:10 +00:00
|
|
|
&p->cpus_allowed))
|
2009-09-10 11:36:25 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
local_group = cpumask_test_cpu(this_cpu,
|
2017-05-01 09:03:12 +00:00
|
|
|
sched_group_span(group));
|
2009-09-10 11:36:25 +00:00
|
|
|
|
2016-10-14 13:41:08 +00:00
|
|
|
/*
|
|
|
|
* Tally up the load of all CPUs in the group and find
|
|
|
|
* the group containing the CPU with most spare capacity.
|
|
|
|
*/
|
2009-09-10 11:36:25 +00:00
|
|
|
avg_load = 0;
|
sched/core: Use load_avg for selecting idlest group
find_idlest_group() only compares the runnable_load_avg when looking
for the least loaded group. But on fork intensive use case like
hackbench where tasks blocked quickly after the fork, this can lead to
selecting the same CPU instead of other CPUs, which have similar
runnable load but a lower load_avg.
When the runnable_load_avg of 2 CPUs are close, we now take into
account the amount of blocked load as a 2nd selection factor. There is
now 3 zones for the runnable_load of the rq:
- [0 .. (runnable_load - imbalance)]:
Select the new rq which has significantly less runnable_load
- [(runnable_load - imbalance) .. (runnable_load + imbalance)]:
The runnable loads are close so we use load_avg to chose
between the 2 rq
- [(runnable_load + imbalance) .. ULONG_MAX]:
Keep the current rq which has significantly less runnable_load
The scale factor that is currently used for comparing runnable_load,
doesn't work well with small value. As an example, the use of a
scaling factor fails as soon as this_runnable_load == 0 because we
always select local rq even if min_runnable_load is only 1, which
doesn't really make sense because they are just the same. So instead
of scaling factor, we use an absolute margin for runnable_load to
detect CPUs with similar runnable_load and we keep using scaling
factor for blocked load.
For use case like hackbench, this enable the scheduler to select
different CPUs during the fork sequence and to spread tasks across the
system.
Tests have been done on a Hikey board (ARM based octo cores) for
several kernel. The result below gives min, max, avg and stdev values
of 18 runs with each configuration.
The patches depend on the "no missing update_rq_clock()" work.
hackbench -P -g 1
ea86cb4b7621 7dc603c9028e v4.8 v4.8+patches
min 0.049 0.050 0.051 0,048
avg 0.057 0.057(0%) 0.057(0%) 0,055(+5%)
max 0.066 0.068 0.070 0,063
stdev +/-9% +/-9% +/-8% +/-9%
More performance numbers here:
https://lkml.kernel.org/r/20161203214707.GI20785@codeblueprint.co.uk
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Morten.Rasmussen@arm.com
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-3-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:54 +00:00
|
|
|
runnable_load = 0;
|
2016-10-14 13:41:08 +00:00
|
|
|
max_spare_cap = 0;
|
2009-09-10 11:36:25 +00:00
|
|
|
|
2017-05-01 09:03:12 +00:00
|
|
|
for_each_cpu(i, sched_group_span(group)) {
|
2009-09-10 11:36:25 +00:00
|
|
|
/* Bias balancing toward cpus of our domain */
|
|
|
|
if (local_group)
|
|
|
|
load = source_load(i, load_idx);
|
|
|
|
else
|
|
|
|
load = target_load(i, load_idx);
|
|
|
|
|
sched/core: Use load_avg for selecting idlest group
find_idlest_group() only compares the runnable_load_avg when looking
for the least loaded group. But on fork intensive use case like
hackbench where tasks blocked quickly after the fork, this can lead to
selecting the same CPU instead of other CPUs, which have similar
runnable load but a lower load_avg.
When the runnable_load_avg of 2 CPUs are close, we now take into
account the amount of blocked load as a 2nd selection factor. There is
now 3 zones for the runnable_load of the rq:
- [0 .. (runnable_load - imbalance)]:
Select the new rq which has significantly less runnable_load
- [(runnable_load - imbalance) .. (runnable_load + imbalance)]:
The runnable loads are close so we use load_avg to chose
between the 2 rq
- [(runnable_load + imbalance) .. ULONG_MAX]:
Keep the current rq which has significantly less runnable_load
The scale factor that is currently used for comparing runnable_load,
doesn't work well with small value. As an example, the use of a
scaling factor fails as soon as this_runnable_load == 0 because we
always select local rq even if min_runnable_load is only 1, which
doesn't really make sense because they are just the same. So instead
of scaling factor, we use an absolute margin for runnable_load to
detect CPUs with similar runnable_load and we keep using scaling
factor for blocked load.
For use case like hackbench, this enable the scheduler to select
different CPUs during the fork sequence and to spread tasks across the
system.
Tests have been done on a Hikey board (ARM based octo cores) for
several kernel. The result below gives min, max, avg and stdev values
of 18 runs with each configuration.
The patches depend on the "no missing update_rq_clock()" work.
hackbench -P -g 1
ea86cb4b7621 7dc603c9028e v4.8 v4.8+patches
min 0.049 0.050 0.051 0,048
avg 0.057 0.057(0%) 0.057(0%) 0,055(+5%)
max 0.066 0.068 0.070 0,063
stdev +/-9% +/-9% +/-8% +/-9%
More performance numbers here:
https://lkml.kernel.org/r/20161203214707.GI20785@codeblueprint.co.uk
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Morten.Rasmussen@arm.com
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-3-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:54 +00:00
|
|
|
runnable_load += load;
|
|
|
|
|
|
|
|
avg_load += cfs_rq_load_avg(&cpu_rq(i)->cfs);
|
2016-10-14 13:41:08 +00:00
|
|
|
|
|
|
|
spare_cap = capacity_spare_wake(i, p);
|
|
|
|
|
|
|
|
if (spare_cap > max_spare_cap)
|
|
|
|
max_spare_cap = spare_cap;
|
2009-09-10 11:36:25 +00:00
|
|
|
}
|
|
|
|
|
2014-05-26 22:19:37 +00:00
|
|
|
/* Adjust by relative CPU capacity of the group */
|
sched/core: Use load_avg for selecting idlest group
find_idlest_group() only compares the runnable_load_avg when looking
for the least loaded group. But on fork intensive use case like
hackbench where tasks blocked quickly after the fork, this can lead to
selecting the same CPU instead of other CPUs, which have similar
runnable load but a lower load_avg.
When the runnable_load_avg of 2 CPUs are close, we now take into
account the amount of blocked load as a 2nd selection factor. There is
now 3 zones for the runnable_load of the rq:
- [0 .. (runnable_load - imbalance)]:
Select the new rq which has significantly less runnable_load
- [(runnable_load - imbalance) .. (runnable_load + imbalance)]:
The runnable loads are close so we use load_avg to chose
between the 2 rq
- [(runnable_load + imbalance) .. ULONG_MAX]:
Keep the current rq which has significantly less runnable_load
The scale factor that is currently used for comparing runnable_load,
doesn't work well with small value. As an example, the use of a
scaling factor fails as soon as this_runnable_load == 0 because we
always select local rq even if min_runnable_load is only 1, which
doesn't really make sense because they are just the same. So instead
of scaling factor, we use an absolute margin for runnable_load to
detect CPUs with similar runnable_load and we keep using scaling
factor for blocked load.
For use case like hackbench, this enable the scheduler to select
different CPUs during the fork sequence and to spread tasks across the
system.
Tests have been done on a Hikey board (ARM based octo cores) for
several kernel. The result below gives min, max, avg and stdev values
of 18 runs with each configuration.
The patches depend on the "no missing update_rq_clock()" work.
hackbench -P -g 1
ea86cb4b7621 7dc603c9028e v4.8 v4.8+patches
min 0.049 0.050 0.051 0,048
avg 0.057 0.057(0%) 0.057(0%) 0,055(+5%)
max 0.066 0.068 0.070 0,063
stdev +/-9% +/-9% +/-8% +/-9%
More performance numbers here:
https://lkml.kernel.org/r/20161203214707.GI20785@codeblueprint.co.uk
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Morten.Rasmussen@arm.com
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-3-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:54 +00:00
|
|
|
avg_load = (avg_load * SCHED_CAPACITY_SCALE) /
|
|
|
|
group->sgc->capacity;
|
|
|
|
runnable_load = (runnable_load * SCHED_CAPACITY_SCALE) /
|
|
|
|
group->sgc->capacity;
|
2009-09-10 11:36:25 +00:00
|
|
|
|
|
|
|
if (local_group) {
|
sched/core: Use load_avg for selecting idlest group
find_idlest_group() only compares the runnable_load_avg when looking
for the least loaded group. But on fork intensive use case like
hackbench where tasks blocked quickly after the fork, this can lead to
selecting the same CPU instead of other CPUs, which have similar
runnable load but a lower load_avg.
When the runnable_load_avg of 2 CPUs are close, we now take into
account the amount of blocked load as a 2nd selection factor. There is
now 3 zones for the runnable_load of the rq:
- [0 .. (runnable_load - imbalance)]:
Select the new rq which has significantly less runnable_load
- [(runnable_load - imbalance) .. (runnable_load + imbalance)]:
The runnable loads are close so we use load_avg to chose
between the 2 rq
- [(runnable_load + imbalance) .. ULONG_MAX]:
Keep the current rq which has significantly less runnable_load
The scale factor that is currently used for comparing runnable_load,
doesn't work well with small value. As an example, the use of a
scaling factor fails as soon as this_runnable_load == 0 because we
always select local rq even if min_runnable_load is only 1, which
doesn't really make sense because they are just the same. So instead
of scaling factor, we use an absolute margin for runnable_load to
detect CPUs with similar runnable_load and we keep using scaling
factor for blocked load.
For use case like hackbench, this enable the scheduler to select
different CPUs during the fork sequence and to spread tasks across the
system.
Tests have been done on a Hikey board (ARM based octo cores) for
several kernel. The result below gives min, max, avg and stdev values
of 18 runs with each configuration.
The patches depend on the "no missing update_rq_clock()" work.
hackbench -P -g 1
ea86cb4b7621 7dc603c9028e v4.8 v4.8+patches
min 0.049 0.050 0.051 0,048
avg 0.057 0.057(0%) 0.057(0%) 0,055(+5%)
max 0.066 0.068 0.070 0,063
stdev +/-9% +/-9% +/-8% +/-9%
More performance numbers here:
https://lkml.kernel.org/r/20161203214707.GI20785@codeblueprint.co.uk
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Morten.Rasmussen@arm.com
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-3-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:54 +00:00
|
|
|
this_runnable_load = runnable_load;
|
|
|
|
this_avg_load = avg_load;
|
2016-10-14 13:41:08 +00:00
|
|
|
this_spare = max_spare_cap;
|
|
|
|
} else {
|
sched/core: Use load_avg for selecting idlest group
find_idlest_group() only compares the runnable_load_avg when looking
for the least loaded group. But on fork intensive use case like
hackbench where tasks blocked quickly after the fork, this can lead to
selecting the same CPU instead of other CPUs, which have similar
runnable load but a lower load_avg.
When the runnable_load_avg of 2 CPUs are close, we now take into
account the amount of blocked load as a 2nd selection factor. There is
now 3 zones for the runnable_load of the rq:
- [0 .. (runnable_load - imbalance)]:
Select the new rq which has significantly less runnable_load
- [(runnable_load - imbalance) .. (runnable_load + imbalance)]:
The runnable loads are close so we use load_avg to chose
between the 2 rq
- [(runnable_load + imbalance) .. ULONG_MAX]:
Keep the current rq which has significantly less runnable_load
The scale factor that is currently used for comparing runnable_load,
doesn't work well with small value. As an example, the use of a
scaling factor fails as soon as this_runnable_load == 0 because we
always select local rq even if min_runnable_load is only 1, which
doesn't really make sense because they are just the same. So instead
of scaling factor, we use an absolute margin for runnable_load to
detect CPUs with similar runnable_load and we keep using scaling
factor for blocked load.
For use case like hackbench, this enable the scheduler to select
different CPUs during the fork sequence and to spread tasks across the
system.
Tests have been done on a Hikey board (ARM based octo cores) for
several kernel. The result below gives min, max, avg and stdev values
of 18 runs with each configuration.
The patches depend on the "no missing update_rq_clock()" work.
hackbench -P -g 1
ea86cb4b7621 7dc603c9028e v4.8 v4.8+patches
min 0.049 0.050 0.051 0,048
avg 0.057 0.057(0%) 0.057(0%) 0,055(+5%)
max 0.066 0.068 0.070 0,063
stdev +/-9% +/-9% +/-8% +/-9%
More performance numbers here:
https://lkml.kernel.org/r/20161203214707.GI20785@codeblueprint.co.uk
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Morten.Rasmussen@arm.com
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-3-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:54 +00:00
|
|
|
if (min_runnable_load > (runnable_load + imbalance)) {
|
|
|
|
/*
|
|
|
|
* The runnable load is significantly smaller
|
|
|
|
* so we can pick this new cpu
|
|
|
|
*/
|
|
|
|
min_runnable_load = runnable_load;
|
|
|
|
min_avg_load = avg_load;
|
|
|
|
idlest = group;
|
|
|
|
} else if ((runnable_load < (min_runnable_load + imbalance)) &&
|
|
|
|
(100*min_avg_load > imbalance_scale*avg_load)) {
|
|
|
|
/*
|
|
|
|
* The runnable loads are close so take the
|
|
|
|
* blocked load into account through avg_load.
|
|
|
|
*/
|
|
|
|
min_avg_load = avg_load;
|
2016-10-14 13:41:08 +00:00
|
|
|
idlest = group;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (most_spare < max_spare_cap) {
|
|
|
|
most_spare = max_spare_cap;
|
|
|
|
most_spare_sg = group;
|
|
|
|
}
|
2009-09-10 11:36:25 +00:00
|
|
|
}
|
|
|
|
} while (group = group->next, group != sd->groups);
|
|
|
|
|
2016-10-14 13:41:08 +00:00
|
|
|
/*
|
|
|
|
* The cross-over point between using spare capacity or least load
|
|
|
|
* is too conservative for high utilization tasks on partially
|
|
|
|
* utilized systems if we require spare_capacity > task_util(p),
|
|
|
|
* so we allow for some task stuffing by using
|
|
|
|
* spare_capacity > task_util(p)/2.
|
sched/core: Fix find_idlest_group() for fork
During fork, the utilization of a task is init once the rq has been
selected because the current utilization level of the rq is used to
set the utilization of the fork task. As the task's utilization is
still 0 at this step of the fork sequence, it doesn't make sense to
look for some spare capacity that can fit the task's utilization.
Furthermore, I can see perf regressions for the test:
hackbench -P -g 1
because the least loaded policy is always bypassed and tasks are not
spread during fork.
With this patch and the fix below, we are back to same performances as
for v4.8. The fix below is only a temporary one used for the test
until a smarter solution is found because we can't simply remove the
test which is useful for others benchmarks
| @@ -5708,13 +5708,6 @@ static int select_idle_cpu(struct task_struct *p, struct sched_domain *sd, int t
|
| avg_cost = this_sd->avg_scan_cost;
|
| - /*
| - * Due to large variance we need a large fuzz factor; hackbench in
| - * particularly is sensitive here.
| - */
| - if ((avg_idle / 512) < avg_cost)
| - return -1;
| -
| time = local_clock();
|
| for_each_cpu_wrap(cpu, sched_domain_span(sd), target, wrap) {
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Acked-by: Morten Rasmussen <morten.rasmussen@arm.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-2-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:53 +00:00
|
|
|
*
|
|
|
|
* Spare capacity can't be used for fork because the utilization has
|
|
|
|
* not been set yet, we must first select a rq to compute the initial
|
|
|
|
* utilization.
|
2016-10-14 13:41:08 +00:00
|
|
|
*/
|
sched/core: Fix find_idlest_group() for fork
During fork, the utilization of a task is init once the rq has been
selected because the current utilization level of the rq is used to
set the utilization of the fork task. As the task's utilization is
still 0 at this step of the fork sequence, it doesn't make sense to
look for some spare capacity that can fit the task's utilization.
Furthermore, I can see perf regressions for the test:
hackbench -P -g 1
because the least loaded policy is always bypassed and tasks are not
spread during fork.
With this patch and the fix below, we are back to same performances as
for v4.8. The fix below is only a temporary one used for the test
until a smarter solution is found because we can't simply remove the
test which is useful for others benchmarks
| @@ -5708,13 +5708,6 @@ static int select_idle_cpu(struct task_struct *p, struct sched_domain *sd, int t
|
| avg_cost = this_sd->avg_scan_cost;
|
| - /*
| - * Due to large variance we need a large fuzz factor; hackbench in
| - * particularly is sensitive here.
| - */
| - if ((avg_idle / 512) < avg_cost)
| - return -1;
| -
| time = local_clock();
|
| for_each_cpu_wrap(cpu, sched_domain_span(sd), target, wrap) {
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Acked-by: Morten Rasmussen <morten.rasmussen@arm.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-2-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:53 +00:00
|
|
|
if (sd_flag & SD_BALANCE_FORK)
|
|
|
|
goto skip_spare;
|
|
|
|
|
2016-10-14 13:41:08 +00:00
|
|
|
if (this_spare > task_util(p) / 2 &&
|
sched/core: Use load_avg for selecting idlest group
find_idlest_group() only compares the runnable_load_avg when looking
for the least loaded group. But on fork intensive use case like
hackbench where tasks blocked quickly after the fork, this can lead to
selecting the same CPU instead of other CPUs, which have similar
runnable load but a lower load_avg.
When the runnable_load_avg of 2 CPUs are close, we now take into
account the amount of blocked load as a 2nd selection factor. There is
now 3 zones for the runnable_load of the rq:
- [0 .. (runnable_load - imbalance)]:
Select the new rq which has significantly less runnable_load
- [(runnable_load - imbalance) .. (runnable_load + imbalance)]:
The runnable loads are close so we use load_avg to chose
between the 2 rq
- [(runnable_load + imbalance) .. ULONG_MAX]:
Keep the current rq which has significantly less runnable_load
The scale factor that is currently used for comparing runnable_load,
doesn't work well with small value. As an example, the use of a
scaling factor fails as soon as this_runnable_load == 0 because we
always select local rq even if min_runnable_load is only 1, which
doesn't really make sense because they are just the same. So instead
of scaling factor, we use an absolute margin for runnable_load to
detect CPUs with similar runnable_load and we keep using scaling
factor for blocked load.
For use case like hackbench, this enable the scheduler to select
different CPUs during the fork sequence and to spread tasks across the
system.
Tests have been done on a Hikey board (ARM based octo cores) for
several kernel. The result below gives min, max, avg and stdev values
of 18 runs with each configuration.
The patches depend on the "no missing update_rq_clock()" work.
hackbench -P -g 1
ea86cb4b7621 7dc603c9028e v4.8 v4.8+patches
min 0.049 0.050 0.051 0,048
avg 0.057 0.057(0%) 0.057(0%) 0,055(+5%)
max 0.066 0.068 0.070 0,063
stdev +/-9% +/-9% +/-8% +/-9%
More performance numbers here:
https://lkml.kernel.org/r/20161203214707.GI20785@codeblueprint.co.uk
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Morten.Rasmussen@arm.com
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-3-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:54 +00:00
|
|
|
imbalance_scale*this_spare > 100*most_spare)
|
2016-10-14 13:41:08 +00:00
|
|
|
return NULL;
|
sched/core: Use load_avg for selecting idlest group
find_idlest_group() only compares the runnable_load_avg when looking
for the least loaded group. But on fork intensive use case like
hackbench where tasks blocked quickly after the fork, this can lead to
selecting the same CPU instead of other CPUs, which have similar
runnable load but a lower load_avg.
When the runnable_load_avg of 2 CPUs are close, we now take into
account the amount of blocked load as a 2nd selection factor. There is
now 3 zones for the runnable_load of the rq:
- [0 .. (runnable_load - imbalance)]:
Select the new rq which has significantly less runnable_load
- [(runnable_load - imbalance) .. (runnable_load + imbalance)]:
The runnable loads are close so we use load_avg to chose
between the 2 rq
- [(runnable_load + imbalance) .. ULONG_MAX]:
Keep the current rq which has significantly less runnable_load
The scale factor that is currently used for comparing runnable_load,
doesn't work well with small value. As an example, the use of a
scaling factor fails as soon as this_runnable_load == 0 because we
always select local rq even if min_runnable_load is only 1, which
doesn't really make sense because they are just the same. So instead
of scaling factor, we use an absolute margin for runnable_load to
detect CPUs with similar runnable_load and we keep using scaling
factor for blocked load.
For use case like hackbench, this enable the scheduler to select
different CPUs during the fork sequence and to spread tasks across the
system.
Tests have been done on a Hikey board (ARM based octo cores) for
several kernel. The result below gives min, max, avg and stdev values
of 18 runs with each configuration.
The patches depend on the "no missing update_rq_clock()" work.
hackbench -P -g 1
ea86cb4b7621 7dc603c9028e v4.8 v4.8+patches
min 0.049 0.050 0.051 0,048
avg 0.057 0.057(0%) 0.057(0%) 0,055(+5%)
max 0.066 0.068 0.070 0,063
stdev +/-9% +/-9% +/-8% +/-9%
More performance numbers here:
https://lkml.kernel.org/r/20161203214707.GI20785@codeblueprint.co.uk
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Morten.Rasmussen@arm.com
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-3-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:54 +00:00
|
|
|
|
|
|
|
if (most_spare > task_util(p) / 2)
|
2016-10-14 13:41:08 +00:00
|
|
|
return most_spare_sg;
|
|
|
|
|
sched/core: Fix find_idlest_group() for fork
During fork, the utilization of a task is init once the rq has been
selected because the current utilization level of the rq is used to
set the utilization of the fork task. As the task's utilization is
still 0 at this step of the fork sequence, it doesn't make sense to
look for some spare capacity that can fit the task's utilization.
Furthermore, I can see perf regressions for the test:
hackbench -P -g 1
because the least loaded policy is always bypassed and tasks are not
spread during fork.
With this patch and the fix below, we are back to same performances as
for v4.8. The fix below is only a temporary one used for the test
until a smarter solution is found because we can't simply remove the
test which is useful for others benchmarks
| @@ -5708,13 +5708,6 @@ static int select_idle_cpu(struct task_struct *p, struct sched_domain *sd, int t
|
| avg_cost = this_sd->avg_scan_cost;
|
| - /*
| - * Due to large variance we need a large fuzz factor; hackbench in
| - * particularly is sensitive here.
| - */
| - if ((avg_idle / 512) < avg_cost)
| - return -1;
| -
| time = local_clock();
|
| for_each_cpu_wrap(cpu, sched_domain_span(sd), target, wrap) {
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Acked-by: Morten Rasmussen <morten.rasmussen@arm.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-2-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:53 +00:00
|
|
|
skip_spare:
|
sched/core: Use load_avg for selecting idlest group
find_idlest_group() only compares the runnable_load_avg when looking
for the least loaded group. But on fork intensive use case like
hackbench where tasks blocked quickly after the fork, this can lead to
selecting the same CPU instead of other CPUs, which have similar
runnable load but a lower load_avg.
When the runnable_load_avg of 2 CPUs are close, we now take into
account the amount of blocked load as a 2nd selection factor. There is
now 3 zones for the runnable_load of the rq:
- [0 .. (runnable_load - imbalance)]:
Select the new rq which has significantly less runnable_load
- [(runnable_load - imbalance) .. (runnable_load + imbalance)]:
The runnable loads are close so we use load_avg to chose
between the 2 rq
- [(runnable_load + imbalance) .. ULONG_MAX]:
Keep the current rq which has significantly less runnable_load
The scale factor that is currently used for comparing runnable_load,
doesn't work well with small value. As an example, the use of a
scaling factor fails as soon as this_runnable_load == 0 because we
always select local rq even if min_runnable_load is only 1, which
doesn't really make sense because they are just the same. So instead
of scaling factor, we use an absolute margin for runnable_load to
detect CPUs with similar runnable_load and we keep using scaling
factor for blocked load.
For use case like hackbench, this enable the scheduler to select
different CPUs during the fork sequence and to spread tasks across the
system.
Tests have been done on a Hikey board (ARM based octo cores) for
several kernel. The result below gives min, max, avg and stdev values
of 18 runs with each configuration.
The patches depend on the "no missing update_rq_clock()" work.
hackbench -P -g 1
ea86cb4b7621 7dc603c9028e v4.8 v4.8+patches
min 0.049 0.050 0.051 0,048
avg 0.057 0.057(0%) 0.057(0%) 0,055(+5%)
max 0.066 0.068 0.070 0,063
stdev +/-9% +/-9% +/-8% +/-9%
More performance numbers here:
https://lkml.kernel.org/r/20161203214707.GI20785@codeblueprint.co.uk
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Morten.Rasmussen@arm.com
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-3-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:54 +00:00
|
|
|
if (!idlest)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (min_runnable_load > (this_runnable_load + imbalance))
|
2009-09-10 11:36:25 +00:00
|
|
|
return NULL;
|
sched/core: Use load_avg for selecting idlest group
find_idlest_group() only compares the runnable_load_avg when looking
for the least loaded group. But on fork intensive use case like
hackbench where tasks blocked quickly after the fork, this can lead to
selecting the same CPU instead of other CPUs, which have similar
runnable load but a lower load_avg.
When the runnable_load_avg of 2 CPUs are close, we now take into
account the amount of blocked load as a 2nd selection factor. There is
now 3 zones for the runnable_load of the rq:
- [0 .. (runnable_load - imbalance)]:
Select the new rq which has significantly less runnable_load
- [(runnable_load - imbalance) .. (runnable_load + imbalance)]:
The runnable loads are close so we use load_avg to chose
between the 2 rq
- [(runnable_load + imbalance) .. ULONG_MAX]:
Keep the current rq which has significantly less runnable_load
The scale factor that is currently used for comparing runnable_load,
doesn't work well with small value. As an example, the use of a
scaling factor fails as soon as this_runnable_load == 0 because we
always select local rq even if min_runnable_load is only 1, which
doesn't really make sense because they are just the same. So instead
of scaling factor, we use an absolute margin for runnable_load to
detect CPUs with similar runnable_load and we keep using scaling
factor for blocked load.
For use case like hackbench, this enable the scheduler to select
different CPUs during the fork sequence and to spread tasks across the
system.
Tests have been done on a Hikey board (ARM based octo cores) for
several kernel. The result below gives min, max, avg and stdev values
of 18 runs with each configuration.
The patches depend on the "no missing update_rq_clock()" work.
hackbench -P -g 1
ea86cb4b7621 7dc603c9028e v4.8 v4.8+patches
min 0.049 0.050 0.051 0,048
avg 0.057 0.057(0%) 0.057(0%) 0,055(+5%)
max 0.066 0.068 0.070 0,063
stdev +/-9% +/-9% +/-8% +/-9%
More performance numbers here:
https://lkml.kernel.org/r/20161203214707.GI20785@codeblueprint.co.uk
Tested-by: Matt Fleming <matt@codeblueprint.co.uk>
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Morten.Rasmussen@arm.com
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: dietmar.eggemann@arm.com
Cc: kernellwp@gmail.com
Cc: umgwanakikbuti@gmail.com
Cc: yuyang.du@intel.comc
Link: http://lkml.kernel.org/r/1481216215-24651-3-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-08 16:56:54 +00:00
|
|
|
|
|
|
|
if ((this_runnable_load < (min_runnable_load + imbalance)) &&
|
|
|
|
(100*this_avg_load < imbalance_scale*min_avg_load))
|
|
|
|
return NULL;
|
|
|
|
|
2009-09-10 11:36:25 +00:00
|
|
|
return idlest;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2017-10-05 11:45:12 +00:00
|
|
|
* find_idlest_group_cpu - find the idlest cpu among the cpus in group.
|
2009-09-10 11:36:25 +00:00
|
|
|
*/
|
|
|
|
static int
|
2017-10-05 11:45:12 +00:00
|
|
|
find_idlest_group_cpu(struct sched_group *group, struct task_struct *p, int this_cpu)
|
2009-09-10 11:36:25 +00:00
|
|
|
{
|
|
|
|
unsigned long load, min_load = ULONG_MAX;
|
2014-09-04 15:32:10 +00:00
|
|
|
unsigned int min_exit_latency = UINT_MAX;
|
|
|
|
u64 latest_idle_timestamp = 0;
|
|
|
|
int least_loaded_cpu = this_cpu;
|
|
|
|
int shallowest_idle_cpu = -1;
|
2009-09-10 11:36:25 +00:00
|
|
|
int i;
|
|
|
|
|
2016-06-22 17:03:14 +00:00
|
|
|
/* Check if we have any choice: */
|
|
|
|
if (group->group_weight == 1)
|
2017-05-01 09:03:12 +00:00
|
|
|
return cpumask_first(sched_group_span(group));
|
2016-06-22 17:03:14 +00:00
|
|
|
|
2009-09-10 11:36:25 +00:00
|
|
|
/* Traverse only the allowed CPUs */
|
2017-05-01 09:03:12 +00:00
|
|
|
for_each_cpu_and(i, sched_group_span(group), &p->cpus_allowed) {
|
2014-09-04 15:32:10 +00:00
|
|
|
if (idle_cpu(i)) {
|
|
|
|
struct rq *rq = cpu_rq(i);
|
|
|
|
struct cpuidle_state *idle = idle_get_state(rq);
|
|
|
|
if (idle && idle->exit_latency < min_exit_latency) {
|
|
|
|
/*
|
|
|
|
* We give priority to a CPU whose idle state
|
|
|
|
* has the smallest exit latency irrespective
|
|
|
|
* of any idle timestamp.
|
|
|
|
*/
|
|
|
|
min_exit_latency = idle->exit_latency;
|
|
|
|
latest_idle_timestamp = rq->idle_stamp;
|
|
|
|
shallowest_idle_cpu = i;
|
|
|
|
} else if ((!idle || idle->exit_latency == min_exit_latency) &&
|
|
|
|
rq->idle_stamp > latest_idle_timestamp) {
|
|
|
|
/*
|
|
|
|
* If equal or no active idle state, then
|
|
|
|
* the most recently idled CPU might have
|
|
|
|
* a warmer cache.
|
|
|
|
*/
|
|
|
|
latest_idle_timestamp = rq->idle_stamp;
|
|
|
|
shallowest_idle_cpu = i;
|
|
|
|
}
|
2014-10-28 04:08:06 +00:00
|
|
|
} else if (shallowest_idle_cpu == -1) {
|
2017-05-24 05:29:54 +00:00
|
|
|
load = weighted_cpuload(cpu_rq(i));
|
2017-12-15 15:39:44 +00:00
|
|
|
if (load < min_load) {
|
2014-09-04 15:32:10 +00:00
|
|
|
min_load = load;
|
|
|
|
least_loaded_cpu = i;
|
|
|
|
}
|
2008-01-25 20:08:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-04 15:32:10 +00:00
|
|
|
return shallowest_idle_cpu != -1 ? shallowest_idle_cpu : least_loaded_cpu;
|
2009-09-10 11:36:25 +00:00
|
|
|
}
|
2008-01-25 20:08:09 +00:00
|
|
|
|
2017-10-05 11:45:12 +00:00
|
|
|
static inline int find_idlest_cpu(struct sched_domain *sd, struct task_struct *p,
|
|
|
|
int cpu, int prev_cpu, int sd_flag)
|
|
|
|
{
|
2017-10-05 11:45:16 +00:00
|
|
|
int new_cpu = cpu;
|
2017-10-05 11:45:12 +00:00
|
|
|
|
2017-10-05 11:45:15 +00:00
|
|
|
if (!cpumask_intersects(sched_domain_span(sd), &p->cpus_allowed))
|
|
|
|
return prev_cpu;
|
|
|
|
|
2017-10-05 11:45:12 +00:00
|
|
|
while (sd) {
|
|
|
|
struct sched_group *group;
|
|
|
|
struct sched_domain *tmp;
|
|
|
|
int weight;
|
|
|
|
|
|
|
|
if (!(sd->flags & sd_flag)) {
|
|
|
|
sd = sd->child;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
group = find_idlest_group(sd, p, cpu, sd_flag);
|
|
|
|
if (!group) {
|
|
|
|
sd = sd->child;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
new_cpu = find_idlest_group_cpu(group, p, cpu);
|
2017-10-05 11:45:13 +00:00
|
|
|
if (new_cpu == cpu) {
|
2017-10-05 11:45:12 +00:00
|
|
|
/* Now try balancing at a lower domain level of cpu */
|
|
|
|
sd = sd->child;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now try balancing at a lower domain level of new_cpu */
|
|
|
|
cpu = new_cpu;
|
|
|
|
weight = sd->span_weight;
|
|
|
|
sd = NULL;
|
|
|
|
for_each_domain(cpu, tmp) {
|
|
|
|
if (weight <= tmp->span_weight)
|
|
|
|
break;
|
|
|
|
if (tmp->flags & sd_flag)
|
|
|
|
sd = tmp;
|
|
|
|
}
|
|
|
|
/* while loop will break here if sd == NULL */
|
|
|
|
}
|
|
|
|
|
|
|
|
return new_cpu;
|
|
|
|
}
|
|
|
|
|
2016-05-09 08:38:05 +00:00
|
|
|
#ifdef CONFIG_SCHED_SMT
|
|
|
|
|
|
|
|
static inline void set_idle_cores(int cpu, int val)
|
|
|
|
{
|
|
|
|
struct sched_domain_shared *sds;
|
|
|
|
|
|
|
|
sds = rcu_dereference(per_cpu(sd_llc_shared, cpu));
|
|
|
|
if (sds)
|
|
|
|
WRITE_ONCE(sds->has_idle_cores, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool test_idle_cores(int cpu, bool def)
|
|
|
|
{
|
|
|
|
struct sched_domain_shared *sds;
|
|
|
|
|
|
|
|
sds = rcu_dereference(per_cpu(sd_llc_shared, cpu));
|
|
|
|
if (sds)
|
|
|
|
return READ_ONCE(sds->has_idle_cores);
|
|
|
|
|
|
|
|
return def;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scans the local SMT mask to see if the entire core is idle, and records this
|
|
|
|
* information in sd_llc_shared->has_idle_cores.
|
|
|
|
*
|
|
|
|
* Since SMT siblings share all cache levels, inspecting this limited remote
|
|
|
|
* state should be fairly cheap.
|
|
|
|
*/
|
2016-05-09 08:38:41 +00:00
|
|
|
void __update_idle_core(struct rq *rq)
|
2016-05-09 08:38:05 +00:00
|
|
|
{
|
|
|
|
int core = cpu_of(rq);
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
if (test_idle_cores(core, true))
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
for_each_cpu(cpu, cpu_smt_mask(core)) {
|
|
|
|
if (cpu == core)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!idle_cpu(cpu))
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_idle_cores(core, 1);
|
|
|
|
unlock:
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scan the entire LLC domain for idle cores; this dynamically switches off if
|
|
|
|
* there are no idle cores left in the system; tracked through
|
|
|
|
* sd_llc->shared->has_idle_cores and enabled through update_idle_core() above.
|
|
|
|
*/
|
|
|
|
static int select_idle_core(struct task_struct *p, struct sched_domain *sd, int target)
|
|
|
|
{
|
|
|
|
struct cpumask *cpus = this_cpu_cpumask_var_ptr(select_idle_mask);
|
2017-04-14 12:20:05 +00:00
|
|
|
int core, cpu;
|
2016-05-09 08:38:05 +00:00
|
|
|
|
2016-05-09 08:38:41 +00:00
|
|
|
if (!static_branch_likely(&sched_smt_present))
|
|
|
|
return -1;
|
|
|
|
|
2016-05-09 08:38:05 +00:00
|
|
|
if (!test_idle_cores(target, false))
|
|
|
|
return -1;
|
|
|
|
|
2017-02-05 14:38:10 +00:00
|
|
|
cpumask_and(cpus, sched_domain_span(sd), &p->cpus_allowed);
|
2016-05-09 08:38:05 +00:00
|
|
|
|
2017-04-14 12:20:05 +00:00
|
|
|
for_each_cpu_wrap(core, cpus, target) {
|
2016-05-09 08:38:05 +00:00
|
|
|
bool idle = true;
|
|
|
|
|
|
|
|
for_each_cpu(cpu, cpu_smt_mask(core)) {
|
|
|
|
cpumask_clear_cpu(cpu, cpus);
|
|
|
|
if (!idle_cpu(cpu))
|
|
|
|
idle = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (idle)
|
|
|
|
return core;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Failed to find an idle core; stop looking for one.
|
|
|
|
*/
|
|
|
|
set_idle_cores(target, 0);
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scan the local SMT mask for idle CPUs.
|
|
|
|
*/
|
|
|
|
static int select_idle_smt(struct task_struct *p, struct sched_domain *sd, int target)
|
|
|
|
{
|
|
|
|
int cpu;
|
|
|
|
|
2016-05-09 08:38:41 +00:00
|
|
|
if (!static_branch_likely(&sched_smt_present))
|
|
|
|
return -1;
|
|
|
|
|
2016-05-09 08:38:05 +00:00
|
|
|
for_each_cpu(cpu, cpu_smt_mask(target)) {
|
2017-02-05 14:38:10 +00:00
|
|
|
if (!cpumask_test_cpu(cpu, &p->cpus_allowed))
|
2016-05-09 08:38:05 +00:00
|
|
|
continue;
|
|
|
|
if (idle_cpu(cpu))
|
|
|
|
return cpu;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* CONFIG_SCHED_SMT */
|
|
|
|
|
|
|
|
static inline int select_idle_core(struct task_struct *p, struct sched_domain *sd, int target)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int select_idle_smt(struct task_struct *p, struct sched_domain *sd, int target)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_SCHED_SMT */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scan the LLC domain for idle CPUs; this is dynamically regulated by
|
|
|
|
* comparing the average scan cost (tracked in sd->avg_scan_cost) against the
|
|
|
|
* average idle time for this rq (as found in rq->avg_idle).
|
2009-11-12 14:55:28 +00:00
|
|
|
*/
|
2016-05-09 08:38:05 +00:00
|
|
|
static int select_idle_cpu(struct task_struct *p, struct sched_domain *sd, int target)
|
|
|
|
{
|
2016-10-09 00:04:03 +00:00
|
|
|
struct sched_domain *this_sd;
|
2017-05-17 10:53:50 +00:00
|
|
|
u64 avg_cost, avg_idle;
|
2016-05-09 08:38:05 +00:00
|
|
|
u64 time, cost;
|
|
|
|
s64 delta;
|
2017-05-17 10:53:50 +00:00
|
|
|
int cpu, nr = INT_MAX;
|
2016-05-09 08:38:05 +00:00
|
|
|
|
2016-10-09 00:04:03 +00:00
|
|
|
this_sd = rcu_dereference(*this_cpu_ptr(&sd_llc));
|
|
|
|
if (!this_sd)
|
|
|
|
return -1;
|
|
|
|
|
2016-05-09 08:38:05 +00:00
|
|
|
/*
|
|
|
|
* Due to large variance we need a large fuzz factor; hackbench in
|
|
|
|
* particularly is sensitive here.
|
|
|
|
*/
|
2017-05-17 10:53:50 +00:00
|
|
|
avg_idle = this_rq()->avg_idle / 512;
|
|
|
|
avg_cost = this_sd->avg_scan_cost + 1;
|
|
|
|
|
|
|
|
if (sched_feat(SIS_AVG_CPU) && avg_idle < avg_cost)
|
2016-05-09 08:38:05 +00:00
|
|
|
return -1;
|
|
|
|
|
2017-05-17 10:53:50 +00:00
|
|
|
if (sched_feat(SIS_PROP)) {
|
|
|
|
u64 span_avg = sd->span_weight * avg_idle;
|
|
|
|
if (span_avg > 4*avg_cost)
|
|
|
|
nr = div_u64(span_avg, avg_cost);
|
|
|
|
else
|
|
|
|
nr = 4;
|
|
|
|
}
|
|
|
|
|
2016-05-09 08:38:05 +00:00
|
|
|
time = local_clock();
|
|
|
|
|
2017-04-14 12:20:05 +00:00
|
|
|
for_each_cpu_wrap(cpu, sched_domain_span(sd), target) {
|
2017-05-17 10:53:50 +00:00
|
|
|
if (!--nr)
|
|
|
|
return -1;
|
2017-02-05 14:38:10 +00:00
|
|
|
if (!cpumask_test_cpu(cpu, &p->cpus_allowed))
|
2016-05-09 08:38:05 +00:00
|
|
|
continue;
|
|
|
|
if (idle_cpu(cpu))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
time = local_clock() - time;
|
|
|
|
cost = this_sd->avg_scan_cost;
|
|
|
|
delta = (s64)(time - cost) / 8;
|
|
|
|
this_sd->avg_scan_cost += delta;
|
|
|
|
|
|
|
|
return cpu;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try and locate an idle core/thread in the LLC cache domain.
|
2009-11-12 14:55:28 +00:00
|
|
|
*/
|
2016-06-22 17:03:13 +00:00
|
|
|
static int select_idle_sibling(struct task_struct *p, int prev, int target)
|
2009-11-12 14:55:28 +00:00
|
|
|
{
|
2010-03-31 23:47:45 +00:00
|
|
|
struct sched_domain *sd;
|
2018-01-30 10:45:55 +00:00
|
|
|
int i, recent_used_cpu;
|
2009-11-12 14:55:28 +00:00
|
|
|
|
2013-01-28 11:19:25 +00:00
|
|
|
if (idle_cpu(target))
|
|
|
|
return target;
|
2010-03-31 23:47:45 +00:00
|
|
|
|
|
|
|
/*
|
2016-05-09 08:38:05 +00:00
|
|
|
* If the previous cpu is cache affine and idle, don't be stupid.
|
2010-03-31 23:47:45 +00:00
|
|
|
*/
|
2016-06-22 17:03:13 +00:00
|
|
|
if (prev != target && cpus_share_cache(prev, target) && idle_cpu(prev))
|
|
|
|
return prev;
|
2009-11-12 14:55:28 +00:00
|
|
|
|
2018-01-30 10:45:55 +00:00
|
|
|
/* Check a recently used CPU as a potential idle candidate */
|
|
|
|
recent_used_cpu = p->recent_used_cpu;
|
|
|
|
if (recent_used_cpu != prev &&
|
|
|
|
recent_used_cpu != target &&
|
|
|
|
cpus_share_cache(recent_used_cpu, target) &&
|
|
|
|
idle_cpu(recent_used_cpu) &&
|
|
|
|
cpumask_test_cpu(p->recent_used_cpu, &p->cpus_allowed)) {
|
|
|
|
/*
|
|
|
|
* Replace recent_used_cpu with prev as it is a potential
|
|
|
|
* candidate for the next wake.
|
|
|
|
*/
|
|
|
|
p->recent_used_cpu = prev;
|
|
|
|
return recent_used_cpu;
|
|
|
|
}
|
|
|
|
|
2011-12-07 14:07:31 +00:00
|
|
|
sd = rcu_dereference(per_cpu(sd_llc, target));
|
2016-05-09 08:38:05 +00:00
|
|
|
if (!sd)
|
|
|
|
return target;
|
2016-06-22 17:03:13 +00:00
|
|
|
|
2016-05-09 08:38:05 +00:00
|
|
|
i = select_idle_core(p, sd, target);
|
|
|
|
if ((unsigned)i < nr_cpumask_bits)
|
|
|
|
return i;
|
2012-09-16 19:29:43 +00:00
|
|
|
|
2016-05-09 08:38:05 +00:00
|
|
|
i = select_idle_cpu(p, sd, target);
|
|
|
|
if ((unsigned)i < nr_cpumask_bits)
|
|
|
|
return i;
|
|
|
|
|
|
|
|
i = select_idle_smt(p, sd, target);
|
|
|
|
if ((unsigned)i < nr_cpumask_bits)
|
|
|
|
return i;
|
2012-06-12 03:18:32 +00:00
|
|
|
|
2009-11-12 14:55:28 +00:00
|
|
|
return target;
|
|
|
|
}
|
2015-08-14 16:23:13 +00:00
|
|
|
|
2015-03-04 07:48:47 +00:00
|
|
|
/*
|
2015-08-14 16:23:12 +00:00
|
|
|
* cpu_util returns the amount of capacity of a CPU that is used by CFS
|
2015-03-04 07:48:47 +00:00
|
|
|
* tasks. The unit of the return value must be the one of capacity so we can
|
2015-08-14 16:23:12 +00:00
|
|
|
* compare the utilization with the capacity of the CPU that is available for
|
|
|
|
* CFS task (ie cpu_capacity).
|
2015-08-14 16:23:13 +00:00
|
|
|
*
|
|
|
|
* cfs_rq.avg.util_avg is the sum of running time of runnable tasks plus the
|
|
|
|
* recent utilization of currently non-runnable tasks on a CPU. It represents
|
|
|
|
* the amount of utilization of a CPU in the range [0..capacity_orig] where
|
|
|
|
* capacity_orig is the cpu_capacity available at the highest frequency
|
|
|
|
* (arch_scale_freq_capacity()).
|
|
|
|
* The utilization of a CPU converges towards a sum equal to or less than the
|
|
|
|
* current capacity (capacity_curr <= capacity_orig) of the CPU because it is
|
|
|
|
* the running time on this CPU scaled by capacity_curr.
|
|
|
|
*
|
|
|
|
* Nevertheless, cfs_rq.avg.util_avg can be higher than capacity_curr or even
|
|
|
|
* higher than capacity_orig because of unfortunate rounding in
|
|
|
|
* cfs.avg.util_avg or just after migrating tasks and new task wakeups until
|
|
|
|
* the average stabilizes with the new running time. We need to check that the
|
|
|
|
* utilization stays within the range of [0..capacity_orig] and cap it if
|
|
|
|
* necessary. Without utilization capping, a group could be seen as overloaded
|
|
|
|
* (CPU0 utilization at 121% + CPU1 utilization at 80%) whereas CPU1 has 20% of
|
|
|
|
* available capacity. We allow utilization to overshoot capacity_curr (but not
|
|
|
|
* capacity_orig) as it useful for predicting the capacity required after task
|
|
|
|
* migrations (scheduler-driven DVFS).
|
2015-03-04 07:48:47 +00:00
|
|
|
*/
|
2017-12-05 17:10:15 +00:00
|
|
|
static unsigned long cpu_util(int cpu)
|
2015-03-04 07:48:47 +00:00
|
|
|
{
|
2015-08-14 16:23:12 +00:00
|
|
|
unsigned long util = cpu_rq(cpu)->cfs.avg.util_avg;
|
2015-03-04 07:48:47 +00:00
|
|
|
unsigned long capacity = capacity_orig_of(cpu);
|
|
|
|
|
2015-08-14 16:23:13 +00:00
|
|
|
return (util >= capacity) ? capacity : util;
|
2015-03-04 07:48:47 +00:00
|
|
|
}
|
2009-11-12 14:55:28 +00:00
|
|
|
|
2017-12-05 17:10:15 +00:00
|
|
|
static inline unsigned long task_util(struct task_struct *p)
|
2016-07-25 13:34:26 +00:00
|
|
|
{
|
|
|
|
return p->se.avg.util_avg;
|
|
|
|
}
|
|
|
|
|
2016-10-14 13:41:07 +00:00
|
|
|
/*
|
|
|
|
* cpu_util_wake: Compute cpu utilization with any contributions from
|
|
|
|
* the waking task p removed.
|
|
|
|
*/
|
2017-12-05 17:10:15 +00:00
|
|
|
static unsigned long cpu_util_wake(int cpu, struct task_struct *p)
|
2016-10-14 13:41:07 +00:00
|
|
|
{
|
|
|
|
unsigned long util, capacity;
|
|
|
|
|
|
|
|
/* Task has no contribution or is new */
|
|
|
|
if (cpu != task_cpu(p) || !p->se.avg.last_update_time)
|
|
|
|
return cpu_util(cpu);
|
|
|
|
|
|
|
|
capacity = capacity_orig_of(cpu);
|
|
|
|
util = max_t(long, cpu_rq(cpu)->cfs.avg.util_avg - task_util(p), 0);
|
|
|
|
|
|
|
|
return (util >= capacity) ? capacity : util;
|
|
|
|
}
|
|
|
|
|
2016-07-25 13:34:26 +00:00
|
|
|
/*
|
|
|
|
* Disable WAKE_AFFINE in the case where task @p doesn't fit in the
|
|
|
|
* capacity of either the waking CPU @cpu or the previous CPU @prev_cpu.
|
|
|
|
*
|
|
|
|
* In that case WAKE_AFFINE doesn't make sense and we'll let
|
|
|
|
* BALANCE_WAKE sort things out.
|
|
|
|
*/
|
|
|
|
static int wake_cap(struct task_struct *p, int cpu, int prev_cpu)
|
|
|
|
{
|
|
|
|
long min_cap, max_cap;
|
|
|
|
|
|
|
|
min_cap = min(capacity_orig_of(prev_cpu), capacity_orig_of(cpu));
|
|
|
|
max_cap = cpu_rq(cpu)->rd->max_cpu_capacity;
|
|
|
|
|
|
|
|
/* Minimum capacity is close to max, no need to abort wake_affine */
|
|
|
|
if (max_cap - min_cap < max_cap >> 3)
|
|
|
|
return 0;
|
|
|
|
|
2016-10-14 13:41:07 +00:00
|
|
|
/* Bring task utilization in sync with prev_cpu */
|
|
|
|
sync_entity_load_avg(&p->se);
|
|
|
|
|
2016-07-25 13:34:26 +00:00
|
|
|
return min_cap * 1024 < task_util(p) * capacity_margin;
|
|
|
|
}
|
|
|
|
|
2009-09-10 11:36:25 +00:00
|
|
|
/*
|
2014-02-18 14:14:24 +00:00
|
|
|
* select_task_rq_fair: Select target runqueue for the waking task in domains
|
|
|
|
* that have the 'sd_flag' flag set. In practice, this is SD_BALANCE_WAKE,
|
|
|
|
* SD_BALANCE_FORK, or SD_BALANCE_EXEC.
|
2009-09-10 11:36:25 +00:00
|
|
|
*
|
2014-02-18 14:14:24 +00:00
|
|
|
* Balances load by selecting the idlest cpu in the idlest group, or under
|
|
|
|
* certain conditions an idle sibling cpu if the domain has SD_WAKE_AFFINE set.
|
2009-09-10 11:36:25 +00:00
|
|
|
*
|
2014-02-18 14:14:24 +00:00
|
|
|
* Returns the target cpu number.
|
2009-09-10 11:36:25 +00:00
|
|
|
*
|
|
|
|
* preempt must be disabled.
|
|
|
|
*/
|
2010-03-24 17:34:10 +00:00
|
|
|
static int
|
2013-10-07 10:29:16 +00:00
|
|
|
select_task_rq_fair(struct task_struct *p, int prev_cpu, int sd_flag, int wake_flags)
|
2009-09-10 11:36:25 +00:00
|
|
|
{
|
2009-09-17 07:01:14 +00:00
|
|
|
struct sched_domain *tmp, *affine_sd = NULL, *sd = NULL;
|
sched: Merge select_task_rq_fair() and sched_balance_self()
The problem with wake_idle() is that is doesn't respect things like
cpu_power, which means it doesn't deal well with SMT nor the recent
RT interaction.
To cure this, it needs to do what sched_balance_self() does, which
leads to the possibility of merging select_task_rq_fair() and
sched_balance_self().
Modify sched_balance_self() to:
- update_shares() when walking up the domain tree,
(it only called it for the top domain, but it should
have done this anyway), which allows us to remove
this ugly bit from try_to_wake_up().
- do wake_affine() on the smallest domain that contains
both this (the waking) and the prev (the wakee) cpu for
WAKE invocations.
Then use the top-down balance steps it had to replace wake_idle().
This leads to the dissapearance of SD_WAKE_BALANCE and
SD_WAKE_IDLE_FAR, with SD_WAKE_IDLE replaced with SD_BALANCE_WAKE.
SD_WAKE_AFFINE needs SD_BALANCE_WAKE to be effective.
Touch all topology bits to replace the old with new SD flags --
platforms might need re-tuning, enabling SD_BALANCE_WAKE
conditionally on a NUMA distance seems like a good additional
feature, magny-core and small nehalem systems would want this
enabled, systems with slow interconnects would not.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-09-10 11:50:02 +00:00
|
|
|
int cpu = smp_processor_id();
|
2015-07-14 15:39:50 +00:00
|
|
|
int new_cpu = prev_cpu;
|
2010-03-31 23:47:45 +00:00
|
|
|
int want_affine = 0;
|
2009-09-16 11:46:59 +00:00
|
|
|
int sync = wake_flags & WF_SYNC;
|
sched: Merge select_task_rq_fair() and sched_balance_self()
The problem with wake_idle() is that is doesn't respect things like
cpu_power, which means it doesn't deal well with SMT nor the recent
RT interaction.
To cure this, it needs to do what sched_balance_self() does, which
leads to the possibility of merging select_task_rq_fair() and
sched_balance_self().
Modify sched_balance_self() to:
- update_shares() when walking up the domain tree,
(it only called it for the top domain, but it should
have done this anyway), which allows us to remove
this ugly bit from try_to_wake_up().
- do wake_affine() on the smallest domain that contains
both this (the waking) and the prev (the wakee) cpu for
WAKE invocations.
Then use the top-down balance steps it had to replace wake_idle().
This leads to the dissapearance of SD_WAKE_BALANCE and
SD_WAKE_IDLE_FAR, with SD_WAKE_IDLE replaced with SD_BALANCE_WAKE.
SD_WAKE_AFFINE needs SD_BALANCE_WAKE to be effective.
Touch all topology bits to replace the old with new SD flags --
platforms might need re-tuning, enabling SD_BALANCE_WAKE
conditionally on a NUMA distance seems like a good additional
feature, magny-core and small nehalem systems would want this
enabled, systems with slow interconnects would not.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-09-10 11:50:02 +00:00
|
|
|
|
2016-05-12 07:19:59 +00:00
|
|
|
if (sd_flag & SD_BALANCE_WAKE) {
|
|
|
|
record_wakee(p);
|
2016-07-25 13:34:26 +00:00
|
|
|
want_affine = !wake_wide(p) && !wake_cap(p, cpu, prev_cpu)
|
2017-02-05 14:38:10 +00:00
|
|
|
&& cpumask_test_cpu(cpu, &p->cpus_allowed);
|
2016-05-12 07:19:59 +00:00
|
|
|
}
|
2009-09-10 11:36:25 +00:00
|
|
|
|
2011-04-07 12:09:50 +00:00
|
|
|
rcu_read_lock();
|
2009-09-10 11:36:25 +00:00
|
|
|
for_each_domain(cpu, tmp) {
|
2009-12-16 17:04:34 +00:00
|
|
|
if (!(tmp->flags & SD_LOAD_BALANCE))
|
2015-07-14 15:39:50 +00:00
|
|
|
break;
|
2009-12-16 17:04:34 +00:00
|
|
|
|
2009-11-12 14:55:29 +00:00
|
|
|
/*
|
2010-03-31 23:47:45 +00:00
|
|
|
* If both cpu and prev_cpu are part of this domain,
|
|
|
|
* cpu is a valid SD_WAKE_AFFINE target.
|
2009-11-12 14:55:29 +00:00
|
|
|
*/
|
2010-03-31 23:47:45 +00:00
|
|
|
if (want_affine && (tmp->flags & SD_WAKE_AFFINE) &&
|
|
|
|
cpumask_test_cpu(prev_cpu, sched_domain_span(tmp))) {
|
|
|
|
affine_sd = tmp;
|
2009-09-17 07:01:14 +00:00
|
|
|
break;
|
2012-07-26 00:55:34 +00:00
|
|
|
}
|
2009-09-17 07:01:14 +00:00
|
|
|
|
2012-07-26 00:55:34 +00:00
|
|
|
if (tmp->flags & sd_flag)
|
2009-09-17 07:01:14 +00:00
|
|
|
sd = tmp;
|
2015-07-14 15:39:50 +00:00
|
|
|
else if (!want_affine)
|
|
|
|
break;
|
2009-09-17 07:01:14 +00:00
|
|
|
}
|
|
|
|
|
2015-07-14 15:39:50 +00:00
|
|
|
if (affine_sd) {
|
|
|
|
sd = NULL; /* Prefer wake_affine over balance flags */
|
2017-06-23 16:55:28 +00:00
|
|
|
if (cpu == prev_cpu)
|
|
|
|
goto pick_cpu;
|
|
|
|
|
2018-01-30 10:45:53 +00:00
|
|
|
new_cpu = wake_affine(affine_sd, p, prev_cpu, sync);
|
2010-03-11 16:17:16 +00:00
|
|
|
}
|
2008-01-25 20:08:09 +00:00
|
|
|
|
2017-10-05 10:55:51 +00:00
|
|
|
if (sd && !(sd_flag & SD_BALANCE_FORK)) {
|
|
|
|
/*
|
|
|
|
* We're going to need the task's util for capacity_spare_wake
|
|
|
|
* in find_idlest_group. Sync it up to prev_cpu's
|
|
|
|
* last_update_time.
|
|
|
|
*/
|
|
|
|
sync_entity_load_avg(&p->se);
|
|
|
|
}
|
|
|
|
|
2015-07-14 15:39:50 +00:00
|
|
|
if (!sd) {
|
2017-10-05 10:55:51 +00:00
|
|
|
pick_cpu:
|
2018-01-30 10:45:55 +00:00
|
|
|
if (sd_flag & SD_BALANCE_WAKE) { /* XXX always ? */
|
2016-06-22 17:03:13 +00:00
|
|
|
new_cpu = select_idle_sibling(p, prev_cpu, new_cpu);
|
2015-07-14 15:39:50 +00:00
|
|
|
|
2018-01-30 10:45:55 +00:00
|
|
|
if (want_affine)
|
|
|
|
current->recent_used_cpu = cpu;
|
|
|
|
}
|
2017-10-05 11:45:12 +00:00
|
|
|
} else {
|
|
|
|
new_cpu = find_idlest_cpu(sd, p, cpu, prev_cpu, sd_flag);
|
2008-01-25 20:08:09 +00:00
|
|
|
}
|
2011-04-07 12:09:50 +00:00
|
|
|
rcu_read_unlock();
|
2008-01-25 20:08:09 +00:00
|
|
|
|
sched: Merge select_task_rq_fair() and sched_balance_self()
The problem with wake_idle() is that is doesn't respect things like
cpu_power, which means it doesn't deal well with SMT nor the recent
RT interaction.
To cure this, it needs to do what sched_balance_self() does, which
leads to the possibility of merging select_task_rq_fair() and
sched_balance_self().
Modify sched_balance_self() to:
- update_shares() when walking up the domain tree,
(it only called it for the top domain, but it should
have done this anyway), which allows us to remove
this ugly bit from try_to_wake_up().
- do wake_affine() on the smallest domain that contains
both this (the waking) and the prev (the wakee) cpu for
WAKE invocations.
Then use the top-down balance steps it had to replace wake_idle().
This leads to the dissapearance of SD_WAKE_BALANCE and
SD_WAKE_IDLE_FAR, with SD_WAKE_IDLE replaced with SD_BALANCE_WAKE.
SD_WAKE_AFFINE needs SD_BALANCE_WAKE to be effective.
Touch all topology bits to replace the old with new SD flags --
platforms might need re-tuning, enabling SD_BALANCE_WAKE
conditionally on a NUMA distance seems like a good additional
feature, magny-core and small nehalem systems would want this
enabled, systems with slow interconnects would not.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-09-10 11:50:02 +00:00
|
|
|
return new_cpu;
|
2008-01-25 20:08:09 +00:00
|
|
|
}
|
2012-10-04 11:18:30 +00:00
|
|
|
|
2017-05-11 15:57:24 +00:00
|
|
|
static void detach_entity_cfs_rq(struct sched_entity *se);
|
|
|
|
|
2012-10-04 11:18:30 +00:00
|
|
|
/*
|
|
|
|
* Called immediately before a task is migrated to a new cpu; task_cpu(p) and
|
|
|
|
* cfs_rq_of(p) references at time of call are still valid and identify the
|
2015-11-18 00:34:59 +00:00
|
|
|
* previous cpu. The caller guarantees p->pi_lock or task_rq(p)->lock is held.
|
2012-10-04 11:18:30 +00:00
|
|
|
*/
|
2015-09-23 06:55:59 +00:00
|
|
|
static void migrate_task_rq_fair(struct task_struct *p)
|
2012-10-04 11:18:30 +00:00
|
|
|
{
|
2016-05-10 16:24:37 +00:00
|
|
|
/*
|
|
|
|
* As blocked tasks retain absolute vruntime the migration needs to
|
|
|
|
* deal with this by subtracting the old and adding the new
|
|
|
|
* min_vruntime -- the latter is done by enqueue_entity() when placing
|
|
|
|
* the task on the new runqueue.
|
|
|
|
*/
|
|
|
|
if (p->state == TASK_WAKING) {
|
|
|
|
struct sched_entity *se = &p->se;
|
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
|
|
|
u64 min_vruntime;
|
|
|
|
|
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
u64 min_vruntime_copy;
|
|
|
|
|
|
|
|
do {
|
|
|
|
min_vruntime_copy = cfs_rq->min_vruntime_copy;
|
|
|
|
smp_rmb();
|
|
|
|
min_vruntime = cfs_rq->min_vruntime;
|
|
|
|
} while (min_vruntime != min_vruntime_copy);
|
|
|
|
#else
|
|
|
|
min_vruntime = cfs_rq->min_vruntime;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
se->vruntime -= min_vruntime;
|
|
|
|
}
|
|
|
|
|
2017-05-11 15:57:24 +00:00
|
|
|
if (p->on_rq == TASK_ON_RQ_MIGRATING) {
|
|
|
|
/*
|
|
|
|
* In case of TASK_ON_RQ_MIGRATING we in fact hold the 'old'
|
|
|
|
* rq->lock and can modify state directly.
|
|
|
|
*/
|
|
|
|
lockdep_assert_held(&task_rq(p)->lock);
|
|
|
|
detach_entity_cfs_rq(&p->se);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We are supposed to update the task to "current" time, then
|
|
|
|
* its up to date and ready to go to new CPU/cfs_rq. But we
|
|
|
|
* have difficulty in getting what current time is, so simply
|
|
|
|
* throw away the out-of-date time. This will result in the
|
|
|
|
* wakee task is less decayed, but giving the wakee more load
|
|
|
|
* sounds not bad.
|
|
|
|
*/
|
|
|
|
remove_entity_load_avg(&p->se);
|
|
|
|
}
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
|
|
|
|
/* Tell new CPU we are migrated */
|
|
|
|
p->se.avg.last_update_time = 0;
|
2014-05-15 22:59:20 +00:00
|
|
|
|
|
|
|
/* We have migrated, no longer consider this task hot */
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
p->se.exec_start = 0;
|
2012-10-04 11:18:30 +00:00
|
|
|
}
|
2015-07-15 00:04:40 +00:00
|
|
|
|
|
|
|
static void task_dead_fair(struct task_struct *p)
|
|
|
|
{
|
|
|
|
remove_entity_load_avg(&p->se);
|
|
|
|
}
|
2008-01-25 20:08:09 +00:00
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
2017-12-07 13:30:43 +00:00
|
|
|
static unsigned long wakeup_gran(struct sched_entity *se)
|
2008-04-19 17:44:57 +00:00
|
|
|
{
|
|
|
|
unsigned long gran = sysctl_sched_wakeup_granularity;
|
|
|
|
|
|
|
|
/*
|
2009-01-14 11:39:19 +00:00
|
|
|
* Since its curr running now, convert the gran from real-time
|
|
|
|
* to virtual-time in his units.
|
2010-03-11 16:17:04 +00:00
|
|
|
*
|
|
|
|
* By using 'se' instead of 'curr' we penalize light tasks, so
|
|
|
|
* they get preempted easier. That is, if 'se' < 'curr' then
|
|
|
|
* the resulting gran will be larger, therefore penalizing the
|
|
|
|
* lighter, if otoh 'se' > 'curr' then the resulting gran will
|
|
|
|
* be smaller, again penalizing the lighter task.
|
|
|
|
*
|
|
|
|
* This is especially important for buddies when the leftmost
|
|
|
|
* task is higher priority than the buddy.
|
2008-04-19 17:44:57 +00:00
|
|
|
*/
|
2011-04-08 04:53:09 +00:00
|
|
|
return calc_delta_fair(gran, se);
|
2008-04-19 17:44:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-24 09:06:15 +00:00
|
|
|
/*
|
|
|
|
* Should 'se' preempt 'curr'.
|
|
|
|
*
|
|
|
|
* |s1
|
|
|
|
* |s2
|
|
|
|
* |s3
|
|
|
|
* g
|
|
|
|
* |<--->|c
|
|
|
|
*
|
|
|
|
* w(c, s1) = -1
|
|
|
|
* w(c, s2) = 0
|
|
|
|
* w(c, s3) = 1
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se)
|
|
|
|
{
|
|
|
|
s64 gran, vdiff = curr->vruntime - se->vruntime;
|
|
|
|
|
|
|
|
if (vdiff <= 0)
|
|
|
|
return -1;
|
|
|
|
|
2017-12-07 13:30:43 +00:00
|
|
|
gran = wakeup_gran(se);
|
2008-10-24 09:06:15 +00:00
|
|
|
if (vdiff > gran)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-04 20:25:10 +00:00
|
|
|
static void set_last_buddy(struct sched_entity *se)
|
|
|
|
{
|
2011-04-14 01:21:09 +00:00
|
|
|
if (entity_is_task(se) && unlikely(task_of(se)->policy == SCHED_IDLE))
|
|
|
|
return;
|
|
|
|
|
2017-05-10 20:11:39 +00:00
|
|
|
for_each_sched_entity(se) {
|
|
|
|
if (SCHED_WARN_ON(!se->on_rq))
|
|
|
|
return;
|
2011-04-14 01:21:09 +00:00
|
|
|
cfs_rq_of(se)->last = se;
|
2017-05-10 20:11:39 +00:00
|
|
|
}
|
2008-11-04 20:25:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void set_next_buddy(struct sched_entity *se)
|
|
|
|
{
|
2011-04-14 01:21:09 +00:00
|
|
|
if (entity_is_task(se) && unlikely(task_of(se)->policy == SCHED_IDLE))
|
|
|
|
return;
|
|
|
|
|
2017-05-10 20:11:39 +00:00
|
|
|
for_each_sched_entity(se) {
|
|
|
|
if (SCHED_WARN_ON(!se->on_rq))
|
|
|
|
return;
|
2011-04-14 01:21:09 +00:00
|
|
|
cfs_rq_of(se)->next = se;
|
2017-05-10 20:11:39 +00:00
|
|
|
}
|
2008-11-04 20:25:10 +00:00
|
|
|
}
|
|
|
|
|
2011-02-01 14:51:03 +00:00
|
|
|
static void set_skip_buddy(struct sched_entity *se)
|
|
|
|
{
|
2011-04-14 01:21:09 +00:00
|
|
|
for_each_sched_entity(se)
|
|
|
|
cfs_rq_of(se)->skip = se;
|
2011-02-01 14:51:03 +00:00
|
|
|
}
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
|
|
|
* Preempt the current task with a newly woken task if needed:
|
|
|
|
*/
|
2009-09-16 11:47:58 +00:00
|
|
|
static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_flags)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
|
|
|
struct task_struct *curr = rq->curr;
|
2007-10-15 15:00:12 +00:00
|
|
|
struct sched_entity *se = &curr->se, *pse = &p->se;
|
2008-12-16 07:45:30 +00:00
|
|
|
struct cfs_rq *cfs_rq = task_cfs_rq(curr);
|
sched: Strengthen buddies and mitigate buddy induced latencies
This patch restores the effectiveness of LAST_BUDDY in preventing
pgsql+oltp from collapsing due to wakeup preemption. It also
switches LAST_BUDDY to exclusively do what it does best, namely
mitigate the effects of aggressive wakeup preemption, which
improves vmark throughput markedly, and restores mysql+oltp
scalability.
Since buddies are about scalability, enable them beginning at the
point where we begin expanding sched_latency, namely
sched_nr_latency. Previously, buddies were cleared aggressively,
which seriously reduced their effectiveness. Not clearing
aggressively however, produces a small drop in mysql+oltp
throughput immediately after peak, indicating that LAST_BUDDY is
actually doing some harm. This is right at the point where X on the
desktop in competition with another load wants low latency service.
Ergo, do not enable until we need to scale.
To mitigate latency induced by buddies, or by a task just missing
wakeup preemption, check latency at tick time.
Last hunk prevents buddies from stymieing BALANCE_NEWIDLE via
CACHE_HOT_BUDDY.
Supporting performance tests:
tip = v2.6.32-rc5-1497-ga525b32
tipx = NO_GENTLE_FAIR_SLEEPERS NEXT_BUDDY granularity knobs = 31 knobs + 31 buddies
tip+x = NO_GENTLE_FAIR_SLEEPERS granularity knobs = 31 knobs
(Three run averages except where noted.)
vmark:
------
tip 108466 messages per second
tip+ 125307 messages per second
tip+x 125335 messages per second
tipx 117781 messages per second
2.6.31.3 122729 messages per second
mysql+oltp:
-----------
clients 1 2 4 8 16 32 64 128 256
..........................................................................................
tip 9949.89 18690.20 34801.24 34460.04 32682.88 30765.97 28305.27 25059.64 19548.08
tip+ 10013.90 18526.84 34900.38 34420.14 33069.83 32083.40 30578.30 28010.71 25605.47
tipx 9698.71 18002.70 34477.56 33420.01 32634.30 31657.27 29932.67 26827.52 21487.18
2.6.31.3 8243.11 18784.20 34404.83 33148.38 31900.32 31161.90 29663.81 25995.94 18058.86
pgsql+oltp:
-----------
clients 1 2 4 8 16 32 64 128 256
..........................................................................................
tip 13686.37 26609.25 51934.28 51347.81 49479.51 45312.65 36691.91 26851.57 24145.35
tip+ (1x) 13907.85 27135.87 52951.98 52514.04 51742.52 50705.43 49947.97 48374.19 46227.94
tip+x 13906.78 27065.81 52951.19 52542.59 52176.11 51815.94 50838.90 49439.46 46891.00
tipx 13742.46 26769.81 52351.99 51891.73 51320.79 50938.98 50248.65 48908.70 46553.84
2.6.31.3 13815.35 26906.46 52683.34 52061.31 51937.10 51376.80 50474.28 49394.47 47003.25
Signed-off-by: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-23 21:09:22 +00:00
|
|
|
int scale = cfs_rq->nr_running >= sched_nr_latency;
|
2011-04-14 17:30:53 +00:00
|
|
|
int next_buddy_marked = 0;
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2008-03-19 00:42:00 +00:00
|
|
|
if (unlikely(se == pse))
|
|
|
|
return;
|
|
|
|
|
2011-07-21 16:43:37 +00:00
|
|
|
/*
|
2014-08-20 09:48:29 +00:00
|
|
|
* This is possible from callers such as attach_tasks(), in which we
|
2011-07-21 16:43:37 +00:00
|
|
|
* unconditionally check_prempt_curr() after an enqueue (which may have
|
|
|
|
* lead to a throttle). This both saves work and prevents false
|
|
|
|
* next-buddy nomination below.
|
|
|
|
*/
|
|
|
|
if (unlikely(throttled_hierarchy(cfs_rq_of(pse))))
|
|
|
|
return;
|
|
|
|
|
2011-04-14 17:30:53 +00:00
|
|
|
if (sched_feat(NEXT_BUDDY) && scale && !(wake_flags & WF_FORK)) {
|
2009-09-11 10:01:17 +00:00
|
|
|
set_next_buddy(pse);
|
2011-04-14 17:30:53 +00:00
|
|
|
next_buddy_marked = 1;
|
|
|
|
}
|
2008-09-23 13:33:45 +00:00
|
|
|
|
2008-08-28 09:12:49 +00:00
|
|
|
/*
|
|
|
|
* We can come here with TIF_NEED_RESCHED already set from new task
|
|
|
|
* wake up path.
|
2011-07-21 16:43:37 +00:00
|
|
|
*
|
|
|
|
* Note: this also catches the edge-case of curr being in a throttled
|
|
|
|
* group (e.g. via set_curr_task), since update_curr() (in the
|
|
|
|
* enqueue of curr) will have resulted in resched being set. This
|
|
|
|
* prevents us from potentially nominating it as a false LAST_BUDDY
|
|
|
|
* below.
|
2008-08-28 09:12:49 +00:00
|
|
|
*/
|
|
|
|
if (test_tsk_need_resched(curr))
|
|
|
|
return;
|
|
|
|
|
2011-02-22 21:04:33 +00:00
|
|
|
/* Idle tasks are by definition preempted by non-idle tasks. */
|
|
|
|
if (unlikely(curr->policy == SCHED_IDLE) &&
|
|
|
|
likely(p->policy != SCHED_IDLE))
|
|
|
|
goto preempt;
|
|
|
|
|
2007-10-15 15:00:18 +00:00
|
|
|
/*
|
2011-02-22 21:04:33 +00:00
|
|
|
* Batch and idle tasks do not preempt non-idle tasks (their preemption
|
|
|
|
* is driven by the tick):
|
2007-10-15 15:00:18 +00:00
|
|
|
*/
|
2012-10-14 12:28:50 +00:00
|
|
|
if (unlikely(p->policy != SCHED_NORMAL) || !sched_feat(WAKEUP_PREEMPTION))
|
2007-10-15 15:00:18 +00:00
|
|
|
return;
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2008-10-24 09:06:15 +00:00
|
|
|
find_matching_se(&se, &pse);
|
2011-07-06 02:07:21 +00:00
|
|
|
update_curr(cfs_rq_of(se));
|
2009-04-08 22:29:43 +00:00
|
|
|
BUG_ON(!pse);
|
2011-04-14 17:30:53 +00:00
|
|
|
if (wakeup_preempt_entity(se, pse) == 1) {
|
|
|
|
/*
|
|
|
|
* Bias pick_next to pick the sched entity that is
|
|
|
|
* triggering this preemption.
|
|
|
|
*/
|
|
|
|
if (!next_buddy_marked)
|
|
|
|
set_next_buddy(pse);
|
2009-11-28 17:51:02 +00:00
|
|
|
goto preempt;
|
2011-04-14 17:30:53 +00:00
|
|
|
}
|
2008-10-24 09:06:15 +00:00
|
|
|
|
2009-11-28 17:51:02 +00:00
|
|
|
return;
|
2009-11-17 09:51:40 +00:00
|
|
|
|
2009-11-28 17:51:02 +00:00
|
|
|
preempt:
|
2014-06-28 20:03:57 +00:00
|
|
|
resched_curr(rq);
|
2009-11-28 17:51:02 +00:00
|
|
|
/*
|
|
|
|
* Only set the backward buddy when the current task is still
|
|
|
|
* on the rq. This can happen when a wakeup gets interleaved
|
|
|
|
* with schedule on the ->pre_schedule() or idle_balance()
|
|
|
|
* point, either of which can * drop the rq lock.
|
|
|
|
*
|
|
|
|
* Also, during early boot the idle thread is in the fair class,
|
|
|
|
* for obvious reasons its a bad idea to schedule back to it.
|
|
|
|
*/
|
|
|
|
if (unlikely(!se->on_rq || curr == rq->idle))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (sched_feat(LAST_BUDDY) && scale && entity_is_task(se))
|
|
|
|
set_last_buddy(se);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2012-02-11 05:05:00 +00:00
|
|
|
static struct task_struct *
|
2016-09-21 13:38:10 +00:00
|
|
|
pick_next_task_fair(struct rq *rq, struct task_struct *prev, struct rq_flags *rf)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
|
|
|
struct cfs_rq *cfs_rq = &rq->cfs;
|
|
|
|
struct sched_entity *se;
|
2012-02-11 05:05:00 +00:00
|
|
|
struct task_struct *p;
|
2014-02-14 11:25:08 +00:00
|
|
|
int new_tasks;
|
2012-02-11 05:05:00 +00:00
|
|
|
|
2014-02-11 15:11:48 +00:00
|
|
|
again:
|
2012-02-11 05:05:00 +00:00
|
|
|
if (!cfs_rq->nr_running)
|
2014-01-23 19:32:21 +00:00
|
|
|
goto idle;
|
2012-02-11 05:05:00 +00:00
|
|
|
|
2017-05-24 05:29:55 +00:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2014-02-12 09:49:30 +00:00
|
|
|
if (prev->sched_class != &fair_sched_class)
|
2012-02-11 05:05:00 +00:00
|
|
|
goto simple;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Because of the set_next_buddy() in dequeue_task_fair() it is rather
|
|
|
|
* likely that a next task is from the same cgroup as the current.
|
|
|
|
*
|
|
|
|
* Therefore attempt to avoid putting and setting the entire cgroup
|
|
|
|
* hierarchy, only change the part that actually changes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
do {
|
|
|
|
struct sched_entity *curr = cfs_rq->curr;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since we got here without doing put_prev_entity() we also
|
|
|
|
* have to consider cfs_rq->curr. If it is still a runnable
|
|
|
|
* entity, update_curr() will update its vruntime, otherwise
|
|
|
|
* forget we've ever seen it.
|
|
|
|
*/
|
2015-04-06 22:28:10 +00:00
|
|
|
if (curr) {
|
|
|
|
if (curr->on_rq)
|
|
|
|
update_curr(cfs_rq);
|
|
|
|
else
|
|
|
|
curr = NULL;
|
2012-02-11 05:05:00 +00:00
|
|
|
|
2015-04-06 22:28:10 +00:00
|
|
|
/*
|
|
|
|
* This call to check_cfs_rq_runtime() will do the
|
|
|
|
* throttle and dequeue its entity in the parent(s).
|
2017-05-24 05:29:55 +00:00
|
|
|
* Therefore the nr_running test will indeed
|
2015-04-06 22:28:10 +00:00
|
|
|
* be correct.
|
|
|
|
*/
|
2017-05-24 05:29:55 +00:00
|
|
|
if (unlikely(check_cfs_rq_runtime(cfs_rq))) {
|
|
|
|
cfs_rq = &rq->cfs;
|
|
|
|
|
|
|
|
if (!cfs_rq->nr_running)
|
|
|
|
goto idle;
|
|
|
|
|
2015-04-06 22:28:10 +00:00
|
|
|
goto simple;
|
2017-05-24 05:29:55 +00:00
|
|
|
}
|
2015-04-06 22:28:10 +00:00
|
|
|
}
|
2012-02-11 05:05:00 +00:00
|
|
|
|
|
|
|
se = pick_next_entity(cfs_rq, curr);
|
|
|
|
cfs_rq = group_cfs_rq(se);
|
|
|
|
} while (cfs_rq);
|
|
|
|
|
|
|
|
p = task_of(se);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since we haven't yet done put_prev_entity and if the selected task
|
|
|
|
* is a different task than we started out with, try and touch the
|
|
|
|
* least amount of cfs_rqs.
|
|
|
|
*/
|
|
|
|
if (prev != p) {
|
|
|
|
struct sched_entity *pse = &prev->se;
|
|
|
|
|
|
|
|
while (!(cfs_rq = is_same_group(se, pse))) {
|
|
|
|
int se_depth = se->depth;
|
|
|
|
int pse_depth = pse->depth;
|
|
|
|
|
|
|
|
if (se_depth <= pse_depth) {
|
|
|
|
put_prev_entity(cfs_rq_of(pse), pse);
|
|
|
|
pse = parent_entity(pse);
|
|
|
|
}
|
|
|
|
if (se_depth >= pse_depth) {
|
|
|
|
set_next_entity(cfs_rq_of(se), se);
|
|
|
|
se = parent_entity(se);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
put_prev_entity(cfs_rq, pse);
|
|
|
|
set_next_entity(cfs_rq, se);
|
|
|
|
}
|
|
|
|
|
2017-09-13 10:24:30 +00:00
|
|
|
goto done;
|
2012-02-11 05:05:00 +00:00
|
|
|
simple:
|
|
|
|
#endif
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2014-02-12 09:49:30 +00:00
|
|
|
put_prev_task(rq, prev);
|
2012-02-11 05:05:00 +00:00
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
do {
|
2012-02-11 05:05:00 +00:00
|
|
|
se = pick_next_entity(cfs_rq, NULL);
|
2008-11-04 20:25:07 +00:00
|
|
|
set_next_entity(cfs_rq, se);
|
2007-07-09 16:51:58 +00:00
|
|
|
cfs_rq = group_cfs_rq(se);
|
|
|
|
} while (cfs_rq);
|
|
|
|
|
2008-01-25 20:08:29 +00:00
|
|
|
p = task_of(se);
|
2012-02-11 05:05:00 +00:00
|
|
|
|
2017-09-13 10:24:30 +00:00
|
|
|
done: __maybe_unused
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/*
|
|
|
|
* Move the next running task to the front of
|
|
|
|
* the list, so our cfs_tasks list becomes MRU
|
|
|
|
* one.
|
|
|
|
*/
|
|
|
|
list_move(&p->se.group_node, &rq->cfs_tasks);
|
|
|
|
#endif
|
|
|
|
|
2011-11-22 14:20:07 +00:00
|
|
|
if (hrtick_enabled(rq))
|
|
|
|
hrtick_start_fair(rq, p);
|
2008-01-25 20:08:29 +00:00
|
|
|
|
|
|
|
return p;
|
2014-01-23 19:32:21 +00:00
|
|
|
|
|
|
|
idle:
|
2016-09-21 13:38:12 +00:00
|
|
|
new_tasks = idle_balance(rq, rf);
|
|
|
|
|
2014-02-14 11:25:08 +00:00
|
|
|
/*
|
|
|
|
* Because idle_balance() releases (and re-acquires) rq->lock, it is
|
|
|
|
* possible for any higher priority task to appear. In that case we
|
|
|
|
* must re-start the pick_next_entity() loop.
|
|
|
|
*/
|
2014-03-06 09:31:55 +00:00
|
|
|
if (new_tasks < 0)
|
2014-02-14 11:25:08 +00:00
|
|
|
return RETRY_TASK;
|
|
|
|
|
2014-03-06 09:31:55 +00:00
|
|
|
if (new_tasks > 0)
|
2014-01-23 19:32:21 +00:00
|
|
|
goto again;
|
|
|
|
|
|
|
|
return NULL;
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Account for a descheduled task:
|
|
|
|
*/
|
2007-08-09 09:16:49 +00:00
|
|
|
static void put_prev_task_fair(struct rq *rq, struct task_struct *prev)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
|
|
|
struct sched_entity *se = &prev->se;
|
|
|
|
struct cfs_rq *cfs_rq;
|
|
|
|
|
|
|
|
for_each_sched_entity(se) {
|
|
|
|
cfs_rq = cfs_rq_of(se);
|
2007-08-09 09:16:48 +00:00
|
|
|
put_prev_entity(cfs_rq, se);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-01 14:51:03 +00:00
|
|
|
/*
|
|
|
|
* sched_yield() is very simple
|
|
|
|
*
|
|
|
|
* The magic of dealing with the ->skip buddy is in pick_next_entity.
|
|
|
|
*/
|
|
|
|
static void yield_task_fair(struct rq *rq)
|
|
|
|
{
|
|
|
|
struct task_struct *curr = rq->curr;
|
|
|
|
struct cfs_rq *cfs_rq = task_cfs_rq(curr);
|
|
|
|
struct sched_entity *se = &curr->se;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Are we the only task in the tree?
|
|
|
|
*/
|
|
|
|
if (unlikely(rq->nr_running == 1))
|
|
|
|
return;
|
|
|
|
|
|
|
|
clear_buddies(cfs_rq, se);
|
|
|
|
|
|
|
|
if (curr->policy != SCHED_BATCH) {
|
|
|
|
update_rq_clock(rq);
|
|
|
|
/*
|
|
|
|
* Update run-time statistics of the 'current'.
|
|
|
|
*/
|
|
|
|
update_curr(cfs_rq);
|
2011-11-22 14:21:26 +00:00
|
|
|
/*
|
|
|
|
* Tell update_rq_clock() that we've just updated,
|
|
|
|
* so we don't do microscopic update in schedule()
|
|
|
|
* and double the fastpath cost.
|
|
|
|
*/
|
2015-01-05 10:18:11 +00:00
|
|
|
rq_clock_skip_update(rq, true);
|
2011-02-01 14:51:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
set_skip_buddy(se);
|
|
|
|
}
|
|
|
|
|
2011-02-01 14:50:51 +00:00
|
|
|
static bool yield_to_task_fair(struct rq *rq, struct task_struct *p, bool preempt)
|
|
|
|
{
|
|
|
|
struct sched_entity *se = &p->se;
|
|
|
|
|
2011-07-21 16:43:37 +00:00
|
|
|
/* throttled hierarchies are not runnable */
|
|
|
|
if (!se->on_rq || throttled_hierarchy(cfs_rq_of(se)))
|
2011-02-01 14:50:51 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Tell the scheduler that we'd really like pse to run next. */
|
|
|
|
set_next_buddy(se);
|
|
|
|
|
|
|
|
yield_task_fair(rq);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2007-10-24 16:23:51 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2007-07-09 16:51:58 +00:00
|
|
|
/**************************************************
|
2012-07-03 11:53:26 +00:00
|
|
|
* Fair scheduling class load-balancing methods.
|
|
|
|
*
|
|
|
|
* BASICS
|
|
|
|
*
|
|
|
|
* The purpose of load-balancing is to achieve the same basic fairness the
|
|
|
|
* per-cpu scheduler provides, namely provide a proportional amount of compute
|
|
|
|
* time to each task. This is expressed in the following equation:
|
|
|
|
*
|
|
|
|
* W_i,n/P_i == W_j,n/P_j for all i,j (1)
|
|
|
|
*
|
|
|
|
* Where W_i,n is the n-th weight average for cpu i. The instantaneous weight
|
|
|
|
* W_i,0 is defined as:
|
|
|
|
*
|
|
|
|
* W_i,0 = \Sum_j w_i,j (2)
|
|
|
|
*
|
|
|
|
* Where w_i,j is the weight of the j-th runnable task on cpu i. This weight
|
2016-03-29 23:07:51 +00:00
|
|
|
* is derived from the nice value as per sched_prio_to_weight[].
|
2012-07-03 11:53:26 +00:00
|
|
|
*
|
|
|
|
* The weight average is an exponential decay average of the instantaneous
|
|
|
|
* weight:
|
|
|
|
*
|
|
|
|
* W'_i,n = (2^n - 1) / 2^n * W_i,n + 1 / 2^n * W_i,0 (3)
|
|
|
|
*
|
2014-05-26 22:19:38 +00:00
|
|
|
* C_i is the compute capacity of cpu i, typically it is the
|
2012-07-03 11:53:26 +00:00
|
|
|
* fraction of 'recent' time available for SCHED_OTHER task execution. But it
|
|
|
|
* can also include other factors [XXX].
|
|
|
|
*
|
|
|
|
* To achieve this balance we define a measure of imbalance which follows
|
|
|
|
* directly from (1):
|
|
|
|
*
|
2014-05-26 22:19:38 +00:00
|
|
|
* imb_i,j = max{ avg(W/C), W_i/C_i } - min{ avg(W/C), W_j/C_j } (4)
|
2012-07-03 11:53:26 +00:00
|
|
|
*
|
|
|
|
* We them move tasks around to minimize the imbalance. In the continuous
|
|
|
|
* function space it is obvious this converges, in the discrete case we get
|
|
|
|
* a few fun cases generally called infeasible weight scenarios.
|
|
|
|
*
|
|
|
|
* [XXX expand on:
|
|
|
|
* - infeasible weights;
|
|
|
|
* - local vs global optima in the discrete case. ]
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* SCHED DOMAINS
|
|
|
|
*
|
|
|
|
* In order to solve the imbalance equation (4), and avoid the obvious O(n^2)
|
|
|
|
* for all i,j solution, we create a tree of cpus that follows the hardware
|
|
|
|
* topology where each level pairs two lower groups (or better). This results
|
|
|
|
* in O(log n) layers. Furthermore we reduce the number of cpus going up the
|
|
|
|
* tree to only the first of the previous level and we decrease the frequency
|
|
|
|
* of load-balance at each level inv. proportional to the number of cpus in
|
|
|
|
* the groups.
|
|
|
|
*
|
|
|
|
* This yields:
|
|
|
|
*
|
|
|
|
* log_2 n 1 n
|
|
|
|
* \Sum { --- * --- * 2^i } = O(n) (5)
|
|
|
|
* i = 0 2^i 2^i
|
|
|
|
* `- size of each group
|
|
|
|
* | | `- number of cpus doing load-balance
|
|
|
|
* | `- freq
|
|
|
|
* `- sum over all levels
|
|
|
|
*
|
|
|
|
* Coupled with a limit on how many tasks we can migrate every balance pass,
|
|
|
|
* this makes (5) the runtime complexity of the balancer.
|
|
|
|
*
|
|
|
|
* An important property here is that each CPU is still (indirectly) connected
|
|
|
|
* to every other cpu in at most O(log n) steps:
|
|
|
|
*
|
|
|
|
* The adjacency matrix of the resulting graph is given by:
|
|
|
|
*
|
2015-07-05 09:33:48 +00:00
|
|
|
* log_2 n
|
2012-07-03 11:53:26 +00:00
|
|
|
* A_i,j = \Union (i % 2^k == 0) && i / 2^(k+1) == j / 2^(k+1) (6)
|
|
|
|
* k = 0
|
|
|
|
*
|
|
|
|
* And you'll find that:
|
|
|
|
*
|
|
|
|
* A^(log_2 n)_i,j != 0 for all i,j (7)
|
|
|
|
*
|
|
|
|
* Showing there's indeed a path between every cpu in at most O(log n) steps.
|
|
|
|
* The task movement gives a factor of O(m), giving a convergence complexity
|
|
|
|
* of:
|
|
|
|
*
|
|
|
|
* O(nm log n), n := nr_cpus, m := nr_tasks (8)
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* WORK CONSERVING
|
|
|
|
*
|
|
|
|
* In order to avoid CPUs going idle while there's still work to do, new idle
|
|
|
|
* balancing is more aggressive and has the newly idle cpu iterate up the domain
|
|
|
|
* tree itself instead of relying on other CPUs to bring it work.
|
|
|
|
*
|
|
|
|
* This adds some complexity to both (5) and (8) but it reduces the total idle
|
|
|
|
* time.
|
|
|
|
*
|
|
|
|
* [XXX more?]
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* CGROUPS
|
|
|
|
*
|
|
|
|
* Cgroups make a horror show out of (2), instead of a simple sum we get:
|
|
|
|
*
|
|
|
|
* s_k,i
|
|
|
|
* W_i,0 = \Sum_j \Prod_k w_k * ----- (9)
|
|
|
|
* S_k
|
|
|
|
*
|
|
|
|
* Where
|
|
|
|
*
|
|
|
|
* s_k,i = \Sum_j w_i,j,k and S_k = \Sum_i s_k,i (10)
|
|
|
|
*
|
|
|
|
* w_i,j,k is the weight of the j-th runnable task in the k-th cgroup on cpu i.
|
|
|
|
*
|
|
|
|
* The big problem is S_k, its a global sum needed to compute a local (W_i)
|
|
|
|
* property.
|
|
|
|
*
|
|
|
|
* [XXX write more on how we solve this.. _after_ merging pjt's patches that
|
|
|
|
* rewrite all of this once again.]
|
2015-07-05 09:33:48 +00:00
|
|
|
*/
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2012-01-31 02:40:32 +00:00
|
|
|
static unsigned long __read_mostly max_load_balance_interval = HZ/10;
|
|
|
|
|
2013-10-07 10:29:33 +00:00
|
|
|
enum fbq_type { regular, remote, all };
|
|
|
|
|
2012-02-22 18:27:40 +00:00
|
|
|
#define LBF_ALL_PINNED 0x01
|
2012-02-20 20:49:09 +00:00
|
|
|
#define LBF_NEED_BREAK 0x02
|
2013-08-19 10:41:09 +00:00
|
|
|
#define LBF_DST_PINNED 0x04
|
|
|
|
#define LBF_SOME_PINNED 0x08
|
2012-02-22 18:27:40 +00:00
|
|
|
|
|
|
|
struct lb_env {
|
|
|
|
struct sched_domain *sd;
|
|
|
|
|
|
|
|
struct rq *src_rq;
|
2012-06-19 12:17:34 +00:00
|
|
|
int src_cpu;
|
2012-02-22 18:27:40 +00:00
|
|
|
|
|
|
|
int dst_cpu;
|
|
|
|
struct rq *dst_rq;
|
|
|
|
|
2012-06-19 12:13:15 +00:00
|
|
|
struct cpumask *dst_grpmask;
|
|
|
|
int new_dst_cpu;
|
2012-02-22 18:27:40 +00:00
|
|
|
enum cpu_idle_type idle;
|
2012-05-02 12:20:37 +00:00
|
|
|
long imbalance;
|
2012-07-12 08:10:13 +00:00
|
|
|
/* The set of CPUs under consideration for load-balancing */
|
|
|
|
struct cpumask *cpus;
|
|
|
|
|
2012-02-22 18:27:40 +00:00
|
|
|
unsigned int flags;
|
2012-02-20 20:49:09 +00:00
|
|
|
|
|
|
|
unsigned int loop;
|
|
|
|
unsigned int loop_break;
|
|
|
|
unsigned int loop_max;
|
2013-10-07 10:29:33 +00:00
|
|
|
|
|
|
|
enum fbq_type fbq_type;
|
2014-08-20 09:48:29 +00:00
|
|
|
struct list_head tasks;
|
2012-02-22 18:27:40 +00:00
|
|
|
};
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
/*
|
|
|
|
* Is this task likely cache-hot:
|
|
|
|
*/
|
2014-06-10 08:58:43 +00:00
|
|
|
static int task_hot(struct task_struct *p, struct lb_env *env)
|
2011-10-25 08:00:11 +00:00
|
|
|
{
|
|
|
|
s64 delta;
|
|
|
|
|
2014-08-20 09:48:01 +00:00
|
|
|
lockdep_assert_held(&env->src_rq->lock);
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
if (p->sched_class != &fair_sched_class)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (unlikely(p->policy == SCHED_IDLE))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Buddy candidates are cache hot:
|
|
|
|
*/
|
2014-06-10 08:58:43 +00:00
|
|
|
if (sched_feat(CACHE_HOT_BUDDY) && env->dst_rq->nr_running &&
|
2011-10-25 08:00:11 +00:00
|
|
|
(&p->se == cfs_rq_of(&p->se)->next ||
|
|
|
|
&p->se == cfs_rq_of(&p->se)->last))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (sysctl_sched_migration_cost == -1)
|
|
|
|
return 1;
|
|
|
|
if (sysctl_sched_migration_cost == 0)
|
|
|
|
return 0;
|
|
|
|
|
2014-06-10 08:58:43 +00:00
|
|
|
delta = rq_clock_task(env->src_rq) - p->se.exec_start;
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
return delta < (s64)sysctl_sched_migration_cost;
|
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:00 +00:00
|
|
|
#ifdef CONFIG_NUMA_BALANCING
|
2015-05-15 02:59:36 +00:00
|
|
|
/*
|
2015-06-16 11:55:59 +00:00
|
|
|
* Returns 1, if task migration degrades locality
|
|
|
|
* Returns 0, if task migration improves locality i.e migration preferred.
|
|
|
|
* Returns -1, if task migration is not affected by locality.
|
2015-05-15 02:59:36 +00:00
|
|
|
*/
|
2015-06-16 11:55:59 +00:00
|
|
|
static int migrate_degrades_locality(struct task_struct *p, struct lb_env *env)
|
2013-10-07 10:29:00 +00:00
|
|
|
{
|
2014-05-15 17:03:06 +00:00
|
|
|
struct numa_group *numa_group = rcu_dereference(p->numa_group);
|
2015-05-15 02:59:36 +00:00
|
|
|
unsigned long src_faults, dst_faults;
|
2013-10-07 10:29:00 +00:00
|
|
|
int src_nid, dst_nid;
|
|
|
|
|
2015-08-11 16:24:21 +00:00
|
|
|
if (!static_branch_likely(&sched_numa_balancing))
|
2015-06-16 11:55:59 +00:00
|
|
|
return -1;
|
|
|
|
|
2015-08-11 11:00:12 +00:00
|
|
|
if (!p->numa_faults || !(env->sd->flags & SD_NUMA))
|
2015-06-16 11:55:59 +00:00
|
|
|
return -1;
|
2013-10-07 10:29:01 +00:00
|
|
|
|
|
|
|
src_nid = cpu_to_node(env->src_cpu);
|
|
|
|
dst_nid = cpu_to_node(env->dst_cpu);
|
|
|
|
|
2013-10-07 10:29:27 +00:00
|
|
|
if (src_nid == dst_nid)
|
2015-06-16 11:55:59 +00:00
|
|
|
return -1;
|
2013-10-07 10:29:01 +00:00
|
|
|
|
2015-06-16 11:55:59 +00:00
|
|
|
/* Migrating away from the preferred node is always bad. */
|
|
|
|
if (src_nid == p->numa_preferred_nid) {
|
|
|
|
if (env->src_rq->nr_running > env->src_rq->nr_preferred_running)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
}
|
2014-05-15 17:03:06 +00:00
|
|
|
|
2015-05-15 02:59:36 +00:00
|
|
|
/* Encourage migration to the preferred node. */
|
|
|
|
if (dst_nid == p->numa_preferred_nid)
|
2015-06-16 11:55:59 +00:00
|
|
|
return 0;
|
2014-05-15 17:03:06 +00:00
|
|
|
|
2017-06-23 16:55:27 +00:00
|
|
|
/* Leaving a core idle is often worse than degrading locality. */
|
|
|
|
if (env->idle != CPU_NOT_IDLE)
|
|
|
|
return -1;
|
|
|
|
|
2015-05-15 02:59:36 +00:00
|
|
|
if (numa_group) {
|
|
|
|
src_faults = group_faults(p, src_nid);
|
|
|
|
dst_faults = group_faults(p, dst_nid);
|
|
|
|
} else {
|
|
|
|
src_faults = task_faults(p, src_nid);
|
|
|
|
dst_faults = task_faults(p, dst_nid);
|
2014-05-15 17:03:06 +00:00
|
|
|
}
|
|
|
|
|
2015-05-15 02:59:36 +00:00
|
|
|
return dst_faults < src_faults;
|
2013-10-07 10:29:01 +00:00
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:00 +00:00
|
|
|
#else
|
2015-06-16 11:55:59 +00:00
|
|
|
static inline int migrate_degrades_locality(struct task_struct *p,
|
2013-10-07 10:29:00 +00:00
|
|
|
struct lb_env *env)
|
|
|
|
{
|
2015-06-16 11:55:59 +00:00
|
|
|
return -1;
|
2013-10-07 10:29:01 +00:00
|
|
|
}
|
2013-10-07 10:29:00 +00:00
|
|
|
#endif
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/*
|
|
|
|
* can_migrate_task - may task p from runqueue rq be migrated to this_cpu?
|
|
|
|
*/
|
|
|
|
static
|
2012-02-22 11:47:19 +00:00
|
|
|
int can_migrate_task(struct task_struct *p, struct lb_env *env)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2015-06-16 11:55:59 +00:00
|
|
|
int tsk_cache_hot;
|
2014-08-20 09:48:01 +00:00
|
|
|
|
|
|
|
lockdep_assert_held(&env->src_rq->lock);
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/*
|
|
|
|
* We do not migrate tasks that are:
|
2013-04-23 08:27:40 +00:00
|
|
|
* 1) throttled_lb_pair, or
|
2009-12-17 16:00:43 +00:00
|
|
|
* 2) cannot be migrated to this CPU due to cpus_allowed, or
|
2013-04-23 08:27:40 +00:00
|
|
|
* 3) running (obviously), or
|
|
|
|
* 4) are cache-hot on their current CPU.
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2013-04-23 08:27:40 +00:00
|
|
|
if (throttled_lb_pair(task_group(p), env->src_cpu, env->dst_cpu))
|
|
|
|
return 0;
|
|
|
|
|
2017-02-05 14:38:10 +00:00
|
|
|
if (!cpumask_test_cpu(env->dst_cpu, &p->cpus_allowed)) {
|
2013-04-23 08:27:42 +00:00
|
|
|
int cpu;
|
2012-06-19 12:13:15 +00:00
|
|
|
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(p->se.statistics.nr_failed_migrations_affine);
|
2012-06-19 12:13:15 +00:00
|
|
|
|
2013-08-19 10:41:09 +00:00
|
|
|
env->flags |= LBF_SOME_PINNED;
|
|
|
|
|
2012-06-19 12:13:15 +00:00
|
|
|
/*
|
|
|
|
* Remember if this task can be migrated to any other cpu in
|
|
|
|
* our sched_group. We may want to revisit it if we couldn't
|
|
|
|
* meet load balance goals by pulling other tasks on src_cpu.
|
|
|
|
*
|
2017-06-07 19:18:57 +00:00
|
|
|
* Avoid computing new_dst_cpu for NEWLY_IDLE or if we have
|
|
|
|
* already computed one in current iteration.
|
2012-06-19 12:13:15 +00:00
|
|
|
*/
|
2017-06-07 19:18:57 +00:00
|
|
|
if (env->idle == CPU_NEWLY_IDLE || (env->flags & LBF_DST_PINNED))
|
2012-06-19 12:13:15 +00:00
|
|
|
return 0;
|
|
|
|
|
2013-04-23 08:27:42 +00:00
|
|
|
/* Prevent to re-select dst_cpu via env's cpus */
|
|
|
|
for_each_cpu_and(cpu, env->dst_grpmask, env->cpus) {
|
2017-02-05 14:38:10 +00:00
|
|
|
if (cpumask_test_cpu(cpu, &p->cpus_allowed)) {
|
2013-08-19 10:41:09 +00:00
|
|
|
env->flags |= LBF_DST_PINNED;
|
2013-04-23 08:27:42 +00:00
|
|
|
env->new_dst_cpu = cpu;
|
|
|
|
break;
|
|
|
|
}
|
2012-06-19 12:13:15 +00:00
|
|
|
}
|
2013-04-23 08:27:42 +00:00
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2012-06-19 12:13:15 +00:00
|
|
|
|
|
|
|
/* Record that we found atleast one task that could run on dst_cpu */
|
2012-02-22 11:47:19 +00:00
|
|
|
env->flags &= ~LBF_ALL_PINNED;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2012-02-22 18:27:40 +00:00
|
|
|
if (task_running(env->src_rq, p)) {
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(p->se.statistics.nr_failed_migrations_running);
|
2009-12-17 16:00:43 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Aggressive migration if:
|
2013-10-07 10:29:00 +00:00
|
|
|
* 1) destination numa is preferred
|
|
|
|
* 2) task is cache cold, or
|
|
|
|
* 3) too many balance attempts have failed.
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2015-06-16 11:55:59 +00:00
|
|
|
tsk_cache_hot = migrate_degrades_locality(p, env);
|
|
|
|
if (tsk_cache_hot == -1)
|
|
|
|
tsk_cache_hot = task_hot(p, env);
|
2013-10-07 10:29:00 +00:00
|
|
|
|
2015-06-16 11:55:59 +00:00
|
|
|
if (tsk_cache_hot <= 0 ||
|
2014-09-22 18:36:12 +00:00
|
|
|
env->sd->nr_balance_failed > env->sd->cache_nice_tries) {
|
2015-06-16 11:55:59 +00:00
|
|
|
if (tsk_cache_hot == 1) {
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(env->sd->lb_hot_gained[env->idle]);
|
|
|
|
schedstat_inc(p->se.statistics.nr_forced_migrations);
|
2013-10-07 10:29:00 +00:00
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(p->se.statistics.nr_failed_migrations_hot);
|
2013-04-10 06:04:55 +00:00
|
|
|
return 0;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
2009-12-17 16:45:42 +00:00
|
|
|
/*
|
2014-08-20 09:48:29 +00:00
|
|
|
* detach_task() -- detach the task for the migration specified in env
|
|
|
|
*/
|
|
|
|
static void detach_task(struct task_struct *p, struct lb_env *env)
|
|
|
|
{
|
|
|
|
lockdep_assert_held(&env->src_rq->lock);
|
|
|
|
|
|
|
|
p->on_rq = TASK_ON_RQ_MIGRATING;
|
2017-02-21 16:15:21 +00:00
|
|
|
deactivate_task(env->src_rq, p, DEQUEUE_NOCLOCK);
|
2014-08-20 09:48:29 +00:00
|
|
|
set_task_cpu(p, env->dst_cpu);
|
|
|
|
}
|
|
|
|
|
2009-12-17 16:45:42 +00:00
|
|
|
/*
|
2014-08-20 09:48:01 +00:00
|
|
|
* detach_one_task() -- tries to dequeue exactly one task from env->src_rq, as
|
2009-12-17 16:45:42 +00:00
|
|
|
* part of active balancing operations within "domain".
|
|
|
|
*
|
2014-08-20 09:48:01 +00:00
|
|
|
* Returns a task if successful and NULL otherwise.
|
2009-12-17 16:45:42 +00:00
|
|
|
*/
|
2014-08-20 09:48:01 +00:00
|
|
|
static struct task_struct *detach_one_task(struct lb_env *env)
|
2009-12-17 16:45:42 +00:00
|
|
|
{
|
2017-09-13 10:24:30 +00:00
|
|
|
struct task_struct *p;
|
2009-12-17 16:45:42 +00:00
|
|
|
|
2014-08-20 09:48:01 +00:00
|
|
|
lockdep_assert_held(&env->src_rq->lock);
|
|
|
|
|
2017-09-13 10:24:30 +00:00
|
|
|
list_for_each_entry_reverse(p,
|
|
|
|
&env->src_rq->cfs_tasks, se.group_node) {
|
2012-02-20 20:49:09 +00:00
|
|
|
if (!can_migrate_task(p, env))
|
|
|
|
continue;
|
2009-12-17 16:45:42 +00:00
|
|
|
|
2014-08-20 09:48:29 +00:00
|
|
|
detach_task(p, env);
|
2014-08-20 09:48:01 +00:00
|
|
|
|
2012-02-20 20:49:09 +00:00
|
|
|
/*
|
2014-08-20 09:48:01 +00:00
|
|
|
* Right now, this is only the second place where
|
2014-08-20 09:48:29 +00:00
|
|
|
* lb_gained[env->idle] is updated (other is detach_tasks)
|
2014-08-20 09:48:01 +00:00
|
|
|
* so we can safely collect stats here rather than
|
2014-08-20 09:48:29 +00:00
|
|
|
* inside detach_tasks().
|
2012-02-20 20:49:09 +00:00
|
|
|
*/
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(env->sd->lb_gained[env->idle]);
|
2014-08-20 09:48:01 +00:00
|
|
|
return p;
|
2009-12-17 16:45:42 +00:00
|
|
|
}
|
2014-08-20 09:48:01 +00:00
|
|
|
return NULL;
|
2009-12-17 16:45:42 +00:00
|
|
|
}
|
|
|
|
|
2012-04-17 11:38:40 +00:00
|
|
|
static const unsigned int sched_nr_migrate_break = 32;
|
|
|
|
|
2012-03-09 23:07:36 +00:00
|
|
|
/*
|
2014-08-20 09:48:29 +00:00
|
|
|
* detach_tasks() -- tries to detach up to imbalance weighted load from
|
|
|
|
* busiest_rq, as part of a balancing operation within domain "sd".
|
2012-03-09 23:07:36 +00:00
|
|
|
*
|
2014-08-20 09:48:29 +00:00
|
|
|
* Returns number of detached tasks if successful and 0 otherwise.
|
2012-03-09 23:07:36 +00:00
|
|
|
*/
|
2014-08-20 09:48:29 +00:00
|
|
|
static int detach_tasks(struct lb_env *env)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2012-03-09 23:07:36 +00:00
|
|
|
struct list_head *tasks = &env->src_rq->cfs_tasks;
|
|
|
|
struct task_struct *p;
|
2012-02-20 20:49:09 +00:00
|
|
|
unsigned long load;
|
2014-08-20 09:48:29 +00:00
|
|
|
int detached = 0;
|
|
|
|
|
|
|
|
lockdep_assert_held(&env->src_rq->lock);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2012-05-02 12:20:37 +00:00
|
|
|
if (env->imbalance <= 0)
|
2012-03-09 23:07:36 +00:00
|
|
|
return 0;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2012-03-09 23:07:36 +00:00
|
|
|
while (!list_empty(tasks)) {
|
2015-07-05 22:11:51 +00:00
|
|
|
/*
|
|
|
|
* We don't want to steal all, otherwise we may be treated likewise,
|
|
|
|
* which could at worst lead to a livelock crash.
|
|
|
|
*/
|
|
|
|
if (env->idle != CPU_NOT_IDLE && env->src_rq->nr_running <= 1)
|
|
|
|
break;
|
|
|
|
|
2017-09-13 10:24:30 +00:00
|
|
|
p = list_last_entry(tasks, struct task_struct, se.group_node);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2012-02-20 20:49:09 +00:00
|
|
|
env->loop++;
|
|
|
|
/* We've more or less seen every task there is, call it quits */
|
2012-03-09 23:07:36 +00:00
|
|
|
if (env->loop > env->loop_max)
|
2012-02-20 20:49:09 +00:00
|
|
|
break;
|
2012-03-09 23:07:36 +00:00
|
|
|
|
|
|
|
/* take a breather every nr_migrate tasks */
|
2012-02-20 20:49:09 +00:00
|
|
|
if (env->loop > env->loop_break) {
|
2012-04-17 11:38:40 +00:00
|
|
|
env->loop_break += sched_nr_migrate_break;
|
2012-02-22 11:47:19 +00:00
|
|
|
env->flags |= LBF_NEED_BREAK;
|
2009-12-17 16:25:20 +00:00
|
|
|
break;
|
2011-09-22 13:30:18 +00:00
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2013-04-23 08:27:40 +00:00
|
|
|
if (!can_migrate_task(p, env))
|
2012-02-20 20:49:09 +00:00
|
|
|
goto next;
|
|
|
|
|
|
|
|
load = task_h_load(p);
|
2012-03-09 23:07:36 +00:00
|
|
|
|
2012-04-17 11:38:40 +00:00
|
|
|
if (sched_feat(LB_MIN) && load < 16 && !env->sd->nr_balance_failed)
|
2012-02-20 20:49:09 +00:00
|
|
|
goto next;
|
|
|
|
|
2012-05-02 12:20:37 +00:00
|
|
|
if ((load / 2) > env->imbalance)
|
2012-02-20 20:49:09 +00:00
|
|
|
goto next;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2014-08-20 09:48:29 +00:00
|
|
|
detach_task(p, env);
|
|
|
|
list_add(&p->se.group_node, &env->tasks);
|
|
|
|
|
|
|
|
detached++;
|
2012-05-02 12:20:37 +00:00
|
|
|
env->imbalance -= load;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_PREEMPT
|
2009-12-17 16:25:20 +00:00
|
|
|
/*
|
|
|
|
* NEWIDLE balancing is a source of latency, so preemptible
|
2014-08-20 09:48:29 +00:00
|
|
|
* kernels will stop after the first task is detached to minimize
|
2009-12-17 16:25:20 +00:00
|
|
|
* the critical section.
|
|
|
|
*/
|
2012-03-09 23:07:36 +00:00
|
|
|
if (env->idle == CPU_NEWLY_IDLE)
|
2009-12-17 16:25:20 +00:00
|
|
|
break;
|
2009-12-17 16:00:43 +00:00
|
|
|
#endif
|
|
|
|
|
2009-12-17 16:25:20 +00:00
|
|
|
/*
|
|
|
|
* We only want to steal up to the prescribed amount of
|
|
|
|
* weighted load.
|
|
|
|
*/
|
2012-05-02 12:20:37 +00:00
|
|
|
if (env->imbalance <= 0)
|
2009-12-17 16:25:20 +00:00
|
|
|
break;
|
2012-02-20 20:49:09 +00:00
|
|
|
|
|
|
|
continue;
|
|
|
|
next:
|
2017-09-13 10:24:30 +00:00
|
|
|
list_move(&p->se.group_node, tasks);
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
2012-03-09 23:07:36 +00:00
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/*
|
2014-08-20 09:48:29 +00:00
|
|
|
* Right now, this is one of only two places we collect this stat
|
|
|
|
* so we can safely collect detach_one_task() stats here rather
|
|
|
|
* than inside detach_one_task().
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_add(env->sd->lb_gained[env->idle], detached);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2014-08-20 09:48:29 +00:00
|
|
|
return detached;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* attach_task() -- attach the task detached by detach_task() to its new rq.
|
|
|
|
*/
|
|
|
|
static void attach_task(struct rq *rq, struct task_struct *p)
|
|
|
|
{
|
|
|
|
lockdep_assert_held(&rq->lock);
|
|
|
|
|
|
|
|
BUG_ON(task_rq(p) != rq);
|
2017-02-21 16:15:21 +00:00
|
|
|
activate_task(rq, p, ENQUEUE_NOCLOCK);
|
2015-11-13 03:38:54 +00:00
|
|
|
p->on_rq = TASK_ON_RQ_QUEUED;
|
2014-08-20 09:48:29 +00:00
|
|
|
check_preempt_curr(rq, p, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* attach_one_task() -- attaches the task returned from detach_one_task() to
|
|
|
|
* its new rq.
|
|
|
|
*/
|
|
|
|
static void attach_one_task(struct rq *rq, struct task_struct *p)
|
|
|
|
{
|
2016-10-04 14:04:35 +00:00
|
|
|
struct rq_flags rf;
|
|
|
|
|
|
|
|
rq_lock(rq, &rf);
|
2017-02-21 16:15:21 +00:00
|
|
|
update_rq_clock(rq);
|
2014-08-20 09:48:29 +00:00
|
|
|
attach_task(rq, p);
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_unlock(rq, &rf);
|
2014-08-20 09:48:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* attach_tasks() -- attaches all tasks detached by detach_tasks() to their
|
|
|
|
* new rq.
|
|
|
|
*/
|
|
|
|
static void attach_tasks(struct lb_env *env)
|
|
|
|
{
|
|
|
|
struct list_head *tasks = &env->tasks;
|
|
|
|
struct task_struct *p;
|
2016-10-04 14:04:35 +00:00
|
|
|
struct rq_flags rf;
|
2014-08-20 09:48:29 +00:00
|
|
|
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_lock(env->dst_rq, &rf);
|
2017-02-21 16:15:21 +00:00
|
|
|
update_rq_clock(env->dst_rq);
|
2014-08-20 09:48:29 +00:00
|
|
|
|
|
|
|
while (!list_empty(tasks)) {
|
|
|
|
p = list_first_entry(tasks, struct task_struct, se.group_node);
|
|
|
|
list_del_init(&p->se.group_node);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2014-08-20 09:48:29 +00:00
|
|
|
attach_task(env->dst_rq, p);
|
|
|
|
}
|
|
|
|
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_unlock(env->dst_rq, &rf);
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
2009-12-17 16:47:12 +00:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2017-04-26 00:43:50 +00:00
|
|
|
|
|
|
|
static inline bool cfs_rq_is_decayed(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
|
|
|
if (cfs_rq->load.weight)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (cfs_rq->avg.load_sum)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (cfs_rq->avg.util_sum)
|
|
|
|
return false;
|
|
|
|
|
2017-05-06 13:59:54 +00:00
|
|
|
if (cfs_rq->avg.runnable_load_sum)
|
2017-04-26 00:43:50 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-10-04 11:18:31 +00:00
|
|
|
static void update_blocked_averages(int cpu)
|
2010-11-15 23:47:02 +00:00
|
|
|
{
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
2017-04-26 00:43:50 +00:00
|
|
|
struct cfs_rq *cfs_rq, *pos;
|
2016-10-04 14:04:35 +00:00
|
|
|
struct rq_flags rf;
|
2010-11-15 23:47:02 +00:00
|
|
|
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_lock_irqsave(rq, &rf);
|
2012-10-04 11:18:31 +00:00
|
|
|
update_rq_clock(rq);
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
|
2011-07-13 11:09:25 +00:00
|
|
|
/*
|
|
|
|
* Iterates the task_group tree in a bottom up fashion, see
|
|
|
|
* list_add_leaf_cfs_rq() for details.
|
|
|
|
*/
|
2017-04-26 00:43:50 +00:00
|
|
|
for_each_leaf_cfs_rq_safe(rq, cfs_rq, pos) {
|
2017-03-17 13:47:22 +00:00
|
|
|
struct sched_entity *se;
|
|
|
|
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
/* throttled entities do not contribute to load */
|
|
|
|
if (throttled_hierarchy(cfs_rq))
|
|
|
|
continue;
|
2012-10-04 11:18:31 +00:00
|
|
|
|
2017-05-24 05:29:56 +00:00
|
|
|
if (update_cfs_rq_load_avg(cfs_rq_clock_task(cfs_rq), cfs_rq))
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
update_tg_load_avg(cfs_rq, 0);
|
2016-11-08 09:53:46 +00:00
|
|
|
|
2017-03-17 13:47:22 +00:00
|
|
|
/* Propagate pending load changes to the parent, if any: */
|
|
|
|
se = cfs_rq->tg->se[cpu];
|
|
|
|
if (se && !skip_blocked_update(se))
|
2017-05-06 15:32:43 +00:00
|
|
|
update_load_avg(cfs_rq_of(se), se, 0);
|
2017-04-26 00:43:50 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* There can be a lot of idle CPU cgroups. Don't let fully
|
|
|
|
* decayed cfs_rqs linger on the list.
|
|
|
|
*/
|
|
|
|
if (cfs_rq_is_decayed(cfs_rq))
|
|
|
|
list_del_leaf_cfs_rq(cfs_rq);
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
}
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_unlock_irqrestore(rq, &rf);
|
2010-11-15 23:47:02 +00:00
|
|
|
}
|
|
|
|
|
2011-07-13 11:09:25 +00:00
|
|
|
/*
|
sched: Move h_load calculation to task_h_load()
The bad thing about update_h_load(), which computes hierarchical load
factor for task groups, is that it is called for each task group in the
system before every load balancer run, and since rebalance can be
triggered very often, this function can eat really a lot of cpu time if
there are many cpu cgroups in the system.
Although the situation was improved significantly by commit a35b646
('sched, cgroup: Reduce rq->lock hold times for large cgroup
hierarchies'), the problem still can arise under some kinds of loads,
e.g. when cpus are switching from idle to busy and back very frequently.
For instance, when I start 1000 of processes that wake up every
millisecond on my 8 cpus host, 'top' and 'perf top' show:
Cpu(s): 17.8%us, 24.3%sy, 0.0%ni, 57.9%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 243K cycles
7.57% [kernel] [k] __schedule
7.08% [kernel] [k] timerqueue_add
6.13% libc-2.12.so [.] usleep
Then if I create 10000 *idle* cpu cgroups (no processes in them), cpu
usage increases significantly although the 'wakers' are still executing
in the root cpu cgroup:
Cpu(s): 19.1%us, 48.7%sy, 0.0%ni, 31.6%id, 0.0%wa, 0.0%hi, 0.7%si
Events: 230K cycles
24.56% [kernel] [k] tg_load_down
5.76% [kernel] [k] __schedule
This happens because this particular kind of load triggers 'new idle'
rebalance very frequently, which requires calling update_h_load(),
which, in turn, calls tg_load_down() for every *idle* cpu cgroup even
though it is absolutely useless, because idle cpu cgroups have no tasks
to pull.
This patch tries to improve the situation by making h_load calculation
proceed only when h_load is really necessary. To achieve this, it
substitutes update_h_load() with update_cfs_rq_h_load(), which computes
h_load only for a given cfs_rq and all its ascendants, and makes the
load balancer call this function whenever it considers if a task should
be pulled, i.e. it moves h_load calculations directly to task_h_load().
For h_load of the same cfs_rq not to be updated multiple times (in case
several tasks in the same cgroup are considered during the same balance
run), the patch keeps the time of the last h_load update for each cfs_rq
and breaks calculation when it finds h_load to be uptodate.
The benefit of it is that h_load is computed only for those cfs_rq's,
which really need it, in particular all idle task groups are skipped.
Although this, in fact, moves h_load calculation under rq lock, it
should not affect latency much, because the amount of work done under rq
lock while trying to pull tasks is limited by sched_nr_migrate.
After the patch applied with the setup described above (1000 wakers in
the root cgroup and 10000 idle cgroups), I get:
Cpu(s): 16.9%us, 24.8%sy, 0.0%ni, 58.4%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 242K cycles
7.57% [kernel] [k] __schedule
6.70% [kernel] [k] timerqueue_add
5.93% libc-2.12.so [.] usleep
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1373896159-1278-1-git-send-email-vdavydov@parallels.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-15 13:49:19 +00:00
|
|
|
* Compute the hierarchical load factor for cfs_rq and all its ascendants.
|
2011-07-13 11:09:25 +00:00
|
|
|
* This needs to be done in a top-down fashion because the load of a child
|
|
|
|
* group is a fraction of its parents load.
|
|
|
|
*/
|
sched: Move h_load calculation to task_h_load()
The bad thing about update_h_load(), which computes hierarchical load
factor for task groups, is that it is called for each task group in the
system before every load balancer run, and since rebalance can be
triggered very often, this function can eat really a lot of cpu time if
there are many cpu cgroups in the system.
Although the situation was improved significantly by commit a35b646
('sched, cgroup: Reduce rq->lock hold times for large cgroup
hierarchies'), the problem still can arise under some kinds of loads,
e.g. when cpus are switching from idle to busy and back very frequently.
For instance, when I start 1000 of processes that wake up every
millisecond on my 8 cpus host, 'top' and 'perf top' show:
Cpu(s): 17.8%us, 24.3%sy, 0.0%ni, 57.9%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 243K cycles
7.57% [kernel] [k] __schedule
7.08% [kernel] [k] timerqueue_add
6.13% libc-2.12.so [.] usleep
Then if I create 10000 *idle* cpu cgroups (no processes in them), cpu
usage increases significantly although the 'wakers' are still executing
in the root cpu cgroup:
Cpu(s): 19.1%us, 48.7%sy, 0.0%ni, 31.6%id, 0.0%wa, 0.0%hi, 0.7%si
Events: 230K cycles
24.56% [kernel] [k] tg_load_down
5.76% [kernel] [k] __schedule
This happens because this particular kind of load triggers 'new idle'
rebalance very frequently, which requires calling update_h_load(),
which, in turn, calls tg_load_down() for every *idle* cpu cgroup even
though it is absolutely useless, because idle cpu cgroups have no tasks
to pull.
This patch tries to improve the situation by making h_load calculation
proceed only when h_load is really necessary. To achieve this, it
substitutes update_h_load() with update_cfs_rq_h_load(), which computes
h_load only for a given cfs_rq and all its ascendants, and makes the
load balancer call this function whenever it considers if a task should
be pulled, i.e. it moves h_load calculations directly to task_h_load().
For h_load of the same cfs_rq not to be updated multiple times (in case
several tasks in the same cgroup are considered during the same balance
run), the patch keeps the time of the last h_load update for each cfs_rq
and breaks calculation when it finds h_load to be uptodate.
The benefit of it is that h_load is computed only for those cfs_rq's,
which really need it, in particular all idle task groups are skipped.
Although this, in fact, moves h_load calculation under rq lock, it
should not affect latency much, because the amount of work done under rq
lock while trying to pull tasks is limited by sched_nr_migrate.
After the patch applied with the setup described above (1000 wakers in
the root cgroup and 10000 idle cgroups), I get:
Cpu(s): 16.9%us, 24.8%sy, 0.0%ni, 58.4%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 242K cycles
7.57% [kernel] [k] __schedule
6.70% [kernel] [k] timerqueue_add
5.93% libc-2.12.so [.] usleep
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1373896159-1278-1-git-send-email-vdavydov@parallels.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-15 13:49:19 +00:00
|
|
|
static void update_cfs_rq_h_load(struct cfs_rq *cfs_rq)
|
2011-07-13 11:09:25 +00:00
|
|
|
{
|
sched: Move h_load calculation to task_h_load()
The bad thing about update_h_load(), which computes hierarchical load
factor for task groups, is that it is called for each task group in the
system before every load balancer run, and since rebalance can be
triggered very often, this function can eat really a lot of cpu time if
there are many cpu cgroups in the system.
Although the situation was improved significantly by commit a35b646
('sched, cgroup: Reduce rq->lock hold times for large cgroup
hierarchies'), the problem still can arise under some kinds of loads,
e.g. when cpus are switching from idle to busy and back very frequently.
For instance, when I start 1000 of processes that wake up every
millisecond on my 8 cpus host, 'top' and 'perf top' show:
Cpu(s): 17.8%us, 24.3%sy, 0.0%ni, 57.9%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 243K cycles
7.57% [kernel] [k] __schedule
7.08% [kernel] [k] timerqueue_add
6.13% libc-2.12.so [.] usleep
Then if I create 10000 *idle* cpu cgroups (no processes in them), cpu
usage increases significantly although the 'wakers' are still executing
in the root cpu cgroup:
Cpu(s): 19.1%us, 48.7%sy, 0.0%ni, 31.6%id, 0.0%wa, 0.0%hi, 0.7%si
Events: 230K cycles
24.56% [kernel] [k] tg_load_down
5.76% [kernel] [k] __schedule
This happens because this particular kind of load triggers 'new idle'
rebalance very frequently, which requires calling update_h_load(),
which, in turn, calls tg_load_down() for every *idle* cpu cgroup even
though it is absolutely useless, because idle cpu cgroups have no tasks
to pull.
This patch tries to improve the situation by making h_load calculation
proceed only when h_load is really necessary. To achieve this, it
substitutes update_h_load() with update_cfs_rq_h_load(), which computes
h_load only for a given cfs_rq and all its ascendants, and makes the
load balancer call this function whenever it considers if a task should
be pulled, i.e. it moves h_load calculations directly to task_h_load().
For h_load of the same cfs_rq not to be updated multiple times (in case
several tasks in the same cgroup are considered during the same balance
run), the patch keeps the time of the last h_load update for each cfs_rq
and breaks calculation when it finds h_load to be uptodate.
The benefit of it is that h_load is computed only for those cfs_rq's,
which really need it, in particular all idle task groups are skipped.
Although this, in fact, moves h_load calculation under rq lock, it
should not affect latency much, because the amount of work done under rq
lock while trying to pull tasks is limited by sched_nr_migrate.
After the patch applied with the setup described above (1000 wakers in
the root cgroup and 10000 idle cgroups), I get:
Cpu(s): 16.9%us, 24.8%sy, 0.0%ni, 58.4%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 242K cycles
7.57% [kernel] [k] __schedule
6.70% [kernel] [k] timerqueue_add
5.93% libc-2.12.so [.] usleep
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1373896159-1278-1-git-send-email-vdavydov@parallels.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-15 13:49:19 +00:00
|
|
|
struct rq *rq = rq_of(cfs_rq);
|
|
|
|
struct sched_entity *se = cfs_rq->tg->se[cpu_of(rq)];
|
2012-08-08 19:46:40 +00:00
|
|
|
unsigned long now = jiffies;
|
sched: Move h_load calculation to task_h_load()
The bad thing about update_h_load(), which computes hierarchical load
factor for task groups, is that it is called for each task group in the
system before every load balancer run, and since rebalance can be
triggered very often, this function can eat really a lot of cpu time if
there are many cpu cgroups in the system.
Although the situation was improved significantly by commit a35b646
('sched, cgroup: Reduce rq->lock hold times for large cgroup
hierarchies'), the problem still can arise under some kinds of loads,
e.g. when cpus are switching from idle to busy and back very frequently.
For instance, when I start 1000 of processes that wake up every
millisecond on my 8 cpus host, 'top' and 'perf top' show:
Cpu(s): 17.8%us, 24.3%sy, 0.0%ni, 57.9%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 243K cycles
7.57% [kernel] [k] __schedule
7.08% [kernel] [k] timerqueue_add
6.13% libc-2.12.so [.] usleep
Then if I create 10000 *idle* cpu cgroups (no processes in them), cpu
usage increases significantly although the 'wakers' are still executing
in the root cpu cgroup:
Cpu(s): 19.1%us, 48.7%sy, 0.0%ni, 31.6%id, 0.0%wa, 0.0%hi, 0.7%si
Events: 230K cycles
24.56% [kernel] [k] tg_load_down
5.76% [kernel] [k] __schedule
This happens because this particular kind of load triggers 'new idle'
rebalance very frequently, which requires calling update_h_load(),
which, in turn, calls tg_load_down() for every *idle* cpu cgroup even
though it is absolutely useless, because idle cpu cgroups have no tasks
to pull.
This patch tries to improve the situation by making h_load calculation
proceed only when h_load is really necessary. To achieve this, it
substitutes update_h_load() with update_cfs_rq_h_load(), which computes
h_load only for a given cfs_rq and all its ascendants, and makes the
load balancer call this function whenever it considers if a task should
be pulled, i.e. it moves h_load calculations directly to task_h_load().
For h_load of the same cfs_rq not to be updated multiple times (in case
several tasks in the same cgroup are considered during the same balance
run), the patch keeps the time of the last h_load update for each cfs_rq
and breaks calculation when it finds h_load to be uptodate.
The benefit of it is that h_load is computed only for those cfs_rq's,
which really need it, in particular all idle task groups are skipped.
Although this, in fact, moves h_load calculation under rq lock, it
should not affect latency much, because the amount of work done under rq
lock while trying to pull tasks is limited by sched_nr_migrate.
After the patch applied with the setup described above (1000 wakers in
the root cgroup and 10000 idle cgroups), I get:
Cpu(s): 16.9%us, 24.8%sy, 0.0%ni, 58.4%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 242K cycles
7.57% [kernel] [k] __schedule
6.70% [kernel] [k] timerqueue_add
5.93% libc-2.12.so [.] usleep
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1373896159-1278-1-git-send-email-vdavydov@parallels.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-15 13:49:19 +00:00
|
|
|
unsigned long load;
|
2012-08-08 19:46:40 +00:00
|
|
|
|
sched: Move h_load calculation to task_h_load()
The bad thing about update_h_load(), which computes hierarchical load
factor for task groups, is that it is called for each task group in the
system before every load balancer run, and since rebalance can be
triggered very often, this function can eat really a lot of cpu time if
there are many cpu cgroups in the system.
Although the situation was improved significantly by commit a35b646
('sched, cgroup: Reduce rq->lock hold times for large cgroup
hierarchies'), the problem still can arise under some kinds of loads,
e.g. when cpus are switching from idle to busy and back very frequently.
For instance, when I start 1000 of processes that wake up every
millisecond on my 8 cpus host, 'top' and 'perf top' show:
Cpu(s): 17.8%us, 24.3%sy, 0.0%ni, 57.9%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 243K cycles
7.57% [kernel] [k] __schedule
7.08% [kernel] [k] timerqueue_add
6.13% libc-2.12.so [.] usleep
Then if I create 10000 *idle* cpu cgroups (no processes in them), cpu
usage increases significantly although the 'wakers' are still executing
in the root cpu cgroup:
Cpu(s): 19.1%us, 48.7%sy, 0.0%ni, 31.6%id, 0.0%wa, 0.0%hi, 0.7%si
Events: 230K cycles
24.56% [kernel] [k] tg_load_down
5.76% [kernel] [k] __schedule
This happens because this particular kind of load triggers 'new idle'
rebalance very frequently, which requires calling update_h_load(),
which, in turn, calls tg_load_down() for every *idle* cpu cgroup even
though it is absolutely useless, because idle cpu cgroups have no tasks
to pull.
This patch tries to improve the situation by making h_load calculation
proceed only when h_load is really necessary. To achieve this, it
substitutes update_h_load() with update_cfs_rq_h_load(), which computes
h_load only for a given cfs_rq and all its ascendants, and makes the
load balancer call this function whenever it considers if a task should
be pulled, i.e. it moves h_load calculations directly to task_h_load().
For h_load of the same cfs_rq not to be updated multiple times (in case
several tasks in the same cgroup are considered during the same balance
run), the patch keeps the time of the last h_load update for each cfs_rq
and breaks calculation when it finds h_load to be uptodate.
The benefit of it is that h_load is computed only for those cfs_rq's,
which really need it, in particular all idle task groups are skipped.
Although this, in fact, moves h_load calculation under rq lock, it
should not affect latency much, because the amount of work done under rq
lock while trying to pull tasks is limited by sched_nr_migrate.
After the patch applied with the setup described above (1000 wakers in
the root cgroup and 10000 idle cgroups), I get:
Cpu(s): 16.9%us, 24.8%sy, 0.0%ni, 58.4%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 242K cycles
7.57% [kernel] [k] __schedule
6.70% [kernel] [k] timerqueue_add
5.93% libc-2.12.so [.] usleep
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1373896159-1278-1-git-send-email-vdavydov@parallels.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-15 13:49:19 +00:00
|
|
|
if (cfs_rq->last_h_load_update == now)
|
2012-08-08 19:46:40 +00:00
|
|
|
return;
|
|
|
|
|
sched: Move h_load calculation to task_h_load()
The bad thing about update_h_load(), which computes hierarchical load
factor for task groups, is that it is called for each task group in the
system before every load balancer run, and since rebalance can be
triggered very often, this function can eat really a lot of cpu time if
there are many cpu cgroups in the system.
Although the situation was improved significantly by commit a35b646
('sched, cgroup: Reduce rq->lock hold times for large cgroup
hierarchies'), the problem still can arise under some kinds of loads,
e.g. when cpus are switching from idle to busy and back very frequently.
For instance, when I start 1000 of processes that wake up every
millisecond on my 8 cpus host, 'top' and 'perf top' show:
Cpu(s): 17.8%us, 24.3%sy, 0.0%ni, 57.9%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 243K cycles
7.57% [kernel] [k] __schedule
7.08% [kernel] [k] timerqueue_add
6.13% libc-2.12.so [.] usleep
Then if I create 10000 *idle* cpu cgroups (no processes in them), cpu
usage increases significantly although the 'wakers' are still executing
in the root cpu cgroup:
Cpu(s): 19.1%us, 48.7%sy, 0.0%ni, 31.6%id, 0.0%wa, 0.0%hi, 0.7%si
Events: 230K cycles
24.56% [kernel] [k] tg_load_down
5.76% [kernel] [k] __schedule
This happens because this particular kind of load triggers 'new idle'
rebalance very frequently, which requires calling update_h_load(),
which, in turn, calls tg_load_down() for every *idle* cpu cgroup even
though it is absolutely useless, because idle cpu cgroups have no tasks
to pull.
This patch tries to improve the situation by making h_load calculation
proceed only when h_load is really necessary. To achieve this, it
substitutes update_h_load() with update_cfs_rq_h_load(), which computes
h_load only for a given cfs_rq and all its ascendants, and makes the
load balancer call this function whenever it considers if a task should
be pulled, i.e. it moves h_load calculations directly to task_h_load().
For h_load of the same cfs_rq not to be updated multiple times (in case
several tasks in the same cgroup are considered during the same balance
run), the patch keeps the time of the last h_load update for each cfs_rq
and breaks calculation when it finds h_load to be uptodate.
The benefit of it is that h_load is computed only for those cfs_rq's,
which really need it, in particular all idle task groups are skipped.
Although this, in fact, moves h_load calculation under rq lock, it
should not affect latency much, because the amount of work done under rq
lock while trying to pull tasks is limited by sched_nr_migrate.
After the patch applied with the setup described above (1000 wakers in
the root cgroup and 10000 idle cgroups), I get:
Cpu(s): 16.9%us, 24.8%sy, 0.0%ni, 58.4%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 242K cycles
7.57% [kernel] [k] __schedule
6.70% [kernel] [k] timerqueue_add
5.93% libc-2.12.so [.] usleep
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1373896159-1278-1-git-send-email-vdavydov@parallels.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-15 13:49:19 +00:00
|
|
|
cfs_rq->h_load_next = NULL;
|
|
|
|
for_each_sched_entity(se) {
|
|
|
|
cfs_rq = cfs_rq_of(se);
|
|
|
|
cfs_rq->h_load_next = se;
|
|
|
|
if (cfs_rq->last_h_load_update == now)
|
|
|
|
break;
|
|
|
|
}
|
2012-08-08 19:46:40 +00:00
|
|
|
|
sched: Move h_load calculation to task_h_load()
The bad thing about update_h_load(), which computes hierarchical load
factor for task groups, is that it is called for each task group in the
system before every load balancer run, and since rebalance can be
triggered very often, this function can eat really a lot of cpu time if
there are many cpu cgroups in the system.
Although the situation was improved significantly by commit a35b646
('sched, cgroup: Reduce rq->lock hold times for large cgroup
hierarchies'), the problem still can arise under some kinds of loads,
e.g. when cpus are switching from idle to busy and back very frequently.
For instance, when I start 1000 of processes that wake up every
millisecond on my 8 cpus host, 'top' and 'perf top' show:
Cpu(s): 17.8%us, 24.3%sy, 0.0%ni, 57.9%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 243K cycles
7.57% [kernel] [k] __schedule
7.08% [kernel] [k] timerqueue_add
6.13% libc-2.12.so [.] usleep
Then if I create 10000 *idle* cpu cgroups (no processes in them), cpu
usage increases significantly although the 'wakers' are still executing
in the root cpu cgroup:
Cpu(s): 19.1%us, 48.7%sy, 0.0%ni, 31.6%id, 0.0%wa, 0.0%hi, 0.7%si
Events: 230K cycles
24.56% [kernel] [k] tg_load_down
5.76% [kernel] [k] __schedule
This happens because this particular kind of load triggers 'new idle'
rebalance very frequently, which requires calling update_h_load(),
which, in turn, calls tg_load_down() for every *idle* cpu cgroup even
though it is absolutely useless, because idle cpu cgroups have no tasks
to pull.
This patch tries to improve the situation by making h_load calculation
proceed only when h_load is really necessary. To achieve this, it
substitutes update_h_load() with update_cfs_rq_h_load(), which computes
h_load only for a given cfs_rq and all its ascendants, and makes the
load balancer call this function whenever it considers if a task should
be pulled, i.e. it moves h_load calculations directly to task_h_load().
For h_load of the same cfs_rq not to be updated multiple times (in case
several tasks in the same cgroup are considered during the same balance
run), the patch keeps the time of the last h_load update for each cfs_rq
and breaks calculation when it finds h_load to be uptodate.
The benefit of it is that h_load is computed only for those cfs_rq's,
which really need it, in particular all idle task groups are skipped.
Although this, in fact, moves h_load calculation under rq lock, it
should not affect latency much, because the amount of work done under rq
lock while trying to pull tasks is limited by sched_nr_migrate.
After the patch applied with the setup described above (1000 wakers in
the root cgroup and 10000 idle cgroups), I get:
Cpu(s): 16.9%us, 24.8%sy, 0.0%ni, 58.4%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 242K cycles
7.57% [kernel] [k] __schedule
6.70% [kernel] [k] timerqueue_add
5.93% libc-2.12.so [.] usleep
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1373896159-1278-1-git-send-email-vdavydov@parallels.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-15 13:49:19 +00:00
|
|
|
if (!se) {
|
2015-07-15 00:04:42 +00:00
|
|
|
cfs_rq->h_load = cfs_rq_load_avg(cfs_rq);
|
sched: Move h_load calculation to task_h_load()
The bad thing about update_h_load(), which computes hierarchical load
factor for task groups, is that it is called for each task group in the
system before every load balancer run, and since rebalance can be
triggered very often, this function can eat really a lot of cpu time if
there are many cpu cgroups in the system.
Although the situation was improved significantly by commit a35b646
('sched, cgroup: Reduce rq->lock hold times for large cgroup
hierarchies'), the problem still can arise under some kinds of loads,
e.g. when cpus are switching from idle to busy and back very frequently.
For instance, when I start 1000 of processes that wake up every
millisecond on my 8 cpus host, 'top' and 'perf top' show:
Cpu(s): 17.8%us, 24.3%sy, 0.0%ni, 57.9%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 243K cycles
7.57% [kernel] [k] __schedule
7.08% [kernel] [k] timerqueue_add
6.13% libc-2.12.so [.] usleep
Then if I create 10000 *idle* cpu cgroups (no processes in them), cpu
usage increases significantly although the 'wakers' are still executing
in the root cpu cgroup:
Cpu(s): 19.1%us, 48.7%sy, 0.0%ni, 31.6%id, 0.0%wa, 0.0%hi, 0.7%si
Events: 230K cycles
24.56% [kernel] [k] tg_load_down
5.76% [kernel] [k] __schedule
This happens because this particular kind of load triggers 'new idle'
rebalance very frequently, which requires calling update_h_load(),
which, in turn, calls tg_load_down() for every *idle* cpu cgroup even
though it is absolutely useless, because idle cpu cgroups have no tasks
to pull.
This patch tries to improve the situation by making h_load calculation
proceed only when h_load is really necessary. To achieve this, it
substitutes update_h_load() with update_cfs_rq_h_load(), which computes
h_load only for a given cfs_rq and all its ascendants, and makes the
load balancer call this function whenever it considers if a task should
be pulled, i.e. it moves h_load calculations directly to task_h_load().
For h_load of the same cfs_rq not to be updated multiple times (in case
several tasks in the same cgroup are considered during the same balance
run), the patch keeps the time of the last h_load update for each cfs_rq
and breaks calculation when it finds h_load to be uptodate.
The benefit of it is that h_load is computed only for those cfs_rq's,
which really need it, in particular all idle task groups are skipped.
Although this, in fact, moves h_load calculation under rq lock, it
should not affect latency much, because the amount of work done under rq
lock while trying to pull tasks is limited by sched_nr_migrate.
After the patch applied with the setup described above (1000 wakers in
the root cgroup and 10000 idle cgroups), I get:
Cpu(s): 16.9%us, 24.8%sy, 0.0%ni, 58.4%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 242K cycles
7.57% [kernel] [k] __schedule
6.70% [kernel] [k] timerqueue_add
5.93% libc-2.12.so [.] usleep
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1373896159-1278-1-git-send-email-vdavydov@parallels.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-15 13:49:19 +00:00
|
|
|
cfs_rq->last_h_load_update = now;
|
|
|
|
}
|
|
|
|
|
|
|
|
while ((se = cfs_rq->h_load_next) != NULL) {
|
|
|
|
load = cfs_rq->h_load;
|
2015-07-15 00:04:42 +00:00
|
|
|
load = div64_ul(load * se->avg.load_avg,
|
|
|
|
cfs_rq_load_avg(cfs_rq) + 1);
|
sched: Move h_load calculation to task_h_load()
The bad thing about update_h_load(), which computes hierarchical load
factor for task groups, is that it is called for each task group in the
system before every load balancer run, and since rebalance can be
triggered very often, this function can eat really a lot of cpu time if
there are many cpu cgroups in the system.
Although the situation was improved significantly by commit a35b646
('sched, cgroup: Reduce rq->lock hold times for large cgroup
hierarchies'), the problem still can arise under some kinds of loads,
e.g. when cpus are switching from idle to busy and back very frequently.
For instance, when I start 1000 of processes that wake up every
millisecond on my 8 cpus host, 'top' and 'perf top' show:
Cpu(s): 17.8%us, 24.3%sy, 0.0%ni, 57.9%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 243K cycles
7.57% [kernel] [k] __schedule
7.08% [kernel] [k] timerqueue_add
6.13% libc-2.12.so [.] usleep
Then if I create 10000 *idle* cpu cgroups (no processes in them), cpu
usage increases significantly although the 'wakers' are still executing
in the root cpu cgroup:
Cpu(s): 19.1%us, 48.7%sy, 0.0%ni, 31.6%id, 0.0%wa, 0.0%hi, 0.7%si
Events: 230K cycles
24.56% [kernel] [k] tg_load_down
5.76% [kernel] [k] __schedule
This happens because this particular kind of load triggers 'new idle'
rebalance very frequently, which requires calling update_h_load(),
which, in turn, calls tg_load_down() for every *idle* cpu cgroup even
though it is absolutely useless, because idle cpu cgroups have no tasks
to pull.
This patch tries to improve the situation by making h_load calculation
proceed only when h_load is really necessary. To achieve this, it
substitutes update_h_load() with update_cfs_rq_h_load(), which computes
h_load only for a given cfs_rq and all its ascendants, and makes the
load balancer call this function whenever it considers if a task should
be pulled, i.e. it moves h_load calculations directly to task_h_load().
For h_load of the same cfs_rq not to be updated multiple times (in case
several tasks in the same cgroup are considered during the same balance
run), the patch keeps the time of the last h_load update for each cfs_rq
and breaks calculation when it finds h_load to be uptodate.
The benefit of it is that h_load is computed only for those cfs_rq's,
which really need it, in particular all idle task groups are skipped.
Although this, in fact, moves h_load calculation under rq lock, it
should not affect latency much, because the amount of work done under rq
lock while trying to pull tasks is limited by sched_nr_migrate.
After the patch applied with the setup described above (1000 wakers in
the root cgroup and 10000 idle cgroups), I get:
Cpu(s): 16.9%us, 24.8%sy, 0.0%ni, 58.4%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 242K cycles
7.57% [kernel] [k] __schedule
6.70% [kernel] [k] timerqueue_add
5.93% libc-2.12.so [.] usleep
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1373896159-1278-1-git-send-email-vdavydov@parallels.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-15 13:49:19 +00:00
|
|
|
cfs_rq = group_cfs_rq(se);
|
|
|
|
cfs_rq->h_load = load;
|
|
|
|
cfs_rq->last_h_load_update = now;
|
|
|
|
}
|
2011-07-13 11:09:25 +00:00
|
|
|
}
|
|
|
|
|
2012-02-20 20:49:09 +00:00
|
|
|
static unsigned long task_h_load(struct task_struct *p)
|
2009-12-17 16:47:12 +00:00
|
|
|
{
|
2012-02-20 20:49:09 +00:00
|
|
|
struct cfs_rq *cfs_rq = task_cfs_rq(p);
|
2009-12-17 16:47:12 +00:00
|
|
|
|
sched: Move h_load calculation to task_h_load()
The bad thing about update_h_load(), which computes hierarchical load
factor for task groups, is that it is called for each task group in the
system before every load balancer run, and since rebalance can be
triggered very often, this function can eat really a lot of cpu time if
there are many cpu cgroups in the system.
Although the situation was improved significantly by commit a35b646
('sched, cgroup: Reduce rq->lock hold times for large cgroup
hierarchies'), the problem still can arise under some kinds of loads,
e.g. when cpus are switching from idle to busy and back very frequently.
For instance, when I start 1000 of processes that wake up every
millisecond on my 8 cpus host, 'top' and 'perf top' show:
Cpu(s): 17.8%us, 24.3%sy, 0.0%ni, 57.9%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 243K cycles
7.57% [kernel] [k] __schedule
7.08% [kernel] [k] timerqueue_add
6.13% libc-2.12.so [.] usleep
Then if I create 10000 *idle* cpu cgroups (no processes in them), cpu
usage increases significantly although the 'wakers' are still executing
in the root cpu cgroup:
Cpu(s): 19.1%us, 48.7%sy, 0.0%ni, 31.6%id, 0.0%wa, 0.0%hi, 0.7%si
Events: 230K cycles
24.56% [kernel] [k] tg_load_down
5.76% [kernel] [k] __schedule
This happens because this particular kind of load triggers 'new idle'
rebalance very frequently, which requires calling update_h_load(),
which, in turn, calls tg_load_down() for every *idle* cpu cgroup even
though it is absolutely useless, because idle cpu cgroups have no tasks
to pull.
This patch tries to improve the situation by making h_load calculation
proceed only when h_load is really necessary. To achieve this, it
substitutes update_h_load() with update_cfs_rq_h_load(), which computes
h_load only for a given cfs_rq and all its ascendants, and makes the
load balancer call this function whenever it considers if a task should
be pulled, i.e. it moves h_load calculations directly to task_h_load().
For h_load of the same cfs_rq not to be updated multiple times (in case
several tasks in the same cgroup are considered during the same balance
run), the patch keeps the time of the last h_load update for each cfs_rq
and breaks calculation when it finds h_load to be uptodate.
The benefit of it is that h_load is computed only for those cfs_rq's,
which really need it, in particular all idle task groups are skipped.
Although this, in fact, moves h_load calculation under rq lock, it
should not affect latency much, because the amount of work done under rq
lock while trying to pull tasks is limited by sched_nr_migrate.
After the patch applied with the setup described above (1000 wakers in
the root cgroup and 10000 idle cgroups), I get:
Cpu(s): 16.9%us, 24.8%sy, 0.0%ni, 58.4%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 242K cycles
7.57% [kernel] [k] __schedule
6.70% [kernel] [k] timerqueue_add
5.93% libc-2.12.so [.] usleep
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1373896159-1278-1-git-send-email-vdavydov@parallels.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-15 13:49:19 +00:00
|
|
|
update_cfs_rq_h_load(cfs_rq);
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
return div64_ul(p->se.avg.load_avg * cfs_rq->h_load,
|
2015-07-15 00:04:42 +00:00
|
|
|
cfs_rq_load_avg(cfs_rq) + 1);
|
2009-12-17 16:47:12 +00:00
|
|
|
}
|
|
|
|
#else
|
2012-10-04 11:18:31 +00:00
|
|
|
static inline void update_blocked_averages(int cpu)
|
2010-11-15 23:47:02 +00:00
|
|
|
{
|
2015-07-15 00:04:38 +00:00
|
|
|
struct rq *rq = cpu_rq(cpu);
|
|
|
|
struct cfs_rq *cfs_rq = &rq->cfs;
|
2016-10-04 14:04:35 +00:00
|
|
|
struct rq_flags rf;
|
2015-07-15 00:04:38 +00:00
|
|
|
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_lock_irqsave(rq, &rf);
|
2015-07-15 00:04:38 +00:00
|
|
|
update_rq_clock(rq);
|
2017-05-24 05:29:56 +00:00
|
|
|
update_cfs_rq_load_avg(cfs_rq_clock_task(cfs_rq), cfs_rq);
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_unlock_irqrestore(rq, &rf);
|
2010-11-15 23:47:02 +00:00
|
|
|
}
|
|
|
|
|
2012-02-20 20:49:09 +00:00
|
|
|
static unsigned long task_h_load(struct task_struct *p)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
return p->se.avg.load_avg;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
2009-12-17 16:47:12 +00:00
|
|
|
#endif
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
/********** Helpers for find_busiest_group ************************/
|
2014-07-28 18:16:28 +00:00
|
|
|
|
|
|
|
enum group_type {
|
|
|
|
group_other = 0,
|
|
|
|
group_imbalanced,
|
|
|
|
group_overloaded,
|
|
|
|
};
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/*
|
|
|
|
* sg_lb_stats - stats of a sched_group required for load_balancing
|
|
|
|
*/
|
|
|
|
struct sg_lb_stats {
|
|
|
|
unsigned long avg_load; /*Avg load across the CPUs of the group */
|
|
|
|
unsigned long group_load; /* Total load over the CPUs of the group */
|
|
|
|
unsigned long sum_weighted_load; /* Weighted load of group's tasks */
|
2013-08-06 08:36:43 +00:00
|
|
|
unsigned long load_per_task;
|
2014-05-26 22:19:37 +00:00
|
|
|
unsigned long group_capacity;
|
2015-08-14 16:23:12 +00:00
|
|
|
unsigned long group_util; /* Total utilization of the group */
|
2013-08-19 13:22:57 +00:00
|
|
|
unsigned int sum_nr_running; /* Nr tasks running in the group */
|
|
|
|
unsigned int idle_cpus;
|
|
|
|
unsigned int group_weight;
|
2014-07-28 18:16:28 +00:00
|
|
|
enum group_type group_type;
|
2015-02-27 15:54:11 +00:00
|
|
|
int group_no_capacity;
|
2013-10-07 10:29:33 +00:00
|
|
|
#ifdef CONFIG_NUMA_BALANCING
|
|
|
|
unsigned int nr_numa_running;
|
|
|
|
unsigned int nr_preferred_running;
|
|
|
|
#endif
|
2009-12-17 16:00:43 +00:00
|
|
|
};
|
|
|
|
|
2013-08-06 08:36:43 +00:00
|
|
|
/*
|
|
|
|
* sd_lb_stats - Structure to store the statistics of a sched_domain
|
|
|
|
* during load balancing.
|
|
|
|
*/
|
|
|
|
struct sd_lb_stats {
|
|
|
|
struct sched_group *busiest; /* Busiest group in this sd */
|
|
|
|
struct sched_group *local; /* Local group in this sd */
|
2017-07-31 15:50:05 +00:00
|
|
|
unsigned long total_running;
|
2013-08-06 08:36:43 +00:00
|
|
|
unsigned long total_load; /* Total load of all groups in sd */
|
2014-05-26 22:19:37 +00:00
|
|
|
unsigned long total_capacity; /* Total capacity of all groups in sd */
|
2013-08-06 08:36:43 +00:00
|
|
|
unsigned long avg_load; /* Average load across all groups in sd */
|
|
|
|
|
|
|
|
struct sg_lb_stats busiest_stat;/* Statistics of the busiest group */
|
2013-08-19 13:22:57 +00:00
|
|
|
struct sg_lb_stats local_stat; /* Statistics of the local group */
|
2013-08-06 08:36:43 +00:00
|
|
|
};
|
|
|
|
|
2013-08-19 13:22:57 +00:00
|
|
|
static inline void init_sd_lb_stats(struct sd_lb_stats *sds)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Skimp on the clearing to avoid duplicate work. We can avoid clearing
|
|
|
|
* local_stat because update_sg_lb_stats() does a full clear/assignment.
|
|
|
|
* We must however clear busiest_stat::avg_load because
|
|
|
|
* update_sd_pick_busiest() reads this before assignment.
|
|
|
|
*/
|
|
|
|
*sds = (struct sd_lb_stats){
|
|
|
|
.busiest = NULL,
|
|
|
|
.local = NULL,
|
2017-07-31 15:50:05 +00:00
|
|
|
.total_running = 0UL,
|
2013-08-19 13:22:57 +00:00
|
|
|
.total_load = 0UL,
|
2014-05-26 22:19:37 +00:00
|
|
|
.total_capacity = 0UL,
|
2013-08-19 13:22:57 +00:00
|
|
|
.busiest_stat = {
|
|
|
|
.avg_load = 0UL,
|
2014-07-28 18:16:28 +00:00
|
|
|
.sum_nr_running = 0,
|
|
|
|
.group_type = group_other,
|
2013-08-19 13:22:57 +00:00
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/**
|
|
|
|
* get_sd_load_idx - Obtain the load index for a given sched domain.
|
|
|
|
* @sd: The sched_domain whose load_idx is to be obtained.
|
2013-10-13 17:36:15 +00:00
|
|
|
* @idle: The idle status of the CPU for whose sd load_idx is obtained.
|
2013-07-12 18:45:47 +00:00
|
|
|
*
|
|
|
|
* Return: The load index.
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
|
|
|
static inline int get_sd_load_idx(struct sched_domain *sd,
|
|
|
|
enum cpu_idle_type idle)
|
|
|
|
{
|
|
|
|
int load_idx;
|
|
|
|
|
|
|
|
switch (idle) {
|
|
|
|
case CPU_NOT_IDLE:
|
|
|
|
load_idx = sd->busy_idx;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CPU_NEWLY_IDLE:
|
|
|
|
load_idx = sd->newidle_idx;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
load_idx = sd->idle_idx;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return load_idx;
|
|
|
|
}
|
|
|
|
|
2014-05-26 22:19:38 +00:00
|
|
|
static unsigned long scale_rt_capacity(int cpu)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
2015-02-27 15:54:08 +00:00
|
|
|
u64 total, used, age_stamp, avg;
|
2014-02-27 09:40:35 +00:00
|
|
|
s64 delta;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2012-05-22 12:04:28 +00:00
|
|
|
/*
|
|
|
|
* Since we're reading these variables without serialization make sure
|
|
|
|
* we read them once before doing sanity checks on them.
|
|
|
|
*/
|
2015-04-28 20:00:20 +00:00
|
|
|
age_stamp = READ_ONCE(rq->age_stamp);
|
|
|
|
avg = READ_ONCE(rq->rt_avg);
|
2015-01-05 10:18:10 +00:00
|
|
|
delta = __rq_clock_broken(rq) - age_stamp;
|
2012-05-22 12:04:28 +00:00
|
|
|
|
2014-02-27 09:40:35 +00:00
|
|
|
if (unlikely(delta < 0))
|
|
|
|
delta = 0;
|
|
|
|
|
|
|
|
total = sched_avg_period() + delta;
|
2010-10-05 00:03:22 +00:00
|
|
|
|
2015-02-27 15:54:08 +00:00
|
|
|
used = div_u64(avg, total);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2015-02-27 15:54:08 +00:00
|
|
|
if (likely(used < SCHED_CAPACITY_SCALE))
|
|
|
|
return SCHED_CAPACITY_SCALE - used;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2015-02-27 15:54:08 +00:00
|
|
|
return 1;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
2014-05-26 22:19:38 +00:00
|
|
|
static void update_cpu_capacity(struct sched_domain *sd, int cpu)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2015-08-14 16:23:10 +00:00
|
|
|
unsigned long capacity = arch_scale_cpu_capacity(sd, cpu);
|
2009-12-17 16:00:43 +00:00
|
|
|
struct sched_group *sdg = sd->groups;
|
|
|
|
|
2015-02-27 15:54:09 +00:00
|
|
|
cpu_rq(cpu)->cpu_capacity_orig = capacity;
|
2010-06-08 04:57:02 +00:00
|
|
|
|
2014-05-26 22:19:38 +00:00
|
|
|
capacity *= scale_rt_capacity(cpu);
|
2014-05-26 22:19:39 +00:00
|
|
|
capacity >>= SCHED_CAPACITY_SHIFT;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2014-05-26 22:19:38 +00:00
|
|
|
if (!capacity)
|
|
|
|
capacity = 1;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2014-05-26 22:19:38 +00:00
|
|
|
cpu_rq(cpu)->cpu_capacity = capacity;
|
|
|
|
sdg->sgc->capacity = capacity;
|
2016-10-14 13:41:09 +00:00
|
|
|
sdg->sgc->min_capacity = capacity;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
2014-05-26 22:19:37 +00:00
|
|
|
void update_group_capacity(struct sched_domain *sd, int cpu)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
|
|
|
struct sched_domain *child = sd->child;
|
|
|
|
struct sched_group *group, *sdg = sd->groups;
|
2016-10-14 13:41:09 +00:00
|
|
|
unsigned long capacity, min_capacity;
|
2011-12-12 19:21:08 +00:00
|
|
|
unsigned long interval;
|
|
|
|
|
|
|
|
interval = msecs_to_jiffies(sd->balance_interval);
|
|
|
|
interval = clamp(interval, 1UL, max_load_balance_interval);
|
2014-05-26 22:19:37 +00:00
|
|
|
sdg->sgc->next_update = jiffies + interval;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
if (!child) {
|
2014-05-26 22:19:38 +00:00
|
|
|
update_cpu_capacity(sd, cpu);
|
2009-12-17 16:00:43 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-03-03 10:35:03 +00:00
|
|
|
capacity = 0;
|
2016-10-14 13:41:09 +00:00
|
|
|
min_capacity = ULONG_MAX;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2012-05-23 16:00:43 +00:00
|
|
|
if (child->flags & SD_OVERLAP) {
|
|
|
|
/*
|
|
|
|
* SD_OVERLAP domains cannot assume that child groups
|
|
|
|
* span the current group.
|
|
|
|
*/
|
|
|
|
|
2017-05-01 09:03:12 +00:00
|
|
|
for_each_cpu(cpu, sched_group_span(sdg)) {
|
2014-05-26 22:19:37 +00:00
|
|
|
struct sched_group_capacity *sgc;
|
2013-11-12 16:41:26 +00:00
|
|
|
struct rq *rq = cpu_rq(cpu);
|
2013-08-28 09:44:39 +00:00
|
|
|
|
2013-11-12 16:41:26 +00:00
|
|
|
/*
|
2014-05-26 22:19:37 +00:00
|
|
|
* build_sched_domains() -> init_sched_groups_capacity()
|
2013-11-12 16:41:26 +00:00
|
|
|
* gets here before we've attached the domains to the
|
|
|
|
* runqueues.
|
|
|
|
*
|
2014-05-26 22:19:38 +00:00
|
|
|
* Use capacity_of(), which is set irrespective of domains
|
|
|
|
* in update_cpu_capacity().
|
2013-11-12 16:41:26 +00:00
|
|
|
*
|
2015-03-03 10:35:03 +00:00
|
|
|
* This avoids capacity from being 0 and
|
2013-11-12 16:41:26 +00:00
|
|
|
* causing divide-by-zero issues on boot.
|
|
|
|
*/
|
|
|
|
if (unlikely(!rq->sd)) {
|
2014-05-26 22:19:38 +00:00
|
|
|
capacity += capacity_of(cpu);
|
2016-10-14 13:41:09 +00:00
|
|
|
} else {
|
|
|
|
sgc = rq->sd->groups->sgc;
|
|
|
|
capacity += sgc->capacity;
|
2013-11-12 16:41:26 +00:00
|
|
|
}
|
2013-08-28 09:44:39 +00:00
|
|
|
|
2016-10-14 13:41:09 +00:00
|
|
|
min_capacity = min(capacity, min_capacity);
|
2013-08-28 09:44:39 +00:00
|
|
|
}
|
2012-05-23 16:00:43 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* !SD_OVERLAP domains can assume that child groups
|
|
|
|
* span the current group.
|
2015-07-05 09:33:48 +00:00
|
|
|
*/
|
2012-05-23 16:00:43 +00:00
|
|
|
|
|
|
|
group = child->groups;
|
|
|
|
do {
|
2016-10-14 13:41:09 +00:00
|
|
|
struct sched_group_capacity *sgc = group->sgc;
|
|
|
|
|
|
|
|
capacity += sgc->capacity;
|
|
|
|
min_capacity = min(sgc->min_capacity, min_capacity);
|
2012-05-23 16:00:43 +00:00
|
|
|
group = group->next;
|
|
|
|
} while (group != child->groups);
|
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2014-05-26 22:19:37 +00:00
|
|
|
sdg->sgc->capacity = capacity;
|
2016-10-14 13:41:09 +00:00
|
|
|
sdg->sgc->min_capacity = min_capacity;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
2010-06-08 04:57:02 +00:00
|
|
|
/*
|
2015-02-27 15:54:11 +00:00
|
|
|
* Check whether the capacity of the rq has been noticeably reduced by side
|
|
|
|
* activity. The imbalance_pct is used for the threshold.
|
|
|
|
* Return true is the capacity is reduced
|
2010-06-08 04:57:02 +00:00
|
|
|
*/
|
|
|
|
static inline int
|
2015-02-27 15:54:11 +00:00
|
|
|
check_cpu_capacity(struct rq *rq, struct sched_domain *sd)
|
2010-06-08 04:57:02 +00:00
|
|
|
{
|
2015-02-27 15:54:11 +00:00
|
|
|
return ((rq->cpu_capacity * sd->imbalance_pct) <
|
|
|
|
(rq->cpu_capacity_orig * 100));
|
2010-06-08 04:57:02 +00:00
|
|
|
}
|
|
|
|
|
2013-08-15 18:29:29 +00:00
|
|
|
/*
|
|
|
|
* Group imbalance indicates (and tries to solve) the problem where balancing
|
2017-02-05 14:38:10 +00:00
|
|
|
* groups is inadequate due to ->cpus_allowed constraints.
|
2013-08-15 18:29:29 +00:00
|
|
|
*
|
|
|
|
* Imagine a situation of two groups of 4 cpus each and 4 tasks each with a
|
|
|
|
* cpumask covering 1 cpu of the first group and 3 cpus of the second group.
|
|
|
|
* Something like:
|
|
|
|
*
|
2016-11-23 06:37:00 +00:00
|
|
|
* { 0 1 2 3 } { 4 5 6 7 }
|
|
|
|
* * * * *
|
2013-08-15 18:29:29 +00:00
|
|
|
*
|
|
|
|
* If we were to balance group-wise we'd place two tasks in the first group and
|
|
|
|
* two tasks in the second group. Clearly this is undesired as it will overload
|
|
|
|
* cpu 3 and leave one of the cpus in the second group unused.
|
|
|
|
*
|
|
|
|
* The current solution to this issue is detecting the skew in the first group
|
2013-08-19 10:41:09 +00:00
|
|
|
* by noticing the lower domain failed to reach balance and had difficulty
|
|
|
|
* moving tasks due to affinity constraints.
|
2013-08-15 18:29:29 +00:00
|
|
|
*
|
|
|
|
* When this is so detected; this group becomes a candidate for busiest; see
|
2013-10-13 17:36:15 +00:00
|
|
|
* update_sd_pick_busiest(). And calculate_imbalance() and
|
2013-08-19 10:41:09 +00:00
|
|
|
* find_busiest_group() avoid some of the usual balance conditions to allow it
|
2013-08-15 18:29:29 +00:00
|
|
|
* to create an effective group imbalance.
|
|
|
|
*
|
|
|
|
* This is a somewhat tricky proposition since the next run might not find the
|
|
|
|
* group imbalance and decide the groups need to be balanced again. A most
|
|
|
|
* subtle and fragile situation.
|
|
|
|
*/
|
|
|
|
|
2013-08-19 10:41:09 +00:00
|
|
|
static inline int sg_imbalanced(struct sched_group *group)
|
2013-08-15 18:29:29 +00:00
|
|
|
{
|
2014-05-26 22:19:37 +00:00
|
|
|
return group->sgc->imbalance;
|
2013-08-15 18:29:29 +00:00
|
|
|
}
|
|
|
|
|
2013-08-28 09:50:34 +00:00
|
|
|
/*
|
2015-02-27 15:54:11 +00:00
|
|
|
* group_has_capacity returns true if the group has spare capacity that could
|
|
|
|
* be used by some tasks.
|
|
|
|
* We consider that a group has spare capacity if the * number of task is
|
2015-08-14 16:23:12 +00:00
|
|
|
* smaller than the number of CPUs or if the utilization is lower than the
|
|
|
|
* available capacity for CFS tasks.
|
2015-02-27 15:54:11 +00:00
|
|
|
* For the latter, we use a threshold to stabilize the state, to take into
|
|
|
|
* account the variance of the tasks' load and to return true if the available
|
|
|
|
* capacity in meaningful for the load balancer.
|
|
|
|
* As an example, an available capacity of 1% can appear but it doesn't make
|
|
|
|
* any benefit for the load balance.
|
2013-08-28 09:50:34 +00:00
|
|
|
*/
|
2015-02-27 15:54:11 +00:00
|
|
|
static inline bool
|
|
|
|
group_has_capacity(struct lb_env *env, struct sg_lb_stats *sgs)
|
2013-08-28 09:50:34 +00:00
|
|
|
{
|
2015-02-27 15:54:11 +00:00
|
|
|
if (sgs->sum_nr_running < sgs->group_weight)
|
|
|
|
return true;
|
2013-08-28 10:40:38 +00:00
|
|
|
|
2015-02-27 15:54:11 +00:00
|
|
|
if ((sgs->group_capacity * 100) >
|
2015-08-14 16:23:12 +00:00
|
|
|
(sgs->group_util * env->sd->imbalance_pct))
|
2015-02-27 15:54:11 +00:00
|
|
|
return true;
|
2013-08-28 09:50:34 +00:00
|
|
|
|
2015-02-27 15:54:11 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* group_is_overloaded returns true if the group has more tasks than it can
|
|
|
|
* handle.
|
|
|
|
* group_is_overloaded is not equals to !group_has_capacity because a group
|
|
|
|
* with the exact right number of tasks, has no more spare capacity but is not
|
|
|
|
* overloaded so both group_has_capacity and group_is_overloaded return
|
|
|
|
* false.
|
|
|
|
*/
|
|
|
|
static inline bool
|
|
|
|
group_is_overloaded(struct lb_env *env, struct sg_lb_stats *sgs)
|
|
|
|
{
|
|
|
|
if (sgs->sum_nr_running <= sgs->group_weight)
|
|
|
|
return false;
|
2013-08-28 09:50:34 +00:00
|
|
|
|
2015-02-27 15:54:11 +00:00
|
|
|
if ((sgs->group_capacity * 100) <
|
2015-08-14 16:23:12 +00:00
|
|
|
(sgs->group_util * env->sd->imbalance_pct))
|
2015-02-27 15:54:11 +00:00
|
|
|
return true;
|
2013-08-28 09:50:34 +00:00
|
|
|
|
2015-02-27 15:54:11 +00:00
|
|
|
return false;
|
2013-08-28 09:50:34 +00:00
|
|
|
}
|
|
|
|
|
2016-10-14 13:41:10 +00:00
|
|
|
/*
|
|
|
|
* group_smaller_cpu_capacity: Returns true if sched_group sg has smaller
|
|
|
|
* per-CPU capacity than sched_group ref.
|
|
|
|
*/
|
|
|
|
static inline bool
|
|
|
|
group_smaller_cpu_capacity(struct sched_group *sg, struct sched_group *ref)
|
|
|
|
{
|
|
|
|
return sg->sgc->min_capacity * capacity_margin <
|
|
|
|
ref->sgc->min_capacity * 1024;
|
|
|
|
}
|
|
|
|
|
2015-09-15 10:56:45 +00:00
|
|
|
static inline enum
|
|
|
|
group_type group_classify(struct sched_group *group,
|
|
|
|
struct sg_lb_stats *sgs)
|
2014-07-28 18:16:28 +00:00
|
|
|
{
|
2015-02-27 15:54:11 +00:00
|
|
|
if (sgs->group_no_capacity)
|
2014-07-28 18:16:28 +00:00
|
|
|
return group_overloaded;
|
|
|
|
|
|
|
|
if (sg_imbalanced(group))
|
|
|
|
return group_imbalanced;
|
|
|
|
|
|
|
|
return group_other;
|
|
|
|
}
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/**
|
|
|
|
* update_sg_lb_stats - Update sched_group's statistics for load balancing.
|
2012-06-08 20:18:33 +00:00
|
|
|
* @env: The load balancing environment.
|
2009-12-17 16:00:43 +00:00
|
|
|
* @group: sched_group whose statistics are to be updated.
|
|
|
|
* @load_idx: Load index of sched_domain of this_cpu for load calc.
|
|
|
|
* @local_group: Does group contain this_cpu.
|
|
|
|
* @sgs: variable to hold the statistics for this group.
|
2014-07-28 03:38:06 +00:00
|
|
|
* @overload: Indicate more than one runnable task for any CPU.
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2012-05-02 12:20:37 +00:00
|
|
|
static inline void update_sg_lb_stats(struct lb_env *env,
|
|
|
|
struct sched_group *group, int load_idx,
|
2014-06-23 19:16:49 +00:00
|
|
|
int local_group, struct sg_lb_stats *sgs,
|
|
|
|
bool *overload)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2013-08-15 18:29:29 +00:00
|
|
|
unsigned long load;
|
2015-11-25 19:09:38 +00:00
|
|
|
int i, nr_running;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2013-08-28 08:32:32 +00:00
|
|
|
memset(sgs, 0, sizeof(*sgs));
|
|
|
|
|
2017-05-01 09:03:12 +00:00
|
|
|
for_each_cpu_and(i, sched_group_span(group), env->cpus) {
|
2009-12-17 16:00:43 +00:00
|
|
|
struct rq *rq = cpu_rq(i);
|
|
|
|
|
|
|
|
/* Bias balancing toward cpus of our domain */
|
2013-08-19 10:41:09 +00:00
|
|
|
if (local_group)
|
2012-05-10 22:12:02 +00:00
|
|
|
load = target_load(i, load_idx);
|
2013-08-19 10:41:09 +00:00
|
|
|
else
|
2009-12-17 16:00:43 +00:00
|
|
|
load = source_load(i, load_idx);
|
|
|
|
|
|
|
|
sgs->group_load += load;
|
2015-08-14 16:23:12 +00:00
|
|
|
sgs->group_util += cpu_util(i);
|
2014-08-26 11:06:46 +00:00
|
|
|
sgs->sum_nr_running += rq->cfs.h_nr_running;
|
2014-06-23 19:16:49 +00:00
|
|
|
|
2015-11-25 19:09:38 +00:00
|
|
|
nr_running = rq->nr_running;
|
|
|
|
if (nr_running > 1)
|
2014-06-23 19:16:49 +00:00
|
|
|
*overload = true;
|
|
|
|
|
2013-10-07 10:29:33 +00:00
|
|
|
#ifdef CONFIG_NUMA_BALANCING
|
|
|
|
sgs->nr_numa_running += rq->nr_numa_running;
|
|
|
|
sgs->nr_preferred_running += rq->nr_preferred_running;
|
|
|
|
#endif
|
2017-05-24 05:29:54 +00:00
|
|
|
sgs->sum_weighted_load += weighted_cpuload(rq);
|
2015-11-25 19:09:38 +00:00
|
|
|
/*
|
|
|
|
* No need to call idle_cpu() if nr_running is not 0
|
|
|
|
*/
|
|
|
|
if (!nr_running && idle_cpu(i))
|
2010-09-17 22:02:32 +00:00
|
|
|
sgs->idle_cpus++;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
2014-05-26 22:19:37 +00:00
|
|
|
/* Adjust by relative CPU capacity of the group */
|
|
|
|
sgs->group_capacity = group->sgc->capacity;
|
2014-05-26 22:19:39 +00:00
|
|
|
sgs->avg_load = (sgs->group_load*SCHED_CAPACITY_SCALE) / sgs->group_capacity;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2010-02-24 00:13:52 +00:00
|
|
|
if (sgs->sum_nr_running)
|
2013-08-15 17:47:56 +00:00
|
|
|
sgs->load_per_task = sgs->sum_weighted_load / sgs->sum_nr_running;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2010-09-17 22:02:32 +00:00
|
|
|
sgs->group_weight = group->group_weight;
|
2013-08-28 09:50:34 +00:00
|
|
|
|
2015-02-27 15:54:11 +00:00
|
|
|
sgs->group_no_capacity = group_is_overloaded(env, sgs);
|
2015-09-15 10:56:45 +00:00
|
|
|
sgs->group_type = group_classify(group, sgs);
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
2010-06-08 04:57:02 +00:00
|
|
|
/**
|
|
|
|
* update_sd_pick_busiest - return 1 on busiest group
|
2012-06-08 20:18:33 +00:00
|
|
|
* @env: The load balancing environment.
|
2010-06-08 04:57:02 +00:00
|
|
|
* @sds: sched_domain statistics
|
|
|
|
* @sg: sched_group candidate to be checked for being the busiest
|
2010-06-10 02:06:21 +00:00
|
|
|
* @sgs: sched_group statistics
|
2010-06-08 04:57:02 +00:00
|
|
|
*
|
|
|
|
* Determine if @sg is a busier group than the previously selected
|
|
|
|
* busiest group.
|
2013-07-12 18:45:47 +00:00
|
|
|
*
|
|
|
|
* Return: %true if @sg is a busier group than the previously selected
|
|
|
|
* busiest group. %false otherwise.
|
2010-06-08 04:57:02 +00:00
|
|
|
*/
|
2012-05-02 12:20:37 +00:00
|
|
|
static bool update_sd_pick_busiest(struct lb_env *env,
|
2010-06-08 04:57:02 +00:00
|
|
|
struct sd_lb_stats *sds,
|
|
|
|
struct sched_group *sg,
|
2012-05-02 12:20:37 +00:00
|
|
|
struct sg_lb_stats *sgs)
|
2010-06-08 04:57:02 +00:00
|
|
|
{
|
2014-07-28 18:16:28 +00:00
|
|
|
struct sg_lb_stats *busiest = &sds->busiest_stat;
|
2010-06-08 04:57:02 +00:00
|
|
|
|
2014-07-28 18:16:28 +00:00
|
|
|
if (sgs->group_type > busiest->group_type)
|
2010-06-08 04:57:02 +00:00
|
|
|
return true;
|
|
|
|
|
2014-07-28 18:16:28 +00:00
|
|
|
if (sgs->group_type < busiest->group_type)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (sgs->avg_load <= busiest->avg_load)
|
|
|
|
return false;
|
|
|
|
|
2016-10-14 13:41:10 +00:00
|
|
|
if (!(env->sd->flags & SD_ASYM_CPUCAPACITY))
|
|
|
|
goto asym_packing;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Candidate sg has no more than one task per CPU and
|
|
|
|
* has higher per-CPU capacity. Migrating tasks to less
|
|
|
|
* capable CPUs may harm throughput. Maximize throughput,
|
|
|
|
* power/energy consequences are not considered.
|
|
|
|
*/
|
|
|
|
if (sgs->sum_nr_running <= sgs->group_weight &&
|
|
|
|
group_smaller_cpu_capacity(sds->local, sg))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
asym_packing:
|
2014-07-28 18:16:28 +00:00
|
|
|
/* This is the busiest node in its class. */
|
|
|
|
if (!(env->sd->flags & SD_ASYM_PACKING))
|
2010-06-08 04:57:02 +00:00
|
|
|
return true;
|
|
|
|
|
2016-04-06 13:17:40 +00:00
|
|
|
/* No ASYM_PACKING if target cpu is already busy */
|
|
|
|
if (env->idle == CPU_NOT_IDLE)
|
|
|
|
return true;
|
2010-06-08 04:57:02 +00:00
|
|
|
/*
|
2016-11-22 20:23:53 +00:00
|
|
|
* ASYM_PACKING needs to move all the work to the highest
|
|
|
|
* prority CPUs in the group, therefore mark all groups
|
|
|
|
* of lower priority than ourself as busy.
|
2010-06-08 04:57:02 +00:00
|
|
|
*/
|
2016-11-22 20:23:53 +00:00
|
|
|
if (sgs->sum_nr_running &&
|
|
|
|
sched_asym_prefer(env->dst_cpu, sg->asym_prefer_cpu)) {
|
2010-06-08 04:57:02 +00:00
|
|
|
if (!sds->busiest)
|
|
|
|
return true;
|
|
|
|
|
2016-11-22 20:23:53 +00:00
|
|
|
/* Prefer to move from lowest priority cpu's work */
|
|
|
|
if (sched_asym_prefer(sds->busiest->asym_prefer_cpu,
|
|
|
|
sg->asym_prefer_cpu))
|
2010-06-08 04:57:02 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-10-07 10:29:33 +00:00
|
|
|
#ifdef CONFIG_NUMA_BALANCING
|
|
|
|
static inline enum fbq_type fbq_classify_group(struct sg_lb_stats *sgs)
|
|
|
|
{
|
|
|
|
if (sgs->sum_nr_running > sgs->nr_numa_running)
|
|
|
|
return regular;
|
|
|
|
if (sgs->sum_nr_running > sgs->nr_preferred_running)
|
|
|
|
return remote;
|
|
|
|
return all;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline enum fbq_type fbq_classify_rq(struct rq *rq)
|
|
|
|
{
|
|
|
|
if (rq->nr_running > rq->nr_numa_running)
|
|
|
|
return regular;
|
|
|
|
if (rq->nr_running > rq->nr_preferred_running)
|
|
|
|
return remote;
|
|
|
|
return all;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline enum fbq_type fbq_classify_group(struct sg_lb_stats *sgs)
|
|
|
|
{
|
|
|
|
return all;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline enum fbq_type fbq_classify_rq(struct rq *rq)
|
|
|
|
{
|
|
|
|
return regular;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NUMA_BALANCING */
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/**
|
2011-10-12 03:00:59 +00:00
|
|
|
* update_sd_lb_stats - Update sched_domain's statistics for load balancing.
|
2012-06-08 20:18:33 +00:00
|
|
|
* @env: The load balancing environment.
|
2009-12-17 16:00:43 +00:00
|
|
|
* @sds: variable to hold the statistics for this sched_domain.
|
|
|
|
*/
|
2013-10-07 10:29:33 +00:00
|
|
|
static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sds)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2012-05-02 12:20:37 +00:00
|
|
|
struct sched_domain *child = env->sd->child;
|
|
|
|
struct sched_group *sg = env->sd->groups;
|
sched/fair: Prefer sibiling only if local group is under-utilized
If the child domain prefers tasks to go siblings, the local group could
end up pulling tasks to itself even if the local group is almost equally
loaded as the source group.
Lets assume a 4 core,smt==2 machine running 5 thread ebizzy workload.
Everytime, local group has capacity and source group has atleast 2 threads,
local group tries to pull the task. This causes the threads to constantly
move between different cores. This is even more profound if the cores have
more threads, like in Power 8, smt 8 mode.
Fix this by only allowing local group to pull a task, if the source group
has more number of tasks than the local group.
Here are the relevant perf stat numbers of a 22 core,smt 8 Power 8 machine.
Without patch:
Performance counter stats for 'ebizzy -t 22 -S 100' (5 runs):
1,440 context-switches # 0.001 K/sec ( +- 1.26% )
366 cpu-migrations # 0.000 K/sec ( +- 5.58% )
3,933 page-faults # 0.002 K/sec ( +- 11.08% )
Performance counter stats for 'ebizzy -t 48 -S 100' (5 runs):
6,287 context-switches # 0.001 K/sec ( +- 3.65% )
3,776 cpu-migrations # 0.001 K/sec ( +- 4.84% )
5,702 page-faults # 0.001 K/sec ( +- 9.36% )
Performance counter stats for 'ebizzy -t 96 -S 100' (5 runs):
8,776 context-switches # 0.001 K/sec ( +- 0.73% )
2,790 cpu-migrations # 0.000 K/sec ( +- 0.98% )
10,540 page-faults # 0.001 K/sec ( +- 3.12% )
With patch:
Performance counter stats for 'ebizzy -t 22 -S 100' (5 runs):
1,133 context-switches # 0.001 K/sec ( +- 4.72% )
123 cpu-migrations # 0.000 K/sec ( +- 3.42% )
3,858 page-faults # 0.002 K/sec ( +- 8.52% )
Performance counter stats for 'ebizzy -t 48 -S 100' (5 runs):
2,169 context-switches # 0.000 K/sec ( +- 6.19% )
189 cpu-migrations # 0.000 K/sec ( +- 12.75% )
5,917 page-faults # 0.001 K/sec ( +- 8.09% )
Performance counter stats for 'ebizzy -t 96 -S 100' (5 runs):
5,333 context-switches # 0.001 K/sec ( +- 5.91% )
506 cpu-migrations # 0.000 K/sec ( +- 3.35% )
10,792 page-faults # 0.001 K/sec ( +- 7.75% )
Which show that in these workloads CPU migrations get reduced significantly.
Signed-off-by: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Vincent Guittot <vincent.guittot@linaro.org>
Link: http://lkml.kernel.org/r/1490205470-10249-1-git-send-email-srikar@linux.vnet.ibm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-03-22 17:57:50 +00:00
|
|
|
struct sg_lb_stats *local = &sds->local_stat;
|
2013-08-06 08:36:43 +00:00
|
|
|
struct sg_lb_stats tmp_sgs;
|
2009-12-17 16:00:43 +00:00
|
|
|
int load_idx, prefer_sibling = 0;
|
2014-06-23 19:16:49 +00:00
|
|
|
bool overload = false;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
if (child && child->flags & SD_PREFER_SIBLING)
|
|
|
|
prefer_sibling = 1;
|
|
|
|
|
2012-05-02 12:20:37 +00:00
|
|
|
load_idx = get_sd_load_idx(env->sd, env->idle);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
do {
|
2013-08-06 08:36:43 +00:00
|
|
|
struct sg_lb_stats *sgs = &tmp_sgs;
|
2009-12-17 16:00:43 +00:00
|
|
|
int local_group;
|
|
|
|
|
2017-05-01 09:03:12 +00:00
|
|
|
local_group = cpumask_test_cpu(env->dst_cpu, sched_group_span(sg));
|
2013-08-06 08:36:43 +00:00
|
|
|
if (local_group) {
|
|
|
|
sds->local = sg;
|
sched/fair: Prefer sibiling only if local group is under-utilized
If the child domain prefers tasks to go siblings, the local group could
end up pulling tasks to itself even if the local group is almost equally
loaded as the source group.
Lets assume a 4 core,smt==2 machine running 5 thread ebizzy workload.
Everytime, local group has capacity and source group has atleast 2 threads,
local group tries to pull the task. This causes the threads to constantly
move between different cores. This is even more profound if the cores have
more threads, like in Power 8, smt 8 mode.
Fix this by only allowing local group to pull a task, if the source group
has more number of tasks than the local group.
Here are the relevant perf stat numbers of a 22 core,smt 8 Power 8 machine.
Without patch:
Performance counter stats for 'ebizzy -t 22 -S 100' (5 runs):
1,440 context-switches # 0.001 K/sec ( +- 1.26% )
366 cpu-migrations # 0.000 K/sec ( +- 5.58% )
3,933 page-faults # 0.002 K/sec ( +- 11.08% )
Performance counter stats for 'ebizzy -t 48 -S 100' (5 runs):
6,287 context-switches # 0.001 K/sec ( +- 3.65% )
3,776 cpu-migrations # 0.001 K/sec ( +- 4.84% )
5,702 page-faults # 0.001 K/sec ( +- 9.36% )
Performance counter stats for 'ebizzy -t 96 -S 100' (5 runs):
8,776 context-switches # 0.001 K/sec ( +- 0.73% )
2,790 cpu-migrations # 0.000 K/sec ( +- 0.98% )
10,540 page-faults # 0.001 K/sec ( +- 3.12% )
With patch:
Performance counter stats for 'ebizzy -t 22 -S 100' (5 runs):
1,133 context-switches # 0.001 K/sec ( +- 4.72% )
123 cpu-migrations # 0.000 K/sec ( +- 3.42% )
3,858 page-faults # 0.002 K/sec ( +- 8.52% )
Performance counter stats for 'ebizzy -t 48 -S 100' (5 runs):
2,169 context-switches # 0.000 K/sec ( +- 6.19% )
189 cpu-migrations # 0.000 K/sec ( +- 12.75% )
5,917 page-faults # 0.001 K/sec ( +- 8.09% )
Performance counter stats for 'ebizzy -t 96 -S 100' (5 runs):
5,333 context-switches # 0.001 K/sec ( +- 5.91% )
506 cpu-migrations # 0.000 K/sec ( +- 3.35% )
10,792 page-faults # 0.001 K/sec ( +- 7.75% )
Which show that in these workloads CPU migrations get reduced significantly.
Signed-off-by: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Vincent Guittot <vincent.guittot@linaro.org>
Link: http://lkml.kernel.org/r/1490205470-10249-1-git-send-email-srikar@linux.vnet.ibm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-03-22 17:57:50 +00:00
|
|
|
sgs = local;
|
2013-08-28 08:32:32 +00:00
|
|
|
|
|
|
|
if (env->idle != CPU_NEWLY_IDLE ||
|
2014-05-26 22:19:37 +00:00
|
|
|
time_after_eq(jiffies, sg->sgc->next_update))
|
|
|
|
update_group_capacity(env->sd, env->dst_cpu);
|
2013-08-06 08:36:43 +00:00
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2014-06-23 19:16:49 +00:00
|
|
|
update_sg_lb_stats(env, sg, load_idx, local_group, sgs,
|
|
|
|
&overload);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2013-08-28 08:32:32 +00:00
|
|
|
if (local_group)
|
|
|
|
goto next_group;
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/*
|
|
|
|
* In case the child domain prefers tasks go to siblings
|
2015-02-27 15:54:11 +00:00
|
|
|
* first, lower the sg capacity so that we'll try
|
sched: Drop group_capacity to 1 only if local group has extra capacity
When SD_PREFER_SIBLING is set on a sched domain, drop group_capacity to 1
only if the local group has extra capacity. The extra check prevents the case
where you always pull from the heaviest group when it is already under-utilized
(possible with a large weight task outweighs the tasks on the system).
For example, consider a 16-cpu quad-core quad-socket machine with MC and NUMA
scheduling domains. Let's say we spawn 15 nice0 tasks and one nice-15 task,
and each task is running on one core. In this case, we observe the following
events when balancing at the NUMA domain:
- find_busiest_group() will always pick the sched group containing the niced
task to be the busiest group.
- find_busiest_queue() will then always pick one of the cpus running the
nice0 task (never picks the cpu with the nice -15 task since
weighted_cpuload > imbalance).
- The load balancer fails to migrate the task since it is the running task
and increments sd->nr_balance_failed.
- It repeats the above steps a few more times until sd->nr_balance_failed > 5,
at which point it kicks off the active load balancer, wakes up the migration
thread and kicks the nice 0 task off the cpu.
The load balancer doesn't stop until we kick out all nice 0 tasks from
the sched group, leaving you with 3 idle cpus and one cpu running the
nice -15 task.
When balancing at the NUMA domain, we drop sgs.group_capacity to 1 if the child
domain (in this case MC) has SD_PREFER_SIBLING set. Subsequent load checks are
not relevant because the niced task has a very large weight.
In this patch, we add an extra condition to the "if(prefer_sibling)" check in
update_sd_lb_stats(). We drop the capacity of a group only if the local group
has extra capacity, ie. nr_running < group_capacity. This patch preserves the
original intent of the prefer_siblings check (to spread tasks across the system
in low utilization scenarios) and fixes the case above.
It helps in the following ways:
- In low utilization cases (where nr_tasks << nr_cpus), we still drop
group_capacity down to 1 if we prefer siblings.
- On very busy systems (where nr_tasks >> nr_cpus), sgs.nr_running will most
likely be > sgs.group_capacity.
- When balancing large weight tasks, if the local group does not have extra
capacity, we do not pick the group with the niced task as the busiest group.
This prevents failed balances, active migration and the under-utilization
described above.
Signed-off-by: Nikhil Rao <ncrao@google.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <1287173550-30365-5-git-send-email-ncrao@google.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-10-15 20:12:30 +00:00
|
|
|
* and move all the excess tasks away. We lower the capacity
|
|
|
|
* of a group only if the local group has the capacity to fit
|
2015-02-27 15:54:11 +00:00
|
|
|
* these excess tasks. The extra check prevents the case where
|
|
|
|
* you always pull from the heaviest group when it is already
|
|
|
|
* under-utilized (possible with a large weight task outweighs
|
|
|
|
* the tasks on the system).
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2013-08-28 08:32:32 +00:00
|
|
|
if (prefer_sibling && sds->local &&
|
sched/fair: Prefer sibiling only if local group is under-utilized
If the child domain prefers tasks to go siblings, the local group could
end up pulling tasks to itself even if the local group is almost equally
loaded as the source group.
Lets assume a 4 core,smt==2 machine running 5 thread ebizzy workload.
Everytime, local group has capacity and source group has atleast 2 threads,
local group tries to pull the task. This causes the threads to constantly
move between different cores. This is even more profound if the cores have
more threads, like in Power 8, smt 8 mode.
Fix this by only allowing local group to pull a task, if the source group
has more number of tasks than the local group.
Here are the relevant perf stat numbers of a 22 core,smt 8 Power 8 machine.
Without patch:
Performance counter stats for 'ebizzy -t 22 -S 100' (5 runs):
1,440 context-switches # 0.001 K/sec ( +- 1.26% )
366 cpu-migrations # 0.000 K/sec ( +- 5.58% )
3,933 page-faults # 0.002 K/sec ( +- 11.08% )
Performance counter stats for 'ebizzy -t 48 -S 100' (5 runs):
6,287 context-switches # 0.001 K/sec ( +- 3.65% )
3,776 cpu-migrations # 0.001 K/sec ( +- 4.84% )
5,702 page-faults # 0.001 K/sec ( +- 9.36% )
Performance counter stats for 'ebizzy -t 96 -S 100' (5 runs):
8,776 context-switches # 0.001 K/sec ( +- 0.73% )
2,790 cpu-migrations # 0.000 K/sec ( +- 0.98% )
10,540 page-faults # 0.001 K/sec ( +- 3.12% )
With patch:
Performance counter stats for 'ebizzy -t 22 -S 100' (5 runs):
1,133 context-switches # 0.001 K/sec ( +- 4.72% )
123 cpu-migrations # 0.000 K/sec ( +- 3.42% )
3,858 page-faults # 0.002 K/sec ( +- 8.52% )
Performance counter stats for 'ebizzy -t 48 -S 100' (5 runs):
2,169 context-switches # 0.000 K/sec ( +- 6.19% )
189 cpu-migrations # 0.000 K/sec ( +- 12.75% )
5,917 page-faults # 0.001 K/sec ( +- 8.09% )
Performance counter stats for 'ebizzy -t 96 -S 100' (5 runs):
5,333 context-switches # 0.001 K/sec ( +- 5.91% )
506 cpu-migrations # 0.000 K/sec ( +- 3.35% )
10,792 page-faults # 0.001 K/sec ( +- 7.75% )
Which show that in these workloads CPU migrations get reduced significantly.
Signed-off-by: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Vincent Guittot <vincent.guittot@linaro.org>
Link: http://lkml.kernel.org/r/1490205470-10249-1-git-send-email-srikar@linux.vnet.ibm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-03-22 17:57:50 +00:00
|
|
|
group_has_capacity(env, local) &&
|
|
|
|
(sgs->sum_nr_running > local->sum_nr_running + 1)) {
|
2015-02-27 15:54:11 +00:00
|
|
|
sgs->group_no_capacity = 1;
|
2015-09-15 10:56:45 +00:00
|
|
|
sgs->group_type = group_classify(sg, sgs);
|
2014-11-04 23:44:50 +00:00
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2013-08-28 08:32:32 +00:00
|
|
|
if (update_sd_pick_busiest(env, sds, sg, sgs)) {
|
2010-06-08 04:57:02 +00:00
|
|
|
sds->busiest = sg;
|
2013-08-06 08:36:43 +00:00
|
|
|
sds->busiest_stat = *sgs;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
2013-08-28 08:32:32 +00:00
|
|
|
next_group:
|
|
|
|
/* Now, start updating sd_lb_stats */
|
2017-07-31 15:50:05 +00:00
|
|
|
sds->total_running += sgs->sum_nr_running;
|
2013-08-28 08:32:32 +00:00
|
|
|
sds->total_load += sgs->group_load;
|
2014-05-26 22:19:37 +00:00
|
|
|
sds->total_capacity += sgs->group_capacity;
|
2013-08-28 08:32:32 +00:00
|
|
|
|
2010-06-08 04:57:02 +00:00
|
|
|
sg = sg->next;
|
2012-05-02 12:20:37 +00:00
|
|
|
} while (sg != env->sd->groups);
|
2013-10-07 10:29:33 +00:00
|
|
|
|
|
|
|
if (env->sd->flags & SD_NUMA)
|
|
|
|
env->fbq_type = fbq_classify_group(&sds->busiest_stat);
|
2014-06-23 19:16:49 +00:00
|
|
|
|
|
|
|
if (!env->sd->parent) {
|
|
|
|
/* update overload indicator if we are at root domain */
|
|
|
|
if (env->dst_rq->rd->overload != overload)
|
|
|
|
env->dst_rq->rd->overload = overload;
|
|
|
|
}
|
2010-06-08 04:57:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* check_asym_packing - Check to see if the group is packed into the
|
2017-03-07 11:48:02 +00:00
|
|
|
* sched domain.
|
2010-06-08 04:57:02 +00:00
|
|
|
*
|
|
|
|
* This is primarily intended to used at the sibling level. Some
|
|
|
|
* cores like POWER7 prefer to use lower numbered SMT threads. In the
|
|
|
|
* case of POWER7, it can move to lower SMT modes only when higher
|
|
|
|
* threads are idle. When in lower SMT modes, the threads will
|
|
|
|
* perform better since they share less core resources. Hence when we
|
|
|
|
* have idle threads, we want them to be the higher ones.
|
|
|
|
*
|
|
|
|
* This packing function is run on idle threads. It checks to see if
|
|
|
|
* the busiest CPU in this domain (core in the P7 case) has a higher
|
|
|
|
* CPU number than the packing function is being run on. Here we are
|
|
|
|
* assuming lower CPU number will be equivalent to lower a SMT thread
|
|
|
|
* number.
|
|
|
|
*
|
2013-07-12 18:45:47 +00:00
|
|
|
* Return: 1 when packing is required and a task should be moved to
|
2017-09-10 16:55:05 +00:00
|
|
|
* this CPU. The amount of the imbalance is returned in env->imbalance.
|
2010-06-10 02:06:21 +00:00
|
|
|
*
|
2012-06-08 20:18:33 +00:00
|
|
|
* @env: The load balancing environment.
|
2010-06-08 04:57:02 +00:00
|
|
|
* @sds: Statistics of the sched_domain which is to be packed
|
|
|
|
*/
|
2012-05-02 12:20:37 +00:00
|
|
|
static int check_asym_packing(struct lb_env *env, struct sd_lb_stats *sds)
|
2010-06-08 04:57:02 +00:00
|
|
|
{
|
|
|
|
int busiest_cpu;
|
|
|
|
|
2012-05-02 12:20:37 +00:00
|
|
|
if (!(env->sd->flags & SD_ASYM_PACKING))
|
2010-06-08 04:57:02 +00:00
|
|
|
return 0;
|
|
|
|
|
2016-04-06 13:17:40 +00:00
|
|
|
if (env->idle == CPU_NOT_IDLE)
|
|
|
|
return 0;
|
|
|
|
|
2010-06-08 04:57:02 +00:00
|
|
|
if (!sds->busiest)
|
|
|
|
return 0;
|
|
|
|
|
2016-11-22 20:23:53 +00:00
|
|
|
busiest_cpu = sds->busiest->asym_prefer_cpu;
|
|
|
|
if (sched_asym_prefer(busiest_cpu, env->dst_cpu))
|
2010-06-08 04:57:02 +00:00
|
|
|
return 0;
|
|
|
|
|
2012-05-02 12:20:37 +00:00
|
|
|
env->imbalance = DIV_ROUND_CLOSEST(
|
2014-05-26 22:19:37 +00:00
|
|
|
sds->busiest_stat.avg_load * sds->busiest_stat.group_capacity,
|
2014-05-26 22:19:39 +00:00
|
|
|
SCHED_CAPACITY_SCALE);
|
2012-05-02 12:20:37 +00:00
|
|
|
|
2010-06-08 04:57:02 +00:00
|
|
|
return 1;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* fix_small_imbalance - Calculate the minor imbalance that exists
|
|
|
|
* amongst the groups of a sched_domain, during
|
|
|
|
* load balancing.
|
2012-06-08 20:18:33 +00:00
|
|
|
* @env: The load balancing environment.
|
2009-12-17 16:00:43 +00:00
|
|
|
* @sds: Statistics of the sched_domain whose imbalance is to be calculated.
|
|
|
|
*/
|
2012-05-02 12:20:37 +00:00
|
|
|
static inline
|
|
|
|
void fix_small_imbalance(struct lb_env *env, struct sd_lb_stats *sds)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2014-05-26 22:19:37 +00:00
|
|
|
unsigned long tmp, capa_now = 0, capa_move = 0;
|
2009-12-17 16:00:43 +00:00
|
|
|
unsigned int imbn = 2;
|
2010-02-24 00:13:52 +00:00
|
|
|
unsigned long scaled_busy_load_per_task;
|
2013-08-06 08:36:43 +00:00
|
|
|
struct sg_lb_stats *local, *busiest;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2013-08-06 08:36:43 +00:00
|
|
|
local = &sds->local_stat;
|
|
|
|
busiest = &sds->busiest_stat;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2013-08-06 08:36:43 +00:00
|
|
|
if (!local->sum_nr_running)
|
|
|
|
local->load_per_task = cpu_avg_load_per_task(env->dst_cpu);
|
|
|
|
else if (busiest->load_per_task > local->load_per_task)
|
|
|
|
imbn = 1;
|
2010-02-24 00:13:52 +00:00
|
|
|
|
2013-08-06 08:36:43 +00:00
|
|
|
scaled_busy_load_per_task =
|
2014-05-26 22:19:39 +00:00
|
|
|
(busiest->load_per_task * SCHED_CAPACITY_SCALE) /
|
2014-05-26 22:19:37 +00:00
|
|
|
busiest->group_capacity;
|
2013-08-06 08:36:43 +00:00
|
|
|
|
2013-09-15 13:49:14 +00:00
|
|
|
if (busiest->avg_load + scaled_busy_load_per_task >=
|
|
|
|
local->avg_load + (scaled_busy_load_per_task * imbn)) {
|
2013-08-06 08:36:43 +00:00
|
|
|
env->imbalance = busiest->load_per_task;
|
2009-12-17 16:00:43 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* OK, we don't have enough imbalance to justify moving tasks,
|
2014-05-26 22:19:38 +00:00
|
|
|
* however we may be able to increase total CPU capacity used by
|
2009-12-17 16:00:43 +00:00
|
|
|
* moving them.
|
|
|
|
*/
|
|
|
|
|
2014-05-26 22:19:37 +00:00
|
|
|
capa_now += busiest->group_capacity *
|
2013-08-06 08:36:43 +00:00
|
|
|
min(busiest->load_per_task, busiest->avg_load);
|
2014-05-26 22:19:37 +00:00
|
|
|
capa_now += local->group_capacity *
|
2013-08-06 08:36:43 +00:00
|
|
|
min(local->load_per_task, local->avg_load);
|
2014-05-26 22:19:39 +00:00
|
|
|
capa_now /= SCHED_CAPACITY_SCALE;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
/* Amount of load we'd subtract */
|
2014-03-11 16:26:06 +00:00
|
|
|
if (busiest->avg_load > scaled_busy_load_per_task) {
|
2014-05-26 22:19:37 +00:00
|
|
|
capa_move += busiest->group_capacity *
|
2013-08-06 08:36:43 +00:00
|
|
|
min(busiest->load_per_task,
|
2014-03-11 16:26:06 +00:00
|
|
|
busiest->avg_load - scaled_busy_load_per_task);
|
2013-08-06 08:36:43 +00:00
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
/* Amount of load we'd add */
|
2014-05-26 22:19:37 +00:00
|
|
|
if (busiest->avg_load * busiest->group_capacity <
|
2014-05-26 22:19:39 +00:00
|
|
|
busiest->load_per_task * SCHED_CAPACITY_SCALE) {
|
2014-05-26 22:19:37 +00:00
|
|
|
tmp = (busiest->avg_load * busiest->group_capacity) /
|
|
|
|
local->group_capacity;
|
2013-08-06 08:36:43 +00:00
|
|
|
} else {
|
2014-05-26 22:19:39 +00:00
|
|
|
tmp = (busiest->load_per_task * SCHED_CAPACITY_SCALE) /
|
2014-05-26 22:19:37 +00:00
|
|
|
local->group_capacity;
|
2013-08-06 08:36:43 +00:00
|
|
|
}
|
2014-05-26 22:19:37 +00:00
|
|
|
capa_move += local->group_capacity *
|
2013-08-15 18:37:48 +00:00
|
|
|
min(local->load_per_task, local->avg_load + tmp);
|
2014-05-26 22:19:39 +00:00
|
|
|
capa_move /= SCHED_CAPACITY_SCALE;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
/* Move if we gain throughput */
|
2014-05-26 22:19:37 +00:00
|
|
|
if (capa_move > capa_now)
|
2013-08-06 08:36:43 +00:00
|
|
|
env->imbalance = busiest->load_per_task;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* calculate_imbalance - Calculate the amount of imbalance present within the
|
|
|
|
* groups of a given sched_domain during load balance.
|
2012-05-02 12:20:37 +00:00
|
|
|
* @env: load balance environment
|
2009-12-17 16:00:43 +00:00
|
|
|
* @sds: statistics of the sched_domain whose imbalance is to be calculated.
|
|
|
|
*/
|
2012-05-02 12:20:37 +00:00
|
|
|
static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *sds)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2010-02-24 00:13:52 +00:00
|
|
|
unsigned long max_pull, load_above_capacity = ~0UL;
|
2013-08-06 08:36:43 +00:00
|
|
|
struct sg_lb_stats *local, *busiest;
|
|
|
|
|
|
|
|
local = &sds->local_stat;
|
|
|
|
busiest = &sds->busiest_stat;
|
2010-02-24 00:13:52 +00:00
|
|
|
|
2014-07-28 18:16:28 +00:00
|
|
|
if (busiest->group_type == group_imbalanced) {
|
2013-08-15 18:29:29 +00:00
|
|
|
/*
|
|
|
|
* In the group_imb case we cannot rely on group-wide averages
|
|
|
|
* to ensure cpu-load equilibrium, look at wider averages. XXX
|
|
|
|
*/
|
2013-08-06 08:36:43 +00:00
|
|
|
busiest->load_per_task =
|
|
|
|
min(busiest->load_per_task, sds->avg_load);
|
2010-02-24 00:13:52 +00:00
|
|
|
}
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/*
|
2016-04-29 19:32:39 +00:00
|
|
|
* Avg load of busiest sg can be less and avg load of local sg can
|
|
|
|
* be greater than avg load across all sgs of sd because avg load
|
|
|
|
* factors in sg capacity and sgs with smaller group_type are
|
|
|
|
* skipped when updating the busiest sg:
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2013-09-15 13:49:13 +00:00
|
|
|
if (busiest->avg_load <= sds->avg_load ||
|
|
|
|
local->avg_load >= sds->avg_load) {
|
2012-05-02 12:20:37 +00:00
|
|
|
env->imbalance = 0;
|
|
|
|
return fix_small_imbalance(env, sds);
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:15:11 +00:00
|
|
|
/*
|
|
|
|
* If there aren't any idle cpus, avoid creating some.
|
|
|
|
*/
|
|
|
|
if (busiest->group_type == group_overloaded &&
|
|
|
|
local->group_type == group_overloaded) {
|
2016-05-06 10:21:23 +00:00
|
|
|
load_above_capacity = busiest->sum_nr_running * SCHED_CAPACITY_SCALE;
|
2016-04-29 19:32:40 +00:00
|
|
|
if (load_above_capacity > busiest->group_capacity) {
|
2015-02-27 15:54:11 +00:00
|
|
|
load_above_capacity -= busiest->group_capacity;
|
2016-08-10 10:27:27 +00:00
|
|
|
load_above_capacity *= scale_load_down(NICE_0_LOAD);
|
2016-04-29 19:32:40 +00:00
|
|
|
load_above_capacity /= busiest->group_capacity;
|
|
|
|
} else
|
2015-02-27 15:54:11 +00:00
|
|
|
load_above_capacity = ~0UL;
|
2010-02-24 00:13:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We're trying to get all the cpus to the average_load, so we don't
|
|
|
|
* want to push ourselves above the average load, nor do we wish to
|
|
|
|
* reduce the max loaded cpu below the average load. At the same time,
|
2016-04-29 19:32:38 +00:00
|
|
|
* we also don't want to reduce the group load below the group
|
|
|
|
* capacity. Thus we look for the minimum possible imbalance.
|
2010-02-24 00:13:52 +00:00
|
|
|
*/
|
2013-08-15 18:29:29 +00:00
|
|
|
max_pull = min(busiest->avg_load - sds->avg_load, load_above_capacity);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
/* How much load to actually move to equalise the imbalance */
|
2013-08-06 08:36:43 +00:00
|
|
|
env->imbalance = min(
|
2014-05-26 22:19:37 +00:00
|
|
|
max_pull * busiest->group_capacity,
|
|
|
|
(sds->avg_load - local->avg_load) * local->group_capacity
|
2014-05-26 22:19:39 +00:00
|
|
|
) / SCHED_CAPACITY_SCALE;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* if *imbalance is less than the average load per runnable task
|
2011-03-31 01:57:33 +00:00
|
|
|
* there is no guarantee that any tasks will be moved so we'll have
|
2009-12-17 16:00:43 +00:00
|
|
|
* a think about bumping its value to force at least one task to be
|
|
|
|
* moved
|
|
|
|
*/
|
2013-08-06 08:36:43 +00:00
|
|
|
if (env->imbalance < busiest->load_per_task)
|
2012-05-02 12:20:37 +00:00
|
|
|
return fix_small_imbalance(env, sds);
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
2010-10-15 20:12:29 +00:00
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/******* find_busiest_group() helpers end here *********************/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* find_busiest_group - Returns the busiest group within the sched_domain
|
2016-04-29 19:32:38 +00:00
|
|
|
* if there is an imbalance.
|
2009-12-17 16:00:43 +00:00
|
|
|
*
|
|
|
|
* Also calculates the amount of weighted load which should be moved
|
|
|
|
* to restore balance.
|
|
|
|
*
|
2012-06-08 20:18:33 +00:00
|
|
|
* @env: The load balancing environment.
|
2009-12-17 16:00:43 +00:00
|
|
|
*
|
2013-07-12 18:45:47 +00:00
|
|
|
* Return: - The busiest group if imbalance exists.
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2013-08-06 08:36:43 +00:00
|
|
|
static struct sched_group *find_busiest_group(struct lb_env *env)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2013-08-06 08:36:43 +00:00
|
|
|
struct sg_lb_stats *local, *busiest;
|
2009-12-17 16:00:43 +00:00
|
|
|
struct sd_lb_stats sds;
|
|
|
|
|
2013-08-19 13:22:57 +00:00
|
|
|
init_sd_lb_stats(&sds);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Compute the various statistics relavent for load balancing at
|
|
|
|
* this level.
|
|
|
|
*/
|
2013-08-06 08:36:42 +00:00
|
|
|
update_sd_lb_stats(env, &sds);
|
2013-08-06 08:36:43 +00:00
|
|
|
local = &sds.local_stat;
|
|
|
|
busiest = &sds.busiest_stat;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2015-02-27 15:54:11 +00:00
|
|
|
/* ASYM feature bypasses nice load balance check */
|
2016-04-06 13:17:40 +00:00
|
|
|
if (check_asym_packing(env, &sds))
|
2010-06-08 04:57:02 +00:00
|
|
|
return sds.busiest;
|
|
|
|
|
2011-02-21 17:55:32 +00:00
|
|
|
/* There is no busy sibling group to pull tasks from */
|
2013-08-06 08:36:43 +00:00
|
|
|
if (!sds.busiest || busiest->sum_nr_running == 0)
|
2009-12-17 16:00:43 +00:00
|
|
|
goto out_balanced;
|
|
|
|
|
2017-07-31 15:50:05 +00:00
|
|
|
/* XXX broken for overlapping NUMA groups */
|
2014-05-26 22:19:39 +00:00
|
|
|
sds.avg_load = (SCHED_CAPACITY_SCALE * sds.total_load)
|
|
|
|
/ sds.total_capacity;
|
2011-04-08 00:23:22 +00:00
|
|
|
|
2011-02-21 17:56:47 +00:00
|
|
|
/*
|
|
|
|
* If the busiest group is imbalanced the below checks don't
|
2013-08-15 18:29:29 +00:00
|
|
|
* work because they assume all things are equal, which typically
|
2011-02-21 17:56:47 +00:00
|
|
|
* isn't true due to cpus_allowed constraints and the like.
|
|
|
|
*/
|
2014-07-28 18:16:28 +00:00
|
|
|
if (busiest->group_type == group_imbalanced)
|
2011-02-21 17:56:47 +00:00
|
|
|
goto force_balance;
|
|
|
|
|
2017-10-05 10:58:54 +00:00
|
|
|
/*
|
|
|
|
* When dst_cpu is idle, prevent SMP nice and/or asymmetric group
|
|
|
|
* capacities from resulting in underutilization due to avg_load.
|
|
|
|
*/
|
|
|
|
if (env->idle != CPU_NOT_IDLE && group_has_capacity(env, local) &&
|
2015-02-27 15:54:11 +00:00
|
|
|
busiest->group_no_capacity)
|
2010-10-15 20:12:29 +00:00
|
|
|
goto force_balance;
|
|
|
|
|
2011-02-21 17:55:32 +00:00
|
|
|
/*
|
2014-09-21 01:24:36 +00:00
|
|
|
* If the local group is busier than the selected busiest group
|
2011-02-21 17:55:32 +00:00
|
|
|
* don't try and pull any tasks.
|
|
|
|
*/
|
2013-08-06 08:36:43 +00:00
|
|
|
if (local->avg_load >= busiest->avg_load)
|
2009-12-17 16:00:43 +00:00
|
|
|
goto out_balanced;
|
|
|
|
|
2011-02-21 17:55:32 +00:00
|
|
|
/*
|
|
|
|
* Don't pull any tasks if this group is already above the domain
|
|
|
|
* average load.
|
|
|
|
*/
|
2013-08-06 08:36:43 +00:00
|
|
|
if (local->avg_load >= sds.avg_load)
|
2009-12-17 16:00:43 +00:00
|
|
|
goto out_balanced;
|
|
|
|
|
2012-05-02 12:20:37 +00:00
|
|
|
if (env->idle == CPU_IDLE) {
|
2010-09-17 22:02:32 +00:00
|
|
|
/*
|
2014-10-01 13:38:55 +00:00
|
|
|
* This cpu is idle. If the busiest group is not overloaded
|
|
|
|
* and there is no imbalance between this and busiest group
|
|
|
|
* wrt idle cpus, it is balanced. The imbalance becomes
|
|
|
|
* significant if the diff is greater than 1 otherwise we
|
|
|
|
* might end up to just move the imbalance on another group
|
2010-09-17 22:02:32 +00:00
|
|
|
*/
|
2014-10-01 13:38:55 +00:00
|
|
|
if ((busiest->group_type != group_overloaded) &&
|
|
|
|
(local->idle_cpus <= (busiest->idle_cpus + 1)))
|
2010-09-17 22:02:32 +00:00
|
|
|
goto out_balanced;
|
2011-02-21 17:52:53 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* In the CPU_NEWLY_IDLE, CPU_NOT_IDLE cases, use
|
|
|
|
* imbalance_pct to be conservative.
|
|
|
|
*/
|
2013-08-06 08:36:43 +00:00
|
|
|
if (100 * busiest->avg_load <=
|
|
|
|
env->sd->imbalance_pct * local->avg_load)
|
2011-02-21 17:52:53 +00:00
|
|
|
goto out_balanced;
|
2010-09-17 22:02:32 +00:00
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2010-10-15 20:12:29 +00:00
|
|
|
force_balance:
|
2009-12-17 16:00:43 +00:00
|
|
|
/* Looks like there is an imbalance. Compute it */
|
2012-05-02 12:20:37 +00:00
|
|
|
calculate_imbalance(env, &sds);
|
2009-12-17 16:00:43 +00:00
|
|
|
return sds.busiest;
|
|
|
|
|
|
|
|
out_balanced:
|
2012-05-02 12:20:37 +00:00
|
|
|
env->imbalance = 0;
|
2009-12-17 16:00:43 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* find_busiest_queue - find the busiest runqueue among the cpus in group.
|
|
|
|
*/
|
2012-05-02 12:20:37 +00:00
|
|
|
static struct rq *find_busiest_queue(struct lb_env *env,
|
2012-07-12 08:10:13 +00:00
|
|
|
struct sched_group *group)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
|
|
|
struct rq *busiest = NULL, *rq;
|
2014-05-26 22:19:38 +00:00
|
|
|
unsigned long busiest_load = 0, busiest_capacity = 1;
|
2009-12-17 16:00:43 +00:00
|
|
|
int i;
|
|
|
|
|
2017-05-01 09:03:12 +00:00
|
|
|
for_each_cpu_and(i, sched_group_span(group), env->cpus) {
|
2015-02-27 15:54:11 +00:00
|
|
|
unsigned long capacity, wl;
|
2013-10-07 10:29:33 +00:00
|
|
|
enum fbq_type rt;
|
|
|
|
|
|
|
|
rq = cpu_rq(i);
|
|
|
|
rt = fbq_classify_rq(rq);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2013-10-07 10:29:33 +00:00
|
|
|
/*
|
|
|
|
* We classify groups/runqueues into three groups:
|
|
|
|
* - regular: there are !numa tasks
|
|
|
|
* - remote: there are numa tasks that run on the 'wrong' node
|
|
|
|
* - all: there is no distinction
|
|
|
|
*
|
|
|
|
* In order to avoid migrating ideally placed numa tasks,
|
|
|
|
* ignore those when there's better options.
|
|
|
|
*
|
|
|
|
* If we ignore the actual busiest queue to migrate another
|
|
|
|
* task, the next balance pass can still reduce the busiest
|
|
|
|
* queue by moving tasks around inside the node.
|
|
|
|
*
|
|
|
|
* If we cannot move enough load due to this classification
|
|
|
|
* the next pass will adjust the group classification and
|
|
|
|
* allow migration of more tasks.
|
|
|
|
*
|
|
|
|
* Both cases only affect the total convergence complexity.
|
|
|
|
*/
|
|
|
|
if (rt > env->fbq_type)
|
|
|
|
continue;
|
|
|
|
|
2014-05-26 22:19:38 +00:00
|
|
|
capacity = capacity_of(i);
|
2010-06-08 04:57:02 +00:00
|
|
|
|
2017-05-24 05:29:54 +00:00
|
|
|
wl = weighted_cpuload(rq);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2010-02-16 15:48:56 +00:00
|
|
|
/*
|
|
|
|
* When comparing with imbalance, use weighted_cpuload()
|
2014-05-26 22:19:38 +00:00
|
|
|
* which is not scaled with the cpu capacity.
|
2010-02-16 15:48:56 +00:00
|
|
|
*/
|
2015-02-27 15:54:11 +00:00
|
|
|
|
|
|
|
if (rq->nr_running == 1 && wl > env->imbalance &&
|
|
|
|
!check_cpu_capacity(rq, env->sd))
|
2009-12-17 16:00:43 +00:00
|
|
|
continue;
|
|
|
|
|
2010-02-16 15:48:56 +00:00
|
|
|
/*
|
|
|
|
* For the load comparisons with the other cpu's, consider
|
2014-05-26 22:19:38 +00:00
|
|
|
* the weighted_cpuload() scaled with the cpu capacity, so
|
|
|
|
* that the load can be moved away from the cpu that is
|
|
|
|
* potentially running at a lower capacity.
|
2013-08-06 08:36:41 +00:00
|
|
|
*
|
2014-05-26 22:19:38 +00:00
|
|
|
* Thus we're looking for max(wl_i / capacity_i), crosswise
|
2013-08-06 08:36:41 +00:00
|
|
|
* multiplication to rid ourselves of the division works out
|
2014-05-26 22:19:38 +00:00
|
|
|
* to: wl_i * capacity_j > wl_j * capacity_i; where j is
|
|
|
|
* our previous maximum.
|
2010-02-16 15:48:56 +00:00
|
|
|
*/
|
2014-05-26 22:19:38 +00:00
|
|
|
if (wl * busiest_capacity > busiest_load * capacity) {
|
2013-08-06 08:36:41 +00:00
|
|
|
busiest_load = wl;
|
2014-05-26 22:19:38 +00:00
|
|
|
busiest_capacity = capacity;
|
2009-12-17 16:00:43 +00:00
|
|
|
busiest = rq;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return busiest;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Max backoff if we encounter pinned tasks. Pretty arbitrary value, but
|
|
|
|
* so long as it is large enough.
|
|
|
|
*/
|
|
|
|
#define MAX_PINNED_INTERVAL 512
|
|
|
|
|
2012-05-02 12:20:37 +00:00
|
|
|
static int need_active_balance(struct lb_env *env)
|
2009-12-23 14:10:31 +00:00
|
|
|
{
|
2012-05-02 12:20:37 +00:00
|
|
|
struct sched_domain *sd = env->sd;
|
|
|
|
|
|
|
|
if (env->idle == CPU_NEWLY_IDLE) {
|
2010-06-08 04:57:02 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ASYM_PACKING needs to force migrate tasks from busy but
|
2016-11-22 20:23:53 +00:00
|
|
|
* lower priority CPUs in order to pack all tasks in the
|
|
|
|
* highest priority CPUs.
|
2010-06-08 04:57:02 +00:00
|
|
|
*/
|
2016-11-22 20:23:53 +00:00
|
|
|
if ((sd->flags & SD_ASYM_PACKING) &&
|
|
|
|
sched_asym_prefer(env->dst_cpu, env->src_cpu))
|
2010-06-08 04:57:02 +00:00
|
|
|
return 1;
|
2009-12-23 14:10:31 +00:00
|
|
|
}
|
|
|
|
|
2015-02-27 15:54:14 +00:00
|
|
|
/*
|
|
|
|
* The dst_cpu is idle and the src_cpu CPU has only 1 CFS task.
|
|
|
|
* It's worth migrating the task if the src_cpu's capacity is reduced
|
|
|
|
* because of other sched_class or IRQs if more capacity stays
|
|
|
|
* available on dst_cpu.
|
|
|
|
*/
|
|
|
|
if ((env->idle != CPU_NOT_IDLE) &&
|
|
|
|
(env->src_rq->cfs.h_nr_running == 1)) {
|
|
|
|
if ((check_cpu_capacity(env->src_rq, sd)) &&
|
|
|
|
(capacity_of(env->src_cpu)*sd->imbalance_pct < capacity_of(env->dst_cpu)*100))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-12-23 14:10:31 +00:00
|
|
|
return unlikely(sd->nr_balance_failed > sd->cache_nice_tries+2);
|
|
|
|
}
|
|
|
|
|
2010-05-06 16:49:21 +00:00
|
|
|
static int active_load_balance_cpu_stop(void *data);
|
|
|
|
|
2013-08-06 08:36:42 +00:00
|
|
|
static int should_we_balance(struct lb_env *env)
|
|
|
|
{
|
|
|
|
struct sched_group *sg = env->sd->groups;
|
|
|
|
int cpu, balance_cpu = -1;
|
|
|
|
|
2017-10-09 08:36:53 +00:00
|
|
|
/*
|
|
|
|
* Ensure the balancing environment is consistent; can happen
|
|
|
|
* when the softirq triggers 'during' hotplug.
|
|
|
|
*/
|
|
|
|
if (!cpumask_test_cpu(env->dst_cpu, env->cpus))
|
|
|
|
return 0;
|
|
|
|
|
2013-08-06 08:36:42 +00:00
|
|
|
/*
|
|
|
|
* In the newly idle case, we will allow all the cpu's
|
|
|
|
* to do the newly idle load balance.
|
|
|
|
*/
|
|
|
|
if (env->idle == CPU_NEWLY_IDLE)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* Try to find first idle cpu */
|
2017-05-01 08:47:02 +00:00
|
|
|
for_each_cpu_and(cpu, group_balance_mask(sg), env->cpus) {
|
2017-05-01 06:51:05 +00:00
|
|
|
if (!idle_cpu(cpu))
|
2013-08-06 08:36:42 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
balance_cpu = cpu;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (balance_cpu == -1)
|
|
|
|
balance_cpu = group_balance_cpu(sg);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First idle cpu or the first cpu(busiest) in this sched group
|
|
|
|
* is eligible for doing load balancing at this and above domains.
|
|
|
|
*/
|
2013-09-10 06:54:49 +00:00
|
|
|
return balance_cpu == env->dst_cpu;
|
2013-08-06 08:36:42 +00:00
|
|
|
}
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/*
|
|
|
|
* Check this_cpu to ensure it is balanced within domain. Attempt to move
|
|
|
|
* tasks if there is an imbalance.
|
|
|
|
*/
|
|
|
|
static int load_balance(int this_cpu, struct rq *this_rq,
|
|
|
|
struct sched_domain *sd, enum cpu_idle_type idle,
|
2013-08-06 08:36:42 +00:00
|
|
|
int *continue_balancing)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2012-06-19 12:13:15 +00:00
|
|
|
int ld_moved, cur_ld_moved, active_balance = 0;
|
2013-08-19 10:41:09 +00:00
|
|
|
struct sched_domain *sd_parent = sd->parent;
|
2009-12-17 16:00:43 +00:00
|
|
|
struct sched_group *group;
|
|
|
|
struct rq *busiest;
|
2016-10-04 14:04:35 +00:00
|
|
|
struct rq_flags rf;
|
2014-08-27 00:12:21 +00:00
|
|
|
struct cpumask *cpus = this_cpu_cpumask_var_ptr(load_balance_mask);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2012-02-22 11:47:19 +00:00
|
|
|
struct lb_env env = {
|
|
|
|
.sd = sd,
|
2012-02-22 18:27:40 +00:00
|
|
|
.dst_cpu = this_cpu,
|
|
|
|
.dst_rq = this_rq,
|
2017-05-01 09:03:12 +00:00
|
|
|
.dst_grpmask = sched_group_span(sd->groups),
|
2012-02-22 11:47:19 +00:00
|
|
|
.idle = idle,
|
2012-04-17 11:38:40 +00:00
|
|
|
.loop_break = sched_nr_migrate_break,
|
2012-07-12 08:10:13 +00:00
|
|
|
.cpus = cpus,
|
2013-10-07 10:29:33 +00:00
|
|
|
.fbq_type = all,
|
2014-08-20 09:48:29 +00:00
|
|
|
.tasks = LIST_HEAD_INIT(env.tasks),
|
2012-02-22 11:47:19 +00:00
|
|
|
};
|
|
|
|
|
2017-06-07 19:18:57 +00:00
|
|
|
cpumask_and(cpus, sched_domain_span(sd), cpu_active_mask);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(sd->lb_count[idle]);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
redo:
|
2013-08-06 08:36:42 +00:00
|
|
|
if (!should_we_balance(&env)) {
|
|
|
|
*continue_balancing = 0;
|
2009-12-17 16:00:43 +00:00
|
|
|
goto out_balanced;
|
2013-08-06 08:36:42 +00:00
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2013-08-06 08:36:42 +00:00
|
|
|
group = find_busiest_group(&env);
|
2009-12-17 16:00:43 +00:00
|
|
|
if (!group) {
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(sd->lb_nobusyg[idle]);
|
2009-12-17 16:00:43 +00:00
|
|
|
goto out_balanced;
|
|
|
|
}
|
|
|
|
|
2012-07-12 08:10:13 +00:00
|
|
|
busiest = find_busiest_queue(&env, group);
|
2009-12-17 16:00:43 +00:00
|
|
|
if (!busiest) {
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(sd->lb_nobusyq[idle]);
|
2009-12-17 16:00:43 +00:00
|
|
|
goto out_balanced;
|
|
|
|
}
|
|
|
|
|
2012-08-06 08:41:59 +00:00
|
|
|
BUG_ON(busiest == env.dst_rq);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_add(sd->lb_imbalance[idle], env.imbalance);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2015-02-27 15:54:14 +00:00
|
|
|
env.src_cpu = busiest->cpu;
|
|
|
|
env.src_rq = busiest;
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
ld_moved = 0;
|
|
|
|
if (busiest->nr_running > 1) {
|
|
|
|
/*
|
|
|
|
* Attempt to move tasks. If find_busiest_group has found
|
|
|
|
* an imbalance but busiest->nr_running <= 1, the group is
|
|
|
|
* still unbalanced. ld_moved simply stays zero, so it is
|
|
|
|
* correctly treated as an imbalance.
|
|
|
|
*/
|
2012-02-22 11:47:19 +00:00
|
|
|
env.flags |= LBF_ALL_PINNED;
|
2012-04-26 11:12:27 +00:00
|
|
|
env.loop_max = min(sysctl_sched_nr_migrate, busiest->nr_running);
|
2012-02-22 11:47:19 +00:00
|
|
|
|
2012-03-09 23:07:36 +00:00
|
|
|
more_balance:
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_lock_irqsave(busiest, &rf);
|
2016-10-03 14:35:32 +00:00
|
|
|
update_rq_clock(busiest);
|
2012-06-19 12:13:15 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* cur_ld_moved - load moved in current iteration
|
|
|
|
* ld_moved - cumulative load moved across iterations
|
|
|
|
*/
|
2014-08-20 09:48:29 +00:00
|
|
|
cur_ld_moved = detach_tasks(&env);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
/*
|
2014-08-20 09:48:29 +00:00
|
|
|
* We've detached some tasks from busiest_rq. Every
|
|
|
|
* task is masked "TASK_ON_RQ_MIGRATING", so we can safely
|
|
|
|
* unlock busiest->lock, and we are able to be sure
|
|
|
|
* that nobody can manipulate the tasks in parallel.
|
|
|
|
* See task_rq_lock() family for the details.
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2014-08-20 09:48:29 +00:00
|
|
|
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_unlock(busiest, &rf);
|
2014-08-20 09:48:29 +00:00
|
|
|
|
|
|
|
if (cur_ld_moved) {
|
|
|
|
attach_tasks(&env);
|
|
|
|
ld_moved += cur_ld_moved;
|
|
|
|
}
|
|
|
|
|
2016-10-04 14:04:35 +00:00
|
|
|
local_irq_restore(rf.flags);
|
2012-06-19 12:13:15 +00:00
|
|
|
|
2013-04-23 08:27:37 +00:00
|
|
|
if (env.flags & LBF_NEED_BREAK) {
|
|
|
|
env.flags &= ~LBF_NEED_BREAK;
|
|
|
|
goto more_balance;
|
|
|
|
}
|
|
|
|
|
2012-06-19 12:13:15 +00:00
|
|
|
/*
|
|
|
|
* Revisit (affine) tasks on src_cpu that couldn't be moved to
|
|
|
|
* us and move them to an alternate dst_cpu in our sched_group
|
|
|
|
* where they can run. The upper limit on how many times we
|
|
|
|
* iterate on same src_cpu is dependent on number of cpus in our
|
|
|
|
* sched_group.
|
|
|
|
*
|
|
|
|
* This changes load balance semantics a bit on who can move
|
|
|
|
* load to a given_cpu. In addition to the given_cpu itself
|
|
|
|
* (or a ilb_cpu acting on its behalf where given_cpu is
|
|
|
|
* nohz-idle), we now have balance_cpu in a position to move
|
|
|
|
* load to given_cpu. In rare situations, this may cause
|
|
|
|
* conflicts (balance_cpu and given_cpu/ilb_cpu deciding
|
|
|
|
* _independently_ and at _same_ time to move some load to
|
|
|
|
* given_cpu) causing exceess load to be moved to given_cpu.
|
|
|
|
* This however should not happen so much in practice and
|
|
|
|
* moreover subsequent load balance cycles should correct the
|
|
|
|
* excess load moved.
|
|
|
|
*/
|
2013-08-19 10:41:09 +00:00
|
|
|
if ((env.flags & LBF_DST_PINNED) && env.imbalance > 0) {
|
2012-06-19 12:13:15 +00:00
|
|
|
|
2013-09-15 17:30:13 +00:00
|
|
|
/* Prevent to re-select dst_cpu via env's cpus */
|
|
|
|
cpumask_clear_cpu(env.dst_cpu, env.cpus);
|
|
|
|
|
2012-08-06 08:41:59 +00:00
|
|
|
env.dst_rq = cpu_rq(env.new_dst_cpu);
|
2012-06-19 12:13:15 +00:00
|
|
|
env.dst_cpu = env.new_dst_cpu;
|
2013-08-19 10:41:09 +00:00
|
|
|
env.flags &= ~LBF_DST_PINNED;
|
2012-06-19 12:13:15 +00:00
|
|
|
env.loop = 0;
|
|
|
|
env.loop_break = sched_nr_migrate_break;
|
2013-04-23 08:27:42 +00:00
|
|
|
|
2012-06-19 12:13:15 +00:00
|
|
|
/*
|
|
|
|
* Go back to "more_balance" rather than "redo" since we
|
|
|
|
* need to continue with same src_cpu.
|
|
|
|
*/
|
|
|
|
goto more_balance;
|
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2013-08-19 10:41:09 +00:00
|
|
|
/*
|
|
|
|
* We failed to reach balance because of affinity.
|
|
|
|
*/
|
|
|
|
if (sd_parent) {
|
2014-05-26 22:19:37 +00:00
|
|
|
int *group_imbalance = &sd_parent->groups->sgc->imbalance;
|
2013-08-19 10:41:09 +00:00
|
|
|
|
2014-08-26 11:06:44 +00:00
|
|
|
if ((env.flags & LBF_SOME_PINNED) && env.imbalance > 0)
|
2013-08-19 10:41:09 +00:00
|
|
|
*group_imbalance = 1;
|
|
|
|
}
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/* All tasks on this runqueue were pinned by CPU affinity */
|
2012-02-22 11:47:19 +00:00
|
|
|
if (unlikely(env.flags & LBF_ALL_PINNED)) {
|
2009-12-17 16:00:43 +00:00
|
|
|
cpumask_clear_cpu(cpu_of(busiest), cpus);
|
2017-06-07 19:18:57 +00:00
|
|
|
/*
|
|
|
|
* Attempting to continue load balancing at the current
|
|
|
|
* sched_domain level only makes sense if there are
|
|
|
|
* active CPUs remaining as possible busiest CPUs to
|
|
|
|
* pull load from which are not contained within the
|
|
|
|
* destination group that is receiving any migrated
|
|
|
|
* load.
|
|
|
|
*/
|
|
|
|
if (!cpumask_subset(cpus, env.dst_grpmask)) {
|
2012-06-19 12:22:07 +00:00
|
|
|
env.loop = 0;
|
|
|
|
env.loop_break = sched_nr_migrate_break;
|
2009-12-17 16:00:43 +00:00
|
|
|
goto redo;
|
2012-06-19 12:22:07 +00:00
|
|
|
}
|
2014-08-26 11:06:44 +00:00
|
|
|
goto out_all_pinned;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ld_moved) {
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(sd->lb_failed[idle]);
|
2010-09-11 01:19:17 +00:00
|
|
|
/*
|
|
|
|
* Increment the failure counter only on periodic balance.
|
|
|
|
* We do not want newidle balance, which can be very
|
|
|
|
* frequent, pollute the failure counter causing
|
|
|
|
* excessive cache_hot migrations and active balances.
|
|
|
|
*/
|
|
|
|
if (idle != CPU_NEWLY_IDLE)
|
|
|
|
sd->nr_balance_failed++;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2012-05-02 12:20:37 +00:00
|
|
|
if (need_active_balance(&env)) {
|
2016-10-04 14:04:35 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
raw_spin_lock_irqsave(&busiest->lock, flags);
|
|
|
|
|
2010-05-06 16:49:21 +00:00
|
|
|
/* don't kick the active_load_balance_cpu_stop,
|
|
|
|
* if the curr task on busiest cpu can't be
|
|
|
|
* moved to this_cpu
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2017-02-05 14:38:10 +00:00
|
|
|
if (!cpumask_test_cpu(this_cpu, &busiest->curr->cpus_allowed)) {
|
2009-12-17 16:00:43 +00:00
|
|
|
raw_spin_unlock_irqrestore(&busiest->lock,
|
|
|
|
flags);
|
2012-02-22 11:47:19 +00:00
|
|
|
env.flags |= LBF_ALL_PINNED;
|
2009-12-17 16:00:43 +00:00
|
|
|
goto out_one_pinned;
|
|
|
|
}
|
|
|
|
|
2010-05-06 16:49:21 +00:00
|
|
|
/*
|
|
|
|
* ->active_balance synchronizes accesses to
|
|
|
|
* ->active_balance_work. Once set, it's cleared
|
|
|
|
* only after active load balance is finished.
|
|
|
|
*/
|
2009-12-17 16:00:43 +00:00
|
|
|
if (!busiest->active_balance) {
|
|
|
|
busiest->active_balance = 1;
|
|
|
|
busiest->push_cpu = this_cpu;
|
|
|
|
active_balance = 1;
|
|
|
|
}
|
|
|
|
raw_spin_unlock_irqrestore(&busiest->lock, flags);
|
2010-05-06 16:49:21 +00:00
|
|
|
|
2012-05-02 12:20:37 +00:00
|
|
|
if (active_balance) {
|
2010-05-06 16:49:21 +00:00
|
|
|
stop_one_cpu_nowait(cpu_of(busiest),
|
|
|
|
active_load_balance_cpu_stop, busiest,
|
|
|
|
&busiest->active_balance_work);
|
2012-05-02 12:20:37 +00:00
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2016-03-23 12:24:44 +00:00
|
|
|
/* We've kicked active balancing, force task migration. */
|
2009-12-17 16:00:43 +00:00
|
|
|
sd->nr_balance_failed = sd->cache_nice_tries+1;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
sd->nr_balance_failed = 0;
|
|
|
|
|
|
|
|
if (likely(!active_balance)) {
|
|
|
|
/* We were unbalanced, so reset the balancing interval */
|
|
|
|
sd->balance_interval = sd->min_interval;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If we've begun active balancing, start to back off. This
|
|
|
|
* case may not be covered by the all_pinned logic if there
|
|
|
|
* is only 1 task on the busy runqueue (because we don't call
|
2014-08-20 09:48:29 +00:00
|
|
|
* detach_tasks).
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
|
|
|
if (sd->balance_interval < sd->max_interval)
|
|
|
|
sd->balance_interval *= 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
out_balanced:
|
2014-08-26 11:06:44 +00:00
|
|
|
/*
|
|
|
|
* We reach balance although we may have faced some affinity
|
|
|
|
* constraints. Clear the imbalance flag if it was set.
|
|
|
|
*/
|
|
|
|
if (sd_parent) {
|
|
|
|
int *group_imbalance = &sd_parent->groups->sgc->imbalance;
|
|
|
|
|
|
|
|
if (*group_imbalance)
|
|
|
|
*group_imbalance = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
out_all_pinned:
|
|
|
|
/*
|
|
|
|
* We reach balance because all tasks are pinned at this level so
|
|
|
|
* we can't migrate them. Let the imbalance flag set so parent level
|
|
|
|
* can try to migrate them.
|
|
|
|
*/
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(sd->lb_balanced[idle]);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
sd->nr_balance_failed = 0;
|
|
|
|
|
|
|
|
out_one_pinned:
|
|
|
|
/* tune up the balancing interval */
|
2012-02-22 11:47:19 +00:00
|
|
|
if (((env.flags & LBF_ALL_PINNED) &&
|
2011-09-22 13:23:13 +00:00
|
|
|
sd->balance_interval < MAX_PINNED_INTERVAL) ||
|
2009-12-17 16:00:43 +00:00
|
|
|
(sd->balance_interval < sd->max_interval))
|
|
|
|
sd->balance_interval *= 2;
|
|
|
|
|
2011-02-14 22:38:50 +00:00
|
|
|
ld_moved = 0;
|
2009-12-17 16:00:43 +00:00
|
|
|
out:
|
|
|
|
return ld_moved;
|
|
|
|
}
|
|
|
|
|
sched: Fix the rq->next_balance logic in rebalance_domains() and idle_balance()
Currently, in idle_balance(), we update rq->next_balance when we pull_tasks.
However, it is also important to update this in the !pulled_tasks case too.
When the CPU is "busy" (the CPU isn't idle), rq->next_balance gets computed
using sd->busy_factor (so we increase the balance interval when the CPU is
busy). However, when the CPU goes idle, rq->next_balance could still be set
to a large value that was computed with the sd->busy_factor.
Thus, we need to also update rq->next_balance in idle_balance() in the cases
where !pulled_tasks too, so that rq->next_balance gets updated without taking
the busy_factor into account when the CPU is about to go idle.
This patch makes rq->next_balance get updated independently of whether or
not we pulled_task. Also, we add logic to ensure that we always traverse
at least 1 of the sched domains to get a proper next_balance value for
updating rq->next_balance.
Additionally, since load_balance() modifies the sd->balance_interval, we
need to re-obtain the sched domain's interval after the call to
load_balance() in rebalance_domains() before we update rq->next_balance.
This patch adds and uses 2 new helper functions, update_next_balance() and
get_sd_balance_interval() to update next_balance and obtain the sched
domain's balance_interval.
Signed-off-by: Jason Low <jason.low2@hp.com>
Reviewed-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: daniel.lezcano@linaro.org
Cc: alex.shi@linaro.org
Cc: efault@gmx.de
Cc: vincent.guittot@linaro.org
Cc: morten.rasmussen@arm.com
Cc: aswin@hp.com
Link: http://lkml.kernel.org/r/1399596562.2200.7.camel@j-VirtualBox
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-05-09 00:49:22 +00:00
|
|
|
static inline unsigned long
|
|
|
|
get_sd_balance_interval(struct sched_domain *sd, int cpu_busy)
|
|
|
|
{
|
|
|
|
unsigned long interval = sd->balance_interval;
|
|
|
|
|
|
|
|
if (cpu_busy)
|
|
|
|
interval *= sd->busy_factor;
|
|
|
|
|
|
|
|
/* scale ms to jiffies */
|
|
|
|
interval = msecs_to_jiffies(interval);
|
|
|
|
interval = clamp(interval, 1UL, max_load_balance_interval);
|
|
|
|
|
|
|
|
return interval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
2016-08-05 06:31:29 +00:00
|
|
|
update_next_balance(struct sched_domain *sd, unsigned long *next_balance)
|
sched: Fix the rq->next_balance logic in rebalance_domains() and idle_balance()
Currently, in idle_balance(), we update rq->next_balance when we pull_tasks.
However, it is also important to update this in the !pulled_tasks case too.
When the CPU is "busy" (the CPU isn't idle), rq->next_balance gets computed
using sd->busy_factor (so we increase the balance interval when the CPU is
busy). However, when the CPU goes idle, rq->next_balance could still be set
to a large value that was computed with the sd->busy_factor.
Thus, we need to also update rq->next_balance in idle_balance() in the cases
where !pulled_tasks too, so that rq->next_balance gets updated without taking
the busy_factor into account when the CPU is about to go idle.
This patch makes rq->next_balance get updated independently of whether or
not we pulled_task. Also, we add logic to ensure that we always traverse
at least 1 of the sched domains to get a proper next_balance value for
updating rq->next_balance.
Additionally, since load_balance() modifies the sd->balance_interval, we
need to re-obtain the sched domain's interval after the call to
load_balance() in rebalance_domains() before we update rq->next_balance.
This patch adds and uses 2 new helper functions, update_next_balance() and
get_sd_balance_interval() to update next_balance and obtain the sched
domain's balance_interval.
Signed-off-by: Jason Low <jason.low2@hp.com>
Reviewed-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: daniel.lezcano@linaro.org
Cc: alex.shi@linaro.org
Cc: efault@gmx.de
Cc: vincent.guittot@linaro.org
Cc: morten.rasmussen@arm.com
Cc: aswin@hp.com
Link: http://lkml.kernel.org/r/1399596562.2200.7.camel@j-VirtualBox
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-05-09 00:49:22 +00:00
|
|
|
{
|
|
|
|
unsigned long interval, next;
|
|
|
|
|
2016-08-05 06:31:29 +00:00
|
|
|
/* used by idle balance, so cpu_busy = 0 */
|
|
|
|
interval = get_sd_balance_interval(sd, 0);
|
sched: Fix the rq->next_balance logic in rebalance_domains() and idle_balance()
Currently, in idle_balance(), we update rq->next_balance when we pull_tasks.
However, it is also important to update this in the !pulled_tasks case too.
When the CPU is "busy" (the CPU isn't idle), rq->next_balance gets computed
using sd->busy_factor (so we increase the balance interval when the CPU is
busy). However, when the CPU goes idle, rq->next_balance could still be set
to a large value that was computed with the sd->busy_factor.
Thus, we need to also update rq->next_balance in idle_balance() in the cases
where !pulled_tasks too, so that rq->next_balance gets updated without taking
the busy_factor into account when the CPU is about to go idle.
This patch makes rq->next_balance get updated independently of whether or
not we pulled_task. Also, we add logic to ensure that we always traverse
at least 1 of the sched domains to get a proper next_balance value for
updating rq->next_balance.
Additionally, since load_balance() modifies the sd->balance_interval, we
need to re-obtain the sched domain's interval after the call to
load_balance() in rebalance_domains() before we update rq->next_balance.
This patch adds and uses 2 new helper functions, update_next_balance() and
get_sd_balance_interval() to update next_balance and obtain the sched
domain's balance_interval.
Signed-off-by: Jason Low <jason.low2@hp.com>
Reviewed-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: daniel.lezcano@linaro.org
Cc: alex.shi@linaro.org
Cc: efault@gmx.de
Cc: vincent.guittot@linaro.org
Cc: morten.rasmussen@arm.com
Cc: aswin@hp.com
Link: http://lkml.kernel.org/r/1399596562.2200.7.camel@j-VirtualBox
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-05-09 00:49:22 +00:00
|
|
|
next = sd->last_balance + interval;
|
|
|
|
|
|
|
|
if (time_after(*next_balance, next))
|
|
|
|
*next_balance = next;
|
|
|
|
}
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/*
|
|
|
|
* idle_balance is called by schedule() if this_cpu is about to become
|
|
|
|
* idle. Attempts to pull tasks from other CPUs.
|
|
|
|
*/
|
2016-09-21 13:38:12 +00:00
|
|
|
static int idle_balance(struct rq *this_rq, struct rq_flags *rf)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
sched: Fix the rq->next_balance logic in rebalance_domains() and idle_balance()
Currently, in idle_balance(), we update rq->next_balance when we pull_tasks.
However, it is also important to update this in the !pulled_tasks case too.
When the CPU is "busy" (the CPU isn't idle), rq->next_balance gets computed
using sd->busy_factor (so we increase the balance interval when the CPU is
busy). However, when the CPU goes idle, rq->next_balance could still be set
to a large value that was computed with the sd->busy_factor.
Thus, we need to also update rq->next_balance in idle_balance() in the cases
where !pulled_tasks too, so that rq->next_balance gets updated without taking
the busy_factor into account when the CPU is about to go idle.
This patch makes rq->next_balance get updated independently of whether or
not we pulled_task. Also, we add logic to ensure that we always traverse
at least 1 of the sched domains to get a proper next_balance value for
updating rq->next_balance.
Additionally, since load_balance() modifies the sd->balance_interval, we
need to re-obtain the sched domain's interval after the call to
load_balance() in rebalance_domains() before we update rq->next_balance.
This patch adds and uses 2 new helper functions, update_next_balance() and
get_sd_balance_interval() to update next_balance and obtain the sched
domain's balance_interval.
Signed-off-by: Jason Low <jason.low2@hp.com>
Reviewed-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: daniel.lezcano@linaro.org
Cc: alex.shi@linaro.org
Cc: efault@gmx.de
Cc: vincent.guittot@linaro.org
Cc: morten.rasmussen@arm.com
Cc: aswin@hp.com
Link: http://lkml.kernel.org/r/1399596562.2200.7.camel@j-VirtualBox
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-05-09 00:49:22 +00:00
|
|
|
unsigned long next_balance = jiffies + HZ;
|
|
|
|
int this_cpu = this_rq->cpu;
|
2009-12-17 16:00:43 +00:00
|
|
|
struct sched_domain *sd;
|
|
|
|
int pulled_task = 0;
|
2013-09-13 18:26:52 +00:00
|
|
|
u64 curr_cost = 0;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2014-02-11 15:11:48 +00:00
|
|
|
/*
|
|
|
|
* We must set idle_stamp _before_ calling idle_balance(), such that we
|
|
|
|
* measure the duration of idle_balance() as idle time.
|
|
|
|
*/
|
|
|
|
this_rq->idle_stamp = rq_clock(this_rq);
|
|
|
|
|
2017-09-07 15:03:50 +00:00
|
|
|
/*
|
|
|
|
* Do not pull tasks towards !active CPUs...
|
|
|
|
*/
|
|
|
|
if (!cpu_active(this_cpu))
|
|
|
|
return 0;
|
|
|
|
|
2016-09-21 13:38:12 +00:00
|
|
|
/*
|
|
|
|
* This is OK, because current is on_cpu, which avoids it being picked
|
|
|
|
* for load-balance and preemption/IRQs are still disabled avoiding
|
|
|
|
* further scheduler activity on it and we're being very careful to
|
|
|
|
* re-start the picking loop.
|
|
|
|
*/
|
|
|
|
rq_unpin_lock(this_rq, rf);
|
|
|
|
|
2014-06-23 19:16:49 +00:00
|
|
|
if (this_rq->avg_idle < sysctl_sched_migration_cost ||
|
|
|
|
!this_rq->rd->overload) {
|
sched: Fix the rq->next_balance logic in rebalance_domains() and idle_balance()
Currently, in idle_balance(), we update rq->next_balance when we pull_tasks.
However, it is also important to update this in the !pulled_tasks case too.
When the CPU is "busy" (the CPU isn't idle), rq->next_balance gets computed
using sd->busy_factor (so we increase the balance interval when the CPU is
busy). However, when the CPU goes idle, rq->next_balance could still be set
to a large value that was computed with the sd->busy_factor.
Thus, we need to also update rq->next_balance in idle_balance() in the cases
where !pulled_tasks too, so that rq->next_balance gets updated without taking
the busy_factor into account when the CPU is about to go idle.
This patch makes rq->next_balance get updated independently of whether or
not we pulled_task. Also, we add logic to ensure that we always traverse
at least 1 of the sched domains to get a proper next_balance value for
updating rq->next_balance.
Additionally, since load_balance() modifies the sd->balance_interval, we
need to re-obtain the sched domain's interval after the call to
load_balance() in rebalance_domains() before we update rq->next_balance.
This patch adds and uses 2 new helper functions, update_next_balance() and
get_sd_balance_interval() to update next_balance and obtain the sched
domain's balance_interval.
Signed-off-by: Jason Low <jason.low2@hp.com>
Reviewed-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: daniel.lezcano@linaro.org
Cc: alex.shi@linaro.org
Cc: efault@gmx.de
Cc: vincent.guittot@linaro.org
Cc: morten.rasmussen@arm.com
Cc: aswin@hp.com
Link: http://lkml.kernel.org/r/1399596562.2200.7.camel@j-VirtualBox
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-05-09 00:49:22 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
sd = rcu_dereference_check_sched_domain(this_rq->sd);
|
|
|
|
if (sd)
|
2016-08-05 06:31:29 +00:00
|
|
|
update_next_balance(sd, &next_balance);
|
sched: Fix the rq->next_balance logic in rebalance_domains() and idle_balance()
Currently, in idle_balance(), we update rq->next_balance when we pull_tasks.
However, it is also important to update this in the !pulled_tasks case too.
When the CPU is "busy" (the CPU isn't idle), rq->next_balance gets computed
using sd->busy_factor (so we increase the balance interval when the CPU is
busy). However, when the CPU goes idle, rq->next_balance could still be set
to a large value that was computed with the sd->busy_factor.
Thus, we need to also update rq->next_balance in idle_balance() in the cases
where !pulled_tasks too, so that rq->next_balance gets updated without taking
the busy_factor into account when the CPU is about to go idle.
This patch makes rq->next_balance get updated independently of whether or
not we pulled_task. Also, we add logic to ensure that we always traverse
at least 1 of the sched domains to get a proper next_balance value for
updating rq->next_balance.
Additionally, since load_balance() modifies the sd->balance_interval, we
need to re-obtain the sched domain's interval after the call to
load_balance() in rebalance_domains() before we update rq->next_balance.
This patch adds and uses 2 new helper functions, update_next_balance() and
get_sd_balance_interval() to update next_balance and obtain the sched
domain's balance_interval.
Signed-off-by: Jason Low <jason.low2@hp.com>
Reviewed-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: daniel.lezcano@linaro.org
Cc: alex.shi@linaro.org
Cc: efault@gmx.de
Cc: vincent.guittot@linaro.org
Cc: morten.rasmussen@arm.com
Cc: aswin@hp.com
Link: http://lkml.kernel.org/r/1399596562.2200.7.camel@j-VirtualBox
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-05-09 00:49:22 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
2014-02-11 15:11:48 +00:00
|
|
|
goto out;
|
sched: Fix the rq->next_balance logic in rebalance_domains() and idle_balance()
Currently, in idle_balance(), we update rq->next_balance when we pull_tasks.
However, it is also important to update this in the !pulled_tasks case too.
When the CPU is "busy" (the CPU isn't idle), rq->next_balance gets computed
using sd->busy_factor (so we increase the balance interval when the CPU is
busy). However, when the CPU goes idle, rq->next_balance could still be set
to a large value that was computed with the sd->busy_factor.
Thus, we need to also update rq->next_balance in idle_balance() in the cases
where !pulled_tasks too, so that rq->next_balance gets updated without taking
the busy_factor into account when the CPU is about to go idle.
This patch makes rq->next_balance get updated independently of whether or
not we pulled_task. Also, we add logic to ensure that we always traverse
at least 1 of the sched domains to get a proper next_balance value for
updating rq->next_balance.
Additionally, since load_balance() modifies the sd->balance_interval, we
need to re-obtain the sched domain's interval after the call to
load_balance() in rebalance_domains() before we update rq->next_balance.
This patch adds and uses 2 new helper functions, update_next_balance() and
get_sd_balance_interval() to update next_balance and obtain the sched
domain's balance_interval.
Signed-off-by: Jason Low <jason.low2@hp.com>
Reviewed-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: daniel.lezcano@linaro.org
Cc: alex.shi@linaro.org
Cc: efault@gmx.de
Cc: vincent.guittot@linaro.org
Cc: morten.rasmussen@arm.com
Cc: aswin@hp.com
Link: http://lkml.kernel.org/r/1399596562.2200.7.camel@j-VirtualBox
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-05-09 00:49:22 +00:00
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2009-12-23 14:29:42 +00:00
|
|
|
raw_spin_unlock(&this_rq->lock);
|
|
|
|
|
2012-10-04 11:18:31 +00:00
|
|
|
update_blocked_averages(this_cpu);
|
2011-04-07 12:09:50 +00:00
|
|
|
rcu_read_lock();
|
2009-12-17 16:00:43 +00:00
|
|
|
for_each_domain(this_cpu, sd) {
|
2013-08-06 08:36:42 +00:00
|
|
|
int continue_balancing = 1;
|
2013-09-13 18:26:52 +00:00
|
|
|
u64 t0, domain_cost;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
if (!(sd->flags & SD_LOAD_BALANCE))
|
|
|
|
continue;
|
|
|
|
|
sched: Fix the rq->next_balance logic in rebalance_domains() and idle_balance()
Currently, in idle_balance(), we update rq->next_balance when we pull_tasks.
However, it is also important to update this in the !pulled_tasks case too.
When the CPU is "busy" (the CPU isn't idle), rq->next_balance gets computed
using sd->busy_factor (so we increase the balance interval when the CPU is
busy). However, when the CPU goes idle, rq->next_balance could still be set
to a large value that was computed with the sd->busy_factor.
Thus, we need to also update rq->next_balance in idle_balance() in the cases
where !pulled_tasks too, so that rq->next_balance gets updated without taking
the busy_factor into account when the CPU is about to go idle.
This patch makes rq->next_balance get updated independently of whether or
not we pulled_task. Also, we add logic to ensure that we always traverse
at least 1 of the sched domains to get a proper next_balance value for
updating rq->next_balance.
Additionally, since load_balance() modifies the sd->balance_interval, we
need to re-obtain the sched domain's interval after the call to
load_balance() in rebalance_domains() before we update rq->next_balance.
This patch adds and uses 2 new helper functions, update_next_balance() and
get_sd_balance_interval() to update next_balance and obtain the sched
domain's balance_interval.
Signed-off-by: Jason Low <jason.low2@hp.com>
Reviewed-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: daniel.lezcano@linaro.org
Cc: alex.shi@linaro.org
Cc: efault@gmx.de
Cc: vincent.guittot@linaro.org
Cc: morten.rasmussen@arm.com
Cc: aswin@hp.com
Link: http://lkml.kernel.org/r/1399596562.2200.7.camel@j-VirtualBox
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-05-09 00:49:22 +00:00
|
|
|
if (this_rq->avg_idle < curr_cost + sd->max_newidle_lb_cost) {
|
2016-08-05 06:31:29 +00:00
|
|
|
update_next_balance(sd, &next_balance);
|
2013-09-13 18:26:52 +00:00
|
|
|
break;
|
sched: Fix the rq->next_balance logic in rebalance_domains() and idle_balance()
Currently, in idle_balance(), we update rq->next_balance when we pull_tasks.
However, it is also important to update this in the !pulled_tasks case too.
When the CPU is "busy" (the CPU isn't idle), rq->next_balance gets computed
using sd->busy_factor (so we increase the balance interval when the CPU is
busy). However, when the CPU goes idle, rq->next_balance could still be set
to a large value that was computed with the sd->busy_factor.
Thus, we need to also update rq->next_balance in idle_balance() in the cases
where !pulled_tasks too, so that rq->next_balance gets updated without taking
the busy_factor into account when the CPU is about to go idle.
This patch makes rq->next_balance get updated independently of whether or
not we pulled_task. Also, we add logic to ensure that we always traverse
at least 1 of the sched domains to get a proper next_balance value for
updating rq->next_balance.
Additionally, since load_balance() modifies the sd->balance_interval, we
need to re-obtain the sched domain's interval after the call to
load_balance() in rebalance_domains() before we update rq->next_balance.
This patch adds and uses 2 new helper functions, update_next_balance() and
get_sd_balance_interval() to update next_balance and obtain the sched
domain's balance_interval.
Signed-off-by: Jason Low <jason.low2@hp.com>
Reviewed-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: daniel.lezcano@linaro.org
Cc: alex.shi@linaro.org
Cc: efault@gmx.de
Cc: vincent.guittot@linaro.org
Cc: morten.rasmussen@arm.com
Cc: aswin@hp.com
Link: http://lkml.kernel.org/r/1399596562.2200.7.camel@j-VirtualBox
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-05-09 00:49:22 +00:00
|
|
|
}
|
2013-09-13 18:26:52 +00:00
|
|
|
|
2009-12-23 14:29:42 +00:00
|
|
|
if (sd->flags & SD_BALANCE_NEWIDLE) {
|
2013-09-13 18:26:52 +00:00
|
|
|
t0 = sched_clock_cpu(this_cpu);
|
|
|
|
|
2009-12-23 14:29:42 +00:00
|
|
|
pulled_task = load_balance(this_cpu, this_rq,
|
2013-08-06 08:36:42 +00:00
|
|
|
sd, CPU_NEWLY_IDLE,
|
|
|
|
&continue_balancing);
|
2013-09-13 18:26:52 +00:00
|
|
|
|
|
|
|
domain_cost = sched_clock_cpu(this_cpu) - t0;
|
|
|
|
if (domain_cost > sd->max_newidle_lb_cost)
|
|
|
|
sd->max_newidle_lb_cost = domain_cost;
|
|
|
|
|
|
|
|
curr_cost += domain_cost;
|
2009-12-23 14:29:42 +00:00
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2016-08-05 06:31:29 +00:00
|
|
|
update_next_balance(sd, &next_balance);
|
2014-04-24 01:30:35 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop searching for tasks to pull if there are
|
|
|
|
* now runnable tasks on this rq.
|
|
|
|
*/
|
|
|
|
if (pulled_task || this_rq->nr_running > 0)
|
2009-12-17 16:00:43 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-04-07 12:09:50 +00:00
|
|
|
rcu_read_unlock();
|
2009-12-23 14:29:42 +00:00
|
|
|
|
|
|
|
raw_spin_lock(&this_rq->lock);
|
|
|
|
|
2014-04-28 22:45:54 +00:00
|
|
|
if (curr_cost > this_rq->max_idle_balance_cost)
|
|
|
|
this_rq->max_idle_balance_cost = curr_cost;
|
|
|
|
|
2014-01-17 09:04:02 +00:00
|
|
|
/*
|
2014-04-28 22:45:54 +00:00
|
|
|
* While browsing the domains, we released the rq lock, a task could
|
|
|
|
* have been enqueued in the meantime. Since we're not going idle,
|
|
|
|
* pretend we pulled a task.
|
2014-01-17 09:04:02 +00:00
|
|
|
*/
|
2014-04-28 22:45:54 +00:00
|
|
|
if (this_rq->cfs.h_nr_running && !pulled_task)
|
2014-02-11 15:11:48 +00:00
|
|
|
pulled_task = 1;
|
2014-01-17 09:04:02 +00:00
|
|
|
|
sched: Fix the rq->next_balance logic in rebalance_domains() and idle_balance()
Currently, in idle_balance(), we update rq->next_balance when we pull_tasks.
However, it is also important to update this in the !pulled_tasks case too.
When the CPU is "busy" (the CPU isn't idle), rq->next_balance gets computed
using sd->busy_factor (so we increase the balance interval when the CPU is
busy). However, when the CPU goes idle, rq->next_balance could still be set
to a large value that was computed with the sd->busy_factor.
Thus, we need to also update rq->next_balance in idle_balance() in the cases
where !pulled_tasks too, so that rq->next_balance gets updated without taking
the busy_factor into account when the CPU is about to go idle.
This patch makes rq->next_balance get updated independently of whether or
not we pulled_task. Also, we add logic to ensure that we always traverse
at least 1 of the sched domains to get a proper next_balance value for
updating rq->next_balance.
Additionally, since load_balance() modifies the sd->balance_interval, we
need to re-obtain the sched domain's interval after the call to
load_balance() in rebalance_domains() before we update rq->next_balance.
This patch adds and uses 2 new helper functions, update_next_balance() and
get_sd_balance_interval() to update next_balance and obtain the sched
domain's balance_interval.
Signed-off-by: Jason Low <jason.low2@hp.com>
Reviewed-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: daniel.lezcano@linaro.org
Cc: alex.shi@linaro.org
Cc: efault@gmx.de
Cc: vincent.guittot@linaro.org
Cc: morten.rasmussen@arm.com
Cc: aswin@hp.com
Link: http://lkml.kernel.org/r/1399596562.2200.7.camel@j-VirtualBox
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-05-09 00:49:22 +00:00
|
|
|
out:
|
|
|
|
/* Move the next balance forward */
|
|
|
|
if (time_after(this_rq->next_balance, next_balance))
|
2009-12-17 16:00:43 +00:00
|
|
|
this_rq->next_balance = next_balance;
|
2013-09-13 18:26:52 +00:00
|
|
|
|
2014-03-06 09:31:55 +00:00
|
|
|
/* Is there a task of a high priority class? */
|
2014-03-14 22:15:07 +00:00
|
|
|
if (this_rq->nr_running != this_rq->cfs.h_nr_running)
|
2014-03-06 09:31:55 +00:00
|
|
|
pulled_task = -1;
|
|
|
|
|
2015-10-20 12:04:41 +00:00
|
|
|
if (pulled_task)
|
2014-02-11 15:11:48 +00:00
|
|
|
this_rq->idle_stamp = 0;
|
|
|
|
|
2016-09-21 13:38:12 +00:00
|
|
|
rq_repin_lock(this_rq, rf);
|
|
|
|
|
2014-01-17 09:04:03 +00:00
|
|
|
return pulled_task;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-05-06 16:49:21 +00:00
|
|
|
* active_load_balance_cpu_stop is run by cpu stopper. It pushes
|
|
|
|
* running tasks off the busiest CPU onto idle CPUs. It requires at
|
|
|
|
* least 1 task to be running on each physical CPU where possible, and
|
|
|
|
* avoids physical / logical imbalances.
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2010-05-06 16:49:21 +00:00
|
|
|
static int active_load_balance_cpu_stop(void *data)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2010-05-06 16:49:21 +00:00
|
|
|
struct rq *busiest_rq = data;
|
|
|
|
int busiest_cpu = cpu_of(busiest_rq);
|
2009-12-17 16:00:43 +00:00
|
|
|
int target_cpu = busiest_rq->push_cpu;
|
2010-05-06 16:49:21 +00:00
|
|
|
struct rq *target_rq = cpu_rq(target_cpu);
|
2009-12-17 16:00:43 +00:00
|
|
|
struct sched_domain *sd;
|
2014-08-20 09:48:01 +00:00
|
|
|
struct task_struct *p = NULL;
|
2016-10-04 14:04:35 +00:00
|
|
|
struct rq_flags rf;
|
2010-05-06 16:49:21 +00:00
|
|
|
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_lock_irq(busiest_rq, &rf);
|
2017-09-07 15:03:51 +00:00
|
|
|
/*
|
|
|
|
* Between queueing the stop-work and running it is a hole in which
|
|
|
|
* CPUs can become inactive. We should not move tasks from or to
|
|
|
|
* inactive CPUs.
|
|
|
|
*/
|
|
|
|
if (!cpu_active(busiest_cpu) || !cpu_active(target_cpu))
|
|
|
|
goto out_unlock;
|
2010-05-06 16:49:21 +00:00
|
|
|
|
|
|
|
/* make sure the requested cpu hasn't gone down in the meantime */
|
|
|
|
if (unlikely(busiest_cpu != smp_processor_id() ||
|
|
|
|
!busiest_rq->active_balance))
|
|
|
|
goto out_unlock;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
/* Is there any task to move? */
|
|
|
|
if (busiest_rq->nr_running <= 1)
|
2010-05-06 16:49:21 +00:00
|
|
|
goto out_unlock;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This condition is "impossible", if it occurs
|
|
|
|
* we need to fix it. Originally reported by
|
|
|
|
* Bjorn Helgaas on a 128-cpu setup.
|
|
|
|
*/
|
|
|
|
BUG_ON(busiest_rq == target_rq);
|
|
|
|
|
|
|
|
/* Search for an sd spanning us and the target CPU. */
|
2011-04-07 12:09:50 +00:00
|
|
|
rcu_read_lock();
|
2009-12-17 16:00:43 +00:00
|
|
|
for_each_domain(target_cpu, sd) {
|
|
|
|
if ((sd->flags & SD_LOAD_BALANCE) &&
|
|
|
|
cpumask_test_cpu(busiest_cpu, sched_domain_span(sd)))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (likely(sd)) {
|
2012-02-22 11:47:19 +00:00
|
|
|
struct lb_env env = {
|
|
|
|
.sd = sd,
|
2012-02-22 18:27:40 +00:00
|
|
|
.dst_cpu = target_cpu,
|
|
|
|
.dst_rq = target_rq,
|
|
|
|
.src_cpu = busiest_rq->cpu,
|
|
|
|
.src_rq = busiest_rq,
|
2012-02-22 11:47:19 +00:00
|
|
|
.idle = CPU_IDLE,
|
2017-06-07 19:18:57 +00:00
|
|
|
/*
|
|
|
|
* can_migrate_task() doesn't need to compute new_dst_cpu
|
|
|
|
* for active balancing. Since we have CPU_IDLE, but no
|
|
|
|
* @dst_grpmask we need to make that test go away with lying
|
|
|
|
* about DST_PINNED.
|
|
|
|
*/
|
|
|
|
.flags = LBF_DST_PINNED,
|
2012-02-22 11:47:19 +00:00
|
|
|
};
|
|
|
|
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(sd->alb_count);
|
2016-10-03 14:35:32 +00:00
|
|
|
update_rq_clock(busiest_rq);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2014-08-20 09:48:01 +00:00
|
|
|
p = detach_one_task(&env);
|
2016-03-23 12:24:44 +00:00
|
|
|
if (p) {
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(sd->alb_pushed);
|
2016-03-23 12:24:44 +00:00
|
|
|
/* Active balancing done, reset the failure counter. */
|
|
|
|
sd->nr_balance_failed = 0;
|
|
|
|
} else {
|
2016-06-17 17:43:24 +00:00
|
|
|
schedstat_inc(sd->alb_failed);
|
2016-03-23 12:24:44 +00:00
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
2011-04-07 12:09:50 +00:00
|
|
|
rcu_read_unlock();
|
2010-05-06 16:49:21 +00:00
|
|
|
out_unlock:
|
|
|
|
busiest_rq->active_balance = 0;
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_unlock(busiest_rq, &rf);
|
2014-08-20 09:48:01 +00:00
|
|
|
|
|
|
|
if (p)
|
|
|
|
attach_one_task(target_rq, p);
|
|
|
|
|
|
|
|
local_irq_enable();
|
|
|
|
|
2010-05-06 16:49:21 +00:00
|
|
|
return 0;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
2011-12-05 09:01:47 +00:00
|
|
|
static inline int on_null_domain(struct rq *rq)
|
|
|
|
{
|
|
|
|
return unlikely(!rcu_dereference_sched(rq->sd));
|
|
|
|
}
|
|
|
|
|
2011-08-10 21:21:01 +00:00
|
|
|
#ifdef CONFIG_NO_HZ_COMMON
|
2010-05-22 00:09:41 +00:00
|
|
|
/*
|
|
|
|
* idle load balancing details
|
|
|
|
* - When one of the busy CPUs notice that there may be an idle rebalancing
|
|
|
|
* needed, they will kick the idle load balancer, which then does idle
|
|
|
|
* load balancing for all the idle CPUs.
|
|
|
|
*/
|
2009-12-17 16:00:43 +00:00
|
|
|
static struct {
|
2010-05-22 00:09:41 +00:00
|
|
|
cpumask_var_t idle_cpus_mask;
|
2011-12-02 01:07:34 +00:00
|
|
|
atomic_t nr_cpus;
|
2010-05-22 00:09:41 +00:00
|
|
|
unsigned long next_balance; /* in jiffy units */
|
|
|
|
} nohz ____cacheline_aligned;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2014-01-06 11:34:41 +00:00
|
|
|
static inline int find_new_ilb(void)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2011-12-02 01:07:34 +00:00
|
|
|
int ilb = cpumask_first(nohz.idle_cpus_mask);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2011-12-02 01:07:35 +00:00
|
|
|
if (ilb < nr_cpu_ids && idle_cpu(ilb))
|
|
|
|
return ilb;
|
|
|
|
|
|
|
|
return nr_cpu_ids;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
2010-05-22 00:09:41 +00:00
|
|
|
/*
|
|
|
|
* Kick a CPU to do the nohz balancing, if it is time for it. We pick the
|
|
|
|
* nohz_load_balancer CPU (if there is one) otherwise fallback to any idle
|
|
|
|
* CPU (if there is one).
|
|
|
|
*/
|
2014-01-06 11:34:42 +00:00
|
|
|
static void nohz_balancer_kick(void)
|
2010-05-22 00:09:41 +00:00
|
|
|
{
|
|
|
|
int ilb_cpu;
|
|
|
|
|
|
|
|
nohz.next_balance++;
|
|
|
|
|
2014-01-06 11:34:41 +00:00
|
|
|
ilb_cpu = find_new_ilb();
|
2010-05-22 00:09:41 +00:00
|
|
|
|
2011-12-02 01:07:34 +00:00
|
|
|
if (ilb_cpu >= nr_cpu_ids)
|
|
|
|
return;
|
2010-05-22 00:09:41 +00:00
|
|
|
|
2011-12-06 19:26:34 +00:00
|
|
|
if (test_and_set_bit(NOHZ_BALANCE_KICK, nohz_flags(ilb_cpu)))
|
2011-12-02 01:07:32 +00:00
|
|
|
return;
|
|
|
|
/*
|
|
|
|
* Use smp_send_reschedule() instead of resched_cpu().
|
|
|
|
* This way we generate a sched IPI on the target cpu which
|
|
|
|
* is idle. And the softirq performing nohz idle load balance
|
|
|
|
* will be run before returning from the IPI.
|
|
|
|
*/
|
|
|
|
smp_send_reschedule(ilb_cpu);
|
2010-05-22 00:09:41 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-03-10 11:54:20 +00:00
|
|
|
void nohz_balance_exit_idle(unsigned int cpu)
|
2012-01-20 02:28:57 +00:00
|
|
|
{
|
|
|
|
if (unlikely(test_bit(NOHZ_TICK_STOPPED, nohz_flags(cpu)))) {
|
2011-12-05 09:01:47 +00:00
|
|
|
/*
|
|
|
|
* Completely isolated CPUs don't ever set, so we must test.
|
|
|
|
*/
|
|
|
|
if (likely(cpumask_test_cpu(cpu, nohz.idle_cpus_mask))) {
|
|
|
|
cpumask_clear_cpu(cpu, nohz.idle_cpus_mask);
|
|
|
|
atomic_dec(&nohz.nr_cpus);
|
|
|
|
}
|
2012-01-20 02:28:57 +00:00
|
|
|
clear_bit(NOHZ_TICK_STOPPED, nohz_flags(cpu));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-02 01:07:33 +00:00
|
|
|
static inline void set_cpu_sd_state_busy(void)
|
|
|
|
{
|
|
|
|
struct sched_domain *sd;
|
2013-10-30 03:12:52 +00:00
|
|
|
int cpu = smp_processor_id();
|
2011-12-02 01:07:33 +00:00
|
|
|
|
|
|
|
rcu_read_lock();
|
2016-05-09 08:38:01 +00:00
|
|
|
sd = rcu_dereference(per_cpu(sd_llc, cpu));
|
2013-04-23 14:59:02 +00:00
|
|
|
|
|
|
|
if (!sd || !sd->nohz_idle)
|
|
|
|
goto unlock;
|
|
|
|
sd->nohz_idle = 0;
|
|
|
|
|
2016-05-09 08:38:01 +00:00
|
|
|
atomic_inc(&sd->shared->nr_busy_cpus);
|
2013-04-23 14:59:02 +00:00
|
|
|
unlock:
|
2011-12-02 01:07:33 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_cpu_sd_state_idle(void)
|
|
|
|
{
|
|
|
|
struct sched_domain *sd;
|
2013-10-30 03:12:52 +00:00
|
|
|
int cpu = smp_processor_id();
|
2011-12-02 01:07:33 +00:00
|
|
|
|
|
|
|
rcu_read_lock();
|
2016-05-09 08:38:01 +00:00
|
|
|
sd = rcu_dereference(per_cpu(sd_llc, cpu));
|
2013-04-23 14:59:02 +00:00
|
|
|
|
|
|
|
if (!sd || sd->nohz_idle)
|
|
|
|
goto unlock;
|
|
|
|
sd->nohz_idle = 1;
|
|
|
|
|
2016-05-09 08:38:01 +00:00
|
|
|
atomic_dec(&sd->shared->nr_busy_cpus);
|
2013-04-23 14:59:02 +00:00
|
|
|
unlock:
|
2011-12-02 01:07:33 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/*
|
2012-09-10 07:10:58 +00:00
|
|
|
* This routine will record that the cpu is going idle with tick stopped.
|
2011-12-02 01:07:34 +00:00
|
|
|
* This info will be used in performing idle load balancing in the future.
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2012-09-10 07:10:58 +00:00
|
|
|
void nohz_balance_enter_idle(int cpu)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2012-01-20 02:28:57 +00:00
|
|
|
/*
|
|
|
|
* If this cpu is going down, then nothing needs to be done.
|
|
|
|
*/
|
|
|
|
if (!cpu_active(cpu))
|
|
|
|
return;
|
|
|
|
|
2017-06-19 02:12:02 +00:00
|
|
|
/* Spare idle load balancing on CPUs that don't want to be disturbed: */
|
2017-10-27 02:42:35 +00:00
|
|
|
if (!housekeeping_cpu(cpu, HK_FLAG_SCHED))
|
2017-06-19 02:12:02 +00:00
|
|
|
return;
|
|
|
|
|
2012-09-10 07:10:58 +00:00
|
|
|
if (test_bit(NOHZ_TICK_STOPPED, nohz_flags(cpu)))
|
|
|
|
return;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2011-12-05 09:01:47 +00:00
|
|
|
/*
|
|
|
|
* If we're a completely isolated CPU, we don't play.
|
|
|
|
*/
|
|
|
|
if (on_null_domain(cpu_rq(cpu)))
|
|
|
|
return;
|
|
|
|
|
2012-09-10 07:10:58 +00:00
|
|
|
cpumask_set_cpu(cpu, nohz.idle_cpus_mask);
|
|
|
|
atomic_inc(&nohz.nr_cpus);
|
|
|
|
set_bit(NOHZ_TICK_STOPPED, nohz_flags(cpu));
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static DEFINE_SPINLOCK(balancing);
|
|
|
|
|
2011-04-05 08:14:25 +00:00
|
|
|
/*
|
|
|
|
* Scale the max load_balance interval with the number of CPUs in the system.
|
|
|
|
* This trades load-balance latency on larger machines for less cross talk.
|
|
|
|
*/
|
2011-10-25 08:00:11 +00:00
|
|
|
void update_max_interval(void)
|
2011-04-05 08:14:25 +00:00
|
|
|
{
|
|
|
|
max_load_balance_interval = HZ*num_online_cpus()/10;
|
|
|
|
}
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
/*
|
|
|
|
* It checks each scheduling domain to see if it is due to be balanced,
|
|
|
|
* and initiates a balancing operation if so.
|
|
|
|
*
|
2013-04-01 11:14:01 +00:00
|
|
|
* Balancing parameters are set up in init_sched_domains.
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2014-01-06 11:34:43 +00:00
|
|
|
static void rebalance_domains(struct rq *rq, enum cpu_idle_type idle)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2013-08-06 08:36:42 +00:00
|
|
|
int continue_balancing = 1;
|
2014-01-06 11:34:43 +00:00
|
|
|
int cpu = rq->cpu;
|
2009-12-17 16:00:43 +00:00
|
|
|
unsigned long interval;
|
2012-05-10 22:12:02 +00:00
|
|
|
struct sched_domain *sd;
|
2009-12-17 16:00:43 +00:00
|
|
|
/* Earliest time when we have to do rebalance again */
|
|
|
|
unsigned long next_balance = jiffies + 60*HZ;
|
|
|
|
int update_next_balance = 0;
|
2013-09-13 18:26:53 +00:00
|
|
|
int need_serialize, need_decay = 0;
|
|
|
|
u64 max_cost = 0;
|
2009-12-17 16:00:43 +00:00
|
|
|
|
2012-10-04 11:18:31 +00:00
|
|
|
update_blocked_averages(cpu);
|
2010-11-15 23:47:00 +00:00
|
|
|
|
2011-04-07 12:09:50 +00:00
|
|
|
rcu_read_lock();
|
2009-12-17 16:00:43 +00:00
|
|
|
for_each_domain(cpu, sd) {
|
2013-09-13 18:26:53 +00:00
|
|
|
/*
|
|
|
|
* Decay the newidle max times here because this is a regular
|
|
|
|
* visit to all the domains. Decay ~1% per second.
|
|
|
|
*/
|
|
|
|
if (time_after(jiffies, sd->next_decay_max_lb_cost)) {
|
|
|
|
sd->max_newidle_lb_cost =
|
|
|
|
(sd->max_newidle_lb_cost * 253) / 256;
|
|
|
|
sd->next_decay_max_lb_cost = jiffies + HZ;
|
|
|
|
need_decay = 1;
|
|
|
|
}
|
|
|
|
max_cost += sd->max_newidle_lb_cost;
|
|
|
|
|
2009-12-17 16:00:43 +00:00
|
|
|
if (!(sd->flags & SD_LOAD_BALANCE))
|
|
|
|
continue;
|
|
|
|
|
2013-09-13 18:26:53 +00:00
|
|
|
/*
|
|
|
|
* Stop the load balance at this level. There is another
|
|
|
|
* CPU in our sched group which is doing load balancing more
|
|
|
|
* actively.
|
|
|
|
*/
|
|
|
|
if (!continue_balancing) {
|
|
|
|
if (need_decay)
|
|
|
|
continue;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
sched: Fix the rq->next_balance logic in rebalance_domains() and idle_balance()
Currently, in idle_balance(), we update rq->next_balance when we pull_tasks.
However, it is also important to update this in the !pulled_tasks case too.
When the CPU is "busy" (the CPU isn't idle), rq->next_balance gets computed
using sd->busy_factor (so we increase the balance interval when the CPU is
busy). However, when the CPU goes idle, rq->next_balance could still be set
to a large value that was computed with the sd->busy_factor.
Thus, we need to also update rq->next_balance in idle_balance() in the cases
where !pulled_tasks too, so that rq->next_balance gets updated without taking
the busy_factor into account when the CPU is about to go idle.
This patch makes rq->next_balance get updated independently of whether or
not we pulled_task. Also, we add logic to ensure that we always traverse
at least 1 of the sched domains to get a proper next_balance value for
updating rq->next_balance.
Additionally, since load_balance() modifies the sd->balance_interval, we
need to re-obtain the sched domain's interval after the call to
load_balance() in rebalance_domains() before we update rq->next_balance.
This patch adds and uses 2 new helper functions, update_next_balance() and
get_sd_balance_interval() to update next_balance and obtain the sched
domain's balance_interval.
Signed-off-by: Jason Low <jason.low2@hp.com>
Reviewed-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: daniel.lezcano@linaro.org
Cc: alex.shi@linaro.org
Cc: efault@gmx.de
Cc: vincent.guittot@linaro.org
Cc: morten.rasmussen@arm.com
Cc: aswin@hp.com
Link: http://lkml.kernel.org/r/1399596562.2200.7.camel@j-VirtualBox
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-05-09 00:49:22 +00:00
|
|
|
interval = get_sd_balance_interval(sd, idle != CPU_IDLE);
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
need_serialize = sd->flags & SD_SERIALIZE;
|
|
|
|
if (need_serialize) {
|
|
|
|
if (!spin_trylock(&balancing))
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (time_after_eq(jiffies, sd->last_balance + interval)) {
|
2013-08-06 08:36:42 +00:00
|
|
|
if (load_balance(cpu, rq, sd, idle, &continue_balancing)) {
|
2009-12-17 16:00:43 +00:00
|
|
|
/*
|
2013-08-19 10:41:09 +00:00
|
|
|
* The LBF_DST_PINNED logic could have changed
|
2013-04-23 08:27:38 +00:00
|
|
|
* env->dst_cpu, so we can't know our idle
|
|
|
|
* state even if we migrated tasks. Update it.
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2013-04-23 08:27:38 +00:00
|
|
|
idle = idle_cpu(cpu) ? CPU_IDLE : CPU_NOT_IDLE;
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
sd->last_balance = jiffies;
|
sched: Fix the rq->next_balance logic in rebalance_domains() and idle_balance()
Currently, in idle_balance(), we update rq->next_balance when we pull_tasks.
However, it is also important to update this in the !pulled_tasks case too.
When the CPU is "busy" (the CPU isn't idle), rq->next_balance gets computed
using sd->busy_factor (so we increase the balance interval when the CPU is
busy). However, when the CPU goes idle, rq->next_balance could still be set
to a large value that was computed with the sd->busy_factor.
Thus, we need to also update rq->next_balance in idle_balance() in the cases
where !pulled_tasks too, so that rq->next_balance gets updated without taking
the busy_factor into account when the CPU is about to go idle.
This patch makes rq->next_balance get updated independently of whether or
not we pulled_task. Also, we add logic to ensure that we always traverse
at least 1 of the sched domains to get a proper next_balance value for
updating rq->next_balance.
Additionally, since load_balance() modifies the sd->balance_interval, we
need to re-obtain the sched domain's interval after the call to
load_balance() in rebalance_domains() before we update rq->next_balance.
This patch adds and uses 2 new helper functions, update_next_balance() and
get_sd_balance_interval() to update next_balance and obtain the sched
domain's balance_interval.
Signed-off-by: Jason Low <jason.low2@hp.com>
Reviewed-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: daniel.lezcano@linaro.org
Cc: alex.shi@linaro.org
Cc: efault@gmx.de
Cc: vincent.guittot@linaro.org
Cc: morten.rasmussen@arm.com
Cc: aswin@hp.com
Link: http://lkml.kernel.org/r/1399596562.2200.7.camel@j-VirtualBox
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-05-09 00:49:22 +00:00
|
|
|
interval = get_sd_balance_interval(sd, idle != CPU_IDLE);
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
if (need_serialize)
|
|
|
|
spin_unlock(&balancing);
|
|
|
|
out:
|
|
|
|
if (time_after(next_balance, sd->last_balance + interval)) {
|
|
|
|
next_balance = sd->last_balance + interval;
|
|
|
|
update_next_balance = 1;
|
|
|
|
}
|
2013-09-13 18:26:53 +00:00
|
|
|
}
|
|
|
|
if (need_decay) {
|
2009-12-17 16:00:43 +00:00
|
|
|
/*
|
2013-09-13 18:26:53 +00:00
|
|
|
* Ensure the rq-wide value also decays but keep it at a
|
|
|
|
* reasonable floor to avoid funnies with rq->avg_idle.
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2013-09-13 18:26:53 +00:00
|
|
|
rq->max_idle_balance_cost =
|
|
|
|
max((u64)sysctl_sched_migration_cost, max_cost);
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
2011-04-07 12:09:50 +00:00
|
|
|
rcu_read_unlock();
|
2009-12-17 16:00:43 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* next_balance will be updated only when there is a need.
|
|
|
|
* When the cpu is attached to null domain for ex, it will not be
|
|
|
|
* updated.
|
|
|
|
*/
|
2015-08-03 09:55:50 +00:00
|
|
|
if (likely(update_next_balance)) {
|
2009-12-17 16:00:43 +00:00
|
|
|
rq->next_balance = next_balance;
|
2015-08-03 09:55:50 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_NO_HZ_COMMON
|
|
|
|
/*
|
|
|
|
* If this CPU has been elected to perform the nohz idle
|
|
|
|
* balance. Other idle CPUs have already rebalanced with
|
|
|
|
* nohz_idle_balance() and nohz.next_balance has been
|
|
|
|
* updated accordingly. This CPU is now running the idle load
|
|
|
|
* balance for itself and we need to update the
|
|
|
|
* nohz.next_balance accordingly.
|
|
|
|
*/
|
|
|
|
if ((idle == CPU_IDLE) && time_after(nohz.next_balance, rq->next_balance))
|
|
|
|
nohz.next_balance = rq->next_balance;
|
|
|
|
#endif
|
|
|
|
}
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
2011-08-10 21:21:01 +00:00
|
|
|
#ifdef CONFIG_NO_HZ_COMMON
|
2009-12-17 16:00:43 +00:00
|
|
|
/*
|
2011-08-10 21:21:01 +00:00
|
|
|
* In CONFIG_NO_HZ_COMMON case, the idle balance kickee will do the
|
2009-12-17 16:00:43 +00:00
|
|
|
* rebalancing for all the cpus for whom scheduler ticks are stopped.
|
|
|
|
*/
|
2014-01-06 11:34:44 +00:00
|
|
|
static void nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle)
|
2010-05-22 00:09:41 +00:00
|
|
|
{
|
2014-01-06 11:34:44 +00:00
|
|
|
int this_cpu = this_rq->cpu;
|
2010-05-22 00:09:41 +00:00
|
|
|
struct rq *rq;
|
|
|
|
int balance_cpu;
|
2015-08-03 09:55:50 +00:00
|
|
|
/* Earliest time when we have to do rebalance again */
|
|
|
|
unsigned long next_balance = jiffies + 60*HZ;
|
|
|
|
int update_next_balance = 0;
|
2010-05-22 00:09:41 +00:00
|
|
|
|
2011-12-02 01:07:32 +00:00
|
|
|
if (idle != CPU_IDLE ||
|
|
|
|
!test_bit(NOHZ_BALANCE_KICK, nohz_flags(this_cpu)))
|
|
|
|
goto end;
|
2010-05-22 00:09:41 +00:00
|
|
|
|
|
|
|
for_each_cpu(balance_cpu, nohz.idle_cpus_mask) {
|
2011-12-06 19:19:37 +00:00
|
|
|
if (balance_cpu == this_cpu || !idle_cpu(balance_cpu))
|
2010-05-22 00:09:41 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this cpu gets work to do, stop the load balancing
|
|
|
|
* work being done for other cpus. Next load
|
|
|
|
* balancing owner will pick it up.
|
|
|
|
*/
|
2011-12-02 01:07:32 +00:00
|
|
|
if (need_resched())
|
2010-05-22 00:09:41 +00:00
|
|
|
break;
|
|
|
|
|
2012-09-13 04:11:26 +00:00
|
|
|
rq = cpu_rq(balance_cpu);
|
|
|
|
|
2014-05-20 21:39:27 +00:00
|
|
|
/*
|
|
|
|
* If time for next balance is due,
|
|
|
|
* do the balance.
|
|
|
|
*/
|
|
|
|
if (time_after_eq(jiffies, rq->next_balance)) {
|
2016-10-04 14:04:35 +00:00
|
|
|
struct rq_flags rf;
|
|
|
|
|
|
|
|
rq_lock_irq(rq, &rf);
|
2014-05-20 21:39:27 +00:00
|
|
|
update_rq_clock(rq);
|
2016-04-13 13:56:50 +00:00
|
|
|
cpu_load_update_idle(rq);
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_unlock_irq(rq, &rf);
|
|
|
|
|
2014-05-20 21:39:27 +00:00
|
|
|
rebalance_domains(rq, CPU_IDLE);
|
|
|
|
}
|
2010-05-22 00:09:41 +00:00
|
|
|
|
2015-08-03 09:55:50 +00:00
|
|
|
if (time_after(next_balance, rq->next_balance)) {
|
|
|
|
next_balance = rq->next_balance;
|
|
|
|
update_next_balance = 1;
|
|
|
|
}
|
2010-05-22 00:09:41 +00:00
|
|
|
}
|
2015-08-03 09:55:50 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* next_balance will be updated only when there is a need.
|
|
|
|
* When the CPU is attached to null domain for ex, it will not be
|
|
|
|
* updated.
|
|
|
|
*/
|
|
|
|
if (likely(update_next_balance))
|
|
|
|
nohz.next_balance = next_balance;
|
2011-12-02 01:07:32 +00:00
|
|
|
end:
|
|
|
|
clear_bit(NOHZ_BALANCE_KICK, nohz_flags(this_cpu));
|
2010-05-22 00:09:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-12-02 01:07:34 +00:00
|
|
|
* Current heuristic for kicking the idle load balancer in the presence
|
2015-02-27 15:54:14 +00:00
|
|
|
* of an idle cpu in the system.
|
2011-12-02 01:07:34 +00:00
|
|
|
* - This rq has more than one task.
|
2015-02-27 15:54:14 +00:00
|
|
|
* - This rq has at least one CFS task and the capacity of the CPU is
|
|
|
|
* significantly reduced because of RT tasks or IRQs.
|
|
|
|
* - At parent of LLC scheduler domain level, this cpu's scheduler group has
|
|
|
|
* multiple busy cpu.
|
2011-12-02 01:07:34 +00:00
|
|
|
* - For SD_ASYM_PACKING, if the lower numbered cpu's in the scheduler
|
|
|
|
* domain span are idle.
|
2010-05-22 00:09:41 +00:00
|
|
|
*/
|
2015-02-27 15:54:14 +00:00
|
|
|
static inline bool nohz_kick_needed(struct rq *rq)
|
2010-05-22 00:09:41 +00:00
|
|
|
{
|
|
|
|
unsigned long now = jiffies;
|
2016-05-09 08:38:01 +00:00
|
|
|
struct sched_domain_shared *sds;
|
2011-12-02 01:07:34 +00:00
|
|
|
struct sched_domain *sd;
|
2016-11-22 20:23:53 +00:00
|
|
|
int nr_busy, i, cpu = rq->cpu;
|
2015-02-27 15:54:14 +00:00
|
|
|
bool kick = false;
|
2010-05-22 00:09:41 +00:00
|
|
|
|
2014-01-06 11:34:39 +00:00
|
|
|
if (unlikely(rq->idle_balance))
|
2015-02-27 15:54:14 +00:00
|
|
|
return false;
|
2010-05-22 00:09:41 +00:00
|
|
|
|
2011-12-02 01:07:32 +00:00
|
|
|
/*
|
|
|
|
* We may be recently in ticked or tickless idle mode. At the first
|
|
|
|
* busy tick after returning from idle, we will update the busy stats.
|
|
|
|
*/
|
2011-12-02 01:07:33 +00:00
|
|
|
set_cpu_sd_state_busy();
|
2012-09-10 07:10:58 +00:00
|
|
|
nohz_balance_exit_idle(cpu);
|
2011-12-02 01:07:34 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* None are in tickless mode and hence no need for NOHZ idle load
|
|
|
|
* balancing.
|
|
|
|
*/
|
|
|
|
if (likely(!atomic_read(&nohz.nr_cpus)))
|
2015-02-27 15:54:14 +00:00
|
|
|
return false;
|
2011-12-02 01:07:32 +00:00
|
|
|
|
|
|
|
if (time_before(now, nohz.next_balance))
|
2015-02-27 15:54:14 +00:00
|
|
|
return false;
|
2010-05-22 00:09:41 +00:00
|
|
|
|
2011-12-02 01:07:34 +00:00
|
|
|
if (rq->nr_running >= 2)
|
2015-02-27 15:54:14 +00:00
|
|
|
return true;
|
2010-05-22 00:09:41 +00:00
|
|
|
|
2011-12-07 13:32:08 +00:00
|
|
|
rcu_read_lock();
|
2016-05-09 08:38:01 +00:00
|
|
|
sds = rcu_dereference(per_cpu(sd_llc_shared, cpu));
|
|
|
|
if (sds) {
|
|
|
|
/*
|
|
|
|
* XXX: write a coherent comment on why we do this.
|
|
|
|
* See also: http://lkml.kernel.org/r/20111202010832.602203411@sbsiddha-desk.sc.intel.com
|
|
|
|
*/
|
|
|
|
nr_busy = atomic_read(&sds->nr_busy_cpus);
|
2015-02-27 15:54:14 +00:00
|
|
|
if (nr_busy > 1) {
|
|
|
|
kick = true;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
2010-05-22 00:09:41 +00:00
|
|
|
}
|
2013-10-30 03:12:52 +00:00
|
|
|
|
2015-02-27 15:54:14 +00:00
|
|
|
sd = rcu_dereference(rq->sd);
|
|
|
|
if (sd) {
|
|
|
|
if ((rq->cfs.h_nr_running >= 1) &&
|
|
|
|
check_cpu_capacity(rq, sd)) {
|
|
|
|
kick = true;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
}
|
2013-10-30 03:12:52 +00:00
|
|
|
|
2015-02-27 15:54:14 +00:00
|
|
|
sd = rcu_dereference(per_cpu(sd_asym, cpu));
|
2016-11-22 20:23:53 +00:00
|
|
|
if (sd) {
|
|
|
|
for_each_cpu(i, sched_domain_span(sd)) {
|
|
|
|
if (i == cpu ||
|
|
|
|
!cpumask_test_cpu(i, nohz.idle_cpus_mask))
|
|
|
|
continue;
|
2011-12-07 13:32:08 +00:00
|
|
|
|
2016-11-22 20:23:53 +00:00
|
|
|
if (sched_asym_prefer(i, cpu)) {
|
|
|
|
kick = true;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-02-27 15:54:14 +00:00
|
|
|
unlock:
|
2011-12-07 13:32:08 +00:00
|
|
|
rcu_read_unlock();
|
2015-02-27 15:54:14 +00:00
|
|
|
return kick;
|
2010-05-22 00:09:41 +00:00
|
|
|
}
|
|
|
|
#else
|
2014-01-06 11:34:44 +00:00
|
|
|
static void nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle) { }
|
2010-05-22 00:09:41 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* run_rebalance_domains is triggered when needed from the scheduler tick.
|
|
|
|
* Also triggered for nohz idle balancing (with nohz_balancing_kick set).
|
|
|
|
*/
|
2016-06-20 18:42:34 +00:00
|
|
|
static __latent_entropy void run_rebalance_domains(struct softirq_action *h)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
2014-01-06 11:34:44 +00:00
|
|
|
struct rq *this_rq = this_rq();
|
2011-10-03 22:09:01 +00:00
|
|
|
enum cpu_idle_type idle = this_rq->idle_balance ?
|
2009-12-17 16:00:43 +00:00
|
|
|
CPU_IDLE : CPU_NOT_IDLE;
|
|
|
|
|
|
|
|
/*
|
2010-05-22 00:09:41 +00:00
|
|
|
* If this cpu has a pending nohz_balance_kick, then do the
|
2009-12-17 16:00:43 +00:00
|
|
|
* balancing on behalf of the other idle cpus whose ticks are
|
sched: Improve load balancing in the presence of idle CPUs
When a CPU is kicked to do nohz idle balancing, it wakes up to do load
balancing on itself, followed by load balancing on behalf of idle CPUs.
But it may end up with load after the load balancing attempt on itself.
This aborts nohz idle balancing. As a result several idle CPUs are left
without tasks till such a time that an ILB CPU finds it unfavorable to
pull tasks upon itself. This delays spreading of load across idle CPUs
and worse, clutters only a few CPUs with tasks.
The effect of the above problem was observed on an SMT8 POWER server
with 2 levels of numa domains. Busy loops equal to number of cores were
spawned. Since load balancing on fork/exec is discouraged across numa
domains, all busy loops would start on one of the numa domains. However
it was expected that eventually one busy loop would run per core across
all domains due to nohz idle load balancing. But it was observed that it
took as long as 10 seconds to spread the load across numa domains.
Further investigation showed that this was a consequence of the
following:
1. An ILB CPU was chosen from the first numa domain to trigger nohz idle
load balancing [Given the experiment, upto 6 CPUs per core could be
potentially idle in this domain.]
2. However the ILB CPU would call load_balance() on itself before
initiating nohz idle load balancing.
3. Given cores are SMT8, the ILB CPU had enough opportunities to pull
tasks from its sibling cores to even out load.
4. Now that the ILB CPU was no longer idle, it would abort nohz idle
load balancing
As a result the opportunities to spread load across numa domains were
lost until such a time that the cores within the first numa domain had
equal number of tasks among themselves. This is a pretty bad scenario,
since the cores within the first numa domain would have as many as 4
tasks each, while cores in the neighbouring numa domains would all
remain idle.
Fix this, by checking if a CPU was woken up to do nohz idle load
balancing, before it does load balancing upon itself. This way we allow
idle CPUs across the system to do load balancing which results in
quicker spread of load, instead of performing load balancing within the
local sched domain hierarchy of the ILB CPU alone under circumstances
such as above.
Signed-off-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Jason Low <jason.low2@hp.com>
Cc: benh@kernel.crashing.org
Cc: daniel.lezcano@linaro.org
Cc: efault@gmx.de
Cc: iamjoonsoo.kim@lge.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: riel@redhat.com
Cc: srikar@linux.vnet.ibm.com
Cc: svaidy@linux.vnet.ibm.com
Cc: tim.c.chen@linux.intel.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/20150326130014.21532.17158.stgit@preeti.in.ibm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-03-26 13:02:44 +00:00
|
|
|
* stopped. Do nohz_idle_balance *before* rebalance_domains to
|
|
|
|
* give the idle cpus a chance to load balance. Else we may
|
|
|
|
* load balance only within the local sched_domain hierarchy
|
|
|
|
* and abort nohz_idle_balance altogether if we pull some load.
|
2009-12-17 16:00:43 +00:00
|
|
|
*/
|
2014-01-06 11:34:44 +00:00
|
|
|
nohz_idle_balance(this_rq, idle);
|
sched: Improve load balancing in the presence of idle CPUs
When a CPU is kicked to do nohz idle balancing, it wakes up to do load
balancing on itself, followed by load balancing on behalf of idle CPUs.
But it may end up with load after the load balancing attempt on itself.
This aborts nohz idle balancing. As a result several idle CPUs are left
without tasks till such a time that an ILB CPU finds it unfavorable to
pull tasks upon itself. This delays spreading of load across idle CPUs
and worse, clutters only a few CPUs with tasks.
The effect of the above problem was observed on an SMT8 POWER server
with 2 levels of numa domains. Busy loops equal to number of cores were
spawned. Since load balancing on fork/exec is discouraged across numa
domains, all busy loops would start on one of the numa domains. However
it was expected that eventually one busy loop would run per core across
all domains due to nohz idle load balancing. But it was observed that it
took as long as 10 seconds to spread the load across numa domains.
Further investigation showed that this was a consequence of the
following:
1. An ILB CPU was chosen from the first numa domain to trigger nohz idle
load balancing [Given the experiment, upto 6 CPUs per core could be
potentially idle in this domain.]
2. However the ILB CPU would call load_balance() on itself before
initiating nohz idle load balancing.
3. Given cores are SMT8, the ILB CPU had enough opportunities to pull
tasks from its sibling cores to even out load.
4. Now that the ILB CPU was no longer idle, it would abort nohz idle
load balancing
As a result the opportunities to spread load across numa domains were
lost until such a time that the cores within the first numa domain had
equal number of tasks among themselves. This is a pretty bad scenario,
since the cores within the first numa domain would have as many as 4
tasks each, while cores in the neighbouring numa domains would all
remain idle.
Fix this, by checking if a CPU was woken up to do nohz idle load
balancing, before it does load balancing upon itself. This way we allow
idle CPUs across the system to do load balancing which results in
quicker spread of load, instead of performing load balancing within the
local sched domain hierarchy of the ILB CPU alone under circumstances
such as above.
Signed-off-by: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: Jason Low <jason.low2@hp.com>
Cc: benh@kernel.crashing.org
Cc: daniel.lezcano@linaro.org
Cc: efault@gmx.de
Cc: iamjoonsoo.kim@lge.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: riel@redhat.com
Cc: srikar@linux.vnet.ibm.com
Cc: svaidy@linux.vnet.ibm.com
Cc: tim.c.chen@linux.intel.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/20150326130014.21532.17158.stgit@preeti.in.ibm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-03-26 13:02:44 +00:00
|
|
|
rebalance_domains(this_rq, idle);
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Trigger the SCHED_SOFTIRQ if it is time to do periodic load balancing.
|
|
|
|
*/
|
2014-01-06 11:34:38 +00:00
|
|
|
void trigger_load_balance(struct rq *rq)
|
2009-12-17 16:00:43 +00:00
|
|
|
{
|
|
|
|
/* Don't need to rebalance while attached to NULL domain */
|
2014-01-06 11:34:45 +00:00
|
|
|
if (unlikely(on_null_domain(rq)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (time_after_eq(jiffies, rq->next_balance))
|
2009-12-17 16:00:43 +00:00
|
|
|
raise_softirq(SCHED_SOFTIRQ);
|
2011-08-10 21:21:01 +00:00
|
|
|
#ifdef CONFIG_NO_HZ_COMMON
|
2014-01-06 11:34:45 +00:00
|
|
|
if (nohz_kick_needed(rq))
|
2014-01-06 11:34:42 +00:00
|
|
|
nohz_balancer_kick();
|
2010-05-22 00:09:41 +00:00
|
|
|
#endif
|
2009-12-17 16:00:43 +00:00
|
|
|
}
|
|
|
|
|
2009-11-30 11:16:46 +00:00
|
|
|
static void rq_online_fair(struct rq *rq)
|
|
|
|
{
|
|
|
|
update_sysctl();
|
2014-06-25 08:19:42 +00:00
|
|
|
|
|
|
|
update_runtime_enabled(rq);
|
2009-11-30 11:16:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rq_offline_fair(struct rq *rq)
|
|
|
|
{
|
|
|
|
update_sysctl();
|
2012-08-09 22:34:47 +00:00
|
|
|
|
|
|
|
/* Ensure any throttled groups are reachable by pick_next_task */
|
|
|
|
unthrottle_offline_cfs_rqs(rq);
|
2009-11-30 11:16:46 +00:00
|
|
|
}
|
|
|
|
|
2008-06-24 18:09:43 +00:00
|
|
|
#endif /* CONFIG_SMP */
|
2007-10-24 16:23:51 +00:00
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
|
|
|
* scheduler tick hitting a task of our scheduling class:
|
|
|
|
*/
|
2008-01-25 20:08:29 +00:00
|
|
|
static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
|
|
|
struct cfs_rq *cfs_rq;
|
|
|
|
struct sched_entity *se = &curr->se;
|
|
|
|
|
|
|
|
for_each_sched_entity(se) {
|
|
|
|
cfs_rq = cfs_rq_of(se);
|
2008-01-25 20:08:29 +00:00
|
|
|
entity_tick(cfs_rq, se, queued);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
2012-10-04 10:51:20 +00:00
|
|
|
|
2015-10-02 02:18:25 +00:00
|
|
|
if (static_branch_unlikely(&sched_numa_balancing))
|
2012-10-25 12:16:43 +00:00
|
|
|
task_tick_numa(rq, curr);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2009-11-27 16:32:46 +00:00
|
|
|
* called on fork with the child task as argument from the parent's context
|
|
|
|
* - child not yet on the tasklist
|
|
|
|
* - preemption disabled
|
2007-07-09 16:51:58 +00:00
|
|
|
*/
|
2009-11-27 16:32:46 +00:00
|
|
|
static void task_fork_fair(struct task_struct *p)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2011-12-15 05:36:55 +00:00
|
|
|
struct cfs_rq *cfs_rq;
|
|
|
|
struct sched_entity *se = &p->se, *curr;
|
2009-11-27 16:32:46 +00:00
|
|
|
struct rq *rq = this_rq();
|
2016-10-04 14:04:35 +00:00
|
|
|
struct rq_flags rf;
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_lock(rq, &rf);
|
2010-08-19 11:31:43 +00:00
|
|
|
update_rq_clock(rq);
|
|
|
|
|
2011-12-15 05:36:55 +00:00
|
|
|
cfs_rq = task_cfs_rq(current);
|
|
|
|
curr = cfs_rq->curr;
|
2016-06-16 16:51:48 +00:00
|
|
|
if (curr) {
|
|
|
|
update_curr(cfs_rq);
|
sched: Ensure that a child can't gain time over it's parent after fork()
A fork/exec load is usually "pass the baton", so the child
should never be placed behind the parent. With START_DEBIT we
make room for the new task, but with child_runs_first, that
room comes out of the _parent's_ hide. There's nothing to say
that the parent wasn't ahead of min_vruntime at fork() time,
which means that the "baton carrier", who is essentially the
parent in drag, can gain time and increase scheduling latencies
for waiters.
With NEW_FAIR_SLEEPERS + START_DEBIT + child_runs_first
enabled, we essentially pass the sleeper fairness off to the
child, which is fine, but if we don't base placement on the
parent's updated vruntime, we can end up compounding latency
woes if the child itself then does fork/exec. The debit
incurred at fork doesn't hurt the parent who is then going to
sleep and maybe exit, but the child who acquires the error
harms all comers.
This improves latencies of make -j<n> kernel build workloads.
Reported-by: Jens Axboe <jens.axboe@oracle.com>
Signed-off-by: Mike Galbraith <efault@gmx.de>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-09-08 09:12:28 +00:00
|
|
|
se->vruntime = curr->vruntime;
|
2016-06-16 16:51:48 +00:00
|
|
|
}
|
2007-10-15 15:00:05 +00:00
|
|
|
place_entity(cfs_rq, se, 1);
|
2007-10-15 15:00:04 +00:00
|
|
|
|
2009-11-27 16:32:46 +00:00
|
|
|
if (sysctl_sched_child_runs_first && curr && entity_before(curr, se)) {
|
2007-10-15 15:00:08 +00:00
|
|
|
/*
|
2007-10-15 15:00:08 +00:00
|
|
|
* Upon rescheduling, sched_class::put_prev_task() will place
|
|
|
|
* 'current' within the tree based on its new key value.
|
|
|
|
*/
|
2007-10-15 15:00:04 +00:00
|
|
|
swap(curr->vruntime, se->vruntime);
|
2014-06-28 20:03:57 +00:00
|
|
|
resched_curr(rq);
|
2007-10-15 15:00:04 +00:00
|
|
|
}
|
2007-07-09 16:51:58 +00:00
|
|
|
|
sched: Remove the cfs_rq dependency from set_task_cpu()
In order to remove the cfs_rq dependency from set_task_cpu() we
need to ensure the task is cfs_rq invariant for all callsites.
The simple approach is to substract cfs_rq->min_vruntime from
se->vruntime on dequeue, and add cfs_rq->min_vruntime on
enqueue.
However, this has the downside of breaking FAIR_SLEEPERS since
we loose the old vruntime as we only maintain the relative
position.
To solve this, we observe that we only migrate runnable tasks,
we do this using deactivate_task(.sleep=0) and
activate_task(.wakeup=0), therefore we can restrain the
min_vruntime invariance to that state.
The only other case is wakeup balancing, since we want to
maintain the old vruntime we cannot make it relative on dequeue,
but since we don't migrate inactive tasks, we can do so right
before we activate it again.
This is where we need the new pre-wakeup hook, we need to call
this while still holding the old rq->lock. We could fold it into
->select_task_rq(), but since that has multiple callsites and
would obfuscate the locking requirements, that seems like a
fudge.
This leaves the fork() case, simply make sure that ->task_fork()
leaves the ->vruntime in a relative state.
This covers all cases where set_task_cpu() gets called, and
ensures it sees a relative vruntime.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20091216170518.191697025@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 17:04:41 +00:00
|
|
|
se->vruntime -= cfs_rq->min_vruntime;
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_unlock(rq, &rf);
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
|
|
|
|
2008-01-25 20:08:22 +00:00
|
|
|
/*
|
|
|
|
* Priority of the task has changed. Check to see if we preempt
|
|
|
|
* the current task.
|
|
|
|
*/
|
2011-01-17 16:03:27 +00:00
|
|
|
static void
|
|
|
|
prio_changed_fair(struct rq *rq, struct task_struct *p, int oldprio)
|
2008-01-25 20:08:22 +00:00
|
|
|
{
|
2014-08-20 09:47:32 +00:00
|
|
|
if (!task_on_rq_queued(p))
|
2011-01-17 16:03:27 +00:00
|
|
|
return;
|
|
|
|
|
2008-01-25 20:08:22 +00:00
|
|
|
/*
|
|
|
|
* Reschedule if we are currently running on this runqueue and
|
|
|
|
* our priority decreased, or if we are not currently running on
|
|
|
|
* this runqueue and our priority is higher than the current's
|
|
|
|
*/
|
2011-01-17 16:03:27 +00:00
|
|
|
if (rq->curr == p) {
|
2008-01-25 20:08:22 +00:00
|
|
|
if (p->prio > oldprio)
|
2014-06-28 20:03:57 +00:00
|
|
|
resched_curr(rq);
|
2008-01-25 20:08:22 +00:00
|
|
|
} else
|
2008-09-20 21:38:02 +00:00
|
|
|
check_preempt_curr(rq, p, 0);
|
2008-01-25 20:08:22 +00:00
|
|
|
}
|
|
|
|
|
2015-08-20 11:22:00 +00:00
|
|
|
static inline bool vruntime_normalized(struct task_struct *p)
|
2011-01-17 16:03:27 +00:00
|
|
|
{
|
|
|
|
struct sched_entity *se = &p->se;
|
|
|
|
|
|
|
|
/*
|
2015-08-20 11:22:00 +00:00
|
|
|
* In both the TASK_ON_RQ_QUEUED and TASK_ON_RQ_MIGRATING cases,
|
|
|
|
* the dequeue_entity(.flags=0) will already have normalized the
|
|
|
|
* vruntime.
|
|
|
|
*/
|
|
|
|
if (p->on_rq)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When !on_rq, vruntime of the task has usually NOT been normalized.
|
|
|
|
* But there are some cases where it has already been normalized:
|
2011-01-17 16:03:27 +00:00
|
|
|
*
|
2015-08-20 11:22:00 +00:00
|
|
|
* - A forked child which is waiting for being woken up by
|
|
|
|
* wake_up_new_task().
|
|
|
|
* - A task which has been woken up by try_to_wake_up() and
|
|
|
|
* waiting for actually being woken up by sched_ttwu_pending().
|
2011-01-17 16:03:27 +00:00
|
|
|
*/
|
2015-08-20 11:22:00 +00:00
|
|
|
if (!se->sum_exec_runtime || p->state == TASK_WAKING)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-11-08 09:53:45 +00:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
/*
|
|
|
|
* Propagate the changes of the sched_entity across the tg tree to make it
|
|
|
|
* visible to the root
|
|
|
|
*/
|
|
|
|
static void propagate_entity_cfs_rq(struct sched_entity *se)
|
|
|
|
{
|
|
|
|
struct cfs_rq *cfs_rq;
|
|
|
|
|
|
|
|
/* Start to propagate at parent */
|
|
|
|
se = se->parent;
|
|
|
|
|
|
|
|
for_each_sched_entity(se) {
|
|
|
|
cfs_rq = cfs_rq_of(se);
|
|
|
|
|
|
|
|
if (cfs_rq_throttled(cfs_rq))
|
|
|
|
break;
|
|
|
|
|
2017-05-06 15:32:43 +00:00
|
|
|
update_load_avg(cfs_rq, se, UPDATE_TG);
|
2016-11-08 09:53:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static void propagate_entity_cfs_rq(struct sched_entity *se) { }
|
|
|
|
#endif
|
|
|
|
|
2016-11-08 09:53:42 +00:00
|
|
|
static void detach_entity_cfs_rq(struct sched_entity *se)
|
2015-08-20 11:22:00 +00:00
|
|
|
{
|
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
|
|
|
|
sched/fair: Rewrite runnable load and utilization average tracking
The idea of runnable load average (let runnable time contribute to weight)
was proposed by Paul Turner and Ben Segall, and it is still followed by
this rewrite. This rewrite aims to solve the following issues:
1. cfs_rq's load average (namely runnable_load_avg and blocked_load_avg) is
updated at the granularity of an entity at a time, which results in the
cfs_rq's load average is stale or partially updated: at any time, only
one entity is up to date, all other entities are effectively lagging
behind. This is undesirable.
To illustrate, if we have n runnable entities in the cfs_rq, as time
elapses, they certainly become outdated:
t0: cfs_rq { e1_old, e2_old, ..., en_old }
and when we update:
t1: update e1, then we have cfs_rq { e1_new, e2_old, ..., en_old }
t2: update e2, then we have cfs_rq { e1_old, e2_new, ..., en_old }
...
We solve this by combining all runnable entities' load averages together
in cfs_rq's avg, and update the cfs_rq's avg as a whole. This is based
on the fact that if we regard the update as a function, then:
w * update(e) = update(w * e) and
update(e1) + update(e2) = update(e1 + e2), then
w1 * update(e1) + w2 * update(e2) = update(w1 * e1 + w2 * e2)
therefore, by this rewrite, we have an entirely updated cfs_rq at the
time we update it:
t1: update cfs_rq { e1_new, e2_new, ..., en_new }
t2: update cfs_rq { e1_new, e2_new, ..., en_new }
...
2. cfs_rq's load average is different between top rq->cfs_rq and other
task_group's per CPU cfs_rqs in whether or not blocked_load_average
contributes to the load.
The basic idea behind runnable load average (the same for utilization)
is that the blocked state is taken into account as opposed to only
accounting for the currently runnable state. Therefore, the average
should include both the runnable/running and blocked load averages.
This rewrite does that.
In addition, we also combine runnable/running and blocked averages
of all entities into the cfs_rq's average, and update it together at
once. This is based on the fact that:
update(runnable) + update(blocked) = update(runnable + blocked)
This significantly reduces the code as we don't need to separately
maintain/update runnable/running load and blocked load.
3. How task_group entities' share is calculated is complex and imprecise.
We reduce the complexity in this rewrite to allow a very simple rule:
the task_group's load_avg is aggregated from its per CPU cfs_rqs's
load_avgs. Then group entity's weight is simply proportional to its
own cfs_rq's load_avg / task_group's load_avg. To illustrate,
if a task_group has { cfs_rq1, cfs_rq2, ..., cfs_rqn }, then,
task_group_avg = cfs_rq1_avg + cfs_rq2_avg + ... + cfs_rqn_avg, then
cfs_rqx's entity's share = cfs_rqx_avg / task_group_avg * task_group's share
To sum up, this rewrite in principle is equivalent to the current one, but
fixes the issues described above. Turns out, it significantly reduces the
code complexity and hence increases clarity and efficiency. In addition,
the new averages are more smooth/continuous (no spurious spikes and valleys)
and updated more consistently and quickly to reflect the load dynamics.
As a result, we have less load tracking overhead, better performance,
and especially better power efficiency due to more balanced load.
Signed-off-by: Yuyang Du <yuyang.du@intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: arjan@linux.intel.com
Cc: bsegall@google.com
Cc: dietmar.eggemann@arm.com
Cc: fengguang.wu@intel.com
Cc: len.brown@intel.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: rafael.j.wysocki@intel.com
Cc: umgwanakikbuti@gmail.com
Cc: vincent.guittot@linaro.org
Link: http://lkml.kernel.org/r/1436918682-4971-3-git-send-email-yuyang.du@intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-07-15 00:04:37 +00:00
|
|
|
/* Catch up with the cfs_rq and remove our load when we leave */
|
2017-05-06 15:32:43 +00:00
|
|
|
update_load_avg(cfs_rq, se, 0);
|
2015-08-20 11:21:56 +00:00
|
|
|
detach_entity_load_avg(cfs_rq, se);
|
2016-07-13 08:56:25 +00:00
|
|
|
update_tg_load_avg(cfs_rq, false);
|
2016-11-08 09:53:45 +00:00
|
|
|
propagate_entity_cfs_rq(se);
|
2011-01-17 16:03:27 +00:00
|
|
|
}
|
|
|
|
|
2016-11-08 09:53:42 +00:00
|
|
|
static void attach_entity_cfs_rq(struct sched_entity *se)
|
2008-01-25 20:08:22 +00:00
|
|
|
{
|
2015-08-20 11:22:00 +00:00
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
2015-08-10 09:02:55 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2014-02-20 03:14:53 +00:00
|
|
|
/*
|
|
|
|
* Since the real-depth could have been changed (only FAIR
|
|
|
|
* class maintain depth value), reset depth properly.
|
|
|
|
*/
|
|
|
|
se->depth = se->parent ? se->parent->depth + 1 : 0;
|
|
|
|
#endif
|
2015-08-10 09:02:55 +00:00
|
|
|
|
2016-11-08 09:53:42 +00:00
|
|
|
/* Synchronize entity with its cfs_rq */
|
2017-05-06 15:32:43 +00:00
|
|
|
update_load_avg(cfs_rq, se, sched_feat(ATTACH_AGE_LOAD) ? 0 : SKIP_AGE_LOAD);
|
2015-08-20 11:22:00 +00:00
|
|
|
attach_entity_load_avg(cfs_rq, se);
|
2016-07-13 08:56:25 +00:00
|
|
|
update_tg_load_avg(cfs_rq, false);
|
2016-11-08 09:53:45 +00:00
|
|
|
propagate_entity_cfs_rq(se);
|
2016-11-08 09:53:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void detach_task_cfs_rq(struct task_struct *p)
|
|
|
|
{
|
|
|
|
struct sched_entity *se = &p->se;
|
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
|
|
|
|
|
|
|
if (!vruntime_normalized(p)) {
|
|
|
|
/*
|
|
|
|
* Fix up our vruntime so that the current sleep doesn't
|
|
|
|
* cause 'unlimited' sleep bonus.
|
|
|
|
*/
|
|
|
|
place_entity(cfs_rq, se, 0);
|
|
|
|
se->vruntime -= cfs_rq->min_vruntime;
|
|
|
|
}
|
|
|
|
|
|
|
|
detach_entity_cfs_rq(se);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void attach_task_cfs_rq(struct task_struct *p)
|
|
|
|
{
|
|
|
|
struct sched_entity *se = &p->se;
|
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
|
|
|
|
|
|
|
attach_entity_cfs_rq(se);
|
2015-08-20 11:22:00 +00:00
|
|
|
|
|
|
|
if (!vruntime_normalized(p))
|
|
|
|
se->vruntime += cfs_rq->min_vruntime;
|
|
|
|
}
|
2015-08-20 11:21:59 +00:00
|
|
|
|
2015-08-20 11:22:00 +00:00
|
|
|
static void switched_from_fair(struct rq *rq, struct task_struct *p)
|
|
|
|
{
|
|
|
|
detach_task_cfs_rq(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void switched_to_fair(struct rq *rq, struct task_struct *p)
|
|
|
|
{
|
|
|
|
attach_task_cfs_rq(p);
|
2015-08-10 09:02:55 +00:00
|
|
|
|
2015-08-20 11:22:00 +00:00
|
|
|
if (task_on_rq_queued(p)) {
|
2015-08-10 09:02:55 +00:00
|
|
|
/*
|
2015-08-20 11:22:00 +00:00
|
|
|
* We were most likely switched from sched_rt, so
|
|
|
|
* kick off the schedule if running, otherwise just see
|
|
|
|
* if we can still preempt the current task.
|
2015-08-10 09:02:55 +00:00
|
|
|
*/
|
2015-08-20 11:22:00 +00:00
|
|
|
if (rq->curr == p)
|
|
|
|
resched_curr(rq);
|
|
|
|
else
|
|
|
|
check_preempt_curr(rq, p, 0);
|
2015-08-10 09:02:55 +00:00
|
|
|
}
|
2008-01-25 20:08:22 +00:00
|
|
|
}
|
|
|
|
|
2007-10-15 15:00:08 +00:00
|
|
|
/* Account for a task changing its policy or group.
|
|
|
|
*
|
|
|
|
* This routine is mostly called to set cfs_rq->curr field when a task
|
|
|
|
* migrates between groups/classes.
|
|
|
|
*/
|
|
|
|
static void set_curr_task_fair(struct rq *rq)
|
|
|
|
{
|
|
|
|
struct sched_entity *se = &rq->curr->se;
|
|
|
|
|
2011-07-21 16:43:30 +00:00
|
|
|
for_each_sched_entity(se) {
|
|
|
|
struct cfs_rq *cfs_rq = cfs_rq_of(se);
|
|
|
|
|
|
|
|
set_next_entity(cfs_rq, se);
|
|
|
|
/* ensure bandwidth has been allocated on our new cfs_rq */
|
|
|
|
account_cfs_rq_runtime(cfs_rq, 0);
|
|
|
|
}
|
2007-10-15 15:00:08 +00:00
|
|
|
}
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
void init_cfs_rq(struct cfs_rq *cfs_rq)
|
|
|
|
{
|
2017-09-08 23:14:55 +00:00
|
|
|
cfs_rq->tasks_timeline = RB_ROOT_CACHED;
|
2011-10-25 08:00:11 +00:00
|
|
|
cfs_rq->min_vruntime = (u64)(-(1LL << 20));
|
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
cfs_rq->min_vruntime_copy = cfs_rq->min_vruntime;
|
|
|
|
#endif
|
2013-06-26 05:05:39 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2017-05-08 14:51:41 +00:00
|
|
|
raw_spin_lock_init(&cfs_rq->removed.lock);
|
2012-10-04 11:18:30 +00:00
|
|
|
#endif
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
2008-02-29 20:21:01 +00:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2016-06-17 11:38:55 +00:00
|
|
|
static void task_set_group_fair(struct task_struct *p)
|
|
|
|
{
|
|
|
|
struct sched_entity *se = &p->se;
|
|
|
|
|
|
|
|
set_task_rq(p, task_cpu(p));
|
|
|
|
se->depth = se->parent ? se->parent->depth + 1 : 0;
|
|
|
|
}
|
|
|
|
|
2015-08-31 15:13:55 +00:00
|
|
|
static void task_move_group_fair(struct task_struct *p)
|
2008-02-29 20:21:01 +00:00
|
|
|
{
|
2015-08-20 11:22:00 +00:00
|
|
|
detach_task_cfs_rq(p);
|
2010-10-15 13:24:15 +00:00
|
|
|
set_task_rq(p, task_cpu(p));
|
2015-08-20 11:21:59 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/* Tell se's cfs_rq has been changed -- migrated */
|
|
|
|
p->se.avg.last_update_time = 0;
|
|
|
|
#endif
|
2015-08-20 11:22:00 +00:00
|
|
|
attach_task_cfs_rq(p);
|
2008-02-29 20:21:01 +00:00
|
|
|
}
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2016-06-17 11:38:55 +00:00
|
|
|
static void task_change_group_fair(struct task_struct *p, int type)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case TASK_SET_GROUP:
|
|
|
|
task_set_group_fair(p);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TASK_MOVE_GROUP:
|
|
|
|
task_move_group_fair(p);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
void free_fair_sched_group(struct task_group *tg)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
destroy_cfs_bandwidth(tg_cfs_bandwidth(tg));
|
|
|
|
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
if (tg->cfs_rq)
|
|
|
|
kfree(tg->cfs_rq[i]);
|
2016-01-21 21:24:16 +00:00
|
|
|
if (tg->se)
|
2011-10-25 08:00:11 +00:00
|
|
|
kfree(tg->se[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(tg->cfs_rq);
|
|
|
|
kfree(tg->se);
|
|
|
|
}
|
|
|
|
|
|
|
|
int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
|
|
|
|
{
|
|
|
|
struct sched_entity *se;
|
sched/fair: Fix post_init_entity_util_avg() serialization
Chris Wilson reported a divide by 0 at:
post_init_entity_util_avg():
> 725 if (cfs_rq->avg.util_avg != 0) {
> 726 sa->util_avg = cfs_rq->avg.util_avg * se->load.weight;
> -> 727 sa->util_avg /= (cfs_rq->avg.load_avg + 1);
> 728
> 729 if (sa->util_avg > cap)
> 730 sa->util_avg = cap;
> 731 } else {
Which given the lack of serialization, and the code generated from
update_cfs_rq_load_avg() is entirely possible:
if (atomic_long_read(&cfs_rq->removed_load_avg)) {
s64 r = atomic_long_xchg(&cfs_rq->removed_load_avg, 0);
sa->load_avg = max_t(long, sa->load_avg - r, 0);
sa->load_sum = max_t(s64, sa->load_sum - r * LOAD_AVG_MAX, 0);
removed_load = 1;
}
turns into:
ffffffff81087064: 49 8b 85 98 00 00 00 mov 0x98(%r13),%rax
ffffffff8108706b: 48 85 c0 test %rax,%rax
ffffffff8108706e: 74 40 je ffffffff810870b0
ffffffff81087070: 4c 89 f8 mov %r15,%rax
ffffffff81087073: 49 87 85 98 00 00 00 xchg %rax,0x98(%r13)
ffffffff8108707a: 49 29 45 70 sub %rax,0x70(%r13)
ffffffff8108707e: 4c 89 f9 mov %r15,%rcx
ffffffff81087081: bb 01 00 00 00 mov $0x1,%ebx
ffffffff81087086: 49 83 7d 70 00 cmpq $0x0,0x70(%r13)
ffffffff8108708b: 49 0f 49 4d 70 cmovns 0x70(%r13),%rcx
Which you'll note ends up with 'sa->load_avg - r' in memory at
ffffffff8108707a.
By calling post_init_entity_util_avg() under rq->lock we're sure to be
fully serialized against PELT updates and cannot observe intermediate
state like this.
Reported-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Andrey Ryabinin <aryabinin@virtuozzo.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Yuyang Du <yuyang.du@intel.com>
Cc: bsegall@google.com
Cc: morten.rasmussen@arm.com
Cc: pjt@google.com
Cc: steve.muckle@linaro.org
Fixes: 2b8c41daba32 ("sched/fair: Initiate a new task's util avg to a bounded value")
Link: http://lkml.kernel.org/r/20160609130750.GQ30909@twins.programming.kicks-ass.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-06-09 13:07:50 +00:00
|
|
|
struct cfs_rq *cfs_rq;
|
2011-10-25 08:00:11 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
tg->cfs_rq = kzalloc(sizeof(cfs_rq) * nr_cpu_ids, GFP_KERNEL);
|
|
|
|
if (!tg->cfs_rq)
|
|
|
|
goto err;
|
|
|
|
tg->se = kzalloc(sizeof(se) * nr_cpu_ids, GFP_KERNEL);
|
|
|
|
if (!tg->se)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
tg->shares = NICE_0_LOAD;
|
|
|
|
|
|
|
|
init_cfs_bandwidth(tg_cfs_bandwidth(tg));
|
|
|
|
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
cfs_rq = kzalloc_node(sizeof(struct cfs_rq),
|
|
|
|
GFP_KERNEL, cpu_to_node(i));
|
|
|
|
if (!cfs_rq)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
se = kzalloc_node(sizeof(struct sched_entity),
|
|
|
|
GFP_KERNEL, cpu_to_node(i));
|
|
|
|
if (!se)
|
|
|
|
goto err_free_rq;
|
|
|
|
|
|
|
|
init_cfs_rq(cfs_rq);
|
|
|
|
init_tg_cfs_entry(tg, cfs_rq, se, i, parent->se[i]);
|
2015-07-15 00:04:39 +00:00
|
|
|
init_entity_runnable_average(se);
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
err_free_rq:
|
|
|
|
kfree(cfs_rq);
|
|
|
|
err:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-22 12:58:02 +00:00
|
|
|
void online_fair_sched_group(struct task_group *tg)
|
|
|
|
{
|
|
|
|
struct sched_entity *se;
|
|
|
|
struct rq *rq;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
rq = cpu_rq(i);
|
|
|
|
se = tg->se[i];
|
|
|
|
|
|
|
|
raw_spin_lock_irq(&rq->lock);
|
2016-10-03 14:20:59 +00:00
|
|
|
update_rq_clock(rq);
|
2016-11-08 09:53:47 +00:00
|
|
|
attach_entity_cfs_rq(se);
|
2016-06-22 13:14:26 +00:00
|
|
|
sync_throttle(tg, i);
|
2016-06-22 12:58:02 +00:00
|
|
|
raw_spin_unlock_irq(&rq->lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-21 21:24:16 +00:00
|
|
|
void unregister_fair_sched_group(struct task_group *tg)
|
2011-10-25 08:00:11 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2016-01-21 21:24:16 +00:00
|
|
|
struct rq *rq;
|
|
|
|
int cpu;
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2016-01-21 21:24:16 +00:00
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
if (tg->se[cpu])
|
|
|
|
remove_entity_load_avg(tg->se[cpu]);
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2016-01-21 21:24:16 +00:00
|
|
|
/*
|
|
|
|
* Only empty task groups can be destroyed; so we can speculatively
|
|
|
|
* check on_list without danger of it being re-added.
|
|
|
|
*/
|
|
|
|
if (!tg->cfs_rq[cpu]->on_list)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
rq = cpu_rq(cpu);
|
|
|
|
|
|
|
|
raw_spin_lock_irqsave(&rq->lock, flags);
|
|
|
|
list_del_leaf_cfs_rq(tg->cfs_rq[cpu]);
|
|
|
|
raw_spin_unlock_irqrestore(&rq->lock, flags);
|
|
|
|
}
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void init_tg_cfs_entry(struct task_group *tg, struct cfs_rq *cfs_rq,
|
|
|
|
struct sched_entity *se, int cpu,
|
|
|
|
struct sched_entity *parent)
|
|
|
|
{
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
|
|
|
|
|
|
|
cfs_rq->tg = tg;
|
|
|
|
cfs_rq->rq = rq;
|
|
|
|
init_cfs_rq_runtime(cfs_rq);
|
|
|
|
|
|
|
|
tg->cfs_rq[cpu] = cfs_rq;
|
|
|
|
tg->se[cpu] = se;
|
|
|
|
|
|
|
|
/* se could be NULL for root_task_group */
|
|
|
|
if (!se)
|
|
|
|
return;
|
|
|
|
|
2012-02-11 05:05:00 +00:00
|
|
|
if (!parent) {
|
2011-10-25 08:00:11 +00:00
|
|
|
se->cfs_rq = &rq->cfs;
|
2012-02-11 05:05:00 +00:00
|
|
|
se->depth = 0;
|
|
|
|
} else {
|
2011-10-25 08:00:11 +00:00
|
|
|
se->cfs_rq = parent->my_q;
|
2012-02-11 05:05:00 +00:00
|
|
|
se->depth = parent->depth + 1;
|
|
|
|
}
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
se->my_q = cfs_rq;
|
sched: Guarantee new group-entities always have weight
Currently, group entity load-weights are initialized to zero. This
admits some races with respect to the first time they are re-weighted in
earlty use. ( Let g[x] denote the se for "g" on cpu "x". )
Suppose that we have root->a and that a enters a throttled state,
immediately followed by a[0]->t1 (the only task running on cpu[0])
blocking:
put_prev_task(group_cfs_rq(a[0]), t1)
put_prev_entity(..., t1)
check_cfs_rq_runtime(group_cfs_rq(a[0]))
throttle_cfs_rq(group_cfs_rq(a[0]))
Then, before unthrottling occurs, let a[0]->b[0]->t2 wake for the first
time:
enqueue_task_fair(rq[0], t2)
enqueue_entity(group_cfs_rq(b[0]), t2)
enqueue_entity_load_avg(group_cfs_rq(b[0]), t2)
account_entity_enqueue(group_cfs_ra(b[0]), t2)
update_cfs_shares(group_cfs_rq(b[0]))
< skipped because b is part of a throttled hierarchy >
enqueue_entity(group_cfs_rq(a[0]), b[0])
...
We now have b[0] enqueued, yet group_cfs_rq(a[0])->load.weight == 0
which violates invariants in several code-paths. Eliminate the
possibility of this by initializing group entity weight.
Signed-off-by: Paul Turner <pjt@google.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20131016181627.22647.47543.stgit@sword-of-the-dawn.mtv.corp.google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-10-16 18:16:27 +00:00
|
|
|
/* guarantee group entities always have weight */
|
|
|
|
update_load_set(&se->load, NICE_0_LOAD);
|
2011-10-25 08:00:11 +00:00
|
|
|
se->parent = parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEFINE_MUTEX(shares_mutex);
|
|
|
|
|
|
|
|
int sched_group_set_shares(struct task_group *tg, unsigned long shares)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can't change the weight of the root cgroup.
|
|
|
|
*/
|
|
|
|
if (!tg->se[0])
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
shares = clamp(shares, scale_load(MIN_SHARES), scale_load(MAX_SHARES));
|
|
|
|
|
|
|
|
mutex_lock(&shares_mutex);
|
|
|
|
if (tg->shares == shares)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
tg->shares = shares;
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
struct rq *rq = cpu_rq(i);
|
2016-10-04 14:04:35 +00:00
|
|
|
struct sched_entity *se = tg->se[i];
|
|
|
|
struct rq_flags rf;
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
/* Propagate contribution to hierarchy */
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_lock_irqsave(rq, &rf);
|
2013-04-11 23:50:59 +00:00
|
|
|
update_rq_clock(rq);
|
2016-12-21 15:50:26 +00:00
|
|
|
for_each_sched_entity(se) {
|
2017-05-06 15:32:43 +00:00
|
|
|
update_load_avg(cfs_rq_of(se), se, UPDATE_TG);
|
2017-05-06 13:59:54 +00:00
|
|
|
update_cfs_group(se);
|
2016-12-21 15:50:26 +00:00
|
|
|
}
|
2016-10-04 14:04:35 +00:00
|
|
|
rq_unlock_irqrestore(rq, &rf);
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
mutex_unlock(&shares_mutex);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else /* CONFIG_FAIR_GROUP_SCHED */
|
|
|
|
|
|
|
|
void free_fair_sched_group(struct task_group *tg) { }
|
|
|
|
|
|
|
|
int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-06-22 12:58:02 +00:00
|
|
|
void online_fair_sched_group(struct task_group *tg) { }
|
|
|
|
|
2016-01-21 21:24:16 +00:00
|
|
|
void unregister_fair_sched_group(struct task_group *tg) { }
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
#endif /* CONFIG_FAIR_GROUP_SCHED */
|
|
|
|
|
2008-02-29 20:21:01 +00:00
|
|
|
|
2010-01-14 03:21:52 +00:00
|
|
|
static unsigned int get_rr_interval_fair(struct rq *rq, struct task_struct *task)
|
2009-09-21 01:31:53 +00:00
|
|
|
{
|
|
|
|
struct sched_entity *se = &task->se;
|
|
|
|
unsigned int rr_interval = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Time slice is 0 for SCHED_OTHER tasks that are on an otherwise
|
|
|
|
* idle runqueue:
|
|
|
|
*/
|
|
|
|
if (rq->cfs.load.weight)
|
2013-01-08 04:56:52 +00:00
|
|
|
rr_interval = NS_TO_JIFFIES(sched_slice(cfs_rq_of(se), se));
|
2009-09-21 01:31:53 +00:00
|
|
|
|
|
|
|
return rr_interval;
|
|
|
|
}
|
|
|
|
|
2007-07-09 16:51:58 +00:00
|
|
|
/*
|
|
|
|
* All the scheduling class methods:
|
|
|
|
*/
|
2011-10-25 08:00:11 +00:00
|
|
|
const struct sched_class fair_sched_class = {
|
2007-10-15 15:00:12 +00:00
|
|
|
.next = &idle_sched_class,
|
2007-07-09 16:51:58 +00:00
|
|
|
.enqueue_task = enqueue_task_fair,
|
|
|
|
.dequeue_task = dequeue_task_fair,
|
|
|
|
.yield_task = yield_task_fair,
|
2011-02-01 14:50:51 +00:00
|
|
|
.yield_to_task = yield_to_task_fair,
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2007-10-15 15:00:05 +00:00
|
|
|
.check_preempt_curr = check_preempt_wakeup,
|
2007-07-09 16:51:58 +00:00
|
|
|
|
|
|
|
.pick_next_task = pick_next_task_fair,
|
|
|
|
.put_prev_task = put_prev_task_fair,
|
|
|
|
|
2007-10-24 16:23:51 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2008-10-22 07:25:26 +00:00
|
|
|
.select_task_rq = select_task_rq_fair,
|
2012-10-04 11:18:30 +00:00
|
|
|
.migrate_task_rq = migrate_task_rq_fair,
|
2013-06-26 05:05:39 +00:00
|
|
|
|
2009-11-30 11:16:46 +00:00
|
|
|
.rq_online = rq_online_fair,
|
|
|
|
.rq_offline = rq_offline_fair,
|
sched: Remove the cfs_rq dependency from set_task_cpu()
In order to remove the cfs_rq dependency from set_task_cpu() we
need to ensure the task is cfs_rq invariant for all callsites.
The simple approach is to substract cfs_rq->min_vruntime from
se->vruntime on dequeue, and add cfs_rq->min_vruntime on
enqueue.
However, this has the downside of breaking FAIR_SLEEPERS since
we loose the old vruntime as we only maintain the relative
position.
To solve this, we observe that we only migrate runnable tasks,
we do this using deactivate_task(.sleep=0) and
activate_task(.wakeup=0), therefore we can restrain the
min_vruntime invariance to that state.
The only other case is wakeup balancing, since we want to
maintain the old vruntime we cannot make it relative on dequeue,
but since we don't migrate inactive tasks, we can do so right
before we activate it again.
This is where we need the new pre-wakeup hook, we need to call
this while still holding the old rq->lock. We could fold it into
->select_task_rq(), but since that has multiple callsites and
would obfuscate the locking requirements, that seems like a
fudge.
This leaves the fork() case, simply make sure that ->task_fork()
leaves the ->vruntime in a relative state.
This covers all cases where set_task_cpu() gets called, and
ensures it sees a relative vruntime.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20091216170518.191697025@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 17:04:41 +00:00
|
|
|
|
2015-07-15 00:04:40 +00:00
|
|
|
.task_dead = task_dead_fair,
|
2015-05-15 15:43:35 +00:00
|
|
|
.set_cpus_allowed = set_cpus_allowed_common,
|
2007-10-24 16:23:51 +00:00
|
|
|
#endif
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2007-10-15 15:00:08 +00:00
|
|
|
.set_curr_task = set_curr_task_fair,
|
2007-07-09 16:51:58 +00:00
|
|
|
.task_tick = task_tick_fair,
|
2009-11-27 16:32:46 +00:00
|
|
|
.task_fork = task_fork_fair,
|
2008-01-25 20:08:22 +00:00
|
|
|
|
|
|
|
.prio_changed = prio_changed_fair,
|
2011-01-17 16:03:27 +00:00
|
|
|
.switched_from = switched_from_fair,
|
2008-01-25 20:08:22 +00:00
|
|
|
.switched_to = switched_to_fair,
|
2008-02-29 20:21:01 +00:00
|
|
|
|
2009-09-21 01:31:53 +00:00
|
|
|
.get_rr_interval = get_rr_interval_fair,
|
|
|
|
|
sched/cputime: Fix clock_nanosleep()/clock_gettime() inconsistency
Commit d670ec13178d0 "posix-cpu-timers: Cure SMP wobbles" fixes one glibc
test case in cost of breaking another one. After that commit, calling
clock_nanosleep(TIMER_ABSTIME, X) and then clock_gettime(&Y) can result
of Y time being smaller than X time.
Reproducer/tester can be found further below, it can be compiled and ran by:
gcc -o tst-cpuclock2 tst-cpuclock2.c -pthread
while ./tst-cpuclock2 ; do : ; done
This reproducer, when running on a buggy kernel, will complain
about "clock_gettime difference too small".
Issue happens because on start in thread_group_cputimer() we initialize
sum_exec_runtime of cputimer with threads runtime not yet accounted and
then add the threads runtime to running cputimer again on scheduler
tick, making it's sum_exec_runtime bigger than actual threads runtime.
KOSAKI Motohiro posted a fix for this problem, but that patch was never
applied: https://lkml.org/lkml/2013/5/26/191 .
This patch takes different approach to cure the problem. It calls
update_curr() when cputimer starts, that assure we will have updated
stats of running threads and on the next schedule tick we will account
only the runtime that elapsed from cputimer start. That also assure we
have consistent state between cpu times of individual threads and cpu
time of the process consisted by those threads.
Full reproducer (tst-cpuclock2.c):
#define _GNU_SOURCE
#include <unistd.h>
#include <sys/syscall.h>
#include <stdio.h>
#include <time.h>
#include <pthread.h>
#include <stdint.h>
#include <inttypes.h>
/* Parameters for the Linux kernel ABI for CPU clocks. */
#define CPUCLOCK_SCHED 2
#define MAKE_PROCESS_CPUCLOCK(pid, clock) \
((~(clockid_t) (pid) << 3) | (clockid_t) (clock))
static pthread_barrier_t barrier;
/* Help advance the clock. */
static void *chew_cpu(void *arg)
{
pthread_barrier_wait(&barrier);
while (1) ;
return NULL;
}
/* Don't use the glibc wrapper. */
static int do_nanosleep(int flags, const struct timespec *req)
{
clockid_t clock_id = MAKE_PROCESS_CPUCLOCK(0, CPUCLOCK_SCHED);
return syscall(SYS_clock_nanosleep, clock_id, flags, req, NULL);
}
static int64_t tsdiff(const struct timespec *before, const struct timespec *after)
{
int64_t before_i = before->tv_sec * 1000000000ULL + before->tv_nsec;
int64_t after_i = after->tv_sec * 1000000000ULL + after->tv_nsec;
return after_i - before_i;
}
int main(void)
{
int result = 0;
pthread_t th;
pthread_barrier_init(&barrier, NULL, 2);
if (pthread_create(&th, NULL, chew_cpu, NULL) != 0) {
perror("pthread_create");
return 1;
}
pthread_barrier_wait(&barrier);
/* The test. */
struct timespec before, after, sleeptimeabs;
int64_t sleepdiff, diffabs;
const struct timespec sleeptime = {.tv_sec = 0,.tv_nsec = 100000000 };
/* The relative nanosleep. Not sure why this is needed, but its presence
seems to make it easier to reproduce the problem. */
if (do_nanosleep(0, &sleeptime) != 0) {
perror("clock_nanosleep");
return 1;
}
/* Get the current time. */
if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &before) < 0) {
perror("clock_gettime[2]");
return 1;
}
/* Compute the absolute sleep time based on the current time. */
uint64_t nsec = before.tv_nsec + sleeptime.tv_nsec;
sleeptimeabs.tv_sec = before.tv_sec + nsec / 1000000000;
sleeptimeabs.tv_nsec = nsec % 1000000000;
/* Sleep for the computed time. */
if (do_nanosleep(TIMER_ABSTIME, &sleeptimeabs) != 0) {
perror("absolute clock_nanosleep");
return 1;
}
/* Get the time after the sleep. */
if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &after) < 0) {
perror("clock_gettime[3]");
return 1;
}
/* The time after sleep should always be equal to or after the absolute sleep
time passed to clock_nanosleep. */
sleepdiff = tsdiff(&sleeptimeabs, &after);
if (sleepdiff < 0) {
printf("absolute clock_nanosleep woke too early: %" PRId64 "\n", sleepdiff);
result = 1;
printf("Before %llu.%09llu\n", before.tv_sec, before.tv_nsec);
printf("After %llu.%09llu\n", after.tv_sec, after.tv_nsec);
printf("Sleep %llu.%09llu\n", sleeptimeabs.tv_sec, sleeptimeabs.tv_nsec);
}
/* The difference between the timestamps taken before and after the
clock_nanosleep call should be equal to or more than the duration of the
sleep. */
diffabs = tsdiff(&before, &after);
if (diffabs < sleeptime.tv_nsec) {
printf("clock_gettime difference too small: %" PRId64 "\n", diffabs);
result = 1;
}
pthread_cancel(th);
return result;
}
Signed-off-by: Stanislaw Gruszka <sgruszka@redhat.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Rik van Riel <riel@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Link: http://lkml.kernel.org/r/20141112155843.GA24803@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-11-12 15:58:44 +00:00
|
|
|
.update_curr = update_curr_fair,
|
|
|
|
|
2008-02-29 20:21:01 +00:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2016-06-17 11:38:55 +00:00
|
|
|
.task_change_group = task_change_group_fair,
|
2008-02-29 20:21:01 +00:00
|
|
|
#endif
|
2007-07-09 16:51:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
2011-10-25 08:00:11 +00:00
|
|
|
void print_cfs_stats(struct seq_file *m, int cpu)
|
2007-07-09 16:51:58 +00:00
|
|
|
{
|
2017-04-26 00:43:50 +00:00
|
|
|
struct cfs_rq *cfs_rq, *pos;
|
2007-07-09 16:51:58 +00:00
|
|
|
|
2008-01-25 20:08:34 +00:00
|
|
|
rcu_read_lock();
|
2017-04-26 00:43:50 +00:00
|
|
|
for_each_leaf_cfs_rq_safe(cpu_rq(cpu), cfs_rq, pos)
|
2007-08-09 09:16:47 +00:00
|
|
|
print_cfs_rq(m, cpu, cfs_rq);
|
2008-01-25 20:08:34 +00:00
|
|
|
rcu_read_unlock();
|
2007-07-09 16:51:58 +00:00
|
|
|
}
|
2015-06-25 17:21:43 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_NUMA_BALANCING
|
|
|
|
void show_numa_stats(struct task_struct *p, struct seq_file *m)
|
|
|
|
{
|
|
|
|
int node;
|
|
|
|
unsigned long tsf = 0, tpf = 0, gsf = 0, gpf = 0;
|
|
|
|
|
|
|
|
for_each_online_node(node) {
|
|
|
|
if (p->numa_faults) {
|
|
|
|
tsf = p->numa_faults[task_faults_idx(NUMA_MEM, node, 0)];
|
|
|
|
tpf = p->numa_faults[task_faults_idx(NUMA_MEM, node, 1)];
|
|
|
|
}
|
|
|
|
if (p->numa_group) {
|
|
|
|
gsf = p->numa_group->faults[task_faults_idx(NUMA_MEM, node, 0)],
|
|
|
|
gpf = p->numa_group->faults[task_faults_idx(NUMA_MEM, node, 1)];
|
|
|
|
}
|
|
|
|
print_numa_stats(m, node, tsf, tpf, gsf, gpf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NUMA_BALANCING */
|
|
|
|
#endif /* CONFIG_SCHED_DEBUG */
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
__init void init_sched_fair_class(void)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
open_softirq(SCHED_SOFTIRQ, run_rebalance_domains);
|
|
|
|
|
2011-08-10 21:21:01 +00:00
|
|
|
#ifdef CONFIG_NO_HZ_COMMON
|
2012-03-07 22:44:26 +00:00
|
|
|
nohz.next_balance = jiffies;
|
2011-10-25 08:00:11 +00:00
|
|
|
zalloc_cpumask_var(&nohz.idle_cpus_mask, GFP_NOWAIT);
|
|
|
|
#endif
|
|
|
|
#endif /* SMP */
|
|
|
|
|
|
|
|
}
|