Refactor rtree to always use base_alloc() for node allocation.

1 files changed, 82 insertions, 35 deletions

diff --git a/test/unit/rtree.c b/test/unit/rtree.c
index 671e2c8..9c992e1 100644
--- a/test/unit/rtree.c
+++ b/test/unit/rtree.c
@@ -1,10 +1,18 @@
 #include "test/jemalloc_test.h"
 
+rtree_node_alloc_t *rtree_node_alloc_orig;
+rtree_node_dalloc_t *rtree_node_dalloc_orig;
+
+rtree_t *test_rtree;
+
 static rtree_elm_t *
-node_alloc(size_t nelms)
+rtree_node_alloc_intercept(tsdn_t *tsdn, rtree_t *rtree, size_t nelms)
 {
 	rtree_elm_t *node;
 
+	if (rtree != test_rtree)
+		return rtree_node_alloc_orig(tsdn, rtree, nelms);
+
 	node = (rtree_elm_t *)calloc(nelms, sizeof(rtree_elm_t));
 	assert_ptr_not_null(node, "Unexpected calloc() failure");
 
@@ -12,23 +20,33 @@ node_alloc(size_t nelms)
 }
 
 static void
-node_dalloc(rtree_elm_t *node)
+rtree_node_dalloc_intercept(tsdn_t *tsdn, rtree_t *rtree, rtree_elm_t *node)
 {
 
+	if (rtree != test_rtree) {
+		rtree_node_dalloc_orig(tsdn, rtree, node);
+		return;
+	}
+
 	free(node);
 }
 
 TEST_BEGIN(test_rtree_read_empty)
 {
+	tsdn_t *tsdn;
 	unsigned i;
 
+	tsdn = tsdn_fetch();
+
 	for (i = 1; i <= (sizeof(uintptr_t) << 3); i++) {
 		rtree_t rtree;
-		assert_false(rtree_new(&rtree, i, node_alloc, node_dalloc),
+		test_rtree = &rtree;
+		assert_false(rtree_new(&rtree, i),
 		    "Unexpected rtree_new() failure");
-		assert_ptr_null(rtree_read(&rtree, 0, false),
+		assert_ptr_null(rtree_read(tsdn, &rtree, 0, false),
 		    "rtree_read() should return NULL for empty tree");
-		rtree_delete(&rtree);
+		rtree_delete(tsdn, &rtree);
+		test_rtree = NULL;
 	}
 }
 TEST_END
@@ -50,30 +68,34 @@ thd_start(void *varg)
 	thd_start_arg_t *arg = (thd_start_arg_t *)varg;
 	sfmt_t	*sfmt;
 	extent_t *extent;
+	tsdn_t *tsdn;
 	unsigned i;
 
 	sfmt = init_gen_rand(arg->seed);
 	extent = (extent_t *)malloc(sizeof(extent));
 	assert_ptr_not_null(extent, "Unexpected malloc() failure");
+	tsdn = tsdn_fetch();
 
 	for (i = 0; i < NITERS; i++) {
 		uintptr_t key = (uintptr_t)gen_rand64(sfmt);
 		if (i % 2 == 0) {
 			rtree_elm_t *elm;
 
-			elm = rtree_elm_acquire(&arg->rtree, key, false, true);
+			elm = rtree_elm_acquire(tsdn, &arg->rtree, key, false,
+			    true);
 			assert_ptr_not_null(elm,
 			    "Unexpected rtree_elm_acquire() failure");
 			rtree_elm_write_acquired(elm, extent);
 			rtree_elm_release(elm);
 
-			elm = rtree_elm_acquire(&arg->rtree, key, true, false);
+			elm = rtree_elm_acquire(tsdn, &arg->rtree, key, true,
+			    false);
 			assert_ptr_not_null(elm,
 			    "Unexpected rtree_elm_acquire() failure");
 			rtree_elm_read_acquired(elm);
 			rtree_elm_release(elm);
 		} else
-			rtree_read(&arg->rtree, key, false);
+			rtree_read(tsdn, &arg->rtree, key, false);
 	}
 
 	free(extent);
@@ -86,19 +108,23 @@ TEST_BEGIN(test_rtree_concurrent)
 	thd_start_arg_t arg;
 	thd_t thds[NTHREADS];
 	sfmt_t *sfmt;
+	tsdn_t *tsdn;
 	unsigned i, j;
 
 	sfmt = init_gen_rand(SEED);
+	tsdn = tsdn_fetch();
 	for (i = 1; i < MAX_NBITS; i++) {
 		arg.nbits = i;
-		assert_false(rtree_new(&arg.rtree, arg.nbits, node_alloc,
-		    node_dalloc), "Unexpected rtree_new() failure");
+		test_rtree = &arg.rtree;
+		assert_false(rtree_new(&arg.rtree, arg.nbits),
+		    "Unexpected rtree_new() failure");
 		arg.seed = gen_rand32(sfmt);
 		for (j = 0; j < NTHREADS; j++)
 			thd_create(&thds[j], thd_start, (void *)&arg);
 		for (j = 0; j < NTHREADS; j++)
 			thd_join(thds[j], NULL);
-		rtree_delete(&arg.rtree);
+		rtree_delete(tsdn, &arg.rtree);
+		test_rtree = NULL;
 	}
 	fini_gen_rand(sfmt);
 }
@@ -113,60 +139,70 @@ TEST_BEGIN(test_rtree_extrema)
 {
 	unsigned i;
 	extent_t extent_a, extent_b;
+	tsdn_t *tsdn;
+
+	tsdn = tsdn_fetch();
 
 	for (i = 1; i <= (sizeof(uintptr_t) << 3); i++) {
 		rtree_t rtree;
-		assert_false(rtree_new(&rtree, i, node_alloc, node_dalloc),
+		test_rtree = &rtree;
+		assert_false(rtree_new(&rtree, i),
 		    "Unexpected rtree_new() failure");
 
-		assert_false(rtree_write(&rtree, 0, &extent_a),
+		assert_false(rtree_write(tsdn, &rtree, 0, &extent_a),
 		    "Unexpected rtree_write() failure, i=%u", i);
-		assert_ptr_eq(rtree_read(&rtree, 0, true), &extent_a,
+		assert_ptr_eq(rtree_read(tsdn, &rtree, 0, true), &extent_a,
 		    "rtree_read() should return previously set value, i=%u", i);
 
-		assert_false(rtree_write(&rtree, ~((uintptr_t)0), &extent_b),
-		    "Unexpected rtree_write() failure, i=%u", i);
-		assert_ptr_eq(rtree_read(&rtree, ~((uintptr_t)0), true),
+		assert_false(rtree_write(tsdn, &rtree, ~((uintptr_t)0),
+		    &extent_b), "Unexpected rtree_write() failure, i=%u", i);
+		assert_ptr_eq(rtree_read(tsdn, &rtree, ~((uintptr_t)0), true),
 		    &extent_b,
 		    "rtree_read() should return previously set value, i=%u", i);
 
-		rtree_delete(&rtree);
+		rtree_delete(tsdn, &rtree);
+		test_rtree = NULL;
 	}
 }
 TEST_END
 
 TEST_BEGIN(test_rtree_bits)
 {
+	tsdn_t *tsdn;
 	unsigned i, j, k;
 
+	tsdn = tsdn_fetch();
+
 	for (i = 1; i < (sizeof(uintptr_t) << 3); i++) {
 		uintptr_t keys[] = {0, 1,
 		    (((uintptr_t)1) << (sizeof(uintptr_t)*8-i)) - 1};
 		extent_t extent;
 		rtree_t rtree;
 
-		assert_false(rtree_new(&rtree, i, node_alloc, node_dalloc),
+		test_rtree = &rtree;
+		assert_false(rtree_new(&rtree, i),
 		    "Unexpected rtree_new() failure");
 
 		for (j = 0; j < sizeof(keys)/sizeof(uintptr_t); j++) {
-			assert_false(rtree_write(&rtree, keys[j], &extent),
-			    "Unexpected rtree_write() failure");
+			assert_false(rtree_write(tsdn, &rtree, keys[j],
+			    &extent), "Unexpected rtree_write() failure");
 			for (k = 0; k < sizeof(keys)/sizeof(uintptr_t); k++) {
-				assert_ptr_eq(rtree_read(&rtree, keys[k], true),
-				    &extent, "rtree_read() should return "
-				    "previously set value and ignore "
+				assert_ptr_eq(rtree_read(tsdn, &rtree, keys[k],
+				    true), &extent, "rtree_read() should "
+				    "return previously set value and ignore "
 				    "insignificant key bits; i=%u, j=%u, k=%u, "
 				    "set key=%#"FMTxPTR", get key=%#"FMTxPTR, i,
 				    j, k, keys[j], keys[k]);
 			}
-			assert_ptr_null(rtree_read(&rtree,
+			assert_ptr_null(rtree_read(tsdn, &rtree,
 			    (((uintptr_t)1) << (sizeof(uintptr_t)*8-i)), false),
 			    "Only leftmost rtree leaf should be set; "
 			    "i=%u, j=%u", i, j);
-			rtree_clear(&rtree, keys[j]);
+			rtree_clear(tsdn, &rtree, keys[j]);
 		}
 
-		rtree_delete(&rtree);
+		rtree_delete(tsdn, &rtree);
+		test_rtree = NULL;
 	}
 }
 TEST_END
@@ -175,10 +211,12 @@ TEST_BEGIN(test_rtree_random)
 {
 	unsigned i;
 	sfmt_t *sfmt;
+	tsdn_t *tsdn;
 #define	NSET 16
 #define	SEED 42
 
 	sfmt = init_gen_rand(SEED);
+	tsdn = tsdn_fetch();
 	for (i = 1; i <= (sizeof(uintptr_t) << 3); i++) {
 		uintptr_t keys[NSET];
 		extent_t extent;
@@ -186,37 +224,40 @@ TEST_BEGIN(test_rtree_random)
 		rtree_t rtree;
 		rtree_elm_t *elm;
 
-		assert_false(rtree_new(&rtree, i, node_alloc, node_dalloc),
+		test_rtree = &rtree;
+		assert_false(rtree_new(&rtree, i),
 		    "Unexpected rtree_new() failure");
 
 		for (j = 0; j < NSET; j++) {
 			keys[j] = (uintptr_t)gen_rand64(sfmt);
-			elm = rtree_elm_acquire(&rtree, keys[j], false, true);
+			elm = rtree_elm_acquire(tsdn, &rtree, keys[j], false,
+			    true);
 			assert_ptr_not_null(elm,
 			    "Unexpected rtree_elm_acquire() failure");
 			rtree_elm_write_acquired(elm, &extent);
 			rtree_elm_release(elm);
-			assert_ptr_eq(rtree_read(&rtree, keys[j], true),
+			assert_ptr_eq(rtree_read(tsdn, &rtree, keys[j], true),
 			    &extent,
 			    "rtree_read() should return previously set value");
 		}
 		for (j = 0; j < NSET; j++) {
-			assert_ptr_eq(rtree_read(&rtree, keys[j], true),
+			assert_ptr_eq(rtree_read(tsdn, &rtree, keys[j], true),
 			    &extent, "rtree_read() should return previously "
 			    "set value, j=%u", j);
 		}
 
 		for (j = 0; j < NSET; j++) {
-			rtree_clear(&rtree, keys[j]);
-			assert_ptr_null(rtree_read(&rtree, keys[j], true),
+			rtree_clear(tsdn, &rtree, keys[j]);
+			assert_ptr_null(rtree_read(tsdn, &rtree, keys[j], true),
 			    "rtree_read() should return previously set value");
 		}
 		for (j = 0; j < NSET; j++) {
-			assert_ptr_null(rtree_read(&rtree, keys[j], true),
+			assert_ptr_null(rtree_read(tsdn, &rtree, keys[j], true),
 			    "rtree_read() should return previously set value");
 		}
 
-		rtree_delete(&rtree);
+		rtree_delete(tsdn, &rtree);
+		test_rtree = NULL;
 	}
 	fini_gen_rand(sfmt);
 #undef NSET
@@ -228,6 +269,12 @@ int
 main(void)
 {
 
+	rtree_node_alloc_orig = rtree_node_alloc;
+	rtree_node_alloc = rtree_node_alloc_intercept;
+	rtree_node_dalloc_orig = rtree_node_dalloc;
+	rtree_node_dalloc = rtree_node_dalloc_intercept;
+	test_rtree = NULL;
+
 	return (test(
 	    test_rtree_read_empty,
 	    test_rtree_concurrent,