From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S935745AbcHJTzo (ORCPT ); Wed, 10 Aug 2016 15:55:44 -0400 Received: from mga09.intel.com ([134.134.136.24]:17619 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S936161AbcHJSgV (ORCPT ); Wed, 10 Aug 2016 14:36:21 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.28,498,1464678000"; d="scan'208";a="1011742252" From: Yuyang Du To: peterz@infradead.org, mingo@kernel.org, linux-kernel@vger.kernel.org Cc: bsegall@google.com, pjt@google.com, morten.rasmussen@arm.com, vincent.guittot@linaro.org, dietmar.eggemann@arm.com, matt@codeblueprint.co.uk, umgwanakikbuti@gmail.com, Yuyang Du Subject: [PATCH v1 09/10] sched/fair: Rename scale_load() and scale_load_down() Date: Wed, 10 Aug 2016 08:14:54 +0800 Message-Id: <1470788095-2125-10-git-send-email-yuyang.du@intel.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1470788095-2125-1-git-send-email-yuyang.du@intel.com> References: <1470788095-2125-1-git-send-email-yuyang.du@intel.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Rename scale_load() and scale_load_down() to user_to_kernel_load() and kernel_to_user_load() respectively. This helps us tag them clearly and avoid confusion. Signed-off-by: Yuyang Du --- kernel/sched/core.c | 8 ++++---- kernel/sched/fair.c | 13 +++++++++---- kernel/sched/sched.h | 16 ++++++++-------- 3 files changed, 21 insertions(+), 16 deletions(-) diff --git a/kernel/sched/core.c b/kernel/sched/core.c index 30d429b..91fe97f9 100644 --- a/kernel/sched/core.c +++ b/kernel/sched/core.c @@ -735,12 +735,12 @@ static void set_load_weight(struct task_struct *p) * SCHED_IDLE tasks get minimal weight: */ if (idle_policy(p->policy)) { - load->weight = scale_load(WEIGHT_IDLEPRIO); + load->weight = user_to_kernel_load(WEIGHT_IDLEPRIO); load->inv_weight = WMULT_IDLEPRIO; return; } - load->weight = scale_load(sched_prio_to_weight[prio]); + load->weight = user_to_kernel_load(sched_prio_to_weight[prio]); load->inv_weight = sched_prio_to_wmult[prio]; } @@ -8290,7 +8290,7 @@ static void cpu_cgroup_attach(struct cgroup_taskset *tset) static int cpu_shares_write_u64(struct cgroup_subsys_state *css, struct cftype *cftype, u64 shareval) { - return sched_group_set_shares(css_tg(css), scale_load(shareval)); + return sched_group_set_shares(css_tg(css), user_to_kernel_load(shareval)); } static u64 cpu_shares_read_u64(struct cgroup_subsys_state *css, @@ -8298,7 +8298,7 @@ static u64 cpu_shares_read_u64(struct cgroup_subsys_state *css, { struct task_group *tg = css_tg(css); - return (u64) scale_load_down(tg->shares); + return (u64) kernel_to_user_load(tg->shares); } #ifdef CONFIG_CFS_BANDWIDTH diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index 033cf70..1d4640c 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -189,7 +189,7 @@ static void __update_inv_weight(struct load_weight *lw) if (likely(lw->inv_weight)) return; - w = scale_load_down(lw->weight); + w = kernel_to_user_load(lw->weight); if (BITS_PER_LONG > 32 && unlikely(w >= WMULT_CONST)) lw->inv_weight = 1; @@ -210,10 +210,14 @@ static void __update_inv_weight(struct load_weight *lw) * * Or, weight =< lw.weight (because lw.weight is the runqueue weight), thus * weight/lw.weight <= 1, and therefore our shift will also be positive. + * + * Note load.weight falls back to user load scale (i.e., NICE_0's load is + * 1024), instead of possibly increased kernel load scale (i.e., NICE_0's + * load is NICE_0_LOAD) due to multiplication and division efficiency. */ static u64 __calc_delta(u64 delta_exec, unsigned long weight, struct load_weight *lw) { - u64 fact = scale_load_down(weight); + u64 fact = kernel_to_user_load(weight); int shift = WMULT_SHIFT; __update_inv_weight(lw); @@ -2509,7 +2513,7 @@ static long calc_cfs_shares(struct cfs_rq *cfs_rq, struct task_group *tg) * cfs_rq->load.weight, which is its upper bound. This helps ramp up * the shares for small weight interactive tasks. */ - load = scale_load_down(cfs_rq->load.weight); + load = kernel_to_user_load(cfs_rq->load.weight); tg_weight = atomic_long_read(&tg->load_avg); @@ -8714,7 +8718,8 @@ int sched_group_set_shares(struct task_group *tg, unsigned long shares) if (!tg->se[0]) return -EINVAL; - shares = clamp(shares, scale_load(MIN_SHARES), scale_load(MAX_SHARES)); + shares = clamp(shares, user_to_kernel_load(MIN_SHARES), + user_to_kernel_load(MAX_SHARES)); mutex_lock(&shares_mutex); if (tg->shares == shares) diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h index 132a0fa..4723d4a 100644 --- a/kernel/sched/sched.h +++ b/kernel/sched/sched.h @@ -57,22 +57,22 @@ static inline void cpu_load_update_active(struct rq *this_rq) { } */ #ifdef CONFIG_64BIT # define NICE_0_LOAD_SHIFT (SCHED_FIXEDPOINT_SHIFT + SCHED_FIXEDPOINT_SHIFT) -# define scale_load(w) ((w) << SCHED_FIXEDPOINT_SHIFT) -# define scale_load_down(w) ((w) >> SCHED_FIXEDPOINT_SHIFT) +# define user_to_kernel_load(w) ((w) << SCHED_FIXEDPOINT_SHIFT) +# define kernel_to_user_load(w) ((w) >> SCHED_FIXEDPOINT_SHIFT) #else # define NICE_0_LOAD_SHIFT (SCHED_FIXEDPOINT_SHIFT) -# define scale_load(w) (w) -# define scale_load_down(w) (w) +# define user_to_kernel_load(w) (w) +# define kernel_to_user_load(w) (w) #endif /* * Task weight (visible to users) and its load (invisible to users) 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(sched_prio_to_weight[USER_PRIO(NICE_TO_PRIO(0))]) == NICE_0_LOAD + * user_to_kernel_load() and kernel_to_user_load(w) to convert between + * them. The following must be true: * + * user_to_kernel_load(sched_prio_to_weight[USER_PRIO(NICE_TO_PRIO(0))]) == NICE_0_LOAD + * kernel_to_user_load(NICE_0_LOAD) == sched_prio_to_weight[USER_PRIO(NICE_TO_PRIO(0))] */ #define NICE_0_LOAD (1L << NICE_0_LOAD_SHIFT) -- 1.7.9.5