From patchwork Wed May 12 03:49:45 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richael Zhuang X-Patchwork-Id: 93177 Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 180E3A0C3F; Wed, 12 May 2021 05:50:11 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 024D4410F6; Wed, 12 May 2021 05:50:11 +0200 (CEST) Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by mails.dpdk.org (Postfix) with ESMTP id EBCB6410E3 for ; Wed, 12 May 2021 05:50:08 +0200 (CEST) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 631F331B; Tue, 11 May 2021 20:50:08 -0700 (PDT) Received: from wls-arm-cavium06.shanghai.arm.com (wls-arm-cavium06.shanghai.arm.com [10.169.206.120]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 8E8C43F73B; Tue, 11 May 2021 20:50:06 -0700 (PDT) From: Richael Zhuang To: dev@dpdk.org Cc: anatoly.burakov@intel.com, David Hunt Date: Wed, 12 May 2021 11:49:45 +0800 Message-Id: <20210512034946.37550-2-richael.zhuang@arm.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210512034946.37550-1-richael.zhuang@arm.com> References: <20210422061540.23304-2-richael.zhuang@arm.com> <20210512034946.37550-1-richael.zhuang@arm.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH v2 1/2] power: add support for cppc cpufreq X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Currently in DPDK only acpi_cpufreq and pstate_cpufreq drivers are supported, which are both not available on arm64 platforms. Add support for cppc_cpufreq driver which works on most arm64 platforms. Signed-off-by: Richael Zhuang --- app/test/test_power.c | 3 +- app/test/test_power_cpufreq.c | 3 +- lib/power/meson.build | 1 + lib/power/power_cppc_cpufreq.c | 632 +++++++++++++++++++++++++++++++++ lib/power/power_cppc_cpufreq.h | 229 ++++++++++++ lib/power/rte_power.c | 26 ++ lib/power/rte_power.h | 2 +- 7 files changed, 893 insertions(+), 3 deletions(-) create mode 100644 lib/power/power_cppc_cpufreq.c create mode 100644 lib/power/power_cppc_cpufreq.h diff --git a/app/test/test_power.c b/app/test/test_power.c index da1d67c0a..b7b556134 100644 --- a/app/test/test_power.c +++ b/app/test/test_power.c @@ -133,7 +133,8 @@ test_power(void) /* Perform tests for valid environments.*/ const enum power_management_env envs[] = {PM_ENV_ACPI_CPUFREQ, PM_ENV_KVM_VM, - PM_ENV_PSTATE_CPUFREQ}; + PM_ENV_PSTATE_CPUFREQ, + PM_ENV_CPPC_CPUFREQ}; unsigned int i; for (i = 0; i < RTE_DIM(envs); ++i) { diff --git a/app/test/test_power_cpufreq.c b/app/test/test_power_cpufreq.c index f753d24ac..87d07191d 100644 --- a/app/test/test_power_cpufreq.c +++ b/app/test/test_power_cpufreq.c @@ -470,7 +470,8 @@ test_power_cpufreq(void) /* Test environment configuration */ env = rte_power_get_env(); - if ((env != PM_ENV_ACPI_CPUFREQ) && (env != PM_ENV_PSTATE_CPUFREQ)) { + if ((env != PM_ENV_ACPI_CPUFREQ) && (env != PM_ENV_PSTATE_CPUFREQ) && + (env != PM_ENV_CPPC_CPUFREQ)) { printf("Unexpectedly got an environment other than ACPI/PSTATE\n"); goto fail_all; } diff --git a/lib/power/meson.build b/lib/power/meson.build index 74c5f3a29..4a5b07292 100644 --- a/lib/power/meson.build +++ b/lib/power/meson.build @@ -21,6 +21,7 @@ sources = files( 'rte_power.c', 'rte_power_empty_poll.c', 'rte_power_pmd_mgmt.c', + 'power_cppc_cpufreq.c', ) headers = files( 'rte_power.h', diff --git a/lib/power/power_cppc_cpufreq.c b/lib/power/power_cppc_cpufreq.c new file mode 100644 index 000000000..c4a71a3d3 --- /dev/null +++ b/lib/power/power_cppc_cpufreq.c @@ -0,0 +1,632 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Arm Limited + */ + +#include +#include + +#include "power_cppc_cpufreq.h" +#include "power_common.h" + +/* macros used for rounding frequency to nearest 100000 */ +#define FREQ_ROUNDING_DELTA 50000 +#define ROUND_FREQ_TO_N_100000 100000 + +/* the unit of highest_perf and nominal_perf differs on different arm platforms. + * For highest_perf, it maybe 300 or 3000000, both means 3.0GHz. + */ +#define UNIT_DIFF 10000 + +#define POWER_CONVERT_TO_DECIMAL 10 + +#define POWER_GOVERNOR_USERSPACE "userspace" +#define POWER_SYSFILE_SETSPEED \ + "/sys/devices/system/cpu/cpu%u/cpufreq/scaling_setspeed" +#define POWER_SYSFILE_SCALING_MAX_FREQ \ + "/sys/devices/system/cpu/cpu%u/cpufreq/scaling_max_freq" +#define POWER_SYSFILE_SCALING_MIN_FREQ \ + "/sys/devices/system/cpu/cpu%u/cpufreq/scaling_min_freq" +#define POWER_SYSFILE_HIGHEST_PERF \ + "/sys/devices/system/cpu/cpu%u/acpi_cppc/highest_perf" +#define POWER_SYSFILE_NOMINAL_PERF \ + "/sys/devices/system/cpu/cpu%u/acpi_cppc/nominal_perf" +#define POWER_SYSFILE_SYS_MAX \ + "/sys/devices/system/cpu/cpu%u/cpufreq/cpuinfo_max_freq" + +#define POWER_CPPC_DRIVER "cppc-cpufreq" +#define BUS_FREQ 100000 + +enum power_state { + POWER_IDLE = 0, + POWER_ONGOING, + POWER_USED, + POWER_UNKNOWN +}; + +/** + * Power info per lcore. + */ +struct cppc_power_info { + unsigned int lcore_id; /**< Logical core id */ + uint32_t state; /**< Power in use state */ + FILE *f; /**< FD of scaling_setspeed */ + char governor_ori[32]; /**< Original governor name */ + uint32_t curr_idx; /**< Freq index in freqs array */ + uint32_t highest_perf; /**< system wide max freq */ + uint32_t nominal_perf; /**< system wide nominal freq */ + uint16_t turbo_available; /**< Turbo Boost available */ + uint16_t turbo_enable; /**< Turbo Boost enable/disable */ + uint32_t nb_freqs; /**< number of available freqs */ + uint32_t freqs[RTE_MAX_LCORE_FREQS]; /**< Frequency array */ +} __rte_cache_aligned; + +static struct cppc_power_info lcore_power_info[RTE_MAX_LCORE]; + +/** + * It is to set specific freq for specific logical core, according to the index + * of supported frequencies. + */ +static int +set_freq_internal(struct cppc_power_info *pi, uint32_t idx) +{ + if (idx >= RTE_MAX_LCORE_FREQS || idx >= pi->nb_freqs) { + RTE_LOG(ERR, POWER, "Invalid frequency index %u, which " + "should be less than %u\n", idx, pi->nb_freqs); + return -1; + } + + /* Check if it is the same as current */ + if (idx == pi->curr_idx) + return 0; + + POWER_DEBUG_TRACE("Frequency[%u] %u to be set for lcore %u\n", + idx, pi->freqs[idx], pi->lcore_id); + if (fseek(pi->f, 0, SEEK_SET) < 0) { + RTE_LOG(ERR, POWER, "Fail to set file position indicator to 0 " + "for setting frequency for lcore %u\n", pi->lcore_id); + return -1; + } + if (fprintf(pi->f, "%u", pi->freqs[idx]) < 0) { + RTE_LOG(ERR, POWER, "Fail to write new frequency for " + "lcore %u\n", pi->lcore_id); + return -1; + } + fflush(pi->f); + pi->curr_idx = idx; + + return 1; +} + +/** + * It is to check the current scaling governor by reading sys file, and then + * set it into 'userspace' if it is not by writing the sys file. The original + * governor will be saved for rolling back. + */ +static int +power_set_governor_userspace(struct cppc_power_info *pi) +{ + return power_set_governor(pi->lcore_id, POWER_GOVERNOR_USERSPACE, + pi->governor_ori, sizeof(pi->governor_ori)); +} + +static int +power_check_turbo(struct cppc_power_info *pi) +{ + FILE *f_nom, *f_max, *f_cmax; + int ret = -1; + uint32_t nominal_perf = 0, highest_perf = 0, cpuinfo_max_freq = 0; + + open_core_sysfs_file(POWER_SYSFILE_HIGHEST_PERF, pi->lcore_id, "r", + &f_max); + FOPEN_OR_ERR_GOTO(f_max, err); + + open_core_sysfs_file(POWER_SYSFILE_NOMINAL_PERF, pi->lcore_id, "r", + &f_nom); + FOPEN_OR_ERR_GOTO(f_nom, err); + + open_core_sysfs_file(POWER_SYSFILE_SYS_MAX, pi->lcore_id, "r", + &f_cmax); + FOPEN_OR_ERR_GOTO(f_cmax, err); + + ret = read_core_sysfs_u32(f_max, &highest_perf); + FOPS_OR_ERR_GOTO(ret, err); + + ret = read_core_sysfs_u32(f_nom, &nominal_perf); + FOPS_OR_ERR_GOTO(ret, err); + + ret = read_core_sysfs_u32(f_cmax, &cpuinfo_max_freq); + FOPS_OR_ERR_GOTO(ret, err); + + pi->highest_perf = highest_perf; + pi->nominal_perf = nominal_perf; + + if ((highest_perf > nominal_perf) && ((cpuinfo_max_freq == highest_perf) || + cpuinfo_max_freq == highest_perf * UNIT_DIFF)) { + pi->turbo_available = 1; + pi->turbo_enable = 1; + ret = 0; + POWER_DEBUG_TRACE("Lcore %u can do Turbo Boost! highest perf %u, " + "nominal perf %u\n", + pi->lcore_id, highest_perf, nominal_perf); + } else { + pi->turbo_available = 0; + pi->turbo_enable = 0; + POWER_DEBUG_TRACE("Lcore %u Turbo not available! highest perf %u, " + "nominal perf %u\n", + pi->lcore_id, highest_perf, nominal_perf); + } + +err: + if (f_max != NULL) + fclose(f_max); + if (f_nom != NULL) + fclose(f_nom); + if (f_cmax != NULL) + fclose(f_cmax); + + return ret; +} + +/** + * It is to get the available frequencies of the specific lcore by reading the + * sys file. + */ +static int +power_get_available_freqs(struct cppc_power_info *pi) +{ + FILE *f_min, *f_max; + int ret = -1; + uint32_t scaling_min_freq = 0, scaling_max_freq = 0, nominal_perf = 0; + uint32_t i, num_freqs = 0; + + open_core_sysfs_file(POWER_SYSFILE_SCALING_MAX_FREQ, pi->lcore_id, "r", + &f_max); + FOPEN_OR_ERR_GOTO(f_max, out); + + open_core_sysfs_file(POWER_SYSFILE_SCALING_MIN_FREQ, pi->lcore_id, "r", + &f_min); + FOPEN_OR_ERR_GOTO(f_min, out); + + ret = read_core_sysfs_u32(f_max, &scaling_max_freq); + FOPS_OR_ERR_GOTO(ret, out); + + ret = read_core_sysfs_u32(f_min, &scaling_min_freq); + FOPS_OR_ERR_GOTO(ret, out); + + power_check_turbo(pi); + + if (scaling_max_freq < scaling_min_freq) + goto out; + + /* If turbo is available then there is one extra freq bucket + * to store the sys max freq which value is scaling_max_freq + */ + nominal_perf = (pi->nominal_perf < UNIT_DIFF) ? + pi->nominal_perf * UNIT_DIFF : pi->nominal_perf; + num_freqs = (nominal_perf - scaling_min_freq) / BUS_FREQ + 1 + + pi->turbo_available; + + /* Generate the freq bucket array. */ + for (i = 0, pi->nb_freqs = 0; i < num_freqs; i++) { + if ((i == 0) && pi->turbo_available) + pi->freqs[pi->nb_freqs++] = scaling_max_freq; + else + pi->freqs[pi->nb_freqs++] = + nominal_perf - (i - pi->turbo_available) * BUS_FREQ; + } + + ret = 0; + + POWER_DEBUG_TRACE("%d frequency(s) of lcore %u are available\n", + num_freqs, pi->lcore_id); + +out: + if (f_min != NULL) + fclose(f_min); + if (f_max != NULL) + fclose(f_max); + + return ret; +} + +/** + * It is to fopen the sys file for the future setting the lcore frequency. + */ +static int +power_init_for_setting_freq(struct cppc_power_info *pi) +{ + FILE *f; + char buf[BUFSIZ]; + uint32_t i, freq; + int ret; + + open_core_sysfs_file(POWER_SYSFILE_SETSPEED, pi->lcore_id, "rw+", + &f); + FOPEN_OR_ERR_GOTO(f, err); + + ret = read_core_sysfs_s(f, buf, sizeof(buf)); + FOPS_OR_ERR_GOTO(ret, err); + + freq = strtoul(buf, NULL, POWER_CONVERT_TO_DECIMAL); + + /* convert the frequency to nearest 100000 value + * Ex: if freq=1396789 then freq_conv=1400000 + * Ex: if freq=800030 then freq_conv=800000 + */ + unsigned int freq_conv = 0; + freq_conv = (freq + FREQ_ROUNDING_DELTA) + / ROUND_FREQ_TO_N_100000; + freq_conv = freq_conv * ROUND_FREQ_TO_N_100000; + + for (i = 0; i < pi->nb_freqs; i++) { + if (freq_conv == pi->freqs[i]) { + pi->curr_idx = i; + pi->f = f; + return 0; + } + } + +err: + if (f != NULL) + fclose(f); + + return -1; +} + +int +power_cppc_cpufreq_check_supported(void) +{ + return cpufreq_check_scaling_driver(POWER_CPPC_DRIVER); +} + +int +power_cppc_cpufreq_init(unsigned int lcore_id) +{ + struct cppc_power_info *pi; + uint32_t exp_state; + + if (lcore_id >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Lcore id %u can not exceeds %u\n", + lcore_id, RTE_MAX_LCORE - 1U); + return -1; + } + + pi = &lcore_power_info[lcore_id]; + exp_state = POWER_IDLE; + /* The power in use state works as a guard variable between + * the CPU frequency control initialization and exit process. + * The ACQUIRE memory ordering here pairs with the RELEASE + * ordering below as lock to make sure the frequency operations + * in the critical section are done under the correct state. + */ + if (!__atomic_compare_exchange_n(&(pi->state), &exp_state, + POWER_ONGOING, 0, + __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) { + RTE_LOG(INFO, POWER, "Power management of lcore %u is " + "in use\n", lcore_id); + return -1; + } + + pi->lcore_id = lcore_id; + /* Check and set the governor */ + if (power_set_governor_userspace(pi) < 0) { + RTE_LOG(ERR, POWER, "Cannot set governor of lcore %u to " + "userspace\n", lcore_id); + goto fail; + } + + /* Get the available frequencies */ + if (power_get_available_freqs(pi) < 0) { + RTE_LOG(ERR, POWER, "Cannot get available frequencies of " + "lcore %u\n", lcore_id); + goto fail; + } + + /* Init for setting lcore frequency */ + if (power_init_for_setting_freq(pi) < 0) { + RTE_LOG(ERR, POWER, "Cannot init for setting frequency for " + "lcore %u\n", lcore_id); + goto fail; + } + + /* Set freq to max by default */ + if (power_cppc_cpufreq_freq_max(lcore_id) < 0) { + RTE_LOG(ERR, POWER, "Cannot set frequency of lcore %u " + "to max\n", lcore_id); + goto fail; + } + + RTE_LOG(INFO, POWER, "Initialized successfully for lcore %u " + "power management\n", lcore_id); + + __atomic_store_n(&(pi->state), POWER_USED, __ATOMIC_RELEASE); + + return 0; + +fail: + __atomic_store_n(&(pi->state), POWER_UNKNOWN, __ATOMIC_RELEASE); + return -1; +} + +/** + * It is to check the governor and then set the original governor back if + * needed by writing the sys file. + */ +static int +power_set_governor_original(struct cppc_power_info *pi) +{ + return power_set_governor(pi->lcore_id, pi->governor_ori, NULL, 0); +} + +int +power_cppc_cpufreq_exit(unsigned int lcore_id) +{ + struct cppc_power_info *pi; + uint32_t exp_state; + + if (lcore_id >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Lcore id %u can not exceeds %u\n", + lcore_id, RTE_MAX_LCORE - 1U); + return -1; + } + pi = &lcore_power_info[lcore_id]; + exp_state = POWER_USED; + /* The power in use state works as a guard variable between + * the CPU frequency control initialization and exit process. + * The ACQUIRE memory ordering here pairs with the RELEASE + * ordering below as lock to make sure the frequency operations + * in the critical section are done under the correct state. + */ + if (!__atomic_compare_exchange_n(&(pi->state), &exp_state, + POWER_ONGOING, 0, + __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) { + RTE_LOG(INFO, POWER, "Power management of lcore %u is " + "not used\n", lcore_id); + return -1; + } + + /* Close FD of setting freq */ + fclose(pi->f); + pi->f = NULL; + + /* Set the governor back to the original */ + if (power_set_governor_original(pi) < 0) { + RTE_LOG(ERR, POWER, "Cannot set the governor of %u back " + "to the original\n", lcore_id); + goto fail; + } + + RTE_LOG(INFO, POWER, "Power management of lcore %u has exited from " + "'userspace' mode and been set back to the " + "original\n", lcore_id); + __atomic_store_n(&(pi->state), POWER_IDLE, __ATOMIC_RELEASE); + + return 0; + +fail: + __atomic_store_n(&(pi->state), POWER_UNKNOWN, __ATOMIC_RELEASE); + + return -1; +} + +uint32_t +power_cppc_cpufreq_freqs(unsigned int lcore_id, uint32_t *freqs, uint32_t num) +{ + struct cppc_power_info *pi; + + if (lcore_id >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID\n"); + return 0; + } + + if (freqs == NULL) { + RTE_LOG(ERR, POWER, "NULL buffer supplied\n"); + return 0; + } + + pi = &lcore_power_info[lcore_id]; + if (num < pi->nb_freqs) { + RTE_LOG(ERR, POWER, "Buffer size is not enough\n"); + return 0; + } + rte_memcpy(freqs, pi->freqs, pi->nb_freqs * sizeof(uint32_t)); + + return pi->nb_freqs; +} + +uint32_t +power_cppc_cpufreq_get_freq(unsigned int lcore_id) +{ + if (lcore_id >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID\n"); + return RTE_POWER_INVALID_FREQ_INDEX; + } + + return lcore_power_info[lcore_id].curr_idx; +} + +int +power_cppc_cpufreq_set_freq(unsigned int lcore_id, uint32_t index) +{ + if (lcore_id >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID\n"); + return -1; + } + + return set_freq_internal(&(lcore_power_info[lcore_id]), index); +} + +int +power_cppc_cpufreq_freq_down(unsigned int lcore_id) +{ + struct cppc_power_info *pi; + + if (lcore_id >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID\n"); + return -1; + } + + pi = &lcore_power_info[lcore_id]; + if (pi->curr_idx + 1 == pi->nb_freqs) + return 0; + + /* Frequencies in the array are from high to low. */ + return set_freq_internal(pi, pi->curr_idx + 1); +} + +int +power_cppc_cpufreq_freq_up(unsigned int lcore_id) +{ + struct cppc_power_info *pi; + + if (lcore_id >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID\n"); + return -1; + } + + pi = &lcore_power_info[lcore_id]; + if (pi->curr_idx == 0 || (pi->curr_idx == 1 && + pi->turbo_available && !pi->turbo_enable)) + return 0; + + /* Frequencies in the array are from high to low. */ + return set_freq_internal(pi, pi->curr_idx - 1); +} + +int +power_cppc_cpufreq_freq_max(unsigned int lcore_id) +{ + if (lcore_id >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID\n"); + return -1; + } + + /* Frequencies in the array are from high to low. */ + if (lcore_power_info[lcore_id].turbo_available) { + if (lcore_power_info[lcore_id].turbo_enable) + /* Set to Turbo */ + return set_freq_internal( + &lcore_power_info[lcore_id], 0); + else + /* Set to max non-turbo */ + return set_freq_internal( + &lcore_power_info[lcore_id], 1); + } else + return set_freq_internal(&lcore_power_info[lcore_id], 0); +} + +int +power_cppc_cpufreq_freq_min(unsigned int lcore_id) +{ + struct cppc_power_info *pi; + + if (lcore_id >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID\n"); + return -1; + } + + pi = &lcore_power_info[lcore_id]; + + /* Frequencies in the array are from high to low. */ + return set_freq_internal(pi, pi->nb_freqs - 1); +} + +int +power_cppc_turbo_status(unsigned int lcore_id) +{ + struct cppc_power_info *pi; + + if (lcore_id >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID\n"); + return -1; + } + + pi = &lcore_power_info[lcore_id]; + + return pi->turbo_enable; +} + +int +power_cppc_enable_turbo(unsigned int lcore_id) +{ + struct cppc_power_info *pi; + + if (lcore_id >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID\n"); + return -1; + } + + pi = &lcore_power_info[lcore_id]; + + if (pi->turbo_available) + pi->turbo_enable = 1; + else { + pi->turbo_enable = 0; + RTE_LOG(ERR, POWER, + "Failed to enable turbo on lcore %u\n", + lcore_id); + return -1; + } + + /* TODO: must set to max once enbling Turbo? Considering add condition: + * if ((pi->turbo_available) && (pi->curr_idx <= 1)) + */ + /* Max may have changed, so call to max function */ + if (power_cppc_cpufreq_freq_max(lcore_id) < 0) { + RTE_LOG(ERR, POWER, + "Failed to set frequency of lcore %u to max\n", + lcore_id); + return -1; + } + + return 0; +} + +int +power_cppc_disable_turbo(unsigned int lcore_id) +{ + struct cppc_power_info *pi; + + if (lcore_id >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID\n"); + return -1; + } + + pi = &lcore_power_info[lcore_id]; + + pi->turbo_enable = 0; + + if ((pi->turbo_available) && (pi->curr_idx <= 1)) { + /* Try to set freq to max by default coming out of turbo */ + if (power_cppc_cpufreq_freq_max(lcore_id) < 0) { + RTE_LOG(ERR, POWER, + "Failed to set frequency of lcore %u to max\n", + lcore_id); + return -1; + } + } + + return 0; +} + +int +power_cppc_get_capabilities(unsigned int lcore_id, + struct rte_power_core_capabilities *caps) +{ + struct cppc_power_info *pi; + + if (lcore_id >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID\n"); + return -1; + } + if (caps == NULL) { + RTE_LOG(ERR, POWER, "Invalid argument\n"); + return -1; + } + + pi = &lcore_power_info[lcore_id]; + caps->capabilities = 0; + caps->turbo = !!(pi->turbo_available); + + return 0; +} diff --git a/lib/power/power_cppc_cpufreq.h b/lib/power/power_cppc_cpufreq.h new file mode 100644 index 000000000..427ce4f83 --- /dev/null +++ b/lib/power/power_cppc_cpufreq.h @@ -0,0 +1,229 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Arm Limited + */ + +#ifndef _POWER_CPPC_CPUFREQ_H +#define _POWER_CPPC_CPUFREQ_H + +/** + * @file + * RTE Power Management via userspace CPPC cpufreq + */ + +#include +#include +#include +#include +#include "rte_power.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Check if CPPC power management is supported. + * + * @return + * - 1 if supported + * - 0 if unsupported + * - -1 if error, with rte_errno indicating reason for error. + */ +int power_cppc_cpufreq_check_supported(void); + +/** + * Initialize power management for a specific lcore. It will check and set the + * governor to userspace for the lcore, get the available frequencies, and + * prepare to set new lcore frequency. + * + * @param lcore_id + * lcore id. + * + * @return + * - 0 on success. + * - Negative on error. + */ +int power_cppc_cpufreq_init(unsigned int lcore_id); + +/** + * Exit power management on a specific lcore. It will set the governor to which + * is before initialized. + * + * @param lcore_id + * lcore id. + * + * @return + * - 0 on success. + * - Negative on error. + */ +int power_cppc_cpufreq_exit(unsigned int lcore_id); + +/** + * Get the available frequencies of a specific lcore. The return value will be + * the minimal one of the total number of available frequencies and the number + * of buffer. The index of available frequencies used in other interfaces + * should be in the range of 0 to this return value. + * It should be protected outside of this function for threadsafe. + * + * @param lcore_id + * lcore id. + * @param freqs + * The buffer array to save the frequencies. + * @param num + * The number of frequencies to get. + * + * @return + * The number of available frequencies. + */ +uint32_t power_cppc_cpufreq_freqs(unsigned int lcore_id, uint32_t *freqs, + uint32_t num); + +/** + * Return the current index of available frequencies of a specific lcore. It + * will return 'RTE_POWER_INVALID_FREQ_INDEX = (~0)' if error. + * It should be protected outside of this function for threadsafe. + * + * @param lcore_id + * lcore id. + * + * @return + * The current index of available frequencies. + */ +uint32_t power_cppc_cpufreq_get_freq(unsigned int lcore_id); + +/** + * Set the new frequency for a specific lcore by indicating the index of + * available frequencies. + * It should be protected outside of this function for threadsafe. + * + * @param lcore_id + * lcore id. + * @param index + * The index of available frequencies. + * + * @return + * - 1 on success with frequency changed. + * - 0 on success without frequency changed. + * - Negative on error. + */ +int power_cppc_cpufreq_set_freq(unsigned int lcore_id, uint32_t index); + +/** + * Scale up the frequency of a specific lcore according to the available + * frequencies. + * It should be protected outside of this function for threadsafe. + * + * @param lcore_id + * lcore id. + * + * @return + * - 1 on success with frequency changed. + * - 0 on success without frequency changed. + * - Negative on error. + */ +int power_cppc_cpufreq_freq_up(unsigned int lcore_id); + +/** + * Scale down the frequency of a specific lcore according to the available + * frequencies. + * It should be protected outside of this function for threadsafe. + * + * @param lcore_id + * lcore id. + * + * @return + * - 1 on success with frequency changed. + * - 0 on success without frequency changed. + * - Negative on error. + */ +int power_cppc_cpufreq_freq_down(unsigned int lcore_id); + +/** + * Scale up the frequency of a specific lcore to the highest according to the + * available frequencies. + * It should be protected outside of this function for threadsafe. + * + * @param lcore_id + * lcore id. + * + * @return + * - 1 on success with frequency changed. + * - 0 on success without frequency changed. + * - Negative on error. + */ +int power_cppc_cpufreq_freq_max(unsigned int lcore_id); + +/** + * Scale down the frequency of a specific lcore to the lowest according to the + * available frequencies. + * It should be protected outside of this function for threadsafe. + * + * @param lcore_id + * lcore id. + * + * @return + * - 1 on success with frequency changed. + * - 0 on success without frequency changed. + * - Negative on error. + */ +int power_cppc_cpufreq_freq_min(unsigned int lcore_id); + +/** + * Get the turbo status of a specific lcore. + * It should be protected outside of this function for threadsafe. + * + * @param lcore_id + * lcore id. + * + * @return + * - 1 Turbo Boost is enabled on this lcore. + * - 0 Turbo Boost is disabled on this lcore. + * - Negative on error. + */ +int power_cppc_turbo_status(unsigned int lcore_id); + +/** + * Enable Turbo Boost on a specific lcore. + * It should be protected outside of this function for threadsafe. + * + * @param lcore_id + * lcore id. + * + * @return + * - 0 Turbo Boost is enabled successfully on this lcore. + * - Negative on error. + */ +int power_cppc_enable_turbo(unsigned int lcore_id); + +/** + * Disable Turbo Boost on a specific lcore. + * It should be protected outside of this function for threadsafe. + * + * @param lcore_id + * lcore id. + * + * @return + * - 0 Turbo Boost disabled successfully on this lcore. + * - Negative on error. + */ +int power_cppc_disable_turbo(unsigned int lcore_id); + +/** + * Returns power capabilities for a specific lcore. + * + * @param lcore_id + * lcore id. + * @param caps + * pointer to rte_power_core_capabilities object. + * + * @return + * - 0 on success. + * - Negative on error. + */ +int power_cppc_get_capabilities(unsigned int lcore_id, + struct rte_power_core_capabilities *caps); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/power/rte_power.c b/lib/power/rte_power.c index 98eaba915..3d51ff8be 100644 --- a/lib/power/rte_power.c +++ b/lib/power/rte_power.c @@ -10,6 +10,7 @@ #include "power_kvm_vm.h" #include "power_pstate_cpufreq.h" #include "power_common.h" +#include "power_cppc_cpufreq.h" enum power_management_env global_default_env = PM_ENV_NOT_SET; @@ -54,6 +55,8 @@ rte_power_check_env_supported(enum power_management_env env) return power_pstate_cpufreq_check_supported(); case PM_ENV_KVM_VM: return power_kvm_vm_check_supported(); + case PM_ENV_CPPC_CPUFREQ: + return power_cppc_cpufreq_check_supported(); default: rte_errno = EINVAL; return -1; @@ -110,6 +113,18 @@ rte_power_set_env(enum power_management_env env) rte_power_freq_disable_turbo = power_pstate_disable_turbo; rte_power_get_capabilities = power_pstate_get_capabilities; + } else if (env == PM_ENV_CPPC_CPUFREQ) { + rte_power_freqs = power_cppc_cpufreq_freqs; + rte_power_get_freq = power_cppc_cpufreq_get_freq; + rte_power_set_freq = power_cppc_cpufreq_set_freq; + rte_power_freq_up = power_cppc_cpufreq_freq_up; + rte_power_freq_down = power_cppc_cpufreq_freq_down; + rte_power_freq_min = power_cppc_cpufreq_freq_min; + rte_power_freq_max = power_cppc_cpufreq_freq_max; + rte_power_turbo_status = power_cppc_turbo_status; + rte_power_freq_enable_turbo = power_cppc_enable_turbo; + rte_power_freq_disable_turbo = power_cppc_disable_turbo; + rte_power_get_capabilities = power_cppc_get_capabilities; } else { RTE_LOG(ERR, POWER, "Invalid Power Management Environment(%d) set\n", env); @@ -153,6 +168,8 @@ rte_power_init(unsigned int lcore_id) return power_kvm_vm_init(lcore_id); case PM_ENV_PSTATE_CPUFREQ: return power_pstate_cpufreq_init(lcore_id); + case PM_ENV_CPPC_CPUFREQ: + return power_cppc_cpufreq_init(lcore_id); default: RTE_LOG(INFO, POWER, "Env isn't set yet!\n"); } @@ -172,6 +189,13 @@ rte_power_init(unsigned int lcore_id) goto out; } + RTE_LOG(INFO, POWER, "Attempting to initialise CPPC power management...\n"); + ret = power_cppc_cpufreq_init(lcore_id); + if (ret == 0) { + rte_power_set_env(PM_ENV_CPPC_CPUFREQ); + goto out; + } + RTE_LOG(INFO, POWER, "Attempting to initialise VM power management...\n"); ret = power_kvm_vm_init(lcore_id); if (ret == 0) { @@ -194,6 +218,8 @@ rte_power_exit(unsigned int lcore_id) return power_kvm_vm_exit(lcore_id); case PM_ENV_PSTATE_CPUFREQ: return power_pstate_cpufreq_exit(lcore_id); + case PM_ENV_CPPC_CPUFREQ: + return power_cppc_cpufreq_exit(lcore_id); default: RTE_LOG(ERR, POWER, "Environment has not been set, unable to exit gracefully\n"); diff --git a/lib/power/rte_power.h b/lib/power/rte_power.h index c8086bf6b..c5759afa3 100644 --- a/lib/power/rte_power.h +++ b/lib/power/rte_power.h @@ -22,7 +22,7 @@ extern "C" { /* Power Management Environment State */ enum power_management_env {PM_ENV_NOT_SET, PM_ENV_ACPI_CPUFREQ, PM_ENV_KVM_VM, - PM_ENV_PSTATE_CPUFREQ}; + PM_ENV_PSTATE_CPUFREQ, PM_ENV_CPPC_CPUFREQ}; /** * @warning From patchwork Wed May 12 03:49:46 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richael Zhuang X-Patchwork-Id: 93178 Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 68EFBA0C3F; Wed, 12 May 2021 05:50:18 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 935CD410FE; Wed, 12 May 2021 05:50:14 +0200 (CEST) Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by mails.dpdk.org (Postfix) with ESMTP id 58B49410DE; Wed, 12 May 2021 05:50:13 +0200 (CEST) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id D091931B; Tue, 11 May 2021 20:50:12 -0700 (PDT) Received: from wls-arm-cavium06.shanghai.arm.com (wls-arm-cavium06.shanghai.arm.com [10.169.206.120]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 07A553F73B; Tue, 11 May 2021 20:50:10 -0700 (PDT) From: Richael Zhuang To: dev@dpdk.org Cc: anatoly.burakov@intel.com, richael.zhuangw@intel.com, stable@dpdk.org, David Hunt Date: Wed, 12 May 2021 11:49:46 +0800 Message-Id: <20210512034946.37550-3-richael.zhuang@arm.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210512034946.37550-1-richael.zhuang@arm.com> References: <20210422061540.23304-2-richael.zhuang@arm.com> <20210512034946.37550-1-richael.zhuang@arm.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH v2 2/2] test/power: round cpuinfo cur freq only when using CPPC cpufreq X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" On arm platform, the value in "/sys/.../cpuinfo_cur_freq" may not be exactly the same as what was set when using CPPC cpufreq driver. For other cpufreq driver, no need to round it currently, or else this check will fail with turbo enabled. For example, with acpi_cpufreq, cpuinfo_cur_freq can be 2401000 which is equal to freqs[0].It should not be rounded to 2400000. Fixes: 606a234c6d360 ("test/power: round CPU frequency to check") Cc: richael.zhuangw@intel.com Cc: stable@dpdk.org Signed-off-by: Richael Zhuang --- app/test/test_power_cpufreq.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/app/test/test_power_cpufreq.c b/app/test/test_power_cpufreq.c index 87d07191d..0e195afc9 100644 --- a/app/test/test_power_cpufreq.c +++ b/app/test/test_power_cpufreq.c @@ -53,7 +53,9 @@ check_cur_freq(unsigned lcore_id, uint32_t idx) FILE *f; char fullpath[PATH_MAX]; char buf[BUFSIZ]; + enum power_management_env env; uint32_t cur_freq; + uint32_t freq_conv; int ret = -1; int i; @@ -71,15 +73,18 @@ check_cur_freq(unsigned lcore_id, uint32_t idx) goto fail_all; cur_freq = strtoul(buf, NULL, TEST_POWER_CONVERT_TO_DECIMAL); - - /* convert the frequency to nearest 100000 value - * Ex: if cur_freq=1396789 then freq_conv=1400000 - * Ex: if cur_freq=800030 then freq_conv=800000 - */ - unsigned int freq_conv = 0; - freq_conv = (cur_freq + TEST_FREQ_ROUNDING_DELTA) - / TEST_ROUND_FREQ_TO_N_100000; - freq_conv = freq_conv * TEST_ROUND_FREQ_TO_N_100000; + freq_conv = cur_freq; + + env = rte_power_get_env(); + if (env == PM_ENV_CPPC_CPUFREQ) { + /* convert the frequency to nearest 100000 value + * Ex: if cur_freq=1396789 then freq_conv=1400000 + * Ex: if cur_freq=800030 then freq_conv=800000 + */ + freq_conv = (cur_freq + TEST_FREQ_ROUNDING_DELTA) + / TEST_ROUND_FREQ_TO_N_100000; + freq_conv = freq_conv * TEST_ROUND_FREQ_TO_N_100000; + } ret = (freqs[idx] == freq_conv ? 0 : -1);