+/* Licensed under LGPLv2+ - see LICENSE file for details */
#include <ccan/htable/htable.h>
#include <ccan/compiler/compiler.h>
-#include <stdint.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>
#include <assert.h>
-
-/* This means a struct htable takes at least 512 bytes / 1k (32/64 bits). */
-#define HTABLE_BASE_BITS 7
+#include <string.h>
/* We use 0x1 as deleted marker. */
#define HTABLE_DELETED (0x1)
-struct htable {
- size_t (*rehash)(const void *elem, void *priv);
- void *priv;
- unsigned int bits;
- size_t elems, deleted, max, max_with_deleted;
- /* These are the bits which are the same in all pointers. */
- uintptr_t common_mask, common_bits;
- uintptr_t perfect_bit;
- uintptr_t *table;
-};
-
/* We clear out the bits which are always the same, and put metadata there. */
static inline uintptr_t get_extra_ptr_bits(const struct htable *ht,
uintptr_t e)
& ht->common_mask & ~ht->perfect_bit;
}
-struct htable *htable_new(size_t (*rehash)(const void *elem, void *priv),
- void *priv)
+void htable_init(struct htable *ht,
+ size_t (*rehash)(const void *elem, void *priv), void *priv)
{
- struct htable *ht = malloc(sizeof(struct htable));
- if (ht) {
- ht->bits = HTABLE_BASE_BITS;
- ht->rehash = rehash;
- ht->priv = priv;
- ht->elems = 0;
- ht->deleted = 0;
- ht->max = ((size_t)1 << ht->bits) * 3 / 4;
- ht->max_with_deleted = ((size_t)1 << ht->bits) * 9 / 10;
- /* This guarantees we enter update_common first add. */
- ht->common_mask = -1;
- ht->common_bits = 0;
- ht->perfect_bit = 0;
- ht->table = calloc(1 << ht->bits, sizeof(uintptr_t));
- if (!ht->table) {
- free(ht);
- ht = NULL;
- }
+ struct htable empty = HTABLE_INITIALIZER(empty, NULL, NULL);
+ *ht = empty;
+ ht->rehash = rehash;
+ ht->priv = priv;
+ ht->table = &ht->perfect_bit;
+}
+
+/* We've changed ht->bits, update ht->max and ht->max_with_deleted */
+static void htable_adjust_capacity(struct htable *ht)
+{
+ ht->max = ((size_t)3 << ht->bits) / 4;
+ ht->max_with_deleted = ((size_t)9 << ht->bits) / 10;
+}
+
+bool htable_init_sized(struct htable *ht,
+ size_t (*rehash)(const void *, void *),
+ void *priv, size_t expect)
+{
+ htable_init(ht, rehash, priv);
+
+ /* Don't go insane with sizing. */
+ for (ht->bits = 1; ((size_t)3 << ht->bits) / 4 < expect; ht->bits++) {
+ if (ht->bits == 30)
+ break;
+ }
+
+ ht->table = calloc(1 << ht->bits, sizeof(size_t));
+ if (!ht->table) {
+ ht->table = &ht->perfect_bit;
+ return false;
}
- return ht;
+ htable_adjust_capacity(ht);
+ return true;
+}
+
+void htable_clear(struct htable *ht)
+{
+ if (ht->table != &ht->perfect_bit)
+ free((void *)ht->table);
+ htable_init(ht, ht->rehash, ht->priv);
}
-void htable_free(const struct htable *ht)
+bool htable_copy(struct htable *dst, const struct htable *src)
{
- free((void *)ht->table);
- free((void *)ht);
+ uintptr_t *htable = malloc(sizeof(size_t) << src->bits);
+
+ if (!htable)
+ return false;
+
+ *dst = *src;
+ dst->table = htable;
+ memcpy(dst->table, src->table, sizeof(size_t) << src->bits);
+ return true;
}
static size_t hash_bucket(const struct htable *ht, size_t h)
return NULL;
}
+void *htable_prev(const struct htable *ht, struct htable_iter *i)
+{
+ for (;;) {
+ if (!i->off)
+ return NULL;
+ i->off --;
+ if (entry_is_valid(ht->table[i->off]))
+ return get_raw_ptr(ht, ht->table[i->off]);
+ }
+}
+
/* This does not expand the hash table, that's up to caller. */
static void ht_add(struct htable *ht, const void *new, size_t h)
{
ht->table[i] = make_hval(ht, new, get_hash_ptr_bits(ht, h)|perfect);
}
-static COLD_ATTRIBUTE bool double_table(struct htable *ht)
+static COLD bool double_table(struct htable *ht)
{
unsigned int i;
size_t oldnum = (size_t)1 << ht->bits;
return false;
}
ht->bits++;
- ht->max *= 2;
- ht->max_with_deleted *= 2;
+ htable_adjust_capacity(ht);
/* If we lost our "perfect bit", get it back now. */
if (!ht->perfect_bit && ht->common_mask) {
}
}
- for (i = 0; i < oldnum; i++) {
- if (entry_is_valid(e = oldtable[i])) {
- void *p = get_raw_ptr(ht, e);
- ht_add(ht, p, ht->rehash(p, ht->priv));
+ if (oldtable != &ht->perfect_bit) {
+ for (i = 0; i < oldnum; i++) {
+ if (entry_is_valid(e = oldtable[i])) {
+ void *p = get_raw_ptr(ht, e);
+ ht_add(ht, p, ht->rehash(p, ht->priv));
+ }
}
+ free(oldtable);
}
ht->deleted = 0;
- free(oldtable);
return true;
}
-static COLD_ATTRIBUTE void rehash_table(struct htable *ht)
+static COLD void rehash_table(struct htable *ht)
{
size_t start, i;
uintptr_t e;
}
/* We stole some bits, now we need to put them back... */
-static COLD_ATTRIBUTE void update_common(struct htable *ht, const void *p)
+static COLD void update_common(struct htable *ht, const void *p)
{
unsigned int i;
uintptr_t maskdiff, bitsdiff;
if (ht->elems == 0) {
- ht->common_mask = -1;
- ht->common_bits = (uintptr_t)p;
+ /* Always reveal one bit of the pointer in the bucket,
+ * so it's not zero or HTABLE_DELETED (1), even if
+ * hash happens to be 0. Assumes (void *)1 is not a
+ * valid pointer. */
+ for (i = sizeof(uintptr_t)*CHAR_BIT - 1; i > 0; i--) {
+ if ((uintptr_t)p & ((uintptr_t)1 << i))
+ break;
+ }
+
+ ht->common_mask = ~((uintptr_t)1 << i);
+ ht->common_bits = ((uintptr_t)p & ht->common_mask);
ht->perfect_bit = 1;
return;
}