lkml.org 
[lkml]   [2010]   [Sep]   [18]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[084/123] sched: Remove the cfs_rq dependency from set_task_cpu()
    From: Peter Zijlstra <a.p.zijlstra@chello.nl>

    commit 88ec22d3edb72b261f8628226cd543589a6d5e1b upstream

    In order to remove the cfs_rq dependency from set_task_cpu() we
    need to ensure the task is cfs_rq invariant for all callsites.

    The simple approach is to substract cfs_rq->min_vruntime from
    se->vruntime on dequeue, and add cfs_rq->min_vruntime on
    enqueue.

    However, this has the downside of breaking FAIR_SLEEPERS since
    we loose the old vruntime as we only maintain the relative
    position.

    To solve this, we observe that we only migrate runnable tasks,
    we do this using deactivate_task(.sleep=0) and
    activate_task(.wakeup=0), therefore we can restrain the
    min_vruntime invariance to that state.

    The only other case is wakeup balancing, since we want to
    maintain the old vruntime we cannot make it relative on dequeue,
    but since we don't migrate inactive tasks, we can do so right
    before we activate it again.

    This is where we need the new pre-wakeup hook, we need to call
    this while still holding the old rq->lock. We could fold it into
    ->select_task_rq(), but since that has multiple callsites and
    would obfuscate the locking requirements, that seems like a
    fudge.

    This leaves the fork() case, simply make sure that ->task_fork()
    leaves the ->vruntime in a relative state.

    This covers all cases where set_task_cpu() gets called, and
    ensures it sees a relative vruntime.

    Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
    Cc: Mike Galbraith <efault@gmx.de>
    LKML-Reference: <20091216170518.191697025@chello.nl>
    Signed-off-by: Ingo Molnar <mingo@elte.hu>
    Signed-off-by: Mike Galbraith <efault@gmx.de>
    Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
    ---
    include/linux/sched.h | 2 +-
    kernel/sched.c | 6 +-----
    kernel/sched_fair.c | 50 ++++++++++++++++++++++++++++++++++++++++++++------
    3 files changed, 46 insertions(+), 12 deletions(-)

    --- a/include/linux/sched.h
    +++ b/include/linux/sched.h
    @@ -1118,7 +1118,7 @@ struct sched_class {
    struct task_struct *task);

    #ifdef CONFIG_FAIR_GROUP_SCHED
    - void (*moved_group) (struct task_struct *p);
    + void (*moved_group) (struct task_struct *p, int on_rq);
    #endif
    };

    --- a/kernel/sched.c
    +++ b/kernel/sched.c
    @@ -2063,8 +2063,6 @@ task_hot(struct task_struct *p, u64 now,
    void set_task_cpu(struct task_struct *p, unsigned int new_cpu)
    {
    int old_cpu = task_cpu(p);
    - struct cfs_rq *old_cfsrq = task_cfs_rq(p),
    - *new_cfsrq = cpu_cfs_rq(old_cfsrq, new_cpu);

    #ifdef CONFIG_SCHED_DEBUG
    /*
    @@ -2082,8 +2080,6 @@ void set_task_cpu(struct task_struct *p,
    perf_sw_event(PERF_COUNT_SW_CPU_MIGRATIONS,
    1, 1, NULL, 0);
    }
    - p->se.vruntime -= old_cfsrq->min_vruntime -
    - new_cfsrq->min_vruntime;

    __set_task_cpu(p, new_cpu);
    }
    @@ -10144,7 +10140,7 @@ void sched_move_task(struct task_struct

    #ifdef CONFIG_FAIR_GROUP_SCHED
    if (tsk->sched_class->moved_group)
    - tsk->sched_class->moved_group(tsk);
    + tsk->sched_class->moved_group(tsk, on_rq);
    #endif

    if (unlikely(running))
    --- a/kernel/sched_fair.c
    +++ b/kernel/sched_fair.c
    @@ -488,6 +488,7 @@ __update_curr(struct cfs_rq *cfs_rq, str
    curr->sum_exec_runtime += delta_exec;
    schedstat_add(cfs_rq, exec_clock, delta_exec);
    delta_exec_weighted = calc_delta_fair(delta_exec, curr);
    +
    curr->vruntime += delta_exec_weighted;
    update_min_vruntime(cfs_rq);
    }
    @@ -743,16 +744,26 @@ place_entity(struct cfs_rq *cfs_rq, stru
    se->vruntime = vruntime;
    }

    +#define ENQUEUE_WAKEUP 1
    +#define ENQUEUE_MIGRATE 2
    +
    static void
    -enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int wakeup)
    +enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
    {
    /*
    + * Update the normalized vruntime before updating min_vruntime
    + * through callig update_curr().
    + */
    + if (!(flags & ENQUEUE_WAKEUP) || (flags & ENQUEUE_MIGRATE))
    + se->vruntime += cfs_rq->min_vruntime;
    +
    + /*
    * Update run-time statistics of the 'current'.
    */
    update_curr(cfs_rq);
    account_entity_enqueue(cfs_rq, se);

    - if (wakeup) {
    + if (flags & ENQUEUE_WAKEUP) {
    place_entity(cfs_rq, se, 0);
    enqueue_sleeper(cfs_rq, se);
    }
    @@ -806,6 +817,14 @@ dequeue_entity(struct cfs_rq *cfs_rq, st
    __dequeue_entity(cfs_rq, se);
    account_entity_dequeue(cfs_rq, se);
    update_min_vruntime(cfs_rq);
    +
    + /*
    + * Normalize the entity after updating the min_vruntime because the
    + * update can refer to the ->curr item and we need to reflect this
    + * movement in our normalized position.
    + */
    + if (!sleep)
    + se->vruntime -= cfs_rq->min_vruntime;
    }

    /*
    @@ -1016,13 +1035,19 @@ static void enqueue_task_fair(struct rq
    {
    struct cfs_rq *cfs_rq;
    struct sched_entity *se = &p->se;
    + int flags = 0;
    +
    + if (wakeup)
    + flags |= ENQUEUE_WAKEUP;
    + if (p->state == TASK_WAKING)
    + flags |= ENQUEUE_MIGRATE;

    for_each_sched_entity(se) {
    if (se->on_rq)
    break;
    cfs_rq = cfs_rq_of(se);
    - enqueue_entity(cfs_rq, se, wakeup);
    - wakeup = 1;
    + enqueue_entity(cfs_rq, se, flags);
    + flags = ENQUEUE_WAKEUP;
    }

    hrtick_update(rq);
    @@ -1098,6 +1123,14 @@ static void yield_task_fair(struct rq *r

    #ifdef CONFIG_SMP

    +static void task_waking_fair(struct rq *rq, struct task_struct *p)
    +{
    + struct sched_entity *se = &p->se;
    + struct cfs_rq *cfs_rq = cfs_rq_of(se);
    +
    + se->vruntime -= cfs_rq->min_vruntime;
    +}
    +
    #ifdef CONFIG_FAIR_GROUP_SCHED
    /*
    * effective_load() calculates the load change as seen from the root_task_group
    @@ -1943,6 +1976,8 @@ static void task_fork_fair(struct task_s
    resched_task(rq->curr);
    }

    + se->vruntime -= cfs_rq->min_vruntime;
    +
    spin_unlock_irqrestore(&rq->lock, flags);
    }

    @@ -1996,12 +2031,13 @@ static void set_curr_task_fair(struct rq
    }

    #ifdef CONFIG_FAIR_GROUP_SCHED
    -static void moved_group_fair(struct task_struct *p)
    +static void moved_group_fair(struct task_struct *p, int on_rq)
    {
    struct cfs_rq *cfs_rq = task_cfs_rq(p);

    update_curr(cfs_rq);
    - place_entity(cfs_rq, &p->se, 1);
    + if (!on_rq)
    + place_entity(cfs_rq, &p->se, 1);
    }
    #endif

    @@ -2041,6 +2077,8 @@ static const struct sched_class fair_sch
    .move_one_task = move_one_task_fair,
    .rq_online = rq_online_fair,
    .rq_offline = rq_offline_fair,
    +
    + .task_waking = task_waking_fair,
    #endif

    .set_curr_task = set_curr_task_fair,



    \
     
     \ /
      Last update: 2010-09-18 21:45    [W:0.031 / U:0.492 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site