Understanding dequeue_rt_stack() for RT scheduling class linux

Question

enqueue_task_rt function in ./kernel/sched/rt.c is responsible for queuing the task to the run queue. enqueue_task_rt contains call to enqueue_rt_entity which calls dequeue_rt_stack . Most part of the code seems logical but I am a bit lost because of the function dequeue_rt_stack unable to understand what it does. Can somebody tell what is the logic that I am missing or suggest some good read.

Edit: The following is the code for dequeue_rt_stack function

     struct sched_rt_entity *back = NULL;
     /* macro for_each_sched_rt_entity defined as
     for(; rt_se; rt_se = rt_se->parent)*/
     for_each_sched_rt_entity(rt_se) {
             rt_se->back = back;
             back = rt_se;
     }

     for (rt_se = back; rt_se; rt_se = rt_se->back) {
             if (on_rt_rq(rt_se))
                     __dequeue_rt_entity(rt_se);
     }

More specifically, I do not understand why there is a need for this code:

     for_each_sched_rt_entity(rt_se) {
             rt_se->back = back;
             back = rt_se;
     }

What is its relevance.

Answer 1

When a task is to be added to some queue, it must first be removed from the queue that it currently is on, if any.

With the group scheduler , a task is always at the lowest level of the tree, and might have multiple ancestors:

       NULL
         ^
         |
+-----parent------+
|                 |
| top-level group |
|                 |
+-----------------+
         ^      ^_____________
         |                    \
+-----parent------+   +-----parent------+
|                 |   |                 |
| mid-level group |   |   other group   |  ...
|                 |   |                 |
+-----------------+   +-----------------+
         ^      ^_____________
         |                    \
+-----parent------+   +-----------------+
|                 |   |                 |
|      task       |   |   other task    |  ...
|                 |   |                 |
+-----------------+   +-----------------+

To remove the task from the tree, it must be removed from all groups' queues, and this must be done first at the top-level group (otherwise, the scheduler might try to run an already partially-removed task). Therefore, dequeue_rt_stack uses the back pointers to constructs a list in the opposite direction:

   NULL    back
     ^      |
     |      V
+-parent----------+
|                 |
| top-level group |
|                 |
+----------back---+
     ^      |   ^_____________
     |      V                 \
+-parent----------+   +-----parent------+
|                 |   |                 |
| mid-level group |   |   other group   |  ...
|                 |   |                 |
+----------back---+   +-----------------+
     ^      |   ^_____________
     |      V                 \
+-parent----------+   +-----------------+
|                 |   |                 |
|      task       |   |   other task    |  ...
|                 |   |                 |
+----------back---+   +-----------------+
            |
            V
           NULL

That back list can then be used to walk down the tree to remove the entities in the correct order.

Answer 2

I am a fresh man in kernel hacking. This is my first time to answer linux kernel question. Maybe this help to you.

I read the source code. I think it maybe relates to group scheduling.

When kernel have these codes:

#ifdef CONFIG_RT_GROUP_SCHED

It represents that we can collect some schedule entities in to one schduling group.

static void enqueue_rt_entity(struct sched_rt_entity *rt_se, bool head)

{

    dequeue_rt_stack(rt_se);
    for_each_sched_rt_entity(rt_se)
          __enqueue_rt_entity(rt_se, head);

}

Function dequeue_rt_stack(rt_se) extracts all the scheduling entities belong to the group, then add them to run queue.

Hierarchical group I/O scheduling

CFS group scheduling