Add functions to calculate the next power of 2

There are many areas in the code where we need to determine the next
highest power of 2 of a given number.  We tend to always do that in an
ad-hoc way each time, generally with some tight for loop which performs a
bitshift left once per loop and goes until it finds a number above the
given number.

Here we add two generic functions which make use of the existing
pg_leftmost_one_pos* functions which, when available, will allow us to
calculate the next power of 2 without any looping.

Here we don't add any code which uses these new functions. That will be
done in follow-up commits.

Author: David Fetter, with some minor adjustments by me
Reviewed-by: John Naylor, Jesse Zhang
Discussion: https://postgr.es/m/20200114173553.GE32763%40fetter.org

diff --git a/src/include/port/pg_bitutils.h b/src/include/port/pg_bitutils.h
index 498e53230817fe242b47b77a632d5e01d82519f1..4ca92f076dcd52cc59cf044011baea80780021d4 100644 (file)
--- a/src/include/port/pg_bitutils.h
+++ b/src/include/port/pg_bitutils.h
@@ -129,6 +129,78 @@ pg_rightmost_one_pos64(uint64 word)
 #endif                         /* HAVE__BUILTIN_CTZ */
 }
 
+/*
+ * pg_nextpower2_32
+ *     Returns the next highest power of 2 of 'num', or 'num', if it's
+ *     already a power of 2.
+ *
+ * 'num' mustn't be 0 or be above PG_UINT32_MAX / 2 + 1.
+ */
+static inline uint32
+pg_nextpower2_32(uint32 num)
+{
+   Assert(num > 0 && num <= PG_UINT32_MAX / 2 + 1);
+
+   /*
+    * A power 2 number has only 1 bit set.  Subtracting 1 from such a number
+    * will turn on all previous bits resulting in no common bits being set
+    * between num and num-1.
+    */
+   if ((num & (num - 1)) == 0)
+       return num;             /* already power 2 */
+
+   return ((uint32) 1) << (pg_leftmost_one_pos32(num) + 1);
+}
+
+/*
+ * pg_nextpower2_64
+ *     Returns the next highest power of 2 of 'num', or 'num', if it's
+ *     already a power of 2.
+ *
+ * 'num' mustn't be 0 or be above PG_UINT64_MAX / 2  + 1.
+ */
+static inline uint64
+pg_nextpower2_64(uint64 num)
+{
+   Assert(num > 0 && num <= PG_UINT64_MAX / 2 + 1);
+
+   /*
+    * A power 2 number has only 1 bit set.  Subtracting 1 from such a number
+    * will turn on all previous bits resulting in no common bits being set
+    * between num and num-1.
+    */
+   if ((num & (num - 1)) == 0)
+       return num;             /* already power 2 */
+
+   return ((uint64) 1) << (pg_leftmost_one_pos64(num) + 1);
+}
+
+/*
+ * pg_ceil_log2_32
+ *     Returns equivalent of ceil(log2(num))
+ */
+static inline uint32
+pg_ceil_log2_32(uint32 num)
+{
+   if (num < 2)
+       return 0;
+   else
+       return pg_leftmost_one_pos32(num - 1) + 1;
+}
+
+/*
+ * pg_ceil_log2_64
+ *     Returns equivalent of ceil(log2(num))
+ */
+static inline uint64
+pg_ceil_log2_64(uint64 num)
+{
+   if (num < 2)
+       return 0;
+   else
+       return pg_leftmost_one_pos64(num - 1) + 1;
+}
+
 /* Count the number of one-bits in a uint32 or uint64 */
 extern int (*pg_popcount32) (uint32 word);
 extern int (*pg_popcount64) (uint64 word);