Re: [PATCH 1/4] Replace hooks with pre/post schedule and wakeup methods

["Dmitry Adamushko" <dmitry.adamushko@gmail.com>]

On 11/12/2007, Steven Rostedt <rostedt@goodmis.org> wrote:
> To make the main sched.c code more agnostic to the schedule classes.
> Instead of having specific hooks in the schedule code for the RT class
> balancing. They are replaced with a pre_schedule, post_schedule
> and task_wake_up methods. These methods may be used by any of the classes
> but currently, only the sched_rt class implements them.
>
> Signed-off-by: Steven Rostedt <srostedt@goodmis.org>
> ---
>  include/linux/sched.h |    3 +++
>  kernel/sched.c        |   20 ++++++++++++++++----
>  kernel/sched_rt.c     |   17 +++++++----------
>  3 files changed, 26 insertions(+), 14 deletions(-)
>
> Index: linux-sched/include/linux/sched.h
> ===================================================================
> --- linux-sched.orig/include/linux/sched.h      2007-12-10 20:39:11.000000000 -0500
> +++ linux-sched/include/linux/sched.h   2007-12-10 20:39:14.000000000 -0500
> @@ -848,6 +848,9 @@ struct sched_class {
>         int (*move_one_task) (struct rq *this_rq, int this_cpu,
>                               struct rq *busiest, struct sched_domain *sd,
>                               enum cpu_idle_type idle);
> +       void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
> +       void (*post_schedule) (struct rq *this_rq);
> +       void (*task_wake_up) (struct rq *this_rq, struct task_struct *task);

IMHO, it looks much better this way.

I had an idea of having a set of defined 'load balancing' points in
sched.c. Then every sched_class would provide smth like struct
load_balance_ops; that contains a number of callbacks (one per load
balancing point) or just one generic load_balance() method with an
additional argument to distinguish between different 'points'. Then we
could have smth like :

generic_load_balance(event, rq, task)
{
      for_each_sched_class (class) {
              if (!class->load_balance)
                       continue;
              if (class->load_balance(event, rq, task))
                       break; /* success, don't propagate any further */
      }
}

[ i.e., the same way we do it in pick_next_task() ]

then e.g. the following block in schedule()

---
#ifdef CONFIG_SMP
       if (prev->sched_class->pre_schedule)
              prev->sched_class->pre_schedule(rq, prev);
#endif

if (unlikely(!rq->nr_running))
          idle_balance(cpu, rq);
---

would be substituted by:

generic_load_balance(PRE_SCHEDULE, rq, prev);

i.e., the following block

>         if (unlikely(!rq->nr_running))
>                 idle_balance(cpu, rq);

is called from sched_class_fair :: load_balance_fair()
upon getting a PRE_SCHEDULE load-balancing point.

IMHO, it would look nicer this way _BUT_ yeah, this 'full' abstraction
adds additional overhead to the hot-path (which might make it not that
worthy).



-- 
Best regards,
Dmitry Adamushko