mm/slub: remove min_objects loop from calculate_order()

calculate_order() currently has two nested loops. The inner one that
gradually modifies the acceptable waste from 1/16 up to 1/4, and the
outer one that decreases min_objects down to 2.

Upon closer inspection, the outer loop is unnecessary. Decreasing
min_objects could have in theory two effects to make the inner loop and
its call to calc_slab_order() succeed where a previous iteration with
higher min_objects would not:

- it could cause the min_objects-derived min_order to fit within
  slub_max_order. But min_objects is already pre-capped to max_objects
  that's derived from slub_max_order above the loops, so every iteration
  tries at least slub_max_order in calc_slab_order()

- it could cause calc_slab_order() to be called with lower min_objects
  thus potentially lower min_order in its loop. This would make a
  difference if the lower order could cause the fractional waste test to
  succeed where a higher order has already failed with same fract_leftover
  in the previous iteration with a higher min_order. But that's not
  possible, because increasing the order can only result in lower (or
  same) fractional waste. If we increase the slab size 2 times, we will
  fit at least 2 times the number of objects (thus same fraction of
  waste), or it will allow us to fit one more object (lower fraction of
  waste).

For more confidence I have tried adding a printk to notify when
decreasing min_objects resulted in a success, and simulated calculations
for a range of object sizes, nr_cpus and page_sizes. As expected, the
printk never triggered.

Thus remove the outer loop and adjust comments accordingly.

There's almost no functional change except a weird corner case when
slub_min_objects=1 on boot command line would cause the whole two nested
loops to be skipped before this patch. Now it would try to find the best
layout as usual, resulting in potentially higher orderthat minimizes
waste. This is not wrong and will be further expanded by the next patch.

Signed-off-by: Vlastimil Babka <vbabka@suse.cz>
Reviewed-by: Feng Tang <feng.tang@intel.com>
Reviewed-and-tested-by: Jay Patel <jaypatel@linux.ibm.com>

diff --git a/mm/slub.c b/mm/slub.c
index 0710adb5642ac766abbc93cd333d8c982ba2a1b4..c4b5f48149e863270c732617e1084c8c84365d74 100644 (file)
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -4141,14 +4141,6 @@ static inline int calculate_order(unsigned int size)
        unsigned int max_objects;
        unsigned int nr_cpus;
 
-       /*
-        * Attempt to find best configuration for a slab. This
-        * works by first attempting to generate a layout with
-        * the best configuration and backing off gradually.
-        *
-        * First we increase the acceptable waste in a slab. Then
-        * we reduce the minimum objects required in a slab.
-        */
        min_objects = slub_min_objects;
        if (!min_objects) {
                /*
@@ -4168,18 +4160,24 @@ static inline int calculate_order(unsigned int size)
        max_objects = order_objects(slub_max_order, size);
        min_objects = min(min_objects, max_objects);
 
-       while (min_objects > 1) {
-               unsigned int fraction;
-
-               fraction = 16;
-               while (fraction >= 4) {
-                       order = calc_slab_order(size, min_objects,
-                                       slub_max_order, fraction);
-                       if (order <= slub_max_order)
-                               return order;
-                       fraction /= 2;
-               }
-               min_objects--;
+       /*
+        * Attempt to find best configuration for a slab. This works by first
+        * attempting to generate a layout with the best possible configuration
+        * and backing off gradually.
+        *
+        * We start with accepting at most 1/16 waste and try to find the
+        * smallest order from min_objects-derived/slub_min_order up to
+        * slub_max_order that will satisfy the constraint. Note that increasing
+        * the order can only result in same or less fractional waste, not more.
+        *
+        * If that fails, we increase the acceptable fraction of waste and try
+        * again.
+        */
+       for (unsigned int fraction = 16; fraction >= 4; fraction /= 2) {
+               order = calc_slab_order(size, min_objects, slub_max_order,
+                                       fraction);
+               if (order <= slub_max_order)
+                       return order;
        }
 
        /*