[v5,1/2] eal: add additional info if core list too long
Checks
Commit Message
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 <david.hunt@intel.com>
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
---
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.
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 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 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
---
---
lib/eal/common/eal_common_options.c | 87 ++++++++++++++++++++++++++---
1 file changed, 79 insertions(+), 8 deletions(-)
@@ -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;
}