LinuxLists.cc - [PATCH v3 0/8] support for bitmap (and hence CPU) list "N" abbreviation

[permalink] [raw]

Subject: [PATCH 2/8] lib: test_bitmap: add more start-end:offset/len tests

There are inputs to bitmap_parselist() that would probably never
be entered manually by a person, but might result from some kind of
automated input generator. Things like ranges of length 1, or group
lengths longer than nbits, overlaps, or offsets of zero.

Adding these tests serve two purposes:

1) document what might seem odd but nonetheless valid input.

2) don't regress from what we currently accept as valid.

Cc: Yury Norov <[email protected]>
Cc: Rasmus Villemoes <[email protected]>
Cc: Andy Shevchenko <[email protected]>
Signed-off-by: Paul Gortmaker <[email protected]>
---
lib/test_bitmap.c | 22 ++++++++++++++++++++++
1 file changed, 22 insertions(+)

diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c
index 3d2cd3b1de84..807d1e8dd59c 100644
--- a/lib/test_bitmap.c
+++ b/lib/test_bitmap.c
@@ -35,6 +35,8 @@ static const unsigned long exp1[] __initconst = {
BITMAP_FROM_U64(0x3333333311111111ULL),
BITMAP_FROM_U64(0xffffffff77777777ULL),
BITMAP_FROM_U64(0),
+ BITMAP_FROM_U64(0x00008000),
+ BITMAP_FROM_U64(0x80000000),
};

static const unsigned long exp2[] __initconst = {
@@ -335,6 +337,26 @@ static const struct test_bitmap_parselist parselist_tests[] __initconst = {
{0, " , ,, , , ", &exp1[12 * step], 8, 0},
{0, " , ,, , , \n", &exp1[12 * step], 8, 0},

+ {0, "0-0", &exp1[0], 32, 0},
+ {0, "1-1", &exp1[1 * step], 32, 0},
+ {0, "15-15", &exp1[13 * step], 32, 0},
+ {0, "31-31", &exp1[14 * step], 32, 0},
+
+ {0, "0-0:0/1", &exp1[12 * step], 32, 0},
+ {0, "0-0:1/1", &exp1[0], 32, 0},
+ {0, "0-0:1/31", &exp1[0], 32, 0},
+ {0, "0-0:31/31", &exp1[0], 32, 0},
+ {0, "1-1:1/1", &exp1[1 * step], 32, 0},
+ {0, "0-15:16/31", &exp1[2 * step], 32, 0},
+ {0, "15-15:1/2", &exp1[13 * step], 32, 0},
+ {0, "15-15:31/31", &exp1[13 * step], 32, 0},
+ {0, "15-31:1/31", &exp1[13 * step], 32, 0},
+ {0, "16-31:16/31", &exp1[3 * step], 32, 0},
+ {0, "31-31:31/31", &exp1[14 * step], 32, 0},
+
+ {0, "0-31:1/3,1-31:1/3,2-31:1/3", &exp1[8 * step], 32, 0},
+ {0, "1-10:8/12,8-31:24/29,0-31:0/3", &exp1[9 * step], 32, 0},
+
{-EINVAL, "-1", NULL, 8, 0},
{-EINVAL, "-0", NULL, 8, 0},
{-EINVAL, "10-1", NULL, 8, 0}, /* (start > end) ; also ERANGE */
--
2.17.1

2021-01-27 00:45:18

[permalink] [raw]

Subject: [PATCH 6/8] lib: bitmap: support "N" as an alias for size of bitmap

While this is done for all bitmaps, the original use case in mind was
for CPU masks and cpulist_parse() as described below.

It seems that a common configuration is to use the 1st couple cores for
housekeeping tasks. This tends to leave the remaining ones to form a
pool of similarly configured cores to take on the real workload of
interest to the user.

So on machine A - with 32 cores, it could be 0-3 for "system" and then
4-31 being used in boot args like nohz_full=, or rcu_nocbs= as part of
setting up the worker pool of CPUs.

But then newer machine B is added, and it has 48 cores, and so while
the 0-3 part remains unchanged, the pool setup cpu list becomes 4-47.

Multiple deployment becomes easier when we can just simply replace 31
and 47 with "N" and let the system substitute in the actual number at
boot; a number that it knows better than we do.

Cc: Yury Norov <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: "Paul E. McKenney" <[email protected]>
Cc: Rasmus Villemoes <[email protected]>
Cc: Andy Shevchenko <[email protected]>
Suggested-by: Yury Norov <[email protected]>
Signed-off-by: Paul Gortmaker <[email protected]>
---
Documentation/admin-guide/kernel-parameters.rst | 2 ++
lib/bitmap.c | 12 ++++++++++--
2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/Documentation/admin-guide/kernel-parameters.rst b/Documentation/admin-guide/kernel-parameters.rst
index 682ab28b5c94..850917f19476 100644
--- a/Documentation/admin-guide/kernel-parameters.rst
+++ b/Documentation/admin-guide/kernel-parameters.rst
@@ -68,6 +68,8 @@ For example one can add to the command line following parameter:

where the final item represents CPUs 100,101,125,126,150,151,...

+The value "N" can be used to represent the numerically last CPU on the system,
+i.e "foo_cpus=16-N" would be equivalent to "16-31" on a 32 core system.

This document may not be entirely up to date and comprehensive. The command
diff --git a/lib/bitmap.c b/lib/bitmap.c
index f65be2f148fd..2fdd00b312c3 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -519,11 +519,17 @@ static int bitmap_check_region(const struct region *r)
return 0;
}

-static const char *bitmap_getnum(const char *str, unsigned int *num)
+static const char *__bitmap_getnum(const char *str, unsigned int nbits,
+ unsigned int *num)
{
unsigned long long n;
unsigned int len;

+ if (str[0] == 'N') {
+ *num = nbits - 1;
+ return str + 1;
+ }
+
len = _parse_integer(str, 10, &n);
if (!len)
return ERR_PTR(-EINVAL);
@@ -533,7 +539,7 @@ static const char *bitmap_getnum(const char *str, unsigned int *num)
*num = n;
return str + len;
}
-#define bitmap_getrnum(s, r, pos) bitmap_getnum(s, &(r->pos))
+#define bitmap_getrnum(s, r, pos) __bitmap_getnum(s, r->nbits, &(r->pos))

static inline bool end_of_str(char c)
{
@@ -626,6 +632,8 @@ static const char *bitmap_parse_region(const char *str, struct region *r)
* From each group will be used only defined amount of bits.
* Syntax: range:used_size/group_size
* Example: 0-1023:2/256 ==> 0,1,256,257,512,513,768,769
+ * The value 'N' can be used as a dynamically substituted token for the
+ * maximum allowed value; i.e (nmaskbits - 1).
*
* Returns: 0 on success, -errno on invalid input strings. Error values:
*
--
2.17.1

2021-01-27 00:46:07

[permalink] [raw]

Subject: [PATCH 5/8] lib: bitmap_getnum: separate arg into region and field

The bitmap_getnum is only used on a region's start/end/off/group_len
field. Trivially decouple the region from the field so that the region
pointer is available for a pending change.

Cc: Yury Norov <[email protected]>
Cc: Rasmus Villemoes <[email protected]>
Cc: Andy Shevchenko <[email protected]>
Signed-off-by: Paul Gortmaker <[email protected]>
---
lib/bitmap.c | 9 +++++----
1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/bitmap.c b/lib/bitmap.c
index 833f152a2c43..f65be2f148fd 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -533,6 +533,7 @@ static const char *bitmap_getnum(const char *str, unsigned int *num)
*num = n;
return str + len;
}
+#define bitmap_getrnum(s, r, pos) bitmap_getnum(s, &(r->pos))

static inline bool end_of_str(char c)
{
@@ -571,7 +572,7 @@ static const char *bitmap_find_region_reverse(const char *start, const char *end

static const char *bitmap_parse_region(const char *str, struct region *r)
{
- str = bitmap_getnum(str, &r->start);
+ str = bitmap_getrnum(str, r, start);
if (IS_ERR(str))
return str;

@@ -581,7 +582,7 @@ static const char *bitmap_parse_region(const char *str, struct region *r)
if (*str != '-')
return ERR_PTR(-EINVAL);

- str = bitmap_getnum(str + 1, &r->end);
+ str = bitmap_getrnum(str + 1, r, end);
if (IS_ERR(str))
return str;

@@ -591,14 +592,14 @@ static const char *bitmap_parse_region(const char *str, struct region *r)
if (*str != ':')
return ERR_PTR(-EINVAL);

- str = bitmap_getnum(str + 1, &r->off);
+ str = bitmap_getrnum(str + 1, r, off);
if (IS_ERR(str))
return str;

if (*str != '/')
return ERR_PTR(-EINVAL);

- return bitmap_getnum(str + 1, &r->group_len);
+ return bitmap_getrnum(str + 1, r, group_len);

no_end:
r->end = r->start;
--
2.17.1

2021-01-27 06:44:50

[permalink] [raw]

Subject: [PATCH 8/8] rcu: deprecate "all" option to rcu_nocbs=

With the core bitmap support now accepting "N" as a placeholder for
the end of the bitmap, "all" can be represented as "0-N" and has the
advantage of not being specific to RCU (or any other subsystem).

So deprecate the use of "all" by removing documentation references
to it. The support itself needs to remain for now, since we don't
know how many people out there are using it currently, but since it
is in an __init area anyway, it isn't worth losing sleep over.

Cc: Yury Norov <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: "Paul E. McKenney" <[email protected]>
Cc: Josh Triplett <[email protected]>
Signed-off-by: Paul Gortmaker <[email protected]>
---
Documentation/admin-guide/kernel-parameters.txt | 4 +---
kernel/rcu/tree_plugin.h | 6 ++----
2 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index a10b545c2070..a116c0ff0a91 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -4037,9 +4037,7 @@
see CONFIG_RAS_CEC help text.

rcu_nocbs= [KNL]
- The argument is a cpu list, as described above,
- except that the string "all" can be used to
- specify every CPU on the system.
+ The argument is a cpu list, as described above.

In kernels built with CONFIG_RCU_NOCB_CPU=y, set
the specified list of CPUs to be no-callback CPUs.
diff --git a/kernel/rcu/tree_plugin.h b/kernel/rcu/tree_plugin.h
index 7e291ce0a1d6..56788dfde922 100644
--- a/kernel/rcu/tree_plugin.h
+++ b/kernel/rcu/tree_plugin.h
@@ -1463,14 +1463,12 @@ static void rcu_cleanup_after_idle(void)

/*
* Parse the boot-time rcu_nocb_mask CPU list from the kernel parameters.
- * The string after the "rcu_nocbs=" is either "all" for all CPUs, or a
- * comma-separated list of CPUs and/or CPU ranges. If an invalid list is
- * given, a warning is emitted and all CPUs are offloaded.
+ * If the list is invalid, a warning is emitted and all CPUs are offloaded.
*/
static int __init rcu_nocb_setup(char *str)
{
alloc_bootmem_cpumask_var(&rcu_nocb_mask);
- if (!strcasecmp(str, "all"))
+ if (!strcasecmp(str, "all")) /* legacy: use "0-N" instead */
cpumask_setall(rcu_nocb_mask);
else
if (cpulist_parse(str, rcu_nocb_mask)) {
--
2.17.1

2021-01-27 19:53:37

[permalink] [raw]

Subject: Re: [PATCH 2/8] lib: test_bitmap: add more start-end:offset/len tests

On Tue, Jan 26, 2021 at 12:11:35PM -0500, Paul Gortmaker wrote:
> There are inputs to bitmap_parselist() that would probably never
> be entered manually by a person, but might result from some kind of
> automated input generator. Things like ranges of length 1, or group
> lengths longer than nbits, overlaps, or offsets of zero.
>
> Adding these tests serve two purposes:
>
> 1) document what might seem odd but nonetheless valid input.
>
> 2) don't regress from what we currently accept as valid.

Makes sense.
Reviewed-by: Andy Shevchenko <[email protected]>

> Cc: Yury Norov <[email protected]>
> Cc: Rasmus Villemoes <[email protected]>
> Cc: Andy Shevchenko <[email protected]>
> Signed-off-by: Paul Gortmaker <[email protected]>
> ---
> lib/test_bitmap.c | 22 ++++++++++++++++++++++
> 1 file changed, 22 insertions(+)
>
> diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c
> index 3d2cd3b1de84..807d1e8dd59c 100644
> --- a/lib/test_bitmap.c
> +++ b/lib/test_bitmap.c
> @@ -35,6 +35,8 @@ static const unsigned long exp1[] __initconst = {
> BITMAP_FROM_U64(0x3333333311111111ULL),
> BITMAP_FROM_U64(0xffffffff77777777ULL),
> BITMAP_FROM_U64(0),
> + BITMAP_FROM_U64(0x00008000),
> + BITMAP_FROM_U64(0x80000000),
> };
>
> static const unsigned long exp2[] __initconst = {
> @@ -335,6 +337,26 @@ static const struct test_bitmap_parselist parselist_tests[] __initconst = {
> {0, " , ,, , , ", &exp1[12 * step], 8, 0},
> {0, " , ,, , , \n", &exp1[12 * step], 8, 0},
>
> + {0, "0-0", &exp1[0], 32, 0},
> + {0, "1-1", &exp1[1 * step], 32, 0},
> + {0, "15-15", &exp1[13 * step], 32, 0},
> + {0, "31-31", &exp1[14 * step], 32, 0},
> +
> + {0, "0-0:0/1", &exp1[12 * step], 32, 0},
> + {0, "0-0:1/1", &exp1[0], 32, 0},
> + {0, "0-0:1/31", &exp1[0], 32, 0},
> + {0, "0-0:31/31", &exp1[0], 32, 0},
> + {0, "1-1:1/1", &exp1[1 * step], 32, 0},
> + {0, "0-15:16/31", &exp1[2 * step], 32, 0},
> + {0, "15-15:1/2", &exp1[13 * step], 32, 0},
> + {0, "15-15:31/31", &exp1[13 * step], 32, 0},
> + {0, "15-31:1/31", &exp1[13 * step], 32, 0},
> + {0, "16-31:16/31", &exp1[3 * step], 32, 0},
> + {0, "31-31:31/31", &exp1[14 * step], 32, 0},
> +
> + {0, "0-31:1/3,1-31:1/3,2-31:1/3", &exp1[8 * step], 32, 0},
> + {0, "1-10:8/12,8-31:24/29,0-31:0/3", &exp1[9 * step], 32, 0},
> +
> {-EINVAL, "-1", NULL, 8, 0},
> {-EINVAL, "-0", NULL, 8, 0},
> {-EINVAL, "10-1", NULL, 8, 0}, /* (start > end) ; also ERANGE */
> --
> 2.17.1
>

--
With Best Regards,
Andy Shevchenko

2021-01-27 19:54:53

[permalink] [raw]

Subject: Re: [PATCH 5/8] lib: bitmap_getnum: separate arg into region and field

On Tue, Jan 26, 2021 at 12:11:38PM -0500, Paul Gortmaker wrote:
> The bitmap_getnum is only used on a region's start/end/off/group_len
> field. Trivially decouple the region from the field so that the region
> pointer is available for a pending change.

Honestly, I don't like this macro trick. It's bad in couple of ways:
- it hides what actually is done with the fields of r structure
(after you get that they are fields!)
- it breaks possibility to compile time (type) checks

I will listen what others say, but I'm in favour not to proceed like this.

> Cc: Yury Norov <[email protected]>
> Cc: Rasmus Villemoes <[email protected]>
> Cc: Andy Shevchenko <[email protected]>
> Signed-off-by: Paul Gortmaker <[email protected]>
> ---
> lib/bitmap.c | 9 +++++----
> 1 file changed, 5 insertions(+), 4 deletions(-)
>
> diff --git a/lib/bitmap.c b/lib/bitmap.c
> index 833f152a2c43..f65be2f148fd 100644
> --- a/lib/bitmap.c
> +++ b/lib/bitmap.c
> @@ -533,6 +533,7 @@ static const char *bitmap_getnum(const char *str, unsigned int *num)
> *num = n;
> return str + len;
> }
> +#define bitmap_getrnum(s, r, pos) bitmap_getnum(s, &(r->pos))
>
> static inline bool end_of_str(char c)
> {
> @@ -571,7 +572,7 @@ static const char *bitmap_find_region_reverse(const char *start, const char *end
>
> static const char *bitmap_parse_region(const char *str, struct region *r)
> {
> - str = bitmap_getnum(str, &r->start);
> + str = bitmap_getrnum(str, r, start);
> if (IS_ERR(str))
> return str;
>
> @@ -581,7 +582,7 @@ static const char *bitmap_parse_region(const char *str, struct region *r)
> if (*str != '-')
> return ERR_PTR(-EINVAL);
>
> - str = bitmap_getnum(str + 1, &r->end);
> + str = bitmap_getrnum(str + 1, r, end);
> if (IS_ERR(str))
> return str;
>
> @@ -591,14 +592,14 @@ static const char *bitmap_parse_region(const char *str, struct region *r)
> if (*str != ':')
> return ERR_PTR(-EINVAL);
>
> - str = bitmap_getnum(str + 1, &r->off);
> + str = bitmap_getrnum(str + 1, r, off);
> if (IS_ERR(str))
> return str;
>
> if (*str != '/')
> return ERR_PTR(-EINVAL);
>
> - return bitmap_getnum(str + 1, &r->group_len);
> + return bitmap_getrnum(str + 1, r, group_len);
>
> no_end:
> r->end = r->start;
> --
> 2.17.1
>

--
With Best Regards,
Andy Shevchenko

2021-01-27 19:55:47

[permalink] [raw]

Subject: Re: [PATCH 6/8] lib: bitmap: support "N" as an alias for size of bitmap

On Tue, Jan 26, 2021 at 12:11:39PM -0500, Paul Gortmaker wrote:
> While this is done for all bitmaps, the original use case in mind was
> for CPU masks and cpulist_parse() as described below.
>
> It seems that a common configuration is to use the 1st couple cores for
> housekeeping tasks. This tends to leave the remaining ones to form a
> pool of similarly configured cores to take on the real workload of
> interest to the user.
>
> So on machine A - with 32 cores, it could be 0-3 for "system" and then
> 4-31 being used in boot args like nohz_full=, or rcu_nocbs= as part of
> setting up the worker pool of CPUs.
>
> But then newer machine B is added, and it has 48 cores, and so while
> the 0-3 part remains unchanged, the pool setup cpu list becomes 4-47.
>
> Multiple deployment becomes easier when we can just simply replace 31
> and 47 with "N" and let the system substitute in the actual number at
> boot; a number that it knows better than we do.

I would accept lower 'n' as well.

...

> -static const char *bitmap_getnum(const char *str, unsigned int *num)
> +static const char *__bitmap_getnum(const char *str, unsigned int nbits,
> + unsigned int *num)
> {
> unsigned long long n;
> unsigned int len;
>
> + if (str[0] == 'N') {
> + *num = nbits - 1;
> + return str + 1;
> + }

But locating it here makes possible to enter a priori invalid input, like N for
start of the region.

I think this should be separate helper which is called in places where it makes
sense.

> len = _parse_integer(str, 10, &n);
> if (!len)
> return ERR_PTR(-EINVAL);

--
With Best Regards,
Andy Shevchenko

2021-01-27 19:55:52

[permalink] [raw]

Subject: Re: [PATCH 6/8] lib: bitmap: support "N" as an alias for size of bitmap

On Tue, Jan 26, 2021 at 11:37:30PM +0200, Andy Shevchenko wrote:
> On Tue, Jan 26, 2021 at 12:11:39PM -0500, Paul Gortmaker wrote:

...

> > + if (str[0] == 'N') {
> > + *num = nbits - 1;
> > + return str + 1;
> > + }
>
> But locating it here makes possible to enter a priori invalid input, like N for
> start of the region.
>
> I think this should be separate helper which is called in places where it makes
> sense.

Okay, N is 31 on 32 core system... It is a bit counter intuitive, because it's
rather _L_ast than _N_umber of CPUs.

Changing letter?

--
With Best Regards,
Andy Shevchenko

2021-01-27 19:57:32

[permalink] [raw]

Subject: Re: [PATCH 8/8] rcu: deprecate "all" option to rcu_nocbs=

On Tue, Jan 26, 2021 at 9:12 AM Paul Gortmaker
<[email protected]> wrote:
>
> With the core bitmap support now accepting "N" as a placeholder for
> the end of the bitmap, "all" can be represented as "0-N" and has the
> advantage of not being specific to RCU (or any other subsystem).
>
> So deprecate the use of "all" by removing documentation references
> to it. The support itself needs to remain for now, since we don't
> know how many people out there are using it currently, but since it
> is in an __init area anyway, it isn't worth losing sleep over.
>
> Cc: Yury Norov <[email protected]>
> Cc: Peter Zijlstra <[email protected]>
> Cc: "Paul E. McKenney" <[email protected]>
> Cc: Josh Triplett <[email protected]>
> Signed-off-by: Paul Gortmaker <[email protected]>
> ---
> Documentation/admin-guide/kernel-parameters.txt | 4 +---
> kernel/rcu/tree_plugin.h | 6 ++----
> 2 files changed, 3 insertions(+), 7 deletions(-)
>
> diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
> index a10b545c2070..a116c0ff0a91 100644
> --- a/Documentation/admin-guide/kernel-parameters.txt
> +++ b/Documentation/admin-guide/kernel-parameters.txt
> @@ -4037,9 +4037,7 @@
> see CONFIG_RAS_CEC help text.
>
> rcu_nocbs= [KNL]
> - The argument is a cpu list, as described above,
> - except that the string "all" can be used to
> - specify every CPU on the system.
> + The argument is a cpu list, as described above.
>
> In kernels built with CONFIG_RCU_NOCB_CPU=y, set
> the specified list of CPUs to be no-callback CPUs.
> diff --git a/kernel/rcu/tree_plugin.h b/kernel/rcu/tree_plugin.h
> index 7e291ce0a1d6..56788dfde922 100644
> --- a/kernel/rcu/tree_plugin.h
> +++ b/kernel/rcu/tree_plugin.h
> @@ -1463,14 +1463,12 @@ static void rcu_cleanup_after_idle(void)
>
> /*
> * Parse the boot-time rcu_nocb_mask CPU list from the kernel parameters.
> - * The string after the "rcu_nocbs=" is either "all" for all CPUs, or a
> - * comma-separated list of CPUs and/or CPU ranges. If an invalid list is
> - * given, a warning is emitted and all CPUs are offloaded.
> + * If the list is invalid, a warning is emitted and all CPUs are offloaded.
> */
> static int __init rcu_nocb_setup(char *str)
> {
> alloc_bootmem_cpumask_var(&rcu_nocb_mask);
> - if (!strcasecmp(str, "all"))
> + if (!strcasecmp(str, "all")) /* legacy: use "0-N" instead */

I think 'all' and 'none' is a good idea. It's simple and convenient.
But if you don't
like it, can you please at least put this comment in system log using
WARN_ON_ONCE(). It's quite possible that Linux users don't read source code
comments.

> cpumask_setall(rcu_nocb_mask);
> else
> if (cpulist_parse(str, rcu_nocb_mask)) {
> --
> 2.17.1
>

2021-01-27 19:59:17

by Paul E. McKenney

[permalink] [raw]

Subject: Re: [PATCH 8/8] rcu: deprecate "all" option to rcu_nocbs=

On Tue, Jan 26, 2021 at 01:36:23PM -0800, Yury Norov wrote:
> On Tue, Jan 26, 2021 at 9:12 AM Paul Gortmaker
> <[email protected]> wrote:
> >
> > With the core bitmap support now accepting "N" as a placeholder for
> > the end of the bitmap, "all" can be represented as "0-N" and has the
> > advantage of not being specific to RCU (or any other subsystem).
> >
> > So deprecate the use of "all" by removing documentation references
> > to it. The support itself needs to remain for now, since we don't
> > know how many people out there are using it currently, but since it
> > is in an __init area anyway, it isn't worth losing sleep over.
> >
> > Cc: Yury Norov <[email protected]>
> > Cc: Peter Zijlstra <[email protected]>
> > Cc: "Paul E. McKenney" <[email protected]>
> > Cc: Josh Triplett <[email protected]>
> > Signed-off-by: Paul Gortmaker <[email protected]>
> > ---
> > Documentation/admin-guide/kernel-parameters.txt | 4 +---
> > kernel/rcu/tree_plugin.h | 6 ++----
> > 2 files changed, 3 insertions(+), 7 deletions(-)
> >
> > diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
> > index a10b545c2070..a116c0ff0a91 100644
> > --- a/Documentation/admin-guide/kernel-parameters.txt
> > +++ b/Documentation/admin-guide/kernel-parameters.txt
> > @@ -4037,9 +4037,7 @@
> > see CONFIG_RAS_CEC help text.
> >
> > rcu_nocbs= [KNL]
> > - The argument is a cpu list, as described above,
> > - except that the string "all" can be used to
> > - specify every CPU on the system.
> > + The argument is a cpu list, as described above.
> >
> > In kernels built with CONFIG_RCU_NOCB_CPU=y, set
> > the specified list of CPUs to be no-callback CPUs.
> > diff --git a/kernel/rcu/tree_plugin.h b/kernel/rcu/tree_plugin.h
> > index 7e291ce0a1d6..56788dfde922 100644
> > --- a/kernel/rcu/tree_plugin.h
> > +++ b/kernel/rcu/tree_plugin.h
> > @@ -1463,14 +1463,12 @@ static void rcu_cleanup_after_idle(void)
> >
> > /*
> > * Parse the boot-time rcu_nocb_mask CPU list from the kernel parameters.
> > - * The string after the "rcu_nocbs=" is either "all" for all CPUs, or a
> > - * comma-separated list of CPUs and/or CPU ranges. If an invalid list is
> > - * given, a warning is emitted and all CPUs are offloaded.
> > + * If the list is invalid, a warning is emitted and all CPUs are offloaded.
> > */
> > static int __init rcu_nocb_setup(char *str)
> > {
> > alloc_bootmem_cpumask_var(&rcu_nocb_mask);
> > - if (!strcasecmp(str, "all"))
> > + if (!strcasecmp(str, "all")) /* legacy: use "0-N" instead */
>
> I think 'all' and 'none' is a good idea. It's simple and convenient.
> But if you don't
> like it, can you please at least put this comment in system log using
> WARN_ON_ONCE(). It's quite possible that Linux users don't read source code
> comments.

Please leave it silent. This has been available to RCU users for
quite some time, so suddenly spewing warnings at all of them is a bit
unfriendly. The extra code is negligible, and the documentation will
guide people more gently in the right direction. Plus I am the one who
would end up receiving complaints about the warnings, and I have much
better things to do with my time.

Thanx, Paul

> > cpumask_setall(rcu_nocb_mask);
> > else
> > if (cpulist_parse(str, rcu_nocb_mask)) {
> > --
> > 2.17.1
> >

2021-01-27 20:02:24

[permalink] [raw]

Subject: Re: [PATCH v3 0/8] support for bitmap (and hence CPU) list "N" abbreviation

On Tue, Jan 26, 2021 at 9:12 AM Paul Gortmaker
<[email protected]> wrote:
>
> The basic objective here was to add support for "nohz_full=8-N" and/or
> "rcu_nocbs="4-N" -- essentially introduce "N" as a portable reference
> to the last core, evaluated at boot for anything using a CPU list.
>
> The thinking behind this, is that people carve off a few early CPUs to
> support housekeeping tasks, and perhaps dedicate one to a busy I/O
> peripheral, and then the remaining pool of CPUs out to the end are a
> part of a commonly configured pool used for the real work the user
> cares about.
>
> Extend that logic out to a fleet of machines - some new, and some
> nearing EOL, and you've probably got a wide range of core counts to
> contend with - even though the early number of cores dedicated to the
> system overhead probably doesn't vary.
>
> This change would enable sysadmins to have a common bootarg across all
> such systems, and would also avoid any off-by-one fencepost errors that
> happen for users who might briefly forget that core counts start at zero.
>
> Originally I did this at the CPU subsys level, but Yury suggested it
> be moved down further to bitmap level itself, which made the core
> implementation [6/8] smaller and less complex, but the series longer.
>
> New self tests are added to better exercise what bitmap range/region
> currently supports, and new tests are added for the new "N" support.
>
> Also tested boot arg and the post-boot cgroup use case as per below:
>
> root@hackbox:~# cat /proc/cmdline
> BOOT_IMAGE=/boot/bzImage root=/dev/sda1 rcu_nocbs=2,3,8-N:1/2
> root@hackbox:~# dmesg|grep Offl
> rcu: Offload RCU callbacks from CPUs: 2-3,8,10,12,14.
>
> root@hackbox:/sys/fs/cgroup/cpuset/foo# cat cpuset.cpus
>
> root@hackbox:/sys/fs/cgroup/cpuset/foo# /bin/echo 10-N > cpuset.cpus
> root@hackbox:/sys/fs/cgroup/cpuset/foo# cat cpuset.cpus
> 10-15
> root@hackbox:/sys/fs/cgroup/cpuset/foo# /bin/echo N-N:N/N > cpuset.cpus
> root@hackbox:/sys/fs/cgroup/cpuset/foo# cat cpuset.cpus
> 15
>
> This was on a 16 core machine with CONFIG_NR_CPUS=16 in .config file.
>
> Note that "N" is a dynamic quantity, and can change scope if the bitmap
> is changed in size. So at the risk of stating the obvious, don't use it
> for "burn_eFuse=128-N" or "secure_erase_firmware=32-N" type stuff.

I think it's worth moving this sentence to the Documentation. Another
caveat with
N is that users' config may surprisingly become invalid, like if user
says 32-N, and
on some machine with a smaller bitmap this config fails to boot.

It doesn't mean of course that I'm against 'N'. I think it's very
useful especially in
such common cases like "N", "0-N", "1-N".

Would it make sense to treat the mask "32-N" when N < 32 as N-N,
and bark something in dmesg?

> Paul.
> ---
>
> [v1: https://lore.kernel.org/lkml/20210106004850.GA11682@paulmck-ThinkPad-P72/
>
> [v2: push code down from cpu subsys to core bitmap code as per
> Yury's comments. Change "last" to simply be "N" as per PeterZ.]
> https://lore.kernel.org/lkml/[email protected]/
>
> [v3: Allow "N" to be used anywhere in the region spec, i.e. "N-N:N/N" vs.
> just being allowed at end of range like "0-N". Add new self-tests. Drop
> "all" and "none" aliases as redundant and not worth the extra complication. ]
>
> Cc: Li Zefan <[email protected]>
> Cc: Ingo Molnar <[email protected]>
> Cc: Yury Norov <[email protected]>
> Cc: Thomas Gleixner <[email protected]>
> Cc: Josh Triplett <[email protected]>
> Cc: Peter Zijlstra <[email protected]>
> Cc: "Paul E. McKenney" <[email protected]>
> Cc: Frederic Weisbecker <[email protected]>
> Cc: Rasmus Villemoes <[email protected]>
> Cc: Andy Shevchenko <[email protected]>
>
> ---
>
> Paul Gortmaker (8):
> lib: test_bitmap: clearly separate ERANGE from EINVAL tests.
> lib: test_bitmap: add more start-end:offset/len tests
> lib: bitmap: fold nbits into region struct
> lib: bitmap: move ERANGE check from set_region to check_region
> lib: bitmap_getnum: separate arg into region and field
> lib: bitmap: support "N" as an alias for size of bitmap
> lib: test_bitmap: add tests for "N" alias
> rcu: deprecate "all" option to rcu_nocbs=
>
> .../admin-guide/kernel-parameters.rst | 2 +
> .../admin-guide/kernel-parameters.txt | 4 +-
> kernel/rcu/tree_plugin.h | 6 +--
> lib/bitmap.c | 46 ++++++++++--------
> lib/test_bitmap.c | 48 ++++++++++++++++---
> 5 files changed, 72 insertions(+), 34 deletions(-)
>
> --
> 2.17.1
>

2021-01-27 20:58:46

[permalink] [raw]

Subject: Re: [PATCH 5/8] lib: bitmap_getnum: separate arg into region and field

On Tue, Jan 26, 2021 at 1:22 PM Andy Shevchenko
<[email protected]> wrote:
>
> On Tue, Jan 26, 2021 at 12:11:38PM -0500, Paul Gortmaker wrote:
> > The bitmap_getnum is only used on a region's start/end/off/group_len
> > field. Trivially decouple the region from the field so that the region
> > pointer is available for a pending change.
>
> Honestly, I don't like this macro trick. It's bad in couple of ways:
> - it hides what actually is done with the fields of r structure
> (after you get that they are fields!)
> - it breaks possibility to compile time (type) checks
>
> I will listen what others say, but I'm in favour not to proceed like this.

Agree. Would be better to drop the patch. Paul, what kind of pending
change do you mean here? All the following patches are not related to
parsing machinery.

> > Cc: Yury Norov <[email protected]>
> > Cc: Rasmus Villemoes <[email protected]>
> > Cc: Andy Shevchenko <[email protected]>
> > Signed-off-by: Paul Gortmaker <[email protected]>
> > ---
> > lib/bitmap.c | 9 +++++----
> > 1 file changed, 5 insertions(+), 4 deletions(-)
> >
> > diff --git a/lib/bitmap.c b/lib/bitmap.c
> > index 833f152a2c43..f65be2f148fd 100644
> > --- a/lib/bitmap.c
> > +++ b/lib/bitmap.c
> > @@ -533,6 +533,7 @@ static const char *bitmap_getnum(const char *str, unsigned int *num)
> > *num = n;
> > return str + len;
> > }
> > +#define bitmap_getrnum(s, r, pos) bitmap_getnum(s, &(r->pos))
> >
> > static inline bool end_of_str(char c)
> > {
> > @@ -571,7 +572,7 @@ static const char *bitmap_find_region_reverse(const char *start, const char *end
> >
> > static const char *bitmap_parse_region(const char *str, struct region *r)
> > {
> > - str = bitmap_getnum(str, &r->start);
> > + str = bitmap_getrnum(str, r, start);
> > if (IS_ERR(str))
> > return str;
> >
> > @@ -581,7 +582,7 @@ static const char *bitmap_parse_region(const char *str, struct region *r)
> > if (*str != '-')
> > return ERR_PTR(-EINVAL);
> >
> > - str = bitmap_getnum(str + 1, &r->end);
> > + str = bitmap_getrnum(str + 1, r, end);
> > if (IS_ERR(str))
> > return str;
> >
> > @@ -591,14 +592,14 @@ static const char *bitmap_parse_region(const char *str, struct region *r)
> > if (*str != ':')
> > return ERR_PTR(-EINVAL);
> >
> > - str = bitmap_getnum(str + 1, &r->off);
> > + str = bitmap_getrnum(str + 1, r, off);
> > if (IS_ERR(str))
> > return str;
> >
> > if (*str != '/')
> > return ERR_PTR(-EINVAL);
> >
> > - return bitmap_getnum(str + 1, &r->group_len);
> > + return bitmap_getrnum(str + 1, r, group_len);
> >
> > no_end:
> > r->end = r->start;
> > --
> > 2.17.1
> >
>
> --
> With Best Regards,
> Andy Shevchenko
>
>

2021-01-27 21:00:22

[permalink] [raw]

Subject: Re: [PATCH 2/8] lib: test_bitmap: add more start-end:offset/len tests

On Tue, Jan 26, 2021 at 9:12 AM Paul Gortmaker
<[email protected]> wrote:
>
> There are inputs to bitmap_parselist() that would probably never
> be entered manually by a person, but might result from some kind of
> automated input generator. Things like ranges of length 1, or group
> lengths longer than nbits, overlaps, or offsets of zero.
>
> Adding these tests serve two purposes:
>
> 1) document what might seem odd but nonetheless valid input.
>
> 2) don't regress from what we currently accept as valid.
>
> Cc: Yury Norov <[email protected]>
> Cc: Rasmus Villemoes <[email protected]>
> Cc: Andy Shevchenko <[email protected]>
> Signed-off-by: Paul Gortmaker <[email protected]>
> ---
> lib/test_bitmap.c | 22 ++++++++++++++++++++++
> 1 file changed, 22 insertions(+)
>
> diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c
> index 3d2cd3b1de84..807d1e8dd59c 100644
> --- a/lib/test_bitmap.c
> +++ b/lib/test_bitmap.c
> @@ -35,6 +35,8 @@ static const unsigned long exp1[] __initconst = {
> BITMAP_FROM_U64(0x3333333311111111ULL),
> BITMAP_FROM_U64(0xffffffff77777777ULL),
> BITMAP_FROM_U64(0),
> + BITMAP_FROM_U64(0x00008000),
> + BITMAP_FROM_U64(0x80000000),
> };
>
> static const unsigned long exp2[] __initconst = {
> @@ -335,6 +337,26 @@ static const struct test_bitmap_parselist parselist_tests[] __initconst = {
> {0, " , ,, , , ", &exp1[12 * step], 8, 0},
> {0, " , ,, , , \n", &exp1[12 * step], 8, 0},
>
> + {0, "0-0", &exp1[0], 32, 0},
> + {0, "1-1", &exp1[1 * step], 32, 0},
> + {0, "15-15", &exp1[13 * step], 32, 0},
> + {0, "31-31", &exp1[14 * step], 32, 0},
> +
> + {0, "0-0:0/1", &exp1[12 * step], 32, 0},
> + {0, "0-0:1/1", &exp1[0], 32, 0},
> + {0, "0-0:1/31", &exp1[0], 32, 0},
> + {0, "0-0:31/31", &exp1[0], 32, 0},
> + {0, "1-1:1/1", &exp1[1 * step], 32, 0},
> + {0, "0-15:16/31", &exp1[2 * step], 32, 0},
> + {0, "15-15:1/2", &exp1[13 * step], 32, 0},
> + {0, "15-15:31/31", &exp1[13 * step], 32, 0},
> + {0, "15-31:1/31", &exp1[13 * step], 32, 0},
> + {0, "16-31:16/31", &exp1[3 * step], 32, 0},
> + {0, "31-31:31/31", &exp1[14 * step], 32, 0},
> +
> + {0, "0-31:1/3,1-31:1/3,2-31:1/3", &exp1[8 * step], 32, 0},
> + {0, "1-10:8/12,8-31:24/29,0-31:0/3", &exp1[9 * step], 32, 0},
> +
> {-EINVAL, "-1", NULL, 8, 0},
> {-EINVAL, "-0", NULL, 8, 0},
> {-EINVAL, "10-1", NULL, 8, 0}, /* (start > end) ; also ERANGE */
> --
> 2.17.1

Acked-by: Yury Norov <[email protected]>

2021-01-27 21:38:02

[permalink] [raw]

Subject: Re: [PATCH 6/8] lib: bitmap: support "N" as an alias for size of bitmap

[Re: [PATCH 6/8] lib: bitmap: support "N" as an alias for size of bitmap] On 26/01/2021 (Tue 23:37) Andy Shevchenko wrote:

> On Tue, Jan 26, 2021 at 12:11:39PM -0500, Paul Gortmaker wrote:
> > While this is done for all bitmaps, the original use case in mind was
> > for CPU masks and cpulist_parse() as described below.
> >
> > It seems that a common configuration is to use the 1st couple cores for
> > housekeeping tasks. This tends to leave the remaining ones to form a
> > pool of similarly configured cores to take on the real workload of
> > interest to the user.
> >
> > So on machine A - with 32 cores, it could be 0-3 for "system" and then
> > 4-31 being used in boot args like nohz_full=, or rcu_nocbs= as part of
> > setting up the worker pool of CPUs.
> >
> > But then newer machine B is added, and it has 48 cores, and so while
> > the 0-3 part remains unchanged, the pool setup cpu list becomes 4-47.
> >
> > Multiple deployment becomes easier when we can just simply replace 31
> > and 47 with "N" and let the system substitute in the actual number at
> > boot; a number that it knows better than we do.
>
> I would accept lower 'n' as well.
>
> ...
>
> > -static const char *bitmap_getnum(const char *str, unsigned int *num)
> > +static const char *__bitmap_getnum(const char *str, unsigned int nbits,
> > + unsigned int *num)
> > {
> > unsigned long long n;
> > unsigned int len;
> >
> > + if (str[0] == 'N') {
> > + *num = nbits - 1;
> > + return str + 1;
> > + }
>
> But locating it here makes possible to enter a priori invalid input, like N for
> start of the region.

Actually, no. N can be valid input for start of the region - or for any
field in the region. I was originally thinking like you -- that N
was only valid as the end of the region, but Yury made a compelling
argument that N should be treated exactly as any other number is.

Skip down to where Yury says:
So, when I do echo N-N > cpuset.cpus, I want it to work as
if I do echo 15-15 > cpuset.cpus.

https://lore.kernel.org/lkml/[email protected]/

You weren't Cc'd at that point as I'd not added any self-test changes
to the series yet - so you didn't probably see that discussion.

This is why you'll see "N-N:N/N" added as a self-test that works. It
doesn't make any more sense than using 15-15:15/15 does (vs. "15") but
both are equally valid inputs, in that they don't trigger an error.

Thanks,
Paul.
--

>
> I think this should be separate helper which is called in places where it makes
> sense.
>
> > len = _parse_integer(str, 10, &n);
> > if (!len)
> > return ERR_PTR(-EINVAL);
>
>
> --
> With Best Regards,
> Andy Shevchenko
>
>

2021-01-27 21:39:46

[permalink] [raw]

Subject: Re: [PATCH 5/8] lib: bitmap_getnum: separate arg into region and field

[Re: [PATCH 5/8] lib: bitmap_getnum: separate arg into region and field] On 26/01/2021 (Tue 18:58) Yury Norov wrote:

> On Tue, Jan 26, 2021 at 1:22 PM Andy Shevchenko
> <[email protected]> wrote:
> >
> > On Tue, Jan 26, 2021 at 12:11:38PM -0500, Paul Gortmaker wrote:
> > > The bitmap_getnum is only used on a region's start/end/off/group_len
> > > field. Trivially decouple the region from the field so that the region
> > > pointer is available for a pending change.
> >
> > Honestly, I don't like this macro trick. It's bad in couple of ways:
> > - it hides what actually is done with the fields of r structure
> > (after you get that they are fields!)
> > - it breaks possibility to compile time (type) checks
> >
> > I will listen what others say, but I'm in favour not to proceed like this.
>
> Agree. Would be better to drop the patch. Paul, what kind of pending
> change do you mean here? All the following patches are not related to
> parsing machinery.

It was directly related, because...

>
> > > Cc: Yury Norov <[email protected]>
> > > Cc: Rasmus Villemoes <[email protected]>
> > > Cc: Andy Shevchenko <[email protected]>
> > > Signed-off-by: Paul Gortmaker <[email protected]>
> > > ---
> > > lib/bitmap.c | 9 +++++----
> > > 1 file changed, 5 insertions(+), 4 deletions(-)
> > >
> > > diff --git a/lib/bitmap.c b/lib/bitmap.c
> > > index 833f152a2c43..f65be2f148fd 100644
> > > --- a/lib/bitmap.c
> > > +++ b/lib/bitmap.c
> > > @@ -533,6 +533,7 @@ static const char *bitmap_getnum(const char *str, unsigned int *num)
> > > *num = n;
> > > return str + len;
> > > }
> > > +#define bitmap_getrnum(s, r, pos) bitmap_getnum(s, &(r->pos))

...this one line above opened the door to then do [in 6/8]:

-#define bitmap_getrnum(s, r, pos) bitmap_getnum(s, &(r->pos))
+#define bitmap_getrnum(s, r, pos) __bitmap_getnum(s, r->nbits, &(r->pos))

which gets nbits down into bitmap_getnum so we can handle N in there as
the placement you'd specifically requested for treating N as just a number.

In any case, I've decided against putting nbits into the region struct
and have got the nbits value down into getnum() another way for v4,
without using this commit or similar macros.

Paul.
--

> > >
> > > static inline bool end_of_str(char c)
> > > {
> > > @@ -571,7 +572,7 @@ static const char *bitmap_find_region_reverse(const char *start, const char *end
> > >
> > > static const char *bitmap_parse_region(const char *str, struct region *r)
> > > {
> > > - str = bitmap_getnum(str, &r->start);
> > > + str = bitmap_getrnum(str, r, start);
> > > if (IS_ERR(str))
> > > return str;
> > >
> > > @@ -581,7 +582,7 @@ static const char *bitmap_parse_region(const char *str, struct region *r)
> > > if (*str != '-')
> > > return ERR_PTR(-EINVAL);
> > >
> > > - str = bitmap_getnum(str + 1, &r->end);
> > > + str = bitmap_getrnum(str + 1, r, end);
> > > if (IS_ERR(str))
> > > return str;
> > >
> > > @@ -591,14 +592,14 @@ static const char *bitmap_parse_region(const char *str, struct region *r)
> > > if (*str != ':')
> > > return ERR_PTR(-EINVAL);
> > >
> > > - str = bitmap_getnum(str + 1, &r->off);
> > > + str = bitmap_getrnum(str + 1, r, off);
> > > if (IS_ERR(str))
> > > return str;
> > >
> > > if (*str != '/')
> > > return ERR_PTR(-EINVAL);
> > >
> > > - return bitmap_getnum(str + 1, &r->group_len);
> > > + return bitmap_getrnum(str + 1, r, group_len);
> > >
> > > no_end:
> > > r->end = r->start;
> > > --
> > > 2.17.1
> > >
> >
> > --
> > With Best Regards,
> > Andy Shevchenko
> >
> >

2021-01-27 21:45:21

[permalink] [raw]

Subject: Re: [PATCH v3 0/8] support for bitmap (and hence CPU) list "N" abbreviation

[Re: [PATCH v3 0/8] support for bitmap (and hence CPU) list "N" abbreviation] On 26/01/2021 (Tue 14:27) Yury Norov wrote:

> On Tue, Jan 26, 2021 at 9:12 AM Paul Gortmaker
> <[email protected]> wrote:
> >
> > This was on a 16 core machine with CONFIG_NR_CPUS=16 in .config file.
> >
> > Note that "N" is a dynamic quantity, and can change scope if the bitmap
> > is changed in size. So at the risk of stating the obvious, don't use it
> > for "burn_eFuse=128-N" or "secure_erase_firmware=32-N" type stuff.
>
> I think it's worth moving this sentence to the Documentation. Another

Dynamic nature comment added to Documentation

> caveat with
> N is that users' config may surprisingly become invalid, like if user
> says 32-N, and
> on some machine with a smaller bitmap this config fails to boot.

Updated example to indicate that "16-N" becomes invalid if moved from 32
core system to quad core. I'm not currently able to think of an example
where boot will fail -- vs. a subsystem getting -EINVAL from bitmap code
and printing a subsystem error instead.

> It doesn't mean of course that I'm against 'N'. I think it's very
> useful especially in
> such common cases like "N", "0-N", "1-N".
>
> Would it make sense to treat the mask "32-N" when N < 32 as N-N,
> and bark something in dmesg?

I don't think so. For the same reasons you used to convince me -- that N
should be treated as just another number and not have special rules.

If I boot now, with "important_cpu="32-3" on a quad core then I get what
I get for being stupid. We don't special case that and subsitute in a
"3-3" (which would then be "3") -- and nor should we!

Sticking to the CPU example, we have no idea what the caller's use case
is -- we don't know if NUMA stuff might be present and whether having
the single CPU #3 in that set is better or worse than EINVAL and no CPUs
in the set. Expand that to bitmaps in general and we have no idea what
the "right" reaction to garbage input is.

The context of the caller could be simply test_bitmap.c itself -- which
would be expecting the EINVAL, and not some kind of "hot patching" of
the region in order to make it valid.

The only sane option is for the bitmap code to return EINVAL and let the
calling subsystem (with the appropriate context/info) make the decision
as to what to do next. Which is what the series does now.

Paul.
--

>
> > Paul.
> > ---
> >
> > [v1: https://lore.kernel.org/lkml/20210106004850.GA11682@paulmck-ThinkPad-P72/
> >
> > [v2: push code down from cpu subsys to core bitmap code as per
> > Yury's comments. Change "last" to simply be "N" as per PeterZ.]
> > https://lore.kernel.org/lkml/[email protected]/
> >
> > [v3: Allow "N" to be used anywhere in the region spec, i.e. "N-N:N/N" vs.
> > just being allowed at end of range like "0-N". Add new self-tests. Drop
> > "all" and "none" aliases as redundant and not worth the extra complication. ]
> >
> > Cc: Li Zefan <[email protected]>
> > Cc: Ingo Molnar <[email protected]>
> > Cc: Yury Norov <[email protected]>
> > Cc: Thomas Gleixner <[email protected]>
> > Cc: Josh Triplett <[email protected]>
> > Cc: Peter Zijlstra <[email protected]>
> > Cc: "Paul E. McKenney" <[email protected]>
> > Cc: Frederic Weisbecker <[email protected]>
> > Cc: Rasmus Villemoes <[email protected]>
> > Cc: Andy Shevchenko <[email protected]>
> >
> > ---
> >
> > Paul Gortmaker (8):
> > lib: test_bitmap: clearly separate ERANGE from EINVAL tests.
> > lib: test_bitmap: add more start-end:offset/len tests
> > lib: bitmap: fold nbits into region struct
> > lib: bitmap: move ERANGE check from set_region to check_region
> > lib: bitmap_getnum: separate arg into region and field
> > lib: bitmap: support "N" as an alias for size of bitmap
> > lib: test_bitmap: add tests for "N" alias
> > rcu: deprecate "all" option to rcu_nocbs=
> >
> > .../admin-guide/kernel-parameters.rst | 2 +
> > .../admin-guide/kernel-parameters.txt | 4 +-
> > kernel/rcu/tree_plugin.h | 6 +--
> > lib/bitmap.c | 46 ++++++++++--------
> > lib/test_bitmap.c | 48 ++++++++++++++++---
> > 5 files changed, 72 insertions(+), 34 deletions(-)
> >
> > --
> > 2.17.1
> >

2021-01-28 00:11:49

[permalink] [raw]

Subject: Re: [PATCH 6/8] lib: bitmap: support "N" as an alias for size of bitmap

On Tue, Jan 26, 2021 at 1:40 PM Andy Shevchenko
<[email protected]> wrote:
>
> On Tue, Jan 26, 2021 at 11:37:30PM +0200, Andy Shevchenko wrote:
> > On Tue, Jan 26, 2021 at 12:11:39PM -0500, Paul Gortmaker wrote:
>
> ...
>
> > > + if (str[0] == 'N') {
> > > + *num = nbits - 1;
> > > + return str + 1;
> > > + }
> >
> > But locating it here makes possible to enter a priori invalid input, like N for
> > start of the region.
> >
> > I think this should be separate helper which is called in places where it makes
> > sense.
>
> Okay, N is 31 on 32 core system... It is a bit counter intuitive, because it's
> rather _L_ast than _N_umber of CPUs.
>
> Changing letter?

No objections.

2021-02-10 01:32:52

[permalink] [raw]

Subject: Re: [PATCH 6/8] lib: bitmap: support "N" as an alias for size of bitmap

On Tue, Feb 9, 2021 at 3:01 PM Paul Gortmaker
<[email protected]> wrote:
>
> While this is done for all bitmaps, the original use case in mind was
> for CPU masks and cpulist_parse() as described below.
>
> It seems that a common configuration is to use the 1st couple cores for
> housekeeping tasks. This tends to leave the remaining ones to form a
> pool of similarly configured cores to take on the real workload of
> interest to the user.
>
> So on machine A - with 32 cores, it could be 0-3 for "system" and then
> 4-31 being used in boot args like nohz_full=, or rcu_nocbs= as part of
> setting up the worker pool of CPUs.
>
> But then newer machine B is added, and it has 48 cores, and so while
> the 0-3 part remains unchanged, the pool setup cpu list becomes 4-47.
>
> Multiple deployment becomes easier when we can just simply replace 31
> and 47 with "N" and let the system substitute in the actual number at
> boot; a number that it knows better than we do.
>
> Cc: Yury Norov <[email protected]>
> Cc: Peter Zijlstra <[email protected]>
> Cc: "Paul E. McKenney" <[email protected]>
> Cc: Rasmus Villemoes <[email protected]>
> Cc: Andy Shevchenko <[email protected]>
> Suggested-by: Yury Norov <[email protected]> # move it from CPU code
> Signed-off-by: Paul Gortmaker <[email protected]>
> ---
> .../admin-guide/kernel-parameters.rst | 7 +++++
> lib/bitmap.c | 27 ++++++++++++++-----
> 2 files changed, 27 insertions(+), 7 deletions(-)
>
> diff --git a/Documentation/admin-guide/kernel-parameters.rst b/Documentation/admin-guide/kernel-parameters.rst
> index 682ab28b5c94..7733a773f5f8 100644
> --- a/Documentation/admin-guide/kernel-parameters.rst
> +++ b/Documentation/admin-guide/kernel-parameters.rst
> @@ -68,6 +68,13 @@ For example one can add to the command line following parameter:
>
> where the final item represents CPUs 100,101,125,126,150,151,...
>
> +The value "N" can be used to represent the numerically last CPU on the system,
> +i.e "foo_cpus=16-N" would be equivalent to "16-31" on a 32 core system.
> +
> +Keep in mind that "N" is dynamic, so if system changes cause the bitmap width
> +to change, such as less cores in the CPU list, then N and any ranges using N
> +will also change. Use the same on a small 4 core system, and "16-N" becomes
> +"16-3" and now the same boot input will be flagged as invalid (start > end).
>
>
> This document may not be entirely up to date and comprehensive. The command
> diff --git a/lib/bitmap.c b/lib/bitmap.c
> index 6b568f98af3d..cc7cb1fca1ac 100644
> --- a/lib/bitmap.c
> +++ b/lib/bitmap.c
> @@ -530,11 +530,17 @@ static int bitmap_check_region(const struct bitmap_region *br)
> return 0;
> }
>
> -static const char *bitmap_getnum(const char *str, unsigned int *num)
> +static const char *bitmap_getnum(const char *str, unsigned int *num,
> + unsigned int lastbit)

The idea of struct bitmap_region is avoid passing the lastbit to the functions.
But here you do pass. Can you please be consistent? Or if I misunderstand
the idea of struct bitmap_region, can you please clarify it?

Also, I don't think that in this specific case it's worth it to create
a hierarchy of
structures. Just adding lastbits to struct region will be simpler and more
transparent.

> {
> unsigned long long n;
> unsigned int len;
>
> + if (str[0] == 'N') {
> + *num = lastbit;
> + return str + 1;
> + }
> +
> len = _parse_integer(str, 10, &n);
> if (!len)
> return ERR_PTR(-EINVAL);
> @@ -580,9 +586,12 @@ static const char *bitmap_find_region_reverse(const char *start, const char *end
> return end;
> }
>
> -static const char *bitmap_parse_region(const char *str, struct region *r)
> +static const char *bitmap_parse_region(const char *str, struct bitmap_region *br)

It seems like you declare struct bitmap_region in patch 8, but use it
in patch 6.
Can you please reorder your patches and resubmit?

> {
> - str = bitmap_getnum(str, &r->start);
> + struct region *r = br->r;
> + unsigned int lastbit = br->nbits - 1;
> +
> + str = bitmap_getnum(str, &r->start, lastbit);
> if (IS_ERR(str))
> return str;
>
> @@ -592,7 +601,7 @@ static const char *bitmap_parse_region(const char *str, struct region *r)
> if (*str != '-')
> return ERR_PTR(-EINVAL);
>
> - str = bitmap_getnum(str + 1, &r->end);
> + str = bitmap_getnum(str + 1, &r->end, lastbit);
> if (IS_ERR(str))
> return str;
>
> @@ -602,14 +611,14 @@ static const char *bitmap_parse_region(const char *str, struct region *r)
> if (*str != ':')
> return ERR_PTR(-EINVAL);
>
> - str = bitmap_getnum(str + 1, &r->off);
> + str = bitmap_getnum(str + 1, &r->off, lastbit);
> if (IS_ERR(str))
> return str;
>
> if (*str != '/')
> return ERR_PTR(-EINVAL);
>
> - return bitmap_getnum(str + 1, &r->group_len);
> + return bitmap_getnum(str + 1, &r->group_len, lastbit);
>
> no_end:
> r->end = r->start;
> @@ -636,6 +645,10 @@ static const char *bitmap_parse_region(const char *str, struct region *r)
> * From each group will be used only defined amount of bits.
> * Syntax: range:used_size/group_size
> * Example: 0-1023:2/256 ==> 0,1,256,257,512,513,768,769
> + * The value 'N' can be used as a dynamically substituted token for the
> + * maximum allowed value; i.e (nmaskbits - 1). Keep in mind that it is
> + * dynamic, so if system changes cause the bitmap width to change, such
> + * as more cores in a CPU list, then any ranges using N will also change.
> *
> * Returns: 0 on success, -errno on invalid input strings. Error values:
> *
> @@ -660,7 +673,7 @@ int bitmap_parselist(const char *buf, unsigned long *maskp, int nmaskbits)
> if (buf == NULL)
> return 0;
>
> - buf = bitmap_parse_region(buf, &r);
> + buf = bitmap_parse_region(buf, &br);
> if (IS_ERR(buf))
> return PTR_ERR(buf);
>
> --
> 2.17.1
>

2021-02-10 16:00:32

[permalink] [raw]

Subject: Re: [PATCH 6/8] lib: bitmap: support "N" as an alias for size of bitmap

[Re: [PATCH 6/8] lib: bitmap: support "N" as an alias for size of bitmap] On 09/02/2021 (Tue 15:16) Yury Norov wrote:

> On Tue, Feb 9, 2021 at 3:01 PM Paul Gortmaker
> <[email protected]> wrote:

[...]

> >
> > -static const char *bitmap_getnum(const char *str, unsigned int *num)
> > +static const char *bitmap_getnum(const char *str, unsigned int *num,
> > + unsigned int lastbit)
>
> The idea of struct bitmap_region is avoid passing the lastbit to the functions.
> But here you do pass. Can you please be consistent? Or if I misunderstand
> the idea of struct bitmap_region, can you please clarify it?
>
> Also, I don't think that in this specific case it's worth it to create
> a hierarchy of
> structures. Just adding lastbits to struct region will be simpler and more
> transparent.

I'm getting mixed messages from different people as to what is wanted here.

Here is what the code looks like now; only relevant lines shown:

-------------------------------
int bitmap_parselist(const char *buf, unsigned long *maskp, int nmaskbits)
{

struct region r;

bitmap_parse_region(buf, &r); <-----------
bitmap_check_region(&r);
bitmap_set_region(&r, maskp, nmaskbits);
}

static const char *bitmap_parse_region(const char *str, struct region *r)
{
bitmap_getnum(str, &r->start);
bitmap_getnum(str + 1, &r->end);
bitmap_getnum(str + 1, &r->off);
bitmap_getnum(str + 1, &r->group_len);
}

static const char *bitmap_getnum(const char *str, unsigned int *num)
{
/* PG: We need nmaskbits here for N processing. */
}
-------------------------------

Note the final function - the one where you asked to locate the N
processing into -- does not take a region. So even if we bundle nbits
into the region struct, it doesn't get the data to where we need it.

Choices:

1) pass in nbits just like bitmap_set_region() does currently.

2) add nbits to region and pass full region instead of start/end/off.

2a) add nbits to region and pass full region and also start/end/off.

3) use *num as a bi-directional data path and initialize with nbits.

Yury doesn't want us add any function args -- i.e. not to do #1.

Andy didn't like #2 because it "hides" that we are writing to r.

I ruled out sending 2a -- bitmap_getnum(str, r, &r->end) because
it adds an arg, AND seems rather redundant to pass r and r->field.

The #3 is the smallest change - but seems like we are trying to be
too clever just to save a line of code or a couple bytes. (see below)

Yury - in your reply to patch 5, you indicate you wrote the region
code and want me to go back to putting nbits into region directly.

Can you guys please clarify who is maintainer and hence exactly how
you want this relatively minor detail handled? I'll gladly do it
in whatever way the maintainer wants just to get this finally done.

I'd rather not keep going in circles and guessing and annoying everyone
else on the Cc: list by filling their inbox any more than I already have.

That would help a lot in getting this finished.

Thanks,
Paul.
--

Example #3 -- not sent..

+#define DECLARE_REGION(rname, initval) \
+struct region rname = { \
+ .start = initval, \
+ .off = initval, \
+ .group_len = initval, \
+ .end = initval, \
+}

[...]

- struct region r;
+ DECLARE_REGION(r, nmaskbits - 1); /* "N-N:N/N" */

[...]

+/*
+ * Seeing 'N' tells us to leave the value of "num" unchanged (which will
+ * be the max value for the width of the bitmap, set via DECLARE_REGION).
+ */
static const char *bitmap_getnum(const char *str, unsigned int *num)
{
unsigned long long n;
unsigned int len;

+ if (str[0] == 'N') /* nothing to do, just advance str */
+ return str + 1;

2021-02-10 16:56:37

[permalink] [raw]

Subject: Re: [PATCH 6/8] lib: bitmap: support "N" as an alias for size of bitmap

On Wed, Feb 10, 2021 at 10:58:25AM -0500, Paul Gortmaker wrote:
> [Re: [PATCH 6/8] lib: bitmap: support "N" as an alias for size of bitmap] On 09/02/2021 (Tue 15:16) Yury Norov wrote:
>
> > On Tue, Feb 9, 2021 at 3:01 PM Paul Gortmaker
> > <[email protected]> wrote:
>
> [...]
>
> > > -static const char *bitmap_getnum(const char *str, unsigned int *num)
> > > +static const char *bitmap_getnum(const char *str, unsigned int *num,
> > > + unsigned int lastbit)
> >
> > The idea of struct bitmap_region is avoid passing the lastbit to the functions.
> > But here you do pass. Can you please be consistent? Or if I misunderstand
> > the idea of struct bitmap_region, can you please clarify it?
> >
> > Also, I don't think that in this specific case it's worth it to create
> > a hierarchy of
> > structures. Just adding lastbits to struct region will be simpler and more
> > transparent.
>
> I'm getting mixed messages from different people as to what is wanted here.
>
> Here is what the code looks like now; only relevant lines shown:
>
> -------------------------------
> int bitmap_parselist(const char *buf, unsigned long *maskp, int nmaskbits)
> {
>
> struct region r;
>
> bitmap_parse_region(buf, &r); <-----------
> bitmap_check_region(&r);
> bitmap_set_region(&r, maskp, nmaskbits);
> }
>
> static const char *bitmap_parse_region(const char *str, struct region *r)
> {
> bitmap_getnum(str, &r->start);
> bitmap_getnum(str + 1, &r->end);
> bitmap_getnum(str + 1, &r->off);
> bitmap_getnum(str + 1, &r->group_len);
> }
>
> static const char *bitmap_getnum(const char *str, unsigned int *num)
> {
> /* PG: We need nmaskbits here for N processing. */
> }
> -------------------------------
>
>
> Note the final function - the one where you asked to locate the N
> processing into -- does not take a region. So even if we bundle nbits
> into the region struct, it doesn't get the data to where we need it.
>
> Choices:
>
> 1) pass in nbits just like bitmap_set_region() does currently.
>
> 2) add nbits to region and pass full region instead of start/end/off.
>
> 2a) add nbits to region and pass full region and also start/end/off.
>
> 3) use *num as a bi-directional data path and initialize with nbits.
>
>
> Yury doesn't want us add any function args -- i.e. not to do #1.
>
> Andy didn't like #2 because it "hides" that we are writing to r.
>
> I ruled out sending 2a -- bitmap_getnum(str, r, &r->end) because
> it adds an arg, AND seems rather redundant to pass r and r->field.
>
> The #3 is the smallest change - but seems like we are trying to be
> too clever just to save a line of code or a couple bytes. (see below)
>
> Yury - in your reply to patch 5, you indicate you wrote the region
> code and want me to go back to putting nbits into region directly.
>
> Can you guys please clarify who is maintainer and hence exactly how
> you want this relatively minor detail handled? I'll gladly do it
> in whatever way the maintainer wants just to get this finally done.

Funny that there is no maintainer of the code.
That said, I consider #1 or #3 is good enough. Rationale for
- #1: it doesn't touch purity of getnum(), I think it's good enough not to know
region details
- #3 (as you posted below): I like how it looks like (one nit below, though)

But let's put this way, I think Yury had done a lot in the area, let's listen
more to him than to me.

> I'd rather not keep going in circles and guessing and annoying everyone
> else on the Cc: list by filling their inbox any more than I already have.
>
> That would help a lot in getting this finished.

Agree!

> Example #3 -- not sent..
>
> +#define DECLARE_REGION(rname, initval) \
> +struct region rname = { \
> + .start = initval, \
> + .off = initval, \
> + .group_len = initval, \
> + .end = initval, \
> +}
>
> [...]
>
> - struct region r;
> + DECLARE_REGION(r, nmaskbits - 1); /* "N-N:N/N" */

I would initialize with nmaskbits to be sure the value is invalid, but it will
add some code, below, so up to you, guys.

> +/*
> + * Seeing 'N' tells us to leave the value of "num" unchanged (which will
> + * be the max value for the width of the bitmap, set via DECLARE_REGION).
> + */
> static const char *bitmap_getnum(const char *str, unsigned int *num)
> {
> unsigned long long n;
> unsigned int len;
>
> + if (str[0] == 'N') /* nothing to do, just advance str */
> + return str + 1;
>

--
With Best Regards,
Andy Shevchenko

2021-02-12 01:25:52

[permalink] [raw]

Subject: Re: [PATCH 6/8] lib: bitmap: support "N" as an alias for size of bitmap

On Wed, Feb 10, 2021 at 06:49:30PM +0200, Andy Shevchenko wrote:
> On Wed, Feb 10, 2021 at 10:58:25AM -0500, Paul Gortmaker wrote:
> > [Re: [PATCH 6/8] lib: bitmap: support "N" as an alias for size of bitmap] On 09/02/2021 (Tue 15:16) Yury Norov wrote:
> >
> > > On Tue, Feb 9, 2021 at 3:01 PM Paul Gortmaker
> > > <[email protected]> wrote:
> >
> > [...]
> >
> > > > -static const char *bitmap_getnum(const char *str, unsigned int *num)
> > > > +static const char *bitmap_getnum(const char *str, unsigned int *num,
> > > > + unsigned int lastbit)
> > >
> > > The idea of struct bitmap_region is avoid passing the lastbit to the functions.
> > > But here you do pass. Can you please be consistent? Or if I misunderstand
> > > the idea of struct bitmap_region, can you please clarify it?
> > >
> > > Also, I don't think that in this specific case it's worth it to create
> > > a hierarchy of
> > > structures. Just adding lastbits to struct region will be simpler and more
> > > transparent.
> >
> > I'm getting mixed messages from different people as to what is wanted here.
> >
> > Here is what the code looks like now; only relevant lines shown:
> >
> > -------------------------------
> > int bitmap_parselist(const char *buf, unsigned long *maskp, int nmaskbits)
> > {
> >
> > struct region r;
> >
> > bitmap_parse_region(buf, &r); <-----------
> > bitmap_check_region(&r);
> > bitmap_set_region(&r, maskp, nmaskbits);
> > }
> >
> > static const char *bitmap_parse_region(const char *str, struct region *r)
> > {
> > bitmap_getnum(str, &r->start);
> > bitmap_getnum(str + 1, &r->end);
> > bitmap_getnum(str + 1, &r->off);
> > bitmap_getnum(str + 1, &r->group_len);
> > }
> >
> > static const char *bitmap_getnum(const char *str, unsigned int *num)
> > {
> > /* PG: We need nmaskbits here for N processing. */
> > }
> > -------------------------------
> >
> >
> > Note the final function - the one where you asked to locate the N
> > processing into -- does not take a region. So even if we bundle nbits
> > into the region struct, it doesn't get the data to where we need it.
> >
> > Choices:
> >
> > 1) pass in nbits just like bitmap_set_region() does currently.
> >
> > 2) add nbits to region and pass full region instead of start/end/off.
> >
> > 2a) add nbits to region and pass full region and also start/end/off.
> >
> > 3) use *num as a bi-directional data path and initialize with nbits.
> >
> >
> > Yury doesn't want us add any function args -- i.e. not to do #1.
> >
> > Andy didn't like #2 because it "hides" that we are writing to r.
> >
> > I ruled out sending 2a -- bitmap_getnum(str, r, &r->end) because
> > it adds an arg, AND seems rather redundant to pass r and r->field.
> >
> > The #3 is the smallest change - but seems like we are trying to be
> > too clever just to save a line of code or a couple bytes. (see below)
> >
> > Yury - in your reply to patch 5, you indicate you wrote the region
> > code and want me to go back to putting nbits into region directly.
> >
> > Can you guys please clarify who is maintainer and hence exactly how
> > you want this relatively minor detail handled? I'll gladly do it
> > in whatever way the maintainer wants just to get this finally done.
>
> Funny that there is no maintainer of the code.
> That said, I consider #1 or #3 is good enough. Rationale for
> - #1: it doesn't touch purity of getnum(), I think it's good enough not to know
> region details
> - #3 (as you posted below): I like how it looks like (one nit below, though)
>
> But let's put this way, I think Yury had done a lot in the area, let's listen
> more to him than to me.

I think that the simplest approach is the best. For me, the simplest
thing is to add a field to existing structure, like this:

struct region {
unsigned int start;
unsigned int off;
unsigned int group_len;
unsigned int end;
unsigned int nbits;
};

Of course we can do like:

struct region {
struct boundaries;
struct periodic_part;
};

struct bitmap_region {
struct region;
unsigned int nbits;
};

But it would be nothing better than simple flat structure.

> > I'd rather not keep going in circles and guessing and annoying everyone
> > else on the Cc: list by filling their inbox any more than I already have.
> >
> > That would help a lot in getting this finished.
>
> Agree!
>
> > Example #3 -- not sent..
> >
> > +#define DECLARE_REGION(rname, initval) \
> > +struct region rname = { \
> > + .start = initval, \
> > + .off = initval, \
> > + .group_len = initval, \
> > + .end = initval, \
> > +}
> >
> > [...]
> >
> > - struct region r;
> > + DECLARE_REGION(r, nmaskbits - 1); /* "N-N:N/N" */
>
> I would initialize with nmaskbits to be sure the value is invalid, but it will
> add some code, below, so up to you, guys.

We don't need to initialize r because it's purely internal and helpers
don't expect that r is initialized, so it's waste of cycles.

> > +/*
> > + * Seeing 'N' tells us to leave the value of "num" unchanged (which will
> > + * be the max value for the width of the bitmap, set via DECLARE_REGION).
> > + */
> > static const char *bitmap_getnum(const char *str, unsigned int *num)
> > {
> > unsigned long long n;
> > unsigned int len;
> >
> > + if (str[0] == 'N') /* nothing to do, just advance str */
> > + return str + 1;

Is my understanding correct that this is an attempt to avoid adding
the nbits to struct region? It would probably work, but I'd prefer
to extend the structure. For me it's more readable and maintainable
approach.

Yury

2021-02-21 08:10:42