Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 87e31886 authored by Ashwini Muduganti's avatar Ashwini Muduganti Committed by Gerrit - the friendly Code Review server
Browse files

Revert "mm: use sc->priority for slab shrink targets" 



This reverts commit 125459f4.

Change-Id: Ifdee460f67a59a5343f2838c1b2b95796ca9e4e4
Signed-off-by: default avatarAshwini Muduganti <amudug@codeaurora.org>
parent 65f5a4b1

include/trace/events/vmscan.h

+13 −10
Original line number Diff line number Diff line
@@ -188,12 +188,12 @@ DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_softlimit_re 


TRACE_EVENT(mm_shrink_slab_start,

	TP_PROTO(struct shrinker *shr, struct shrink_control *sc,

		long nr_objects_to_shrink, unsigned long cache_items,

		unsigned long long delta, unsigned long total_scan,

		int priority),

		long nr_objects_to_shrink, unsigned long pgs_scanned,

		unsigned long lru_pgs, unsigned long cache_items,

		unsigned long long delta, unsigned long total_scan),



	TP_ARGS(shr, sc, nr_objects_to_shrink, cache_items, delta, total_scan,

		priority),

	TP_ARGS(shr, sc, nr_objects_to_shrink, pgs_scanned, lru_pgs,

		cache_items, delta, total_scan),



	TP_STRUCT__entry(

		__field(struct shrinker *, shr)
@@ -201,10 +201,11 @@ TRACE_EVENT(mm_shrink_slab_start, 
		__field(int, nid)

		__field(long, nr_objects_to_shrink)

		__field(gfp_t, gfp_flags)

		__field(unsigned long, pgs_scanned)

		__field(unsigned long, lru_pgs)

		__field(unsigned long, cache_items)

		__field(unsigned long long, delta)

		__field(unsigned long, total_scan)

		__field(int, priority)

	),



	TP_fast_assign(
@@ -213,22 +214,24 @@ TRACE_EVENT(mm_shrink_slab_start, 
		__entry->nid = sc->nid;

		__entry->nr_objects_to_shrink = nr_objects_to_shrink;

		__entry->gfp_flags = sc->gfp_mask;

		__entry->pgs_scanned = pgs_scanned;

		__entry->lru_pgs = lru_pgs;

		__entry->cache_items = cache_items;

		__entry->delta = delta;

		__entry->total_scan = total_scan;

		__entry->priority = priority;

	),



	TP_printk("%pF %p: nid: %d objects to shrink %ld gfp_flags %s cache items %ld delta %lld total_scan %ld priority %d",

	TP_printk("%pF %p: nid: %d objects to shrink %ld gfp_flags %s pgs_scanned %ld lru_pgs %ld cache items %ld delta %lld total_scan %ld",

		__entry->shrink,

		__entry->shr,

		__entry->nid,

		__entry->nr_objects_to_shrink,

		show_gfp_flags(__entry->gfp_flags),

		__entry->pgs_scanned,

		__entry->lru_pgs,

		__entry->cache_items,

		__entry->delta,

		__entry->total_scan,

		__entry->priority)

		__entry->total_scan)

);



TRACE_EVENT(mm_shrink_slab_end,

mm/vmscan.c

+34 −13
Original line number Diff line number Diff line
@@ -317,7 +317,9 @@ EXPORT_SYMBOL(unregister_shrinker); 
#define SHRINK_BATCH 128



static unsigned long do_shrink_slab(struct shrink_control *shrinkctl,

				    struct shrinker *shrinker, int priority)

				    struct shrinker *shrinker,

				    unsigned long nr_scanned,

				    unsigned long nr_eligible)

{

	unsigned long freed = 0;

	unsigned long long delta;
@@ -346,9 +348,9 @@ static unsigned long do_shrink_slab(struct shrink_control *shrinkctl, 
	nr = atomic_long_xchg(&shrinker->nr_deferred[nid], 0);



	total_scan = nr;

	delta = freeable >> priority;

	delta *= 4;

	do_div(delta, shrinker->seeks);

	delta = (4 * nr_scanned) / shrinker->seeks;

	delta *= freeable;

	do_div(delta, nr_eligible + 1);

	total_scan += delta;

	if (total_scan < 0) {

		pr_err("shrink_slab: %pF negative objects to delete nr=%ld\n",
@@ -382,7 +384,8 @@ static unsigned long do_shrink_slab(struct shrink_control *shrinkctl, 
		total_scan = freeable * 2;



	trace_mm_shrink_slab_start(shrinker, shrinkctl, nr,

				   freeable, delta, total_scan, priority);

				   nr_scanned, nr_eligible,

				   freeable, delta, total_scan);



	/*

	 * Normally, we should not scan less than batch_size objects in one
@@ -442,7 +445,8 @@ static unsigned long do_shrink_slab(struct shrink_control *shrinkctl, 
 * @gfp_mask: allocation context

 * @nid: node whose slab caches to target

 * @memcg: memory cgroup whose slab caches to target

 * @priority: the reclaim priority

 * @nr_scanned: pressure numerator

 * @nr_eligible: pressure denominator

 *

 * Call the shrink functions to age shrinkable caches.

 *
@@ -454,14 +458,20 @@ static unsigned long do_shrink_slab(struct shrink_control *shrinkctl, 
 * objects from the memory cgroup specified. Otherwise, only unaware

 * shrinkers are called.

 *

 * @priority is sc->priority, we take the number of objects and >> by priority

 * in order to get the scan target.

 * @nr_scanned and @nr_eligible form a ratio that indicate how much of

 * the available objects should be scanned.  Page reclaim for example

 * passes the number of pages scanned and the number of pages on the

 * LRU lists that it considered on @nid, plus a bias in @nr_scanned

 * when it encountered mapped pages.  The ratio is further biased by

 * the ->seeks setting of the shrink function, which indicates the

 * cost to recreate an object relative to that of an LRU page.

 *

 * Returns the number of reclaimed slab objects.

 */

static unsigned long shrink_slab(gfp_t gfp_mask, int nid,

				 struct mem_cgroup *memcg,

				 int priority)

				 unsigned long nr_scanned,

				 unsigned long nr_eligible)

{

	struct shrinker *shrinker;

	unsigned long freed = 0;
@@ -469,6 +479,9 @@ static unsigned long shrink_slab(gfp_t gfp_mask, int nid, 
	if (memcg && (!memcg_kmem_enabled() || !mem_cgroup_online(memcg)))

		return 0;



	if (nr_scanned == 0)

		nr_scanned = SWAP_CLUSTER_MAX;



	if (!down_read_trylock(&shrinker_rwsem)) {

		/*

		 * If we would return 0, our callers would understand that we
@@ -499,7 +512,7 @@ static unsigned long shrink_slab(gfp_t gfp_mask, int nid, 
		if (!(shrinker->flags & SHRINKER_NUMA_AWARE))

			sc.nid = 0;



		freed += do_shrink_slab(&sc, shrinker, priority);

		freed += do_shrink_slab(&sc, shrinker, nr_scanned, nr_eligible);

	}



	up_read(&shrinker_rwsem);
@@ -517,7 +530,8 @@ void drop_slab_node(int nid) 


		freed = 0;

		do {

			freed += shrink_slab(GFP_KERNEL, nid, memcg, 0);

			freed += shrink_slab(GFP_KERNEL, nid, memcg,

					     1000, 1000);

		} while ((memcg = mem_cgroup_iter(NULL, memcg, NULL)) != NULL);

	} while (freed > 10);

}
@@ -2698,12 +2712,14 @@ static bool shrink_node(pg_data_t *pgdat, struct scan_control *sc) 


			reclaimed = sc->nr_reclaimed;

			scanned = sc->nr_scanned;



			shrink_node_memcg(pgdat, memcg, sc, &lru_pages);

			node_lru_pages += lru_pages;



			if (memcg)

				shrink_slab(sc->gfp_mask, pgdat->node_id,

					    memcg, sc->priority);

					    memcg, sc->nr_scanned - scanned,

					    lru_pages);



			/* Record the group's reclaim efficiency */

			vmpressure(sc->gfp_mask, memcg, false,
@@ -2727,9 +2743,14 @@ static bool shrink_node(pg_data_t *pgdat, struct scan_control *sc) 
			}

		} while ((memcg = mem_cgroup_iter(root, memcg, &reclaim)));



		/*

		 * Shrink the slab caches in the same proportion that

		 * the eligible LRU pages were scanned.

		 */

		if (global_reclaim(sc))

			shrink_slab(sc->gfp_mask, pgdat->node_id, NULL,

				    sc->priority);

				    sc->nr_scanned - nr_scanned,

				    node_lru_pages);



		/*

		 * Record the subtree's reclaim efficiency. The reclaimed