Skip to contentSkip to conversation

Replace hooks with pre/post schedule and wakeup methods

PATCH Dmitry Adamushko 1 participant 1 message Dec 11, 2007 2 messages not in the archive

lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

#2 lore raw
Quoted 18 lines · Steven Rostedt

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.

---
 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
===================================================================

include/linux/sched.h 2007-12-10 20:39:14.000000000 -0500 struct sched_class { · line 853

Quoted 6 lines
include/linux/sched.h 2007-12-10 20:39:14.000000000 -0500 renamed from include/linux/sched.h 2007-12-10 20:39:11.000000000 -0500 +3 -0
@@ -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

include/linux/sched.h 2007-12-10 20:39:14.000000000 -0500 struct sched_class { · line 855

Quoted 2 lines
include/linux/sched.h 2007-12-10 20:39:14.000000000 -0500 renamed from include/linux/sched.h 2007-12-10 20:39:11.000000000 -0500 +0 -0
        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).

Signature · 2 lines
Best regards,
Dmitry Adamushko