lkml.org 
[lkml]   [2017]   [Jul]   [31]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[RHEL-ALT-7.4 PATCH 1/2] numa,sched: slow down scan rate if shared faults dominate
    Date
    From: Rik van Riel <riel@redhat.com>

    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: Rik van Riel <riel@redhat.com>
    ---
    kernel/sched/fair.c | 39 +++++++++++++++++++++++++--------------
    1 file changed, 25 insertions(+), 14 deletions(-)

    diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
    index 5d98836d9f73..f8481b24a834 100644
    --- a/kernel/sched/fair.c
    +++ b/kernel/sched/fair.c
    @@ -1897,7 +1897,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];
    @@ -1927,25 +1927,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,
    --
    2.9.4
    \
     
     \ /
      Last update: 2017-07-31 21:36    [W:3.069 / U:0.156 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site