jbitset: rename to jset, use ccan/tcon

It's now a completely generic set implementation, and uses ccan/tcon
to always be typesafe.  It handles both integer and pointer types.

Makefile

@@ -12,7 +12,7 @@
 
 # Trying to build the whole repo is usually a lose; there will be some
 # dependencies you don't have.
-EXCLUDE=wwviaudio ogg_to_pcm jmap jbitset nfs
+EXCLUDE=wwviaudio ogg_to_pcm jmap jset nfs
 
 # Where make scores puts the results
 SCOREDIR=scores/$(shell whoami)/$(shell uname -s)-$(shell uname -m)-$(CC)-$(shell git describe --always --dirty)

ccan/jbitset/jbitset_type.h

-/* Licensed under LGPLv2.1+ - see LICENSE file for details */
-#ifndef CCAN_JBITSET_TYPE_H
-#define CCAN_JBITSET_TYPE_H
-#include <ccan/jbitset/jbitset.h>
-
-/**
- * JBIT_DEFINE_TYPE - create a set of jbit ops for a given pointer type
- * @type: a type whose pointers will go into the bitset.
- * @name: a name for all the functions to define (of form jbit_<name>_*)
- *
- * This macro defines a set of inline functions for typesafe and convenient
- * usage of a Judy bitset for pointers.  It is assumed that a NULL pointer
- * is never set in the bitset.
- *
- * Example:
- *	JBIT_DEFINE_TYPE(char, char);
- *	JBIT_DEFINE_TYPE(struct foo, foo);
- *
- *	static struct jbitset_char *jc;
- *	struct jbitset_foo *jf;
- *
- *	static void add_to_bitsets(const char *p, const struct foo *f)
- *	{
- *		// Note, this adds the pointer, not the string!
- *		jbit_char_set(jc, p);
- *		jbit_foo_set(jf, f);
- *	}
- */
-#define JBIT_DEFINE_TYPE(type, name)					\
-struct jbitset_##name;							\
-static inline struct jbitset_##name *jbit_##name##_new(void)		\
-{									\
-	return (struct jbitset_##name *)jbit_new();			\
-}									\
-static inline void jbit_##name##_free(const struct jbitset_##name *set)	\
-{									\
-	jbit_free((const struct jbitset *)set);				\
-}									\
-static inline const char *jbit_##name##_error(struct jbitset_##name *set) \
-{									\
-	return jbit_error((struct jbitset *)set);			\
-}									\
-static inline bool jbit_##name##_test(const struct jbitset_##name *set,	\
-				      const type *index)		\
-{									\
-	return jbit_test((const struct jbitset *)set, (size_t)index);	\
-}									\
-static inline bool jbit_##name##_set(struct jbitset_##name *set,	\
-				     const type *index)			\
-{									\
-	return jbit_set((struct jbitset *)set, (size_t)index);		\
-}									\
-static inline bool jbit_##name##_clear(struct jbitset_##name *set,	\
-				       const type *index)		\
-{									\
-	return jbit_clear((struct jbitset *)set, (size_t)index);	\
-}									\
-static inline size_t jbit_##name##_count(struct jbitset_##name *set)	\
-{									\
-	return jbit_popcount((const struct jbitset *)set, 0, -1);	\
-}									\
-static inline type *jbit_##name##_nth(const struct jbitset_##name *set,	\
-					    size_t n)			\
-{									\
-	return (type *)jbit_nth((const struct jbitset *)set, n, 0);	\
-}									\
-static inline type *jbit_##name##_first(const struct jbitset_##name *set) \
-{									\
-	return (type *)jbit_first((const struct jbitset *)set, 0);	\
-}									\
-static inline type *jbit_##name##_next(struct jbitset_##name *set,	\
-				       const type *prev)		\
-{									\
-	return (type *)jbit_next((const struct jbitset *)set, (size_t)prev, 0);	\
-}									\
-static inline type *jbit_##name##_last(struct jbitset_##name *set)	\
-{									\
-	return (type *)jbit_last((const struct jbitset *)set, 0);	\
-}									\
-static inline type *jbit_##name##_prev(struct jbitset_##name *set,	\
-				       const type *prev)		\
-{									\
-	return (type *)jbit_prev((const struct jbitset *)set, (size_t)prev, 0);	\
-}
-#endif /* CCAN_JBITSET_TYPE_H */

ccan/jbitset/test/run-type.c

-#include <ccan/tap/tap.h>
-#include <ccan/jbitset/jbitset_type.h>
-#include <ccan/jbitset/jbitset.c>
-
-struct foo;
-
-JBIT_DEFINE_TYPE(struct foo, foo);
-
-static int cmp_ptr(const void *a, const void *b)
-{
-	return *(char **)a - *(char **)b;
-}
-
-#define NUM 100
-
-int main(int argc, char *argv[])
-{
-	struct jbitset_foo *set;
-	struct foo *foo[NUM];
-	unsigned int i;
-
-	plan_tests(20);
-	for (i = 0; i < NUM; i++)
-		foo[i] = malloc(20);
-
-	set = jbit_foo_new();
-	ok1(jbit_foo_error(set) == NULL);
-
-	ok1(jbit_foo_set(set, foo[0]) == true);
-	ok1(jbit_foo_set(set, foo[0]) == false);
-	ok1(jbit_foo_clear(set, foo[0]) == true);
-	ok1(jbit_foo_clear(set, foo[0]) == false);
-	ok1(jbit_foo_count(set) == 0);
-	ok1(jbit_foo_nth(set, 0) == (struct foo *)NULL);
-	ok1(jbit_foo_first(set) == (struct foo *)NULL);
-	ok1(jbit_foo_last(set) == (struct foo *)NULL);
-
-	for (i = 0; i < NUM; i++)
-		jbit_foo_set(set, foo[i]);
-
-	qsort(foo, NUM, sizeof(foo[0]), cmp_ptr);
-
-	ok1(jbit_foo_count(set) == NUM);
-	ok1(jbit_foo_nth(set, 0) == foo[0]);
-	ok1(jbit_foo_nth(set, NUM-1) == foo[NUM-1]);
-	ok1(jbit_foo_nth(set, NUM) == (struct foo *)NULL);
-	ok1(jbit_foo_first(set) == foo[0]);
-	ok1(jbit_foo_last(set) == foo[NUM-1]);
-	ok1(jbit_foo_next(set, foo[0]) == foo[1]);
-	ok1(jbit_foo_next(set, foo[NUM-1]) == (struct foo *)NULL);
-	ok1(jbit_foo_prev(set, foo[1]) == foo[0]);
-	ok1(jbit_foo_prev(set, foo[0]) == (struct foo *)NULL);
-	ok1(jbit_foo_error(set) == NULL);
-	jbit_foo_free(set);
-
-	for (i = 0; i < NUM; i++)
-		free(foo[i]);
-
-	return exit_status();
-}

ccan/jbitset/test/run.c

-#include <ccan/tap/tap.h>
-#include <ccan/jbitset/jbitset.c>
-
-int main(int argc, char *argv[])
-{
-	struct jbitset *set;
-	size_t i;
-	const char *err;
-
-	plan_tests(36);
-
-	set = jbit_new();
-	ok1(jbit_error(set) == NULL);
-
-	ok1(jbit_set(set, 0) == true);
-	ok1(jbit_set(set, 0) == false);
-	ok1(jbit_clear(set, 0) == true);
-	ok1(jbit_clear(set, 0) == false);
-	ok1(jbit_popcount(set, 0, -1) == 0);
-	ok1(jbit_nth(set, 0, 0) == 0);
-	ok1(jbit_nth(set, 0, -1) == (size_t)-1);
-	ok1(jbit_first(set, 0) == 0);
-	ok1(jbit_first(set, -1) == (size_t)-1);
-	ok1(jbit_last(set, 0) == 0);
-	ok1(jbit_last(set, -1) == (size_t)-1);
-	ok1(jbit_first_clear(set, -1) == 0);
-	ok1(jbit_first_clear(set, -2) == 0);
-	ok1(jbit_last_clear(set, 0) == (size_t)-1);
-	ok1(jbit_prev_clear(set, 1, -1) == 0);
-	ok1(jbit_next_clear(set, 0, -1) == 1);
-	ok1(jbit_next_clear(set, -1, -1) == -1);
-
-	/* Set a million bits, 16 bits apart. */
-	for (i = 0; i < 1000000; i++)
-		jbit_set(set, i << 4);
-
-	/* This only take 1.7MB on my 32-bit system. */
-	diag("%u bytes memory used\n", (unsigned)Judy1MemUsed(set->judy));
-	
-	ok1(jbit_popcount(set, 0, -1) == 1000000);
-	ok1(jbit_nth(set, 0, -1) == 0);
-	ok1(jbit_nth(set, 999999, -1) == 999999 << 4);
-	ok1(jbit_nth(set, 1000000, -1) == (size_t)-1);
-	ok1(jbit_first(set, -1) == 0);
-	ok1(jbit_last(set, -1) == 999999 << 4);
-	ok1(jbit_first_clear(set, -1) == 1);
-	ok1(jbit_last_clear(set, 0) == (size_t)-1);
-	ok1(jbit_prev_clear(set, 1, -1) == (size_t)-1);
-	ok1(jbit_next(set, 0, -1) == 1 << 4);
-	ok1(jbit_next(set, 999999 << 4, -1) == (size_t)-1);
-	ok1(jbit_prev(set, 1, -1) == 0);
-	ok1(jbit_prev(set, 0, -1) == (size_t)-1);
-	ok1(jbit_error(set) == NULL);
-
-	/* Test error handling */
-	JU_ERRNO(&set->err) = 100;
-	JU_ERRID(&set->err) = 991;
-	err = jbit_error(set);
-	ok1(err);
-	ok1(strstr(err, "100"));
-	ok1(strstr(err, "991"));
-	ok1(err == set->errstr);
-	jbit_free(set);
-
-	return exit_status();
-}

ccan/jbitset/_info → ccan/jset/_info

@@ -3,56 +3,56 @@
 #include "config.h"
 
 /**
- * jbitset - variable-length bitset (based on libJudy)
+ * jset - set of pointers (based on libJudy)
  *
  * This provides a convenient wrapper for using Judy bitsets; using
- * integers or pointers as an index, Judy arrays provide an efficient
- * bit array or bit map of variable size.
+ * pointers (or unsigned longs) as the index, Judy arrays provide an
+ * efficient bit array or bit map of variable size.
  *
- * jbitset.h simply contains wrappers for a size_t-indexed bitset, and
- * jbitset_type.h contain a wrapper macro for pointer bitsets.
+ * jset.h contains typesafe wrappers for this usage.
  *
  * Example:
  * // Simple analysis of one-byte mallocs.
+ * #include <ccan/jset/jset.h>
  * #include <stdlib.h>
  * #include <stdio.h>
  * #include <err.h>
- * #include <ccan/jbitset/jbitset_type.h>
- * 
- * // Define jbit_char_<op> and jbitset_char, for char * bitset.
- * JBIT_DEFINE_TYPE(char, char);
- * 
+ *
+ * struct jset_char {
+ *	JSET_MEMBERS(char *);
+ * };
+ *
  * int main(int argc, char *argv[])
  * {
  * 	unsigned int i, runs, reuse;
  * 	size_t mindist = -1;
- * 	struct jbitset_char *set = jbit_char_new();
+ * 	struct jset_char *set = jset_new(struct jset_char);
  * 	char *p, *prev;
- * 
+ *
  * 	runs = (argc == 1 ? 1000 : atoi(argv[1]));
  * 	if (!runs)
  * 		errx(1, "Invalid number of allocations '%s'", argv[1]);
- * 
+ *
  * 	for (i = 0; i < runs; i++)
- * 		if (!jbit_char_set(set, malloc(1)))
+ * 		if (!jset_set(set, malloc(1)))
  * 			errx(1, "same pointer allocated twice!");
- * 
+ *
  * 	// Calculate minimum distance
- * 	prev = jbit_char_first(set)+1;
- * 	for (p = jbit_char_first(set); p; prev = p, p = jbit_char_next(set,p))
+ * 	prev = jset_first(set)+1;
+ * 	for (p = jset_first(set); p; prev = p, p = jset_next(set,p))
  * 		if (p - prev < mindist)
  * 			mindist = p - prev;
- * 
+ *
  * 	// Free them all, see how many we reallocate.
- * 	for (p = jbit_char_first(set); p; p = jbit_char_next(set, p))
+ * 	for (p = jset_first(set); p; p = jset_next(set, p))
  * 		free(p);
  * 	for (reuse = 0, i = 0; i < runs; i++)
- * 		reuse += jbit_char_test(set, malloc(1));
- * 
+ * 		reuse += jset_test(set, malloc(1));
+ *
  * 	printf("Allocation density (bytes): %zu\n"
  * 	       "Minimum inter-pointer distance: %zu\n"
  * 	       "Reuse rate: %.0f%%\n",
- * 	       (jbit_char_last(set) - jbit_char_first(set)) / runs,
+ * 	       (jset_last(set) - jset_first(set)) / runs,
  * 	       mindist,
  * 	       100.0 * reuse / runs);
  * 	return 0;
@@ -69,6 +69,7 @@ int main(int argc, char *argv[])
 	if (strcmp(argv[1], "depends") == 0) {
 		printf("ccan/build_assert\n");
 		printf("ccan/compiler\n");
+		printf("ccan/tcon\n");
 		printf("Judy\n");
 		return 0;
 	}

ccan/jbitset/jbitset.c → ccan/jset/jset.c

 /* Licensed under LGPLv2.1+ - see LICENSE file for details */
-#include <ccan/jbitset/jbitset.h>
+#include <ccan/jset/jset.h>
 #include <ccan/build_assert/build_assert.h>
 #include <stdlib.h>
 #include <string.h>
 
-struct jbitset *jbit_new(void)
+struct jset *jset_new_(size_t size)
 {
-	struct jbitset *set;
+	struct jset *set;
 
 	/* Judy uses Word_t, we use unsigned long directly. */
 	BUILD_ASSERT(sizeof(unsigned long) == sizeof(Word_t));
-	/* We pack pointers into jbitset (in jbitset_type.h) */
+	/* We pack pointers into jset (in jset_type.h) */
 	BUILD_ASSERT(sizeof(Word_t) >= sizeof(void *));
 
-	set = malloc(sizeof(*set));
+	assert(size >= sizeof(*set));
+	set = malloc(size);
 	if (set) {
 		set->judy = NULL;
 		memset(&set->err, 0, sizeof(set->err));
@@ -22,7 +23,7 @@ struct jbitset *jbit_new(void)
 	return set;
 }
 
-const char *jbit_error_(struct jbitset *set)
+const char *jset_error_str_(struct jset *set)
 {
 	char *str;
 	free((char *)set->errstr);
@@ -36,7 +37,7 @@ const char *jbit_error_(struct jbitset *set)
 	return str;
 }
 
-void jbit_free(const struct jbitset *set)
+void jset_free_(const struct jset *set)
 {
 	free((char *)set->errstr);
 	Judy1FreeArray((PPvoid_t)&set->judy, PJE0);

ccan/jset/test/run-pointer-type.c

+#include <ccan/tap/tap.h>
+#include <ccan/jset/jset.c>
+
+struct foo;
+
+struct jset_foo {
+	JSET_MEMBERS(struct foo *);
+};
+
+static int cmp_ptr(const void *a, const void *b)
+{
+	return *(char **)a - *(char **)b;
+}
+
+#define NUM 100
+
+int main(int argc, char *argv[])
+{
+	struct jset_foo *set;
+	struct foo *foo[NUM];
+	unsigned int i;
+
+	plan_tests(20);
+	for (i = 0; i < NUM; i++)
+		foo[i] = malloc(20);
+
+	set = jset_new(struct jset_foo);
+	ok1(jset_error(set) == NULL);
+
+	ok1(jset_set(set, foo[0]) == true);
+	ok1(jset_set(set, foo[0]) == false);
+	ok1(jset_clear(set, foo[0]) == true);
+	ok1(jset_clear(set, foo[0]) == false);
+	ok1(jset_count(set) == 0);
+	ok1(jset_nth(set, 0, NULL) == (struct foo *)NULL);
+	ok1(jset_first(set) == (struct foo *)NULL);
+	ok1(jset_last(set) == (struct foo *)NULL);
+
+	for (i = 0; i < NUM; i++)
+		jset_set(set, foo[i]);
+
+	qsort(foo, NUM, sizeof(foo[0]), cmp_ptr);
+
+	ok1(jset_count(set) == NUM);
+	ok1(jset_nth(set, 0, NULL) == foo[0]);
+	ok1(jset_nth(set, NUM-1, NULL) == foo[NUM-1]);
+	ok1(jset_nth(set, NUM, NULL) == (struct foo *)NULL);
+	ok1(jset_first(set) == foo[0]);
+	ok1(jset_last(set) == foo[NUM-1]);
+	ok1(jset_next(set, foo[0]) == foo[1]);
+	ok1(jset_next(set, foo[NUM-1]) == (struct foo *)NULL);
+	ok1(jset_prev(set, foo[1]) == foo[0]);
+	ok1(jset_prev(set, foo[0]) == (struct foo *)NULL);
+	ok1(jset_error(set) == NULL);
+	jset_free(set);
+
+	for (i = 0; i < NUM; i++)
+		free(foo[i]);
+
+	return exit_status();
+}

ccan/jset/test/run.c

+#include <ccan/tap/tap.h>
+#include <ccan/jset/jset.c>
+
+int main(int argc, char *argv[])
+{
+	struct jset_long {
+		JSET_MEMBERS(unsigned long);
+	} *set;
+	size_t i;
+	const char *err;
+
+	plan_tests(34);
+
+	set = jset_new(struct jset_long);
+	ok1(jset_error(set) == NULL);
+
+	ok1(jset_set(set, 0) == true);
+	ok1(jset_set(set, 0) == false);
+	ok1(jset_clear(set, 0) == true);
+	ok1(jset_clear(set, 0) == false);
+	ok1(jset_popcount(set, 0, -1) == 0);
+	ok1(jset_nth(set, 0, 0) == 0);
+	ok1(jset_nth(set, 0, -1) == (size_t)-1);
+	ok1(jset_first(set) == 0);
+	ok1(jset_last(set) == 0);
+	ok1(jset_first_clear(set) == 1);
+	ok1(jset_last_clear(set) == (size_t)-1);
+	ok1(jset_prev_clear(set, 1) == 0);
+	ok1(jset_next_clear(set, 1) == 2);
+	ok1(jset_next_clear(set, -1) == 0);
+
+	/* Set a million bits, 16 bits apart. */
+	for (i = 0; i < 1000000; i++)
+		jset_set(set, 1 + (i << 4));
+
+	/* This only take 1.7MB on my 32-bit system. */
+	diag("%u bytes memory used\n", (unsigned)Judy1MemUsed(set->raw.judy));
+
+	ok1(jset_popcount(set, 0, -1) == 1000000);
+	ok1(jset_nth(set, 0, -1) == 1);
+	ok1(jset_nth(set, 999999, -1) == 1 + (999999 << 4));
+	ok1(jset_nth(set, 1000000, -1) == (size_t)-1);
+	ok1(jset_first(set) == 1);
+	ok1(jset_last(set) == 1 + (999999 << 4));
+	ok1(jset_first_clear(set) == 2);
+	ok1(jset_last_clear(set) == (size_t)-1);
+	ok1(jset_prev_clear(set, 3) == 2);
+	ok1(jset_prev_clear(set, 2) == 0);
+	ok1(jset_next(set, 1) == 1 + (1 << 4));
+	ok1(jset_next(set, 1 + (999999 << 4)) == 0);
+	ok1(jset_prev(set, 1) == 0);
+	ok1(jset_prev(set, 2) == 1);
+	ok1(jset_error(set) == NULL);
+
+	/* Test error handling */
+	JU_ERRNO(&set->raw.err) = 100;
+	JU_ERRID(&set->raw.err) = 991;
+	err = jset_error(set);
+	ok1(err);
+	ok1(strstr(err, "100"));
+	ok1(strstr(err, "991"));
+	ok1(err == set->raw.errstr);
+	jset_free(set);
+
+	return exit_status();
+}