From: Liam R. Howlett <Liam.Howlett@Oracle.com>
Date: Thu, 19 Nov 2020 17:15:22 +0000 (-0500)
Subject: maple_tree: Code clean up
X-Git-Url: https://www.infradead.org/git/?a=commitdiff_plain;h=07c40e98a1d2d4fb399d330922db13a63235cf73;p=users%2Fjedix%2Flinux-maple.git

maple_tree: Code clean up

Signed-off-by: Liam R. Howlett <Liam.Howlett@Oracle.com>
---

diff --git a/lib/maple_tree.c b/lib/maple_tree.c
index 02505ede97db..63d4bc2e00c1 100644
--- a/lib/maple_tree.c
+++ b/lib/maple_tree.c
@@ -60,7 +60,7 @@ static const unsigned char mt_min_slots[] = {
 };
 #define mt_min_slot_count(x) mt_min_slots[mte_node_type(x)]
 
-#define MAPLE_BIG_NODE_SLOTS	(MAPLE_RANGE64_SLOTS* 2 + 2)
+#define MAPLE_BIG_NODE_SLOTS	(MAPLE_RANGE64_SLOTS * 2 + 2)
 
 struct maple_big_node {
 	struct maple_pnode *parent;
@@ -123,6 +123,7 @@ static unsigned int mt_height(const struct maple_tree *mt)
 static void mas_set_height(struct ma_state *mas)
 {
 	unsigned int new_flags = mas->tree->ma_flags;
+
 	new_flags &= ~MAPLE_HEIGHT_MASK;
 	new_flags |= mas->depth << MAPLE_HEIGHT_OFFSET;
 	mas->tree->ma_flags = new_flags;
@@ -821,7 +822,8 @@ parent_is_root:
 
 	if (!max || min == ULONG_MAX) {
 		if (mas->node == a_enode) {
-			printk("Failed on node %p (%p)\n", mas_mn(mas), a_enode);
+			pr_err("Failed on node %p (%p)\n", mas_mn(mas),
+			       a_enode);
 			//FIXME: Restart and retry if the lock is held.
 			MT_BUG_ON(mas->tree, mas->node == a_enode);
 		}
@@ -929,12 +931,13 @@ static inline void mas_alloc_nodes(struct ma_state *mas, gfp_t gfp)
 
 	node = mas->alloc;
 	while (requested) {
-		void **slots = (void**)&node->slot;
+		void **slots = (void **)&node->slot;
 		unsigned int max_req = MAPLE_NODE_SLOTS - 1;
 
 		if (node->slot[0]) {
 			unsigned int offset = node->node_count + 1;
-			slots = (void**)&node->slot[offset];
+
+			slots = (void **)&node->slot[offset];
 			max_req -= offset;
 		}
 
@@ -944,7 +947,7 @@ static inline void mas_alloc_nodes(struct ma_state *mas, gfp_t gfp)
 			goto nomem;
 
 		node->node_count += count;
-		if (slots == (void**)&node->slot)
+		if (slots == (void **)&node->slot)
 			node->node_count--; // zero indexed.
 
 		success += count;
@@ -1135,7 +1138,7 @@ ma_max_gap(struct maple_node *node, unsigned long *gaps, enum maple_type mt,
 			max_gap = gaps[i];
 			*offset = i;
 		}
-	} while(i--);
+	} while (i--);
 
 	return max_gap;
 }
@@ -1145,9 +1148,10 @@ ma_max_gap(struct maple_node *node, unsigned long *gaps, enum maple_type mt,
  */
 static inline unsigned long mas_max_gap(struct ma_state *mas)
 {
-	unsigned long *gaps;//, *pivots;
+	unsigned long *gaps;
 	unsigned char offset;
 	enum maple_type mt;
+
 	if (mte_is_leaf(mas->node))
 		return mas_leaf_max_gap(mas);
 
@@ -1203,10 +1207,10 @@ ascend:
 		return;
 
 	if (offset != meta_offset) {
-	    if (meta_gap > new)
-		return;
+		if (meta_gap > new)
+			return;
 
-	    ma_set_meta_gap(pnode, pmt, offset);
+		ma_set_meta_gap(pnode, pmt, offset);
 	} else if (new < meta_gap) {
 		meta_offset = 15;
 		new = ma_max_gap(pnode, pgaps, pmt, &meta_offset);
@@ -1531,7 +1535,7 @@ static inline void mas_mab_cp(struct ma_state *mas, unsigned char mas_start,
 
 	memcpy(b_node->slot + mab_start,
 	       slots + mas_start,
-	       sizeof(void*) * (j - mab_start));
+	       sizeof(void *) * (j - mab_start));
 
 	if (!mte_is_leaf(mas->node) && mt_is_alloc(mas->tree)) {
 		gaps = ma_gaps(node, mt);
@@ -1571,12 +1575,13 @@ static inline void mab_mas_cp(struct maple_big_node *b_node,
 	}
 
 	memcpy(slots, b_node->slot + mab_start,
-	       sizeof(void*) * (i - mab_start));
+	       sizeof(void *) * (i - mab_start));
 
 	if (!ma_is_leaf(mt) && mt_is_alloc(mas->tree)) {
 		unsigned long max_gap = 0;
 		unsigned char offset = 15, tmp;
 		unsigned char end = i - mab_start;
+
 		gaps = ma_gaps(mas_mn(mas), mt);
 		for (tmp = 0; tmp < end; tmp++) {
 			gaps[tmp] = b_node->gap[mab_start + tmp];
@@ -1613,8 +1618,7 @@ static inline void mas_descend_adopt(struct ma_state *mas)
 	mas_dup_state(&next[0], mas);
 
 
-	while (!mte_is_leaf(list[0].node))
-	{
+	while (!mte_is_leaf(list[0].node)) {
 		n = 0;
 		for (i = 0; i < 3; i++) {
 			if (mas_is_none(&list[i]))
@@ -1920,6 +1924,7 @@ static inline bool mast_cousin_rebalance_right(struct maple_subtree_state *mast)
 {
 	struct maple_enode *old_l = mast->orig_l->node;
 	struct maple_enode *old_r = mast->orig_r->node;
+
 	MA_STATE(tmp, mast->orig_r->tree, mast->orig_r->index, mast->orig_r->last);
 
 	mas_dup_state(&tmp, mast->orig_r);
@@ -2959,7 +2964,7 @@ static inline bool mas_node_walk(struct ma_state *mas, enum maple_type type,
 		goto dense;
 	}
 
-	while(mas->offset < mt_slots[type]) {
+	while (mas->offset < mt_slots[type]) {
 		pivot = _mas_safe_pivot(mas, pivots, mas->offset, type);
 
 		if (!pivot && mas->offset) {
@@ -3200,16 +3205,17 @@ static inline bool mas_node_store(struct ma_state *mas, void *entry,
 		new_end++;
 		offset_end = offset;
 	} else if (mas->last == mas->max) { // runs right to the end of the node.
-			new_end = offset;
-			offset_end = end + 1; // no data beyond this range.
+		new_end = offset;
+		offset_end = end + 1; // no data beyond this range.
 	} else {
 		unsigned long piv = 0;
+
 		new_end++;
 		do {
 			offset_end++;
 			new_end--;
 			piv = mas_logical_pivot(mas, pivots, offset_end, mt);
-		} while(piv <= mas->last);
+		} while (piv <= mas->last);
 	}
 
 	if (min < mas->index) // new range starts within a range.
@@ -3239,7 +3245,7 @@ static inline bool mas_node_store(struct ma_state *mas, void *entry,
 	dst_slots = ma_slots(newnode, mt);
 	// Copy from start to insert point
 	memcpy(dst_pivots, pivots, sizeof(unsigned long) * (offset + 1));
-	memcpy(dst_slots, slots, sizeof(void*) * (offset + 1));
+	memcpy(dst_slots, slots, sizeof(void *) * (offset + 1));
 	dst_offset = offset;
 
 	// Handle insert of new range starting after old range
@@ -3378,7 +3384,7 @@ static inline void *_mas_store(struct ma_state *mas, void *entry, bool overwrite
 
 	if (!entry) {
 		enum maple_type mt = mte_node_type(mas->node);
-		unsigned long *pivots = ma_pivots(mas_mn(mas),mt);
+		unsigned long *pivots = ma_pivots(mas_mn(mas), mt);
 		void **slots = ma_slots(mas_mn(mas), mt);
 		unsigned char offset_end = mas->offset;
 
@@ -3490,7 +3496,7 @@ restart_prev_node:
 		mt = mte_node_type(mas->node);
 		slots = ma_slots(mas_mn(mas), mt);
 		offset = mt_slots[mt];
-		do {} while(!mas_get_slot(mas, --offset));
+		do {} while (!mas_get_slot(mas, --offset));
 		mas->max = mas_safe_pivot(mas, offset);
 	}
 
@@ -3572,7 +3578,7 @@ ascend_again:
 		pivot = mas_safe_pivot(mas, offset);
 	}
 
-	mas->node = mas_slot(mas, slots,offset);
+	mas->node = mas_slot(mas, slots, offset);
 	mas->min = prev_piv + 1;
 	mas->max = pivot;
 	return mas->max;
@@ -4984,10 +4990,10 @@ int mas_entry_count(struct ma_state *mas, unsigned long nr_entries)
 	nr_nodes = max(nr_entries, nr_entries * 2 + 1);
 
 	if (!mt_is_alloc(mas->tree))
-	    nonleaf_cap = MAPLE_RANGE64_SLOTS - 2;
+		nonleaf_cap = MAPLE_RANGE64_SLOTS - 2;
 
 	// Leaves
-	nr_nodes = DIV_ROUND_UP(nr_nodes , MAPLE_RANGE64_SLOTS - 1);
+	nr_nodes = DIV_ROUND_UP(nr_nodes, MAPLE_RANGE64_SLOTS - 1);
 	// Internal nodes.
 	nr_nodes += DIV_ROUND_UP(nr_nodes, nonleaf_cap);
 	mas_node_count(mas, nr_nodes);
@@ -5025,9 +5031,9 @@ void mas_destroy(struct ma_state *mas)
 
 		__mas_walk(mas, &range_min, &range_max);
 		end = mas_data_end(mas) + 1;
-		if (end < mt_min_slot_count(mas->node) - 1) {
+		if (end < mt_min_slot_count(mas->node) - 1)
 			mas_destroy_rebalance(mas, end);
-		}
+
 		mas->mas_flags &= ~MA_STATE_REBALANCE;
 	}
 	mas->mas_flags &= ~MA_STATE_BULK;
@@ -5036,7 +5042,7 @@ void mas_destroy(struct ma_state *mas)
 		node = mas->alloc;
 		mas->alloc = mas->alloc->slot[0];
 		if (node->node_count > 0)
-			mt_free_bulk(node->node_count, (void**)&node->slot[1]);
+			mt_free_bulk(node->node_count, (void **)&node->slot[1]);
 		kmem_cache_free(maple_node_cache, node);
 	}
 	mas->alloc = NULL;
@@ -5486,7 +5492,7 @@ static inline void mas_dfs_postorder(struct ma_state *mas, unsigned long max)
 
 void mt_validate_nulls(struct maple_tree *mt)
 {
-	void *entry, *last = (void*)1;
+	void *entry, *last = (void *)1;
 	unsigned char end, offset = 0;
 	void **slots;
 	MA_STATE(mas, mt, 0, 0);
@@ -5495,9 +5501,8 @@ void mt_validate_nulls(struct maple_tree *mt)
 	if (mas_is_none(&mas) || (mas.node == MAS_ROOT))
 		return;
 
-	while (!mte_is_leaf(mas.node)) {
+	while (!mte_is_leaf(mas.node))
 		mas_descend(&mas);
-	}
 
 	slots = ma_slots(mte_to_node(mas.node), mte_node_type(mas.node));
 	end = mas_data_end(&mas);
@@ -5520,7 +5525,7 @@ void mt_validate_nulls(struct maple_tree *mt)
 		} else
 			offset++;
 
-	} while(!mas_is_none(&mas));
+	} while (!mas_is_none(&mas));
 }
 /*
  * validate a maple tree by checking:
diff --git a/lib/test_maple_tree.c b/lib/test_maple_tree.c
index ed68357b99d5..59a1561052aa 100644
--- a/lib/test_maple_tree.c
+++ b/lib/test_maple_tree.c
@@ -88,8 +88,9 @@ static noinline void check_load(struct maple_tree *mt, unsigned long index,
 				void *ptr)
 {
 	void *ret = mtree_test_load(mt, index);
+
 	if (ret != ptr)
-		printk("Load %lu returned %p expect %p\n", index, ret, ptr);
+		pr_err("Load %lu returned %p expect %p\n", index, ret, ptr);
 	MT_BUG_ON(mt, ret != ptr);
 }
 
@@ -297,6 +298,7 @@ static noinline void check_new_node(struct maple_tree *mt)
 	MT_BUG_ON(mt, !mas_nomem(&mas, GFP_KERNEL));
 	for (i = total; i > 0; i--) {
 		unsigned int e = 0; // expected node_count
+
 		if (i >= 35)
 			e = i - 35;
 		else if (i >= 5)
@@ -360,7 +362,7 @@ static noinline void check_new_node(struct maple_tree *mt)
 	MT_BUG_ON(mt, !mas.alloc);
 	i = 1;
 	smn = mas.alloc;
-	while(i < total) {
+	while (i < total) {
 		for (j = 0; j < MAPLE_ALLOC_SLOTS; j++) {
 			i++;
 			MT_BUG_ON(mt, !smn->slot[j]);
@@ -494,7 +496,7 @@ static noinline void check_seq(struct maple_tree *mt, unsigned long max,
 		for (j = 0; j <= i; j++)
 			check_index_load(mt, j);
 
-		if(i)
+		if (i)
 			MT_BUG_ON(mt, !mt_height(mt));
 		check_load(mt, i + 1, NULL);
 	}
@@ -1098,6 +1100,7 @@ int mas_ce2_over_count(struct ma_state *mas_start, struct ma_state *mas_end,
 	} else { // !null_entry (store)
 		bool esplit = e_max > mas_end->last;
 		bool ssplit = s_min != mas_start->index;
+
 		if (s_entry && e_entry) {
 			if (esplit && ssplit)
 				count--;
@@ -35225,7 +35228,7 @@ static void check_dfs_preorder(struct maple_tree *mt)
 	do {
 		count++;
 		mas_dfs_preorder(&mas);
-	} while(!mas_is_none(&mas));
+	} while (!mas_is_none(&mas));
 	// 68 + MAS_START = 69 + 1 for no jitter
 	//printk("count %lu\n", count);
 	MT_BUG_ON(mt, count != 70);
@@ -35238,7 +35241,7 @@ static void check_dfs_preorder(struct maple_tree *mt)
 	do {
 		count++;
 		mas_dfs_preorder(&mas);
-	} while(!mas_is_none(&mas));
+	} while (!mas_is_none(&mas));
 	//printk("count %lu\n", count);
 	// 71 + MAS_START = 72 + 1 for no jitter
 	MT_BUG_ON(mt, count != 72);
@@ -35251,7 +35254,7 @@ static void check_dfs_preorder(struct maple_tree *mt)
 	do {
 		count++;
 		mas_dfs_preorder(&mas);
-	} while(!mas_is_none(&mas));
+	} while (!mas_is_none(&mas));
 	// 71 + MAS_START = 72
 	//printk("count %lu\n", count);
 	MT_BUG_ON(mt, count != 77);
@@ -35262,7 +35265,7 @@ static void check_dfs_preorder(struct maple_tree *mt)
 	nr_tallocated = 0;
 	mt_set_non_kernel(200);
 	mas_entry_count(&mas, max);
-	for(count = 0; count <= max; count++) {
+	for (count = 0; count <= max; count++) {
 		mas.index = mas.last = count;
 		mas_store(&mas, xa_mk_value(count));
 		MT_BUG_ON(mt, mas_is_err(&mas));
@@ -35278,9 +35281,9 @@ static void check_dfs_preorder(struct maple_tree *mt)
 
 static noinline void bench_slot_store(struct maple_tree *mt)
 {
-	int i, brk = 105, max = 1040, brk_start= 100, count = 20000000;
+	int i, brk = 105, max = 1040, brk_start = 100, count = 20000000;
 
-	for (i = 0; i < max; i+=10)
+	for (i = 0; i < max; i += 10)
 		mtree_store_range(mt, i, i + 5, xa_mk_value(i), GFP_KERNEL);
 
 	for (i = 0; i < count; i++) {
@@ -35294,7 +35297,7 @@ static noinline void bench_node_store(struct maple_tree *mt)
 {
 	int i, overwrite = 76, max = 240, count = 20000000;
 
-	for (i = 0; i < max; i+=10)
+	for (i = 0; i < max; i += 10)
 		mtree_store_range(mt, i, i + 5, xa_mk_value(i), GFP_KERNEL);
 
 	for (i = 0; i < count; i++) {
@@ -35328,7 +35331,7 @@ static noinline void check_forking(struct maple_tree *mt)
 	mas.index = 0;
 	mas.last = 0;
 	if (mas_entry_count(&newmas, nr_entries)) {
-		printk("OOM!");
+		pr_err("OOM!");
 		BUG_ON(1);
 	}
 	mas_for_each(&mas, val, ULONG_MAX) {
@@ -35379,6 +35382,9 @@ static noinline void bench_forking(struct maple_tree *mt)
 	}
 }
 
+//#define BENCH_SLOT_STORE
+//#define BENCH_NODE_STORE
+//#define BENCH_FORK
 static DEFINE_MTREE(tree);
 static int maple_tree_seed(void)
 {
@@ -35389,19 +35395,22 @@ static int maple_tree_seed(void)
 
 	pr_info("\nTEST STARTING\n\n");
 
-#if 0
+#if BENCH_SLOT_STORE
+#define BENCH
 	mtree_init(&tree, MAPLE_ALLOC_RANGE);
 	bench_slot_store(&tree);
 	mtree_destroy(&tree);
 	goto skip;
 #endif
-#if 0
+#if BENCH_NODE_STORE
+#define BENCH
 	mtree_init(&tree, MAPLE_ALLOC_RANGE);
 	bench_node_store(&tree);
 	mtree_destroy(&tree);
 	goto skip;
 #endif
-#if 0
+#if BENCH_FORK
+#define BENCH
 	mtree_init(&tree, MAPLE_ALLOC_RANGE);
 	bench_forking(&tree);
 	mtree_destroy(&tree);
@@ -35582,7 +35591,9 @@ static int maple_tree_seed(void)
 	check_node_overwrite(&tree);
 	mtree_destroy(&tree);
 
+#if BENCH
 skip:
+#endif
 	rcu_barrier();
 	pr_info("maple_tree: %u of %u tests passed\n", maple_tree_tests_passed,
 			maple_tree_tests_run);