lkml.org 
[lkml]   [2016]   [Jun]   [13]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Date
    Subject[PATCH 3.16 109/114] sched: Replace post_schedule with a balance callback list
    3.16.36-rc1 review patch.  If anyone has any objections, please let me know.

    ------------------

    From: Peter Zijlstra <peterz@infradead.org>

    commit e3fca9e7cbfb72694a21c886fcdf9f059cfded9c upstream.

    Generalize the post_schedule() stuff into a balance callback list.
    This allows us to more easily use it outside of schedule() and cross
    sched_class.

    Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
    Cc: ktkhai@parallels.com
    Cc: rostedt@goodmis.org
    Cc: juri.lelli@gmail.com
    Cc: pang.xunlei@linaro.org
    Cc: oleg@redhat.com
    Cc: wanpeng.li@linux.intel.com
    Cc: umgwanakikbuti@gmail.com
    Link: http://lkml.kernel.org/r/20150611124742.424032725@infradead.org
    Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
    [Conflicts: kernel/sched/core.c]
    Signed-off-by: Byungchul Park <byungchul.park@lge.com>
    Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
    ---
    kernel/sched/core.c | 36 ++++++++++++++++++++++++------------
    kernel/sched/deadline.c | 21 +++++++++++----------
    kernel/sched/rt.c | 25 +++++++++++--------------
    kernel/sched/sched.h | 19 +++++++++++++++++--
    4 files changed, 63 insertions(+), 38 deletions(-)

    --- a/kernel/sched/core.c
    +++ b/kernel/sched/core.c
    @@ -2258,23 +2258,35 @@ static void finish_task_switch(struct rq
    #ifdef CONFIG_SMP

    /* rq->lock is NOT held, but preemption is disabled */
    -static inline void post_schedule(struct rq *rq)
    +static void __balance_callback(struct rq *rq)
    {
    - if (rq->post_schedule) {
    - unsigned long flags;
    + struct callback_head *head, *next;
    + void (*func)(struct rq *rq);
    + unsigned long flags;

    - raw_spin_lock_irqsave(&rq->lock, flags);
    - if (rq->curr->sched_class->post_schedule)
    - rq->curr->sched_class->post_schedule(rq);
    - raw_spin_unlock_irqrestore(&rq->lock, flags);
    + raw_spin_lock_irqsave(&rq->lock, flags);
    + head = rq->balance_callback;
    + rq->balance_callback = NULL;
    + while (head) {
    + func = (void (*)(struct rq *))head->func;
    + next = head->next;
    + head->next = NULL;
    + head = next;

    - rq->post_schedule = 0;
    + func(rq);
    }
    + raw_spin_unlock_irqrestore(&rq->lock, flags);
    +}
    +
    +static inline void balance_callback(struct rq *rq)
    +{
    + if (unlikely(rq->balance_callback))
    + __balance_callback(rq);
    }

    #else

    -static inline void post_schedule(struct rq *rq)
    +static inline void balance_callback(struct rq *rq)
    {
    }

    @@ -2295,7 +2307,7 @@ asmlinkage __visible void schedule_tail(
    * FIXME: do we need to worry about rq being invalidated by the
    * task_switch?
    */
    - post_schedule(rq);
    + balance_callback(rq);

    #ifdef __ARCH_WANT_UNLOCKED_CTXSW
    /* In this case, finish_task_switch does not reenable preemption */
    @@ -2822,7 +2834,7 @@ need_resched:
    } else
    raw_spin_unlock_irq(&rq->lock);

    - post_schedule(rq);
    + balance_callback(rq);

    sched_preempt_enable_no_resched();
    if (need_resched())
    @@ -7001,7 +7013,7 @@ void __init sched_init(void)
    rq->sd = NULL;
    rq->rd = NULL;
    rq->cpu_capacity = SCHED_CAPACITY_SCALE;
    - rq->post_schedule = 0;
    + rq->balance_callback = NULL;
    rq->active_balance = 0;
    rq->next_balance = jiffies;
    rq->push_cpu = 0;
    --- a/kernel/sched/deadline.c
    +++ b/kernel/sched/deadline.c
    @@ -213,9 +213,16 @@ static inline bool need_pull_dl_task(str
    return dl_task(prev);
    }

    -static inline void set_post_schedule(struct rq *rq)
    +static DEFINE_PER_CPU(struct callback_head, dl_balance_head);
    +
    +static void push_dl_tasks(struct rq *);
    +
    +static inline void queue_push_tasks(struct rq *rq)
    {
    - rq->post_schedule = has_pushable_dl_tasks(rq);
    + if (!has_pushable_dl_tasks(rq))
    + return;
    +
    + queue_balance_callback(rq, &per_cpu(dl_balance_head, rq->cpu), push_dl_tasks);
    }

    #else
    @@ -250,7 +257,7 @@ static inline int pull_dl_task(struct rq
    return 0;
    }

    -static inline void set_post_schedule(struct rq *rq)
    +static inline void queue_push_tasks(struct rq *rq)
    {
    }
    #endif /* CONFIG_SMP */
    @@ -1043,7 +1050,7 @@ struct task_struct *pick_next_task_dl(st
    start_hrtick_dl(rq, p);
    #endif

    - set_post_schedule(rq);
    + queue_push_tasks(rq);

    return p;
    }
    @@ -1452,11 +1459,6 @@ skip:
    return ret;
    }

    -static void post_schedule_dl(struct rq *rq)
    -{
    - push_dl_tasks(rq);
    -}
    -
    /*
    * Since the task is not running and a reschedule is not going to happen
    * anytime soon on its runqueue, we try pushing it away now.
    @@ -1644,7 +1646,6 @@ const struct sched_class dl_sched_class
    .set_cpus_allowed = set_cpus_allowed_dl,
    .rq_online = rq_online_dl,
    .rq_offline = rq_offline_dl,
    - .post_schedule = post_schedule_dl,
    .task_woken = task_woken_dl,
    #endif

    --- a/kernel/sched/rt.c
    +++ b/kernel/sched/rt.c
    @@ -338,13 +338,16 @@ static inline int has_pushable_tasks(str
    return !plist_head_empty(&rq->rt.pushable_tasks);
    }

    -static inline void set_post_schedule(struct rq *rq)
    +static DEFINE_PER_CPU(struct callback_head, rt_balance_head);
    +
    +static void push_rt_tasks(struct rq *);
    +
    +static inline void queue_push_tasks(struct rq *rq)
    {
    - /*
    - * We detect this state here so that we can avoid taking the RQ
    - * lock again later if there is no need to push
    - */
    - rq->post_schedule = has_pushable_tasks(rq);
    + if (!has_pushable_tasks(rq))
    + return;
    +
    + queue_balance_callback(rq, &per_cpu(rt_balance_head, rq->cpu), push_rt_tasks);
    }

    static void enqueue_pushable_task(struct rq *rq, struct task_struct *p)
    @@ -401,7 +404,7 @@ static inline int pull_rt_task(struct rq
    return 0;
    }

    -static inline void set_post_schedule(struct rq *rq)
    +static inline void queue_push_tasks(struct rq *rq)
    {
    }
    #endif /* CONFIG_SMP */
    @@ -1472,7 +1475,7 @@ pick_next_task_rt(struct rq *rq, struct
    if (p)
    dequeue_pushable_task(rq, p);

    - set_post_schedule(rq);
    + queue_push_tasks(rq);

    return p;
    }
    @@ -1852,11 +1855,6 @@ skip:
    return ret;
    }

    -static void post_schedule_rt(struct rq *rq)
    -{
    - push_rt_tasks(rq);
    -}
    -
    /*
    * If we are not running and we are not going to reschedule soon, we should
    * try to push tasks away now
    @@ -2128,7 +2126,6 @@ const struct sched_class rt_sched_class
    .set_cpus_allowed = set_cpus_allowed_rt,
    .rq_online = rq_online_rt,
    .rq_offline = rq_offline_rt,
    - .post_schedule = post_schedule_rt,
    .task_woken = task_woken_rt,
    .switched_from = switched_from_rt,
    #endif
    --- a/kernel/sched/sched.h
    +++ b/kernel/sched/sched.h
    @@ -569,9 +569,10 @@ struct rq {

    unsigned long cpu_capacity;

    + struct callback_head *balance_callback;
    +
    unsigned char idle_balance;
    /* For active balancing */
    - int post_schedule;
    int active_balance;
    int push_cpu;
    struct cpu_stop_work active_balance_work;
    @@ -670,6 +671,21 @@ extern int migrate_swap(struct task_stru

    #ifdef CONFIG_SMP

    +static inline void
    +queue_balance_callback(struct rq *rq,
    + struct callback_head *head,
    + void (*func)(struct rq *rq))
    +{
    + lockdep_assert_held(&rq->lock);
    +
    + if (unlikely(head->next))
    + return;
    +
    + head->func = (void (*)(struct callback_head *))func;
    + head->next = rq->balance_callback;
    + rq->balance_callback = head;
    +}
    +
    extern void sched_ttwu_pending(void);

    #define rcu_dereference_check_sched_domain(p) \
    @@ -1127,7 +1143,6 @@ struct sched_class {
    int (*select_task_rq)(struct task_struct *p, int task_cpu, int sd_flag, int flags);
    void (*migrate_task_rq)(struct task_struct *p, int next_cpu);

    - void (*post_schedule) (struct rq *this_rq);
    void (*task_waking) (struct task_struct *task);
    void (*task_woken) (struct rq *this_rq, struct task_struct *task);

    \
     
     \ /
      Last update: 2016-06-13 21:21    [W:2.196 / U:0.624 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site