bits.h: move popcount up, fix erroneous japanese '−' instead of '-' (minus)

c/hash.c

@@ -5,7 +5,7 @@
 #include "hash.h"
 
 /* Return the hash of a string of known length */
-unsigned int full_name_hash(const void *salt, const char *name, unsigned int len)
+unsigned int hash_string(const void *salt, const char *name, unsigned int len)
 {
 	unsigned long hash = init_name_hash(salt);
 	while (len--)

c/include/bits.h

@@ -10,10 +10,11 @@
  * SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
  *
  */
-#ifndef BITS_H
-#define BITS_H
+#ifndef _BITS_H
+#define _BITS_H
 
 #include <stdint.h>
+#include <stdbool.h>
 
 /* next include will define __WORDSIZE: 32 or 64
  */
@@ -48,6 +49,30 @@ typedef unsigned int uint;
 typedef unsigned short ushort;
 typedef unsigned char uchar;
 
+/* count set bits:  10101000 -> 3
+ *                  ^ ^ ^
+ */
+static __always_inline int popcount64(u64 n)
+{
+#   if __has_builtin(__builtin_popcountl)
+#   ifdef DEBUG_BITS
+    log_f(1, "builtin.\n");
+#   endif
+    return __builtin_popcountl(n);
+
+#   else
+#   ifdef DEBUG_BITS
+    log_f(1, "emulated.\n");
+#   endif
+    int count = 0;
+    while (n) {
+        count++;
+        n &= (n - 1);
+    }
+    return count;
+#   endif
+}
+
 /* char is a special case, as it can be signed or unsigned
  */
 typedef signed char schar;
@@ -73,7 +98,7 @@ static __always_inline int ctz64(u64 n)
 #   ifdef DEBUG_BITS
     log_f(1, "emulated.\n");
 #   endif
-    return popcount64((n & −n) − 1);
+    return popcount64((n & -n) - 1);
 #   endif
 }
 
@@ -95,7 +120,7 @@ static __always_inline int ctz32(u32 n)
 #   ifdef DEBUG_BITS
     log_f(1, "emulated.\n");
 #   endif
-    return popcount32((n & −n) − 1);
+    return popcount32((n & -n) - 1);
 #   endif
 }
 
@@ -217,30 +242,6 @@ static __always_inline uint ffs32(u32 n)
 #   endif
 }
 
-/* count set bits:  10101000 -> 3
- *                  ^ ^ ^
- */
-static __always_inline int popcount64(u64 n)
-{
-#   if __has_builtin(__builtin_popcountl)
-#   ifdef DEBUG_BITS
-    log_f(1, "builtin.\n");
-#   endif
-    return __builtin_popcountl(n);
-
-#   else
-#   ifdef DEBUG_BITS
-    log_f(1, "emulated.\n");
-#   endif
-    int count = 0;
-    while (n) {
-        count++;
-        n &= (n - 1);
-    }
-    return count;
-#   endif
-}
-
 static __always_inline int popcount32(u32 n)
 {
 #   if __has_builtin(__builtin_popcount)
@@ -346,7 +347,147 @@ static inline u8 ror8(u8 word, unsigned int shift)
 	return (word >> (shift & 7)) | (word << ((-shift) & 7));
 }
 
+/**
+ * ilog2 -
+ */
+static __always_inline __attribute__((const))
+int __ilog2_u32(u32 n)
+{
+	return fls32(n) - 1;
+}
 
+static __always_inline __attribute__((const))
+int __ilog2_u64(u64 n)
+{
+	return fls64(n) - 1;
+}
+
+/**
+ * is_power_of_2() - check if a value is a power of two
+ * @n: the value to check
+ *
+ * Determine whether some value is a power of two, where zero is
+ * *not* considered a power of two.
+ * Return: true if @n is a power of 2, otherwise false.
+ */
+static inline __attribute__((const))
+bool is_power_of_2(unsigned long n)
+{
+	return (n != 0 && ((n & (n - 1)) == 0));
+}
+
+/**
+ * ilog2 - log 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) < 2 ? 0 :			\
+	 63 - __builtin_clzll(n)) :	\
+	(sizeof(n) <= 4) ?		\
+	__ilog2_u32(n) :		\
+	__ilog2_u64(n)			\
+ )
+
+/**
+ * roundup_pow_of_two - round the given value up to nearest power of two
+ * @n: parameter
+ *
+ * round the given value up 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 roundup_pow_of_two(n)			\
+(						\
+	__builtin_constant_p(n) ? (		\
+		((n) == 1) ? 1 :		\
+		(1UL << (ilog2((n) - 1) + 1))	\
+				   ) :		\
+	__roundup_pow_of_two(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)		\
+ )
+
+static inline __attribute_const__
+int __order_base_2(unsigned long n)
+{
+	return n > 1 ? ilog2(n - 1) + 1 : 0;
+}
+
+/**
+ * order_base_2 - calculate the (rounded up) base 2 order of the argument
+ * @n: parameter
+ *
+ * The first few values calculated by this routine:
+ *  ob2(0) = 0
+ *  ob2(1) = 0
+ *  ob2(2) = 1
+ *  ob2(3) = 2
+ *  ob2(4) = 2
+ *  ob2(5) = 3
+ *  ... and so on.
+ */
+#define order_base_2(n)				\
+(						\
+	__builtin_constant_p(n) ? (		\
+		((n) == 0 || (n) == 1) ? 0 :	\
+		ilog2((n) - 1) + 1) :		\
+	__order_base_2(n)			\
+)
+
+static inline __attribute__((const))
+int __bits_per(unsigned long n)
+{
+	if (n < 2)
+		return 1;
+	if (is_power_of_2(n))
+		return order_base_2(n) + 1;
+	return order_base_2(n);
+}
+
+/**
+ * bits_per - calculate the number of bits required for the argument
+ * @n: parameter
+ *
+ * This is constant-capable and can be used for compile time
+ * initializations, e.g bitfields.
+ *
+ * The first few values calculated by this routine:
+ * bf(0) = 1
+ * bf(1) = 1
+ * bf(2) = 2
+ * bf(3) = 2
+ * bf(4) = 3
+ * ... and so on.
+ */
+#define bits_per(n)				\
+(						\
+	__builtin_constant_p(n) ? (		\
+		((n) == 0 || (n) == 1)		\
+			? 1 : ilog2(n) + 1	\
+	) :					\
+	__bits_per(n)				\
+)
 
 /** bit_for_each - iterate over an u64/u32 bits
  * @pos:        an int used as current bit
@@ -377,4 +518,4 @@ static inline u8 ror8(u8 word, unsigned int shift)
 #define bit_for_each32_2(pos, tmp, ul)                                  \
     for (tmp = ul, pos = ctz32(tmp); tmp; tmp ^= 1U << pos, pos = ctz32(tmp))
 
-#endif  /* BITS_H */
+#endif  /* _BITS_H */

c/include/br.h

@@ -1,4 +1,4 @@
-/* bits.h - bits functions.
+/* br.h - misc macros.
  *
  * Copyright (C) 2021-2022 Bruno Raoult ("br")
  * Licensed under the GNU General Public License v3.0 or later.
@@ -18,12 +18,18 @@
 #ifndef _BR_H
 #define _BR_H
 
+/* Indirect stringification.  Doing two levels allows the parameter to be a
+ * macro itself.  For example, compile with -DFOO=bar, __stringify(FOO)
+ * converts to "bar".
+ */
+#define __stringify_1(x...)	#x
+#define __stringify(x...)	__stringify_1(x)
+
 /* generate a (maybe) unique id.
  */
 #define ___PASTE(x, y)      x##y
 #define __PASTE(x, y)       ___PASTE(x, y)
 #define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
-//__##prefix##__COUNTER__
 
 /* see https://lkml.org/lkml/2018/3/20/845 for explanation of this monster
  */

c/include/hash.h

@@ -8,7 +8,6 @@
 /* Fast hashing routine for ints,  longs and pointers.
    (C) 2002 Nadia Yvette Chambers, IBM */
 
-#include <asm/types.h>
 #include <asm/bitsperlong.h>
 #include "bits.h"
 #include "br.h"
@@ -157,7 +156,7 @@ static inline unsigned int end_name_hash(unsigned long hash)
  *
  * If not set, this falls back to a wrapper around the preceding.
  */
-extern unsigned int __pure full_name_hash(const void *salt, const char *, unsigned int);
+extern unsigned int __pure hash_string(const void *salt, const char *, unsigned int);
 
 /*
  * A hash_len is a u64 with the hash of a string in the low

c/include/hashtable.h

@@ -12,8 +12,6 @@
 #define _LINUX_HASHTABLE_H
 
 #include "list.h"
-#include <linux/types.h>
-#include <linux/kernel.h>
 #include "hash.h"
 //#include <linux/rculist.h>
 

c/include/plist.h

@@ -1,4 +1,9 @@
 /* SPDX-License-Identifier: GPL-2.0-or-later */
+
+/* adaptation of kernel's <linux/plist.h>
+ *
+ */
+
 /*
  * Descending-priority-sorted double-linked list
  *
@@ -152,6 +157,14 @@ extern void plist_requeue(struct plist_node *node, struct plist_head *head);
 #define plist_for_each(pos, head)                               \
     list_for_each_entry(pos, &(head)->node_list, node_list)
 
+/**
+ * plist_for_each_reverse - iterate backwards over the plist
+ * @pos:	the type * to use as a loop counter
+ * @head:	the head for your list
+ */
+#define plist_for_each_reverse(pos, head)                       \
+    list_for_each_entry_reverse(pos, &(head)->node_list, node_list)
+
 /**
  * plist_for_each_continue - continue iteration over the plist
  * @pos:	the type * to use as a loop cursor
@@ -159,9 +172,20 @@ extern void plist_requeue(struct plist_node *node, struct plist_head *head);
  *
  * Continue to iterate over plist, continuing after the current position.
  */
-#define plist_for_each_continue(pos, head)                              \
+#define plist_for_each_continue(pos, head)                      \
     list_for_each_entry_continue(pos, &(head)->node_list, node_list)
 
+/**
+ * plist_for_each_continue_reverse - continue iteration over the plist
+ * @pos:	the type * to use as a loop cursor
+ * @head:	the head for your list
+ *
+ * Continue to iterate backwards over plist, continuing after the current
+ * position.
+ */
+#define plist_for_each_continue_reverse(pos, head)              \
+    list_for_each_entry_continue_reverse(pos, &(head)->node_list, node_list)
+
 /**
  * plist_for_each_safe - iterate safely over a plist of given type
  * @pos:	the type * to use as a loop counter
@@ -170,9 +194,20 @@ extern void plist_requeue(struct plist_node *node, struct plist_head *head);
  *
  * Iterate over a plist of given type, safe against removal of list entry.
  */
-#define plist_for_each_safe(pos, n, head)                               \
+#define plist_for_each_safe(pos, n, head)                       \
     list_for_each_entry_safe(pos, n, &(head)->node_list, node_list)
 
+/**
+ * plist_for_each_safe_reverse - iterate backwards safely over a plist of given type
+ * @pos:	the type * to use as a loop counter
+ * @n:	another type * to use as temporary storage
+ * @head:	the head for your list
+ *
+ * Iterate backwards over a plist of given type, safe against removal of list entry.
+ */
+#define plist_for_each_safe_reverse(pos, n, head)               \
+    list_for_each_entry_safe_reverse(pos, n, &(head)->node_list, node_list)
+
 /**
  * plist_for_each_entry	- iterate over list of given type
  * @pos:	the type * to use as a loop counter
@@ -182,6 +217,15 @@ extern void plist_requeue(struct plist_node *node, struct plist_head *head);
 #define plist_for_each_entry(pos, head, mem)                    \
     list_for_each_entry(pos, &(head)->node_list, mem.node_list)
 
+/**
+ * plist_for_each_entry_reverse	- iterate backwards over list of given type
+ * @pos:	the type * to use as a loop counter
+ * @head:	the head for your list
+ * @mem:	the name of the list_head within the struct
+ */
+#define plist_for_each_entry_reverse(pos, head, mem)                    \
+    list_for_each_entry_reverse(pos, &(head)->node_list, mem.node_list)
+
 /**
  * plist_for_each_entry_continue - continue iteration over list of given type
  * @pos:	the type * to use as a loop cursor

c/include/pool.h

@@ -1,6 +1,6 @@
 /* pool.h - A simple memory pool manager.
  *
- * Copyright (C) 2021 Bruno Raoult ("br")
+ * Copyright (C) 2021-2022 Bruno Raoult ("br")
  * Licensed under the GNU General Public License v3.0 or later.
  * Some rights reserved. See COPYING.
  *

c/pool.c

@@ -153,11 +153,11 @@ void pool_destroy(pool_t *pool)
     log(5, "blocks:");
 #   endif
     list_for_each_entry_safe(block, tmp, &pool->list_blocks, list_blocks) {
-        list_del(&block->list_blocks);
-        free(block);
 #       ifdef DEBUG_POOL
         log(5, " %p", block);
 #       endif
+        list_del(&block->list_blocks);
+        free(block);
     }
 #   ifdef DEBUG_POOL
     log(5, "\n");