sched/numa: Update NUMA hinting faults once per scan

NUMA hinting fault counts and placement decisions are both recorded in the
same array which distorts the samples in an unpredictable fashion. The values
linearly accumulate during the scan and then decay creating a sawtooth-like
pattern in the per-node counts. It also means that placement decisions are
time sensitive. At best it means that it is very difficult to state that
the buffer holds a decaying average of past faulting behaviour. At worst,
it can confuse the load balancer if it sees one node with an artifically high
count due to very recent faulting activity and may create a bouncing effect.

This patch adds a second array. numa_faults stores the historical data
which is used for placement decisions. numa_faults_buffer holds the
fault activity during the current scan window. When the scan completes,
numa_faults decays and the values from numa_faults_buffer are copied
across.

Signed-off-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1381141781-10992-22-git-send-email-mgorman@suse.de
Signed-off-by: Ingo Molnar <mingo@kernel.org>

diff --git a/include/linux/sched.h b/include/linux/sched.h
index b1fc75e7187b55455720731ad46a67802aaecdf6..a463bc3ad4377ad69b3b58aedcfb4bd64038855b 100644 (file)
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1343,7 +1343,20 @@ struct task_struct {
        u64 node_stamp;                 /* migration stamp  */
        struct callback_head numa_work;
 
+       /*
+        * Exponential decaying average of faults on a per-node basis.
+        * Scheduling placement decisions are made based on the these counts.
+        * The values remain static for the duration of a PTE scan
+        */
        unsigned long *numa_faults;
+
+       /*
+        * numa_faults_buffer records faults per node during the current
+        * scan window. When the scan completes, the counts in numa_faults
+        * decay and these values are copied.
+        */
+       unsigned long *numa_faults_buffer;
+
        int numa_preferred_nid;
 #endif /* CONFIG_NUMA_BALANCING */
 

diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index d15cd70f85b5231628bd6ef8d551939384218c4e..064a0af44540ec58ad60d5d82ebe51f29a26c73f 100644 (file)
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -1636,6 +1636,7 @@ static void __sched_fork(struct task_struct *p)
        p->numa_preferred_nid = -1;
        p->numa_work.next = &p->numa_work;
        p->numa_faults = NULL;
+       p->numa_faults_buffer = NULL;
 #endif /* CONFIG_NUMA_BALANCING */
 }
 

diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index 9efd34f63e8196c9ab56baa9fc3cdbf0e5185047..3abc651bc38a2bdd156d0dec3e8bfc9be007d2ee 100644 (file)
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -892,8 +892,14 @@ static void task_numa_placement(struct task_struct *p)
 
        /* Find the node with the highest number of faults */
        for_each_online_node(nid) {
-               unsigned long faults = p->numa_faults[nid];
+               unsigned long faults;
+
+               /* Decay existing window and copy faults since last scan */
                p->numa_faults[nid] >>= 1;
+               p->numa_faults[nid] += p->numa_faults_buffer[nid];
+               p->numa_faults_buffer[nid] = 0;
+
+               faults = p->numa_faults[nid];
                if (faults > max_faults) {
                        max_faults = faults;
                        max_nid = nid;
@@ -919,9 +925,13 @@ void task_numa_fault(int node, int pages, bool migrated)
        if (unlikely(!p->numa_faults)) {
                int size = sizeof(*p->numa_faults) * nr_node_ids;
 
-               p->numa_faults = kzalloc(size, GFP_KERNEL|__GFP_NOWARN);
+               /* numa_faults and numa_faults_buffer share the allocation */
+               p->numa_faults = kzalloc(size * 2, GFP_KERNEL|__GFP_NOWARN);
                if (!p->numa_faults)
                        return;
+
+               BUG_ON(p->numa_faults_buffer);
+               p->numa_faults_buffer = p->numa_faults + nr_node_ids;
        }
 
        /*
@@ -939,7 +949,7 @@ void task_numa_fault(int node, int pages, bool migrated)
 
        task_numa_placement(p);
 
-       p->numa_faults[node] += pages;
+       p->numa_faults_buffer[node] += pages;
 }
 
 static void reset_ptenuma_scan(struct task_struct *p)