lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
Open Source and information security mailing list archives
| ||
|
Message-Id: <1443981419-16665-2-git-send-email-yuyang.du@intel.com> Date: Mon, 5 Oct 2015 01:56:56 +0800 From: Yuyang Du <yuyang.du@...el.com> To: mingo@...nel.org, peterz@...radead.org, linux-kernel@...r.kernel.org Cc: pjt@...gle.com, bsegall@...gle.com, morten.rasmussen@....com, vincent.guittot@...aro.org, dietmar.eggemann@....com, Yuyang Du <yuyang.du@...el.com> Subject: [PATCH 1/4] sched/fair: Generalize the load/util averages resolution definition Metric needs certain resolution to allow detail we can look into, which also determines the range of the metric. For instance, increasing the resolution of [0, 1] (two levels), one can multiply 1024 and get [0..1024] (1025 levels). In sched/fair, a few metrics depend on the resolution: weight, load, load_avg, util_avg, freq, and capacity. In order to reduce the risks of making mistakes relating to the resolution and range, we generalize the resolution by defining a basic resolution constant number, and then formalize all metrics to base on the basic resolution. The basic resolution is 1024 or (1 << 10). Further, one can recursively apply the basic resolution to have higher resolution. Pointed out by Ben Segall, weight (visible to user, e.g., NICE-0 has 1024) and load (e.g., NICE_0_LOAD) have independent resolution, but they must be well calibrated. Signed-off-by: Yuyang Du <yuyang.du@...el.com> --- include/linux/sched.h | 15 ++++++++++++--- kernel/sched/fair.c | 4 ---- kernel/sched/sched.h | 15 ++++++++++----- 3 files changed, 22 insertions(+), 12 deletions(-) diff --git a/include/linux/sched.h b/include/linux/sched.h index bd38b3e..b3ba0fb 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -910,9 +910,18 @@ enum cpu_idle_type { }; /* + * Integer metrics need certain resolution to allow how much detail we + * can look into, e.g., load, load_avg, util_avg, freq, and capacity. + * We define a basic resolution constant number, and then formalize + * all these metrics based on that basic resolution. + */ +# define SCHED_RESOLUTION_SHIFT 10 +# define SCHED_RESOLUTION_SCALE (1L << SCHED_RESOLUTION_SHIFT) + +/* * Increase resolution of cpu_capacity calculations */ -#define SCHED_CAPACITY_SHIFT 10 +#define SCHED_CAPACITY_SHIFT SCHED_RESOLUTION_SHIFT #define SCHED_CAPACITY_SCALE (1L << SCHED_CAPACITY_SHIFT) /* @@ -1180,8 +1189,8 @@ struct load_weight { * 1) load_avg factors frequency scaling into the amount of time that a * sched_entity is runnable on a rq into its weight. For cfs_rq, it is the * aggregated such weights of all runnable and blocked sched_entities. - * 2) util_avg factors frequency and cpu scaling into the amount of time - * that a sched_entity is running on a CPU, in the range [0..SCHED_LOAD_SCALE]. + * 2) util_avg factors frequency and cpu capacity scaling into the amount of time + * that a sched_entity is running on a CPU, in the range [0..SCHED_CAPACITY_SCALE]. * For cfs_rq, it is the aggregated such times of all runnable and * blocked sched_entities. * The 64 bit load_sum can: diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index 4df37a4..c61fd8e 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -2522,10 +2522,6 @@ static u32 __compute_runnable_contrib(u64 n) return contrib + runnable_avg_yN_sum[n]; } -#if (SCHED_LOAD_SHIFT - SCHED_LOAD_RESOLUTION) != 10 || SCHED_CAPACITY_SHIFT != 10 -#error "load tracking assumes 2^10 as unit" -#endif - #define cap_scale(v, s) ((v)*(s) >> SCHED_CAPACITY_SHIFT) /* diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h index 3845a71..31b4022 100644 --- a/kernel/sched/sched.h +++ b/kernel/sched/sched.h @@ -53,18 +53,23 @@ static inline void update_cpu_load_active(struct rq *this_rq) { } * increased costs. */ #if 0 /* BITS_PER_LONG > 32 -- currently broken: it increases power usage under light load */ -# define SCHED_LOAD_RESOLUTION 10 -# define scale_load(w) ((w) << SCHED_LOAD_RESOLUTION) -# define scale_load_down(w) ((w) >> SCHED_LOAD_RESOLUTION) +# define SCHED_LOAD_SHIFT (SCHED_RESOLUTION_SHIFT + SCHED_RESOLUTION_SHIFT) +# define scale_load(w) ((w) << SCHED_RESOLUTION_SHIFT) +# define scale_load_down(w) ((w) >> SCHED_RESOLUTION_SHIFT) #else -# define SCHED_LOAD_RESOLUTION 0 +# define SCHED_LOAD_SHIFT (SCHED_RESOLUTION_SHIFT) # define scale_load(w) (w) # define scale_load_down(w) (w) #endif -#define SCHED_LOAD_SHIFT (10 + SCHED_LOAD_RESOLUTION) #define SCHED_LOAD_SCALE (1L << SCHED_LOAD_SHIFT) +/* + * NICE_0's weight (visible to user) and its load (invisible to user) have + * independent resolution, but they should be well calibrated. We use scale_load() + * and scale_load_down(w) to convert between them, the following must be true: + * scale_load(prio_to_weight[20]) == NICE_0_LOAD + */ #define NICE_0_LOAD SCHED_LOAD_SCALE #define NICE_0_SHIFT SCHED_LOAD_SHIFT -- 2.1.4 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@...r.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
Powered by blists - more mailing lists