add new command line argument parsing library
Subsystems (2)
v3 cover add new command line argument parsing library
A recent thread on the mailing list[1] discussed corelist and coremask parsing and the idea of a new library dedicated to command line parsing was mentioned[2]. This patchset adds the library, along with the new APIs, and edits the existing EAL, DLB2 driver and some example application functions to use these APIs, rather than each implementing their own copies.
The new APIs work similar to the existing functions in EAL, however instead of filling a core array like this:
[1, -1, -1, 2, 3] (a non -1 refers to an 'active core' at that index) It fills it like this:
[0, 3, 4] (with the value at each index being an 'active core').
The new APIs will also return the number of cores contained in the passed corelist/coremask, so in the above example, 3 would be returned.
New in the v3, is a heuristic parser which searches for key markers in the core string, returning a enum value based off this search to indicate if a parameter is likely a coremask or a corelist. This heuristic function is also wrapped in a parser function allowing apps to handle both coremasks and corelists simultaneously.
[1] https://mails.dpdk.org/archives/dev/2023-November/280957.html
[2] https://mails.dpdk.org/archives/dev/2023-November/280966.html
v3:
* new 'combined core string parser' and 'heuristic parser'
* changes to eventdev_pipeline and l3fwd-power example applications
* various struct optimisations in arg_parser.c
* fix for windows build relating to RTE_SWAP()
* minor changes for issues flagged during review
v2:
* changes to EAL service core related parsers to call API.
* various optimisations in core_bit related functions in arg_parser.c.
* add lib to list for windows build.
* minor changes for issues flagged during review.
Euan Bourke (8):
arg_parser: new library for command line parsing
arg_parser: add new coremask parsing API
eal: add support for new arg parsing library
eal: update to service core related parsers event/dlb2: add new arg parsing library API support
arg_parser: added common core string and heuristic parsers examples/eventdev_pipeline: update to call arg parser API examples/l3fwd-power: update to call arg parser API
.mailmap | 1 + MAINTAINERS | 4 + doc/api/doxy-api-index.md | 3 +- doc/api/doxy-api.conf.in | 1 + drivers/event/dlb2/dlb2_priv.h | 4 +- drivers/event/dlb2/pf/base/dlb2_resource.c | 51 ++-- examples/eventdev_pipeline/main.c | 65 +---- examples/eventdev_pipeline/pipeline_common.h | 1 + examples/l3fwd-power/perf_core.c | 51 +--- lib/arg_parser/arg_parser.c | 229 +++++++++++++++ lib/arg_parser/meson.build | 7 + lib/arg_parser/rte_arg_parser.h | 160 +++++++++++ lib/arg_parser/version.map | 13 + lib/eal/common/eal_common_options.c | 285 ++++--------------- lib/eal/meson.build | 2 +- lib/meson.build | 2 + 16 files changed, 513 insertions(+), 366 deletions(-) create mode 100644 lib/arg_parser/arg_parser.c create mode 100644 lib/arg_parser/meson.build create mode 100644 lib/arg_parser/rte_arg_parser.h create mode 100644 lib/arg_parser/version.map
Signature · 1 line
2.34.1
PATCH v3 1/8 arg_parser: new library for command line parsing
Add a new library to make it easier for eal and other libraries to parse command line arguments.
The first function in this library is one to parse a corelist string into an array of individual core ids. The function will then return the total number of cores described in the corelist.
--- .mailmap | 1 + MAINTAINERS | 4 ++ doc/api/doxy-api-index.md | 3 +- doc/api/doxy-api.conf.in | 1 + lib/arg_parser/arg_parser.c | 108 ++++++++++++++++++++++++++++++++ lib/arg_parser/meson.build | 7 +++ lib/arg_parser/rte_arg_parser.h | 66 +++++++++++++++++++ lib/arg_parser/version.map | 10 +++ lib/meson.build | 2 + 9 files changed, 201 insertions(+), 1 deletion(-) create mode 100644 lib/arg_parser/arg_parser.c create mode 100644 lib/arg_parser/meson.build create mode 100644 lib/arg_parser/rte_arg_parser.h create mode 100644 lib/arg_parser/version.map
.mailmap +1 -0
@@ -379,6 +379,7 @@ Eric Zhang <[email protected]> Erik Gabriel Carrillo <[email protected]> Erik Ziegenbalg <[email protected]> Erlu Chen <[email protected]> +Euan Bourke <[email protected]> Eugenio Pérez <[email protected]> Eugeny Parshutin <[email protected]> Evan Swanson <[email protected]>
MAINTAINERS +4 -0
@@ -1756,6 +1756,10 @@ M: Nithin Dabilpuram <[email protected]> M: Pavan Nikhilesh <[email protected]> F: lib/node/ +Argument parsing +M: Bruce Richardson <[email protected]> +F: lib/arg_parser/ + Test Applications -----------------
doc/api/doxy-api-index.md +2 -1
@@ -221,7 +221,8 @@ The public API headers are grouped by topics: [config file](@ref rte_cfgfile.h), [key/value args](@ref rte_kvargs.h), [string](@ref rte_string_fns.h), - [thread](@ref rte_thread.h) + [thread](@ref rte_thread.h), + [argument parsing](@ref rte_arg_parser.h) - **debug**: [jobstats](@ref rte_jobstats.h),
doc/api/doxy-api.conf.in +1 -0
@@ -28,6 +28,7 @@ INPUT = @TOPDIR@/doc/api/doxy-api-index.md \ @TOPDIR@/lib/eal/include \ @TOPDIR@/lib/eal/include/generic \ @TOPDIR@/lib/acl \ + @TOPDIR@/lib/arg_parser \ @TOPDIR@/lib/bbdev \ @TOPDIR@/lib/bitratestats \ @TOPDIR@/lib/bpf \
lib/arg_parser/arg_parser.c new file +108 -0
108 lines not on this page · raw message
lib/arg_parser/meson.build new file +7 -0
@@ -0,0 +1,7 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2023 Intel Corporation + +sources = files('arg_parser.c') +headers = files('rte_arg_parser.h') + +includes += global_inc
lib/arg_parser/rte_arg_parser.h new file +66 -0
66 lines not on this page · raw message
lib/arg_parser/version.map new file +10 -0
@@ -0,0 +1,10 @@ +DPDK_24 { + local: *; +}; + +EXPERIMENTAL { + global: + + # added in 24.03 + rte_arg_parse_corelist; +};
lib/meson.build +2 -0
@@ -11,6 +11,7 @@ libraries = [ 'log', 'kvargs', # eal depends on kvargs + 'arg_parser', 'telemetry', # basic info querying 'eal', # everything depends on eal 'ring',
@@ -72,6 +73,7 @@ if is_ms_compiler 'log', 'kvargs', 'telemetry', + 'arg_parser', ] endif
Signature · 1 line
2.34.1
Re: [PATCH v3 1/8] arg_parser: new library for command line parsing
Quoted 8 lines · Euan Bourke
Add a new library to make it easier for eal and other libraries to parse command line arguments.
The first function in this library is one to parse a corelist string into an array of individual core ids. The function will then return the total number of cores described in the corelist.
Signed-off-by Euan Bourke <[email protected]>
There are other patches outstanding on the list for argument parsing too [1], and we need to reconcile what goes into what libraries with what names! Probably they can all be merged into one, but we need to check.
[1] http://patches.dpdk.org/project/dpdk/list/?series=30439
Some minor comments inline below for any v4.
Quoted 48 lines
--- .mailmap | 1 + MAINTAINERS | 4 ++ doc/api/doxy-api-index.md | 3 +- doc/api/doxy-api.conf.in | 1 + lib/arg_parser/arg_parser.c | 108 ++++++++++++++++++++++++++++++++ lib/arg_parser/meson.build | 7 +++ lib/arg_parser/rte_arg_parser.h | 66 +++++++++++++++++++ lib/arg_parser/version.map | 10 +++ lib/meson.build | 2 + 9 files changed, 201 insertions(+), 1 deletion(-) create mode 100644 lib/arg_parser/arg_parser.c create mode 100644 lib/arg_parser/meson.build create mode 100644 lib/arg_parser/rte_arg_parser.h create mode 100644 lib/arg_parser/version.map.mailmap +1
-0@@ -379,6 +379,7 @@ Eric Zhang <[email protected]> Erik Gabriel Carrillo <[email protected]> Erik Ziegenbalg <[email protected]> Erlu Chen <[email protected]> +Euan Bourke <[email protected]> Eugenio Pérez <[email protected]> Eugeny Parshutin <[email protected]> Evan Swanson <[email protected]>MAINTAINERS +4
-0@@ -1756,6 +1756,10 @@ M: Nithin Dabilpuram <[email protected]> M: Pavan Nikhilesh <[email protected]> F: lib/node/ +Argument parsing +M: Bruce Richardson <[email protected]> +F: lib/arg_parser/ + Test Applications -----------------doc/api/doxy-api-index.md +0
-0
doc/api/doxy-api-index.md The public API headers are grouped by topics: · line 225
Quoted 6 lines
doc/api/doxy-api-index.md +2
-1@@ -221,7 +221,8 @@ The public API headers are grouped by topics: [config file](@ref rte_cfgfile.h), [key/value args](@ref rte_kvargs.h), [string](@ref rte_string_fns.h), - [thread](@ref rte_thread.h) + [thread](@ref rte_thread.h), + [argument parsing](@ref rte_arg_parser.h)
Not sure what order, if any, these elements are in, but I think argument parsing could well be further up the list. It also reduces the diff by one line, since you don't need to append the comma on the end of rte_thread line.
Quoted 106 lines
doc/api/doxy-api-index.md +0
-0- **debug**: [jobstats](@ref rte_jobstats.h),doc/api/doxy-api.conf.in +1
-0@@ -28,6 +28,7 @@ INPUT = @TOPDIR@/doc/api/doxy-api-index.md \ @TOPDIR@/lib/eal/include \ @TOPDIR@/lib/eal/include/generic \ @TOPDIR@/lib/acl \ + @TOPDIR@/lib/arg_parser \ @TOPDIR@/lib/bbdev \ @TOPDIR@/lib/bitratestats \ @TOPDIR@/lib/bpf \lib/arg_parser/arg_parser.c new file +85
-0@@ -0,0 +1,108 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2023 Intel Corporation +*/ + +#include "errno.h" +#include "stdlib.h" +#include "ctype.h" +#include "string.h" +#include "stdbool.h" + +#include <rte_arg_parser.h> +#include <rte_common.h> + + +struct core_bits { +uint8_t bits[(UINT16_MAX +1 ) /CHAR_BIT ]; +uint16_t max_bit_set; +uint16_t min_bit_set; +uint32_t total_bits_set; +}; + +static inline bool +get_core_bit (struct core_bits *mask,uint16_t idx) +{ +return !!(mask->bits[idx /CHAR_BIT ] & (1 << (idx %CHAR_BIT ))); +} + +static inline void +set_core_bit (struct core_bits *mask,uint16_t idx) +{ +if (get_core_bit (mask, idx)) +return ; + + mask->bits[idx /CHAR_BIT ] |=1 << (idx %CHAR_BIT ); +/* Update min and max bit if its first time setting a bit */ +if (++(mask->total_bits_set) ==1 ) { + mask->min_bit_set = idx; + mask->max_bit_set = idx; +return ; + } + +if (idx > mask->max_bit_set) + mask->max_bit_set = idx; + +if (idx < mask->min_bit_set) + mask->min_bit_set = idx; +} + +static inline uint32_t +corebits_to_array (struct core_bits *mask,uint16_t *cores,size_t max_cores) +{ +uint32_t count =0 ; +for (uint32_t i = mask->min_bit_set; i <= mask->max_bit_set && count < max_cores; i++) { +if (get_core_bit (mask, i)) + cores[count++] = i; + } +return mask->total_bits_set; +} + + +int +rte_arg_parse_corelist (const char *corelist,uint16_t *cores,uint32_t cores_len) +{ +struct core_bits mask = {0 }; +int32_t min =-1 ; +char *end =NULL ; + + min =-1 ; + do { + int64_t idx; + int32_t max; + + while (isblank(*corelist)) + corelist++; + if (!isdigit(*corelist)) + return -1; + + errno = 0; + idx = strtol(corelist, &end, 10); + if (errno || end == NULL || idx > UINT16_MAX) + return -1; + while (isblank(*end)) + end++; + if (*end == '-') + min = idx;
lib/arg_parser/arg_parser.c line 95
Quoted 10 lines
lib/arg_parser/arg_parser.c new file +10
-0+ +else if (*end ==',' || *end =='\0' ) { +if (min ==-1 ) + min = max = idx; +else if (min > idx) { + max = min; + min = idx; + }else + max = idx; +
This set of if-else branches could do with a few comments.
The first case, min == -1, is for when we get a bare number without a range, right? The second is when the range is reversed, e.g. 6-3, rather than 3-6, and the last is for normal ranges. A one-line comment in each leg of the condition would make this clearer for anyone editing it in future.
lib/arg_parser/arg_parser.c line 107
Quoted 12 lines
lib/arg_parser/arg_parser.c new file +12
-0+for (; min <= max; min++) +set_core_bit (&mask, min); + + min =-1 ; + }else +return -1 ; + corelist = end +1 ; + }while (*end !='\0' ); + +uint32_t total_count =corebits_to_array (&mask, cores, cores_len); + +return total_count;
Since you no longer have the bitmask on the heap, total_count is unnecessary since there is no "free" call.
You can just do "return corebits_to_array(...)"
Quoted 125 lines
lib/arg_parser/arg_parser.c new file +1
-0+}lib/arg_parser/meson.build new file +7
-0@@ -0,0 +1,7 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2023 Intel Corporation + +sources = files('arg_parser.c') +headers = files('rte_arg_parser.h') + +includes += global_inclib/arg_parser/rte_arg_parser.h new file +66
-0@@ -0,0 +1,66 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2023 Intel Corporation +*/ + +#ifndef _RTE_ARG_PARSER_H_ +#define _RTE_ARG_PARSER_H_ + +/** +* @file +* +* RTE Argument Parsing API +* +* The argument parsing API is a collection of functions to help parse +* command line arguments. The API takes a string input and will return +* it to the user in a more usable format. +*/ + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdint.h> + +#include <rte_compat.h> + + +/** +* Convert a string describing a list of core ids into an array of core ids. +* +* On success, the passed array is filled with the core ids present in the list up +* to the "cores_len", and the number of unique cores present in the "corelist" +* is returned. +* For example, passing a 1-3,6 "corelist" results in an array of [1, 2, 3, 6] +* and would return 4. +* +* NOTE: if the length of the input array is insufficient to hold the number of core ids +* in "corelist" the input array is filled to capacity but the return value is the +* number of elements which would have been written to the array, had enough space been +* available. [This is similar to the behaviour of the snprintf function]. Because of +* this, the number of core values in the "corelist" may be determined by calling the +* function with a NULL array pointer and array length given as 0. +* +* @param corelist +* Input string describing a list of core ids. +* @param cores +* An array where to store the core ids. +* Array can be NULL if "cores_len" is 0. +* @param cores_len +* The length of the "cores" array. +* If the size is smaller than that needed to hold all cores from "corelist", +* only "cores_len" elements will be written to the array. +* @return +* n: the number of unique cores present in "corelist". +* -1 if the string was invalid. +* NOTE: if n > "cores_len", then only "cores_len" elements in the "cores" array are valid. +*/ +__rte_experimental +int +rte_arg_parse_corelist (const char *corelist,uint16_t *cores,uint32_t cores_len); + + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_ARG_PARSER_H_ */ lib/arg_parser/version.map new file +10
-0@@ -0,0 +1,10 @@ +DPDK_24 { + local: *; +}; + +EXPERIMENTAL { + global: + + # added in 24.03 + rte_arg_parse_corelist; +};lib/meson.build +2
-0@@ -11,6 +11,7 @@ libraries = [ 'log', 'kvargs', # eal depends on kvargs + 'arg_parser', 'telemetry', # basic info querying 'eal', # everything depends on eal 'ring',@@ -72,6 +73,7 @@ if is_ms_compiler 'log', 'kvargs', 'telemetry', + 'arg_parser', ] endifSignature · 1 line
2.34.1
Re: [PATCH v3 1/8] arg_parser: new library for command line parsing
In reply to Euan BourkeQuoted 83 lines · Euan Bourke
Add a new library to make it easier for eal and other libraries to parse command line arguments.
The first function in this library is one to parse a corelist string into an array of individual core ids. The function will then return the total number of cores described in the corelist.
Signed-off-by Euan Bourke <[email protected]>--- .mailmap | 1 + MAINTAINERS | 4 ++ doc/api/doxy-api-index.md | 3 +- doc/api/doxy-api.conf.in | 1 + lib/arg_parser/arg_parser.c | 108 ++++++++++++++++++++++++++++++++ lib/arg_parser/meson.build | 7 +++ lib/arg_parser/rte_arg_parser.h | 66 +++++++++++++++++++ lib/arg_parser/version.map | 10 +++ lib/meson.build | 2 + 9 files changed, 201 insertions(+), 1 deletion(-) create mode 100644 lib/arg_parser/arg_parser.c create mode 100644 lib/arg_parser/meson.build create mode 100644 lib/arg_parser/rte_arg_parser.h create mode 100644 lib/arg_parser/version.map.mailmap +1
-0@@ -379,6 +379,7 @@ Eric Zhang <[email protected]> Erik Gabriel Carrillo <[email protected]> Erik Ziegenbalg <[email protected]> Erlu Chen <[email protected]> +Euan Bourke <[email protected]> Eugenio Pérez <[email protected]> Eugeny Parshutin <[email protected]> Evan Swanson <[email protected]>MAINTAINERS +4
-0@@ -1756,6 +1756,10 @@ M: Nithin Dabilpuram <[email protected]> M: Pavan Nikhilesh <[email protected]> F: lib/node/ +Argument parsing +M: Bruce Richardson <[email protected]> +F: lib/arg_parser/ + Test Applications -----------------doc/api/doxy-api-index.md +2
-1@@ -221,7 +221,8 @@ The public API headers are grouped by topics: [config file](@ref rte_cfgfile.h), [key/value args](@ref rte_kvargs.h), [string](@ref rte_string_fns.h), - [thread](@ref rte_thread.h) + [thread](@ref rte_thread.h), + [argument parsing](@ref rte_arg_parser.h) - **debug**: [jobstats](@ref rte_jobstats.h),doc/api/doxy-api.conf.in +1
-0@@ -28,6 +28,7 @@ INPUT = @TOPDIR@/doc/api/doxy-api-index.md \ @TOPDIR@/lib/eal/include \ @TOPDIR@/lib/eal/include/generic \ @TOPDIR@/lib/acl \ + @TOPDIR@/lib/arg_parser \ @TOPDIR@/lib/bbdev \ @TOPDIR@/lib/bitratestats \ @TOPDIR@/lib/bpf \lib/arg_parser/arg_parser.c new file +0
-0
lib/arg_parser/arg_parser.c line 9
Quoted 9 lines
lib/arg_parser/arg_parser.c new file +9
-0@@ -0,0 +1,108 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2023 Intel Corporation +*/ + +#include "errno.h" +#include "stdlib.h" +#include "ctype.h" +#include "string.h" +#include "stdbool.h"
should be <> not "" quotes for system or standard library headers includes.
Quoted 4 lines
lib/arg_parser/arg_parser.c new file +4
-0+ +#include <rte_arg_parser.h> +#include <rte_common.h> +
lib/arg_parser/arg_parser.c line 23
Quoted 10 lines
lib/arg_parser/arg_parser.c new file +10
-0+ +struct core_bits { +uint8_t bits[(UINT16_MAX +1 ) /CHAR_BIT ]; +uint16_t max_bit_set; +uint16_t min_bit_set; +uint32_t total_bits_set; +}; + +static inline bool +get_core_bit (struct core_bits *mask,uint16_t idx)
nit: use size_t typed parameters for things that are used as an offset / subscript value. applies to all instances in the series.
PATCH v3 2/8 arg_parser: add new coremask parsing API
In reply to Euan BourkeAdd new coremask parsing API. This API behaves similarly to the corelist parsing API, taking a coremask string, a cores array and a cores_len int. Parsing the coremask string, filling its values into the cores array up to cores_len.
The API also returns a 'count' which corresponds to the total number of cores in the coremask string.
--- lib/arg_parser/arg_parser.c | 53 +++++++++++++++++++++++++++++++++ lib/arg_parser/rte_arg_parser.h | 34 +++++++++++++++++++++ lib/arg_parser/version.map | 1 + 3 files changed, 88 insertions(+)
lib/arg_parser/arg_parser.c +53 -0
@@ -11,6 +11,9 @@#include <rte_arg_parser.h> #include <rte_common.h> +#define BITS_PER_HEX 4 +#define MAX_COREMASK_SIZE ((UINT16_MAX + 1) / BITS_PER_HEX) +struct core_bits {uint8_t bits[(UINT16_MAX +1 ) /CHAR_BIT ];
@@ -57,6 +60,15 @@ corebits_to_array(struct core_bits *mask, uint16_t *cores, size_t max_cores)return mask->total_bits_set; } +static int xdigit2val (unsigned char c) +{ +if (isdigit (c)) +return c -'0' ; +else if (isupper (c)) +return c -'A' +10 ; +else +return c -'a' +10 ; +}int rte_arg_parse_corelist (const char *corelist,uint16_t *cores,uint32_t cores_len)
@@ -106,3 +118,44 @@ rte_arg_parse_corelist(const char *corelist, uint16_t *cores, uint32_t cores_lenreturn total_count; } + +int +rte_arg_parse_coremask (const char *coremask,uint16_t *cores,uint32_t cores_len) +{ +struct core_bits mask = {0 }; + +/* Remove all blank characters ahead and after . +* Remove 0x/0X if exists. +*/ +while (isblank (*coremask)) + coremask++; +if (coremask[0 ] =='0' && ((coremask[1 ] =='x' ) || (coremask[1 ] =='X' ))) + coremask +=2 ; + +int32_t i =strlen (coremask); +while ((i >0 ) &&isblank (coremask[i -1 ])) + i--; +if (i ==0 || i >MAX_COREMASK_SIZE ) +return -1 ; + +uint32_t idx =0 ; + +for (i = i -1 ; i >=0 ; i--) { +int val; +char c = coremask[i]; + +if (isxdigit (c) ==0 ) +return -1 ; + + val =xdigit2val (c); + +for (uint8_t j =0 ; j <BITS_PER_HEX ; j++, idx++) { +if ((1 << j) & val) +set_core_bit (&mask, idx); + } + } + +uint32_t total_count =corebits_to_array (&mask, cores, cores_len); + +return total_count; +}
lib/arg_parser/rte_arg_parser.h +34 -0
@@ -58,6 +58,40 @@ __rte_experimentalint rte_arg_parse_corelist (const char *corelist,uint16_t *cores,uint32_t cores_len); +/** +* Convert a string describing a bitmask of core ids into an array of core ids. +* +* On success, the passed array is filled with the core ids present in the +* bitmask up to the "cores_len", and the number of unique cores present in the +* "coremask" is returned. +* For example, passing a 0xA "coremask" results in an array of [1, 3] +* and would return 2. +* +* NOTE: if the length of the input array is insufficient to hold the number of core ids +* in "coremask" the input array is filled to capacity but the return value is the +* number of elements which would have been written to the array, had enough space been +* available. [This is similar to the behaviour of the snprintf function]. Because of +* this, the number of core values in the "coremask" may be determined by calling the +* function with a NULL array pointer and array length given as 0. +* +* @param coremask +* A string containing a bitmask of core ids. +* @param cores +* An array where to store the core ids. +* Array can be NULL if "cores_len" is 0. +* @param cores_len +* The length of the "cores" array. +* If the size is smaller than that needed to hold all cores from "coremask", +* only "cores_len" elements will be written to the array. +* @return +* n: the number of unique cores present in "coremask". +* -1 if the string was invalid. +* NOTE: if n > "cores_len", then only "cores_len" elements in the "cores" array are valid. +*/ +__rte_experimental +int +rte_arg_parse_coremask (const char *coremask,uint16_t *cores,uint32_t cores_len); + #ifdef __cplusplus }
lib/arg_parser/version.map +1 -0
@@ -7,4 +7,5 @@ EXPERIMENTAL { # added in 24.03 rte_arg_parse_corelist; + rte_arg_parse_coremask; };
Signature · 1 line
2.34.1
PATCH v3 3/8 eal: add support for new arg parsing library
In reply to Euan BourkeUpdate to eal functions relating to corelist and coremask parsing to support the new arg parsing library. Functions now call the API instead of implementing their own version.
--- lib/eal/common/eal_common_options.c | 114 ++++------------------------ lib/eal/meson.build | 2 +- 2 files changed, 14 insertions(+), 102 deletions(-)
lib/eal/common/eal_common_options.c +13 -101
@@ -30,6 +30,7 @@#include <rte_tailq.h> #include <rte_version.h> #include <rte_devargs.h> +#include <rte_arg_parser.h> #include <rte_memcpy.h> #ifndef RTE_EXEC_ENV_WINDOWS #include <rte_telemetry.h>
@@ -706,7 +707,7 @@ update_lcore_config(int *cores) }static int -check_core_list (int *lcores,unsigned int count) +check_core_list (uint16_t *lcores,unsigned int count) {char lcorestr[RTE_MAX_LCORE *10 ];bool overflow = false;
@@ -746,60 +747,18 @@ check_core_list(int *lcores, unsigned int count)int rte_eal_parse_coremask (const char *coremask,int *cores) { -const char *coremask_orig = coremask; -int lcores[RTE_MAX_LCORE ]; -unsigned int count =0 ; -int i, j, idx; -int val; -char c; +int count; +uint16_t lcores[RTE_MAX_LCORE ]; +int idx;for (idx =0 ; idx <RTE_MAX_LCORE ; idx++) cores[idx] =-1 ; - idx =0 ; -/* Remove all blank characters ahead and after . -* Remove 0x/0X if exists. -*/ -while (isblank (*coremask)) - coremask++; -if (coremask[0 ] =='0' && ((coremask[1 ] =='x' ) - || (coremask[1 ] =='X' ))) - coremask +=2 ; - i =strlen (coremask); -while ((i >0 ) &&isblank (coremask[i -1 ])) - i--; -if (i ==0 ) { -RTE_LOG (ERR ,EAL ,"No lcores in coremask: [%s]\n" , - coremask_orig); -return -1 ; - } +/* Call public coremask parsing API */ + count =rte_arg_parse_coremask (coremask, lcores,RTE_MAX_LCORE ); -for (i = i -1 ; i >=0 ; i--) { - c = coremask[i]; -if (isxdigit (c) ==0 ) { -/* invalid characters */ -RTE_LOG (ERR ,EAL ,"invalid characters in coremask: [%s]\n" , - coremask_orig); -return -1 ; - } - val =xdigit2val (c); -for (j =0 ; j <BITS_PER_HEX ; j++, idx++) - { -if ((1 << j) & val) { -if (count >=RTE_MAX_LCORE ) { -RTE_LOG (ERR ,EAL ,"Too many lcores provided. Cannot exceed RTE_MAX_LCORE (%d)\n" , -RTE_MAX_LCORE ); -return -1 ; - } - lcores[count++] = idx; - } - } - } -if (count ==0 ) { -RTE_LOG (ERR ,EAL ,"No lcores in coremask: [%s]\n" , - coremask_orig); +if (count <=0 || count >RTE_MAX_LCORE )return -1 ; - }if (check_core_list (lcores, count))return -1 ;
@@ -898,64 +857,17 @@ eal_parse_service_corelist(const char *corelist)static int eal_parse_corelist (const char *corelist,int *cores) { -unsigned int count =0 , i; -int lcores[RTE_MAX_LCORE ]; -char *end =NULL ; -int min, max; +int count; +uint16_t lcores[RTE_MAX_LCORE ];int idx;for (idx =0 ; idx <RTE_MAX_LCORE ; idx++) cores[idx] =-1 ; -/* Remove all blank characters ahead */ -while (isblank (*corelist)) - corelist++; +/* Call public corelist parsing API */ + count =rte_arg_parse_corelist (corelist, lcores,RTE_MAX_LCORE ); -/* Get list of cores */ - min =-1 ; -do { -while (isblank (*corelist)) - corelist++; -if (*corelist =='\0' ) -return -1 ; - errno =0 ; - idx =strtol (corelist, &end,10 ); -if (errno || end ==NULL ) -return -1 ; -if (idx <0 ) -return -1 ; -while (isblank (*end)) - end++; -if (*end =='-' ) { - min = idx; - }else if ((*end ==',' ) || (*end =='\0' )) { - max = idx; -if (min ==-1 ) - min = idx; -for (idx = min; idx <= max; idx++) { -bool 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 ) { -RTE_LOG (ERR ,EAL ,"Too many lcores provided. Cannot exceed RTE_MAX_LCORE (%d)\n" , -RTE_MAX_LCORE ); -return -1 ; - } - lcores[count++] = idx; - } - min =-1 ; - }else -return -1 ; - corelist = end +1 ; - }while (*end !='\0' ); - -if (count ==0 ) +if (count <=0 || count >RTE_MAX_LCORE )return -1 ;if (check_core_list (lcores, count))
lib/eal/meson.build +1 -1
@@ -14,7 +14,7 @@ subdir(exec_env) subdir(arch_subdir) -deps += ['log', 'kvargs'] +deps += ['log', 'kvargs', 'arg_parser'] if not is_windows deps += ['telemetry'] endif
Signature · 1 line
2.34.1
PATCH v3 4/8 eal: update to service core related parsers
In reply to Euan BourkeUpdates to the parse service cores functions in EAL to call the arg parser API instead of implementing its own versions.
--- lib/eal/common/eal_common_options.c | 171 +++++++--------------------- 1 file changed, 41 insertions(+), 130 deletions(-)
lib/eal/common/eal_common_options.c +41 -130
@@ -573,97 +573,49 @@ eal_plugins_init(void)* the global configuration (core role and core count) with the parsed * value. */ -static int xdigit2val (unsigned char c) -{ -int val; - -if (isdigit (c)) - val = c -'0' ; -else if (isupper (c)) - val = c -'A' +10 ; -else - val = c -'a' +10 ; -return val; -} -static int eal_parse_service_coremask (const char *coremask) {struct rte_config *cfg =rte_eal_get_configuration (); -int i, j, idx =0 ; -unsigned int count =0 ; -char c; -int val; +uint16_t cores[RTE_MAX_LCORE ]; +int64_t count;uint32_t taken_lcore_count =0 ; -if (coremask ==NULL ) -return -1 ; -/* Remove all blank characters ahead and after . -* Remove 0x/0X if exists. -*/ -while (isblank (*coremask)) - coremask++; -if (coremask[0 ] =='0' && ((coremask[1 ] =='x' ) - || (coremask[1 ] =='X' ))) - coremask +=2 ; - i =strlen (coremask); -while ((i >0 ) &&isblank (coremask[i -1 ])) - i--; - -if (i ==0 ) + count =rte_arg_parse_coremask (coremask, cores,RTE_DIM (cores)); + +if (count ==0 || count ==-1 )return -1 ; -for (i = i -1 ; i >=0 && idx <RTE_MAX_LCORE ; i--) { - c = coremask[i]; -if (isxdigit (c) ==0 ) { -/* invalid characters */ +for (int i =0 ; i < count; i++) { +uint32_t lcore = cores[i]; +if (main_lcore_parsed && + cfg->main_lcore == lcore) { +RTE_LOG (ERR ,EAL , +"lcore %u is main lcore, cannot use as service core\n" , + cores[i]);return -1 ; } - val =xdigit2val (c); -for (j =0 ; j <BITS_PER_HEX && idx <RTE_MAX_LCORE ; - j++, idx++) { -if ((1 << j) & val) { -/* handle main lcore already parsed */ -uint32_t lcore = idx; -if (main_lcore_parsed && - cfg->main_lcore == lcore) { -RTE_LOG (ERR ,EAL , -"lcore %u is main lcore, cannot use as service core\n" , - idx); -return -1 ; - } -if (eal_cpu_detected (idx) ==0 ) { -RTE_LOG (ERR ,EAL , -"lcore %u unavailable\n" , idx); -return -1 ; - } - -if (cfg->lcore_role[idx] ==ROLE_RTE ) - taken_lcore_count++; - - lcore_config[idx].core_role =ROLE_SERVICE ; - count++; - } - } - } - -for (; i >=0 ; i--) -if (coremask[i] !='0' ) +if (eal_cpu_detected (cores[i]) ==0 ) { +RTE_LOG (ERR ,EAL , +"lcore %u unavailable\n" , cores[i]);return -1 ; + } -for (; idx <RTE_MAX_LCORE ; idx++) - lcore_config[idx].core_index =-1 ; - -if (count ==0 ) -return -1 ; +if (cfg->lcore_role[cores[i]] ==ROLE_RTE ) + taken_lcore_count++; + lcore_config[cores[i]].core_role =ROLE_SERVICE ; + }if (core_parsed && taken_lcore_count != count) {RTE_LOG (WARNING ,EAL , -"Not all service cores are in the coremask. " +"Not all service cores were in the coremask. " "Please ensure -c or -l includes service cores\n" ); } +for (uint16_t j = count*4 ; j <RTE_MAX_LCORE ; j++) + lcore_config[j].core_index =-1 ; + cfg->service_lcore_count = count;return 0 ; }
@@ -780,70 +732,29 @@ static int eal_parse_service_corelist(const char *corelist) {struct rte_config *cfg =rte_eal_get_configuration (); -int i; -unsigned count =0 ; -char *end =NULL ; -uint32_t min, max, idx; +int64_t i, count; +uint16_t cores[RTE_MAX_LCORE ];uint32_t taken_lcore_count =0 ; -if (corelist ==NULL ) -return -1 ; + count =rte_arg_parse_corelist (corelist, cores,RTE_DIM (cores)); -/* Remove all blank characters ahead and after */ -while (isblank (*corelist)) - corelist++; - i =strlen (corelist); -while ((i >0 ) &&isblank (corelist[i -1 ])) - i--; +if (count ==0 || count ==-1 ) +return -1 ; -/* Get list of cores */ - min =RTE_MAX_LCORE ; -do { -while (isblank (*corelist)) - corelist++; -if (*corelist =='\0' ) -return -1 ; - errno =0 ; - idx =strtoul (corelist, &end,10 ); -if (errno || end ==NULL ) -return -1 ; -if (idx >=RTE_MAX_LCORE ) -return -1 ; -while (isblank (*end)) - end++; -if (*end =='-' ) { - min = idx; - }else if ((*end ==',' ) || (*end =='\0' )) { - max = idx; -if (min ==RTE_MAX_LCORE ) - min = idx; -for (idx = min; idx <= max; idx++) { -if (cfg->lcore_role[idx] !=ROLE_SERVICE ) { -/* handle main lcore already parsed */ -uint32_t lcore = idx; -if (cfg->main_lcore == lcore && - main_lcore_parsed) { -RTE_LOG (ERR ,EAL , -"Error: lcore %u is main lcore, cannot use as service core\n" , - idx); -return -1 ; - } -if (cfg->lcore_role[idx] ==ROLE_RTE ) - taken_lcore_count++; - - lcore_config[idx].core_role = -ROLE_SERVICE ; - count++; - } - } - min =RTE_MAX_LCORE ; - }else +for (i =0 ; i < count; i++) { +uint32_t lcore = cores[i]; +if (cfg->main_lcore == lcore && + main_lcore_parsed) { +RTE_LOG (ERR ,EAL , +"Error: lcore %u is main lcore, cannot use as service core\n" , + cores[i]);return -1 ; - corelist = end +1 ; - }while (*end !='\0' ); + } +if (cfg->lcore_role[cores[i]] ==ROLE_RTE ) + taken_lcore_count++; -if (count ==0 ) -return -1 ; + lcore_config[cores[i]].core_role =ROLE_SERVICE ; + }if (core_parsed && taken_lcore_count != count) { RTE_LOG(WARNING, EAL,
Signature · 1 line
2.34.1
PATCH v3 5/8 event/dlb2: add new arg parsing library API support
In reply to Euan BourkeSwitched the dlb2 driver to call the new arg parsing library instead of eal for coremask parsing, and updated the resource probe function to support the changed formatting of the API.
--- drivers/event/dlb2/dlb2_priv.h | 4 +- drivers/event/dlb2/pf/base/dlb2_resource.c | 51 +++++++++------------- 2 files changed, 21 insertions(+), 34 deletions(-)
drivers/event/dlb2/dlb2_priv.h +1 -3
@@ -10,6 +10,7 @@#include <rte_eventdev.h> #include <rte_config.h> +#include <rte_arg_parser.h> #include "dlb2_user.h" #include "dlb2_log.h" #include "rte_pmd_dlb2.h"
@@ -729,9 +730,6 @@ void dlb2_event_build_hcws(struct dlb2_port *qm_port,uint8_t *sched_type, uint8_t *queue_id); -/* Extern functions */ -extern int rte_eal_parse_coremask (const char *coremask,int *cores); -/* Extern globals */ extern struct process_local_port_data dlb2_port[][DLB2_NUM_PORT_TYPES ];
drivers/event/dlb2/pf/base/dlb2_resource.c +20 -31
69 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v3 6/8 arg_parser: added common core string and heuristic parsers
In reply to Euan BourkeTwo new functions, the first is a 'heuristic parser' which examines a string describing a set of cores and determines based off heuristics whether its a coremask or a corelist.
Second is a 'combined parser' which calls the first function and then based off the returned value will call the relevant core string parser. This function also takes a 'default_type' int which corresponds to which parser should be used in the case of an ambiguous string.
--- lib/arg_parser/arg_parser.c | 68 +++++++++++++++++++++++++++++++++ lib/arg_parser/rte_arg_parser.h | 60 +++++++++++++++++++++++++++++ lib/arg_parser/version.map | 2 + 3 files changed, 130 insertions(+)
lib/arg_parser/arg_parser.c +68 -0
@@ -7,10 +7,15 @@#include "ctype.h" #include "string.h" #include "stdbool.h" +#include "stdio.h" #include <rte_arg_parser.h> #include <rte_common.h> +#define RTE_ARG_PARSE_TYPE_COREMASK 0 +#define RTE_ARG_PARSE_TYPE_CORELIST 1 +#define RTE_ARG_PARSE_TYPE_UNKNOWN 2 +#define BITS_PER_HEX 4#define MAX_COREMASK_SIZE ((UINT16_MAX + 1) / BITS_PER_HEX)
@@ -22,6 +27,7 @@ struct core_bits {uint32_t total_bits_set; }; +static inline bool get_core_bit (struct core_bits *mask,uint16_t idx) {
@@ -159,3 +165,65 @@ rte_arg_parse_coremask(const char *coremask, uint16_t *cores, uint32_t cores_lenreturn total_count; } + +int +rte_arg_parse_arg_type (const char *core_string) +{ +/* Remove leading whitespace */ +while (isblank (*core_string)) + core_string++; + +/* Check for 0x prefix */ +if (core_string[0 ] =='0' &&tolower (core_string[1 ]) =='x' ) { +if (core_string[2 ] !='\0' ) +return RTE_ARG_PARSE_TYPE_COREMASK ; +return -1 ; + } + +int i =0 , idx =0 ; +/* Check for ',' and '-' and check for A-F */ +do { +while (isblank (core_string[idx])) + idx++; + +if (core_string[idx] ==',' || core_string[idx] =='-' ) +return RTE_ARG_PARSE_TYPE_CORELIST ; + +if (isalpha (core_string[idx])) { +if (isxdigit (core_string[idx])) +return RTE_ARG_PARSE_TYPE_COREMASK ; +return -1 ; + } + idx++; + i++; + }while (core_string[idx] !='\0' ); + +/* Check length of core_string if ambiguous as max length of a uint16_t is 5 digits +* implying its a coremask. +*/ +if (i >5 ) +return RTE_ARG_PARSE_TYPE_COREMASK ; + +return -1 ; +} + +int +rte_arg_parse_core_string (const char *core_string,uint16_t *cores,uint32_t cores_len, +int default_type) +{ +if (default_type !=RTE_ARG_PARSE_TYPE_COREMASK && + default_type !=RTE_ARG_PARSE_TYPE_CORELIST ) { +return -1 ; + } +switch (rte_arg_parse_arg_type (core_string)) { +case RTE_ARG_PARSE_TYPE_COREMASK : +return rte_arg_parse_coremask (core_string, cores, cores_len); +case RTE_ARG_PARSE_TYPE_CORELIST : +return rte_arg_parse_corelist (core_string, cores, cores_len); +default : +return default_type ==RTE_ARG_PARSE_TYPE_COREMASK ? +rte_arg_parse_coremask (core_string, cores, cores_len) : +rte_arg_parse_corelist (core_string, cores, cores_len); +return -1 ; + } +}
lib/arg_parser/rte_arg_parser.h +60 -0
66 lines not on this page · raw message
lib/arg_parser/version.map +2 -0
@@ -8,4 +8,6 @@ EXPERIMENTAL { # added in 24.03 rte_arg_parse_corelist; rte_arg_parse_coremask; + rte_arg_parse_arg_type; + rte_arg_parse_core_string; };
Signature · 1 line
2.34.1
Re: [PATCH v3 6/8] arg_parser: added common core string and heuristic parsers
Quoted 23 lines · Euan Bourke
Two new functions, the first is a 'heuristic parser' which examines a string describing a set of cores and determines based off heuristics whether its a coremask or a corelist.
Second is a 'combined parser' which calls the first function and then based off the returned value will call the relevant core string parser. This function also takes a '
default_type' int which corresponds to which parser should be used in the case of an ambiguous string.Signed-off-by Euan Bourke <[email protected]>--- lib/arg_parser/arg_parser.c | 68 +++++++++++++++++++++++++++++++++ lib/arg_parser/rte_arg_parser.h | 60 +++++++++++++++++++++++++++++ lib/arg_parser/version.map | 2 + 3 files changed, 130 insertions(+)lib/arg_parser/arg_parser.c +0
-0@@ -7,10 +7,15 @@#include "ctype.h" #include "string.h"
lib/arg_parser/arg_parser.c line 18
Quoted 10 lines
lib/arg_parser/arg_parser.c +5
-0#include "stdbool.h" +#include "stdio.h" #include <rte_arg_parser.h> #include <rte_common.h> +#define RTE_ARG_PARSE_TYPE_COREMASK 0 +#define RTE_ARG_PARSE_TYPE_CORELIST 1 +#define RTE_ARG_PARSE_TYPE_UNKNOWN 2 +
As these are used as return values, they need to be defined in the header file so that applications can use them.
lib/arg_parser/arg_parser.c struct core_bits { · line 30
Quoted 8 lines
lib/arg_parser/arg_parser.c +1
-0#define BITS_PER_HEX 4#define MAX_COREMASK_SIZE ((UINT16_MAX + 1) / BITS_PER_HEX)@@ -22,6 +27,7 @@ struct core_bits {uint32_t total_bits_set; }; +
Stray newline added to patch.
Quoted 37 lines
lib/arg_parser/arg_parser.c +30
-0static inline bool get_core_bit (struct core_bits *mask,uint16_t idx) {@@ -159,3 +165,65 @@ rte_arg_parse_coremask(const char *coremask, uint16_t *cores, uint32_t cores_lenreturn total_count; } + +int +rte_arg_parse_arg_type (const char *core_string) +{ +/* Remove leading whitespace */ +while (isblank (*core_string)) + core_string++; + +/* Check for 0x prefix */ +if (core_string[0 ] =='0' &&tolower (core_string[1 ]) =='x' ) { +if (core_string[2 ] !='\0' ) +return RTE_ARG_PARSE_TYPE_COREMASK ; +return -1 ; + } + +int i =0 , idx =0 ; +/* Check for ',' and '-' and check for A-F */ + do { + while (isblank(core_string[idx])) + idx++; + + if (core_string[idx] == ',' || core_string[idx] == '-') + return RTE_ARG_PARSE_TYPE_CORELIST; + + if (isalpha(core_string[idx])) { + if (isxdigit(core_string[idx])) + return RTE_ARG_PARSE_TYPE_COREMASK; + return -1; + } + idx++;
lib/arg_parser/arg_parser.c rte_arg_parse_coremask(const char *coremask, uint16_t *cores, uint32_t cores_len · line 207
Quoted 10 lines
lib/arg_parser/arg_parser.c +10
-0+ i++; + }while (core_string[idx] !='\0' ); + +/* Check length of core_string if ambiguous as max length of a uint16_t is 5 digits +* implying its a coremask. +*/ +if (i >5 ) +return RTE_ARG_PARSE_TYPE_COREMASK ; + +return -1 ;
Rather than returning -1, I think in most/all cases above, the function should return -EINVAL as error code, since it's invalid input passed.
Quoted 27 lines
lib/arg_parser/arg_parser.c +22
-0+} + +int +rte_arg_parse_core_string (const char *core_string,uint16_t *cores,uint32_t cores_len, +int default_type) +{ +if (default_type !=RTE_ARG_PARSE_TYPE_COREMASK && + default_type !=RTE_ARG_PARSE_TYPE_CORELIST ) { +return -1 ; + } +switch (rte_arg_parse_arg_type (core_string)) { +case RTE_ARG_PARSE_TYPE_COREMASK : +return rte_arg_parse_coremask (core_string, cores, cores_len); +case RTE_ARG_PARSE_TYPE_CORELIST : +return rte_arg_parse_corelist (core_string, cores, cores_len); +default : +return default_type ==RTE_ARG_PARSE_TYPE_COREMASK ? +rte_arg_parse_coremask (core_string, cores, cores_len) : +rte_arg_parse_corelist (core_string, cores, cores_len); +return -1 ; + } +}lib/arg_parser/rte_arg_parser.h +0
-0
lib/arg_parser/rte_arg_parser.h __rte_experimental · line 99
Quoted 8 lines
lib/arg_parser/rte_arg_parser.h +5
-0@@ -92,6 +92,66 @@ __rte_experimentalint rte_arg_parse_coremask (const char *coremask,uint16_t *cores,uint32_t cores_len); +/** +* Use heuristics to determine if a string contains a coremask or a corelist. +* +* This function will check a series of conditions and return an int representing which +* core type (mask or list) the string represents or UNKNOWN if the string is ambiguous.
"or report the type as unknown if it is ambiguous"
lib/arg_parser/rte_arg_parser.h __rte_experimental · line 105
Quoted 6 lines
lib/arg_parser/rte_arg_parser.h +6
-0+* +* @param core_string +* A string describing the intended cores to be parsed +* @return +* int representing the core type +* -1: error.
Suggest "negative error code on error". We should also list out the error codes at the end, though I think right now -EINVAL is the only one we need.
lib/arg_parser/rte_arg_parser.h __rte_experimental · line 108
Quoted 3 lines
lib/arg_parser/rte_arg_parser.h +3
-0+* 0: coremask. +* 1: corelist. +* 2: unknown (ambiguous).
Move the #defines from the C file to the header, and use them here rather than magic numbers.
Quoted 27 lines
lib/arg_parser/rte_arg_parser.h +27
-0+*/ +__rte_experimental +int +rte_arg_parse_arg_type (const char *core_string); + +/** +* Convert a string describing either a corelist or coremask into an array of core ids. +* +* This function will fill the "cores" array up to "cores_len" with the core ids described +* in the "core_string". The string can either describe a corelist or a coremask, and +* will be parsed accordingly. The number of unique core ids in the string is then returned. +* For example: +* "1-4" is treated as a corelist and results in an array of [1,2,3,4] with 4 being returned +* "0xA1" is treated as a coremask and results in an array of [0,5,7] with 3 being returned +* +* In the case of an ambiguous string, the function will use the default_type parameter to +* decide. +* +* NOTE: if the length of the input array is insufficient to hold the number of core ids +* in "core_string" the input array is filled to capacity but the return value is the +* number of elements which would have been written to the array, had enough space been +* available. [This is similar to the behaviour of the snprintf function]. Because of +* this, the number of core values in the "core_string" may be determined by calling the +* function with a NULL array pointer and array length given as 0. +* +* @param core_string +* A string describing the intended cores to be parsed.
lib/arg_parser/rte_arg_parser.h __rte_experimental · line 145
Quoted 10 lines
lib/arg_parser/rte_arg_parser.h +10
-0+* @param cores +* An array where to store the core ids. +* Array can be NULL if "cores_len" is 0. +* @param cores_len +* The length of the "cores" array. +* If the size is smaller than that needed to hold all cores from "core_string" +* @param default_type +* How to treat ambiguous cases (e.g. '4' could be mask or list). +* 0: mask. +* 1: list.
Again, use the defines.
Quoted 17 lines
lib/arg_parser/rte_arg_parser.h +9
-0+* @return +* n: the number of unique cores present in "core_string". +* -1 if the string was invalid. +* NOTE: if n > "cores_len", then only "cores_len" elements in the "cores" array are valid. +*/ +__rte_experimental +int +rte_arg_parse_core_string (const char *core_string,uint16_t *cores,uint32_t cores_len, +int default_type); #ifdef __cplusplus }lib/arg_parser/version.map +0
-0
lib/arg_parser/version.map EXPERIMENTAL { · line 12
Quoted 5 lines
lib/arg_parser/version.map +2
-0@@ -8,4 +8,6 @@ EXPERIMENTAL { # added in 24.03 rte_arg_parse_corelist; rte_arg_parse_coremask; + rte_arg_parse_arg_type; + rte_arg_parse_core_string;
The version.map lists are kept alphabetical, so the new entries need to be moved up.
Quoted 4 lines
lib/arg_parser/version.map +0
-0};Signature · 1 line
2.34.1
PATCH v3 7/8 examples/eventdev_pipeline: update to call arg parser API
In reply to Euan BourkeUpdate to the eventdev_pipeline example application to call the arg parser library for its 'combined core string parser' instead of implementing its own coremask parser. The default_type passed into the function call is a coremask.
--- examples/eventdev_pipeline/main.c | 65 +++----------------- examples/eventdev_pipeline/pipeline_common.h | 1 + 2 files changed, 10 insertions(+), 56 deletions(-)
examples/eventdev_pipeline/main.c +9 -56
@@ -56,69 +56,22 @@ core_in_use(unsigned int lcore_id) { fdata->tx_core[lcore_id] || fdata->worker_core[lcore_id]); } -/* -* Parse the coremask given as argument (hexadecimal string) and fill -* the global configuration (core role and core count) with the parsed -* value. -*/ -static int xdigit2val (unsigned char c) -{ -int val; - -if (isdigit (c)) - val = c -'0' ; -else if (isupper (c)) - val = c -'A' +10 ; -else - val = c -'a' +10 ; -return val; -} -static uint64_t parse_coremask (const char *coremask) { -int i, j, idx =0 ; -unsigned int count =0 ; -char c; -int val; +int count; +uint16_t i;uint64_t mask =0 ; -const int32_t BITS_HEX =4 ; +uint16_t cores[RTE_MAX_LCORE ]; -if (coremask ==NULL ) -return -1 ; -/* Remove all blank characters ahead and after . -* Remove 0x/0X if exists. -*/ -while (isblank (*coremask)) - coremask++; -if (coremask[0 ] =='0' && ((coremask[1 ] =='x' ) - || (coremask[1 ] =='X' ))) - coremask +=2 ; - i =strlen (coremask); -while ((i >0 ) &&isblank (coremask[i -1 ])) - i--; -if (i ==0 ) -return -1 ; + count =rte_arg_parse_core_string (coremask, cores,RTE_DIM (cores),0 ); -for (i = i -1 ; i >=0 && idx <MAX_NUM_CORE ; i--) { - c = coremask[i]; -if (isxdigit (c) ==0 ) { -/* invalid characters */ -return -1 ; - } - val =xdigit2val (c); -for (j =0 ; j <BITS_HEX && idx <MAX_NUM_CORE ; j++, idx++) { -if ((1 << j) & val) { - mask |= (1ULL << idx); - count++; - } - } - } -for (; i >=0 ; i--) -if (coremask[i] !='0' ) -return -1 ; -if (count ==0 ) +if (count ==0 || count ==-1 )return -1 ; + +for (i =0 ; i < count; i++) + mask |=1ULL << cores[i]; +return mask; }
examples/eventdev_pipeline/pipeline_common.h +1 -0
@@ -6,6 +6,7 @@#include <stdbool.h> +#include <rte_arg_parser.h> #include <rte_eal.h> #include <rte_mempool.h> #include <rte_mbuf.h>
Signature · 1 line
2.34.1
PATCH v3 8/8 examples/l3fwd-power: update to call arg parser API
In reply to Euan BourkeUpdate to the l3fwd-power example application to call the arg parser library for its 'combined core string parser' instead of implementing its own corelist parser. The default_type passed into the function call is a corelist.
--- examples/l3fwd-power/perf_core.c | 51 +++++--------------------------- 1 file changed, 8 insertions(+), 43 deletions(-)
examples/l3fwd-power/perf_core.c +8 -43
@@ -12,6 +12,7 @@#include <rte_lcore.h> #include <rte_power.h> #include <rte_string_fns.h> +#include <rte_arg_parser.h> #include "perf_core.h" #include "main.h"
@@ -177,56 +178,20 @@ parse_perf_config(const char *q_arg)int parse_perf_core_list (const char *corelist) { -int i, idx =0 ; -unsigned int count =0 ; -char *end =NULL ; -int min, max; +int count; +uint16_t cores[RTE_MAX_LCORE ];if (corelist ==NULL ) {printf ("invalid core list\n" );return -1 ; } + count =rte_arg_parse_core_string (corelist, cores,RTE_DIM (cores),1 ); -/* Remove all blank characters ahead and after */ -while (isblank (*corelist)) - corelist++; - i =strlen (corelist); -while ((i >0 ) &&isblank (corelist[i -1 ])) - i--; +for (int i =0 ; i < count; i++) + hp_lcores[i] = cores[i]; -/* Get list of cores */ - min =RTE_MAX_LCORE ; -do { -while (isblank (*corelist)) - corelist++; -if (*corelist =='\0' ) -return -1 ; - errno =0 ; - idx =strtoul (corelist, &end,10 ); -if (errno || end ==NULL ) -return -1 ; -while (isblank (*end)) - end++; -if (*end =='-' ) { - min = idx; - }else if ((*end ==',' ) || (*end =='\0' )) { - max = idx; -if (min ==RTE_MAX_LCORE ) - min = idx; -for (idx = min; idx <= max; idx++) { - hp_lcores[count] = idx; - count++; - } - min =RTE_MAX_LCORE ; - }else { -printf ("invalid core list\n" ); -return -1 ; - } - corelist = end +1 ; - }while (*end !='\0' ); - -if (count ==0 ) { +if (count ==0 || count ==-1 ) {printf ("invalid core list\n" );return -1 ; }
@@ -234,7 +199,7 @@ parse_perf_core_list(const char *corelist) nb_hp_lcores = count;printf ("Configured %d high performance cores\n" , nb_hp_lcores); -for (i =0 ; i < nb_hp_lcores; i++) +for (uint16_t i =0 ; i < nb_hp_lcores; i++)printf ("\tHigh performance core %d %d\n" , i, hp_lcores[i]);
Signature · 1 line
2.34.1
Re: [PATCH v3 8/8] examples/l3fwd-power: update to call arg parser API
Hi Euan,
Quoted 37 lines · Euan Bourke
Update to the l3fwd-power example application to call the arg parser library for its 'combined core string parser' instead of implementing its own corelist parser. The
default_typepassed into the function call is a corelist.Signed-off-by Euan Bourke <[email protected]>--- examples/l3fwd-power/perf_core.c | 51 +++++--------------------------- 1 file changed, 8 insertions(+), 43 deletions(-)examples/l3fwd-power/perf_core.c +3
-4@@ -12,6 +12,7 @@#include <rte_lcore.h> #include <rte_power.h> #include <rte_string_fns.h> +#include <rte_arg_parser.h> #include "perf_core.h" #include "main.h" @@ -177,56 +178,20 @@ parse_perf_config(const char *q_arg)int parse_perf_core_list (const char *corelist) { -int i, idx =0 ; -unsigned int count =0 ; -char *end =NULL ; -int min, max; +int count; +uint16_t cores[RTE_MAX_LCORE ];if (corelist ==NULL ) {printf ("invalid core list\n" );return -1 ; }
examples/l3fwd-power/perf_core.c parse_perf_config(const char *q_arg) · line 191
Quoted 10 lines
examples/l3fwd-power/perf_core.c +2
-6+ count =rte_arg_parse_core_string (corelist, cores,RTE_DIM (cores),1 ); -/* Remove all blank characters ahead and after */ -while (isblank (*corelist)) - corelist++; - i =strlen (corelist); -while ((i >0 ) &&isblank (corelist[i -1 ])) - i--; +for (int i =0 ; i < count; i++)
nit: you've used int here, but below you use uint16_t for a for loop. If you're re-spinning, it might be worth making consistent. But no biggie.
--snip--
examples/l3fwd-power/perf_core.c parse_perf_core_list(const char *corelist) · line 205
Quoted 9 lines
examples/l3fwd-power/perf_core.c +1
-1@@ -234,7 +199,7 @@ parse_perf_core_list(const char *corelist) nb_hp_lcores = count;printf ("Configured %d high performance cores\n" , nb_hp_lcores); -for (i =0 ; i < nb_hp_lcores; i++) +for (uint16_t i =0 ; i < nb_hp_lcores; i++)printf ("\tHigh performance core %d %d\n" , i, hp_lcores[i]);
I've also tested this with a 16-core incantation of l3fwd-power with various combinations of cores, seems to work well.
RE: [PATCH v3 8/8] examples/l3fwd-power: update to call arg parser API
In reply to Euan Bourke[AMD Official Use Only - General]
Hi Euan,
Quoted 40 lines
-----Original Message-----
From: Euan Bourke <[email protected]>
Sent: Thursday, December 7, 2023 9:48 PM
To: [email protected]
Cc: Euan Bourke <[email protected]>; Anatoly Burakov <[email protected]>; David Hunt <[email protected]>; Tummala, Sivaprasad <[email protected]>
Subject: [PATCH v3 8/8] examples/l3fwd-power: update to call arg parser APICaution: This message originated from an External Source. Use proper caution when opening attachments, clicking links, or responding.
Update to the l3fwd-power example application to call the arg parser library for its 'combined core string parser' instead of implementing its own corelist parser. The
default_typepassed into the function call is a corelist.Signed-off-by Euan Bourke <[email protected]>--- examples/l3fwd-power/perf_core.c | 51 +++++--------------------------- 1 file changed, 8 insertions(+), 43 deletions(-)examples/l3fwd-power/perf_core.c +1
-4@@ -12,6 +12,7 @@#include <rte_lcore.h> #include <rte_power.h> #include <rte_string_fns.h> +#include <rte_arg_parser.h> #include "perf_core.h" #include "main.h" @@ -177,56 +178,20 @@ parse_perf_config(const char *q_arg) int parse_perf_core_list(const char *corelist) { -int i, idx =0 ; -unsigned int count =0 ; -char *end =NULL ; -int min, max;
examples/l3fwd-power/perf_core.c parse_perf_config(const char *q_arg) int · line 188
Quoted 10 lines
examples/l3fwd-power/perf_core.c +4
-0+int count; +uint16_t cores[RTE_MAX_LCORE ];if (corelist ==NULL ) {printf ("invalid core list\n" );return -1 ; } + count =rte_arg_parse_core_string (corelist, cores, +RTE_DIM (cores),1 );
Can you replace the magic number with "RTE_ARG_PARSE_TYPE_CORELIST" as default parse type.
Quoted 57 lines
examples/l3fwd-power/perf_core.c +4
-40-/* Remove all blank characters ahead and after */ -while (isblank (*corelist)) - corelist++; - i =strlen (corelist); -while ((i >0 ) &&isblank (corelist[i -1 ])) - i--; +for (int i =0 ; i < count; i++) + hp_lcores[i] = cores[i]; -/* Get list of cores */ - min =RTE_MAX_LCORE ; -do { -while (isblank (*corelist)) - corelist++; -if (*corelist =='\0' ) -return -1 ; - errno =0 ; - idx =strtoul (corelist, &end,10 ); -if (errno || end ==NULL ) -return -1 ; -while (isblank (*end)) - end++; -if (*end =='-' ) { - min = idx; - }else if ((*end ==',' ) || (*end =='\0' )) { - max = idx; -if (min ==RTE_MAX_LCORE ) - min = idx; -for (idx = min; idx <= max; idx++) { - hp_lcores[count] = idx; - count++; - } - min =RTE_MAX_LCORE ; - }else { -printf ("invalid core list\n" ); -return -1 ; - } - corelist = end +1 ; - }while (*end !='\0' ); - -if (count ==0 ) { +if (count ==0 || count ==-1 ) {printf ("invalid core list\n" );return -1 ; }@@ -234,7 +199,7 @@ parse_perf_core_list(const char *corelist) nb_hp_lcores = count;printf ("Configured %d high performance cores\n" , nb_hp_lcores); -for (i =0 ; i < nb_hp_lcores; i++) +for (uint16_t i =0 ; i < nb_hp_lcores; i++)printf ("\tHigh performance core %d %d\n" , i, hp_lcores[i]); --2.34.1
Quoted 16 lines · On Thu, 7 Dec 2023 16:18:10 +0000 Euan Bourke <[email protected]> wrote:
A recent thread on the mailing list[1] discussed corelist and coremask parsing and the idea of a new library dedicated to command line parsing was mentioned[2]. This patchset adds the library, along with the new APIs, and edits the existing EAL, DLB2 driver and some example application functions to use these APIs, rather than each implementing their own copies.
The new APIs work similar to the existing functions in EAL, however instead of filling a core array like this:
[1, -1, -1, 2, 3] (a non -1 refers to an 'active core' at that index) It fills it like this:
[0, 3, 4] (with the value at each index being an 'active core').The new APIs will also return the number of cores contained in the passed corelist/coremask, so in the above example, 3 would be returned.
Quoted 9 lines
New in the v3, is a heuristic parser which searches for key markers in the core string, returning a enum value based off this search to indicate if a parameter is likely a coremask or a corelist. This heuristic function is also wrapped in a parser function allowing apps to handle both coremasks and corelists simultaneously.
[1] https://mails.dpdk.org/archives/dev/2023-November/280957.html
[2] https://mails.dpdk.org/archives/dev/2023-November/280966.html
To avoid confusion with the other work to handle better args in DPDK, maybe this should be call coreparse library?