From: "Liam R. Howlett" <liam.howl...@oracle.com>

commit a3c63c8c5df6406e79490456a1fc41a287676070 upstream.

mtree_range_walk() needed to be updated to avoid checking if there was a
pivot value.  On closer examination, the code could avoid setting min or
max in certain scenarios.  The commit removes the extra check for
pivot[offset] before setting max and only sets max when necessary.  It
also only sets min if it is necessary by checking offset 0 prior to the
loop (as it has always done).

The commit also drops a dead node check since the end of the node will
return the array size when the last slot is occupied (by a potential reuse
in a dead node).  The data will be discarded later if the node is marked
dead.

Benchmarking these changes results in an increase in performance of 5.45%
using the BENCH_WALK in the maple tree test code.

Link: 
https://lkml.kernel.org/r/20231101171629.3612299-13-liam.howl...@oracle.com
Signed-off-by: Liam R. Howlett <liam.howl...@oracle.com>
Cc: Peng Zhang <zhangpeng...@bytedance.com>
Signed-off-by: Andrew Morton <a...@linux-foundation.org>
Signed-off-by: Yu Kuai <yuku...@huawei.com>
---
 lib/maple_tree.c | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/lib/maple_tree.c b/lib/maple_tree.c
index ad8bf3413889..d90f4b7e7511 100644
--- a/lib/maple_tree.c
+++ b/lib/maple_tree.c
@@ -2806,32 +2806,29 @@ static inline void *mtree_range_walk(struct ma_state 
*mas)
        min = mas->min;
        max = mas->max;
        do {
-               offset = 0;
                last = next;
                node = mte_to_node(next);
                type = mte_node_type(next);
                pivots = ma_pivots(node, type);
                end = ma_data_end(node, type, pivots, max);
-               if (unlikely(ma_dead_node(node)))
-                       goto dead_node;
-
-               if (pivots[offset] >= mas->index) {
-                       prev_max = max;
-                       prev_min = min;
-                       max = pivots[offset];
+               prev_min = min;
+               prev_max = max;
+               if (pivots[0] >= mas->index) {
+                       offset = 0;
+                       max = pivots[0];
                        goto next;
                }
 
-               do {
+               offset = 1;
+               while (offset < end) {
+                       if (pivots[offset] >= mas->index) {
+                               max = pivots[offset];
+                               break;
+                       }
                        offset++;
-               } while ((offset < end) && (pivots[offset] < mas->index));
+               }
 
-               prev_min = min;
                min = pivots[offset - 1] + 1;
-               prev_max = max;
-               if (likely(offset < end && pivots[offset]))
-                       max = pivots[offset];
-
 next:
                slots = ma_slots(node, type);
                next = mt_slot(mas->tree, slots, offset);
-- 
2.39.2

Reply via email to