On 10/12/18 11:24 PM, David Rientjes wrote:
> The slab allocator has a heuristic that checks whether the internal
> fragmentation is satisfactory and, if not, increases cachep->gfporder to
> try to improve this.
>
> If the amount of waste is the same at higher cachep->gfporder values,
> there is no significant benefit to allocating higher order memory. There
> will be fewer calls to the page allocator, but each call will require
> zone->lock and finding the page of best fit from the per-zone free areas.
>
> Instead, it is better to allocate order-0 memory if possible so that pages
> can be returned from the per-cpu pagesets (pcp).
>
> There are two reasons to prefer this over allocating high order memory:
>
> - allocating from the pcp lists does not require a per-zone lock, and
>
> - this reduces stranding of MIGRATE_UNMOVABLE pageblocks on pcp lists
> that increases slab fragmentation across a zone.
>
> We are particularly interested in the second point to eliminate cases
> where all other pages on a pageblock are movable (or free) and fallback to
> pageblocks of other migratetypes from the per-zone free areas causes
> high-order slab memory to be allocated from them rather than from free
> MIGRATE_UNMOVABLE pages on the pcp.
>
> Signed-off-by: David Rientjes <rientjes@xxxxxxxxxx>
> ---
> mm/slab.c | 15 +++++++++++++++
> 1 file changed, 15 insertions(+)
>
> diff --git a/mm/slab.c b/mm/slab.c
> --- a/mm/slab.c
> +++ b/mm/slab.c
> @@ -1748,6 +1748,7 @@ static size_t calculate_slab_order(struct kmem_cache *cachep,
> for (gfporder = 0; gfporder <= KMALLOC_MAX_ORDER; gfporder++) {
> unsigned int num;
> size_t remainder;
> + int order;
>
> num = cache_estimate(gfporder, size, flags, &remainder);
> if (!num)
> @@ -1803,6 +1804,20 @@ static size_t calculate_slab_order(struct kmem_cache *cachep,
> */
> if (left_over * 8 <= (PAGE_SIZE << gfporder))
> break;
> +
> + /*
> + * If a higher gfporder would not reduce internal fragmentation,
> + * no need to continue. The preference is to keep gfporder as
> + * small as possible so slab allocations can be served from
> + * MIGRATE_UNMOVABLE pcp lists to avoid stranding.
> + */
> + for (order = gfporder + 1; order <= slab_max_order; order++) {
> + cache_estimate(order, size, flags, &remainder);
> + if (remainder < left_over)
I think this can be suboptimal when left_over is e.g. 500 for the lower
order and remainder is 800 for the higher order, so wasted memory per
page is lower, although the absolute value isn't. Can that happen?
Probably not for order-0 vs order-1 case, but for higher orders? In that
case left_order should be shifted left by (gfporder - order) in the
comparison?
> + break;
> + }
> + if (order > slab_max_order)
> + break;
> }
> return left_over;
> }
>
