From patchwork Tue Jul 14 06:36:52 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Viresh Kumar X-Patchwork-Id: 235504 Delivered-To: patch@linaro.org Received: by 2002:a92:d244:0:0:0:0:0 with SMTP id v4csp3477081ilg; Mon, 13 Jul 2020 23:37:08 -0700 (PDT) X-Google-Smtp-Source: ABdhPJzxWItEhtieG4tjrG3CB/2zvuiPI9mKNek/l4A4HNU4GKR2FRErbJUu+aI/bj7s/g832WrJ X-Received: by 2002:a17:906:a44:: with SMTP id x4mr3349475ejf.193.1594708628200; Mon, 13 Jul 2020 23:37:08 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1594708628; cv=none; d=google.com; s=arc-20160816; b=JPSKpAt7jJaSOcB1/3OMq1hUHTh5RZzdWV01u7u175i2bINR1RpBwt15NKCoOGNmaY cekDMQk3QkjW+6nc+rXzYRcGuDnBRaELHOXMW/2LXXBkxdNVNUHQCS+SwyrfrUmSuVsa U7k5jXNCNyyvplItNMQBfnDOxYMiCe/JR7E+vB+LKqnAioMZVq43ydlVVYQoIo0tFLIL TRBsHSDvcgi0tLGmaYcWFM+nIbMopQomQ5TAt5tWiFEwLSSqq2dqhlcNxJdU/0vZkvIv LqRhkcezOHW3D9YNg+2kYrA54wEuO0W+ghV5m3JZ0cPdUS5CeQJKRAY0wp+zeFnSC2bF VHKA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=YJvOVI5+haMioIoipWHZfVf+fDy3gUcruBvuYCoy5JY=; b=ttgKQVHdKMs/2jy2HnOQQ9wdemOoO1MFfe0Wiy4dNiCPP4jWf7R8kUCnYPcCyaFAcY biX8KlwXM1uw6fj0p5276N/DUcy44JwcT50J1Qri0jzkS81q9qgFOf/bmUedG1kb2HtH LTFF2B/H4D40IvJqNturu2QYuLRsjx7IN8JqFtdmZ6IAn/77BKeWBS9OS7QAC6iHWZP2 rBWdMW4LrUPBkbNZZhRyjCuz44o5TbOeadPfLbanzwifKH39+sjH+CY7MaKRLkxFSvsx hnpGVUDQ+CY61XyY4kyaxojGWwo7l4V3WX3z62VdGapbShMtagk2Cd9SXcb5w7dC1RnP mS6g== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=T71LGTaC; spf=pass (google.com: domain of linux-pm-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-pm-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id c102si12582697edf.216.2020.07.13.23.37.07; Mon, 13 Jul 2020 23:37:08 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-pm-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=T71LGTaC; spf=pass (google.com: domain of linux-pm-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-pm-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727101AbgGNGhH (ORCPT + 10 others); Tue, 14 Jul 2020 02:37:07 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37368 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727095AbgGNGhD (ORCPT ); Tue, 14 Jul 2020 02:37:03 -0400 Received: from mail-pl1-x643.google.com (mail-pl1-x643.google.com [IPv6:2607:f8b0:4864:20::643]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7EA72C08C5C1 for ; Mon, 13 Jul 2020 23:37:03 -0700 (PDT) Received: by mail-pl1-x643.google.com with SMTP id x9so6620726plr.2 for ; Mon, 13 Jul 2020 23:37:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=YJvOVI5+haMioIoipWHZfVf+fDy3gUcruBvuYCoy5JY=; b=T71LGTaCk3UJziEYnsQBwYebQnyCzNN5fObtjzPl83mugAuqiaxXoeFJfX85Wr5T5H 6YWqFDdqAdSHncwymUpcufJ47+9h1E8loSlg93gR4XNx+JYu/mjiZIB0uWZCNQgxXZ9y kRbQx8FcOEkKgOjeNtmTUPQompYfjbHAAzX0noRA913lRAVmAmlNknmP0qTY9xSAaHJD 5bg7iJGOZuwvnB9mKjaPoz8qTEZdJzd2VzOzYCK8hOl+n0k2UitR9A8GAht8uJ8vFSGw wkGxNEZQ3w+uoocSB5B0IWuyehWG7BFzZ/azeAqdq4sfaWtSsoc7k4kdAARu1JnkEwst I7mA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=YJvOVI5+haMioIoipWHZfVf+fDy3gUcruBvuYCoy5JY=; b=jvtlQ0znLrFutDxbdqVBJVSDbd32FDoMYykEseuZ5YSzE+RQW+mKSpWGyyqbSaz9ei 7S6aCIdXOlRXOAaoZ9gLj1f13g2tUA+O1l7WhMfwdH2OCyZWe52euD1gmxw3gVFWgfEg 7ETiQ0r2eqN5NM9fRLAlHRZz1hn/5eIc+YHW19JVfSNdN3uB9ZhjrmGytO3DiBgkD36L 10fp6plIxfsJZEVkKVGxTr320ceUmQ5DVt3kfWX4gq11PJrqNGQOQaIXTuvlQPJc8Mmx ko6dEdyMw+ldi8yHAJH1pQdRqHgLWermQJ3WjrBwGvG6wNrSM8l5HYMjamGmn2ZREeIz Nmeg== X-Gm-Message-State: AOAM530LLy7ia7VRD55SxHrgfskiSFztZd4qXkAdel2Vm3wbYMh25SqU v1uFoCLPs8UjCQCrkKH4GENLqQ== X-Received: by 2002:a17:90a:2e85:: with SMTP id r5mr3097464pjd.232.1594708622819; Mon, 13 Jul 2020 23:37:02 -0700 (PDT) Received: from localhost ([122.172.34.142]) by smtp.gmail.com with ESMTPSA id g10sm8252664pfr.164.2020.07.13.23.37.01 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Mon, 13 Jul 2020 23:37:01 -0700 (PDT) From: Viresh Kumar To: Ingo Molnar , Peter Zijlstra , Vincent Guittot , Zhang Rui , Daniel Lezcano , Juri Lelli , Dietmar Eggemann , Steven Rostedt , Ben Segall , Mel Gorman , "Rafael J. Wysocki" , Viresh Kumar Cc: linux-kernel@vger.kernel.org, Quentin Perret , linux-pm@vger.kernel.org Subject: [PATCH 1/2] sched/core: Rename and move schedutil_cpu_util to core.c Date: Tue, 14 Jul 2020 12:06:52 +0530 Message-Id: <83d42cb2e589235750d68c9beada882ec93aeedd.1594707424.git.viresh.kumar@linaro.org> X-Mailer: git-send-email 2.25.0.rc1.19.g042ed3e048af In-Reply-To: References: MIME-Version: 1.0 Sender: linux-pm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org There is nothing schedutil specific in schedutil_cpu_util() and is used by fair.c as well. Allow it to be used by other parts of the kernel as well. Move it to core.c and rename it to effective_cpu_util(). While at it, rename "enum schedutil_type" as well. Signed-off-by: Viresh Kumar --- kernel/sched/core.c | 106 ++++++++++++++++++++++++++++++ kernel/sched/cpufreq_schedutil.c | 108 +------------------------------ kernel/sched/fair.c | 6 +- kernel/sched/sched.h | 20 ++---- 4 files changed, 115 insertions(+), 125 deletions(-) -- 2.25.0.rc1.19.g042ed3e048af Acked-by: Rafael J. Wysocki diff --git a/kernel/sched/core.c b/kernel/sched/core.c index a2a244af9a53..c5b345fdf81d 100644 --- a/kernel/sched/core.c +++ b/kernel/sched/core.c @@ -4879,6 +4879,112 @@ struct task_struct *idle_task(int cpu) return cpu_rq(cpu)->idle; } +/* + * This function computes an effective utilization for the given CPU, to be + * used for frequency selection given the linear relation: f = u * f_max. + * + * The scheduler tracks the following metrics: + * + * cpu_util_{cfs,rt,dl,irq}() + * cpu_bw_dl() + * + * Where the cfs,rt and dl util numbers are tracked with the same metric and + * synchronized windows and are thus directly comparable. + * + * The cfs,rt,dl utilization are the running times measured with rq->clock_task + * which excludes things like IRQ and steal-time. These latter are then accrued + * in the irq utilization. + * + * The DL bandwidth number otoh is not a measured metric but a value computed + * based on the task model parameters and gives the minimal utilization + * required to meet deadlines. + */ +unsigned long effective_cpu_util(int cpu, unsigned long util_cfs, + unsigned long max, enum cpu_util_type type, + struct task_struct *p) +{ + unsigned long dl_util, util, irq; + struct rq *rq = cpu_rq(cpu); + + if (!uclamp_is_used() && + type == FREQUENCY_UTIL && rt_rq_is_runnable(&rq->rt)) { + return max; + } + + /* + * Early check to see if IRQ/steal time saturates the CPU, can be + * because of inaccuracies in how we track these -- see + * update_irq_load_avg(). + */ + irq = cpu_util_irq(rq); + if (unlikely(irq >= max)) + return max; + + /* + * Because the time spend on RT/DL tasks is visible as 'lost' time to + * CFS tasks and we use the same metric to track the effective + * utilization (PELT windows are synchronized) we can directly add them + * to obtain the CPU's actual utilization. + * + * CFS and RT utilization can be boosted or capped, depending on + * utilization clamp constraints requested by currently RUNNABLE + * tasks. + * When there are no CFS RUNNABLE tasks, clamps are released and + * frequency will be gracefully reduced with the utilization decay. + */ + util = util_cfs + cpu_util_rt(rq); + if (type == FREQUENCY_UTIL) + util = uclamp_rq_util_with(rq, util, p); + + dl_util = cpu_util_dl(rq); + + /* + * For frequency selection we do not make cpu_util_dl() a permanent part + * of this sum because we want to use cpu_bw_dl() later on, but we need + * to check if the CFS+RT+DL sum is saturated (ie. no idle time) such + * that we select f_max when there is no idle time. + * + * NOTE: numerical errors or stop class might cause us to not quite hit + * saturation when we should -- something for later. + */ + if (util + dl_util >= max) + return max; + + /* + * OTOH, for energy computation we need the estimated running time, so + * include util_dl and ignore dl_bw. + */ + if (type == ENERGY_UTIL) + util += dl_util; + + /* + * There is still idle time; further improve the number by using the + * irq metric. Because IRQ/steal time is hidden from the task clock we + * need to scale the task numbers: + * + * max - irq + * U' = irq + --------- * U + * max + */ + util = scale_irq_capacity(util, irq, max); + util += irq; + + /* + * Bandwidth required by DEADLINE must always be granted while, for + * FAIR and RT, we use blocked utilization of IDLE CPUs as a mechanism + * to gracefully reduce the frequency when no tasks show up for longer + * periods of time. + * + * Ideally we would like to set bw_dl as min/guaranteed freq and util + + * bw_dl as requested freq. However, cpufreq is not yet ready for such + * an interface. So, we only do the latter for now. + */ + if (type == FREQUENCY_UTIL) + util += cpu_bw_dl(rq); + + return min(max, util); +} + /** * find_process_by_pid - find a process with a matching PID value. * @pid: the pid in question. diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c index dc6835bc6490..e9623527741b 100644 --- a/kernel/sched/cpufreq_schedutil.c +++ b/kernel/sched/cpufreq_schedutil.c @@ -183,112 +183,6 @@ static unsigned int get_next_freq(struct sugov_policy *sg_policy, return cpufreq_driver_resolve_freq(policy, freq); } -/* - * This function computes an effective utilization for the given CPU, to be - * used for frequency selection given the linear relation: f = u * f_max. - * - * The scheduler tracks the following metrics: - * - * cpu_util_{cfs,rt,dl,irq}() - * cpu_bw_dl() - * - * Where the cfs,rt and dl util numbers are tracked with the same metric and - * synchronized windows and are thus directly comparable. - * - * The cfs,rt,dl utilization are the running times measured with rq->clock_task - * which excludes things like IRQ and steal-time. These latter are then accrued - * in the irq utilization. - * - * The DL bandwidth number otoh is not a measured metric but a value computed - * based on the task model parameters and gives the minimal utilization - * required to meet deadlines. - */ -unsigned long schedutil_cpu_util(int cpu, unsigned long util_cfs, - unsigned long max, enum schedutil_type type, - struct task_struct *p) -{ - unsigned long dl_util, util, irq; - struct rq *rq = cpu_rq(cpu); - - if (!uclamp_is_used() && - type == FREQUENCY_UTIL && rt_rq_is_runnable(&rq->rt)) { - return max; - } - - /* - * Early check to see if IRQ/steal time saturates the CPU, can be - * because of inaccuracies in how we track these -- see - * update_irq_load_avg(). - */ - irq = cpu_util_irq(rq); - if (unlikely(irq >= max)) - return max; - - /* - * Because the time spend on RT/DL tasks is visible as 'lost' time to - * CFS tasks and we use the same metric to track the effective - * utilization (PELT windows are synchronized) we can directly add them - * to obtain the CPU's actual utilization. - * - * CFS and RT utilization can be boosted or capped, depending on - * utilization clamp constraints requested by currently RUNNABLE - * tasks. - * When there are no CFS RUNNABLE tasks, clamps are released and - * frequency will be gracefully reduced with the utilization decay. - */ - util = util_cfs + cpu_util_rt(rq); - if (type == FREQUENCY_UTIL) - util = uclamp_rq_util_with(rq, util, p); - - dl_util = cpu_util_dl(rq); - - /* - * For frequency selection we do not make cpu_util_dl() a permanent part - * of this sum because we want to use cpu_bw_dl() later on, but we need - * to check if the CFS+RT+DL sum is saturated (ie. no idle time) such - * that we select f_max when there is no idle time. - * - * NOTE: numerical errors or stop class might cause us to not quite hit - * saturation when we should -- something for later. - */ - if (util + dl_util >= max) - return max; - - /* - * OTOH, for energy computation we need the estimated running time, so - * include util_dl and ignore dl_bw. - */ - if (type == ENERGY_UTIL) - util += dl_util; - - /* - * There is still idle time; further improve the number by using the - * irq metric. Because IRQ/steal time is hidden from the task clock we - * need to scale the task numbers: - * - * max - irq - * U' = irq + --------- * U - * max - */ - util = scale_irq_capacity(util, irq, max); - util += irq; - - /* - * Bandwidth required by DEADLINE must always be granted while, for - * FAIR and RT, we use blocked utilization of IDLE CPUs as a mechanism - * to gracefully reduce the frequency when no tasks show up for longer - * periods of time. - * - * Ideally we would like to set bw_dl as min/guaranteed freq and util + - * bw_dl as requested freq. However, cpufreq is not yet ready for such - * an interface. So, we only do the latter for now. - */ - if (type == FREQUENCY_UTIL) - util += cpu_bw_dl(rq); - - return min(max, util); -} - static unsigned long sugov_get_util(struct sugov_cpu *sg_cpu) { struct rq *rq = cpu_rq(sg_cpu->cpu); @@ -298,7 +192,7 @@ static unsigned long sugov_get_util(struct sugov_cpu *sg_cpu) sg_cpu->max = max; sg_cpu->bw_dl = cpu_bw_dl(rq); - return schedutil_cpu_util(sg_cpu->cpu, util, max, FREQUENCY_UTIL, NULL); + return effective_cpu_util(sg_cpu->cpu, util, max, FREQUENCY_UTIL, NULL); } /** diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index 3213cb247aff..94d564745499 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -6490,7 +6490,7 @@ compute_energy(struct task_struct *p, int dst_cpu, struct perf_domain *pd) * is already enough to scale the EM reported power * consumption at the (eventually clamped) cpu_capacity. */ - sum_util += schedutil_cpu_util(cpu, util_cfs, cpu_cap, + sum_util += effective_cpu_util(cpu, util_cfs, cpu_cap, ENERGY_UTIL, NULL); /* @@ -6500,7 +6500,7 @@ compute_energy(struct task_struct *p, int dst_cpu, struct perf_domain *pd) * NOTE: in case RT tasks are running, by default the * FREQUENCY_UTIL's utilization can be max OPP. */ - cpu_util = schedutil_cpu_util(cpu, util_cfs, cpu_cap, + cpu_util = effective_cpu_util(cpu, util_cfs, cpu_cap, FREQUENCY_UTIL, tsk); max_util = max(max_util, cpu_util); } @@ -6597,7 +6597,7 @@ static int find_energy_efficient_cpu(struct task_struct *p, int prev_cpu) * IOW, placing the task there would make the CPU * overutilized. Take uclamp into account to see how * much capacity we can get out of the CPU; this is - * aligned with schedutil_cpu_util(). + * aligned with effective_cpu_util(). */ util = uclamp_rq_util_with(cpu_rq(cpu), util, p); if (!fits_capacity(util, cpu_cap)) diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h index 65b72e0487bf..dabfc7fa1270 100644 --- a/kernel/sched/sched.h +++ b/kernel/sched/sched.h @@ -2465,24 +2465,22 @@ static inline unsigned long capacity_orig_of(int cpu) #endif /** - * enum schedutil_type - CPU utilization type + * enum cpu_util_type - CPU utilization type * @FREQUENCY_UTIL: Utilization used to select frequency * @ENERGY_UTIL: Utilization used during energy calculation * * The utilization signals of all scheduling classes (CFS/RT/DL) and IRQ time * need to be aggregated differently depending on the usage made of them. This - * enum is used within schedutil_freq_util() to differentiate the types of + * enum is used within effective_cpu_util() to differentiate the types of * utilization expected by the callers, and adjust the aggregation accordingly. */ -enum schedutil_type { +enum cpu_util_type { FREQUENCY_UTIL, ENERGY_UTIL, }; -#ifdef CONFIG_CPU_FREQ_GOV_SCHEDUTIL - -unsigned long schedutil_cpu_util(int cpu, unsigned long util_cfs, - unsigned long max, enum schedutil_type type, +unsigned long effective_cpu_util(int cpu, unsigned long util_cfs, + unsigned long max, enum cpu_util_type type, struct task_struct *p); static inline unsigned long cpu_bw_dl(struct rq *rq) @@ -2511,14 +2509,6 @@ static inline unsigned long cpu_util_rt(struct rq *rq) { return READ_ONCE(rq->avg_rt.util_avg); } -#else /* CONFIG_CPU_FREQ_GOV_SCHEDUTIL */ -static inline unsigned long schedutil_cpu_util(int cpu, unsigned long util_cfs, - unsigned long max, enum schedutil_type type, - struct task_struct *p) -{ - return 0; -} -#endif /* CONFIG_CPU_FREQ_GOV_SCHEDUTIL */ #ifdef CONFIG_HAVE_SCHED_AVG_IRQ static inline unsigned long cpu_util_irq(struct rq *rq) From patchwork Tue Jul 14 06:36:53 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Viresh Kumar X-Patchwork-Id: 235505 Delivered-To: patch@linaro.org Received: by 2002:a92:d244:0:0:0:0:0 with SMTP id v4csp3477085ilg; Mon, 13 Jul 2020 23:37:08 -0700 (PDT) X-Google-Smtp-Source: ABdhPJzsTo4iKToncEX4xLz98gD2YAr1MnjuBdClSlm0VvceZILZ7s9PkctjVDrhb5aIxDf3hl7G X-Received: by 2002:a17:906:dce:: with SMTP id p14mr3063366eji.442.1594708628662; Mon, 13 Jul 2020 23:37:08 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1594708628; cv=none; d=google.com; s=arc-20160816; b=fBQFqnMNPsbhVLn4dESyplwMytEpUHPGGlm3nVbYqntOTJPeuavELJcL1TCWS4/c9p v2QPaV2M7/kvdK7xwAnpH+i+pJZIQgGVBwwHVTXBZZLuiRwzYOErWXSmVpuKW0FFnVNg INYT1fL4E6ALUMEPez9XNX1dspUJTrjSKhHH9F24ywW7VlLCzqdrKNgZk5Kl0XQt+g7U ZD/DLaZkGo1vpAKvAnaFLHMwFZpMeW4j78yowL/5y+1GJHGgP8WUFHIcRPKHtDkrl5s4 kfak40yVPYcRL3T/Mbrso07AaiIz3/b+U6QTGQXV+DJS5/zGatLnHaXy8E90jgkQrWhl 4bTw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=vW6KQNy5+oCCRnnC1Q8VPuviXyfCEPdbUReZkc1RE18=; b=OK+sfKMie+Kj4zGUfKP+dF/YCZP8FoIM4aQPEU59pR2HEN1YeMq0BSDQgfv3V437I+ Q1o+5DSrQMoSchmqd+SSsC6YfA11TFMX2Jlt0skkKBmDFREb0KhS11PQCc1rJo8YPckd sBemCjTUMvtIEg/zRx/pQ9bl2+nZJn46OXRdXA/eyLCz8HyUkCAPBQK6DTiLGLQReZD7 jyt3lmkfj6c57rsDq7CLvaKSwxm4n6PeHEIA5TScucM55PVEASVBSzFQLF7iv1PPdjtp 4CxwlUSRJPNIc2ERboZQ/eQq04+drPchXuWVznOzj5RX3riNz4syi1JBPMKjXcmF8zwA oLaw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=sLBXfe3t; spf=pass (google.com: domain of linux-pm-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-pm-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id c102si12582697edf.216.2020.07.13.23.37.08; Mon, 13 Jul 2020 23:37:08 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-pm-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=sLBXfe3t; spf=pass (google.com: domain of linux-pm-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-pm-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727055AbgGNGhH (ORCPT + 10 others); Tue, 14 Jul 2020 02:37:07 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37382 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727104AbgGNGhH (ORCPT ); Tue, 14 Jul 2020 02:37:07 -0400 Received: from mail-pj1-x1042.google.com (mail-pj1-x1042.google.com [IPv6:2607:f8b0:4864:20::1042]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 08F86C061755 for ; Mon, 13 Jul 2020 23:37:07 -0700 (PDT) Received: by mail-pj1-x1042.google.com with SMTP id ls15so1109117pjb.1 for ; Mon, 13 Jul 2020 23:37:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=vW6KQNy5+oCCRnnC1Q8VPuviXyfCEPdbUReZkc1RE18=; b=sLBXfe3ttAMfTz75e+ERY2AsS9FIU/c552V9ylpEOSE595ixwhhjeZhxlfNesV9IpO zd1NGnpeih9vKO0Ey8fZYmRTyORhlacRU/MgWpoRfzpGqYElumOD7eSFPh59pYLuGEK3 gZfMOMDdFRSyiieGMIN3sCqenjPsCuZZlpENJSzJxTEJ705jrtNUjYGrjdL1dUxsoJCA 0tprF+BFztmbNPUljlXaGezagsiaXi+fFroI3A2f29TfxwEBXXZ5C7DnyOj2avvbU1qY ALmw1/oaZbDi0TwM+vg/OfRM5A9Lfck0pVdeneS1Z7q4cdRwt5K+A2Uxz2fnaJ8OWLKX lVUA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=vW6KQNy5+oCCRnnC1Q8VPuviXyfCEPdbUReZkc1RE18=; b=nguptquUtxm4v85ABrSFvRW54NJ5N/F65NdeulrF67Fx7pwoeruMIKhuIevgHgB1WT UZ1pt5yc9NwslR4VMsf2DNZQ+V2A+pBx0gJwcgEF8MVOvHdO534I+IQIsDCIwRolkO/I dmNm9SjwRV+9p34R12akDT9U/V4zBwQzuG/qdbWZ86zJAoLhNlhjmDL1zE0wHYL9/eA9 DY/Q9uHnsVYOKSplYiil+2RhQsvGkRRWtSgNFmwhfUvbaD2MsPTDGfa2O9cwHhjqAz+J Jd6oEjE+oB9x8xOdQ+9K+fRhVOyadHbFlLMIbl0PYb7IzMi6Sh5l3a/KYicRPZRmUCaq fEiQ== X-Gm-Message-State: AOAM531IRiLE8NUJoElUpGQ1lcwp1sTwa3sFAImj3DUXNvHL59sPE4mC Gp9G+Hkb9+pMxwdN6itKEXHRcA== X-Received: by 2002:a17:902:e901:: with SMTP id k1mr2847764pld.130.1594708626463; Mon, 13 Jul 2020 23:37:06 -0700 (PDT) Received: from localhost ([122.172.34.142]) by smtp.gmail.com with ESMTPSA id hg13sm1331299pjb.21.2020.07.13.23.37.05 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Mon, 13 Jul 2020 23:37:05 -0700 (PDT) From: Viresh Kumar To: Ingo Molnar , Peter Zijlstra , Vincent Guittot , Zhang Rui , Daniel Lezcano , Amit Daniel Kachhap , Viresh Kumar , Javi Merino , Amit Kucheria Cc: linux-kernel@vger.kernel.org, Quentin Perret , Rafael Wysocki , linux-pm@vger.kernel.org Subject: [PATCH 2/2] thermal: cpufreq_cooling: Reuse effective_cpu_util() Date: Tue, 14 Jul 2020 12:06:53 +0530 Message-Id: X-Mailer: git-send-email 2.25.0.rc1.19.g042ed3e048af In-Reply-To: References: MIME-Version: 1.0 Sender: linux-pm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org Several parts of the kernel are already using the effective CPU utilization to get the current load on the CPU, do the same here instead of depending on the idle time of the CPU, which isn't that accurate comparatively. Note that, this (and CPU frequency scaling in general) doesn't work that well with idle injection as that is done from rt threads and is counted as load while it tries to do quite the opposite. That should be solved separately though. Signed-off-by: Viresh Kumar --- drivers/thermal/cpufreq_cooling.c | 65 +++++++------------------------ 1 file changed, 15 insertions(+), 50 deletions(-) -- 2.25.0.rc1.19.g042ed3e048af diff --git a/drivers/thermal/cpufreq_cooling.c b/drivers/thermal/cpufreq_cooling.c index 6c0e1b053126..74340b2b0da7 100644 --- a/drivers/thermal/cpufreq_cooling.c +++ b/drivers/thermal/cpufreq_cooling.c @@ -23,6 +23,7 @@ #include #include +#include "../../kernel/sched/sched.h" /* * Cooling state <-> CPUFreq frequency @@ -38,16 +39,6 @@ * ... */ -/** - * struct time_in_idle - Idle time stats - * @time: previous reading of the absolute time that this cpu was idle - * @timestamp: wall time of the last invocation of get_cpu_idle_time_us() - */ -struct time_in_idle { - u64 time; - u64 timestamp; -}; - /** * struct cpufreq_cooling_device - data for cooling device with cpufreq * @id: unique integer value corresponding to each cpufreq_cooling_device @@ -62,7 +53,6 @@ struct time_in_idle { * registered cooling device. * @policy: cpufreq policy. * @node: list_head to link all cpufreq_cooling_device together. - * @idle_time: idle time stats * @qos_req: PM QoS contraint to apply * * This structure is required for keeping information of each registered @@ -76,7 +66,6 @@ struct cpufreq_cooling_device { struct em_perf_domain *em; struct cpufreq_policy *policy; struct list_head node; - struct time_in_idle *idle_time; struct freq_qos_request qos_req; }; @@ -132,34 +121,21 @@ static u32 cpu_power_to_freq(struct cpufreq_cooling_device *cpufreq_cdev, } /** - * get_load() - get load for a cpu since last updated + * get_load() - get current load for a cpu * @cpufreq_cdev: &struct cpufreq_cooling_device for this cpu * @cpu: cpu number - * @cpu_idx: index of the cpu in time_in_idle* + * @cpu_idx: index of the cpu * - * Return: The average load of cpu @cpu in percentage since this - * function was last called. + * Return: The current load of cpu @cpu in percentage. */ static u32 get_load(struct cpufreq_cooling_device *cpufreq_cdev, int cpu, int cpu_idx) { - u32 load; - u64 now, now_idle, delta_time, delta_idle; - struct time_in_idle *idle_time = &cpufreq_cdev->idle_time[cpu_idx]; - - now_idle = get_cpu_idle_time(cpu, &now, 0); - delta_idle = now_idle - idle_time->time; - delta_time = now - idle_time->timestamp; + unsigned long util = cpu_util_cfs(cpu_rq(cpu)); + unsigned long max = arch_scale_cpu_capacity(cpu); - if (delta_time <= delta_idle) - load = 0; - else - load = div64_u64(100 * (delta_time - delta_idle), delta_time); - - idle_time->time = now_idle; - idle_time->timestamp = now; - - return load; + util = effective_cpu_util(cpu, util, max, ENERGY_UTIL, NULL); + return (util * 100) / max; } /** @@ -192,13 +168,12 @@ static u32 get_dynamic_power(struct cpufreq_cooling_device *cpufreq_cdev, * Instead, we calculate the current power on the assumption that the * immediate future will look like the immediate past. * - * We use the current frequency and the average load since this - * function was last called. In reality, there could have been - * multiple opps since this function was last called and that affects - * the load calculation. While it's not perfectly accurate, this - * simplification is good enough and works. REVISIT this, as more - * complex code may be needed if experiments show that it's not - * accurate enough. + * We use the current frequency and the current load. In reality, + * there could have been multiple opps since this function was last + * called and that affects the load calculation. While it's not + * perfectly accurate, this simplification is good enough and works. + * REVISIT this, as more complex code may be needed if experiments show + * that it's not accurate enough. * * Return: 0 on success, -E* if getting the static power failed. */ @@ -523,13 +498,6 @@ __cpufreq_cooling_register(struct device_node *np, cpufreq_cdev->policy = policy; num_cpus = cpumask_weight(policy->related_cpus); - cpufreq_cdev->idle_time = kcalloc(num_cpus, - sizeof(*cpufreq_cdev->idle_time), - GFP_KERNEL); - if (!cpufreq_cdev->idle_time) { - cdev = ERR_PTR(-ENOMEM); - goto free_cdev; - } /* max_level is an index, not a counter */ cpufreq_cdev->max_level = i - 1; @@ -537,7 +505,7 @@ __cpufreq_cooling_register(struct device_node *np, ret = ida_simple_get(&cpufreq_ida, 0, 0, GFP_KERNEL); if (ret < 0) { cdev = ERR_PTR(ret); - goto free_idle_time; + goto free_cdev; } cpufreq_cdev->id = ret; @@ -586,8 +554,6 @@ __cpufreq_cooling_register(struct device_node *np, freq_qos_remove_request(&cpufreq_cdev->qos_req); remove_ida: ida_simple_remove(&cpufreq_ida, cpufreq_cdev->id); -free_idle_time: - kfree(cpufreq_cdev->idle_time); free_cdev: kfree(cpufreq_cdev); return cdev; @@ -680,7 +646,6 @@ void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev) thermal_cooling_device_unregister(cdev); freq_qos_remove_request(&cpufreq_cdev->qos_req); ida_simple_remove(&cpufreq_ida, cpufreq_cdev->id); - kfree(cpufreq_cdev->idle_time); kfree(cpufreq_cdev); } EXPORT_SYMBOL_GPL(cpufreq_cooling_unregister);