optimize a bunch of junk

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

diff --git a/lib/maple_tree.c b/lib/maple_tree.c
index ec971af3397b9a3e9cb1590864e8b4f46edc9c08..99d1807c1b80ace2d41d6b96915f8f2bbc04549d 100644 (file)
--- a/lib/maple_tree.c
+++ b/lib/maple_tree.c
@@ -2246,24 +2246,35 @@ static inline void mas_wr_node_walk(struct ma_wr_state *wr_mas)
 {
        struct ma_state *mas = wr_mas->mas;
        unsigned char count, offset;
+       unsigned long *pivs;
+       unsigned long index;
 
+
+       index = mas->index;
        if (unlikely(ma_is_dense(wr_mas->type))) {
-               wr_mas->r_max = wr_mas->r_min = mas->index;
+               wr_mas->r_max = wr_mas->r_min = index;
                mas->offset = mas->index = mas->min;
                return;
        }
 
        wr_mas->node = mas_mn(wr_mas->mas);
-       wr_mas->pivots = ma_pivots(wr_mas->node, wr_mas->type);
+       pivs = wr_mas->pivots = ma_pivots(wr_mas->node, wr_mas->type);
        count = mas->end = ma_data_end(wr_mas->node, wr_mas->type,
-                                      wr_mas->pivots, mas->max);
+                                      pivs, mas->max);
        offset = mas->offset;
 
-       while (offset < count && mas->index > wr_mas->pivots[offset])
+       if (index > pivs[count - 1]) {
+               wr_mas->r_max = mas->max;
+               wr_mas->offset_end = mas->offset = count;
+               wr_mas->r_min = pivs[count - 1] + 1;
+               return;
+       }
+
+       while (index > pivs[offset])
                offset++;
 
-       wr_mas->r_max = offset < count ? wr_mas->pivots[offset] : mas->max;
-       wr_mas->r_min = mas_safe_min(mas, wr_mas->pivots, offset);
+       wr_mas->r_max = pivs[offset];
+       wr_mas->r_min = mas_safe_min(mas, pivs, offset);
        wr_mas->offset_end = mas->offset = offset;
 }
 
@@ -4536,16 +4547,24 @@ static inline void mas_wr_extend_null(struct ma_wr_state *wr_mas)
        }
 }
 
-static inline void mas_wr_end_piv(struct ma_wr_state *wr_mas)
+static __always_inline void mas_wr_end_piv(struct ma_wr_state *wr_mas)
 {
-       while ((wr_mas->offset_end < wr_mas->mas->end) &&
-              (wr_mas->mas->last > wr_mas->pivots[wr_mas->offset_end]))
-               wr_mas->offset_end++;
+       unsigned char offset_end;
+       unsigned long last = wr_mas->mas->last;
+       unsigned long *pivs = wr_mas->pivots;
 
-       if (wr_mas->offset_end < wr_mas->mas->end)
-               wr_mas->end_piv = wr_mas->pivots[wr_mas->offset_end];
-       else
+       if (last > pivs[wr_mas->mas->end - 1]) {
+               wr_mas->offset_end = wr_mas->mas->end;
                wr_mas->end_piv = wr_mas->mas->max;
+               return;
+       }
+
+       offset_end = wr_mas->offset_end;
+       while (last > pivs[offset_end])
+               offset_end++;
+
+       wr_mas->end_piv = pivs[offset_end];
+       wr_mas->offset_end = offset_end;
 }
 
 /*
@@ -4648,12 +4667,12 @@ static inline void mas_wr_store_entry(struct ma_wr_state *wr_mas)
        case wr_store_root:
                mas_store_root(mas, wr_mas->entry);
                break;
-       case wr_append:
-               mas_wr_append(wr_mas, new_end);
-               break;
        case wr_spanning_store:
                mas_wr_spanning_store(wr_mas);
                break;
+       case wr_append:
+               mas_wr_append(wr_mas, new_end);
+               break;
        case wr_invalid:
                MT_BUG_ON(mas->tree, 1);
                return;
@@ -4776,6 +4795,7 @@ static inline enum store_type mas_wr_store_type(struct ma_wr_state *wr_mas)
        mas_wr_end_piv(wr_mas);
        if (!wr_mas->entry)
                mas_wr_extend_null(wr_mas);
+       new_end = mas_wr_new_end(wr_mas);
 
        if ((wr_mas->r_min == mas->index) && (wr_mas->r_max == mas->last))
                return wr_exact_fit;
@@ -4783,7 +4803,6 @@ static inline enum store_type mas_wr_store_type(struct ma_wr_state *wr_mas)
        if (unlikely(!mas->index && mas->last == ULONG_MAX))
                return wr_new_root;
 
-       new_end = mas_wr_new_end(wr_mas);
        /* Potential spanning rebalance collapsing a node */
        if (new_end < mt_min_slots[wr_mas->type]) {
                if (!mte_is_root(mas->node) && !(mas->mas_flags & MA_STATE_BULK))