Scheduler -8- (Deadline Scheduler)

Deadline 스케줄러는 Dario Faggioli에 의해 2013년 3월 Kernel v3.14 에서 소개되었다.

deadline 스케줄러는 EDF(Earliest Deadline First) + CBS(Constant Bandwidth Server) 알고리즘 기반으로 동작한다. 처음 UP 시스템용으로 구현되었다가 SMP 시스템에서는 이를 더 발전 시켜 각 cpu의 earliest deadline을 관리하고 다른 cpu로 전달하여 더욱 효과적으로 스케줄한다. Linus Tovalds는 Realtime 스케줄러에 대해 회의적인 시각이 있어 Mainstream에서는 아직 많이 사용하지 않고 있다. 임베디드 개발자들이 원하는 기능이지만 Linus는 cpu 스케줄러만 가지고 해결할 수 없다고 보는 관점이 있다. 그러나 최근 OS X 에서의 움직임도 있고, 2017 Linaro connect 등을 통해 새 버전의 deadline 스케줄러가 안내되어 어떻게 변해갈지 주목할 듯 하다. 구글도 핸드폰에 이러한 스케줄러를 사용한 application을 필요로할 듯 하다. 이 새 버전의 코드는 다음 기회에 분석하기로 하고 추가된 기능은 다음과 같다.

  • CFS 스케줄러 처럼 PELT와 유사한 로드 트래킹을 통한 로드밸런싱
  • GRUB (“greedy utilization of unused bandwidth”) 알고리즘을 적용하여 대역폭을 조절
  • RT 스케줄러와 연동하여 그룹 스케줄링을 사용하는 방법등이 고려
  • Multi-processor Bandwidth Inheritance Protocol 지원
  • Clock frequency selection hints

 

DL 스케줄러 우선 순위

dl 태스크들은 rt 및 cfs 태스크들보다 항상 우선순위가 높아 먼저 실행될 권리를 갖는다. 다만 cpu를 offline 시킬 때 사용하는 stop 스케줄러에서 사용되는 stop 태스크 보다는 우선 순위가 낮다. 스케줄러들 끼리의 우선 순위를 보면 다음과 같다.

 

DL 태스크의 우선 순위

태스크 마다 주어진 주기마다 런타임이 실행되는 것을 보장해야 한다. dl 태스크들의 우선 순위는 종종 변동되는데, 만료 시각이 먼저 다가 오는 태스크에 우선 처리할 기회가 주어진다. 실제 구현은 아래 그림보다는 복잡하며 conceptual한 시각으로 이해하여야 한다.

  • dl_period는 매 주기마다 작업을 해야 할 간격을 설정한다.
  • dl_runtime은 최악의 경우 매 기간(dl_period) 마다 최대 실행될 수 있는 시간으로 설정한다.

 

DL 런큐

dl 런큐는 cpu 수 만큼 생성된다. dl 스케줄러는 rt나 cfs 스케줄러와는 다르게 그룹 스케줄링을 지원하지 않는다. dl 태스크들이 dl 스케줄러에 큐잉되면 dl 런큐에 존재하는 RB 트리에서 관리된다. deadline 스케줄러는 2 개 이상의 태스크가 큐에서 관리될 때 만료 시각이 가장 이른 태스크를 찾아 실행시킨다. 아래 그림에서 초록색 -> 파란색 순서로 실행하게된다.

 

 

DL 태스크 실행 시간

dl 태스크는 매 주기마다 실행되는데 보통 매 주기에 잠깐 실행되고 작업이 완료되면 스스로 슬립한다. 그러나 작업이 지연되는 경우 매 주기마다 dl_runtime 만큼 실행된다. 작업이 처리되는 동안 다른 dl 태스크에 의해 preemption될 수 있다. 커널 태스크의 경우 preemption 커널 모델에 따라 순서가 바뀌지 않을 수도 있다. 그러나 dl 스케줄러를 사용한다는 것은 사용자가 real-time 환경을 원하기 때문에 사용하였을 것이며 당연히 커널도 preemption 가능하도록 준비하는 것이 좋다. (CONFIG_PREEMPT)

 

dl 태스크에 설정하는 파라메터는 다음과 같이 3개이다.

  • dl_period: 설정된 주기 마다 dl 태스크가 깨어난다.
  • dl_deadline: 설정된 데드라인 이내에 dl 태스크의 작업이 완료될 수 있도록 한다. 2 개 이상의 dl 태스크가 경쟁 상황에서 우선 순위 결정에 사용된다. (보통 dl_period와 동일한 값을 사용한다.)
  • dl_runtime: 최대 런타임 시간으로, WCET(Worst Case Execution Time)로도 불린다.

 

다음 그림에서 10ms 주기로 dl 태스크가 실행하는데 처음 주기에선 설정된 런타임을 초과하여 deadline 스케줄러가 통제(스로틀)하였고, 두 번째 주기에서는 최대 런타임 이내에서 처리가 되었음을 보여준다.

 

DL 밴드위드와 스로틀

DL 밴드위드는 태스크마다 주어진다.  태스크에 매 기간마다 주어진 런타임이 다 소진되면 스로틀(스스로 슬립)한다.

  • cfs나 rt 스케줄러에서는 밴드위드 설정이 그룹 스케줄링을 사용하는 경우에 각 태스크 그룹에 대해서 설정되었으나 DL 밴드위드는 태스크 단위로 설정한다.

스로틀링이 발생하면 다음 우선 순위의 대기 태스크에게 기회가 주어진다. 현재 cpu에서 더 이상 수행할 태스크가 없는 경우 idle로 진입한다.

  • cfs나 rt 스케줄러에서는 스로틀링이 그룹 스케줄링을 사용하는 경우에 각 태스크 그룹에 대해서 설정되었으나 DL 스케줄러에서는 태스크 단위로 수행된다.
  • 아래 그림에서 붉은 색 점선으로 표현된 구간이 되면 dl 스케줄러에서 동작하는 cpu가 스로틀하여 다음 순위의 스케줄러에 있는 태스크를 수행시킬 수 있다. 즉 붉은 색 점선에서 rt, cfs 태스크가 동작할 수 있고 수행시킬 수 있는 태스크가 하나도 없으면 idle 상태로 진입한다.

DL 밴드위드에 따른 스로틀 발생과 관련하여 각 타이머들의 동작을 알아본다.

  • sched tick: dl 태스크가 현재 동작하고 있을 때 매 스케줄 틱마다 진입하여 런타임 잔량을 체크하여 0 이하가 되면 스로틀링한다.
  • hrtick: 태스크가 처음 수행될 때 최대 런타임(dl_runtime) 만큼 타이머를 동작시킨다.
  • deadline timer: 런타임 잔량이 다 소모된 후에 스로틀된 dl 태스크를 다음 주기에 깨우기 위해 가동되는 타이머이다. 스로틀할 때 남은 주기(dl_period)만큼 deadline 시간을 정하여 deadline 타이머를 프로그램한다.

 

earliest deadline에 따른 우선 순위 변경

만료 시각이 급한 태스크가 동작해야 할 때 우선 순위 바꿈(preemption)이 일어난다. deadline 타이머에 의해 태스크가 곧바로 깨어날지 기존 dl 태스크가 계속 수행할지 여부에 대한 판단은 deadline 우선 순위로 결정한다. 아래 그림에서  처음 Task A -> Task B -> Task A로 수행 순서가 변경되는 과정을 알아본다. Task A가 수행 중에 Task B의 deadline 타이머에 의해 처음 판단을 하게 된다. 그 순간 deadline이 가장 먼저인 Task B를 선택하여 수행하고 런타임 잔량을 모두 소모하면 스로틀링이 발생한다. 다시 자연스럽게 대기하고 있던 Task A로 실행 순서가 바뀐다.

hrtick의 동작은 더 복잡하므로 이에 대해 자세히 알아보자. 아래 그림에서 Task A가 동작할 때 hrtick 타이머를 프로그램한다. Task B의 deadline 타이머 만료 시 Task B의 hrtick 타이머도 프로그램한다. Task A에서 준비한 hrtick 타이머가 만료되어 깨어날 때 현재 동작 태스크는 Task B로 이미 순서가 변경된 후 실행되고 있던 순간이다. 따라서 Task A의 런타임 잔량을 체크하는 것이 아니라 Task B의 런타임 잔량을 체크하고 아직 남아 있기 때문에 남은 기간으로 재조정하여 hrtick 타이머를 재프로그램한다. 재프로그램한 타이머가 만료되어 꺠어나면 Task B의 런타임 잔량이 다 소모되었으므로 스로틀링하고 Task A로의 전환이 발생한다. 그 후 Task A의 남은 런타임 잔량만큼 다시 hrtick을 재프로그램 한다.

 

종합하여 보면 earliest deadline 우선 처리하도록 다음과 같이 처리된다.

 

기타

DL 로드밸런스와 관련된 다음 항목들은 코드 분석 중에 보여준다.

  • push operation
  • pull operation
  • overload
  • CPU deadline 관리

 

dl 태스크로 변경하는 방법

다음 코드는 100ms 주기와 데드라인, 그리고 30ms의 최대 런타임을 설정하여 태스크의 속성을 바꾸는 방법을 보여준다. (root 권한이 필요하다)

#include <sched.h>
...
struct sched_attr attr;
attr.size = sizeof(struct attr);
attr.sched_policy = SCHED_DEADLINE;
attr.sched_runtime = 30000000;
attr.sched_period = 100000000;
attr.sched_deadline = attr.sched_period;
...
if (sched_setattr(gettid(), &attr, 0))
    perror("sched_setattr()");

 

Deadline 스케줄 틱

task_tick_dl()

kernel/sched/deadline.c

static void task_tick_dl(struct rq *rq, struct task_struct *p, int queued)
{
        update_curr_dl(rq);

        /*
         * Even when we have runtime, update_curr_dl() might have resulted in us
         * not being the leftmost task anymore. In that case NEED_RESCHED will
         * be set and schedule() will start a new hrtick for the next task.
         */
        if (hrtick_enabled(rq) && queued && p->dl.runtime > 0 &&
            is_leftmost(p, &rq->dl))
                start_hrtick_dl(rq, p);
} 

이 함수는 dl 태스크가 수행 중에 스케줄 틱 또는 hrtick 인터럽트가 발생 시 호출된다.

  • 코드 라인 3에서 cfs 로드밸런스를 위해 dl 런타임을 rt_avg에 갱신하고 설정된 밴드위드에 따른 동작을 수행한다. 이 때 스로틀이 발생하는 경우 리스케줄된다.
  • 코드 라인 10~12에서 만일 스케줄 틱이 아니라 hrtick 인터럽트에 의해 호출되었으면서 여전히 런타임 잔량이 모두 소모되지 않은 경우 이를 계속 처리하려한다. 단 dl 런큐에서 대기중인 첫 태스크(earliest deadline task)인 경우이면 다시 남은 런타임 잔량 만큼 hrtick 타이머를 재 동작시킨다.
    • DL 태스크들은 각자 자신의 hrtick 타이머를 가지고 있다.

 

 

로드 및 runtime 갱신

update_curr_dl()

kernel/sched/deadline.c – 1/2

/*
 * Update the current task's runtime statistics (provided it is still
 * a -deadline task and has not been removed from the dl_rq).
 */
static void update_curr_dl(struct rq *rq)
{
        struct task_struct *curr = rq->curr;
        struct sched_dl_entity *dl_se = &curr->dl;
        u64 delta_exec;

        if (!dl_task(curr) || !on_dl_rq(dl_se))
                return;

        /*
         * Consumed budget is computed considering the time as
         * observed by schedulable tasks (excluding time spent
         * in hardirq context, etc.). Deadlines are instead
         * computed using hard walltime. This seems to be the more
         * natural solution, but the full ramifications of this
         * approach need further study.
         */
        delta_exec = rq_clock_task(rq) - curr->se.exec_start;
        if (unlikely((s64)delta_exec <= 0))
                return;

        schedstat_set(curr->se.statistics.exec_max,
                      max(curr->se.statistics.exec_max, delta_exec));

        curr->se.sum_exec_runtime += delta_exec;
        account_group_exec_runtime(curr, delta_exec);

        curr->se.exec_start = rq_clock_task(rq);
        cpuacct_charge(curr, delta_exec);

        sched_rt_avg_update(rq, delta_exec);

DL 스케줄러에서 스케줄 틱마다 로드 및 런타임을 갱신한다.

  • 코드 라인 11~12에서 현재 런큐에서 수행중인 태스크가 dl 태스크가 아니거나 dl 엔티티가 dl 런큐에 엔큐되지 않은 경우 함수 처리를 빠져나간다.
  • 코드 라인 22~24에서 delta 실행 시간을 구해와서 0보다 작은 경우 함수 처리를 빠져나간다.
  • 코드 라인 29에서 구한 delta 실행 시간을 더해 현재 dl 태스크의 총 실행 시간을 갱신한다. (curr->se.sum_exec_runtime)
  • 코드 라인 30에서 현재 스레드 그룹용 총 시간 관리를 위해 cpu 타이머가 동작하는 동안 총 실행 시간을 갱신한다.
    • posix timer를 통해 만료 시 시그널을 발생한다.
  • 코드 라인 32에서 현재 시각(rq->clock_task)으로 현재 dl 태스크의 시작 실행 시각을 갱신한다. (curr->se.exec_start)
  • 코드 라인 33에서 현재 태스크의 cpu accounting 그룹용 총 실행 시간을 갱신한다.
  • 코드 라인 35에서 rt 런타임 평균을 갱신한다.

 

kernel/sched/deadline.c – 2/2

        dl_se->runtime -= dl_se->dl_yielded ? 0 : delta_exec;
        if (dl_runtime_exceeded(rq, dl_se)) {
                dl_se->dl_throttled = 1;
                __dequeue_task_dl(rq, curr, 0);
                if (unlikely(!start_dl_timer(dl_se, curr->dl.dl_boosted)))
                        enqueue_task_dl(rq, curr, ENQUEUE_REPLENISH);

                if (!is_leftmost(curr, &rq->dl))
                        resched_curr(rq);
        }

        /*
         * Because -- for now -- we share the rt bandwidth, we need to
         * account our runtime there too, otherwise actual rt tasks
         * would be able to exceed the shared quota.
         *
         * Account to the root rt group for now.
         *
         * The solution we're working towards is having the RT groups scheduled
         * using deadline servers -- however there's a few nasties to figure
         * out before that can happen.
         */
        if (rt_bandwidth_enabled()) { 
                struct rt_rq *rt_rq = &rq->rt;

                raw_spin_lock(&rt_rq->rt_runtime_lock);
                /*
                 * We'll let actual RT tasks worry about the overflow here, we
                 * have our own CBS to keep us inline; only account when RT
                 * bandwidth is relevant.
                 */
                if (sched_rt_bandwidth_account(rt_rq))
                        rt_rq->rt_time += delta_exec;
                raw_spin_unlock(&rt_rq->rt_runtime_lock);
        }
}
  • 코드 라인 1에서 dl 태스크에 런타임을 delta 실행시간 만큼 빼서 소모시킨다. 단 양보된 태스크인 경우 소모시키지 않는다.
  • 코드 라인 2~4에서 런타임 잔량이 남아 있지 않는 경우 dl 스로틀에 1을 대입하고 dl 태스크를 디큐한다.
  • 코드 라인 5~6에서 낮은 확률로 deadline 타이머를 가동한다. 단 다음과 같은 경우 런타임 잔량과 관계 없이 dl 태스크를 계속 실행하도록 deadline 타이머를 가동하지 않고 dl 태스크를 다시 엔큐 한다.
    • deadline을 넘긴 경우
    • 부스트된 경우
  • 코드 라인 8~9에서 현재 태스크가 대기중인 dl 런큐가 아닌 경우 리스케줄 요청 플래그를 설정한다.
  • 코드 라인 23~35에서 rt bandwidth가 설정되었고 rt period 타이머가 동작중이거나 rt 런타임의 잔량이 남아있는 경우 rt 태스크에 delta 시간 만큼 rt 런타임을 소비한다.
    • dl 태스크는 rt bandwidth 런타임 할당량을 share 하며 사용한다.

 

DL 런타임 초과 여부

dl_runtime_exceeded

static
int dl_runtime_exceeded(struct rq *rq, struct sched_dl_entity *dl_se)
{
        return (dl_se->runtime <= 0);
}

dl 엔티티의 런타임이 모두 소모된 경우 true(1)를 반환한다.

 

Enqueue & Dequeue DL 엔티티

 

Enqueue DL Task

enqueue_task_dl()

kernel/sched/deadline.c

static void enqueue_task_dl(struct rq *rq, struct task_struct *p, int flags)
{
        struct task_struct *pi_task = rt_mutex_get_top_task(p);
        struct sched_dl_entity *pi_se = &p->dl;

        /*
         * Use the scheduling parameters of the top pi-waiter
         * task if we have one and its (relative) deadline is
         * smaller than our one... OTW we keep our runtime and
         * deadline.
         */
        if (pi_task && p->dl.dl_boosted && dl_prio(pi_task->normal_prio)) {
                pi_se = &pi_task->dl;
        } else if (!dl_prio(p->normal_prio)) {
                /*
                 * Special case in which we have a !SCHED_DEADLINE task
                 * that is going to be deboosted, but exceedes its
                 * runtime while doing so. No point in replenishing
                 * it, as it's going to return back to its original
                 * scheduling class after this.
                 */
                BUG_ON(!p->dl.dl_boosted || flags != ENQUEUE_REPLENISH);
                return;
        }

        /*
         * If p is throttled, we do nothing. In fact, if it exhausted
         * its budget it needs a replenishment and, since it now is on
         * its rq, the bandwidth timer callback (which clearly has not
         * run yet) will take care of this.
         */
        if (p->dl.dl_throttled && !(flags & ENQUEUE_REPLENISH))
                return;

        enqueue_dl_entity(&p->dl, pi_se, flags);

        if (!task_current(rq, p) && p->nr_cpus_allowed > 1)
                enqueue_pushable_dl_task(rq, p);
}

dl 태스크를 dl 런큐에 엔큐한다.

  • 코드 라인 3에서 요청한 태스크의 rt-mutex에 락 대기 중인 최상위 우선 순위 태스크를 알아온다.
  • 코드 라인 12~13에서 rt-mutex 락 대기 중인 dl 태스크가 있고 부스트되었으면 그 태스크의 dl 엔티티를 알아온다.
  • 코드 라인 14~24에서 요청한 태스크가 dl 태스크가 아니면 함수를 빠져나간다.
  • 코드 라인 32~33에서 태스크가 스로틀 되었으면서 replenish 플래그가 아니면 함수를 빠져나간다.
  • 코드 라인 35에서 dl 엔티티 및 pi 엔티티를 사용하여 엔큐한다.
  • 코드 라인 37~38에서 요청한 태스크가 런큐에서 현재 태스크가 아니면서 태스크에 지정된 cpu가 2개 이상인 경우 요청한 dl 태스크를 pushable dl 리스트에 추가한다.
    • 현재 런큐에서 우선 순위에 의해 밀려났으므로 가능하면 다른 cpu에서라도 빠르게 처리되기 위해 push 한다.

 

enqueue_dl_entity()

kernel/sched/deadline.c

static void
enqueue_dl_entity(struct sched_dl_entity *dl_se,
                  struct sched_dl_entity *pi_se, int flags)
{
        BUG_ON(on_dl_rq(dl_se));

        /*
         * If this is a wakeup or a new instance, the scheduling
         * parameters of the task might need updating. Otherwise,
         * we want a replenishment of its runtime.
         */
        if (dl_se->dl_new || flags & ENQUEUE_WAKEUP)
                update_dl_entity(dl_se, pi_se);
        else if (flags & ENQUEUE_REPLENISH)
                replenish_dl_entity(dl_se, pi_se);

        __enqueue_dl_entity(dl_se);
}

dl 엔티티를 dl 런큐에 엔큐한다.

  • 코드 라인 12~13에서 new dl 엔티티인 경우 또는 wakeup 플래그 설정된 경우 조건에 따라 dl 엔티티의 런타임 및 deadline을 갱신한다.
  • 코드 라인 14~15에서 보충(replenish) 플래그 요청이 있는 경우 조건에 따라 pi 엔티티에 할당된 deadline 및 런타임을 dl 엔티티에 설정하거나 보충한다.
  • 코드 라인 17에서 dl 엔티티를 dl 런큐에 엔큐한다.

 

__enqueue_dl_entity()

kernel/sched/deadline.c

static void __enqueue_dl_entity(struct sched_dl_entity *dl_se)
{
        struct dl_rq *dl_rq = dl_rq_of_se(dl_se);
        struct rb_node **link = &dl_rq->rb_root.rb_node;
        struct rb_node *parent = NULL;
        struct sched_dl_entity *entry;
        int leftmost = 1;

        BUG_ON(!RB_EMPTY_NODE(&dl_se->rb_node));

        while (*link) {
                parent = *link;
                entry = rb_entry(parent, struct sched_dl_entity, rb_node);
                if (dl_time_before(dl_se->deadline, entry->deadline))
                        link = &parent->rb_left;
                else {
                        link = &parent->rb_right;
                        leftmost = 0;
                }
        }

        if (leftmost)
                dl_rq->rb_leftmost = &dl_se->rb_node;

        rb_link_node(&dl_se->rb_node, parent, link);
        rb_insert_color(&dl_se->rb_node, &dl_rq->rb_root);

        inc_dl_tasks(dl_se, dl_rq);
}

dl 엔티티를 dl 런큐에 엔큐한다.

  • 코드 라인 11~20에서 요청한 dl 엔티티를 RB 트리에 추가할 RB 트리 링크를 찾는다. deadline 시각이 가장 빠르면 좌측에 들어간다.
  • 코드 라인 22~23에서 요청한 dl 엔티티의 deadline이 가장 빠른 시각인 경우 rb_leftmost에 연결한다.
  • 코드 라인 25~26에서 요청한 dl 엔티티를 RB 트리에 추가하고 color를 결정한다.
  • 코드 라인 28에서 dl 태스크를 dl 런큐에 추가한 후 각종 갱신할 일들을 수행한다.
    • dl 태스크 카운터 갱신, deadline 관리, migration 처리

 

inc_dl_tasks()

kernel/sched/deadline.c

static inline
void inc_dl_tasks(struct sched_dl_entity *dl_se, struct dl_rq *dl_rq)
{
        int prio = dl_task_of(dl_se)->prio;
        u64 deadline = dl_se->deadline;

        WARN_ON(!dl_prio(prio));
        dl_rq->dl_nr_running++;
        add_nr_running(rq_of_dl_rq(dl_rq), 1);

        inc_dl_deadline(dl_rq, deadline);
        inc_dl_migration(dl_se, dl_rq);
}

dl 태스크를 dl 런큐에 엔큐한 이후 각종 갱신할 일들을 수행한다.

  • 코드 라인 8에서 dl 런큐의 dl 태스크 수를 증가시킨다.
  • 코드 라인 9에서 런큐에서 태스크 수를 1 증가시킨다.
    • 태스크의 수가 1 -> 2로 증가하면 smp 시스템인 경우 루트 도메인에 오버로드 설정을 하고 nohz full 상태였었던 경우 벗어난다.
  • 코드 라인 11에서 dl 태스크가 엔큐될 때 dl 런큐에서 earliest deadline인 경우 earliest_dl 및 cpudl을 갱신한다.
  • 코드 라인 12에서 dl 태스크가 엔큐되면서 dl 런큐의 오버로드 여부를 갱신한다.

 

Dequeue DL Task

dequeue_task_dl()

kernel/sched/deadline.c

static void dequeue_task_dl(struct rq *rq, struct task_struct *p, int flags)
{
        update_curr_dl(rq);
        __dequeue_task_dl(rq, p, flags);
}

로드 및 런타임을 갱신하고 dl 태스크를 dl 런큐에서 디큐한다.

 

__dequeue_task_dl()

kernel/sched/deadline.c

static void __dequeue_task_dl(struct rq *rq, struct task_struct *p, int flags)
{
        dequeue_dl_entity(&p->dl);
        dequeue_pushable_dl_task(rq, p);
}

dl 태스크를 dl 런큐에서 디큐하고 pushable 리스트에서도 디큐한다.

 

dequeue_dl_entity()

kernel/sched/deadline.c

static void dequeue_dl_entity(struct sched_dl_entity *dl_se)
{
        __dequeue_dl_entity(dl_se);
}

dl 엔티티를 dl 런큐에서 디큐한다.

 

__dequeue_task_dl()

kernel/sched/deadline.c

static void __dequeue_dl_entity(struct sched_dl_entity *dl_se)
{
        struct dl_rq *dl_rq = dl_rq_of_se(dl_se);

        if (RB_EMPTY_NODE(&dl_se->rb_node))
                return;

        if (dl_rq->rb_leftmost == &dl_se->rb_node) {
                struct rb_node *next_node;

                next_node = rb_next(&dl_se->rb_node);
                dl_rq->rb_leftmost = next_node;
        }

        rb_erase(&dl_se->rb_node, &dl_rq->rb_root);
        RB_CLEAR_NODE(&dl_se->rb_node);

        dec_dl_tasks(dl_se, dl_rq);
}

dl 엔티티를 dl 런큐에서 디큐한다.

  • 코드 라인 5~6에서 dl 엔티티가 dl 런큐의 RB 트리에 없으면 함수를 빠져나간다.
  • 코드 라인 8~13에서 요청한 dl 엔티티가 earliest deadline인 경우 dl 런큐의 대기중인 earliest deadline인 첫 엔티티를 rb_leftmost에 설정한다. (rb_leftmost 갱신)
  • 코드 라인 15~16에서 dl 런큐의 RB 트리에서 요청한 dl 엔티티를 제거한다.
  • 코드 라인 18에서 dl 태스크를 dl 런큐에 제거하였으므로 그 이후 각종 갱신할 일들을 수행한다.
    • dl 태스크 카운터 갱신, deadline 관리, migration 처리

 

dec_dl_tasks()

kernel/sched/deadline.c

static inline
void dec_dl_tasks(struct sched_dl_entity *dl_se, struct dl_rq *dl_rq)
{
        int prio = dl_task_of(dl_se)->prio;

        WARN_ON(!dl_prio(prio));
        WARN_ON(!dl_rq->dl_nr_running);
        dl_rq->dl_nr_running--;
        sub_nr_running(rq_of_dl_rq(dl_rq), 1);

        dec_dl_deadline(dl_rq, dl_se->deadline);
        dec_dl_migration(dl_se, dl_rq);
}

dl 태스크를 dl 런큐에 디큐한 이후 각종 갱신할 일들을 수행한다.

  • 코드 라인 8에서 dl 런큐의 dl 태스크 수를 1 감소시킨다.
  • 코드 라인 9에서 런큐에서 태스크 수를 1 감소시킨다.
  • 코드 라인 11에서 dl 태스크가 디큐될 때 dl 런큐에서 earliest deadline인 경우 earliest_dl 및 cpudl을 갱신한다.
  • 코드 라인 12에서 dl 태스크가 디큐되면서 dl 런큐의 오버로드 여부를 갱신한다.

 

DL 엔티티 갱신

update_dl_entity()

kernel/sched/deadline.c

/*
 * When a -deadline entity is queued back on the runqueue, its runtime and
 * deadline might need updating.
 *
 * The policy here is that we update the deadline of the entity only if:
 *  - the current deadline is in the past,
 *  - using the remaining runtime with the current deadline would make
 *    the entity exceed its bandwidth.
 */
static void update_dl_entity(struct sched_dl_entity *dl_se,
                             struct sched_dl_entity *pi_se)
{
        struct dl_rq *dl_rq = dl_rq_of_se(dl_se);
        struct rq *rq = rq_of_dl_rq(dl_rq);

        /*
         * The arrival of a new instance needs special treatment, i.e.,
         * the actual scheduling parameters have to be "renewed".
         */
        if (dl_se->dl_new) {
                setup_new_dl_entity(dl_se, pi_se);
                return;
        }

        if (dl_time_before(dl_se->deadline, rq_clock(rq)) ||
            dl_entity_overflow(dl_se, pi_se, rq_clock(rq))) {
                dl_se->deadline = rq_clock(rq) + pi_se->dl_deadline;
                dl_se->runtime = pi_se->dl_runtime;
        }
} 

음수 deadline(현재 시각을 이미 지난 상태), 오버플로우 또는 새 dl 엔티티가 엔큐된 경우 dl 엔티티의 런타임과 deadline을 다시 갱신한다.

  • 코드 라인 20~23에서 새로운 dl 엔티티인 경우 설정한 후 함수를 빠져나간다.
  • 코드 라인 25~29에서 deadline이 이미 현재 시각을 이미 지난 경우이거나 PI(priority inversion)을 해결하기 위해 오버플로우된 경우 dl 엔티티의 deadline 및 런타임 잔량을 pi 엔티티의 요구 deadline 및 할당된 런타임으로 갱신한다.

 

setup_new_dl_entity()

kernel/sched/deadline.c

/*
 * We are being explicitly informed that a new instance is starting,
 * and this means that:
 *  - the absolute deadline of the entity has to be placed at
 *    current time + relative deadline;
 *  - the runtime of the entity has to be set to the maximum value.
 *
 * The capability of specifying such event is useful whenever a -deadline
 * entity wants to (try to!) synchronize its behaviour with the scheduler's
 * one, and to (try to!) reconcile itself with its own scheduling
 * parameters.
 */
static inline void setup_new_dl_entity(struct sched_dl_entity *dl_se,
                                       struct sched_dl_entity *pi_se)
{
        struct dl_rq *dl_rq = dl_rq_of_se(dl_se);
        struct rq *rq = rq_of_dl_rq(dl_rq);

        WARN_ON(!dl_se->dl_new || dl_se->dl_throttled);

        /*
         * We use the regular wall clock time to set deadlines in the
         * future; in fact, we must consider execution overheads (time
         * spent on hardirq context, etc.).
         */
        dl_se->deadline = rq_clock(rq) + pi_se->dl_deadline;
        dl_se->runtime = pi_se->dl_runtime;
        dl_se->dl_new = 0;
}

새 dl 엔티티의 런타임 및 deadline을 설정한다.

  • 코드 라인 26~28에서 PI(priority inversion)을 해결하기 위해 pi 엔티티의 요구 deadline 및 할당된 런타임을 dl 엔티티의 deadline 및 런타임 잔량에 설정한다.

 

dl_entity_overflow()

kernel/sched/deadline.c

/*
 * Here we check if --at time t-- an entity (which is probably being
 * [re]activated or, in general, enqueued) can use its remaining runtime
 * and its current deadline _without_ exceeding the bandwidth it is
 * assigned (function returns true if it can't). We are in fact applying
 * one of the CBS rules: when a task wakes up, if the residual runtime
 * over residual deadline fits within the allocated bandwidth, then we
 * can keep the current (absolute) deadline and residual budget without
 * disrupting the schedulability of the system. Otherwise, we should
 * refill the runtime and set the deadline a period in the future,
 * because keeping the current (absolute) deadline of the task would
 * result in breaking guarantees promised to other tasks (refer to
 * Documentation/scheduler/sched-deadline.txt for more informations).
 *
 * This function returns true if:
 *
 *   runtime / (deadline - t) > dl_runtime / dl_period ,
 *
 * IOW we can't recycle current parameters.
 *
 * Notice that the bandwidth check is done against the period. For
 * task with deadline equal to period this is the same of using
 * dl_deadline instead of dl_period in the equation above.
 */
static bool dl_entity_overflow(struct sched_dl_entity *dl_se,
                               struct sched_dl_entity *pi_se, u64 t)
{
        u64 left, right;

        /*
         * left and right are the two sides of the equation above,
         * after a bit of shuffling to use multiplications instead
         * of divisions.
         *
         * Note that none of the time values involved in the two
         * multiplications are absolute: dl_deadline and dl_runtime
         * are the relative deadline and the maximum runtime of each
         * instance, runtime is the runtime left for the last instance
         * and (deadline - t), since t is rq->clock, is the time left
         * to the (absolute) deadline. Even if overflowing the u64 type
         * is very unlikely to occur in both cases, here we scale down
         * as we want to avoid that risk at all. Scaling down by 10
         * means that we reduce granularity to 1us. We are fine with it,
         * since this is only a true/false check and, anyway, thinking
         * of anything below microseconds resolution is actually fiction
         * (but still we want to give the user that illusion >;).
         */
        left = (pi_se->dl_period >> DL_SCALE) * (dl_se->runtime >> DL_SCALE);
        right = ((dl_se->deadline - t) >> DL_SCALE) *
                (pi_se->dl_runtime >> DL_SCALE);

        return dl_time_before(right, left);
}

이 함수는 태스크가 깨어나거나 엔큐될 때 스케줄링 가능 여부를 타진한다. 남은 런타임 잔량이 남은 만료 기간내에 처리할 수 있는 비율이 기존 설정된 비율(설정 런타임 / 설정 기간)을 초과해 오버플로우되는지 여부를 체크한다. true=오버플로우 된다. false=적절하게 처리할 수 있다.

  • 수식은 나눗셈이지만 구현은 곱셈을 사용하였다.
    • 수식: 런타임 잔량(runtime) / 남은 만료 시간(deadline – t) > 설정 런타임(dl_runtime) / 설정 기간(dl period)
    • 구현: 런타임 잔량(runtime) * 설정 기간(dl_period) > 설정 런타임(dl_runtime) * 남은 만료 시간(deadline – t)
  • 나노초를 DL_SCALE(10) 비트만큼 우측으로 쉬프트하여 us 단위로 바꾸어 연산한다. 사실 us 단위 조차도 픽션 ^^;

 

다음 그림과 같이 태스크가 다시 깨어나 엔큐되어 스케줄링하고자 할 때 overflow 되는지 여부를 확인한다.  overflow 되면 런타임 잔량 및 만료 시각 설정을 다시 설정 런타임(dl_runtime) 및 설정 만료 시간(dl_deadline)으로 refill 한다.

 

 

런타임 보충(replenish)

replenish_dl_entity()

다음 조건에 따라 pi 엔티티에 할당된 deadline 및 런타임을 dl 엔티티에 설정하거나 보충한다.

  • dl 엔티티의 deadline이 설정되지 않은 경우
  • dl 엔티티의 deadline을 이미 지나간 경우
  • dl 엔티티의 런타임 잔량을 다 소모 및 초과한 경우

kernel/sched/deadline.c – 1/2

/*
 * Pure Earliest Deadline First (EDF) scheduling does not deal with the
 * possibility of a entity lasting more than what it declared, and thus
 * exhausting its runtime.
 *
 * Here we are interested in making runtime overrun possible, but we do
 * not want a entity which is misbehaving to affect the scheduling of all
 * other entities.
 * Therefore, a budgeting strategy called Constant Bandwidth Server (CBS)
 * is used, in order to confine each entity within its own bandwidth.
 *
 * This function deals exactly with that, and ensures that when the runtime
 * of a entity is replenished, its deadline is also postponed. That ensures
 * the overrunning entity can't interfere with other entity in the system and
 * can't make them miss their deadlines. Reasons why this kind of overruns
 * could happen are, typically, a entity voluntarily trying to overcome its
 * runtime, or it just underestimated it during sched_setattr().
 */
static void replenish_dl_entity(struct sched_dl_entity *dl_se,
                                struct sched_dl_entity *pi_se)
{
        struct dl_rq *dl_rq = dl_rq_of_se(dl_se);
        struct rq *rq = rq_of_dl_rq(dl_rq);

        BUG_ON(pi_se->dl_runtime <= 0);

        /*
         * This could be the case for a !-dl task that is boosted.
         * Just go with full inherited parameters.
         */
        if (dl_se->dl_deadline == 0) {
                dl_se->deadline = rq_clock(rq) + pi_se->dl_deadline;
                dl_se->runtime = pi_se->dl_runtime;
        }

        /*
         * We keep moving the deadline away until we get some
         * available runtime for the entity. This ensures correct
         * handling of situations where the runtime overrun is
         * arbitrary large.
         */
        while (dl_se->runtime <= 0) {
                dl_se->deadline += pi_se->dl_period;
                dl_se->runtime += pi_se->dl_runtime;
        }
  • 코드 라인 31~34에서 dl 엔티티에 설정된 deadline 기간이 없는 경우 pi 엔티티에 할당된 deadline 기간 및 런타임 할당 만큼을 dl 엔티티에 할당한다.
  • 코드 라인 42~45에서 dl 엔티티의 런타임 잔량을 이미 초과 사용한 경우 설정 기간과 설정 런타임을 추가한다. 추가 시 pi 태스크가 존재하는 경우 pi 태스크의 값으로 추가한다.
    • pi 태스크는 우선 순위가 높으므로 deadline 값이 더 작을 것이다.

 

kernel/sched/deadline.c – 2/2

        /*
         * At this point, the deadline really should be "in
         * the future" with respect to rq->clock. If it's
         * not, we are, for some reason, lagging too much!
         * Anyway, after having warn userspace abut that,
         * we still try to keep the things running by
         * resetting the deadline and the budget of the
         * entity.
         */
        if (dl_time_before(dl_se->deadline, rq_clock(rq))) {
                printk_deferred_once("sched: DL replenish lagged to much\n");
                dl_se->deadline = rq_clock(rq) + pi_se->dl_deadline;
                dl_se->runtime = pi_se->dl_runtime;
        }

        if (dl_se->dl_yielded)
                dl_se->dl_yielded = 0;
        if (dl_se->dl_throttled)
                dl_se->dl_throttled = 0;
}
  • 코드 라인 10~14에서 de 엔티티의 deadline을 이미 지나간 경우 pi 엔티티에 할당된 deadline 기간 및 런타임 할당 만큼을 dl 엔티티에 할당한다
  • 코드 라인 16~19에서 dl 엔티티에 dl_yielded와 dl_throttled를 클리어한다.

 

Deadline 설정

inc_dl_deadline()

kernel/sched/deadline.c

static void inc_dl_deadline(struct dl_rq *dl_rq, u64 deadline)
{
        struct rq *rq = rq_of_dl_rq(dl_rq);

        if (dl_rq->earliest_dl.curr == 0 ||
            dl_time_before(deadline, dl_rq->earliest_dl.curr)) {
                /*
                 * If the dl_rq had no -deadline tasks, or if the new task
                 * has shorter deadline than the current one on dl_rq, we
                 * know that the previous earliest becomes our next earliest,
                 * as the new task becomes the earliest itself.
                 */
                dl_rq->earliest_dl.next = dl_rq->earliest_dl.curr;
                dl_rq->earliest_dl.curr = deadline;
                cpudl_set(&rq->rd->cpudl, rq->cpu, deadline, 1);
        } else if (dl_rq->earliest_dl.next == 0 ||
                   dl_time_before(deadline, dl_rq->earliest_dl.next)) {
                /*
                 * On the other hand, if the new -deadline task has a
                 * a later deadline than the earliest one on dl_rq, but
                 * it is earlier than the next (if any), we must
                 * recompute the next-earliest.
                 */
                dl_rq->earliest_dl.next = next_deadline(rq);
        }
}

dl 태스크가 엔큐될 때 dl 런큐에서 earliest deadline인 경우 earliest_dl 및 cpudl을 갱신한다.

  • 코드 라인 5~15에서 요청한 deadline이 현재 동작 중인 dl 태스크의 deadline보다 이전인 경우 earliest_dl 및 cpudl을 갱신한다.
    • earliest_dl.next에 earliest_dl.curr를 대입하고 earliest_dl.curr에 요청한 deadline을 대입한다.
    • cpudl은 현재 실행되고 있는 가장 빠른 deadline으로 갱신된다.
  • 코드 라인 16~25에서 요청한 deadline이 현재 대기 중인 dl 태스크의 deadline 보다 이전인 경우 earliest_dl.next를 갱신한다.

 

dec_dl_deadline()

kernel/sched/deadline.c

static void dec_dl_deadline(struct dl_rq *dl_rq, u64 deadline)
{
        struct rq *rq = rq_of_dl_rq(dl_rq);

        /*
         * Since we may have removed our earliest (and/or next earliest)
         * task we must recompute them.
         */
        if (!dl_rq->dl_nr_running) {
                dl_rq->earliest_dl.curr = 0;
                dl_rq->earliest_dl.next = 0;
                cpudl_set(&rq->rd->cpudl, rq->cpu, 0, 0);
        } else {
                struct rb_node *leftmost = dl_rq->rb_leftmost;
                struct sched_dl_entity *entry;

                entry = rb_entry(leftmost, struct sched_dl_entity, rb_node);
                dl_rq->earliest_dl.curr = entry->deadline;
                dl_rq->earliest_dl.next = next_deadline(rq);
                cpudl_set(&rq->rd->cpudl, rq->cpu, entry->deadline, 1);
        }
}

dl 태스크가 디큐되면서 발생된 deadline 관련 설정을 갱신한다.

  • 코드 라인 9~12에서 dl 태스크가 디큐되면서 dl 런큐에 dl 태스크가 하나도 남지 않는 경우 earliest_dl.curr 및 earliest_dl.next를 비운다. 그리고 cpudl도 0으로 클리어한다.
  • 코드 라인 13~18에서 earliest_dl.curr에 dl 런큐의 RB 트리에서 대기중인 가장 빠른 deadline을 대입한다.
  • 코드 라인 19에서 earliest_dl.next에 dl 런큐의 다음 순위 deadline을 대입한다. (없으면 0)
  • 코드 라인 20에서 cpudl을 가장 빠른 deadline으로 갱신한다.

 

글로벌 CPU deadline 관리

글로벌 cpu deadline 관리는 루트도메인내에서 cpudl 구조체를 통해 관리된다. cpudl 구조체 내에는 cpu 수 만큼의 cpudl_item 구조체가 할당되어 사용된다.

 

cpu에 대한 deadline에서 사용하는 내부 알고리즘으로 힙정렬을 사용하기 위해 힙 트리를 구성한다.

  • cpudl heap tree에는 각 cpu의 earliest deadline 값이 저장되고 그 값으로 힙정렬한다. 가장 큰 deadline 값이 가장 위로 배치된다.
  • 그러므로 deadline이 여유 있는 cpu를 찾을 때 elements[0]번을 사용한다.
  • 참고: 힙정렬 | 위키백과

 

아래 그림은 8개의 cpu들 중 6개의 cpu에 deadline이 설정되었다고 가정한 경우의 cpudl 힙트리를 보여준다.

 

cpudl_set()

kernel/sched/cpudeadline.c

/*
 * cpudl_set - update the cpudl max-heap
 * @cp: the cpudl max-heap context
 * @cpu: the target cpu
 * @dl: the new earliest deadline for this cpu
 *
 * Notes: assumes cpu_rq(cpu)->lock is locked
 *
 * Returns: (void)
 */
void cpudl_set(struct cpudl *cp, int cpu, u64 dl, int is_valid)
{
        int old_idx, new_cpu;
        unsigned long flags;

        WARN_ON(!cpu_present(cpu));
 
        raw_spin_lock_irqsave(&cp->lock, flags);
        old_idx = cp->elements[cpu].idx;
        if (!is_valid) {
                /* remove item */
                if (old_idx == IDX_INVALID) {
                        /*
                         * Nothing to remove if old_idx was invalid.
                         * This could happen if a rq_offline_dl is
                         * called for a CPU without -dl tasks running.
                         */
                        goto out;
                }
                new_cpu = cp->elements[cp->size - 1].cpu;
                cp->elements[old_idx].dl = cp->elements[cp->size - 1].dl;
                cp->elements[old_idx].cpu = new_cpu;
                cp->size--;
                cp->elements[new_cpu].idx = old_idx;
                cp->elements[cpu].idx = IDX_INVALID;
                while (old_idx > 0 && dl_time_before(
                                cp->elements[parent(old_idx)].dl,
                                cp->elements[old_idx].dl)) {
                        cpudl_exchange(cp, old_idx, parent(old_idx));
                        old_idx = parent(old_idx);
                }
                cpumask_set_cpu(cpu, cp->free_cpus);
                cpudl_heapify(cp, old_idx);
        
                goto out;
        }

        if (old_idx == IDX_INVALID) {
                cp->size++;
                cp->elements[cp->size - 1].dl = 0;
                cp->elements[cp->size - 1].cpu = cpu;
                cp->elements[cpu].idx = cp->size - 1;
                cpudl_change_key(cp, cp->size - 1, dl);
                cpumask_clear_cpu(cpu, cp->free_cpus);
        } else {
                cpudl_change_key(cp, old_idx, dl);
        }

out:
        raw_spin_unlock_irqrestore(&cp->lock, flags);
}

요청 cpu에 가장 이른(earliest) deadline을 설정한다. (cpudl heap tree에는 각 cpu의 earliest deadline 값이 저장된다)

  • 코드 라인 19에서 요청한 cpu에 설정된 기존 인덱스 값을 알아온다.

 

요청한 cpu의 deadline 클리어

  • 코드 라인 20에서 요청한 cpu의 deadline을 제거하라는 요청인 경우
  • 코드 라인 22~29에서 해당 cpu에 대한 dl 설정이 없는 경우 함수를 빠져나간다.
  • 코드 라인 30~35에서 마지막 엘레멘트를 꺼내서 요청한 cpu의 엘레멘트로 복사하고 엘레멘트 수를 1 줄인다.
  • 코드 라인 36~41에서 기존 인덱스 값이 1 이상이면서 기존 인덱스보다 부모 deadline이 더 이른 경우 부모와 엘레멘트 교환을 하면서 루트까지 반복한다.
  • 코드 라인 42에서 free_cpus 비트맵에서 요청한 cpu에 해당하는 비트를 설정하여 해당 cpu에 dl 태스크가 설정되지 않았음을 나타낸다.
  • 코드 라인 43에서 기존 인덱스와 관련된 위치부터 그 child 트리 방향으로 힙정렬을 한다.

요청한 cpu의 deadline 설정

  • 코드 라인 48~49에서 해당 cpu에 대한 dl 설정이 없는 경우 엘레멘트 사이즈를 증가시킨다.
  • 코드 라인 50~52에서 엘레멘트의 마지막에 deadline 값을 0으로 하고, cpu를 설정하고, 인덱스는 마지막 값으로 한다.
  • 코드 라인 53에서 마지막에 추가한 위치에 cpudl 값을 갱신시키고 힙정렬시킨다.
  • 코드 라인 54에서 free_cpus 비트맵에서 요청한 cpu에 해당하는 비트를 클리어하여 해당 cpu에 earliest deadline이 설정되었음을 나타낸다.
  • 코드 라인 55~57에서 해당 cpu에 대한 dl 설정이 이미 있는 경우 해당 cpu에 대해 deadline을 갱신하고 힙정렬시킨다.

 

다음 그림은 총 7개의 cpu 시스템에서 6개의 cpu에 deadline이 설정되어 동작하는 중에 2번 cpu의 deadline이 클리어되는 모습을 보여준다.

 

다음 그림은 총 7개의 cpu 시스템에서 6개의 cpu에 deadline이 설정되어 동작하는 중에 미설정된 5번 cpu의 deadline이 설정되는 모습을 보여준다.

 

cpudl_exchange()

kernel/sched/cpudeadline.c

static void cpudl_exchange(struct cpudl *cp, int a, int b)
{
        int cpu_a = cp->elements[a].cpu, cpu_b = cp->elements[b].cpu;

        swap(cp->elements[a].cpu, cp->elements[b].cpu);
        swap(cp->elements[a].dl , cp->elements[b].dl );

        swap(cp->elements[cpu_a].idx, cp->elements[cpu_b].idx);
}

cpudl heap 트리 엘레멘트에서 a 인덱스와 b 인덱스의 엘레멘트를 서로 교환한다.

  • 코드 라인 3에서 인덱스 a 번째 엘레멘트의 cpu와 인덱스 b 번째 엘레멘트의 cpu를 알아온다.
  • 코드 라인 5~6에서 인덱스 a 번째 엘레멘트의 cpu 및 dl을 인덱스 b 번째 엘레멘트의 cpu 및 dl과 교환한다.
  • 코드 라인 8에서 엘레멘트가 교환됨에 따라 해당 엘레멘트의 cpu를 가리키는 인덱스 값도 갱신한다.

 

다음 그림은 3개의 cpu가 deadline이 설정되어 있는데 그 중 cpu #1번과 cpu #2번을 서로 교체하는 경우의 모습을 보여준다.

 

cpudl_change_key()

kernel/sched/cpudeadline.c

static void cpudl_change_key(struct cpudl *cp, int idx, u64 new_dl)
{
        WARN_ON(idx == IDX_INVALID || !cpu_present(idx));

        if (dl_time_before(new_dl, cp->elements[idx].dl)) {
                cp->elements[idx].dl = new_dl;
                cpudl_heapify(cp, idx);
        } else {
                cp->elements[idx].dl = new_dl;
                while (idx > 0 && dl_time_before(cp->elements[parent(idx)].dl,
                                        cp->elements[idx].dl)) {
                        cpudl_exchange(cp, idx, parent(idx));
                        idx = parent(idx);
                }
        }
}

해당 cpu에 대해 deadline을 갱신하고 힙정렬시킨다. (마감 시간이 가장 늦은 cpu의 엘레멘트가 가장 상위에 있는 2진 트리)

  • 코드 라인 5~7에서 요청한 deadline이 earliest deadline인 경우 새로운 deadline으로 갱신하고 힙정렬한다.
  • 코드 라인 8~9에서 요청한 deadline 값으로 갱신한다.
  • 코드 라인 10~14에서 갱신한 위치부터 부모  방향으로 최상위까지 이동하며 이동 중의 엘레멘트에 있는 deadline과 요청한 deadline을 비교하여 요청한 deadline이 더 뒤(after)인 경우 서로 교환시킨다. 즉 큰 deadline을 상위에 배치한다.

 

다음 그림은 큰 값 및 작은 값의 deadline으로 변경 시 부모 방향 또는 자식 방향으로 교체되어 가는 모습을 보여준다.

 

cpudl_heapify()

kernel/sched/cpudeadline.c

static void cpudl_heapify(struct cpudl *cp, int idx)
{
        int l, r, largest;

        /* adapted from lib/prio_heap.c */
        while(1) {
                l = left_child(idx);
                r = right_child(idx);
                largest = idx;

                if ((l < cp->size) && dl_time_before(cp->elements[idx].dl,
                                                        cp->elements[l].dl))
                        largest = l;
                if ((r < cp->size) && dl_time_before(cp->elements[largest].dl,
                                                        cp->elements[r].dl))
                        largest = r;
                if (largest == idx)
                        break;

                /* Push idx down the heap one level and bump one up */
                cpudl_exchange(cp, largest, idx);
                idx = largest;
        }
}

요청한 인덱스 부터 하위 방향으로 힙 정렬한다.  (마감 시간이 가장 늦은 cpu의 엘레멘트가 가장 상위에 있는 2진 트리)

  • 코드 라인 6~8에서 요청한 인덱스부터 하위 방향으로 루프를 도는데 현재 인덱스의 좌/우측 자식 인덱스 값을 산출한다.
    • 예) 인덱스 5의 좌측 인덱스 = (5 << 1) + 1 = 11
    • 예) 인덱스 5의 우측 인덱스 = (5 << 1) + 2 = 12
  • 코드 라인 11~13에서 순회중인 인덱스의 deadline이 산출한 좌측  인덱스의 deadline 보다 먼저인 경우 largest 인덱스 값에 산출한 좌측 인덱스  값을 대입한다.
  • 코드 라인 14~16에서 largest 인덱스의 deadline이 산출한 우측 인덱스의 deadline 보다 먼저인 경우 largest 인덱스 값에 산출한 우측 인덱스  값을 대입한다.
  • 코드 라인 17~18에서 largest 인덱스의 변경이 없으면 함수를 빠져나간다.
  • 코드 라인 21에서 현재 인덱스와 largest 인덱스에 있는 엘레멘트 값을 교환한다.
  • 코드 라인 22에서 largest 값을 순회중인 인덱스 값으로 대입하고 계속 루프를 돈다.

 

cpudl_find()

kernel/sched/cpudeadline.c

/*
 * cpudl_find - find the best (later-dl) CPU in the system
 * @cp: the cpudl max-heap context
 * @p: the task
 * @later_mask: a mask to fill in with the selected CPUs (or NULL)
 *
 * Returns: int - best CPU (heap maximum if suitable)
 */
int cpudl_find(struct cpudl *cp, struct task_struct *p,
               struct cpumask *later_mask)
{
        int best_cpu = -1;
        const struct sched_dl_entity *dl_se = &p->dl;

        if (later_mask &&
            cpumask_and(later_mask, cp->free_cpus, &p->cpus_allowed)) {
                best_cpu = cpumask_any(later_mask);
                goto out;
        } else if (cpumask_test_cpu(cpudl_maximum(cp), &p->cpus_allowed) &&
                        dl_time_before(dl_se->deadline, cp->elements[0].dl)) {
                best_cpu = cpudl_maximum(cp);
                if (later_mask)
                        cpumask_set_cpu(best_cpu, later_mask);
        }

out:
        WARN_ON(best_cpu != -1 && !cpu_present(best_cpu));

        return best_cpu;
}

deadline이 가장 여유 있는 cpu 번호를 찾아 반환한다. 출력 인수 later_mask에는 best cpu들에 대한 비트마스크가 설정되어 반환된다.

  • 코드 라인 15~18에서 인수 later_mask가 준비되었고 earliest deadline이 설정되지 않은 cpu와 태스크에 할당된 cpu들을 만족하는 cpu들이 있는 경우 그들 중 랜덤으로 cpu를 선택해서 반환한다.
  • 코드 라인 19~24에서 가장 늦은 deadline을 사용하는 cpu가 태스크에서 허용된 cpu이고 요청한 dl 태스크의 deadline보다 더 느리거나 같으면 그 cpu를 반환한다.

 

다음 그림은 dl 태스크를 스케줄하기 가장 알맞은 cpu를 찾는 모습을 보여준다.

 

DL Migration, Overload

DL Migration

inc_dl_migration()

kernel/sched/deadline.c

static void inc_dl_migration(struct sched_dl_entity *dl_se, struct dl_rq *dl_rq)
{
        struct task_struct *p = dl_task_of(dl_se);

        if (p->nr_cpus_allowed > 1)
                dl_rq->dl_nr_migratory++;

        update_dl_migration(dl_rq);
}

dl 태스크에 2개 이상의 cpu가 할당된 경우 dl_nr_migratory를 증가시키고 migration 가능 여부를 갱신한다.

 

dec_dl_migration()

kernel/sched/deadline.c

static void dec_dl_migration(struct sched_dl_entity *dl_se, struct dl_rq *dl_rq)
{
        struct task_struct *p = dl_task_of(dl_se);

        if (p->nr_cpus_allowed > 1)
                dl_rq->dl_nr_migratory--;

        update_dl_migration(dl_rq);
}

dl 태스크에 2개 이상의 cpu가 할당된 경우 dl_nr_migratory를 감소시키고 migration 가능 여부를 갱신한다.

 

update_dl_migration()

kernel/sched/deadline.c

static void update_dl_migration(struct dl_rq *dl_rq)
{
        if (dl_rq->dl_nr_migratory && dl_rq->dl_nr_running > 1) {
                if (!dl_rq->overloaded) {
                        dl_set_overload(rq_of_dl_rq(dl_rq));
                        dl_rq->overloaded = 1; 
                }
        } else if (dl_rq->overloaded) {
                dl_clear_overload(rq_of_dl_rq(dl_rq));
                dl_rq->overloaded = 0;
        }
}

런큐의 migration 가능 여부를 갱신한다.

  • 코드 라인 3~7에서 dl 런큐의 dl_nr_migratory가 1 이상이고 dl 런큐에 dl 태스크의 수가 2개 이상인 경우 런큐를 overload 설정한다.
  • 코드 라인 8~11에서 런큐가 이미 오버로드된 경우 클리어한다.

 

DL Overload

dl_set_overload()

kernel/sched/deadline.c

static inline void dl_set_overload(struct rq *rq)
{
        if (!rq->online)
                return;

        cpumask_set_cpu(rq->cpu, rq->rd->dlo_mask);
        /*
         * Must be visible before the overload count is
         * set (as in sched_rt.c).
         *
         * Matched by the barrier in pull_dl_task().
         */
        smp_wmb();
        atomic_inc(&rq->rd->dlo_count);
}

요청한 런큐를 overload 설정한다

  • 코드 라인 3~4에서 런큐가 offline 상태면 함수를 빠져나간다.
  • 코드 라인 6에서 런큐의 루트 도메인에 있는 dlo_mask에 런큐가 동작하는 cpu에 해당하는 비트를 설정한다.
  • 코드 라인 14에서 런큐의 루트 도메인에 있는 dlo_count를 1 증가시킨다.

 

dl_clear_overload()

kernel/sched/deadline.c

static inline void dl_clear_overload(struct rq *rq)
{
        if (!rq->online)
                return;

        atomic_dec(&rq->rd->dlo_count);
        cpumask_clear_cpu(rq->cpu, rq->rd->dlo_mask);
}

요청한 런큐를 overload 클리어한다

  • 코드 라인 3~4에서 런큐가 offline 상태면 함수를 빠져나간다.
  • 코드 라인 6에서 런큐의 루트 도메인에 있는 dlo_count를 1 감소시킨다.
  • 코드 라인 7에서 런큐의 루트 도메인에 있는 dlo_mask에 런큐가 동작하는 cpu에 해당하는 비트를 클리어한다.

 

Pushable DL tasks

Enqueue & Dequeue

enqueue_pushable_dl_task()

kernel/sched/deadline.c

/*
 * The list of pushable -deadline task is not a plist, like in
 * sched_rt.c, it is an rb-tree with tasks ordered by deadline.
 */
static void enqueue_pushable_dl_task(struct rq *rq, struct task_struct *p)
{
        struct dl_rq *dl_rq = &rq->dl;
        struct rb_node **link = &dl_rq->pushable_dl_tasks_root.rb_node;
        struct rb_node *parent = NULL;
        struct task_struct *entry;
        int leftmost = 1;

        BUG_ON(!RB_EMPTY_NODE(&p->pushable_dl_tasks));

        while (*link) {
                parent = *link;
                entry = rb_entry(parent, struct task_struct,
                                 pushable_dl_tasks);
                if (dl_entity_preempt(&p->dl, &entry->dl))
                        link = &parent->rb_left;
                else {
                        link = &parent->rb_right;
                        leftmost = 0;
                }
        }

        if (leftmost)
                dl_rq->pushable_dl_tasks_leftmost = &p->pushable_dl_tasks;

        rb_link_node(&p->pushable_dl_tasks, parent, link);
        rb_insert_color(&p->pushable_dl_tasks, &dl_rq->pushable_dl_tasks_root);
}

요청한 dl 태스크를 pushable dl 태스크 RB 트리에 추가한다.

  • 코드 라인 8에서 요청한 런큐의 dl 런큐에 있는 pushable_dl_tasks_root RB 트리를 알아온다.
  • 코드 라인 15~25에서 요청한 dl 태스크가 위치할 노드를 찾아간다.
  • 코드 라인 27~28에서 dl 태스크의 deadline이 가장 먼저(early)인 경우 leftmost에 연결한다.
  • 코드 라인 30~31에서 dl 태스크를 pushable dl 태스크  RB 트리에 추가하고 color를 갱신한다.

 

dequeue_pushable_dl_task()

kernel/sched/deadline.c

static void dequeue_pushable_dl_task(struct rq *rq, struct task_struct *p)
{
        struct dl_rq *dl_rq = &rq->dl;

        if (RB_EMPTY_NODE(&p->pushable_dl_tasks))
                return;

        if (dl_rq->pushable_dl_tasks_leftmost == &p->pushable_dl_tasks) {
                struct rb_node *next_node;

                next_node = rb_next(&p->pushable_dl_tasks);
                dl_rq->pushable_dl_tasks_leftmost = next_node;
        }

        rb_erase(&p->pushable_dl_tasks, &dl_rq->pushable_dl_tasks_root);
        RB_CLEAR_NODE(&p->pushable_dl_tasks);
}

요청한 dl 태스크를 pushable dl 태스크 RB 트리에서 제거한다.

  • 코드 라인 5~6에서 RB 트리가 이미 비어 있는 경우 함수를 빠져나간다.
  • 코드 라인 8~13에서 제거할 태스크의 deadline이 가장 먼저(early)인 경우 다음으로 deadline이 빠른 태스크를 leftmost에 대입한다.
  • 코드 라인 15~16에서 dl 태스크를 pushable dl 태스크  RB 트리에서 제거하고 color를 갱신한다.

 

Push Operations

has_pushable_dl_tasks()

kernel/sched/deadline.c

static inline int has_pushable_dl_tasks(struct rq *rq)
{
        return !RB_EMPTY_ROOT(&rq->dl.pushable_dl_tasks_root);
}

요청한 런큐의 pushable dl 태스크 RB 트리에 태스크가 존재하는지 여부를 반환한다. 1=존재, 0=비존재

 

push_dl_task()

요청한 런큐에서 오버로드되어 현재 동작하지 않는 dl 태스크에 대해 다른 여유있는 cpu로 migration 시키고 해당 런큐에서 동작중인 태스크에 preemption 요청 플래그를 설정한다.

kernel/sched/deadline.c – 1/2

/*
 * See if the non running -deadline tasks on this rq
 * can be sent to some other CPU where they can preempt
 * and start executing.
 */
static int push_dl_task(struct rq *rq)
{
        struct task_struct *next_task;
        struct rq *later_rq;
        int ret = 0;

        if (!rq->dl.overloaded)
                return 0;

        next_task = pick_next_pushable_dl_task(rq);
        if (!next_task)
                return 0;

retry:
        if (unlikely(next_task == rq->curr)) {
                WARN_ON(1);
                return 0;
        }

        /*
         * If next_task preempts rq->curr, and rq->curr
         * can move away, it makes sense to just reschedule
         * without going further in pushing next_task.
         */
        if (dl_task(rq->curr) &&
            dl_time_before(next_task->dl.deadline, rq->curr->dl.deadline) &&
            rq->curr->nr_cpus_allowed > 1) {
                resched_curr(rq);
                return 0;
        }

        /* We might release rq lock */
        get_task_struct(next_task);
  • 코드 라인 12~13에서 요청한 런큐가 오버로드되지 않은 경우 성공(0)으로 함수를 빠져나간다.
  • 코드 라인 15~17에서 요청한 런큐에서 가장 deadline이 빠른 태스크를 알아온다. 만일 발견하지 못하면 성공(0)으로 함수를 빠져나간다.
  • 코드 라인 20~23에서 낮은 확률로 처리할 태스크가 요청한 런큐에서 이미 동작중인 경우 성공(0)으로 함수를 빠져나간다.
  • 코드 라인 30~35에서 요청한 런큐에서 동작중인 dl 태스크의 deadline보다 다음 태스크의 deadline이 더 먼저이면서 현재 동작중인 dl 태스크에  할당된 cpu가 2개 이상인 경우 리스케줄 요청 플래그를 설정하고 성공(0)으로 함수를 빠져나간다.
    • 현재 dl 태스크보다 더 deadline이 빠른 dl 태스크가 있는 경우 리스케줄한다.
  • 코드 라인 38에서 다음 태스크의 참조 카운터를 증가시킨다.

 

kernel/sched/deadline.c – 2/2

        /* Will lock the rq it'll find */
        later_rq = find_lock_later_rq(next_task, rq);
        if (!later_rq) {
                struct task_struct *task;

                /*
                 * We must check all this again, since
                 * find_lock_later_rq releases rq->lock and it is
                 * then possible that next_task has migrated.
                 */
                task = pick_next_pushable_dl_task(rq);
                if (task_cpu(next_task) == rq->cpu && task == next_task) {
                        /*
                         * The task is still there. We don't try
                         * again, some other cpu will pull it when ready.
                         */
                        goto out;
                }

                if (!task)
                        /* No more tasks */
                        goto out;

                put_task_struct(next_task);
                next_task = task;
                goto retry;
        }

        deactivate_task(rq, next_task, 0);
        set_task_cpu(next_task, later_rq->cpu);
        activate_task(later_rq, next_task, 0);
        ret = 1;

        resched_curr(later_rq);

        double_unlock_balance(rq, later_rq);

out:
        put_task_struct(next_task);

        return ret;
}
  • 코드 라인 2에서 요청한 dl 태스크를 돌릴만한 여유있는 later 런큐를 알아온다.
  • 코드 라인 3~11에서 찾아온 적절한 later 런큐가 없는 경우 pushable dl 태스크 RB 트리에 있는 다음 태스크를 가져온다.
  • 코드 라인 12~18에서 다음 태스크의 cpu가 현재 런큐의 cpu와 같으면서 알아온 태스크가 다음 태스크와 동일한 경우 null을 반환한다.
  • 코드 라인 20~22에서 알아온 태스크가 없으면 null을 반환한다.
  • 코드 라인 24~27에서 알아온 태스크를 다음 태스크에 대입하고 반복한다.
  • 코드 라인 29~31에서 다음 태스크를 런큐에서 디큐하고 태스크에 later 런큐의 cpu를 설정하고 later 런큐에 엔큐한다.
  • 코드 라인 32~41에서 later 런큐에서 동작중인 태스크에 리스케줄 요청 플래그를 설정한 후 1을 반환한다.

 

pick_next_pushable_dl_task()

kernel/sched/deadline.c

static struct task_struct *pick_next_pushable_dl_task(struct rq *rq)
{
        struct task_struct *p;

        if (!has_pushable_dl_tasks(rq))
                return NULL;

        p = rb_entry(rq->dl.pushable_dl_tasks_leftmost,
                     struct task_struct, pushable_dl_tasks);

        BUG_ON(rq->cpu != task_cpu(p));
        BUG_ON(task_current(rq, p));
        BUG_ON(p->nr_cpus_allowed <= 1);

        BUG_ON(!task_on_rq_queued(p));
        BUG_ON(!dl_task(p));

        return p;
}

요청한 런큐에서 가장 deadline이 빠른 태스크를 반환한다.

 

find_lock_later_rq()

kernel/sched/deadline.c

/* Locks the rq it finds */
static struct rq *find_lock_later_rq(struct task_struct *task, struct rq *rq)
{
        struct rq *later_rq = NULL;
        int tries;
        int cpu;

        for (tries = 0; tries < DL_MAX_TRIES; tries++) {
                cpu = find_later_rq(task);

                if ((cpu == -1) || (cpu == rq->cpu))
                        break;

                later_rq = cpu_rq(cpu);

                /* Retry if something changed. */
                if (double_lock_balance(rq, later_rq)) {
                        if (unlikely(task_rq(task) != rq ||
                                     !cpumask_test_cpu(later_rq->cpu,
                                                       &task->cpus_allowed) ||
                                     task_running(rq, task) ||
                                     !task_on_rq_queued(task))) {
                                double_unlock_balance(rq, later_rq);
                                later_rq = NULL;
                                break;
                        }
                }

                /*
                 * If the rq we found has no -deadline task, or
                 * its earliest one has a later deadline than our
                 * task, the rq is a good one.
                 */
                if (!later_rq->dl.dl_nr_running ||
                    dl_time_before(task->dl.deadline,
                                   later_rq->dl.earliest_dl.curr))
                        break;

                /* Otherwise we try again. */
                double_unlock_balance(rq, later_rq);
                later_rq = NULL;
        }

        return later_rq;
}

요청한 dl 태스크를 돌릴만한 여유있는 later 런큐를 찾아 반환한다.

  • 코드 라인 8~9에서 최대 3회 이내를 반복하며 later_mask에 있는 cpu들 중 deadline이 가장 여유있는 cpu 또는 적절한 cpu를 찾아온다.
  • 코드 라인 11~12에서 찾은 cpu가 없거나 현재 런큐의 cpu인 경우 null을 반환한다.
  • 코드 라인 14에서 결정한 cpu의 런큐를 later_rq에 대입한다.
  • 코드 라인 17~27에서 낮은 확률로 다음 조건에 해당하면 null을 반환한다.
    • 요청한 런큐와 태스크가 있는 런큐가 다르거나
    • 태스크에 허락된 cpu들 중 later 런큐의 cpu가 없거나
    • 이미 태스크가 현재 cpu에서 동작중이거나
    • 태스크가 런큐에 없는 경우 null을 반환한다.
  • 코드 라인 34~37에서 later 런큐에 dl 태스크가 하나도 없거나 요청한 태스크의 deadline이 later 런큐에서 동작중인 dl 태스크의 deadline보다 더 먼저인 경우 루프를 탈출하고 later_rq를 반환한다.
    • 이 later 런큐에 dl 태스크가 하나도 없거나 현재 동작 중인 dl 태스크의 deadline 보다 먼저인 경우 이 later 런큐가 적절하다.
  • 코드 라인 40~41에서 later_rq를 다시 null로 하고 루프를 반복한다.

 

find_later_rq()

later_mask에 있는 cpu들 중 deadline이 가장 여유있는 적절한 cpu 또는 적절한 cpu를 찾아 반환한다.

kernel/sched/deadline.c – 1/2

static int find_later_rq(struct task_struct *task)
{
        struct sched_domain *sd;
        struct cpumask *later_mask = this_cpu_cpumask_var_ptr(local_cpu_mask_dl);
        int this_cpu = smp_processor_id();
        int best_cpu, cpu = task_cpu(task);

        /* Make sure the mask is initialized first */
        if (unlikely(!later_mask))
                return -1;

        if (task->nr_cpus_allowed == 1)
                return -1;

        /*
         * We have to consider system topology and task affinity
         * first, then we can look for a suitable cpu.
         */
        best_cpu = cpudl_find(&task_rq(task)->rd->cpudl,
                        task, later_mask);
        if (best_cpu == -1)
                return -1;

        /*
         * If we are here, some target has been found,
         * the most suitable of which is cached in best_cpu.
         * This is, among the runqueues where the current tasks
         * have later deadlines than the task's one, the rq
         * with the latest possible one.
         *
         * Now we check how well this matches with task's
         * affinity and system topology.
         * 
         * The last cpu where the task run is our first
         * guess, since it is most likely cache-hot there.
         */
        if (cpumask_test_cpu(cpu, later_mask))
                return cpu;
        /*
         * Check if this_cpu is to be skipped (i.e., it is
         * not in the mask) or not.
         */
        if (!cpumask_test_cpu(this_cpu, later_mask))
                this_cpu = -1;
  • 코드 라인 4에서 전역 per-cpu local_cpu_mask_dl에서 현재 cpu에 대한 비트마스크를 알아와서 later_mask에 대입한다.
  • 코드 라인 9~10에서 later_mask에 아무것도 설정된 cpu가 없으면 -1을 반환한다.
  • 코드 라인 12~13에서 현재 태스크에 할당된 cpu가 1개 밖에 없으면 -1을 반환한다.
  • 코드 라인 19~22에서 later_mask에 있는 cpu들 중 가장 여유 있는 deadline을 가진 best_cpu를 알아오고 없으면 -1을 반환한다.
  • 코드 라인 37~38에서 later_mask에서 태스크의 cpu에 해당하는 비트가 설정된 경우 태스크의 cpu를 반환한다.
  • 코드 라인 43~44에서 later_mask에서 현재 cpu에 해당하는 비트가 설정되지 않은 경우 this_cpu에 -1을 설정한다.

 

kernel/sched/deadline.c – 2/2

        rcu_read_lock();
        for_each_domain(cpu, sd) {
                if (sd->flags & SD_WAKE_AFFINE) {

                        /*
                         * If possible, preempting this_cpu is
                         * cheaper than migrating.
                         */
                        if (this_cpu != -1 &&
                            cpumask_test_cpu(this_cpu, sched_domain_span(sd))) {
                                rcu_read_unlock();
                                return this_cpu;
                        }

                        /*
                         * Last chance: if best_cpu is valid and is
                         * in the mask, that becomes our choice.
                         */
                        if (best_cpu < nr_cpu_ids &&
                            cpumask_test_cpu(best_cpu, sched_domain_span(sd))) {
                                rcu_read_unlock();
                                return best_cpu;
                        }
                }
        }
        rcu_read_unlock();

        /*
         * At this point, all our guesses failed, we just return
         * 'something', and let the caller sort the things out.
         */
        if (this_cpu != -1)
                return this_cpu;

        cpu = cpumask_any(later_mask);
        if (cpu < nr_cpu_ids)
                return cpu;

        return -1;
}
  • 코드 라인 2~3에서 cpu가 소속된 스케줄 도메인들을 순회하며 순회중인 도메인에 SD_WAKE_AFFINE 플래그가 설정된 경우
  • 코드 라인 9~13에서 later_mask에 현재 cpu가 없고 순회중인 스케줄 도메인에서는 포함된 경우 현재 cpu를 반환한다.
    • 현재 cpu를 사용하는 것이 migration하는 것보다 비용이 저렴하다.
  • 코드 라인 19~23에서 best cpu가 순회 중인 스케줄 도메인에 포함된 경우 best cpu를 반환한다.
  • 코드 라인 32~33에서 later_mask에 현재 cpu가 없는 경우 이 시점에서는 그냥 현재 cpu를 사용한다.
  • 코드 라인 35~37에서 later_mask 중 랜덤으로 하나를 골라 반환한다.

 

Pull Operations

need_pull_dl_task()

kernel/sched/deadline.c

static inline bool need_pull_dl_task(struct rq *rq, struct task_struct *prev)
{
        return dl_task(prev);
}

dl 태스크 여부를 반환한다.

 

dl_task()

include/linux/sched/deadline.h

static inline int dl_task(struct task_struct *p)
{
        return dl_prio(p->prio);
}

dl 태스크 여부를 반환한다.

 

dl_prio()

include/linux/sched/deadline.h

static inline int dl_prio(int prio)
{
        if (unlikely(prio < MAX_DL_PRIO))
                return 1;
        return 0;
}

dl 태스크 여부를 반환한다.

 

include/linux/sched/deadline.h

#define MAX_DL_PRIO             0

 

pull_dl_task()

모든 오버로드된 cpu들에서 대기중인 dl 태스크들 중 가장 급한 태스크를 알아온다.

kernel/sched/deadline.c

static int pull_dl_task(struct rq *this_rq)
{
        int this_cpu = this_rq->cpu, ret = 0, cpu;
        struct task_struct *p;
        struct rq *src_rq;
        u64 dmin = LONG_MAX;

        if (likely(!dl_overloaded(this_rq)))
                return 0;

        /*
         * Match the barrier from dl_set_overloaded; this guarantees that if we
         * see overloaded we must also see the dlo_mask bit.
         */
        smp_rmb();

        for_each_cpu(cpu, this_rq->rd->dlo_mask) {
                if (this_cpu == cpu)
                        continue;

                src_rq = cpu_rq(cpu);

                /*
                 * It looks racy, abd it is! However, as in sched_rt.c,
                 * we are fine with this.
                 */
                if (this_rq->dl.dl_nr_running &&
                    dl_time_before(this_rq->dl.earliest_dl.curr,
                                   src_rq->dl.earliest_dl.next))
                        continue;

                /* Might drop this_rq->lock */
                double_lock_balance(this_rq, src_rq);

                /*
                 * If there are no more pullable tasks on the
                 * rq, we're done with it.
                 */
                if (src_rq->dl.dl_nr_running <= 1)
                        goto skip;

                p = pick_next_earliest_dl_task(src_rq, this_cpu);
  • 코드 라인 8~9에서 높은 확률로 요청한 런큐가 오버로드되지 않은 경우 0을 반환한다.
  • 코드 라인 17~19에서 요청한 런큐에 루트 도메인에 있는 dlo_mask에 설정된 cpu들에 대해 순회를 하며 순회중인 cpu가 요청한 cpu인 경우 skip 한다.
  • 코드 라인 21에서 순회중인 cpu에 대한 런큐를 src_rq에 대입한다.
  • 코드 라인 27~30에서 요청한 런큐에서 동작중인 dl 태스크의 deadline이 dl 런큐에서 대기중인 태스크의 deadline보다 더 우선적으로 요구되는 일반적인 경우 skip 한다.
  • 코드 라인 39~40에서 요청한 런큐에서 동작중인 dl 태스크가 1개 이하인 경우 skip 한다.
  • 코드 라인 42에서 대기중인 다음 dl 태스크가 더 deadline이 더 빠른 경우이므로 이 태스크를 얻어온다.

 

                /*
                 * We found a task to be pulled if:
                 *  - it preempts our current (if there's one),
                 *  - it will preempt the last one we pulled (if any).
                 */
                if (p && dl_time_before(p->dl.deadline, dmin) &&
                    (!this_rq->dl.dl_nr_running ||
                     dl_time_before(p->dl.deadline,
                                    this_rq->dl.earliest_dl.curr))) {
                        WARN_ON(p == src_rq->curr);
                        WARN_ON(!task_on_rq_queued(p));

                        /*
                         * Then we pull iff p has actually an earlier
                         * deadline than the current task of its runqueue.
                         */
                        if (dl_time_before(p->dl.deadline,
                                           src_rq->curr->dl.deadline))
                                goto skip;

                        ret = 1;

                        deactivate_task(src_rq, p, 0);
                        set_task_cpu(p, this_cpu);
                        activate_task(this_rq, p, 0);
                        dmin = p->dl.deadline;

                        /* Is there any other task even earlier? */
                }
skip:
                double_unlock_balance(this_rq, src_rq);
        }

        return ret;
}
  • 코드 라인 6~9에서 현재 런큐에 dl 태스크가 없거나 태스크의 deadline이 현재 런큐에서 동작하는 태스크보다 더 급한 경우
  • 코드 라인 17~19에서 태스크의 deadline이 순회중인 오버로드된 cpu의 런큐보다 더 급한 경우 skip 한다.
  • 코드 라인 23~25에서 요청 태스크를 순회중인 런큐에서 디큐하고 현재 cpu를 설정하며 찾은 런큐에는 엔큐한다.
  • 코드 라인 26에서 태스크의 deadline 값을 보관하여 이 deadline 보다 더 급한 태스크가 나올 경우에만 이 조건을 흐르게 한다.
    • 따라서 각 cpu의 급한 dl 태스크들 중 가장 급한 태스크를 가져올 수 있도록 한다.

 

pick_next_earliest_dl_task()

kernel/sched/deadline.c

/* Returns the second earliest -deadline task, NULL otherwise */
static struct task_struct *pick_next_earliest_dl_task(struct rq *rq, int cpu)
{
        struct rb_node *next_node = rq->dl.rb_leftmost;
        struct sched_dl_entity *dl_se;
        struct task_struct *p = NULL;

next_node: 
        next_node = rb_next(next_node);
        if (next_node) {
                dl_se = rb_entry(next_node, struct sched_dl_entity, rb_node);
                p = dl_task_of(dl_se);

                if (pick_dl_task(rq, p, cpu))
                        return p;

                goto next_node;
        }

        return NULL;
}

요청한 런큐의 dl 런큐에서 대기중인 dl 태스크에서 요청한 cpu에 할당될 수 있는 가장 우선(deadline이 빠른) 태스크를 반환한다.

 

pick_dl_task()

kernel/sched/deadline.c

static int pick_dl_task(struct rq *rq, struct task_struct *p, int cpu)
{
        if (!task_running(rq, p) &&
            cpumask_test_cpu(cpu, tsk_cpus_allowed(p)))
                return 1;
        return 0;
}

요청한 태스크가 런큐에서 동작하지 않은 태스크이며 요청한 cpu에 할당 가능하면 true(1)를 반환한다.

 

Deadline 타이머

 

start_dl_timer()

kernel/sched/deadline.c

/*
 * If the entity depleted all its runtime, and if we want it to sleep
 * while waiting for some new execution time to become available, we
 * set the bandwidth enforcement timer to the replenishment instant
 * and try to activate it.
 *
 * Notice that it is important for the caller to know if the timer
 * actually started or not (i.e., the replenishment instant is in
 * the future or in the past).
 */
static int start_dl_timer(struct sched_dl_entity *dl_se, bool boosted)
{
        struct dl_rq *dl_rq = dl_rq_of_se(dl_se);
        struct rq *rq = rq_of_dl_rq(dl_rq);
        ktime_t now, act;
        ktime_t soft, hard;
        unsigned long range;
        s64 delta;

        if (boosted)
                return 0;
        /*
         * We want the timer to fire at the deadline, but considering
         * that it is actually coming from rq->clock and not from
         * hrtimer's time base reading.
         */
        act = ns_to_ktime(dl_se->deadline);
        now = hrtimer_cb_get_time(&dl_se->dl_timer);
        delta = ktime_to_ns(now) - rq_clock(rq);
        act = ktime_add_ns(act, delta);

        /*
         * If the expiry time already passed, e.g., because the value
         * chosen as the deadline is too small, don't even try to
         * start the timer in the past!
         */
        if (ktime_us_delta(act, now) < 0)
                return 0;

        hrtimer_set_expires(&dl_se->dl_timer, act);

        soft = hrtimer_get_softexpires(&dl_se->dl_timer);
        hard = hrtimer_get_expires(&dl_se->dl_timer);
        range = ktime_to_ns(ktime_sub(hard, soft));
        __hrtimer_start_range_ns(&dl_se->dl_timer, soft,
                                 range, HRTIMER_MODE_ABS, 0);

        return hrtimer_active(&dl_se->dl_timer);
}

dl 타이머를 가동시킨다. 가동된 경우 1을 반환한다.

  • 코드 라인 20~21에서 부스트된 경우 실패(0)을 반환한다.
  • 코드 라인 27~30에서 dl 엔티티의 deadline에 현재 hrtimer의 현재 시각과 런큐 클럭의 차이를 더해 act에 대입한다.
    • 실제 deadline을 발사할 타이밍은 hrtimer의 시각 관점이 아니라 런큐 클럭의 시각 관점이므로 보정이 필요한다.
  • 코드 라인 37~38에서 만료 시각이 지난 경우 0을 반환한다.
  • 코드 라인 40에서 act 시각으로 dl 타이머의 만료 시각을 설정한다.
  • 코드 라인 42~44에서 만료 시각에 range를 두지 않았으므로 soft와 hard의 만료시각은 같고 range는 0이다.
  • 코드 라인 45~46에서 dl 타이머를 가동시킨다.
  • 코드 라인 48에서 dl 타이머의 가동 여부를 반환한다.

 

dl_task_timer()

dl 타이머가 동작되어 호출되는 함수이다. 필요 시 런타임과 deadline을 보충하거나 preemption 요청 플래그를 설정한다.

kernel/sched/deadline.c -1/2

/*
 * This is the bandwidth enforcement timer callback. If here, we know
 * a task is not on its dl_rq, since the fact that the timer was running
 * means the task is throttled and needs a runtime replenishment.
 *
 * However, what we actually do depends on the fact the task is active,
 * (it is on its rq) or has been removed from there by a call to
 * dequeue_task_dl(). In the former case we must issue the runtime
 * replenishment and add the task back to the dl_rq; in the latter, we just
 * do nothing but clearing dl_throttled, so that runtime and deadline
 * updating (and the queueing back to dl_rq) will be done by the
 * next call to enqueue_task_dl().
 */
static enum hrtimer_restart dl_task_timer(struct hrtimer *timer)
{
        struct sched_dl_entity *dl_se = container_of(timer,
                                                     struct sched_dl_entity,
                                                     dl_timer);
        struct task_struct *p = dl_task_of(dl_se);
        unsigned long flags;
        struct rq *rq;

        rq = task_rq_lock(p, &flags);

        /*
         * We need to take care of several possible races here:
         *
         *   - the task might have changed its scheduling policy
         *     to something different than SCHED_DEADLINE
         *   - the task might have changed its reservation parameters
         *     (through sched_setattr())
         *   - the task might have been boosted by someone else and
         *     might be in the boosting/deboosting path
         *
         * In all this cases we bail out, as the task is already
         * in the runqueue or is going to be enqueued back anyway.
         */
        if (!dl_task(p) || dl_se->dl_new ||
            dl_se->dl_boosted || !dl_se->dl_throttled)
                goto unlock;

        sched_clock_tick();
        update_rq_clock(rq);
  • 코드 라인 38~40에서 dl 태스크가 아니거나 새로운 dl 태스크이거나 부스트되었거나 스로틀된 경우가 아니면 함수를 빠져나간다.
  • 코드 라인 42~43에서 런큐 클럭을 갱신한다.

 

kernel/sched/deadline.c -2/2

        /*
         * If the throttle happened during sched-out; like:
         *
         *   schedule()
         *     deactivate_task()
         *       dequeue_task_dl()
         *         update_curr_dl()
         *           start_dl_timer()
         *         __dequeue_task_dl()
         *     prev->on_rq = 0;
         *
         * We can be both throttled and !queued. Replenish the counter
         * but do not enqueue -- wait for our wakeup to do that.
         */
        if (!task_on_rq_queued(p)) {
                replenish_dl_entity(dl_se, dl_se);
                goto unlock;
        }

        enqueue_task_dl(rq, p, ENQUEUE_REPLENISH);
        if (dl_task(rq->curr))
                check_preempt_curr_dl(rq, p, 0);
        else
                resched_curr(rq);
#ifdef CONFIG_SMP
        /*
         * Queueing this task back might have overloaded rq,
         * check if we need to kick someone away.
         */
        if (has_pushable_dl_tasks(rq))
                push_dl_task(rq);
#endif
unlock:
        task_rq_unlock(rq, p, &flags);

        return HRTIMER_NORESTART;
}
  • 코드 라인 15~18에서 태스크가 런큐에 없는 경우 조건에 따라 pi 엔티티에 할당된 deadline 및 런타임을 dl 엔티티에 설정하거나 보충한다.
  • 코드 라인 20에서 태스크를 dl 런큐에 추가한다.
  • 코드 라인 21~24에서 런큐에서 동작 중인 태스크가 dl 태스크인 경우 preemption이 필요한 지 여부를 체크하여 필요 시 preemption 요청 플래그를 설정한다. 그렇지 않은 경우 무조건 preemption 요청 플래그를 설정한다.
  • 코드 라인 30~31에서 요청한 런큐의 dl.pushable_dl_tasks_root RB 트리가 비어 있지 않은 경우 요청한 런큐에서 오버로드되어 현재 동작하지 않는 dl 태스크에 대해 다른 여유있는 cpu로 migration 시키고 해당 런큐에서 동작중인 태스크에 preemption 요청 플래그를 설정한다.

 

태스크 선택

select_task_rq_dl()

kernel/sched/deadline.c

static int
select_task_rq_dl(struct task_struct *p, int cpu, int sd_flag, int flags)
{
        struct task_struct *curr;
        struct rq *rq;

        if (sd_flag != SD_BALANCE_WAKE)
                goto out;

        rq = cpu_rq(cpu);

        rcu_read_lock();
        curr = ACCESS_ONCE(rq->curr); /* unlocked access */

        /*
         * If we are dealing with a -deadline task, we must
         * decide where to wake it up.
         * If it has a later deadline and the current task
         * on this rq can't move (provided the waking task
         * can!) we prefer to send it somewhere else. On the
         * other hand, if it has a shorter deadline, we
         * try to make it stay here, it might be important.
         */
        if (unlikely(dl_task(curr)) &&
            (curr->nr_cpus_allowed < 2 ||
             !dl_entity_preempt(&p->dl, &curr->dl)) &&
            (p->nr_cpus_allowed > 1)) {
                int target = find_later_rq(p);

                if (target != -1)
                        cpu = target;
        }
        rcu_read_unlock();

out:
        return cpu;
}

도메인 로드밸런스가 동작할 때 조건에 따라 deadline이 가장 여유있는 적절한 cpu 또는 적절한 cpu를 찾아 반환한다.

  • 코드 라인 7~8에서 SD_BALANCE_WAKE 도메인 플래그가 설정되지 않았으면 요청한 cpu를 그대로 반환한다.
  • 코드 라인 24~32에서 낮은 확률로 다음 조건을 모두 만족하는 경우 deadline이 가장 여유있는 적절한 cpu 또는 적절한 cpu를 찾아 반환한다.
    • 현재 런큐에서 동작중인 태스크가 dl 태스크인 경우
    • 허락된 cpu가 1개 이하이거나 요청 태스크의 deadline이 더 급해 preemption이 필요한 경우가 아닌 경우
    • 요청한 태스크에 허락된 cpu가 2개 이상인 경우

 

Check Preempt

check_preempt_curr_dl()

kernel/sched/deadline.c

/*
 * Only called when both the current and waking task are -deadline
 * tasks.
 */
static void check_preempt_curr_dl(struct rq *rq, struct task_struct *p,
                                  int flags)
{
        if (dl_entity_preempt(&p->dl, &rq->curr->dl)) {
                resched_curr(rq);
                return;
        }

#ifdef CONFIG_SMP
        /*
         * In the unlikely case current and p have the same deadline
         * let us try to decide what's the best thing to do...
         */
        if ((p->dl.deadline == rq->curr->dl.deadline) &&
            !test_tsk_need_resched(rq->curr))
                check_preempt_equal_dl(rq, p);
#endif /* CONFIG_SMP */
}

preemption 할지 여부를 체크하여 필요 시 리스케줄 요청 플래그를 설정한다.

  • 코드 라인 8~11에서 요청한 dl 태스크의 deadline이 현재 런큐에서 동작중인 dl 태스크의 deadline 보다 만료 시간이 빨라 더 급한 경우 현재 태스크에 리스케줄 요청 플래그를 설정하고 함수를 빠져나간다.
  • 코드 라인 18~20에서 요청한 dl 태스크의  deadline이 런큐에서 동작중인 dl 태스크의  deadline과 동일하고 런큐에서 동작 중인 태스크에 리스케줄 요청이 없었던 경우 cpudl의 deadline과 비교하여 best cpu가 있는 경우 리스케줄 요청 플래그를 설정한다.

 

dl_entity_preempt()

kernel/sched/sched.h

/*
 * Tells if entity @a should preempt entity @b.
 */
static inline bool
dl_entity_preempt(struct sched_dl_entity *a, struct sched_dl_entity *b)
{
        return dl_time_before(a->deadline, b->deadline);
}

a dl 엔티티의 deadline이 b dl 엔티티의 deadline보다 빨라 더 급한 경우 true(1)를 반환한다.

  • b를 preemption 시키고 a가 동작해야 하는 경우 true

 

check_preempt_equal_dl()

kernel/sched/deadline.c

static void check_preempt_equal_dl(struct rq *rq, struct task_struct *p)
{
        /*
         * Current can't be migrated, useless to reschedule,
         * let's hope p can move out.
         */
        if (rq->curr->nr_cpus_allowed == 1 ||
            cpudl_find(&rq->rd->cpudl, rq->curr, NULL) == -1)
                return;

        /*
         * p is migratable, so let's not schedule it and
         * see if it is pushed or pulled somewhere else.
         */
        if (p->nr_cpus_allowed != 1 &&
            cpudl_find(&rq->rd->cpudl, p, NULL) != -1)
                return;

        resched_curr(rq);
}

런큐에서 동작중인 태스크와 요청한 태스크가 동일 deadline을 가졌을 때 preemption 할지 여부를 체크하여 필요 시 리스케줄 요청 플래그를 설정한다.

  • 코드 라인 7~9에서 요청한 런큐에서 동작중인 태스크에 할당된 cpu가 1개 뿐이거나 런큐에서 동작중인 태스크의 deadline 보다 빠른 cpudl에서 찾은 적절한 cpu가 없으면 함수를 빠져나간다.
  • 코드 라인 15~17에서 요청한 태스크의 cpu가 2개 이상의 cpu가 할당되었으면서 요청한 태스크의 deadline보다 빠른 cpudl에서 찾은 best cpu가 없으면 함수를 빠져나간다.
  • 코드 라인 19에서 요청한 런큐의 현재 태스크에 리스케줄 요청 플래그를 설정한다.

 

다음 태스크 픽업

 

다음 그림은 pick_next_task_dl() 함수의 흐름을 보여준다.

 

pick_next_task_dl()

kernel/sched/deadline.c

struct task_struct *pick_next_task_dl(struct rq *rq, struct task_struct *prev)
{
        struct sched_dl_entity *dl_se;
        struct task_struct *p;
        struct dl_rq *dl_rq;

        dl_rq = &rq->dl;

        if (need_pull_dl_task(rq, prev)) {
                pull_dl_task(rq);
                /*
                 * pull_rt_task() can drop (and re-acquire) rq->lock; this
                 * means a stop task can slip in, in which case we need to
                 * re-start task selection.
                 */
                if (rq->stop && task_on_rq_queued(rq->stop))
                        return RETRY_TASK;
        }

        /*
         * When prev is DL, we may throttle it in put_prev_task().
         * So, we update time before we check for dl_nr_running.
         */
        if (prev->sched_class == &dl_sched_class)
                update_curr_dl(rq);

        if (unlikely(!dl_rq->dl_nr_running))
                return NULL;

        put_prev_task(rq, prev);

        dl_se = pick_next_dl_entity(rq, dl_rq);
        BUG_ON(!dl_se);

        p = dl_task_of(dl_se);
        p->se.exec_start = rq_clock_task(rq);

        /* Running task will never be pushed. */
       dequeue_pushable_dl_task(rq, p);

        if (hrtick_enabled(rq))
                start_hrtick_dl(rq, p);

        set_post_schedule(rq);

        return p;
}

다음 실행해야할 dl 태스크를 알아온다.

  • 코드 라인 9~18에서 prev 태스크가 dl 태스크인 경우 요청한 런큐의 모든 오버로드된 cpu들에서 대기중인 dl 태스크들 중 가장 급한 태스크를 알아온다. 만일 런큐의 stop 스케줄러에 태스크가 있는 경우 RETRY_TASK(-1)을 반환한다.
  • 코드 라인 24~25에서 prev 태스크가 dl 스케줄러인 경우 DL 스케줄러에서 로드 및 런타임을 갱신한다.
  • 코드 라인 27~28에서 dl 런큐에서 동작하는 태스크가 없는 경우 null을 반환한다.
  • 코드 라인 30에서 prev 태스크를 다 사용했으므로 다시 prev 태스크의 해당 스케줄러의 관련 함수를 호출한다.
    • prev 태스크가 dl 태스크인 경우 put_prev_task_dl() 함수를 호출하는데 이 때 pushable_dl_tasks_root RB 트리에 엔큐한다.
  • 코드 라인 32에서 요청한  dl 런큐에서 가장 deadline이 빠른 dl 엔티티를 반환한다.
  • 코드 라인 35~36에서 dl 엔티티에 연결된 태스크를 p에 대입하고 시작 실행 시각을 현재 시각으로 대입한다.
  • 코드 라인 39에서 현재 태스크를 곧바로 실행할 예정이므로 pushable_dl_tasks_root RB 트리에서 디큐한다.
  • 코드 라인 41~42에서 hrtick이 활성화된 경우 태스크에 대한 hrtick을 동작시킨다.
  • 코드 라인 44에서 런큐의 post_schedule에 pushable_dl_tasks_root RB 트리에 태스크가 있는지 여부를 기록한다.

 

pick_next_dl_entity()

kernel/sched/deadline.c

static struct sched_dl_entity *pick_next_dl_entity(struct rq *rq,
                                                   struct dl_rq *dl_rq)
{
        struct rb_node *left = dl_rq->rb_leftmost;

        if (!left)
                return NULL;

        return rb_entry(left, struct sched_dl_entity, rb_node);
}

요청한  dl 런큐에서 가장 deadline이 빠른 dl 엔티티를 반환한다. 없으면 null을 반환한다.

 

DL 스케줄러 ops

kernel/sched/deadline.c

const struct sched_class dl_sched_class = {
        .next                   = &rt_sched_class,
        .enqueue_task           = enqueue_task_dl,
        .dequeue_task           = dequeue_task_dl,
        .yield_task             = yield_task_dl,

        .check_preempt_curr     = check_preempt_curr_dl,

        .pick_next_task         = pick_next_task_dl,
        .put_prev_task          = put_prev_task_dl,

#ifdef CONFIG_SMP
        .select_task_rq         = select_task_rq_dl,
        .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

        .set_curr_task          = set_curr_task_dl,
        .task_tick              = task_tick_dl,
        .task_fork              = task_fork_dl,
        .task_dead              = task_dead_dl,

        .prio_changed           = prio_changed_dl,
        .switched_from          = switched_from_dl,
        .switched_to            = switched_to_dl,

        .update_curr            = update_curr_dl,
};

 

 

구조체

sched_dl_entity 구조체

include/linux/sched.h

struct sched_dl_entity {
        struct rb_node  rb_node;

        /*
         * Original scheduling parameters. Copied here from sched_attr
         * during sched_setattr(), they will remain the same until
         * the next sched_setattr().
         */
        u64 dl_runtime;         /* maximum runtime for each instance    */
        u64 dl_deadline;        /* relative deadline of each instance   */
        u64 dl_period;          /* separation of two instances (period) */
        u64 dl_bw;              /* dl_runtime / dl_deadline             */

        /*
         * Actual scheduling parameters. Initialized with the values above,
         * they are continously updated during task execution. Note that
         * the remaining runtime could be < 0 in case we are in overrun.
         */
        s64 runtime;            /* remaining runtime for this instance  */
        u64 deadline;           /* absolute deadline for this instance  */
        unsigned int flags;     /* specifying the scheduler behaviour   */

        /*
         * Some bool flags:
         *
         * @dl_throttled tells if we exhausted the runtime. If so, the
         * task has to wait for a replenishment to be performed at the
         * next firing of dl_timer.
         *
         * @dl_new tells if a new instance arrived. If so we must
         * start executing it with full runtime and reset its absolute
         * deadline;
         *
         * @dl_boosted tells if we are boosted due to DI. If so we are
         * outside bandwidth enforcement mechanism (but only until we
         * exit the critical section);
         *
         * @dl_yielded tells if task gave up the cpu before consuming
         * all its available runtime during the last job.
         */
        int dl_throttled, dl_new, dl_boosted, dl_yielded;

        /*
         * Bandwidth enforcement timer. Each -deadline task has its
         * own bandwidth to be enforced, thus we need one timer per task.
         */
        struct hrtimer dl_timer;
};
  • rb_node
    • dl 런큐의 RB 트리에 엔큐될때 사용하는 노드
  • dl_runtime
    • 할당된 런타임
  • dl_deadline
    • 할당된 deadline 기간
  • dl_period
    • 할당된 dl 태스크의 기간
  • dl_bw
    • dl_runtime / dl_deadline
  • runtime
    • 런타임 잔량
    • 실행된 시간 만큼 점점 줄어들고 0 이하일 때 런타임이 다 소비된 상태이다.
  • deadline
    • 스케줄된 deadline (절대 시각)
  • flags
    • 플래그들
  • dl_throttled
    • 스로틀된 경우 true(1)
  • dl_new
    • 새로 등록된 인스턴스
  • dl_boosted
    • DI를 회피하기 위해 critical 섹션을 벗어나기 전까지 bandwidth 범위를 초과할 수 있도록 부스트한다.
  • dl_timer
    • dl 태스크마다 사용하는 bandwidth 타이머

 

dl_rq 구조체

kernel/sched/sched.h

/* Deadline class' related fields in a runqueue */
struct dl_rq {
        /* runqueue is an rbtree, ordered by deadline */
        struct rb_root rb_root;
        struct rb_node *rb_leftmost;

        unsigned long dl_nr_running;

#ifdef CONFIG_SMP
        /*
         * Deadline values of the currently executing and the
         * earliest ready task on this rq. Caching these facilitates
         * the decision wether or not a ready but not running task
         * should migrate somewhere else.
         */
        struct {
                u64 curr;
                u64 next;
        } earliest_dl;

        unsigned long dl_nr_migratory;
        int overloaded;

        /*
         * Tasks on this rq that can be pushed away. They are kept in
         * an rb-tree, ordered by tasks' deadlines, with caching
         * of the leftmost (earliest deadline) element.
         */
        struct rb_root pushable_dl_tasks_root;
        struct rb_node *pushable_dl_tasks_leftmost;
#else
        struct dl_bw dl_bw;
#endif
};
  • rb_root
    • DL 런큐의 RB 트리로 dl 엔티티가 엔큐되어 등록된다.
  • *rb_leftmost
    • RB 트리에 있는 dl 엔티티중 deadline이 가장 빠른 dl 엔티티를 가리킨다.
    • dl 런큐에서 가장 먼저 스케줄될 dl 엔티티
  • dl_nr_running
    • dl 런큐이하 child 그룹 모두를 합친 dl 태스크의 수
  • earliest_dl.curr
    • dl 런큐에서 현재 동작 중인 deadline 값
  • earliest_dl.next
    • dl 런큐에서 대기중인 가장 첫 dl 엔티티의 deadline 값
  • dl_nr_migratory
    • dl 런큐에서 migration이 가능한 상태의 태스크 수
  • overloaded
    • dl 런큐가 오버로드되었는지 여부
  • pushable_dl_tasks_root
    • pushable 태스크들이 큐잉되는 RB 트리 루트
  • *pushable_dl_tasks_leftmost
    • pushable 태스크들이 큐잉되는 RB 트리 루트에서 가장 빠른 dl 태스크
  • dl_bw
    • UP 시스템에서만 사용하며 dl 태스크들이 최대 동작될 수 있는 비율이 정수형으로 등록된다.

 

dl_bandwidth 구조체

kernel/sched/sched.h

/*
 * To keep the bandwidth of -deadline tasks and groups under control
 * we need some place where:
 *  - store the maximum -deadline bandwidth of the system (the group);
 *  - cache the fraction of that bandwidth that is currently allocated.
 *
 * This is all done in the data structure below. It is similar to the
 * one used for RT-throttling (rt_bandwidth), with the main difference
 * that, since here we are only interested in admission control, we
 * do not decrease any runtime while the group "executes", neither we
 * need a timer to replenish it.
 *
 * With respect to SMP, the bandwidth is given on a per-CPU basis,
 * meaning that:
 *  - dl_bw (< 100%) is the bandwidth of the system (group) on each CPU;
 *  - dl_total_bw array contains, in the i-eth element, the currently
 *    allocated bandwidth on the i-eth CPU.
 * Moreover, groups consume bandwidth on each CPU, while tasks only
 * consume bandwidth on the CPU they're running on.
 * Finally, dl_total_bw_cpu is used to cache the index of dl_total_bw
 * that will be shown the next time the proc or cgroup controls will
 * be red. It on its turn can be changed by writing on its own
 * control.
 */
struct dl_bandwidth {
        raw_spinlock_t dl_runtime_lock;
        u64 dl_runtime;
        u64 dl_period;
};
  • rt_runtime
    • dl bandwidth의 런타임 (ns)
  • dl_period
    • dl bandwidth의 period (ns)

 

dl_bw 구조체
struct dl_bw {
        raw_spinlock_t lock;
        u64 bw, total_bw;
};
  • bw
    • deadline 스케줄러를 위해 사용하는 bandwidth 비율을 정수로 표현한 수
      • SMP 시스템에서는 디폴트로 100%에 해당하는 정수 1M(1,048,576)가 설정된다.
      • cpu가 1개 밖에 없는 UP 시스템에서는 디폴트로 95%에 해당하는 정수 996,147이 설정된다.
        • 996,147 / 1M(1,048,576) = 95%
  • total_bw

 

cpudl 구조체

kernel/sched/cpudeadline.h

struct cpudl {
        raw_spinlock_t lock;
        int size;
        cpumask_var_t free_cpus;
        struct cpudl_item *elements;
};
  • size
    • deadline이 설정된 cpu의 수 (초기 값은 0)
  • free_cpus
    • deadline이 설정되지 않은 cpu의 비트마스크
  • *elements
    • cpudl 엘레멘트들

 

cpudl_item 구조체

kernel/sched/cpudeadline.h

struct cpudl_item {
        u64 dl;
        int cpu;
        int idx;
};
  • dl
    • 현재 cpu에서 가장 빠른 deadline
  • cpu
    • cpu 번호
  • idx
    • 엘레멘트 어레이 중 현재 배열 인덱스 번호를 cpu 번호라고 가정하고 이에 해당하는 cpu가 위치한 엘레멘트의 인덱스 번호를 가리킨다.
    • 예) elements[3].idx = 2 인 경우 3번 cpu는 elements[2] 위치에 존재한다.

 

참고

 

답글 남기기

이메일은 공개되지 않습니다. 필수 입력창은 * 로 표시되어 있습니다.