From patchwork Tue May 24 13:14:04 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kevin Laatz X-Patchwork-Id: 111729 X-Patchwork-Delegate: thomas@monjalon.net 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 3CD82A04FF; Tue, 24 May 2022 15:12:51 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 0BA1E42670; Tue, 24 May 2022 15:12:46 +0200 (CEST) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by mails.dpdk.org (Postfix) with ESMTP id 9E6D6400D6 for ; Tue, 24 May 2022 15:12:43 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1653397963; x=1684933963; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=5Anu1TcP7hsZPZoiOmjRUC81Hh3H7VHq8kYOQ0Tin1Y=; b=mkgWvltG9kQk2MtzM3mSbWYIo/eShYvSmiKw4jdsNxZrtxYaeOPBXu9i TdmAYsGZ1kjPFVdYgq6iVfzxmLL74rCffF+5qYRRF4JgVJ0UQ3bw0mf8R xTkB7WqlhYHHmLndJM0RRx2/SS0zrpAbXYzgg/0IMUIwayv7YgfbrPWGv acyhCQ4SHuamTHhsdnaP/TbCtJm+4nWZomNLNH2Jz+FBbnxkMsDDOewMs Z9OGXqwEBLemFmuel84KccxtdeUgPtbMeTPDSvTnDTUuG2VirSq47XK9Y 1x7Zc94+woCSkS2ndoX3tXfmNSDyfMl0Efck3jZrYIqoEkeIF7/tpUyds g==; X-IronPort-AV: E=McAfee;i="6400,9594,10356"; a="271099170" X-IronPort-AV: E=Sophos;i="5.91,248,1647327600"; d="scan'208";a="271099170" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 24 May 2022 06:12:43 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.91,248,1647327600"; d="scan'208";a="703463253" Received: from silpixa00401122.ir.intel.com ([10.237.213.29]) by orsmga004.jf.intel.com with ESMTP; 24 May 2022 06:12:41 -0700 From: Kevin Laatz To: dev@dpdk.org Cc: anatoly.burakov@intel.com, Kevin Laatz , Ray Kinsella , David Hunt Subject: [PATCH v4 1/4] lib/power: add get and set API for emptypoll max Date: Tue, 24 May 2022 14:14:04 +0100 Message-Id: <20220524131407.423609-2-kevin.laatz@intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20220524131407.423609-1-kevin.laatz@intel.com> References: <20220408140847.1319312-1-kevin.laatz@intel.com> <20220524131407.423609-1-kevin.laatz@intel.com> MIME-Version: 1.0 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 Add new get/set APIs to configure emptypoll max which is used to determine when a queue can go into sleep state. Signed-off-by: Kevin Laatz Acked-by: Ray Kinsella Tested-by: David Hunt --- lib/power/rte_power_pmd_mgmt.c | 21 ++++++++++++++++++--- lib/power/rte_power_pmd_mgmt.h | 27 +++++++++++++++++++++++++++ lib/power/version.map | 4 ++++ 3 files changed, 49 insertions(+), 3 deletions(-) diff --git a/lib/power/rte_power_pmd_mgmt.c b/lib/power/rte_power_pmd_mgmt.c index 39a2b4cd23..dfb7ca9187 100644 --- a/lib/power/rte_power_pmd_mgmt.c +++ b/lib/power/rte_power_pmd_mgmt.c @@ -11,7 +11,7 @@ #include "rte_power_pmd_mgmt.h" -#define EMPTYPOLL_MAX 512 +unsigned int emptypoll_max; /* store some internal state */ static struct pmd_conf_data { @@ -206,7 +206,7 @@ queue_can_sleep(struct pmd_core_cfg *cfg, struct queue_list_entry *qcfg) qcfg->n_empty_polls++; /* if we haven't reached threshold for empty polls, we can't sleep */ - if (qcfg->n_empty_polls <= EMPTYPOLL_MAX) + if (qcfg->n_empty_polls <= emptypoll_max) return false; /* @@ -290,7 +290,7 @@ clb_umwait(uint16_t port_id, uint16_t qidx, struct rte_mbuf **pkts __rte_unused, /* this callback can't do more than one queue, omit multiqueue logic */ if (unlikely(nb_rx == 0)) { queue_conf->n_empty_polls++; - if (unlikely(queue_conf->n_empty_polls > EMPTYPOLL_MAX)) { + if (unlikely(queue_conf->n_empty_polls > emptypoll_max)) { struct rte_power_monitor_cond pmc; int ret; @@ -661,6 +661,18 @@ rte_power_ethdev_pmgmt_queue_disable(unsigned int lcore_id, return 0; } +void +rte_power_pmd_mgmt_set_emptypoll_max(unsigned int max) +{ + emptypoll_max = max; +} + +unsigned int +rte_power_pmd_mgmt_get_emptypoll_max(void) +{ + return emptypoll_max; +} + RTE_INIT(rte_power_ethdev_pmgmt_init) { size_t i; @@ -669,4 +681,7 @@ RTE_INIT(rte_power_ethdev_pmgmt_init) { struct pmd_core_cfg *cfg = &lcore_cfgs[i]; TAILQ_INIT(&cfg->head); } + + /* initialize config defaults */ + emptypoll_max = 512; } diff --git a/lib/power/rte_power_pmd_mgmt.h b/lib/power/rte_power_pmd_mgmt.h index 444e7b8a66..d5a94f8187 100644 --- a/lib/power/rte_power_pmd_mgmt.h +++ b/lib/power/rte_power_pmd_mgmt.h @@ -90,6 +90,33 @@ int rte_power_ethdev_pmgmt_queue_disable(unsigned int lcore_id, uint16_t port_id, uint16_t queue_id); +/** + * @warning + * @b EXPERIMENTAL: this API may change, or be removed, without prior notice. + * + * Set a emptypoll_max to specified value. Used to specify the number of empty + * polls to wait before entering sleep state. + * + * @param max + * The value to set emptypoll_max to. + */ +__rte_experimental +void +rte_power_pmd_mgmt_set_emptypoll_max(unsigned int max); + +/** + * @warning + * @b EXPERIMENTAL: this API may change, or be removed, without prior notice. + * + * Get the current value of emptypoll_max. + * + * @return + * The current emptypoll_max value + */ +__rte_experimental +unsigned int +rte_power_pmd_mgmt_get_emptypoll_max(void); + #ifdef __cplusplus } #endif diff --git a/lib/power/version.map b/lib/power/version.map index 6ec6d5d96d..812843c3f3 100644 --- a/lib/power/version.map +++ b/lib/power/version.map @@ -38,4 +38,8 @@ EXPERIMENTAL { # added in 21.02 rte_power_ethdev_pmgmt_queue_disable; rte_power_ethdev_pmgmt_queue_enable; + + # added in 22.07 + rte_power_pmd_mgmt_get_emptypoll_max; + rte_power_pmd_mgmt_set_emptypoll_max; }; From patchwork Tue May 24 13:14:05 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kevin Laatz X-Patchwork-Id: 111730 X-Patchwork-Delegate: thomas@monjalon.net 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 C5C70A04FF; Tue, 24 May 2022 15:12:57 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id E27964280C; Tue, 24 May 2022 15:12:46 +0200 (CEST) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by mails.dpdk.org (Postfix) with ESMTP id 533514067B for ; Tue, 24 May 2022 15:12:45 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1653397965; x=1684933965; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=4q1RF1lcJ6Q/+9hfrrDpTDZNzPpFl+l/1alZh2xyaxc=; b=QoL8vd8C3g6dG/n8dJMNfctJsEOIDuWFje5Iutm0lGUuMkyyiEQT8yTn CpfmJBvXQKLX/fX1QCelptaIqwQoPPlBIDi+q+C5OP5YBzHA8gwyrzvLc kl5V0+deAfL1XNl4SmSKgkS4/hVLl3ClpmkG5YHzXRFX856k32ZG6NKTu AmCzGtd5qRQsVbhsxnWAfAhbdde4slBrk3mG14+SCniRaXTgKPY0UJiI8 /WCPOpcnuzkVGpvlK9VxXvhw0GvENmKC8ERdRo6yzHjPLvSqCWt4SQz4R 8P+L1zq/oXAzfK8qFfflz8VrEMujOyeyeoDg50xVZVF7smEkCfeAfY3s5 A==; X-IronPort-AV: E=McAfee;i="6400,9594,10356"; a="271099177" X-IronPort-AV: E=Sophos;i="5.91,248,1647327600"; d="scan'208";a="271099177" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 24 May 2022 06:12:44 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.91,248,1647327600"; d="scan'208";a="703463262" Received: from silpixa00401122.ir.intel.com ([10.237.213.29]) by orsmga004.jf.intel.com with ESMTP; 24 May 2022 06:12:43 -0700 From: Kevin Laatz To: dev@dpdk.org Cc: anatoly.burakov@intel.com, Kevin Laatz , Ray Kinsella , David Hunt Subject: [PATCH v4 2/4] lib/power: add get and set API for pause duration Date: Tue, 24 May 2022 14:14:05 +0100 Message-Id: <20220524131407.423609-3-kevin.laatz@intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20220524131407.423609-1-kevin.laatz@intel.com> References: <20220408140847.1319312-1-kevin.laatz@intel.com> <20220524131407.423609-1-kevin.laatz@intel.com> MIME-Version: 1.0 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 Add new get/set API for configuring 'pause_duration' which used to adjust the pause mode callback duration. Signed-off-by: Kevin Laatz Acked-by: Ray Kinsella Acked-by: Anatoly Burakov Tested-by: David Hunt --- v3: changed printf to RTE_LOG --- lib/power/rte_power_pmd_mgmt.c | 25 +++++++++++++++++++++++-- lib/power/rte_power_pmd_mgmt.h | 31 +++++++++++++++++++++++++++++++ lib/power/version.map | 2 ++ 3 files changed, 56 insertions(+), 2 deletions(-) diff --git a/lib/power/rte_power_pmd_mgmt.c b/lib/power/rte_power_pmd_mgmt.c index dfb7ca9187..1374cc213d 100644 --- a/lib/power/rte_power_pmd_mgmt.c +++ b/lib/power/rte_power_pmd_mgmt.c @@ -12,6 +12,7 @@ #include "rte_power_pmd_mgmt.h" unsigned int emptypoll_max; +unsigned int pause_duration; /* store some internal state */ static struct pmd_conf_data { @@ -315,6 +316,7 @@ clb_pause(uint16_t port_id __rte_unused, uint16_t qidx __rte_unused, struct queue_list_entry *queue_conf = arg; struct pmd_core_cfg *lcore_conf; const bool empty = nb_rx == 0; + uint32_t pause_duration = rte_power_pmd_mgmt_get_pause_duration(); lcore_conf = &lcore_cfgs[lcore]; @@ -334,11 +336,11 @@ clb_pause(uint16_t port_id __rte_unused, uint16_t qidx __rte_unused, if (global_data.intrinsics_support.power_pause) { const uint64_t cur = rte_rdtsc(); const uint64_t wait_tsc = - cur + global_data.tsc_per_us; + cur + global_data.tsc_per_us * pause_duration; rte_power_pause(wait_tsc); } else { uint64_t i; - for (i = 0; i < global_data.pause_per_us; i++) + for (i = 0; i < global_data.pause_per_us * pause_duration; i++) rte_pause(); } } @@ -673,6 +675,24 @@ rte_power_pmd_mgmt_get_emptypoll_max(void) return emptypoll_max; } +int +rte_power_pmd_mgmt_set_pause_duration(unsigned int duration) +{ + if (duration == 0) { + RTE_LOG(ERR, POWER, "Pause duration must be greater than 0, value unchanged"); + return -EINVAL; + } + pause_duration = duration; + + return 0; +} + +unsigned int +rte_power_pmd_mgmt_get_pause_duration(void) +{ + return pause_duration; +} + RTE_INIT(rte_power_ethdev_pmgmt_init) { size_t i; @@ -684,4 +704,5 @@ RTE_INIT(rte_power_ethdev_pmgmt_init) { /* initialize config defaults */ emptypoll_max = 512; + pause_duration = 1; } diff --git a/lib/power/rte_power_pmd_mgmt.h b/lib/power/rte_power_pmd_mgmt.h index d5a94f8187..18a9c3abb5 100644 --- a/lib/power/rte_power_pmd_mgmt.h +++ b/lib/power/rte_power_pmd_mgmt.h @@ -117,6 +117,37 @@ __rte_experimental unsigned int rte_power_pmd_mgmt_get_emptypoll_max(void); +/** + * @warning + * @b EXPERIMENTAL: this API may change, or be removed, without prior notice. + * + * Set the pause_duration. Used to adjust the pause mode callback duration. + * + * @note Duration must be greater than zero. + * + * @param duration + * The value to set pause_duration to. + * @return + * 0 on success + * <0 on error + */ +__rte_experimental +int +rte_power_pmd_mgmt_set_pause_duration(unsigned int duration); + +/** + * @warning + * @b EXPERIMENTAL: this API may change, or be removed, without prior notice. + * + * Get the current value of pause_duration. + * + * @return + * The current pause_duration value. + */ +__rte_experimental +unsigned int +rte_power_pmd_mgmt_get_pause_duration(void); + #ifdef __cplusplus } #endif diff --git a/lib/power/version.map b/lib/power/version.map index 812843c3f3..4673b719f9 100644 --- a/lib/power/version.map +++ b/lib/power/version.map @@ -41,5 +41,7 @@ EXPERIMENTAL { # added in 22.07 rte_power_pmd_mgmt_get_emptypoll_max; + rte_power_pmd_mgmt_get_pause_duration; rte_power_pmd_mgmt_set_emptypoll_max; + rte_power_pmd_mgmt_set_pause_duration; }; From patchwork Tue May 24 13:14:06 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kevin Laatz X-Patchwork-Id: 111731 X-Patchwork-Delegate: thomas@monjalon.net 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 94F4EA04FF; Tue, 24 May 2022 15:13:04 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id DB4354282A; Tue, 24 May 2022 15:12:48 +0200 (CEST) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by mails.dpdk.org (Postfix) with ESMTP id 662F64282A for ; Tue, 24 May 2022 15:12:47 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1653397967; x=1684933967; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=vgPY/sPw04vY8qRIKiRwfVsEEhdcaY2LJp2WYV7ay0Y=; b=S2uXtwt+xkRNrZQhMaMJIieVal70vZBan3Zl7NuBsB352h+X/xJ/8BWl b0cA0FK37bFLw5dep8e4smgN/5qkI4oJAyIWSNe6LmRL1oYP/8k6VeT+d D8wjrVggeh3QdTHOc6petlOVWM533FChPpWCDDvVQ4SGU26+w+Y43mjft gBqJhMkYtCrk0O6S0qZLxKcGZIjhRDgmVOWVdmwughBtBrTDBQVVshwxy pvr/FBXZumHKKfbrfHevmJ7tNxLzrH2ZB2vwSSVmUJSf/swwMyTTR8hAG smf19l050Q7m9JcgQG2k46v+vaD6BdsgLxUaZBnDC8adA3YyIANQyQXcA g==; X-IronPort-AV: E=McAfee;i="6400,9594,10356"; a="271099186" X-IronPort-AV: E=Sophos;i="5.91,248,1647327600"; d="scan'208";a="271099186" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 24 May 2022 06:12:46 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.91,248,1647327600"; d="scan'208";a="703463270" Received: from silpixa00401122.ir.intel.com ([10.237.213.29]) by orsmga004.jf.intel.com with ESMTP; 24 May 2022 06:12:45 -0700 From: Kevin Laatz To: dev@dpdk.org Cc: anatoly.burakov@intel.com, Kevin Laatz , Ray Kinsella , David Hunt Subject: [PATCH v4 3/4] lib/power: add get and set API for scaling freq min and max with pstate mode Date: Tue, 24 May 2022 14:14:06 +0100 Message-Id: <20220524131407.423609-4-kevin.laatz@intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20220524131407.423609-1-kevin.laatz@intel.com> References: <20220408140847.1319312-1-kevin.laatz@intel.com> <20220524131407.423609-1-kevin.laatz@intel.com> MIME-Version: 1.0 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 Add new get/set API to allow the user or application to set the minimum and maximum frequencies to use when scaling. Previously, the frequency range was determined by the HW capabilities of the CPU. With this new API, the user or application can constrain this if required. Signed-off-by: Kevin Laatz Acked-by: Ray Kinsella Acked-by: Anatoly Burakov Tested-by: David Hunt --- v4: * fix mismatch between comments and code * fix return value when max freq is not set v3: * updated doxygen comments * added checks to ensure min/max value is valid * consider 0 as 'not set' for scaling_freq_max --- lib/power/power_pstate_cpufreq.c | 24 ++++++++-- lib/power/rte_power_pmd_mgmt.c | 77 ++++++++++++++++++++++++++++++ lib/power/rte_power_pmd_mgmt.h | 81 ++++++++++++++++++++++++++++++++ lib/power/version.map | 4 ++ 4 files changed, 181 insertions(+), 5 deletions(-) diff --git a/lib/power/power_pstate_cpufreq.c b/lib/power/power_pstate_cpufreq.c index f4c36179ec..78c9197695 100644 --- a/lib/power/power_pstate_cpufreq.c +++ b/lib/power/power_pstate_cpufreq.c @@ -12,6 +12,7 @@ #include +#include "rte_power_pmd_mgmt.h" #include "power_pstate_cpufreq.h" #include "power_common.h" @@ -354,6 +355,7 @@ power_get_available_freqs(struct pstate_power_info *pi) FILE *f_min = NULL, *f_max = NULL; int ret = -1; uint32_t sys_min_freq = 0, sys_max_freq = 0, base_max_freq = 0; + int config_min_freq, config_max_freq; uint32_t i, num_freqs = 0; /* open all files */ @@ -388,6 +390,18 @@ power_get_available_freqs(struct pstate_power_info *pi) goto out; } + /* check for config set by user or application to limit frequency range */ + config_min_freq = rte_power_pmd_mgmt_get_scaling_freq_min(pi->lcore_id); + if (config_min_freq < 0) + goto out; + config_max_freq = rte_power_pmd_mgmt_get_scaling_freq_max(pi->lcore_id); + if (config_max_freq < 0) + goto out; + + sys_min_freq = RTE_MAX(sys_min_freq, (uint32_t)config_min_freq); + if (config_max_freq > 0) /* Only use config_max_freq if a value has been set */ + sys_max_freq = RTE_MIN(sys_max_freq, (uint32_t)config_max_freq); + if (sys_max_freq < sys_min_freq) goto out; @@ -411,8 +425,8 @@ power_get_available_freqs(struct pstate_power_info *pi) /* If turbo is available then there is one extra freq bucket * to store the sys max freq which value is base_max +1 */ - num_freqs = (base_max_freq - sys_min_freq) / BUS_FREQ + 1 + - pi->turbo_available; + num_freqs = (RTE_MIN(base_max_freq, sys_max_freq) - sys_min_freq) / BUS_FREQ + + 1 + pi->turbo_available; if (num_freqs >= RTE_MAX_LCORE_FREQS) { RTE_LOG(ERR, POWER, "Too many available frequencies: %d\n", num_freqs); @@ -427,10 +441,10 @@ power_get_available_freqs(struct pstate_power_info *pi) */ for (i = 0, pi->nb_freqs = 0; i < num_freqs; i++) { if ((i == 0) && pi->turbo_available) - pi->freqs[pi->nb_freqs++] = base_max_freq + 1; + pi->freqs[pi->nb_freqs++] = RTE_MIN(base_max_freq, sys_max_freq) + 1; else - pi->freqs[pi->nb_freqs++] = - base_max_freq - (i - pi->turbo_available) * BUS_FREQ; + pi->freqs[pi->nb_freqs++] = RTE_MIN(base_max_freq, sys_max_freq) - + (i - pi->turbo_available) * BUS_FREQ; } ret = 0; diff --git a/lib/power/rte_power_pmd_mgmt.c b/lib/power/rte_power_pmd_mgmt.c index 1374cc213d..a66e08e574 100644 --- a/lib/power/rte_power_pmd_mgmt.c +++ b/lib/power/rte_power_pmd_mgmt.c @@ -10,9 +10,12 @@ #include #include "rte_power_pmd_mgmt.h" +#include "power_common.h" unsigned int emptypoll_max; unsigned int pause_duration; +unsigned int scale_freq_min[RTE_MAX_LCORE]; +unsigned int scale_freq_max[RTE_MAX_LCORE]; /* store some internal state */ static struct pmd_conf_data { @@ -693,8 +696,77 @@ rte_power_pmd_mgmt_get_pause_duration(void) return pause_duration; } +int +rte_power_pmd_mgmt_set_scaling_freq_min(unsigned int lcore, unsigned int min) +{ + if (lcore >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID: %u\n", lcore); + return -EINVAL; + } + + if (min > scale_freq_max[lcore]) { + RTE_LOG(ERR, POWER, "Invalid min frequency: Cannot be greater than max frequency"); + return -EINVAL; + } + scale_freq_min[lcore] = min; + + return 0; +} + +int +rte_power_pmd_mgmt_set_scaling_freq_max(unsigned int lcore, unsigned int max) +{ + if (lcore >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID: %u\n", lcore); + return -EINVAL; + } + + /* Zero means 'not set'. Use UINT32_MAX to enable RTE_MIN/MAX macro use when scaling. */ + if (max == 0) + max = UINT32_MAX; + if (max < scale_freq_min[lcore]) { + RTE_LOG(ERR, POWER, "Invalid max frequency: Cannot be less than min frequency"); + return -EINVAL; + } + + scale_freq_max[lcore] = max; + + return 0; +} + +int +rte_power_pmd_mgmt_get_scaling_freq_min(unsigned int lcore) +{ + if (lcore >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID: %u\n", lcore); + return -EINVAL; + } + + if (scale_freq_max[lcore] == 0) + RTE_LOG(DEBUG, POWER, "Scaling freq min config not set. Using sysfs min freq.\n"); + + return scale_freq_min[lcore]; +} + +int +rte_power_pmd_mgmt_get_scaling_freq_max(unsigned int lcore) +{ + if (lcore >= RTE_MAX_LCORE) { + RTE_LOG(ERR, POWER, "Invalid lcore ID: %u\n", lcore); + return -EINVAL; + } + + if (scale_freq_max[lcore] == UINT32_MAX) { + RTE_LOG(DEBUG, POWER, "Scaling freq max config not set. Using sysfs max freq.\n"); + return 0; + } + + return scale_freq_max[lcore]; +} + RTE_INIT(rte_power_ethdev_pmgmt_init) { size_t i; + int j; /* initialize all tailqs */ for (i = 0; i < RTE_DIM(lcore_cfgs); i++) { @@ -705,4 +777,9 @@ RTE_INIT(rte_power_ethdev_pmgmt_init) { /* initialize config defaults */ emptypoll_max = 512; pause_duration = 1; + /* scaling defaults out of range to ensure not used unless set by user or app */ + for (j = 0; j < RTE_MAX_LCORE; j++) { + scale_freq_min[j] = 0; + scale_freq_max[j] = UINT32_MAX; + } } diff --git a/lib/power/rte_power_pmd_mgmt.h b/lib/power/rte_power_pmd_mgmt.h index 18a9c3abb5..789fbe0e4d 100644 --- a/lib/power/rte_power_pmd_mgmt.h +++ b/lib/power/rte_power_pmd_mgmt.h @@ -148,6 +148,87 @@ __rte_experimental unsigned int rte_power_pmd_mgmt_get_pause_duration(void); +/** + * @warning + * @b EXPERIMENTAL: this API may change, or be removed, without prior notice. + * + * Set the min frequency to be used for frequency scaling or zero to use defaults. + * + * @note Supported by: Pstate mode. + * + * @param lcore + * The ID of the lcore to set the min frequency for. + * @param min + * The value, in KiloHertz, to set the minimum frequency to. + * @return + * 0 on success + * <0 on error + */ +__rte_experimental +int +rte_power_pmd_mgmt_set_scaling_freq_min(unsigned int lcore, unsigned int min); + +/** + * @warning + * @b EXPERIMENTAL: this API may change, or be removed, without prior notice. + * + * Set the max frequency to be used for frequency scaling or zero to use defaults. + * + * @note Supported by: Pstate mode. + * + * @param lcore + * The ID of the lcore to set the max frequency for. + * @param max + * The value, in KiloHertz, to set the maximum frequency to. + * If 'max' is 0, it is considered 'not set'. + * @return + * 0 on success + * <0 on error + */ +__rte_experimental +int +rte_power_pmd_mgmt_set_scaling_freq_max(unsigned int lcore, unsigned int max); + +/** + * @warning + * @b EXPERIMENTAL: this API may change, or be removed, without prior notice. + * + * Get the current configured min frequency used for frequency scaling. + * + * @note Supported by: Pstate mode. + * + * @param lcore + * The ID of the lcore to get the min frequency for. + * @return + * 0 if no value has been configured via the 'set' API. + * >0 if a minimum frequency has been configured. Value is the minimum frequency + * , in KiloHertz, used for frequency scaling. + * <0 on error + */ +__rte_experimental +int +rte_power_pmd_mgmt_get_scaling_freq_min(unsigned int lcore); + +/** + * @warning + * @b EXPERIMENTAL: this API may change, or be removed, without prior notice. + * + * Get the current configured max frequency used for frequency scaling. + * + * @note Supported by: Pstate mode. + * + * @param lcore + * The ID of the lcore to get the max frequency for. + * @return + * 0 if no value has been configured via the 'set' API. + * >0 if a maximum frequency has been configured. Value is the maximum frequency + * , in KiloHertz, used for frequency scaling. + * <0 on error + */ +__rte_experimental +int +rte_power_pmd_mgmt_get_scaling_freq_max(unsigned int lcore); + #ifdef __cplusplus } #endif diff --git a/lib/power/version.map b/lib/power/version.map index 4673b719f9..a687754f4a 100644 --- a/lib/power/version.map +++ b/lib/power/version.map @@ -42,6 +42,10 @@ EXPERIMENTAL { # added in 22.07 rte_power_pmd_mgmt_get_emptypoll_max; rte_power_pmd_mgmt_get_pause_duration; + rte_power_pmd_mgmt_get_scaling_freq_max; + rte_power_pmd_mgmt_get_scaling_freq_min; rte_power_pmd_mgmt_set_emptypoll_max; rte_power_pmd_mgmt_set_pause_duration; + rte_power_pmd_mgmt_set_scaling_freq_max; + rte_power_pmd_mgmt_set_scaling_freq_min; }; From patchwork Tue May 24 13:14:07 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kevin Laatz X-Patchwork-Id: 111732 X-Patchwork-Delegate: thomas@monjalon.net 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 44BC6A04FF; Tue, 24 May 2022 15:13:11 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id E2AF74067B; Tue, 24 May 2022 15:12:52 +0200 (CEST) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by mails.dpdk.org (Postfix) with ESMTP id 0977242B71 for ; Tue, 24 May 2022 15:12:48 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1653397969; x=1684933969; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=dblxa/2JIv/IiVTk7AtqM3mL+LxAQDGKFOfns2z535E=; b=a2jK7H+DmiLe1jnOD8wLiwuafGdu9dbABaxKXiFE5hPmBiHHcAVv9i2P ymaRa2BjYmWcd2AVWBD8SNDOEExAy2cT/h9IXcslRTppX6tDd4rswe/Vg Wtcq3iyc7mBsR1jL9aIvBnx6bDq1u14++TCIdz1FzrJ6+0TtlCLSQvScT TO6p/4kOySuqWLuXsCPW75W1T5ZYG/vVguRBFbA9+s5FQfcX38JDefk0c 4pAHJ98ulWtg2/8MONkFdHcgqU5UHVKknrGRl9TD2sqNYdg7Y+c1BPIyk s7hpyDmTwJgED4Ec3MlzkxLgDSeJpkSzGSXVCJX9EzfQliPO8hgCiaQlu g==; X-IronPort-AV: E=McAfee;i="6400,9594,10356"; a="271099190" X-IronPort-AV: E=Sophos;i="5.91,248,1647327600"; d="scan'208";a="271099190" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 24 May 2022 06:12:48 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.91,248,1647327600"; d="scan'208";a="703463275" Received: from silpixa00401122.ir.intel.com ([10.237.213.29]) by orsmga004.jf.intel.com with ESMTP; 24 May 2022 06:12:47 -0700 From: Kevin Laatz To: dev@dpdk.org Cc: anatoly.burakov@intel.com, Kevin Laatz , David Hunt Subject: [PATCH v4 4/4] examples/l3fwd_power: add cli for configurable options Date: Tue, 24 May 2022 14:14:07 +0100 Message-Id: <20220524131407.423609-5-kevin.laatz@intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20220524131407.423609-1-kevin.laatz@intel.com> References: <20220408140847.1319312-1-kevin.laatz@intel.com> <20220524131407.423609-1-kevin.laatz@intel.com> MIME-Version: 1.0 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 Add CLI options to l3fwd_power to utilize the new power APIs introduced in this patchset. These CLI options allow the user to configure the heuritstics made available through the new API via the l3fwd_power application options. Signed-off-by: Kevin Laatz Acked-by: Anatoly Burakov Tested-by: David Hunt --- v3: move setters out of arg parsing v2: add doc update for l3fwd-power --- .../sample_app_ug/l3_forward_power_man.rst | 8 ++ examples/l3fwd-power/main.c | 86 ++++++++++++++++++- 2 files changed, 93 insertions(+), 1 deletion(-) diff --git a/doc/guides/sample_app_ug/l3_forward_power_man.rst b/doc/guides/sample_app_ug/l3_forward_power_man.rst index 2e350c45f1..8f6d906200 100644 --- a/doc/guides/sample_app_ug/l3_forward_power_man.rst +++ b/doc/guides/sample_app_ug/l3_forward_power_man.rst @@ -109,6 +109,14 @@ where, * --pmd-mgmt: PMD power management mode. +* --max-empty-polls : Number of empty polls to wait before entering sleep state. Applies to --pmd-mgmt mode only. + +* --pause-duration: Set the duration of the pause callback (microseconds). Applies to --pmd-mgmt mode only. + +* --scale-freq-min: Set minimum frequency for scaling. Applies to --pmd-mgmt mode only. + +* --scale-freq-max: Set maximum frequency for scaling. Applies to --pmd-mgmt mode only. + See :doc:`l3_forward` for details. The L3fwd-power example reuses the L3fwd command line options. diff --git a/examples/l3fwd-power/main.c b/examples/l3fwd-power/main.c index 20e5b59af9..887c6eae3f 100644 --- a/examples/l3fwd-power/main.c +++ b/examples/l3fwd-power/main.c @@ -265,6 +265,10 @@ static struct rte_eth_conf port_conf = { }; static uint32_t max_pkt_len; +static uint32_t max_empty_polls = 512; +static uint32_t pause_duration = 1; +static uint32_t scale_freq_min; +static uint32_t scale_freq_max; static struct rte_mempool * pktmbuf_pool[NB_SOCKETS]; @@ -1626,10 +1630,32 @@ print_usage(const char *prgname) " empty polls, full polls, and core busyness to telemetry\n" " --interrupt-only: enable interrupt-only mode\n" " --pmd-mgmt MODE: enable PMD power management mode. " - "Currently supported modes: baseline, monitor, pause, scale\n", + "Currently supported modes: baseline, monitor, pause, scale\n" + " --max-empty-polls MAX_EMPTY_POLLS: number of empty polls to" + " wait before entering sleep state\n" + " --pause-duration DURATION: set the duration, in microseconds," + " of the pause callback\n" + " --scale-freq-min FREQ_MIN: set minimum frequency for scaling mode for" + " all application lcores (FREQ_MIN must be in kHz, in increments of 100MHz)\n" + " --scale-freq-max FREQ_MAX: set maximum frequency for scaling mode for" + " all application lcores (FREQ_MAX must be in kHz, in increments of 100MHz)\n", prgname); } +static int +parse_int(const char *opt) +{ + char *end = NULL; + unsigned long val; + + /* parse integer string */ + val = strtoul(opt, &end, 10); + if ((opt[0] == '\0') || (end == NULL) || (*end != '\0')) + return -1; + + return val; +} + static int parse_max_pkt_len(const char *pktlen) { char *end = NULL; @@ -1803,6 +1829,10 @@ parse_ep_config(const char *q_arg) #define CMD_LINE_OPT_TELEMETRY "telemetry" #define CMD_LINE_OPT_PMD_MGMT "pmd-mgmt" #define CMD_LINE_OPT_MAX_PKT_LEN "max-pkt-len" +#define CMD_LINE_OPT_MAX_EMPTY_POLLS "max-empty-polls" +#define CMD_LINE_OPT_PAUSE_DURATION "pause-duration" +#define CMD_LINE_OPT_SCALE_FREQ_MIN "scale-freq-min" +#define CMD_LINE_OPT_SCALE_FREQ_MAX "scale-freq-max" /* Parse the argument given in the command line of the application */ static int @@ -1825,6 +1855,10 @@ parse_args(int argc, char **argv) {CMD_LINE_OPT_TELEMETRY, 0, 0, 0}, {CMD_LINE_OPT_INTERRUPT_ONLY, 0, 0, 0}, {CMD_LINE_OPT_PMD_MGMT, 1, 0, 0}, + {CMD_LINE_OPT_MAX_EMPTY_POLLS, 1, 0, 0}, + {CMD_LINE_OPT_PAUSE_DURATION, 1, 0, 0}, + {CMD_LINE_OPT_SCALE_FREQ_MIN, 1, 0, 0}, + {CMD_LINE_OPT_SCALE_FREQ_MAX, 1, 0, 0}, {NULL, 0, 0, 0} }; @@ -1975,6 +2009,34 @@ parse_args(int argc, char **argv) parse_ptype = 1; } + if (!strncmp(lgopts[option_index].name, + CMD_LINE_OPT_MAX_EMPTY_POLLS, + sizeof(CMD_LINE_OPT_MAX_EMPTY_POLLS))) { + printf("Maximum empty polls configured\n"); + max_empty_polls = parse_int(optarg); + } + + if (!strncmp(lgopts[option_index].name, + CMD_LINE_OPT_PAUSE_DURATION, + sizeof(CMD_LINE_OPT_PAUSE_DURATION))) { + printf("Pause duration configured\n"); + pause_duration = parse_int(optarg); + } + + if (!strncmp(lgopts[option_index].name, + CMD_LINE_OPT_SCALE_FREQ_MIN, + sizeof(CMD_LINE_OPT_SCALE_FREQ_MIN))) { + printf("Scaling frequency minimum configured\n"); + scale_freq_min = parse_int(optarg); + } + + if (!strncmp(lgopts[option_index].name, + CMD_LINE_OPT_SCALE_FREQ_MAX, + sizeof(CMD_LINE_OPT_SCALE_FREQ_MAX))) { + printf("Scaling frequency maximum configured\n"); + scale_freq_max = parse_int(optarg); + } + break; default: @@ -2801,6 +2863,28 @@ main(int argc, char **argv) } if (app_mode == APP_MODE_PMD_MGMT && !baseline_enabled) { + /* Set power_pmd_mgmt configs passed by user */ + rte_power_pmd_mgmt_set_emptypoll_max(max_empty_polls); + ret = rte_power_pmd_mgmt_set_pause_duration(pause_duration); + if (ret < 0) + rte_exit(EXIT_FAILURE, + "Error setting pause_duration: err=%d, lcore=%d\n", + ret, lcore_id); + + ret = rte_power_pmd_mgmt_set_scaling_freq_min(lcore_id, + scale_freq_min); + if (ret < 0) + rte_exit(EXIT_FAILURE, + "Error setting scaling freq min: err=%d, lcore=%d\n", + ret, lcore_id); + + ret = rte_power_pmd_mgmt_set_scaling_freq_max(lcore_id, + scale_freq_max); + if (ret < 0) + rte_exit(EXIT_FAILURE, + "Error setting scaling freq max: err=%d, lcore %d\n", + ret, lcore_id); + ret = rte_power_ethdev_pmgmt_queue_enable( lcore_id, portid, queueid, pmgmt_type);