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