165#define RT_MAKE_PREFIX(a) CppConcat(a,_)
166#define RT_MAKE_NAME(name) RT_MAKE_NAME_(RT_MAKE_PREFIX(RT_PREFIX),name)
167#define RT_MAKE_NAME_(a,b) CppConcat(a,b)
171#define RT_STR(s) RT_STR_(s)
175#define RT_CREATE RT_MAKE_NAME(create)
176#define RT_FREE RT_MAKE_NAME(free)
177#define RT_FIND RT_MAKE_NAME(find)
179#define RT_ATTACH RT_MAKE_NAME(attach)
180#define RT_DETACH RT_MAKE_NAME(detach)
181#define RT_GET_HANDLE RT_MAKE_NAME(get_handle)
182#define RT_LOCK_EXCLUSIVE RT_MAKE_NAME(lock_exclusive)
183#define RT_LOCK_SHARE RT_MAKE_NAME(lock_share)
184#define RT_UNLOCK RT_MAKE_NAME(unlock)
186#define RT_SET RT_MAKE_NAME(set)
187#define RT_BEGIN_ITERATE RT_MAKE_NAME(begin_iterate)
188#define RT_ITERATE_NEXT RT_MAKE_NAME(iterate_next)
189#define RT_END_ITERATE RT_MAKE_NAME(end_iterate)
191#define RT_DELETE RT_MAKE_NAME(delete)
193#define RT_MEMORY_USAGE RT_MAKE_NAME(memory_usage)
194#define RT_DUMP_NODE RT_MAKE_NAME(dump_node)
195#define RT_STATS RT_MAKE_NAME(stats)
198#define RT_CHILDPTR_IS_VALUE RT_MAKE_NAME(childptr_is_value)
199#define RT_VALUE_IS_EMBEDDABLE RT_MAKE_NAME(value_is_embeddable)
200#define RT_GET_SLOT_RECURSIVE RT_MAKE_NAME(get_slot_recursive)
201#define RT_DELETE_RECURSIVE RT_MAKE_NAME(delete_recursive)
202#define RT_ALLOC_NODE RT_MAKE_NAME(alloc_node)
203#define RT_ALLOC_LEAF RT_MAKE_NAME(alloc_leaf)
204#define RT_FREE_NODE RT_MAKE_NAME(free_node)
205#define RT_FREE_LEAF RT_MAKE_NAME(free_leaf)
206#define RT_FREE_RECURSE RT_MAKE_NAME(free_recurse)
207#define RT_EXTEND_UP RT_MAKE_NAME(extend_up)
208#define RT_EXTEND_DOWN RT_MAKE_NAME(extend_down)
209#define RT_COPY_COMMON RT_MAKE_NAME(copy_common)
210#define RT_PTR_SET_LOCAL RT_MAKE_NAME(ptr_set_local)
211#define RT_NODE_16_SEARCH_EQ RT_MAKE_NAME(node_16_search_eq)
212#define RT_NODE_4_GET_INSERTPOS RT_MAKE_NAME(node_4_get_insertpos)
213#define RT_NODE_16_GET_INSERTPOS RT_MAKE_NAME(node_16_get_insertpos)
214#define RT_SHIFT_ARRAYS_FOR_INSERT RT_MAKE_NAME(shift_arrays_for_insert)
215#define RT_SHIFT_ARRAYS_AND_DELETE RT_MAKE_NAME(shift_arrays_and_delete)
216#define RT_COPY_ARRAYS_FOR_INSERT RT_MAKE_NAME(copy_arrays_for_insert)
217#define RT_COPY_ARRAYS_AND_DELETE RT_MAKE_NAME(copy_arrays_and_delete)
218#define RT_NODE_48_IS_CHUNK_USED RT_MAKE_NAME(node_48_is_chunk_used)
219#define RT_NODE_48_GET_CHILD RT_MAKE_NAME(node_48_get_child)
220#define RT_NODE_256_IS_CHUNK_USED RT_MAKE_NAME(node_256_is_chunk_used)
221#define RT_NODE_256_GET_CHILD RT_MAKE_NAME(node_256_get_child)
222#define RT_KEY_GET_SHIFT RT_MAKE_NAME(key_get_shift)
223#define RT_SHIFT_GET_MAX_VAL RT_MAKE_NAME(shift_get_max_val)
224#define RT_NODE_SEARCH RT_MAKE_NAME(node_search)
225#define RT_NODE_DELETE RT_MAKE_NAME(node_delete)
226#define RT_NODE_INSERT RT_MAKE_NAME(node_insert)
227#define RT_ADD_CHILD_4 RT_MAKE_NAME(add_child_4)
228#define RT_ADD_CHILD_16 RT_MAKE_NAME(add_child_16)
229#define RT_ADD_CHILD_48 RT_MAKE_NAME(add_child_48)
230#define RT_ADD_CHILD_256 RT_MAKE_NAME(add_child_256)
231#define RT_GROW_NODE_4 RT_MAKE_NAME(grow_node_4)
232#define RT_GROW_NODE_16 RT_MAKE_NAME(grow_node_16)
233#define RT_GROW_NODE_48 RT_MAKE_NAME(grow_node_48)
234#define RT_REMOVE_CHILD_4 RT_MAKE_NAME(remove_child_4)
235#define RT_REMOVE_CHILD_16 RT_MAKE_NAME(remove_child_16)
236#define RT_REMOVE_CHILD_48 RT_MAKE_NAME(remove_child_48)
237#define RT_REMOVE_CHILD_256 RT_MAKE_NAME(remove_child_256)
238#define RT_SHRINK_NODE_16 RT_MAKE_NAME(shrink_child_16)
239#define RT_SHRINK_NODE_48 RT_MAKE_NAME(shrink_child_48)
240#define RT_SHRINK_NODE_256 RT_MAKE_NAME(shrink_child_256)
241#define RT_NODE_ITERATE_NEXT RT_MAKE_NAME(node_iterate_next)
242#define RT_VERIFY_NODE RT_MAKE_NAME(verify_node)
245#define RT_RADIX_TREE RT_MAKE_NAME(radix_tree)
246#define RT_RADIX_TREE_CONTROL RT_MAKE_NAME(radix_tree_control)
247#define RT_ITER RT_MAKE_NAME(iter)
249#define RT_HANDLE RT_MAKE_NAME(handle)
251#define RT_NODE RT_MAKE_NAME(node)
252#define RT_CHILD_PTR RT_MAKE_NAME(child_ptr)
253#define RT_NODE_ITER RT_MAKE_NAME(node_iter)
254#define RT_NODE_4 RT_MAKE_NAME(node_4)
255#define RT_NODE_16 RT_MAKE_NAME(node_16)
256#define RT_NODE_48 RT_MAKE_NAME(node_48)
257#define RT_NODE_256 RT_MAKE_NAME(node_256)
258#define RT_SIZE_CLASS RT_MAKE_NAME(size_class)
259#define RT_SIZE_CLASS_ELEM RT_MAKE_NAME(size_class_elem)
260#define RT_SIZE_CLASS_INFO RT_MAKE_NAME(size_class_info)
261#define RT_CLASS_4 RT_MAKE_NAME(class_4)
262#define RT_CLASS_16_LO RT_MAKE_NAME(class_32_min)
263#define RT_CLASS_16_HI RT_MAKE_NAME(class_32_max)
264#define RT_CLASS_48 RT_MAKE_NAME(class_48)
265#define RT_CLASS_256 RT_MAKE_NAME(class_256)
314#define RT_SPAN BITS_PER_BYTE
320#define RT_NODE_MAX_SLOTS (1 << RT_SPAN)
323#define RT_CHUNK_MASK ((1 << RT_SPAN) - 1)
326#define RT_MAX_SHIFT RT_KEY_GET_SHIFT(UINT64_MAX)
329#define RT_MAX_LEVEL ((sizeof(uint64) * BITS_PER_BYTE) / RT_SPAN)
332#define RT_GET_KEY_CHUNK(key, shift) ((uint8) (((key) >> (shift)) & RT_CHUNK_MASK))
335#define RT_BM_IDX(x) ((x) / BITS_PER_BITMAPWORD)
336#define RT_BM_BIT(x) ((x) % BITS_PER_BITMAPWORD)
360#define RT_NODE_KIND_4 0x00
361#define RT_NODE_KIND_16 0x01
362#define RT_NODE_KIND_48 0x02
363#define RT_NODE_KIND_256 0x03
364#define RT_NODE_KIND_COUNT 4
370#define RT_SLAB_BLOCK_SIZE(size) \
371 Max(SLAB_DEFAULT_BLOCK_SIZE, pg_nextpower2_32(size * 32))
400#define RT_PTR_ALLOC dsa_pointer
401#define RT_INVALID_PTR_ALLOC InvalidDsaPointer
402#define RT_PTR_ALLOC_IS_VALID(ptr) DsaPointerIsValid(ptr)
404#define RT_PTR_ALLOC RT_NODE *
405#define RT_INVALID_PTR_ALLOC NULL
406#define RT_PTR_ALLOC_IS_VALID(ptr) PointerIsValid(ptr)
432#ifdef RT_VARLEN_VALUE_SIZE
433#define RT_GET_VALUE_SIZE(v) RT_VARLEN_VALUE_SIZE(v)
435#define RT_GET_VALUE_SIZE(v) sizeof(RT_VALUE_TYPE)
445#ifdef RT_VARLEN_VALUE_SIZE
447#ifdef RT_RUNTIME_EMBEDDABLE_VALUE
465#ifdef RT_VARLEN_VALUE_SIZE
467#ifdef RT_RUNTIME_EMBEDDABLE_VALUE
472 return ((uintptr_t) child) & 1;
491#define RT_FANOUT_4_MAX (8 - sizeof(RT_NODE))
494#define RT_FANOUT_16_MAX 32
504#define RT_FANOUT_48_MAX 64
506#define RT_FANOUT_256 RT_NODE_MAX_SLOTS
557#define RT_INVALID_SLOT_IDX 0xFF
587#if SIZEOF_DSA_POINTER < 8
588#define RT_FANOUT_16_LO ((96 - offsetof(RT_NODE_16, children)) / sizeof(RT_PTR_ALLOC))
589#define RT_FANOUT_16_HI Min(RT_FANOUT_16_MAX, (160 - offsetof(RT_NODE_16, children)) / sizeof(RT_PTR_ALLOC))
590#define RT_FANOUT_48 Min(RT_FANOUT_48_MAX, (512 - offsetof(RT_NODE_48, children)) / sizeof(RT_PTR_ALLOC))
592#define RT_FANOUT_16_LO ((160 - offsetof(RT_NODE_16, children)) / sizeof(RT_PTR_ALLOC))
593#define RT_FANOUT_16_HI Min(RT_FANOUT_16_MAX, (320 - offsetof(RT_NODE_16, children)) / sizeof(RT_PTR_ALLOC))
594#define RT_FANOUT_48 Min(RT_FANOUT_48_MAX, (768 - offsetof(RT_NODE_48, children)) / sizeof(RT_PTR_ALLOC))
600#define RT_FANOUT_16_LO 16
602#define RT_FANOUT_16_HI RT_FANOUT_16_MAX
603#define RT_FANOUT_48 RT_FANOUT_48_MAX
678#define RT_NUM_SIZE_CLASSES lengthof(RT_SIZE_CLASS_INFO)
682#define RT_RADIX_TREE_MAGIC 0x54A48167
847 node = allocnode.
local;
854 memset(node, 0, offsetof(
RT_NODE_4, children));
857 memset(node, 0, offsetof(
RT_NODE_16, children));
863 memset(n48, 0, offsetof(
RT_NODE_48, slot_idxs));
884 tree->ctl->num_nodes[size_class]++;
906 tree->ctl->num_leaves++;
919 (newnode.
local)->count = (oldnode.
local)->count;
944 tree->ctl->num_nodes[
i]--;
962 tree->ctl->num_leaves--;
993#if defined(USE_NO_SIMD) || defined(USE_ASSERT_CHECKING)
996 for (
int i = 0;
i < count;
i++)
1013 cmp1 = vector8_eq(spread_chunk, haystack1);
1014 cmp2 = vector8_eq(spread_chunk, haystack2);
1017 bitfield = vector8_highbit_mask(cmp1) | (vector8_highbit_mask(cmp2) <<
sizeof(
Vector8));
1026 Assert(slot_simd == slot);
1098 Assert(
tree->ctl->magic == RT_RADIX_TREE_MAGIC);
1106 shift =
tree->ctl->start_shift;
1131#define RT_NODE_MUST_GROW(node) \
1132 ((node)->count == (node)->fanout)
1160#if defined(USE_NO_SIMD) || defined(USE_ASSERT_CHECKING)
1188 if (node->
chunks[count - 1] < chunk)
1191#if defined(USE_NO_SIMD) || defined(USE_ASSERT_CHECKING)
1212 min1 = vector8_min(spread_chunk, haystack1);
1213 min2 = vector8_min(spread_chunk, haystack2);
1214 cmp1 = vector8_eq(spread_chunk, min1);
1215 cmp2 = vector8_eq(spread_chunk, min2);
1216 bitfield = vector8_highbit_mask(cmp1) | (vector8_highbit_mask(cmp2) <<
sizeof(
Vector8));
1236 for (
int i = count - 1;
i >= insertpos;
i--)
1242 chunks[
i + 1] = chunks[
i];
1243 children[
i + 1] = children[
i];
1254 int count,
int insertpos)
1256 for (
int i = 0;
i < count;
i++)
1261 int destidx =
i + (
i >= insertpos);
1263 dst_chunks[destidx] = src_chunks[sourceidx];
1264 dst_children[destidx] = src_children[sourceidx];
1315 new256->children[
i] = n48->
children[offset];
1321 new256->isset[word_num] = bitmap;
1325 *parent_slot = newnode.alloc;
1355 Assert(insertpos < n48->base.fanout);
1396 new16->
chunks[insertpos] = chunk;
1403 *parent_slot = newnode.
alloc;
1405 return &new16->
children[insertpos];
1449 *parent_slot = newnode.
alloc;
1452 return &new48->
children[insertpos];
1467 n16->
chunks[insertpos] = chunk;
1497 new16->
chunks[insertpos] = chunk;
1503 *parent_slot = newnode.
alloc;
1506 return &new16->
children[insertpos];
1521 n4->
chunks[insertpos] = chunk;
1581 int shift =
tree->ctl->start_shift;
1583 Assert(shift < target_shift);
1586 while (shift < target_shift)
1604 tree->ctl->start_shift = target_shift;
1624 *parent_slot = child.
alloc;
1666 node.
alloc = *parent_slot;
1709 Assert(
tree->ctl->magic == RT_RADIX_TREE_MAGIC);
1717 if (
tree->ctl->num_keys == 0)
1746 key,
tree->ctl->start_shift, &found);
1758 memcpy(slot, value_p, value_sz);
1760#ifdef RT_RUNTIME_EMBEDDABLE_VALUE
1765 *((uintptr_t *) slot) |= 1;
1797 memcpy(leaf.
local, value_p, value_sz);
1802 tree->ctl->num_keys++;
1834 tree->ctl->handle = dp;
1835 tree->ctl->magic = RT_RADIX_TREE_MAGIC;
1866RT_ATTACH(
dsa_area *dsa, RT_HANDLE handle)
1878 Assert(
tree->ctl->magic == RT_RADIX_TREE_MAGIC);
1886 Assert(
tree->ctl->magic == RT_RADIX_TREE_MAGIC);
1893 Assert(
tree->ctl->magic == RT_RADIX_TREE_MAGIC);
1894 return tree->ctl->handle;
1900 Assert(
tree->ctl->magic == RT_RADIX_TREE_MAGIC);
1907 Assert(
tree->ctl->magic == RT_RADIX_TREE_MAGIC);
1914 Assert(
tree->ctl->magic == RT_RADIX_TREE_MAGIC);
2021 Assert(
tree->ctl->magic == RT_RADIX_TREE_MAGIC);
2031 tree->ctl->magic = 0;
2084 uint8 key_chunk = 0;
2094 node = node_iter->
node;
2098 switch ((node.
local)->kind)
2120 key_chunk = n16->
chunks[node_iter->
idx];
2141 node_iter->
idx = chunk + 1;
2161 node_iter->
idx = chunk + 1;
2188 if (iter->
cur_level == 0 && slot != NULL)
2245 for (
int i = deletepos;
i < count - 1;
i++)
2251 chunks[
i] = chunks[
i + 1];
2252 children[
i] = children[
i + 1];
2263 int count,
int deletepos)
2265 for (
int i = 0;
i < count - 1;
i++)
2271 int sourceidx =
i + (
i >= deletepos);
2274 dst_chunks[destidx] = src_chunks[sourceidx];
2275 dst_children[destidx] = src_children[sourceidx];
2313 new48->slot_idxs[
i] = slot_idx;
2314 new48->children[slot_idx] = n256->
children[
i];
2328 *parent_slot = newnode.alloc;
2335 int shrink_threshold;
2355 if (n256->
base.
count <= shrink_threshold)
2384 new16->
chunks[destidx] = chunk;
2390 Assert(destidx < new16->base.fanout);
2395 *parent_slot = newnode.
alloc;
2423 if (n48->
base.
count <= shrink_threshold)
2453 *parent_slot = newnode.
alloc;
2461 int deletepos = slot - n16->
children;
2496 if (parent_slot == &
tree->ctl->root)
2499 tree->ctl->start_shift = 0;
2520 int deletepos = slot - n4->
children;
2538 switch ((node.
local)->kind)
2573 node.
alloc = *parent_slot;
2617 Assert(
tree->ctl->magic == RT_RADIX_TREE_MAGIC);
2630 tree->ctl->num_keys--;
2653 Assert(
tree->ctl->magic == RT_RADIX_TREE_MAGIC);
2668#ifdef USE_ASSERT_CHECKING
2711 Assert(slot < node->fanout);
2757 fprintf(stderr,
"num_keys = %" PRId64
"\n",
tree->ctl->num_keys);
2772 fprintf(stderr,
", leaves = %" PRId64,
tree->ctl->num_leaves);
2785#define RT_CHILD_PTR_FORMAT DSA_POINTER_FORMAT
2787#define RT_CHILD_PTR_FORMAT "%p"
2790 fprintf(stderr,
"kind %d, fanout %d, count %u\n",
2794 node->fanout == 0 ? 256 : node->fanout,
2795 node->count == 0 ? 256 : node->count);
2803 fprintf(stderr,
"chunks and slots:\n");
2806 fprintf(stderr,
" [%d] chunk %x slot " RT_CHILD_PTR_FORMAT
"\n",
2816 fprintf(stderr,
"chunks and slots:\n");
2819 fprintf(stderr,
" [%d] chunk %x slot " RT_CHILD_PTR_FORMAT
"\n",
2829 fprintf(stderr,
"slot_idxs: \n");
2835 fprintf(stderr,
" idx[%d] = %d\n",
2839 fprintf(stderr,
"isset-bitmap: ");
2847 fprintf(stderr,
"chunks and slots:\n");
2853 fprintf(stderr,
" chunk %x slot " RT_CHILD_PTR_FORMAT
"\n",
2864 fprintf(stderr,
"isset-bitmap: ");
2872 fprintf(stderr,
"chunks and slots:\n");
2878 fprintf(stderr,
" chunk %x slot " RT_CHILD_PTR_FORMAT
"\n",
2897#undef RT_VARLEN_VALUE_SIZE
2898#undef RT_RUNTIME_EMBEDDABLE_VALUE
2904#undef RT_MAKE_PREFIX
2910#undef RT_NODE_MAX_SLOTS
2914#undef RT_GET_KEY_CHUNK
2917#undef RT_NODE_MUST_GROW
2918#undef RT_NODE_KIND_COUNT
2919#undef RT_NUM_SIZE_CLASSES
2920#undef RT_INVALID_SLOT_IDX
2921#undef RT_SLAB_BLOCK_SIZE
2922#undef RT_RADIX_TREE_MAGIC
2923#undef RT_CHILD_PTR_FORMAT
2927#undef RT_RADIX_TREE_CONTROL
2930#undef RT_INVALID_PTR_ALLOC
2935#undef RT_NODE_KIND_4
2936#undef RT_NODE_KIND_16
2937#undef RT_NODE_KIND_48
2938#undef RT_NODE_KIND_256
2944#undef RT_SIZE_CLASS_ELEM
2945#undef RT_SIZE_CLASS_INFO
2947#undef RT_CLASS_16_LO
2948#undef RT_CLASS_16_HI
2952#undef RT_FANOUT_4_MAX
2953#undef RT_FANOUT_16_LO
2954#undef RT_FANOUT_16_HI
2955#undef RT_FANOUT_16_MAX
2957#undef RT_FANOUT_48_MAX
2965#undef RT_LOCK_EXCLUSIVE
2971#undef RT_BEGIN_ITERATE
2972#undef RT_ITERATE_NEXT
2973#undef RT_END_ITERATE
2975#undef RT_MEMORY_USAGE
2980#undef RT_GET_VALUE_SIZE
2981#undef RT_VALUE_IS_EMBEDDABLE
2982#undef RT_CHILDPTR_IS_VALUE
2983#undef RT_GET_SLOT_RECURSIVE
2984#undef RT_DELETE_RECURSIVE
2989#undef RT_FREE_RECURSE
2991#undef RT_EXTEND_DOWN
2992#undef RT_COPY_COMMON
2993#undef RT_PTR_SET_LOCAL
2994#undef RT_PTR_ALLOC_IS_VALID
2995#undef RT_NODE_16_SEARCH_EQ
2996#undef RT_NODE_4_GET_INSERTPOS
2997#undef RT_NODE_16_GET_INSERTPOS
2998#undef RT_SHIFT_ARRAYS_FOR_INSERT
2999#undef RT_SHIFT_ARRAYS_AND_DELETE
3000#undef RT_COPY_ARRAYS_FOR_INSERT
3001#undef RT_COPY_ARRAYS_AND_DELETE
3002#undef RT_NODE_48_IS_CHUNK_USED
3003#undef RT_NODE_48_GET_CHILD
3004#undef RT_NODE_256_IS_CHUNK_USED
3005#undef RT_NODE_256_GET_CHILD
3006#undef RT_KEY_GET_SHIFT
3007#undef RT_SHIFT_GET_MAX_VAL
3008#undef RT_NODE_SEARCH
3009#undef RT_ADD_CHILD_4
3010#undef RT_ADD_CHILD_16
3011#undef RT_ADD_CHILD_48
3012#undef RT_ADD_CHILD_256
3013#undef RT_GROW_NODE_4
3014#undef RT_GROW_NODE_16
3015#undef RT_GROW_NODE_48
3016#undef RT_REMOVE_CHILD_4
3017#undef RT_REMOVE_CHILD_16
3018#undef RT_REMOVE_CHILD_48
3019#undef RT_REMOVE_CHILD_256
3020#undef RT_SHRINK_NODE_16
3021#undef RT_SHRINK_NODE_48
3022#undef RT_SHRINK_NODE_256
3023#undef RT_NODE_DELETE
3024#undef RT_NODE_INSERT
3025#undef RT_NODE_ITERATE_NEXT
3026#undef RT_VERIFY_NODE
Datum idx(PG_FUNCTION_ARGS)
#define bmw_rightmost_one_pos(w)
#define BITS_PER_BITMAPWORD
#define pg_attribute_unused()
#define FLEXIBLE_ARRAY_MEMBER
#define fprintf(file, fmt, msg)
void * dsa_get_address(dsa_area *area, dsa_pointer dp)
size_t dsa_get_total_size(dsa_area *area)
void dsa_free(dsa_area *area, dsa_pointer dp)
#define dsa_allocate0(area, size)
#define DSA_POINTER_FORMAT
#define dsa_allocate(area, size)
Assert(PointerIsAligned(start, uint64))
if(TABLE==NULL||TABLE_index==NULL)
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
void LWLockRelease(LWLock *lock)
void LWLockInitialize(LWLock *lock, int tranche_id)
void * MemoryContextAlloc(MemoryContext context, Size size)
void MemoryContextReset(MemoryContext context)
void pfree(void *pointer)
void * palloc0(Size size)
Size MemoryContextMemAllocated(MemoryContext context, bool recurse)
static int pg_rightmost_one_pos32(uint32 word)
static int pg_leftmost_one_pos64(uint64 word)
#define RT_NODE_ITERATE_NEXT
#define RT_NODE_4_GET_INSERTPOS
#define RT_INVALID_SLOT_IDX
#define RT_CHILDPTR_IS_VALUE
#define RT_REMOVE_CHILD_16
#define RT_VALUE_IS_EMBEDDABLE
RT_SCOPE RT_RADIX_TREE *RT_CHILD_PTR rootnode
#define RT_NODE_16_GET_INSERTPOS
#define RT_NODE_48_GET_CHILD
#define RT_NODE_MAX_SLOTS
#define RT_COPY_ARRAYS_FOR_INSERT
#define RT_DELETE_RECURSIVE
#define RT_GET_SLOT_RECURSIVE
for(int i=0;i< RT_NUM_SIZE_CLASSES;i++)
#define RT_SHRINK_NODE_256
#define RT_SHRINK_NODE_48
#define RT_SIZE_CLASS_ELEM
#define RT_REMOVE_CHILD_256
#define RT_RADIX_TREE_CONTROL
#define RT_NODE_MUST_GROW(node)
#define RT_SLAB_BLOCK_SIZE(size)
#define RT_SHIFT_GET_MAX_VAL
#define RT_NODE_48_IS_CHUNK_USED
#define RT_COPY_ARRAYS_AND_DELETE
#define RT_REMOVE_CHILD_48
#define RT_SHIFT_ARRAYS_AND_DELETE
#define RT_NODE_256_GET_CHILD
StaticAssertDecl(RT_FANOUT_4<=RT_FANOUT_4_MAX, "watch struct padding")
#define RT_SHRINK_NODE_16
#define RT_PTR_ALLOC_IS_VALID(ptr)
#define RT_GET_KEY_CHUNK(key, shift)
#define RT_GET_VALUE_SIZE(v)
#define RT_NODE_256_IS_CHUNK_USED
#define RT_SHIFT_ARRAYS_FOR_INSERT
#define RT_NODE_16_SEARCH_EQ
#define RT_SIZE_CLASS_INFO
#define RT_INVALID_PTR_ALLOC
#define RT_REMOVE_CHILD_4
#define RT_NUM_SIZE_CLASSES
static Vector8 vector8_broadcast(const uint8 c)
static void vector8_load(Vector8 *v, const uint8 *s)
MemoryContext SlabContextCreate(MemoryContext parent, const char *name, Size blockSize, Size chunkSize)
void check_stack_depth(void)
RT_NODE_ITER node_iters[RT_MAX_LEVEL]
RT_PTR_ALLOC children[FLEXIBLE_ARRAY_MEMBER]
uint8 chunks[RT_FANOUT_16_MAX]
RT_PTR_ALLOC children[RT_FANOUT_256]
bitmapword isset[RT_BM_IDX(RT_FANOUT_256)]
RT_PTR_ALLOC children[FLEXIBLE_ARRAY_MEMBER]
uint8 slot_idxs[RT_NODE_MAX_SLOTS]
bitmapword isset[RT_BM_IDX(RT_FANOUT_48_MAX)]
RT_PTR_ALLOC children[FLEXIBLE_ARRAY_MEMBER]
uint8 chunks[RT_FANOUT_4_MAX]
MemoryContextData * node_slabs[RT_NUM_SIZE_CLASSES]
MemoryContextData * leaf_context
RT_RADIX_TREE_CONTROL * ctl
Datum bit(PG_FUNCTION_ARGS)