152 lines
4.8 KiB
Diff
152 lines
4.8 KiB
Diff
From 8ef5456338a947944cc03b95c22c837af5884ddc Mon Sep 17 00:00:00 2001
|
|
From: Eugene Syromyatnikov <evgsyr@gmail.com>
|
|
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 <stdio.h>
|
|
|
|
#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
|
|
|