lkml.org 
[lkml]   [2022]   [Jan]   [23]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 49/54] lib/nodemask: add nodemask_weight_{eq,gt,ge,lt,le}
    Date
    In many cases kernel code uses nodemask_weight() to compare the result
    against some number or expression:

    if (nodes_weight(...) > 1)
    do_something();

    It may be significantly improved for large nodemasks: if first few words
    count set bits to a number greater than given, we can stop counting and
    immediately return.

    The same idea would work in other direction: if we know that the number
    of set bits that we counted so far is small enough, so that it would be
    smaller than required number even if all bits of the rest of the nodemask
    are set, we can stop counting earlier.

    This patch adds nodes_weight{eq, gt, ge, lt, le} helpers based on
    corresponding bitmap functions. The following patches apply new functions
    where appropriate.

    Signed-off-by: Yury Norov <yury.norov@gmail.com>
    ---
    include/linux/nodemask.h | 35 +++++++++++++++++++++++++++++++++++
    1 file changed, 35 insertions(+)

    diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h
    index 567c3ddba2c4..197598e075e9 100644
    --- a/include/linux/nodemask.h
    +++ b/include/linux/nodemask.h
    @@ -38,6 +38,11 @@
    * int nodes_empty(mask) Is mask empty (no bits sets)?
    * int nodes_full(mask) Is mask full (all bits sets)?
    * int nodes_weight(mask) Hamming weight - number of set bits
    + * bool nodes_weight_eq(src, nbits, num) Hamming Weight is equal to num
    + * bool nodes_weight_gt(src, nbits, num) Hamming Weight is greater than num
    + * bool nodes_weight_ge(src, nbits, num) Hamming Weight is greater than or equal to num
    + * bool nodes_weight_lt(src, nbits, num) Hamming Weight is less than num
    + * bool nodes_weight_le(src, nbits, num) Hamming Weight is less than or equal to num
    *
    * void nodes_shift_right(dst, src, n) Shift right
    * void nodes_shift_left(dst, src, n) Shift left
    @@ -240,6 +245,36 @@ static inline int __nodes_weight(const nodemask_t *srcp, unsigned int nbits)
    return bitmap_weight(srcp->bits, nbits);
    }

    +#define nodes_weight_eq(nodemask, num) __nodes_weight_eq(&(nodemask), MAX_NUMNODES, (num))
    +static inline int __nodes_weight_eq(const nodemask_t *srcp, unsigned int nbits, int num)
    +{
    + return bitmap_weight_eq(srcp->bits, nbits, num);
    +}
    +
    +#define nodes_weight_gt(nodemask, num) __nodes_weight_gt(&(nodemask), MAX_NUMNODES, (num))
    +static inline int __nodes_weight_gt(const nodemask_t *srcp, unsigned int nbits, int num)
    +{
    + return bitmap_weight_gt(srcp->bits, nbits, num);
    +}
    +
    +#define nodes_weight_ge(nodemask, num) __nodes_weight_ge(&(nodemask), MAX_NUMNODES, (num))
    +static inline int __nodes_weight_ge(const nodemask_t *srcp, unsigned int nbits, int num)
    +{
    + return bitmap_weight_ge(srcp->bits, nbits, num);
    +}
    +
    +#define nodes_weight_lt(nodemask, num) __nodes_weight_lt(&(nodemask), MAX_NUMNODES, (num))
    +static inline int __nodes_weight_lt(const nodemask_t *srcp, unsigned int nbits, int num)
    +{
    + return bitmap_weight_lt(srcp->bits, nbits, num);
    +}
    +
    +#define nodes_weight_le(nodemask, num) __nodes_weight_le(&(nodemask), MAX_NUMNODES, (num))
    +static inline int __nodes_weight_le(const nodemask_t *srcp, unsigned int nbits, int num)
    +{
    + return bitmap_weight_le(srcp->bits, nbits, num);
    +}
    +
    #define nodes_shift_right(dst, src, n) \
    __nodes_shift_right(&(dst), &(src), (n), MAX_NUMNODES)
    static inline void __nodes_shift_right(nodemask_t *dstp,
    --
    2.30.2
    \
     
     \ /
      Last update: 2022-01-23 19:44    [W:7.728 / U:0.032 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site