From 8ef5456338a947944cc03b95c22c837af5884ddc Mon Sep 17 00:00:00 2001 From: Eugene Syromyatnikov Date: Wed, 18 Aug 2021 21:51:22 +0200 Subject: [PATCH 149/150] trie: use BIT* and MASK* macros This makes reading the code a bit easier. It also solves some issues where there is a hypothertical possibility of having bit shifts of size 64, by virtue of using the *_SAFE macros (that should silence some reported "left shifting by more than 63 bits has undefined behavior" covscan issues). * src/trie.c (trie_create): Use BIT32, MASK64. (trie_create_data_block): Use BIT32, change iterator variable type to size_t. (trie_get_node): Use BIT64, MASK64. (trie_data_block_calc_pos): Use BIT32, MASK64, MASK64_SAFE. (trie_iterate_keys_node): Use BIT64, MASK64, MASK64_SAFE. (trie_free_node): Use BIT64. --- src/trie.c | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/src/trie.c b/src/trie.c index 586ff25..0a231e4 100644 --- a/src/trie.c +++ b/src/trie.c @@ -15,6 +15,7 @@ #include #include "trie.h" +#include "macros.h" #include "xmalloc.h" static const uint8_t ptr_sz_lg = (sizeof(void *) == 8 ? 6 : 5); @@ -87,7 +88,7 @@ trie_create(uint8_t key_size, uint8_t item_size_lg, uint8_t node_key_bits, / t->node_key_bits; if (item_size_lg != 6) - t->empty_value &= (((uint64_t) 1 << (1 << t->item_size_lg)) - 1); + t->empty_value &= MASK64(BIT32(t->item_size_lg)); return t; } @@ -96,8 +97,8 @@ static void * trie_create_data_block(struct trie *t) { uint64_t fill_value = t->empty_value; - for (int i = 1; i < 1 << (6 - t->item_size_lg); i++) { - fill_value <<= (1 << t->item_size_lg); + for (size_t i = 1; i < BIT32(6 - t->item_size_lg); i++) { + fill_value <<= BIT32(t->item_size_lg); fill_value |= t->empty_value; } @@ -105,7 +106,7 @@ trie_create_data_block(struct trie *t) if (sz < 6) sz = 6; - size_t count = 1 << (sz - 6); + size_t count = BIT32(sz - 6); uint64_t *data_block = xcalloc(count, 8); for (size_t i = 0; i < count; i++) @@ -119,7 +120,7 @@ trie_get_node(struct trie *t, uint64_t key, bool auto_create) { void **cur_node = &(t->data); - if (t->key_size < 64 && key > (uint64_t) 1 << t->key_size) + if (t->key_size < 64 && key > MASK64(t->key_size)) return NULL; for (uint8_t cur_depth = 0; cur_depth <= t->max_depth; cur_depth++) { @@ -133,13 +134,13 @@ trie_get_node(struct trie *t, uint64_t key, bool auto_create) if (cur_depth == t->max_depth) *cur_node = trie_create_data_block(t); else - *cur_node = xcalloc(1 << sz, 1); + *cur_node = xcalloc(BIT64(sz), 1); } if (cur_depth == t->max_depth) break; - size_t pos = (key >> offs) & ((1 << (sz - ptr_sz_lg)) - 1); + size_t pos = (key >> offs) & MASK64(sz - ptr_sz_lg); cur_node = (((void **) (*cur_node)) + pos); } @@ -152,7 +153,7 @@ trie_data_block_calc_pos(struct trie *t, uint64_t key, { uint64_t key_mask; - key_mask = (1 << t->data_block_key_bits) - 1; + key_mask = MASK64(t->data_block_key_bits); *pos = (key & key_mask) >> (6 - t->item_size_lg); if (t->item_size_lg == 6) { @@ -161,10 +162,10 @@ trie_data_block_calc_pos(struct trie *t, uint64_t key, return; } - key_mask = (1 << (6 - t->item_size_lg)) - 1; - *offs = (key & key_mask) * (1 << t->item_size_lg); + key_mask = MASK64(6 - t->item_size_lg); + *offs = (key & key_mask) << t->item_size_lg; - *mask = (((uint64_t) 1 << (1 << t->item_size_lg)) - 1) << *offs; + *mask = MASK64_SAFE(BIT32(t->item_size_lg)) << *offs; } bool @@ -211,7 +212,7 @@ trie_iterate_keys_node(struct trie *t, return 0; if (t->key_size < 64) { - uint64_t key_max = ((uint64_t) 1 << t->key_size) - 1; + uint64_t key_max = MASK64(t->key_size); if (end > key_max) end = key_max; } @@ -228,15 +229,14 @@ trie_iterate_keys_node(struct trie *t, t->key_size : trie_get_node_bit_offs(t, depth - 1); - uint64_t first_key_in_node = start & - (uint64_t) -1 << parent_node_bit_off; + uint64_t first_key_in_node = start & ~MASK64_SAFE(parent_node_bit_off); uint8_t node_bit_off = trie_get_node_bit_offs(t, depth); uint8_t node_key_bits = parent_node_bit_off - node_bit_off; - uint64_t mask = ((uint64_t) 1 << (node_key_bits)) - 1; + uint64_t mask = MASK64_SAFE(node_key_bits); uint64_t start_index = (start >> node_bit_off) & mask; uint64_t end_index = (end >> node_bit_off) & mask; - uint64_t child_key_count = (uint64_t) 1 << node_bit_off; + uint64_t child_key_count = BIT64(node_bit_off); uint64_t count = 0; @@ -274,7 +274,7 @@ trie_free_node(struct trie *t, void *node, uint8_t depth) if (depth >= t->max_depth) goto free_node; - size_t sz = 1 << (trie_get_node_size(t, depth) - ptr_sz_lg); + size_t sz = BIT64(trie_get_node_size(t, depth) - ptr_sz_lg); for (size_t i = 0; i < sz; i++) trie_free_node(t, ((void **) node)[i], depth + 1); -- 2.1.4