tools: Adopt rounddown_pow_of_two and deps
tip-bot for Arnaldo Carvalho de Melo
merge botCommit-ID: fa37c025c5bec6704dad714365a7f62d9cb13a36 Gitweb: http://git.kernel.org/tip/fa37c025c5bec6704dad714365a7f62d9cb13a36 Author: Arnaldo Carvalho de Melo <[email protected]> AuthorDate: Tue, 16 Dec 2014 12:14:11 -0300 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 17 Dec 2014 11:58:13 -0300
tools: Adopt rounddown_pow_of_two and deps
Will be used to make sure we pass a power of two when automatically setting up the perf_mmap addr range length, as the kernel code validating input on /proc/sys/kernel/perf_event_mlock_kb accepts any integer, if we plain use it to set up the mmap lenght, we may get an EINVAL when passing a non power of two.
Cc Adrian Hunter <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc David Ahern <[email protected]>
Cc Don Zickus <[email protected]>
Cc Frederic Weisbecker <[email protected]>
Cc Jiri Olsa <[email protected]>
Cc Mike Galbraith <[email protected]>
Cc Namhyung Kim <[email protected]>
Cc Paul Mackerras <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Stephane Eranian <[email protected]>
Signed-off-by Arnaldo Carvalho de Melo <[email protected]>
--- tools/include/linux/log2.h | 134 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 134 insertions(+)
tools/include/linux/log2.h +134 -0
@@ -13,6 +13,30 @@#define _TOOLS_LINUX_LOG2_H/* +* deal with unrepresentable constant logarithms +*/ +extern __attribute__((const, noreturn)) +int ____ilog2_NaN (void ); + +/* +* non-constant log of base 2 calculators +* - the arch may override these in asm/bitops.h if they can be implemented +* more efficiently than using fls() and fls64() +* - the arch is not required to handle n==0 if implementing the fallback +*/ +static inline __attribute__((const)) +int __ilog2_u32 (u32 n) +{ +return fls (n) -1 ; +} + +static inline __attribute__((const)) +int __ilog2_u64 (u64 n) +{ +return fls64 (n) -1 ; +} + +/* * Determine whether some value is a power of two, where zero is * *not* considered a power of two. */
@@ -23,4 +47,114 @@ bool is_power_of_2(unsigned long n) return (n != 0 && ((n & (n - 1)) == 0)); } +/* +* round down to nearest power of two +*/ +static inline __attribute__((const)) +unsigned long __rounddown_pow_of_two (unsigned long n) +{ +return 1UL << (fls_long (n) -1 ); +} + +/** +* ilog2 - log of base 2 of 32-bit or a 64-bit unsigned value +* @n - parameter +* +* constant-capable log of base 2 calculation +* - this can be used to initialise global variables from constant data, hence +* the massive ternary operator construction +* +* selects the appropriately-sized optimised version depending on sizeof(n) +*/ +#define ilog2 (n) \ +( \ + __builtin_constant_p(n) ? ( \ + (n) < 1 ? ____ilog2_NaN() : \ + (n) & (1ULL << 63) ? 63 : \ + (n) & (1ULL << 62) ? 62 : \ + (n) & (1ULL << 61) ? 61 : \ + (n) & (1ULL << 60) ? 60 : \ + (n) & (1ULL << 59) ? 59 : \ + (n) & (1ULL << 58) ? 58 : \ + (n) & (1ULL << 57) ? 57 : \ + (n) & (1ULL << 56) ? 56 : \ + (n) & (1ULL << 55) ? 55 : \ + (n) & (1ULL << 54) ? 54 : \ + (n) & (1ULL << 53) ? 53 : \ + (n) & (1ULL << 52) ? 52 : \ + (n) & (1ULL << 51) ? 51 : \ + (n) & (1ULL << 50) ? 50 : \ + (n) & (1ULL << 49) ? 49 : \ + (n) & (1ULL << 48) ? 48 : \ + (n) & (1ULL << 47) ? 47 : \ + (n) & (1ULL << 46) ? 46 : \ + (n) & (1ULL << 45) ? 45 : \ + (n) & (1ULL << 44) ? 44 : \ + (n) & (1ULL << 43) ? 43 : \ + (n) & (1ULL << 42) ? 42 : \ + (n) & (1ULL << 41) ? 41 : \ + (n) & (1ULL << 40) ? 40 : \ + (n) & (1ULL << 39) ? 39 : \ + (n) & (1ULL << 38) ? 38 : \ + (n) & (1ULL << 37) ? 37 : \ + (n) & (1ULL << 36) ? 36 : \ + (n) & (1ULL << 35) ? 35 : \ + (n) & (1ULL << 34) ? 34 : \ + (n) & (1ULL << 33) ? 33 : \ + (n) & (1ULL << 32) ? 32 : \ + (n) & (1ULL << 31) ? 31 : \ + (n) & (1ULL << 30) ? 30 : \ + (n) & (1ULL << 29) ? 29 : \ + (n) & (1ULL << 28) ? 28 : \ + (n) & (1ULL << 27) ? 27 : \ + (n) & (1ULL << 26) ? 26 : \ + (n) & (1ULL << 25) ? 25 : \ + (n) & (1ULL << 24) ? 24 : \ + (n) & (1ULL << 23) ? 23 : \ + (n) & (1ULL << 22) ? 22 : \ + (n) & (1ULL << 21) ? 21 : \ + (n) & (1ULL << 20) ? 20 : \ + (n) & (1ULL << 19) ? 19 : \ + (n) & (1ULL << 18) ? 18 : \ + (n) & (1ULL << 17) ? 17 : \ + (n) & (1ULL << 16) ? 16 : \ + (n) & (1ULL << 15) ? 15 : \ + (n) & (1ULL << 14) ? 14 : \ + (n) & (1ULL << 13) ? 13 : \ + (n) & (1ULL << 12) ? 12 : \ + (n) & (1ULL << 11) ? 11 : \ + (n) & (1ULL << 10) ? 10 : \ + (n) & (1ULL << 9) ? 9 : \ + (n) & (1ULL << 8) ? 8 : \ + (n) & (1ULL << 7) ? 7 : \ + (n) & (1ULL << 6) ? 6 : \ + (n) & (1ULL << 5) ? 5 : \ + (n) & (1ULL << 4) ? 4 : \ + (n) & (1ULL << 3) ? 3 : \ + (n) & (1ULL << 2) ? 2 : \ + (n) & (1ULL << 1) ? 1 : \ + (n) & (1ULL << 0) ? 0 : \ + ____ilog2_NaN() \ + ) : \ + (sizeof(n) <= 4) ? \ + __ilog2_u32(n) : \ + __ilog2_u64(n) \ + ) + + +/** +* rounddown_pow_of_two - round the given value down to nearest power of two +* @n - parameter +* +* round the given value down to the nearest power of two +* - the result is undefined when n == 0 +* - this can be used to initialise global variables from constant data +*/ +#define rounddown_pow_of_two (n) \ +( \ + __builtin_constant_p(n) ? ( \ + (1UL << ilog2(n))) : \ + __rounddown_pow_of_two(n) \ + ) +#endif /* _TOOLS_LINUX_LOG2_H */