From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id A9DB2A0C53; Wed, 3 Nov 2021 15:32:53 +0100 (CET) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 41C64426E1; Wed, 3 Nov 2021 15:32:53 +0100 (CET) Received: from mga18.intel.com (mga18.intel.com [134.134.136.126]) by mails.dpdk.org (Postfix) with ESMTP id 0814A40E5A for ; Wed, 3 Nov 2021 15:32:51 +0100 (CET) X-IronPort-AV: E=McAfee;i="6200,9189,10156"; a="218409805" X-IronPort-AV: E=Sophos;i="5.87,206,1631602800"; d="scan'208";a="218409805" Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga106.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 03 Nov 2021 07:32:50 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.87,206,1631602800"; d="scan'208";a="638941210" Received: from silpixa00399952.ir.intel.com ([10.55.129.13]) by fmsmga001.fm.intel.com with ESMTP; 03 Nov 2021 07:32:49 -0700 From: David Hunt To: dev@dpdk.org Cc: bruce.richardson@intel.com, thomas@monjalon.net, david.marchand@redhat.com, David Hunt Date: Wed, 3 Nov 2021 14:32:28 +0000 Message-Id: <20211103143229.34503-1-david.hunt@intel.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20210923110213.21350-1-david.hunt@intel.com> References: <20210923110213.21350-1-david.hunt@intel.com> Subject: [dpdk-dev] [PATCH v6 1/2] eal: add additional info if core list too long 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" If the user requests to use an lcore above 128 using -l, the eal will exit with "EAL: invalid core list syntax" and very little else useful information. This patch adds some extra information suggesting to use --lcores so that physical cores above RTE_MAX_LCORE (default 128) can be used. This is achieved by using the --lcores option by mapping the logical cores in the application to physical cores. For example, if "-l 12-16,130,132" is used, we see the following additional output on the command line: EAL: lcore 132 >= RTE_MAX_LCORE (128) EAL: lcore 133 >= RTE_MAX_LCORE (128) EAL: to use high physical core ids , please use --lcores to map them to lcore ids below RTE_MAX_LCORE, EAL: e.g. --lcores 0@12,1@13,2@14,3@15,4@16,5@132,6@133 Signed-off-by: David Hunt Acked-by: Bruce Richardson --- changes in v6 * none changes in v5 * removed un-needed index variables * now ensures snprintf ret > 0 before using * removed corelist_copy, not needed. * reverted err: usage to -1, as no free() needed. * added in code to allow duplicates * other code cleanups changes in v4 * tweaked log messages to be a bit clearer about mapping lcores to physical cores. * improved indenting of log messages. * fixed bug in overrunning end of lcore array * switched from strlcpy to strdup because of a clang error changes in v3 * separated out some of the corelist cheking into separate function * added extra messages for the different failure conditions. * changed allocation of the core strings from static to dynamic * now prints out a message for each core above RTE_MAX_LCORE changes in v2 * Rather than increasing the default max lcores (as in v1), it was agreed to do this instead (switch to --lcores). * As the other patches in the v1 of the set are no longer related to this change, I'll submit as a separate patch set. --- lib/eal/common/eal_common_options.c | 87 ++++++++++++++++++++++++++--- 1 file changed, 79 insertions(+), 8 deletions(-) diff --git a/lib/eal/common/eal_common_options.c b/lib/eal/common/eal_common_options.c index 1802e3d9e1..c35798b288 100644 --- a/lib/eal/common/eal_common_options.c +++ b/lib/eal/common/eal_common_options.c @@ -703,6 +703,50 @@ update_lcore_config(int *cores) return ret; } +static int +check_core_list(int *lcores, unsigned int count) +{ + unsigned int i; + char *lcorestr; + int len = 0, ret; + bool overflow = false; + + for (i = 0; i < count; i++) { + if (lcores[i] >= RTE_MAX_LCORE) { + RTE_LOG(ERR, EAL, "lcore %d >= RTE_MAX_LCORE (%d)\n", + lcores[i], RTE_MAX_LCORE); + overflow = true; + } + } + if (!overflow) + return 0; + + /* + * We've encountered a core that's greater than + * RTE_MAX_LCORE, suggest using --lcores option to + * map lcores onto physical cores greater than + * RTE_MAX_LCORE, then return. + */ + lcorestr = calloc(1, RTE_MAX_LCORE * 10); + if (lcorestr == NULL) { + RTE_LOG(ERR, EAL, "Unable to allocate lcore string\n"); + return -ENOMEM; + } + for (i = 0; i < count; i++) { + ret = snprintf(&lcorestr[len], + RTE_MAX_LCORE * 10 - len, + "%d@%d,", i, lcores[i]); + if (ret > 0) + len = len + ret; + } + if (len > 0) + lcorestr[len - 1] = 0; + RTE_LOG(ERR, EAL, "to use high physical core ids , please use --lcores to map them to lcore ids below RTE_MAX_LCORE,\n"); + RTE_LOG(ERR, EAL, " e.g. --lcores %s\n", lcorestr); + free(lcorestr); + return -1; +} + static int eal_parse_coremask(const char *coremask, int *cores) { @@ -833,10 +877,12 @@ eal_parse_service_corelist(const char *corelist) static int eal_parse_corelist(const char *corelist, int *cores) { - unsigned count = 0; + unsigned int count = 0, i; char *end = NULL; int min, max; int idx; + int lcores[RTE_MAX_LCORE]; + bool dup; for (idx = 0; idx < RTE_MAX_LCORE; idx++) cores[idx] = -1; @@ -846,7 +892,7 @@ eal_parse_corelist(const char *corelist, int *cores) corelist++; /* Get list of cores */ - min = RTE_MAX_LCORE; + min = -1; do { while (isblank(*corelist)) corelist++; @@ -856,7 +902,7 @@ eal_parse_corelist(const char *corelist, int *cores) idx = strtol(corelist, &end, 10); if (errno || end == NULL) return -1; - if (idx < 0 || idx >= RTE_MAX_LCORE) + if (idx < 0) return -1; while (isblank(*end)) end++; @@ -864,15 +910,25 @@ eal_parse_corelist(const char *corelist, int *cores) min = idx; } else if ((*end == ',') || (*end == '\0')) { max = idx; - if (min == RTE_MAX_LCORE) + if (min == -1) min = idx; for (idx = min; idx <= max; idx++) { - if (cores[idx] == -1) { - cores[idx] = count; - count++; + dup = false; + /* Check if this idx is already present */ + for (i = 0; i < count; i++) + if (lcores[i] == idx) + dup = true; + if (dup) + continue; + if (count < RTE_MAX_LCORE) + lcores[count++] = idx; + else { + RTE_LOG(ERR, EAL, "Too many lcores provided. Cannot exceed %d\n", + RTE_MAX_LCORE); + return -1; } } - min = RTE_MAX_LCORE; + min = -1; } else return -1; corelist = end + 1; @@ -880,6 +936,21 @@ eal_parse_corelist(const char *corelist, int *cores) if (count == 0) return -1; + + if (check_core_list(lcores, count)) + return -1; + + /* + * Now that we've got a list of cores no longer than + * RTE_MAX_LCORE, and no lcore in that list is greater + * than RTE_MAX_LCORE, populate the cores + * array and return. + */ + do { + count--; + cores[lcores[count]] = count; + } while (count != 0); + return 0; } -- 2.17.1