[PoC] Improve dead tuple storage for lazy vacuum

From 5dfbe02000aefd3e085bdea0ec809247e1fb71b3 Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Mon, 19 Jul 2021 16:03:28 -0700
Subject: [PATCH 1/3] Fix build warnings.

---
 bdbench/bdbench.c |  2 +-
 bdbench/rtbm.c    |  4 ++--
 bdbench/vtbm.c    | 10 +++++++---
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/bdbench/bdbench.c b/bdbench/bdbench.c
index 800567d..1df5c53 100644
--- a/bdbench/bdbench.c
+++ b/bdbench/bdbench.c
@@ -655,7 +655,7 @@ _bench(LVTestType *lvtt)
 	fclose(f);
 #endif
 
-	elog(NOTICE, "\"%s\": dead tuples %lu, index tuples %lu, mathed %d, mem %zu",
+	elog(NOTICE, "\"%s\": dead tuples %lu, index tuples %lu, matched %d, mem %zu",
 		 lvtt->name,
 		 lvtt->dtinfo.nitems,
 		 IndexTids_cache->dtinfo.nitems,
diff --git a/bdbench/rtbm.c b/bdbench/rtbm.c
index 025d2a9..eac277a 100644
--- a/bdbench/rtbm.c
+++ b/bdbench/rtbm.c
@@ -449,9 +449,9 @@ dump_entry(RTbm *rtbm, DtEntry *entry)
 		}
 	}
 
-	elog(NOTICE, "%s (offset %d len %d)",
+	elog(NOTICE, "%s (offset %llu len %d)",
 		 str.data,
-		 entry->offset, len);
+		 (long long unsigned) entry->offset, len);
 }
 
 static int
diff --git a/bdbench/vtbm.c b/bdbench/vtbm.c
index c59d6e1..63320f5 100644
--- a/bdbench/vtbm.c
+++ b/bdbench/vtbm.c
@@ -72,7 +72,8 @@ vtbm_add_tuples(VTbm *vtbm, const BlockNumber blkno,
 	DtEntry *entry;
 	bool	found;
 	char	oldstatus;
-	int wordnum, bitnum;
+	int wordnum = 0;
+	int bitnum;
 
 	entry = dttable_insert(vtbm->dttable, blkno, &found);
 	Assert(!found);
@@ -216,8 +217,10 @@ vtbm_dump(VTbm *vtbm)
 		 vtbm->bitmap_size, vtbm->npages);
 	for (int i = 0; i < vtbm->npages; i++)
 	{
+		char *bitmap;
+
 		entry = entries[i];
-		char *bitmap = &(vtbm->bitmap[entry->offset]);
+		bitmap = &(vtbm->bitmap[entry->offset]);
 
 		appendStringInfo(&str, "[%5d] : ", entry->blkno);
 		for (int off = 0; off < entry->len; off++)
@@ -239,6 +242,7 @@ vtbm_dump_blk(VTbm *vtbm, BlockNumber blkno)
 {
 	DtEntry *entry;
 	StringInfoData str;
+	char *bitmap;
 
 	initStringInfo(&str);
 
@@ -252,7 +256,7 @@ vtbm_dump_blk(VTbm *vtbm, BlockNumber blkno)
 		return;
 	}
 
-	char *bitmap = &(vtbm->bitmap[entry->offset]);
+	bitmap = &(vtbm->bitmap[entry->offset]);
 
 	appendStringInfo(&str, "[%5d] : ", entry->blkno);
 	for (int off = 1; off < entry->len; off++)
-- 
2.32.0.rc2

From 5ba05ffad4a9605a6fb5a24fe625542aee226ec8 Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Mon, 19 Jul 2021 16:04:55 -0700
Subject: [PATCH 2/3] Add radix tree.

---
 bdbench/radix.c | 3088 +++++++++++++++++++++++++++++++++++++++++++++++
 bdbench/radix.h |   76 ++
 2 files changed, 3164 insertions(+)
 create mode 100644 bdbench/radix.c
 create mode 100644 bdbench/radix.h

diff --git a/bdbench/radix.c b/bdbench/radix.c
new file mode 100644
index 0000000..c7061f0
--- /dev/null
+++ b/bdbench/radix.c
@@ -0,0 +1,3088 @@
+/*
+ *
+ */
+
+#include "postgres.h"
+
+#include "radix.h"
+
+#include "lib/stringinfo.h"
+#include "port/pg_bitutils.h"
+#include "utils/memutils.h"
+
+
+/*
+ * How many bits are encoded in one tree level.
+ *
+ * Linux uses 6, ART uses 8. In a non-adaptive radix tree the disadvantage of
+ * a higher fanout is increased memory usage - but the adapative node size
+ * addresses that to a good degree. Using a common multiple of 8 (i.e. bytes
+ * in a byte) has the advantage of making it easier to eventually support
+ * variable length data. Therefore go with 8 for now.
+ */
+#define BFM_FANOUT			8
+
+#define BFM_MAX_CLASS		(1<<BFM_FANOUT)
+
+#define BFM_MASK			((1 << BFM_FANOUT) - 1)
+
+
+/*
+ * Base type for all node types.
+ */
+struct bfm_tree_node_inner;
+typedef struct bfm_tree_node
+{
+	/*
+	 * Size class of entry (stored as uint8 instead of bfm_tree_node_kind to
+	 * save space).
+	 *
+	 * XXX: For efficiency in random access cases it'd be a good idea to
+	 * encode the kind of a node in the pointer value of upper nodes, in the
+	 * low bits. Being able to do the node type dispatch during traversal
+	 * before the memory for the node has been fetched from memory would
+	 * likely improve performance significantly.  But that'd require at least
+	 * 8 byte alignment, which we don't currently guarantee on all platforms.
+	 */
+	uint8 kind;
+
+	/*
+	 * Shift indicates which part of the key space is represented by this
+	 * node. I.e. the key is shifted by `shift` and the lowest BFM_FANOUT bits
+	 * are then represented in chunk.
+	 */
+	uint8 node_shift;
+	uint8 node_chunk;
+
+	/*
+	 * Number of children - currently uint16 to be able to indicate 256
+	 * children at a fanout of 8.
+	 */
+	uint16 count;
+
+	/* FIXME: Right now there's always unused bytes here :( */
+
+	/*
+	 * FIXME: could be removed by using a stack while walking down to deleted
+	 * node.
+	 */
+	struct bfm_tree_node_inner *parent;
+} bfm_tree_node;
+
+/*
+ * Base type for all inner nodes.
+ */
+typedef struct bfm_tree_node_inner
+{
+	bfm_tree_node b;
+} bfm_tree_node_inner;
+
+/*
+ * Base type for all leaf nodes.
+ */
+typedef struct bfm_tree_node_leaf
+{
+	bfm_tree_node b;
+} bfm_tree_node_leaf;
+
+
+/*
+ * Size classes.
+ *
+ * To reduce memory usage compared to a simple radix tree with a fixed fanout
+ * we use adaptive node sizes, with different storage methods for different
+ * numbers of elements.
+ *
+ * FIXME: These are currently not well chosen. To reduce memory fragmentation
+ * smaller class should optimally fit neatly into the next larger class
+ * (except perhaps at the lowest end). Right now its
+ * 32->56->160->304->1296->2064/2096 bytes for inner/leaf nodes, repeatedly
+ * just above a power of 2, leading to large amounts of allocator padding with
+ * aset.c. Hence the use of slab.
+ *
+ * FIXME: Duplication.
+ *
+ * XXX: Consider implementing path compression, it reduces worst case memory
+ * usage substantially. I.e. collapse sequences of nodes with just one child
+ * into one node. That would make it feasible to use this datastructure for
+ * wide keys. Gut feeling: When compressing inner nodes a limited number of
+ * tree levels should be skippable to keep nodes of a constant size. But when
+ * collapsing to leaf nodes it likely is worth to make them variable width,
+ * it's such a common scenario (a sparse key will always end with such a chain
+ * of nodes).
+ */
+
+/*
+ * Inner node size classes.
+ */
+typedef struct bfm_tree_node_inner_1
+{
+	bfm_tree_node_inner b;
+
+	/* single child, for key chunk */
+	uint8 chunk;
+	bfm_tree_node *slot;
+} bfm_tree_node_inner_1;
+
+typedef struct bfm_tree_node_inner_4
+{
+	bfm_tree_node_inner b;
+
+	/* four children, for key chunks */
+	uint8 chunks[4];
+	bfm_tree_node *slots[4];
+} bfm_tree_node_inner_4;
+
+typedef struct bfm_tree_node_inner_16
+{
+	bfm_tree_node_inner b;
+
+	/* four children, for key chunks */
+	uint8 chunks[16];
+	bfm_tree_node *slots[16];
+} bfm_tree_node_inner_16;
+
+#define BFM_TREE_NODE_32_INVALID 0xFF
+typedef struct bfm_tree_node_inner_32
+{
+	bfm_tree_node_inner b;
+
+	/*
+	 * 32 children. Offsets is indexed by they key chunk and points into
+	 * ->slots. An offset of BFM_TREE_NODE_32_INVALID indicates a non-existing
+	 * entry.
+	 *
+	 * XXX: It'd be nice to shrink the offsets array to use fewer bits - we
+	 * only need to index into an array of 32 entries. But 32 offsets already
+	 * is 5 bits, making a simple & fast encoding nontrivial.
+	 */
+	uint8 chunks[32];
+	bfm_tree_node *slots[32];
+} bfm_tree_node_inner_32;
+
+#define BFM_TREE_NODE_128_INVALID 0xFF
+typedef struct bfm_tree_node_inner_128
+{
+	bfm_tree_node_inner b;
+
+	uint8 offsets[BFM_MAX_CLASS];
+	bfm_tree_node *slots[128];
+} bfm_tree_node_inner_128;
+
+typedef struct bfm_tree_node_inner_max
+{
+	bfm_tree_node_inner b;
+	bfm_tree_node *slots[BFM_MAX_CLASS];
+} bfm_tree_node_inner_max;
+
+
+/*
+ * Leaf node size classes.
+ *
+ * Currently these are separate from inner node size classes for two main
+ * reasons:
+ *
+ * 1) the value type might be different than something fitting into a pointer
+ *    width type
+ * 2) Need to represent non-existing values in a key-type independent way.
+ *
+ * 1) is clearly worth being concerned about, but it's not clear 2) is as
+ * good. It might be better to just indicate non-existing entries the same way
+ * in inner nodes.
+ */
+
+typedef struct bfm_tree_node_leaf_1
+{
+	bfm_tree_node_leaf b;
+	uint8 chunk;
+	bfm_value_type value;
+} bfm_tree_node_leaf_1;
+
+#define BFM_TREE_NODE_LEAF_4_INVALID 0xFFFF
+typedef struct bfm_tree_node_leaf_4
+{
+	bfm_tree_node_leaf b;
+	uint8 chunks[4];
+	bfm_value_type values[4];
+} bfm_tree_node_leaf_4;
+
+#define BFM_TREE_NODE_LEAF_16_INVALID 0xFFFF
+typedef struct bfm_tree_node_leaf_16
+{
+	bfm_tree_node_leaf b;
+	uint8 chunks[16];
+	bfm_value_type values[16];
+} bfm_tree_node_leaf_16;
+
+typedef struct bfm_tree_node_leaf_32
+{
+	bfm_tree_node_leaf b;
+	uint8 chunks[32];
+	bfm_value_type values[32];
+} bfm_tree_node_leaf_32;
+
+typedef struct bfm_tree_node_leaf_128
+{
+	bfm_tree_node_leaf b;
+	uint8 offsets[BFM_MAX_CLASS];
+	bfm_value_type values[128];
+} bfm_tree_node_leaf_128;
+
+typedef struct bfm_tree_node_leaf_max
+{
+	bfm_tree_node_leaf b;
+	uint8 set[BFM_MAX_CLASS / (sizeof(uint8) * BITS_PER_BYTE)];
+	bfm_value_type values[BFM_MAX_CLASS];
+} bfm_tree_node_leaf_max;
+
+
+typedef struct bfm_tree_size_class_info
+{
+	const char *const name;
+	int elements;
+	size_t size;
+} bfm_tree_size_class_info;
+
+const bfm_tree_size_class_info inner_class_info[] =
+{
+	[BFM_KIND_1] = {"1", 1, sizeof(bfm_tree_node_inner_1)},
+	[BFM_KIND_4] = {"4", 4, sizeof(bfm_tree_node_inner_4)},
+	[BFM_KIND_16] = {"16", 16, sizeof(bfm_tree_node_inner_16)},
+	[BFM_KIND_32] = {"32", 32, sizeof(bfm_tree_node_inner_32)},
+	[BFM_KIND_128] = {"128", 128, sizeof(bfm_tree_node_inner_128)},
+	[BFM_KIND_MAX] = {"max", BFM_MAX_CLASS, sizeof(bfm_tree_node_inner_max)},
+};
+
+const bfm_tree_size_class_info leaf_class_info[] =
+{
+	[BFM_KIND_1] = {"1", 1, sizeof(bfm_tree_node_leaf_1)},
+	[BFM_KIND_4] = {"4", 4, sizeof(bfm_tree_node_leaf_4)},
+	[BFM_KIND_16] = {"16", 16, sizeof(bfm_tree_node_leaf_16)},
+	[BFM_KIND_32] = {"32", 32, sizeof(bfm_tree_node_leaf_32)},
+	[BFM_KIND_128] = {"128", 128, sizeof(bfm_tree_node_leaf_128)},
+	[BFM_KIND_MAX] = {"max", BFM_MAX_CLASS, sizeof(bfm_tree_node_leaf_max)},
+};
+
+static void *
+bfm_alloc_node(bfm_tree *root, bool inner, bfm_tree_node_kind kind, size_t size)
+{
+	bfm_tree_node *node;
+
+#ifdef BFM_USE_SLAB
+	if (inner)
+		node = (bfm_tree_node *) MemoryContextAlloc(root->inner_slabs[kind], size);
+	else
+		node = (bfm_tree_node *) MemoryContextAlloc(root->leaf_slabs[kind], size);
+#elif defined(BFM_USE_OS)
+	node = (bfm_tree_node *) malloc(size);
+#else
+	node = (bfm_tree_node *) MemoryContextAlloc(root->context, size);
+#endif
+
+	return node;
+}
+
+static bfm_tree_node_inner *
+bfm_alloc_inner(bfm_tree *root, bfm_tree_node_kind kind, size_t size)
+{
+	bfm_tree_node_inner *node;
+
+	Assert(inner_class_info[kind].size == size);
+#ifdef BFM_STATS
+	root->inner_nodes[kind]++;
+#endif
+
+	node = bfm_alloc_node(root, true, kind, size);
+
+	memset(&node->b, 0, sizeof(node->b));
+	node->b.kind = kind;
+
+	return node;
+}
+
+static bfm_tree_node_inner *
+bfm_alloc_leaf(bfm_tree *root, bfm_tree_node_kind kind, size_t size)
+{
+	bfm_tree_node_inner *node;
+
+	Assert(leaf_class_info[kind].size == size);
+#ifdef BFM_STATS
+	root->leaf_nodes[kind]++;
+#endif
+
+	node = bfm_alloc_node(root, false, kind, size);
+
+	memset(&node->b, 0, sizeof(node->b));
+	node->b.kind = kind;
+
+	return node;
+}
+
+
+static bfm_tree_node_inner_1 *
+bfm_alloc_inner_1(bfm_tree *root)
+{
+	bfm_tree_node_inner_1 *node =
+		(bfm_tree_node_inner_1 *) bfm_alloc_inner(root, BFM_KIND_1, sizeof(*node));
+
+	return node;
+}
+
+#define BFM_TREE_NODE_INNER_4_INVALID 0xFF
+static bfm_tree_node_inner_4 *
+bfm_alloc_inner_4(bfm_tree *root)
+{
+	bfm_tree_node_inner_4 *node =
+		(bfm_tree_node_inner_4 *) bfm_alloc_inner(root, BFM_KIND_4, sizeof(*node));
+
+	return node;
+}
+
+#define BFM_TREE_NODE_INNER_16_INVALID 0xFF
+static bfm_tree_node_inner_16 *
+bfm_alloc_inner_16(bfm_tree *root)
+{
+	bfm_tree_node_inner_16 *node =
+		(bfm_tree_node_inner_16 *) bfm_alloc_inner(root, BFM_KIND_16, sizeof(*node));
+
+	return node;
+}
+
+#define BFM_TREE_NODE_INNER_32_INVALID 0xFF
+static bfm_tree_node_inner_32 *
+bfm_alloc_inner_32(bfm_tree *root)
+{
+	bfm_tree_node_inner_32 *node =
+		(bfm_tree_node_inner_32 *) bfm_alloc_inner(root, BFM_KIND_32, sizeof(*node));
+
+	return node;
+}
+
+static bfm_tree_node_inner_128 *
+bfm_alloc_inner_128(bfm_tree *root)
+{
+	bfm_tree_node_inner_128 *node =
+		(bfm_tree_node_inner_128 *) bfm_alloc_inner(root, BFM_KIND_128, sizeof(*node));
+
+	memset(&node->offsets, BFM_TREE_NODE_128_INVALID, sizeof(node->offsets));
+
+	return node;
+}
+
+static bfm_tree_node_inner_max *
+bfm_alloc_inner_max(bfm_tree *root)
+{
+	bfm_tree_node_inner_max *node =
+		(bfm_tree_node_inner_max *) bfm_alloc_inner(root, BFM_KIND_MAX, sizeof(*node));
+
+	memset(&node->slots, 0, sizeof(node->slots));
+
+	return node;
+}
+
+static bfm_tree_node_leaf_1 *
+bfm_alloc_leaf_1(bfm_tree *root)
+{
+	bfm_tree_node_leaf_1 *node =
+		(bfm_tree_node_leaf_1 *) bfm_alloc_leaf(root, BFM_KIND_1, sizeof(*node));
+
+	return node;
+}
+
+static bfm_tree_node_leaf_4 *
+bfm_alloc_leaf_4(bfm_tree *root)
+{
+	bfm_tree_node_leaf_4 *node =
+		(bfm_tree_node_leaf_4 *) bfm_alloc_leaf(root, BFM_KIND_4, sizeof(*node));
+
+	return node;
+}
+
+static bfm_tree_node_leaf_16 *
+bfm_alloc_leaf_16(bfm_tree *root)
+{
+	bfm_tree_node_leaf_16 *node =
+		(bfm_tree_node_leaf_16 *) bfm_alloc_leaf(root, BFM_KIND_16, sizeof(*node));
+
+	return node;
+}
+
+static bfm_tree_node_leaf_32 *
+bfm_alloc_leaf_32(bfm_tree *root)
+{
+	bfm_tree_node_leaf_32 *node =
+		(bfm_tree_node_leaf_32 *) bfm_alloc_leaf(root, BFM_KIND_32, sizeof(*node));
+
+	return node;
+}
+
+static bfm_tree_node_leaf_128 *
+bfm_alloc_leaf_128(bfm_tree *root)
+{
+	bfm_tree_node_leaf_128 *node =
+		(bfm_tree_node_leaf_128 *) bfm_alloc_leaf(root, BFM_KIND_128, sizeof(*node));
+
+	memset(node->offsets, BFM_TREE_NODE_128_INVALID, sizeof(node->offsets));
+
+	return node;
+}
+
+static bfm_tree_node_leaf_max *
+bfm_alloc_leaf_max(bfm_tree *root)
+{
+	bfm_tree_node_leaf_max *node =
+		(bfm_tree_node_leaf_max *) bfm_alloc_leaf(root, BFM_KIND_MAX, sizeof(*node));
+
+	memset(node->set, 0, sizeof(node->set));
+
+	return node;
+}
+
+static void
+bfm_free_internal(bfm_tree *root, void *p)
+{
+#if defined(BFM_USE_OS)
+	free(p);
+#else
+	pfree(p);
+#endif
+}
+
+static void
+bfm_free_inner(bfm_tree *root, bfm_tree_node_inner *node)
+{
+	Assert(node->b.node_shift != 0);
+
+#ifdef BFM_STATS
+	root->inner_nodes[node->b.kind]--;
+#endif
+
+	bfm_free_internal(root, node);
+}
+
+static void
+bfm_free_leaf(bfm_tree *root, bfm_tree_node_leaf *node)
+{
+	Assert(node->b.node_shift == 0);
+
+#ifdef BFM_STATS
+	root->leaf_nodes[node->b.kind]--;
+#endif
+
+	bfm_free_internal(root, node);
+}
+
+#define BFM_LEAF_MAX_SET_OFFSET(i) (i / (sizeof(uint8) * BITS_PER_BYTE))
+#define BFM_LEAF_MAX_SET_BIT(i) (UINT64_C(1) << (i & ((sizeof(uint8) * BITS_PER_BYTE)-1)))
+
+static inline bool
+bfm_leaf_max_isset(bfm_tree_node_leaf_max *node_max, uint32 i)
+{
+	return node_max->set[BFM_LEAF_MAX_SET_OFFSET(i)] & BFM_LEAF_MAX_SET_BIT(i);
+}
+
+static inline void
+bfm_leaf_max_set(bfm_tree_node_leaf_max *node_max, uint32 i)
+{
+	node_max->set[BFM_LEAF_MAX_SET_OFFSET(i)] |= BFM_LEAF_MAX_SET_BIT(i);
+}
+
+static inline void
+bfm_leaf_max_unset(bfm_tree_node_leaf_max *node_max, uint32 i)
+{
+	node_max->set[BFM_LEAF_MAX_SET_OFFSET(i)] &= ~BFM_LEAF_MAX_SET_BIT(i);
+}
+
+static uint64
+bfm_maxval_shift(uint32 shift)
+{
+	uint32 maxshift = (sizeof(bfm_key_type) * BITS_PER_BYTE) / BFM_FANOUT  * BFM_FANOUT;
+
+	Assert(shift <= maxshift);
+
+	if (shift == maxshift)
+		return UINT64_MAX;
+
+	return (UINT64_C(1) << (shift + BFM_FANOUT)) - 1;
+}
+
+static inline int
+search_chunk_array_4_eq(uint8 *chunks, uint8 match, uint8 count)
+{
+	int index = -1;
+
+	for (int i = 0; i < count; i++)
+	{
+		if (chunks[i] == match)
+		{
+			index = i;
+			break;
+		}
+	}
+
+	return index;
+}
+
+static inline int
+search_chunk_array_4_le(uint8 *chunks, uint8 match, uint8 count)
+{
+	int index;
+
+	for (index = 0; index < count; index++)
+		if (chunks[index] >= match)
+			break;
+
+	return index;
+}
+
+
+#if defined(__SSE2__)
+#include <emmintrin.h> // x86 SSE intrinsics
+#endif
+
+static inline int
+search_chunk_array_16_eq(uint8 *chunks, uint8 match, uint8 count)
+{
+#if !defined(__SSE2__) || defined(USE_ASSERT_CHECKING)
+	int index = -1;
+#endif
+
+#ifdef __SSE2__
+	int index_sse;
+	__m128i spread_chunk = _mm_set1_epi8(match);
+	__m128i haystack = _mm_loadu_si128((__m128i_u*) chunks);
+	__m128i cmp=_mm_cmpeq_epi8(spread_chunk, haystack);
+	uint32_t bitfield=_mm_movemask_epi8(cmp);
+
+	bitfield &= ((1<<count)-1);
+
+	if (bitfield)
+		index_sse = __builtin_ctz(bitfield);
+	else
+		index_sse = -1;
+
+#endif
+
+#if !defined(__SSE2__) || defined(USE_ASSERT_CHECKING)
+	for (int i = 0; i < count; i++)
+	{
+		if (chunks[i] == match)
+		{
+			index = i;
+			break;
+		}
+	}
+
+#if defined(__SSE2__)
+	Assert(index_sse == index);
+#endif
+
+#endif
+
+#if defined(__SSE2__)
+	return index_sse;
+#else
+	return index;
+#endif
+}
+
+/*
+ * This is a bit more complicated than search_chunk_array_16_eq(), because
+ * until recently no unsigned uint8 comparison instruction existed on x86. So
+ * we need to play some trickery using _mm_min_epu8() to effectively get
+ * <=. There never will be any equal elements in the current uses, but that's
+ * what we get here...
+ */
+static inline int
+search_chunk_array_16_le(uint8 *chunks, uint8 match, uint8 count)
+{
+#if !defined(__SSE2__) || defined(USE_ASSERT_CHECKING)
+	int index;
+#endif
+
+#ifdef __SSE2__
+	int index_sse;
+	__m128i spread_chunk = _mm_set1_epi8(match);
+	__m128i haystack = _mm_loadu_si128((__m128i_u*) chunks);
+	__m128i min = _mm_min_epu8(haystack, spread_chunk);
+	__m128i cmp = _mm_cmpeq_epi8(spread_chunk, min);
+	uint32_t bitfield=_mm_movemask_epi8(cmp);
+
+	bitfield &= ((1<<count)-1);
+
+	if (bitfield)
+		index_sse = __builtin_ctz(bitfield);
+	else
+		index_sse = count;
+#endif
+
+#if !defined(__SSE2__) || defined(USE_ASSERT_CHECKING)
+	for (index = 0; index < count; index++)
+		if (chunks[index] >= match)
+			break;
+
+#if defined(__SSE2__)
+	Assert(index_sse == index);
+#endif
+
+#endif
+
+#if defined(__SSE2__)
+	return index_sse;
+#else
+	return index;
+#endif
+}
+
+#if defined(__AVX2__)
+#include <immintrin.h> // x86 SSE intrinsics
+#endif
+
+static inline int
+search_chunk_array_32_eq(uint8 *chunks, uint8 match, uint8 count)
+{
+#if !defined(__AVX2__) || defined(USE_ASSERT_CHECKING)
+	int index = -1;
+#endif
+
+#ifdef __AVX2__
+	int index_sse;
+	__m256i spread_chunk = _mm256_set1_epi8(match);
+	__m256i haystack = _mm256_loadu_si256((__m256i_u*) chunks);
+	__m256i cmp= _mm256_cmpeq_epi8(spread_chunk, haystack);
+	uint32_t bitfield = _mm256_movemask_epi8(cmp);
+
+	bitfield &= ((UINT64_C(1)<<count)-1);
+
+	if (bitfield)
+		index_sse = __builtin_ctz(bitfield);
+	else
+		index_sse = -1;
+
+#endif
+
+#if !defined(__AVX2__) || defined(USE_ASSERT_CHECKING)
+	for (int i = 0; i < count; i++)
+	{
+		if (chunks[i] == match)
+		{
+			index = i;
+			break;
+		}
+	}
+
+#if defined(__AVX2__)
+	Assert(index_sse == index);
+#endif
+
+#endif
+
+#if defined(__AVX2__)
+	return index_sse;
+#else
+	return index;
+#endif
+}
+
+/*
+ * This is a bit more complicated than search_chunk_array_16_eq(), because
+ * until recently no unsigned uint8 comparison instruction existed on x86. So
+ * we need to play some trickery using _mm_min_epu8() to effectively get
+ * <=. There never will be any equal elements in the current uses, but that's
+ * what we get here...
+ */
+static inline int
+search_chunk_array_32_le(uint8 *chunks, uint8 match, uint8 count)
+{
+#if !defined(__AVX2__) || defined(USE_ASSERT_CHECKING)
+	int index;
+#endif
+
+#ifdef __AVX2__
+	int index_sse;
+	__m256i spread_chunk = _mm256_set1_epi8(match);
+	__m256i haystack = _mm256_loadu_si256((__m256i_u*) chunks);
+	__m256i min = _mm256_min_epu8(haystack, spread_chunk);
+	__m256i cmp=_mm256_cmpeq_epi8(spread_chunk, min);
+	uint32_t bitfield=_mm256_movemask_epi8(cmp);
+
+	bitfield &= ((1<<count)-1);
+
+	if (bitfield)
+		index_sse = __builtin_ctz(bitfield);
+	else
+		index_sse = count;
+#endif
+
+#if !defined(__AVX2__) || defined(USE_ASSERT_CHECKING)
+	for (index = 0; index < count; index++)
+		if (chunks[index] >= match)
+			break;
+
+#if defined(__AVX2__)
+	Assert(index_sse == index);
+#endif
+
+#endif
+
+#if defined(__AVX2__)
+	return index_sse;
+#else
+	return index;
+#endif
+}
+
+static inline void
+chunk_slot_array_grow(uint8 *source_chunks, bfm_tree_node **source_slots,
+					  uint8 *target_chunks, bfm_tree_node **target_slots,
+					  bfm_tree_node_inner *oldnode, bfm_tree_node_inner *newnode)
+{
+	memcpy(target_chunks, source_chunks, sizeof(source_chunks[0]) * oldnode->b.count);
+	memcpy(target_slots, source_slots, sizeof(source_slots[0]) * oldnode->b.count);
+
+	for (int i = 0; i < oldnode->b.count; i++)
+	{
+		Assert(source_slots[i]->parent == oldnode);
+		source_slots[i]->parent = newnode;
+	}
+}
+
+/*
+ * FIXME: Find a way to deduplicate with bfm_find_one_level_inner()
+ */
+pg_attribute_always_inline static bfm_tree_node *
+bfm_find_one_level_inner(bfm_tree_node_inner * pg_restrict node, uint8 chunk)
+{
+	bfm_tree_node *slot = NULL;
+
+	Assert(node->b.node_shift != 0); /* is inner node */
+
+	/* tell the compiler it doesn't need a bounds check */
+	if ((bfm_tree_node_kind) node->b.kind > BFM_KIND_MAX)
+		pg_unreachable();
+
+	switch((bfm_tree_node_kind) node->b.kind)
+	{
+		case BFM_KIND_1:
+			{
+				bfm_tree_node_inner_1 *node_1 =
+					(bfm_tree_node_inner_1 *) node;
+
+				Assert(node_1->b.b.count <= 1);
+				if (node_1->chunk == chunk)
+					slot = node_1->slot;
+				break;
+			}
+
+		case BFM_KIND_4:
+			{
+				bfm_tree_node_inner_4 *node_4 =
+					(bfm_tree_node_inner_4 *) node;
+				int index;
+
+				Assert(node_4->b.b.count <= 4);
+				index = search_chunk_array_4_eq(node_4->chunks, chunk, node_4->b.b.count);
+
+				if (index != -1)
+					slot = node_4->slots[index];
+
+				break;
+			}
+
+		case BFM_KIND_16:
+			{
+				bfm_tree_node_inner_16 *node_16 =
+					(bfm_tree_node_inner_16 *) node;
+				int index;
+
+				Assert(node_16->b.b.count <= 16);
+
+				index = search_chunk_array_16_eq(node_16->chunks, chunk, node_16->b.b.count);
+				if (index != -1)
+					slot = node_16->slots[index];
+
+				break;
+			}
+
+		case BFM_KIND_32:
+			{
+				bfm_tree_node_inner_32 *node_32 =
+					(bfm_tree_node_inner_32 *) node;
+				int index;
+
+				Assert(node_32->b.b.count <= 32);
+
+				index = search_chunk_array_32_eq(node_32->chunks, chunk, node_32->b.b.count);
+				if (index != -1)
+					slot = node_32->slots[index];
+
+				break;
+			}
+
+		case BFM_KIND_128:
+			{
+				bfm_tree_node_inner_128 *node_128 =
+					(bfm_tree_node_inner_128 *) node;
+
+				Assert(node_128->b.b.count <= 128);
+
+				if (node_128->offsets[chunk] != BFM_TREE_NODE_128_INVALID)
+				{
+					slot = node_128->slots[node_128->offsets[chunk]];
+				}
+				break;
+			}
+
+		case BFM_KIND_MAX:
+			{
+				bfm_tree_node_inner_max *node_max =
+					(bfm_tree_node_inner_max *) node;
+
+				Assert(node_max->b.b.count <= BFM_MAX_CLASS);
+				slot = node_max->slots[chunk];
+
+				break;
+			}
+	}
+
+	return slot;
+}
+
+/*
+ * FIXME: Find a way to deduplicate with bfm_find_one_level_inner()
+ */
+pg_attribute_always_inline static bool
+bfm_find_one_level_leaf(bfm_tree_node_leaf * pg_restrict node, uint8 chunk, bfm_value_type * pg_restrict valp)
+{
+	bool found = false;
+
+	Assert(node->b.node_shift == 0); /* is leaf node */
+
+	/* tell the compiler it doesn't need a bounds check */
+	if ((bfm_tree_node_kind) node->b.kind > BFM_KIND_MAX)
+		pg_unreachable();
+
+	switch((bfm_tree_node_kind) node->b.kind)
+	{
+		case BFM_KIND_1:
+			{
+				bfm_tree_node_leaf_1 *node_1 =
+					(bfm_tree_node_leaf_1 *) node;
+
+				Assert(node_1->b.b.count <= 1);
+				if (node_1->b.b.count == 1 &&
+					node_1->chunk == chunk)
+				{
+					*valp = node_1->value;
+					found = true;
+					break;
+				}
+				break;
+			}
+
+		case BFM_KIND_4:
+			{
+				bfm_tree_node_leaf_4 *node_4 =
+					(bfm_tree_node_leaf_4 *) node;
+				int index;
+
+				Assert(node_4->b.b.count <= 4);
+				index = search_chunk_array_4_eq(node_4->chunks, chunk, node_4->b.b.count);
+
+				if (index != -1)
+				{
+					*valp = node_4->values[index];
+					found = true;
+				}
+				break;
+			}
+
+		case BFM_KIND_16:
+			{
+				bfm_tree_node_leaf_16 *node_16 =
+					(bfm_tree_node_leaf_16 *) node;
+				int index;
+
+				Assert(node_16->b.b.count <= 16);
+
+				index = search_chunk_array_16_eq(node_16->chunks, chunk, node_16->b.b.count);
+				if (index != -1)
+				{
+					*valp = node_16->values[index];
+					found = true;
+					break;
+				}
+				break;
+			}
+
+		case BFM_KIND_32:
+			{
+				bfm_tree_node_leaf_32 *node_32 =
+					(bfm_tree_node_leaf_32 *) node;
+				int index;
+
+				Assert(node_32->b.b.count <= 32);
+
+				index = search_chunk_array_32_eq(node_32->chunks, chunk, node_32->b.b.count);
+				if (index != -1)
+				{
+					*valp = node_32->values[index];
+					found = true;
+					break;
+				}
+				break;
+			}
+
+		case BFM_KIND_128:
+			{
+				bfm_tree_node_leaf_128 *node_128 =
+					(bfm_tree_node_leaf_128 *) node;
+
+				Assert(node_128->b.b.count <= 128);
+
+				if (node_128->offsets[chunk] != BFM_TREE_NODE_128_INVALID)
+				{
+					*valp = node_128->values[node_128->offsets[chunk]];
+					found = true;
+				}
+				break;
+			}
+
+		case BFM_KIND_MAX:
+			{
+				bfm_tree_node_leaf_max *node_max =
+					(bfm_tree_node_leaf_max *) node;
+
+				Assert(node_max->b.b.count <= BFM_MAX_CLASS);
+
+				if (bfm_leaf_max_isset(node_max, chunk))
+				{
+					*valp = node_max->values[chunk];
+					found = true;
+				}
+				break;
+			}
+	}
+
+	return found;
+}
+
+pg_attribute_always_inline static bool
+bfm_walk(bfm_tree *root, bfm_tree_node **nodep, bfm_value_type *valp, uint64_t key)
+{
+	bfm_tree_node *rnode;
+	bfm_tree_node *cur;
+	uint8 chunk;
+	uint32 shift;
+
+	rnode = root->rnode;
+
+	/* can't be contained in the tree */
+	if (!rnode || key > root->maxval)
+	{
+		*nodep = NULL;
+		return false;
+	}
+
+	shift = rnode->node_shift;
+	chunk = (key >> shift) & BFM_MASK;
+	cur = rnode;
+
+	while (shift > 0)
+	{
+		bfm_tree_node_inner *cur_inner;
+		bfm_tree_node *slot;
+
+		Assert(cur->node_shift > 0); /* leaf nodes look different */
+		Assert(cur->node_shift == shift);
+
+		cur_inner = (bfm_tree_node_inner *) cur;
+
+		slot = bfm_find_one_level_inner(cur_inner, chunk);
+
+		if (slot == NULL)
+		{
+			*nodep = cur;
+			return false;
+		}
+
+		Assert(&slot->parent->b == cur);
+		Assert(slot->node_chunk == chunk);
+
+		cur = slot;
+		shift -= BFM_FANOUT;
+		chunk = (key >> shift) & BFM_MASK;
+	}
+
+	Assert(cur->node_shift == shift && shift == 0);
+
+	*nodep = cur;
+
+	return bfm_find_one_level_leaf((bfm_tree_node_leaf*) cur, chunk, valp);
+}
+
+/*
+ * Redirect parent pointers to oldnode by newnode, for the key chunk
+ * chunk. Used when growing or shrinking nodes.
+ */
+static void
+bfm_redirect(bfm_tree *root, bfm_tree_node *oldnode, bfm_tree_node *newnode, uint8 chunk)
+{
+	bfm_tree_node_inner *parent = oldnode->parent;
+
+	if (parent == NULL)
+	{
+		Assert(root->rnode == oldnode);
+		root->rnode = newnode;
+		return;
+	}
+
+	/* if there is a parent, it needs to be an inner node */
+	Assert(parent->b.node_shift != 0);
+
+	if ((bfm_tree_node_kind) parent->b.kind > BFM_KIND_MAX)
+		pg_unreachable();
+
+	switch((bfm_tree_node_kind) parent->b.kind)
+	{
+		case BFM_KIND_1:
+			{
+				bfm_tree_node_inner_1 *parent_1 =
+					(bfm_tree_node_inner_1 *) parent;
+
+				Assert(parent_1->slot == oldnode);
+				Assert(parent_1->chunk == chunk);
+
+				parent_1->slot = newnode;
+				break;
+			}
+
+		case BFM_KIND_4:
+			{
+				bfm_tree_node_inner_4 *parent_4 =
+					(bfm_tree_node_inner_4 *) parent;
+				int index;
+
+				Assert(parent_4->b.b.count <= 4);
+				index = search_chunk_array_4_eq(parent_4->chunks, chunk, parent_4->b.b.count);
+				Assert(index != -1);
+
+				Assert(parent_4->slots[index] == oldnode);
+				parent_4->slots[index] = newnode;
+
+				break;
+			}
+
+		case BFM_KIND_16:
+			{
+				bfm_tree_node_inner_16 *parent_16 =
+					(bfm_tree_node_inner_16 *) parent;
+				int index;
+
+				index = search_chunk_array_16_eq(parent_16->chunks, chunk, parent_16->b.b.count);
+				Assert(index != -1);
+
+				Assert(parent_16->slots[index] == oldnode);
+				parent_16->slots[index] = newnode;
+				break;
+			}
+
+		case BFM_KIND_32:
+			{
+				bfm_tree_node_inner_32 *parent_32 =
+					(bfm_tree_node_inner_32 *) parent;
+				int index;
+
+				index = search_chunk_array_32_eq(parent_32->chunks, chunk, parent_32->b.b.count);
+				Assert(index != -1);
+
+				Assert(parent_32->slots[index] == oldnode);
+				parent_32->slots[index] = newnode;
+				break;
+			}
+
+		case BFM_KIND_128:
+			{
+				bfm_tree_node_inner_128 *parent_128 =
+					(bfm_tree_node_inner_128 *) parent;
+				uint8 offset;
+
+				offset = parent_128->offsets[chunk];
+				Assert(offset != BFM_TREE_NODE_128_INVALID);
+				Assert(parent_128->slots[offset] == oldnode);
+				parent_128->slots[offset] = newnode;
+				break;
+			}
+
+		case BFM_KIND_MAX:
+			{
+				bfm_tree_node_inner_max *parent_max =
+					(bfm_tree_node_inner_max *) parent;
+
+				Assert(parent_max->slots[chunk] == oldnode);
+				parent_max->slots[chunk] = newnode;
+
+				break;
+			}
+	}
+}
+
+static void
+bfm_node_copy_common(bfm_tree *root, bfm_tree_node *oldnode, bfm_tree_node *newnode)
+{
+	newnode->node_shift = oldnode->node_shift;
+	newnode->node_chunk = oldnode->node_chunk;
+	newnode->count = oldnode->count;
+	newnode->parent = oldnode->parent;
+}
+
+/*
+ * Insert child into node.
+ *
+ * NB: `node` cannot be used after this call anymore, it changes if the node
+ * needs to be grown to fit the insertion.
+ *
+ * FIXME: Find a way to deduplicate with bfm_set_leaf()
+ */
+static void
+bfm_insert_inner(bfm_tree *root, bfm_tree_node_inner *node, bfm_tree_node *child, int child_chunk)
+{
+	Assert(node->b.node_shift != 0); /* is inner node */
+
+	child->node_chunk = child_chunk;
+
+	/* tell the compiler it doesn't need a bounds check */
+	if ((bfm_tree_node_kind) node->b.kind > BFM_KIND_MAX)
+		pg_unreachable();
+
+	switch((bfm_tree_node_kind) node->b.kind)
+	{
+		case BFM_KIND_1:
+			{
+				bfm_tree_node_inner_1 *node_1 =
+					(bfm_tree_node_inner_1 *) node;
+
+				Assert(node_1->b.b.count <= 1);
+
+				if (unlikely(node_1->b.b.count == 1))
+				{
+					/* grow node from 1 -> 4 */
+					bfm_tree_node_inner_4 *newnode_4;
+
+					newnode_4 = bfm_alloc_inner_4(root);
+					bfm_node_copy_common(root, &node->b, &newnode_4->b.b);
+
+					Assert(node_1->slot->parent != NULL);
+					Assert(node_1->slot->parent == node);
+					newnode_4->chunks[0] = node_1->chunk;
+					newnode_4->slots[0] = node_1->slot;
+					node_1->slot->parent = &newnode_4->b;
+
+					bfm_redirect(root, &node->b, &newnode_4->b.b, newnode_4->b.b.node_chunk);
+					bfm_free_inner(root, node);
+					node = &newnode_4->b;
+				}
+				else
+				{
+					child->parent = node;
+					node_1->chunk = child_chunk;
+					node_1->slot = child;
+					break;
+				}
+			}
+			/* fallthrough */
+
+		case BFM_KIND_4:
+			{
+				bfm_tree_node_inner_4 *node_4 =
+					(bfm_tree_node_inner_4 *) node;
+
+				Assert(node_4->b.b.count <= 4);
+				if (unlikely(node_4->b.b.count == 4))
+				{
+					/* grow node from 4 -> 16 */
+					bfm_tree_node_inner_16 *newnode_16;
+
+					newnode_16 = bfm_alloc_inner_16(root);
+					bfm_node_copy_common(root, &node->b, &newnode_16->b.b);
+
+					chunk_slot_array_grow(node_4->chunks, node_4->slots,
+										  newnode_16->chunks, newnode_16->slots,
+										  &node_4->b, &newnode_16->b);
+
+					bfm_redirect(root, &node->b, &newnode_16->b.b, newnode_16->b.b.node_chunk);
+					bfm_free_inner(root, node);
+					node = &newnode_16->b;
+				}
+				else
+				{
+					int insertpos;
+
+					for (insertpos = 0; insertpos < node_4->b.b.count; insertpos++)
+						if (node_4->chunks[insertpos] >= child_chunk)
+							break;
+
+					child->parent = node;
+
+					memmove(&node_4->slots[insertpos + 1],
+							&node_4->slots[insertpos],
+							(node_4->b.b.count - insertpos) * sizeof(node_4->slots[0]));
+					memmove(&node_4->chunks[insertpos + 1],
+							&node_4->chunks[insertpos],
+							(node_4->b.b.count - insertpos) * sizeof(node_4->chunks[0]));
+
+					node_4->chunks[insertpos] = child_chunk;
+					node_4->slots[insertpos] = child;
+					break;
+				}
+			}
+			/* fallthrough */
+
+		case BFM_KIND_16:
+			{
+				bfm_tree_node_inner_16 *node_16 =
+					(bfm_tree_node_inner_16 *) node;
+
+				Assert(node_16->b.b.count <= 16);
+				if (unlikely(node_16->b.b.count == 16))
+				{
+					/* grow node from 16 -> 32 */
+					bfm_tree_node_inner_32 *newnode_32;
+
+					newnode_32 = bfm_alloc_inner_32(root);
+					bfm_node_copy_common(root, &node->b, &newnode_32->b.b);
+
+					chunk_slot_array_grow(node_16->chunks, node_16->slots,
+										  newnode_32->chunks, newnode_32->slots,
+										  &node_16->b, &newnode_32->b);
+
+					bfm_redirect(root, &node->b, &newnode_32->b.b, newnode_32->b.b.node_chunk);
+					bfm_free_inner(root, node);
+					node = &newnode_32->b;
+				}
+				else
+				{
+					int insertpos;
+
+					insertpos = search_chunk_array_16_le(node_16->chunks, child_chunk, node_16->b.b.count);
+
+					child->parent = node;
+
+					memmove(&node_16->slots[insertpos + 1],
+							&node_16->slots[insertpos],
+							(node_16->b.b.count - insertpos) * sizeof(node_16->slots[0]));
+					memmove(&node_16->chunks[insertpos + 1],
+							&node_16->chunks[insertpos],
+							(node_16->b.b.count - insertpos) * sizeof(node_16->chunks[0]));
+
+					node_16->chunks[insertpos] = child_chunk;
+					node_16->slots[insertpos] = child;
+					break;
+				}
+			}
+			/* fallthrough */
+
+		case BFM_KIND_32:
+			{
+				bfm_tree_node_inner_32 *node_32 =
+					(bfm_tree_node_inner_32 *) node;
+
+				Assert(node_32->b.b.count <= 32);
+				if (unlikely(node_32->b.b.count == 32))
+				{
+					/* grow node from 32 -> 128 */
+					bfm_tree_node_inner_128 *newnode_128;
+
+					newnode_128 = bfm_alloc_inner_128(root);
+					bfm_node_copy_common(root, &node->b, &newnode_128->b.b);
+
+					memcpy(newnode_128->slots, node_32->slots, sizeof(node_32->slots));
+
+					/* change parent pointers of children */
+					for (int i = 0; i < 32; i++)
+					{
+						Assert(node_32->slots[i]->parent == node);
+						newnode_128->offsets[node_32->chunks[i]] = i;
+						node_32->slots[i]->parent = &newnode_128->b;
+					}
+
+					bfm_redirect(root, &node->b, &newnode_128->b.b, newnode_128->b.b.node_chunk);
+					bfm_free_inner(root, node);
+					node = &newnode_128->b;
+				}
+				else
+				{
+					int insertpos;
+
+					insertpos = search_chunk_array_32_le(node_32->chunks, child_chunk, node_32->b.b.count);
+
+					child->parent = node;
+
+					memmove(&node_32->slots[insertpos + 1],
+							&node_32->slots[insertpos],
+							(node_32->b.b.count - insertpos) * sizeof(node_32->slots[0]));
+					memmove(&node_32->chunks[insertpos + 1],
+							&node_32->chunks[insertpos],
+							(node_32->b.b.count - insertpos) * sizeof(node_32->chunks[0]));
+
+					node_32->chunks[insertpos] = child_chunk;
+					node_32->slots[insertpos] = child;
+					break;
+				}
+			}
+			/* fallthrough */
+
+		case BFM_KIND_128:
+			{
+				bfm_tree_node_inner_128 *node_128 =
+					(bfm_tree_node_inner_128 *) node;
+				uint8 offset;
+
+				Assert(node_128->b.b.count <= 128);
+				if (unlikely(node_128->b.b.count == 128))
+				{
+					/* grow node from 128 -> max */
+					bfm_tree_node_inner_max *newnode_max;
+
+					newnode_max = bfm_alloc_inner_max(root);
+					bfm_node_copy_common(root, &node->b, &newnode_max->b.b);
+
+					for (int i = 0; i < BFM_MAX_CLASS; i++)
+					{
+						uint8 offset = node_128->offsets[i];
+
+						if (offset == BFM_TREE_NODE_128_INVALID)
+							continue;
+
+						Assert(node_128->slots[offset] != NULL);
+						Assert(node_128->slots[offset]->parent == node);
+
+						node_128->slots[offset]->parent = &newnode_max->b;
+
+						newnode_max->slots[i] = node_128->slots[offset];
+					}
+
+					bfm_redirect(root, &node->b, &newnode_max->b.b, newnode_max->b.b.node_chunk);
+					bfm_free_inner(root, node);
+					node = &newnode_max->b;
+				}
+				else
+				{
+					child->parent = node;
+					offset = node_128->b.b.count;
+					/* FIXME: this may overwrite entry if there had been deletions */
+					node_128->offsets[child_chunk] = offset;
+					node_128->slots[offset] = child;
+					break;
+				}
+			}
+			/* fallthrough */
+
+		case BFM_KIND_MAX:
+			{
+				bfm_tree_node_inner_max *node_max =
+					(bfm_tree_node_inner_max *) node;
+
+				Assert(node_max->b.b.count <= (BFM_MAX_CLASS - 1));
+				Assert(node_max->slots[child_chunk] == NULL);
+
+				child->parent = node;
+				node_max->slots[child_chunk] = child;
+
+				break;
+			}
+	}
+
+	node->b.count++;
+}
+
+static bool pg_noinline
+bfm_grow_leaf_1(bfm_tree *root, bfm_tree_node_leaf_1 *node_1,
+				int child_chunk, bfm_value_type val)
+{
+	/* grow node from 1 -> 4 */
+	bfm_tree_node_leaf_4 *newnode_4;
+
+	Assert(node_1->b.b.count == 1);
+
+	newnode_4 = bfm_alloc_leaf_4(root);
+	bfm_node_copy_common(root, &node_1->b.b, &newnode_4->b.b);
+
+	/* copy old & insert new value in the right order */
+	if (child_chunk < node_1->chunk)
+	{
+		newnode_4->chunks[0] = child_chunk;
+		newnode_4->values[0] = val;
+		newnode_4->chunks[1] = node_1->chunk;
+		newnode_4->values[1] = node_1->value;
+	}
+	else
+	{
+		newnode_4->chunks[0] = node_1->chunk;
+		newnode_4->values[0] = node_1->value;
+		newnode_4->chunks[1] = child_chunk;
+		newnode_4->values[1] = val;
+	}
+
+	newnode_4->b.b.count++;
+#ifdef BFM_STATS
+	root->entries++;
+#endif
+
+	bfm_redirect(root, &node_1->b.b, &newnode_4->b.b, newnode_4->b.b.node_chunk);
+	bfm_free_leaf(root, &node_1->b);
+
+	return false;
+}
+
+static bool pg_noinline
+bfm_grow_leaf_4(bfm_tree *root, bfm_tree_node_leaf_4 *node_4,
+				int child_chunk, bfm_value_type val)
+{
+	/* grow node from 4 -> 16 */
+	bfm_tree_node_leaf_16 *newnode_16;
+	int insertpos;
+
+	Assert(node_4->b.b.count == 4);
+
+	newnode_16 = bfm_alloc_leaf_16(root);
+	bfm_node_copy_common(root, &node_4->b.b, &newnode_16->b.b);
+
+	insertpos = search_chunk_array_4_le(node_4->chunks, child_chunk, node_4->b.b.count);
+
+	/* first copy old elements ordering before */
+	memcpy(&newnode_16->chunks[0],
+		   &node_4->chunks[0],
+		   sizeof(node_4->chunks[0]) * insertpos);
+	memcpy(&newnode_16->values[0],
+		   &node_4->values[0],
+		   sizeof(node_4->values[0]) * insertpos);
+
+	/* then the new element */
+	newnode_16->chunks[insertpos] = child_chunk;
+	newnode_16->values[insertpos] = val;
+
+	/* and lastly the old elements after */
+	memcpy(&newnode_16->chunks[insertpos + 1],
+		   &node_4->chunks[insertpos],
+		   (node_4->b.b.count-insertpos) * sizeof(node_4->chunks[0]));
+	memcpy(&newnode_16->values[insertpos + 1],
+		   &node_4->values[insertpos],
+		   (node_4->b.b.count-insertpos) * sizeof(node_4->values[0]));
+
+	newnode_16->b.b.count++;
+#ifdef BFM_STATS
+	root->entries++;
+#endif
+
+	bfm_redirect(root, &node_4->b.b, &newnode_16->b.b, newnode_16->b.b.node_chunk);
+	bfm_free_leaf(root, &node_4->b);
+
+	return false;
+}
+
+static bool pg_noinline
+bfm_grow_leaf_16(bfm_tree *root, bfm_tree_node_leaf_16 *node_16,
+				int child_chunk, bfm_value_type val)
+{
+	/* grow node from 16 -> 32 */
+	bfm_tree_node_leaf_32 *newnode_32;
+	int insertpos;
+
+	Assert(node_16->b.b.count == 16);
+
+	newnode_32 = bfm_alloc_leaf_32(root);
+	bfm_node_copy_common(root, &node_16->b.b, &newnode_32->b.b);
+
+	insertpos = search_chunk_array_16_le(node_16->chunks, child_chunk, node_16->b.b.count);
+
+	/* first copy old elements ordering before */
+	memcpy(&newnode_32->chunks[0],
+		   &node_16->chunks[0],
+		   sizeof(node_16->chunks[0]) * insertpos);
+	memcpy(&newnode_32->values[0],
+		   &node_16->values[0],
+		   sizeof(node_16->values[0]) * insertpos);
+
+	/* then the new element */
+	newnode_32->chunks[insertpos] = child_chunk;
+	newnode_32->values[insertpos] = val;
+
+	/* and lastly the old elements after */
+	memcpy(&newnode_32->chunks[insertpos + 1],
+		   &node_16->chunks[insertpos],
+		   (node_16->b.b.count-insertpos) * sizeof(node_16->chunks[0]));
+	memcpy(&newnode_32->values[insertpos + 1],
+		   &node_16->values[insertpos],
+		   (node_16->b.b.count-insertpos) * sizeof(node_16->values[0]));
+
+	newnode_32->b.b.count++;
+#ifdef BFM_STATS
+	root->entries++;
+#endif
+
+	bfm_redirect(root, &node_16->b.b, &newnode_32->b.b, newnode_32->b.b.node_chunk);
+	bfm_free_leaf(root, &node_16->b);
+
+	return false;
+}
+
+static bool pg_noinline
+bfm_grow_leaf_32(bfm_tree *root, bfm_tree_node_leaf_32 *node_32,
+				 int child_chunk, bfm_value_type val)
+{
+	/* grow node from 32 -> 128 */
+	bfm_tree_node_leaf_128 *newnode_128;
+	uint8 offset;
+
+	newnode_128 = bfm_alloc_leaf_128(root);
+	bfm_node_copy_common(root, &node_32->b.b, &newnode_128->b.b);
+
+	memcpy(newnode_128->values, node_32->values, sizeof(node_32->values));
+
+	for (int i = 0; i < 32; i++)
+		newnode_128->offsets[node_32->chunks[i]] = i;
+
+	offset = newnode_128->b.b.count;
+	newnode_128->offsets[child_chunk] = offset;
+	newnode_128->values[offset] = val;
+
+	newnode_128->b.b.count++;
+#ifdef BFM_STATS
+	root->entries++;
+#endif
+
+	bfm_redirect(root, &node_32->b.b, &newnode_128->b.b, newnode_128->b.b.node_chunk);
+	bfm_free_leaf(root, &node_32->b);
+
+	return false;
+}
+
+static bool pg_noinline
+bfm_grow_leaf_128(bfm_tree *root, bfm_tree_node_leaf_128 *node_128,
+				  int child_chunk, bfm_value_type val)
+{
+	/* grow node from 128 -> max */
+	bfm_tree_node_leaf_max *newnode_max;
+	int i;
+
+	newnode_max = bfm_alloc_leaf_max(root);
+	bfm_node_copy_common(root, &node_128->b.b, &newnode_max->b.b);
+
+	/*
+	 * The bitmask manipulation is a surprisingly large portion of the
+	 * overhead in the naive implementation. Unrolling the bit manipulation
+	 * removes a lot of that overhead.
+	 */
+	i = 0;
+	for (int byte = 0; byte < BFM_MAX_CLASS / BITS_PER_BYTE; byte++)
+	{
+		uint8 bitmap = 0;
+
+		for (int bit = 0; bit < BITS_PER_BYTE; bit++)
+		{
+			uint8 offset = node_128->offsets[i];
+
+			if (offset != BFM_TREE_NODE_128_INVALID)
+			{
+				bitmap |= 1 << bit;
+				newnode_max->values[i] = node_128->values[offset];
+			}
+
+			i++;
+		}
+
+		newnode_max->set[byte] = bitmap;
+	}
+
+	bfm_leaf_max_set(newnode_max, child_chunk);
+	newnode_max->values[child_chunk] = val;
+	newnode_max->b.b.count++;
+#ifdef BFM_STATS
+	root->entries++;
+#endif
+
+	bfm_redirect(root, &node_128->b.b, &newnode_max->b.b, newnode_max->b.b.node_chunk);
+	bfm_free_leaf(root, &node_128->b);
+
+	return false;
+}
+
+/*
+ * Set key to val. Return false if entry doesn't yet exist, true if it did.
+ *
+ * See comments to bfm_insert_inner().
+ */
+static bool pg_noinline
+bfm_set_leaf(bfm_tree *root, bfm_key_type key, bfm_value_type val,
+			 bfm_tree_node_leaf *node, int child_chunk)
+{
+	Assert(node->b.node_shift == 0); /* is leaf node */
+
+	/* tell the compiler it doesn't need a bounds check */
+	if ((bfm_tree_node_kind) node->b.kind > BFM_KIND_MAX)
+		pg_unreachable();
+
+	switch((bfm_tree_node_kind) node->b.kind)
+	{
+		case BFM_KIND_1:
+			{
+				bfm_tree_node_leaf_1 *node_1 =
+					(bfm_tree_node_leaf_1 *) node;
+
+				Assert(node_1->b.b.count <= 1);
+
+				if (node_1->b.b.count == 1 &&
+					node_1->chunk == child_chunk)
+				{
+					node_1->value = val;
+					return true;
+				}
+				else if (likely(node_1->b.b.count < 1))
+				{
+					node_1->chunk = child_chunk;
+					node_1->value = val;
+				}
+				else
+					return bfm_grow_leaf_1(root, node_1, child_chunk, val);
+
+				break;
+			}
+
+		case BFM_KIND_4:
+			{
+				bfm_tree_node_leaf_4 *node_4 =
+					(bfm_tree_node_leaf_4 *) node;
+				int index;
+
+				Assert(node_4->b.b.count <= 4);
+
+				index = search_chunk_array_4_eq(node_4->chunks, child_chunk, node_4->b.b.count);
+				if (index != -1)
+				{
+					node_4->values[index] = val;
+					return true;
+				}
+
+				if (likely(node_4->b.b.count < 4))
+				{
+					int insertpos;
+
+					insertpos = search_chunk_array_4_le(node_4->chunks, child_chunk, node_4->b.b.count);
+
+					for (int i = node_4->b.b.count - 1; i >= insertpos; i--)
+					{
+						/* workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101481 */
+#ifdef __GNUC__
+						__asm__("");
+#endif
+						node_4->values[i + 1] = node_4->values[i];
+						node_4->chunks[i + 1] = node_4->chunks[i];
+					}
+
+					node_4->chunks[insertpos] = child_chunk;
+					node_4->values[insertpos] = val;
+				}
+				else
+					return bfm_grow_leaf_4(root, node_4, child_chunk, val);
+
+				break;
+			}
+
+		case BFM_KIND_16:
+			{
+				bfm_tree_node_leaf_16 *node_16 =
+					(bfm_tree_node_leaf_16 *) node;
+				int index;
+
+				Assert(node_16->b.b.count <= 16);
+
+				index = search_chunk_array_16_eq(node_16->chunks, child_chunk, node_16->b.b.count);
+				if (index != -1)
+				{
+					node_16->values[index] = val;
+					return true;
+				}
+
+				if (likely(node_16->b.b.count < 16))
+				{
+					int insertpos;
+
+					insertpos = search_chunk_array_16_le(node_16->chunks, child_chunk, node_16->b.b.count);
+
+					if (node_16->b.b.count > 16 || insertpos > 15)
+						pg_unreachable();
+
+					for (int i = node_16->b.b.count - 1; i >= insertpos; i--)
+					{
+						/* workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101481 */
+#ifdef __GNUC__
+						__asm__("");
+#endif
+						node_16->values[i + 1] = node_16->values[i];
+						node_16->chunks[i + 1] = node_16->chunks[i];
+					}
+					node_16->chunks[insertpos] = child_chunk;
+					node_16->values[insertpos] = val;
+				}
+				else
+					return bfm_grow_leaf_16(root, node_16, child_chunk, val);
+
+				break;
+			}
+
+		case BFM_KIND_32:
+			{
+				bfm_tree_node_leaf_32 *node_32 =
+					(bfm_tree_node_leaf_32 *) node;
+				int index;
+
+				Assert(node_32->b.b.count <= 32);
+
+				index = search_chunk_array_32_eq(node_32->chunks, child_chunk, node_32->b.b.count);
+				if (index != -1)
+				{
+					node_32->values[index] = val;
+					return true;
+				}
+
+				if (likely(node_32->b.b.count < 32))
+				{
+					int insertpos;
+
+					insertpos = search_chunk_array_32_le(node_32->chunks, child_chunk, node_32->b.b.count);
+
+					if (node_32->b.b.count > 32 || insertpos > 31)
+						pg_unreachable();
+
+					for (int i = node_32->b.b.count - 1; i >= insertpos; i--)
+					{
+						/* workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101481 */
+#ifdef __GNUC__
+						__asm__("");
+#endif
+						node_32->values[i + 1] = node_32->values[i];
+						node_32->chunks[i + 1] = node_32->chunks[i];
+					}
+					node_32->chunks[insertpos] = child_chunk;
+					node_32->values[insertpos] = val;
+				}
+				else
+					return bfm_grow_leaf_32(root, node_32, child_chunk, val);
+
+				break;
+			}
+
+		case BFM_KIND_128:
+			{
+				bfm_tree_node_leaf_128 *node_128 =
+					(bfm_tree_node_leaf_128 *) node;
+				uint8 offset;
+
+				Assert(node_128->b.b.count <= 128);
+
+				if (node_128->offsets[child_chunk] != BFM_TREE_NODE_128_INVALID)
+				{
+					offset = node_128->offsets[child_chunk];
+					node_128->values[offset] = val;
+
+					return true;
+				}
+				else if (likely(node_128->b.b.count < 128))
+				{
+					offset = node_128->b.b.count;
+					node_128->offsets[child_chunk] = offset;
+					node_128->values[offset] = val;
+				}
+				else
+					return bfm_grow_leaf_128(root, node_128, child_chunk, val);
+
+				break;
+			}
+
+		case BFM_KIND_MAX:
+			{
+				bfm_tree_node_leaf_max *node_max =
+					(bfm_tree_node_leaf_max *) node;
+
+				Assert(node_max->b.b.count <= (BFM_MAX_CLASS - 1));
+
+				if (bfm_leaf_max_isset(node_max, child_chunk))
+				{
+					node_max->values[child_chunk] = val;
+					return true;
+				}
+
+				bfm_leaf_max_set(node_max, child_chunk);
+				node_max->values[child_chunk] = val;
+
+				break;
+			}
+	}
+
+	node->b.count++;
+#ifdef BFM_STATS
+	root->entries++;
+#endif
+
+	return false;
+}
+
+static bool pg_noinline
+bfm_set_extend(bfm_tree *root, bfm_key_type key, bfm_value_type val,
+			   bfm_tree_node_inner *cur_inner,
+			   uint32 shift, uint8 chunk)
+{
+	bfm_tree_node_leaf_1 *new_leaf_1;
+
+	while (shift > BFM_FANOUT)
+	{
+		bfm_tree_node_inner_1 *new_inner_1;
+
+		Assert(shift == cur_inner->b.node_shift);
+
+		new_inner_1 = bfm_alloc_inner_1(root);
+		new_inner_1->b.b.node_shift = shift - BFM_FANOUT;
+
+		bfm_insert_inner(root, cur_inner, &new_inner_1->b.b, chunk);
+
+		shift -= BFM_FANOUT;
+		chunk = (key >> shift) & BFM_MASK;
+		cur_inner = &new_inner_1->b;
+	}
+
+	Assert(shift == BFM_FANOUT && cur_inner->b.node_shift == BFM_FANOUT);
+
+	new_leaf_1 = bfm_alloc_leaf_1(root);
+	new_leaf_1->b.b.count = 1;
+	new_leaf_1->b.b.node_shift = 0;
+
+	new_leaf_1->chunk = key & BFM_MASK;
+	new_leaf_1->value = val;
+
+#ifdef BFM_STATS
+	root->entries++;
+#endif
+
+	bfm_insert_inner(root, cur_inner, &new_leaf_1->b.b, chunk);
+
+	return false;
+}
+
+static bool pg_noinline
+bfm_set_empty(bfm_tree *root, bfm_key_type key, bfm_value_type val)
+{
+	uint32 shift;
+
+	Assert(root->rnode == NULL);
+
+	if (key == 0)
+		shift = 0;
+	else
+		shift = (pg_leftmost_one_pos64(key)/BFM_FANOUT)*BFM_FANOUT;
+
+	if (shift == 0)
+	{
+		bfm_tree_node_leaf_1 *nroot = bfm_alloc_leaf_1(root);
+
+		Assert((key & BFM_MASK) == key);
+
+		nroot->b.b.node_shift = 0;
+		nroot->b.b.node_chunk = 0;
+		nroot->b.b.parent = NULL;
+
+		root->maxval = bfm_maxval_shift(0);
+
+		root->rnode = &nroot->b.b;
+
+		return bfm_set_leaf(root, key, val, &nroot->b, key);
+	}
+	else
+	{
+		bfm_tree_node_inner_1 *nroot = bfm_alloc_inner_1(root);
+
+		nroot->b.b.node_shift = shift;
+		nroot->b.b.node_chunk = 0;
+		nroot->b.b.parent = NULL;
+
+		root->maxval = bfm_maxval_shift(shift);
+		root->rnode = &nroot->b.b;
+
+
+		return bfm_set_extend(root, key, val, &nroot->b,
+								 shift, (key >> shift) & BFM_MASK);
+	}
+}
+
+/*
+ * Tree doesn't have sufficient height. Put new tree node(s) on top, move
+ * the old node below it, and then insert.
+ */
+static bool pg_noinline
+bfm_set_shallow(bfm_tree *root, bfm_key_type key, bfm_value_type val)
+{
+	uint32 shift;
+	bfm_tree_node_inner_1 *nroot = NULL;;
+
+	Assert(root->rnode != NULL);
+
+	if (key == 0)
+		shift = 0;
+	else
+		shift = (pg_leftmost_one_pos64(key)/BFM_FANOUT)*BFM_FANOUT;
+
+	Assert(root->rnode->node_shift < shift);
+
+	while (unlikely(root->rnode->node_shift < shift))
+	{
+		nroot = bfm_alloc_inner_1(root);
+
+		nroot->slot = root->rnode;
+		nroot->chunk = 0;
+		nroot->b.b.count = 1;
+		nroot->b.b.parent = NULL;
+		nroot->b.b.node_shift = root->rnode->node_shift + BFM_FANOUT;
+
+		root->rnode->parent = &nroot->b;
+		root->rnode = &nroot->b.b;
+
+		root->maxval = bfm_maxval_shift(nroot->b.b.node_shift);
+	}
+
+	Assert(nroot != NULL);
+
+	return bfm_set_extend(root, key, val, &nroot->b,
+							 shift, (key >> shift) & BFM_MASK);
+}
+
+static void
+bfm_delete_inner(bfm_tree * pg_restrict root, bfm_tree_node_inner * pg_restrict node, bfm_tree_node *pg_restrict child, int child_chunk)
+{
+	switch((bfm_tree_node_kind) node->b.kind)
+	{
+		case BFM_KIND_1:
+			{
+				bfm_tree_node_inner_1 *node_1 =
+					(bfm_tree_node_inner_1 *) node;
+
+				Assert(node_1->slot == child);
+				Assert(node_1->chunk == child_chunk);
+
+				node_1->chunk = 17;
+				node_1->slot = NULL;
+
+				break;
+			}
+
+		case BFM_KIND_4:
+			{
+				bfm_tree_node_inner_4 *node_4 =
+					(bfm_tree_node_inner_4 *) node;
+				int index;
+
+				index = search_chunk_array_4_eq(node_4->chunks, child_chunk, node_4->b.b.count);
+				Assert(index != -1);
+
+				Assert(node_4->slots[index] == child);
+				memmove(&node_4->slots[index],
+						&node_4->slots[index + 1],
+						(node_4->b.b.count-index-1) * sizeof(void*));
+				memmove(&node_4->chunks[index],
+						&node_4->chunks[index + 1],
+						node_4->b.b.count-index-1);
+
+				node_4->chunks[node_4->b.b.count - 1] = BFM_TREE_NODE_INNER_4_INVALID;
+				node_4->slots[node_4->b.b.count - 1] = NULL;
+
+				break;
+			}
+
+		case BFM_KIND_16:
+			{
+				bfm_tree_node_inner_16 *node_16 =
+					(bfm_tree_node_inner_16 *) node;
+				int index;
+
+				index = search_chunk_array_16_eq(node_16->chunks, child_chunk, node_16->b.b.count);
+				Assert(index != -1);
+
+				Assert(node_16->slots[index] == child);
+				memmove(&node_16->slots[index],
+						&node_16->slots[index + 1],
+						(node_16->b.b.count - index - 1) * sizeof(node_16->slots[0]));
+				memmove(&node_16->chunks[index],
+						&node_16->chunks[index + 1],
+						(node_16->b.b.count - index - 1) * sizeof(node_16->chunks[0]));
+
+				node_16->chunks[node_16->b.b.count - 1] = BFM_TREE_NODE_INNER_16_INVALID;
+				node_16->slots[node_16->b.b.count - 1] = NULL;
+
+				break;
+			}
+
+		case BFM_KIND_32:
+			{
+				bfm_tree_node_inner_32 *node_32 =
+					(bfm_tree_node_inner_32 *) node;
+				int index;
+
+				index = search_chunk_array_32_eq(node_32->chunks, child_chunk, node_32->b.b.count);
+				Assert(index != -1);
+
+				Assert(node_32->slots[index] == child);
+				memmove(&node_32->slots[index],
+						&node_32->slots[index + 1],
+						(node_32->b.b.count - index - 1) * sizeof(node_32->slots[0]));
+				memmove(&node_32->chunks[index],
+						&node_32->chunks[index + 1],
+						(node_32->b.b.count - index - 1) * sizeof(node_32->chunks[0]));
+
+				node_32->chunks[node_32->b.b.count - 1] = BFM_TREE_NODE_INNER_32_INVALID;
+				node_32->slots[node_32->b.b.count - 1] = NULL;
+
+				break;
+			}
+
+		case BFM_KIND_128:
+			{
+				bfm_tree_node_inner_128 *node_128 =
+					(bfm_tree_node_inner_128 *) node;
+				uint8 offset;
+
+				offset = node_128->offsets[child_chunk];
+				Assert(offset != BFM_TREE_NODE_128_INVALID);
+				Assert(node_128->slots[offset] == child);
+				node_128->offsets[child_chunk] = BFM_TREE_NODE_128_INVALID;
+				node_128->slots[offset] = NULL;
+				break;
+			}
+
+		case BFM_KIND_MAX:
+			{
+				bfm_tree_node_inner_max *node_max =
+					(bfm_tree_node_inner_max *) node;
+
+				Assert(node_max->slots[child_chunk] == child);
+				node_max->slots[child_chunk] = NULL;
+
+				break;
+			}
+	}
+
+	node->b.count--;
+
+	if (node->b.count == 0)
+	{
+		if (node->b.parent)
+			bfm_delete_inner(root, node->b.parent, &node->b, node->b.node_chunk);
+		else
+			root->rnode = NULL;
+		bfm_free_inner(root, node);
+	}
+}
+
+/*
+ * NB: After this call node cannot be used anymore, it may have been freed or
+ * shrunk.
+ *
+ * FIXME: this should implement shrinking of nodes
+ */
+static void pg_noinline
+bfm_delete_leaf(bfm_tree * pg_restrict root, bfm_tree_node_leaf *pg_restrict node, int child_chunk)
+{
+	/* tell the compiler it doesn't need a bounds check */
+	if ((bfm_tree_node_kind) node->b.kind > BFM_KIND_MAX)
+		pg_unreachable();
+
+	switch((bfm_tree_node_kind) node->b.kind)
+	{
+		case BFM_KIND_1:
+			{
+				bfm_tree_node_leaf_1 *node_1 =
+					(bfm_tree_node_leaf_1 *) node;
+
+				Assert(node_1->chunk == child_chunk);
+
+				node_1->chunk = 17;
+				break;
+			}
+
+		case BFM_KIND_4:
+			{
+				bfm_tree_node_leaf_4 *node_4 =
+					(bfm_tree_node_leaf_4 *) node;
+				int index;
+
+				index = search_chunk_array_4_eq(node_4->chunks, child_chunk, node_4->b.b.count);
+				Assert(index != -1);
+
+				memmove(&node_4->values[index],
+						&node_4->values[index + 1],
+						(node_4->b.b.count - index - 1) * sizeof(node_4->values[0]));
+				memmove(&node_4->chunks[index],
+						&node_4->chunks[index + 1],
+						(node_4->b.b.count - index - 1) * sizeof(node_4->chunks[0]));
+
+				node_4->chunks[node_4->b.b.count - 1] = BFM_TREE_NODE_INNER_4_INVALID;
+				node_4->values[node_4->b.b.count - 1] = 0xFF;
+
+				break;
+			}
+
+		case BFM_KIND_16:
+			{
+				bfm_tree_node_leaf_16 *node_16 =
+					(bfm_tree_node_leaf_16 *) node;
+				int index;
+
+				index = search_chunk_array_16_eq(node_16->chunks, child_chunk, node_16->b.b.count);
+				Assert(index != -1);
+
+				memmove(&node_16->values[index],
+						&node_16->values[index + 1],
+						(node_16->b.b.count - index - 1) * sizeof(node_16->values[0]));
+				memmove(&node_16->chunks[index],
+						&node_16->chunks[index + 1],
+						(node_16->b.b.count - index - 1) * sizeof(node_16->chunks[0]));
+
+				node_16->chunks[node_16->b.b.count - 1] = BFM_TREE_NODE_INNER_16_INVALID;
+				node_16->values[node_16->b.b.count - 1] = 0xFF;
+
+				break;
+			}
+
+		case BFM_KIND_32:
+			{
+				bfm_tree_node_leaf_32 *node_32 =
+					(bfm_tree_node_leaf_32 *) node;
+				int index;
+
+				index = search_chunk_array_32_eq(node_32->chunks, child_chunk, node_32->b.b.count);
+				Assert(index != -1);
+
+				memmove(&node_32->values[index],
+						&node_32->values[index + 1],
+						(node_32->b.b.count - index - 1) * sizeof(node_32->values[0]));
+				memmove(&node_32->chunks[index],
+						&node_32->chunks[index + 1],
+						(node_32->b.b.count - index - 1) * sizeof(node_32->chunks[0]));
+
+				node_32->chunks[node_32->b.b.count - 1] = BFM_TREE_NODE_INNER_32_INVALID;
+				node_32->values[node_32->b.b.count - 1] = 0xFF;
+
+				break;
+			}
+
+		case BFM_KIND_128:
+			{
+				bfm_tree_node_leaf_128 *node_128 =
+					(bfm_tree_node_leaf_128 *) node;
+
+				Assert(node_128->offsets[child_chunk] != BFM_TREE_NODE_128_INVALID);
+				node_128->offsets[child_chunk] = BFM_TREE_NODE_128_INVALID;
+				break;
+			}
+
+		case BFM_KIND_MAX:
+			{
+				bfm_tree_node_leaf_max *node_max =
+					(bfm_tree_node_leaf_max *) node;
+
+				Assert(bfm_leaf_max_isset(node_max, child_chunk));
+				bfm_leaf_max_unset(node_max, child_chunk);
+
+				break;
+			}
+	}
+
+#ifdef BFM_STATS
+	root->entries--;
+#endif
+	node->b.count--;
+
+	if (node->b.count == 0)
+	{
+		if (node->b.parent)
+			bfm_delete_inner(root, node->b.parent, &node->b, node->b.node_chunk);
+		else
+			root->rnode = NULL;
+		bfm_free_leaf(root, node);
+	}
+}
+
+void
+bfm_init(bfm_tree *root)
+{
+	memset(root, 0, sizeof(*root));
+
+#if 1
+	root->context = AllocSetContextCreate(CurrentMemoryContext, "radix bench internal",
+										  ALLOCSET_DEFAULT_SIZES);
+#else
+	root->context = CurrentMemoryContext;
+#endif
+
+#ifdef BFM_USE_SLAB
+	for (int i = 0; i < BFM_KIND_COUNT; i++)
+	{
+		root->inner_slabs[i] = SlabContextCreate(root->context,
+												 inner_class_info[i].name,
+												 Max(pg_nextpower2_32((MAXALIGN(inner_class_info[i].size) + 16) * 32), 1024),
+												 inner_class_info[i].size);
+		root->leaf_slabs[i] = SlabContextCreate(root->context,
+												leaf_class_info[i].name,
+												Max(pg_nextpower2_32((MAXALIGN(leaf_class_info[i].size) + 16) * 32), 1024),
+												leaf_class_info[i].size);
+#if 0
+		elog(LOG, "%s %s size original %zu, mult %zu, round %u",
+			 "leaf",
+			 leaf_class_info[i].name,
+			 leaf_class_info[i].size,
+			 leaf_class_info[i].size * 32,
+			 pg_nextpower2_32(leaf_class_info[i].size * 32));
+#endif
+	}
+#endif
+
+	/*
+	 * XXX: Might be worth to always allocate a root node, to avoid related
+	 * branches?
+	 */
+}
+
+bool
+bfm_lookup(bfm_tree *root, uint64_t key, bfm_value_type *val)
+{
+	bfm_tree_node *node;
+
+	return bfm_walk(root, &node, val, key);
+}
+
+/*
+ * Set key to val. Returns false if entry doesn't yet exist, true if it did.
+ */
+bool
+bfm_set(bfm_tree *root, bfm_key_type key, bfm_value_type val)
+{
+	bfm_tree_node *cur;
+	bfm_tree_node_leaf *target;
+	uint8 chunk;
+	uint32 shift;
+
+	if (unlikely(!root->rnode))
+		return bfm_set_empty(root, key, val);
+	else if (key > root->maxval)
+		return bfm_set_shallow(root, key, val);
+
+	shift = root->rnode->node_shift;
+	chunk = (key >> shift) & BFM_MASK;
+	cur = root->rnode;
+
+	while (shift > 0)
+	{
+		bfm_tree_node_inner *cur_inner;
+		bfm_tree_node *slot;
+
+		Assert(cur->node_shift > 0); /* leaf nodes look different */
+		Assert(cur->node_shift == shift);
+
+		cur_inner = (bfm_tree_node_inner *) cur;
+
+		slot = bfm_find_one_level_inner(cur_inner, chunk);
+
+		if (slot == NULL)
+			return bfm_set_extend(root, key, val, cur_inner, shift, chunk);
+
+		Assert(&slot->parent->b == cur);
+		Assert(slot->node_chunk == chunk);
+
+		cur = slot;
+		shift -= BFM_FANOUT;
+		chunk = (key >> shift) & BFM_MASK;
+	}
+
+	Assert(shift == 0 && cur->node_shift == 0);
+
+	target = (bfm_tree_node_leaf *) cur;
+
+	/*
+	 * FIXME: what is the best API to deal with existing values? Overwrite?
+	 * Overwrite and return old value? Just return true?
+	 */
+	return bfm_set_leaf(root, key, val, target, chunk);
+}
+
+bool
+bfm_delete(bfm_tree *root, uint64 key)
+{
+	bfm_tree_node *node;
+	bfm_value_type val;
+
+	if (!bfm_walk(root, &node, &val, key))
+		return false;
+
+	Assert(node != NULL && node->node_shift == 0);
+
+	/* recurses upwards and deletes parent nodes if necessary */
+	bfm_delete_leaf(root, (bfm_tree_node_leaf *) node, key & BFM_MASK);
+
+	return true;
+}
+
+
+StringInfo
+bfm_stats(bfm_tree *root)
+{
+	StringInfo s;
+#ifdef BFM_STATS
+	size_t total;
+	size_t inner_bytes;
+	size_t leaf_bytes;
+	size_t allocator_bytes;
+#endif
+
+	s = makeStringInfo();
+
+	/* FIXME: Some of the below could be printed even without BFM_STATS */
+#ifdef BFM_STATS
+	appendStringInfo(s, "%zu entries and depth %d\n",
+					 root->entries,
+					 root->rnode ? root->rnode->node_shift / BFM_FANOUT : 0);
+
+	{
+		appendStringInfo(s, "\tinner nodes:");
+		total = 0;
+		inner_bytes = 0;
+		for (int i = 0; i < BFM_KIND_COUNT; i++)
+		{
+			total += root->inner_nodes[i];
+			inner_bytes += inner_class_info[i].size * root->inner_nodes[i];
+			appendStringInfo(s, " %s: %zu, ",
+							 inner_class_info[i].name,
+							 root->inner_nodes[i]);
+		}
+		appendStringInfo(s, " total: %zu, total_bytes: %zu\n", total,
+						 inner_bytes);
+	}
+
+	{
+		appendStringInfo(s, "\tleaf nodes:");
+		total = 0;
+		leaf_bytes = 0;
+		for (int i = 0; i < BFM_KIND_COUNT; i++)
+		{
+			total += root->leaf_nodes[i];
+			leaf_bytes += leaf_class_info[i].size * root->leaf_nodes[i];
+			appendStringInfo(s, " %s: %zu, ",
+							 leaf_class_info[i].name,
+							 root->leaf_nodes[i]);
+		}
+		appendStringInfo(s, " total: %zu, total_bytes: %zu\n", total,
+						 leaf_bytes);
+	}
+
+	allocator_bytes = MemoryContextMemAllocated(root->context, true);
+
+	appendStringInfo(s, "\t%.2f MB excluding allocator overhead, %.2f MiB including\n",
+					 (inner_bytes + leaf_bytes) / (double) (1024 * 1024),
+					 allocator_bytes / (double) (1024 * 1024));
+	appendStringInfo(s, "\t%.2f bytes/entry excluding allocator overhead\n",
+					 root->entries > 0 ?
+					 (inner_bytes + leaf_bytes)/(double)root->entries : 0);
+	appendStringInfo(s, "\t%.2f bytes/entry including allocator overhead\n",
+					 root->entries > 0 ?
+					 allocator_bytes/(double)root->entries : 0);
+#endif
+
+	if (0)
+		bfm_print(root);
+
+	return s;
+}
+
+static void
+bfm_print_node(StringInfo s, int indent, bfm_value_type key, bfm_tree_node *node);
+
+static void
+bfm_print_node_child(StringInfo s, int indent, bfm_value_type key, bfm_tree_node *node,
+					 int i, uint8 chunk, bfm_tree_node *child)
+{
+	appendStringInfoSpaces(s, indent + 2);
+	appendStringInfo(s, "%u: child chunk: 0x%.2X, child: %p\n",
+					 i, chunk, child);
+	key |= ((uint64) chunk) << node->node_shift;
+
+	bfm_print_node(s, indent + 4, key, child);
+}
+
+static void
+bfm_print_value(StringInfo s, int indent, bfm_value_type key, bfm_tree_node *node,
+				int i, uint8 chunk, bfm_value_type value)
+{
+	key |= chunk;
+
+	appendStringInfoSpaces(s, indent + 2);
+	appendStringInfo(s, "%u: chunk: 0x%.2X, key: 0x%llX/%llu, value: 0x%llX/%llu\n",
+					 i,
+					 chunk,
+					 (unsigned long long) key,
+					 (unsigned long long) key,
+					 (unsigned long long) value,
+					 (unsigned long long) value);
+}
+
+static void
+bfm_print_node(StringInfo s, int indent, bfm_value_type key, bfm_tree_node *node)
+{
+	appendStringInfoSpaces(s, indent);
+	appendStringInfo(s, "%s: kind %d, children: %u, shift: %u, node chunk: 0x%.2X, partial key: 0x%llX\n",
+					 node->node_shift != 0 ? "inner" : "leaf",
+					 node->kind,
+					 node->count,
+					 node->node_shift,
+					 node->node_chunk,
+					 (long long unsigned) key);
+
+	if (node->node_shift != 0)
+	{
+		bfm_tree_node_inner *inner = (bfm_tree_node_inner *) node;
+
+		switch((bfm_tree_node_kind) inner->b.kind)
+		{
+			case BFM_KIND_1:
+				{
+					bfm_tree_node_inner_1 *node_1 =
+						(bfm_tree_node_inner_1 *) node;
+
+					if (node_1->b.b.count > 0)
+						bfm_print_node_child(s, indent, key, node,
+											 0, node_1->chunk, node_1->slot);
+
+					break;
+				}
+
+			case BFM_KIND_4:
+				{
+					bfm_tree_node_inner_4 *node_4 =
+						(bfm_tree_node_inner_4 *) node;
+
+					for (int i = 0; i < node_4->b.b.count; i++)
+					{
+						bfm_print_node_child(s, indent, key, node,
+											 i, node_4->chunks[i], node_4->slots[i]);
+					}
+
+					break;
+				}
+
+			case BFM_KIND_16:
+				{
+					bfm_tree_node_inner_16 *node_16 =
+						(bfm_tree_node_inner_16 *) node;
+
+					for (int i = 0; i < node_16->b.b.count; i++)
+					{
+						bfm_print_node_child(s, indent, key, node,
+											 i, node_16->chunks[i], node_16->slots[i]);
+					}
+
+					break;
+				}
+
+			case BFM_KIND_32:
+				{
+					bfm_tree_node_inner_32 *node_32 =
+						(bfm_tree_node_inner_32 *) node;
+
+					for (int i = 0; i < node_32->b.b.count; i++)
+					{
+						bfm_print_node_child(s, indent, key, node,
+											 i, node_32->chunks[i], node_32->slots[i]);
+					}
+
+					break;
+				}
+
+			case BFM_KIND_128:
+				{
+					bfm_tree_node_inner_128 *node_128 =
+						(bfm_tree_node_inner_128 *) node;
+
+					for (int i = 0; i < BFM_MAX_CLASS; i++)
+					{
+						uint8 offset = node_128->offsets[i];
+
+						if (offset == BFM_TREE_NODE_128_INVALID)
+							continue;
+
+						bfm_print_node_child(s, indent, key, node,
+											 offset, i, node_128->slots[offset]);
+					}
+
+					break;
+				}
+
+			case BFM_KIND_MAX:
+				{
+					bfm_tree_node_inner_max *node_max =
+						(bfm_tree_node_inner_max *) node;
+
+					for (int i = 0; i < BFM_MAX_CLASS; i++)
+					{
+						if (node_max->slots[i] == NULL)
+							continue;
+
+						bfm_print_node_child(s, indent, key, node,
+											 i, i, node_max->slots[i]);
+					}
+
+					break;
+				}
+		}
+	}
+	else
+	{
+		bfm_tree_node_leaf *leaf = (bfm_tree_node_leaf *) node;
+
+		switch((bfm_tree_node_kind) leaf->b.kind)
+		{
+			case BFM_KIND_1:
+				{
+					bfm_tree_node_leaf_1 *node_1 =
+						(bfm_tree_node_leaf_1 *) node;
+
+					if (node_1->b.b.count > 0)
+						bfm_print_value(s, indent, key, node,
+										0, node_1->chunk, node_1->value);
+
+					break;
+				}
+
+			case BFM_KIND_4:
+				{
+					bfm_tree_node_leaf_4 *node_4 =
+						(bfm_tree_node_leaf_4 *) node;
+
+					for (int i = 0; i < node_4->b.b.count; i++)
+					{
+						bfm_print_value(s, indent, key, node,
+										i, node_4->chunks[i], node_4->values[i]);
+					}
+
+					break;
+				}
+
+			case BFM_KIND_16:
+				{
+					bfm_tree_node_leaf_16 *node_16 =
+						(bfm_tree_node_leaf_16 *) node;
+
+					for (int i = 0; i < node_16->b.b.count; i++)
+					{
+						bfm_print_value(s, indent, key, node,
+										i, node_16->chunks[i], node_16->values[i]);
+					}
+
+					break;
+				}
+
+			case BFM_KIND_32:
+				{
+					bfm_tree_node_leaf_32 *node_32 =
+						(bfm_tree_node_leaf_32 *) node;
+
+					for (int i = 0; i < node_32->b.b.count; i++)
+					{
+						bfm_print_value(s, indent, key, node,
+										i, node_32->chunks[i], node_32->values[i]);
+					}
+
+					break;
+				}
+
+			case BFM_KIND_128:
+				{
+					bfm_tree_node_leaf_128 *node_128 =
+						(bfm_tree_node_leaf_128 *) node;
+
+					for (int i = 0; i < BFM_MAX_CLASS; i++)
+					{
+						uint8 offset = node_128->offsets[i];
+
+						if (offset == BFM_TREE_NODE_128_INVALID)
+							continue;
+
+						bfm_print_value(s, indent, key, node,
+										offset, i, node_128->values[offset]);
+					}
+
+					break;
+				}
+
+			case BFM_KIND_MAX:
+				{
+					bfm_tree_node_leaf_max *node_max =
+						(bfm_tree_node_leaf_max *) node;
+
+					for (int i = 0; i < BFM_MAX_CLASS; i++)
+					{
+						if (!bfm_leaf_max_isset(node_max, i))
+							continue;
+
+						bfm_print_value(s, indent, key, node,
+										i, i, node_max->values[i]);
+					}
+
+					break;
+				}
+		}
+	}
+}
+
+void
+bfm_print(bfm_tree *root)
+{
+	StringInfoData s;
+
+	initStringInfo(&s);
+
+	if (root->rnode)
+		bfm_print_node(&s, 0 /* indent */, 0 /* key */, root->rnode);
+
+	elog(LOG, "radix debug print:\n%s", s.data);
+	pfree(s.data);
+}
+
+
+#define EXPECT_TRUE(expr)	\
+	do { \
+		if (!(expr)) \
+			elog(ERROR, \
+				 "%s was unexpectedly false in file \"%s\" line %u", \
+				 #expr, __FILE__, __LINE__); \
+	} while (0)
+
+#define EXPECT_FALSE(expr)	\
+	do { \
+		if (expr) \
+			elog(ERROR, \
+				 "%s was unexpectedly true in file \"%s\" line %u", \
+				 #expr, __FILE__, __LINE__); \
+	} while (0)
+
+#define EXPECT_EQ_U32(result_expr, expected_expr)	\
+	do { \
+		uint32		result = (result_expr); \
+		uint32		expected = (expected_expr); \
+		if (result != expected) \
+			elog(ERROR, \
+				 "%s yielded %u, expected %s in file \"%s\" line %u", \
+				 #result_expr, result, #expected_expr, __FILE__, __LINE__); \
+	} while (0)
+
+static void
+bfm_test_insert_leaf_grow(bfm_tree *root)
+{
+	bfm_value_type val;
+
+	/* 0->1 */
+	EXPECT_FALSE(bfm_set(root, 0, 0+3));
+	EXPECT_TRUE(bfm_lookup(root, 0, &val));
+	EXPECT_EQ_U32(val, 0+3);
+
+	/* node 1->4 */
+	for (int i = 1; i < 4; i++)
+	{
+		EXPECT_FALSE(bfm_set(root, i, i+3));
+	}
+	for (int i = 0; i < 4; i++)
+	{
+		EXPECT_TRUE(bfm_lookup(root, i, &val));
+		EXPECT_EQ_U32(val, i+3);
+	}
+
+	/* node 4->16, reverse order, for giggles */
+	for (int i = 15; i >= 4; i--)
+	{
+		EXPECT_FALSE(bfm_set(root, i, i+3));
+	}
+	for (int i = 0; i < 16; i++)
+	{
+		EXPECT_TRUE(bfm_lookup(root, i, &val));
+		EXPECT_EQ_U32(val, i+3);
+	}
+
+	/* node 16->32 */
+	for (int i = 16; i < 32; i++)
+	{
+		EXPECT_FALSE(bfm_set(root, i, i+3));
+	}
+	for (int i = 0; i < 32; i++)
+	{
+		EXPECT_TRUE(bfm_lookup(root, i, &val));
+		EXPECT_EQ_U32(val, i+3);
+	}
+
+	/* node 32->128 */
+	for (int i = 32; i < 128; i++)
+	{
+		EXPECT_FALSE(bfm_set(root, i, i+3));
+	}
+	for (int i = 0; i < 128; i++)
+	{
+		EXPECT_TRUE(bfm_lookup(root, i, &val));
+		EXPECT_EQ_U32(val, i+3);
+	}
+
+	/* node 128->max */
+	for (int i = 128; i < BFM_MAX_CLASS; i++)
+	{
+		EXPECT_FALSE(bfm_set(root, i, i+3));
+	}
+	for (int i = 0; i < BFM_MAX_CLASS; i++)
+	{
+		EXPECT_TRUE(bfm_lookup(root, i, &val));
+		EXPECT_EQ_U32(val, i+3);
+	}
+
+}
+
+static void
+bfm_test_insert_inner_grow(void)
+{
+	bfm_tree root;
+	bfm_value_type val;
+	bfm_value_type cur;
+
+	bfm_init(&root);
+
+	cur = 1025;
+
+	while (!root.rnode ||
+		   root.rnode->node_shift == 0 ||
+		   root.rnode->count < 4)
+	{
+		EXPECT_FALSE(bfm_set(&root, cur, -cur));
+		cur += BFM_MAX_CLASS;
+	}
+
+	for (int i = 1025; i < cur; i += BFM_MAX_CLASS)
+	{
+		EXPECT_TRUE(bfm_lookup(&root, i, &val));
+		EXPECT_EQ_U32(val, -i);
+	}
+
+	while (root.rnode->count < 32)
+	{
+		EXPECT_FALSE(bfm_set(&root, cur, -cur));
+		cur += BFM_MAX_CLASS;
+	}
+
+	for (int i = 1025; i < cur; i += BFM_MAX_CLASS)
+	{
+		EXPECT_TRUE(bfm_lookup(&root, i, &val));
+		EXPECT_EQ_U32(val, -i);
+	}
+
+	while (root.rnode->count < 128)
+	{
+		EXPECT_FALSE(bfm_set(&root, cur, -cur));
+		cur += BFM_MAX_CLASS;
+	}
+
+	for (int i = 1025; i < cur; i += BFM_MAX_CLASS)
+	{
+		EXPECT_TRUE(bfm_lookup(&root, i, &val));
+		EXPECT_EQ_U32(val, -i);
+	}
+
+	while (root.rnode->count < BFM_MAX_CLASS)
+	{
+		EXPECT_FALSE(bfm_set(&root, cur, -cur));
+		cur += BFM_MAX_CLASS;
+	}
+
+	for (int i = 1025; i < cur; i += BFM_MAX_CLASS)
+	{
+		EXPECT_TRUE(bfm_lookup(&root, i, &val));
+		EXPECT_EQ_U32(val, -i);
+	}
+
+	while (root.rnode->count == BFM_MAX_CLASS)
+	{
+		EXPECT_FALSE(bfm_set(&root, cur, -cur));
+		cur += BFM_MAX_CLASS;
+	}
+
+	for (int i = 1025; i < cur; i += BFM_MAX_CLASS)
+	{
+		EXPECT_TRUE(bfm_lookup(&root, i, &val));
+		EXPECT_EQ_U32(val, -i);
+	}
+
+}
+
+static void
+bfm_test_delete_lots(void)
+{
+	bfm_tree root;
+	bfm_value_type val;
+	bfm_key_type insertval;
+
+	bfm_init(&root);
+
+	insertval = 0;
+	while (!root.rnode ||
+		   root.rnode->node_shift != (BFM_FANOUT * 2))
+	{
+		EXPECT_FALSE(bfm_set(&root, insertval, -insertval));
+		insertval++;
+	}
+
+	for (bfm_key_type i = 0; i < insertval; i++)
+	{
+		EXPECT_TRUE(bfm_lookup(&root, i, &val));
+		EXPECT_EQ_U32(val, -i);
+		EXPECT_TRUE(bfm_delete(&root, i));
+		EXPECT_FALSE(bfm_lookup(&root, i, &val));
+	}
+
+	EXPECT_TRUE(root.rnode == NULL);
+}
+
+#include "portability/instr_time.h"
+
+static void
+bfm_test_insert_bulk(int count)
+{
+	bfm_tree root;
+	bfm_value_type val;
+	instr_time start, end, diff;
+	int misses;
+	int mult = 1;
+
+	bfm_init(&root);
+
+	INSTR_TIME_SET_CURRENT(start);
+
+	for (int i = 0; i < count; i++)
+		bfm_set(&root, i*mult, -i);
+
+	INSTR_TIME_SET_CURRENT(end);
+	INSTR_TIME_SET_ZERO(diff);
+	INSTR_TIME_ACCUM_DIFF(diff, end, start);
+
+	elog(NOTICE, "%d ordered insertions in %f seconds, %d/sec",
+		 count,
+		 INSTR_TIME_GET_DOUBLE(diff),
+		 (int)(count/INSTR_TIME_GET_DOUBLE(diff)));
+
+	INSTR_TIME_SET_CURRENT(start);
+
+	misses = 0;
+	for (int i = 0; i < count; i++)
+	{
+		if (unlikely(!bfm_lookup(&root, i*mult, &val)))
+			misses++;
+	}
+	if (misses > 0)
+		elog(ERROR, "not present for lookup: %d entries", misses);
+
+	INSTR_TIME_SET_CURRENT(end);
+	INSTR_TIME_SET_ZERO(diff);
+	INSTR_TIME_ACCUM_DIFF(diff, end, start);
+
+	elog(NOTICE, "%d ordered lookups in %f seconds, %d/sec",
+		 count,
+		 INSTR_TIME_GET_DOUBLE(diff),
+		 (int)(count/INSTR_TIME_GET_DOUBLE(diff)));
+
+	elog(LOG, "stats after lookup are: %s",
+		 bfm_stats(&root)->data);
+
+	INSTR_TIME_SET_CURRENT(start);
+
+	misses = 0;
+	for (int i = 0; i < count; i++)
+	{
+		if (unlikely(!bfm_delete(&root, i*mult)))
+			misses++;
+	}
+	if (misses > 0)
+		elog(ERROR, "not present for deletion: %d entries", misses);
+
+	INSTR_TIME_SET_CURRENT(end);
+	INSTR_TIME_SET_ZERO(diff);
+	INSTR_TIME_ACCUM_DIFF(diff, end, start);
+
+	elog(NOTICE, "%d ordered deletions in %f seconds, %d/sec",
+		 count,
+		 INSTR_TIME_GET_DOUBLE(diff),
+		 (int)(count/INSTR_TIME_GET_DOUBLE(diff)));
+
+	elog(LOG, "stats after deletion are: %s",
+		 bfm_stats(&root)->data);
+}
+
+void
+bfm_tests(void)
+{
+	bfm_tree root;
+	bfm_value_type val;
+
+	/* initialize a tree starting with a large value */
+	bfm_init(&root);
+	EXPECT_FALSE(bfm_set(&root, 1024, 1));
+	EXPECT_TRUE(bfm_lookup(&root, 1024, &val));
+	EXPECT_EQ_U32(val, 1);
+	/* there should only be the key we inserted */
+#ifdef BFM_STATS
+	EXPECT_EQ_U32(root.leaf_nodes[0], 1);
+#endif
+
+	/* check that we can subsequently insert a small value */
+	EXPECT_FALSE(bfm_set(&root, 1, 2));
+	EXPECT_TRUE(bfm_lookup(&root, 1, &val));
+	EXPECT_EQ_U32(val, 2);
+	EXPECT_TRUE(bfm_lookup(&root, 1024, &val));
+	EXPECT_EQ_U32(val, 1);
+
+	/* check that a 0 key and 0 value are correctly recognized */
+	bfm_init(&root);
+	EXPECT_FALSE(bfm_lookup(&root, 0, &val));
+	EXPECT_FALSE(bfm_set(&root, 0, 17));
+	EXPECT_TRUE(bfm_lookup(&root, 0, &val));
+	EXPECT_EQ_U32(val, 17);
+
+	EXPECT_FALSE(bfm_lookup(&root, 2, &val));
+	EXPECT_FALSE(bfm_set(&root, 2, 0));
+	EXPECT_TRUE(bfm_lookup(&root, 2, &val));
+	EXPECT_EQ_U32(val, 0);
+
+	/* check that repeated insertion of the same key updates value */
+	bfm_init(&root);
+	EXPECT_FALSE(bfm_set(&root, 9, 12));
+	EXPECT_TRUE(bfm_lookup(&root, 9, &val));
+	EXPECT_EQ_U32(val, 12);
+	EXPECT_TRUE(bfm_set(&root, 9, 13));
+	EXPECT_TRUE(bfm_lookup(&root, 9, &val));
+	EXPECT_EQ_U32(val, 13);
+
+
+	/* initialize a tree starting with a leaf value */
+	bfm_init(&root);
+	EXPECT_FALSE(bfm_set(&root, 3, 1));
+	EXPECT_TRUE(bfm_lookup(&root, 3, &val));
+	EXPECT_EQ_U32(val, 1);
+	/* there should only be the key we inserted */
+#ifdef BFM_STATS
+	EXPECT_EQ_U32(root.leaf_nodes[0], 1);
+#endif
+	/* and no inner ones */
+#ifdef BFM_STATS
+	EXPECT_EQ_U32(root.inner_nodes[0], 0);
+#endif
+
+	EXPECT_FALSE(bfm_set(&root, 1717, 17));
+	EXPECT_TRUE(bfm_lookup(&root, 1717, &val));
+	EXPECT_EQ_U32(val, 17);
+
+	/* check that a root leaf node grows correctly */
+	bfm_init(&root);
+	bfm_test_insert_leaf_grow(&root);
+
+	/* check that a non-root leaf node grows correctly */
+	bfm_init(&root);
+	EXPECT_FALSE(bfm_set(&root, 1024, 1024));
+	bfm_test_insert_leaf_grow(&root);
+
+	/* check that an inner node grows correctly */
+	bfm_test_insert_inner_grow();
+
+
+	bfm_init(&root);
+	EXPECT_FALSE(bfm_set(&root, 1, 1));
+	EXPECT_TRUE(bfm_lookup(&root, 1, &val));
+
+	/* deletion from leaf node at root */
+	EXPECT_TRUE(bfm_delete(&root, 1));
+	EXPECT_FALSE(bfm_lookup(&root, 1, &val));
+
+	/* repeated deletion fails */
+	EXPECT_FALSE(bfm_delete(&root, 1));
+	EXPECT_TRUE(root.rnode == NULL);
+
+	/* one deletion doesn't disturb other values in leaf */
+	EXPECT_FALSE(bfm_set(&root, 1, 1));
+	EXPECT_FALSE(bfm_set(&root, 2, 2));
+	EXPECT_TRUE(bfm_delete(&root, 1));
+	EXPECT_FALSE(bfm_lookup(&root, 1, &val));
+	EXPECT_TRUE(bfm_lookup(&root, 2, &val));
+	EXPECT_EQ_U32(val, 2);
+
+	EXPECT_TRUE(bfm_delete(&root, 2));
+	EXPECT_FALSE(bfm_lookup(&root, 2, &val));
+	EXPECT_TRUE(root.rnode == NULL);
+
+	/* deletion from a leaf node succeeds */
+	EXPECT_FALSE(bfm_set(&root, 0xFFFF02, 0xFFFF02));
+	EXPECT_FALSE(bfm_set(&root, 1, 1));
+	EXPECT_FALSE(bfm_set(&root, 2, 2));
+
+	EXPECT_TRUE(bfm_delete(&root, 1));
+	EXPECT_TRUE(bfm_lookup(&root, 0xFFFF02, &val));
+	EXPECT_FALSE(bfm_lookup(&root, 1, &val));
+	EXPECT_TRUE(bfm_lookup(&root, 2, &val));
+
+	EXPECT_TRUE(bfm_delete(&root, 2));
+	EXPECT_TRUE(bfm_lookup(&root, 0xFFFF02, &val));
+	EXPECT_FALSE(bfm_lookup(&root, 1, &val));
+
+	EXPECT_TRUE(bfm_delete(&root, 0xFFFF02));
+	EXPECT_FALSE(bfm_delete(&root, 0xFFFF02));
+	EXPECT_FALSE(bfm_lookup(&root, 0xFFFF02, &val));
+	EXPECT_TRUE(root.rnode == NULL);
+
+	/* check that repeatedly inserting and deleting the same value works */
+	bfm_init(&root);
+	EXPECT_FALSE(bfm_set(&root, 0x10000, -0x10000));
+	EXPECT_FALSE(bfm_set(&root, 0, 0));
+	EXPECT_TRUE(bfm_lookup(&root, 0, &val));
+	EXPECT_TRUE(bfm_delete(&root, 0));
+	EXPECT_FALSE(bfm_lookup(&root, 0, &val));
+	EXPECT_FALSE(bfm_set(&root, 0, 0));
+	EXPECT_TRUE(bfm_set(&root, 0, 0));
+	EXPECT_TRUE(bfm_lookup(&root, 0, &val));
+
+	bfm_test_delete_lots();
+
+	if (0)
+	{
+		int cnt = 300;
+
+		bfm_init(&root);
+		MemoryContextStats(root.context);
+		for (int i = 0; i < cnt; i++)
+			EXPECT_FALSE(bfm_set(&root, i, i));
+		MemoryContextStats(root.context);
+		for (int i = 0; i < cnt; i++)
+			EXPECT_TRUE(bfm_delete(&root, i));
+		MemoryContextStats(root.context);
+	}
+
+	if (1)
+	{
+		//bfm_test_insert_bulk(        100 * 1000);
+		//bfm_test_insert_bulk(       1000 * 1000);
+#ifdef USE_ASSERT_CHECKING
+		bfm_test_insert_bulk(   1 * 1000 * 1000);
+#endif
+		//bfm_test_insert_bulk(  10 * 1000 * 1000);
+#ifndef USE_ASSERT_CHECKING
+		bfm_test_insert_bulk( 100 * 1000 * 1000);
+#endif
+		//bfm_test_insert_bulk(1000 * 1000 * 1000);
+	}
+
+	//bfm_print(&root);
+}
diff --git a/bdbench/radix.h b/bdbench/radix.h
new file mode 100644
index 0000000..c908aa5
--- /dev/null
+++ b/bdbench/radix.h
@@ -0,0 +1,76 @@
+/*-------------------------------------------------------------------------
+ *
+ * radix.h
+ *	  radix tree, yay.
+ *
+ *
+ * Portions Copyright (c) 2014-2021, PostgreSQL Global Development Group
+ *
+ * src/include/storage/radix.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef RADIX_H
+#define RADIX_H
+
+typedef uint64 bfm_key_type;
+typedef uint64 bfm_value_type;
+//typedef uint32 bfm_value_type;
+//typedef char bfm_value_type;
+
+/* How many different size classes are there */
+#define BFM_KIND_COUNT 6
+
+typedef enum bfm_tree_node_kind
+{
+	BFM_KIND_1,
+	BFM_KIND_4,
+	BFM_KIND_16,
+	BFM_KIND_32,
+	BFM_KIND_128,
+	BFM_KIND_MAX
+} bfm_tree_node_kind;
+
+struct MemoryContextData;
+struct bfm_tree_node;
+
+/* NB: makes things a bit slower */
+#define BFM_STATS
+
+#define BFM_USE_SLAB
+//#define BFM_USE_OS
+
+/*
+ * A radix tree with nodes that are sized based on occupancy.
+ */
+typedef struct bfm_tree
+{
+	struct bfm_tree_node *rnode;
+	uint64 maxval;
+
+	struct MemoryContextData *context;
+#ifdef BFM_USE_SLAB
+	struct MemoryContextData *inner_slabs[BFM_KIND_COUNT];
+	struct MemoryContextData *leaf_slabs[BFM_KIND_COUNT];
+#endif
+
+#ifdef BFM_STATS
+	/* stats */
+	size_t entries;
+	size_t inner_nodes[BFM_KIND_COUNT];
+	size_t leaf_nodes[BFM_KIND_COUNT];
+#endif
+} bfm_tree;
+
+extern void bfm_init(bfm_tree *root);
+extern bool bfm_lookup(bfm_tree *root, bfm_key_type key, bfm_value_type *val);
+extern bool bfm_set(bfm_tree *root, bfm_key_type key, bfm_value_type val);
+extern bool bfm_delete(bfm_tree *root, bfm_key_type key);
+
+extern struct StringInfoData* bfm_stats(bfm_tree *root);
+extern void bfm_print(bfm_tree *root);
+
+extern void bfm_tests(void);
+
+#endif
-- 
2.32.0.rc2

From 131074dcbe72ff8af00cb879c7c92747dc100e69 Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Mon, 19 Jul 2021 16:05:44 -0700
Subject: [PATCH 3/3] Add radix tree benchmark integration.

---
 bdbench/Makefile         |   2 +-
 bdbench/bdbench--1.0.sql |   4 +
 bdbench/bdbench.c        | 181 ++++++++++++++++++++++++++++++++++++++-
 bdbench/bench.sql        |   6 +-
 4 files changed, 189 insertions(+), 4 deletions(-)

diff --git a/bdbench/Makefile b/bdbench/Makefile
index 6d52940..723132a 100644
--- a/bdbench/Makefile
+++ b/bdbench/Makefile
@@ -2,7 +2,7 @@
 
 MODULE_big = bdbench
 DATA = bdbench--1.0.sql
-OBJS = bdbench.o vtbm.o rtbm.o
+OBJS = bdbench.o vtbm.o rtbm.o radix.o
 
 EXTENSION = bdbench
 REGRESS= bdbench
diff --git a/bdbench/bdbench--1.0.sql b/bdbench/bdbench--1.0.sql
index 933cf71..bd59293 100644
--- a/bdbench/bdbench--1.0.sql
+++ b/bdbench/bdbench--1.0.sql
@@ -109,3 +109,7 @@ RETURNS text
 AS 'MODULE_PATHNAME'
 LANGUAGE C STRICT VOLATILE;
 
+CREATE FUNCTION radix_run_tests()
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT VOLATILE;
diff --git a/bdbench/bdbench.c b/bdbench/bdbench.c
index 1df5c53..85d8eaa 100644
--- a/bdbench/bdbench.c
+++ b/bdbench/bdbench.c
@@ -19,6 +19,7 @@
 
 #include "vtbm.h"
 #include "rtbm.h"
+#include "radix.h"
 
 //#define DEBUG_DUMP_MATCHED 1
 
@@ -89,6 +90,7 @@ PG_FUNCTION_INFO_V1(attach_dead_tuples);
 PG_FUNCTION_INFO_V1(bench);
 PG_FUNCTION_INFO_V1(test_generate_tid);
 PG_FUNCTION_INFO_V1(rtbm_test);
+PG_FUNCTION_INFO_V1(radix_run_tests);
 PG_FUNCTION_INFO_V1(prepare);
 
 /*
@@ -137,6 +139,16 @@ static void rtbm_attach(LVTestType *lvtt, uint64 nitems, BlockNumber minblk,
 static bool rtbm_reaped(LVTestType *lvtt, ItemPointer itemptr);
 static Size rtbm_mem_usage(LVTestType *lvtt);
 
+/* radix */
+static void radix_init(LVTestType *lvtt, uint64 nitems);
+static void radix_fini(LVTestType *lvtt);
+static void radix_attach(LVTestType *lvtt, uint64 nitems, BlockNumber minblk,
+						 BlockNumber maxblk, OffsetNumber maxoff);
+static bool radix_reaped(LVTestType *lvtt, ItemPointer itemptr);
+static Size radix_mem_usage(LVTestType *lvtt);
+static void radix_load(void *tbm, ItemPointerData *itemptrs, int nitems);
+
+
 /* Misc functions */
 static void generate_index_tuples(uint64 nitems, BlockNumber minblk,
 								  BlockNumber maxblk, OffsetNumber maxoff);
@@ -156,12 +168,13 @@ static void load_rtbm(RTbm *vtbm, ItemPointerData *itemptrs, int nitems);
 		.dtinfo = {0}, \
 		.name = #n, \
 		.init_fn = n##_init, \
+		.fini_fn = n##_fini, \
 		.attach_fn = n##_attach, \
 		.reaped_fn = n##_reaped, \
 		.mem_usage_fn = n##_mem_usage, \
 			}
 
-#define TEST_SUBJECT_TYPES 5
+#define TEST_SUBJECT_TYPES 6
 static LVTestType LVTestSubjects[TEST_SUBJECT_TYPES] =
 {
 	DECLARE_SUBJECT(array),
@@ -169,6 +182,7 @@ static LVTestType LVTestSubjects[TEST_SUBJECT_TYPES] =
 	DECLARE_SUBJECT(intset),
 	DECLARE_SUBJECT(vtbm),
 	DECLARE_SUBJECT(rtbm),
+	DECLARE_SUBJECT(radix)
 };
 
 static bool
@@ -192,6 +206,31 @@ update_info(DeadTupleInfo *info, uint64 nitems, BlockNumber minblk,
 	info->maxoff = maxoff;
 }
 
+
+/* from geqo's init_tour(), geqo_randint() */
+static int
+shuffle_randrange(unsigned short xseed[3], int lower, int upper)
+{
+	return (int) floor( pg_erand48(xseed) * ((upper-lower)+0.999999)) + lower;
+}
+
+/* Naive Fisher-Yates implementation*/
+static void
+shuffle_itemptrs(uint64 nitems, ItemPointer itemptrs)
+{
+	/* reproducability */
+	unsigned short xseed[3] = {0};
+
+	for (int i = 0; i < nitems - 1; i++)
+	{
+		int j = shuffle_randrange(xseed, i, nitems - 1);
+		ItemPointerData t = itemptrs[j];
+
+		itemptrs[j] = itemptrs[i];
+		itemptrs[i] = t;
+	}
+}
+
 static void
 generate_index_tuples(uint64 nitems, BlockNumber minblk, BlockNumber maxblk,
 					 OffsetNumber maxoff)
@@ -586,6 +625,138 @@ load_rtbm(RTbm *rtbm, ItemPointerData *itemptrs, int nitems)
 	rtbm_add_tuples(rtbm, curblkno, offs, noffs);
 }
 
+/* ---------- radix ---------- */
+static void
+radix_init(LVTestType *lvtt, uint64 nitems)
+{
+	MemoryContext old_ctx;
+
+	lvtt->mcxt = AllocSetContextCreate(TopMemoryContext,
+									   "radix bench",
+									   ALLOCSET_DEFAULT_SIZES);
+	old_ctx = MemoryContextSwitchTo(lvtt->mcxt);
+	lvtt->private = palloc(sizeof(bfm_tree));
+	bfm_init(lvtt->private);
+	MemoryContextSwitchTo(old_ctx);
+}
+static void
+radix_fini(LVTestType *lvtt)
+{
+#if 0
+	if (lvtt->private)
+		bfm_free((RTbm *) lvtt->private);
+#endif
+}
+
+/* log(sizeof(bfm_value_type) * BITS_PER_BYTE, 2) = log(64, 2) = 6 */
+#define ENCODE_BITS 6
+
+static uint64
+radix_to_key_off(ItemPointer tid, uint32 *off)
+{
+	uint64 upper;
+
+	uint32 shift = pg_ceil_log2_32(MaxHeapTuplesPerPage);
+	int64 tid_i;
+
+	Assert(ItemPointerGetOffsetNumber(tid) < MaxHeapTuplesPerPage);
+
+	tid_i = ItemPointerGetOffsetNumber(tid);
+	tid_i |= ItemPointerGetBlockNumber(tid) << shift;
+
+	*off = tid_i & ((1 << ENCODE_BITS)-1);
+	upper = tid_i >> ENCODE_BITS;
+	Assert(*off < (sizeof(bfm_value_type) * BITS_PER_BYTE));
+
+	Assert(*off < 64);
+
+	return upper;
+}
+
+static void
+radix_attach(LVTestType *lvtt, uint64 nitems, BlockNumber minblk,
+			   BlockNumber maxblk, OffsetNumber maxoff)
+{
+	MemoryContext oldcontext = MemoryContextSwitchTo(lvtt->mcxt);
+
+	radix_load(lvtt->private,
+			   DeadTuples_orig->itemptrs,
+			   DeadTuples_orig->dtinfo.nitems);
+
+	MemoryContextSwitchTo(oldcontext);
+}
+
+
+static bool
+radix_reaped(LVTestType *lvtt, ItemPointer itemptr)
+{
+	uint64 key;
+	uint32 off;
+	bfm_value_type val;
+
+	key = radix_to_key_off(itemptr, &off);
+
+	if (!bfm_lookup((bfm_tree *) lvtt->private, key, &val))
+		return false;
+
+	return val & ((bfm_value_type)1 << off);
+}
+
+static uint64
+radix_mem_usage(LVTestType *lvtt)
+{
+	bfm_tree *root = lvtt->private;
+	size_t mem = MemoryContextMemAllocated(lvtt->mcxt, true);
+	StringInfo s;
+
+	s = bfm_stats(root);
+
+	ereport(NOTICE,
+			errmsg("radix tree of %.2f MB, %s",
+				   (double) mem / (1024 * 1024),
+				   s->data),
+			errhidestmt(true),
+			errhidecontext(true));
+
+	pfree(s->data);
+	pfree(s);
+
+	return mem;
+}
+
+static void
+radix_load(void *tbm, ItemPointerData *itemptrs, int nitems)
+{
+	bfm_tree *root = (bfm_tree *) tbm;
+	uint64 last_key = PG_UINT64_MAX;
+	uint64 val = 0;
+
+	for (int i = 0; i < nitems; i++)
+	{
+		ItemPointer tid = &(itemptrs[i]);
+		uint64 key;
+		uint32 off;
+
+		key = radix_to_key_off(tid, &off);
+
+		if (last_key != PG_UINT64_MAX &&
+			last_key != key)
+		{
+			bfm_set(root, last_key, val);
+			val = 0;
+		}
+
+		last_key = key;
+		val |= (uint64)1 << off;
+	}
+
+	if (last_key != PG_UINT64_MAX)
+	{
+		bfm_set(root, last_key, val);
+	}
+}
+
+
 static void
 attach(LVTestType *lvtt, uint64 nitems, BlockNumber minblk, BlockNumber maxblk,
 	   OffsetNumber maxoff)
@@ -952,3 +1123,11 @@ rtbm_test(PG_FUNCTION_ARGS)
 	PG_RETURN_NULL();
 
 }
+
+Datum
+radix_run_tests(PG_FUNCTION_ARGS)
+{
+	bfm_tests();
+
+	PG_RETURN_VOID();
+}
diff --git a/bdbench/bench.sql b/bdbench/bench.sql
index c5ef2d3..94cfde0 100644
--- a/bdbench/bench.sql
+++ b/bdbench/bench.sql
@@ -11,10 +11,11 @@ select prepare(
 
 -- Load dead tuples to all data structures.
 select 'array', attach_dead_tuples('array');
-select 'tbm', attach_dead_tuples('tbm');
 select 'intset', attach_dead_tuples('intset');
-select 'vtbm', attach_dead_tuples('vtbm');
 select 'rtbm', attach_dead_tuples('rtbm');
+select 'tbm', attach_dead_tuples('tbm');
+select 'vtbm', attach_dead_tuples('vtbm');
+select 'radix', attach_dead_tuples('radix');
 
 -- Do benchmark of lazy_tid_reaped.
 select 'array bench', bench('array');
@@ -22,6 +23,7 @@ select 'intset bench', bench('intset');
 select 'rtbm bench', bench('rtbm');
 select 'tbm bench', bench('tbm');
 select 'vtbm bench', bench('vtbm');
+select 'radix', bench('radix');
 
 -- Check the memory usage.
 select * from pg_backend_memory_contexts where name ~ 'bench' or name = 'TopMemoryContext' order by name;
-- 
2.32.0.rc2

From 3a6c96cc705b1af412cf9300be6f676f6c5e4aa6 Mon Sep 17 00:00:00 2001
From: Yura Sokolov <funny.falcon@gmail.com>
Date: Sun, 25 Jul 2021 03:06:48 +0300
Subject: [PATCH] svtm - specialized vacuum tid map

---
 bdbench/Makefile  |   2 +-
 bdbench/bdbench.c |  91 ++++++-
 bdbench/bench.sql |   2 +
 bdbench/svtm.c    | 635 ++++++++++++++++++++++++++++++++++++++++++++++
 bdbench/svtm.h    |  19 ++
 5 files changed, 746 insertions(+), 3 deletions(-)
 create mode 100644 bdbench/svtm.c
 create mode 100644 bdbench/svtm.h

diff --git a/bdbench/Makefile b/bdbench/Makefile
index 723132a..a6f758f 100644
--- a/bdbench/Makefile
+++ b/bdbench/Makefile
@@ -2,7 +2,7 @@
 
 MODULE_big = bdbench
 DATA = bdbench--1.0.sql
-OBJS = bdbench.o vtbm.o rtbm.o radix.o
+OBJS = bdbench.o vtbm.o rtbm.o radix.o svtm.o
 
 EXTENSION = bdbench
 REGRESS= bdbench
diff --git a/bdbench/bdbench.c b/bdbench/bdbench.c
index 85d8eaa..a8bc49a 100644
--- a/bdbench/bdbench.c
+++ b/bdbench/bdbench.c
@@ -7,6 +7,7 @@
 
 #include "postgres.h"
 
+#include <math.h>
 #include "catalog/index.h"
 #include "fmgr.h"
 #include "funcapi.h"
@@ -20,6 +21,7 @@
 #include "vtbm.h"
 #include "rtbm.h"
 #include "radix.h"
+#include "svtm.h"
 
 //#define DEBUG_DUMP_MATCHED 1
 
@@ -148,6 +150,15 @@ static bool radix_reaped(LVTestType *lvtt, ItemPointer itemptr);
 static Size radix_mem_usage(LVTestType *lvtt);
 static void radix_load(void *tbm, ItemPointerData *itemptrs, int nitems);
 
+/* svtm */
+static void svtm_init(LVTestType *lvtt, uint64 nitems);
+static void svtm_fini(LVTestType *lvtt);
+static void svtm_attach(LVTestType *lvtt, uint64 nitems, BlockNumber minblk,
+						 BlockNumber maxblk, OffsetNumber maxoff);
+static bool svtm_reaped(LVTestType *lvtt, ItemPointer itemptr);
+static Size svtm_mem_usage(LVTestType *lvtt);
+static void svtm_load(SVTm *tbm, ItemPointerData *itemptrs, int nitems);
+
 
 /* Misc functions */
 static void generate_index_tuples(uint64 nitems, BlockNumber minblk,
@@ -174,7 +185,7 @@ static void load_rtbm(RTbm *vtbm, ItemPointerData *itemptrs, int nitems);
 		.mem_usage_fn = n##_mem_usage, \
 			}
 
-#define TEST_SUBJECT_TYPES 6
+#define TEST_SUBJECT_TYPES 7
 static LVTestType LVTestSubjects[TEST_SUBJECT_TYPES] =
 {
 	DECLARE_SUBJECT(array),
@@ -182,7 +193,8 @@ static LVTestType LVTestSubjects[TEST_SUBJECT_TYPES] =
 	DECLARE_SUBJECT(intset),
 	DECLARE_SUBJECT(vtbm),
 	DECLARE_SUBJECT(rtbm),
-	DECLARE_SUBJECT(radix)
+	DECLARE_SUBJECT(radix),
+	DECLARE_SUBJECT(svtm)
 };
 
 static bool
@@ -756,6 +768,81 @@ radix_load(void *tbm, ItemPointerData *itemptrs, int nitems)
 	}
 }
 
+/* ------------ svtm ----------- */
+static void
+svtm_init(LVTestType *lvtt, uint64 nitems)
+{
+	MemoryContext old_ctx;
+
+	lvtt->mcxt = AllocSetContextCreate(TopMemoryContext,
+									   "svtm bench",
+									   ALLOCSET_DEFAULT_SIZES);
+	old_ctx = MemoryContextSwitchTo(lvtt->mcxt);
+	lvtt->private = svtm_create();
+	MemoryContextSwitchTo(old_ctx);
+}
+
+static void
+svtm_fini(LVTestType *lvtt)
+{
+	if (lvtt->private != NULL)
+		svtm_free(lvtt->private);
+}
+
+static void
+svtm_attach(LVTestType *lvtt, uint64 nitems, BlockNumber minblk,
+			   BlockNumber maxblk, OffsetNumber maxoff)
+{
+	MemoryContext oldcontext = MemoryContextSwitchTo(lvtt->mcxt);
+
+	svtm_load(lvtt->private,
+			   DeadTuples_orig->itemptrs,
+			   DeadTuples_orig->dtinfo.nitems);
+
+	MemoryContextSwitchTo(oldcontext);
+}
+
+static bool
+svtm_reaped(LVTestType *lvtt, ItemPointer itemptr)
+{
+	return svtm_lookup(lvtt->private, itemptr);
+}
+
+static uint64
+svtm_mem_usage(LVTestType *lvtt)
+{
+	svtm_stats((SVTm *) lvtt->private);
+	return MemoryContextMemAllocated(lvtt->mcxt, true);
+}
+
+static void
+svtm_load(SVTm *svtm, ItemPointerData *itemptrs, int nitems)
+{
+	BlockNumber curblkno = InvalidBlockNumber;
+	OffsetNumber offs[1024];
+	int noffs = 0;
+
+	for (int i = 0; i < nitems; i++)
+	{
+		ItemPointer tid = &(itemptrs[i]);
+		BlockNumber blkno = ItemPointerGetBlockNumber(tid);
+
+		if (curblkno != InvalidBlockNumber &&
+			curblkno != blkno)
+		{
+			svtm_add_page(svtm, curblkno, offs, noffs);
+			curblkno = blkno;
+			noffs = 0;
+		}
+
+		curblkno = blkno;
+		offs[noffs++] = ItemPointerGetOffsetNumber(tid);
+	}
+
+	svtm_add_page(svtm, curblkno, offs, noffs);
+	svtm_finalize_addition(svtm);
+}
+
 
 static void
 attach(LVTestType *lvtt, uint64 nitems, BlockNumber minblk, BlockNumber maxblk,
diff --git a/bdbench/bench.sql b/bdbench/bench.sql
index 94cfde0..b303591 100644
--- a/bdbench/bench.sql
+++ b/bdbench/bench.sql
@@ -16,6 +16,7 @@ select 'rtbm', attach_dead_tuples('rtbm');
 select 'tbm', attach_dead_tuples('tbm');
 select 'vtbm', attach_dead_tuples('vtbm');
 select 'radix', attach_dead_tuples('radix');
+select 'svtm', attach_dead_tuples('svtm');
 
 -- Do benchmark of lazy_tid_reaped.
 select 'array bench', bench('array');
@@ -24,6 +25,7 @@ select 'rtbm bench', bench('rtbm');
 select 'tbm bench', bench('tbm');
 select 'vtbm bench', bench('vtbm');
 select 'radix', bench('radix');
+select 'svtm', bench('svtm');
 
 -- Check the memory usage.
 select * from pg_backend_memory_contexts where name ~ 'bench' or name = 'TopMemoryContext' order by name;
diff --git a/bdbench/svtm.c b/bdbench/svtm.c
new file mode 100644
index 0000000..6ce4ed9
--- /dev/null
+++ b/bdbench/svtm.c
@@ -0,0 +1,635 @@
+/*------------------------------------------------------------------------------
+ *
+ * svtm.c - Specialized Vacuum TID Map
+ *		Data structure to hold TIDs of dead tuples during vacuum.
+ *
+ * It takes in account following properties of PostgreSQL ItemPointer and
+ * vacuum heap scan process:
+ * - page number is 32bit integer
+ * - 14 bit is enough for tuple offset.
+ *   - but usually number of tuples is significantly lesser
+ *   - and 0 is InvalidOffset
+ * - heap is scanned sequentially therefore pages are in increasing order,
+ * - tuples of a single page could be added at once.
+ *
+ * It uses techniques from HATM (Hash Array Mapped Trie), and Roaring bitmaps.
+ *
+ * # Page.
+ *
+ * Page information consists of 16 bit page header and bitmap or sparse bitmap
+ * container. Header and bitmap contains different information
+ * depending on high bits of header.
+ *
+ * Sparse bitmap is made from raw bitmap by skipping all-zero bytes. Non-zero
+ * bytes than indexed with bitmap of sparseness.
+ *
+ * If bitmap contains a lot of all-one bytes, then it is inverted before
+ * going to be sparse.
+ *
+ * Kinds of header/bitmap:
+ * - embedded 1 offset
+ *     high bits: 11
+ *     lower bits: 14bit tuple offset
+ *     bitmap: no external bitmap
+ *
+ * - raw bitmap
+ *     high bits: 00
+ *     lower bits: 14bit offset in bitmap container
+ *     bitmap: 1 byte bitmap length = K
+ *             K byte raw bitmap
+ *   This container is used if there is no detectable pattern in offsets.
+ *
+ * - sparse bitmap
+ *     high bits: 10
+ *     lower bits: 14bit offset in bitmap container
+ *     bitmap: 1 byte raw bitmap length = K
+ *     		   1 byte sparseness bitmap length = S
+ *     		   S bytes sparseness bitmap
+ *     		   Z bytes of non-zero bitmap bytes
+ *   If raw bitmap contains > 62.5% of zero bytes, then sparse bitmap format is
+ *   chosen.
+ *
+ * - inverted sparse bitmap
+ *     high bits: 10
+ *     lower bits: 14bit offset in bitmap container
+ *     bitmap: 1 byte raw bitmap length = K
+ *     		   1 byte sparseness bitmap length = S
+ *     		   S bytes sparseness bitmap
+ *     		   Z bytes of non-zero inverted bitmap bytes
+ *   If raw bitmap contains > 62.5% of all-ones bytes, then sparse bitmap format
+ *   is used to encode whenever tuple is not dead instead.
+ *
+ * # Page map chunk.
+ *
+ * 32 consecutive page headers are stored in an sparse array together with
+ * their bitmaps. Pages without any dead tuple are skipped from this array.
+ *
+ * Therefore chunk map contains:
+ * - 32bitmap of pages presence
+ * - array of 0-32 page headers
+ * - byte array of concatenated bitmaps for all pages in a chunk (with offsets
+ *   encoded in page headers).
+ *
+ * Maximum chunk size:
+ * - page header map: 4 + 32*2 = 68 bytes
+ * - bitmaps byte array:
+ *     32kb page: 32 * 148 = 4736 byte
+ *     8kb page: 32 * 36 = 1152 byte
+ * - sum:
+ *     32kb page: 4804 bytes
+ *     8kb page: 1220 bytes
+ *
+ * Each chunk is allocated as a single blob.
+ *
+ * # Page chunk map.
+ *
+ * Pointers to chunks are stored into sparse array indexed with ixmap bitmap.
+ * Number of first non-empty chunk and first empty chunk after it are
+ * remembered to reduce size of bitmap and speedup access to first run
+ * of non-empty chunks.
+ */
+
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "utils/builtins.h"
+#include "utils/memutils.h"
+#include "lib/stringinfo.h"
+#include "port/pg_bitutils.h"
+
+#include "svtm.h"
+
+#define PAGES_PER_CHUNK (1<<5)
+#define BITMAP_PER_PAGE (MaxHeapTuplesPerPage/8 + 1)
+#define PAGE_TO_CHUNK(blkno) ((uint32)(blkno)>>5)
+#define CHUNK_TO_PAGE(chunkno) ((chunkno)<<5)
+
+#define SVTAllocChunk ((1<<19)-128)
+
+typedef struct SVTPagesChunk SVTPagesChunk;
+typedef struct SVTChunkBuilder SVTChunkBuilder;
+typedef struct SVTAlloc		 SVTAlloc;
+typedef struct IxMap IxMap;
+typedef uint16 SVTHeader;
+
+struct SVTAlloc {
+	SVTAlloc*	next;
+	Size		pos;
+	Size		limit;
+	uint8		bytes[FLEXIBLE_ARRAY_MEMBER];
+};
+
+struct SVTChunkBuilder
+{
+	uint32	chunk_number;
+	uint32  npages;
+	uint32  bitmaps_pos;
+	uint32  hcnt[4];
+	BlockNumber	pages[PAGES_PER_CHUNK];
+	SVTHeader	headers[PAGES_PER_CHUNK];
+	/* we add 3 for BITMAP_PER_PAGE for 4 byte roundup */
+	uint8   bitmaps[(BITMAP_PER_PAGE+3)*PAGES_PER_CHUNK];
+};
+
+struct IxMap {
+	uint32	bitmap;
+	uint32	offset;
+};
+
+struct SVTm
+{
+	BlockNumber	lastblock; 	/* max block number + 1 */
+	struct {
+		uint32	start, end;
+	}			firstrun;
+	uint32		nchunks;
+	SVTPagesChunk **chunks; /* chunks pointers */
+	IxMap	   *ixmap;   	/* compression map for chunks */
+	Size		total_size;
+	SVTAlloc	*alloc;
+
+	uint32  npages;
+	uint32  hcnt[4];
+
+	SVTChunkBuilder builder; /* builder for current chunk */
+};
+
+struct SVTPagesChunk
+{
+	uint32  chunk_number;
+	uint32 	bitmap;
+	SVTHeader	headers[FLEXIBLE_ARRAY_MEMBER];
+};
+
+#define bm2(b,c) (((b)<<1)|(c))
+enum SVTHeaderType {
+	SVTH_rawBitmap     = bm2(0,0),
+	SVTH_inverseBitmap = bm2(0,1),
+	SVTH_sparseBitmap  = bm2(1,0),
+	SVTH_single        = bm2(1,1),
+};
+#define HeaderTypeOffset (14)
+#define MakeHeaderType(l) ((SVTHeader)(l) << HeaderTypeOffset)
+#define HeaderType(h) (((h)>>14)&3)
+
+#define BitmapPosition(h) ((h) & ((1<<14)-1))
+#define MakeBitmapPosition(l) ((l) & ((1<<14)-1))
+#define MaxBitmapPosition ((1<<14)-1)
+
+#define SingleItem(h) ((h) & ((1<<14)-1))
+#define MakeSingleItem(h) ((h) & ((1<<14)-1))
+
+/*
+ * we could not use pg_popcount32 in contrib in windows,
+ * therefore define our own.
+ */
+#define INVALID_INDEX (~(uint32)0)
+const uint8 four_bit_cnt[32] = {
+	0, 1, 1, 2, 1, 2, 2, 3,
+	1, 2, 2, 3, 2, 3, 3, 4,
+	1, 2, 2, 3, 2, 3, 3, 4,
+	2, 3, 3, 4, 3, 4, 4, 5,
+};
+
+#define makeoff(v, bits) ((v)/bits)
+#define makebit(v, bits) (1<<((v)&((bits)-1)))
+#define maskbits(v, vits) ((v) & ((1<<(bits))-1))
+#define bitszero(v, vits) (maskbits((v), (bits)) == 0)
+
+static inline uint32 svt_popcnt32(uint32 val);
+static void svtm_build_chunk(SVTm *store);
+
+static inline uint32
+svt_popcnt8(uint8 val)
+{
+	return four_bit_cnt[val&15] + four_bit_cnt[(val>>4)&15];
+}
+
+static inline uint32
+svt_popcnt32(uint32 val)
+{
+	return pg_popcount32(val);
+}
+
+static SVTAlloc*
+svtm_alloc_alloc(void)
+{
+	SVTAlloc *alloc = palloc0(SVTAllocChunk);
+	alloc->limit = SVTAllocChunk - offsetof(SVTAlloc, bytes);
+	return alloc;
+}
+
+SVTm*
+svtm_create(void)
+{
+	SVTm* store = palloc0(sizeof(SVTm));
+	/* preallocate chunks just to pass it to repalloc later */
+	store->chunks = palloc(sizeof(SVTPagesChunk*)*2);
+	store->alloc = svtm_alloc_alloc();
+	return store;
+}
+
+static void*
+svtm_alloc(SVTm *store, Size size)
+{
+	SVTAlloc *alloc = store->alloc;
+	void *res;
+
+	size = INTALIGN(size);
+
+	if (alloc->limit - alloc->pos < size)
+	{
+		alloc = svtm_alloc_alloc();
+		alloc->next = store->alloc;
+		store->alloc = alloc;
+	}
+
+	res = alloc->bytes + alloc->pos;
+	alloc->pos += size;
+
+	return res;
+}
+
+void
+svtm_free(SVTm *store)
+{
+	SVTAlloc *alloc, *next;
+
+	if (store == NULL)
+		return;
+	if (store->ixmap != NULL)
+		pfree(store->ixmap);
+	if (store->chunks != NULL)
+		pfree(store->chunks);
+	alloc = store->alloc;
+	while (alloc != NULL)
+	{
+		next = alloc->next;
+		pfree(alloc);
+		alloc = next;
+	}
+	pfree(store);
+}
+
+void
+svtm_add_page(SVTm *store, const BlockNumber blkno,
+		const OffsetNumber *offnums, uint32 nitems)
+{
+	SVTChunkBuilder		*bld = &store->builder;
+	SVTHeader	header = 0;
+	uint32	chunkno = PAGE_TO_CHUNK(blkno);
+	uint32	bmlen = 0, bbmlen = 0, bbbmlen = 0;
+	uint32  sbmlen = 0;
+	uint32  nonzerocnt;
+	uint32  allzerocnt = 0, allonecnt = 0;
+	uint32  firstoff, lastoff;
+	uint32	i, j;
+	uint8  *append;
+	uint8	bitmap[BITMAP_PER_PAGE] = {0};
+	uint8	spix1[BITMAP_PER_PAGE/8+1] = {0};
+	uint8	spix2[BITMAP_PER_PAGE/64+2] = {0};
+#define off(i) (offnums[i]-1)
+
+	if (nitems == 0)
+		return;
+
+	if (chunkno != bld->chunk_number)
+	{
+		Assert(chunkno > bld->chunk_number);
+		svtm_build_chunk(store);
+		bld->chunk_number = chunkno;
+	}
+
+	Assert(bld->npages == 0 || blkno > bld->pages[bld->npages-1]);
+
+	firstoff = off(0);
+	lastoff = off(nitems-1);
+	Assert(lastoff < (1<<11));
+
+	if (nitems == 1 && lastoff < (1<<10))
+	{
+		/* 1 embedded item */
+		header = MakeHeaderType(SVTH_single);
+		header |= firstoff;
+	}
+	else
+	{
+		Assert(bld->bitmaps_pos < MaxBitmapPosition);
+
+		append = bld->bitmaps + bld->bitmaps_pos;
+		header = MakeBitmapPosition(bld->bitmaps_pos);
+		/* calculate bitmap */
+		for (i = 0; i < nitems; i++)
+		{
+			Assert(i == 0 || off(i) < off(i-1));
+			bitmap[makeoff(off(i),8)] |= makebit(off(i), 8);
+		}
+
+		bmlen = lastoff/8 + 1;
+		append[0] = bmlen;
+
+		for (i = 0; i < bmlen; i++)
+		{
+			allzerocnt += bitmap[i] == 0;
+			allonecnt += bitmap[i] == 0xff;
+		}
+
+		/* if we could not abuse sparness of bitmap, pack it as is */
+		if (allzerocnt <= bmlen*5/8 && allonecnt <= bmlen*5/8)
+		{
+			header |= MakeHeaderType(SVTH_rawBitmap);
+			memmove(append+1, bitmap, bmlen);
+			bld->bitmaps_pos += bmlen + 1;
+		}
+		else
+		{
+			/* if there is more present tuples than absent, invert map */
+			if (allonecnt > bmlen*5/8)
+			{
+				header |= MakeHeaderType(SVTH_inverseBitmap);
+				for (i = 0; i < bmlen; i++)
+					bitmap[i] ^= 0xff;
+				nonzerocnt = bmlen - allonecnt;
+			}
+			else
+			{
+				header |= MakeHeaderType(SVTH_sparseBitmap);
+				nonzerocnt = bmlen - allzerocnt;
+			}
+
+			/* Then we compose two level bitmap index for bitmap. */
+
+			/* First compress bitmap itself with first level index */
+			bbmlen = (bmlen+7)/8;
+			j = 0;
+			for (i = 0; i < bmlen; i++)
+			{
+				if (bitmap[i] != 0)
+				{
+					spix1[makeoff(i, 8)] |= makebit(i, 8);
+					bitmap[j] = bitmap[i];
+					j++;
+				}
+			}
+			Assert(j == nonzerocnt);
+
+			/* Then compress first level index with second level */
+			bbbmlen = (bbmlen+7)/8;
+			Assert(bbbmlen <= 3);
+			sbmlen = 0;
+			for (i = 0; i < bbmlen; i++)
+			{
+				if (spix1[i] != 0)
+				{
+					spix2[makeoff(i, 8)] |= makebit(i, 8);
+					spix1[sbmlen] = spix1[i];
+					sbmlen++;
+				}
+			}
+			Assert(sbmlen < 19);
+
+			/*
+			 * second byte contains length of first level and offset
+			 * to compressed bitmap itself.
+			 */
+			append[1] = (bbbmlen << 5) | (bbbmlen + sbmlen);
+			memmove(append+2, spix2, bbbmlen);
+			memmove(append+2+bbbmlen, spix1, sbmlen);
+			memmove(append+2+bbbmlen+sbmlen, bitmap, nonzerocnt);
+			bld->bitmaps_pos += bbbmlen + sbmlen + nonzerocnt + 2;
+		}
+		Assert(bld->bitmaps_pos <= MaxBitmapPosition);
+	}
+	bld->pages[bld->npages] = blkno;
+	bld->headers[bld->npages] = header;
+	bld->npages++;
+	bld->hcnt[HeaderType(header)]++;
+}
+#undef off
+
+static void
+svtm_build_chunk(SVTm *store)
+{
+	SVTChunkBuilder		*bld = &store->builder;
+	SVTPagesChunk	*chunk;
+	uint32 bitmap = 0;
+	BlockNumber startblock;
+	uint32 off;
+	uint32 i;
+	Size total_size;
+
+	Assert(bld->npages < ~(uint16)0);
+
+	if (bld->npages == 0)
+		return;
+
+	startblock = CHUNK_TO_PAGE(bld->chunk_number);
+	for (i = 0; i < bld->npages; i++)
+	{
+		off = bld->pages[i] - startblock;
+		bitmap |= makebit(off, 32);
+	}
+
+	total_size = offsetof(SVTPagesChunk, headers) +
+		sizeof(SVTHeader)*bld->npages +
+		bld->bitmaps_pos;
+
+	chunk = svtm_alloc(store, total_size);
+	chunk->chunk_number = bld->chunk_number;;
+	chunk->bitmap = bitmap;
+	memmove(chunk->headers,
+			bld->headers, sizeof(SVTHeader)*bld->npages);
+	memmove((char*)(chunk->headers + bld->npages),
+			bld->bitmaps, bld->bitmaps_pos);
+
+	/*
+	 * We allocate store->chunks in power-of-two sizes.
+	 * Then check for "we will overflow" is equal to "nchunks is power of two".
+	 */
+	if ((store->nchunks & (store->nchunks-1)) == 0)
+	{
+		Size new_nchunks = store->nchunks ? (store->nchunks<<1) : 1;
+		store->chunks = (SVTPagesChunk**) repalloc(store->chunks,
+				new_nchunks * sizeof(SVTPagesChunk*));
+	}
+	store->chunks[store->nchunks] = chunk;
+	store->nchunks++;
+	store->lastblock = bld->pages[bld->npages-1];
+	store->total_size += total_size;
+
+	for (i = 0; i<4; i++)
+		store->hcnt[i] += bld->hcnt[i];
+	store->npages += bld->npages;
+
+	memset(bld, 0, sizeof(SVTChunkBuilder));
+}
+
+void
+svtm_finalize_addition(SVTm *store)
+{
+	SVTPagesChunk **chunks = store->chunks;
+	IxMap  *ixmap;
+	uint32	last_chunk, chunkno;
+	uint32	firstrun, firstrunend;
+	uint32	nmaps;
+	uint32	i;
+
+	if (store->nchunks == 0)
+	{
+		/*
+		 * block number will be rejected with:
+		 * block <= lastblock, lastblock == 0
+		 * chunk >= firstrun.start, firstrun.start = 1
+		 */
+		store->firstrun.start = 1;
+		return;
+	}
+
+	firstrun = chunks[0]->chunk_number;
+	firstrunend = firstrun+1;
+
+	/* adsorb last chunk */
+	svtm_build_chunk(store);
+
+	/* Now we need to build ixmap */
+	last_chunk = PAGE_TO_CHUNK(store->lastblock);
+	nmaps = makeoff(last_chunk, 32) + 1;
+	ixmap = palloc0(nmaps * sizeof(IxMap));
+
+	for (i = 0; i < store->nchunks; i++)
+	{
+		chunkno = chunks[i]->chunk_number;
+		if (chunkno == firstrunend)
+			firstrunend++;
+		chunkno -= firstrun;
+		ixmap[makeoff(chunkno,32)].bitmap |= makebit(chunkno,32);
+	}
+
+	for (i = 1; i < nmaps; i++)
+	{
+		ixmap[i].offset = ixmap[i-1].offset;
+		ixmap[i].offset += svt_popcnt32(ixmap[i-1].bitmap);
+	}
+
+	store->firstrun.start = firstrun;
+	store->firstrun.end = firstrunend;
+	store->ixmap = ixmap;
+}
+
+bool
+svtm_lookup(SVTm *store, ItemPointer tid)
+{
+	BlockNumber		blkno = ItemPointerGetBlockNumber(tid);
+	OffsetNumber	offset = ItemPointerGetOffsetNumber(tid) - 1;
+	SVTPagesChunk  *chunk;
+	IxMap          *ixmap = store->ixmap;
+	uint32			off, bit;
+
+	SVTHeader		header;
+	uint8		   *bitmaps;
+	uint8		   *bitmap;
+	uint32	index;
+	uint32	chunkno, blk_in_chunk;
+	uint8	type;
+	uint8	bmoff, bmbit, bmlen, bmbyte;
+	uint8	bmstart, bbmoff, bbmbit, bbmbyte;
+	uint8	bbbmlen, bbbmoff, bbbmbit;
+	uint8	six1off, sbmoff;
+	bool	inverse, bitset;
+
+	if (blkno > store->lastblock)
+		return false;
+
+	chunkno = PAGE_TO_CHUNK(blkno);
+	if (chunkno < store->firstrun.start)
+		return false;
+
+	if (chunkno < store->firstrun.end)
+		index = chunkno - store->firstrun.start;
+	else
+	{
+		off = makeoff(chunkno - store->firstrun.start, 32);
+		bit = makebit(chunkno - store->firstrun.start, 32);
+		if ((ixmap[off].bitmap & bit) == 0)
+			return false;
+
+		index = ixmap[off].offset + svt_popcnt32(ixmap[off].bitmap & (bit-1));
+	}
+	chunk = store->chunks[index];
+	Assert(chunkno == chunk->chunk_number);
+
+	blk_in_chunk = blkno - CHUNK_TO_PAGE(chunkno);
+	bit = makebit(blk_in_chunk, 32);
+
+	if ((chunk->bitmap & bit) == 0)
+		return false;
+	index = svt_popcnt32(chunk->bitmap & (bit - 1));
+	header = chunk->headers[index];
+
+	type = HeaderType(header);
+	if (type == SVTH_single)
+		return offset == SingleItem(header);
+
+	bitmaps = (uint8*)(chunk->headers + svt_popcnt32(chunk->bitmap));
+	bmoff = makeoff(offset, 8);
+	bmbit = makebit(offset, 8);
+	inverse = false;
+
+	bitmap = bitmaps + BitmapPosition(header);
+	bmlen = bitmap[0];
+	if (bmoff >= bmlen)
+		return false;
+
+	switch (type)
+	{
+		case SVTH_rawBitmap:
+			return (bitmap[bmoff+1] & bmbit) != 0;
+
+		case SVTH_inverseBitmap:
+			inverse = true;
+			/* fallthrough */
+		case SVTH_sparseBitmap:
+			bmstart = bitmap[1] & 0x1f;
+			bbbmlen = bitmap[1] >> 5;
+			bitmap += 2;
+			bbmoff = makeoff(bmoff, 8);
+			bbmbit = makebit(bmoff, 8);
+			bbbmoff = makeoff(bbmoff, 8);
+			bbbmbit = makebit(bbmoff, 8);
+			/* check bit in second level index */
+			if ((bitmap[bbbmoff] & bbbmbit) == 0)
+				return inverse;
+			/* calculate sparse offset into compressed first level index */
+			six1off = pg_popcount((char*)bitmap, bbbmoff) +
+						svt_popcnt8(bitmap[bbbmoff] & (bbbmbit-1));
+			/* check bit in first level index */
+			bbmbyte = bitmap[bbbmlen+six1off];
+			if ((bbmbyte & bbmbit) == 0)
+				return inverse;
+			/* and sparse offset into compressed bitmap itself */
+			sbmoff = pg_popcount((char*)bitmap+bbbmlen, six1off) +
+						svt_popcnt8(bbmbyte & (bbmbit-1));
+			bmbyte = bitmap[bmstart + sbmoff];
+			/* finally check bit in bitmap */
+			bitset = (bmbyte & bmbit) != 0;
+			return bitset != inverse;
+	}
+	Assert(false);
+	return false;
+}
+
+void svtm_stats(SVTm *store)
+{
+	StringInfo s;
+
+	s = makeStringInfo();
+	appendStringInfo(s, "svtm: nchunks %u npages %u\n",
+			store->nchunks, store->npages);
+	appendStringInfo(s, "single=%u raw=%u inserse=%u sparse=%u",
+			store->hcnt[SVTH_single], store->hcnt[SVTH_rawBitmap],
+			store->hcnt[SVTH_inverseBitmap], store->hcnt[SVTH_sparseBitmap]);
+
+	elog(NOTICE, "%s", s->data);
+	pfree(s->data);
+	pfree(s);
+}
diff --git a/bdbench/svtm.h b/bdbench/svtm.h
new file mode 100644
index 0000000..fdb5e3f
--- /dev/null
+++ b/bdbench/svtm.h
@@ -0,0 +1,19 @@
+#ifndef _SVTM_H
+#define _SVTM_H
+
+/* Specialized Vacuum TID Map */
+typedef struct SVTm SVTm;
+
+SVTm *svtm_create(void);
+void svtm_free(SVTm *store);
+/*
+ * Add page tuple offsets to map.
+ * offnums should be sorted. Max offset number should be < 2048.
+ */
+void svtm_add_page(SVTm *store, const BlockNumber blkno,
+		const OffsetNumber *offnums, uint32 nitems);
+void svtm_finalize_addition(SVTm *store);
+bool svtm_lookup(SVTm *store, ItemPointer tid);
+void svtm_stats(SVTm *store);
+
+#endif
-- 
2.32.0

From c555983109cf202a2bd395de77711f302b7a5024 Mon Sep 17 00:00:00 2001
From: Yura Sokolov <funny.falcon@gmail.com>
Date: Wed, 28 Jul 2021 17:21:02 +0300
Subject: [PATCH] integerset2

---
 bdbench/Makefile         |   2 +-
 bdbench/bdbench--1.0.sql |   5 +
 bdbench/bdbench.c        |  86 +++-
 bdbench/bench.sql        |   2 +
 bdbench/integerset2.c    | 887 +++++++++++++++++++++++++++++++++++++++
 bdbench/integerset2.h    |  15 +
 6 files changed, 994 insertions(+), 3 deletions(-)
 create mode 100644 bdbench/integerset2.c
 create mode 100644 bdbench/integerset2.h

diff --git a/bdbench/Makefile b/bdbench/Makefile
index a6f758f..0b00211 100644
--- a/bdbench/Makefile
+++ b/bdbench/Makefile
@@ -2,7 +2,7 @@
 
 MODULE_big = bdbench
 DATA = bdbench--1.0.sql
-OBJS = bdbench.o vtbm.o rtbm.o radix.o svtm.o
+OBJS = bdbench.o vtbm.o rtbm.o radix.o svtm.o integerset2.o
 
 EXTENSION = bdbench
 REGRESS= bdbench
diff --git a/bdbench/bdbench--1.0.sql b/bdbench/bdbench--1.0.sql
index 0ba10a8..ae15514 100644
--- a/bdbench/bdbench--1.0.sql
+++ b/bdbench/bdbench--1.0.sql
@@ -115,3 +115,8 @@ CREATE FUNCTION radix_run_tests()
 RETURNS void
 AS 'MODULE_PATHNAME'
 LANGUAGE C STRICT VOLATILE;
+
+CREATE FUNCTION intset2_run_tests()
+RETURNS void
+AS 'MODULE_PATHNAME'
+LANGUAGE C STRICT VOLATILE;
diff --git a/bdbench/bdbench.c b/bdbench/bdbench.c
index d15526e..883099c 100644
--- a/bdbench/bdbench.c
+++ b/bdbench/bdbench.c
@@ -22,6 +22,7 @@
 #include "rtbm.h"
 #include "radix.h"
 #include "svtm.h"
+#include "integerset2.h"
 
 //#define DEBUG_DUMP_MATCHED 1
 
@@ -93,6 +94,7 @@ PG_FUNCTION_INFO_V1(bench);
 PG_FUNCTION_INFO_V1(test_generate_tid);
 PG_FUNCTION_INFO_V1(rtbm_test);
 PG_FUNCTION_INFO_V1(radix_run_tests);
+PG_FUNCTION_INFO_V1(intset2_run_tests);
 PG_FUNCTION_INFO_V1(prepare);
 
 /*
@@ -159,6 +161,14 @@ static bool svtm_reaped(LVTestType *lvtt, ItemPointer itemptr);
 static Size svtm_mem_usage(LVTestType *lvtt);
 static void svtm_load(SVTm *tbm, ItemPointerData *itemptrs, int nitems);
 
+/* intset2 */
+static void intset2_init(LVTestType *lvtt, uint64 nitems);
+static void intset2_fini(LVTestType *lvtt);
+static void intset2_attach(LVTestType *lvtt, uint64 nitems, BlockNumber minblk,
+						 BlockNumber maxblk, OffsetNumber maxoff);
+static bool intset2_reaped(LVTestType *lvtt, ItemPointer itemptr);
+static Size intset2_mem_usage(LVTestType *lvtt);
+
 
 /* Misc functions */
 static void generate_index_tuples(uint64 nitems, BlockNumber minblk,
@@ -185,7 +195,7 @@ static void load_rtbm(RTbm *vtbm, ItemPointerData *itemptrs, int nitems);
 		.mem_usage_fn = n##_mem_usage, \
 			}
 
-#define TEST_SUBJECT_TYPES 7
+#define TEST_SUBJECT_TYPES 8
 static LVTestType LVTestSubjects[TEST_SUBJECT_TYPES] =
 {
 	DECLARE_SUBJECT(array),
@@ -194,7 +204,8 @@ static LVTestType LVTestSubjects[TEST_SUBJECT_TYPES] =
 	DECLARE_SUBJECT(vtbm),
 	DECLARE_SUBJECT(rtbm),
 	DECLARE_SUBJECT(radix),
-	DECLARE_SUBJECT(svtm)
+	DECLARE_SUBJECT(svtm),
+	DECLARE_SUBJECT(intset2)
 };
 
 static bool
@@ -843,6 +854,69 @@ svtm_load(SVTm *svtm, ItemPointerData *itemptrs, int nitems)
 	svtm_finalize_addition(svtm);
 }
 
+/* ------------ intset2 ----------- */
+static void
+intset2_init(LVTestType *lvtt, uint64 nitems)
+{
+	MemoryContext old_ctx;
+
+	lvtt->mcxt = AllocSetContextCreate(TopMemoryContext,
+									   "intset2 bench",
+									   ALLOCSET_DEFAULT_SIZES);
+	old_ctx = MemoryContextSwitchTo(lvtt->mcxt);
+	lvtt->private = intset2_create();
+	MemoryContextSwitchTo(old_ctx);
+}
+
+static void
+intset2_fini(LVTestType *lvtt)
+{
+	if (lvtt->private != NULL)
+		intset2_free(lvtt->private);
+}
+
+static inline uint64
+intset2_encode(ItemPointer tid)
+{
+	uint64 tid_i;
+	uint32 shift = pg_ceil_log2_32(MaxHeapTuplesPerPage);
+
+	Assert(ItemPointerGetOffsetNumber(tid)>0);
+	tid_i = ItemPointerGetOffsetNumber(tid) - 1;
+	tid_i |= (uint64)ItemPointerGetBlockNumber(tid) << shift;
+
+	return tid_i;
+}
+
+static void
+intset2_attach(LVTestType *lvtt, uint64 nitems, BlockNumber minblk,
+			   BlockNumber maxblk, OffsetNumber maxoff)
+{
+	uint64 i;
+	MemoryContext oldcontext = MemoryContextSwitchTo(lvtt->mcxt);
+
+	for (i = 0; i < nitems; i++)
+	{
+		intset2_add_member(lvtt->private,
+				intset2_encode(DeadTuples_orig->itemptrs + i));
+	}
+
+	MemoryContextSwitchTo(oldcontext);
+}
+
+static bool
+intset2_reaped(LVTestType *lvtt, ItemPointer itemptr)
+{
+	return intset2_is_member(lvtt->private, intset2_encode(itemptr));
+}
+
+static uint64
+intset2_mem_usage(LVTestType *lvtt)
+{
+	//svtm_stats((SVTm *) lvtt->private);
+	return MemoryContextMemAllocated(lvtt->mcxt, true);
+}
+
 
 static void
 attach(LVTestType *lvtt, uint64 nitems, BlockNumber minblk, BlockNumber maxblk,
@@ -1229,3 +1303,11 @@ radix_run_tests(PG_FUNCTION_ARGS)
 
 	PG_RETURN_VOID();
 }
+
+Datum
+intset2_run_tests(PG_FUNCTION_ARGS)
+{
+	intset2_test_1();
+
+	PG_RETURN_VOID();
+}
diff --git a/bdbench/bench.sql b/bdbench/bench.sql
index b303591..01ee846 100644
--- a/bdbench/bench.sql
+++ b/bdbench/bench.sql
@@ -17,6 +17,7 @@ select 'tbm', attach_dead_tuples('tbm');
 select 'vtbm', attach_dead_tuples('vtbm');
 select 'radix', attach_dead_tuples('radix');
 select 'svtm', attach_dead_tuples('svtm');
+select 'intset2', attach_dead_tuples('intset2');
 
 -- Do benchmark of lazy_tid_reaped.
 select 'array bench', bench('array');
@@ -26,6 +27,7 @@ select 'tbm bench', bench('tbm');
 select 'vtbm bench', bench('vtbm');
 select 'radix', bench('radix');
 select 'svtm', bench('svtm');
+select 'intset2', bench('intset2');
 
 -- Check the memory usage.
 select * from pg_backend_memory_contexts where name ~ 'bench' or name = 'TopMemoryContext' order by name;
diff --git a/bdbench/integerset2.c b/bdbench/integerset2.c
new file mode 100644
index 0000000..441e224
--- /dev/null
+++ b/bdbench/integerset2.c
@@ -0,0 +1,887 @@
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "utils/builtins.h"
+#include "utils/memutils.h"
+#include "lib/stringinfo.h"
+#include "port/pg_bitutils.h"
+#include "nodes/bitmapset.h"
+
+#include "integerset2.h"
+
+#define ONE ((bitmapword)1)
+#if BITS_PER_BITMAPWORD == 64
+#define SHIFT 6
+#define pg_popcountW pg_popcount64
+#else
+#define SHIFT 5
+#define pg_popcountW pg_popcount32
+#endif
+#define START(x) ((x) >> SHIFT)
+#define STARTN(x, n) ((x) >> (SHIFT*(n)))
+#define NBIT(x) ((x) & (((uint64)1 << SHIFT)-1))
+#define BIT(x) (ONE << NBIT(x))
+#define NBITN(x, n) NBIT(STARTN(x, (n)-1))
+#define BITN(x, n) (ONE << NBITN((x), (n)))
+
+/*
+ * Compressed leaf bitmap is indexed with 2 level bitmap index with
+ * 1 byte in root level. Therefore there is 8 bytes in second level
+ * and 64 bytes in third level.
+ */
+#define LEAF_SHIFT (3+3+3)
+#define LEAF_BITS (1 << LEAF_SHIFT)
+#define LEAF_BYTES (LEAF_BITS / 8)
+#define LBYTE(x) (((x) / 8) & (LEAF_BYTES-1))
+#define LBIT(x) (1 << ((x) & 7));
+
+#define CHUNK_LEAFS BITS_PER_BITMAPWORD
+#define CHUNK_SHIFT (LEAF_SHIFT + SHIFT)
+#define CSTART(x) ((x) & ~(((uint64)1 << CHUNK_SHIFT)-1))
+#define CPOS(x) NBIT((x) >> LEAF_SHIFT)
+
+#define VAL_TO_PAGE(val) ((val) >> LEAF_SHIFT)
+#define VAL_TO_CHUNK(val) ((val) >> CHUNK_SHIFT)
+#define TRIE_LEVELS (64 / SHIFT)
+
+#define ISAllocBatch (1<<18)
+
+typedef struct IntsetAllocator IntsetAllocator;
+struct IntsetAllocator
+{
+	Size	total_size;
+	Size	alloc_size;
+	Size	pos;
+	Size	limit;
+	uint8  *current;
+	List   *chunks;
+};
+
+/* TRIE (HAMT like) */
+typedef struct IntsetTrieVal IntsetTrieVal;
+typedef struct IntsetTrieElem IntsetTrieElem;
+typedef void* (*trie_alloc)(Size size, void *arg);
+typedef struct IntsetTrie IntsetTrie;
+
+struct IntsetTrieElem
+{
+	uint64	key;
+	bitmapword	bitmap;
+	union
+	{
+		void		*val;
+		IntsetTrieElem	*children;
+	}			p;
+};
+
+struct IntsetTrie
+{
+	trie_alloc	alloc;
+	void *alloc_arg;
+
+	int root_level;
+	IntsetTrieElem	root;
+	uint32 n[TRIE_LEVELS - 1];
+	IntsetTrieElem l[TRIE_LEVELS - 1][BITS_PER_BITMAPWORD];
+};
+
+struct IntsetTrieVal
+{
+	bitmapword	bitmap;
+	void	   *val;
+};
+
+/* Intset */
+
+typedef enum IntsetLeafType IntsetLeafType;
+typedef struct IntsetLeafBitmap IntsetLeafBitmap;
+typedef struct IntsetLeafEmbed IntsetLeafEmbed;
+typedef union IntsetLeafHeader IntsetLeafHeader;
+/* alias for pointer */
+typedef IntsetLeafHeader IntsetChunk;
+typedef struct IntsetLeafBuilder IntsetLeafBuilder;
+typedef struct IntsetChunkBuilder IntsetChunkBuilder;
+
+#define bm2(b,c) (((b)<<1)|(c))
+enum IntsetLeafType {
+	LT_RAW     = bm2(0, 0),
+	LT_INVERSE = bm2(0, 1),
+	LT_SPARSE  = bm2(1, 0),
+	LT_EMBED   = bm2(1, 1),
+};
+
+struct IntsetLeafBitmap
+{
+	IntsetLeafType	type:2;
+	uint32  minbyte:6;
+	uint32  maxbyte:6;
+	uint32	offset:16;
+};
+
+struct IntsetLeafEmbed
+{
+	IntsetLeafType	type:2;
+	uint32	v0:9;
+	uint32	v1:9;
+	uint32	v2:9;
+};
+
+union IntsetLeafHeader
+{
+	IntsetLeafBitmap	b;
+	IntsetLeafEmbed		e;
+	uint32	v;
+};
+
+StaticAssertDecl(sizeof(IntsetLeafBitmap) == sizeof(IntsetLeafEmbed),
+		"incompatible bit field packing");
+StaticAssertDecl(sizeof(IntsetLeafBitmap) == sizeof(uint32),
+		"incompatible bit field packing");
+
+
+struct IntsetLeafBuilder
+{
+	uint16	nvals;
+	uint16	embed[3];
+	uint8	minbyte;
+	uint8	maxbyte;
+	uint8	bytes[LEAF_BYTES];
+};
+
+struct IntsetChunkBuilder
+{
+	uint64	chunk;
+	bitmapword bitmap;
+	IntsetLeafBuilder leafs[CHUNK_LEAFS];
+};
+
+struct IntegerSet2
+{
+	uint64	firstvalue;
+	uint64	nvalues;
+
+	IntsetAllocator alloc;
+
+	IntsetChunkBuilder current;
+	IntsetTrie trie;
+};
+
+
+/* Allocator functions */
+
+static void *intset2_alloc(Size size, IntsetAllocator *alloc);
+static void  intset2_alloc_free(IntsetAllocator *alloc);
+
+/* Trie functions */
+
+static inline void intset2_trie_init(IntsetTrie *trie,
+									 trie_alloc alloc,
+									 void* arg);
+static void intset2_trie_insert(IntsetTrie *trie,
+								uint64 key,
+								IntsetTrieVal val);
+static IntsetTrieVal intset2_trie_lookup(IntsetTrie *trie, uint64 key);
+
+/* Intset functions */
+
+static uint8 intset2_leafbuilder_add(IntsetLeafBuilder *leaf, uint64 v);
+static inline bool intset2_leafbuilder_is_member(IntsetLeafBuilder *leaf,
+												 uint64 v);
+static uint8 intset2_chunkbuilder_add(IntsetChunkBuilder *chunk, uint64 v);
+static bool intset2_chunkbuilder_is_member(IntsetChunkBuilder *chunk,
+										   uint64 v);
+static bool intset2_chunk_is_member(IntsetChunk *chunk,
+									bitmapword bitmap,
+									uint64 v);
+
+static void intset2_compress_current(IntegerSet2 *intset);
+
+static inline uint8 pg_popcount8(uint8 b);
+static inline uint8 pg_popcount8_lowbits(uint8 b, uint8 nbits);
+static inline uint8 pg_popcount_small(uint8 *b, uint8 len);
+static inline uint32 intset2_compact(uint8 *dest, uint8 *src, uint8 len, bool inverse);
+
+/* Allocator */
+
+static void*
+intset2_alloc(Size size, IntsetAllocator *alloc)
+{
+	Assert(size < ISAllocBatch);
+
+	size = MAXALIGN(size);
+
+	if (alloc->limit - alloc->pos < size)
+	{
+		alloc->current = palloc0(ISAllocBatch);
+		alloc->chunks = lappend(alloc->chunks, alloc->current);
+		alloc->pos = 0;
+		alloc->limit = ISAllocBatch;
+		alloc->total_size += ISAllocBatch;
+	}
+
+	alloc->pos += size;
+	alloc->alloc_size += size;
+	return alloc->current + (alloc->pos - size);
+}
+
+static void
+intset2_alloc_free(IntsetAllocator *alloc)
+{
+	list_free_deep(alloc->chunks);
+}
+
+/* Trie */
+
+static inline void
+intset2_trie_init(IntsetTrie *trie, trie_alloc alloc, void* arg)
+{
+	memset(trie, 0, sizeof(*trie));
+	trie->root_level = -1;
+	trie->alloc = alloc;
+	trie->alloc_arg = arg;
+}
+
+static void
+intset2_trie_insert(IntsetTrie *trie, uint64 key, IntsetTrieVal val)
+{
+	IntsetTrieElem *root = &trie->root;
+	IntsetTrieElem *chunk;
+	IntsetTrieElem *parent;
+	IntsetTrieElem insert;
+	int level = trie->root_level;
+
+	if (level == -1)
+	{
+		trie->root_level = 0;
+		root->key = key;
+		root->bitmap = val.bitmap;
+		root->p.val = val.val;
+		return;
+	}
+
+	Assert(root->key <= STARTN(key, level));
+	Assert(trie->root_level != 0 || root->key < key);
+
+	/* Adjust root level */
+	while (root->key != STARTN(key, level))
+	{
+		trie->l[level][0] = *root;
+		trie->n[level] = 1;
+		root->p.children = trie->l[level];
+		root->bitmap = BIT(root->key);
+		root->key >>= SHIFT;
+		level++;
+	}
+	trie->root_level = level;
+
+	/* Actual insert */
+	insert.key = key;
+	insert.bitmap = val.bitmap;
+	insert.p.val = val.val;
+
+	/*
+	 * Iterate while we need to move current level to alloced
+	 * space.
+	 *
+	 * Since we've fixed root in the loop above, we certainly
+	 * will quit.
+	 */
+	for (level = 0;; level++) {
+		IntsetTrieElem *alloced;
+		uint32 n = trie->n[level];
+		Size asize;
+
+		chunk = trie->l[level];
+		Assert(chunk[n-1].key <= insert.key);
+
+		if (level < trie->root_level-1)
+			parent = &trie->l[level+1][trie->n[level+1]-1];
+		else
+			parent = root;
+
+		Assert(pg_popcountW(parent->bitmap) == n);
+
+		if (parent->key == START(insert.key))
+			/* Yes, we are in the same chunk */
+			break;
+
+		/*
+		 * We are not in the same chunk. We need to move
+		 * layer to allocated space and start new one.
+		 */
+		asize = n * sizeof(IntsetTrieElem);
+		alloced = trie->alloc(asize, trie->alloc_arg);
+		memmove(alloced, chunk, asize);
+		parent->p.children = alloced;
+
+		/* insert into this level */
+		memset(chunk, 0, sizeof(*chunk) * BITS_PER_BITMAPWORD);
+		chunk[0] = insert;
+		trie->n[level] = 1;
+
+		/* prepare insertion into upper level */
+		insert.bitmap = BIT(insert.key);
+		insert.p.children = chunk;
+		insert.key >>= SHIFT;
+	}
+
+	Assert((parent->bitmap & BIT(insert.key)) == 0);
+
+	parent->bitmap |= BIT(insert.key);
+	chunk[trie->n[level]] = insert;
+	trie->n[level]++;
+
+	Assert(pg_popcountW(parent->bitmap) == trie->n[level]);
+}
+
+static IntsetTrieVal
+intset2_trie_lookup(IntsetTrie *trie, uint64 key)
+{
+	IntsetTrieVal	result = {0, NULL};
+	IntsetTrieElem *current = &trie->root;
+	int level = trie->root_level;
+
+	if (level == -1)
+		return result;
+
+	/* root is out of bound */
+	if (current->key != STARTN(key, level))
+		return result;
+
+	for (; level > 0; level--)
+	{
+		int n;
+		uint64 bit = BITN(key, level);
+
+		if ((current->bitmap & bit) == 0)
+			/* Not found */
+			return result;
+		n = pg_popcountW(current->bitmap & (bit-1));
+		current = &current->p.children[n];
+	}
+
+	Assert(current->key == key);
+
+	result.bitmap = current->bitmap;
+	result.val = current->p.val;
+
+	return result;
+}
+
+/* Intset */
+
+/* returns 1 if new element were added, 0 otherwise */
+static uint8
+intset2_leafbuilder_add(IntsetLeafBuilder *leaf, uint64 v)
+{
+	uint16	bv;
+	uint8	lbyte, lbit, missing;
+
+	bv = v % LEAF_BITS;
+	lbyte = LBYTE(bv);
+	lbit = LBIT(bv);
+
+	if (leaf->nvals < 3)
+		leaf->embed[leaf->nvals] = bv;
+	if (leaf->nvals == 0)
+		leaf->minbyte = leaf->maxbyte = lbyte;
+	else
+	{
+		Assert(lbyte >= leaf->maxbyte);
+		leaf->maxbyte = lbyte;
+	}
+
+	lbyte -= leaf->minbyte;
+
+	missing = (leaf->bytes[lbyte] & lbit) == 0;
+	leaf->bytes[lbyte] |= lbit;
+	leaf->nvals += missing;
+	return missing;
+}
+
+static inline bool
+intset2_leafbuilder_is_member(IntsetLeafBuilder *leaf, uint64 v)
+{
+	uint16	bv;
+	uint8	lbyte, lbit;
+
+	bv = v % LEAF_BITS;
+	lbyte = LBYTE(bv);
+	lbit = LBIT(bv);
+
+	/* we shouldn't be here unless we set something */
+	Assert(leaf->nvals != 0);
+
+	if (lbyte < leaf->minbyte || lbyte > leaf->maxbyte)
+		return false;
+	lbyte -= leaf->minbyte;
+	return (leaf->bytes[lbyte] & lbit) != 0;
+}
+
+static uint8
+intset2_chunkbuilder_add(IntsetChunkBuilder *chunk, uint64 v)
+{
+	IntsetLeafBuilder *leafs = chunk->leafs;
+
+	Assert(CSTART(v) == chunk->chunk);
+	chunk->bitmap |= (bitmapword)1<<CPOS(v);
+	return intset2_leafbuilder_add(&leafs[CPOS(v)], v);
+}
+
+static bool
+intset2_chunkbuilder_is_member(IntsetChunkBuilder *chunk, uint64 v)
+{
+	IntsetLeafBuilder *leafs = chunk->leafs;
+
+	Assert(CSTART(v) == chunk->chunk);
+	if ((chunk->bitmap & ((bitmapword)1<<CPOS(v))) == 0)
+		return false;
+	return intset2_leafbuilder_is_member(&leafs[CPOS(v)], v);
+}
+
+static bool
+intset2_chunk_is_member(IntsetChunk *chunk, bitmapword bitmap, uint64 v)
+{
+	IntsetLeafHeader	h;
+
+	uint32	cpos;
+	bitmapword	cbit;
+	uint8	*buf;
+	uint32	bv;
+	uint8	root;
+	uint8	lbyte;
+	uint8	l1bm;
+	uint8	l1len;
+	uint8	l1pos;
+	uint8	lbit;
+	bool	found;
+	bool	inverse;
+
+	cpos = CPOS(v);
+	cbit = ONE << cpos;
+
+	if ((bitmap & cbit) == 0)
+		return false;
+	h = chunk[pg_popcountW(bitmap & (cbit-1))];
+
+	bv = v % LEAF_BITS;
+	if (h.e.type == LT_EMBED)
+		return bv == h.e.v0 || bv == h.e.v1 || bv == h.e.v2;
+
+	lbyte = LBYTE(bv);
+	lbit = LBIT(bv);
+	buf = (uint8*)(chunk + pg_popcountW(bitmap)) + h.b.offset;
+
+	if (lbyte < h.b.minbyte || lbyte > h.b.maxbyte)
+		return false;
+	lbyte -= h.b.minbyte;
+
+	if (h.b.type == LT_RAW)
+		return (buf[lbyte] & lbit) != 0;
+
+	inverse = h.b.type == LT_INVERSE;
+
+	/*
+	 * Bitmap is sparse, so we have to recalculate lbyte.
+	 * lbyte = popcount(bits in level1 up to lbyte)
+	 */
+	root = buf[0];
+	if ((root & (1<<(lbyte/8))) == 0)
+		return inverse;
+
+	/* Calculate position in sparse level1 index. */
+	l1pos = pg_popcount8_lowbits(root, lbyte/8);
+	l1bm = buf[1+l1pos];
+	if ((l1bm & (1<<(lbyte&7))) == 0)
+		return inverse;
+	/* Now we have to check bitmap byte itself */
+	/* Calculate length of sparse level1 index */
+	l1len = pg_popcount8(root);
+	/*
+	 * Corrected lbyte position is count of bits set in the level1 upto
+	 * our original position.
+	 */
+	lbyte = pg_popcount_small(buf+1, l1pos) +
+			pg_popcount8_lowbits(l1bm, lbyte&7);
+	found = (buf[1+l1len+lbyte] & lbit) != 0;
+	return found != inverse;
+}
+
+IntegerSet2*
+intset2_create(void)
+{
+	IntegerSet2 *intset = palloc0(sizeof(IntegerSet2));
+
+	intset2_trie_init(&intset->trie,
+			(trie_alloc)intset2_alloc,
+			&intset->alloc);
+
+	return intset;
+}
+
+void
+intset2_free(IntegerSet2 *intset)
+{
+	intset2_alloc_free(&intset->alloc);
+	pfree(intset);
+}
+
+void
+intset2_add_member(IntegerSet2 *intset, uint64 v)
+{
+	uint64 cstart;
+	if (intset->nvalues == 0)
+	{
+		uint8 add;
+
+		intset->firstvalue = CSTART(v);
+		v -= intset->firstvalue;
+		add = intset2_chunkbuilder_add(&intset->current, v);
+		Assert(add == 1);
+		intset->nvalues += add;
+		return;
+	}
+
+	v -= intset->firstvalue;
+	cstart = CSTART(v);
+	Assert(cstart >= intset->current.chunk);
+	if (cstart != intset->current.chunk)
+	{
+		intset2_compress_current(intset);
+		intset->current.chunk = cstart;
+	}
+
+	intset->nvalues += intset2_chunkbuilder_add(&intset->current, v);
+}
+
+bool
+intset2_is_member(IntegerSet2 *intset, uint64 v)
+{
+	IntsetTrieVal trieval;
+
+	if (intset->nvalues == 0)
+		return false;
+
+	if (v < intset->firstvalue)
+		return false;
+
+	v -= intset->firstvalue;
+
+	if (intset->current.chunk < CSTART(v))
+		return false;
+
+	if (intset->current.chunk == CSTART(v))
+		return intset2_chunkbuilder_is_member(&intset->current, v);
+
+	trieval = intset2_trie_lookup(&intset->trie, v>>CHUNK_SHIFT);
+	return intset2_chunk_is_member(trieval.val, trieval.bitmap, v);
+}
+
+uint64
+intset2_num_entries(IntegerSet2 *intset)
+{
+	return intset->nvalues;
+}
+
+uint64
+intset2_memory_usage(IntegerSet2 *intset)
+{
+	/* we are missing alloc->chunks here */
+	return sizeof(IntegerSet2) + intset->alloc.total_size;
+}
+
+static void
+intset2_compress_current(IntegerSet2 *intset)
+{
+	IntsetChunkBuilder *bld = &intset->current;
+	IntsetLeafBuilder *leaf;
+	uint32 nheaders = 0;
+	IntsetLeafHeader headers[BITS_PER_BITMAPWORD];
+	IntsetLeafHeader h = {.v = 0};
+	IntsetTrieVal    trieval = {0, NULL};
+	uint64  triekey;
+	uint32	hlen, totallen;
+	uint32	bufpos = 0;
+	uint32	i;
+	uint8	buffer[BITS_PER_BITMAPWORD * LEAF_BYTES];
+
+	for (i = 0; i < BITS_PER_BITMAPWORD; i++)
+	{
+		if ((bld->bitmap & (ONE<<i)) == 0)
+			continue;
+
+		leaf = &bld->leafs[i];
+		Assert(leaf->nvals != 0);
+
+		if (leaf->nvals < 3)
+		{
+			h.e.type = LT_EMBED;
+			/*
+			 * Header elements should be all filled because we doesn't store
+			 * their amount;
+			 * do the trick to fill possibly empty place
+			 * n = 1 => n/2 = 0, n-1 = 0
+			 * n = 2 => n/2 = 1, n-1 = 1
+			 * n = 3 => n/2 = 1, n-1 = 2
+			 */
+			h.e.v0 = leaf->embed[0];
+			h.e.v1 = leaf->embed[leaf->nvals/2];
+			h.e.v2 = leaf->embed[leaf->nvals-1];
+		}
+		else
+		{
+			/* root raw and root inverse */
+			uint8	rraw = 0,
+					rinv = 0;
+			/* level 1 index raw and index inverse */
+			uint8	raw[LEAF_BYTES/8] = {0},
+					inv[LEAF_BYTES/8] = {0};
+			/* zero count for raw map and inverse map */
+			uint8	cnt_00 = 0,
+					cnt_ff = 0;
+			uint8	mlen, llen;
+			uint8   splen, invlen, threshold;
+			uint8	b00, bff;
+			uint8  *buf;
+			int j;
+
+			h.b.minbyte = leaf->minbyte;
+			h.b.maxbyte = leaf->maxbyte;
+			h.b.offset = bufpos;
+
+			mlen = leaf->maxbyte+1 - leaf->minbyte;
+			for (j = 0; j < mlen; j++)
+			{
+				b00 = leaf->bytes[j] == 0;
+				bff = leaf->bytes[j] == 0xff;
+				cnt_00 += b00;
+				cnt_ff += bff;
+				raw[j/8] |= (1-b00) << (j&7);
+				inv[j/8] |= (1-bff) << (j&7);
+				Assert(j/64 == 0);
+				rraw |= (1-b00) << ((j/8)&7);
+				rinv |= (1-bff) << ((j/8)&7);
+			}
+
+			llen = (mlen-1)/8+1;
+			for (j = 0; j < llen; j++)
+			{
+				cnt_00 += raw[j] == 0;
+				cnt_ff += inv[j] == 0;
+			}
+
+			buf = buffer + bufpos;
+
+			splen = mlen + llen + 1 - cnt_00;
+			invlen = mlen + llen + 1 - cnt_ff;
+			threshold = mlen <= 4 ? 0 : /* don't compress */
+						mlen <= 8 ? mlen - 2 :
+									mlen * 3 / 4;
+
+			/* sparse map compresses well */
+			if (splen <= threshold && splen <= invlen)
+			{
+				h.b.type = LT_SPARSE;
+				*buf++ = rraw;
+				buf += intset2_compact(buf, raw, llen, false);
+				buf += intset2_compact(buf, leaf->bytes, mlen, false);
+			}
+			/* inverse sparse map compresses well */
+			else if (invlen <= threshold)
+			{
+				h.b.type = LT_INVERSE;
+				*buf++ = rinv;
+				buf += intset2_compact(buf, inv, llen, false);
+				buf += intset2_compact(buf, leaf->bytes, mlen, true);
+			}
+			/* fallback to raw type */
+			else
+			{
+				h.b.type = LT_RAW;
+				memmove(buf, leaf->bytes, mlen);
+				buf += mlen;
+			}
+
+			bufpos = buf - buffer;
+		}
+		headers[nheaders] = h;
+		nheaders++;
+	}
+
+	hlen = nheaders * sizeof(h);
+	totallen = hlen + bufpos;
+
+	trieval.bitmap = bld->bitmap;
+	trieval.val = intset2_alloc(totallen, &intset->alloc);
+	memmove(trieval.val, headers, hlen);
+	memmove((char*)trieval.val + hlen, buffer, bufpos);
+
+	triekey = bld->chunk >> CHUNK_SHIFT;
+	intset2_trie_insert(&intset->trie, triekey, trieval);
+
+	memset(&intset->current, 0, sizeof(intset->current));
+}
+
+#define EXPECT_TRUE(expr)	\
+	do { \
+		Assert(expr); \
+		if (!(expr)) \
+			elog(ERROR, \
+				 "%s was unexpectedly false in file \"%s\" line %u", \
+				 #expr, __FILE__, __LINE__); \
+	} while (0)
+
+#define EXPECT_FALSE(expr)	\
+	do { \
+		Assert(!(expr)); \
+		if (expr) \
+			elog(ERROR, \
+				 "%s was unexpectedly true in file \"%s\" line %u", \
+				 #expr, __FILE__, __LINE__); \
+	} while (0)
+
+#define EXPECT_EQ_U32(result_expr, expected_expr)	\
+	do { \
+		uint32		result = (result_expr); \
+		uint32		expected = (expected_expr); \
+		Assert(result == expected); \
+		if (result != expected) \
+			elog(ERROR, \
+				 "%s yielded %u, expected %s in file \"%s\" line %u", \
+				 #result_expr, result, #expected_expr, __FILE__, __LINE__); \
+	} while (0)
+
+static void
+intset2_test_1_off(uint64 off)
+{
+	IntegerSet2 *intset;
+	uint64 i, d, v;
+
+	intset = intset2_create();
+
+#define K 799
+
+	for (i = 0, d = 1; d < (ONE << (CHUNK_SHIFT + SHIFT + 1)); i+=(d=1+i/K))
+	{
+		v = i + off;
+		EXPECT_FALSE(intset2_is_member(intset, v));
+		EXPECT_FALSE(intset2_is_member(intset, v+1));
+		if (i != 0)
+		{
+			EXPECT_TRUE(intset2_is_member(intset, v-d));
+		}
+		if (d > 1)
+		{
+			EXPECT_FALSE(intset2_is_member(intset, v-1));
+			EXPECT_FALSE(intset2_is_member(intset, v-(d-1)));
+		}
+		intset2_add_member(intset, v);
+		EXPECT_TRUE(intset2_is_member(intset, v));
+		if (i != 0)
+		{
+			EXPECT_TRUE(intset2_is_member(intset, v-d));
+		}
+		if (d > 1)
+		{
+			EXPECT_FALSE(intset2_is_member(intset, v-1));
+			EXPECT_FALSE(intset2_is_member(intset, v-(d-1)));
+		}
+		EXPECT_FALSE(intset2_is_member(intset, v+1));
+	}
+
+	for (i = 0, d = 0; d < (1 << (CHUNK_SHIFT + SHIFT + 1)); i+=(d=1+i/K))
+	{
+		v = i + off;
+
+		EXPECT_TRUE(intset2_is_member(intset, v));
+		if (d != 0)
+		{
+			EXPECT_TRUE(intset2_is_member(intset, v-d));
+		}
+		if (d > 1)
+		{
+			EXPECT_FALSE(intset2_is_member(intset, v+1));
+			EXPECT_FALSE(intset2_is_member(intset, v-1));
+			EXPECT_FALSE(intset2_is_member(intset, v-(d-1)));
+		}
+	}
+
+	intset2_free(intset);
+}
+
+void
+intset2_test_1(void)
+{
+	intset2_test_1_off(0);
+	intset2_test_1_off(1001);
+	intset2_test_1_off(10000001);
+	intset2_test_1_off(100000000001);
+}
+
+/* Tools */
+
+static inline uint32
+intset2_compact(uint8 *dest, uint8 *src, uint8 len, bool inverse)
+{
+	uint32	i, j;
+	uint8	b;
+
+	for (i = j = 0; i < len; i++)
+	{
+		b = inverse ? ~src[i] : src[i];
+		dest[j] = b;
+		j += b != 0;
+	}
+
+	return j;
+}
+
+static const uint8 popcnt[256] = {
+	0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
+	1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+	1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+	2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+	1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+	2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+	2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+	3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+	1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+	2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+	2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+	3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+	2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+	3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+	3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+	4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
+};
+
+static inline uint8
+pg_popcount8(uint8 b)
+{
+	return popcnt[b];
+}
+
+static inline uint8
+pg_popcount8_lowbits(uint8 b, uint8 nbits)
+{
+	Assert(nbits < 8);
+	return popcnt[b&((1<<nbits)-1)];
+}
+
+static inline uint8
+pg_popcount_small(uint8 *b, uint8 len)
+{
+	uint8 r = 0;
+	switch (len&7)
+	{
+		case 7:	r += popcnt[b[6]]; /* fallthrough */
+		case 6:	r += popcnt[b[5]]; /* fallthrough */
+		case 5:	r += popcnt[b[4]]; /* fallthrough */
+		case 4:	r += popcnt[b[3]]; /* fallthrough */
+		case 3:	r += popcnt[b[2]]; /* fallthrough */
+		case 2:	r += popcnt[b[1]]; /* fallthrough */
+		case 1:	r += popcnt[b[0]]; /* fallthrough */
+	}
+	return r;
+}
+
diff --git a/bdbench/integerset2.h b/bdbench/integerset2.h
new file mode 100644
index 0000000..b987605
--- /dev/null
+++ b/bdbench/integerset2.h
@@ -0,0 +1,15 @@
+#ifndef INTEGERSET2_H
+#define INTEGERSET2_H
+
+typedef struct IntegerSet2 IntegerSet2;
+
+extern IntegerSet2 *intset2_create(void);
+extern void intset2_free(IntegerSet2 *intset);
+extern void intset2_add_member(IntegerSet2 *intset, uint64 x);
+extern bool intset2_is_member(IntegerSet2 *intset, uint64 x);
+
+extern uint64 intset2_num_entries(IntegerSet2 *intset);
+extern uint64 intset2_memory_usage(IntegerSet2 *intset);
+
+extern void intset2_test_1(void);
+#endif  /* INTEGERSET2_H */
-- 
2.32.0

diff --git a/src/backend/lib/Makefile b/src/backend/lib/Makefile
index 9dad31398a..fd002d594a 100644
--- a/src/backend/lib/Makefile
+++ b/src/backend/lib/Makefile
@@ -22,6 +22,9 @@ OBJS = \
 	integerset.o \
 	knapsack.o \
 	pairingheap.o \
+	radixtree.o \
 	rbtree.o \
 
+radixtree.o: CFLAGS+=-mavx2
+
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/lib/radixtree.c b/src/backend/lib/radixtree.c
new file mode 100644
index 0000000000..a5ad897ee9
--- /dev/null
+++ b/src/backend/lib/radixtree.c
@@ -0,0 +1,1377 @@
+/*-------------------------------------------------------------------------
+ *
+ * radixtree.c
+ *		Implementation for adaptive radix tree.
+ *
+ * This module is based on the paper "The Adaptive Radix Tree: ARTful Indexing
+ * for Main-Memory Databases" by Viktor Leis, Alfons Kemper, and Thomas Neumann,
+ * 2013.
+ *
+ * There are some difference from the proposed implementation.  For instance,
+ * this radix tree module utilize AVX2 instruction, enabling us to use 256-bit
+ * width SIMD vector, whereas 128-bit witdh SIMD vector is used in the paper.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/lib/radixtree.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "miscadmin.h"
+#include "port/pg_bitutils.h"
+#include "utils/memutils.h"
+#include "lib/radixtree.h"
+#include "lib/stringinfo.h"
+
+#if defined(__AVX2__)
+#include <immintrin.h> // x86 AVX2 intrinsics
+#endif
+
+/* How many bits are encoded in one tree level */
+#define RADIX_TREE_NODE_FANOUT	8
+
+#define RADIX_TREE_NODE_MAX_SLOTS (1 << RADIX_TREE_NODE_FANOUT)
+#define RADIX_TREE_NODE_MAX_SLOT_BITS \
+	(RADIX_TREE_NODE_MAX_SLOTS / (sizeof(uint8) * BITS_PER_BYTE))
+
+#define RADIX_TREE_CHUNK_MASK ((1 << RADIX_TREE_NODE_FANOUT) - 1)
+#define RADIX_TREE_MAX_SHIFT	key_get_shift(UINT64_MAX)
+#define RADIX_TREE_MAX_LEVEL	((sizeof(uint64) * BITS_PER_BYTE) / RADIX_TREE_NODE_FANOUT)
+
+#define GET_KEY_CHUNK(key, shift) \
+	((uint8) (((key) >> (shift)) & RADIX_TREE_CHUNK_MASK))
+
+typedef enum radix_tree_node_kind
+{
+	RADIX_TREE_NODE_KIND_4 = 0,
+	RADIX_TREE_NODE_KIND_32,
+	RADIX_TREE_NODE_KIND_128,
+	RADIX_TREE_NODE_KIND_256
+} radix_tree_node_kind;
+#define RADIX_TREE_NODE_KIND_COUNT 4
+
+/*
+ * Base type for all nodes types.
+ *
+ * The key is a 64-bit unsigned integer and the value is a Datum. The internal
+ * tree nodes, shift > 0, store the pointer to its child nodes as a Datum value.
+ * The leaf nodes, shift == 0, stores the value that the user specified as a Datum
+ * value.
+ */
+typedef struct radix_tree_node
+{
+	/*
+	 * Number of children.  We use uint16 to be able to indicate 256 children
+	 * at fanout of 8.
+	 */
+	uint16	count;
+
+	/*
+	 * Shift indicates which part of the key space is represented by this node.
+	 * That is, the key is shifted by 'shift' and the lowest RADIX_TREE_NODE_FANOUT
+	 * bits are then represented in chunk.
+	 */
+	uint8	shift;
+	uint8	chunk;
+
+	/* Size class of the node */
+	radix_tree_node_kind	kind;
+} radix_tree_node;
+#define NodeIsLeaf(n) (((radix_tree_node *) (n))->shift == 0)
+#define NodeHasFreeSlot(n) \
+	(((radix_tree_node *) (n))->count < \
+	 radix_tree_node_info[((radix_tree_node *) (n))->kind].max_slots)
+
+/*
+ * To reduce memory usage compared to a simple radix tree with a fixed fanout
+ * we use adaptive node sides, with different storage methods for different
+ * numbers of elements.
+ */
+typedef struct radix_tree_node_4
+{
+	radix_tree_node n;
+
+	/* 4 children, for key chunks */
+	uint8	chunks[4];
+	Datum	slots[4];
+} radix_tree_node_4;
+
+typedef struct radix_tree_node_32
+{
+	radix_tree_node n;
+
+	/* 32 children, for key chunks */
+	uint8	chunks[32];
+	Datum slots[32];
+} radix_tree_node_32;
+
+typedef struct radix_tree_node_128
+{
+	radix_tree_node n;
+
+	/*
+	 * The index of slots for each fanout. 0 means unused whereas slots is
+	 * 0-indexed. So we can get the slots of the chunk C by slots[C - 1].
+	 */
+	uint8	slot_idxs[RADIX_TREE_NODE_MAX_SLOTS];
+
+	Datum	slots[128];
+} radix_tree_node_128;
+
+typedef struct radix_tree_node_256
+{
+	radix_tree_node n;
+
+	/* A bitmap to track which slot is in use */
+	uint8	set[RADIX_TREE_NODE_MAX_SLOT_BITS];
+
+	Datum	slots[RADIX_TREE_NODE_MAX_SLOTS];
+} radix_tree_node_256;
+#define RADIX_TREE_NODE_256_SET_BYTE(v) ((v) / RADIX_TREE_NODE_FANOUT)
+#define RADIX_TREE_NODE_256_SET_BIT(v) (UINT64_C(1) << ((v) % RADIX_TREE_NODE_FANOUT))
+
+/* Information of each size class */
+typedef struct radix_tree_node_info_elem
+{
+	const char *name;
+	int		max_slots;
+	Size	size;
+} radix_tree_node_info_elem;
+
+static radix_tree_node_info_elem radix_tree_node_info[] =
+{
+	{"radix tree node 4", 4, sizeof(radix_tree_node_4)},
+	{"radix tree node 32", 32, sizeof(radix_tree_node_32)},
+	{"radix tree node 128", 128, sizeof(radix_tree_node_128)},
+	{"radix tree node 256", 256, sizeof(radix_tree_node_256)},
+};
+
+/*
+ * Iteration support.
+ *
+ * Iterating the radix tree returns each pair of key and value in the ascending order
+ * of the key.  To support this, the we iterate nodes of each level.
+ * radix_tree_iter_node_data struct is used to track the iteration within a node.
+ * radix_tree_iter has the array of this struct, stack, in order to track the iteration
+ * of every level.  During the iteration, we also construct the key to return. The key
+ * is updated whenever we update the node iteration information, e.g., when advancing
+ * the current index within the node or when moving to the next node at the same level.
+ */
+typedef struct radix_tree_iter_node_data
+{
+	radix_tree_node *node;	/* current node being iterated */
+	int	current_idx;		/* current position. -1 for initial value */
+} radix_tree_iter_node_data;
+
+struct radix_tree_iter
+{
+	radix_tree *tree;
+
+	/* Track the iteration on nodes of each level */
+	radix_tree_iter_node_data stack[RADIX_TREE_MAX_LEVEL];
+	int	stack_len;
+
+	/* The key is being constructed during the iteration */
+	uint64	key;
+};
+
+/* A radix tree with nodes */
+struct radix_tree
+{
+	MemoryContext context;
+
+	radix_tree_node	*root;
+	uint64	max_val;
+	uint64	num_keys;
+	MemoryContextData *slabs[RADIX_TREE_NODE_KIND_COUNT];
+
+	/* stats */
+	uint64	mem_used;
+	int32	cnt[RADIX_TREE_NODE_KIND_COUNT];
+};
+
+static radix_tree_node *radix_tree_node_grow(radix_tree *tree, radix_tree_node *parent, radix_tree_node *node);
+static radix_tree_node *radix_tree_find_child(radix_tree_node *node, uint64 key);
+static Datum *radix_tree_find_slot_ptr(radix_tree_node *node, uint8 chunk);
+static void radix_tree_replace_slot(radix_tree_node *parent, radix_tree_node *node,
+									uint8 chunk);
+static void radix_tree_extend(radix_tree *tree, uint64 key);
+static void radix_tree_new_root(radix_tree *tree, uint64 key, Datum val);
+static radix_tree_node *radix_tree_insert_child(radix_tree *tree, radix_tree_node *parent, radix_tree_node *node,
+												uint64 key);
+static void radix_tree_insert_val(radix_tree *tree, radix_tree_node *parent, radix_tree_node *node,
+								  uint64 key, Datum val, bool *replaced_p);
+
+static inline void radix_tree_iter_update_key(radix_tree_iter *iter, uint8 chunk, uint8 shift);
+static Datum radix_tree_node_iterate_next(radix_tree_iter *iter, radix_tree_iter_node_data *node_iter,
+										  bool *found_p);
+static void radix_tree_store_iter_node(radix_tree_iter *iter, radix_tree_iter_node_data *node_iter,
+									   radix_tree_node *node);
+static void radix_tree_update_iter_stack(radix_tree_iter *iter, int from);
+
+static inline int
+node_32_search_eq(radix_tree_node_32 *node, uint8 chunk)
+{
+#ifdef __AVX2__
+	__m256i	_key = _mm256_set1_epi8(chunk);
+	__m256i _data = _mm256_loadu_si256((__m256i_u *) node->chunks);
+	__m256i _cmp = _mm256_cmpeq_epi8(_key, _data);
+	uint32	bitfield = _mm256_movemask_epi8(_cmp);
+
+	bitfield &= ((UINT64_C(1) << node->n.count) - 1);
+
+	return (bitfield) ? __builtin_ctz(bitfield) : -1;
+
+#else
+	for (int i = 0; i < node->n.count; i++)
+	{
+		if (node->chunks[i] > chunk)
+			return -1;
+
+		if (node->chunks[i] == chunk)
+			return i;
+	}
+
+	return -1;
+#endif	/* __AVX2__ */
+}
+
+/*
+ * This is a bit more complicated than search_chunk_array_16_eq(), because
+ * until recently no unsigned uint8 comparison instruction existed on x86. So
+ * we need to play some trickery using _mm_min_epu8() to effectively get
+ * <=. There never will be any equal elements in the current uses, but that's
+ * what we get here...
+ */
+static inline int
+node_32_search_le(radix_tree_node_32 *node, uint8 chunk)
+{
+#ifdef __AVX2__
+	__m256i _key = _mm256_set1_epi8(chunk);
+	__m256i _data = _mm256_loadu_si256((__m256i_u*) node->chunks);
+	__m256i _min = _mm256_min_epu8(_key, _data);
+	__m256i cmp = _mm256_cmpeq_epi8(_key, _min);
+	uint32_t bitfield=_mm256_movemask_epi8(cmp);
+
+	bitfield &= ((UINT64_C(1) << node->n.count) - 1);
+
+	return (bitfield) ? __builtin_ctz(bitfield) : node->n.count;
+#else
+	int index;
+
+	for (index = 0; index < node->n.count; index++)
+	{
+		if (node->chunks[index] >= chunk)
+			break;
+	}
+
+	return index;
+#endif	/* __AVX2__ */
+}
+
+static inline int
+node_128_get_slot_pos(radix_tree_node_128 *node, uint8 chunk)
+{
+	return node->slot_idxs[chunk] - 1;
+}
+
+static inline bool
+node_128_is_slot_used(radix_tree_node_128 *node, uint8 chunk)
+{
+	return (node_128_get_slot_pos(node, chunk) >= 0);
+}
+
+/* Return true if the slot corresponding to the given chunk is in use */
+static inline bool
+node_256_is_slot_used(radix_tree_node_256 *node, uint8 chunk)
+{
+	return (node->set[RADIX_TREE_NODE_256_SET_BYTE(chunk)] &
+			RADIX_TREE_NODE_256_SET_BIT(chunk)) != 0;
+
+}
+
+/* Set the slot at the given chunk position */
+static inline void
+node_256_set(radix_tree_node_256 *node, uint8 chunk, Datum slot)
+{
+	node->slots[chunk] = slot;
+	node->set[RADIX_TREE_NODE_256_SET_BYTE(chunk)] |= RADIX_TREE_NODE_256_SET_BIT(chunk);
+}
+
+/* Return the shift that is satisfied to store the given key */
+inline static int
+key_get_shift(uint64 key)
+{
+	return (key == 0)
+		? 0
+		: (pg_leftmost_one_pos64(key) / RADIX_TREE_NODE_FANOUT) * RADIX_TREE_NODE_FANOUT;
+}
+
+/* Return the max value stored in a node with the given shift */
+static uint64
+shift_get_max_val(int shift)
+{
+	if (shift == RADIX_TREE_MAX_SHIFT)
+		return UINT64_MAX;
+
+	return (UINT64_C(1) << (shift + RADIX_TREE_NODE_FANOUT)) - 1;
+}
+
+/* Allocate a new node with the given node kind */
+static radix_tree_node *
+radix_tree_alloc_node(radix_tree *tree, radix_tree_node_kind kind)
+{
+	radix_tree_node *newnode;
+
+	newnode = (radix_tree_node *) MemoryContextAllocZero(tree->slabs[kind],
+														 radix_tree_node_info[kind].size);
+	newnode->kind = kind;
+
+	/* update stats */
+	tree->mem_used += GetMemoryChunkSpace(newnode);
+	tree->cnt[kind]++;
+
+	return newnode;
+}
+
+/* Free the given node */
+static void
+radix_tree_free_node(radix_tree *tree, radix_tree_node *node)
+{
+	/* update stats */
+	tree->mem_used -= GetMemoryChunkSpace(node);
+	tree->cnt[node->kind]--;
+
+	pfree(node);
+}
+
+/* Copy the common fields without the node kind */
+static void
+radix_tree_copy_node_common(radix_tree_node *src, radix_tree_node *dst)
+{
+	dst->shift = src->shift;
+	dst->chunk = src->chunk;
+	dst->count = src->count;
+}
+
+/* The tree doesn't have not sufficient height, so grow it */
+static void
+radix_tree_extend(radix_tree *tree, uint64 key)
+{
+	int max_shift;
+	int shift = tree->root->shift + RADIX_TREE_NODE_FANOUT;
+
+	max_shift = key_get_shift(key);
+
+	/* Grow tree from 'shift' to 'max_shift' */
+	while (shift <= max_shift)
+	{
+		radix_tree_node_4 *node =
+			(radix_tree_node_4 *) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_4);
+
+		node->n.count = 1;
+		node->n.shift = shift;
+		node->chunks[0] = 0;
+		node->slots[0] = PointerGetDatum(tree->root);
+
+		tree->root->chunk = 0;
+		tree->root = (radix_tree_node *) node;
+
+		shift += RADIX_TREE_NODE_FANOUT;
+	}
+
+	tree->max_val = shift_get_max_val(max_shift);
+}
+
+/*
+ * Return the pointer to the child node corresponding with the key. Otherwise (if
+ * not found) return NULL.
+ */
+static radix_tree_node *
+radix_tree_find_child(radix_tree_node *node, uint64 key)
+{
+	Datum *slot_ptr;
+	int chunk = GET_KEY_CHUNK(key, node->shift);
+
+	slot_ptr = radix_tree_find_slot_ptr(node, chunk);
+
+	return (slot_ptr == NULL) ? NULL : (radix_tree_node *) DatumGetPointer(*slot_ptr);
+}
+
+/*
+ * Return the address of the slot corresponding to chunk in the node, if found.
+ * Otherwise return NULL.
+ */
+static Datum *
+radix_tree_find_slot_ptr(radix_tree_node *node, uint8 chunk)
+{
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+		{
+			radix_tree_node_4 *n4 = (radix_tree_node_4 *) node;
+
+			/* Do linear search */
+			for (int i = 0; i < n4->n.count; i++)
+			{
+				if (n4->chunks[i] > chunk)
+					break;
+
+				if (n4->chunks[i] == chunk)
+					return &(n4->slots[i]);
+			}
+
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_32:
+		{
+			radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+			int ret;
+
+			/* Search by SIMD instructions */
+			ret = node_32_search_eq(n32, chunk);
+
+			if (ret < 0)
+				break;
+
+			return &(n32->slots[ret]);
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_128:
+		{
+			radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+
+			if (!node_128_is_slot_used(n128, chunk))
+				break;
+
+			return &(n128->slots[node_128_get_slot_pos(n128, chunk)]);
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_256:
+		{
+			radix_tree_node_256 *n256 = (radix_tree_node_256 *) node;
+
+			if (!node_256_is_slot_used(n256, chunk))
+				break;
+
+			return &(n256->slots[chunk]);
+			break;
+		}
+	}
+
+	return NULL;
+}
+
+/* Link from the parent to the node */
+static void
+radix_tree_replace_slot(radix_tree_node *parent, radix_tree_node *node, uint8 chunk)
+{
+	Datum *slot_ptr;
+
+	slot_ptr = radix_tree_find_slot_ptr(parent, chunk);
+	*slot_ptr = PointerGetDatum(node);
+}
+
+/*
+ * Create a new node as the root. Subordinate nodes will be created during
+ * the insertion.
+ */
+static void
+radix_tree_new_root(radix_tree *tree, uint64 key, Datum val)
+{
+	radix_tree_node_4 * n4 =
+		(radix_tree_node_4 * ) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_4);
+	int shift = key_get_shift(key);
+
+	n4->n.shift = shift;
+	tree->max_val = shift_get_max_val(shift);
+	tree->root = (radix_tree_node *) n4;
+}
+
+/* Insert 'node' as a child node of 'parent' */
+static radix_tree_node *
+radix_tree_insert_child(radix_tree *tree, radix_tree_node *parent, radix_tree_node *node,
+						uint64 key)
+{
+	radix_tree_node *newchild =
+		(radix_tree_node *) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_4);
+
+	Assert(!NodeIsLeaf(node));
+
+	newchild->shift = node->shift - RADIX_TREE_NODE_FANOUT;
+	newchild->chunk = GET_KEY_CHUNK(key, node->shift);
+
+	radix_tree_insert_val(tree, parent, node, key, PointerGetDatum(newchild), NULL);
+
+	return (radix_tree_node *) newchild;
+}
+
+/*
+ * Insert the value to the node. The node grows if it's full.
+ *
+ * *replaced_p is set to true if the key already exists and its value is updated
+ * by this function.
+ */
+static void
+radix_tree_insert_val(radix_tree *tree, radix_tree_node *parent, radix_tree_node *node,
+					  uint64 key, Datum val, bool *replaced_p)
+{
+	int chunk = GET_KEY_CHUNK(key, node->shift);
+	bool replaced = false;
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+		{
+			radix_tree_node_4 *n4 = (radix_tree_node_4 *) node;
+			int idx;
+
+			for (idx = 0; idx < n4->n.count; idx++)
+			{
+				if (n4->chunks[idx] >= chunk)
+					break;
+			}
+
+			if (NodeHasFreeSlot(n4))
+			{
+				if (n4->n.count == 0)
+				{
+					/* the first key for this node, add it */
+				}
+				else if (n4->chunks[idx] == chunk)
+				{
+					/* found the key, replace it */
+					replaced = true;
+				}
+				else if (idx != n4->n.count)
+				{
+					/*
+					 * the key needs to be inserted in the middle of the array,
+					 * make space for the new key.
+					 */
+					memmove(&(n4->chunks[idx + 1]), &(n4->chunks[idx]),
+							sizeof(uint8) * (n4->n.count - idx));
+					memmove(&(n4->slots[idx + 1]), &(n4->slots[idx]),
+							sizeof(radix_tree_node *) * (n4->n.count - idx));
+				}
+
+				n4->chunks[idx] = chunk;
+				n4->slots[idx] = val;
+
+				/* Done */
+				break;
+			}
+
+			/* The node needs to grow */
+			node = radix_tree_node_grow(tree, parent, node);
+			Assert(node->kind == RADIX_TREE_NODE_KIND_32);
+		}
+		/* FALLTHROUGH */
+		case RADIX_TREE_NODE_KIND_32:
+		{
+			radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+			int idx;
+
+			idx = node_32_search_le(n32, chunk);
+
+			if (NodeHasFreeSlot(n32))
+			{
+				if (n32->n.count == 0)
+				{
+					/* first key for this node, add it */
+				}
+				else if (n32->chunks[idx] == chunk)
+				{
+					/* found the key, replace it */
+					replaced = true;
+				}
+				else if (idx != n32->n.count)
+				{
+					/*
+					 * the key needs to be inserted in the middle of the array,
+					 * make space for the new key.
+					 */
+					memmove(&(n32->chunks[idx + 1]), &(n32->chunks[idx]),
+							sizeof(uint8) * (n32->n.count - idx));
+					memmove(&(n32->slots[idx + 1]), &(n32->slots[idx]),
+							sizeof(radix_tree_node *) * (n32->n.count - idx));
+				}
+
+				n32->chunks[idx] = chunk;
+				n32->slots[idx] = val;
+				break;
+			}
+
+			/* The node needs to grow */
+			node = radix_tree_node_grow(tree, parent, node);
+			Assert(node->kind == RADIX_TREE_NODE_KIND_128);
+		}
+		/* FALLTHROUGH */
+		case RADIX_TREE_NODE_KIND_128:
+		{
+			radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+
+			if (node_128_is_slot_used(n128, chunk))
+			{
+				n128->slots[node_128_get_slot_pos(n128, chunk)] = val;
+				replaced = true;
+				break;
+			}
+
+			if (NodeHasFreeSlot(n128))
+			{
+				uint8 pos = n128->n.count + 1;
+
+				n128->slot_idxs[chunk] = pos;
+				n128->slots[pos - 1] = val;
+				break;
+			}
+
+			node = radix_tree_node_grow(tree, parent, node);
+			Assert(node->kind == RADIX_TREE_NODE_KIND_256);
+		}
+		/* FALLTHROUGH */
+		case RADIX_TREE_NODE_KIND_256:
+		{
+			radix_tree_node_256 *n256 = (radix_tree_node_256 *) node;
+
+			if (node_256_is_slot_used(n256, chunk))
+				replaced = true;
+
+			node_256_set(n256, chunk, val);
+			break;
+		}
+	}
+
+	if (!replaced)
+		node->count++;
+
+	if (replaced_p)
+		*replaced_p = replaced;
+}
+
+/* Change the node type to a larger one */
+static radix_tree_node *
+radix_tree_node_grow(radix_tree *tree, radix_tree_node *parent, radix_tree_node *node)
+{
+	radix_tree_node *newnode = NULL;
+
+	Assert(node->count ==
+		   radix_tree_node_info[node->kind].max_slots);
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+		{
+			radix_tree_node_4 *n4 = (radix_tree_node_4 *) node;
+			radix_tree_node_32 *new32 =
+				(radix_tree_node_32 *) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_32);
+
+			radix_tree_copy_node_common((radix_tree_node *) n4,
+										(radix_tree_node *) new32);
+
+			memcpy(&(new32->chunks), &(n4->chunks), sizeof(uint8) * 4);
+			memcpy(&(new32->slots), &(n4->slots), sizeof(Datum) * 4);
+
+			newnode = (radix_tree_node *) new32;
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_32:
+		{
+			radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+			radix_tree_node_128 *new128 =
+				(radix_tree_node_128 *) radix_tree_alloc_node(tree,RADIX_TREE_NODE_KIND_128);
+
+			radix_tree_copy_node_common((radix_tree_node *) n32,
+										(radix_tree_node *) new128);
+
+			for (int i = 0; i < n32->n.count; i++)
+			{
+				new128->slot_idxs[n32->chunks[i]] = i + 1;
+				new128->slots[i] = n32->slots[i];
+			}
+
+			newnode = (radix_tree_node *) new128;
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_128:
+		{
+			radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+			radix_tree_node_256 *new256 =
+				(radix_tree_node_256 *) radix_tree_alloc_node(tree,RADIX_TREE_NODE_KIND_256);
+			int cnt = 0;
+
+			radix_tree_copy_node_common((radix_tree_node *) n128,
+										(radix_tree_node *) new256);
+
+			for (int i = 0; i < RADIX_TREE_NODE_MAX_SLOTS && cnt < n128->n.count; i++)
+			{
+				if (!node_128_is_slot_used(n128, i))
+					continue;
+
+				node_256_set(new256, i, n128->slots[node_128_get_slot_pos(n128, i)]);
+				cnt++;
+			}
+
+			newnode = (radix_tree_node *) new256;
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_256:
+			elog(ERROR, "radix tree node_256 cannot grow");
+			break;
+	}
+
+	/* Replace the old node with the new one */
+	if (parent == node)
+		tree->root = newnode;
+	else
+		radix_tree_replace_slot(parent, newnode, node->chunk);
+
+	/* Free the old node */
+	radix_tree_free_node(tree, node);
+
+	return newnode;
+}
+
+/* Create the radix tree in the given memory context */
+radix_tree *
+radix_tree_create(MemoryContext ctx)
+{
+	radix_tree *tree;
+	MemoryContext old_ctx;
+
+	old_ctx = MemoryContextSwitchTo(ctx);
+
+	tree = palloc(sizeof(radix_tree));
+	tree->max_val = 0;
+	tree->root = NULL;
+	tree->context = ctx;
+	tree->num_keys = 0;
+	tree->mem_used = 0;
+
+	/* Create the slab allocator for each size class */
+	for (int i = 0; i < RADIX_TREE_NODE_KIND_COUNT; i++)
+	{
+		tree->slabs[i] = SlabContextCreate(ctx,
+										   radix_tree_node_info[i].name,
+										   SLAB_DEFAULT_BLOCK_SIZE,
+										   radix_tree_node_info[i].size);
+		tree->cnt[i] = 0;
+	}
+
+	MemoryContextSwitchTo(old_ctx);
+
+	return tree;
+}
+
+void
+radix_tree_destroy(radix_tree *tree)
+{
+	for (int i = 0; i < RADIX_TREE_NODE_KIND_COUNT; i++)
+		MemoryContextDelete(tree->slabs[i]);
+
+	pfree(tree);
+}
+
+/*
+ * Insert the key with the val.
+ *
+ * found_p is set to true if the key already present, otherwise false, if
+ * it's not NULL.
+ *
+ * XXX: consider a better API. Is it better to support like 'update' flag
+ * instead of 'found_p' so the user can asks to update the value if already
+ * exists?
+ */
+void
+radix_tree_insert(radix_tree *tree, uint64 key, Datum val, bool *found_p)
+{
+	int shift;
+	bool	replaced;
+	radix_tree_node *node;
+	radix_tree_node *parent = tree->root;
+
+	/* Empty tree, create the root */
+	if (!tree->root)
+		radix_tree_new_root(tree, key, val);
+
+	/* Extend the tree if necessary */
+	if (key > tree->max_val)
+		radix_tree_extend(tree, key);
+
+	Assert(tree->root);
+
+	shift = tree->root->shift;
+	node = tree->root;
+	while (shift > 0)
+	{
+		radix_tree_node *child;
+
+		child = radix_tree_find_child(node, key);
+
+		if (child == NULL)
+			child = radix_tree_insert_child(tree, parent, node, key);
+
+		parent = node;
+		node = child;
+		shift -= RADIX_TREE_NODE_FANOUT;
+	}
+
+	/* arrived at a leaf, so insert the value */
+	Assert(NodeIsLeaf(node));
+	radix_tree_insert_val(tree, parent, node, key, val, &replaced);
+
+	if (!replaced)
+		tree->num_keys++;
+
+	if (found_p)
+		*found_p = replaced;
+}
+
+/*
+ * Return the Datum value of the given key.
+ *
+ * found_p is set to true if it's found, otherwise false.
+ */
+Datum
+radix_tree_search(radix_tree *tree, uint64 key, bool *found_p)
+{
+	radix_tree_node *node;
+	int shift;
+
+	if (!tree->root || key > tree->max_val)
+		goto not_found;
+
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift >= 0)
+	{
+		radix_tree_node *child;
+
+		if (NodeIsLeaf(node))
+		{
+			Datum *slot_ptr;
+			int chunk = GET_KEY_CHUNK(key, node->shift);
+
+			/* We reached at a leaf node, find the corresponding slot */
+			slot_ptr = radix_tree_find_slot_ptr(node, chunk);
+
+			if (slot_ptr == NULL)
+				goto not_found;
+
+			/* Found! */
+			*found_p = true;
+			return *slot_ptr;
+		}
+
+		child = radix_tree_find_child(node, key);
+
+		if (child == NULL)
+			goto not_found;
+
+		node = child;
+		shift -= RADIX_TREE_NODE_FANOUT;
+	}
+
+not_found:
+	*found_p = false;
+	return (Datum) 0;
+}
+
+/* Create and return the iterator for the given radix tree */
+radix_tree_iter *
+radix_tree_begin_iterate(radix_tree *tree)
+{
+	MemoryContext old_ctx;
+	radix_tree_iter *iter;
+	int top_level;
+
+	old_ctx = MemoryContextSwitchTo(tree->context);
+
+	iter = (radix_tree_iter *) palloc0(sizeof(radix_tree_iter));
+	iter->tree = tree;
+
+	/* empty tree */
+	if (!iter->tree)
+		return iter;
+
+	top_level = iter->tree->root->shift / RADIX_TREE_NODE_FANOUT;
+
+	iter->stack_len = top_level;
+	iter->stack[top_level].node = iter->tree->root;
+	iter->stack[top_level].current_idx = -1;
+
+	/* Descend to the left most leaf node from the root */
+	radix_tree_update_iter_stack(iter, top_level);
+
+	MemoryContextSwitchTo(old_ctx);
+
+	return iter;
+}
+
+/*
+ * Return true with setting key_p and value_p if there is next key.  Otherwise,
+ * return false.
+ */
+bool
+radix_tree_iterate_next(radix_tree_iter *iter, uint64 *key_p, Datum *value_p)
+{
+	bool found = false;
+	Datum slot = (Datum) 0;
+	int level;
+
+	/* Empty tree */
+	if (!iter->tree)
+		return false;
+
+	for (;;)
+	{
+		radix_tree_node *node;
+		radix_tree_iter_node_data *node_iter;
+
+		/*
+		 * Iterate node at each level from the bottom of the tree until we find
+		 * the next slot.
+		 */
+		for (level = 0; level <= iter->stack_len; level++)
+		{
+			slot = radix_tree_node_iterate_next(iter, &(iter->stack[level]), &found);
+
+			if (found)
+				break;
+		}
+
+		/* end of iteration */
+		if (!found)
+			return false;
+
+		/* found the next slot at the leaf node, return it */
+		if (level == 0)
+		{
+			*key_p = iter->key;
+			*value_p = slot;
+			return true;
+		}
+
+		/*
+		 * We have advanced more than one nodes including internal nodes. So we need
+		 * to update the stack by descending to the left most leaf node from this level.
+		 */
+		node = (radix_tree_node *) DatumGetPointer(slot);
+		node_iter = &(iter->stack[level - 1]);
+		radix_tree_store_iter_node(iter, node_iter, node);
+
+		radix_tree_update_iter_stack(iter, level - 1);
+	}
+}
+
+void
+radix_tree_end_iterate(radix_tree_iter *iter)
+{
+	pfree(iter);
+}
+
+/*
+ * Update the part of the key being constructed during the iteration with the
+ * given chunk
+ */
+static inline void
+radix_tree_iter_update_key(radix_tree_iter *iter, uint8 chunk, uint8 shift)
+{
+	iter->key &= ~(((uint64) RADIX_TREE_CHUNK_MASK) << shift);
+	iter->key |= (((uint64) chunk) << shift);
+}
+
+/*
+ * Iterate over the given radix tree node and returns the next slot of the given
+ * node and set true to *found_p, if any.  Otherwise, set false to *found_p.
+ */
+static Datum
+radix_tree_node_iterate_next(radix_tree_iter *iter, radix_tree_iter_node_data *node_iter,
+							 bool *found_p)
+{
+	radix_tree_node *node = node_iter->node;
+	Datum slot = (Datum) 0;
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+		{
+			radix_tree_node_4 *n4 = (radix_tree_node_4 *) node_iter->node;
+
+			node_iter->current_idx++;
+
+			if (node_iter->current_idx >= n4->n.count)
+				goto not_found;
+
+			slot = n4->slots[node_iter->current_idx];
+
+			/* Update the part of the key with the current chunk */
+			if (NodeIsLeaf(node))
+				radix_tree_iter_update_key(iter, n4->chunks[node_iter->current_idx], 0);
+
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_32:
+		{
+			radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+
+			node_iter->current_idx++;
+
+			if (node_iter->current_idx >= n32->n.count)
+				goto not_found;
+
+			slot = n32->slots[node_iter->current_idx];
+
+			/* Update the part of the key with the current chunk */
+			if (NodeIsLeaf(node))
+				radix_tree_iter_update_key(iter, n32->chunks[node_iter->current_idx], 0);
+
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_128:
+		{
+			radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+			int i;
+
+			for (i = node_iter->current_idx + 1; i < RADIX_TREE_NODE_MAX_SLOTS; i++)
+			{
+				if (node_128_is_slot_used(n128, i))
+					break;
+			}
+
+			if (i >= RADIX_TREE_NODE_MAX_SLOTS)
+				goto not_found;
+
+			node_iter->current_idx = i;
+			slot = n128->slots[node_128_get_slot_pos(n128, i)];
+
+			/* Update the part of the key */
+			if (NodeIsLeaf(node))
+				radix_tree_iter_update_key(iter, node_iter->current_idx, 0);
+
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_256:
+		{
+			radix_tree_node_256 *n256 = (radix_tree_node_256 *) node;
+			int i;
+
+			for (i = node_iter->current_idx + 1; i < RADIX_TREE_NODE_MAX_SLOTS; i++)
+			{
+				if (node_256_is_slot_used(n256, i))
+					break;
+			}
+
+			if (i >= RADIX_TREE_NODE_MAX_SLOTS)
+				goto not_found;
+
+			node_iter->current_idx = i;
+			slot = n256->slots[i];
+
+			/* Update the part of the key */
+			if (NodeIsLeaf(node))
+				radix_tree_iter_update_key(iter, node_iter->current_idx, 0);
+
+			break;
+		}
+	}
+
+	*found_p = true;
+	return slot;
+
+not_found:
+	*found_p = false;
+	return (Datum) 0;
+}
+
+/*
+ * Initialize and update the node iteration struct with the given radix tree node.
+ * This function also updates the part of the key with the chunk of the given node.
+ */
+static void
+radix_tree_store_iter_node(radix_tree_iter *iter, radix_tree_iter_node_data *node_iter,
+						   radix_tree_node *node)
+{
+	node_iter->node = node;
+	node_iter->current_idx = -1;
+
+	radix_tree_iter_update_key(iter, node->chunk, node->shift + RADIX_TREE_NODE_FANOUT);
+}
+
+/*
+ * Build the stack of the radix tree node while descending to the leaf from the 'from'
+ * level.
+ */
+static void
+radix_tree_update_iter_stack(radix_tree_iter *iter, int from)
+{
+	radix_tree_node *node = iter->stack[from].node;
+	int level = from;
+
+	for (;;)
+	{
+		radix_tree_iter_node_data *node_iter = &(iter->stack[level--]);
+		bool found;
+
+		/* Set the current node */
+		radix_tree_store_iter_node(iter, node_iter, node);
+
+		if (NodeIsLeaf(node))
+			break;
+
+		node = (radix_tree_node *)
+			DatumGetPointer(radix_tree_node_iterate_next(iter, node_iter, &found));
+
+		/*
+		 * Since we always get the first slot in the node, we have to found
+		 * the slot.
+		 */
+		Assert(found);
+	}
+}
+
+uint64
+radix_tree_num_entries(radix_tree *tree)
+{
+	return tree->num_keys;
+}
+
+uint64
+radix_tree_memory_usage(radix_tree *tree)
+{
+	return tree->mem_used;
+}
+
+/***************** DEBUG FUNCTIONS *****************/
+#ifdef RADIX_TREE_DEBUG
+void
+radix_tree_stats(radix_tree *tree)
+{
+	fprintf(stderr, "num_keys = %lu, height = %u, n4 = %u(%lu), n32 = %u(%lu), n128 = %u(%lu), n256 = %u(%lu)",
+			tree->num_keys,
+			tree->root->shift / RADIX_TREE_NODE_FANOUT,
+			tree->cnt[0], tree->cnt[0] * sizeof(radix_tree_node_4),
+			tree->cnt[1], tree->cnt[1] * sizeof(radix_tree_node_32),
+			tree->cnt[2], tree->cnt[2] * sizeof(radix_tree_node_128),
+			tree->cnt[3], tree->cnt[3] * sizeof(radix_tree_node_256));
+	//radix_tree_dump(tree);
+}
+
+static void
+radix_tree_print_slot(StringInfo buf, uint8 chunk, Datum slot, int idx, bool is_leaf, int level)
+{
+	char space[128] = {0};
+
+	if (level > 0)
+		sprintf(space, "%*c", level * 4, ' ');
+
+	if (is_leaf)
+		appendStringInfo(buf, "%s[%d] \"0x%X\" val(0x%lX) LEAF\n",
+						 space,
+						 idx,
+						 chunk,
+						 DatumGetInt64(slot));
+	else
+		appendStringInfo(buf , "%s[%d] \"0x%X\" -> ",
+						 space,
+						 idx,
+						 chunk);
+}
+
+static void
+radix_tree_dump_node(radix_tree_node *node, int level, StringInfo buf, bool recurse)
+{
+	bool is_leaf = NodeIsLeaf(node);
+
+	appendStringInfo(buf, "[\"%s\" type %d, cnt %u, shift %u, chunk \"0x%X\"] chunks:\n",
+					 NodeIsLeaf(node) ? "LEAF" : "INNR",
+					 (node->kind == RADIX_TREE_NODE_KIND_4) ? 4 :
+					 (node->kind == RADIX_TREE_NODE_KIND_32) ? 32 :
+					 (node->kind == RADIX_TREE_NODE_KIND_128) ? 128 : 256,
+					 node->count, node->shift, node->chunk);
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+		{
+			radix_tree_node_4 *n4 = (radix_tree_node_4 *) node;
+
+			for (int i = 0; i < n4->n.count; i++)
+			{
+				radix_tree_print_slot(buf, n4->chunks[i], n4->slots[i], i, is_leaf, level);
+
+				if (!is_leaf)
+				{
+					if (recurse)
+					{
+						StringInfoData buf2;
+
+						initStringInfo(&buf2);
+						radix_tree_dump_node((radix_tree_node *) n4->slots[i], level + 1, &buf2, recurse);
+						appendStringInfo(buf, "%s", buf2.data);
+					}
+					else
+						appendStringInfo(buf, "\n");
+				}
+			}
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_32:
+		{
+			radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+
+			for (int i = 0; i < n32->n.count; i++)
+			{
+				radix_tree_print_slot(buf, n32->chunks[i], n32->slots[i], i, is_leaf, level);
+
+				if (!is_leaf)
+				{
+					if (recurse)
+					{
+						StringInfoData buf2;
+
+						initStringInfo(&buf2);
+						radix_tree_dump_node((radix_tree_node *) n32->slots[i], level + 1, &buf2, recurse);
+						appendStringInfo(buf, "%s", buf2.data);
+					}
+					else
+						appendStringInfo(buf, "\n");
+				}
+			}
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_128:
+		{
+			radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+
+			for (int i = 0; i < RADIX_TREE_NODE_MAX_SLOTS; i++)
+			{
+				if (!node_128_is_slot_used(n128, i))
+					continue;
+
+				radix_tree_print_slot(buf, i, n128->slots[node_128_get_slot_pos(n128, i)],
+									  i, is_leaf, level);
+
+				if (!is_leaf)
+				{
+					if (recurse)
+					{
+						StringInfoData buf2;
+
+						initStringInfo(&buf2);
+						radix_tree_dump_node((radix_tree_node *) n128->slots[node_128_get_slot_pos(n128, i)],
+											 level + 1, &buf2, recurse);
+						appendStringInfo(buf, "%s", buf2.data);
+					}
+					else
+						appendStringInfo(buf, "\n");
+				}
+			}
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_256:
+		{
+			radix_tree_node_256 *n256 = (radix_tree_node_256 *) node;
+
+			for (int i = 0; i < RADIX_TREE_NODE_MAX_SLOTS; i++)
+			{
+				if (!node_256_is_slot_used(n256, i))
+					continue;
+
+				radix_tree_print_slot(buf, i, n256->slots[i], i, is_leaf, level);
+
+				if (!is_leaf)
+				{
+					if (recurse)
+					{
+						StringInfoData buf2;
+
+						initStringInfo(&buf2);
+						radix_tree_dump_node((radix_tree_node *) n256->slots[i], level + 1, &buf2, recurse);
+						appendStringInfo(buf, "%s", buf2.data);
+					}
+					else
+						appendStringInfo(buf, "\n");
+				}
+			}
+			break;
+		}
+	}
+}
+
+void
+radix_tree_dump_search(radix_tree *tree, uint64 key)
+{
+	StringInfoData buf;
+	radix_tree_node *node;
+	int shift;
+	int level = 0;
+
+	elog(WARNING, "-----------------------------------------------------------");
+	elog(WARNING, "max_val = %lu (0x%lX)", tree->max_val, tree->max_val);
+
+	if (!tree->root)
+	{
+		elog(WARNING, "tree is empty");
+		return;
+	}
+
+	if (key > tree->max_val)
+	{
+		elog(WARNING, "key %lu (0x%lX) is larger than max val",
+			 key, key);
+		return;
+	}
+
+	initStringInfo(&buf);
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift >= 0)
+	{
+		radix_tree_node *child;
+
+		radix_tree_dump_node(node, level, &buf, false);
+
+		if (NodeIsLeaf(node))
+		{
+			int chunk = GET_KEY_CHUNK(key, node->shift);
+
+			/* We reached at a leaf node, find the corresponding slot */
+			radix_tree_find_slot_ptr(node, chunk);
+
+			break;
+		}
+
+		child = radix_tree_find_child(node, key);
+
+		if (child == NULL)
+			break;
+
+		node = child;
+		shift -= RADIX_TREE_NODE_FANOUT;
+		level++;
+	}
+
+	elog(WARNING, "\n%s", buf.data);
+}
+
+void
+radix_tree_dump(radix_tree *tree)
+{
+	StringInfoData buf;
+
+	initStringInfo(&buf);
+
+	elog(WARNING, "-----------------------------------------------------------");
+	elog(WARNING, "max_val = %lu", tree->max_val);
+	radix_tree_dump_node(tree->root, 0, &buf, true);
+	elog(WARNING, "\n%s", buf.data);
+	elog(WARNING, "-----------------------------------------------------------");
+}
+#endif
diff --git a/src/include/lib/radixtree.h b/src/include/lib/radixtree.h
new file mode 100644
index 0000000000..fe5a4fd79a
--- /dev/null
+++ b/src/include/lib/radixtree.h
@@ -0,0 +1,41 @@
+/*-------------------------------------------------------------------------
+ *
+ * radixtree.h
+ *	  Interface for radix tree.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		src/include/lib/radixtree.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RADIXTREE_H
+#define RADIXTREE_H
+
+#include "postgres.h"
+
+#define RADIX_TREE_DEBUG 1
+
+typedef struct radix_tree radix_tree;
+typedef struct radix_tree_iter radix_tree_iter;
+
+extern radix_tree *radix_tree_create(MemoryContext ctx);
+extern Datum radix_tree_search(radix_tree *tree, uint64 key, bool *found);
+extern void radix_tree_destroy(radix_tree *tree);
+extern void radix_tree_insert(radix_tree *tree, uint64 key, Datum val, bool *found_p);
+extern uint64 radix_tree_memory_usage(radix_tree *tree);
+extern uint64 radix_tree_num_entries(radix_tree *tree);
+
+extern radix_tree_iter *radix_tree_begin_iterate(radix_tree *tree);
+extern bool radix_tree_iterate_next(radix_tree_iter *iter, uint64 *key_p, Datum *value_p);
+extern void radix_tree_end_iterate(radix_tree_iter *iter);
+
+
+#ifdef RADIX_TREE_DEBUG
+extern void radix_tree_dump(radix_tree *tree);
+extern void radix_tree_dump_search(radix_tree *tree, uint64 key);
+extern void radix_tree_stats(radix_tree *tree);
+#endif
+
+#endif /* RADIXTREE_H */
diff --git a/src/test/modules/Makefile b/src/test/modules/Makefile
index 9090226daa..51b2514faf 100644
--- a/src/test/modules/Makefile
+++ b/src/test/modules/Makefile
@@ -24,6 +24,7 @@ SUBDIRS = \
 		  test_parser \
 		  test_pg_dump \
 		  test_predtest \
+		  test_radixtree \
 		  test_rbtree \
 		  test_regex \
 		  test_rls_hooks \
diff --git a/src/test/modules/test_radixtree/.gitignore b/src/test/modules/test_radixtree/.gitignore
new file mode 100644
index 0000000000..5dcb3ff972
--- /dev/null
+++ b/src/test/modules/test_radixtree/.gitignore
@@ -0,0 +1,4 @@
+# Generated subdirectories
+/log/
+/results/
+/tmp_check/
diff --git a/src/test/modules/test_radixtree/Makefile b/src/test/modules/test_radixtree/Makefile
new file mode 100644
index 0000000000..da06b93da3
--- /dev/null
+++ b/src/test/modules/test_radixtree/Makefile
@@ -0,0 +1,23 @@
+# src/test/modules/test_radixtree/Makefile
+
+MODULE_big = test_radixtree
+OBJS = \
+	$(WIN32RES) \
+	test_radixtree.o
+PGFILEDESC = "test_radixtree - test code for src/backend/lib/radixtree.c"
+
+EXTENSION = test_radixtree
+DATA = test_radixtree--1.0.sql
+
+REGRESS = test_radixtree
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = src/test/modules/test_radixtree
+top_builddir = ../../../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
diff --git a/src/test/modules/test_radixtree/README b/src/test/modules/test_radixtree/README
new file mode 100644
index 0000000000..a8b271869a
--- /dev/null
+++ b/src/test/modules/test_radixtree/README
@@ -0,0 +1,7 @@
+test_integerset contains unit tests for testing the integer set implementation
+in src/backend/lib/integerset.c.
+
+The tests verify the correctness of the implementation, but they can also be
+used as a micro-benchmark.  If you set the 'intset_test_stats' flag in
+test_integerset.c, the tests will print extra information about execution time
+and memory usage.
diff --git a/src/test/modules/test_radixtree/expected/test_radixtree.out b/src/test/modules/test_radixtree/expected/test_radixtree.out
new file mode 100644
index 0000000000..0c96ebc739
--- /dev/null
+++ b/src/test/modules/test_radixtree/expected/test_radixtree.out
@@ -0,0 +1,20 @@
+CREATE EXTENSION test_radixtree;
+--
+-- All the logic is in the test_radixtree() function. It will throw
+-- an error if something fails.
+--
+SELECT test_radixtree();
+NOTICE:  testing radix tree with pattern "all ones"
+NOTICE:  testing radix tree with pattern "alternating bits"
+NOTICE:  testing radix tree with pattern "clusters of ten"
+NOTICE:  testing radix tree with pattern "clusters of hundred"
+NOTICE:  testing radix tree with pattern "one-every-64k"
+NOTICE:  testing radix tree with pattern "sparse"
+NOTICE:  testing radix tree with pattern "single values, distance > 2^32"
+NOTICE:  testing radix tree with pattern "clusters, distance > 2^32"
+NOTICE:  testing radix tree with pattern "clusters, distance > 2^60"
+ test_radixtree 
+----------------
+ 
+(1 row)
+
diff --git a/src/test/modules/test_radixtree/sql/test_radixtree.sql b/src/test/modules/test_radixtree/sql/test_radixtree.sql
new file mode 100644
index 0000000000..41ece5e9f5
--- /dev/null
+++ b/src/test/modules/test_radixtree/sql/test_radixtree.sql
@@ -0,0 +1,7 @@
+CREATE EXTENSION test_radixtree;
+
+--
+-- All the logic is in the test_radixtree() function. It will throw
+-- an error if something fails.
+--
+SELECT test_radixtree();
diff --git a/src/test/modules/test_radixtree/test_radixtree--1.0.sql b/src/test/modules/test_radixtree/test_radixtree--1.0.sql
new file mode 100644
index 0000000000..074a5a7ea7
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree--1.0.sql
@@ -0,0 +1,8 @@
+/* src/test/modules/test_radixtree/test_radixtree--1.0.sql */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION test_radixtree" to load this file. \quit
+
+CREATE FUNCTION test_radixtree()
+RETURNS pg_catalog.void STRICT
+AS 'MODULE_PATHNAME' LANGUAGE C;
diff --git a/src/test/modules/test_radixtree/test_radixtree.c b/src/test/modules/test_radixtree/test_radixtree.c
new file mode 100644
index 0000000000..e9fe7e0124
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree.c
@@ -0,0 +1,397 @@
+/*--------------------------------------------------------------------------
+ *
+ * test_radixtree.c
+ *		Test radixtree set data structure.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		src/test/modules/test_radixtree/test_radixtree.c
+ *
+ * -------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "common/pg_prng.h"
+#include "fmgr.h"
+#include "lib/radixtree.h"
+#include "miscadmin.h"
+#include "nodes/bitmapset.h"
+#include "storage/block.h"
+#include "storage/itemptr.h"
+#include "utils/memutils.h"
+#include "utils/timestamp.h"
+
+#define UINT64_HEX_FORMAT "%" INT64_MODIFIER "X"
+
+/*
+ * If you enable this, the "pattern" tests will print information about
+ * how long populating, probing, and iterating the test set takes, and
+ * how much memory the test set consumed.  That can be used as
+ * micro-benchmark of various operations and input patterns (you might
+ * want to increase the number of values used in each of the test, if
+ * you do that, to reduce noise).
+ *
+ * The information is printed to the server's stderr, mostly because
+ * that's where MemoryContextStats() output goes.
+ */
+static const bool intset_test_stats = true;
+
+static int radix_tree_node_max_entries[] = {4, 16, 48, 256};
+
+/*
+ * A struct to define a pattern of integers, for use with the test_pattern()
+ * function.
+ */
+typedef struct
+{
+	char	   *test_name;		/* short name of the test, for humans */
+	char	   *pattern_str;	/* a bit pattern */
+	uint64		spacing;		/* pattern repeats at this interval */
+	uint64		num_values;		/* number of integers to set in total */
+} test_spec;
+
+static const test_spec test_specs[] = {
+	{
+		"all ones", "1111111111",
+		10, 1000000
+	},
+	{
+		"alternating bits", "0101010101",
+		10, 1000000
+	},
+	{
+		"clusters of ten", "1111111111",
+		10000, 1000000
+	},
+	{
+		"clusters of hundred",
+		"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111",
+		10000, 10000000
+	},
+	{
+		"one-every-64k", "1",
+		65536, 1000000
+	},
+	{
+		"sparse", "100000000000000000000000000000001",
+		10000000, 1000000
+	},
+	{
+		"single values, distance > 2^32", "1",
+		UINT64CONST(10000000000), 100000
+	},
+	{
+		"clusters, distance > 2^32", "10101010",
+		UINT64CONST(10000000000), 1000000
+	},
+	{
+		"clusters, distance > 2^60", "10101010",
+		UINT64CONST(2000000000000000000),
+		23						/* can't be much higher than this, or we
+								 * overflow uint64 */
+	}
+};
+
+PG_MODULE_MAGIC;
+
+PG_FUNCTION_INFO_V1(test_radixtree);
+
+static void test_empty(void);
+
+static void
+test_empty(void)
+{
+	radix_tree *radixtree;
+	bool found;
+
+	radixtree = radix_tree_create(CurrentMemoryContext);
+
+	radix_tree_search(radixtree, 0, &found);
+	if (found)
+		elog(ERROR, "radix_tree_search on empty tree returned true");
+
+	radix_tree_search(radixtree, 1, &found);
+	if (found)
+		elog(ERROR, "radix_tree_search on empty tree returned true");
+
+	radix_tree_search(radixtree, PG_UINT64_MAX, &found);
+	if (found)
+		elog(ERROR, "radix_tree_search on empty tree returned true");
+
+	if (radix_tree_num_entries(radixtree) != 0)
+		elog(ERROR, "radix_tree_num_entries on empty tree return non-zero");
+
+	radix_tree_destroy(radixtree);
+}
+
+static void
+check_search_on_node(radix_tree *radixtree, uint8 shift, int start, int end)
+{
+	for (int i = start; i < end; i++)
+	{
+		uint64 key = ((uint64) i << shift);
+		bool found;
+		Datum val;
+
+		val = radix_tree_search(radixtree, key, &found);
+		if (!found)
+			elog(ERROR, "key 0x" UINT64_HEX_FORMAT " is not found on node-%d",
+				 key, end);
+		if (DatumGetUInt64(val) != key)
+			elog(ERROR, "radix_tree_search with key 0x" UINT64_HEX_FORMAT " returns 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT,
+				 key, DatumGetUInt64(val), key);
+	}
+}
+
+static void
+test_node_types(uint8 shift)
+{
+	radix_tree *radixtree;
+	uint64 num_entries;
+
+	radixtree = radix_tree_create(CurrentMemoryContext);
+
+	for (int i = 0; i < 256; i++)
+	{
+		uint64 key = ((uint64) i << shift);
+		bool found;
+
+		radix_tree_insert(radixtree, key, Int64GetDatum(key), &found);
+
+		if (found)
+			elog(ERROR, "newly inserted key 0x" UINT64_HEX_FORMAT " found", key);
+
+		for (int j = 0; j < lengthof(radix_tree_node_max_entries); j++)
+		{
+			if (i == (radix_tree_node_max_entries[j] - 1))
+			{
+				check_search_on_node(radixtree, shift,
+									 (j == 0) ? 0 : radix_tree_node_max_entries[j - 1],
+									 radix_tree_node_max_entries[j]);
+				break;
+			}
+		}
+	}
+
+	num_entries = radix_tree_num_entries(radixtree);
+
+	if (num_entries != 256)
+		elog(ERROR,
+			 "radix_tree_num_entries returned" UINT64_FORMAT ", expected " UINT64_FORMAT,
+			 num_entries, UINT64CONST(256));
+}
+
+/*
+ * Test with a repeating pattern, defined by the 'spec'.
+ */
+static void
+test_pattern(const test_spec *spec)
+{
+	radix_tree *radixtree;
+	radix_tree_iter *iter;
+	MemoryContext radixtree_ctx;
+	TimestampTz starttime;
+	TimestampTz endtime;
+	uint64		n;
+	uint64		last_int;
+	int			patternlen;
+	uint64	   *pattern_values;
+	uint64		pattern_num_values;
+
+	elog(NOTICE, "testing radix tree with pattern \"%s\"", spec->test_name);
+	if (intset_test_stats)
+		fprintf(stderr, "-----\ntesting radix tree with pattern \"%s\"\n", spec->test_name);
+
+	/* Pre-process the pattern, creating an array of integers from it. */
+	patternlen = strlen(spec->pattern_str);
+	pattern_values = palloc(patternlen * sizeof(uint64));
+	pattern_num_values = 0;
+	for (int i = 0; i < patternlen; i++)
+	{
+		if (spec->pattern_str[i] == '1')
+			pattern_values[pattern_num_values++] = i;
+	}
+
+	/*
+	 * Allocate the integer set.
+	 *
+	 * Allocate it in a separate memory context, so that we can print its
+	 * memory usage easily.  (intset_create() creates a memory context of its
+	 * own, too, but we don't have direct access to it, so we cannot call
+	 * MemoryContextStats() on it directly).
+	 */
+	radixtree_ctx = AllocSetContextCreate(CurrentMemoryContext,
+										  "radixtree test",
+										  ALLOCSET_SMALL_SIZES);
+	MemoryContextSetIdentifier(radixtree_ctx, spec->test_name);
+	radixtree = radix_tree_create(radixtree_ctx);
+
+	/*
+	 * Add values to the set.
+	 */
+	starttime = GetCurrentTimestamp();
+
+	n = 0;
+	last_int = 0;
+	while (n < spec->num_values)
+	{
+		uint64		x = 0;
+
+		for (int i = 0; i < pattern_num_values && n < spec->num_values; i++)
+		{
+			bool found;
+
+			x = last_int + pattern_values[i];
+
+			radix_tree_insert(radixtree, x, Int64GetDatum(x), &found);
+
+			if (found)
+				elog(ERROR, "newly inserted key 0x" UINT64_HEX_FORMAT " found", x);
+
+			n++;
+		}
+		last_int += spec->spacing;
+	}
+
+	endtime = GetCurrentTimestamp();
+
+	if (intset_test_stats)
+		fprintf(stderr, "added " UINT64_FORMAT " values in %d ms\n",
+				spec->num_values, (int) (endtime - starttime) / 1000);
+
+	/*
+	 * Print stats on the amount of memory used.
+	 *
+	 * We print the usage reported by intset_memory_usage(), as well as the
+	 * stats from the memory context.  They should be in the same ballpark,
+	 * but it's hard to automate testing that, so if you're making changes to
+	 * the implementation, just observe that manually.
+	 */
+	if (intset_test_stats)
+	{
+		uint64		mem_usage;
+
+		/*
+		 * Also print memory usage as reported by intset_memory_usage().  It
+		 * should be in the same ballpark as the usage reported by
+		 * MemoryContextStats().
+		 */
+		mem_usage = radix_tree_memory_usage(radixtree);
+		fprintf(stderr, "radix_tree_memory_usage() reported " UINT64_FORMAT " (%0.2f bytes / integer)\n",
+				mem_usage, (double) mem_usage / spec->num_values);
+
+		MemoryContextStats(radixtree_ctx);
+	}
+
+	/* Check that intset_get_num_entries works */
+	n = radix_tree_num_entries(radixtree);
+	if (n != spec->num_values)
+		elog(ERROR, "radix_tree_num_entries returned " UINT64_FORMAT ", expected " UINT64_FORMAT, n, spec->num_values);
+
+	/*
+	 * Test random-access probes with intset_is_member()
+	 */
+	starttime = GetCurrentTimestamp();
+
+	for (n = 0; n < 100000; n++)
+	{
+		bool		found;
+		bool		expected;
+		uint64		x;
+		Datum		v;
+
+		/*
+		 * Pick next value to probe at random.  We limit the probes to the
+		 * last integer that we added to the set, plus an arbitrary constant
+		 * (1000).  There's no point in probing the whole 0 - 2^64 range, if
+		 * only a small part of the integer space is used.  We would very
+		 * rarely hit values that are actually in the set.
+		 */
+		x = pg_prng_uint64_range(&pg_global_prng_state, 0, last_int + 1000);
+
+		/* Do we expect this value to be present in the set? */
+		if (x >= last_int)
+			expected = false;
+		else
+		{
+			uint64		idx = x % spec->spacing;
+
+			if (idx >= patternlen)
+				expected = false;
+			else if (spec->pattern_str[idx] == '1')
+				expected = true;
+			else
+				expected = false;
+		}
+
+		/* Is it present according to intset_is_member() ? */
+		v = radix_tree_search(radixtree, x, &found);
+
+		if (found != expected)
+			elog(ERROR, "mismatch at 0x" UINT64_HEX_FORMAT ": %d vs %d", x, found, expected);
+		if (found && (DatumGetUInt64(v) != x))
+			elog(ERROR, "found 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT,
+				 DatumGetUInt64(v), x);
+	}
+	endtime = GetCurrentTimestamp();
+	if (intset_test_stats)
+		fprintf(stderr, "probed " UINT64_FORMAT " values in %d ms\n",
+				n, (int) (endtime - starttime) / 1000);
+
+	/*
+	 * Test iterator
+	 */
+	starttime = GetCurrentTimestamp();
+
+	iter = radix_tree_begin_iterate(radixtree);
+	n = 0;
+	last_int = 0;
+	while (n < spec->num_values)
+	{
+		for (int i = 0; i < pattern_num_values && n < spec->num_values; i++)
+		{
+			uint64		expected = last_int + pattern_values[i];
+			uint64		x;
+			uint64		val;
+
+			if (!radix_tree_iterate_next(iter, &x, &val))
+				break;
+
+			if (x != expected)
+				elog(ERROR,
+					 "iterate returned wrong key; got 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT " at %d", x, expected, i);
+			if (DatumGetUInt64(val) != expected)
+				elog(ERROR,
+					 "iterate returned wrong value; got 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT " at %d", x, expected, i);
+			n++;
+		}
+		last_int += spec->spacing;
+	}
+	endtime = GetCurrentTimestamp();
+	if (intset_test_stats)
+		fprintf(stderr, "iterated " UINT64_FORMAT " values in %d ms\n",
+				n, (int) (endtime - starttime) / 1000);
+
+	if (n < spec->num_values)
+		elog(ERROR, "iterator stopped short after " UINT64_FORMAT " entries, expected " UINT64_FORMAT, n, spec->num_values);
+	if (n > spec->num_values)
+		elog(ERROR, "iterator returned " UINT64_FORMAT " entries, " UINT64_FORMAT " was expected", n, spec->num_values);
+
+	MemoryContextDelete(radixtree_ctx);
+}
+
+Datum
+test_radixtree(PG_FUNCTION_ARGS)
+{
+	test_empty();
+
+	for (int shift = 0; shift <= (64 - 8); shift += 8)
+		test_node_types(shift);
+
+	/* Test different test patterns, with lots of entries */
+	for (int i = 0; i < lengthof(test_specs); i++)
+		test_pattern(&test_specs[i]);
+
+	PG_RETURN_VOID();
+}
diff --git a/src/test/modules/test_radixtree/test_radixtree.control b/src/test/modules/test_radixtree/test_radixtree.control
new file mode 100644
index 0000000000..e53f2a3e0c
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree.control
@@ -0,0 +1,4 @@
+comment = 'Test code for radix tree'
+default_version = '1.0'
+module_pathname = '$libdir/test_radixtree'
+relocatable = true

diff --git a/src/backend/lib/Makefile b/src/backend/lib/Makefile
index 9dad31398a..fd002d594a 100644
--- a/src/backend/lib/Makefile
+++ b/src/backend/lib/Makefile
@@ -22,6 +22,9 @@ OBJS = \
 	integerset.o \
 	knapsack.o \
 	pairingheap.o \
+	radixtree.o \
 	rbtree.o \
 
+radixtree.o: CFLAGS+=-mavx2
+
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/lib/radixtree.c b/src/backend/lib/radixtree.c
new file mode 100644
index 0000000000..ad08f45fd8
--- /dev/null
+++ b/src/backend/lib/radixtree.c
@@ -0,0 +1,1632 @@
+/*-------------------------------------------------------------------------
+ *
+ * radixtree.c
+ *		Implementation for adaptive radix tree.
+ *
+ * This module employs the idea from the paper "The Adaptive Radix Tree: ARTful
+ * Indexing for Main-Memory Databases" by Viktor Leis, Alfons Kemper, and Thomas
+ * Neumann, 2013.
+ *
+ * There are some differences from the proposed implementation.  For instance,
+ * this radix tree module utilizes AVX2 instruction, enabling us to use 256-bit
+ * width SIMD vector, whereas 128-bit witdh SIMD vector is used in the paper.
+ * Also, there is no support for path compression and lazy path expansion. The
+ * radix tree supports fixed length of the key so we don't expect the tree level
+ * wouldn't be high.
+ *
+ * The key is a 64-bit unsigned integer and the value is a Datum. Both internal
+ * nodes and leaf nodes have the identical structure. For internal tree nodes,
+ * shift > 0, store the pointer to its child node as the value. The leaf nodes,
+ * shift == 0, also have the Datum value that is specified by the user.
+ *
+ * Interface
+ * ---------
+ *
+ * radix_tree_create		- Create a new, empty radix tree
+ * radix_tree_destroy		- Destroy the radix tree
+ * radix_tree_insert		- Insert a key-value pair
+ * radix_tree_delete		- Delete a key-value pair
+ * radix_tree_begin_iterate	- Begin iterating through all key-value pairs
+ * radix_tree_iterate_next	- Return next key-value pair, if any
+ * radix_tree_end_iterate	- End iteration
+ *
+ * radix_tree_create() creates an empty radix tree in the given memory context
+ * and memory contexts for all kinds of radix tree node under the memory context.
+ *
+ * radix_tree_iterate_next() ensures returning key-value pairs in the ascending
+ * order of the key.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/lib/radixtree.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "miscadmin.h"
+#include "port/pg_bitutils.h"
+#include "utils/memutils.h"
+#include "lib/radixtree.h"
+#include "lib/stringinfo.h"
+
+#if defined(__AVX2__)
+#include <immintrin.h> // x86 AVX2 intrinsics
+#endif
+
+/* The number of bits are encoded in one tree level */
+#define RADIX_TREE_NODE_FANOUT	8
+
+/* The number of maximum slots in the node, used in node-256 */
+#define RADIX_TREE_NODE_MAX_SLOTS (1 << RADIX_TREE_NODE_FANOUT)
+
+/*
+ * Return the number of bits required to represent nslots slots, used
+ * in node-128 and node-256.
+ */
+#define RADIX_TREE_NODE_NSLOTS_BITS(nslots) ((nslots) / (sizeof(uint8) * BITS_PER_BYTE))
+
+/* Mask for extracting a chunk from the key */
+#define RADIX_TREE_CHUNK_MASK ((1 << RADIX_TREE_NODE_FANOUT) - 1)
+
+/* Maximum shift the radix tree uses */
+#define RADIX_TREE_MAX_SHIFT	key_get_shift(UINT64_MAX)
+
+/* Tree level the radix tree uses */
+#define RADIX_TREE_MAX_LEVEL	((sizeof(uint64) * BITS_PER_BYTE) / RADIX_TREE_NODE_FANOUT)
+
+/* Get a chunk from the key */
+#define GET_KEY_CHUNK(key, shift) \
+	((uint8) (((key) >> (shift)) & RADIX_TREE_CHUNK_MASK))
+
+/* Mapping from value to the bit in is-set bitmap in the node */
+#define NODE_BITMAP_BYTE(v) ((v) / RADIX_TREE_NODE_FANOUT)
+#define NODE_BITMAP_BIT(v) (UINT64_C(1) << ((v) % RADIX_TREE_NODE_FANOUT))
+
+/* Enum used radix_tree_node_search */
+typedef enum radix_tree_action
+{
+	RADIX_TREE_FIND = 0, /* find the key-value */
+	RADIX_TREE_DELETE,	/* delete the key-value */
+} radix_tree_action;
+
+/*
+ * supported radix tree nodes.
+ *
+ * XXX: should we add KIND_16 as we can utilize SSE2 SIMD instructions?
+ */
+typedef enum radix_tree_node_kind
+{
+	RADIX_TREE_NODE_KIND_4 = 0,
+	RADIX_TREE_NODE_KIND_32,
+	RADIX_TREE_NODE_KIND_128,
+	RADIX_TREE_NODE_KIND_256
+} radix_tree_node_kind;
+#define RADIX_TREE_NODE_KIND_COUNT 4
+
+/*
+ * Base type for all nodes types.
+ */
+typedef struct radix_tree_node
+{
+	/*
+	 * Number of children.  We use uint16 to be able to indicate 256 children
+	 * at ta fanout of 8.
+	 */
+	uint16	count;
+
+	/*
+	 * Shift indicates which part of the key space is represented by this node.
+	 * That is, the key is shifted by 'shift' and the lowest RADIX_TREE_NODE_FANOUT
+	 * bits are then represented in chunk.
+	 */
+	uint8	shift;
+	uint8	chunk;
+
+	/* Size class of the node */
+	radix_tree_node_kind	kind;
+} radix_tree_node;
+/* Macros for radix tree nodes */
+#define IS_LEAF_NODE(n) (((radix_tree_node *) (n))->shift == 0)
+#define IS_EMPTY_NODE(n) (((radix_tree_node *) (n))->count == 0)
+#define HAS_FREE_SLOT(n) \
+	(((radix_tree_node *) (n))->count < \
+	 radix_tree_node_info[((radix_tree_node *) (n))->kind].max_slots)
+
+/*
+ * To reduce memory usage compared to a simple radix tree with a fixed fanout
+ * we use adaptive node sides, with different storage methods for different
+ * numbers of elements.
+ */
+typedef struct radix_tree_node_4
+{
+	radix_tree_node n;
+
+	/* 4 children, for key chunks */
+	uint8	chunks[4];
+	Datum	slots[4];
+} radix_tree_node_4;
+
+typedef struct radix_tree_node_32
+{
+	radix_tree_node n;
+
+	/* 32 children, for key chunks */
+	uint8	chunks[32];
+	Datum slots[32];
+} radix_tree_node_32;
+
+#define RADIX_TREE_NODE_128_BITS RADIX_TREE_NODE_NSLOTS_BITS(128)
+typedef struct radix_tree_node_128
+{
+	radix_tree_node n;
+
+	/*
+	 * The index of slots for each fanout. 0 means unused whereas slots is
+	 * 0-indexed. So we can get the slots of the chunk C by slots[C - 1].
+	 */
+	uint8	slot_idxs[RADIX_TREE_NODE_MAX_SLOTS];
+
+	/* A bitmap to track which slot is in use */
+	uint8	isset[RADIX_TREE_NODE_128_BITS];
+	Datum	slots[128];
+} radix_tree_node_128;
+
+#define RADIX_TREE_NODE_MAX_BITS RADIX_TREE_NODE_NSLOTS_BITS(RADIX_TREE_NODE_MAX_SLOTS)
+typedef struct radix_tree_node_256
+{
+	radix_tree_node n;
+
+	/* A bitmap to track which slot is in use */
+	uint8	isset[RADIX_TREE_NODE_MAX_BITS];
+
+	Datum	slots[RADIX_TREE_NODE_MAX_SLOTS];
+} radix_tree_node_256;
+
+/* Information of each size class */
+typedef struct radix_tree_node_info_elem
+{
+	const char *name;
+	int		max_slots;
+	Size	size;
+} radix_tree_node_info_elem;
+
+static radix_tree_node_info_elem radix_tree_node_info[] =
+{
+	{"radix tree node 4", 4, sizeof(radix_tree_node_4)},
+	{"radix tree node 32", 32, sizeof(radix_tree_node_32)},
+	{"radix tree node 128", 128, sizeof(radix_tree_node_128)},
+	{"radix tree node 256", 256, sizeof(radix_tree_node_256)},
+};
+
+/*
+ * As we descend a radix tree, we push the node to the stack. The stack is used
+ * at deletion.
+ */
+typedef struct radix_tree_stack_data
+{
+	radix_tree_node	*node;
+	struct radix_tree_stack_data	*parent;
+} radix_tree_stack_data;
+typedef radix_tree_stack_data *radix_tree_stack;
+
+/*
+ * Iteration support.
+ *
+ * Iterating the radix tree returns each pair of key and value in the ascending order
+ * of the key. To support this, the we iterate nodes of each level.
+ * radix_tree_iter_node_data struct is used to track the iteration within a node.
+ * radix_tree_iter has the array of this struct, stack, in order to track the iteration
+ * of every level. During the iteration, we also construct the key to return. The key
+ * is updated whenever we update the node iteration information, e.g., when advancing
+ * the current index within the node or when moving to the next node at the same level.
+ */
+typedef struct radix_tree_iter_node_data
+{
+	radix_tree_node *node;	/* current node being iterated */
+	int	current_idx;		/* current position. -1 for initial value */
+} radix_tree_iter_node_data;
+
+struct radix_tree_iter
+{
+	radix_tree *tree;
+
+	/* Track the iteration on nodes of each level */
+	radix_tree_iter_node_data stack[RADIX_TREE_MAX_LEVEL];
+	int	stack_len;
+
+	/* The key is being constructed during the iteration */
+	uint64	key;
+};
+
+/* A radix tree with nodes */
+struct radix_tree
+{
+	MemoryContext context;
+
+	radix_tree_node	*root;
+	uint64	max_val;
+	uint64	num_keys;
+	MemoryContextData *slabs[RADIX_TREE_NODE_KIND_COUNT];
+
+	/* stats */
+	uint64	mem_used;
+	int32	cnt[RADIX_TREE_NODE_KIND_COUNT];
+};
+
+static radix_tree_node *radix_tree_node_grow(radix_tree *tree, radix_tree_node *parent,
+											 radix_tree_node *node, uint64 key);
+static bool radix_tree_node_search_child(radix_tree_node *node, radix_tree_node **child_p,
+										 uint64 key);
+static bool radix_tree_node_search(radix_tree_node *node, Datum **slot_p, uint64 key,
+								   radix_tree_action action);
+static void radix_tree_extend(radix_tree *tree, uint64 key);
+static void radix_tree_new_root(radix_tree *tree, uint64 key, Datum val);
+static radix_tree_node *radix_tree_node_insert_child(radix_tree *tree,
+													 radix_tree_node *parent,
+													 radix_tree_node *node,
+													 uint64 key);
+static void radix_tree_node_insert_val(radix_tree *tree, radix_tree_node *parent,
+									   radix_tree_node *node, uint64 key, Datum val,
+									   bool *replaced_p);
+static inline void radix_tree_iter_update_key(radix_tree_iter *iter, uint8 chunk, uint8 shift);
+static Datum radix_tree_node_iterate_next(radix_tree_iter *iter, radix_tree_iter_node_data *node_iter,
+										  bool *found_p);
+static void radix_tree_store_iter_node(radix_tree_iter *iter, radix_tree_iter_node_data *node_iter,
+									   radix_tree_node *node);
+static void radix_tree_update_iter_stack(radix_tree_iter *iter, int from);
+
+/*
+ * Helper functions for accessing each kind of nodes.
+ */
+static inline int
+node_32_search_eq(radix_tree_node_32 *node, uint8 chunk)
+{
+#ifdef __AVX2__
+	__m256i	_key = _mm256_set1_epi8(chunk);
+	__m256i _data = _mm256_loadu_si256((__m256i_u *) node->chunks);
+	__m256i _cmp = _mm256_cmpeq_epi8(_key, _data);
+	uint32	bitfield = _mm256_movemask_epi8(_cmp);
+
+	bitfield &= ((UINT64_C(1) << node->n.count) - 1);
+
+	return (bitfield) ? __builtin_ctz(bitfield) : -1;
+
+#else
+	for (int i = 0; i < node->n.count; i++)
+	{
+		if (node->chunks[i] > chunk)
+			return -1;
+
+		if (node->chunks[i] == chunk)
+			return i;
+	}
+
+	return -1;
+#endif	/* __AVX2__ */
+}
+
+/*
+ * This is a bit more complicated than search_chunk_array_16_eq(), because
+ * until recently no unsigned uint8 comparison instruction existed on x86. So
+ * we need to play some trickery using _mm_min_epu8() to effectively get
+ * <=. There never will be any equal elements in the current uses, but that's
+ * what we get here...
+ */
+static inline int
+node_32_search_le(radix_tree_node_32 *node, uint8 chunk)
+{
+#ifdef __AVX2__
+	__m256i _key = _mm256_set1_epi8(chunk);
+	__m256i _data = _mm256_loadu_si256((__m256i_u*) node->chunks);
+	__m256i _min = _mm256_min_epu8(_key, _data);
+	__m256i cmp = _mm256_cmpeq_epi8(_key, _min);
+	uint32_t bitfield=_mm256_movemask_epi8(cmp);
+
+	bitfield &= ((UINT64_C(1) << node->n.count) - 1);
+
+	return (bitfield) ? __builtin_ctz(bitfield) : node->n.count;
+#else
+	int index;
+
+	for (index = 0; index < node->n.count; index++)
+	{
+		if (node->chunks[index] >= chunk)
+			break;
+	}
+
+	return index;
+#endif	/* __AVX2__ */
+}
+
+/* Does the given chunk in the node has the value? */
+static inline bool
+node_128_is_chunk_used(radix_tree_node_128 *node, uint8 chunk)
+{
+	return (node->slot_idxs[chunk] != 0);
+}
+
+/* Is the slot in the node used */
+static inline bool
+node_128_is_slot_used(radix_tree_node_128 *node, uint8 slot)
+{
+	return ((node->isset[NODE_BITMAP_BYTE(slot)] & NODE_BITMAP_BIT(slot)) != 0);
+}
+
+/* Set the slot at the corresponding chunk */
+static inline void
+node_128_set(radix_tree_node_128 *node, uint8 chunk, Datum slot)
+{
+	int	slotpos = 0;
+
+	while (node_128_is_slot_used(node, slotpos))
+		slotpos++;
+	node->slot_idxs[chunk] = slotpos + 1;
+	node->slots[slotpos] = slot;
+	node->isset[NODE_BITMAP_BYTE(slotpos)] |= NODE_BITMAP_BIT(slotpos);
+}
+
+/* Delete the slot at the corresponding chunk */
+static inline void
+node_128_unset(radix_tree_node_128 *node, uint8 chunk)
+{
+	node->slot_idxs[chunk] = 0;
+	node->isset[NODE_BITMAP_BYTE(chunk)] &= ~(NODE_BITMAP_BIT(chunk));
+}
+
+/* Return the slot data corresponding to the chunk */
+static inline Datum
+node_128_get_chunk_slot(radix_tree_node_128 *node, uint8 chunk)
+{
+	return node->slots[node->slot_idxs[chunk] - 1];
+}
+
+/* Return true if the slot corresponding to the given chunk is in use */
+static inline bool
+node_256_is_chunk_used(radix_tree_node_256 *node, uint8 chunk)
+{
+	return (node->isset[NODE_BITMAP_BYTE(chunk)] & NODE_BITMAP_BIT(chunk)) != 0;
+}
+
+/* Set the slot at the given chunk position */
+static inline void
+node_256_set(radix_tree_node_256 *node, uint8 chunk, Datum slot)
+{
+	node->slots[chunk] = slot;
+	node->isset[NODE_BITMAP_BYTE(chunk)] |= NODE_BITMAP_BIT(chunk);
+}
+
+/* Set the slot at the given chunk position */
+static inline void
+node_256_unset(radix_tree_node_256 *node, uint8 chunk)
+{
+	node->isset[NODE_BITMAP_BYTE(chunk)] &= ~(NODE_BITMAP_BIT(chunk));
+}
+
+/*
+ * Return the shift that is satisfied to store the given key.
+ */
+inline static int
+key_get_shift(uint64 key)
+{
+	return (key == 0)
+		? 0
+		: (pg_leftmost_one_pos64(key) / RADIX_TREE_NODE_FANOUT) * RADIX_TREE_NODE_FANOUT;
+}
+
+/*
+ * Return the max value stored in a node with the given shift.
+ */
+static uint64
+shift_get_max_val(int shift)
+{
+	if (shift == RADIX_TREE_MAX_SHIFT)
+		return UINT64_MAX;
+
+	return (UINT64_C(1) << (shift + RADIX_TREE_NODE_FANOUT)) - 1;
+}
+
+/*
+ * Allocate a new node with the given node kind.
+ */
+static radix_tree_node *
+radix_tree_alloc_node(radix_tree *tree, radix_tree_node_kind kind)
+{
+	radix_tree_node *newnode;
+
+	newnode = (radix_tree_node *) MemoryContextAllocZero(tree->slabs[kind],
+														 radix_tree_node_info[kind].size);
+	newnode->kind = kind;
+
+	/* stats */
+	tree->mem_used += GetMemoryChunkSpace(newnode);
+	tree->cnt[kind]++;
+
+	return newnode;
+}
+
+/* Free the given node */
+static void
+radix_tree_free_node(radix_tree *tree, radix_tree_node *node)
+{
+	/* stats */
+	tree->mem_used -= GetMemoryChunkSpace(node);
+	tree->cnt[node->kind]--;
+
+	pfree(node);
+}
+
+/* Free a stack made by radix_tree_delete */
+static void
+radix_tree_free_stack(radix_tree_stack stack)
+{
+	radix_tree_stack ostack;
+
+	while (stack != NULL)
+	{
+		ostack = stack;
+		stack = stack->parent;
+		pfree(ostack);
+	}
+}
+
+/* Copy the common fields without the kind */
+static void
+radix_tree_copy_node_common(radix_tree_node *src, radix_tree_node *dst)
+{
+	dst->shift = src->shift;
+	dst->chunk = src->chunk;
+	dst->count = src->count;
+}
+
+/* The tree doesn't have not sufficient height, so grow it */
+static void
+radix_tree_extend(radix_tree *tree, uint64 key)
+{
+	int max_shift;
+	int shift = tree->root->shift + RADIX_TREE_NODE_FANOUT;
+
+	max_shift = key_get_shift(key);
+
+	/* Grow tree from 'shift' to 'max_shift' */
+	while (shift <= max_shift)
+	{
+		radix_tree_node_4 *node =
+			(radix_tree_node_4 *) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_4);
+
+		node->n.count = 1;
+		node->n.shift = shift;
+		node->chunks[0] = 0;
+		node->slots[0] = PointerGetDatum(tree->root);
+
+		tree->root->chunk = 0;
+		tree->root = (radix_tree_node *) node;
+
+		shift += RADIX_TREE_NODE_FANOUT;
+	}
+
+	tree->max_val = shift_get_max_val(max_shift);
+}
+
+/*
+ * Wrapper for radix_tree_node_search to search the pointer to the child node in the
+ * node.
+ *
+ * Return true if the corresponding child is found, otherwise return false.  On success,
+ * it sets child_p.
+ */
+static bool
+radix_tree_node_search_child(radix_tree_node *node, radix_tree_node **child_p, uint64 key)
+{
+	bool	found = false;
+	Datum	*slot_ptr;
+
+	if (radix_tree_node_search(node, &slot_ptr, key, RADIX_TREE_FIND))
+	{
+		/* Found the pointer to the child node */
+		found = true;
+		*child_p = (radix_tree_node *) DatumGetPointer(*slot_ptr);
+	}
+
+	return found;
+}
+
+/*
+ * Return true if the corresponding slot is used, otherwise return false.  On success,
+ * sets the pointer to the slot to slot_p.
+ */
+static bool
+radix_tree_node_search(radix_tree_node *node, Datum **slot_p, uint64 key,
+					   radix_tree_action action)
+{
+	int		chunk = GET_KEY_CHUNK(key, node->shift);
+	bool	found = false;
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+		{
+			radix_tree_node_4 *n4 = (radix_tree_node_4 *) node;
+
+			/* Do linear search */
+			for (int i = 0; i < n4->n.count; i++)
+			{
+				if (n4->chunks[i] > chunk)
+					break;
+
+				if (n4->chunks[i] == chunk)
+				{
+					if (action == RADIX_TREE_FIND)
+						*slot_p = &(n4->slots[i]);
+					else	/* RADIX_TREE_DELETE */
+					{
+						memmove(&(n4->chunks[i]), &(n4->chunks[i + 1]),
+								sizeof(uint8) * (n4->n.count - i - 1));
+						memmove(&(n4->slots[i]), &(n4->slots[i + 1]),
+								sizeof(radix_tree_node *) * (n4->n.count - i - 1));
+					}
+
+					found = true;
+					break;
+				}
+			}
+
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_32:
+		{
+			radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+			int idx;
+
+			/* Search by SIMD instructions */
+			idx = node_32_search_eq(n32, chunk);
+
+			if (idx >= 0)
+			{
+				if (action == RADIX_TREE_FIND)
+					*slot_p = &(n32->slots[idx]);
+				else /* RADIX_TREE_DELETE */
+				{
+					memmove(&(n32->chunks[idx]), &(n32->chunks[idx + 1]),
+							sizeof(uint8) * (n32->n.count - idx - 1));
+					memmove(&(n32->slots[idx]), &(n32->slots[idx + 1]),
+							sizeof(radix_tree_node *) * (n32->n.count - idx - 1));
+				}
+
+				found = true;
+			}
+
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_128:
+		{
+			radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+
+			if (node_128_is_chunk_used(n128, chunk))
+			{
+				if (action == RADIX_TREE_FIND)
+					*slot_p = &(n128->slots[n128->slot_idxs[chunk] - 1]);
+				else /* RADIX_TREE_DELETE */
+					node_128_unset(n128, chunk);
+
+				found = true;
+			}
+
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_256:
+		{
+			radix_tree_node_256 *n256 = (radix_tree_node_256 *) node;
+
+			if (node_256_is_chunk_used(n256, chunk))
+			{
+				if (action == RADIX_TREE_FIND)
+					*slot_p = &(n256->slots[chunk]);
+				else /* RADIX_TREE_DELETE */
+					node_256_unset(n256, chunk);
+
+				found = true;
+			}
+
+			break;
+		}
+	}
+
+	/* Update statistics */
+	if (action == RADIX_TREE_DELETE && found)
+		node->count--;
+
+	return found;
+}
+
+/*
+ * Create a new node as the root. Subordinate nodes will be created during
+ * the insertion.
+ */
+static void
+radix_tree_new_root(radix_tree *tree, uint64 key, Datum val)
+{
+	radix_tree_node_4 * n4 =
+		(radix_tree_node_4 * ) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_4);
+	int shift = key_get_shift(key);
+
+	n4->n.shift = shift;
+	tree->max_val = shift_get_max_val(shift);
+	tree->root = (radix_tree_node *) n4;
+}
+
+/* Insert 'node' as a child node of 'parent' */
+static radix_tree_node *
+radix_tree_node_insert_child(radix_tree *tree, radix_tree_node *parent,
+							 radix_tree_node *node, uint64 key)
+{
+	radix_tree_node *newchild =
+		(radix_tree_node *) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_4);
+
+	Assert(!IS_LEAF_NODE(node));
+
+	newchild->shift = node->shift - RADIX_TREE_NODE_FANOUT;
+	newchild->chunk = GET_KEY_CHUNK(key, node->shift);
+
+	radix_tree_node_insert_val(tree, parent, node, key, PointerGetDatum(newchild), NULL);
+
+	return (radix_tree_node *) newchild;
+}
+
+/*
+ * Insert the value to the node. The node grows if it's full.
+ */
+static void
+radix_tree_node_insert_val(radix_tree *tree, radix_tree_node *parent,
+						   radix_tree_node *node, uint64 key, Datum val,
+						   bool *replaced_p)
+{
+	int chunk = GET_KEY_CHUNK(key, node->shift);
+	bool replaced = false;
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+		{
+			radix_tree_node_4 *n4 = (radix_tree_node_4 *) node;
+			int idx;
+
+			for (idx = 0; idx < n4->n.count; idx++)
+			{
+				if (n4->chunks[idx] >= chunk)
+					break;
+			}
+
+			if (HAS_FREE_SLOT(n4))
+			{
+				if (n4->n.count == 0)
+				{
+					/* the first key for this node, add it */
+				}
+				else if (n4->chunks[idx] == chunk)
+				{
+					/* found the key, replace it */
+					replaced = true;
+				}
+				else if (idx != n4->n.count)
+				{
+					/*
+					 * the key needs to be inserted in the middle of the array,
+					 * make space for the new key.
+					 */
+					memmove(&(n4->chunks[idx + 1]), &(n4->chunks[idx]),
+							sizeof(uint8) * (n4->n.count - idx));
+					memmove(&(n4->slots[idx + 1]), &(n4->slots[idx]),
+							sizeof(radix_tree_node *) * (n4->n.count - idx));
+				}
+
+				n4->chunks[idx] = chunk;
+				n4->slots[idx] = val;
+
+				/* Done */
+				break;
+			}
+
+			/* The node needs to grow */
+			node = radix_tree_node_grow(tree, parent, node, key);
+			Assert(node->kind == RADIX_TREE_NODE_KIND_32);
+		}
+		/* FALLTHROUGH */
+		case RADIX_TREE_NODE_KIND_32:
+		{
+			radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+			int idx;
+
+			idx = node_32_search_le(n32, chunk);
+
+			if (HAS_FREE_SLOT(n32))
+			{
+				if (n32->n.count == 0)
+				{
+					/* first key for this node, add it */
+				}
+				else if (n32->chunks[idx] == chunk)
+				{
+					/* found the key, replace it */
+					replaced = true;
+				}
+				else if (idx != n32->n.count)
+				{
+					/*
+					 * the key needs to be inserted in the middle of the array,
+					 * make space for the new key.
+					 */
+					memmove(&(n32->chunks[idx + 1]), &(n32->chunks[idx]),
+							sizeof(uint8) * (n32->n.count - idx));
+					memmove(&(n32->slots[idx + 1]), &(n32->slots[idx]),
+							sizeof(radix_tree_node *) * (n32->n.count - idx));
+				}
+
+				n32->chunks[idx] = chunk;
+				n32->slots[idx] = val;
+				break;
+			}
+
+			/* The node needs to grow */
+			node = radix_tree_node_grow(tree, parent, node, key);
+			Assert(node->kind == RADIX_TREE_NODE_KIND_128);
+		}
+		/* FALLTHROUGH */
+		case RADIX_TREE_NODE_KIND_128:
+		{
+			radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+
+			if (node_128_is_chunk_used(n128, chunk))
+			{
+				/* found the existing value */
+				node_128_set(n128, chunk, val);
+				replaced = true;
+				break;
+			}
+
+			if (HAS_FREE_SLOT(n128))
+			{
+				node_128_set(n128, chunk, val);
+				break;
+			}
+
+			node = radix_tree_node_grow(tree, parent, node, key);
+			Assert(node->kind == RADIX_TREE_NODE_KIND_256);
+		}
+		/* FALLTHROUGH */
+		case RADIX_TREE_NODE_KIND_256:
+		{
+			radix_tree_node_256 *n256 = (radix_tree_node_256 *) node;
+
+			if (node_256_is_chunk_used(n256, chunk))
+				replaced = true;
+
+			node_256_set(n256, chunk, val);
+			break;
+		}
+	}
+
+	if (!replaced)
+		node->count++;
+
+	if (replaced_p)
+		*replaced_p = replaced;
+}
+
+/* Change the node type to a larger one */
+static radix_tree_node *
+radix_tree_node_grow(radix_tree *tree, radix_tree_node *parent, radix_tree_node *node,
+					 uint64 key)
+{
+	radix_tree_node *newnode = NULL;
+
+	Assert(node->count ==
+		   radix_tree_node_info[node->kind].max_slots);
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+		{
+			radix_tree_node_4 *n4 = (radix_tree_node_4 *) node;
+			radix_tree_node_32 *new32 =
+				(radix_tree_node_32 *) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_32);
+
+			radix_tree_copy_node_common((radix_tree_node *) n4,
+										(radix_tree_node *) new32);
+
+			memcpy(&(new32->chunks), &(n4->chunks), sizeof(uint8) * 4);
+			memcpy(&(new32->slots), &(n4->slots), sizeof(Datum) * 4);
+
+#ifdef USE_ASSERT_CHECKING
+			{
+				/* Check if the chunks in the new node are sorted */
+				for (int i = 1; i < new32->n.count ; i++)
+					Assert(new32->chunks[i - 1] <= new32->chunks[i]);
+				Assert(new32->n.count == 4);
+			}
+#endif
+
+			newnode = (radix_tree_node *) new32;
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_32:
+		{
+			radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+			radix_tree_node_128 *new128 =
+				(radix_tree_node_128 *) radix_tree_alloc_node(tree,RADIX_TREE_NODE_KIND_128);
+
+			radix_tree_copy_node_common((radix_tree_node *) n32,
+										(radix_tree_node *) new128);
+
+			for (int i = 0; i < n32->n.count; i++)
+				node_128_set(new128, n32->chunks[i], n32->slots[i]);
+
+#ifdef USE_ASSERT_CHECKING
+			{
+				for (int i = 0; i < n32->n.count; i++)
+					Assert(node_128_is_chunk_used(new128, n32->chunks[i]));
+				Assert(new128->n.count == 32);
+			}
+#endif
+
+			newnode = (radix_tree_node *) new128;
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_128:
+		{
+			radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+			radix_tree_node_256 *new256 =
+				(radix_tree_node_256 *) radix_tree_alloc_node(tree,RADIX_TREE_NODE_KIND_256);
+			int cnt = 0;
+
+			radix_tree_copy_node_common((radix_tree_node *) n128,
+										(radix_tree_node *) new256);
+
+			for (int i = 0; i < 256 && cnt < n128->n.count; i++)
+			{
+				if (!node_128_is_chunk_used(n128, i))
+					continue;
+
+				node_256_set(new256, i, node_128_get_chunk_slot(n128, i));
+				cnt++;
+			}
+
+#ifdef USE_ASSERT_CHECKING
+			{
+				int n = 0;
+				for (int i = 0; i < RADIX_TREE_NODE_MAX_BITS; i++)
+					n += pg_popcount32(new256->isset[i]);
+
+				Assert(new256->n.count == n);
+			}
+#endif
+
+			newnode = (radix_tree_node *) new256;
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_256:
+			elog(ERROR, "radix tree node_256 cannot be grew");
+			break;
+	}
+
+	if (parent == node)
+	{
+		/* Replace the root node with the new large node */
+		tree->root = newnode;
+	}
+	else
+	{
+		Datum *slot_ptr = NULL;
+
+		/* Redirect from the parent to the node */
+		radix_tree_node_search(parent, &slot_ptr, key, RADIX_TREE_FIND);
+		Assert(*slot_ptr);
+		*slot_ptr = PointerGetDatum(newnode);
+	}
+
+	radix_tree_free_node(tree, node);
+
+	return newnode;
+}
+
+radix_tree *
+radix_tree_create(MemoryContext ctx)
+{
+	radix_tree *tree;
+	MemoryContext old_ctx;
+
+	old_ctx = MemoryContextSwitchTo(ctx);
+
+	tree = palloc(sizeof(radix_tree));
+	tree->max_val = 0;
+	tree->root = NULL;
+	tree->context = ctx;
+	tree->num_keys = 0;
+	tree->mem_used = 0;
+
+	/* Create the slab allocator for each size class */
+	for (int i = 0; i < RADIX_TREE_NODE_KIND_COUNT; i++)
+	{
+		tree->slabs[i] = SlabContextCreate(ctx,
+										   radix_tree_node_info[i].name,
+										   SLAB_DEFAULT_BLOCK_SIZE,
+										   radix_tree_node_info[i].size);
+		tree->cnt[i] = 0;
+	}
+
+	MemoryContextSwitchTo(old_ctx);
+
+	return tree;
+}
+
+void
+radix_tree_destroy(radix_tree *tree)
+{
+	for (int i = 0; i < RADIX_TREE_NODE_KIND_COUNT; i++)
+		MemoryContextDelete(tree->slabs[i]);
+
+	pfree(tree);
+}
+
+/*
+ * Insert the key with the val.
+ *
+ * found_p is set to true if the key already present, otherwise false, if
+ * it's not NULL.
+ *
+ * XXX: do we need to support update_if_exists behavior?
+ */
+void
+radix_tree_insert(radix_tree *tree, uint64 key, Datum val, bool *found_p)
+{
+	int shift;
+	bool	replaced;
+	radix_tree_node *node;
+	radix_tree_node *parent = tree->root;
+
+	/* Empty tree, create the root */
+	if (!tree->root)
+		radix_tree_new_root(tree, key, val);
+
+	/* Extend the tree if necessary */
+	if (key > tree->max_val)
+		radix_tree_extend(tree, key);
+
+	Assert(tree->root);
+
+	shift = tree->root->shift;
+	node = tree->root;
+	while (shift > 0)
+	{
+		radix_tree_node *child;
+
+		if (!radix_tree_node_search_child(node, &child, key))
+			child = radix_tree_node_insert_child(tree, parent, node, key);
+
+		Assert(child != NULL);
+
+		parent = node;
+		node = child;
+		shift -= RADIX_TREE_NODE_FANOUT;
+	}
+
+	/* arrived at a leaf */
+	Assert(IS_LEAF_NODE(node));
+
+	radix_tree_node_insert_val(tree, parent, node, key, val, &replaced);
+
+	/* Update the statistics */
+	if (!replaced)
+		tree->num_keys++;
+
+	if (found_p)
+		*found_p = replaced;
+}
+
+/*
+ * Search the given key in the radix tree. Return true if the key is successfully
+ * found, otherwise return false.  On success, we set the value to *val_p so
+ * it must not be NULL.
+ */
+bool
+radix_tree_search(radix_tree *tree, uint64 key, Datum *val_p)
+{
+	radix_tree_node *node;
+	Datum *value_ptr;
+	int shift;
+
+	Assert(val_p);
+
+	if (!tree->root || key > tree->max_val)
+		return false;
+
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift > 0)
+	{
+		radix_tree_node *child;
+
+		if (!radix_tree_node_search_child(node, &child, key))
+			return false;
+
+		node = child;
+		shift -= RADIX_TREE_NODE_FANOUT;
+	}
+
+	/* We reached at a leaf node, search the corresponding slot */
+	Assert(IS_LEAF_NODE(node));
+
+	if (!radix_tree_node_search(node, &value_ptr, key, RADIX_TREE_FIND))
+		return false;
+
+	/* Found, set the value to return */
+	*val_p = *value_ptr;
+	return true;
+}
+
+bool
+radix_tree_delete(radix_tree *tree, uint64 key)
+{
+	radix_tree_node *node;
+	int shift;
+	radix_tree_stack stack = NULL;
+	bool deleted;
+
+	if (!tree->root || key > tree->max_val)
+		return false;
+
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift >= 0)
+	{
+		radix_tree_node *child;
+		radix_tree_stack new_stack;
+
+		new_stack = (radix_tree_stack) palloc(sizeof(radix_tree_stack_data));
+		new_stack->node = node;
+		new_stack->parent = stack;
+		stack = new_stack;
+
+		if (IS_LEAF_NODE(node))
+			break;
+
+		if (!radix_tree_node_search_child(node, &child, key))
+		{
+			radix_tree_free_stack(stack);
+			return false;
+		}
+
+		node = child;
+		shift -= RADIX_TREE_NODE_FANOUT;
+	}
+
+	Assert(IS_LEAF_NODE(stack->node));
+	while (stack != NULL)
+	{
+		radix_tree_node *node = stack->node;
+		Datum	*slot;
+
+		stack = stack->parent;
+
+		deleted = radix_tree_node_search(node, &slot, key, RADIX_TREE_DELETE);
+
+		if (!IS_EMPTY_NODE(node))
+			break;
+
+		Assert(deleted);
+		radix_tree_free_node(tree, node);
+	}
+
+	if (deleted)
+		tree->num_keys--;
+
+	radix_tree_free_stack(stack);
+	return deleted;
+}
+
+/* Create and return the iterator for the given radix tree */
+radix_tree_iter *
+radix_tree_begin_iterate(radix_tree *tree)
+{
+	MemoryContext old_ctx;
+	radix_tree_iter *iter;
+	int top_level;
+
+	old_ctx = MemoryContextSwitchTo(tree->context);
+
+	iter = (radix_tree_iter *) palloc0(sizeof(radix_tree_iter));
+	iter->tree = tree;
+
+	/* empty tree */
+	if (!iter->tree)
+		return iter;
+
+	top_level = iter->tree->root->shift / RADIX_TREE_NODE_FANOUT;
+
+	iter->stack_len = top_level;
+	iter->stack[top_level].node = iter->tree->root;
+	iter->stack[top_level].current_idx = -1;
+
+	/* Descend to the left most leaf node from the root */
+	radix_tree_update_iter_stack(iter, top_level);
+
+	MemoryContextSwitchTo(old_ctx);
+
+	return iter;
+}
+
+/*
+ * Return true with setting key_p and value_p if there is next key.  Otherwise,
+ * return false.
+ */
+bool
+radix_tree_iterate_next(radix_tree_iter *iter, uint64 *key_p, Datum *value_p)
+{
+	bool found = false;
+	Datum slot = (Datum) 0;
+	int level;
+
+	/* Empty tree */
+	if (!iter->tree)
+		return false;
+
+	for (;;)
+	{
+		radix_tree_node *node;
+		radix_tree_iter_node_data *node_iter;
+
+		/*
+		 * Iterate node at each level from the bottom of the tree until we search
+		 * the next slot.
+		 */
+		for (level = 0; level <= iter->stack_len; level++)
+		{
+			slot = radix_tree_node_iterate_next(iter, &(iter->stack[level]), &found);
+
+			if (found)
+				break;
+		}
+
+		/* end of iteration */
+		if (!found)
+			return false;
+
+		/* found the next slot at the leaf node, return it */
+		if (level == 0)
+		{
+			*key_p = iter->key;
+			*value_p = slot;
+			return true;
+		}
+
+		/*
+		 * We have advanced more than one nodes including internal nodes. So we need
+		 * to update the stack by descending to the left most leaf node from this level.
+		 */
+		node = (radix_tree_node *) DatumGetPointer(slot);
+		node_iter = &(iter->stack[level - 1]);
+		radix_tree_store_iter_node(iter, node_iter, node);
+
+		radix_tree_update_iter_stack(iter, level - 1);
+	}
+}
+
+void
+radix_tree_end_iterate(radix_tree_iter *iter)
+{
+	pfree(iter);
+}
+
+/*
+ * Update the part of the key being constructed during the iteration with the
+ * given chunk
+ */
+static inline void
+radix_tree_iter_update_key(radix_tree_iter *iter, uint8 chunk, uint8 shift)
+{
+	iter->key &= ~(((uint64) RADIX_TREE_CHUNK_MASK) << shift);
+	iter->key |= (((uint64) chunk) << shift);
+}
+
+/*
+ * Iterate over the given radix tree node and returns the next slot of the given
+ * node and set true to *found_p, if any.  Otherwise, set false to *found_p.
+ */
+static Datum
+radix_tree_node_iterate_next(radix_tree_iter *iter, radix_tree_iter_node_data *node_iter,
+							 bool *found_p)
+{
+	radix_tree_node *node = node_iter->node;
+	Datum slot = (Datum) 0;
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+		{
+			radix_tree_node_4 *n4 = (radix_tree_node_4 *) node_iter->node;
+
+			node_iter->current_idx++;
+
+			if (node_iter->current_idx >= n4->n.count)
+				goto not_found;
+
+			slot = n4->slots[node_iter->current_idx];
+
+			/* Update the part of the key with the current chunk */
+			if (IS_LEAF_NODE(node))
+				radix_tree_iter_update_key(iter, n4->chunks[node_iter->current_idx], 0);
+
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_32:
+		{
+			radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+
+			node_iter->current_idx++;
+
+			if (node_iter->current_idx >= n32->n.count)
+				goto not_found;
+
+			slot = n32->slots[node_iter->current_idx];
+
+			/* Update the part of the key with the current chunk */
+			if (IS_LEAF_NODE(node))
+				radix_tree_iter_update_key(iter, n32->chunks[node_iter->current_idx], 0);
+
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_128:
+		{
+			radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+			int i;
+
+			for (i = node_iter->current_idx + 1; i < 256; i++)
+			{
+				if (node_128_is_chunk_used(n128, i))
+					break;
+			}
+
+			if (i >= 256)
+				goto not_found;
+
+			node_iter->current_idx = i;
+			slot = node_128_get_chunk_slot(n128, i);
+
+			/* Update the part of the key */
+			if (IS_LEAF_NODE(node))
+				radix_tree_iter_update_key(iter, node_iter->current_idx, 0);
+
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_256:
+		{
+			radix_tree_node_256 *n256 = (radix_tree_node_256 *) node;
+			int i;
+
+			for (i = node_iter->current_idx + 1; i < 256; i++)
+			{
+				if (node_256_is_chunk_used(n256, i))
+					break;
+			}
+
+			if (i >= 256)
+				goto not_found;
+
+			node_iter->current_idx = i;
+			slot = n256->slots[i];
+
+			/* Update the part of the key */
+			if (IS_LEAF_NODE(node))
+				radix_tree_iter_update_key(iter, node_iter->current_idx, 0);
+
+			break;
+		}
+	}
+
+	*found_p = true;
+	return slot;
+
+not_found:
+	*found_p = false;
+	return (Datum) 0;
+}
+
+/*
+ * Initialize and update the node iteration struct with the given radix tree node.
+ * This function also updates the part of the key with the chunk of the given node.
+ */
+static void
+radix_tree_store_iter_node(radix_tree_iter *iter, radix_tree_iter_node_data *node_iter,
+						   radix_tree_node *node)
+{
+	node_iter->node = node;
+	node_iter->current_idx = -1;
+
+	radix_tree_iter_update_key(iter, node->chunk, node->shift + RADIX_TREE_NODE_FANOUT);
+}
+
+/*
+ * Build the stack of the radix tree node while descending to the leaf from the 'from'
+ * level.
+ */
+static void
+radix_tree_update_iter_stack(radix_tree_iter *iter, int from)
+{
+	radix_tree_node *node = iter->stack[from].node;
+	int level = from;
+
+	for (;;)
+	{
+		radix_tree_iter_node_data *node_iter = &(iter->stack[level--]);
+		bool found;
+
+		/* Set the current node */
+		radix_tree_store_iter_node(iter, node_iter, node);
+
+		if (IS_LEAF_NODE(node))
+			break;
+
+		node = (radix_tree_node *)
+			DatumGetPointer(radix_tree_node_iterate_next(iter, node_iter, &found));
+
+		/*
+		 * Since we always get the first slot in the node, we have to found
+		 * the slot.
+		 */
+		Assert(found);
+	}
+}
+
+uint64
+radix_tree_num_entries(radix_tree *tree)
+{
+	return tree->num_keys;
+}
+
+uint64
+radix_tree_memory_usage(radix_tree *tree)
+{
+	return tree->mem_used;
+}
+
+/***************** DEBUG FUNCTIONS *****************/
+#ifdef RADIX_TREE_DEBUG
+void
+radix_tree_stats(radix_tree *tree)
+{
+	fprintf(stderr, "num_keys = %lu, height = %u, n4 = %u(%lu), n32 = %u(%lu), n128 = %u(%lu), n256 = %u(%lu)",
+			tree->num_keys,
+			tree->root->shift / RADIX_TREE_NODE_FANOUT,
+			tree->cnt[0], tree->cnt[0] * sizeof(radix_tree_node_4),
+			tree->cnt[1], tree->cnt[1] * sizeof(radix_tree_node_32),
+			tree->cnt[2], tree->cnt[2] * sizeof(radix_tree_node_128),
+			tree->cnt[3], tree->cnt[3] * sizeof(radix_tree_node_256));
+	//radix_tree_dump(tree);
+}
+
+static void
+radix_tree_print_slot(StringInfo buf, uint8 chunk, Datum slot, int idx, bool is_leaf, int level)
+{
+	char space[128] = {0};
+
+	if (level > 0)
+		sprintf(space, "%*c", level * 4, ' ');
+
+	if (is_leaf)
+		appendStringInfo(buf, "%s[%d] \"0x%X\" val(0x%lX) LEAF\n",
+						 space,
+						 idx,
+						 chunk,
+						 DatumGetInt64(slot));
+	else
+		appendStringInfo(buf , "%s[%d] \"0x%X\" -> ",
+						 space,
+						 idx,
+						 chunk);
+}
+
+static void
+radix_tree_dump_node(radix_tree_node *node, int level, StringInfo buf, bool recurse)
+{
+	bool is_leaf = IS_LEAF_NODE(node);
+
+	appendStringInfo(buf, "[\"%s\" type %d, cnt %u, shift %u, chunk \"0x%X\"] chunks:\n",
+					 IS_LEAF_NODE(node) ? "LEAF" : "INNR",
+					 (node->kind == RADIX_TREE_NODE_KIND_4) ? 4 :
+					 (node->kind == RADIX_TREE_NODE_KIND_32) ? 32 :
+					 (node->kind == RADIX_TREE_NODE_KIND_128) ? 128 : 256,
+					 node->count, node->shift, node->chunk);
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+		{
+			radix_tree_node_4 *n4 = (radix_tree_node_4 *) node;
+
+			for (int i = 0; i < n4->n.count; i++)
+			{
+				radix_tree_print_slot(buf, n4->chunks[i], n4->slots[i], i, is_leaf, level);
+
+				if (!is_leaf)
+				{
+					if (recurse)
+					{
+						StringInfoData buf2;
+
+						initStringInfo(&buf2);
+						radix_tree_dump_node((radix_tree_node *) n4->slots[i], level + 1, &buf2, recurse);
+						appendStringInfo(buf, "%s", buf2.data);
+					}
+					else
+						appendStringInfo(buf, "\n");
+				}
+			}
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_32:
+		{
+			radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+
+			for (int i = 0; i < n32->n.count; i++)
+			{
+				radix_tree_print_slot(buf, n32->chunks[i], n32->slots[i], i, is_leaf, level);
+
+				if (!is_leaf)
+				{
+					if (recurse)
+					{
+						StringInfoData buf2;
+
+						initStringInfo(&buf2);
+						radix_tree_dump_node((radix_tree_node *) n32->slots[i], level + 1, &buf2, recurse);
+						appendStringInfo(buf, "%s", buf2.data);
+					}
+					else
+						appendStringInfo(buf, "\n");
+				}
+			}
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_128:
+		{
+			radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+
+			for (int j = 0; j < 256; j++)
+			{
+				if (!node_128_is_chunk_used(n128, j))
+					continue;
+
+				appendStringInfo(buf, "slot_idxs[%d]=%d, ", j, n128->slot_idxs[j]);
+			}
+			appendStringInfo(buf, "\nisset-bitmap:");
+			for (int j = 0; j < 16; j++)
+			{
+				appendStringInfo(buf, "%X ", (uint8) n128->isset[j]);
+			}
+			appendStringInfo(buf, "\n");
+
+			for (int i = 0; i < 256; i++)
+			{
+				if (!node_128_is_chunk_used(n128, i))
+					continue;
+
+				radix_tree_print_slot(buf, i, node_128_get_chunk_slot(n128, i),
+									  i, is_leaf, level);
+
+				if (!is_leaf)
+				{
+					if (recurse)
+					{
+						StringInfoData buf2;
+
+						initStringInfo(&buf2);
+						radix_tree_dump_node((radix_tree_node *) node_128_get_chunk_slot(n128, i),
+											 level + 1, &buf2, recurse);
+						appendStringInfo(buf, "%s", buf2.data);
+					}
+					else
+						appendStringInfo(buf, "\n");
+				}
+			}
+			break;
+		}
+		case RADIX_TREE_NODE_KIND_256:
+		{
+			radix_tree_node_256 *n256 = (radix_tree_node_256 *) node;
+
+			for (int i = 0; i < 256; i++)
+			{
+				if (!node_256_is_chunk_used(n256, i))
+					continue;
+
+				radix_tree_print_slot(buf, i, n256->slots[i], i, is_leaf, level);
+
+				if (!is_leaf)
+				{
+					if (recurse)
+					{
+						StringInfoData buf2;
+
+						initStringInfo(&buf2);
+						radix_tree_dump_node((radix_tree_node *) n256->slots[i], level + 1, &buf2, recurse);
+						appendStringInfo(buf, "%s", buf2.data);
+					}
+					else
+						appendStringInfo(buf, "\n");
+				}
+			}
+			break;
+		}
+	}
+}
+
+void
+radix_tree_dump_search(radix_tree *tree, uint64 key)
+{
+	StringInfoData buf;
+	radix_tree_node *node;
+	int shift;
+	int level = 0;
+
+	elog(NOTICE, "-----------------------------------------------------------");
+	elog(NOTICE, "max_val = %lu (0x%lX)", tree->max_val, tree->max_val);
+
+	if (!tree->root)
+	{
+		elog(NOTICE, "tree is empty");
+		return;
+	}
+
+	if (key > tree->max_val)
+	{
+		elog(NOTICE, "key %lu (0x%lX) is larger than max val",
+			 key, key);
+		return;
+	}
+
+	initStringInfo(&buf);
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift >= 0)
+	{
+		radix_tree_node *child;
+
+		radix_tree_dump_node(node, level, &buf, false);
+
+		if (IS_LEAF_NODE(node))
+		{
+			Datum *dummy;
+
+			/* We reached at a leaf node, find the corresponding slot */
+			radix_tree_node_search(node, &dummy, key, RADIX_TREE_FIND);
+
+			break;
+		}
+
+		if (!radix_tree_node_search_child(node, &child, key))
+			break;
+
+		node = child;
+		shift -= RADIX_TREE_NODE_FANOUT;
+		level++;
+	}
+
+	elog(NOTICE, "\n%s", buf.data);
+}
+
+void
+radix_tree_dump(radix_tree *tree)
+{
+	StringInfoData buf;
+
+	initStringInfo(&buf);
+
+	elog(NOTICE, "-----------------------------------------------------------");
+	elog(NOTICE, "max_val = %lu", tree->max_val);
+	radix_tree_dump_node(tree->root, 0, &buf, true);
+	elog(NOTICE, "\n%s", buf.data);
+	elog(NOTICE, "-----------------------------------------------------------");
+}
+#endif
diff --git a/src/include/lib/radixtree.h b/src/include/lib/radixtree.h
new file mode 100644
index 0000000000..c072f8ea98
--- /dev/null
+++ b/src/include/lib/radixtree.h
@@ -0,0 +1,42 @@
+/*-------------------------------------------------------------------------
+ *
+ * radixtree.h
+ *	  Interface for radix tree.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		src/include/lib/radixtree.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RADIXTREE_H
+#define RADIXTREE_H
+
+#include "postgres.h"
+
+#define RADIX_TREE_DEBUG 1
+
+typedef struct radix_tree radix_tree;
+typedef struct radix_tree_iter radix_tree_iter;
+
+extern radix_tree *radix_tree_create(MemoryContext ctx);
+extern bool radix_tree_search(radix_tree *tree, uint64 key, Datum *val_p);
+extern void radix_tree_insert(radix_tree *tree, uint64 key, Datum val, bool *found_p);
+extern bool radix_tree_delete(radix_tree *tree, uint64 key);
+extern void radix_tree_destroy(radix_tree *tree);
+extern uint64 radix_tree_memory_usage(radix_tree *tree);
+extern uint64 radix_tree_num_entries(radix_tree *tree);
+
+extern radix_tree_iter *radix_tree_begin_iterate(radix_tree *tree);
+extern bool radix_tree_iterate_next(radix_tree_iter *iter, uint64 *key_p, Datum *value_p);
+extern void radix_tree_end_iterate(radix_tree_iter *iter);
+
+
+#ifdef RADIX_TREE_DEBUG
+extern void radix_tree_dump(radix_tree *tree);
+extern void radix_tree_dump_search(radix_tree *tree, uint64 key);
+extern void radix_tree_stats(radix_tree *tree);
+#endif
+
+#endif /* RADIXTREE_H */
diff --git a/src/test/modules/Makefile b/src/test/modules/Makefile
index 9090226daa..51b2514faf 100644
--- a/src/test/modules/Makefile
+++ b/src/test/modules/Makefile
@@ -24,6 +24,7 @@ SUBDIRS = \
 		  test_parser \
 		  test_pg_dump \
 		  test_predtest \
+		  test_radixtree \
 		  test_rbtree \
 		  test_regex \
 		  test_rls_hooks \
diff --git a/src/test/modules/test_radixtree/.gitignore b/src/test/modules/test_radixtree/.gitignore
new file mode 100644
index 0000000000..5dcb3ff972
--- /dev/null
+++ b/src/test/modules/test_radixtree/.gitignore
@@ -0,0 +1,4 @@
+# Generated subdirectories
+/log/
+/results/
+/tmp_check/
diff --git a/src/test/modules/test_radixtree/Makefile b/src/test/modules/test_radixtree/Makefile
new file mode 100644
index 0000000000..da06b93da3
--- /dev/null
+++ b/src/test/modules/test_radixtree/Makefile
@@ -0,0 +1,23 @@
+# src/test/modules/test_radixtree/Makefile
+
+MODULE_big = test_radixtree
+OBJS = \
+	$(WIN32RES) \
+	test_radixtree.o
+PGFILEDESC = "test_radixtree - test code for src/backend/lib/radixtree.c"
+
+EXTENSION = test_radixtree
+DATA = test_radixtree--1.0.sql
+
+REGRESS = test_radixtree
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = src/test/modules/test_radixtree
+top_builddir = ../../../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
diff --git a/src/test/modules/test_radixtree/README b/src/test/modules/test_radixtree/README
new file mode 100644
index 0000000000..a8b271869a
--- /dev/null
+++ b/src/test/modules/test_radixtree/README
@@ -0,0 +1,7 @@
+test_integerset contains unit tests for testing the integer set implementation
+in src/backend/lib/integerset.c.
+
+The tests verify the correctness of the implementation, but they can also be
+used as a micro-benchmark.  If you set the 'intset_test_stats' flag in
+test_integerset.c, the tests will print extra information about execution time
+and memory usage.
diff --git a/src/test/modules/test_radixtree/expected/test_integerset.out b/src/test/modules/test_radixtree/expected/test_integerset.out
new file mode 100644
index 0000000000..822dd031e9
--- /dev/null
+++ b/src/test/modules/test_radixtree/expected/test_integerset.out
@@ -0,0 +1,31 @@
+CREATE EXTENSION test_integerset;
+--
+-- All the logic is in the test_integerset() function. It will throw
+-- an error if something fails.
+--
+SELECT test_integerset();
+NOTICE:  testing intset with empty set
+NOTICE:  testing intset with distances > 2^60 between values
+NOTICE:  testing intset with single value 0
+NOTICE:  testing intset with single value 1
+NOTICE:  testing intset with single value 18446744073709551614
+NOTICE:  testing intset with single value 18446744073709551615
+NOTICE:  testing intset with value 0, and all between 1000 and 2000
+NOTICE:  testing intset with value 1, and all between 1000 and 2000
+NOTICE:  testing intset with value 1, and all between 1000 and 2000000
+NOTICE:  testing intset with value 18446744073709551614, and all between 1000 and 2000
+NOTICE:  testing intset with value 18446744073709551615, and all between 1000 and 2000
+NOTICE:  testing intset with pattern "all ones"
+NOTICE:  testing intset with pattern "alternating bits"
+NOTICE:  testing intset with pattern "clusters of ten"
+NOTICE:  testing intset with pattern "clusters of hundred"
+NOTICE:  testing intset with pattern "one-every-64k"
+NOTICE:  testing intset with pattern "sparse"
+NOTICE:  testing intset with pattern "single values, distance > 2^32"
+NOTICE:  testing intset with pattern "clusters, distance > 2^32"
+NOTICE:  testing intset with pattern "clusters, distance > 2^60"
+ test_integerset 
+-----------------
+ 
+(1 row)
+
diff --git a/src/test/modules/test_radixtree/expected/test_radixtree.out b/src/test/modules/test_radixtree/expected/test_radixtree.out
new file mode 100644
index 0000000000..0c96ebc739
--- /dev/null
+++ b/src/test/modules/test_radixtree/expected/test_radixtree.out
@@ -0,0 +1,20 @@
+CREATE EXTENSION test_radixtree;
+--
+-- All the logic is in the test_radixtree() function. It will throw
+-- an error if something fails.
+--
+SELECT test_radixtree();
+NOTICE:  testing radix tree with pattern "all ones"
+NOTICE:  testing radix tree with pattern "alternating bits"
+NOTICE:  testing radix tree with pattern "clusters of ten"
+NOTICE:  testing radix tree with pattern "clusters of hundred"
+NOTICE:  testing radix tree with pattern "one-every-64k"
+NOTICE:  testing radix tree with pattern "sparse"
+NOTICE:  testing radix tree with pattern "single values, distance > 2^32"
+NOTICE:  testing radix tree with pattern "clusters, distance > 2^32"
+NOTICE:  testing radix tree with pattern "clusters, distance > 2^60"
+ test_radixtree 
+----------------
+ 
+(1 row)
+
diff --git a/src/test/modules/test_radixtree/sql/test_radixtree.sql b/src/test/modules/test_radixtree/sql/test_radixtree.sql
new file mode 100644
index 0000000000..41ece5e9f5
--- /dev/null
+++ b/src/test/modules/test_radixtree/sql/test_radixtree.sql
@@ -0,0 +1,7 @@
+CREATE EXTENSION test_radixtree;
+
+--
+-- All the logic is in the test_radixtree() function. It will throw
+-- an error if something fails.
+--
+SELECT test_radixtree();
diff --git a/src/test/modules/test_radixtree/test_radixtree--1.0.sql b/src/test/modules/test_radixtree/test_radixtree--1.0.sql
new file mode 100644
index 0000000000..074a5a7ea7
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree--1.0.sql
@@ -0,0 +1,8 @@
+/* src/test/modules/test_radixtree/test_radixtree--1.0.sql */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION test_radixtree" to load this file. \quit
+
+CREATE FUNCTION test_radixtree()
+RETURNS pg_catalog.void STRICT
+AS 'MODULE_PATHNAME' LANGUAGE C;
diff --git a/src/test/modules/test_radixtree/test_radixtree.c b/src/test/modules/test_radixtree/test_radixtree.c
new file mode 100644
index 0000000000..e93c7f6676
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree.c
@@ -0,0 +1,446 @@
+/*--------------------------------------------------------------------------
+ *
+ * test_radixtree.c
+ *		Test radixtree set data structure.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		src/test/modules/test_radixtree/test_radixtree.c
+ *
+ * -------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "common/pg_prng.h"
+#include "fmgr.h"
+#include "lib/radixtree.h"
+#include "miscadmin.h"
+#include "nodes/bitmapset.h"
+#include "storage/block.h"
+#include "storage/itemptr.h"
+#include "utils/memutils.h"
+#include "utils/timestamp.h"
+
+#define UINT64_HEX_FORMAT "%" INT64_MODIFIER "X"
+
+/*
+ * If you enable this, the "pattern" tests will print information about
+ * how long populating, probing, and iterating the test set takes, and
+ * how much memory the test set consumed.  That can be used as
+ * micro-benchmark of various operations and input patterns (you might
+ * want to increase the number of values used in each of the test, if
+ * you do that, to reduce noise).
+ *
+ * The information is printed to the server's stderr, mostly because
+ * that's where MemoryContextStats() output goes.
+ */
+static const bool radix_tree_test_stats = true;
+
+static int radix_tree_node_max_entries[] = {4, 16, 128, 256};
+
+/*
+ * A struct to define a pattern of integers, for use with the test_pattern()
+ * function.
+ */
+typedef struct
+{
+	char	   *test_name;		/* short name of the test, for humans */
+	char	   *pattern_str;	/* a bit pattern */
+	uint64		spacing;		/* pattern repeats at this interval */
+	uint64		num_values;		/* number of integers to set in total */
+} test_spec;
+
+static const test_spec test_specs[] = {
+	{
+		"all ones", "1111111111",
+		10, 1000000
+	},
+	{
+		"alternating bits", "0101010101",
+		10, 1000000
+	},
+	{
+		"clusters of ten", "1111111111",
+		10000, 1000000
+	},
+	{
+		"clusters of hundred",
+		"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111",
+		10000, 10000000
+	},
+	{
+		"one-every-64k", "1",
+		65536, 1000000
+	},
+	{
+		"sparse", "100000000000000000000000000000001",
+		10000000, 1000000
+	},
+	{
+		"single values, distance > 2^32", "1",
+		UINT64CONST(10000000000), 100000
+	},
+	{
+		"clusters, distance > 2^32", "10101010",
+		UINT64CONST(10000000000), 1000000
+	},
+	{
+		"clusters, distance > 2^60", "10101010",
+		UINT64CONST(2000000000000000000),
+		23						/* can't be much higher than this, or we
+								 * overflow uint64 */
+	}
+};
+
+PG_MODULE_MAGIC;
+
+PG_FUNCTION_INFO_V1(test_radixtree);
+
+static void test_empty(void);
+
+static void
+test_empty(void)
+{
+	radix_tree *radixtree;
+	Datum dummy;
+
+	radixtree = radix_tree_create(CurrentMemoryContext);
+
+	if (radix_tree_search(radixtree, 0, &dummy))
+		elog(ERROR, "radix_tree_search on empty tree returned true");
+
+	if (radix_tree_search(radixtree, 1, &dummy))
+		elog(ERROR, "radix_tree_search on empty tree returned true");
+
+	if (radix_tree_search(radixtree, PG_UINT64_MAX, &dummy))
+		elog(ERROR, "radix_tree_search on empty tree returned true");
+
+	if (radix_tree_num_entries(radixtree) != 0)
+		elog(ERROR, "radix_tree_num_entries on empty tree return non-zero");
+
+	radix_tree_destroy(radixtree);
+}
+
+static void
+check_search_on_node(radix_tree *radixtree, uint8 shift, int start, int end)
+{
+	for (int i = start; i < end; i++)
+	{
+		uint64 key = ((uint64) i << shift);
+		Datum val;
+
+		if (!radix_tree_search(radixtree, key, &val))
+			elog(ERROR, "key 0x" UINT64_HEX_FORMAT " is not found on node-%d",
+				 key, end);
+		if (DatumGetUInt64(val) != key)
+			elog(ERROR, "radix_tree_search with key 0x" UINT64_HEX_FORMAT " returns 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT,
+				 key, DatumGetUInt64(val), key);
+	}
+}
+
+static void
+test_node_types(uint8 shift)
+{
+	radix_tree *radixtree;
+	uint64 num_entries;
+
+	radixtree = radix_tree_create(CurrentMemoryContext);
+
+	for (int i = 0; i < 256; i++)
+	{
+		uint64 key = ((uint64) i << shift);
+		bool found;
+
+		radix_tree_insert(radixtree, key, Int64GetDatum(key), &found);
+
+		if (found)
+			elog(ERROR, "newly inserted key 0x" UINT64_HEX_FORMAT " found", key);
+
+		for (int j = 0; j < lengthof(radix_tree_node_max_entries); j++)
+		{
+			if (i == (radix_tree_node_max_entries[j] - 1))
+			{
+				check_search_on_node(radixtree, shift,
+									 (j == 0) ? 0 : radix_tree_node_max_entries[j - 1],
+									 radix_tree_node_max_entries[j]);
+				break;
+			}
+		}
+	}
+
+	num_entries = radix_tree_num_entries(radixtree);
+
+	if (num_entries != 256)
+		elog(ERROR,
+			 "radix_tree_num_entries returned" UINT64_FORMAT ", expected " UINT64_FORMAT,
+			 num_entries, UINT64CONST(256));
+}
+
+/*
+ * Test with a repeating pattern, defined by the 'spec'.
+ */
+static void
+test_pattern(const test_spec *spec)
+{
+	radix_tree *radixtree;
+	radix_tree_iter *iter;
+	MemoryContext radixtree_ctx;
+	TimestampTz starttime;
+	TimestampTz endtime;
+	uint64		n;
+	uint64		last_int;
+	uint64		ndeleted;
+	uint64		nbefore;
+	uint64		nafter;
+	int			patternlen;
+	uint64	   *pattern_values;
+	uint64		pattern_num_values;
+
+	elog(NOTICE, "testing radix tree with pattern \"%s\"", spec->test_name);
+	if (radix_tree_test_stats)
+		fprintf(stderr, "-----\ntesting radix tree with pattern \"%s\"\n", spec->test_name);
+
+	/* Pre-process the pattern, creating an array of integers from it. */
+	patternlen = strlen(spec->pattern_str);
+	pattern_values = palloc(patternlen * sizeof(uint64));
+	pattern_num_values = 0;
+	for (int i = 0; i < patternlen; i++)
+	{
+		if (spec->pattern_str[i] == '1')
+			pattern_values[pattern_num_values++] = i;
+	}
+
+	/*
+	 * Allocate the integer set.
+	 *
+	 * Allocate it in a separate memory context, so that we can print its
+	 * memory usage easily.
+	 */
+	radixtree_ctx = AllocSetContextCreate(CurrentMemoryContext,
+										  "radixtree test",
+										  ALLOCSET_SMALL_SIZES);
+	MemoryContextSetIdentifier(radixtree_ctx, spec->test_name);
+	radixtree = radix_tree_create(radixtree_ctx);
+
+	/*
+	 * Add values to the set.
+	 */
+	starttime = GetCurrentTimestamp();
+
+	n = 0;
+	last_int = 0;
+	while (n < spec->num_values)
+	{
+		uint64		x = 0;
+
+		for (int i = 0; i < pattern_num_values && n < spec->num_values; i++)
+		{
+			bool found;
+
+			x = last_int + pattern_values[i];
+
+			radix_tree_insert(radixtree, x, Int64GetDatum(x), &found);
+
+			if (found)
+				elog(ERROR, "newly inserted key 0x" UINT64_HEX_FORMAT " found", x);
+
+			n++;
+		}
+		last_int += spec->spacing;
+	}
+
+	endtime = GetCurrentTimestamp();
+
+	if (radix_tree_test_stats)
+		fprintf(stderr, "added " UINT64_FORMAT " values in %d ms\n",
+				spec->num_values, (int) (endtime - starttime) / 1000);
+
+	/*
+	 * Print stats on the amount of memory used.
+	 *
+	 * We print the usage reported by radix_tree_memory_usage(), as well as the
+	 * stats from the memory context.  They should be in the same ballpark,
+	 * but it's hard to automate testing that, so if you're making changes to
+	 * the implementation, just observe that manually.
+	 */
+	if (radix_tree_test_stats)
+	{
+		uint64		mem_usage;
+
+		/*
+		 * Also print memory usage as reported by radix_tree_memory_usage().  It
+		 * should be in the same ballpark as the usage reported by
+		 * MemoryContextStats().
+		 */
+		mem_usage = radix_tree_memory_usage(radixtree);
+		fprintf(stderr, "radix_tree_memory_usage() reported " UINT64_FORMAT " (%0.2f bytes / integer)\n",
+				mem_usage, (double) mem_usage / spec->num_values);
+
+		MemoryContextStats(radixtree_ctx);
+	}
+
+	/* Check that radix_tree_num_entries works */
+	n = radix_tree_num_entries(radixtree);
+	if (n != spec->num_values)
+		elog(ERROR, "radix_tree_num_entries returned " UINT64_FORMAT ", expected " UINT64_FORMAT, n, spec->num_values);
+
+	/*
+	 * Test random-access probes with radix_tree_search()
+	 */
+	starttime = GetCurrentTimestamp();
+
+	for (n = 0; n < 100000; n++)
+	{
+		bool		found;
+		bool		expected;
+		uint64		x;
+		Datum		v;
+
+		/*
+		 * Pick next value to probe at random.  We limit the probes to the
+		 * last integer that we added to the set, plus an arbitrary constant
+		 * (1000).  There's no point in probing the whole 0 - 2^64 range, if
+		 * only a small part of the integer space is used.  We would very
+		 * rarely hit values that are actually in the set.
+		 */
+		x = pg_prng_uint64_range(&pg_global_prng_state, 0, last_int + 1000);
+
+		/* Do we expect this value to be present in the set? */
+		if (x >= last_int)
+			expected = false;
+		else
+		{
+			uint64		idx = x % spec->spacing;
+
+			if (idx >= patternlen)
+				expected = false;
+			else if (spec->pattern_str[idx] == '1')
+				expected = true;
+			else
+				expected = false;
+		}
+
+		/* Is it present according to radix_tree_search() ? */
+		found = radix_tree_search(radixtree, x, &v);
+
+		if (found != expected)
+			elog(ERROR, "mismatch at 0x" UINT64_HEX_FORMAT ": %d vs %d", x, found, expected);
+		if (found && (DatumGetUInt64(v) != x))
+		{
+			radix_tree_dump_search(radixtree, x);
+			elog(ERROR, "found 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT,
+				 DatumGetUInt64(v), x);
+		}
+	}
+	endtime = GetCurrentTimestamp();
+	if (radix_tree_test_stats)
+		fprintf(stderr, "probed " UINT64_FORMAT " values in %d ms\n",
+				n, (int) (endtime - starttime) / 1000);
+
+	/*
+	 * Test iterator
+	 */
+	starttime = GetCurrentTimestamp();
+
+	iter = radix_tree_begin_iterate(radixtree);
+	n = 0;
+	last_int = 0;
+	while (n < spec->num_values)
+	{
+		for (int i = 0; i < pattern_num_values && n < spec->num_values; i++)
+		{
+			uint64		expected = last_int + pattern_values[i];
+			uint64		x;
+			uint64		val;
+
+			if (!radix_tree_iterate_next(iter, &x, &val))
+				break;
+
+			if (x != expected)
+				elog(ERROR,
+					 "iterate returned wrong key; got 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT " at %d", x, expected, i);
+			if (DatumGetUInt64(val) != expected)
+				elog(ERROR,
+					 "iterate returned wrong value; got 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT " at %d", x, expected, i);
+			n++;
+		}
+		last_int += spec->spacing;
+	}
+	endtime = GetCurrentTimestamp();
+	if (radix_tree_test_stats)
+		fprintf(stderr, "iterated " UINT64_FORMAT " values in %d ms\n",
+				n, (int) (endtime - starttime) / 1000);
+
+	if (n < spec->num_values)
+		elog(ERROR, "iterator stopped short after " UINT64_FORMAT " entries, expected " UINT64_FORMAT, n, spec->num_values);
+	if (n > spec->num_values)
+		elog(ERROR, "iterator returned " UINT64_FORMAT " entries, " UINT64_FORMAT " was expected", n, spec->num_values);
+
+	/*
+	 * Test random-access probes with radix_tree_delete()
+	 */
+	starttime = GetCurrentTimestamp();
+
+	nbefore = radix_tree_num_entries(radixtree);
+	ndeleted = 0;
+	for (n = 0; n < 100000; n++)
+	{
+		bool		found;
+		uint64		x;
+		Datum		v;
+
+		/*
+		 * Pick next value to probe at random.  We limit the probes to the
+		 * last integer that we added to the set, plus an arbitrary constant
+		 * (1000).  There's no point in probing the whole 0 - 2^64 range, if
+		 * only a small part of the integer space is used.  We would very
+		 * rarely hit values that are actually in the set.
+		 */
+		x = pg_prng_uint64_range(&pg_global_prng_state, 0, last_int + 1000);
+
+		/* Is it present according to radix_tree_search() ? */
+		found = radix_tree_search(radixtree, x, &v);
+
+		if (!found)
+			continue;
+
+		/* If the key is found, delete it and check again */
+		if (!radix_tree_delete(radixtree, x))
+			elog(ERROR, "could not delete key 0x" UINT64_HEX_FORMAT, x);
+		if (radix_tree_search(radixtree, x, &v))
+			elog(ERROR, "found deleted key 0x" UINT64_HEX_FORMAT, x);
+		if (radix_tree_delete(radixtree, x))
+			elog(ERROR, "deleted already-deleted key 0x" UINT64_HEX_FORMAT, x);
+
+		ndeleted++;
+	}
+	endtime = GetCurrentTimestamp();
+	if (radix_tree_test_stats)
+		fprintf(stderr, "deleted " UINT64_FORMAT " values in %d ms\n",
+				ndeleted, (int) (endtime - starttime) / 1000);
+
+	nafter = radix_tree_num_entries(radixtree);
+
+	/* Check that radix_tree_num_entries works */
+	if ((nbefore - ndeleted) != nafter)
+		elog(ERROR, "radix_tree_num_entries returned " UINT64_FORMAT ", expected " UINT64_FORMAT "after " UINT64_FORMAT " deletion",
+			 nafter, (nbefore - ndeleted), ndeleted);
+
+	MemoryContextDelete(radixtree_ctx);
+}
+
+Datum
+test_radixtree(PG_FUNCTION_ARGS)
+{
+	test_empty();
+
+	for (int shift = 0; shift <= (64 - 8); shift += 8)
+		test_node_types(shift);
+
+	/* Test different test patterns, with lots of entries */
+	for (int i = 0; i < lengthof(test_specs); i++)
+		test_pattern(&test_specs[i]);
+
+	PG_RETURN_VOID();
+}
diff --git a/src/test/modules/test_radixtree/test_radixtree.control b/src/test/modules/test_radixtree/test_radixtree.control
new file mode 100644
index 0000000000..e53f2a3e0c
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree.control
@@ -0,0 +1,4 @@
+comment = 'Test code for radix tree'
+default_version = '1.0'
+module_pathname = '$libdir/test_radixtree'
+relocatable = true

diff --git a/config/c-compiler.m4 b/config/c-compiler.m4
index d3562d6fee..a56d6e89da 100644
--- a/config/c-compiler.m4
+++ b/config/c-compiler.m4
@@ -676,3 +676,27 @@ if test x"$Ac_cachevar" = x"yes"; then
 fi
 undefine([Ac_cachevar])dnl
 ])# PGAC_ARMV8_CRC32C_INTRINSICS
+
+# PGAC_AVX2_INTRINSICS
+# --------------------
+# Check if the compiler supports the Intel AVX2 instructinos.
+#
+# If the intrinsics are supported, sets pgac_avx2_intrinsics, and CFLAGS_AVX2.
+AC_DEFUN([PGAC_AVX2_INTRINSICS],
+[define([Ac_cachevar], [AS_TR_SH([pgac_cv_avx2_intrinsics_$1])])dnl
+AC_CACHE_CHECK([for _mm256_set_1_epi8 _mm256_cmpeq_epi8 _mm256_movemask_epi8 CFLAGS=$1], [Ac_cachevar],
+[pgac_save_CFLAGS=$CFLAGS
+CFLAGS="$pgac_save_CFLAGS $1"
+AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <immintrin.h>],
+  [__m256i vec = _mm256_set1_epi8(0);
+   __m256i cmp = _mm256_cmpeq_epi8(vec, vec);
+   return _mm256_movemask_epi8(cmp) > 0;])],
+  [Ac_cachevar=yes],
+  [Ac_cachevar=no])
+CFLAGS="$pgac_save_CFLAGS"])
+if test x"$Ac_cachevar" = x"yes"; then
+  CFLAGS_AVX2="$1"
+  pgac_avx2_intrinsics=yes
+fi
+undefine([Ac_cachevar])dnl
+])# PGAC_AVX2_INTRINSICS
diff --git a/configure b/configure
index 7dec6b7bf9..6ebc15a8c1 100755
--- a/configure
+++ b/configure
@@ -645,6 +645,7 @@ XGETTEXT
 MSGMERGE
 MSGFMT_FLAGS
 MSGFMT
+CFLAGS_AVX2
 PG_CRC32C_OBJS
 CFLAGS_ARMV8_CRC32C
 CFLAGS_SSE42
@@ -18829,6 +18830,82 @@ $as_echo "slicing-by-8" >&6; }
 fi
 
 
+# Check for Intel AVX2 intrinsics.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for _mm256i CFLAGS=" >&5
+$as_echo_n "checking for _mm256i CFLAGS=... " >&6; }
+if ${pgac_cv_avx2_intrinsics_+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  pgac_save_CFLAGS=$CFLAGS
+CFLAGS="$pgac_save_CFLAGS "
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <immintrin.h>
+int
+main ()
+{
+__m256i vec = _mm256_set1_epi8(0);
+   __m256i cmp = _mm256_cmpeq_epi8(vec, vec);
+   return _mm256_movemask_epi8(cmp) > 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  pgac_cv_avx2_intrinsics_=yes
+else
+  pgac_cv_avx2_intrinsics_=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+CFLAGS="$pgac_save_CFLAGS"
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $pgac_cv_avx2_intrinsics_" >&5
+$as_echo "$pgac_cv_avx2_intrinsics_" >&6; }
+if test x"$pgac_cv_avx2_intrinsics_" = x"yes"; then
+  CFLAGS_AVX2=""
+  pgac_avx2_intrinsics=yes
+fi
+
+if test x"pgac_avx2_intrinsics" != x"yes"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _mm256i CFLAGS=-mavx2" >&5
+$as_echo_n "checking for _mm256i CFLAGS=-mavx2... " >&6; }
+if ${pgac_cv_avx2_intrinsics__mavx2+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  pgac_save_CFLAGS=$CFLAGS
+CFLAGS="$pgac_save_CFLAGS -mavx2"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <immintrin.h>
+int
+main ()
+{
+__m256i vec = _mm256_set1_epi8(0);
+   __m256i cmp = _mm256_cmpeq_epi8(vec, vec);
+   return _mm256_movemask_epi8(cmp) > 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  pgac_cv_avx2_intrinsics__mavx2=yes
+else
+  pgac_cv_avx2_intrinsics__mavx2=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+CFLAGS="$pgac_save_CFLAGS"
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $pgac_cv_avx2_intrinsics__mavx2" >&5
+$as_echo "$pgac_cv_avx2_intrinsics__mavx2" >&6; }
+if test x"$pgac_cv_avx2_intrinsics__mavx2" = x"yes"; then
+  CFLAGS_AVX2="-mavx2"
+  pgac_avx2_intrinsics=yes
+fi
+
+fi
+
 
 # Select semaphore implementation type.
 if test "$PORTNAME" != "win32"; then
diff --git a/configure.ac b/configure.ac
index d093fb88dd..6b6d095306 100644
--- a/configure.ac
+++ b/configure.ac
@@ -2300,6 +2300,12 @@ else
 fi
 AC_SUBST(PG_CRC32C_OBJS)
 
+# Check for Intel AVX2 intrinsics.
+PGAC_AVX2_INTRINSICS([])
+if test x"pgac_avx2_intrinsics" != x"yes"; then
+  PGAC_AVX2_INTRINSICS([-mavx2])
+fi
+AC_SUBST(CFLAGS_AVX2)
 
 # Select semaphore implementation type.
 if test "$PORTNAME" != "win32"; then
diff --git a/src/Makefile.global.in b/src/Makefile.global.in
index 051718e4fe..9717094724 100644
--- a/src/Makefile.global.in
+++ b/src/Makefile.global.in
@@ -263,6 +263,7 @@ CFLAGS_UNROLL_LOOPS = @CFLAGS_UNROLL_LOOPS@
 CFLAGS_VECTORIZE = @CFLAGS_VECTORIZE@
 CFLAGS_SSE42 = @CFLAGS_SSE42@
 CFLAGS_ARMV8_CRC32C = @CFLAGS_ARMV8_CRC32C@
+CFLAGS_AVX2 = @CFLAGS_AVX2@
 PERMIT_DECLARATION_AFTER_STATEMENT = @PERMIT_DECLARATION_AFTER_STATEMENT@
 CXXFLAGS = @CXXFLAGS@
 
diff --git a/src/backend/lib/Makefile b/src/backend/lib/Makefile
index 9dad31398a..5e4516ca90 100644
--- a/src/backend/lib/Makefile
+++ b/src/backend/lib/Makefile
@@ -22,6 +22,10 @@ OBJS = \
 	integerset.o \
 	knapsack.o \
 	pairingheap.o \
+	radixtree.o \
 	rbtree.o \
 
+# radixtree.o need CFLAGS_AVX2
+radixtree.o: CFLAGS+=$(CFLAGS_AVX2)
+
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/lib/radixtree.c b/src/backend/lib/radixtree.c
new file mode 100644
index 0000000000..bf87f932fd
--- /dev/null
+++ b/src/backend/lib/radixtree.c
@@ -0,0 +1,1763 @@
+/*-------------------------------------------------------------------------
+ *
+ * radixtree.c
+ *		Implementation for adaptive radix tree.
+ *
+ * This module employs the idea from the paper "The Adaptive Radix Tree: ARTful
+ * Indexing for Main-Memory Databases" by Viktor Leis, Alfons Kemper, and Thomas
+ * Neumann, 2013.
+ *
+ * There are some differences from the proposed implementation.  For instance,
+ * this radix tree module utilizes AVX2 instruction, enabling us to use 256-bit
+ * width SIMD vector, whereas 128-bit width SIMD vector is used in the paper.
+ * Also, there is no support for path compression and lazy path expansion. The
+ * radix tree supports fixed length of the key so we don't expect the tree level
+ * wouldn't be high.
+ *
+ * The key is a 64-bit unsigned integer and the value is a Datum. Both internal
+ * nodes and leaf nodes have the identical structure. For internal tree nodes,
+ * shift > 0, store the pointer to its child node as the value. The leaf nodes,
+ * shift == 0, also have the Datum value that is specified by the user.
+ *
+ * XXX: the radix tree node never be shrunk.
+ *
+ * Interface
+ * ---------
+ *
+ * radix_tree_create		- Create a new, empty radix tree
+ * radix_tree_free			- Free the radix tree
+ * radix_tree_insert		- Insert a key-value pair
+ * radix_tree_delete		- Delete a key-value pair
+ * radix_tree_begin_iterate	- Begin iterating through all key-value pairs
+ * radix_tree_iterate_next	- Return next key-value pair, if any
+ * radix_tree_end_iterate	- End iteration
+ *
+ * radix_tree_create() creates an empty radix tree in the given memory context
+ * and memory contexts for all kinds of radix tree node under the memory context.
+ *
+ * radix_tree_iterate_next() ensures returning key-value pairs in the ascending
+ * order of the key.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/lib/radixtree.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "miscadmin.h"
+#include "port/pg_bitutils.h"
+#include "utils/memutils.h"
+#include "lib/radixtree.h"
+#include "lib/stringinfo.h"
+
+#if defined(__AVX2__)
+#include <immintrin.h>			/* AVX2 intrinsics */
+#endif
+
+/* The number of bits encoded in one tree level */
+#define RADIX_TREE_NODE_FANOUT	8
+
+/* The number of maximum slots in the node, used in node-256 */
+#define RADIX_TREE_NODE_MAX_SLOTS (1 << RADIX_TREE_NODE_FANOUT)
+
+/*
+ * Return the number of bits required to represent nslots slots, used
+ * in node-128 and node-256.
+ */
+#define RADIX_TREE_NODE_NSLOTS_BITS(nslots) ((nslots) / (sizeof(uint8) * BITS_PER_BYTE))
+
+/* Mask for extracting a chunk from the key */
+#define RADIX_TREE_CHUNK_MASK ((1 << RADIX_TREE_NODE_FANOUT) - 1)
+
+/* Maximum shift the radix tree uses */
+#define RADIX_TREE_MAX_SHIFT	key_get_shift(UINT64_MAX)
+
+/* Tree level the radix tree uses */
+#define RADIX_TREE_MAX_LEVEL	((sizeof(uint64) * BITS_PER_BYTE) / RADIX_TREE_NODE_FANOUT)
+
+/* Get a chunk from the key */
+#define GET_KEY_CHUNK(key, shift) \
+	((uint8) (((key) >> (shift)) & RADIX_TREE_CHUNK_MASK))
+
+/* Mapping from the value to the bit in is-set bitmap in the node-128 and node-256 */
+#define NODE_BITMAP_BYTE(v) ((v) / RADIX_TREE_NODE_FANOUT)
+#define NODE_BITMAP_BIT(v) (UINT64_C(1) << ((v) % RADIX_TREE_NODE_FANOUT))
+
+/* Enum used radix_tree_node_search() */
+typedef enum
+{
+	RADIX_TREE_FIND = 0,		/* find the key-value */
+	RADIX_TREE_DELETE,			/* delete the key-value */
+} radix_tree_action;
+
+/*
+ * supported radix tree nodes.
+ *
+ * XXX: should we add KIND_16 as we can utilize SSE2 SIMD instructions?
+ */
+typedef enum radix_tree_node_kind
+{
+	RADIX_TREE_NODE_KIND_4 = 0,
+	RADIX_TREE_NODE_KIND_32,
+	RADIX_TREE_NODE_KIND_128,
+	RADIX_TREE_NODE_KIND_256
+} radix_tree_node_kind;
+#define RADIX_TREE_NODE_KIND_COUNT 4
+
+/*
+ * Base type for all nodes types.
+ */
+typedef struct radix_tree_node
+{
+	/*
+	 * Number of children.  We use uint16 to be able to indicate 256 children
+	 * at ta fanout of 8.
+	 */
+	uint16		count;
+
+	/*
+	 * Shift indicates which part of the key space is represented by this
+	 * node. That is, the key is shifted by 'shift' and the lowest
+	 * RADIX_TREE_NODE_FANOUT bits are then represented in chunk.
+	 */
+	uint8		shift;
+	uint8		chunk;
+
+	/* Size class of the node */
+	radix_tree_node_kind kind;
+} radix_tree_node;
+
+/* Macros for radix tree nodes */
+#define IS_LEAF_NODE(n) (((radix_tree_node *) (n))->shift == 0)
+#define IS_EMPTY_NODE(n) (((radix_tree_node *) (n))->count == 0)
+#define NODE_HAS_FREE_SLOT(n) \
+	(((radix_tree_node *) (n))->count < \
+	 radix_tree_node_info[((radix_tree_node *) (n))->kind].max_slots)
+
+/*
+ * To reduce memory usage compared to a simple radix tree with a fixed fanout
+ * we use adaptive node sides, with different storage methods for different
+ * numbers of elements.
+ */
+typedef struct radix_tree_node_4
+{
+	radix_tree_node n;
+
+	/* 4 children, for key chunks */
+	uint8		chunks[4];
+	Datum		slots[4];
+} radix_tree_node_4;
+
+typedef struct radix_tree_node_32
+{
+	radix_tree_node n;
+
+	/* 32 children, for key chunks */
+	uint8		chunks[32];
+	Datum		slots[32];
+} radix_tree_node_32;
+
+#define RADIX_TREE_NODE_128_BITS RADIX_TREE_NODE_NSLOTS_BITS(128)
+typedef struct radix_tree_node_128
+{
+	radix_tree_node n;
+
+	/*
+	 * The index of slots for each fanout. 0 means unused whereas slots is
+	 * 0-indexed. So we can get the slot of the chunk C by slots[C] - 1.
+	 */
+	uint8		slot_idxs[RADIX_TREE_NODE_MAX_SLOTS];
+
+	/* A bitmap to track which slot is in use */
+	uint8		isset[RADIX_TREE_NODE_128_BITS];
+
+	Datum		slots[128];
+} radix_tree_node_128;
+
+#define RADIX_TREE_NODE_MAX_BITS RADIX_TREE_NODE_NSLOTS_BITS(RADIX_TREE_NODE_MAX_SLOTS)
+typedef struct radix_tree_node_256
+{
+	radix_tree_node n;
+
+	/* A bitmap to track which slot is in use */
+	uint8		isset[RADIX_TREE_NODE_MAX_BITS];
+
+	Datum		slots[RADIX_TREE_NODE_MAX_SLOTS];
+} radix_tree_node_256;
+
+/* Information of each size class */
+typedef struct radix_tree_node_info_elem
+{
+	const char *name;
+	int			max_slots;
+	Size		size;
+} radix_tree_node_info_elem;
+
+static radix_tree_node_info_elem radix_tree_node_info[] =
+{
+	{"radix tree node 4", 4, sizeof(radix_tree_node_4)},
+	{"radix tree node 32", 32, sizeof(radix_tree_node_32)},
+	{"radix tree node 128", 128, sizeof(radix_tree_node_128)},
+	{"radix tree node 256", 256, sizeof(radix_tree_node_256)},
+};
+
+/*
+ * As we descend a radix tree, we push the node to the stack. The stack is used
+ * at deletion.
+ */
+typedef struct radix_tree_stack_data
+{
+	radix_tree_node *node;
+	struct radix_tree_stack_data *parent;
+} radix_tree_stack_data;
+typedef radix_tree_stack_data *radix_tree_stack;
+
+/*
+ * Iteration support.
+ *
+ * Iterating the radix tree returns each pair of key and value in the ascending order
+ * of the key. To support this, the we iterate nodes of each level.
+ * radix_tree_iter_node_data struct is used to track the iteration within a node.
+ * radix_tree_iter has the array of this struct, stack, in order to track the iteration
+ * of every level. During the iteration, we also construct the key to return. The key
+ * is updated whenever we update the node iteration information, e.g., when advancing
+ * the current index within the node or when moving to the next node at the same level.
+ */
+typedef struct radix_tree_iter_node_data
+{
+	radix_tree_node *node;		/* current node being iterated */
+	int			current_idx;	/* current position. -1 for initial value */
+} radix_tree_iter_node_data;
+
+struct radix_tree_iter
+{
+	radix_tree *tree;
+
+	/* Track the iteration on nodes of each level */
+	radix_tree_iter_node_data stack[RADIX_TREE_MAX_LEVEL];
+	int			stack_len;
+
+	/* The key is being constructed during the iteration */
+	uint64		key;
+};
+
+/* A radix tree with nodes */
+struct radix_tree
+{
+	MemoryContext context;
+
+	radix_tree_node *root;
+	uint64		max_val;
+	uint64		num_keys;
+	MemoryContextData *slabs[RADIX_TREE_NODE_KIND_COUNT];
+
+	/* statistics */
+	uint64		mem_used;
+	int32		cnt[RADIX_TREE_NODE_KIND_COUNT];
+};
+
+static radix_tree_node *radix_tree_node_grow(radix_tree *tree, radix_tree_node *parent,
+											 radix_tree_node *node, uint64 key);
+static bool radix_tree_node_search_child(radix_tree_node *node, radix_tree_node **child_p,
+										 uint64 key);
+static bool radix_tree_node_search(radix_tree_node *node, Datum **slot_p, uint64 key,
+								   radix_tree_action action);
+static void radix_tree_extend(radix_tree *tree, uint64 key);
+static void radix_tree_new_root(radix_tree *tree, uint64 key, Datum val);
+static radix_tree_node *radix_tree_node_insert_child(radix_tree *tree,
+													 radix_tree_node *parent,
+													 radix_tree_node *node,
+													 uint64 key);
+static void radix_tree_node_insert_val(radix_tree *tree, radix_tree_node *parent,
+									   radix_tree_node *node, uint64 key, Datum val,
+									   bool *replaced_p);
+static inline void radix_tree_iter_update_key(radix_tree_iter *iter, uint8 chunk, uint8 shift);
+static Datum radix_tree_node_iterate_next(radix_tree_iter *iter, radix_tree_iter_node_data *node_iter,
+										  bool *found_p);
+static void radix_tree_store_iter_node(radix_tree_iter *iter, radix_tree_iter_node_data *node_iter,
+									   radix_tree_node *node);
+static void radix_tree_update_iter_stack(radix_tree_iter *iter, int from);
+static void radix_tree_verify_node(radix_tree_node *node);
+
+/*
+ * Helper functions for accessing each kind of nodes.
+ */
+static inline int
+node_32_search_eq(radix_tree_node_32 *node, uint8 chunk)
+{
+#ifdef __AVX2__
+	__m256i		_key = _mm256_set1_epi8(chunk);
+	__m256i		_data = _mm256_loadu_si256((__m256i_u *) node->chunks);
+	__m256i		_cmp = _mm256_cmpeq_epi8(_key, _data);
+	uint32		bitfield = _mm256_movemask_epi8(_cmp);
+
+	bitfield &= ((UINT64_C(1) << node->n.count) - 1);
+
+	return (bitfield) ? __builtin_ctz(bitfield) : -1;
+
+#else
+	for (int i = 0; i < node->n.count; i++)
+	{
+		if (node->chunks[i] > chunk)
+			return -1;
+
+		if (node->chunks[i] == chunk)
+			return i;
+	}
+
+	return -1;
+#endif							/* __AVX2__ */
+}
+
+/*
+ * This is a bit more complicated than search_chunk_array_16_eq(), because
+ * until recently no unsigned uint8 comparison instruction existed on x86. So
+ * we need to play some trickery using _mm_min_epu8() to effectively get
+ * <=. There never will be any equal elements in the current uses, but that's
+ * what we get here...
+ */
+static inline int
+node_32_search_le(radix_tree_node_32 *node, uint8 chunk)
+{
+#ifdef __AVX2__
+	__m256i		_key = _mm256_set1_epi8(chunk);
+	__m256i		_data = _mm256_loadu_si256((__m256i_u *) node->chunks);
+	__m256i		_min = _mm256_min_epu8(_key, _data);
+	__m256i		cmp = _mm256_cmpeq_epi8(_key, _min);
+	uint32_t	bitfield = _mm256_movemask_epi8(cmp);
+
+	bitfield &= ((UINT64_C(1) << node->n.count) - 1);
+
+	return (bitfield) ? __builtin_ctz(bitfield) : node->n.count;
+#else
+	int			index;
+
+	for (index = 0; index < node->n.count; index++)
+	{
+		if (node->chunks[index] >= chunk)
+			break;
+	}
+
+	return index;
+#endif							/* __AVX2__ */
+}
+
+/* Does the given chunk in the node has the value? */
+static inline bool
+node_128_is_chunk_used(radix_tree_node_128 *node, uint8 chunk)
+{
+	return (node->slot_idxs[chunk] != 0);
+}
+
+/* Is the slot in the node used? */
+static inline bool
+node_128_is_slot_used(radix_tree_node_128 *node, uint8 slot)
+{
+	return ((node->isset[NODE_BITMAP_BYTE(slot)] & NODE_BITMAP_BIT(slot)) != 0);
+}
+
+/* Set the slot at the corresponding chunk */
+static inline void
+node_128_set(radix_tree_node_128 *node, uint8 chunk, Datum val)
+{
+	int			slotpos = 0;
+
+	/* Search an unused slot */
+	while (node_128_is_slot_used(node, slotpos))
+		slotpos++;
+
+	node->slot_idxs[chunk] = slotpos + 1;
+	node->slots[slotpos] = val;
+	node->isset[NODE_BITMAP_BYTE(slotpos)] |= NODE_BITMAP_BIT(slotpos);
+}
+
+/* Delete the slot at the corresponding chunk */
+static inline void
+node_128_unset(radix_tree_node_128 *node, uint8 chunk)
+{
+	int			slotpos = node->slot_idxs[chunk] - 1;
+
+	if (!node_128_is_chunk_used(node, chunk))
+		return;
+
+	node->isset[NODE_BITMAP_BYTE(slotpos)] &= ~(NODE_BITMAP_BIT(slotpos));
+	node->slot_idxs[chunk] = 0;
+}
+
+/* Return the slot data corresponding to the chunk */
+static inline Datum
+node_128_get_chunk_slot(radix_tree_node_128 *node, uint8 chunk)
+{
+	return node->slots[node->slot_idxs[chunk] - 1];
+}
+
+/* Return true if the slot corresponding to the given chunk is in use */
+static inline bool
+node_256_is_chunk_used(radix_tree_node_256 *node, uint8 chunk)
+{
+	return (node->isset[NODE_BITMAP_BYTE(chunk)] & NODE_BITMAP_BIT(chunk)) != 0;
+}
+
+/* Set the slot at the given chunk position */
+static inline void
+node_256_set(radix_tree_node_256 *node, uint8 chunk, Datum slot)
+{
+	node->slots[chunk] = slot;
+	node->isset[NODE_BITMAP_BYTE(chunk)] |= NODE_BITMAP_BIT(chunk);
+}
+
+/* Set the slot at the given chunk position */
+static inline void
+node_256_unset(radix_tree_node_256 *node, uint8 chunk)
+{
+	node->isset[NODE_BITMAP_BYTE(chunk)] &= ~(NODE_BITMAP_BIT(chunk));
+}
+
+/*
+ * Return the shift that is satisfied to store the given key.
+ */
+inline static int
+key_get_shift(uint64 key)
+{
+	return (key == 0)
+		? 0
+		: (pg_leftmost_one_pos64(key) / RADIX_TREE_NODE_FANOUT) * RADIX_TREE_NODE_FANOUT;
+}
+
+/*
+ * Return the max value stored in a node with the given shift.
+ */
+static uint64
+shift_get_max_val(int shift)
+{
+	if (shift == RADIX_TREE_MAX_SHIFT)
+		return UINT64_MAX;
+
+	return (UINT64_C(1) << (shift + RADIX_TREE_NODE_FANOUT)) - 1;
+}
+
+/*
+ * Allocate a new node with the given node kind.
+ */
+static radix_tree_node *
+radix_tree_alloc_node(radix_tree *tree, radix_tree_node_kind kind)
+{
+	radix_tree_node *newnode;
+
+	newnode = (radix_tree_node *) MemoryContextAllocZero(tree->slabs[kind],
+														 radix_tree_node_info[kind].size);
+	newnode->kind = kind;
+
+	/* update the statistics */
+	tree->mem_used += GetMemoryChunkSpace(newnode);
+	tree->cnt[kind]++;
+
+	return newnode;
+}
+
+/* Free the given node */
+static void
+radix_tree_free_node(radix_tree *tree, radix_tree_node *node)
+{
+	/*
+	 * XXX: If we're deleting the root node, make the tree empty
+	 */
+	if (tree->root == node)
+	{
+		tree->root = NULL;
+	}
+
+	/* update the statistics */
+	tree->mem_used -= GetMemoryChunkSpace(node);
+	tree->cnt[node->kind]--;
+
+	Assert(tree->mem_used >= 0);
+	Assert(tree->cnt[node->kind] >= 0);
+
+	pfree(node);
+}
+
+/* Free a stack made by radix_tree_delete */
+static void
+radix_tree_free_stack(radix_tree_stack stack)
+{
+	radix_tree_stack ostack;
+
+	while (stack != NULL)
+	{
+		ostack = stack;
+		stack = stack->parent;
+		pfree(ostack);
+	}
+}
+
+/* Copy the common fields without the kind */
+static void
+radix_tree_copy_node_common(radix_tree_node *src, radix_tree_node *dst)
+{
+	dst->shift = src->shift;
+	dst->chunk = src->chunk;
+	dst->count = src->count;
+}
+
+/*
+ * The radix tree doesn't sufficient height. Extend the radix tree so it can
+ * store the key.
+ */
+static void
+radix_tree_extend(radix_tree *tree, uint64 key)
+{
+	int			max_shift;
+	int			shift = tree->root->shift + RADIX_TREE_NODE_FANOUT;
+
+	max_shift = key_get_shift(key);
+
+	/* Grow tree from 'shift' to 'max_shift' */
+	while (shift <= max_shift)
+	{
+		radix_tree_node_4 *node =
+		(radix_tree_node_4 *) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_4);
+
+		node->n.count = 1;
+		node->n.shift = shift;
+		node->chunks[0] = 0;
+		node->slots[0] = PointerGetDatum(tree->root);
+
+		tree->root->chunk = 0;
+		tree->root = (radix_tree_node *) node;
+
+		shift += RADIX_TREE_NODE_FANOUT;
+	}
+
+	tree->max_val = shift_get_max_val(max_shift);
+}
+
+/*
+ * Wrapper for radix_tree_node_search to search the pointer to the child node in the
+ * node.
+ *
+ * Return true if the corresponding child is found, otherwise return false.  On success,
+ * it sets child_p.
+ */
+static bool
+radix_tree_node_search_child(radix_tree_node *node, radix_tree_node **child_p, uint64 key)
+{
+	bool		found = false;
+	Datum	   *slot_ptr;
+
+	if (radix_tree_node_search(node, &slot_ptr, key, RADIX_TREE_FIND))
+	{
+		/* Found the pointer to the child node */
+		found = true;
+		*child_p = (radix_tree_node *) DatumGetPointer(*slot_ptr);
+	}
+
+	return found;
+}
+
+/*
+ * Return true if the corresponding slot is used, otherwise return false.  On success,
+ * sets the pointer to the slot to slot_p.
+ */
+static bool
+radix_tree_node_search(radix_tree_node *node, Datum **slot_p, uint64 key,
+					   radix_tree_action action)
+{
+	int			chunk = GET_KEY_CHUNK(key, node->shift);
+	bool		found = false;
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+			{
+				radix_tree_node_4 *n4 = (radix_tree_node_4 *) node;
+
+				/* Do linear search */
+				for (int i = 0; i < n4->n.count; i++)
+				{
+					if (n4->chunks[i] > chunk)
+						break;
+
+					/*
+					 * If we find the chunk in the node, do the specified
+					 * action
+					 */
+					if (n4->chunks[i] == chunk)
+					{
+						if (action == RADIX_TREE_FIND)
+							*slot_p = &(n4->slots[i]);
+						else	/* RADIX_TREE_DELETE */
+						{
+							memmove(&(n4->chunks[i]), &(n4->chunks[i + 1]),
+									sizeof(uint8) * (n4->n.count - i - 1));
+							memmove(&(n4->slots[i]), &(n4->slots[i + 1]),
+									sizeof(radix_tree_node *) * (n4->n.count - i - 1));
+						}
+
+						found = true;
+						break;
+					}
+				}
+
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_32:
+			{
+				radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+				int			idx;
+
+				/* Search by SIMD instructions */
+				idx = node_32_search_eq(n32, chunk);
+
+				/* If we find the chunk in the node, do the specified action */
+				if (idx >= 0)
+				{
+					if (action == RADIX_TREE_FIND)
+						*slot_p = &(n32->slots[idx]);
+					else		/* RADIX_TREE_DELETE */
+					{
+						memmove(&(n32->chunks[idx]), &(n32->chunks[idx + 1]),
+								sizeof(uint8) * (n32->n.count - idx - 1));
+						memmove(&(n32->slots[idx]), &(n32->slots[idx + 1]),
+								sizeof(radix_tree_node *) * (n32->n.count - idx - 1));
+					}
+
+					found = true;
+				}
+
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_128:
+			{
+				radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+
+				/* If we find the chunk in the node, do the specified action */
+				if (node_128_is_chunk_used(n128, chunk))
+				{
+					if (action == RADIX_TREE_FIND)
+						*slot_p = &(n128->slots[n128->slot_idxs[chunk] - 1]);
+					else		/* RADIX_TREE_DELETE */
+						node_128_unset(n128, chunk);
+
+					found = true;
+				}
+
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_256:
+			{
+				radix_tree_node_256 *n256 = (radix_tree_node_256 *) node;
+
+				/* If we find the chunk in the node, do the specified action */
+				if (node_256_is_chunk_used(n256, chunk))
+				{
+					if (action == RADIX_TREE_FIND)
+						*slot_p = &(n256->slots[chunk]);
+					else		/* RADIX_TREE_DELETE */
+						node_256_unset(n256, chunk);
+
+					found = true;
+				}
+
+				break;
+			}
+	}
+
+	/* Update the statistics */
+	if (action == RADIX_TREE_DELETE && found)
+		node->count--;
+
+	return found;
+}
+
+/*
+ * Create a new node as the root. Subordinate nodes will be created during
+ * the insertion.
+ */
+static void
+radix_tree_new_root(radix_tree *tree, uint64 key, Datum val)
+{
+	radix_tree_node_4 *n4 =
+	(radix_tree_node_4 *) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_4);
+	int			shift = key_get_shift(key);
+
+	n4->n.shift = shift;
+	tree->max_val = shift_get_max_val(shift);
+	tree->root = (radix_tree_node *) n4;
+}
+
+/* Insert 'node' as a child node of 'parent' */
+static radix_tree_node *
+radix_tree_node_insert_child(radix_tree *tree, radix_tree_node *parent,
+							 radix_tree_node *node, uint64 key)
+{
+	radix_tree_node *newchild =
+	(radix_tree_node *) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_4);
+
+	Assert(!IS_LEAF_NODE(node));
+
+	newchild->shift = node->shift - RADIX_TREE_NODE_FANOUT;
+	newchild->chunk = GET_KEY_CHUNK(key, node->shift);
+
+	radix_tree_node_insert_val(tree, parent, node, key, PointerGetDatum(newchild), NULL);
+
+	return (radix_tree_node *) newchild;
+}
+
+/*
+ * Insert the value to the node. The node grows if it's full.
+ */
+static void
+radix_tree_node_insert_val(radix_tree *tree, radix_tree_node *parent,
+						   radix_tree_node *node, uint64 key, Datum val,
+						   bool *replaced_p)
+{
+	int			chunk = GET_KEY_CHUNK(key, node->shift);
+	bool		replaced = false;
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+			{
+				radix_tree_node_4 *n4 = (radix_tree_node_4 *) node;
+				int			idx;
+
+				for (idx = 0; idx < n4->n.count; idx++)
+				{
+					if (n4->chunks[idx] >= chunk)
+						break;
+				}
+
+				if (NODE_HAS_FREE_SLOT(n4))
+				{
+					if (n4->n.count == 0)
+					{
+						/* the first key for this node, add it */
+					}
+					else if (n4->chunks[idx] == chunk)
+					{
+						/* found the key, replace it */
+						replaced = true;
+					}
+					else if (idx != n4->n.count)
+					{
+						/*
+						 * the key needs to be inserted in the middle of the
+						 * array, make space for the new key.
+						 */
+						memmove(&(n4->chunks[idx + 1]), &(n4->chunks[idx]),
+								sizeof(uint8) * (n4->n.count - idx));
+						memmove(&(n4->slots[idx + 1]), &(n4->slots[idx]),
+								sizeof(radix_tree_node *) * (n4->n.count - idx));
+					}
+
+					n4->chunks[idx] = chunk;
+					n4->slots[idx] = val;
+
+					/* Done */
+					break;
+				}
+
+				/* The node doesn't have free slot so needs to grow */
+				node = radix_tree_node_grow(tree, parent, node, key);
+				Assert(node->kind == RADIX_TREE_NODE_KIND_32);
+			}
+			/* FALLTHROUGH */
+		case RADIX_TREE_NODE_KIND_32:
+			{
+				radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+				int			idx;
+
+				idx = node_32_search_le(n32, chunk);
+
+				if (NODE_HAS_FREE_SLOT(n32))
+				{
+					if (n32->n.count == 0)
+					{
+						/* first key for this node, add it */
+					}
+					else if (n32->chunks[idx] == chunk)
+					{
+						/* found the key, replace it */
+						replaced = true;
+					}
+					else if (idx != n32->n.count)
+					{
+						/*
+						 * the key needs to be inserted in the middle of the
+						 * array, make space for the new key.
+						 */
+						memmove(&(n32->chunks[idx + 1]), &(n32->chunks[idx]),
+								sizeof(uint8) * (n32->n.count - idx));
+						memmove(&(n32->slots[idx + 1]), &(n32->slots[idx]),
+								sizeof(radix_tree_node *) * (n32->n.count - idx));
+					}
+
+					n32->chunks[idx] = chunk;
+					n32->slots[idx] = val;
+
+					/* Done */
+					break;
+				}
+
+				/* The node doesn't have free slot so needs to grow */
+				node = radix_tree_node_grow(tree, parent, node, key);
+				Assert(node->kind == RADIX_TREE_NODE_KIND_128);
+			}
+			/* FALLTHROUGH */
+		case RADIX_TREE_NODE_KIND_128:
+			{
+				radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+
+				if (node_128_is_chunk_used(n128, chunk))
+				{
+					/* found the existing value */
+					node_128_set(n128, chunk, val);
+					replaced = true;
+					break;
+				}
+
+				if (NODE_HAS_FREE_SLOT(n128))
+				{
+					node_128_set(n128, chunk, val);
+
+					/* Done */
+					break;
+				}
+
+				/* The node doesn't have free slot so needs to grow */
+				node = radix_tree_node_grow(tree, parent, node, key);
+				Assert(node->kind == RADIX_TREE_NODE_KIND_256);
+			}
+			/* FALLTHROUGH */
+		case RADIX_TREE_NODE_KIND_256:
+			{
+				radix_tree_node_256 *n256 = (radix_tree_node_256 *) node;
+
+				if (node_256_is_chunk_used(n256, chunk))
+					replaced = true;
+
+				node_256_set(n256, chunk, val);
+
+				break;
+			}
+	}
+
+	/* Update statistics */
+	if (!replaced)
+		node->count++;
+
+	if (replaced_p)
+		*replaced_p = replaced;
+
+	/*
+	 * Done. Finally, verify the chunk and value is inserted or replaced
+	 * properly in the node.
+	 */
+	radix_tree_verify_node(node);
+}
+
+/* Change the node type to the next larger one */
+static radix_tree_node *
+radix_tree_node_grow(radix_tree *tree, radix_tree_node *parent, radix_tree_node *node,
+					 uint64 key)
+{
+	radix_tree_node *newnode = NULL;
+
+	Assert(node->count == radix_tree_node_info[node->kind].max_slots);
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+			{
+				radix_tree_node_4 *n4 = (radix_tree_node_4 *) node;
+				radix_tree_node_32 *new32 =
+				(radix_tree_node_32 *) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_32);
+
+				radix_tree_copy_node_common((radix_tree_node *) n4,
+											(radix_tree_node *) new32);
+
+				/* Copy both chunks and slots to the new node */
+				memcpy(&(new32->chunks), &(n4->chunks), sizeof(uint8) * 4);
+				memcpy(&(new32->slots), &(n4->slots), sizeof(Datum) * 4);
+
+				newnode = (radix_tree_node *) new32;
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_32:
+			{
+				radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+				radix_tree_node_128 *new128 =
+				(radix_tree_node_128 *) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_128);
+
+				/* Copy both chunks and slots to the new node */
+				radix_tree_copy_node_common((radix_tree_node *) n32,
+											(radix_tree_node *) new128);
+
+				for (int i = 0; i < n32->n.count; i++)
+					node_128_set(new128, n32->chunks[i], n32->slots[i]);
+
+				newnode = (radix_tree_node *) new128;
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_128:
+			{
+				radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+				radix_tree_node_256 *new256 =
+				(radix_tree_node_256 *) radix_tree_alloc_node(tree, RADIX_TREE_NODE_KIND_256);
+				int			cnt = 0;
+
+				radix_tree_copy_node_common((radix_tree_node *) n128,
+											(radix_tree_node *) new256);
+
+				for (int i = 0; i < RADIX_TREE_NODE_MAX_SLOTS && cnt < n128->n.count; i++)
+				{
+					if (!node_128_is_chunk_used(n128, i))
+						continue;
+
+					node_256_set(new256, i, node_128_get_chunk_slot(n128, i));
+					cnt++;
+				}
+
+				newnode = (radix_tree_node *) new256;
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_256:
+			elog(ERROR, "radix tree node-256 cannot grow");
+			break;
+	}
+
+	if (parent == node)
+	{
+		/* Replace the root node with the new large node */
+		tree->root = newnode;
+	}
+	else
+	{
+		Datum	   *slot_ptr = NULL;
+
+		/* Redirect from the parent to the node */
+		radix_tree_node_search(parent, &slot_ptr, key, RADIX_TREE_FIND);
+		Assert(*slot_ptr);
+		*slot_ptr = PointerGetDatum(newnode);
+	}
+
+	/* Verify the node has grown properly */
+	radix_tree_verify_node(newnode);
+
+	/* Free the old node */
+	radix_tree_free_node(tree, node);
+
+	return newnode;
+}
+
+/*
+ * Create the radix tree in the given memory context and return it.
+ */
+radix_tree *
+radix_tree_create(MemoryContext ctx)
+{
+	radix_tree *tree;
+	MemoryContext old_ctx;
+
+	old_ctx = MemoryContextSwitchTo(ctx);
+
+	tree = palloc(sizeof(radix_tree));
+	tree->max_val = 0;
+	tree->root = NULL;
+	tree->context = ctx;
+	tree->num_keys = 0;
+	tree->mem_used = 0;
+
+	/* Create the slab allocator for each size class */
+	for (int i = 0; i < RADIX_TREE_NODE_KIND_COUNT; i++)
+	{
+		tree->slabs[i] = SlabContextCreate(ctx,
+										   radix_tree_node_info[i].name,
+										   SLAB_DEFAULT_BLOCK_SIZE,
+										   radix_tree_node_info[i].size);
+		tree->cnt[i] = 0;
+	}
+
+	MemoryContextSwitchTo(old_ctx);
+
+	return tree;
+}
+
+/*
+ * Free the given radix tree.
+ */
+void
+radix_tree_free(radix_tree *tree)
+{
+	for (int i = 0; i < RADIX_TREE_NODE_KIND_COUNT; i++)
+		MemoryContextDelete(tree->slabs[i]);
+
+	pfree(tree);
+}
+
+/*
+ * Insert the key with the val.
+ *
+ * found_p is set to true if the key already present, otherwise false, if
+ * it's not NULL.
+ *
+ * XXX: do we need to support update_if_exists behavior?
+ */
+void
+radix_tree_insert(radix_tree *tree, uint64 key, Datum val, bool *found_p)
+{
+	int			shift;
+	bool		replaced;
+	radix_tree_node *node;
+	radix_tree_node *parent = tree->root;
+
+	/* Empty tree, create the root */
+	if (!tree->root)
+		radix_tree_new_root(tree, key, val);
+
+	/* Extend the tree if necessary */
+	if (key > tree->max_val)
+		radix_tree_extend(tree, key);
+
+	Assert(tree->root);
+
+	shift = tree->root->shift;
+	node = tree->root;
+	while (shift > 0)
+	{
+		radix_tree_node *child;
+
+		if (!radix_tree_node_search_child(node, &child, key))
+			child = radix_tree_node_insert_child(tree, parent, node, key);
+
+		Assert(child != NULL);
+
+		parent = node;
+		node = child;
+		shift -= RADIX_TREE_NODE_FANOUT;
+	}
+
+	/* arrived at a leaf */
+	Assert(IS_LEAF_NODE(node));
+
+	radix_tree_node_insert_val(tree, parent, node, key, val, &replaced);
+
+	/* Update the statistics */
+	if (!replaced)
+		tree->num_keys++;
+
+	if (found_p)
+		*found_p = replaced;
+}
+
+/*
+ * Search the given key in the radix tree. Return true if the key is successfully
+ * found, otherwise return false.  On success, we set the value to *val_p so
+ * it must not be NULL.
+ */
+bool
+radix_tree_search(radix_tree *tree, uint64 key, Datum *val_p)
+{
+	radix_tree_node *node;
+	Datum	   *value_ptr;
+	int			shift;
+
+	Assert(val_p);
+
+	if (!tree->root || key > tree->max_val)
+		return false;
+
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift > 0)
+	{
+		radix_tree_node *child;
+
+		if (!radix_tree_node_search_child(node, &child, key))
+			return false;
+
+		node = child;
+		shift -= RADIX_TREE_NODE_FANOUT;
+	}
+
+	/* We reached at a leaf node, search the corresponding slot */
+	Assert(IS_LEAF_NODE(node));
+
+	if (!radix_tree_node_search(node, &value_ptr, key, RADIX_TREE_FIND))
+		return false;
+
+	/* Found, set the value to return */
+	*val_p = *value_ptr;
+	return true;
+}
+
+/*
+ * Delete the given key from the radix tree. Return true if the key is found (and
+ * deleted), otherwise do nothing and return false.
+ */
+bool
+radix_tree_delete(radix_tree *tree, uint64 key)
+{
+	radix_tree_node *node;
+	int			shift;
+	radix_tree_stack stack = NULL;
+	bool		deleted;
+
+	if (!tree->root || key > tree->max_val)
+		return false;
+
+	/*
+	 * Descending the tree to search the key while building a stack of nodes
+	 * we visited.
+	 */
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift >= 0)
+	{
+		radix_tree_node *child;
+		radix_tree_stack new_stack;
+
+		new_stack = (radix_tree_stack) palloc(sizeof(radix_tree_stack_data));
+		new_stack->node = node;
+		new_stack->parent = stack;
+		stack = new_stack;
+
+		if (IS_LEAF_NODE(node))
+			break;
+
+		if (!radix_tree_node_search_child(node, &child, key))
+		{
+			radix_tree_free_stack(stack);
+			return false;
+		}
+
+		node = child;
+		shift -= RADIX_TREE_NODE_FANOUT;
+	}
+
+	/*
+	 * Delete the key from the leaf node and recursively delete internal nodes
+	 * if necessary.
+	 */
+	Assert(IS_LEAF_NODE(stack->node));
+	while (stack != NULL)
+	{
+		radix_tree_node *node;
+		Datum	   *slot;
+
+		/* pop the node from the stack */
+		node = stack->node;
+		stack = stack->parent;
+
+		deleted = radix_tree_node_search(node, &slot, key, RADIX_TREE_DELETE);
+
+		/* If the node didn't become empty, we stop deleting the key */
+		if (!IS_EMPTY_NODE(node))
+			break;
+
+		Assert(deleted);
+
+		/* The node became empty */
+		radix_tree_free_node(tree, node);
+
+		/*
+		 * If we eventually deleted the root node while recursively deleting
+		 * empty nodes, we make the tree empty.
+		 */
+		if (stack == NULL)
+		{
+			tree->root = NULL;
+			tree->max_val = 0;
+		}
+	}
+
+	if (deleted)
+		tree->num_keys--;
+
+	radix_tree_free_stack(stack);
+	return deleted;
+}
+
+/* Create and return the iterator for the given radix tree */
+radix_tree_iter *
+radix_tree_begin_iterate(radix_tree *tree)
+{
+	MemoryContext old_ctx;
+	radix_tree_iter *iter;
+	int			top_level;
+
+	old_ctx = MemoryContextSwitchTo(tree->context);
+
+	iter = (radix_tree_iter *) palloc0(sizeof(radix_tree_iter));
+	iter->tree = tree;
+
+	/* empty tree */
+	if (!iter->tree)
+		return iter;
+
+	top_level = iter->tree->root->shift / RADIX_TREE_NODE_FANOUT;
+
+	iter->stack_len = top_level;
+	iter->stack[top_level].node = iter->tree->root;
+	iter->stack[top_level].current_idx = -1;
+
+	/* Descend to the left most leaf node from the root */
+	radix_tree_update_iter_stack(iter, top_level);
+
+	MemoryContextSwitchTo(old_ctx);
+
+	return iter;
+}
+
+/*
+ * Return true with setting key_p and value_p if there is next key.  Otherwise,
+ * return false.
+ */
+bool
+radix_tree_iterate_next(radix_tree_iter *iter, uint64 *key_p, Datum *value_p)
+{
+	bool		found = false;
+	Datum		slot = (Datum) 0;
+	int			level;
+
+	/* Empty tree */
+	if (!iter->tree)
+		return false;
+
+	for (;;)
+	{
+		radix_tree_node *node;
+		radix_tree_iter_node_data *node_iter;
+
+		/*
+		 * Iterate node at each level from the bottom of the tree until we
+		 * search the next slot.
+		 */
+		for (level = 0; level <= iter->stack_len; level++)
+		{
+			slot = radix_tree_node_iterate_next(iter, &(iter->stack[level]), &found);
+
+			if (found)
+				break;
+		}
+
+		/* end of iteration */
+		if (!found)
+			return false;
+
+		/* found the next slot at the leaf node, return it */
+		if (level == 0)
+		{
+			*key_p = iter->key;
+			*value_p = slot;
+			return true;
+		}
+
+		/*
+		 * We have advanced more than one nodes including internal nodes. So
+		 * we need to update the stack by descending to the left most leaf
+		 * node from this level.
+		 */
+		node = (radix_tree_node *) DatumGetPointer(slot);
+		node_iter = &(iter->stack[level - 1]);
+		radix_tree_store_iter_node(iter, node_iter, node);
+
+		radix_tree_update_iter_stack(iter, level - 1);
+	}
+}
+
+void
+radix_tree_end_iterate(radix_tree_iter *iter)
+{
+	pfree(iter);
+}
+
+/*
+ * Update the part of the key being constructed during the iteration with the
+ * given chunk
+ */
+static inline void
+radix_tree_iter_update_key(radix_tree_iter *iter, uint8 chunk, uint8 shift)
+{
+	iter->key &= ~(((uint64) RADIX_TREE_CHUNK_MASK) << shift);
+	iter->key |= (((uint64) chunk) << shift);
+}
+
+/*
+ * Iterate over the given radix tree node and returns the next slot of the given
+ * node and set true to *found_p, if any.  Otherwise, set false to *found_p.
+ */
+static Datum
+radix_tree_node_iterate_next(radix_tree_iter *iter, radix_tree_iter_node_data *node_iter,
+							 bool *found_p)
+{
+	radix_tree_node *node = node_iter->node;
+	Datum		slot = (Datum) 0;
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+			{
+				radix_tree_node_4 *n4 = (radix_tree_node_4 *) node_iter->node;
+
+				node_iter->current_idx++;
+
+				if (node_iter->current_idx >= n4->n.count)
+					goto not_found;
+
+				slot = n4->slots[node_iter->current_idx];
+
+				/* Update the part of the key with the current chunk */
+				if (IS_LEAF_NODE(node))
+					radix_tree_iter_update_key(iter, n4->chunks[node_iter->current_idx], 0);
+
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_32:
+			{
+				radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+
+				node_iter->current_idx++;
+
+				if (node_iter->current_idx >= n32->n.count)
+					goto not_found;
+
+				slot = n32->slots[node_iter->current_idx];
+
+				/* Update the part of the key with the current chunk */
+				if (IS_LEAF_NODE(node))
+					radix_tree_iter_update_key(iter, n32->chunks[node_iter->current_idx], 0);
+
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_128:
+			{
+				radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+				int			i;
+
+				for (i = node_iter->current_idx + 1; i < 256; i++)
+				{
+					if (node_128_is_chunk_used(n128, i))
+						break;
+				}
+
+				if (i >= 256)
+					goto not_found;
+
+				node_iter->current_idx = i;
+				slot = node_128_get_chunk_slot(n128, i);
+
+				/* Update the part of the key */
+				if (IS_LEAF_NODE(node))
+					radix_tree_iter_update_key(iter, node_iter->current_idx, 0);
+
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_256:
+			{
+				radix_tree_node_256 *n256 = (radix_tree_node_256 *) node;
+				int			i;
+
+				for (i = node_iter->current_idx + 1; i < 256; i++)
+				{
+					if (node_256_is_chunk_used(n256, i))
+						break;
+				}
+
+				if (i >= 256)
+					goto not_found;
+
+				node_iter->current_idx = i;
+				slot = n256->slots[i];
+
+				/* Update the part of the key */
+				if (IS_LEAF_NODE(node))
+					radix_tree_iter_update_key(iter, node_iter->current_idx, 0);
+
+				break;
+			}
+	}
+
+	*found_p = true;
+	return slot;
+
+not_found:
+	*found_p = false;
+	return (Datum) 0;
+}
+
+/*
+ * Initialize and update the node iteration struct with the given radix tree node.
+ * This function also updates the part of the key with the chunk of the given node.
+ */
+static void
+radix_tree_store_iter_node(radix_tree_iter *iter, radix_tree_iter_node_data *node_iter,
+						   radix_tree_node *node)
+{
+	node_iter->node = node;
+	node_iter->current_idx = -1;
+
+	radix_tree_iter_update_key(iter, node->chunk, node->shift + RADIX_TREE_NODE_FANOUT);
+}
+
+/*
+ * Build the stack of the radix tree node while descending to the leaf from the 'from'
+ * level.
+ */
+static void
+radix_tree_update_iter_stack(radix_tree_iter *iter, int from)
+{
+	radix_tree_node *node = iter->stack[from].node;
+	int			level = from;
+
+	for (;;)
+	{
+		radix_tree_iter_node_data *node_iter = &(iter->stack[level--]);
+		bool		found;
+
+		/* Set the current node */
+		radix_tree_store_iter_node(iter, node_iter, node);
+
+		if (IS_LEAF_NODE(node))
+			break;
+
+		node = (radix_tree_node *)
+			DatumGetPointer(radix_tree_node_iterate_next(iter, node_iter, &found));
+
+		/*
+		 * Since we always get the first slot in the node, we have to found
+		 * the slot.
+		 */
+		Assert(found);
+	}
+}
+
+/*
+ * Return the number of keys in the radix tree.
+ */
+uint64
+radix_tree_num_entries(radix_tree *tree)
+{
+	return tree->num_keys;
+}
+
+/*
+ * Return the statistics of the amount of memory used by the radix tree.
+ */
+uint64
+radix_tree_memory_usage(radix_tree *tree)
+{
+	return tree->mem_used;
+}
+
+/*
+ * Verify the radix tree node.
+ */
+static void
+radix_tree_verify_node(radix_tree_node *node)
+{
+#ifdef USE_ASSERT_CHECKING
+	Assert(node->count >= 0);
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+			{
+				radix_tree_node_4 *n4 = (radix_tree_node_4 *) node;
+
+				/* Check if the chunks in the node are sorted */
+				for (int i = 1; i < n4->n.count; i++)
+					Assert(n4->chunks[i - 1] < n4->chunks[i]);
+
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_32:
+			{
+				radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+
+				/* Check if the chunks in the node are sorted */
+				for (int i = 1; i < n32->n.count; i++)
+					Assert(n32->chunks[i - 1] < n32->chunks[i]);
+
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_128:
+			{
+				radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+				int			cnt = 0;
+
+				for (int i = 0; i < RADIX_TREE_NODE_MAX_SLOTS; i++)
+				{
+					if (!node_128_is_chunk_used(n128, i))
+						continue;
+
+					/* Check if the corresponding slot is used */
+					Assert(node_128_is_slot_used(n128, n128->slot_idxs[i] - 1));
+
+					cnt++;
+				}
+
+				Assert(n128->n.count == cnt);
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_256:
+			{
+				radix_tree_node_256 *n256 = (radix_tree_node_256 *) node;
+				int			cnt = 0;
+
+				for (int i = 0; i < RADIX_TREE_NODE_MAX_BITS; i++)
+					cnt += pg_popcount32(n256->isset[i]);
+
+				/* Check if the number of used chunk matches */
+				Assert(n256->n.count == cnt);
+
+				break;
+			}
+	}
+#endif
+}
+
+/***************** DEBUG FUNCTIONS *****************/
+#ifdef RADIX_TREE_DEBUG
+void
+radix_tree_stats(radix_tree *tree)
+{
+	fprintf(stderr, "num_keys = %lu, height = %u, n4 = %u(%lu), n32 = %u(%lu), n128 = %u(%lu), n256 = %u(%lu)",
+			tree->num_keys,
+			tree->root->shift / RADIX_TREE_NODE_FANOUT,
+			tree->cnt[0], tree->cnt[0] * sizeof(radix_tree_node_4),
+			tree->cnt[1], tree->cnt[1] * sizeof(radix_tree_node_32),
+			tree->cnt[2], tree->cnt[2] * sizeof(radix_tree_node_128),
+			tree->cnt[3], tree->cnt[3] * sizeof(radix_tree_node_256));
+	/* radix_tree_dump(tree); */
+}
+
+static void
+radix_tree_print_slot(StringInfo buf, uint8 chunk, Datum slot, int idx, bool is_leaf, int level)
+{
+	char		space[128] = {0};
+
+	if (level > 0)
+		sprintf(space, "%*c", level * 4, ' ');
+
+	if (is_leaf)
+		appendStringInfo(buf, "%s[%d] \"0x%X\" val(0x%lX) LEAF\n",
+						 space,
+						 idx,
+						 chunk,
+						 DatumGetInt64(slot));
+	else
+		appendStringInfo(buf, "%s[%d] \"0x%X\" -> ",
+						 space,
+						 idx,
+						 chunk);
+}
+
+static void
+radix_tree_dump_node(radix_tree_node *node, int level, StringInfo buf, bool recurse)
+{
+	bool		is_leaf = IS_LEAF_NODE(node);
+
+	appendStringInfo(buf, "[\"%s\" type %d, cnt %u, shift %u, chunk \"0x%X\"] chunks:\n",
+					 IS_LEAF_NODE(node) ? "LEAF" : "INNR",
+					 (node->kind == RADIX_TREE_NODE_KIND_4) ? 4 :
+					 (node->kind == RADIX_TREE_NODE_KIND_32) ? 32 :
+					 (node->kind == RADIX_TREE_NODE_KIND_128) ? 128 : 256,
+					 node->count, node->shift, node->chunk);
+
+	switch (node->kind)
+	{
+		case RADIX_TREE_NODE_KIND_4:
+			{
+				radix_tree_node_4 *n4 = (radix_tree_node_4 *) node;
+
+				for (int i = 0; i < n4->n.count; i++)
+				{
+					radix_tree_print_slot(buf, n4->chunks[i], n4->slots[i], i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							radix_tree_dump_node((radix_tree_node *) n4->slots[i], level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_32:
+			{
+				radix_tree_node_32 *n32 = (radix_tree_node_32 *) node;
+
+				for (int i = 0; i < n32->n.count; i++)
+				{
+					radix_tree_print_slot(buf, n32->chunks[i], n32->slots[i], i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							radix_tree_dump_node((radix_tree_node *) n32->slots[i], level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_128:
+			{
+				radix_tree_node_128 *n128 = (radix_tree_node_128 *) node;
+
+				for (int j = 0; j < 256; j++)
+				{
+					if (!node_128_is_chunk_used(n128, j))
+						continue;
+
+					appendStringInfo(buf, "slot_idxs[%d]=%d, ", j, n128->slot_idxs[j]);
+				}
+				appendStringInfo(buf, "\nisset-bitmap:");
+				for (int j = 0; j < 16; j++)
+				{
+					appendStringInfo(buf, "%X ", (uint8) n128->isset[j]);
+				}
+				appendStringInfo(buf, "\n");
+
+				for (int i = 0; i < 256; i++)
+				{
+					if (!node_128_is_chunk_used(n128, i))
+						continue;
+
+					radix_tree_print_slot(buf, i, node_128_get_chunk_slot(n128, i),
+										  i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							radix_tree_dump_node((radix_tree_node *) node_128_get_chunk_slot(n128, i),
+												 level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+				break;
+			}
+		case RADIX_TREE_NODE_KIND_256:
+			{
+				radix_tree_node_256 *n256 = (radix_tree_node_256 *) node;
+
+				for (int i = 0; i < 256; i++)
+				{
+					if (!node_256_is_chunk_used(n256, i))
+						continue;
+
+					radix_tree_print_slot(buf, i, n256->slots[i], i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							radix_tree_dump_node((radix_tree_node *) n256->slots[i], level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+				break;
+			}
+	}
+}
+
+void
+radix_tree_dump_search(radix_tree *tree, uint64 key)
+{
+	StringInfoData buf;
+	radix_tree_node *node;
+	int			shift;
+	int			level = 0;
+
+	elog(NOTICE, "-----------------------------------------------------------");
+	elog(NOTICE, "max_val = %lu (0x%lX)", tree->max_val, tree->max_val);
+
+	if (!tree->root)
+	{
+		elog(NOTICE, "tree is empty");
+		return;
+	}
+
+	if (key > tree->max_val)
+	{
+		elog(NOTICE, "key %lu (0x%lX) is larger than max val",
+			 key, key);
+		return;
+	}
+
+	initStringInfo(&buf);
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift >= 0)
+	{
+		radix_tree_node *child;
+
+		radix_tree_dump_node(node, level, &buf, false);
+
+		if (IS_LEAF_NODE(node))
+		{
+			Datum	   *dummy;
+
+			/* We reached at a leaf node, find the corresponding slot */
+			radix_tree_node_search(node, &dummy, key, RADIX_TREE_FIND);
+
+			break;
+		}
+
+		if (!radix_tree_node_search_child(node, &child, key))
+			break;
+
+		node = child;
+		shift -= RADIX_TREE_NODE_FANOUT;
+		level++;
+	}
+
+	elog(NOTICE, "\n%s", buf.data);
+}
+
+void
+radix_tree_dump(radix_tree *tree)
+{
+	StringInfoData buf;
+
+	initStringInfo(&buf);
+
+	elog(NOTICE, "-----------------------------------------------------------");
+	elog(NOTICE, "max_val = %lu", tree->max_val);
+	radix_tree_dump_node(tree->root, 0, &buf, true);
+	elog(NOTICE, "\n%s", buf.data);
+	elog(NOTICE, "-----------------------------------------------------------");
+}
+#endif
diff --git a/src/include/lib/radixtree.h b/src/include/lib/radixtree.h
new file mode 100644
index 0000000000..7e864d124b
--- /dev/null
+++ b/src/include/lib/radixtree.h
@@ -0,0 +1,42 @@
+/*-------------------------------------------------------------------------
+ *
+ * radixtree.h
+ *	  Interface for radix tree.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		src/include/lib/radixtree.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RADIXTREE_H
+#define RADIXTREE_H
+
+#include "postgres.h"
+
+/* #define RADIX_TREE_DEBUG 1 */
+
+typedef struct radix_tree radix_tree;
+typedef struct radix_tree_iter radix_tree_iter;
+
+extern radix_tree *radix_tree_create(MemoryContext ctx);
+extern bool radix_tree_search(radix_tree *tree, uint64 key, Datum *val_p);
+extern void radix_tree_insert(radix_tree *tree, uint64 key, Datum val, bool *found_p);
+extern bool radix_tree_delete(radix_tree *tree, uint64 key);
+extern void radix_tree_free(radix_tree *tree);
+extern uint64 radix_tree_memory_usage(radix_tree *tree);
+extern uint64 radix_tree_num_entries(radix_tree *tree);
+
+extern radix_tree_iter *radix_tree_begin_iterate(radix_tree *tree);
+extern bool radix_tree_iterate_next(radix_tree_iter *iter, uint64 *key_p, Datum *value_p);
+extern void radix_tree_end_iterate(radix_tree_iter *iter);
+
+
+#ifdef RADIX_TREE_DEBUG
+extern void radix_tree_dump(radix_tree *tree);
+extern void radix_tree_dump_search(radix_tree *tree, uint64 key);
+extern void radix_tree_stats(radix_tree *tree);
+#endif
+
+#endif							/* RADIXTREE_H */
diff --git a/src/test/modules/Makefile b/src/test/modules/Makefile
index 9090226daa..51b2514faf 100644
--- a/src/test/modules/Makefile
+++ b/src/test/modules/Makefile
@@ -24,6 +24,7 @@ SUBDIRS = \
 		  test_parser \
 		  test_pg_dump \
 		  test_predtest \
+		  test_radixtree \
 		  test_rbtree \
 		  test_regex \
 		  test_rls_hooks \
diff --git a/src/test/modules/test_radixtree/.gitignore b/src/test/modules/test_radixtree/.gitignore
new file mode 100644
index 0000000000..5dcb3ff972
--- /dev/null
+++ b/src/test/modules/test_radixtree/.gitignore
@@ -0,0 +1,4 @@
+# Generated subdirectories
+/log/
+/results/
+/tmp_check/
diff --git a/src/test/modules/test_radixtree/Makefile b/src/test/modules/test_radixtree/Makefile
new file mode 100644
index 0000000000..da06b93da3
--- /dev/null
+++ b/src/test/modules/test_radixtree/Makefile
@@ -0,0 +1,23 @@
+# src/test/modules/test_radixtree/Makefile
+
+MODULE_big = test_radixtree
+OBJS = \
+	$(WIN32RES) \
+	test_radixtree.o
+PGFILEDESC = "test_radixtree - test code for src/backend/lib/radixtree.c"
+
+EXTENSION = test_radixtree
+DATA = test_radixtree--1.0.sql
+
+REGRESS = test_radixtree
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = src/test/modules/test_radixtree
+top_builddir = ../../../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
diff --git a/src/test/modules/test_radixtree/README b/src/test/modules/test_radixtree/README
new file mode 100644
index 0000000000..a8b271869a
--- /dev/null
+++ b/src/test/modules/test_radixtree/README
@@ -0,0 +1,7 @@
+test_integerset contains unit tests for testing the integer set implementation
+in src/backend/lib/integerset.c.
+
+The tests verify the correctness of the implementation, but they can also be
+used as a micro-benchmark.  If you set the 'intset_test_stats' flag in
+test_integerset.c, the tests will print extra information about execution time
+and memory usage.
diff --git a/src/test/modules/test_radixtree/expected/test_radixtree.out b/src/test/modules/test_radixtree/expected/test_radixtree.out
new file mode 100644
index 0000000000..cc6970c87c
--- /dev/null
+++ b/src/test/modules/test_radixtree/expected/test_radixtree.out
@@ -0,0 +1,28 @@
+CREATE EXTENSION test_radixtree;
+--
+-- All the logic is in the test_radixtree() function. It will throw
+-- an error if something fails.
+--
+SELECT test_radixtree();
+NOTICE:  testing radix tree node types with shift "0"
+NOTICE:  testing radix tree node types with shift "8"
+NOTICE:  testing radix tree node types with shift "16"
+NOTICE:  testing radix tree node types with shift "24"
+NOTICE:  testing radix tree node types with shift "32"
+NOTICE:  testing radix tree node types with shift "40"
+NOTICE:  testing radix tree node types with shift "48"
+NOTICE:  testing radix tree node types with shift "56"
+NOTICE:  testing radix tree with pattern "all ones"
+NOTICE:  testing radix tree with pattern "alternating bits"
+NOTICE:  testing radix tree with pattern "clusters of ten"
+NOTICE:  testing radix tree with pattern "clusters of hundred"
+NOTICE:  testing radix tree with pattern "one-every-64k"
+NOTICE:  testing radix tree with pattern "sparse"
+NOTICE:  testing radix tree with pattern "single values, distance > 2^32"
+NOTICE:  testing radix tree with pattern "clusters, distance > 2^32"
+NOTICE:  testing radix tree with pattern "clusters, distance > 2^60"
+ test_radixtree 
+----------------
+ 
+(1 row)
+
diff --git a/src/test/modules/test_radixtree/sql/test_radixtree.sql b/src/test/modules/test_radixtree/sql/test_radixtree.sql
new file mode 100644
index 0000000000..41ece5e9f5
--- /dev/null
+++ b/src/test/modules/test_radixtree/sql/test_radixtree.sql
@@ -0,0 +1,7 @@
+CREATE EXTENSION test_radixtree;
+
+--
+-- All the logic is in the test_radixtree() function. It will throw
+-- an error if something fails.
+--
+SELECT test_radixtree();
diff --git a/src/test/modules/test_radixtree/test_radixtree--1.0.sql b/src/test/modules/test_radixtree/test_radixtree--1.0.sql
new file mode 100644
index 0000000000..074a5a7ea7
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree--1.0.sql
@@ -0,0 +1,8 @@
+/* src/test/modules/test_radixtree/test_radixtree--1.0.sql */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION test_radixtree" to load this file. \quit
+
+CREATE FUNCTION test_radixtree()
+RETURNS pg_catalog.void STRICT
+AS 'MODULE_PATHNAME' LANGUAGE C;
diff --git a/src/test/modules/test_radixtree/test_radixtree.c b/src/test/modules/test_radixtree/test_radixtree.c
new file mode 100644
index 0000000000..6d5b06a800
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree.c
@@ -0,0 +1,502 @@
+/*--------------------------------------------------------------------------
+ *
+ * test_radixtree.c
+ *		Test radixtree set data structure.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		src/test/modules/test_radixtree/test_radixtree.c
+ *
+ * -------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "common/pg_prng.h"
+#include "fmgr.h"
+#include "lib/radixtree.h"
+#include "miscadmin.h"
+#include "nodes/bitmapset.h"
+#include "storage/block.h"
+#include "storage/itemptr.h"
+#include "utils/memutils.h"
+#include "utils/timestamp.h"
+
+#define UINT64_HEX_FORMAT "%" INT64_MODIFIER "X"
+
+/*
+ * If you enable this, the "pattern" tests will print information about
+ * how long populating, probing, and iterating the test set takes, and
+ * how much memory the test set consumed.  That can be used as
+ * micro-benchmark of various operations and input patterns (you might
+ * want to increase the number of values used in each of the test, if
+ * you do that, to reduce noise).
+ *
+ * The information is printed to the server's stderr, mostly because
+ * that's where MemoryContextStats() output goes.
+ */
+static const bool radix_tree_test_stats = false;
+
+/* The maximum number of entries each node type can have */
+static int radix_tree_node_max_entries[] = {
+	4,		/* RADIX_TREE_NODE_KIND_4 */
+	16,		/* RADIX_TREE_NODE_KIND_16 */
+	128,	/* RADIX_TREE_NODE_KIND_128 */
+	256		/* RADIX_TREE_NODE_KIND_256 */
+};
+
+/*
+ * A struct to define a pattern of integers, for use with the test_pattern()
+ * function.
+ */
+typedef struct
+{
+	char	   *test_name;		/* short name of the test, for humans */
+	char	   *pattern_str;	/* a bit pattern */
+	uint64		spacing;		/* pattern repeats at this interval */
+	uint64		num_values;		/* number of integers to set in total */
+} test_spec;
+
+/* Test patterns borrowed from test_integerset.c */
+static const test_spec test_specs[] = {
+	{
+		"all ones", "1111111111",
+		10, 1000000
+	},
+	{
+		"alternating bits", "0101010101",
+		10, 1000000
+	},
+	{
+		"clusters of ten", "1111111111",
+		10000, 1000000
+	},
+	{
+		"clusters of hundred",
+		"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111",
+		10000, 10000000
+	},
+	{
+		"one-every-64k", "1",
+		65536, 1000000
+	},
+	{
+		"sparse", "100000000000000000000000000000001",
+		10000000, 1000000
+	},
+	{
+		"single values, distance > 2^32", "1",
+		UINT64CONST(10000000000), 100000
+	},
+	{
+		"clusters, distance > 2^32", "10101010",
+		UINT64CONST(10000000000), 1000000
+	},
+	{
+		"clusters, distance > 2^60", "10101010",
+		UINT64CONST(2000000000000000000),
+		23						/* can't be much higher than this, or we
+								 * overflow uint64 */
+	}
+};
+
+PG_MODULE_MAGIC;
+
+PG_FUNCTION_INFO_V1(test_radixtree);
+
+static void
+test_empty(void)
+{
+	radix_tree *radixtree;
+	Datum dummy;
+
+	radixtree = radix_tree_create(CurrentMemoryContext);
+
+	if (radix_tree_search(radixtree, 0, &dummy))
+		elog(ERROR, "radix_tree_search on empty tree returned true");
+
+	if (radix_tree_search(radixtree, 1, &dummy))
+		elog(ERROR, "radix_tree_search on empty tree returned true");
+
+	if (radix_tree_search(radixtree, PG_UINT64_MAX, &dummy))
+		elog(ERROR, "radix_tree_search on empty tree returned true");
+
+	if (radix_tree_num_entries(radixtree) != 0)
+		elog(ERROR, "radix_tree_num_entries on empty tree return non-zero");
+
+	radix_tree_free(radixtree);
+}
+
+/*
+ * Check if keys from start to end with the shift exist in the tree.
+ */
+static void
+check_search_on_node(radix_tree *radixtree, uint8 shift, int start, int end)
+{
+	for (int i = start; i < end; i++)
+	{
+		uint64 key = ((uint64) i << shift);
+		Datum val;
+
+		if (!radix_tree_search(radixtree, key, &val))
+			elog(ERROR, "key 0x" UINT64_HEX_FORMAT " is not found on node-%d",
+				 key, end);
+		if (DatumGetUInt64(val) != key)
+			elog(ERROR, "radix_tree_search with key 0x" UINT64_HEX_FORMAT " returns 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT,
+				 key, DatumGetUInt64(val), key);
+	}
+}
+
+static void
+test_node_types_insert(radix_tree *radixtree, uint8 shift)
+{
+	uint64 num_entries;
+
+	for (int i = 0; i < 256; i++)
+	{
+		uint64 key = ((uint64) i << shift);
+		bool found;
+
+		radix_tree_insert(radixtree, key, Int64GetDatum(key), &found);
+
+		if (found)
+			elog(ERROR, "newly inserted key 0x" UINT64_HEX_FORMAT " found", key);
+
+		for (int j = 0; j < lengthof(radix_tree_node_max_entries); j++)
+		{
+			/*
+			 * After filling all slots in each node type, check if the values are
+			 * stored properly.
+			 */
+			if (i == (radix_tree_node_max_entries[j] - 1))
+			{
+				check_search_on_node(radixtree, shift,
+									 (j == 0) ? 0 : radix_tree_node_max_entries[j - 1],
+									 radix_tree_node_max_entries[j]);
+				break;
+			}
+		}
+	}
+
+	num_entries = radix_tree_num_entries(radixtree);
+
+	if (num_entries != 256)
+		elog(ERROR,
+			 "radix_tree_num_entries returned" UINT64_FORMAT ", expected " UINT64_FORMAT,
+			 num_entries, UINT64CONST(256));
+}
+
+static void
+test_node_types_delete(radix_tree *radixtree, uint8 shift)
+{
+	uint64 num_entries;
+
+	for (int i = 0; i < 256; i++)
+	{
+		uint64	key = ((uint64) i << shift);
+		bool	found;
+
+		found = radix_tree_delete(radixtree, key);
+
+		if (!found)
+			elog(ERROR, "inserted key 0x" UINT64_HEX_FORMAT " is not found", key);
+	}
+
+	num_entries = radix_tree_num_entries(radixtree);
+
+	/* The tree must be empty */
+	if (num_entries != 0)
+		elog(ERROR,
+			 "radix_tree_num_entries returned" UINT64_FORMAT ", expected " UINT64_FORMAT,
+			 num_entries, UINT64CONST(256));
+}
+
+/*
+ * Test for inserting and deleting key-value pairs to each node type at the given shift
+ * level.
+ */
+static void
+test_node_types(uint8 shift)
+{
+	radix_tree *radixtree;
+
+	elog(NOTICE, "testing radix tree node types with shift \"%d\"", shift);
+
+	radixtree = radix_tree_create(CurrentMemoryContext);
+
+	/*
+	 * Insert and search entries for every node type at the 'shift' level,
+	 * then delete all entries to make it empty, and insert and search
+	 * entries again.
+	 */
+	test_node_types_insert(radixtree, shift);
+	test_node_types_delete(radixtree, shift);
+	test_node_types_insert(radixtree, shift);
+
+	radix_tree_free(radixtree);
+}
+
+/*
+ * Test with a repeating pattern, defined by the 'spec'.
+ */
+static void
+test_pattern(const test_spec *spec)
+{
+	radix_tree *radixtree;
+	radix_tree_iter *iter;
+	MemoryContext radixtree_ctx;
+	TimestampTz starttime;
+	TimestampTz endtime;
+	uint64		n;
+	uint64		last_int;
+	uint64		ndeleted;
+	uint64		nbefore;
+	uint64		nafter;
+	int			patternlen;
+	uint64	   *pattern_values;
+	uint64		pattern_num_values;
+
+	elog(NOTICE, "testing radix tree with pattern \"%s\"", spec->test_name);
+	if (radix_tree_test_stats)
+		fprintf(stderr, "-----\ntesting radix tree with pattern \"%s\"\n", spec->test_name);
+
+	/* Pre-process the pattern, creating an array of integers from it. */
+	patternlen = strlen(spec->pattern_str);
+	pattern_values = palloc(patternlen * sizeof(uint64));
+	pattern_num_values = 0;
+	for (int i = 0; i < patternlen; i++)
+	{
+		if (spec->pattern_str[i] == '1')
+			pattern_values[pattern_num_values++] = i;
+	}
+
+	/*
+	 * Allocate the radix tree.
+	 *
+	 * Allocate it in a separate memory context, so that we can print its
+	 * memory usage easily.
+	 */
+	radixtree_ctx = AllocSetContextCreate(CurrentMemoryContext,
+										  "radixtree test",
+										  ALLOCSET_SMALL_SIZES);
+	MemoryContextSetIdentifier(radixtree_ctx, spec->test_name);
+	radixtree = radix_tree_create(radixtree_ctx);
+
+	/*
+	 * Add values to the set.
+	 */
+	starttime = GetCurrentTimestamp();
+
+	n = 0;
+	last_int = 0;
+	while (n < spec->num_values)
+	{
+		uint64		x = 0;
+
+		for (int i = 0; i < pattern_num_values && n < spec->num_values; i++)
+		{
+			bool found;
+
+			x = last_int + pattern_values[i];
+
+			radix_tree_insert(radixtree, x, Int64GetDatum(x), &found);
+
+			if (found)
+				elog(ERROR, "newly inserted key 0x" UINT64_HEX_FORMAT " found", x);
+
+			n++;
+		}
+		last_int += spec->spacing;
+	}
+
+	endtime = GetCurrentTimestamp();
+
+	if (radix_tree_test_stats)
+		fprintf(stderr, "added " UINT64_FORMAT " values in %d ms\n",
+				spec->num_values, (int) (endtime - starttime) / 1000);
+
+	/*
+	 * Print stats on the amount of memory used.
+	 *
+	 * We print the usage reported by radix_tree_memory_usage(), as well as the
+	 * stats from the memory context.  They should be in the same ballpark,
+	 * but it's hard to automate testing that, so if you're making changes to
+	 * the implementation, just observe that manually.
+	 */
+	if (radix_tree_test_stats)
+	{
+		uint64		mem_usage;
+
+		/*
+		 * Also print memory usage as reported by radix_tree_memory_usage().  It
+		 * should be in the same ballpark as the usage reported by
+		 * MemoryContextStats().
+		 */
+		mem_usage = radix_tree_memory_usage(radixtree);
+		fprintf(stderr, "radix_tree_memory_usage() reported " UINT64_FORMAT " (%0.2f bytes / integer)\n",
+				mem_usage, (double) mem_usage / spec->num_values);
+
+		MemoryContextStats(radixtree_ctx);
+	}
+
+	/* Check that radix_tree_num_entries works */
+	n = radix_tree_num_entries(radixtree);
+	if (n != spec->num_values)
+		elog(ERROR, "radix_tree_num_entries returned " UINT64_FORMAT ", expected " UINT64_FORMAT, n, spec->num_values);
+
+	/*
+	 * Test random-access probes with radix_tree_search()
+	 */
+	starttime = GetCurrentTimestamp();
+
+	for (n = 0; n < 100000; n++)
+	{
+		bool		found;
+		bool		expected;
+		uint64		x;
+		Datum		v;
+
+		/*
+		 * Pick next value to probe at random.  We limit the probes to the
+		 * last integer that we added to the set, plus an arbitrary constant
+		 * (1000).  There's no point in probing the whole 0 - 2^64 range, if
+		 * only a small part of the integer space is used.  We would very
+		 * rarely hit values that are actually in the set.
+		 */
+		x = pg_prng_uint64_range(&pg_global_prng_state, 0, last_int + 1000);
+
+		/* Do we expect this value to be present in the set? */
+		if (x >= last_int)
+			expected = false;
+		else
+		{
+			uint64		idx = x % spec->spacing;
+
+			if (idx >= patternlen)
+				expected = false;
+			else if (spec->pattern_str[idx] == '1')
+				expected = true;
+			else
+				expected = false;
+		}
+
+		/* Is it present according to radix_tree_search() ? */
+		found = radix_tree_search(radixtree, x, &v);
+
+		if (found != expected)
+			elog(ERROR, "mismatch at 0x" UINT64_HEX_FORMAT ": %d vs %d", x, found, expected);
+		if (found && (DatumGetUInt64(v) != x))
+			elog(ERROR, "found 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT,
+				 DatumGetUInt64(v), x);
+	}
+	endtime = GetCurrentTimestamp();
+	if (radix_tree_test_stats)
+		fprintf(stderr, "probed " UINT64_FORMAT " values in %d ms\n",
+				n, (int) (endtime - starttime) / 1000);
+
+	/*
+	 * Test iterator
+	 */
+	starttime = GetCurrentTimestamp();
+
+	iter = radix_tree_begin_iterate(radixtree);
+	n = 0;
+	last_int = 0;
+	while (n < spec->num_values)
+	{
+		for (int i = 0; i < pattern_num_values && n < spec->num_values; i++)
+		{
+			uint64		expected = last_int + pattern_values[i];
+			uint64		x;
+			uint64		val;
+
+			if (!radix_tree_iterate_next(iter, &x, &val))
+				break;
+
+			if (x != expected)
+				elog(ERROR,
+					 "iterate returned wrong key; got 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT " at %d", x, expected, i);
+			if (DatumGetUInt64(val) != expected)
+				elog(ERROR,
+					 "iterate returned wrong value; got 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT " at %d", x, expected, i);
+			n++;
+		}
+		last_int += spec->spacing;
+	}
+	endtime = GetCurrentTimestamp();
+	if (radix_tree_test_stats)
+		fprintf(stderr, "iterated " UINT64_FORMAT " values in %d ms\n",
+				n, (int) (endtime - starttime) / 1000);
+
+	if (n < spec->num_values)
+		elog(ERROR, "iterator stopped short after " UINT64_FORMAT " entries, expected " UINT64_FORMAT, n, spec->num_values);
+	if (n > spec->num_values)
+		elog(ERROR, "iterator returned " UINT64_FORMAT " entries, " UINT64_FORMAT " was expected", n, spec->num_values);
+
+	/*
+	 * Test random-access probes with radix_tree_delete()
+	 */
+	starttime = GetCurrentTimestamp();
+
+	nbefore = radix_tree_num_entries(radixtree);
+	ndeleted = 0;
+	for (n = 0; n < 100000; n++)
+	{
+		bool		found;
+		uint64		x;
+		Datum		v;
+
+		/*
+		 * Pick next value to probe at random.  We limit the probes to the
+		 * last integer that we added to the set, plus an arbitrary constant
+		 * (1000).  There's no point in probing the whole 0 - 2^64 range, if
+		 * only a small part of the integer space is used.  We would very
+		 * rarely hit values that are actually in the set.
+		 */
+		x = pg_prng_uint64_range(&pg_global_prng_state, 0, last_int + 1000);
+
+		/* Is it present according to radix_tree_search() ? */
+		found = radix_tree_search(radixtree, x, &v);
+
+		if (!found)
+			continue;
+
+		/* If the key is found, delete it and check again */
+		if (!radix_tree_delete(radixtree, x))
+			elog(ERROR, "could not delete key 0x" UINT64_HEX_FORMAT, x);
+		if (radix_tree_search(radixtree, x, &v))
+			elog(ERROR, "found deleted key 0x" UINT64_HEX_FORMAT, x);
+		if (radix_tree_delete(radixtree, x))
+			elog(ERROR, "deleted already-deleted key 0x" UINT64_HEX_FORMAT, x);
+
+		ndeleted++;
+	}
+	endtime = GetCurrentTimestamp();
+	if (radix_tree_test_stats)
+		fprintf(stderr, "deleted " UINT64_FORMAT " values in %d ms\n",
+				ndeleted, (int) (endtime - starttime) / 1000);
+
+	nafter = radix_tree_num_entries(radixtree);
+
+	/* Check that radix_tree_num_entries works */
+	if ((nbefore - ndeleted) != nafter)
+		elog(ERROR, "radix_tree_num_entries returned " UINT64_FORMAT ", expected " UINT64_FORMAT "after " UINT64_FORMAT " deletion",
+			 nafter, (nbefore - ndeleted), ndeleted);
+
+	MemoryContextDelete(radixtree_ctx);
+}
+
+Datum
+test_radixtree(PG_FUNCTION_ARGS)
+{
+	test_empty();
+
+	for (int shift = 0; shift <= (64 - 8); shift += 8)
+		test_node_types(shift);
+
+	/* Test different test patterns, with lots of entries */
+	for (int i = 0; i < lengthof(test_specs); i++)
+		test_pattern(&test_specs[i]);
+
+	PG_RETURN_VOID();
+}
diff --git a/src/test/modules/test_radixtree/test_radixtree.control b/src/test/modules/test_radixtree/test_radixtree.control
new file mode 100644
index 0000000000..e53f2a3e0c
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree.control
@@ -0,0 +1,4 @@
+comment = 'Test code for radix tree'
+default_version = '1.0'
+module_pathname = '$libdir/test_radixtree'
+relocatable = true

diff --git a/src/backend/lib/radixtree.c b/src/backend/lib/radixtree.c
index bf87f932fd..2bb04eba86 100644
--- a/src/backend/lib/radixtree.c
+++ b/src/backend/lib/radixtree.c
@@ -16,6 +16,11 @@
  *
  * The key is a 64-bit unsigned integer and the value is a Datum. Both internal
  * nodes and leaf nodes have the identical structure. For internal tree nodes,
+It might worth mentioning:
+- the paper refers to this technique as "Multi-value leaves"
+- we chose it (I assume) for simplicity and to avoid an additional pointer traversal
+- it is the reason this code currently does not support variable-length keys.
+
  * shift > 0, store the pointer to its child node as the value. The leaf nodes,
  * shift == 0, also have the Datum value that is specified by the user.
  *
@@ -24,6 +29,7 @@
  * Interface
  * ---------
  *
+*_search belongs here too.
  * radix_tree_create		- Create a new, empty radix tree
  * radix_tree_free			- Free the radix tree
  * radix_tree_insert		- Insert a key-value pair
@@ -58,12 +64,18 @@
 #include <immintrin.h>			/* AVX2 intrinsics */
 #endif
 
+// The name prefixes are a bit long, to shorten, maybe s/radix_tree_/rt_/ ?
+// ...and same for capitalized macros -> RT_
+
 /* The number of bits encoded in one tree level */
+// terminology: this is not fanout, it's "span" -- ART has variable fanout (the different node types)
+// maybe BITS_PER_BYTE since the entire code assumes that chunks are byte-addressable
 #define RADIX_TREE_NODE_FANOUT	8
 
 /* The number of maximum slots in the node, used in node-256 */
 #define RADIX_TREE_NODE_MAX_SLOTS (1 << RADIX_TREE_NODE_FANOUT)
 
+// maybe call them "nodes indexed by array lookups" -- the actual size is unimportant and could change
 /*
  * Return the number of bits required to represent nslots slots, used
  * in node-128 and node-256.
@@ -84,7 +96,9 @@
 	((uint8) (((key) >> (shift)) & RADIX_TREE_CHUNK_MASK))
 
 /* Mapping from the value to the bit in is-set bitmap in the node-128 and node-256 */
+// these macros assume we're addressing bytes, so maybe BITS_PER_BYTE instead of span (here referred to as fanout)?
 #define NODE_BITMAP_BYTE(v) ((v) / RADIX_TREE_NODE_FANOUT)
+// Should this be UINT64CONST?
 #define NODE_BITMAP_BIT(v) (UINT64_C(1) << ((v) % RADIX_TREE_NODE_FANOUT))
 
 /* Enum used radix_tree_node_search() */
@@ -132,6 +146,7 @@ typedef struct radix_tree_node
 } radix_tree_node;
 
 /* Macros for radix tree nodes */
+// not sure why are we doing casts here?
 #define IS_LEAF_NODE(n) (((radix_tree_node *) (n))->shift == 0)
 #define IS_EMPTY_NODE(n) (((radix_tree_node *) (n))->count == 0)
 #define NODE_HAS_FREE_SLOT(n) \
@@ -161,11 +176,14 @@ typedef struct radix_tree_node_32
 	Datum		slots[32];
 } radix_tree_node_32;
 
+// unnecessary symbol
 #define RADIX_TREE_NODE_128_BITS RADIX_TREE_NODE_NSLOTS_BITS(128)
 typedef struct radix_tree_node_128
 {
 	radix_tree_node n;
 
+// maybe use 0xFF for INVALID_IDX ? then we can use 0-indexing
+// and if we do that, do we need isset? on creation, we can just memset slot_idx to INVALID_IDX
 	/*
 	 * The index of slots for each fanout. 0 means unused whereas slots is
 	 * 0-indexed. So we can get the slot of the chunk C by slots[C] - 1.
@@ -178,6 +196,7 @@ typedef struct radix_tree_node_128
 	Datum		slots[128];
 } radix_tree_node_128;
 
+// unnecessary symbol
 #define RADIX_TREE_NODE_MAX_BITS RADIX_TREE_NODE_NSLOTS_BITS(RADIX_TREE_NODE_MAX_SLOTS)
 typedef struct radix_tree_node_256
 {
@@ -205,6 +224,7 @@ static radix_tree_node_info_elem radix_tree_node_info[] =
 	{"radix tree node 256", 256, sizeof(radix_tree_node_256)},
 };
 
+// this comment is about a data structure, but talks about code somewhere else
 /*
  * As we descend a radix tree, we push the node to the stack. The stack is used
  * at deletion.
@@ -262,6 +282,7 @@ struct radix_tree
 
 static radix_tree_node *radix_tree_node_grow(radix_tree *tree, radix_tree_node *parent,
 											 radix_tree_node *node, uint64 key);
+// maybe _node_find_child or _get_child because "search child" implies to me that we're searching within the child.
 static bool radix_tree_node_search_child(radix_tree_node *node, radix_tree_node **child_p,
 										 uint64 key);
 static bool radix_tree_node_search(radix_tree_node *node, Datum **slot_p, uint64 key,
@@ -289,14 +310,19 @@ static void radix_tree_verify_node(radix_tree_node *node);
 static inline int
 node_32_search_eq(radix_tree_node_32 *node, uint8 chunk)
 {
+// If we use SSE intrinsics on Windows, this code might be still be slow (see below),
+// so also guard with HAVE__BUILTIN_CTZ
 #ifdef __AVX2__
 	__m256i		_key = _mm256_set1_epi8(chunk);
 	__m256i		_data = _mm256_loadu_si256((__m256i_u *) node->chunks);
 	__m256i		_cmp = _mm256_cmpeq_epi8(_key, _data);
 	uint32		bitfield = _mm256_movemask_epi8(_cmp);
 
+// bitfield is uint32, so we don't need UINT64_C
 	bitfield &= ((UINT64_C(1) << node->n.count) - 1);
 
+// To make this portable, should be pg_rightmost_one_pos32().
+// Future TODO: This is slow on Windows, until will need to add the correct interfaces to pg_bitutils.h.
 	return (bitfield) ? __builtin_ctz(bitfield) : -1;
 
 #else
@@ -313,6 +339,7 @@ node_32_search_eq(radix_tree_node_32 *node, uint8 chunk)
 #endif							/* __AVX2__ */
 }
 
+// copy-paste error: search_chunk_array_16_eq
 /*
  * This is a bit more complicated than search_chunk_array_16_eq(), because
  * until recently no unsigned uint8 comparison instruction existed on x86. So
@@ -346,6 +373,7 @@ node_32_search_le(radix_tree_node_32 *node, uint8 chunk)
 #endif							/* __AVX2__ */
 }
 
+// see 0xFF idea above
 /* Does the given chunk in the node has the value? */
 static inline bool
 node_128_is_chunk_used(radix_tree_node_128 *node, uint8 chunk)
@@ -367,6 +395,8 @@ node_128_set(radix_tree_node_128 *node, uint8 chunk, Datum val)
 	int			slotpos = 0;
 
 	/* Search an unused slot */
+	// this could be slow - maybe iterate over the bytes and if the byte < 0xFF then check each bit
+	//
 	while (node_128_is_slot_used(node, slotpos))
 		slotpos++;
 
@@ -516,6 +546,7 @@ radix_tree_extend(radix_tree *tree, uint64 key)
 
 	max_shift = key_get_shift(key);
 
+	// why do we need the "max height" and not just one more?
 	/* Grow tree from 'shift' to 'max_shift' */
 	while (shift <= max_shift)
 	{
@@ -752,6 +783,7 @@ radix_tree_node_insert_val(radix_tree *tree, radix_tree_node *parent,
 						memmove(&(n4->chunks[idx + 1]), &(n4->chunks[idx]),
 								sizeof(uint8) * (n4->n.count - idx));
 						memmove(&(n4->slots[idx + 1]), &(n4->slots[idx]),
+								// sizeof(Datum) ?
 								sizeof(radix_tree_node *) * (n4->n.count - idx));
 					}
 

diff --git a/src/backend/lib/Makefile b/src/backend/lib/Makefile
index 9dad31398a..ead0755d25 100644
--- a/src/backend/lib/Makefile
+++ b/src/backend/lib/Makefile
@@ -22,6 +22,9 @@ OBJS = \
 	integerset.o \
 	knapsack.o \
 	pairingheap.o \
+	radixtree.o \
 	rbtree.o \
 
+radixtree.o: CFLAGS+=-msse2
+
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/lib/radixtree.c b/src/backend/lib/radixtree.c
new file mode 100644
index 0000000000..f1118679d6
--- /dev/null
+++ b/src/backend/lib/radixtree.c
@@ -0,0 +1,2040 @@
+/*-------------------------------------------------------------------------
+ *
+ * radixtree.c
+ *		Implementation for adaptive radix tree.
+ *
+ * This module employs the idea from the paper "The Adaptive Radix Tree: ARTful
+ * Indexing for Main-Memory Databases" by Viktor Leis, Alfons Kemper, and Thomas
+ * Neumann, 2013. The radix tree uses adaptive node sizes, a small number of node
+ * types, each with a different numbers of elements. Depending on the number of
+ * children, the appropriate node type is used.
+ *
+ * There are some differences from the proposed implementation.  For instance,
+ * this radix tree module utilizes AVX2 instruction, enabling us to use 256-bit
+ * width SIMD vector, whereas 128-bit width SIMD vector is used in the paper.
+ * Also, there is no support for path compression and lazy path expansion. The
+ * radix tree supports fixed length of the key so we don't expect the tree level
+ * wouldn't be high.
+ *
+ * The key is a 64-bit unsigned integer and the value is a Datum. Both internal
+ * nodes and leaf nodes have the identical structure. For internal tree nodes,
+ * shift > 0, store the pointer to its child node as the value. The leaf nodes,
+ * shift == 0, also have the Datum value that is specified by the user. The
+ * paper refers to this technique as "Multi-value leaves".  We choose it for
+ * simplicity and to avoid an additional pointer traversal.  It is the reason
+ * this code currently does not support variable-length keys.
+ *
+ * XXX: the radix tree node never be shrunk.
+ *
+ * Interface
+ * ---------
+ *
+ * rt_create		- Create a new, empty radix tree
+ * rt_free			- Free the radix tree
+ * rt_search		- Search a key-value pair
+ * rt_insert		- Insert a key-value pair
+ * rt_delete		- Delete a key-value pair
+ * rt_begin_iterate	- Begin iterating through all key-value pairs
+ * rt_iterate_next	- Return next key-value pair, if any
+ * rt_end_iterate	- End iteration
+ *
+ * rt_create() creates an empty radix tree in the given memory context
+ * and memory contexts for all kinds of radix tree node under the memory context.
+ *
+ * rt_iterate_next() ensures returning key-value pairs in the ascending
+ * order of the key.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/lib/radixtree.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "miscadmin.h"
+#include "port/pg_bitutils.h"
+#include "utils/memutils.h"
+#include "lib/radixtree.h"
+#include "lib/stringinfo.h"
+
+#if defined(__SSE2__)
+#include <emmintrin.h>          /* SSE2 intrinsics */
+#endif
+
+/* The number of bits encoded in one tree level */
+#define RT_NODE_SPAN	BITS_PER_BYTE
+
+/* The number of maximum slots in the node */
+#define RT_NODE_MAX_SLOTS (1 << RT_NODE_SPAN)
+
+/*
+ * Return the number of bits required to represent nslots slots, used
+ * nodes indexed by array lookup.
+ */
+#define RT_NODE_NSLOTS_BITS(nslots) ((nslots) / (sizeof(uint8) * BITS_PER_BYTE))
+
+/* Mask for extracting a chunk from the key */
+#define RT_CHUNK_MASK ((1 << RT_NODE_SPAN) - 1)
+
+/* Maximum shift the radix tree uses */
+#define RT_MAX_SHIFT	key_get_shift(UINT64_MAX)
+
+/* Tree level the radix tree uses */
+#define RT_MAX_LEVEL	((sizeof(uint64) * BITS_PER_BYTE) / RT_NODE_SPAN)
+
+/* Get a chunk from the key */
+#define RT_GET_KEY_CHUNK(key, shift) \
+	((uint8) (((key) >> (shift)) & RT_CHUNK_MASK))
+
+/*
+ * Mapping from the value to the bit in is-set bitmap in the node-128
+ * and node-256.
+ */
+#define RT_NODE_BITMAP_BYTE(v) ((v) / BITS_PER_BYTE)
+#define RT_NODE_BITMAP_BIT(v) (UINT64CONST(1) << ((v) % RT_NODE_SPAN))
+
+/* Enum used rt_node_search() */
+typedef enum
+{
+	RT_ACTION_FIND = 0,		/* find the key-value */
+	RT_ACTION_DELETE,			/* delete the key-value */
+} rt_action;
+
+/*
+ * Supported radix tree nodes.
+ *
+ * XXX: These are currently not well chosen. To reduce memory fragmentation
+ * smaller class should optimally fit neatly into the next larger class
+ * (except perhaps at the lowest end). Right now its
+ * 48 -> 152 -> 296 -> 1304 -> 2088 bytes for inner/leaf nodes, leading to
+ * large amounts of allocator padding with aset.c. Hence the use of slab.
+ *
+ * XXX: need to explain why we choose these node types based on benchmark
+ * results etc.
+ */
+typedef enum rt_node_kind
+{
+	RT_NODE_KIND_4 = 0,
+	RT_NODE_KIND_16,
+	RT_NODE_KIND_32,
+	RT_NODE_KIND_128,
+	RT_NODE_KIND_256
+} rt_node_kind;
+#define RT_NODE_KIND_COUNT 5
+
+/*
+ * Base type for all nodes types.
+ */
+typedef struct rt_node
+{
+	/*
+	 * Number of children.  We use uint16 to be able to indicate 256 children
+	 * at the fanout of 8.
+	 */
+	uint16		count;
+
+	/*
+	 * Shift indicates which part of the key space is represented by this
+	 * node. That is, the key is shifted by 'shift' and the lowest
+	 * RT_NODE_SPAN bits are then represented in chunk.
+	 */
+	uint8		shift;
+	uint8		chunk;
+
+	/* Size class of the node */
+	rt_node_kind kind;
+} rt_node;
+
+/* Macros for radix tree nodes */
+#define IS_LEAF_NODE(n) (((rt_node *) (n))->shift == 0)
+#define IS_EMPTY_NODE(n) (((rt_node *) (n))->count == 0)
+#define NODE_HAS_FREE_SLOT(n) \
+	(((rt_node *) (n))->count < rt_node_info[((rt_node *) (n))->kind].max_slots)
+
+/*
+ * To reduce memory usage compared to a simple radix tree with a fixed
+ * fanout we use adaptive node sides, with different storage methods
+ * for different numbers of elements.
+ */
+typedef struct rt_node_4
+{
+	rt_node n;
+
+	/* 4 children, for key chunks */
+	uint8		chunks[4];
+	Datum		slots[4];
+} rt_node_4;
+
+typedef struct rt_node_16
+{
+	rt_node n;
+
+	/* 16 children, for key chunks */
+	uint8		chunks[16];
+	Datum		slots[16];
+} rt_node_16;
+
+typedef struct rt_node_32
+{
+	rt_node n;
+
+	/* 32 children, for key chunks */
+	uint8		chunks[32];
+	Datum		slots[32];
+} rt_node_32;
+
+#define RT_NODE_128_INVALID_IDX	0xFF
+typedef struct rt_node_128
+{
+	rt_node n;
+
+	/* The index of slots for each fanout */
+	uint8		slot_idxs[RT_NODE_MAX_SLOTS];
+
+	/*
+	 * Slots for 128 children.
+	 *
+	 * Since the rt_node_xxx node is used by both inner and leaf nodes,
+	 * we need to distinguish between a null pointer in inner nodes and
+	 * a (Datum) 0 value in leaf node. isset is a bitmap to track which
+	 * slot is in use.
+	 */
+	Datum		slots[128];
+	uint8		isset[RT_NODE_NSLOTS_BITS(128)];
+} rt_node_128;
+
+typedef struct rt_node_256
+{
+	rt_node n;
+
+	/*
+	 * Slots for 256 children. The isset is a bitmap to track which slot
+	 * is in use.
+	 */
+	Datum		slots[RT_NODE_MAX_SLOTS];
+	uint8		isset[RT_NODE_NSLOTS_BITS(RT_NODE_MAX_SLOTS)];
+} rt_node_256;
+
+/* Information of each size class */
+typedef struct rt_node_info_elem
+{
+	const char *name;
+	int			max_slots;
+	Size		size;
+} rt_node_info_elem;
+
+static rt_node_info_elem rt_node_info[] =
+{
+	{"radix tree node 4", 4, sizeof(rt_node_4)},
+	{"radix tree node 16", 16, sizeof(rt_node_16)},
+	{"radix tree node 32", 32, sizeof(rt_node_32)},
+	{"radix tree node 128", 128, sizeof(rt_node_128)},
+	{"radix tree node 256", 256, sizeof(rt_node_256)},
+};
+
+/*
+ * The data structure for stacking the radix tree nodes.
+ *
+ * During deleting a key-value pair, we descend the radix tree while pushing
+ * the inner nodes. The stack can be freed by using rt_free_stack.
+ */
+typedef struct rt_stack_data
+{
+	rt_node *node;
+	struct rt_stack_data *parent;
+} rt_stack_data;
+typedef rt_stack_data *rt_stack;
+
+/*
+ * Iteration support.
+ *
+ * Iterating the radix tree returns each pair of key and value in the ascending order
+ * of the key. To support this, the we iterate nodes of each level.
+ * rt_iter_node_data struct is used to track the iteration within a node.
+ * rt_iter has the array of this struct, stack, in order to track the iteration
+ * of every level. During the iteration, we also construct the key to return. The key
+ * is updated whenever we update the node iteration information, e.g., when advancing
+ * the current index within the node or when moving to the next node at the same level.
+ */
+typedef struct rt_iter_node_data
+{
+	rt_node *node;		/* current node being iterated */
+	int			current_idx;	/* current position. -1 for initial value */
+} rt_iter_node_data;
+
+struct rt_iter
+{
+	radix_tree *tree;
+
+	/* Track the iteration on nodes of each level */
+	rt_iter_node_data stack[RT_MAX_LEVEL];
+	int			stack_len;
+
+	/* The key is being constructed during the iteration */
+	uint64		key;
+};
+
+/* A radix tree with nodes */
+struct radix_tree
+{
+	MemoryContext context;
+
+	rt_node		*root;
+	uint64		max_val;
+	uint64		num_keys;
+	MemoryContextData *slabs[RT_NODE_KIND_COUNT];
+
+	/* statistics */
+	uint64		mem_used;
+	int32		cnt[RT_NODE_KIND_COUNT];
+};
+
+static rt_node *rt_node_grow(radix_tree *tree, rt_node *parent,
+											 rt_node *node, uint64 key);
+static bool rt_node_find_child(rt_node *node, rt_node **child_p, uint64 key);
+static bool rt_node_search(rt_node *node, Datum **slot_p, uint64 key,
+								   rt_action action);
+static void rt_extend(radix_tree *tree, uint64 key);
+static void rt_new_root(radix_tree *tree, uint64 key, Datum val);
+static rt_node *rt_node_insert_child(radix_tree *tree,
+													 rt_node *parent,
+													 rt_node *node,
+													 uint64 key);
+static void rt_node_insert_val(radix_tree *tree, rt_node *parent,
+									   rt_node *node, uint64 key, Datum val,
+									   bool *replaced_p);
+static inline void rt_iter_update_key(rt_iter *iter, uint8 chunk, uint8 shift);
+static Datum rt_node_iterate_next(rt_iter *iter, rt_iter_node_data *node_iter,
+										  bool *found_p);
+static void rt_store_iter_node(rt_iter *iter, rt_iter_node_data *node_iter,
+									   rt_node *node);
+static void rt_update_iter_stack(rt_iter *iter, int from);
+static void rt_verify_node(rt_node *node);
+
+/*
+ * Helper functions for accessing each kind of nodes.
+ */
+
+static inline int
+node_16_search_eq(rt_node_16 *node, uint8 chunk)
+{
+/*
+ * On Windows, even if we use SSE intrinsics, pg_rightmost_one_pos32 is slow.
+ * So we guard with HAVE__BUILTIN_CTZ as well.
+ *
+ * XXX: once we have the correct interfaces to pg_bitutils.h for Windows
+ * we can remove the HAVE__BUILTIN_CTZ condition.
+ */
+#if defined(__SSE2__) && defined(HAVE__BUILTIN_CTZ)
+	__m128i	key_v = _mm_set1_epi8(chunk);
+	__m128i data_v = _mm_loadu_si128((__m128i_u *) node->chunks);
+	__m128i cmp_v = _mm_cmpeq_epi8(key_v, data_v);
+	uint32	bitfield = _mm_movemask_epi8(cmp_v);
+
+	bitfield &= ((1 << node->n.count) - 1);
+
+	return bitfield ? pg_rightmost_one_pos32(bitfield) : -1;
+#else
+	for (int i = 0; i < node->n.count; i++)
+	{
+		if (node->chunks[i] > chunk)
+			return -1;
+
+		if (node->chunks[i] == chunk)
+			return i;
+	}
+
+	return -1;
+#endif
+}
+
+/*
+ * This is a bit more complicated than search_chunk_array_16_eq(), because
+ * until recently no unsigned uint8 comparison instruction existed on x86. So
+ * we need to play some trickery using _mm_min_epu8() to effectively get
+ * <=. There never will be any equal elements in the current uses, but that's
+ * what we get here...
+ */
+static inline int
+node_16_search_le(rt_node_16 *node, uint8 chunk)
+{
+#if defined(__SSE2__) && defined(HAVE__BUILTIN_CTZ)
+	__m128i key_v = _mm_set1_epi8(chunk);
+	__m128i data_v = _mm_loadu_si128((__m128i_u *) node->chunks);
+	__m128i min_v = _mm_min_epu8(data_v, key_v);
+	__m128i cmp_v = _mm_cmpeq_epi8(key_v, min_v);
+	uint32	bitfield = _mm_movemask_epi8(cmp_v);
+
+	bitfield &= ((1 << node->n.count) - 1);
+
+	return (bitfield) ? pg_rightmost_one_pos32(bitfield) : node->n.count;
+#else
+	int			index;
+
+	for (index = 0; index < node->n.count; index++)
+	{
+		if (node->chunks[index] >= chunk)
+			break;
+	}
+
+	return index;
+#endif
+}
+
+static inline int
+node_32_search_eq(rt_node_32 *node, uint8 chunk)
+{
+#if defined(__SSE2__) && defined(HAVE__BUILTIN_CTZ)
+	int	index = 0;
+	__m128i key_v = _mm_set1_epi8(chunk);
+
+	while (index < node->n.count)
+	{
+		__m128i data_v = _mm_loadu_si128((__m128i_u *) &(node->chunks[index]));
+		__m128i cmp_v = _mm_cmpeq_epi8(key_v, data_v);
+		uint32	bitfield = _mm_movemask_epi8(cmp_v);
+
+		bitfield &= ((UINT64CONST(1) << node->n.count) - 1);
+
+		if (bitfield)
+		{
+			index += pg_rightmost_one_pos32(bitfield);
+			break;
+		}
+
+		index += 16;
+	}
+
+	return (index < node->n.count) ? index : -1;
+#else
+	for (int i = 0; i < node->n.count; i++)
+	{
+		if (node->chunks[i] > chunk)
+			return -1;
+
+		if (node->chunks[i] == chunk)
+			return i;
+	}
+
+	return -1;
+#endif
+}
+
+/*
+ * Similar to node_16_search_le we need to play some trickery using
+ * _mm_min_epu8() to effectively get <=. There never will be any equal elements
+ * in the current uses, but that's what we get here...
+ */
+static inline int
+node_32_search_le(rt_node_32 *node, uint8 chunk)
+{
+#if defined(__SSE2__) && defined(HAVE__BUILTIN_CTZ)
+	int index = 0;
+	bool found = false;
+	__m128i key_v = _mm_set1_epi8(chunk);
+
+	while (index < node->n.count)
+	{
+		__m128i data_v = _mm_loadu_si128((__m128i_u *) &(node->chunks[index]));
+		__m128i min_v = _mm_min_epu8(data_v, key_v);
+		__m128i cmp_v = _mm_cmpeq_epi8(key_v, min_v);
+		uint32	bitfield = _mm_movemask_epi8(cmp_v);
+
+		bitfield &= ((UINT64CONST(1) << node->n.count)-1);
+
+		if (bitfield)
+		{
+			index += pg_rightmost_one_pos32(bitfield);
+			found = true;
+			break;
+		}
+
+		index += 16;
+	}
+
+	return found ? index : node->n.count;
+#else
+	int			index;
+
+	for (index = 0; index < node->n.count; index++)
+	{
+		if (node->chunks[index] >= chunk)
+			break;
+	}
+
+	return index;
+#endif
+}
+
+/* Does the given chunk in the node has the value? */
+static inline bool
+node_128_is_chunk_used(rt_node_128 *node, uint8 chunk)
+{
+	return node->slot_idxs[chunk] != RT_NODE_128_INVALID_IDX;
+}
+
+/* Is the slot in the node used? */
+static inline bool
+node_128_is_slot_used(rt_node_128 *node, uint8 slot)
+{
+	return ((node->isset[RT_NODE_BITMAP_BYTE(slot)] & RT_NODE_BITMAP_BIT(slot)) != 0);
+}
+
+/* Set the slot at the corresponding chunk */
+static inline void
+node_128_set(rt_node_128 *node, uint8 chunk, Datum val)
+{
+	int		slotpos;
+
+	/*
+	 * Find an unused slot. We iterate over the isset bitmap per byte
+	 * then check each bit.
+	 */
+	for (slotpos = 0; slotpos < RT_NODE_NSLOTS_BITS(128); slotpos++)
+	{
+		if (node->isset[slotpos] < 0xFF)
+			break;
+	}
+	Assert(slotpos < RT_NODE_NSLOTS_BITS(128));
+
+	slotpos *= BITS_PER_BYTE;
+	while (node_128_is_slot_used(node, slotpos))
+		slotpos++;
+
+	node->slot_idxs[chunk] = slotpos;
+	node->slots[slotpos] = val;
+	node->isset[RT_NODE_BITMAP_BYTE(slotpos)] |= RT_NODE_BITMAP_BIT(slotpos);
+}
+
+/* Delete the slot at the corresponding chunk */
+static inline void
+node_128_unset(rt_node_128 *node, uint8 chunk)
+{
+	int			slotpos = node->slot_idxs[chunk];
+
+	if (!node_128_is_chunk_used(node, chunk))
+		return;
+
+	node->isset[RT_NODE_BITMAP_BYTE(slotpos)] &= ~(RT_NODE_BITMAP_BIT(slotpos));
+	node->slot_idxs[chunk] = RT_NODE_128_INVALID_IDX;
+}
+
+/* Return the slot data corresponding to the chunk */
+static inline Datum
+node_128_get_chunk_slot(rt_node_128 *node, uint8 chunk)
+{
+	return node->slots[node->slot_idxs[chunk]];
+}
+
+/* Return true if the slot corresponding to the given chunk is in use */
+static inline bool
+node_256_is_chunk_used(rt_node_256 *node, uint8 chunk)
+{
+	return (node->isset[RT_NODE_BITMAP_BYTE(chunk)] & RT_NODE_BITMAP_BIT(chunk)) != 0;
+}
+
+/* Set the slot at the given chunk position */
+static inline void
+node_256_set(rt_node_256 *node, uint8 chunk, Datum slot)
+{
+	node->slots[chunk] = slot;
+	node->isset[RT_NODE_BITMAP_BYTE(chunk)] |= RT_NODE_BITMAP_BIT(chunk);
+}
+
+/* Set the slot at the given chunk position */
+static inline void
+node_256_unset(rt_node_256 *node, uint8 chunk)
+{
+	node->isset[RT_NODE_BITMAP_BYTE(chunk)] &= ~(RT_NODE_BITMAP_BIT(chunk));
+}
+
+/*
+ * Return the shift that is satisfied to store the given key.
+ */
+inline static int
+key_get_shift(uint64 key)
+{
+	return (key == 0)
+		? 0
+		: (pg_leftmost_one_pos64(key) / RT_NODE_SPAN) * RT_NODE_SPAN;
+}
+
+/*
+ * Return the max value stored in a node with the given shift.
+ */
+static uint64
+shift_get_max_val(int shift)
+{
+	if (shift == RT_MAX_SHIFT)
+		return UINT64_MAX;
+
+	return (UINT64CONST(1) << (shift + RT_NODE_SPAN)) - 1;
+}
+
+/*
+ * Allocate a new node with the given node kind.
+ */
+static rt_node *
+rt_alloc_node(radix_tree *tree, rt_node_kind kind)
+{
+	rt_node *newnode;
+
+	newnode = (rt_node *) MemoryContextAllocZero(tree->slabs[kind],
+												 rt_node_info[kind].size);
+	newnode->kind = kind;
+
+	/* Initialize slot_idxs to invalid values */
+	if (kind == RT_NODE_KIND_128)
+	{
+		rt_node_128 *n128 = (rt_node_128 *) newnode;
+
+		memset(&(n128->slot_idxs), RT_NODE_128_INVALID_IDX,
+			   sizeof(n128->slot_idxs));
+	}
+
+	/* update the statistics */
+	tree->mem_used += GetMemoryChunkSpace(newnode);
+	tree->cnt[kind]++;
+
+	return newnode;
+}
+
+/* Free the given node */
+static void
+rt_free_node(radix_tree *tree, rt_node *node)
+{
+	/* If we're deleting the root node, make the tree empty */
+	if (tree->root == node)
+		tree->root = NULL;
+
+	/* update the statistics */
+	tree->mem_used -= GetMemoryChunkSpace(node);
+	tree->cnt[node->kind]--;
+
+	Assert(tree->mem_used >= 0);
+	Assert(tree->cnt[node->kind] >= 0);
+
+	pfree(node);
+}
+
+/* Free a stack made by rt_delete */
+static void
+rt_free_stack(rt_stack stack)
+{
+	rt_stack ostack;
+
+	while (stack != NULL)
+	{
+		ostack = stack;
+		stack = stack->parent;
+		pfree(ostack);
+	}
+}
+
+/* Copy the common fields without the kind */
+static void
+rt_copy_node_common(rt_node *src, rt_node *dst)
+{
+	dst->shift = src->shift;
+	dst->chunk = src->chunk;
+	dst->count = src->count;
+}
+
+/*
+ * The radix tree doesn't sufficient height. Extend the radix tree so it can
+ * store the key.
+ */
+static void
+rt_extend(radix_tree *tree, uint64 key)
+{
+	int			target_shift;
+	int			shift = tree->root->shift + RT_NODE_SPAN;
+
+	target_shift = key_get_shift(key);
+
+	/* Grow tree from 'shift' to 'target_shift' */
+	while (shift <= target_shift)
+	{
+		rt_node_4 *node =
+		(rt_node_4 *) rt_alloc_node(tree, RT_NODE_KIND_4);
+
+		node->n.count = 1;
+		node->n.shift = shift;
+		node->chunks[0] = 0;
+		node->slots[0] = PointerGetDatum(tree->root);
+
+		tree->root->chunk = 0;
+		tree->root = (rt_node *) node;
+
+		shift += RT_NODE_SPAN;
+	}
+
+	tree->max_val = shift_get_max_val(target_shift);
+}
+
+/*
+ * Wrapper for rt_node_search to search the pointer to the child node in the
+ * node.
+ *
+ * Return true if the corresponding child is found, otherwise return false.  On success,
+ * it sets child_p.
+ */
+static bool
+rt_node_find_child(rt_node *node, rt_node **child_p, uint64 key)
+{
+	bool		found = false;
+	Datum	   *slot_ptr;
+
+	if (rt_node_search(node, &slot_ptr, key, RT_ACTION_FIND))
+	{
+		/* Found the pointer to the child node */
+		found = true;
+		*child_p = (rt_node *) DatumGetPointer(*slot_ptr);
+	}
+
+	return found;
+}
+
+/*
+ * Return true if the corresponding slot is used, otherwise return false.  On success,
+ * sets the pointer to the slot to slot_p.
+ */
+static bool
+rt_node_search(rt_node *node, Datum **slot_p, uint64 key,
+					   rt_action action)
+{
+	int			chunk = RT_GET_KEY_CHUNK(key, node->shift);
+	bool		found = false;
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			{
+				rt_node_4 *n4 = (rt_node_4 *) node;
+
+				/* Do linear search */
+				for (int i = 0; i < n4->n.count; i++)
+				{
+					if (n4->chunks[i] > chunk)
+						break;
+
+					/*
+					 * If we find the chunk in the node, do the specified
+					 * action
+					 */
+					if (n4->chunks[i] == chunk)
+					{
+						if (action == RT_ACTION_FIND)
+							*slot_p = &(n4->slots[i]);
+						else	/* RT_ACTION_DELETE */
+						{
+							memmove(&(n4->chunks[i]), &(n4->chunks[i + 1]),
+									sizeof(uint8) * (n4->n.count - i - 1));
+							memmove(&(n4->slots[i]), &(n4->slots[i + 1]),
+									sizeof(rt_node *) * (n4->n.count - i - 1));
+						}
+
+						found = true;
+						break;
+					}
+				}
+
+				break;
+			}
+		case RT_NODE_KIND_16:
+			{
+				rt_node_16 *n16 = (rt_node_16 *) node;
+				int			idx;
+
+				/* Search by SIMD instructions */
+				idx = node_16_search_eq(n16, chunk);
+
+				/* If we find the chunk in the node, do the specified action */
+				if (idx >= 0)
+				{
+					if (action == RT_ACTION_FIND)
+						*slot_p = &(n16->slots[idx]);
+					else		/* RT_ACTION_DELETE */
+					{
+						memmove(&(n16->chunks[idx]), &(n16->chunks[idx + 1]),
+								sizeof(uint8) * (n16->n.count - idx - 1));
+						memmove(&(n16->slots[idx]), &(n16->slots[idx + 1]),
+								sizeof(rt_node *) * (n16->n.count - idx - 1));
+					}
+
+					found = true;
+				}
+
+				break;
+			}
+		case RT_NODE_KIND_32:
+			{
+				rt_node_32 *n32 = (rt_node_32 *) node;
+				int			idx;
+
+				/* Search by SIMD instructions */
+				idx = node_32_search_eq(n32, chunk);
+
+				/* If we find the chunk in the node, do the specified action */
+				if (idx >= 0)
+				{
+					if (action == RT_ACTION_FIND)
+						*slot_p = &(n32->slots[idx]);
+					else		/* RT_ACTION_DELETE */
+					{
+						memmove(&(n32->chunks[idx]), &(n32->chunks[idx + 1]),
+								sizeof(uint8) * (n32->n.count - idx - 1));
+						memmove(&(n32->slots[idx]), &(n32->slots[idx + 1]),
+								sizeof(rt_node *) * (n32->n.count - idx - 1));
+					}
+
+					found = true;
+				}
+
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_128 *n128 = (rt_node_128 *) node;
+
+				/* If we find the chunk in the node, do the specified action */
+				if (node_128_is_chunk_used(n128, chunk))
+				{
+					if (action == RT_ACTION_FIND)
+						*slot_p = &(n128->slots[n128->slot_idxs[chunk]]);
+					else		/* RT_ACTION_DELETE */
+						node_128_unset(n128, chunk);
+
+					found = true;
+				}
+
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				rt_node_256 *n256 = (rt_node_256 *) node;
+
+				/* If we find the chunk in the node, do the specified action */
+				if (node_256_is_chunk_used(n256, chunk))
+				{
+					if (action == RT_ACTION_FIND)
+						*slot_p = &(n256->slots[chunk]);
+					else		/* RT_ACTION_DELETE */
+						node_256_unset(n256, chunk);
+
+					found = true;
+				}
+
+				break;
+			}
+	}
+
+	/* Update the statistics */
+	if (action == RT_ACTION_DELETE && found)
+		node->count--;
+
+	return found;
+}
+
+/*
+ * Create a new node as the root. Subordinate nodes will be created during
+ * the insertion.
+ */
+static void
+rt_new_root(radix_tree *tree, uint64 key, Datum val)
+{
+	rt_node_4 *n4 =
+	(rt_node_4 *) rt_alloc_node(tree, RT_NODE_KIND_4);
+	int			shift = key_get_shift(key);
+
+	n4->n.shift = shift;
+	tree->max_val = shift_get_max_val(shift);
+	tree->root = (rt_node *) n4;
+}
+
+/* Insert 'node' as a child node of 'parent' */
+static rt_node *
+rt_node_insert_child(radix_tree *tree, rt_node *parent,
+					 rt_node *node, uint64 key)
+{
+	rt_node *newchild =
+	(rt_node *) rt_alloc_node(tree, RT_NODE_KIND_4);
+
+	Assert(!IS_LEAF_NODE(node));
+
+	newchild->shift = node->shift - RT_NODE_SPAN;
+	newchild->chunk = RT_GET_KEY_CHUNK(key, node->shift);
+
+	rt_node_insert_val(tree, parent, node, key, PointerGetDatum(newchild), NULL);
+
+	return (rt_node *) newchild;
+}
+
+/*
+ * Insert the value to the node. The node grows if it's full.
+ */
+static void
+rt_node_insert_val(radix_tree *tree, rt_node *parent,
+						   rt_node *node, uint64 key, Datum val,
+						   bool *replaced_p)
+{
+	int			chunk = RT_GET_KEY_CHUNK(key, node->shift);
+	bool		replaced = false;
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			{
+				rt_node_4 *n4 = (rt_node_4 *) node;
+				int			idx;
+
+				for (idx = 0; idx < n4->n.count; idx++)
+				{
+					if (n4->chunks[idx] >= chunk)
+						break;
+				}
+
+				if (NODE_HAS_FREE_SLOT(n4))
+				{
+					if (n4->n.count == 0)
+					{
+						/* the first key for this node, add it */
+					}
+					else if (n4->chunks[idx] == chunk)
+					{
+						/* found the key, replace it */
+						replaced = true;
+					}
+					else if (idx != n4->n.count)
+					{
+						/*
+						 * the key needs to be inserted in the middle of the
+						 * array, make space for the new key.
+						 */
+						memmove(&(n4->chunks[idx + 1]), &(n4->chunks[idx]),
+								sizeof(uint8) * (n4->n.count - idx));
+						memmove(&(n4->slots[idx + 1]), &(n4->slots[idx]),
+								sizeof(Datum) * (n4->n.count - idx));
+					}
+
+					n4->chunks[idx] = chunk;
+					n4->slots[idx] = val;
+
+					/* Done */
+					break;
+				}
+
+				/* The node doesn't have free slot so needs to grow */
+				node = rt_node_grow(tree, parent, node, key);
+				Assert(node->kind == RT_NODE_KIND_16);
+			}
+			/* FALLTHROUGH */
+		case RT_NODE_KIND_16:
+			{
+				rt_node_16 *n16 = (rt_node_16 *) node;
+				int			idx;
+
+				idx = node_16_search_le(n16, chunk);
+
+				if (NODE_HAS_FREE_SLOT(n16))
+				{
+					if (n16->n.count == 0)
+					{
+						/* first key for this node, add it */
+					}
+					else if (n16->chunks[idx] == chunk)
+					{
+						/* found the key, replace it */
+						replaced = true;
+					}
+					else if (idx != n16->n.count)
+					{
+						/*
+						 * the key needs to be inserted in the middle of the
+						 * array, make space for the new key.
+						 */
+						memmove(&(n16->chunks[idx + 1]), &(n16->chunks[idx]),
+								sizeof(uint8) * (n16->n.count - idx));
+						memmove(&(n16->slots[idx + 1]), &(n16->slots[idx]),
+								sizeof(Datum) * (n16->n.count - idx));
+					}
+
+					n16->chunks[idx] = chunk;
+					n16->slots[idx] = val;
+
+					/* Done */
+					break;
+				}
+
+				/* The node doesn't have free slot so needs to grow */
+				node = rt_node_grow(tree, parent, node, key);
+				Assert(node->kind == RT_NODE_KIND_32);
+			}
+			/* FALLTHROUGH */
+		case RT_NODE_KIND_32:
+			{
+				rt_node_32 *n32 = (rt_node_32 *) node;
+				int			idx;
+
+				idx = node_32_search_le(n32, chunk);
+
+				if (NODE_HAS_FREE_SLOT(n32))
+				{
+					if (n32->n.count == 0)
+					{
+						/* first key for this node, add it */
+					}
+					else if (n32->chunks[idx] == chunk)
+					{
+						/* found the key, replace it */
+						replaced = true;
+					}
+					else if (idx != n32->n.count)
+					{
+						/*
+						 * the key needs to be inserted in the middle of the
+						 * array, make space for the new key.
+						 */
+						memmove(&(n32->chunks[idx + 1]), &(n32->chunks[idx]),
+								sizeof(uint8) * (n32->n.count - idx));
+						memmove(&(n32->slots[idx + 1]), &(n32->slots[idx]),
+								sizeof(Datum) * (n32->n.count - idx));
+					}
+
+					n32->chunks[idx] = chunk;
+					n32->slots[idx] = val;
+
+					/* Done */
+					break;
+				}
+
+				/* The node doesn't have free slot so needs to grow */
+				node = rt_node_grow(tree, parent, node, key);
+				Assert(node->kind == RT_NODE_KIND_128);
+			}
+			/* FALLTHROUGH */
+		case RT_NODE_KIND_128:
+			{
+				rt_node_128 *n128 = (rt_node_128 *) node;
+
+				if (node_128_is_chunk_used(n128, chunk))
+				{
+					/* found the existing value */
+					node_128_set(n128, chunk, val);
+					replaced = true;
+					break;
+				}
+
+				if (NODE_HAS_FREE_SLOT(n128))
+				{
+					node_128_set(n128, chunk, val);
+
+					/* Done */
+					break;
+				}
+
+				/* The node doesn't have free slot so needs to grow */
+				node = rt_node_grow(tree, parent, node, key);
+				Assert(node->kind == RT_NODE_KIND_256);
+			}
+			/* FALLTHROUGH */
+		case RT_NODE_KIND_256:
+			{
+				rt_node_256 *n256 = (rt_node_256 *) node;
+
+				if (node_256_is_chunk_used(n256, chunk))
+					replaced = true;
+
+				node_256_set(n256, chunk, val);
+
+				break;
+			}
+	}
+
+	/* Update statistics */
+	if (!replaced)
+		node->count++;
+
+	if (replaced_p)
+		*replaced_p = replaced;
+
+	/*
+	 * Done. Finally, verify the chunk and value is inserted or replaced
+	 * properly in the node.
+	 */
+	rt_verify_node(node);
+}
+
+/* Change the node type to the next larger one */
+static rt_node *
+rt_node_grow(radix_tree *tree, rt_node *parent, rt_node *node,
+					 uint64 key)
+{
+	rt_node *newnode = NULL;
+
+	Assert(node->count == rt_node_info[node->kind].max_slots);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			{
+				rt_node_4 *n4 = (rt_node_4 *) node;
+				rt_node_16 *new16 =
+				(rt_node_16 *) rt_alloc_node(tree, RT_NODE_KIND_16);
+
+				rt_copy_node_common((rt_node *) n4,
+											(rt_node *) new16);
+
+				/* Copy both chunks and slots to the new node */
+				memcpy(&(new16->chunks), &(n4->chunks), sizeof(uint8) * 4);
+				memcpy(&(new16->slots), &(n4->slots), sizeof(Datum) * 4);
+
+				newnode = (rt_node *) new16;
+				break;
+			}
+		case RT_NODE_KIND_16:
+			{
+				rt_node_16 *n16 = (rt_node_16 *) node;
+				rt_node_32 *new32 =
+				(rt_node_32 *) rt_alloc_node(tree, RT_NODE_KIND_32);
+
+				rt_copy_node_common((rt_node *) n16,
+											(rt_node *) new32);
+
+				/* Copy both chunks and slots to the new node */
+				memcpy(&(new32->chunks), &(n16->chunks), sizeof(uint8) * 16);
+				memcpy(&(new32->slots), &(n16->slots), sizeof(Datum) * 16);
+
+				newnode = (rt_node *) new32;
+				break;
+			}
+		case RT_NODE_KIND_32:
+			{
+				rt_node_32 *n32 = (rt_node_32 *) node;
+				rt_node_128 *new128 =
+				(rt_node_128 *) rt_alloc_node(tree, RT_NODE_KIND_128);
+
+				/* Copy both chunks and slots to the new node */
+				rt_copy_node_common((rt_node *) n32,
+											(rt_node *) new128);
+
+				for (int i = 0; i < n32->n.count; i++)
+					node_128_set(new128, n32->chunks[i], n32->slots[i]);
+
+				newnode = (rt_node *) new128;
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_128 *n128 = (rt_node_128 *) node;
+				rt_node_256 *new256 =
+				(rt_node_256 *) rt_alloc_node(tree, RT_NODE_KIND_256);
+				int			cnt = 0;
+
+				rt_copy_node_common((rt_node *) n128,
+											(rt_node *) new256);
+
+				for (int i = 0; i < RT_NODE_MAX_SLOTS && cnt < n128->n.count; i++)
+				{
+					if (!node_128_is_chunk_used(n128, i))
+						continue;
+
+					node_256_set(new256, i, node_128_get_chunk_slot(n128, i));
+					cnt++;
+				}
+
+				newnode = (rt_node *) new256;
+				break;
+			}
+		case RT_NODE_KIND_256:
+			elog(ERROR, "radix tree node-256 cannot grow");
+			break;
+	}
+
+	if (parent == node)
+	{
+		/* Replace the root node with the new large node */
+		tree->root = newnode;
+	}
+	else
+	{
+		Datum	   *slot_ptr = NULL;
+
+		/* Redirect from the parent to the node */
+		rt_node_search(parent, &slot_ptr, key, RT_ACTION_FIND);
+		Assert(*slot_ptr);
+		*slot_ptr = PointerGetDatum(newnode);
+	}
+
+	/* Verify the node has grown properly */
+	rt_verify_node(newnode);
+
+	/* Free the old node */
+	rt_free_node(tree, node);
+
+	return newnode;
+}
+
+/*
+ * Create the radix tree in the given memory context and return it.
+ */
+radix_tree *
+rt_create(MemoryContext ctx)
+{
+	radix_tree *tree;
+	MemoryContext old_ctx;
+
+	old_ctx = MemoryContextSwitchTo(ctx);
+
+	tree = palloc(sizeof(radix_tree));
+	tree->context = ctx;
+	tree->root = NULL;
+	tree->max_val = 0;
+	tree->num_keys = 0;
+	tree->mem_used = 0;
+
+	/* Create the slab allocator for each size class */
+	for (int i = 0; i < RT_NODE_KIND_COUNT; i++)
+	{
+		tree->slabs[i] = SlabContextCreate(ctx,
+										   rt_node_info[i].name,
+										   SLAB_DEFAULT_BLOCK_SIZE,
+										   rt_node_info[i].size);
+		tree->cnt[i] = 0;
+	}
+
+	MemoryContextSwitchTo(old_ctx);
+
+	return tree;
+}
+
+/*
+ * Free the given radix tree.
+ */
+void
+rt_free(radix_tree *tree)
+{
+	for (int i = 0; i < RT_NODE_KIND_COUNT; i++)
+		MemoryContextDelete(tree->slabs[i]);
+
+	pfree(tree);
+}
+
+/*
+ * Insert the key with the val.
+ *
+ * found_p is set to true if the key already present, otherwise false, if
+ * it's not NULL.
+ *
+ * XXX: do we need to support update_if_exists behavior?
+ */
+void
+rt_insert(radix_tree *tree, uint64 key, Datum val, bool *found_p)
+{
+	int			shift;
+	bool		replaced;
+	rt_node *node;
+	rt_node *parent = tree->root;
+
+	/* Empty tree, create the root */
+	if (!tree->root)
+		rt_new_root(tree, key, val);
+
+	/* Extend the tree if necessary */
+	if (key > tree->max_val)
+		rt_extend(tree, key);
+
+	Assert(tree->root);
+
+	shift = tree->root->shift;
+	node = tree->root;
+	while (shift > 0)
+	{
+		rt_node *child;
+
+		if (!rt_node_find_child(node, &child, key))
+			child = rt_node_insert_child(tree, parent, node, key);
+
+		Assert(child != NULL);
+
+		parent = node;
+		node = child;
+		shift -= RT_NODE_SPAN;
+	}
+
+	/* arrived at a leaf */
+	Assert(IS_LEAF_NODE(node));
+
+	rt_node_insert_val(tree, parent, node, key, val, &replaced);
+
+	/* Update the statistics */
+	if (!replaced)
+		tree->num_keys++;
+
+	if (found_p)
+		*found_p = replaced;
+}
+
+/*
+ * Search the given key in the radix tree. Return true if the key is successfully
+ * found, otherwise return false.  On success, we set the value to *val_p so
+ * it must not be NULL.
+ */
+bool
+rt_search(radix_tree *tree, uint64 key, Datum *val_p)
+{
+	rt_node *node;
+	Datum	   *value_ptr;
+	int			shift;
+
+	Assert(val_p);
+
+	if (!tree->root || key > tree->max_val)
+		return false;
+
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift > 0)
+	{
+		rt_node *child;
+
+		if (!rt_node_find_child(node, &child, key))
+			return false;
+
+		node = child;
+		shift -= RT_NODE_SPAN;
+	}
+
+	/* We reached at a leaf node, search the corresponding slot */
+	Assert(IS_LEAF_NODE(node));
+
+	if (!rt_node_search(node, &value_ptr, key, RT_ACTION_FIND))
+		return false;
+
+	/* Found, set the value to return */
+	*val_p = *value_ptr;
+	return true;
+}
+
+/*
+ * Delete the given key from the radix tree. Return true if the key is found (and
+ * deleted), otherwise do nothing and return false.
+ */
+bool
+rt_delete(radix_tree *tree, uint64 key)
+{
+	rt_node *node;
+	int			shift;
+	rt_stack stack = NULL;
+	bool		deleted;
+
+	if (!tree->root || key > tree->max_val)
+		return false;
+
+	/*
+	 * Descending the tree to search the key while building a stack of nodes
+	 * we visited.
+	 */
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift >= 0)
+	{
+		rt_node *child;
+		rt_stack new_stack;
+
+		new_stack = (rt_stack) palloc(sizeof(rt_stack_data));
+		new_stack->node = node;
+		new_stack->parent = stack;
+		stack = new_stack;
+
+		if (IS_LEAF_NODE(node))
+			break;
+
+		if (!rt_node_find_child(node, &child, key))
+		{
+			rt_free_stack(stack);
+			return false;
+		}
+
+		node = child;
+		shift -= RT_NODE_SPAN;
+	}
+
+	/*
+	 * Delete the key from the leaf node and recursively delete internal nodes
+	 * if necessary.
+	 */
+	Assert(IS_LEAF_NODE(stack->node));
+	while (stack != NULL)
+	{
+		rt_node *node;
+		Datum	   *slot;
+
+		/* pop the node from the stack */
+		node = stack->node;
+		stack = stack->parent;
+
+		deleted = rt_node_search(node, &slot, key, RT_ACTION_DELETE);
+
+		/* If the node didn't become empty, we stop deleting the key */
+		if (!IS_EMPTY_NODE(node))
+			break;
+
+		Assert(deleted);
+
+		/* The node became empty */
+		rt_free_node(tree, node);
+
+		/*
+		 * If we eventually deleted the root node while recursively deleting
+		 * empty nodes, we make the tree empty.
+		 */
+		if (stack == NULL)
+		{
+			tree->root = NULL;
+			tree->max_val = 0;
+		}
+	}
+
+	if (deleted)
+		tree->num_keys--;
+
+	rt_free_stack(stack);
+	return deleted;
+}
+
+/* Create and return the iterator for the given radix tree */
+rt_iter *
+rt_begin_iterate(radix_tree *tree)
+{
+	MemoryContext old_ctx;
+	rt_iter *iter;
+	int			top_level;
+
+	old_ctx = MemoryContextSwitchTo(tree->context);
+
+	iter = (rt_iter *) palloc0(sizeof(rt_iter));
+	iter->tree = tree;
+
+	/* empty tree */
+	if (!iter->tree)
+		return iter;
+
+	top_level = iter->tree->root->shift / RT_NODE_SPAN;
+
+	iter->stack_len = top_level;
+	iter->stack[top_level].node = iter->tree->root;
+	iter->stack[top_level].current_idx = -1;
+
+	/*
+	 * Descend to the left most leaf node from the root. The key is being
+	 * constructed while descending to the leaf.
+	 */
+	rt_update_iter_stack(iter, top_level);
+
+	MemoryContextSwitchTo(old_ctx);
+
+	return iter;
+}
+
+/*
+ * Update the stack of the radix tree node while descending to the leaf from
+ * the 'from' level.
+ */
+static void
+rt_update_iter_stack(rt_iter *iter, int from)
+{
+	rt_node *node = iter->stack[from].node;
+	int			level = from;
+
+	for (;;)
+	{
+		rt_iter_node_data *node_iter = &(iter->stack[level--]);
+		bool		found;
+
+		/* Set the node to this level */
+		rt_store_iter_node(iter, node_iter, node);
+
+		/* Finish if we reached to the leaf node */
+		if (IS_LEAF_NODE(node))
+			break;
+
+		/* Advance to the next slot in the node */
+		node = (rt_node *)
+			DatumGetPointer(rt_node_iterate_next(iter, node_iter, &found));
+
+		/*
+		 * Since we always get the first slot in the node, we have to found
+		 * the slot.
+		 */
+		Assert(found);
+	}
+}
+
+/*
+ * Return true with setting key_p and value_p if there is next key.  Otherwise,
+ * return false.
+ */
+bool
+rt_iterate_next(rt_iter *iter, uint64 *key_p, Datum *value_p)
+{
+	bool		found = false;
+	Datum		slot = (Datum) 0;
+
+	/* Empty tree */
+	if (!iter->tree)
+		return false;
+
+	for (;;)
+	{
+		rt_node *node;
+		rt_iter_node_data *node_iter;
+		int		level;
+
+		/*
+		 * Iterate node at each level from the bottom of the tree, i.e.,
+		 * the lead node, until we find the next slot.
+		 */
+		for (level = 0; level <= iter->stack_len; level++)
+		{
+			slot = rt_node_iterate_next(iter, &(iter->stack[level]), &found);
+
+			if (found)
+				break;
+		}
+
+		/* We could not find any new key-value pair, the iteration finished */
+		if (!found)
+			break;
+
+		/* found the next slot at the leaf node, return it */
+		if (level == 0)
+		{
+			*key_p = iter->key;
+			*value_p = slot;
+			break;
+		}
+
+		/*
+		 * We have advanced slots more than one nodes including both the lead
+		 * node and internal nodes. So we update the stack by descending to the
+		 * left most leaf node from this level.
+		 */
+		node = (rt_node *) DatumGetPointer(slot);
+		node_iter = &(iter->stack[level - 1]);
+		rt_store_iter_node(iter, node_iter, node);
+		rt_update_iter_stack(iter, level - 1);
+	}
+
+	return found;
+}
+
+void
+rt_end_iterate(rt_iter *iter)
+{
+	pfree(iter);
+}
+
+/*
+ * Iterate over the given radix tree node and returns the next slot of the given
+ * node and set true to *found_p, if any.  Otherwise, set false to *found_p.
+ */
+static Datum
+rt_node_iterate_next(rt_iter *iter, rt_iter_node_data *node_iter, bool *found_p)
+{
+	rt_node *node = node_iter->node;
+	Datum		slot = (Datum) 0;
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			{
+				rt_node_4 *n4 = (rt_node_4 *) node_iter->node;
+
+				node_iter->current_idx++;
+
+				if (node_iter->current_idx >= n4->n.count)
+					goto not_found;
+
+				slot = n4->slots[node_iter->current_idx];
+
+				/* Update the part of the key by the current chunk */
+				if (IS_LEAF_NODE(n4))
+					rt_iter_update_key(iter, n4->chunks[node_iter->current_idx], 0);
+
+				break;
+			}
+		case RT_NODE_KIND_16:
+			{
+				rt_node_16 *n16 = (rt_node_16 *) node;
+
+				node_iter->current_idx++;
+
+				if (node_iter->current_idx >= n16->n.count)
+					goto not_found;
+
+				slot = n16->slots[node_iter->current_idx];
+
+				/* Update the part of the key */
+				if (IS_LEAF_NODE(n16))
+					rt_iter_update_key(iter, n16->chunks[node_iter->current_idx], 0);
+
+				break;
+			}
+		case RT_NODE_KIND_32:
+			{
+				rt_node_32 *n32 = (rt_node_32 *) node;
+
+				node_iter->current_idx++;
+
+				if (node_iter->current_idx >= n32->n.count)
+					goto not_found;
+
+				slot = n32->slots[node_iter->current_idx];
+
+				/* Update the part of the key */
+				if (IS_LEAF_NODE(n32))
+					rt_iter_update_key(iter, n32->chunks[node_iter->current_idx], 0);
+
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_128 *n128 = (rt_node_128 *) node;
+				int			i;
+
+				for (i = node_iter->current_idx + 1; i < 256; i++)
+				{
+					if (node_128_is_chunk_used(n128, i))
+						break;
+				}
+
+				if (i >= 256)
+					goto not_found;
+
+				node_iter->current_idx = i;
+				slot = node_128_get_chunk_slot(n128, i);
+
+				/* Update the part of the key */
+				if (IS_LEAF_NODE(n128))
+					rt_iter_update_key(iter, node_iter->current_idx, 0);
+
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				rt_node_256 *n256 = (rt_node_256 *) node;
+				int			i;
+
+				for (i = node_iter->current_idx + 1; i < 256; i++)
+				{
+					if (node_256_is_chunk_used(n256, i))
+						break;
+				}
+
+				if (i >= 256)
+					goto not_found;
+
+				node_iter->current_idx = i;
+				slot = n256->slots[i];
+
+				/* Update the part of the key */
+				if (IS_LEAF_NODE(n256))
+					rt_iter_update_key(iter, node_iter->current_idx, 0);
+
+				break;
+			}
+	}
+
+	*found_p = true;
+	return slot;
+
+not_found:
+	*found_p = false;
+	return (Datum) 0;
+}
+
+/*
+ * Initialize and update the node iteration struct with the given radix tree
+ * node. This function also updates the part of the key by the chunk of the
+ * given node.
+ */
+static void
+rt_store_iter_node(rt_iter *iter, rt_iter_node_data *node_iter,
+				   rt_node *node)
+{
+	node_iter->node = node;
+	node_iter->current_idx = -1;
+
+	rt_iter_update_key(iter, node->chunk, node->shift + RT_NODE_SPAN);
+}
+
+static inline void
+rt_iter_update_key(rt_iter *iter, uint8 chunk, uint8 shift)
+{
+	iter->key &= ~(((uint64) RT_CHUNK_MASK) << shift);
+	iter->key |= (((uint64) chunk) << shift);
+}
+
+/*
+ * Return the number of keys in the radix tree.
+ */
+uint64
+rt_num_entries(radix_tree *tree)
+{
+	return tree->num_keys;
+}
+
+/*
+ * Return the statistics of the amount of memory used by the radix tree.
+ */
+uint64
+rt_memory_usage(radix_tree *tree)
+{
+	return tree->mem_used;
+}
+
+/*
+ * Verify the radix tree node.
+ */
+static void
+rt_verify_node(rt_node *node)
+{
+#ifdef USE_ASSERT_CHECKING
+	Assert(node->count >= 0);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			{
+				rt_node_4 *n4 = (rt_node_4 *) node;
+
+				/* Check if the chunks in the node are sorted */
+				for (int i = 1; i < n4->n.count; i++)
+					Assert(n4->chunks[i - 1] < n4->chunks[i]);
+
+				break;
+			}
+		case RT_NODE_KIND_16:
+			{
+				rt_node_16 *n16 = (rt_node_16 *) node;
+
+				/* Check if the chunks in the node are sorted */
+				for (int i = 1; i < n16->n.count; i++)
+					Assert(n16->chunks[i - 1] < n16->chunks[i]);
+
+				break;
+			}
+		case RT_NODE_KIND_32:
+			{
+				rt_node_32 *n32 = (rt_node_32 *) node;
+
+				/* Check if the chunks in the node are sorted */
+				for (int i = 1; i < n32->n.count; i++)
+					Assert(n32->chunks[i - 1] < n32->chunks[i]);
+
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_128 *n128 = (rt_node_128 *) node;
+				int			cnt = 0;
+
+				for (int i = 0; i < RT_NODE_MAX_SLOTS; i++)
+				{
+					if (!node_128_is_chunk_used(n128, i))
+						continue;
+
+					/* Check if the corresponding slot is used */
+					Assert(node_128_is_slot_used(n128, n128->slot_idxs[i]));
+
+					cnt++;
+				}
+
+				Assert(n128->n.count == cnt);
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				rt_node_256 *n256 = (rt_node_256 *) node;
+				int			cnt = 0;
+
+				for (int i = 0; i < RT_NODE_NSLOTS_BITS(RT_NODE_MAX_SLOTS); i++)
+					cnt += pg_popcount32(n256->isset[i]);
+
+				/* Check if the number of used chunk matches */
+				Assert(n256->n.count == cnt);
+
+				break;
+			}
+	}
+#endif
+}
+
+/***************** DEBUG FUNCTIONS *****************/
+#ifdef RT_DEBUG
+void
+rt_stats(radix_tree *tree)
+{
+	fprintf(stderr, "num_keys = %lu, height = %u, n4 = %u(%lu), n16 = %u(%lu),n32 = %u(%lu), n128 = %u(%lu), n256 = %u(%lu)",
+			tree->num_keys,
+			tree->root->shift / RT_NODE_SPAN,
+			tree->cnt[0], tree->cnt[0] * sizeof(rt_node_4),
+			tree->cnt[1], tree->cnt[1] * sizeof(rt_node_16),
+			tree->cnt[2], tree->cnt[2] * sizeof(rt_node_32),
+			tree->cnt[3], tree->cnt[3] * sizeof(rt_node_128),
+			tree->cnt[4], tree->cnt[4] * sizeof(rt_node_256));
+	/* rt_dump(tree); */
+}
+
+static void
+rt_print_slot(StringInfo buf, uint8 chunk, Datum slot, int idx, bool is_leaf, int level)
+{
+	char		space[128] = {0};
+
+	if (level > 0)
+		sprintf(space, "%*c", level * 4, ' ');
+
+	if (is_leaf)
+		appendStringInfo(buf, "%s[%d] \"0x%X\" val(0x%lX) LEAF\n",
+						 space,
+						 idx,
+						 chunk,
+						 DatumGetInt64(slot));
+	else
+		appendStringInfo(buf, "%s[%d] \"0x%X\" -> ",
+						 space,
+						 idx,
+						 chunk);
+}
+
+static void
+rt_dump_node(rt_node *node, int level, StringInfo buf, bool recurse)
+{
+	bool		is_leaf = IS_LEAF_NODE(node);
+
+	appendStringInfo(buf, "[\"%s\" type %d, cnt %u, shift %u, chunk \"0x%X\"] chunks:\n",
+					 IS_LEAF_NODE(node) ? "LEAF" : "INNR",
+					 (node->kind == RT_NODE_KIND_4) ? 4 :
+					 (node->kind == RT_NODE_KIND_32) ? 32 :
+					 (node->kind == RT_NODE_KIND_128) ? 128 : 256,
+					 node->count, node->shift, node->chunk);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			{
+				rt_node_4 *n4 = (rt_node_4 *) node;
+
+				for (int i = 0; i < n4->n.count; i++)
+				{
+					rt_print_slot(buf, n4->chunks[i], n4->slots[i], i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							rt_dump_node((rt_node *) n4->slots[i], level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+				break;
+			}
+		case RT_NODE_KIND_16:
+			{
+				rt_node_16 *n16 = (rt_node_16 *) node;
+
+				for (int i = 0; i < n16->n.count; i++)
+				{
+					rt_print_slot(buf, n16->chunks[i], n16->slots[i], i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							rt_dump_node((rt_node *) n16->slots[i], level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+				break;
+			}
+		case RT_NODE_KIND_32:
+			{
+				rt_node_32 *n32 = (rt_node_32 *) node;
+
+				for (int i = 0; i < n32->n.count; i++)
+				{
+					rt_print_slot(buf, n32->chunks[i], n32->slots[i], i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							rt_dump_node((rt_node *) n32->slots[i], level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_128 *n128 = (rt_node_128 *) node;
+
+				for (int j = 0; j < 256; j++)
+				{
+					if (!node_128_is_chunk_used(n128, j))
+						continue;
+
+					appendStringInfo(buf, "slot_idxs[%d]=%d, ", j, n128->slot_idxs[j]);
+				}
+				appendStringInfo(buf, "\nisset-bitmap:");
+				for (int j = 0; j < 16; j++)
+				{
+					appendStringInfo(buf, "%X ", (uint8) n128->isset[j]);
+				}
+				appendStringInfo(buf, "\n");
+
+				for (int i = 0; i < 256; i++)
+				{
+					if (!node_128_is_chunk_used(n128, i))
+						continue;
+
+					rt_print_slot(buf, i, node_128_get_chunk_slot(n128, i),
+										  i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							rt_dump_node((rt_node *) node_128_get_chunk_slot(n128, i),
+												 level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				rt_node_256 *n256 = (rt_node_256 *) node;
+
+				for (int i = 0; i < 256; i++)
+				{
+					if (!node_256_is_chunk_used(n256, i))
+						continue;
+
+					rt_print_slot(buf, i, n256->slots[i], i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							rt_dump_node((rt_node *) n256->slots[i], level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+				break;
+			}
+	}
+}
+
+void
+rt_dump_search(radix_tree *tree, uint64 key)
+{
+	StringInfoData buf;
+	rt_node *node;
+	int			shift;
+	int			level = 0;
+
+	elog(NOTICE, "-----------------------------------------------------------");
+	elog(NOTICE, "max_val = %lu (0x%lX)", tree->max_val, tree->max_val);
+
+	if (!tree->root)
+	{
+		elog(NOTICE, "tree is empty");
+		return;
+	}
+
+	if (key > tree->max_val)
+	{
+		elog(NOTICE, "key %lu (0x%lX) is larger than max val",
+			 key, key);
+		return;
+	}
+
+	initStringInfo(&buf);
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift >= 0)
+	{
+		rt_node *child;
+
+		rt_dump_node(node, level, &buf, false);
+
+		if (IS_LEAF_NODE(node))
+		{
+			Datum	   *dummy;
+
+			/* We reached at a leaf node, find the corresponding slot */
+			rt_node_search(node, &dummy, key, RT_ACTION_FIND);
+
+			break;
+		}
+
+		if (!rt_node_find_child(node, &child, key))
+			break;
+
+		node = child;
+		shift -= RT_NODE_SPAN;
+		level++;
+	}
+
+	elog(NOTICE, "\n%s", buf.data);
+}
+
+void
+rt_dump(radix_tree *tree)
+{
+	StringInfoData buf;
+
+	initStringInfo(&buf);
+
+	elog(NOTICE, "-----------------------------------------------------------");
+	elog(NOTICE, "max_val = %lu", tree->max_val);
+	rt_dump_node(tree->root, 0, &buf, true);
+	elog(NOTICE, "\n%s", buf.data);
+	elog(NOTICE, "-----------------------------------------------------------");
+}
+#endif
diff --git a/src/include/lib/radixtree.h b/src/include/lib/radixtree.h
new file mode 100644
index 0000000000..7efd4bb735
--- /dev/null
+++ b/src/include/lib/radixtree.h
@@ -0,0 +1,42 @@
+/*-------------------------------------------------------------------------
+ *
+ * radixtree.h
+ *	  Interface for radix tree.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		src/include/lib/radixtree.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RADIXTREE_H
+#define RADIXTREE_H
+
+#include "postgres.h"
+
+/* #define RT_DEBUG 1 */
+
+typedef struct radix_tree radix_tree;
+typedef struct rt_iter rt_iter;
+
+extern radix_tree *rt_create(MemoryContext ctx);
+extern bool rt_search(radix_tree *tree, uint64 key, Datum *val_p);
+extern void rt_insert(radix_tree *tree, uint64 key, Datum val, bool *found_p);
+extern bool rt_delete(radix_tree *tree, uint64 key);
+extern void rt_free(radix_tree *tree);
+extern uint64 rt_memory_usage(radix_tree *tree);
+extern uint64 rt_num_entries(radix_tree *tree);
+
+extern rt_iter *rt_begin_iterate(radix_tree *tree);
+extern bool rt_iterate_next(rt_iter *iter, uint64 *key_p, Datum *value_p);
+extern void rt_end_iterate(rt_iter *iter);
+
+
+#ifdef RT_DEBUG
+extern void rt_dump(radix_tree *tree);
+extern void rt_dump_search(radix_tree *tree, uint64 key);
+extern void rt_stats(radix_tree *tree);
+#endif
+
+#endif							/* RADIXTREE_H */
diff --git a/src/test/modules/Makefile b/src/test/modules/Makefile
index 9090226daa..51b2514faf 100644
--- a/src/test/modules/Makefile
+++ b/src/test/modules/Makefile
@@ -24,6 +24,7 @@ SUBDIRS = \
 		  test_parser \
 		  test_pg_dump \
 		  test_predtest \
+		  test_radixtree \
 		  test_rbtree \
 		  test_regex \
 		  test_rls_hooks \
diff --git a/src/test/modules/test_radixtree/.gitignore b/src/test/modules/test_radixtree/.gitignore
new file mode 100644
index 0000000000..5dcb3ff972
--- /dev/null
+++ b/src/test/modules/test_radixtree/.gitignore
@@ -0,0 +1,4 @@
+# Generated subdirectories
+/log/
+/results/
+/tmp_check/
diff --git a/src/test/modules/test_radixtree/Makefile b/src/test/modules/test_radixtree/Makefile
new file mode 100644
index 0000000000..da06b93da3
--- /dev/null
+++ b/src/test/modules/test_radixtree/Makefile
@@ -0,0 +1,23 @@
+# src/test/modules/test_radixtree/Makefile
+
+MODULE_big = test_radixtree
+OBJS = \
+	$(WIN32RES) \
+	test_radixtree.o
+PGFILEDESC = "test_radixtree - test code for src/backend/lib/radixtree.c"
+
+EXTENSION = test_radixtree
+DATA = test_radixtree--1.0.sql
+
+REGRESS = test_radixtree
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = src/test/modules/test_radixtree
+top_builddir = ../../../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
diff --git a/src/test/modules/test_radixtree/README b/src/test/modules/test_radixtree/README
new file mode 100644
index 0000000000..a8b271869a
--- /dev/null
+++ b/src/test/modules/test_radixtree/README
@@ -0,0 +1,7 @@
+test_integerset contains unit tests for testing the integer set implementation
+in src/backend/lib/integerset.c.
+
+The tests verify the correctness of the implementation, but they can also be
+used as a micro-benchmark.  If you set the 'intset_test_stats' flag in
+test_integerset.c, the tests will print extra information about execution time
+and memory usage.
diff --git a/src/test/modules/test_radixtree/expected/test_radixtree.out b/src/test/modules/test_radixtree/expected/test_radixtree.out
new file mode 100644
index 0000000000..cc6970c87c
--- /dev/null
+++ b/src/test/modules/test_radixtree/expected/test_radixtree.out
@@ -0,0 +1,28 @@
+CREATE EXTENSION test_radixtree;
+--
+-- All the logic is in the test_radixtree() function. It will throw
+-- an error if something fails.
+--
+SELECT test_radixtree();
+NOTICE:  testing radix tree node types with shift "0"
+NOTICE:  testing radix tree node types with shift "8"
+NOTICE:  testing radix tree node types with shift "16"
+NOTICE:  testing radix tree node types with shift "24"
+NOTICE:  testing radix tree node types with shift "32"
+NOTICE:  testing radix tree node types with shift "40"
+NOTICE:  testing radix tree node types with shift "48"
+NOTICE:  testing radix tree node types with shift "56"
+NOTICE:  testing radix tree with pattern "all ones"
+NOTICE:  testing radix tree with pattern "alternating bits"
+NOTICE:  testing radix tree with pattern "clusters of ten"
+NOTICE:  testing radix tree with pattern "clusters of hundred"
+NOTICE:  testing radix tree with pattern "one-every-64k"
+NOTICE:  testing radix tree with pattern "sparse"
+NOTICE:  testing radix tree with pattern "single values, distance > 2^32"
+NOTICE:  testing radix tree with pattern "clusters, distance > 2^32"
+NOTICE:  testing radix tree with pattern "clusters, distance > 2^60"
+ test_radixtree 
+----------------
+ 
+(1 row)
+
diff --git a/src/test/modules/test_radixtree/sql/test_radixtree.sql b/src/test/modules/test_radixtree/sql/test_radixtree.sql
new file mode 100644
index 0000000000..41ece5e9f5
--- /dev/null
+++ b/src/test/modules/test_radixtree/sql/test_radixtree.sql
@@ -0,0 +1,7 @@
+CREATE EXTENSION test_radixtree;
+
+--
+-- All the logic is in the test_radixtree() function. It will throw
+-- an error if something fails.
+--
+SELECT test_radixtree();
diff --git a/src/test/modules/test_radixtree/test_radixtree--1.0.sql b/src/test/modules/test_radixtree/test_radixtree--1.0.sql
new file mode 100644
index 0000000000..074a5a7ea7
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree--1.0.sql
@@ -0,0 +1,8 @@
+/* src/test/modules/test_radixtree/test_radixtree--1.0.sql */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION test_radixtree" to load this file. \quit
+
+CREATE FUNCTION test_radixtree()
+RETURNS pg_catalog.void STRICT
+AS 'MODULE_PATHNAME' LANGUAGE C;
diff --git a/src/test/modules/test_radixtree/test_radixtree.c b/src/test/modules/test_radixtree/test_radixtree.c
new file mode 100644
index 0000000000..384b1fc41d
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree.c
@@ -0,0 +1,503 @@
+/*--------------------------------------------------------------------------
+ *
+ * test_radixtree.c
+ *		Test radixtree set data structure.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		src/test/modules/test_radixtree/test_radixtree.c
+ *
+ * -------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "common/pg_prng.h"
+#include "fmgr.h"
+#include "lib/radixtree.h"
+#include "miscadmin.h"
+#include "nodes/bitmapset.h"
+#include "storage/block.h"
+#include "storage/itemptr.h"
+#include "utils/memutils.h"
+#include "utils/timestamp.h"
+
+#define UINT64_HEX_FORMAT "%" INT64_MODIFIER "X"
+
+/*
+ * If you enable this, the "pattern" tests will print information about
+ * how long populating, probing, and iterating the test set takes, and
+ * how much memory the test set consumed.  That can be used as
+ * micro-benchmark of various operations and input patterns (you might
+ * want to increase the number of values used in each of the test, if
+ * you do that, to reduce noise).
+ *
+ * The information is printed to the server's stderr, mostly because
+ * that's where MemoryContextStats() output goes.
+ */
+static const bool rt_test_stats = false;
+
+/* The maximum number of entries each node type can have */
+static int rt_node_max_entries[] = {
+	4,		/* RT_NODE_KIND_4 */
+	16,		/* RT_NODE_KIND_16 */
+	32,		/* RT_NODE_KIND_32 */
+	128,	/* RT_NODE_KIND_128 */
+	256		/* RT_NODE_KIND_256 */
+};
+
+/*
+ * A struct to define a pattern of integers, for use with the test_pattern()
+ * function.
+ */
+typedef struct
+{
+	char	   *test_name;		/* short name of the test, for humans */
+	char	   *pattern_str;	/* a bit pattern */
+	uint64		spacing;		/* pattern repeats at this interval */
+	uint64		num_values;		/* number of integers to set in total */
+} test_spec;
+
+/* Test patterns borrowed from test_integerset.c */
+static const test_spec test_specs[] = {
+	{
+		"all ones", "1111111111",
+		10, 1000000
+	},
+	{
+		"alternating bits", "0101010101",
+		10, 1000000
+	},
+	{
+		"clusters of ten", "1111111111",
+		10000, 1000000
+	},
+	{
+		"clusters of hundred",
+		"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111",
+		10000, 10000000
+	},
+	{
+		"one-every-64k", "1",
+		65536, 1000000
+	},
+	{
+		"sparse", "100000000000000000000000000000001",
+		10000000, 1000000
+	},
+	{
+		"single values, distance > 2^32", "1",
+		UINT64CONST(10000000000), 100000
+	},
+	{
+		"clusters, distance > 2^32", "10101010",
+		UINT64CONST(10000000000), 1000000
+	},
+	{
+		"clusters, distance > 2^60", "10101010",
+		UINT64CONST(2000000000000000000),
+		23						/* can't be much higher than this, or we
+								 * overflow uint64 */
+	}
+};
+
+PG_MODULE_MAGIC;
+
+PG_FUNCTION_INFO_V1(test_radixtree);
+
+static void
+test_empty(void)
+{
+	radix_tree *radixtree;
+	Datum dummy;
+
+	radixtree = rt_create(CurrentMemoryContext);
+
+	if (rt_search(radixtree, 0, &dummy))
+		elog(ERROR, "rt_search on empty tree returned true");
+
+	if (rt_search(radixtree, 1, &dummy))
+		elog(ERROR, "rt_search on empty tree returned true");
+
+	if (rt_search(radixtree, PG_UINT64_MAX, &dummy))
+		elog(ERROR, "rt_search on empty tree returned true");
+
+	if (rt_num_entries(radixtree) != 0)
+		elog(ERROR, "rt_num_entries on empty tree return non-zero");
+
+	rt_free(radixtree);
+}
+
+/*
+ * Check if keys from start to end with the shift exist in the tree.
+ */
+static void
+check_search_on_node(radix_tree *radixtree, uint8 shift, int start, int end)
+{
+	for (int i = start; i < end; i++)
+	{
+		uint64 key = ((uint64) i << shift);
+		Datum val;
+
+		if (!rt_search(radixtree, key, &val))
+			elog(ERROR, "key 0x" UINT64_HEX_FORMAT " is not found on node-%d",
+				 key, end);
+		if (DatumGetUInt64(val) != key)
+			elog(ERROR, "rt_search with key 0x" UINT64_HEX_FORMAT " returns 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT,
+				 key, DatumGetUInt64(val), key);
+	}
+}
+
+static void
+test_node_types_insert(radix_tree *radixtree, uint8 shift)
+{
+	uint64 num_entries;
+
+	for (int i = 0; i < 256; i++)
+	{
+		uint64 key = ((uint64) i << shift);
+		bool found;
+
+		rt_insert(radixtree, key, Int64GetDatum(key), &found);
+
+		if (found)
+			elog(ERROR, "newly inserted key 0x" UINT64_HEX_FORMAT " found", key);
+
+		for (int j = 0; j < lengthof(rt_node_max_entries); j++)
+		{
+			/*
+			 * After filling all slots in each node type, check if the values are
+			 * stored properly.
+			 */
+			if (i == (rt_node_max_entries[j] - 1))
+			{
+				check_search_on_node(radixtree, shift,
+									 (j == 0) ? 0 : rt_node_max_entries[j - 1],
+									 rt_node_max_entries[j]);
+				break;
+			}
+		}
+	}
+
+	num_entries = rt_num_entries(radixtree);
+
+	if (num_entries != 256)
+		elog(ERROR,
+			 "rt_num_entries returned" UINT64_FORMAT ", expected " UINT64_FORMAT,
+			 num_entries, UINT64CONST(256));
+}
+
+static void
+test_node_types_delete(radix_tree *radixtree, uint8 shift)
+{
+	uint64 num_entries;
+
+	for (int i = 0; i < 256; i++)
+	{
+		uint64	key = ((uint64) i << shift);
+		bool	found;
+
+		found = rt_delete(radixtree, key);
+
+		if (!found)
+			elog(ERROR, "inserted key 0x" UINT64_HEX_FORMAT " is not found", key);
+	}
+
+	num_entries = rt_num_entries(radixtree);
+
+	/* The tree must be empty */
+	if (num_entries != 0)
+		elog(ERROR,
+			 "rt_num_entries returned" UINT64_FORMAT ", expected " UINT64_FORMAT,
+			 num_entries, UINT64CONST(256));
+}
+
+/*
+ * Test for inserting and deleting key-value pairs to each node type at the given shift
+ * level.
+ */
+static void
+test_node_types(uint8 shift)
+{
+	radix_tree *radixtree;
+
+	elog(NOTICE, "testing radix tree node types with shift \"%d\"", shift);
+
+	radixtree = rt_create(CurrentMemoryContext);
+
+	/*
+	 * Insert and search entries for every node type at the 'shift' level,
+	 * then delete all entries to make it empty, and insert and search
+	 * entries again.
+	 */
+	test_node_types_insert(radixtree, shift);
+	test_node_types_delete(radixtree, shift);
+	test_node_types_insert(radixtree, shift);
+
+	rt_free(radixtree);
+}
+
+/*
+ * Test with a repeating pattern, defined by the 'spec'.
+ */
+static void
+test_pattern(const test_spec *spec)
+{
+	radix_tree *radixtree;
+	rt_iter *iter;
+	MemoryContext radixtree_ctx;
+	TimestampTz starttime;
+	TimestampTz endtime;
+	uint64		n;
+	uint64		last_int;
+	uint64		ndeleted;
+	uint64		nbefore;
+	uint64		nafter;
+	int			patternlen;
+	uint64	   *pattern_values;
+	uint64		pattern_num_values;
+
+	elog(NOTICE, "testing radix tree with pattern \"%s\"", spec->test_name);
+	if (rt_test_stats)
+		fprintf(stderr, "-----\ntesting radix tree with pattern \"%s\"\n", spec->test_name);
+
+	/* Pre-process the pattern, creating an array of integers from it. */
+	patternlen = strlen(spec->pattern_str);
+	pattern_values = palloc(patternlen * sizeof(uint64));
+	pattern_num_values = 0;
+	for (int i = 0; i < patternlen; i++)
+	{
+		if (spec->pattern_str[i] == '1')
+			pattern_values[pattern_num_values++] = i;
+	}
+
+	/*
+	 * Allocate the radix tree.
+	 *
+	 * Allocate it in a separate memory context, so that we can print its
+	 * memory usage easily.
+	 */
+	radixtree_ctx = AllocSetContextCreate(CurrentMemoryContext,
+										  "radixtree test",
+										  ALLOCSET_SMALL_SIZES);
+	MemoryContextSetIdentifier(radixtree_ctx, spec->test_name);
+	radixtree = rt_create(radixtree_ctx);
+
+	/*
+	 * Add values to the set.
+	 */
+	starttime = GetCurrentTimestamp();
+
+	n = 0;
+	last_int = 0;
+	while (n < spec->num_values)
+	{
+		uint64		x = 0;
+
+		for (int i = 0; i < pattern_num_values && n < spec->num_values; i++)
+		{
+			bool found;
+
+			x = last_int + pattern_values[i];
+
+			rt_insert(radixtree, x, Int64GetDatum(x), &found);
+
+			if (found)
+				elog(ERROR, "newly inserted key 0x" UINT64_HEX_FORMAT " found", x);
+
+			n++;
+		}
+		last_int += spec->spacing;
+	}
+
+	endtime = GetCurrentTimestamp();
+
+	if (rt_test_stats)
+		fprintf(stderr, "added " UINT64_FORMAT " values in %d ms\n",
+				spec->num_values, (int) (endtime - starttime) / 1000);
+
+	/*
+	 * Print stats on the amount of memory used.
+	 *
+	 * We print the usage reported by rt_memory_usage(), as well as the
+	 * stats from the memory context.  They should be in the same ballpark,
+	 * but it's hard to automate testing that, so if you're making changes to
+	 * the implementation, just observe that manually.
+	 */
+	if (rt_test_stats)
+	{
+		uint64		mem_usage;
+
+		/*
+		 * Also print memory usage as reported by rt_memory_usage().  It
+		 * should be in the same ballpark as the usage reported by
+		 * MemoryContextStats().
+		 */
+		mem_usage = rt_memory_usage(radixtree);
+		fprintf(stderr, "rt_memory_usage() reported " UINT64_FORMAT " (%0.2f bytes / integer)\n",
+				mem_usage, (double) mem_usage / spec->num_values);
+
+		MemoryContextStats(radixtree_ctx);
+	}
+
+	/* Check that rt_num_entries works */
+	n = rt_num_entries(radixtree);
+	if (n != spec->num_values)
+		elog(ERROR, "rt_num_entries returned " UINT64_FORMAT ", expected " UINT64_FORMAT, n, spec->num_values);
+
+	/*
+	 * Test random-access probes with rt_search()
+	 */
+	starttime = GetCurrentTimestamp();
+
+	for (n = 0; n < 100000; n++)
+	{
+		bool		found;
+		bool		expected;
+		uint64		x;
+		Datum		v;
+
+		/*
+		 * Pick next value to probe at random.  We limit the probes to the
+		 * last integer that we added to the set, plus an arbitrary constant
+		 * (1000).  There's no point in probing the whole 0 - 2^64 range, if
+		 * only a small part of the integer space is used.  We would very
+		 * rarely hit values that are actually in the set.
+		 */
+		x = pg_prng_uint64_range(&pg_global_prng_state, 0, last_int + 1000);
+
+		/* Do we expect this value to be present in the set? */
+		if (x >= last_int)
+			expected = false;
+		else
+		{
+			uint64		idx = x % spec->spacing;
+
+			if (idx >= patternlen)
+				expected = false;
+			else if (spec->pattern_str[idx] == '1')
+				expected = true;
+			else
+				expected = false;
+		}
+
+		/* Is it present according to rt_search() ? */
+		found = rt_search(radixtree, x, &v);
+
+		if (found != expected)
+			elog(ERROR, "mismatch at 0x" UINT64_HEX_FORMAT ": %d vs %d", x, found, expected);
+		if (found && (DatumGetUInt64(v) != x))
+			elog(ERROR, "found 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT,
+				 DatumGetUInt64(v), x);
+	}
+	endtime = GetCurrentTimestamp();
+	if (rt_test_stats)
+		fprintf(stderr, "probed " UINT64_FORMAT " values in %d ms\n",
+				n, (int) (endtime - starttime) / 1000);
+
+	/*
+	 * Test iterator
+	 */
+	starttime = GetCurrentTimestamp();
+
+	iter = rt_begin_iterate(radixtree);
+	n = 0;
+	last_int = 0;
+	while (n < spec->num_values)
+	{
+		for (int i = 0; i < pattern_num_values && n < spec->num_values; i++)
+		{
+			uint64		expected = last_int + pattern_values[i];
+			uint64		x;
+			uint64		val;
+
+			if (!rt_iterate_next(iter, &x, &val))
+				break;
+
+			if (x != expected)
+				elog(ERROR,
+					 "iterate returned wrong key; got 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT " at %d", x, expected, i);
+			if (DatumGetUInt64(val) != expected)
+				elog(ERROR,
+					 "iterate returned wrong value; got 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT " at %d", x, expected, i);
+			n++;
+		}
+		last_int += spec->spacing;
+	}
+	endtime = GetCurrentTimestamp();
+	if (rt_test_stats)
+		fprintf(stderr, "iterated " UINT64_FORMAT " values in %d ms\n",
+				n, (int) (endtime - starttime) / 1000);
+
+	if (n < spec->num_values)
+		elog(ERROR, "iterator stopped short after " UINT64_FORMAT " entries, expected " UINT64_FORMAT, n, spec->num_values);
+	if (n > spec->num_values)
+		elog(ERROR, "iterator returned " UINT64_FORMAT " entries, " UINT64_FORMAT " was expected", n, spec->num_values);
+
+	/*
+	 * Test random-access probes with rt_delete()
+	 */
+	starttime = GetCurrentTimestamp();
+
+	nbefore = rt_num_entries(radixtree);
+	ndeleted = 0;
+	for (n = 0; n < 100000; n++)
+	{
+		bool		found;
+		uint64		x;
+		Datum		v;
+
+		/*
+		 * Pick next value to probe at random.  We limit the probes to the
+		 * last integer that we added to the set, plus an arbitrary constant
+		 * (1000).  There's no point in probing the whole 0 - 2^64 range, if
+		 * only a small part of the integer space is used.  We would very
+		 * rarely hit values that are actually in the set.
+		 */
+		x = pg_prng_uint64_range(&pg_global_prng_state, 0, last_int + 1000);
+
+		/* Is it present according to rt_search() ? */
+		found = rt_search(radixtree, x, &v);
+
+		if (!found)
+			continue;
+
+		/* If the key is found, delete it and check again */
+		if (!rt_delete(radixtree, x))
+			elog(ERROR, "could not delete key 0x" UINT64_HEX_FORMAT, x);
+		if (rt_search(radixtree, x, &v))
+			elog(ERROR, "found deleted key 0x" UINT64_HEX_FORMAT, x);
+		if (rt_delete(radixtree, x))
+			elog(ERROR, "deleted already-deleted key 0x" UINT64_HEX_FORMAT, x);
+
+		ndeleted++;
+	}
+	endtime = GetCurrentTimestamp();
+	if (rt_test_stats)
+		fprintf(stderr, "deleted " UINT64_FORMAT " values in %d ms\n",
+				ndeleted, (int) (endtime - starttime) / 1000);
+
+	nafter = rt_num_entries(radixtree);
+
+	/* Check that rt_num_entries works */
+	if ((nbefore - ndeleted) != nafter)
+		elog(ERROR, "rt_num_entries returned " UINT64_FORMAT ", expected " UINT64_FORMAT "after " UINT64_FORMAT " deletion",
+			 nafter, (nbefore - ndeleted), ndeleted);
+
+	MemoryContextDelete(radixtree_ctx);
+}
+
+Datum
+test_radixtree(PG_FUNCTION_ARGS)
+{
+	test_empty();
+
+	for (int shift = 0; shift <= (64 - 8); shift += 8)
+		test_node_types(shift);
+
+	/* Test different test patterns, with lots of entries */
+	for (int i = 0; i < lengthof(test_specs); i++)
+		test_pattern(&test_specs[i]);
+
+	PG_RETURN_VOID();
+}
diff --git a/src/test/modules/test_radixtree/test_radixtree.control b/src/test/modules/test_radixtree/test_radixtree.control
new file mode 100644
index 0000000000..e53f2a3e0c
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree.control
@@ -0,0 +1,4 @@
+comment = 'Test code for radix tree'
+default_version = '1.0'
+module_pathname = '$libdir/test_radixtree'
+relocatable = true

diff --git a/src/backend/lib/Makefile b/src/backend/lib/Makefile
index 9dad31398a..ead0755d25 100644
--- a/src/backend/lib/Makefile
+++ b/src/backend/lib/Makefile
@@ -22,6 +22,9 @@ OBJS = \
 	integerset.o \
 	knapsack.o \
 	pairingheap.o \
+	radixtree.o \
 	rbtree.o \
 
+radixtree.o: CFLAGS+=-msse2
+
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/lib/radixtree.c b/src/backend/lib/radixtree.c
new file mode 100644
index 0000000000..1aececbf46
--- /dev/null
+++ b/src/backend/lib/radixtree.c
@@ -0,0 +1,2336 @@
+/*-------------------------------------------------------------------------
+ *
+ * radixtree.c
+ *		Implementation for adaptive radix tree.
+ *
+ * This module employs the idea from the paper "The Adaptive Radix Tree: ARTful
+ * Indexing for Main-Memory Databases" by Viktor Leis, Alfons Kemper, and Thomas
+ * Neumann, 2013. The radix tree uses adaptive node sizes, a small number of node
+ * types, each with a different numbers of elements. Depending on the number of
+ * children, the appropriate node type is used.
+ *
+ * There are some differences from the proposed implementation. For instance,
+ * this radix tree module utilizes AVX2 instruction, enabling us to use 256-bit
+ * width SIMD vector, whereas 128-bit width SIMD vector is used in the paper.
+ * Also, there is no support for path compression and lazy path expansion. The
+ * radix tree supports fixed length of the key so we don't expect the tree level
+ * wouldn't be high.
+ *
+ * Both the key and the value are 64-bit unsigned integer. The internal nodes and
+ * the leaf nodes have slightly different structure: for internal tree nodes,
+ * shift > 0, store the pointer to its child node as the value. The leaf nodes,
+ * shift == 0, have the 64-bit unsigned integer that is specified by the user as
+ * the value. The paper refers to this technique as "Multi-value leaves".  We
+ * choose it to avoid an additional pointer traversal.  It is the reason this code
+ * currently does not support variable-length keys.
+ *
+ * XXX: the radix tree node never be shrunk.
+ *
+ * Interface
+ * ---------
+ *
+ * rt_create		- Create a new, empty radix tree
+ * rt_free			- Free the radix tree
+ * rt_search		- Search a key-value pair
+ * rt_set			- Set a key-value pair
+ * rt_delete		- Delete a key-value pair
+ * rt_begin_iter	- Begin iterating through all key-value pairs
+ * rt_iter_next		- Return next key-value pair, if any
+ * rt_end_iter		- End iteration
+ *
+ * rt_create() creates an empty radix tree in the given memory context
+ * and memory contexts for all kinds of radix tree node under the memory context.
+ *
+ * rt_iterate_next() ensures returning key-value pairs in the ascending
+ * order of the key.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/lib/radixtree.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "miscadmin.h"
+#include "port/pg_bitutils.h"
+#include "utils/memutils.h"
+#include "lib/radixtree.h"
+#include "lib/stringinfo.h"
+
+#if defined(__SSE2__)
+#include <emmintrin.h>			/* SSE2 intrinsics */
+#endif
+
+/* The number of bits encoded in one tree level */
+#define RT_NODE_SPAN	BITS_PER_BYTE
+
+/* The number of maximum slots in the node */
+#define RT_NODE_MAX_SLOTS (1 << RT_NODE_SPAN)
+
+/*
+ * Return the number of bits required to represent nslots slots, used
+ * nodes indexed by array lookup.
+ */
+#define RT_NODE_NSLOTS_BITS(nslots) ((nslots) / (sizeof(uint8) * BITS_PER_BYTE))
+
+/* Mask for extracting a chunk from the key */
+#define RT_CHUNK_MASK ((1 << RT_NODE_SPAN) - 1)
+
+/* Maximum shift the radix tree uses */
+#define RT_MAX_SHIFT	key_get_shift(UINT64_MAX)
+
+/* Tree level the radix tree uses */
+#define RT_MAX_LEVEL	((sizeof(uint64) * BITS_PER_BYTE) / RT_NODE_SPAN)
+
+/* Invalid index used in node-128 */
+#define RT_NODE_128_INVALID_IDX	0xFF
+
+/* Get a chunk from the key */
+#define RT_GET_KEY_CHUNK(key, shift) \
+	((uint8) (((key) >> (shift)) & RT_CHUNK_MASK))
+
+/*
+ * Mapping from the value to the bit in is-set bitmap in the node-256.
+ */
+#define RT_NODE_BITMAP_BYTE(v) ((v) / BITS_PER_BYTE)
+#define RT_NODE_BITMAP_BIT(v) (UINT64CONST(1) << ((v) % RT_NODE_SPAN))
+
+/* Enum used rt_node_search() */
+typedef enum
+{
+	RT_ACTION_FIND = 0,			/* find the key-value */
+	RT_ACTION_DELETE,			/* delete the key-value */
+} rt_action;
+
+/*
+ * Supported radix tree nodes.
+ *
+ * XXX: These are currently not well chosen. To reduce memory fragmentation
+ * smaller class should optimally fit neatly into the next larger class
+ * (except perhaps at the lowest end). Right now its
+ * 48 -> 152 -> 296 -> 1304 -> 2088 bytes for inner/leaf nodes, leading to
+ * large amounts of allocator padding with aset.c. Hence the use of slab.
+ *
+ * XXX: need to have node-1 until there is no path compression optimization?
+ *
+ * XXX: need to explain why we choose these node types based on benchmark
+ * results etc.
+ */
+typedef enum rt_node_kind
+{
+	RT_NODE_KIND_4 = 0,
+	RT_NODE_KIND_16,
+	RT_NODE_KIND_32,
+	RT_NODE_KIND_128,
+	RT_NODE_KIND_256
+} rt_node_kind;
+#define RT_NODE_KIND_COUNT (RT_NODE_KIND_256 + 1)
+
+/*
+ * Base type for all nodes types.
+ */
+typedef struct rt_node
+{
+	/*
+	 * Number of children.  We use uint16 to be able to indicate 256 children
+	 * at the fanout of 8.
+	 */
+	uint16		count;
+
+	/*
+	 * Shift indicates which part of the key space is represented by this
+	 * node. That is, the key is shifted by 'shift' and the lowest
+	 * RT_NODE_SPAN bits are then represented in chunk.
+	 */
+	uint8		shift;
+	uint8		chunk;
+
+	/* Size class of the node */
+	rt_node_kind kind;
+} rt_node;
+
+/* Macros for radix tree nodes */
+#define IS_LEAF_NODE(n) (((rt_node *) (n))->shift == 0)
+#define IS_EMPTY_NODE(n) (((rt_node *) (n))->count == 0)
+#define NODE_HAS_FREE_SLOT(n) \
+	(((rt_node *) (n))->count < rt_node_info[((rt_node *) (n))->kind].fanout)
+
+/* Base types for inner and leaf nodes of each node type */
+typedef struct rd_node_base_4
+{
+	rt_node		n;
+
+	/* 4 children, for key chunks */
+	uint8		chunks[4];
+} rt_node_base_4;
+
+typedef struct rd_node_base_16
+{
+	rt_node		n;
+
+	/* 16 children, for key chunks */
+	uint8		chunks[16];
+}			rt_node_base_16;
+
+typedef struct rd_node_base_32
+{
+	rt_node		n;
+
+	/* 32 children, for key chunks */
+	uint8		chunks[32];
+} rt_node_base_32;
+
+typedef struct rd_node_base_128
+{
+	rt_node		n;
+
+	/* The index of slots for each fanout */
+	uint8		slot_idxs[RT_NODE_MAX_SLOTS];
+
+	/* isset is a bitmap to track which slot is in use */
+	uint8		isset[RT_NODE_NSLOTS_BITS(128)];
+} rt_node_base_128;
+
+typedef struct rd_node_base_256
+{
+	rt_node		n;
+
+	/* isset is a bitmap to track which slot is in use */
+	uint8		isset[RT_NODE_NSLOTS_BITS(RT_NODE_MAX_SLOTS)];
+} rt_node_base_256;
+
+/*
+ * Inner and leaf nodes.
+ *
+ * There are separate from inner node size classes for two main reasons:
+ *
+ * 1) the value type might be different than something fitting into a pointer
+ *    width type
+ * 2) Need to represent non-existing values in a key-type independent way.
+ *
+ * 1) is clearly worth being concerned about, but it's not clear 2) is as
+ * good. It might be better to just indicate non-existing entries the same way
+ * in inner nodes.
+ */
+typedef struct rt_node_inner_4
+{
+	rt_node_base_4 base;
+
+	/* 4 children, for key chunks */
+	rt_node    *children[4];
+} rt_node_inner_4;
+
+typedef struct rt_node_leaf_4
+{
+	rt_node_base_4 base;
+
+	/* 4 values, for key chunks */
+	uint64		values[4];
+}			rt_node_leaf_4;
+
+typedef struct rt_node_inner_16
+{
+	rt_node_base_16 base;
+
+	/* 16 children, for key chunks */
+	rt_node    *children[16];
+}			rt_node_inner_16;
+
+typedef struct rt_node_leaf_16
+{
+	rt_node_base_16 base;
+
+	/* 16 values, for key chunks */
+	uint64		values[16];
+}			rt_node_leaf_16;
+
+typedef struct rt_node_inner_32
+{
+	rt_node_base_32 base;
+
+	/* 32 children, for key chunks */
+	rt_node    *children[32];
+} rt_node_inner_32;
+
+typedef struct rt_node_leaf_32
+{
+	rt_node_base_32 base;
+
+	/* 32 values, for key chunks */
+	uint64		values[32];
+} rt_node_leaf_32;
+
+typedef struct rt_node_inner_128
+{
+	rt_node_base_128 base;
+
+	/* Slots for 128 children */
+	rt_node    *children[128];
+} rt_node_inner_128;
+
+typedef struct rt_node_leaf_128
+{
+	rt_node_base_128 base;
+
+	/* Slots for 128 values */
+	uint64		values[128];
+} rt_node_leaf_128;
+
+typedef struct rt_node_inner_256
+{
+	rt_node_base_256 base;
+
+	/* Slots for 256 children */
+	rt_node    *children[RT_NODE_MAX_SLOTS];
+} rt_node_inner_256;
+
+typedef struct rt_node_leaf_256
+{
+	rt_node_base_256 base;
+
+	/* Slots for 256 values */
+	uint64		values[RT_NODE_MAX_SLOTS];
+} rt_node_leaf_256;
+
+/* Information of each size class */
+typedef struct rt_node_info_elem
+{
+	const char *name;
+	int			fanout;
+	Size		inner_size;
+	Size		leaf_size;
+} rt_node_info_elem;
+
+static rt_node_info_elem rt_node_info[RT_NODE_KIND_COUNT] = {
+
+	[RT_NODE_KIND_4] = {
+		.name = "radix tree node 4",
+		.fanout = 4,
+		.inner_size = sizeof(rt_node_inner_4),
+		.leaf_size = sizeof(rt_node_leaf_4),
+	},
+	[RT_NODE_KIND_16] = {
+		.name = "radix tree node 16",
+		.fanout = 16,
+		.inner_size = sizeof(rt_node_inner_16),
+		.leaf_size = sizeof(rt_node_leaf_16),
+	},
+	[RT_NODE_KIND_32] = {
+		.name = "radix tree node 32",
+		.fanout = 32,
+		.inner_size = sizeof(rt_node_inner_32),
+		.leaf_size = sizeof(rt_node_leaf_32),
+	},
+	[RT_NODE_KIND_128] = {
+		.name = "radix tree node 128",
+		.fanout = 128,
+		.inner_size = sizeof(rt_node_inner_128),
+		.leaf_size = sizeof(rt_node_leaf_128),
+	},
+	[RT_NODE_KIND_256] = {
+		.name = "radix tree node 256",
+		.fanout = 256,
+		.inner_size = sizeof(rt_node_inner_256),
+		.leaf_size = sizeof(rt_node_leaf_256),
+	},
+};
+
+/*
+ * Iteration support.
+ *
+ * Iterating the radix tree returns each pair of key and value in the ascending
+ * order of the key. To support this, the we iterate nodes of each level.
+ * rt_iter_node_data struct is used to track the iteration within a node.
+ * rt_iter has the array of this struct, stack, in order to track the iteration
+ * of every level. During the iteration, we also construct the key to return
+ * whenever we update the node iteration information, e.g., when advancing the
+ * current index within the node or when moving to the next node at the same level.
+ */
+typedef struct rt_iter_node_data
+{
+	rt_node    *node;			/* current node being iterated */
+	int			current_idx;	/* current position. -1 for initial value */
+} rt_iter_node_data;
+
+struct rt_iter
+{
+	radix_tree *tree;
+
+	/* Track the iteration on nodes of each level */
+	rt_iter_node_data stack[RT_MAX_LEVEL];
+	int			stack_len;
+
+	/* The key is being constructed during the iteration */
+	uint64		key;
+};
+
+/* A radix tree with nodes */
+struct radix_tree
+{
+	MemoryContext context;
+
+	rt_node    *root;
+	uint64		max_val;
+	uint64		num_keys;
+
+	MemoryContextData *inner_slabs[RT_NODE_KIND_COUNT];
+	MemoryContextData *leaf_slabs[RT_NODE_KIND_COUNT];
+
+	/* statistics */
+	int32		cnt[RT_NODE_KIND_COUNT];
+};
+
+static rt_node *rt_node_grow(radix_tree *tree, rt_node *parent,
+							 rt_node *node, uint64 key);
+static rt_node *rt_alloc_node(radix_tree *tree, rt_node_kind kind, bool inner);
+static void rt_free_node(radix_tree *tree, rt_node *node);
+static void rt_copy_node_common(rt_node *src, rt_node *dst);
+static void rt_extend(radix_tree *tree, uint64 key);
+static void rt_new_root(radix_tree *tree, uint64 key);
+
+/* search */
+static bool rt_node_search_inner(rt_node *node, uint64 key, rt_action action,
+								 rt_node **child_p);
+static bool rt_node_search_leaf(rt_node *node, uint64 key, rt_action action,
+								uint64 *value_p);
+static bool rt_node_search(rt_node *node, uint64 key, rt_action action, void **slot_p);
+
+/* insertion */
+static rt_node *rt_node_add_new_child(radix_tree *tree, rt_node *parent,
+									  rt_node *node, uint64 key);
+static int	rt_node_prepare_insert(radix_tree *tree, rt_node *parent,
+								   rt_node **node_p, uint64 key,
+								   bool *will_replace_p);
+static void rt_node_insert_inner(radix_tree *tree, rt_node *parent, rt_node *node,
+								 uint64 key, rt_node *child, bool *replaced_p);
+static void rt_node_insert_leaf(radix_tree *tree, rt_node *parent, rt_node *node,
+								uint64 key, uint64 value, bool *replaced_p);
+
+static rt_node *rt_alloc_node(radix_tree *tree, rt_node_kind kind, bool inner);
+static void rt_extend(radix_tree *tree, uint64 key);
+static void rt_new_root(radix_tree *tree, uint64 key);
+static void rt_copy_node_common(rt_node *src, rt_node *dst);
+
+/* iteration */
+static pg_attribute_always_inline void rt_iter_update_key(rt_iter *iter, uint8 chunk,
+														  uint8 shift);
+static void *rt_node_iterate_next(rt_iter *iter, rt_iter_node_data *node_iter,
+								  bool *found_p);
+static void rt_store_iter_node(rt_iter *iter, rt_iter_node_data *node_iter,
+							   rt_node *node);
+static void rt_update_iter_stack(rt_iter *iter, int from);
+
+/* verification (available only with assertion) */
+static void rt_verify_node(rt_node *node);
+
+/*
+ * The fanout threshold to choice how to search the key in the chunk array.
+ *
+ * On platforms where vector instructions, we use the simple for-loop approach for
+ * all cases.
+ */
+#define RT_SIMPLE_LOOP_THRESHOLD		4	/* use simple for-loop */
+#define RT_VECRTORIZED_LOOP_THRESHOLD	32	/* use SIMD instructions */
+
+static pg_attribute_always_inline int
+search_chunk_array_eq(uint8 *chunks, uint8 key, uint8 node_fanout, uint8 node_count)
+{
+	if (node_fanout <= RT_SIMPLE_LOOP_THRESHOLD)
+	{
+		for (int i = 0; i < node_count; i++)
+		{
+			if (chunks[i] > key)
+				return -1;
+
+			if (chunks[i] == key)
+				return i;
+		}
+
+		return -1;
+	}
+	else if (node_fanout <= RT_VECRTORIZED_LOOP_THRESHOLD)
+	{
+		/*
+		 * On Windows, even if we use SSE intrinsics, pg_rightmost_one_pos32
+		 * is slow. So we guard with HAVE__BUILTIN_CTZ as well.
+		 *
+		 * XXX: once we have the correct interfaces to pg_bitutils.h for
+		 * Windows we can remove the HAVE__BUILTIN_CTZ condition.
+		 */
+#if defined(__SSE2__) && defined(HAVE__BUILTIN_CTZ)
+		int			index = 0;
+		__m128i		key_v = _mm_set1_epi8(key);
+
+		while (index < node_count)
+		{
+			__m128i		data_v = _mm_loadu_si128((__m128i_u *) & (chunks[index]));
+			__m128i		cmp_v = _mm_cmpeq_epi8(key_v, data_v);
+			uint32		bitfield = _mm_movemask_epi8(cmp_v);
+
+			bitfield &= ((UINT64CONST(1) << node_count) - 1);
+
+			if (bitfield)
+			{
+				index += pg_rightmost_one_pos32(bitfield);
+				break;
+			}
+
+			index += 16;
+		}
+
+		return (index < node_count) ? index : -1;
+#else
+		for (int i = 0; i < node_count; i++)
+		{
+			if (chunks[i] > key)
+				return -1;
+
+			if (chunks[i] == key)
+				return i;
+		}
+
+		return -1;
+#endif
+	}
+	else
+		elog(ERROR, "unsupported fanout size %u for chunk array search",
+			 node_fanout);
+}
+
+/*
+ * This is a bit more complicated than search_chunk_array_16_eq(), because
+ * until recently no unsigned uint8 comparison instruction existed on x86. So
+ * we need to play some trickery using _mm_min_epu8() to effectively get
+ * <=. There never will be any equal elements in the current uses, but that's
+ * what we get here...
+ */
+static pg_attribute_always_inline int
+search_chunk_array_le(uint8 *chunks, uint8 key, uint8 node_fanout, uint8 node_count)
+{
+	if (node_fanout <= RT_SIMPLE_LOOP_THRESHOLD)
+	{
+		int			index;
+
+		for (index = 0; index < node_count; index++)
+		{
+			if (chunks[index] >= key)
+				break;
+		}
+
+		return index;
+	}
+	else if (node_fanout <= RT_VECRTORIZED_LOOP_THRESHOLD)
+	{
+#if defined(__SSE2__) && defined(HAVE__BUILTIN_CTZ)
+		int			index = 0;
+		bool		found = false;
+		__m128i		key_v = _mm_set1_epi8(key);
+
+		while (index < node_count)
+		{
+			__m128i		data_v = _mm_loadu_si128((__m128i_u *) & (chunks[index]));
+			__m128i		min_v = _mm_min_epu8(data_v, key_v);
+			__m128i		cmp_v = _mm_cmpeq_epi8(key_v, min_v);
+			uint32		bitfield = _mm_movemask_epi8(cmp_v);
+
+			bitfield &= ((UINT64CONST(1) << node_count) - 1);
+
+			if (bitfield)
+			{
+				index += pg_rightmost_one_pos32(bitfield);
+				found = true;
+				break;
+			}
+
+			index += 16;
+		}
+
+		return found ? index : node_count;
+#else
+		int			index;
+
+		for (index = 0; index < node_count; index++)
+		{
+			if (chunks[index] >= key)
+				break;
+		}
+
+		return index;
+#endif
+	}
+	else
+		elog(ERROR, "unsupported fanout size %u for chunk array search",
+			 node_fanout);
+}
+
+/* Node support functions for all node types to get its children or values */
+
+/* Return the array of children in the inner node */
+static rt_node **
+rt_node_get_inner_children(rt_node *node)
+{
+	rt_node   **children = NULL;
+
+	Assert(!IS_LEAF_NODE(node));
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			children = (rt_node **) ((rt_node_inner_4 *) node)->children;
+			break;
+		case RT_NODE_KIND_16:
+			children = (rt_node **) ((rt_node_inner_16 *) node)->children;
+			break;
+		case RT_NODE_KIND_32:
+			children = (rt_node **) ((rt_node_inner_32 *) node)->children;
+			break;
+		case RT_NODE_KIND_128:
+			children = (rt_node **) ((rt_node_inner_128 *) node)->children;
+			break;
+		case RT_NODE_KIND_256:
+			children = (rt_node **) ((rt_node_inner_256 *) node)->children;
+			break;
+		default:
+			elog(ERROR, "unexpected node type %u", node->kind);
+	}
+
+	return children;
+}
+
+/* Return the array of values in the leaf node */
+static uint64 *
+rt_node_get_leaf_values(rt_node *node)
+{
+	uint64	   *values = NULL;
+
+	Assert(IS_LEAF_NODE(node));
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			values = ((rt_node_leaf_4 *) node)->values;
+			break;
+		case RT_NODE_KIND_16:
+			values = ((rt_node_leaf_16 *) node)->values;
+			break;
+		case RT_NODE_KIND_32:
+			values = ((rt_node_leaf_32 *) node)->values;
+			break;
+		case RT_NODE_KIND_128:
+			values = ((rt_node_leaf_128 *) node)->values;
+			break;
+		case RT_NODE_KIND_256:
+			values = ((rt_node_leaf_256 *) node)->values;
+			break;
+		default:
+			elog(ERROR, "unexpected node type %u", node->kind);
+	}
+
+	return values;
+}
+
+/*
+ * Node support functions for node-4, node-16, and node-32.
+ *
+ * These three node types have similar structure -- they have the array of chunks with
+ * different length and corresponding pointers or values depending on inner nodes or
+ * leaf nodes.
+ */
+#define ENSURE_CHUNK_ARRAY_NODE(node) \
+	Assert(((((rt_node*) node)->kind) == RT_NODE_KIND_4) || \
+		   ((((rt_node*) node)->kind) == RT_NODE_KIND_16) || \
+		   ((((rt_node*) node)->kind) == RT_NODE_KIND_32))
+
+/* Get the pointer to either the child or the value at 'idx */
+static void *
+chunk_array_node_get_slot(rt_node *node, int idx)
+{
+	void	   *slot;
+
+	ENSURE_CHUNK_ARRAY_NODE(node);
+
+	if (IS_LEAF_NODE(node))
+	{
+		uint64	   *values = rt_node_get_leaf_values(node);
+
+		slot = (void *) &(values[idx]);
+	}
+	else
+	{
+		rt_node   **children = rt_node_get_inner_children(node);
+
+		slot = (void *) children[idx];
+	}
+
+	return slot;
+}
+
+/* Return the chunk array in the node */
+static uint8 *
+chunk_array_node_get_chunks(rt_node *node)
+{
+	uint8	   *chunk = NULL;
+
+	ENSURE_CHUNK_ARRAY_NODE(node);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			chunk = (uint8 *) ((rt_node_base_4 *) node)->chunks;
+			break;
+		case RT_NODE_KIND_16:
+			chunk = (uint8 *) ((rt_node_base_16 *) node)->chunks;
+			break;
+		case RT_NODE_KIND_32:
+			chunk = (uint8 *) ((rt_node_base_32 *) node)->chunks;
+			break;
+		default:
+			/* this function don't support node-128 and node-256 */
+			elog(ERROR, "unsupported node type %d", node->kind);
+	}
+
+	return chunk;
+}
+
+/* Copy the contents of the node from 'src' to 'dst' */
+static void
+chunk_array_node_copy_chunks_and_slots(rt_node *src, rt_node *dst)
+{
+	uint8	   *chunks_src,
+			   *chunks_dst;
+
+	ENSURE_CHUNK_ARRAY_NODE(src);
+	ENSURE_CHUNK_ARRAY_NODE(dst);
+
+	/* Copy base type */
+	rt_copy_node_common(src, dst);
+
+	/* Copy chunk array */
+	chunks_src = chunk_array_node_get_chunks(src);
+	chunks_dst = chunk_array_node_get_chunks(dst);
+	memcpy(chunks_dst, chunks_src, sizeof(uint8) * src->count);
+
+	/* Copy children or values */
+	if (IS_LEAF_NODE(src))
+	{
+		uint64	   *values_src,
+				   *values_dst;
+
+		Assert(IS_LEAF_NODE(dst));
+		values_src = rt_node_get_leaf_values(src);
+		values_dst = rt_node_get_leaf_values(dst);
+		memcpy(values_dst, values_src, sizeof(uint64) * src->count);
+	}
+	else
+	{
+		rt_node   **children_src,
+				  **children_dst;
+
+		Assert(!IS_LEAF_NODE(dst));
+		children_src = rt_node_get_inner_children(src);
+		children_dst = rt_node_get_inner_children(dst);
+		memcpy(children_dst, children_src, sizeof(rt_node *) * src->count);
+	}
+}
+
+/*
+ * Return the index of the (sorted) chunk array where the chunk is inserted.
+ * Set true to replaced_p if the chunk already exists in the array.
+ */
+static int
+chunk_array_node_find_insert_pos(rt_node *node, uint8 chunk, bool *found_p)
+{
+	uint8	   *chunks;
+	int			idx;
+
+	ENSURE_CHUNK_ARRAY_NODE(node);
+
+	*found_p = false;
+	chunks = chunk_array_node_get_chunks(node);
+
+	/* Find the insert pos */
+	idx = search_chunk_array_le(chunks, chunk,
+								rt_node_info[node->kind].fanout,
+								node->count);
+
+	if (idx < node->count && chunks[idx] == chunk)
+		*found_p = true;
+
+	return idx;
+}
+
+/* Delete the chunk at idx */
+static void
+chunk_array_node_delete(rt_node *node, int idx)
+{
+	uint8	   *chunks = chunk_array_node_get_chunks(node);
+
+	/* delete the chunk from the chunk array */
+	memmove(&(chunks[idx]), &(chunks[idx + 1]),
+			sizeof(uint8) * (node->count - idx - 1));
+
+	/* delete either the value or the child as well */
+	if (IS_LEAF_NODE(node))
+	{
+		uint64	   *values = rt_node_get_leaf_values(node);
+
+		memmove(&(values[idx]),
+				&(values[idx + 1]),
+				sizeof(uint64) * (node->count - idx - 1));
+	}
+	else
+	{
+		rt_node   **children = rt_node_get_inner_children(node);
+
+		memmove(&(children[idx]),
+				&(children[idx + 1]),
+				sizeof(rt_node *) * (node->count - idx - 1));
+	}
+}
+
+/* Support function for both node-128 */
+
+/* Does the given chunk in the node has the value? */
+static pg_attribute_always_inline bool
+node_128_is_chunk_used(rt_node_base_128 *node, uint8 chunk)
+{
+	return node->slot_idxs[chunk] != RT_NODE_128_INVALID_IDX;
+}
+
+/* Is the slot in the node used? */
+static pg_attribute_always_inline bool
+node_128_is_slot_used(rt_node_base_128 *node, uint8 slot)
+{
+	return ((node->isset[RT_NODE_BITMAP_BYTE(slot)] & RT_NODE_BITMAP_BIT(slot)) != 0);
+}
+
+/* Get the pointer to either the child or the value corresponding to chunk */
+static void *
+node_128_get_slot(rt_node_base_128 *node, uint8 chunk)
+{
+	int			slotpos;
+	void	   *slot;
+
+	slotpos = node->slot_idxs[chunk];
+	Assert(slotpos != RT_NODE_128_INVALID_IDX);
+
+	if (IS_LEAF_NODE(node))
+		slot = (void *) &(((rt_node_leaf_128 *) node)->values[slotpos]);
+	else
+		slot = (void *) (((rt_node_inner_128 *) node)->children[slotpos]);
+
+	return slot;
+}
+
+/* Delete the chunk in the node */
+static void
+node_128_delete(rt_node_base_128 *node, uint8 chunk)
+{
+	int			slotpos = node->slot_idxs[chunk];
+
+	node->isset[RT_NODE_BITMAP_BYTE(slotpos)] &= ~(RT_NODE_BITMAP_BIT(slotpos));
+	node->slot_idxs[chunk] = RT_NODE_128_INVALID_IDX;
+}
+
+/* Return an unused slot in node-128 */
+static int
+node_128_find_unused_slot(rt_node_base_128 *node, uint8 chunk)
+{
+	int			slotpos;
+
+	/*
+	 * Find an unused slot. We iterate over the isset bitmap per byte then
+	 * check each bit.
+	 */
+	for (slotpos = 0; slotpos < RT_NODE_NSLOTS_BITS(128); slotpos++)
+	{
+		if (node->isset[slotpos] < 0xFF)
+			break;
+	}
+	Assert(slotpos < RT_NODE_NSLOTS_BITS(128));
+
+	slotpos *= BITS_PER_BYTE;
+	while (node_128_is_slot_used(node, slotpos))
+		slotpos++;
+
+	return slotpos;
+}
+
+
+/* XXX: duplicate with node_128_set_leaf */
+static void
+node_128_set_inner(rt_node_base_128 *node, uint8 chunk, rt_node *child)
+{
+	int			slotpos;
+	rt_node_inner_128 *n128 = (rt_node_inner_128 *) node;
+
+	/* Overwrite the existing value if exists */
+	if (node_128_is_chunk_used(node, chunk))
+	{
+		n128->children[n128->base.slot_idxs[chunk]] = child;
+		return;
+	}
+
+	/* find unused slot */
+	slotpos = node_128_find_unused_slot(node, chunk);
+
+	n128->base.slot_idxs[chunk] = slotpos;
+	n128->base.isset[RT_NODE_BITMAP_BYTE(slotpos)] |= RT_NODE_BITMAP_BIT(slotpos);
+	n128->children[slotpos] = child;
+}
+
+/* Set the slot at the corresponding chunk */
+static void
+node_128_set_leaf(rt_node_base_128 *node, uint8 chunk, uint64 value)
+{
+	int			slotpos;
+	rt_node_leaf_128 *n128 = (rt_node_leaf_128 *) node;
+
+	/* Overwrite the existing value if exists */
+	if (node_128_is_chunk_used(node, chunk))
+	{
+		n128->values[n128->base.slot_idxs[chunk]] = value;
+		return;
+	}
+
+	/* find unused slot */
+	slotpos = node_128_find_unused_slot(node, chunk);
+
+	n128->base.slot_idxs[chunk] = slotpos;
+	n128->base.isset[RT_NODE_BITMAP_BYTE(slotpos)] |= RT_NODE_BITMAP_BIT(slotpos);
+	n128->values[slotpos] = value;
+}
+
+/* Return true if the slot corresponding to the given chunk is in use */
+static bool
+node_256_is_chunk_used(rt_node_base_256 *node, uint8 chunk)
+{
+	return (node->isset[RT_NODE_BITMAP_BYTE(chunk)] & RT_NODE_BITMAP_BIT(chunk)) != 0;
+}
+
+/* Get the pointer to either the child or the value corresponding to chunk */
+static void *
+node_256_get_slot(rt_node_base_256 *node, uint8 chunk)
+{
+	void	   *slot;
+
+	Assert(node_256_is_chunk_used(node, chunk));
+	if (IS_LEAF_NODE(node))
+		slot = (void *) &(((rt_node_leaf_256 *) node)->values[chunk]);
+	else
+		slot = (void *) (((rt_node_inner_256 *) node)->children[chunk]);
+
+	return slot;
+}
+
+/* Set the child in the node-256 */
+static pg_attribute_always_inline void
+node_256_set_inner(rt_node_base_256 *node, uint8 chunk, rt_node *child)
+{
+	rt_node_inner_256 *n256 = (rt_node_inner_256 *) node;
+
+	n256->base.isset[RT_NODE_BITMAP_BYTE(chunk)] |= RT_NODE_BITMAP_BIT(chunk);
+	n256->children[chunk] = child;
+}
+
+/* Set the value in the node-256 */
+static pg_attribute_always_inline void
+node_256_set_leaf(rt_node_base_256 *node, uint8 chunk, uint64 value)
+{
+	rt_node_leaf_256 *n256 = (rt_node_leaf_256 *) node;
+
+	n256->base.isset[RT_NODE_BITMAP_BYTE(chunk)] |= RT_NODE_BITMAP_BIT(chunk);
+	n256->values[chunk] = value;
+}
+
+/* Set the slot at the given chunk position */
+static pg_attribute_always_inline void
+node_256_delete(rt_node_base_256 *node, uint8 chunk)
+{
+	node->isset[RT_NODE_BITMAP_BYTE(chunk)] &= ~(RT_NODE_BITMAP_BIT(chunk));
+}
+
+/*
+ * Return the shift that is satisfied to store the given key.
+ */
+static pg_attribute_always_inline int
+key_get_shift(uint64 key)
+{
+	return (key == 0)
+		? 0
+		: (pg_leftmost_one_pos64(key) / RT_NODE_SPAN) * RT_NODE_SPAN;
+}
+
+/*
+ * Return the max value stored in a node with the given shift.
+ */
+static uint64
+shift_get_max_val(int shift)
+{
+	if (shift == RT_MAX_SHIFT)
+		return UINT64_MAX;
+
+	return (UINT64CONST(1) << (shift + RT_NODE_SPAN)) - 1;
+}
+
+/*
+ * Allocate a new node with the given node kind.
+ */
+static rt_node *
+rt_alloc_node(radix_tree *tree, rt_node_kind kind, bool inner)
+{
+	rt_node    *newnode;
+
+	if (inner)
+		newnode = (rt_node *) MemoryContextAllocZero(tree->inner_slabs[kind],
+													 rt_node_info[kind].inner_size);
+	else
+		newnode = (rt_node *) MemoryContextAllocZero(tree->leaf_slabs[kind],
+													 rt_node_info[kind].leaf_size);
+
+	newnode->kind = kind;
+
+	/* Initialize slot_idxs to invalid values */
+	if (kind == RT_NODE_KIND_128)
+	{
+		rt_node_base_128 *n128 = (rt_node_base_128 *) newnode;
+
+		memset(n128->slot_idxs, RT_NODE_128_INVALID_IDX, sizeof(n128->slot_idxs));
+	}
+
+	/* update the statistics */
+	tree->cnt[kind]++;
+
+	return newnode;
+}
+
+/* Free the given node */
+static void
+rt_free_node(radix_tree *tree, rt_node *node)
+{
+	/* If we're deleting the root node, make the tree empty */
+	if (tree->root == node)
+		tree->root = NULL;
+
+	/* update the statistics */
+	tree->cnt[node->kind]--;
+
+	Assert(tree->cnt[node->kind] >= 0);
+
+	pfree(node);
+}
+
+/* Copy the common fields without the node kind */
+static void
+rt_copy_node_common(rt_node *src, rt_node *dst)
+{
+	dst->shift = src->shift;
+	dst->chunk = src->chunk;
+	dst->count = src->count;
+}
+
+/*
+ * The radix tree doesn't sufficient height. Extend the radix tree so it can
+ * store the key.
+ */
+static void
+rt_extend(radix_tree *tree, uint64 key)
+{
+	int			target_shift;
+	int			shift = tree->root->shift + RT_NODE_SPAN;
+
+	target_shift = key_get_shift(key);
+
+	/* Grow tree from 'shift' to 'target_shift' */
+	while (shift <= target_shift)
+	{
+		rt_node_inner_4 *node =
+		(rt_node_inner_4 *) rt_alloc_node(tree, RT_NODE_KIND_4, true);
+
+		node->base.n.count = 1;
+		node->base.n.shift = shift;
+		node->base.chunks[0] = 0;
+		node->children[0] = tree->root;
+
+		tree->root->chunk = 0;
+		tree->root = (rt_node *) node;
+
+		shift += RT_NODE_SPAN;
+	}
+
+	tree->max_val = shift_get_max_val(target_shift);
+}
+
+/*
+ * Wrapper for rt_node_search to search the pointer to the child node in the
+ * node.
+ *
+ * Return true if the corresponding child is found, otherwise return false.  On success,
+ * it sets child_p.
+ */
+static bool
+rt_node_search_inner(rt_node *node, uint64 key, rt_action action, rt_node **child_p)
+{
+	rt_node    *child;
+
+	if (!rt_node_search(node, key, action, (void **) &child))
+		return false;
+
+	if (child_p)
+		*child_p = child;
+
+	return true;
+}
+
+static bool
+rt_node_search_leaf(rt_node *node, uint64 key, rt_action action, uint64 *value_p)
+{
+	uint64	   *value;
+
+	if (!rt_node_search(node, key, action, (void **) &value))
+		return false;
+
+	if (value_p)
+		*value_p = *value;
+
+	return true;
+}
+
+/*
+ * Return true if the corresponding slot is used, otherwise return false.  On success,
+ * sets the pointer to the slot to slot_p.
+ */
+static bool
+rt_node_search(rt_node *node, uint64 key, rt_action action, void **slot_p)
+{
+	uint8		chunk = RT_GET_KEY_CHUNK(key, node->shift);
+	bool		found = false;
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				int			idx;
+				uint8	   *chunks = chunk_array_node_get_chunks(node);
+
+				idx = search_chunk_array_eq(chunks, chunk,
+											rt_node_info[node->kind].fanout,
+											node->count);
+
+				if (idx < 0)
+					break;
+
+				found = true;
+				if (action == RT_ACTION_FIND)
+					*slot_p = chunk_array_node_get_slot(node, idx);
+				else			/* RT_ACTION_DELETE */
+					chunk_array_node_delete(node, idx);
+
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_base_128 *n128 = (rt_node_base_128 *) node;
+
+				/* If we find the chunk in the node, do the specified action */
+				if (node_128_is_chunk_used(n128, chunk))
+				{
+					if (action == RT_ACTION_FIND)
+						*slot_p = node_128_get_slot(n128, chunk);
+					else		/* RT_ACTION_DELETE */
+						node_128_delete(n128, chunk);
+
+					found = true;
+				}
+
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				rt_node_base_256 *n256 = (rt_node_base_256 *) node;
+
+				/* If we find the chunk in the node, do the specified action */
+				if (node_256_is_chunk_used(n256, chunk))
+				{
+					found = true;
+
+					if (action == RT_ACTION_FIND)
+						*slot_p = node_256_get_slot(n256, chunk);
+					else		/* RT_ACTION_DELETE */
+						node_256_delete(n256, chunk);
+				}
+
+				break;
+			}
+	}
+
+	/* Update the statistics */
+	if (action == RT_ACTION_DELETE && found)
+		node->count--;
+
+	return found;
+}
+
+/*
+ * Create a new node as the root. Subordinate nodes will be created during
+ * the insertion.
+ */
+static void
+rt_new_root(radix_tree *tree, uint64 key)
+{
+	int			shift = key_get_shift(key);
+	rt_node    *node;
+
+	node = (rt_node *) rt_alloc_node(tree, RT_NODE_KIND_4, shift > 0);
+	node->shift = shift;
+	tree->max_val = shift_get_max_val(shift);
+	tree->root = node;
+}
+
+/* Insert 'node' as a child node of 'parent' */
+static rt_node *
+rt_node_add_new_child(radix_tree *tree, rt_node *parent, rt_node *node, uint64 key)
+{
+	uint8		newshift = node->shift - RT_NODE_SPAN;
+	rt_node    *newchild =
+	(rt_node *) rt_alloc_node(tree, RT_NODE_KIND_4, newshift > 0);
+
+	Assert(!IS_LEAF_NODE(node));
+
+	newchild->shift = newshift;
+	newchild->chunk = RT_GET_KEY_CHUNK(key, node->shift);
+
+	rt_node_insert_inner(tree, parent, node, key, newchild, NULL);
+
+	return (rt_node *) newchild;
+}
+
+/*
+ * For upcoming insertions, we make sure that the node has enough free slots or
+ * grow the node if necessary.  We set true to will_replace_p if the chunk
+ * already exists and will be replaced on insertion.
+ *
+ * Return the index in the chunk array where the key can be inserted. We always
+ * return 0 in node-128 and node-256 cases.
+ */
+static int
+rt_node_prepare_insert(radix_tree *tree, rt_node *parent, rt_node **node_p,
+					   uint64 key, bool *will_replace_p)
+{
+	rt_node    *node = *node_p;
+	uint8		chunk = RT_GET_KEY_CHUNK(key, node->shift);
+	bool		will_replace = false;
+	int			idx = 0;
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				bool		can_insert = false;
+
+				while ((node->kind == RT_NODE_KIND_4) ||
+					   (node->kind == RT_NODE_KIND_16) ||
+					   (node->kind == RT_NODE_KIND_32))
+				{
+					/* Find the insert pos */
+					idx = chunk_array_node_find_insert_pos(node, chunk, &will_replace);
+
+					if (will_replace || NODE_HAS_FREE_SLOT(node))
+					{
+						can_insert = true;
+						break;
+					}
+
+					node = rt_node_grow(tree, parent, node, key);
+				}
+
+				if (can_insert)
+				{
+					uint8	   *chunks = chunk_array_node_get_chunks(node);
+
+					/*
+					 * The node has unused slot for this chunk. If the key
+					 * needs to be inserted in the middle of the array, we
+					 * make space for the new key.
+					 */
+					if (!will_replace && node->count != 0 && idx != node->count)
+					{
+						memmove(&(chunks[idx + 1]), &(chunks[idx]),
+								sizeof(uint8) * (node->count - idx));
+
+						/* shift either the values array or the children array */
+						if (IS_LEAF_NODE(node))
+						{
+							uint64	   *values = rt_node_get_leaf_values(node);
+
+							memmove(&(values[idx + 1]),
+									&(values[idx]),
+									sizeof(uint64) * (node->count - idx));
+						}
+						else
+						{
+							rt_node   **children = rt_node_get_inner_children(node);
+
+							memmove(&(children[idx + 1]),
+									&(children[idx]),
+									sizeof(rt_node *) * (node->count - idx));
+						}
+					}
+
+					break;
+				}
+			}
+			/* FALLTHROUGH */
+		case RT_NODE_KIND_128:
+			{
+				rt_node_base_128 *n128 = (rt_node_base_128 *) node;
+
+				if (node_128_is_chunk_used(n128, chunk) || NODE_HAS_FREE_SLOT(n128))
+				{
+					if (node_128_is_chunk_used(n128, chunk))
+						will_replace = true;
+
+					break;
+				}
+
+				node = rt_node_grow(tree, parent, node, key);
+			}
+			/* FALLTHROUGH */
+		case RT_NODE_KIND_256:
+			{
+				rt_node_base_256 *n256 = (rt_node_base_256 *) node;
+
+				if (node_256_is_chunk_used(n256, chunk))
+					will_replace = true;
+
+				break;
+			}
+	}
+
+	*node_p = node;
+	*will_replace_p = will_replace;
+
+	return idx;
+}
+
+/* Insert the child to the inner node */
+static void
+rt_node_insert_inner(radix_tree *tree, rt_node *parent, rt_node *node,
+					 uint64 key, rt_node *child, bool *replaced_p)
+{
+	uint8		chunk = RT_GET_KEY_CHUNK(key, node->shift);
+	int			idx;
+	bool		replaced;
+
+	Assert(!IS_LEAF_NODE(node));
+
+	idx = rt_node_prepare_insert(tree, parent, &node, key, &replaced);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				uint8	   *chunks = chunk_array_node_get_chunks(node);
+				rt_node   **children = rt_node_get_inner_children(node);
+
+				Assert(idx >= 0);
+				chunks[idx] = chunk;
+				children[idx] = child;
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				node_128_set_inner((rt_node_base_128 *) node, chunk, child);
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				node_256_set_inner((rt_node_base_256 *) node, chunk, child);
+				break;
+			}
+	}
+
+	/* Update statistics */
+	if (!replaced)
+		node->count++;
+
+	if (replaced_p)
+		*replaced_p = replaced;
+
+	/*
+	 * Done. Finally, verify the chunk and value is inserted or replaced
+	 * properly in the node.
+	 */
+	rt_verify_node(node);
+}
+
+/* Insert the value to the leaf node */
+static void
+rt_node_insert_leaf(radix_tree *tree, rt_node *parent, rt_node *node,
+					uint64 key, uint64 value, bool *replaced_p)
+{
+	uint8		chunk = RT_GET_KEY_CHUNK(key, node->shift);
+	int			idx;
+	bool		replaced;
+
+	Assert(IS_LEAF_NODE(node));
+
+	idx = rt_node_prepare_insert(tree, parent, &node, key, &replaced);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				uint8	   *chunks = chunk_array_node_get_chunks(node);
+				uint64	   *values = rt_node_get_leaf_values(node);
+
+				Assert(idx >= 0);
+				chunks[idx] = chunk;
+				values[idx] = value;
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				node_128_set_leaf((rt_node_base_128 *) node, chunk, value);
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				node_256_set_leaf((rt_node_base_256 *) node, chunk, value);
+				break;
+			}
+	}
+
+	/* Update statistics */
+	if (!replaced)
+		node->count++;
+
+	*replaced_p = replaced;
+
+	/*
+	 * Done. Finally, verify the chunk and value is inserted or replaced
+	 * properly in the node.
+	 */
+	rt_verify_node(node);
+}
+
+/* Change the node type to the next larger one */
+static rt_node *
+rt_node_grow(radix_tree *tree, rt_node *parent, rt_node *node, uint64 key)
+{
+	rt_node    *newnode = NULL;
+
+	Assert(node->count == rt_node_info[node->kind].fanout);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			{
+				newnode = rt_alloc_node(tree, RT_NODE_KIND_16,
+										IS_LEAF_NODE(node));
+
+				/* Copy both chunks and slots to the new node */
+				chunk_array_node_copy_chunks_and_slots(node, newnode);
+				break;
+			}
+		case RT_NODE_KIND_16:
+			{
+				newnode = rt_alloc_node(tree, RT_NODE_KIND_32,
+										IS_LEAF_NODE(node));
+
+				/* Copy both chunks and slots to the new node */
+				chunk_array_node_copy_chunks_and_slots(node, newnode);
+				break;
+			}
+		case RT_NODE_KIND_32:
+			{
+				newnode = rt_alloc_node(tree, RT_NODE_KIND_128,
+										IS_LEAF_NODE(node));
+
+				/* Copy both chunks and slots to the new node */
+				rt_copy_node_common(node, newnode);
+
+				if (IS_LEAF_NODE(node))
+				{
+					rt_node_leaf_32 *n32 = (rt_node_leaf_32 *) node;
+
+					for (int i = 0; i < node->count; i++)
+						node_128_set_leaf((rt_node_base_128 *) newnode,
+										  n32->base.chunks[i], n32->values[i]);
+				}
+				else
+				{
+					rt_node_inner_32 *n32 = (rt_node_inner_32 *) node;
+
+					for (int i = 0; i < node->count; i++)
+						node_128_set_inner((rt_node_base_128 *) newnode,
+										   n32->base.chunks[i], n32->children[i]);
+				}
+
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_base_128 *n128 = (rt_node_base_128 *) node;
+				int			cnt = 0;
+
+				newnode = rt_alloc_node(tree, RT_NODE_KIND_256,
+										IS_LEAF_NODE(node));
+
+				/* Copy both chunks and slots to the new node */
+				rt_copy_node_common(node, newnode);
+
+				for (int i = 0; i < RT_NODE_MAX_SLOTS && cnt < n128->n.count; i++)
+				{
+					void	   *slot;
+
+					if (!node_128_is_chunk_used(n128, i))
+						continue;
+
+					slot = node_128_get_slot(n128, i);
+
+					if (IS_LEAF_NODE(node))
+						node_256_set_leaf((rt_node_base_256 *) newnode, i,
+										  *(uint64 *) slot);
+					else
+						node_256_set_inner((rt_node_base_256 *) newnode, i,
+										   (rt_node *) slot);
+
+					cnt++;
+				}
+
+				break;
+			}
+		case RT_NODE_KIND_256:
+			elog(ERROR, "radix tree node-256 cannot grow");
+			break;
+	}
+
+	if (parent == node)
+	{
+		/* Replace the root node with the new large node */
+		tree->root = newnode;
+	}
+	else
+	{
+		/* Set the new node to the parent node */
+		rt_node_insert_inner(tree, NULL, parent, key, newnode, NULL);
+	}
+
+	/* Verify the node has grown properly */
+	rt_verify_node(newnode);
+
+	/* Free the old node */
+	rt_free_node(tree, node);
+
+	return newnode;
+}
+
+/*
+ * Create the radix tree in the given memory context and return it.
+ */
+radix_tree *
+rt_create(MemoryContext ctx)
+{
+	radix_tree *tree;
+	MemoryContext old_ctx;
+
+	old_ctx = MemoryContextSwitchTo(ctx);
+
+	tree = palloc(sizeof(radix_tree));
+	tree->context = ctx;
+	tree->root = NULL;
+	tree->max_val = 0;
+	tree->num_keys = 0;
+
+	/* Create the slab allocator for each size class */
+	for (int i = 0; i < RT_NODE_KIND_COUNT; i++)
+	{
+		tree->inner_slabs[i] = SlabContextCreate(ctx,
+												 rt_node_info[i].name,
+												 SLAB_DEFAULT_BLOCK_SIZE,
+												 rt_node_info[i].inner_size);
+		tree->leaf_slabs[i] = SlabContextCreate(ctx,
+												rt_node_info[i].name,
+												SLAB_DEFAULT_BLOCK_SIZE,
+												rt_node_info[i].leaf_size);
+		tree->cnt[i] = 0;
+	}
+
+	MemoryContextSwitchTo(old_ctx);
+
+	return tree;
+}
+
+/*
+ * Free the given radix tree.
+ */
+void
+rt_free(radix_tree *tree)
+{
+	for (int i = 0; i < RT_NODE_KIND_COUNT; i++)
+	{
+		MemoryContextDelete(tree->inner_slabs[i]);
+		MemoryContextDelete(tree->leaf_slabs[i]);
+	}
+
+	pfree(tree);
+}
+
+/*
+ * Set key to value. If the entry exists, we update its value to 'value' and return
+ * true. Returns false if entry doesn't yet exist.
+ */
+bool
+rt_set(radix_tree *tree, uint64 key, uint64 value)
+{
+	int			shift;
+	bool		replaced;
+	rt_node    *node;
+	rt_node    *parent = tree->root;
+
+	/* Empty tree, create the root */
+	if (!tree->root)
+		rt_new_root(tree, key);
+
+	/* Extend the tree if necessary */
+	if (key > tree->max_val)
+		rt_extend(tree, key);
+
+	Assert(tree->root);
+
+	shift = tree->root->shift;
+	node = tree->root;
+
+	while (shift > 0)
+	{
+		rt_node    *child;
+
+		if (!rt_node_search_inner(node, key, RT_ACTION_FIND, &child))
+			child = rt_node_add_new_child(tree, parent, node, key);
+
+		Assert(child);
+
+		parent = node;
+		node = child;
+		shift -= RT_NODE_SPAN;
+	}
+
+	/* arrived at a leaf */
+	Assert(IS_LEAF_NODE(node));
+
+	rt_node_insert_leaf(tree, parent, node, key, value, &replaced);
+
+	/* Update the statistics */
+	if (!replaced)
+		tree->num_keys++;
+
+	return replaced;
+}
+
+/*
+ * Search the given key in the radix tree. Return true if the key is successfully
+ * found, otherwise return false.  On success, we set the value to *val_p so
+ * it must not be NULL.
+ */
+bool
+rt_search(radix_tree *tree, uint64 key, uint64 *value_p)
+{
+	rt_node    *node;
+	int			shift;
+
+	Assert(value_p);
+
+	if (!tree->root || key > tree->max_val)
+		return false;
+
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift > 0)
+	{
+		rt_node    *child;
+
+		if (!rt_node_search_inner(node, key, RT_ACTION_FIND, &child))
+			return false;
+
+		node = child;
+		shift -= RT_NODE_SPAN;
+	}
+
+	/* We reached at a leaf node, search the corresponding slot */
+	Assert(IS_LEAF_NODE(node));
+
+	if (!rt_node_search_leaf(node, key, RT_ACTION_FIND, value_p))
+		return false;
+
+	return true;
+}
+
+/*
+ * Delete the given key from the radix tree. Return true if the key is found (and
+ * deleted), otherwise do nothing and return false.
+ */
+bool
+rt_delete(radix_tree *tree, uint64 key)
+{
+	rt_node    *node;
+	int			shift;
+	rt_node    *stack[RT_MAX_LEVEL] = {0};
+	int			level;
+	bool		deleted;
+
+	if (!tree->root || key > tree->max_val)
+		return false;
+
+	/*
+	 * Descending the tree to search the key while building a stack of nodes
+	 * we visited.
+	 */
+	node = tree->root;
+	shift = tree->root->shift;
+	level = 0;
+	while (shift >= 0)
+	{
+		rt_node    *child;
+
+		/* Push the current node to the stack */
+		stack[level] = node;
+
+		if (IS_LEAF_NODE(node))
+			break;
+
+		if (!rt_node_search_inner(node, key, RT_ACTION_FIND, &child))
+			return false;
+
+		node = child;
+		shift -= RT_NODE_SPAN;
+		level++;
+	}
+
+	/*
+	 * Delete the key from the leaf node and recursively delete internal nodes
+	 * if necessary.
+	 */
+	Assert(IS_LEAF_NODE(stack[level]));
+	while (level >= 0)
+	{
+		rt_node    *node = stack[level--];
+
+		if (IS_LEAF_NODE(node))
+			deleted = rt_node_search_leaf(node, key, RT_ACTION_DELETE, NULL);
+		else
+			deleted = rt_node_search_inner(node, key, RT_ACTION_DELETE, NULL);
+
+		/* If the node didn't become empty, we stop deleting the key */
+		if (!IS_EMPTY_NODE(node))
+			break;
+
+		Assert(deleted);
+
+		/* The node became empty */
+		rt_free_node(tree, node);
+
+	}
+
+	/*
+	 * If we eventually deleted the root node while recursively deleting empty
+	 * nodes, we make the tree empty.
+	 */
+	if (level == 0)
+	{
+		tree->root = NULL;
+		tree->max_val = 0;
+	}
+
+	if (deleted)
+		tree->num_keys--;
+
+	return deleted;
+}
+
+/* Create and return the iterator for the given radix tree */
+rt_iter *
+rt_begin_iterate(radix_tree *tree)
+{
+	MemoryContext old_ctx;
+	rt_iter    *iter;
+	int			top_level;
+
+	old_ctx = MemoryContextSwitchTo(tree->context);
+
+	iter = (rt_iter *) palloc0(sizeof(rt_iter));
+	iter->tree = tree;
+
+	/* empty tree */
+	if (!iter->tree)
+		return iter;
+
+	top_level = iter->tree->root->shift / RT_NODE_SPAN;
+
+	iter->stack_len = top_level;
+	iter->stack[top_level].node = iter->tree->root;
+	iter->stack[top_level].current_idx = -1;
+
+	/*
+	 * Descend to the left most leaf node from the root. The key is being
+	 * constructed while descending to the leaf.
+	 */
+	rt_update_iter_stack(iter, top_level);
+
+	MemoryContextSwitchTo(old_ctx);
+
+	return iter;
+}
+
+/*
+ * Update the stack of the radix tree node while descending to the leaf from
+ * the 'from' level.
+ */
+static void
+rt_update_iter_stack(rt_iter *iter, int from)
+{
+	rt_node    *node = iter->stack[from].node;
+	int			level = from;
+
+	for (;;)
+	{
+		rt_iter_node_data *node_iter = &(iter->stack[level--]);
+		bool		found;
+
+		/* Set the node to this level */
+		rt_store_iter_node(iter, node_iter, node);
+
+		/* Finish if we reached to the leaf node */
+		if (IS_LEAF_NODE(node))
+			break;
+
+		/* Advance to the next slot in the node */
+		node = (rt_node *) rt_node_iterate_next(iter, node_iter, &found);
+
+		/*
+		 * Since we always get the first slot in the node, we have to found
+		 * the slot.
+		 */
+		Assert(found);
+	}
+}
+
+/*
+ * Return true with setting key_p and value_p if there is next key.  Otherwise,
+ * return false.
+ */
+bool
+rt_iterate_next(rt_iter *iter, uint64 *key_p, uint64 *value_p)
+{
+	bool		found = false;
+	void	   *slot;
+
+	/* Empty tree */
+	if (!iter->tree)
+		return false;
+
+	for (;;)
+	{
+		rt_node    *node;
+		rt_iter_node_data *node_iter;
+		int			level;
+
+		/*
+		 * Iterate node at each level from the bottom of the tree, i.e., the
+		 * lead node, until we find the next slot.
+		 */
+		for (level = 0; level <= iter->stack_len; level++)
+		{
+			slot = rt_node_iterate_next(iter, &(iter->stack[level]), &found);
+
+			if (found)
+				break;
+		}
+
+		/* We could not find any new key-value pair, the iteration finished */
+		if (!found)
+			break;
+
+		/* found the next slot at the leaf node, return it */
+		if (level == 0)
+		{
+			*key_p = iter->key;
+			*value_p = *((uint64 *) slot);
+			break;
+		}
+
+		/*
+		 * We have advanced slots more than one nodes including both the lead
+		 * node and internal nodes. So we update the stack by descending to
+		 * the left most leaf node from this level.
+		 */
+		node = (rt_node *) (rt_node *) slot;
+		node_iter = &(iter->stack[level - 1]);
+		rt_store_iter_node(iter, node_iter, node);
+		rt_update_iter_stack(iter, level - 1);
+	}
+
+	return found;
+}
+
+void
+rt_end_iterate(rt_iter *iter)
+{
+	pfree(iter);
+}
+
+/*
+ * Iterate over the given radix tree node and returns the next slot of the given
+ * node and set true to *found_p, if any.  Otherwise, set false to *found_p.
+ */
+static void *
+rt_node_iterate_next(rt_iter *iter, rt_iter_node_data *node_iter, bool *found_p)
+{
+	rt_node    *node = node_iter->node;
+	void	   *slot = NULL;
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				node_iter->current_idx++;
+
+				if (node_iter->current_idx >= node->count)
+					goto not_found;
+
+				slot = chunk_array_node_get_slot(node, node_iter->current_idx);
+
+				/* Update the part of the key by the current chunk */
+				if (IS_LEAF_NODE(node))
+				{
+					uint8	   *chunks = chunk_array_node_get_chunks(node);
+
+					rt_iter_update_key(iter, chunks[node_iter->current_idx], 0);
+				}
+
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_base_128 *n128 = (rt_node_base_128 *) node;
+				int			i;
+
+				for (i = node_iter->current_idx + 1; i < 256; i++)
+				{
+					if (node_128_is_chunk_used(n128, i))
+						break;
+				}
+
+				if (i >= 256)
+					goto not_found;
+
+				node_iter->current_idx = i;
+				slot = node_128_get_slot(n128, i);
+
+				/* Update the part of the key */
+				if (IS_LEAF_NODE(n128))
+					rt_iter_update_key(iter, node_iter->current_idx, 0);
+
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				rt_node_base_256 *n256 = (rt_node_base_256 *) node;
+				int			i;
+
+				for (i = node_iter->current_idx + 1; i < 256; i++)
+				{
+					if (node_256_is_chunk_used(n256, i))
+						break;
+				}
+
+				if (i >= 256)
+					goto not_found;
+
+				node_iter->current_idx = i;
+				slot = node_256_get_slot(n256, i);
+
+				/* Update the part of the key */
+				if (IS_LEAF_NODE(n256))
+					rt_iter_update_key(iter, node_iter->current_idx, 0);
+
+				break;
+			}
+	}
+
+	Assert(slot);
+	*found_p = true;
+	return slot;
+
+not_found:
+	*found_p = false;
+	return NULL;
+}
+
+/*
+ * Set the node to the node_iter so we can begin the iteration of the node.
+ * Also, we update the part of the key by the chunk of the given node.
+ */
+static void
+rt_store_iter_node(rt_iter *iter, rt_iter_node_data *node_iter,
+				   rt_node *node)
+{
+	node_iter->node = node;
+	node_iter->current_idx = -1;
+
+	rt_iter_update_key(iter, node->chunk, node->shift + RT_NODE_SPAN);
+}
+
+static pg_attribute_always_inline void
+rt_iter_update_key(rt_iter *iter, uint8 chunk, uint8 shift)
+{
+	iter->key &= ~(((uint64) RT_CHUNK_MASK) << shift);
+	iter->key |= (((uint64) chunk) << shift);
+}
+
+/*
+ * Return the number of keys in the radix tree.
+ */
+uint64
+rt_num_entries(radix_tree *tree)
+{
+	return tree->num_keys;
+}
+
+/*
+ * Return the statistics of the amount of memory used by the radix tree.
+ */
+uint64
+rt_memory_usage(radix_tree *tree)
+{
+	Size		total = 0;
+
+	for (int i = 0; i < RT_NODE_KIND_COUNT; i++)
+	{
+		total += MemoryContextMemAllocated(tree->inner_slabs[i], true);
+		total += MemoryContextMemAllocated(tree->leaf_slabs[i], true);
+	}
+
+	return total;
+}
+
+/*
+ * Verify the radix tree node.
+ */
+static void
+rt_verify_node(rt_node *node)
+{
+#ifdef USE_ASSERT_CHECKING
+	Assert(node->count >= 0);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				uint8	   *chunks = chunk_array_node_get_chunks(node);
+
+				/* Check if the chunks in the node are sorted */
+				for (int i = 1; i < node->count; i++)
+					Assert(chunks[i - 1] < chunks[i]);
+
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_base_128 *n128 = (rt_node_base_128 *) node;
+				int			cnt = 0;
+
+				for (int i = 0; i < RT_NODE_MAX_SLOTS; i++)
+				{
+					if (!node_128_is_chunk_used(n128, i))
+						continue;
+
+					/* Check if the corresponding slot is used */
+					Assert(node_128_is_slot_used(n128, n128->slot_idxs[i]));
+
+					cnt++;
+				}
+
+				Assert(n128->n.count == cnt);
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				rt_node_base_256 *n256 = (rt_node_base_256 *) node;
+				int			cnt = 0;
+
+				for (int i = 0; i < RT_NODE_NSLOTS_BITS(RT_NODE_MAX_SLOTS); i++)
+					cnt += pg_popcount32(n256->isset[i]);
+
+				/* Check if the number of used chunk matches */
+				Assert(n256->n.count == cnt);
+
+				break;
+			}
+	}
+#endif
+}
+
+/***************** DEBUG FUNCTIONS *****************/
+#ifdef RT_DEBUG
+void
+rt_stats(radix_tree *tree)
+{
+	fprintf(stderr, "num_keys = %lu, height = %u, n4 = %u, n16 = %u,n32 = %u, n128 = %u, n256 = %u",
+			tree->num_keys,
+			tree->root->shift / RT_NODE_SPAN,
+			tree->cnt[0],
+			tree->cnt[1],
+			tree->cnt[2],
+			tree->cnt[3],
+			tree->cnt[4]);
+	/* rt_dump(tree); */
+}
+
+static void
+rt_print_slot(StringInfo buf, uint8 chunk, uint64 value, int idx, bool is_leaf, int level)
+{
+	char		space[128] = {0};
+
+	if (level > 0)
+		sprintf(space, "%*c", level * 4, ' ');
+
+	if (is_leaf)
+		appendStringInfo(buf, "%s[%d] \"0x%X\" val(0x%lX) LEAF\n",
+						 space,
+						 idx,
+						 chunk,
+						 value);
+	else
+		appendStringInfo(buf, "%s[%d] \"0x%X\" -> ",
+						 space,
+						 idx,
+						 chunk);
+}
+
+static void
+rt_dump_node(rt_node *node, int level, StringInfo buf, bool recurse)
+{
+	bool		is_leaf = IS_LEAF_NODE(node);
+
+	appendStringInfo(buf, "[\"%s\" type %d, cnt %u, shift %u, chunk \"0x%X\"] chunks:\n",
+					 IS_LEAF_NODE(node) ? "LEAF" : "INNR",
+					 (node->kind == RT_NODE_KIND_4) ? 4 :
+					 (node->kind == RT_NODE_KIND_32) ? 32 :
+					 (node->kind == RT_NODE_KIND_128) ? 128 : 256,
+					 node->count, node->shift, node->chunk);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				uint8	   *chunks = chunk_array_node_get_chunks(node);
+
+				for (int i = 0; i < node->count; i++)
+				{
+					if (IS_LEAF_NODE(node))
+					{
+						uint64	   *values = rt_node_get_leaf_values(node);
+
+						rt_print_slot(buf, chunks[i],
+									  values[i],
+									  i, is_leaf, level);
+					}
+					else
+						rt_print_slot(buf, chunks[i],
+									  UINT64_MAX,
+									  i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							rt_node   **children = rt_node_get_inner_children(node);
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							rt_dump_node(children[i],
+										 level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_base_128 *n128 = (rt_node_base_128 *) node;
+				uint8	   *tmp = (uint8 *) n128->isset;
+
+				appendStringInfo(buf, "slot_idxs:");
+				for (int j = 0; j < 256; j++)
+				{
+					if (!node_128_is_chunk_used(n128, j))
+						continue;
+
+					appendStringInfo(buf, " [%d]=%d, ", j, n128->slot_idxs[j]);
+				}
+				appendStringInfo(buf, "\nisset-bitmap:");
+				for (int j = 0; j < 16; j++)
+				{
+					appendStringInfo(buf, "%X ", (uint8) tmp[j]);
+				}
+				appendStringInfo(buf, "\n");
+
+				for (int i = 0; i < 256; i++)
+				{
+					void	   *slot;
+
+					if (!node_128_is_chunk_used(n128, i))
+						continue;
+
+					slot = node_128_get_slot(n128, i);
+
+					if (is_leaf)
+						rt_print_slot(buf, i, *(uint64 *) slot,
+									  i, is_leaf, level);
+					else
+						rt_print_slot(buf, i, UINT64_MAX, i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							rt_dump_node((rt_node *) slot,
+										 level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				rt_node_base_256 *n256 = (rt_node_base_256 *) node;
+
+				for (int i = 0; i < 256; i++)
+				{
+					void	   *slot;
+
+					if (!node_256_is_chunk_used(n256, i))
+						continue;
+
+					slot = node_256_get_slot(n256, i);
+
+					if (is_leaf)
+						rt_print_slot(buf, i, *(uint64 *) slot, i, is_leaf, level);
+					else
+						rt_print_slot(buf, i, UINT64_MAX, i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							rt_dump_node((rt_node *) slot, level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+				break;
+			}
+	}
+}
+
+void
+rt_dump_search(radix_tree *tree, uint64 key)
+{
+	StringInfoData buf;
+	rt_node    *node;
+	int			shift;
+	int			level = 0;
+
+	elog(NOTICE, "-----------------------------------------------------------");
+	elog(NOTICE, "max_val = %lu (0x%lX)", tree->max_val, tree->max_val);
+
+	if (!tree->root)
+	{
+		elog(NOTICE, "tree is empty");
+		return;
+	}
+
+	if (key > tree->max_val)
+	{
+		elog(NOTICE, "key %lu (0x%lX) is larger than max val",
+			 key, key);
+		return;
+	}
+
+	initStringInfo(&buf);
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift >= 0)
+	{
+		rt_node    *child;
+
+		rt_dump_node(node, level, &buf, false);
+
+		if (IS_LEAF_NODE(node))
+		{
+			uint64		dummy;
+
+			/* We reached at a leaf node, find the corresponding slot */
+			rt_node_search_leaf(node, key, RT_ACTION_FIND, &dummy);
+
+			break;
+		}
+
+		if (!rt_node_search_inner(node, key, RT_ACTION_FIND, &child))
+			break;
+
+		node = child;
+		shift -= RT_NODE_SPAN;
+		level++;
+	}
+
+	elog(NOTICE, "\n%s", buf.data);
+}
+
+void
+rt_dump(radix_tree *tree)
+{
+	StringInfoData buf;
+
+	initStringInfo(&buf);
+
+	elog(NOTICE, "-----------------------------------------------------------");
+	elog(NOTICE, "max_val = %lu", tree->max_val);
+	rt_dump_node(tree->root, 0, &buf, true);
+	elog(NOTICE, "\n%s", buf.data);
+	elog(NOTICE, "-----------------------------------------------------------");
+}
+#endif
diff --git a/src/include/lib/radixtree.h b/src/include/lib/radixtree.h
new file mode 100644
index 0000000000..788eb13204
--- /dev/null
+++ b/src/include/lib/radixtree.h
@@ -0,0 +1,42 @@
+/*-------------------------------------------------------------------------
+ *
+ * radixtree.h
+ *	  Interface for radix tree.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		src/include/lib/radixtree.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RADIXTREE_H
+#define RADIXTREE_H
+
+#include "postgres.h"
+
+#define RT_DEBUG 1
+
+typedef struct radix_tree radix_tree;
+typedef struct rt_iter rt_iter;
+
+extern radix_tree *rt_create(MemoryContext ctx);
+extern bool rt_search(radix_tree *tree, uint64 key, uint64 *val_p);
+extern bool rt_set(radix_tree *tree, uint64 key, uint64 val);
+extern bool rt_delete(radix_tree *tree, uint64 key);
+extern void rt_free(radix_tree *tree);
+extern uint64 rt_memory_usage(radix_tree *tree);
+extern uint64 rt_num_entries(radix_tree *tree);
+
+extern rt_iter *rt_begin_iterate(radix_tree *tree);
+extern bool rt_iterate_next(rt_iter *iter, uint64 *key_p, uint64 *value_p);
+extern void rt_end_iterate(rt_iter *iter);
+
+
+#ifdef RT_DEBUG
+extern void rt_dump(radix_tree *tree);
+extern void rt_dump_search(radix_tree *tree, uint64 key);
+extern void rt_stats(radix_tree *tree);
+#endif
+
+#endif							/* RADIXTREE_H */
diff --git a/src/test/modules/Makefile b/src/test/modules/Makefile
index 9090226daa..51b2514faf 100644
--- a/src/test/modules/Makefile
+++ b/src/test/modules/Makefile
@@ -24,6 +24,7 @@ SUBDIRS = \
 		  test_parser \
 		  test_pg_dump \
 		  test_predtest \
+		  test_radixtree \
 		  test_rbtree \
 		  test_regex \
 		  test_rls_hooks \
diff --git a/src/test/modules/test_radixtree/.gitignore b/src/test/modules/test_radixtree/.gitignore
new file mode 100644
index 0000000000..5dcb3ff972
--- /dev/null
+++ b/src/test/modules/test_radixtree/.gitignore
@@ -0,0 +1,4 @@
+# Generated subdirectories
+/log/
+/results/
+/tmp_check/
diff --git a/src/test/modules/test_radixtree/Makefile b/src/test/modules/test_radixtree/Makefile
new file mode 100644
index 0000000000..da06b93da3
--- /dev/null
+++ b/src/test/modules/test_radixtree/Makefile
@@ -0,0 +1,23 @@
+# src/test/modules/test_radixtree/Makefile
+
+MODULE_big = test_radixtree
+OBJS = \
+	$(WIN32RES) \
+	test_radixtree.o
+PGFILEDESC = "test_radixtree - test code for src/backend/lib/radixtree.c"
+
+EXTENSION = test_radixtree
+DATA = test_radixtree--1.0.sql
+
+REGRESS = test_radixtree
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = src/test/modules/test_radixtree
+top_builddir = ../../../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
diff --git a/src/test/modules/test_radixtree/README b/src/test/modules/test_radixtree/README
new file mode 100644
index 0000000000..a8b271869a
--- /dev/null
+++ b/src/test/modules/test_radixtree/README
@@ -0,0 +1,7 @@
+test_integerset contains unit tests for testing the integer set implementation
+in src/backend/lib/integerset.c.
+
+The tests verify the correctness of the implementation, but they can also be
+used as a micro-benchmark.  If you set the 'intset_test_stats' flag in
+test_integerset.c, the tests will print extra information about execution time
+and memory usage.
diff --git a/src/test/modules/test_radixtree/expected/test_radixtree.out b/src/test/modules/test_radixtree/expected/test_radixtree.out
new file mode 100644
index 0000000000..cc6970c87c
--- /dev/null
+++ b/src/test/modules/test_radixtree/expected/test_radixtree.out
@@ -0,0 +1,28 @@
+CREATE EXTENSION test_radixtree;
+--
+-- All the logic is in the test_radixtree() function. It will throw
+-- an error if something fails.
+--
+SELECT test_radixtree();
+NOTICE:  testing radix tree node types with shift "0"
+NOTICE:  testing radix tree node types with shift "8"
+NOTICE:  testing radix tree node types with shift "16"
+NOTICE:  testing radix tree node types with shift "24"
+NOTICE:  testing radix tree node types with shift "32"
+NOTICE:  testing radix tree node types with shift "40"
+NOTICE:  testing radix tree node types with shift "48"
+NOTICE:  testing radix tree node types with shift "56"
+NOTICE:  testing radix tree with pattern "all ones"
+NOTICE:  testing radix tree with pattern "alternating bits"
+NOTICE:  testing radix tree with pattern "clusters of ten"
+NOTICE:  testing radix tree with pattern "clusters of hundred"
+NOTICE:  testing radix tree with pattern "one-every-64k"
+NOTICE:  testing radix tree with pattern "sparse"
+NOTICE:  testing radix tree with pattern "single values, distance > 2^32"
+NOTICE:  testing radix tree with pattern "clusters, distance > 2^32"
+NOTICE:  testing radix tree with pattern "clusters, distance > 2^60"
+ test_radixtree 
+----------------
+ 
+(1 row)
+
diff --git a/src/test/modules/test_radixtree/sql/test_radixtree.sql b/src/test/modules/test_radixtree/sql/test_radixtree.sql
new file mode 100644
index 0000000000..41ece5e9f5
--- /dev/null
+++ b/src/test/modules/test_radixtree/sql/test_radixtree.sql
@@ -0,0 +1,7 @@
+CREATE EXTENSION test_radixtree;
+
+--
+-- All the logic is in the test_radixtree() function. It will throw
+-- an error if something fails.
+--
+SELECT test_radixtree();
diff --git a/src/test/modules/test_radixtree/test_radixtree--1.0.sql b/src/test/modules/test_radixtree/test_radixtree--1.0.sql
new file mode 100644
index 0000000000..074a5a7ea7
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree--1.0.sql
@@ -0,0 +1,8 @@
+/* src/test/modules/test_radixtree/test_radixtree--1.0.sql */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION test_radixtree" to load this file. \quit
+
+CREATE FUNCTION test_radixtree()
+RETURNS pg_catalog.void STRICT
+AS 'MODULE_PATHNAME' LANGUAGE C;
diff --git a/src/test/modules/test_radixtree/test_radixtree.c b/src/test/modules/test_radixtree/test_radixtree.c
new file mode 100644
index 0000000000..671c3e0f47
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree.c
@@ -0,0 +1,507 @@
+/*--------------------------------------------------------------------------
+ *
+ * test_radixtree.c
+ *		Test radixtree set data structure.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		src/test/modules/test_radixtree/test_radixtree.c
+ *
+ * -------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "common/pg_prng.h"
+#include "fmgr.h"
+#include "lib/radixtree.h"
+#include "miscadmin.h"
+#include "nodes/bitmapset.h"
+#include "storage/block.h"
+#include "storage/itemptr.h"
+#include "utils/memutils.h"
+#include "utils/timestamp.h"
+
+#define UINT64_HEX_FORMAT "%" INT64_MODIFIER "X"
+
+/*
+ * If you enable this, the "pattern" tests will print information about
+ * how long populating, probing, and iterating the test set takes, and
+ * how much memory the test set consumed.  That can be used as
+ * micro-benchmark of various operations and input patterns (you might
+ * want to increase the number of values used in each of the test, if
+ * you do that, to reduce noise).
+ *
+ * The information is printed to the server's stderr, mostly because
+ * that's where MemoryContextStats() output goes.
+ */
+static const bool rt_test_stats = false;
+
+/* The maximum number of entries each node type can have */
+static int rt_node_max_entries[] = {
+	4,		/* RT_NODE_KIND_4 */
+	16,		/* RT_NODE_KIND_16 */
+	32,		/* RT_NODE_KIND_32 */
+	128,	/* RT_NODE_KIND_128 */
+	256		/* RT_NODE_KIND_256 */
+};
+
+/*
+ * A struct to define a pattern of integers, for use with the test_pattern()
+ * function.
+ */
+typedef struct
+{
+	char	   *test_name;		/* short name of the test, for humans */
+	char	   *pattern_str;	/* a bit pattern */
+	uint64		spacing;		/* pattern repeats at this interval */
+	uint64		num_values;		/* number of integers to set in total */
+} test_spec;
+
+/* Test patterns borrowed from test_integerset.c */
+static const test_spec test_specs[] = {
+	{
+		"all ones", "1111111111",
+		10, 1000000
+	},
+	{
+		"alternating bits", "0101010101",
+		10, 1000000
+	},
+	{
+		"clusters of ten", "1111111111",
+		10000, 1000000
+	},
+	{
+		"clusters of hundred",
+		"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111",
+		10000, 10000000
+	},
+	{
+		"one-every-64k", "1",
+		65536, 1000000
+	},
+	{
+		"sparse", "100000000000000000000000000000001",
+		10000000, 1000000
+	},
+	{
+		"single values, distance > 2^32", "1",
+		UINT64CONST(10000000000), 100000
+	},
+	{
+		"clusters, distance > 2^32", "10101010",
+		UINT64CONST(10000000000), 1000000
+	},
+	{
+		"clusters, distance > 2^60", "10101010",
+		UINT64CONST(2000000000000000000),
+		23						/* can't be much higher than this, or we
+								 * overflow uint64 */
+	}
+};
+
+PG_MODULE_MAGIC;
+
+PG_FUNCTION_INFO_V1(test_radixtree);
+
+static void
+test_empty(void)
+{
+	radix_tree *radixtree;
+	uint64 dummy;
+
+	radixtree = rt_create(CurrentMemoryContext);
+
+	if (rt_search(radixtree, 0, &dummy))
+		elog(ERROR, "rt_search on empty tree returned true");
+
+	if (rt_search(radixtree, 1, &dummy))
+		elog(ERROR, "rt_search on empty tree returned true");
+
+	if (rt_search(radixtree, PG_UINT64_MAX, &dummy))
+		elog(ERROR, "rt_search on empty tree returned true");
+
+	if (rt_num_entries(radixtree) != 0)
+		elog(ERROR, "rt_num_entries on empty tree return non-zero");
+
+	rt_free(radixtree);
+}
+
+/*
+ * Check if keys from start to end with the shift exist in the tree.
+ */
+static void
+check_search_on_node(radix_tree *radixtree, uint8 shift, int start, int end)
+{
+	for (int i = start; i < end; i++)
+	{
+		uint64 key = ((uint64) i << shift);
+		uint64 val;
+
+		if (!rt_search(radixtree, key, &val))
+			elog(ERROR, "key 0x" UINT64_HEX_FORMAT " is not found on node-%d",
+				 key, end);
+		if (val != key)
+		{
+			rt_dump(radixtree);
+			elog(ERROR, "rt_search with key 0x" UINT64_HEX_FORMAT " returns 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT,
+				 key, val, key);
+		}
+	}
+}
+
+static void
+test_node_types_insert(radix_tree *radixtree, uint8 shift)
+{
+	uint64 num_entries;
+
+	for (int i = 0; i < 256; i++)
+	{
+		uint64 key = ((uint64) i << shift);
+		bool found;
+
+		found = rt_set(radixtree, key, key);
+
+		if (found)
+			elog(ERROR, "newly inserted key 0x" UINT64_HEX_FORMAT " found", key);
+
+		for (int j = 0; j < lengthof(rt_node_max_entries); j++)
+		{
+			/*
+			 * After filling all slots in each node type, check if the values are
+			 * stored properly.
+			 */
+			if (i == (rt_node_max_entries[j] - 1))
+			{
+				check_search_on_node(radixtree, shift,
+									 (j == 0) ? 0 : rt_node_max_entries[j - 1],
+									 rt_node_max_entries[j]);
+				break;
+			}
+		}
+	}
+
+	num_entries = rt_num_entries(radixtree);
+
+	if (num_entries != 256)
+		elog(ERROR,
+			 "rt_num_entries returned" UINT64_FORMAT ", expected " UINT64_FORMAT,
+			 num_entries, UINT64CONST(256));
+}
+
+static void
+test_node_types_delete(radix_tree *radixtree, uint8 shift)
+{
+	uint64 num_entries;
+
+	for (int i = 0; i < 256; i++)
+	{
+		uint64	key = ((uint64) i << shift);
+		bool	found;
+
+		found = rt_delete(radixtree, key);
+
+		if (!found)
+			elog(ERROR, "inserted key 0x" UINT64_HEX_FORMAT " is not found", key);
+	}
+
+	num_entries = rt_num_entries(radixtree);
+
+	/* The tree must be empty */
+	if (num_entries != 0)
+		elog(ERROR,
+			 "rt_num_entries returned" UINT64_FORMAT ", expected " UINT64_FORMAT,
+			 num_entries, UINT64CONST(256));
+}
+
+/*
+ * Test for inserting and deleting key-value pairs to each node type at the given shift
+ * level.
+ */
+static void
+test_node_types(uint8 shift)
+{
+	radix_tree *radixtree;
+
+	elog(NOTICE, "testing radix tree node types with shift \"%d\"", shift);
+
+	radixtree = rt_create(CurrentMemoryContext);
+
+	/*
+	 * Insert and search entries for every node type at the 'shift' level,
+	 * then delete all entries to make it empty, and insert and search
+	 * entries again.
+	 */
+	test_node_types_insert(radixtree, shift);
+	test_node_types_delete(radixtree, shift);
+	test_node_types_insert(radixtree, shift);
+
+	rt_free(radixtree);
+}
+
+/*
+ * Test with a repeating pattern, defined by the 'spec'.
+ */
+static void
+test_pattern(const test_spec *spec)
+{
+	radix_tree *radixtree;
+	rt_iter *iter;
+	MemoryContext radixtree_ctx;
+	TimestampTz starttime;
+	TimestampTz endtime;
+	uint64		n;
+	uint64		last_int;
+	uint64		ndeleted;
+	uint64		nbefore;
+	uint64		nafter;
+	int			patternlen;
+	uint64	   *pattern_values;
+	uint64		pattern_num_values;
+
+	elog(NOTICE, "testing radix tree with pattern \"%s\"", spec->test_name);
+	if (rt_test_stats)
+		fprintf(stderr, "-----\ntesting radix tree with pattern \"%s\"\n", spec->test_name);
+
+	/* Pre-process the pattern, creating an array of integers from it. */
+	patternlen = strlen(spec->pattern_str);
+	pattern_values = palloc(patternlen * sizeof(uint64));
+	pattern_num_values = 0;
+	for (int i = 0; i < patternlen; i++)
+	{
+		if (spec->pattern_str[i] == '1')
+			pattern_values[pattern_num_values++] = i;
+	}
+
+	/*
+	 * Allocate the radix tree.
+	 *
+	 * Allocate it in a separate memory context, so that we can print its
+	 * memory usage easily.
+	 */
+	radixtree_ctx = AllocSetContextCreate(CurrentMemoryContext,
+										  "radixtree test",
+										  ALLOCSET_SMALL_SIZES);
+	MemoryContextSetIdentifier(radixtree_ctx, spec->test_name);
+	radixtree = rt_create(radixtree_ctx);
+
+	/*
+	 * Add values to the set.
+	 */
+	starttime = GetCurrentTimestamp();
+
+	n = 0;
+	last_int = 0;
+	while (n < spec->num_values)
+	{
+		uint64		x = 0;
+
+		for (int i = 0; i < pattern_num_values && n < spec->num_values; i++)
+		{
+			bool found;
+
+			x = last_int + pattern_values[i];
+
+			found = rt_set(radixtree, x, x);
+
+			if (found)
+				elog(ERROR, "newly inserted key 0x" UINT64_HEX_FORMAT " found", x);
+
+			n++;
+		}
+		last_int += spec->spacing;
+	}
+
+	endtime = GetCurrentTimestamp();
+
+	if (rt_test_stats)
+		fprintf(stderr, "added " UINT64_FORMAT " values in %d ms\n",
+				spec->num_values, (int) (endtime - starttime) / 1000);
+
+	/*
+	 * Print stats on the amount of memory used.
+	 *
+	 * We print the usage reported by rt_memory_usage(), as well as the
+	 * stats from the memory context.  They should be in the same ballpark,
+	 * but it's hard to automate testing that, so if you're making changes to
+	 * the implementation, just observe that manually.
+	 */
+	if (rt_test_stats)
+	{
+		uint64		mem_usage;
+
+		/*
+		 * Also print memory usage as reported by rt_memory_usage().  It
+		 * should be in the same ballpark as the usage reported by
+		 * MemoryContextStats().
+		 */
+		mem_usage = rt_memory_usage(radixtree);
+		fprintf(stderr, "rt_memory_usage() reported " UINT64_FORMAT " (%0.2f bytes / integer)\n",
+				mem_usage, (double) mem_usage / spec->num_values);
+
+		MemoryContextStats(radixtree_ctx);
+	}
+
+	/* Check that rt_num_entries works */
+	n = rt_num_entries(radixtree);
+	if (n != spec->num_values)
+		elog(ERROR, "rt_num_entries returned " UINT64_FORMAT ", expected " UINT64_FORMAT, n, spec->num_values);
+
+	/*
+	 * Test random-access probes with rt_search()
+	 */
+	starttime = GetCurrentTimestamp();
+
+	for (n = 0; n < 100000; n++)
+	{
+		bool		found;
+		bool		expected;
+		uint64		x;
+		uint64		v;
+
+		/*
+		 * Pick next value to probe at random.  We limit the probes to the
+		 * last integer that we added to the set, plus an arbitrary constant
+		 * (1000).  There's no point in probing the whole 0 - 2^64 range, if
+		 * only a small part of the integer space is used.  We would very
+		 * rarely hit values that are actually in the set.
+		 */
+		x = pg_prng_uint64_range(&pg_global_prng_state, 0, last_int + 1000);
+
+		/* Do we expect this value to be present in the set? */
+		if (x >= last_int)
+			expected = false;
+		else
+		{
+			uint64		idx = x % spec->spacing;
+
+			if (idx >= patternlen)
+				expected = false;
+			else if (spec->pattern_str[idx] == '1')
+				expected = true;
+			else
+				expected = false;
+		}
+
+		/* Is it present according to rt_search() ? */
+		found = rt_search(radixtree, x, &v);
+
+		if (found != expected)
+			elog(ERROR, "mismatch at 0x" UINT64_HEX_FORMAT ": %d vs %d", x, found, expected);
+		if (found && (v != x))
+			elog(ERROR, "found 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT,
+				 v, x);
+	}
+	endtime = GetCurrentTimestamp();
+	if (rt_test_stats)
+		fprintf(stderr, "probed " UINT64_FORMAT " values in %d ms\n",
+				n, (int) (endtime - starttime) / 1000);
+
+	/*
+	 * Test iterator
+	 */
+	starttime = GetCurrentTimestamp();
+
+	iter = rt_begin_iterate(radixtree);
+	n = 0;
+	last_int = 0;
+	while (n < spec->num_values)
+	{
+		for (int i = 0; i < pattern_num_values && n < spec->num_values; i++)
+		{
+			uint64		expected = last_int + pattern_values[i];
+			uint64		x;
+			uint64		val;
+
+			if (!rt_iterate_next(iter, &x, &val))
+				break;
+
+			if (x != expected)
+				elog(ERROR,
+					 "iterate returned wrong key; got 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT " at %d",
+					 x, expected, i);
+			if (val != expected)
+				elog(ERROR,
+					 "iterate returned wrong value; got 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT " at %d", x, expected, i);
+			n++;
+		}
+		last_int += spec->spacing;
+	}
+	endtime = GetCurrentTimestamp();
+	if (rt_test_stats)
+		fprintf(stderr, "iterated " UINT64_FORMAT " values in %d ms\n",
+				n, (int) (endtime - starttime) / 1000);
+
+	if (n < spec->num_values)
+		elog(ERROR, "iterator stopped short after " UINT64_FORMAT " entries, expected " UINT64_FORMAT, n, spec->num_values);
+	if (n > spec->num_values)
+		elog(ERROR, "iterator returned " UINT64_FORMAT " entries, " UINT64_FORMAT " was expected", n, spec->num_values);
+
+	/*
+	 * Test random-access probes with rt_delete()
+	 */
+	starttime = GetCurrentTimestamp();
+
+	nbefore = rt_num_entries(radixtree);
+	ndeleted = 0;
+	for (n = 0; n < 100000; n++)
+	{
+		bool		found;
+		uint64		x;
+		uint64		v;
+
+		/*
+		 * Pick next value to probe at random.  We limit the probes to the
+		 * last integer that we added to the set, plus an arbitrary constant
+		 * (1000).  There's no point in probing the whole 0 - 2^64 range, if
+		 * only a small part of the integer space is used.  We would very
+		 * rarely hit values that are actually in the set.
+		 */
+		x = pg_prng_uint64_range(&pg_global_prng_state, 0, last_int + 1000);
+
+		/* Is it present according to rt_search() ? */
+		found = rt_search(radixtree, x, &v);
+
+		if (!found)
+			continue;
+
+		/* If the key is found, delete it and check again */
+		if (!rt_delete(radixtree, x))
+			elog(ERROR, "could not delete key 0x" UINT64_HEX_FORMAT, x);
+		if (rt_search(radixtree, x, &v))
+			elog(ERROR, "found deleted key 0x" UINT64_HEX_FORMAT, x);
+		if (rt_delete(radixtree, x))
+			elog(ERROR, "deleted already-deleted key 0x" UINT64_HEX_FORMAT, x);
+
+		ndeleted++;
+	}
+	endtime = GetCurrentTimestamp();
+	if (rt_test_stats)
+		fprintf(stderr, "deleted " UINT64_FORMAT " values in %d ms\n",
+				ndeleted, (int) (endtime - starttime) / 1000);
+
+	nafter = rt_num_entries(radixtree);
+
+	/* Check that rt_num_entries works */
+	if ((nbefore - ndeleted) != nafter)
+		elog(ERROR, "rt_num_entries returned " UINT64_FORMAT ", expected " UINT64_FORMAT "after " UINT64_FORMAT " deletion",
+			 nafter, (nbefore - ndeleted), ndeleted);
+
+	MemoryContextDelete(radixtree_ctx);
+}
+
+Datum
+test_radixtree(PG_FUNCTION_ARGS)
+{
+	test_empty();
+
+	for (int shift = 0; shift <= (64 - 8); shift += 8)
+		test_node_types(shift);
+
+	/* Test different test patterns, with lots of entries */
+	for (int i = 0; i < lengthof(test_specs); i++)
+		test_pattern(&test_specs[i]);
+
+	PG_RETURN_VOID();
+}
diff --git a/src/test/modules/test_radixtree/test_radixtree.control b/src/test/modules/test_radixtree/test_radixtree.control
new file mode 100644
index 0000000000..e53f2a3e0c
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree.control
@@ -0,0 +1,4 @@
+comment = 'Test code for radix tree'
+default_version = '1.0'
+module_pathname = '$libdir/test_radixtree'
+relocatable = true

From 5d0115b068ecb01d791eab5f8a78a6d25b9cf45c Mon Sep 17 00:00:00 2001
From: Masahiko Sawada <sawada.mshk@gmail.com>
Date: Wed, 14 Sep 2022 12:38:01 +0000
Subject: [PATCH v6 1/3] Support pg_lsearch8_eq and pg_lsearch8_ge

---
 src/include/port/pg_lfind.h                   |  71 ++++++++
 src/include/port/simd.h                       | 155 +++++++++++++++++-
 .../test_lfind/expected/test_lfind.out        |  12 ++
 .../modules/test_lfind/sql/test_lfind.sql     |   2 +
 .../modules/test_lfind/test_lfind--1.0.sql    |   8 +
 src/test/modules/test_lfind/test_lfind.c      | 139 ++++++++++++++++
 6 files changed, 378 insertions(+), 9 deletions(-)

diff --git a/src/include/port/pg_lfind.h b/src/include/port/pg_lfind.h
index 0625cac6b5..583f204763 100644
--- a/src/include/port/pg_lfind.h
+++ b/src/include/port/pg_lfind.h
@@ -80,6 +80,77 @@ pg_lfind8_le(uint8 key, uint8 *base, uint32 nelem)
 	return false;
 }
 
+/*
+ * pg_lsearch8
+ *
+ * Return the index of the element in 'base' that equals to 'key', otherwise return
+ * -1.
+ */
+static inline int
+pg_lsearch8(uint8 key, uint8 *base, uint32 nelem)
+{
+	uint32		i;
+
+	/* round down to multiple of vector length */
+	uint32		tail_idx = nelem & ~(sizeof(Vector8) - 1);
+	Vector8		chunk;
+
+	for (i = 0; i < tail_idx; i += sizeof(Vector8))
+	{
+		int idx;
+
+		vector8_load(&chunk, &base[i]);
+		if ((idx = vector8_search_eq(chunk, key)) != -1)
+			return i + idx;
+	}
+
+	/* Process the remaining elements one at a time. */
+	for (; i < nelem; i++)
+	{
+		if (key == base[i])
+			return i;
+	}
+
+	return -1;
+}
+
+
+/*
+ * pg_lsearch8_ge
+ *
+ * Return the index of the first element in 'base' that is greater than or equal to
+ * 'key'. Return nelem if there is no such element.
+ *
+ * Note that this function assumes the elements in 'base' are sorted.
+ */
+static inline int
+pg_lsearch8_ge(uint8 key, uint8 *base, uint32 nelem)
+{
+	uint32		i;
+
+	/* round down to multiple of vector length */
+	uint32		tail_idx = nelem & ~(sizeof(Vector8) - 1);
+	Vector8		chunk;
+
+	for (i = 0; i < tail_idx; i += sizeof(Vector8))
+	{
+		int idx;
+
+		vector8_load(&chunk, &base[i]);
+		if ((idx = vector8_search_ge(chunk, key)) != sizeof(Vector8))
+			return i + idx;
+	}
+
+	/* Process the remaining elements one at a time. */
+	for (; i < nelem; i++)
+	{
+		if (base[i] >= key)
+			break;
+	}
+
+	return i;
+}
+
 /*
  * pg_lfind32
  *
diff --git a/src/include/port/simd.h b/src/include/port/simd.h
index 61ae4ecf60..e2a99578a5 100644
--- a/src/include/port/simd.h
+++ b/src/include/port/simd.h
@@ -18,6 +18,8 @@
 #ifndef SIMD_H
 #define SIMD_H
 
+#include "port/pg_bitutils.h"
+
 #if (defined(__x86_64__) || defined(_M_AMD64))
 /*
  * SSE2 instructions are part of the spec for the 64-bit x86 ISA. We assume
@@ -88,14 +90,9 @@ static inline Vector32 vector32_or(const Vector32 v1, const Vector32 v2);
 static inline Vector8 vector8_ssub(const Vector8 v1, const Vector8 v2);
 #endif
 
-/*
- * comparisons between vectors
- *
- * Note: These return a vector rather than boolean, which is why we don't
- * have non-SIMD implementations.
- */
-#ifndef USE_NO_SIMD
+/* comparisons between vectors */
 static inline Vector8 vector8_eq(const Vector8 v1, const Vector8 v2);
+#ifndef USE_NO_SIMD
 static inline Vector32 vector32_eq(const Vector32 v1, const Vector32 v2);
 #endif
 
@@ -277,6 +274,140 @@ vector8_is_highbit_set(const Vector8 v)
 #endif
 }
 
+/*
+ * Return the bitmak of the high-bit of each element.
+ */
+static inline uint32
+vector8_highbit_mask(const Vector8 v)
+{
+#ifdef USE_SSE2
+	return (uint32) _mm_movemask_epi8(v);
+#elif defined(USE_NEON)
+	static const uint8 mask[16] = {
+        1 << 0, 1 << 1, 1 << 2, 1 << 3,
+        1 << 4, 1 << 5, 1 << 6, 1 << 7,
+        1 << 0, 1 << 1, 1 << 2, 1 << 3,
+        1 << 4, 1 << 5, 1 << 6, 1 << 7,
+      };
+
+    uint8x16_t masked = vandq_u8(vld1q_u8(mask), (uint8x16_t) vshrq_n_s8(v, 7));
+    uint8x16_t maskedhi = vextq_u8(masked, masked, 8);
+
+    return (uint32) vaddvq_u16((uint16x8_t) vzip1q_u8(masked, maskedhi));
+#else
+	uint32 mask = 0;
+
+	for (Size i = 0; i < sizeof(Vector8); i++)
+		mask |= (((const uint8 *) &v)[i] >> 7) << i;
+
+	return mask;
+#endif
+}
+
+/*
+ * Compare the given vectors and return the vector of minimum elements.
+ */
+static inline Vector8
+vector8_min(const Vector8 v1, const Vector8 v2)
+{
+#ifdef USE_SSE2
+	return _mm_min_epu8(v1, v2);
+#elif defined(USE_NEON)
+	return vminq_u8(v1, v2);
+#else /* USE_NO_SIMD */
+	Vector8 r = 0;
+	uint8 *rp = (uint8 *) &r;
+
+	for (Size i = 0; i < sizeof(Vector8); i++)
+		rp[i] = Min(((const uint8 *) &v1)[i], ((const uint8 *) &v2)[i]);
+
+	return r;
+#endif
+}
+
+/*
+ * Return the index of the element in the vector that equal to the given
+ * scalar. Otherwise, return -1.
+ */
+static inline int
+vector8_search_eq(const Vector8 v, const uint8 c)
+{
+	Vector8 keys = vector8_broadcast(c);
+	Vector8	cmp;
+	uint32	mask;
+	int		result;
+
+#ifdef USE_ASSERT_CHECKING
+	int		assert_result = -1;
+
+	for (Size i = 0; i < sizeof(Vector8); i++)
+	{
+		if (((const uint8 *) &v)[i] == c)
+		{
+			assert_result = i;
+			break;
+		}
+	}
+#endif							/* USE_ASSERT_CHECKING */
+
+	cmp = vector8_eq(keys, v);
+	mask = vector8_highbit_mask(cmp);
+
+	if (mask)
+		result = pg_rightmost_one_pos32(mask);
+	else
+		result = -1;
+
+	Assert(assert_result == result);
+	return result;
+}
+
+/*
+ * Return the index of the first element in the vector that is greater than
+ * or eual to the given scalar. Return sizeof(Vector8) if there is no such
+ * element.
+ *
+ * Note that this function assumes the elements in the vector are sorted.
+ */
+static inline int
+vector8_search_ge(const Vector8 v, const uint8 c)
+{
+	Vector8 keys = vector8_broadcast(c);
+	Vector8 min;
+	Vector8	cmp;
+	uint32	mask;
+	int		result;
+
+#ifdef USE_ASSERT_CHECKING
+	int		assert_result = -1;
+	Size	i;
+
+	for (i = 0; i < sizeof(Vector8); i++)
+	{
+		if (((const uint8 *) &v)[i] >= c)
+			break;
+	}
+	assert_result = i;
+#endif							/* USE_ASSERT_CHECKING */
+
+	/*
+	 * There is a bit more complicated than vector8_search_eq(), because
+	 * until recently no unsigned uint8 compasion instruction existed.
+	 * Therefore, we need to use vector8_min() to effectively get <= elements.
+	 */
+	min = vector8_min(v, keys);
+	cmp = vector8_eq(keys, min);
+	mask = vector8_highbit_mask(cmp);
+
+	if (mask)
+		result = pg_rightmost_one_pos32(mask);
+	else
+		result = sizeof(Vector8);
+
+	Assert(assert_result == result);
+	return result;
+}
+
 /*
  * Exactly like vector8_is_highbit_set except for the input type, so it
  * looks at each byte separately.
@@ -348,7 +479,6 @@ vector8_ssub(const Vector8 v1, const Vector8 v2)
  * Return a vector with all bits set in each lane where the the corresponding
  * lanes in the inputs are equal.
  */
-#ifndef USE_NO_SIMD
 static inline Vector8
 vector8_eq(const Vector8 v1, const Vector8 v2)
 {
@@ -356,9 +486,16 @@ vector8_eq(const Vector8 v1, const Vector8 v2)
 	return _mm_cmpeq_epi8(v1, v2);
 #elif defined(USE_NEON)
 	return vceqq_u8(v1, v2);
+#else /* USE_NO_SIMD */
+	Vector8 r = 0;
+	uint8 *rp = (uint8 *) &r;
+
+	for (Size i = 0; i < sizeof(Vector8); i++)
+		rp[i] = (((const uint8 *) &v1)[i] == ((const uint8 *) &v2)[i]) ? 0xFF : 0;
+
+	return r;
 #endif
 }
-#endif							/* ! USE_NO_SIMD */
 
 #ifndef USE_NO_SIMD
 static inline Vector32
diff --git a/src/test/modules/test_lfind/expected/test_lfind.out b/src/test/modules/test_lfind/expected/test_lfind.out
index 1d4b14e703..9416161955 100644
--- a/src/test/modules/test_lfind/expected/test_lfind.out
+++ b/src/test/modules/test_lfind/expected/test_lfind.out
@@ -22,3 +22,15 @@ SELECT test_lfind32();
  
 (1 row)
 
+SELECT test_lsearch8();
+ test_lsearch8 
+---------------
+ 
+(1 row)
+
+SELECT test_lsearch8_ge();
+ test_lsearch8_ge 
+------------------
+ 
+(1 row)
+
diff --git a/src/test/modules/test_lfind/sql/test_lfind.sql b/src/test/modules/test_lfind/sql/test_lfind.sql
index 766c640831..d0dbb142ec 100644
--- a/src/test/modules/test_lfind/sql/test_lfind.sql
+++ b/src/test/modules/test_lfind/sql/test_lfind.sql
@@ -8,3 +8,5 @@ CREATE EXTENSION test_lfind;
 SELECT test_lfind8();
 SELECT test_lfind8_le();
 SELECT test_lfind32();
+SELECT test_lsearch8();
+SELECT test_lsearch8_ge();
diff --git a/src/test/modules/test_lfind/test_lfind--1.0.sql b/src/test/modules/test_lfind/test_lfind--1.0.sql
index 81801926ae..13857cec3b 100644
--- a/src/test/modules/test_lfind/test_lfind--1.0.sql
+++ b/src/test/modules/test_lfind/test_lfind--1.0.sql
@@ -14,3 +14,11 @@ CREATE FUNCTION test_lfind8()
 CREATE FUNCTION test_lfind8_le()
 	RETURNS pg_catalog.void
 	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_lsearch8()
+	RETURNS pg_catalog.void
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_lsearch8_ge()
+	RETURNS pg_catalog.void
+	AS 'MODULE_PATHNAME' LANGUAGE C;
diff --git a/src/test/modules/test_lfind/test_lfind.c b/src/test/modules/test_lfind/test_lfind.c
index 82673d54c6..c494c27436 100644
--- a/src/test/modules/test_lfind/test_lfind.c
+++ b/src/test/modules/test_lfind/test_lfind.c
@@ -14,6 +14,7 @@
 #include "postgres.h"
 
 #include "fmgr.h"
+#include "lib/stringinfo.h"
 #include "port/pg_lfind.h"
 
 /*
@@ -115,6 +116,144 @@ test_lfind8_le(PG_FUNCTION_ARGS)
 	PG_RETURN_VOID();
 }
 
+static void
+test_lsearch8_internal(uint8 key)
+{
+	uint8		charbuf[LEN_WITH_TAIL(Vector8)];
+	const int	len_no_tail = LEN_NO_TAIL(Vector8);
+	const int	len_with_tail = LEN_WITH_TAIL(Vector8);
+	int			keypos;
+
+	memset(charbuf, 0xFF, len_with_tail);
+	/* search tail to test one-byte-at-a-time path */
+	keypos = len_with_tail - 1;
+	charbuf[keypos] = key;
+	if (key > 0x00 && (pg_lsearch8(key - 1, charbuf, len_with_tail) != -1))
+		elog(ERROR, "pg_lsearch8() found nonexistent element '0x%x'", key - 1);
+	if (key < 0xFF && (pg_lsearch8(key, charbuf, len_with_tail) != keypos))
+		elog(ERROR, "pg_lsearch8() did not find existing element '0x%x'", key);
+	if (key < 0xFE && (pg_lsearch8(key + 1, charbuf, len_with_tail) != -1))
+		elog(ERROR, "pg_lsearch8() found nonexistent element '0x%x'", key + 1);
+
+	memset(charbuf, 0xFF, len_with_tail);
+	/* search with vector operations */
+	keypos = len_no_tail - 1;
+	charbuf[keypos] = key;
+	if (key > 0x00 && (pg_lsearch8(key - 1, charbuf, len_no_tail) != -1))
+		elog(ERROR, "pg_lsearch8() found nonexistent element '0x%x'", key - 1);
+	if (key < 0xFF && (pg_lsearch8(key, charbuf, len_no_tail) != keypos))
+		elog(ERROR, "pg_lsearch8() did not find existing element '0x%x'", key);
+	if (key < 0xFE && (pg_lsearch8(key + 1, charbuf, len_no_tail) != -1))
+		elog(ERROR, "pg_lsearch8() found nonexistent element '0x%x'", key + 1);
+}
+
+PG_FUNCTION_INFO_V1(test_lsearch8);
+Datum
+test_lsearch8(PG_FUNCTION_ARGS)
+{
+	test_lsearch8_internal(0);
+	test_lsearch8_internal(1);
+	test_lsearch8_internal(0x7F);
+	test_lsearch8_internal(0x80);
+	test_lsearch8_internal(0x81);
+	test_lsearch8_internal(0xFD);
+	test_lsearch8_internal(0xFE);
+	test_lsearch8_internal(0xFF);
+
+	PG_RETURN_VOID();
+}
+
+static void
+report_lsearch8_error(uint8 *buf, int size, uint8 key, int result, int expected)
+{
+	StringInfoData bufstr;
+	char *sep = "";
+
+	initStringInfo(&bufstr);
+
+	for (int i = 0; i < size; i++)
+	{
+		appendStringInfo(&bufstr, "%s0x%02x", sep, buf[i]);
+		sep = ",";
+	}
+
+	elog(ERROR,
+		 "pg_lsearch8_ge returned %d, expected %d, key 0x%02x buffer %s",
+		 result, expected, key, bufstr.data);
+}
+
+/* workhorse for test_lsearch8_ge */
+static void
+test_lsearch8_ge_internal(uint8 *buf, uint8 key)
+{
+	const int	len_no_tail = LEN_NO_TAIL(Vector8);
+	const int	len_with_tail = LEN_WITH_TAIL(Vector8);
+	int			expected;
+	int			result;
+	int			i;
+
+	/* search tail to test one-byte-at-a-time path */
+	for (i = 0; i < len_with_tail; i++)
+	{
+		if (buf[i] >= key)
+			break;
+	}
+	expected = i;
+	result = pg_lsearch8_ge(key, buf, len_with_tail);
+
+	if (result != expected)
+		report_lsearch8_error(buf, len_with_tail, key, result, expected);
+
+	/* search with vector operations */
+	for (i = 0; i < len_no_tail; i++)
+	{
+		if (buf[i] >= key)
+			break;
+	}
+	expected = i;
+	result = pg_lsearch8_ge(key, buf, len_no_tail);
+
+	if (result != expected)
+		report_lsearch8_error(buf, len_no_tail, key, result, expected);
+}
+
+static int
+cmp(const void *p1, const void *p2)
+{
+	uint8	v1 = *((const uint8 *) p1);
+	uint8	v2 = *((const uint8 *) p2);
+
+	if (v1 < v2)
+		return -1;
+	if (v1 > v2)
+		return 1;
+	return 0;
+}
+
+PG_FUNCTION_INFO_V1(test_lsearch8_ge);
+Datum
+test_lsearch8_ge(PG_FUNCTION_ARGS)
+{
+	uint8		charbuf[LEN_WITH_TAIL(Vector8)];
+	const int	len_with_tail = LEN_WITH_TAIL(Vector8);
+
+	for (int i = 0; i < len_with_tail; i++)
+		charbuf[i] = (uint8) rand();
+
+	qsort(charbuf, len_with_tail, sizeof(uint8), cmp);
+
+	test_lsearch8_ge_internal(charbuf, 0);
+	test_lsearch8_ge_internal(charbuf, 1);
+	test_lsearch8_ge_internal(charbuf, 0x7F);
+	test_lsearch8_ge_internal(charbuf, 0x80);
+	test_lsearch8_ge_internal(charbuf, 0x81);
+	test_lsearch8_ge_internal(charbuf, 0xFD);
+	test_lsearch8_ge_internal(charbuf, 0xFE);
+	test_lsearch8_ge_internal(charbuf, 0xFF);
+
+	PG_RETURN_VOID();
+}
+
 PG_FUNCTION_INFO_V1(test_lfind32);
 Datum
 test_lfind32(PG_FUNCTION_ARGS)
-- 
2.31.1

From f49e91ec2a2dcb19259cbf1bc0fd73f36b29a201 Mon Sep 17 00:00:00 2001
From: Masahiko Sawada <sawada.mshk@gmail.com>
Date: Wed, 14 Sep 2022 12:38:51 +0000
Subject: [PATCH v6 2/3] Add radix implementation.

---
 src/backend/lib/Makefile                      |    1 +
 src/backend/lib/radixtree.c                   | 2225 +++++++++++++++++
 src/include/lib/radixtree.h                   |   42 +
 src/test/modules/Makefile                     |    1 +
 src/test/modules/test_radixtree/.gitignore    |    4 +
 src/test/modules/test_radixtree/Makefile      |   23 +
 src/test/modules/test_radixtree/README        |    7 +
 .../expected/test_radixtree.out               |   28 +
 .../test_radixtree/sql/test_radixtree.sql     |    7 +
 .../test_radixtree/test_radixtree--1.0.sql    |    8 +
 .../modules/test_radixtree/test_radixtree.c   |  504 ++++
 .../test_radixtree/test_radixtree.control     |    4 +
 12 files changed, 2854 insertions(+)
 create mode 100644 src/backend/lib/radixtree.c
 create mode 100644 src/include/lib/radixtree.h
 create mode 100644 src/test/modules/test_radixtree/.gitignore
 create mode 100644 src/test/modules/test_radixtree/Makefile
 create mode 100644 src/test/modules/test_radixtree/README
 create mode 100644 src/test/modules/test_radixtree/expected/test_radixtree.out
 create mode 100644 src/test/modules/test_radixtree/sql/test_radixtree.sql
 create mode 100644 src/test/modules/test_radixtree/test_radixtree--1.0.sql
 create mode 100644 src/test/modules/test_radixtree/test_radixtree.c
 create mode 100644 src/test/modules/test_radixtree/test_radixtree.control

diff --git a/src/backend/lib/Makefile b/src/backend/lib/Makefile
index 9dad31398a..4c1db794b6 100644
--- a/src/backend/lib/Makefile
+++ b/src/backend/lib/Makefile
@@ -22,6 +22,7 @@ OBJS = \
 	integerset.o \
 	knapsack.o \
 	pairingheap.o \
+	radixtree.o \
 	rbtree.o \
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/lib/radixtree.c b/src/backend/lib/radixtree.c
new file mode 100644
index 0000000000..b163eac480
--- /dev/null
+++ b/src/backend/lib/radixtree.c
@@ -0,0 +1,2225 @@
+/*-------------------------------------------------------------------------
+ *
+ * radixtree.c
+ *		Implementation for adaptive radix tree.
+ *
+ * This module employs the idea from the paper "The Adaptive Radix Tree: ARTful
+ * Indexing for Main-Memory Databases" by Viktor Leis, Alfons Kemper, and Thomas
+ * Neumann, 2013. The radix tree uses adaptive node sizes, a small number of node
+ * types, each with a different numbers of elements. Depending on the number of
+ * children, the appropriate node type is used.
+ *
+ * There are some differences from the proposed implementation. For instance,
+ * this radix tree module utilizes AVX2 instruction, enabling us to use 256-bit
+ * width SIMD vector, whereas 128-bit width SIMD vector is used in the paper.
+ * Also, there is no support for path compression and lazy path expansion. The
+ * radix tree supports fixed length of the key so we don't expect the tree level
+ * wouldn't be high.
+ *
+ * Both the key and the value are 64-bit unsigned integer. The inner nodes and
+ * the leaf nodes have slightly different structure: for inner tree nodes,
+ * shift > 0, store the pointer to its child node as the value. The leaf nodes,
+ * shift == 0, have the 64-bit unsigned integer that is specified by the user as
+ * the value. The paper refers to this technique as "Multi-value leaves".  We
+ * choose it to avoid an additional pointer traversal.  It is the reason this code
+ * currently does not support variable-length keys.
+ *
+ * XXX: the radix tree node never be shrunk.
+ *
+ * Interface
+ * ---------
+ *
+ * rt_create		- Create a new, empty radix tree
+ * rt_free			- Free the radix tree
+ * rt_search		- Search a key-value pair
+ * rt_set			- Set a key-value pair
+ * rt_delete		- Delete a key-value pair
+ * rt_begin_iter	- Begin iterating through all key-value pairs
+ * rt_iter_next		- Return next key-value pair, if any
+ * rt_end_iter		- End iteration
+ * rt_memory_usage	- Get the memory usage
+ * rt_num_entries	- Get the number of key-value pairs
+ *
+ * rt_create() creates an empty radix tree in the given memory context
+ * and memory contexts for all kinds of radix tree node under the memory context.
+ *
+ * rt_iterate_next() ensures returning key-value pairs in the ascending
+ * order of the key.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/lib/radixtree.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "miscadmin.h"
+#include "port/pg_bitutils.h"
+#include "port/pg_lfind.h"
+#include "utils/memutils.h"
+#include "lib/radixtree.h"
+#include "lib/stringinfo.h"
+
+/* The number of bits encoded in one tree level */
+#define RT_NODE_SPAN	BITS_PER_BYTE
+
+/* The number of maximum slots in the node */
+#define RT_NODE_MAX_SLOTS (1 << RT_NODE_SPAN)
+
+/*
+ * Return the number of bits required to represent nslots slots, used
+ * nodes indexed by array lookup.
+ */
+#define RT_NODE_NSLOTS_BITS(nslots) ((nslots) / (sizeof(uint8) * BITS_PER_BYTE))
+
+/* Mask for extracting a chunk from the key */
+#define RT_CHUNK_MASK ((1 << RT_NODE_SPAN) - 1)
+
+/* Maximum shift the radix tree uses */
+#define RT_MAX_SHIFT	key_get_shift(UINT64_MAX)
+
+/* Tree level the radix tree uses */
+#define RT_MAX_LEVEL	((sizeof(uint64) * BITS_PER_BYTE) / RT_NODE_SPAN)
+
+/* Invalid index used in node-128 */
+#define RT_NODE_128_INVALID_IDX	0xFF
+
+/* Get a chunk from the key */
+#define RT_GET_KEY_CHUNK(key, shift) \
+	((uint8) (((key) >> (shift)) & RT_CHUNK_MASK))
+
+/*
+ * Mapping from the value to the bit in is-set bitmap in the node-256.
+ */
+#define RT_NODE_BITMAP_BYTE(v) ((v) / BITS_PER_BYTE)
+#define RT_NODE_BITMAP_BIT(v) (UINT64CONST(1) << ((v) % RT_NODE_SPAN))
+
+/* Enum used rt_node_search() */
+typedef enum
+{
+	RT_ACTION_FIND = 0,			/* find the key-value */
+	RT_ACTION_DELETE,			/* delete the key-value */
+} rt_action;
+
+/*
+ * Supported radix tree nodes.
+ *
+ * XXX: These are currently not well chosen. To reduce memory fragmentation
+ * smaller class should optimally fit neatly into the next larger class
+ * (except perhaps at the lowest end). Right now its
+ * 48 -> 152 -> 296 -> 1304 -> 2088 bytes for inner/leaf nodes, leading to
+ * large amounts of allocator padding with aset.c. Hence the use of slab.
+ *
+ * XXX: need to have node-1 until there is no path compression optimization?
+ *
+ * XXX: need to explain why we choose these node types based on benchmark
+ * results etc.
+ */
+typedef enum rt_node_kind
+{
+	RT_NODE_KIND_4 = 0,
+	RT_NODE_KIND_16,
+	RT_NODE_KIND_32,
+	RT_NODE_KIND_128,
+	RT_NODE_KIND_256
+} rt_node_kind;
+#define RT_NODE_KIND_COUNT (RT_NODE_KIND_256 + 1)
+
+/*
+ * Base type for all nodes types.
+ */
+typedef struct rt_node
+{
+	/*
+	 * Number of children.  We use uint16 to be able to indicate 256 children
+	 * at the fanout of 8.
+	 */
+	uint16		count;
+
+	/*
+	 * Shift indicates which part of the key space is represented by this
+	 * node. That is, the key is shifted by 'shift' and the lowest
+	 * RT_NODE_SPAN bits are then represented in chunk.
+	 */
+	uint8		shift;
+	uint8		chunk;
+
+	/* Size class of the node */
+	rt_node_kind kind;
+} rt_node;
+
+/* Macros for radix tree nodes */
+#define IS_LEAF_NODE(n) (((rt_node *) (n))->shift == 0)
+#define IS_EMPTY_NODE(n) (((rt_node *) (n))->count == 0)
+#define NODE_HAS_FREE_SLOT(n) \
+	(((rt_node *) (n))->count < rt_node_info[((rt_node *) (n))->kind].fanout)
+
+/*
+ * Definitions of the base types for inner and leaf nodes of each node type.
+ */
+
+/*
+ * node-4, node-16, and node-32 have similar structure but have different
+ * the number of fanout. They have the same length for chunks and values
+ * (or child pointers in inner nodes). The chunks and values are stored at
+ * corresponding position and chunks are sorted.
+*/
+typedef struct rd_node_base_4
+{
+	rt_node		n;
+
+	/* 4 children, for key chunks */
+	uint8		chunks[4];
+} rt_node_base_4;
+
+typedef struct rd_node_base_16
+{
+	rt_node		n;
+
+	/* 16 children, for key chunks */
+	uint8		chunks[16];
+} rt_node_base_16;
+
+typedef struct rd_node_base_32
+{
+	rt_node		n;
+
+	/* 32 children, for key chunks */
+	uint8		chunks[32];
+} rt_node_base_32;
+
+/*
+ * node-128 uses slot_idx array, an array of RT_NODE_MAX_SLOTS length, typically
+ * 256, to store indexes into a second array that contains up to 128 values (or
+ * child pointers in inner nodes).
+ */
+typedef struct rd_node_base_128
+{
+	rt_node		n;
+
+	/* The index of slots for each fanout */
+	uint8		slot_idxs[RT_NODE_MAX_SLOTS];
+
+	/* isset is a bitmap to track which slot is in use */
+	uint8		isset[RT_NODE_NSLOTS_BITS(128)];
+} rt_node_base_128;
+
+/*
+ * node-256 is the largest node type. This node has RT_NODE_MAX_SLOTS length array
+ * for directly storing values (or child pointers in inner nodes).
+ */
+typedef struct rd_node_base_256
+{
+	rt_node		n;
+
+	/* isset is a bitmap to track which slot is in use */
+	uint8		isset[RT_NODE_NSLOTS_BITS(RT_NODE_MAX_SLOTS)];
+} rt_node_base_256;
+
+/*
+ * Inner and leaf nodes.
+ *
+ * There are separate from inner node size classes for two main reasons:
+ *
+ * 1) the value type might be different than something fitting into a pointer
+ *    width type
+ * 2) Need to represent non-existing values in a key-type independent way.
+ *
+ * 1) is clearly worth being concerned about, but it's not clear 2) is as
+ * good. It might be better to just indicate non-existing entries the same way
+ * in inner nodes.
+ */
+typedef struct rt_node_inner_4
+{
+	rt_node_base_4 base;
+
+	/* 4 children, for key chunks */
+	rt_node    *children[4];
+} rt_node_inner_4;
+
+typedef struct rt_node_leaf_4
+{
+	rt_node_base_4 base;
+
+	/* 4 values, for key chunks */
+	uint64		values[4];
+} rt_node_leaf_4;
+
+typedef struct rt_node_inner_16
+{
+	rt_node_base_16 base;
+
+	/* 16 children, for key chunks */
+	rt_node    *children[16];
+} rt_node_inner_16;
+
+typedef struct rt_node_leaf_16
+{
+	rt_node_base_16 base;
+
+	/* 16 values, for key chunks */
+	uint64		values[16];
+} rt_node_leaf_16;
+
+typedef struct rt_node_inner_32
+{
+	rt_node_base_32 base;
+
+	/* 32 children, for key chunks */
+	rt_node    *children[32];
+} rt_node_inner_32;
+
+typedef struct rt_node_leaf_32
+{
+	rt_node_base_32 base;
+
+	/* 32 values, for key chunks */
+	uint64		values[32];
+} rt_node_leaf_32;
+
+typedef struct rt_node_inner_128
+{
+	rt_node_base_128 base;
+
+	/* Slots for 128 children */
+	rt_node    *children[128];
+} rt_node_inner_128;
+
+typedef struct rt_node_leaf_128
+{
+	rt_node_base_128 base;
+
+	/* Slots for 128 values */
+	uint64		values[128];
+} rt_node_leaf_128;
+
+typedef struct rt_node_inner_256
+{
+	rt_node_base_256 base;
+
+	/* Slots for 256 children */
+	rt_node    *children[RT_NODE_MAX_SLOTS];
+} rt_node_inner_256;
+
+typedef struct rt_node_leaf_256
+{
+	rt_node_base_256 base;
+
+	/* Slots for 256 values */
+	uint64		values[RT_NODE_MAX_SLOTS];
+} rt_node_leaf_256;
+
+/* Information of each size class */
+typedef struct rt_node_info_elem
+{
+	const char *name;
+	int			fanout;
+	Size		inner_size;
+	Size		leaf_size;
+} rt_node_info_elem;
+
+static rt_node_info_elem rt_node_info[RT_NODE_KIND_COUNT] = {
+
+	[RT_NODE_KIND_4] = {
+		.name = "radix tree node 4",
+		.fanout = 4,
+		.inner_size = sizeof(rt_node_inner_4),
+		.leaf_size = sizeof(rt_node_leaf_4),
+	},
+	[RT_NODE_KIND_16] = {
+		.name = "radix tree node 16",
+		.fanout = 16,
+		.inner_size = sizeof(rt_node_inner_16),
+		.leaf_size = sizeof(rt_node_leaf_16),
+	},
+	[RT_NODE_KIND_32] = {
+		.name = "radix tree node 32",
+		.fanout = 32,
+		.inner_size = sizeof(rt_node_inner_32),
+		.leaf_size = sizeof(rt_node_leaf_32),
+	},
+	[RT_NODE_KIND_128] = {
+		.name = "radix tree node 128",
+		.fanout = 128,
+		.inner_size = sizeof(rt_node_inner_128),
+		.leaf_size = sizeof(rt_node_leaf_128),
+	},
+	[RT_NODE_KIND_256] = {
+		.name = "radix tree node 256",
+		.fanout = 256,
+		.inner_size = sizeof(rt_node_inner_256),
+		.leaf_size = sizeof(rt_node_leaf_256),
+	},
+};
+
+/*
+ * Iteration support.
+ *
+ * Iterating the radix tree returns each pair of key and value in the ascending
+ * order of the key. To support this, the we iterate nodes of each level.
+ *
+ * rt_node_iter struct is used to track the iteration within a node.
+ *
+ * rt_iter is the struct for iteration of the radix tree, and uses rt_node_iter
+ * in order to track the iteration of each level. During the iteration, we also
+ * construct the key whenever updating the node iteration information, e.g., when
+ * advancing the current index within the node or when moving to the next node
+ * at the same level.
+ */
+typedef struct rt_node_iter
+{
+	rt_node    *node;			/* current node being iterated */
+	int			current_idx;	/* current position. -1 for initial value */
+} rt_node_iter;
+
+struct rt_iter
+{
+	radix_tree *tree;
+
+	/* Track the iteration on nodes of each level */
+	rt_node_iter stack[RT_MAX_LEVEL];
+	int			stack_len;
+
+	/* The key is being constructed during the iteration */
+	uint64		key;
+};
+
+/* A radix tree with nodes */
+struct radix_tree
+{
+	MemoryContext context;
+
+	rt_node    *root;
+	uint64		max_val;
+	uint64		num_keys;
+
+	MemoryContextData *inner_slabs[RT_NODE_KIND_COUNT];
+	MemoryContextData *leaf_slabs[RT_NODE_KIND_COUNT];
+
+	/* statistics */
+#ifdef RT_DEBUG
+	int32		cnt[RT_NODE_KIND_COUNT];
+#endif
+};
+
+static void rt_new_root(radix_tree *tree, uint64 key);
+static rt_node *rt_alloc_node(radix_tree *tree, rt_node_kind kind, bool inner);
+static void rt_free_node(radix_tree *tree, rt_node *node);
+static void rt_copy_node_common(rt_node *src, rt_node *dst);
+static void rt_extend(radix_tree *tree, uint64 key);
+static bool rt_node_search(rt_node *node, uint64 key, rt_action action, void **slot_p);
+static bool rt_node_search_inner(rt_node *node, uint64 key, rt_action action,
+								 rt_node **child_p);
+static bool rt_node_search_leaf(rt_node *node, uint64 key, rt_action action,
+								uint64 *value_p);
+static rt_node *rt_node_add_new_child(radix_tree *tree, rt_node *parent,
+									  rt_node *node, uint64 key);
+static int	rt_node_prepare_insert(radix_tree *tree, rt_node *parent,
+								   rt_node **node_p, uint64 key,
+								   bool *will_replace_p);
+static void rt_node_insert_inner(radix_tree *tree, rt_node *parent, rt_node *node,
+								 uint64 key, rt_node *child, bool *replaced_p);
+static void rt_node_insert_leaf(radix_tree *tree, rt_node *parent, rt_node *node,
+								uint64 key, uint64 value, bool *replaced_p);
+static rt_node *rt_node_grow(radix_tree *tree, rt_node *parent,
+							 rt_node *node, uint64 key);
+static void rt_update_iter_stack(rt_iter *iter, int from);
+static void *rt_node_iterate_next(rt_iter *iter, rt_node_iter *node_iter,
+								  bool *found_p);
+static void rt_update_node_iter(rt_iter *iter, rt_node_iter *node_iter,
+								rt_node *node);
+static pg_attribute_always_inline void rt_iter_update_key(rt_iter *iter, uint8 chunk,
+														  uint8 shift);
+
+/* verification (available only with assertion) */
+static void rt_verify_node(rt_node *node);
+
+/* Return the array of children in the given inner node */
+static rt_node **
+rt_node_get_children(rt_node *node)
+{
+	rt_node   **children = NULL;
+
+	Assert(!IS_LEAF_NODE(node));
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			children = (rt_node **) ((rt_node_inner_4 *) node)->children;
+			break;
+		case RT_NODE_KIND_16:
+			children = (rt_node **) ((rt_node_inner_16 *) node)->children;
+			break;
+		case RT_NODE_KIND_32:
+			children = (rt_node **) ((rt_node_inner_32 *) node)->children;
+			break;
+		case RT_NODE_KIND_128:
+			children = (rt_node **) ((rt_node_inner_128 *) node)->children;
+			break;
+		case RT_NODE_KIND_256:
+			children = (rt_node **) ((rt_node_inner_256 *) node)->children;
+			break;
+		default:
+			elog(ERROR, "unexpected node type %u", node->kind);
+	}
+
+	return children;
+}
+
+/* Return the array of values in the given leaf node */
+static uint64 *
+rt_node_get_values(rt_node *node)
+{
+	uint64	   *values = NULL;
+
+	Assert(IS_LEAF_NODE(node));
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			values = ((rt_node_leaf_4 *) node)->values;
+			break;
+		case RT_NODE_KIND_16:
+			values = ((rt_node_leaf_16 *) node)->values;
+			break;
+		case RT_NODE_KIND_32:
+			values = ((rt_node_leaf_32 *) node)->values;
+			break;
+		case RT_NODE_KIND_128:
+			values = ((rt_node_leaf_128 *) node)->values;
+			break;
+		case RT_NODE_KIND_256:
+			values = ((rt_node_leaf_256 *) node)->values;
+			break;
+		default:
+			elog(ERROR, "unexpected node type %u", node->kind);
+	}
+
+	return values;
+}
+
+/*
+ * Node support functions for node-4, node-16, and node-32.
+ *
+ * These three node types have similar structure -- they have the array of chunks with
+ * different length and corresponding pointers or values depending on inner nodes or
+ * leaf nodes.
+ */
+#define CHECK_CHUNK_ARRAY_NODE(node) \
+	Assert(((((rt_node*) node)->kind) == RT_NODE_KIND_4) || \
+		   ((((rt_node*) node)->kind) == RT_NODE_KIND_16) || \
+		   ((((rt_node*) node)->kind) == RT_NODE_KIND_32))
+
+/* Get the pointer to either the child or the value at 'idx */
+static void *
+chunk_array_node_get_slot(rt_node *node, int idx)
+{
+	void	   *slot;
+
+	CHECK_CHUNK_ARRAY_NODE(node);
+
+	if (IS_LEAF_NODE(node))
+	{
+		uint64	   *values = rt_node_get_values(node);
+
+		slot = (void *) &(values[idx]);
+	}
+	else
+	{
+		rt_node   **children = rt_node_get_children(node);
+
+		slot = (void *) children[idx];
+	}
+
+	return slot;
+}
+
+/* Return the chunk array in the node */
+static uint8 *
+chunk_array_node_get_chunks(rt_node *node)
+{
+	uint8	   *chunk = NULL;
+
+	CHECK_CHUNK_ARRAY_NODE(node);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			chunk = (uint8 *) ((rt_node_base_4 *) node)->chunks;
+			break;
+		case RT_NODE_KIND_16:
+			chunk = (uint8 *) ((rt_node_base_16 *) node)->chunks;
+			break;
+		case RT_NODE_KIND_32:
+			chunk = (uint8 *) ((rt_node_base_32 *) node)->chunks;
+			break;
+		default:
+			/* this function don't support node-128 and node-256 */
+			elog(ERROR, "unsupported node type %d", node->kind);
+	}
+
+	return chunk;
+}
+
+/* Copy the contents of the node from 'src' to 'dst' */
+static void
+chunk_array_node_copy_contents(rt_node *src, rt_node *dst)
+{
+	uint8	   *chunks_src,
+			   *chunks_dst;
+
+	CHECK_CHUNK_ARRAY_NODE(src);
+	CHECK_CHUNK_ARRAY_NODE(dst);
+
+	/* Copy base type */
+	rt_copy_node_common(src, dst);
+
+	/* Copy chunk array */
+	chunks_src = chunk_array_node_get_chunks(src);
+	chunks_dst = chunk_array_node_get_chunks(dst);
+	memcpy(chunks_dst, chunks_src, sizeof(uint8) * src->count);
+
+	/* Copy children or values */
+	if (IS_LEAF_NODE(src))
+	{
+		uint64	   *values_src,
+				   *values_dst;
+
+		Assert(IS_LEAF_NODE(dst));
+		values_src = rt_node_get_values(src);
+		values_dst = rt_node_get_values(dst);
+		memcpy(values_dst, values_src, sizeof(uint64) * src->count);
+	}
+	else
+	{
+		rt_node   **children_src,
+				  **children_dst;
+
+		Assert(!IS_LEAF_NODE(dst));
+		children_src = rt_node_get_children(src);
+		children_dst = rt_node_get_children(dst);
+		memcpy(children_dst, children_src, sizeof(rt_node *) * src->count);
+	}
+}
+
+/*
+ * Return the index of the (sorted) chunk array where the chunk is inserted.
+ * Set true to replaced_p if the chunk already exists in the array.
+ */
+static int
+chunk_array_node_find_insert_pos(rt_node *node, uint8 chunk, bool *found_p)
+{
+	uint8	   *chunks;
+	int			idx;
+
+	CHECK_CHUNK_ARRAY_NODE(node);
+
+	*found_p = false;
+	chunks = chunk_array_node_get_chunks(node);
+
+	/* Find the insert pos */
+	idx = pg_lsearch8_ge(chunk, chunks, node->count);
+
+	if (idx < node->count && chunks[idx] == chunk)
+		*found_p = true;
+
+	return idx;
+}
+
+/* Delete the chunk at idx */
+static void
+chunk_array_node_delete(rt_node *node, int idx)
+{
+	uint8	   *chunks = chunk_array_node_get_chunks(node);
+
+	/* delete the chunk from the chunk array */
+	memmove(&(chunks[idx]), &(chunks[idx + 1]),
+			sizeof(uint8) * (node->count - idx - 1));
+
+	/* delete either the value or the child as well */
+	if (IS_LEAF_NODE(node))
+	{
+		uint64	   *values = rt_node_get_values(node);
+
+		memmove(&(values[idx]),
+				&(values[idx + 1]),
+				sizeof(uint64) * (node->count - idx - 1));
+	}
+	else
+	{
+		rt_node   **children = rt_node_get_children(node);
+
+		memmove(&(children[idx]),
+				&(children[idx + 1]),
+				sizeof(rt_node *) * (node->count - idx - 1));
+	}
+}
+
+/* Support function for both node-128 */
+
+/* Does the given chunk in the node has the value? */
+static pg_attribute_always_inline bool
+node_128_is_chunk_used(rt_node_base_128 *node, uint8 chunk)
+{
+	return node->slot_idxs[chunk] != RT_NODE_128_INVALID_IDX;
+}
+
+/* Is the slot in the node used? */
+static pg_attribute_always_inline bool
+node_128_is_slot_used(rt_node_base_128 *node, uint8 slot)
+{
+	return ((node->isset[RT_NODE_BITMAP_BYTE(slot)] & RT_NODE_BITMAP_BIT(slot)) != 0);
+}
+
+/* Get the pointer to either the child or the value corresponding to chunk */
+static void *
+node_128_get_slot(rt_node_base_128 *node, uint8 chunk)
+{
+	int			slotpos;
+	void	   *slot;
+
+	slotpos = node->slot_idxs[chunk];
+	Assert(slotpos != RT_NODE_128_INVALID_IDX);
+
+	if (IS_LEAF_NODE(node))
+		slot = (void *) &(((rt_node_leaf_128 *) node)->values[slotpos]);
+	else
+		slot = (void *) (((rt_node_inner_128 *) node)->children[slotpos]);
+
+	return slot;
+}
+
+/* Delete the chunk in the node */
+static void
+node_128_delete(rt_node_base_128 *node, uint8 chunk)
+{
+	int			slotpos = node->slot_idxs[chunk];
+
+	node->isset[RT_NODE_BITMAP_BYTE(slotpos)] &= ~(RT_NODE_BITMAP_BIT(slotpos));
+	node->slot_idxs[chunk] = RT_NODE_128_INVALID_IDX;
+}
+
+/* Return an unused slot in node-128 */
+static int
+node_128_find_unused_slot(rt_node_base_128 *node, uint8 chunk)
+{
+	int			slotpos;
+
+	/*
+	 * Find an unused slot. We iterate over the isset bitmap per byte then
+	 * check each bit.
+	 */
+	for (slotpos = 0; slotpos < RT_NODE_NSLOTS_BITS(128); slotpos++)
+	{
+		if (node->isset[slotpos] < 0xFF)
+			break;
+	}
+	Assert(slotpos < RT_NODE_NSLOTS_BITS(128));
+
+	slotpos *= BITS_PER_BYTE;
+	while (node_128_is_slot_used(node, slotpos))
+		slotpos++;
+
+	return slotpos;
+}
+
+
+/* XXX: duplicate with node_128_set_leaf */
+static void
+node_128_set_inner(rt_node_base_128 *node, uint8 chunk, rt_node *child)
+{
+	int			slotpos;
+	rt_node_inner_128 *n128 = (rt_node_inner_128 *) node;
+
+	/* Overwrite the existing value if exists */
+	if (node_128_is_chunk_used(node, chunk))
+	{
+		n128->children[n128->base.slot_idxs[chunk]] = child;
+		return;
+	}
+
+	/* find unused slot */
+	slotpos = node_128_find_unused_slot(node, chunk);
+
+	n128->base.slot_idxs[chunk] = slotpos;
+	n128->base.isset[RT_NODE_BITMAP_BYTE(slotpos)] |= RT_NODE_BITMAP_BIT(slotpos);
+	n128->children[slotpos] = child;
+}
+
+/* Set the slot at the corresponding chunk */
+static void
+node_128_set_leaf(rt_node_base_128 *node, uint8 chunk, uint64 value)
+{
+	int			slotpos;
+	rt_node_leaf_128 *n128 = (rt_node_leaf_128 *) node;
+
+	/* Overwrite the existing value if exists */
+	if (node_128_is_chunk_used(node, chunk))
+	{
+		n128->values[n128->base.slot_idxs[chunk]] = value;
+		return;
+	}
+
+	/* find unused slot */
+	slotpos = node_128_find_unused_slot(node, chunk);
+
+	n128->base.slot_idxs[chunk] = slotpos;
+	n128->base.isset[RT_NODE_BITMAP_BYTE(slotpos)] |= RT_NODE_BITMAP_BIT(slotpos);
+	n128->values[slotpos] = value;
+}
+
+/* Return true if the slot corresponding to the given chunk is in use */
+static bool
+node_256_is_chunk_used(rt_node_base_256 *node, uint8 chunk)
+{
+	return (node->isset[RT_NODE_BITMAP_BYTE(chunk)] & RT_NODE_BITMAP_BIT(chunk)) != 0;
+}
+
+/* Get the pointer to either the child or the value corresponding to chunk */
+static void *
+node_256_get_slot(rt_node_base_256 *node, uint8 chunk)
+{
+	void	   *slot;
+
+	Assert(node_256_is_chunk_used(node, chunk));
+	if (IS_LEAF_NODE(node))
+		slot = (void *) &(((rt_node_leaf_256 *) node)->values[chunk]);
+	else
+		slot = (void *) (((rt_node_inner_256 *) node)->children[chunk]);
+
+	return slot;
+}
+
+/* Set the child in the node-256 */
+static pg_attribute_always_inline void
+node_256_set_inner(rt_node_base_256 *node, uint8 chunk, rt_node *child)
+{
+	rt_node_inner_256 *n256 = (rt_node_inner_256 *) node;
+
+	n256->base.isset[RT_NODE_BITMAP_BYTE(chunk)] |= RT_NODE_BITMAP_BIT(chunk);
+	n256->children[chunk] = child;
+}
+
+/* Set the value in the node-256 */
+static pg_attribute_always_inline void
+node_256_set_leaf(rt_node_base_256 *node, uint8 chunk, uint64 value)
+{
+	rt_node_leaf_256 *n256 = (rt_node_leaf_256 *) node;
+
+	n256->base.isset[RT_NODE_BITMAP_BYTE(chunk)] |= RT_NODE_BITMAP_BIT(chunk);
+	n256->values[chunk] = value;
+}
+
+/* Set the slot at the given chunk position */
+static pg_attribute_always_inline void
+node_256_delete(rt_node_base_256 *node, uint8 chunk)
+{
+	node->isset[RT_NODE_BITMAP_BYTE(chunk)] &= ~(RT_NODE_BITMAP_BIT(chunk));
+}
+
+/*
+ * Return the shift that is satisfied to store the given key.
+ */
+static pg_attribute_always_inline int
+key_get_shift(uint64 key)
+{
+	return (key == 0)
+		? 0
+		: (pg_leftmost_one_pos64(key) / RT_NODE_SPAN) * RT_NODE_SPAN;
+}
+
+/*
+ * Return the max value stored in a node with the given shift.
+ */
+static uint64
+shift_get_max_val(int shift)
+{
+	if (shift == RT_MAX_SHIFT)
+		return UINT64_MAX;
+
+	return (UINT64CONST(1) << (shift + RT_NODE_SPAN)) - 1;
+}
+
+/*
+ * Create a new node as the root. Subordinate nodes will be created during
+ * the insertion.
+ */
+static void
+rt_new_root(radix_tree *tree, uint64 key)
+{
+	int			shift = key_get_shift(key);
+	rt_node    *node;
+
+	node = (rt_node *) rt_alloc_node(tree, RT_NODE_KIND_4, shift > 0);
+	node->shift = shift;
+	tree->max_val = shift_get_max_val(shift);
+	tree->root = node;
+}
+
+/*
+ * Allocate a new node with the given node kind.
+ */
+static rt_node *
+rt_alloc_node(radix_tree *tree, rt_node_kind kind, bool inner)
+{
+	rt_node    *newnode;
+
+	if (inner)
+		newnode = (rt_node *) MemoryContextAllocZero(tree->inner_slabs[kind],
+													 rt_node_info[kind].inner_size);
+	else
+		newnode = (rt_node *) MemoryContextAllocZero(tree->leaf_slabs[kind],
+													 rt_node_info[kind].leaf_size);
+
+	newnode->kind = kind;
+
+	/* Initialize slot_idxs to invalid values */
+	if (kind == RT_NODE_KIND_128)
+	{
+		rt_node_base_128 *n128 = (rt_node_base_128 *) newnode;
+
+		memset(n128->slot_idxs, RT_NODE_128_INVALID_IDX, sizeof(n128->slot_idxs));
+	}
+
+#ifdef RT_DEBUG
+	/* update the statistics */
+	tree->cnt[kind]++;
+#endif
+
+	return newnode;
+}
+
+/* Free the given node */
+static void
+rt_free_node(radix_tree *tree, rt_node *node)
+{
+	/* If we're deleting the root node, make the tree empty */
+	if (tree->root == node)
+		tree->root = NULL;
+
+#ifdef RT_DEBUG
+	/* update the statistics */
+	tree->cnt[node->kind]--;
+
+	Assert(tree->cnt[node->kind] >= 0);
+#endif
+
+	pfree(node);
+}
+
+/* Copy the common fields without the node kind */
+static void
+rt_copy_node_common(rt_node *src, rt_node *dst)
+{
+	dst->shift = src->shift;
+	dst->chunk = src->chunk;
+	dst->count = src->count;
+}
+
+/*
+ * The radix tree doesn't sufficient height. Extend the radix tree so it can
+ * store the key.
+ */
+static void
+rt_extend(radix_tree *tree, uint64 key)
+{
+	int			target_shift;
+	int			shift = tree->root->shift + RT_NODE_SPAN;
+
+	target_shift = key_get_shift(key);
+
+	/* Grow tree from 'shift' to 'target_shift' */
+	while (shift <= target_shift)
+	{
+		rt_node_inner_4 *node =
+		(rt_node_inner_4 *) rt_alloc_node(tree, RT_NODE_KIND_4, true);
+
+		node->base.n.count = 1;
+		node->base.n.shift = shift;
+		node->base.chunks[0] = 0;
+		node->children[0] = tree->root;
+
+		tree->root->chunk = 0;
+		tree->root = (rt_node *) node;
+
+		shift += RT_NODE_SPAN;
+	}
+
+	tree->max_val = shift_get_max_val(target_shift);
+}
+
+/*
+ * Search for the given key in the node. Return true if the key is found, otherwise
+ * return false. On success, we do the specified action for the key, and set the
+ * pointer to the slot to slot_p.
+ */
+static bool
+rt_node_search(rt_node *node, uint64 key, rt_action action, void **slot_p)
+{
+	uint8		chunk = RT_GET_KEY_CHUNK(key, node->shift);
+	bool		found = false;
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				int			idx;
+				uint8	   *chunks = chunk_array_node_get_chunks(node);
+
+				idx = pg_lsearch8(chunk, chunks, node->count);
+				if (idx < 0)
+					break;
+
+				found = true;
+				if (action == RT_ACTION_FIND)
+					*slot_p = chunk_array_node_get_slot(node, idx);
+				else			/* RT_ACTION_DELETE */
+					chunk_array_node_delete(node, idx);
+
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_base_128 *n128 = (rt_node_base_128 *) node;
+
+				if (!node_128_is_chunk_used(n128, chunk))
+					break;
+
+				found = true;
+				if (action == RT_ACTION_FIND)
+					*slot_p = node_128_get_slot(n128, chunk);
+				else		/* RT_ACTION_DELETE */
+					node_128_delete(n128, chunk);
+
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				rt_node_base_256 *n256 = (rt_node_base_256 *) node;
+
+				if (!node_256_is_chunk_used(n256, chunk))
+					break;
+
+				found = true;
+				if (action == RT_ACTION_FIND)
+					*slot_p = node_256_get_slot(n256, chunk);
+				else		/* RT_ACTION_DELETE */
+					node_256_delete(n256, chunk);
+
+				break;
+			}
+	}
+
+	/* Update the statistics */
+	if (action == RT_ACTION_DELETE && found)
+		node->count--;
+
+	return found;
+}
+
+/*
+ * Search for the child pointer corresponding to the key in the given node.
+ *
+ * Return true if the key is found, otherwise return false. On success, the child
+ * pointer is set to child_p.
+ */
+static bool
+rt_node_search_inner(rt_node *node, uint64 key, rt_action action, rt_node **child_p)
+{
+	rt_node    *child;
+
+	if (!rt_node_search(node, key, action, (void **) &child))
+		return false;
+
+	if (child_p)
+		*child_p = child;
+
+	return true;
+}
+
+/*
+ * Search for the value corresponding to the key in the given node.
+ *
+ * Return true if the key is found, otherwise return false. On success, the pointer
+ * to the value is set to value_p.
+ */
+static bool
+rt_node_search_leaf(rt_node *node, uint64 key, rt_action action, uint64 *value_p)
+{
+	uint64	   *value;
+
+	if (!rt_node_search(node, key, action, (void **) &value))
+		return false;
+
+	if (value_p)
+		*value_p = *value;
+
+	return true;
+}
+
+/* Insert 'node' as a child node of 'parent' */
+static rt_node *
+rt_node_add_new_child(radix_tree *tree, rt_node *parent, rt_node *node, uint64 key)
+{
+	uint8		newshift = node->shift - RT_NODE_SPAN;
+	rt_node    *newchild =
+	(rt_node *) rt_alloc_node(tree, RT_NODE_KIND_4, newshift > 0);
+
+	Assert(!IS_LEAF_NODE(node));
+
+	newchild->shift = newshift;
+	newchild->chunk = RT_GET_KEY_CHUNK(key, node->shift);
+
+	rt_node_insert_inner(tree, parent, node, key, newchild, NULL);
+
+	return (rt_node *) newchild;
+}
+
+/*
+ * For a upcoming insertion, we make sure that the node has enough free slots or
+ * grow the node if necessary. node_p is updated with the grown node. We set true
+ * to will_replace_p to tell the caller that the given chunk already exists in the
+ * node.
+ *
+ * Return the index in the chunk array where the key can be inserted. We always
+ * return 0 in node-128 and node-256 cases.
+ */
+static int
+rt_node_prepare_insert(radix_tree *tree, rt_node *parent, rt_node **node_p,
+					   uint64 key, bool *will_replace_p)
+{
+	rt_node    *node = *node_p;
+	uint8		chunk = RT_GET_KEY_CHUNK(key, node->shift);
+	bool		will_replace = false;
+	int			idx = 0;
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				bool		can_insert = false;
+
+				while ((node->kind == RT_NODE_KIND_4) ||
+					   (node->kind == RT_NODE_KIND_16) ||
+					   (node->kind == RT_NODE_KIND_32))
+				{
+					/* Find the insert pos */
+					idx = chunk_array_node_find_insert_pos(node, chunk, &will_replace);
+
+					if (will_replace || NODE_HAS_FREE_SLOT(node))
+					{
+						/*
+						 * Found. We can insert a new one or replace the exiting
+						 * value.
+						 */
+						can_insert = true;
+						break;
+					}
+
+					node = rt_node_grow(tree, parent, node, key);
+				}
+
+				if (can_insert)
+				{
+					uint8	   *chunks = chunk_array_node_get_chunks(node);
+
+					Assert(idx >= 0);
+
+					/*
+					 * Make the space for the new key if it will be inserted in
+					 * the middle of the array.
+					 */
+					if (!will_replace && node->count != 0 && idx < node->count)
+					{
+						/* shift chunks array */
+						memmove(&(chunks[idx + 1]), &(chunks[idx]),
+								sizeof(uint8) * (node->count - idx));
+
+						/* shift either the values array or the children array */
+						if (IS_LEAF_NODE(node))
+						{
+							uint64	   *values = rt_node_get_values(node);
+
+							memmove(&(values[idx + 1]), &(values[idx]),
+									sizeof(uint64) * (node->count - idx));
+						}
+						else
+						{
+							rt_node   **children = rt_node_get_children(node);
+
+							memmove(&(children[idx + 1]), &(children[idx]),
+									sizeof(rt_node *) * (node->count - idx));
+						}
+					}
+
+					break;
+				}
+
+				Assert(node->kind == RT_NODE_KIND_128);
+			}
+			/* FALLTHROUGH */
+		case RT_NODE_KIND_128:
+			{
+				rt_node_base_128 *n128 = (rt_node_base_128 *) node;
+
+				if (node_128_is_chunk_used(n128, chunk) || NODE_HAS_FREE_SLOT(n128))
+				{
+					if (node_128_is_chunk_used(n128, chunk))
+						will_replace = true;
+
+					break;
+				}
+
+				node = rt_node_grow(tree, parent, node, key);
+			}
+			/* FALLTHROUGH */
+		case RT_NODE_KIND_256:
+			{
+				rt_node_base_256 *n256 = (rt_node_base_256 *) node;
+
+				if (node_256_is_chunk_used(n256, chunk))
+					will_replace = true;
+
+				break;
+			}
+	}
+
+	*node_p = node;
+	*will_replace_p = will_replace;
+
+	return idx;
+}
+
+/* Insert the child to the inner node */
+static void
+rt_node_insert_inner(radix_tree *tree, rt_node *parent, rt_node *node,
+					 uint64 key, rt_node *child, bool *replaced_p)
+{
+	uint8		chunk = RT_GET_KEY_CHUNK(key, node->shift);
+	int			idx;
+	bool		replaced;
+
+	Assert(!IS_LEAF_NODE(node));
+
+	idx = rt_node_prepare_insert(tree, parent, &node, key, &replaced);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				uint8	   *chunks = chunk_array_node_get_chunks(node);
+				rt_node   **children = rt_node_get_children(node);
+
+				Assert(idx >= 0);
+				chunks[idx] = chunk;
+				children[idx] = child;
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				node_128_set_inner((rt_node_base_128 *) node, chunk, child);
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				node_256_set_inner((rt_node_base_256 *) node, chunk, child);
+				break;
+			}
+	}
+
+	/* Update statistics */
+	if (!replaced)
+		node->count++;
+
+	if (replaced_p)
+		*replaced_p = replaced;
+
+	/*
+	 * Done. Finally, verify the chunk and value is inserted or replaced
+	 * properly in the node.
+	 */
+	rt_verify_node(node);
+}
+
+/* Insert the value to the leaf node */
+static void
+rt_node_insert_leaf(radix_tree *tree, rt_node *parent, rt_node *node,
+					uint64 key, uint64 value, bool *replaced_p)
+{
+	uint8		chunk = RT_GET_KEY_CHUNK(key, node->shift);
+	int			idx;
+	bool		replaced;
+
+	Assert(IS_LEAF_NODE(node));
+
+	idx = rt_node_prepare_insert(tree, parent, &node, key, &replaced);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				uint8	   *chunks = chunk_array_node_get_chunks(node);
+				uint64	   *values = rt_node_get_values(node);
+
+				Assert(idx >= 0);
+				chunks[idx] = chunk;
+				values[idx] = value;
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				node_128_set_leaf((rt_node_base_128 *) node, chunk, value);
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				node_256_set_leaf((rt_node_base_256 *) node, chunk, value);
+				break;
+			}
+	}
+
+	/* Update statistics */
+	if (!replaced)
+		node->count++;
+
+	*replaced_p = replaced;
+
+	/*
+	 * Done. Finally, verify if the chunk and value is inserted or replaced
+	 * properly in the node.
+	 */
+	rt_verify_node(node);
+}
+
+/* Change the node type to the next larger one */
+static rt_node *
+rt_node_grow(radix_tree *tree, rt_node *parent, rt_node *node, uint64 key)
+{
+	rt_node    *newnode = NULL;
+
+	Assert(node->count == rt_node_info[node->kind].fanout);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+			{
+				newnode = rt_alloc_node(tree, RT_NODE_KIND_16,
+										IS_LEAF_NODE(node));
+
+				/* Copy both chunks and slots to the new node */
+				chunk_array_node_copy_contents(node, newnode);
+				break;
+			}
+		case RT_NODE_KIND_16:
+			{
+				newnode = rt_alloc_node(tree, RT_NODE_KIND_32,
+										IS_LEAF_NODE(node));
+
+				/* Copy both chunks and slots to the new node */
+				chunk_array_node_copy_contents(node, newnode);
+				break;
+			}
+		case RT_NODE_KIND_32:
+			{
+				newnode = rt_alloc_node(tree, RT_NODE_KIND_128,
+										IS_LEAF_NODE(node));
+
+				/* Copy both chunks and slots to the new node */
+				rt_copy_node_common(node, newnode);
+
+				if (IS_LEAF_NODE(node))
+				{
+					rt_node_leaf_32 *n32 = (rt_node_leaf_32 *) node;
+
+					for (int i = 0; i < node->count; i++)
+						node_128_set_leaf((rt_node_base_128 *) newnode,
+										  n32->base.chunks[i], n32->values[i]);
+				}
+				else
+				{
+					rt_node_inner_32 *n32 = (rt_node_inner_32 *) node;
+
+					for (int i = 0; i < node->count; i++)
+						node_128_set_inner((rt_node_base_128 *) newnode,
+										   n32->base.chunks[i], n32->children[i]);
+				}
+
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_base_128 *n128 = (rt_node_base_128 *) node;
+				int			cnt = 0;
+
+				newnode = rt_alloc_node(tree, RT_NODE_KIND_256,
+										IS_LEAF_NODE(node));
+
+				/* Copy both chunks and slots to the new node */
+				rt_copy_node_common(node, newnode);
+
+				for (int i = 0; i < RT_NODE_MAX_SLOTS && cnt < n128->n.count; i++)
+				{
+					void	   *slot;
+
+					if (!node_128_is_chunk_used(n128, i))
+						continue;
+
+					slot = node_128_get_slot(n128, i);
+
+					if (IS_LEAF_NODE(node))
+						node_256_set_leaf((rt_node_base_256 *) newnode, i,
+										  *(uint64 *) slot);
+					else
+						node_256_set_inner((rt_node_base_256 *) newnode, i,
+										   (rt_node *) slot);
+
+					cnt++;
+				}
+
+				break;
+			}
+		case RT_NODE_KIND_256:
+			elog(ERROR, "radix tree node-256 cannot grow");
+			break;
+	}
+
+	if (parent == node)
+	{
+		/* Replace the root node with the new large node */
+		tree->root = newnode;
+	}
+	else
+	{
+		/* Set the new node to the parent node */
+		rt_node_insert_inner(tree, NULL, parent, key, newnode, NULL);
+	}
+
+	/* Verify if the node has grown properly */
+	rt_verify_node(newnode);
+
+	/* Free the old node */
+	rt_free_node(tree, node);
+
+	return newnode;
+}
+
+/*
+ * Create the radix tree in the given memory context and return it.
+ */
+radix_tree *
+rt_create(MemoryContext ctx)
+{
+	radix_tree *tree;
+	MemoryContext old_ctx;
+
+	old_ctx = MemoryContextSwitchTo(ctx);
+
+	tree = palloc(sizeof(radix_tree));
+	tree->context = ctx;
+	tree->root = NULL;
+	tree->max_val = 0;
+	tree->num_keys = 0;
+
+	/* Create the slab allocator for each size class */
+	for (int i = 0; i < RT_NODE_KIND_COUNT; i++)
+	{
+		tree->inner_slabs[i] = SlabContextCreate(ctx,
+												 rt_node_info[i].name,
+												 SLAB_DEFAULT_BLOCK_SIZE,
+												 rt_node_info[i].inner_size);
+		tree->leaf_slabs[i] = SlabContextCreate(ctx,
+												rt_node_info[i].name,
+												SLAB_DEFAULT_BLOCK_SIZE,
+												rt_node_info[i].leaf_size);
+#ifdef RT_DEBUG
+		tree->cnt[i] = 0;
+#endif
+	}
+
+	MemoryContextSwitchTo(old_ctx);
+
+	return tree;
+}
+
+/*
+ * Free the given radix tree.
+ */
+void
+rt_free(radix_tree *tree)
+{
+	for (int i = 0; i < RT_NODE_KIND_COUNT; i++)
+	{
+		MemoryContextDelete(tree->inner_slabs[i]);
+		MemoryContextDelete(tree->leaf_slabs[i]);
+	}
+
+	pfree(tree);
+}
+
+/*
+ * Set key to value. If the entry already exists, we update its value to 'value'
+ * and return true. Returns false if entry doesn't yet exist.
+ */
+bool
+rt_set(radix_tree *tree, uint64 key, uint64 value)
+{
+	int			shift;
+	bool		replaced;
+	rt_node    *node;
+	rt_node    *parent = tree->root;
+
+	/* Empty tree, create the root */
+	if (!tree->root)
+		rt_new_root(tree, key);
+
+	/* Extend the tree if necessary */
+	if (key > tree->max_val)
+		rt_extend(tree, key);
+
+	Assert(tree->root);
+
+	shift = tree->root->shift;
+	node = tree->root;
+
+	/* Descend the tree until a leaf node */
+	while (shift >= 0)
+	{
+		rt_node    *child;
+
+		if (IS_LEAF_NODE(node))
+			break;
+
+		if (!rt_node_search_inner(node, key, RT_ACTION_FIND, &child))
+			child = rt_node_add_new_child(tree, parent, node, key);
+
+		Assert(child);
+
+		parent = node;
+		node = child;
+		shift -= RT_NODE_SPAN;
+	}
+
+	/* arrived at a leaf */
+	Assert(IS_LEAF_NODE(node));
+
+	rt_node_insert_leaf(tree, parent, node, key, value, &replaced);
+
+	/* Update the statistics */
+	if (!replaced)
+		tree->num_keys++;
+
+	return replaced;
+}
+
+/*
+ * Search the given key in the radix tree. Return true if there is the key,
+ * otherwise return false.  On success, we set the value to *val_p so it must
+ * not be NULL.
+ */
+bool
+rt_search(radix_tree *tree, uint64 key, uint64 *value_p)
+{
+	rt_node    *node;
+	int			shift;
+
+	Assert(value_p != NULL);
+
+	if (!tree->root || key > tree->max_val)
+		return false;
+
+	node = tree->root;
+	shift = tree->root->shift;
+
+	/* Descend the tree until a leaf node */
+	while (shift >= 0)
+	{
+		rt_node    *child;
+
+		if (IS_LEAF_NODE(node))
+			break;
+
+		if (!rt_node_search_inner(node, key, RT_ACTION_FIND, &child))
+			return false;
+
+		node = child;
+		shift -= RT_NODE_SPAN;
+	}
+
+	/* We reached at a leaf node, so search the corresponding slot */
+	Assert(IS_LEAF_NODE(node));
+	if (!rt_node_search_leaf(node, key, RT_ACTION_FIND, value_p))
+		return false;
+
+	return true;
+}
+
+/*
+ * Delete the given key from the radix tree. Return true if the key is found (and
+ * deleted), otherwise do nothing and return false.
+ */
+bool
+rt_delete(radix_tree *tree, uint64 key)
+{
+	rt_node    *node;
+	int			shift;
+	rt_node    *stack[RT_MAX_LEVEL] = {0};
+	int			level;
+
+	if (!tree->root || key > tree->max_val)
+		return false;
+
+	/*
+	 * Descend the tree to search the key while building a stack of nodes
+	 * we visited.
+	 */
+	node = tree->root;
+	shift = tree->root->shift;
+	level = 0;
+	while (shift >= 0)
+	{
+		rt_node    *child;
+
+		/* Push the current node to the stack */
+		stack[level] = node;
+
+		if (IS_LEAF_NODE(node))
+			break;
+
+		if (!rt_node_search_inner(node, key, RT_ACTION_FIND, &child))
+			return false;
+
+		node = child;
+		shift -= RT_NODE_SPAN;
+		level++;
+	}
+
+	Assert(IS_LEAF_NODE(node));
+
+	/* there is no key to delete */
+	if (!rt_node_search_leaf(node, key, RT_ACTION_FIND, NULL))
+		return false;
+
+	/* Update the statistics */
+	tree->num_keys--;
+
+	/*
+	 * Delete the key from the leaf node and recursively delete the key in
+	 * inner nodes if necessary.
+	 */
+	Assert(IS_LEAF_NODE(stack[level]));
+	while (level >= 0)
+	{
+		rt_node    *node = stack[level--];
+
+		if (IS_LEAF_NODE(node))
+			rt_node_search_leaf(node, key, RT_ACTION_DELETE, NULL);
+		else
+			rt_node_search_inner(node, key, RT_ACTION_DELETE, NULL);
+
+		/* If the node didn't become empty, we stop deleting the key */
+		if (!IS_EMPTY_NODE(node))
+			break;
+
+		/* The node became empty */
+		rt_free_node(tree, node);
+	}
+
+	/*
+	 * If we eventually deleted the root node while recursively deleting empty
+	 * nodes, we make the tree empty.
+	 */
+	if (level == 0)
+	{
+		tree->root = NULL;
+		tree->max_val = 0;
+	}
+
+	return true;;
+}
+
+/* Create and return the iterator for the given radix tree */
+rt_iter *
+rt_begin_iterate(radix_tree *tree)
+{
+	MemoryContext old_ctx;
+	rt_iter    *iter;
+	int			top_level;
+
+	old_ctx = MemoryContextSwitchTo(tree->context);
+
+	iter = (rt_iter *) palloc0(sizeof(rt_iter));
+	iter->tree = tree;
+
+	/* empty tree */
+	if (!iter->tree)
+		return iter;
+
+	top_level = iter->tree->root->shift / RT_NODE_SPAN;
+
+	iter->stack_len = top_level;
+	iter->stack[top_level].node = iter->tree->root;
+	iter->stack[top_level].current_idx = -1;
+
+	/*
+	 * Descend to the left most leaf node from the root. The key is being
+	 * constructed while descending to the leaf.
+	 */
+	rt_update_iter_stack(iter, top_level);
+
+	MemoryContextSwitchTo(old_ctx);
+
+	return iter;
+}
+
+/*
+ * Update the stack of the radix tree node while descending to the leaf from
+ * the 'from' level.
+ */
+static void
+rt_update_iter_stack(rt_iter *iter, int from)
+{
+	rt_node    *node = iter->stack[from].node;
+	int			level = from;
+
+	for (;;)
+	{
+		rt_node_iter *node_iter = &(iter->stack[level--]);
+		bool		found;
+
+		/* Set the node to this level */
+		rt_update_node_iter(iter, node_iter, node);
+
+		/* Finish if we reached to the leaf node */
+		if (IS_LEAF_NODE(node))
+			break;
+
+		/* Advance to the next slot in the node */
+		node = (rt_node *) rt_node_iterate_next(iter, node_iter, &found);
+
+		/*
+		 * Since we always get the first slot in the node, we have to found
+		 * the slot.
+		 */
+		Assert(found);
+	}
+}
+
+/*
+ * Return true with setting key_p and value_p if there is next key.  Otherwise,
+ * return false.
+ */
+bool
+rt_iterate_next(rt_iter *iter, uint64 *key_p, uint64 *value_p)
+{
+	bool		found = false;
+	void	   *slot;
+
+	/* Empty tree */
+	if (!iter->tree)
+		return false;
+
+	for (;;)
+	{
+		rt_node    *node;
+		rt_node_iter *node_iter;
+		int			level;
+
+		/*
+		 * Iterate node at each level from the bottom of the tree, i.e., the
+		 * lead node, until we find the next slot.
+		 */
+		for (level = 0; level <= iter->stack_len; level++)
+		{
+			slot = rt_node_iterate_next(iter, &(iter->stack[level]), &found);
+
+			if (found)
+				break;
+		}
+
+		/* We could not find any new key-value pair, the iteration finished */
+		if (!found)
+			break;
+
+		/* found the next slot at the leaf node, return it */
+		if (level == 0)
+		{
+			*key_p = iter->key;
+			*value_p = *((uint64 *) slot);
+			break;
+		}
+
+		/*
+		 * We have advanced slots more than one nodes including both the lead
+		 * node and inner nodes. So we update the stack by descending to
+		 * the left most leaf node from this level.
+		 */
+		node = (rt_node *) (rt_node *) slot;
+		node_iter = &(iter->stack[level - 1]);
+		rt_update_node_iter(iter, node_iter, node);
+		rt_update_iter_stack(iter, level - 1);
+	}
+
+	return found;
+}
+
+void
+rt_end_iterate(rt_iter *iter)
+{
+	pfree(iter);
+}
+
+/*
+ * Iterate over the given radix tree node and returns the next slot of the given
+ * node and set true to *found_p, if any.  Otherwise, set false to *found_p.
+ */
+static void *
+rt_node_iterate_next(rt_iter *iter, rt_node_iter *node_iter, bool *found_p)
+{
+	rt_node    *node = node_iter->node;
+	void	   *slot = NULL;
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				node_iter->current_idx++;
+
+				if (node_iter->current_idx >= node->count)
+					goto not_found;
+
+				slot = chunk_array_node_get_slot(node, node_iter->current_idx);
+
+				/* Update the part of the key by the current chunk */
+				if (IS_LEAF_NODE(node))
+				{
+					uint8	   *chunks = chunk_array_node_get_chunks(node);
+
+					rt_iter_update_key(iter, chunks[node_iter->current_idx], 0);
+				}
+
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_base_128 *n128 = (rt_node_base_128 *) node;
+				int			i;
+
+				for (i = node_iter->current_idx + 1; i < 256; i++)
+				{
+					if (node_128_is_chunk_used(n128, i))
+						break;
+				}
+
+				if (i >= 256)
+					goto not_found;
+
+				node_iter->current_idx = i;
+				slot = node_128_get_slot(n128, i);
+
+				/* Update the part of the key */
+				if (IS_LEAF_NODE(n128))
+					rt_iter_update_key(iter, node_iter->current_idx, 0);
+
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				rt_node_base_256 *n256 = (rt_node_base_256 *) node;
+				int			i;
+
+				for (i = node_iter->current_idx + 1; i < 256; i++)
+				{
+					if (node_256_is_chunk_used(n256, i))
+						break;
+				}
+
+				if (i >= 256)
+					goto not_found;
+
+				node_iter->current_idx = i;
+				slot = node_256_get_slot(n256, i);
+
+				/* Update the part of the key */
+				if (IS_LEAF_NODE(n256))
+					rt_iter_update_key(iter, node_iter->current_idx, 0);
+
+				break;
+			}
+	}
+
+	Assert(slot);
+	*found_p = true;
+	return slot;
+
+not_found:
+	*found_p = false;
+	return NULL;
+}
+
+/*
+ * Set the node to the node_iter so we can begin the iteration of the node.
+ * Also, we update the part of the key by the chunk of the given node.
+ */
+static void
+rt_update_node_iter(rt_iter *iter, rt_node_iter *node_iter,
+					rt_node *node)
+{
+	node_iter->node = node;
+	node_iter->current_idx = -1;
+
+	rt_iter_update_key(iter, node->chunk, node->shift + RT_NODE_SPAN);
+}
+
+static pg_attribute_always_inline void
+rt_iter_update_key(rt_iter *iter, uint8 chunk, uint8 shift)
+{
+	iter->key &= ~(((uint64) RT_CHUNK_MASK) << shift);
+	iter->key |= (((uint64) chunk) << shift);
+}
+
+/*
+ * Return the number of keys in the radix tree.
+ */
+uint64
+rt_num_entries(radix_tree *tree)
+{
+	return tree->num_keys;
+}
+
+/*
+ * Return the statistics of the amount of memory used by the radix tree.
+ */
+uint64
+rt_memory_usage(radix_tree *tree)
+{
+	Size		total = 0;
+
+	for (int i = 0; i < RT_NODE_KIND_COUNT; i++)
+	{
+		total += MemoryContextMemAllocated(tree->inner_slabs[i], true);
+		total += MemoryContextMemAllocated(tree->leaf_slabs[i], true);
+	}
+
+	return total;
+}
+
+/*
+ * Verify the radix tree node.
+ */
+static void
+rt_verify_node(rt_node *node)
+{
+#ifdef USE_ASSERT_CHECKING
+	Assert(node->count >= 0);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				uint8	   *chunks = chunk_array_node_get_chunks(node);
+
+				/* Check if the chunks in the node are sorted */
+				for (int i = 1; i < node->count; i++)
+					Assert(chunks[i - 1] < chunks[i]);
+
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_base_128 *n128 = (rt_node_base_128 *) node;
+				int			cnt = 0;
+
+				for (int i = 0; i < RT_NODE_MAX_SLOTS; i++)
+				{
+					if (!node_128_is_chunk_used(n128, i))
+						continue;
+
+					/* Check if the corresponding slot is used */
+					Assert(node_128_is_slot_used(n128, n128->slot_idxs[i]));
+
+					cnt++;
+				}
+
+				Assert(n128->n.count == cnt);
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				rt_node_base_256 *n256 = (rt_node_base_256 *) node;
+				int			cnt = 0;
+
+				for (int i = 0; i < RT_NODE_NSLOTS_BITS(RT_NODE_MAX_SLOTS); i++)
+					cnt += pg_popcount32(n256->isset[i]);
+
+				/* Check if the number of used chunk matches */
+				Assert(n256->n.count == cnt);
+
+				break;
+			}
+	}
+#endif
+}
+
+/***************** DEBUG FUNCTIONS *****************/
+#ifdef RT_DEBUG
+void
+rt_stats(radix_tree *tree)
+{
+	fprintf(stderr, "num_keys = %lu, height = %u, n4 = %u, n16 = %u,n32 = %u, n128 = %u, n256 = %u",
+			tree->num_keys,
+			tree->root->shift / RT_NODE_SPAN,
+			tree->cnt[0],
+			tree->cnt[1],
+			tree->cnt[2],
+			tree->cnt[3],
+			tree->cnt[4]);
+	/* rt_dump(tree); */
+}
+
+static void
+rt_print_slot(StringInfo buf, uint8 chunk, uint64 value, int idx, bool is_leaf, int level)
+{
+	char		space[128] = {0};
+
+	if (level > 0)
+		sprintf(space, "%*c", level * 4, ' ');
+
+	if (is_leaf)
+		appendStringInfo(buf, "%s[%d] \"0x%X\" val(0x%lX) LEAF\n",
+						 space,
+						 idx,
+						 chunk,
+						 value);
+	else
+		appendStringInfo(buf, "%s[%d] \"0x%X\" -> ",
+						 space,
+						 idx,
+						 chunk);
+}
+
+static void
+rt_dump_node(rt_node *node, int level, StringInfo buf, bool recurse)
+{
+	bool		is_leaf = IS_LEAF_NODE(node);
+
+	appendStringInfo(buf, "[\"%s\" type %d, cnt %u, shift %u, chunk \"0x%X\"] chunks:\n",
+					 IS_LEAF_NODE(node) ? "LEAF" : "INNR",
+					 (node->kind == RT_NODE_KIND_4) ? 4 :
+					 (node->kind == RT_NODE_KIND_32) ? 32 :
+					 (node->kind == RT_NODE_KIND_128) ? 128 : 256,
+					 node->count, node->shift, node->chunk);
+
+	switch (node->kind)
+	{
+		case RT_NODE_KIND_4:
+		case RT_NODE_KIND_16:
+		case RT_NODE_KIND_32:
+			{
+				uint8	   *chunks = chunk_array_node_get_chunks(node);
+
+				for (int i = 0; i < node->count; i++)
+				{
+					if (IS_LEAF_NODE(node))
+					{
+						uint64	   *values = rt_node_get_values(node);
+
+						rt_print_slot(buf, chunks[i],
+									  values[i],
+									  i, is_leaf, level);
+					}
+					else
+						rt_print_slot(buf, chunks[i],
+									  UINT64_MAX,
+									  i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							rt_node   **children = rt_node_get_children(node);
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							rt_dump_node(children[i],
+										 level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+
+				break;
+			}
+		case RT_NODE_KIND_128:
+			{
+				rt_node_base_128 *n128 = (rt_node_base_128 *) node;
+				uint8	   *tmp = (uint8 *) n128->isset;
+
+				appendStringInfo(buf, "slot_idxs:");
+				for (int j = 0; j < 256; j++)
+				{
+					if (!node_128_is_chunk_used(n128, j))
+						continue;
+
+					appendStringInfo(buf, " [%d]=%d, ", j, n128->slot_idxs[j]);
+				}
+				appendStringInfo(buf, "\nisset-bitmap:");
+				for (int j = 0; j < 16; j++)
+				{
+					appendStringInfo(buf, "%X ", (uint8) tmp[j]);
+				}
+				appendStringInfo(buf, "\n");
+
+				for (int i = 0; i < 256; i++)
+				{
+					void	   *slot;
+
+					if (!node_128_is_chunk_used(n128, i))
+						continue;
+
+					slot = node_128_get_slot(n128, i);
+
+					if (is_leaf)
+						rt_print_slot(buf, i, *(uint64 *) slot,
+									  i, is_leaf, level);
+					else
+						rt_print_slot(buf, i, UINT64_MAX, i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							rt_dump_node((rt_node *) slot,
+										 level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+				break;
+			}
+		case RT_NODE_KIND_256:
+			{
+				rt_node_base_256 *n256 = (rt_node_base_256 *) node;
+
+				for (int i = 0; i < 256; i++)
+				{
+					void	   *slot;
+
+					if (!node_256_is_chunk_used(n256, i))
+						continue;
+
+					slot = node_256_get_slot(n256, i);
+
+					if (is_leaf)
+						rt_print_slot(buf, i, *(uint64 *) slot, i, is_leaf, level);
+					else
+						rt_print_slot(buf, i, UINT64_MAX, i, is_leaf, level);
+
+					if (!is_leaf)
+					{
+						if (recurse)
+						{
+							StringInfoData buf2;
+
+							initStringInfo(&buf2);
+							rt_dump_node((rt_node *) slot, level + 1, &buf2, recurse);
+							appendStringInfo(buf, "%s", buf2.data);
+						}
+						else
+							appendStringInfo(buf, "\n");
+					}
+				}
+				break;
+			}
+	}
+}
+
+void
+rt_dump_search(radix_tree *tree, uint64 key)
+{
+	StringInfoData buf;
+	rt_node    *node;
+	int			shift;
+	int			level = 0;
+
+	elog(NOTICE, "-----------------------------------------------------------");
+	elog(NOTICE, "max_val = %lu (0x%lX)", tree->max_val, tree->max_val);
+
+	if (!tree->root)
+	{
+		elog(NOTICE, "tree is empty");
+		return;
+	}
+
+	if (key > tree->max_val)
+	{
+		elog(NOTICE, "key %lu (0x%lX) is larger than max val",
+			 key, key);
+		return;
+	}
+
+	initStringInfo(&buf);
+	node = tree->root;
+	shift = tree->root->shift;
+	while (shift >= 0)
+	{
+		rt_node    *child;
+
+		rt_dump_node(node, level, &buf, false);
+
+		if (IS_LEAF_NODE(node))
+		{
+			uint64		dummy;
+
+			/* We reached at a leaf node, find the corresponding slot */
+			rt_node_search_leaf(node, key, RT_ACTION_FIND, &dummy);
+
+			break;
+		}
+
+		if (!rt_node_search_inner(node, key, RT_ACTION_FIND, &child))
+			break;
+
+		node = child;
+		shift -= RT_NODE_SPAN;
+		level++;
+	}
+
+	elog(NOTICE, "\n%s", buf.data);
+}
+
+void
+rt_dump(radix_tree *tree)
+{
+	StringInfoData buf;
+
+	initStringInfo(&buf);
+
+	elog(NOTICE, "-----------------------------------------------------------");
+	elog(NOTICE, "max_val = %lu", tree->max_val);
+	rt_dump_node(tree->root, 0, &buf, true);
+	elog(NOTICE, "\n%s", buf.data);
+	elog(NOTICE, "-----------------------------------------------------------");
+}
+#endif
diff --git a/src/include/lib/radixtree.h b/src/include/lib/radixtree.h
new file mode 100644
index 0000000000..38cc6abf4c
--- /dev/null
+++ b/src/include/lib/radixtree.h
@@ -0,0 +1,42 @@
+/*-------------------------------------------------------------------------
+ *
+ * radixtree.h
+ *	  Interface for radix tree.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		src/include/lib/radixtree.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RADIXTREE_H
+#define RADIXTREE_H
+
+#include "postgres.h"
+
+/* #define RT_DEBUG 1 */
+
+typedef struct radix_tree radix_tree;
+typedef struct rt_iter rt_iter;
+
+extern radix_tree *rt_create(MemoryContext ctx);
+extern void rt_free(radix_tree *tree);
+extern bool rt_search(radix_tree *tree, uint64 key, uint64 *val_p);
+extern bool rt_set(radix_tree *tree, uint64 key, uint64 val);
+extern rt_iter *rt_begin_iterate(radix_tree *tree);
+
+extern bool rt_iterate_next(rt_iter *iter, uint64 *key_p, uint64 *value_p);
+extern void rt_end_iterate(rt_iter *iter);
+extern bool rt_delete(radix_tree *tree, uint64 key);
+
+extern uint64 rt_memory_usage(radix_tree *tree);
+extern uint64 rt_num_entries(radix_tree *tree);
+
+#ifdef RT_DEBUG
+extern void rt_dump(radix_tree *tree);
+extern void rt_dump_search(radix_tree *tree, uint64 key);
+extern void rt_stats(radix_tree *tree);
+#endif
+
+#endif							/* RADIXTREE_H */
diff --git a/src/test/modules/Makefile b/src/test/modules/Makefile
index 6c31c8707c..8252ec41c4 100644
--- a/src/test/modules/Makefile
+++ b/src/test/modules/Makefile
@@ -25,6 +25,7 @@ SUBDIRS = \
 		  test_parser \
 		  test_pg_dump \
 		  test_predtest \
+		  test_radixtree \
 		  test_rbtree \
 		  test_regex \
 		  test_rls_hooks \
diff --git a/src/test/modules/test_radixtree/.gitignore b/src/test/modules/test_radixtree/.gitignore
new file mode 100644
index 0000000000..5dcb3ff972
--- /dev/null
+++ b/src/test/modules/test_radixtree/.gitignore
@@ -0,0 +1,4 @@
+# Generated subdirectories
+/log/
+/results/
+/tmp_check/
diff --git a/src/test/modules/test_radixtree/Makefile b/src/test/modules/test_radixtree/Makefile
new file mode 100644
index 0000000000..da06b93da3
--- /dev/null
+++ b/src/test/modules/test_radixtree/Makefile
@@ -0,0 +1,23 @@
+# src/test/modules/test_radixtree/Makefile
+
+MODULE_big = test_radixtree
+OBJS = \
+	$(WIN32RES) \
+	test_radixtree.o
+PGFILEDESC = "test_radixtree - test code for src/backend/lib/radixtree.c"
+
+EXTENSION = test_radixtree
+DATA = test_radixtree--1.0.sql
+
+REGRESS = test_radixtree
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = src/test/modules/test_radixtree
+top_builddir = ../../../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
diff --git a/src/test/modules/test_radixtree/README b/src/test/modules/test_radixtree/README
new file mode 100644
index 0000000000..a8b271869a
--- /dev/null
+++ b/src/test/modules/test_radixtree/README
@@ -0,0 +1,7 @@
+test_integerset contains unit tests for testing the integer set implementation
+in src/backend/lib/integerset.c.
+
+The tests verify the correctness of the implementation, but they can also be
+used as a micro-benchmark.  If you set the 'intset_test_stats' flag in
+test_integerset.c, the tests will print extra information about execution time
+and memory usage.
diff --git a/src/test/modules/test_radixtree/expected/test_radixtree.out b/src/test/modules/test_radixtree/expected/test_radixtree.out
new file mode 100644
index 0000000000..cc6970c87c
--- /dev/null
+++ b/src/test/modules/test_radixtree/expected/test_radixtree.out
@@ -0,0 +1,28 @@
+CREATE EXTENSION test_radixtree;
+--
+-- All the logic is in the test_radixtree() function. It will throw
+-- an error if something fails.
+--
+SELECT test_radixtree();
+NOTICE:  testing radix tree node types with shift "0"
+NOTICE:  testing radix tree node types with shift "8"
+NOTICE:  testing radix tree node types with shift "16"
+NOTICE:  testing radix tree node types with shift "24"
+NOTICE:  testing radix tree node types with shift "32"
+NOTICE:  testing radix tree node types with shift "40"
+NOTICE:  testing radix tree node types with shift "48"
+NOTICE:  testing radix tree node types with shift "56"
+NOTICE:  testing radix tree with pattern "all ones"
+NOTICE:  testing radix tree with pattern "alternating bits"
+NOTICE:  testing radix tree with pattern "clusters of ten"
+NOTICE:  testing radix tree with pattern "clusters of hundred"
+NOTICE:  testing radix tree with pattern "one-every-64k"
+NOTICE:  testing radix tree with pattern "sparse"
+NOTICE:  testing radix tree with pattern "single values, distance > 2^32"
+NOTICE:  testing radix tree with pattern "clusters, distance > 2^32"
+NOTICE:  testing radix tree with pattern "clusters, distance > 2^60"
+ test_radixtree 
+----------------
+ 
+(1 row)
+
diff --git a/src/test/modules/test_radixtree/sql/test_radixtree.sql b/src/test/modules/test_radixtree/sql/test_radixtree.sql
new file mode 100644
index 0000000000..41ece5e9f5
--- /dev/null
+++ b/src/test/modules/test_radixtree/sql/test_radixtree.sql
@@ -0,0 +1,7 @@
+CREATE EXTENSION test_radixtree;
+
+--
+-- All the logic is in the test_radixtree() function. It will throw
+-- an error if something fails.
+--
+SELECT test_radixtree();
diff --git a/src/test/modules/test_radixtree/test_radixtree--1.0.sql b/src/test/modules/test_radixtree/test_radixtree--1.0.sql
new file mode 100644
index 0000000000..074a5a7ea7
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree--1.0.sql
@@ -0,0 +1,8 @@
+/* src/test/modules/test_radixtree/test_radixtree--1.0.sql */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION test_radixtree" to load this file. \quit
+
+CREATE FUNCTION test_radixtree()
+RETURNS pg_catalog.void STRICT
+AS 'MODULE_PATHNAME' LANGUAGE C;
diff --git a/src/test/modules/test_radixtree/test_radixtree.c b/src/test/modules/test_radixtree/test_radixtree.c
new file mode 100644
index 0000000000..a4aa80a99c
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree.c
@@ -0,0 +1,504 @@
+/*--------------------------------------------------------------------------
+ *
+ * test_radixtree.c
+ *		Test radixtree set data structure.
+ *
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		src/test/modules/test_radixtree/test_radixtree.c
+ *
+ * -------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "common/pg_prng.h"
+#include "fmgr.h"
+#include "lib/radixtree.h"
+#include "miscadmin.h"
+#include "nodes/bitmapset.h"
+#include "storage/block.h"
+#include "storage/itemptr.h"
+#include "utils/memutils.h"
+#include "utils/timestamp.h"
+
+#define UINT64_HEX_FORMAT "%" INT64_MODIFIER "X"
+
+/*
+ * If you enable this, the "pattern" tests will print information about
+ * how long populating, probing, and iterating the test set takes, and
+ * how much memory the test set consumed.  That can be used as
+ * micro-benchmark of various operations and input patterns (you might
+ * want to increase the number of values used in each of the test, if
+ * you do that, to reduce noise).
+ *
+ * The information is printed to the server's stderr, mostly because
+ * that's where MemoryContextStats() output goes.
+ */
+static const bool rt_test_stats = false;
+
+/* The maximum number of entries each node type can have */
+static int rt_node_max_entries[] = {
+	4,		/* RT_NODE_KIND_4 */
+	16,		/* RT_NODE_KIND_16 */
+	32,		/* RT_NODE_KIND_32 */
+	128,	/* RT_NODE_KIND_128 */
+	256		/* RT_NODE_KIND_256 */
+};
+
+/*
+ * A struct to define a pattern of integers, for use with the test_pattern()
+ * function.
+ */
+typedef struct
+{
+	char	   *test_name;		/* short name of the test, for humans */
+	char	   *pattern_str;	/* a bit pattern */
+	uint64		spacing;		/* pattern repeats at this interval */
+	uint64		num_values;		/* number of integers to set in total */
+} test_spec;
+
+/* Test patterns borrowed from test_integerset.c */
+static const test_spec test_specs[] = {
+	{
+		"all ones", "1111111111",
+		10, 1000000
+	},
+	{
+		"alternating bits", "0101010101",
+		10, 1000000
+	},
+	{
+		"clusters of ten", "1111111111",
+		10000, 1000000
+	},
+	{
+		"clusters of hundred",
+		"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111",
+		10000, 10000000
+	},
+	{
+		"one-every-64k", "1",
+		65536, 1000000
+	},
+	{
+		"sparse", "100000000000000000000000000000001",
+		10000000, 1000000
+	},
+	{
+		"single values, distance > 2^32", "1",
+		UINT64CONST(10000000000), 100000
+	},
+	{
+		"clusters, distance > 2^32", "10101010",
+		UINT64CONST(10000000000), 1000000
+	},
+	{
+		"clusters, distance > 2^60", "10101010",
+		UINT64CONST(2000000000000000000),
+		23						/* can't be much higher than this, or we
+								 * overflow uint64 */
+	}
+};
+
+PG_MODULE_MAGIC;
+
+PG_FUNCTION_INFO_V1(test_radixtree);
+
+static void
+test_empty(void)
+{
+	radix_tree *radixtree;
+	uint64 dummy;
+
+	radixtree = rt_create(CurrentMemoryContext);
+
+	if (rt_search(radixtree, 0, &dummy))
+		elog(ERROR, "rt_search on empty tree returned true");
+
+	if (rt_search(radixtree, 1, &dummy))
+		elog(ERROR, "rt_search on empty tree returned true");
+
+	if (rt_search(radixtree, PG_UINT64_MAX, &dummy))
+		elog(ERROR, "rt_search on empty tree returned true");
+
+	if (rt_num_entries(radixtree) != 0)
+		elog(ERROR, "rt_num_entries on empty tree return non-zero");
+
+	rt_free(radixtree);
+}
+
+/*
+ * Check if keys from start to end with the shift exist in the tree.
+ */
+static void
+check_search_on_node(radix_tree *radixtree, uint8 shift, int start, int end)
+{
+	for (int i = start; i < end; i++)
+	{
+		uint64 key = ((uint64) i << shift);
+		uint64 val;
+
+		if (!rt_search(radixtree, key, &val))
+			elog(ERROR, "key 0x" UINT64_HEX_FORMAT " is not found on node-%d",
+				 key, end);
+		if (val != key)
+			elog(ERROR, "rt_search with key 0x" UINT64_HEX_FORMAT " returns 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT,
+				 key, val, key);
+	}
+}
+
+static void
+test_node_types_insert(radix_tree *radixtree, uint8 shift)
+{
+	uint64 num_entries;
+
+	for (int i = 0; i < 256; i++)
+	{
+		uint64 key = ((uint64) i << shift);
+		bool found;
+
+		found = rt_set(radixtree, key, key);
+
+		if (found)
+			elog(ERROR, "newly inserted key 0x" UINT64_HEX_FORMAT " found", key);
+
+		for (int j = 0; j < lengthof(rt_node_max_entries); j++)
+		{
+			/*
+			 * After filling all slots in each node type, check if the values are
+			 * stored properly.
+			 */
+			if (i == (rt_node_max_entries[j] - 1))
+			{
+				check_search_on_node(radixtree, shift,
+									 (j == 0) ? 0 : rt_node_max_entries[j - 1],
+									 rt_node_max_entries[j]);
+				break;
+			}
+		}
+	}
+
+	num_entries = rt_num_entries(radixtree);
+
+	if (num_entries != 256)
+		elog(ERROR,
+			 "rt_num_entries returned" UINT64_FORMAT ", expected " UINT64_FORMAT,
+			 num_entries, UINT64CONST(256));
+}
+
+static void
+test_node_types_delete(radix_tree *radixtree, uint8 shift)
+{
+	uint64 num_entries;
+
+	for (int i = 0; i < 256; i++)
+	{
+		uint64	key = ((uint64) i << shift);
+		bool	found;
+
+		found = rt_delete(radixtree, key);
+
+		if (!found)
+			elog(ERROR, "inserted key 0x" UINT64_HEX_FORMAT " is not found", key);
+	}
+
+	num_entries = rt_num_entries(radixtree);
+
+	/* The tree must be empty */
+	if (num_entries != 0)
+		elog(ERROR,
+			 "rt_num_entries returned" UINT64_FORMAT ", expected " UINT64_FORMAT,
+			 num_entries, UINT64CONST(256));
+}
+
+/*
+ * Test for inserting and deleting key-value pairs to each node type at the given shift
+ * level.
+ */
+static void
+test_node_types(uint8 shift)
+{
+	radix_tree *radixtree;
+
+	elog(NOTICE, "testing radix tree node types with shift \"%d\"", shift);
+
+	radixtree = rt_create(CurrentMemoryContext);
+
+	/*
+	 * Insert and search entries for every node type at the 'shift' level,
+	 * then delete all entries to make it empty, and insert and search
+	 * entries again.
+	 */
+	test_node_types_insert(radixtree, shift);
+	test_node_types_delete(radixtree, shift);
+	test_node_types_insert(radixtree, shift);
+
+	rt_free(radixtree);
+}
+
+/*
+ * Test with a repeating pattern, defined by the 'spec'.
+ */
+static void
+test_pattern(const test_spec *spec)
+{
+	radix_tree *radixtree;
+	rt_iter *iter;
+	MemoryContext radixtree_ctx;
+	TimestampTz starttime;
+	TimestampTz endtime;
+	uint64		n;
+	uint64		last_int;
+	uint64		ndeleted;
+	uint64		nbefore;
+	uint64		nafter;
+	int			patternlen;
+	uint64	   *pattern_values;
+	uint64		pattern_num_values;
+
+	elog(NOTICE, "testing radix tree with pattern \"%s\"", spec->test_name);
+	if (rt_test_stats)
+		fprintf(stderr, "-----\ntesting radix tree with pattern \"%s\"\n", spec->test_name);
+
+	/* Pre-process the pattern, creating an array of integers from it. */
+	patternlen = strlen(spec->pattern_str);
+	pattern_values = palloc(patternlen * sizeof(uint64));
+	pattern_num_values = 0;
+	for (int i = 0; i < patternlen; i++)
+	{
+		if (spec->pattern_str[i] == '1')
+			pattern_values[pattern_num_values++] = i;
+	}
+
+	/*
+	 * Allocate the radix tree.
+	 *
+	 * Allocate it in a separate memory context, so that we can print its
+	 * memory usage easily.
+	 */
+	radixtree_ctx = AllocSetContextCreate(CurrentMemoryContext,
+										  "radixtree test",
+										  ALLOCSET_SMALL_SIZES);
+	MemoryContextSetIdentifier(radixtree_ctx, spec->test_name);
+	radixtree = rt_create(radixtree_ctx);
+
+	/*
+	 * Add values to the set.
+	 */
+	starttime = GetCurrentTimestamp();
+
+	n = 0;
+	last_int = 0;
+	while (n < spec->num_values)
+	{
+		uint64		x = 0;
+
+		for (int i = 0; i < pattern_num_values && n < spec->num_values; i++)
+		{
+			bool found;
+
+			x = last_int + pattern_values[i];
+
+			found = rt_set(radixtree, x, x);
+
+			if (found)
+				elog(ERROR, "newly inserted key 0x" UINT64_HEX_FORMAT " found", x);
+
+			n++;
+		}
+		last_int += spec->spacing;
+	}
+
+	endtime = GetCurrentTimestamp();
+
+	if (rt_test_stats)
+		fprintf(stderr, "added " UINT64_FORMAT " values in %d ms\n",
+				spec->num_values, (int) (endtime - starttime) / 1000);
+
+	/*
+	 * Print stats on the amount of memory used.
+	 *
+	 * We print the usage reported by rt_memory_usage(), as well as the
+	 * stats from the memory context.  They should be in the same ballpark,
+	 * but it's hard to automate testing that, so if you're making changes to
+	 * the implementation, just observe that manually.
+	 */
+	if (rt_test_stats)
+	{
+		uint64		mem_usage;
+
+		/*
+		 * Also print memory usage as reported by rt_memory_usage().  It
+		 * should be in the same ballpark as the usage reported by
+		 * MemoryContextStats().
+		 */
+		mem_usage = rt_memory_usage(radixtree);
+		fprintf(stderr, "rt_memory_usage() reported " UINT64_FORMAT " (%0.2f bytes / integer)\n",
+				mem_usage, (double) mem_usage / spec->num_values);
+
+		MemoryContextStats(radixtree_ctx);
+	}
+
+	/* Check that rt_num_entries works */
+	n = rt_num_entries(radixtree);
+	if (n != spec->num_values)
+		elog(ERROR, "rt_num_entries returned " UINT64_FORMAT ", expected " UINT64_FORMAT, n, spec->num_values);
+
+	/*
+	 * Test random-access probes with rt_search()
+	 */
+	starttime = GetCurrentTimestamp();
+
+	for (n = 0; n < 100000; n++)
+	{
+		bool		found;
+		bool		expected;
+		uint64		x;
+		uint64		v;
+
+		/*
+		 * Pick next value to probe at random.  We limit the probes to the
+		 * last integer that we added to the set, plus an arbitrary constant
+		 * (1000).  There's no point in probing the whole 0 - 2^64 range, if
+		 * only a small part of the integer space is used.  We would very
+		 * rarely hit values that are actually in the set.
+		 */
+		x = pg_prng_uint64_range(&pg_global_prng_state, 0, last_int + 1000);
+
+		/* Do we expect this value to be present in the set? */
+		if (x >= last_int)
+			expected = false;
+		else
+		{
+			uint64		idx = x % spec->spacing;
+
+			if (idx >= patternlen)
+				expected = false;
+			else if (spec->pattern_str[idx] == '1')
+				expected = true;
+			else
+				expected = false;
+		}
+
+		/* Is it present according to rt_search() ? */
+		found = rt_search(radixtree, x, &v);
+
+		if (found != expected)
+			elog(ERROR, "mismatch at 0x" UINT64_HEX_FORMAT ": %d vs %d", x, found, expected);
+		if (found && (v != x))
+			elog(ERROR, "found 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT,
+				 v, x);
+	}
+	endtime = GetCurrentTimestamp();
+	if (rt_test_stats)
+		fprintf(stderr, "probed " UINT64_FORMAT " values in %d ms\n",
+				n, (int) (endtime - starttime) / 1000);
+
+	/*
+	 * Test iterator
+	 */
+	starttime = GetCurrentTimestamp();
+
+	iter = rt_begin_iterate(radixtree);
+	n = 0;
+	last_int = 0;
+	while (n < spec->num_values)
+	{
+		for (int i = 0; i < pattern_num_values && n < spec->num_values; i++)
+		{
+			uint64		expected = last_int + pattern_values[i];
+			uint64		x;
+			uint64		val;
+
+			if (!rt_iterate_next(iter, &x, &val))
+				break;
+
+			if (x != expected)
+				elog(ERROR,
+					 "iterate returned wrong key; got 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT " at %d",
+					 x, expected, i);
+			if (val != expected)
+				elog(ERROR,
+					 "iterate returned wrong value; got 0x" UINT64_HEX_FORMAT ", expected 0x" UINT64_HEX_FORMAT " at %d", x, expected, i);
+			n++;
+		}
+		last_int += spec->spacing;
+	}
+	endtime = GetCurrentTimestamp();
+	if (rt_test_stats)
+		fprintf(stderr, "iterated " UINT64_FORMAT " values in %d ms\n",
+				n, (int) (endtime - starttime) / 1000);
+
+	if (n < spec->num_values)
+		elog(ERROR, "iterator stopped short after " UINT64_FORMAT " entries, expected " UINT64_FORMAT, n, spec->num_values);
+	if (n > spec->num_values)
+		elog(ERROR, "iterator returned " UINT64_FORMAT " entries, " UINT64_FORMAT " was expected", n, spec->num_values);
+
+	/*
+	 * Test random-access probes with rt_delete()
+	 */
+	starttime = GetCurrentTimestamp();
+
+	nbefore = rt_num_entries(radixtree);
+	ndeleted = 0;
+	for (n = 0; n < 100000; n++)
+	{
+		bool		found;
+		uint64		x;
+		uint64		v;
+
+		/*
+		 * Pick next value to probe at random.  We limit the probes to the
+		 * last integer that we added to the set, plus an arbitrary constant
+		 * (1000).  There's no point in probing the whole 0 - 2^64 range, if
+		 * only a small part of the integer space is used.  We would very
+		 * rarely hit values that are actually in the set.
+		 */
+		x = pg_prng_uint64_range(&pg_global_prng_state, 0, last_int + 1000);
+
+		/* Is it present according to rt_search() ? */
+		found = rt_search(radixtree, x, &v);
+
+		if (!found)
+			continue;
+
+		/* If the key is found, delete it and check again */
+		if (!rt_delete(radixtree, x))
+			elog(ERROR, "could not delete key 0x" UINT64_HEX_FORMAT, x);
+		if (rt_search(radixtree, x, &v))
+			elog(ERROR, "found deleted key 0x" UINT64_HEX_FORMAT, x);
+		if (rt_delete(radixtree, x))
+			elog(ERROR, "deleted already-deleted key 0x" UINT64_HEX_FORMAT, x);
+
+		ndeleted++;
+	}
+	endtime = GetCurrentTimestamp();
+	if (rt_test_stats)
+		fprintf(stderr, "deleted " UINT64_FORMAT " values in %d ms\n",
+				ndeleted, (int) (endtime - starttime) / 1000);
+
+	nafter = rt_num_entries(radixtree);
+
+	/* Check that rt_num_entries works */
+	if ((nbefore - ndeleted) != nafter)
+		elog(ERROR, "rt_num_entries returned " UINT64_FORMAT ", expected " UINT64_FORMAT "after " UINT64_FORMAT " deletion",
+			 nafter, (nbefore - ndeleted), ndeleted);
+
+	MemoryContextDelete(radixtree_ctx);
+}
+
+Datum
+test_radixtree(PG_FUNCTION_ARGS)
+{
+	test_empty();
+
+	for (int shift = 0; shift <= (64 - 8); shift += 8)
+		test_node_types(shift);
+
+	/* Test different test patterns, with lots of entries */
+	for (int i = 0; i < lengthof(test_specs); i++)
+		test_pattern(&test_specs[i]);
+
+	PG_RETURN_VOID();
+}
diff --git a/src/test/modules/test_radixtree/test_radixtree.control b/src/test/modules/test_radixtree/test_radixtree.control
new file mode 100644
index 0000000000..e53f2a3e0c
--- /dev/null
+++ b/src/test/modules/test_radixtree/test_radixtree.control
@@ -0,0 +1,4 @@
+comment = 'Test code for radix tree'
+default_version = '1.0'
+module_pathname = '$libdir/test_radixtree'
+relocatable = true
-- 
2.31.1

From 39f0019d95eb4808d235a07d107aee2ff46856e2 Mon Sep 17 00:00:00 2001
From: Masahiko Sawada <sawada.mshk@gmail.com>
Date: Fri, 16 Sep 2022 11:57:03 +0900
Subject: [PATCH v6 3/3] tool for measuring radix tree performance

---
 contrib/bench_radix_tree/Makefile             |  21 ++
 .../bench_radix_tree--1.0.sql                 |  42 +++
 contrib/bench_radix_tree/bench_radix_tree.c   | 301 ++++++++++++++++++
 .../bench_radix_tree/bench_radix_tree.control |   6 +
 contrib/bench_radix_tree/expected/bench.out   |  13 +
 contrib/bench_radix_tree/sql/bench.sql        |  16 +
 6 files changed, 399 insertions(+)
 create mode 100644 contrib/bench_radix_tree/Makefile
 create mode 100644 contrib/bench_radix_tree/bench_radix_tree--1.0.sql
 create mode 100644 contrib/bench_radix_tree/bench_radix_tree.c
 create mode 100644 contrib/bench_radix_tree/bench_radix_tree.control
 create mode 100644 contrib/bench_radix_tree/expected/bench.out
 create mode 100644 contrib/bench_radix_tree/sql/bench.sql

diff --git a/contrib/bench_radix_tree/Makefile b/contrib/bench_radix_tree/Makefile
new file mode 100644
index 0000000000..b8f70e12d1
--- /dev/null
+++ b/contrib/bench_radix_tree/Makefile
@@ -0,0 +1,21 @@
+# contrib/bench_radix_tree/Makefile
+
+MODULE_big = bench_radix_tree
+OBJS = \
+	bench_radix_tree.o
+
+EXTENSION = bench_radix_tree
+DATA = bench_radix_tree--1.0.sql
+
+REGRESS = bench
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = contrib/bench_radix_tree
+top_builddir = ../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
diff --git a/contrib/bench_radix_tree/bench_radix_tree--1.0.sql b/contrib/bench_radix_tree/bench_radix_tree--1.0.sql
new file mode 100644
index 0000000000..6663abe6a4
--- /dev/null
+++ b/contrib/bench_radix_tree/bench_radix_tree--1.0.sql
@@ -0,0 +1,42 @@
+/* contrib/bench_radix_tree/bench_radix_tree--1.0.sql */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION bench_radix_tree" to load this file. \quit
+
+create function bench_shuffle_search(
+minblk int4,
+maxblk int4,
+OUT nkeys int8,
+OUT rt_mem_allocated int8,
+OUT array_mem_allocated int8,
+OUT rt_load_ms int8,
+OUT array_load_ms int8,
+OUT rt_search_ms int8,
+OUT array_serach_ms int8
+)
+returns record
+as 'MODULE_PATHNAME'
+LANGUAGE C STRICT VOLATILE PARALLEL UNSAFE;
+
+create function bench_seq_search(
+minblk int4,
+maxblk int4,
+OUT nkeys int8,
+OUT rt_mem_allocated int8,
+OUT array_mem_allocated int8,
+OUT rt_load_ms int8,
+OUT array_load_ms int8,
+OUT rt_search_ms int8,
+OUT array_serach_ms int8
+)
+returns record
+as 'MODULE_PATHNAME'
+LANGUAGE C STRICT VOLATILE PARALLEL UNSAFE;
+
+create function bench_load_random_int(
+cnt int8,
+OUT mem_allocated int8,
+OUT load_ms int8)
+returns record
+as 'MODULE_PATHNAME'
+LANGUAGE C STRICT VOLATILE PARALLEL UNSAFE;
diff --git a/contrib/bench_radix_tree/bench_radix_tree.c b/contrib/bench_radix_tree/bench_radix_tree.c
new file mode 100644
index 0000000000..5806ef7519
--- /dev/null
+++ b/contrib/bench_radix_tree/bench_radix_tree.c
@@ -0,0 +1,301 @@
+/*-------------------------------------------------------------------------
+ *
+ * bench_radix_tree.c
+ *
+ * Copyright (c) 2016-2022, PostgreSQL Global Development Group
+ *
+ *	  contrib/bench_radix_tree/bench_radix_tree.c
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "common/pg_prng.h"
+#include "fmgr.h"
+#include "funcapi.h"
+#include "lib/radixtree.h"
+#include "miscadmin.h"
+#include "utils/timestamp.h"
+
+PG_MODULE_MAGIC;
+
+#define TIDS_PER_BLOCK_FOR_LOAD		30
+#define TIDS_PER_BLOCK_FOR_LOOKUP	50
+
+PG_FUNCTION_INFO_V1(bench_seq_search);
+PG_FUNCTION_INFO_V1(bench_shuffle_search);
+PG_FUNCTION_INFO_V1(bench_load_random_int);
+
+static radix_tree *rt = NULL;
+static ItemPointer itemptrs = NULL;
+
+static uint64
+tid_to_key_off(ItemPointer tid, uint32 *off)
+{
+	uint32 upper;
+	uint32 shift = pg_ceil_log2_32(MaxHeapTuplesPerPage);
+	int64 tid_i;
+
+	Assert(ItemPointerGetOffsetNumber(tid) < MaxHeapTuplesPerPage);
+
+	tid_i = ItemPointerGetOffsetNumber(tid);
+	tid_i |= ItemPointerGetBlockNumber(tid) << shift;
+
+	/* log(sizeof(uint64) * BITS_PER_BYTE, 2) = log(64, 2) = 6 */
+	*off = tid_i & ((1 << 6) - 1);
+	upper = tid_i >> 6;
+	Assert(*off < (sizeof(uint64) * BITS_PER_BYTE));
+
+	Assert(*off < 64);
+
+	return upper;
+}
+
+static int
+shuffle_randrange(pg_prng_state *state, int lower, int upper)
+{
+	return (int) floor(pg_prng_double(state) * ((upper-lower)+0.999999)) + lower;
+}
+
+/* Naive Fisher-Yates implementation*/
+static void
+shuffle_itemptrs(ItemPointer itemptr, uint64 nitems)
+{
+	/* reproducability */
+	pg_prng_state state;
+
+	pg_prng_seed(&state, 0);
+
+	for (int i = 0; i < nitems - 1; i++)
+	{
+		int j = shuffle_randrange(&state, i, nitems - 1);
+		ItemPointerData t = itemptrs[j];
+
+		itemptrs[j] = itemptrs[i];
+		itemptrs[i] = t;
+	}
+}
+
+static ItemPointer
+generate_tids(BlockNumber minblk, BlockNumber maxblk, int ntids_per_blk, uint64 *ntids_p)
+{
+	ItemPointer	tids;
+	uint64	maxitems;
+	uint64	ntids = 0;
+
+	maxitems = (maxblk - minblk + 1) * ntids_per_blk;
+	tids = MemoryContextAllocHuge(TopTransactionContext,
+								  sizeof(ItemPointerData) * maxitems);
+
+	for (BlockNumber blk = minblk; blk < maxblk; blk++)
+	{
+		for (OffsetNumber off = FirstOffsetNumber;
+			 off <= ntids_per_blk; off++)
+		{
+			CHECK_FOR_INTERRUPTS();
+
+			ItemPointerSetBlockNumber(&(tids[ntids]), blk);
+			ItemPointerSetOffsetNumber(&(tids[ntids]), off);
+
+			ntids++;
+		}
+	}
+
+	*ntids_p = ntids;
+	return tids;
+}
+
+static int
+vac_cmp_itemptr(const void *left, const void *right)
+{
+	BlockNumber lblk,
+				rblk;
+	OffsetNumber loff,
+				roff;
+
+	lblk = ItemPointerGetBlockNumber((ItemPointer) left);
+	rblk = ItemPointerGetBlockNumber((ItemPointer) right);
+
+	if (lblk < rblk)
+		return -1;
+	if (lblk > rblk)
+		return 1;
+
+	loff = ItemPointerGetOffsetNumber((ItemPointer) left);
+	roff = ItemPointerGetOffsetNumber((ItemPointer) right);
+
+	if (loff < roff)
+		return -1;
+	if (loff > roff)
+		return 1;
+
+	return 0;
+}
+
+static Datum
+bench_search(FunctionCallInfo fcinfo, bool shuffle)
+{
+	BlockNumber minblk = PG_GETARG_INT32(0);
+	BlockNumber maxblk = PG_GETARG_INT32(1);
+	uint64	ntids;
+	uint64	key;
+	uint64	last_key = PG_UINT64_MAX;;
+	uint64	val = 0;
+	ItemPointer tids;
+	TupleDesc	tupdesc;
+	TimestampTz	start_time,	end_time;
+	long	secs;
+	int		usecs;
+	int64	rt_load_ms, rt_search_ms, ar_load_ms, ar_search_ms;
+	Datum	values[7];
+	bool	nulls[7];
+
+	/* Build a tuple descriptor for our result type */
+	if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
+		elog(ERROR, "return type must be a row type");
+
+	tids = generate_tids(minblk, maxblk, TIDS_PER_BLOCK_FOR_LOAD, &ntids);
+
+	/* measure the load time of the radix tree */
+	rt = rt_create(CurrentMemoryContext);
+	start_time = GetCurrentTimestamp();
+	for (int i = 0; i < ntids; i++)
+	{
+		ItemPointer tid = &(tids[i]);
+		uint32	off;
+
+		CHECK_FOR_INTERRUPTS();
+
+		key = tid_to_key_off(tid, &off);
+
+		if (last_key != PG_UINT64_MAX && last_key != key)
+		{
+			rt_set(rt, last_key, val);
+			val = 0;
+		}
+
+		last_key = key;
+		val |= (uint64) 1 << off;
+	}
+	if (last_key != PG_UINT64_MAX)
+		rt_set(rt, last_key, val);
+
+	end_time = GetCurrentTimestamp();
+	TimestampDifference(start_time, end_time, &secs, &usecs);
+	rt_load_ms = secs * 1000 + usecs / 1000;
+
+	/* measure the load time of the array */
+	itemptrs = MemoryContextAllocHuge(CurrentMemoryContext,
+									  sizeof(ItemPointerData) * ntids);
+	start_time = GetCurrentTimestamp();
+	for (int i = 0; i < ntids; i++)
+	{
+		ItemPointerSetBlockNumber(&(itemptrs[i]),
+								  ItemPointerGetBlockNumber(&(tids[i])));
+		ItemPointerSetOffsetNumber(&(itemptrs[i]),
+								   ItemPointerGetOffsetNumber(&(tids[i])));
+	}
+	end_time = GetCurrentTimestamp();
+	TimestampDifference(start_time, end_time, &secs, &usecs);
+	ar_load_ms = secs * 1000 + usecs / 1000;
+
+	if (shuffle)
+		shuffle_itemptrs(tids, ntids);
+
+	/* meaure the serach time of the radix tree */
+	start_time = GetCurrentTimestamp();
+	for (int i = 0; i < ntids; i++)
+	{
+		ItemPointer tid = &(tids[i]);
+		uint64	key, val;
+		uint32	off;
+
+		CHECK_FOR_INTERRUPTS();
+
+		key = tid_to_key_off(tid, &off);
+
+		rt_search(rt, key, &val);
+	}
+	end_time = GetCurrentTimestamp();
+	TimestampDifference(start_time, end_time, &secs, &usecs);
+	rt_search_ms = secs * 1000 + usecs / 1000;
+
+	/* next, measure the serach time of the array */
+	start_time = GetCurrentTimestamp();
+	for (int i = 0; i < ntids; i++)
+	{
+		ItemPointer tid = &(tids[i]);
+
+		bsearch((void *) tid,
+				(void *) itemptrs,
+				ntids,
+				sizeof(ItemPointerData),
+				vac_cmp_itemptr);
+	}
+	end_time = GetCurrentTimestamp();
+	TimestampDifference(start_time, end_time, &secs, &usecs);
+	ar_search_ms = secs * 1000 + usecs / 1000;
+
+	MemSet(nulls, false, sizeof(nulls));
+	values[0] = Int64GetDatum(rt_num_entries(rt));
+	values[1] = Int64GetDatum(rt_memory_usage(rt));
+	values[2] = Int64GetDatum(sizeof(ItemPointerData) * ntids);
+	values[3] = Int64GetDatum(rt_load_ms);
+	values[4] = Int64GetDatum(ar_load_ms);
+	values[5] = Int64GetDatum(rt_search_ms);
+	values[6] = Int64GetDatum(ar_search_ms);
+
+	PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
+}
+
+Datum
+bench_seq_search(PG_FUNCTION_ARGS)
+{
+	return bench_search(fcinfo, false);
+}
+
+Datum
+bench_shuffle_search(PG_FUNCTION_ARGS)
+{
+	return bench_search(fcinfo, true);
+}
+
+Datum
+bench_load_random_int(PG_FUNCTION_ARGS)
+{
+	uint64	cnt = (uint64) PG_GETARG_INT64(0);
+	radix_tree *rt;
+	pg_prng_state state;
+	TupleDesc	tupdesc;
+	TimestampTz	start_time,	end_time;
+	long	secs;
+	int		usecs;
+	int64	load_time_ms;
+	Datum	values[2];
+	bool	nulls[2];
+
+	/* Build a tuple descriptor for our result type */
+	if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
+		elog(ERROR, "return type must be a row type");
+
+	pg_prng_seed(&state, 0);
+	rt = rt_create(CurrentMemoryContext);
+
+	start_time = GetCurrentTimestamp();
+	for (uint64 i = 0; i < cnt; i++)
+	{
+		uint64 key = pg_prng_uint64(&state);
+
+		rt_set(rt, key, key);
+	}
+	end_time = GetCurrentTimestamp();
+
+	TimestampDifference(start_time, end_time, &secs, &usecs);
+	load_time_ms = secs * 1000 + usecs / 1000;
+
+	MemSet(nulls, false, sizeof(nulls));
+	values[0] = Int64GetDatum(rt_memory_usage(rt));
+	values[1] = Int64GetDatum(load_time_ms);
+
+	rt_free(rt);
+	PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
+}
diff --git a/contrib/bench_radix_tree/bench_radix_tree.control b/contrib/bench_radix_tree/bench_radix_tree.control
new file mode 100644
index 0000000000..1d988e6c9a
--- /dev/null
+++ b/contrib/bench_radix_tree/bench_radix_tree.control
@@ -0,0 +1,6 @@
+# bench_radix_tree extension
+comment = 'benchmark suits for radix tree'
+default_version = '1.0'
+module_pathname = '$libdir/bench_radix_tree'
+relocatable = true
+trusted = true
diff --git a/contrib/bench_radix_tree/expected/bench.out b/contrib/bench_radix_tree/expected/bench.out
new file mode 100644
index 0000000000..60c303892e
--- /dev/null
+++ b/contrib/bench_radix_tree/expected/bench.out
@@ -0,0 +1,13 @@
+create extension bench_radix_tree;
+\o seq_search.data
+begin;
+select * from bench_seq_search(0, 1000000);
+commit;
+\o shuffle_search.data
+begin;
+select * from bench_shuffle_search(0, 1000000);
+commit;
+\o random_load.data
+begin;
+select * from bench_load_random_int(10000000);
+commit;
diff --git a/contrib/bench_radix_tree/sql/bench.sql b/contrib/bench_radix_tree/sql/bench.sql
new file mode 100644
index 0000000000..a46018c9d4
--- /dev/null
+++ b/contrib/bench_radix_tree/sql/bench.sql
@@ -0,0 +1,16 @@
+create extension bench_radix_tree;
+
+\o seq_search.data
+begin;
+select * from bench_seq_search(0, 1000000);
+commit;
+
+\o shuffle_search.data
+begin;
+select * from bench_shuffle_search(0, 1000000);
+commit;
+
+\o random_load.data
+begin;
+select * from bench_load_random_int(10000000);
+commit;
-- 
2.31.1

commit 18407962e96ccec6c9aeeba97412edd762a5a4fe
Author: John Naylor <john.naylor@postgresql.org>
Date:   Wed Sep 21 11:44:43 2022 +0700

    Add special benchmark function to test effect of fanout

diff --git a/contrib/bench_radix_tree/Makefile b/contrib/bench_radix_tree/Makefile
index b8f70e12d1..952bb0ceae 100644
--- a/contrib/bench_radix_tree/Makefile
+++ b/contrib/bench_radix_tree/Makefile
@@ -7,7 +7,7 @@ OBJS = \
 EXTENSION = bench_radix_tree
 DATA = bench_radix_tree--1.0.sql
 
-REGRESS = bench
+REGRESS = bench_fixed_height
 
 ifdef USE_PGXS
 PG_CONFIG = pg_config
diff --git a/contrib/bench_radix_tree/bench_radix_tree--1.0.sql b/contrib/bench_radix_tree/bench_radix_tree--1.0.sql
index 6663abe6a4..f2fee15b17 100644
--- a/contrib/bench_radix_tree/bench_radix_tree--1.0.sql
+++ b/contrib/bench_radix_tree/bench_radix_tree--1.0.sql
@@ -40,3 +40,15 @@ OUT load_ms int8)
 returns record
 as 'MODULE_PATHNAME'
 LANGUAGE C STRICT VOLATILE PARALLEL UNSAFE;
+
+create function bench_fixed_height_search(
+fanout int4,
+OUT fanout int4,
+OUT nkeys int8,
+OUT rt_mem_allocated int8,
+OUT rt_load_ms int8,
+OUT rt_search_ms int8
+)
+returns record
+as 'MODULE_PATHNAME'
+LANGUAGE C STRICT VOLATILE PARALLEL UNSAFE;
diff --git a/contrib/bench_radix_tree/bench_radix_tree.c b/contrib/bench_radix_tree/bench_radix_tree.c
index 5806ef7519..0778da2d7b 100644
--- a/contrib/bench_radix_tree/bench_radix_tree.c
+++ b/contrib/bench_radix_tree/bench_radix_tree.c
@@ -13,6 +13,7 @@
 #include "fmgr.h"
 #include "funcapi.h"
 #include "lib/radixtree.h"
+#include <math.h>
 #include "miscadmin.h"
 #include "utils/timestamp.h"
 
@@ -24,6 +25,7 @@ PG_MODULE_MAGIC;
 PG_FUNCTION_INFO_V1(bench_seq_search);
 PG_FUNCTION_INFO_V1(bench_shuffle_search);
 PG_FUNCTION_INFO_V1(bench_load_random_int);
+PG_FUNCTION_INFO_V1(bench_fixed_height_search);
 
 static radix_tree *rt = NULL;
 static ItemPointer itemptrs = NULL;
@@ -299,3 +301,108 @@ bench_load_random_int(PG_FUNCTION_ARGS)
 	rt_free(rt);
 	PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
 }
+
+Datum
+bench_fixed_height_search(PG_FUNCTION_ARGS)
+{
+	int	fanout = PG_GETARG_INT32(0);
+	radix_tree *rt;
+	TupleDesc	tupdesc;
+	TimestampTz	start_time,	end_time;
+	long	secs;
+	int		usecs;
+	int64	rt_load_ms, rt_search_ms;
+	Datum	values[5];
+	bool	nulls[5];
+
+	/* test boundary between vector and iteration */
+	const int		n_keys = 5 * 16 * 16 * 16 * 16;
+	uint64		r, h, i, j, k;
+	int key_id;
+
+	/* Build a tuple descriptor for our result type */
+	if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
+		elog(ERROR, "return type must be a row type");
+
+	rt = rt_create(CurrentMemoryContext);
+
+	start_time = GetCurrentTimestamp();
+
+	key_id = 0;
+	/*  lower nodes have limited fanout, the top is only limited by bits-per-byte */
+	for (r=1;;r++)
+	{
+		for (h = 1; h <= fanout; h++)
+		{
+			for (i = 1; i <= fanout; i++)
+			{
+				for (j = 1; j <= fanout; j++)
+				{
+					for (k = 1; k <= fanout; k++)
+					{
+						uint64	key;
+						key = (r<<32) | (h<<24) | (i<<16) | (j<<8) | (k);
+
+						CHECK_FOR_INTERRUPTS();
+
+						key_id++;
+						if (key_id > n_keys)
+							goto finish_set;
+
+						rt_set(rt, key, key_id);
+					}
+				}
+			}
+		}
+	}
+finish_set:
+	end_time = GetCurrentTimestamp();
+	TimestampDifference(start_time, end_time, &secs, &usecs);
+	rt_load_ms = secs * 1000 + usecs / 1000;
+
+	rt_stats(rt);
+
+	/* meaure the search time of the radix tree */
+	start_time = GetCurrentTimestamp();
+
+	key_id = 0;
+	for (r=1;;r++)
+	{
+		for (h = 1; h <= fanout; h++)
+		{
+			for (i = 1; i <= fanout; i++)
+			{
+				for (j = 1; j <= fanout; j++)
+				{
+					for (k = 1; k <= fanout; k++)
+					{
+						uint64	key, val;
+						key = (r<<32) | (h<<24) | (i<<16) | (j<<8) | (k);
+
+						CHECK_FOR_INTERRUPTS();
+
+						key_id++;
+						if (key_id > n_keys)
+							goto finish_search;
+
+						rt_search(rt, key, &val);
+					}
+				}
+			}
+		}
+	}
+finish_search:
+	end_time = GetCurrentTimestamp();
+	TimestampDifference(start_time, end_time, &secs, &usecs);
+	rt_search_ms = secs * 1000 + usecs / 1000;
+
+	MemSet(nulls, false, sizeof(nulls));
+	values[0] = Int32GetDatum(fanout);
+	values[1] = Int64GetDatum(rt_num_entries(rt));
+	values[2] = Int64GetDatum(rt_memory_usage(rt));
+	values[3] = Int64GetDatum(rt_load_ms);
+	values[4] = Int64GetDatum(rt_search_ms);
+
+	rt_free(rt);
+	PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
+}
diff --git a/contrib/bench_radix_tree/expected/bench_fixed_height.out b/contrib/bench_radix_tree/expected/bench_fixed_height.out
new file mode 100644
index 0000000000..c4995afc13
--- /dev/null
+++ b/contrib/bench_radix_tree/expected/bench_fixed_height.out
@@ -0,0 +1,6 @@
+create extension bench_radix_tree;
+\o fixed_height_search.data
+begin;
+select * from bench_fixed_height_search(15);
+select * from bench_fixed_height_search(16);
+commit;
diff --git a/contrib/bench_radix_tree/sql/bench_fixed_height.sql b/contrib/bench_radix_tree/sql/bench_fixed_height.sql
new file mode 100644
index 0000000000..0c06570e9a
--- /dev/null
+++ b/contrib/bench_radix_tree/sql/bench_fixed_height.sql
@@ -0,0 +1,7 @@
+create extension bench_radix_tree;
+
+\o fixed_height_search.data
+begin;
+select * from bench_fixed_height_search(15);
+select * from bench_fixed_height_search(16);
+commit;
diff --git a/src/backend/lib/radixtree.c b/src/backend/lib/radixtree.c
index b163eac480..4ce8e9ad9d 100644
--- a/src/backend/lib/radixtree.c
+++ b/src/backend/lib/radixtree.c
@@ -1980,7 +1980,7 @@ rt_verify_node(rt_node *node)
 void
 rt_stats(radix_tree *tree)
 {
-	fprintf(stderr, "num_keys = %lu, height = %u, n4 = %u, n16 = %u,n32 = %u, n128 = %u, n256 = %u",
+	fprintf(stderr, "num_keys = %lu, height = %u, n4 = %u, n16 = %u,n32 = %u, n128 = %u, n256 = %u\n",
 			tree->num_keys,
 			tree->root->shift / RT_NODE_SPAN,
 			tree->cnt[0],
diff --git a/src/include/lib/radixtree.h b/src/include/lib/radixtree.h
index 38cc6abf4c..6016d593ee 100644
--- a/src/include/lib/radixtree.h
+++ b/src/include/lib/radixtree.h
@@ -15,7 +15,7 @@
 
 #include "postgres.h"
 
-/* #define RT_DEBUG 1 */
+#define RT_DEBUG 1 
 
 typedef struct radix_tree radix_tree;
 typedef struct rt_iter rt_iter;