Commit 37ec97de authored by Rik van Riel's avatar Rik van Riel Committed by Ingo Molnar
Browse files

sched/numa: Slow down scan rate if shared faults dominate 



The comment above update_task_scan_period() says the scan period should
be increased (scanning slows down) if the majority of memory accesses
are on the local node, or if the majority of the page accesses are
shared with other tasks.

However, with the current code, all a high ratio of shared accesses
does is slow down the rate at which scanning is made faster.

This patch changes things so either lots of shared accesses or
lots of local accesses will slow down scanning, and numa scanning
is sped up only when there are lots of private faults on remote
memory pages.

Signed-off-by: default avatarRik van Riel <riel@redhat.com>
Signed-off-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: default avatarMel Gorman <mgorman@suse.de>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: jhladky@redhat.com
Cc: lvenanci@redhat.com
Link: http://lkml.kernel.org/r/20170731192847.23050-2-riel@redhat.com


Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parent f235a54f

kernel/sched/fair.c

+25 −14
Original line number Diff line number Diff line
@@ -1892,7 +1892,7 @@ static void update_task_scan_period(struct task_struct *p, 
			unsigned long shared, unsigned long private)

{

	unsigned int period_slot;

	int ratio;

	int lr_ratio, ps_ratio;

	int diff;



	unsigned long remote = p->numa_faults_locality[0];
@@ -1922,25 +1922,36 @@ static void update_task_scan_period(struct task_struct *p, 
	 *	 >= NUMA_PERIOD_THRESHOLD scan period increases (scan slower)

	 */

	period_slot = DIV_ROUND_UP(p->numa_scan_period, NUMA_PERIOD_SLOTS);

	ratio = (local * NUMA_PERIOD_SLOTS) / (local + remote);

	if (ratio >= NUMA_PERIOD_THRESHOLD) {

		int slot = ratio - NUMA_PERIOD_THRESHOLD;

	lr_ratio = (local * NUMA_PERIOD_SLOTS) / (local + remote);

	ps_ratio = (private * NUMA_PERIOD_SLOTS) / (private + shared);



	if (ps_ratio >= NUMA_PERIOD_THRESHOLD) {

		/*

		 * Most memory accesses are local. There is no need to

		 * do fast NUMA scanning, since memory is already local.

		 */

		int slot = ps_ratio - NUMA_PERIOD_THRESHOLD;

		if (!slot)

			slot = 1;

		diff = slot * period_slot;

	} else if (lr_ratio >= NUMA_PERIOD_THRESHOLD) {

		/*

		 * Most memory accesses are shared with other tasks.

		 * There is no point in continuing fast NUMA scanning,

		 * since other tasks may just move the memory elsewhere.

		 */

		int slot = lr_ratio - NUMA_PERIOD_THRESHOLD;

		if (!slot)

			slot = 1;

		diff = slot * period_slot;

	} else {

		diff = -(NUMA_PERIOD_THRESHOLD - ratio) * period_slot;



		/*

		 * Scale scan rate increases based on sharing. There is an

		 * inverse relationship between the degree of sharing and

		 * the adjustment made to the scanning period. Broadly

		 * speaking the intent is that there is little point

		 * scanning faster if shared accesses dominate as it may

		 * simply bounce migrations uselessly

		 * Private memory faults exceed (SLOTS-THRESHOLD)/SLOTS,

		 * yet they are not on the local NUMA node. Speed up

		 * NUMA scanning to get the memory moved over.

		 */

		ratio = DIV_ROUND_UP(private * NUMA_PERIOD_SLOTS, (private + shared + 1));

		diff = (diff * ratio) / NUMA_PERIOD_SLOTS;

		int ratio = max(lr_ratio, ps_ratio);

		diff = -(NUMA_PERIOD_THRESHOLD - ratio) * period_slot;

	}



	p->numa_scan_period = clamp(p->numa_scan_period + diff,

CRA Git | Maintained and supported by SUSTech CRA and CCSE