Linux Task Scheduling

Transcription

1 Linux Task Scheduling Hyunmin Yoon

2 2 This document is based-on linux version (released at ) 2

3 3 Task Scheduling COMPLETELY FAIR SCHEDULING 3

4 4 Completely Fair Scheduler (CFS) CFS is based on a simple concept The goal is to achieve an ideal multitasking system Provide each task CPU time proportional to its weight CPU time Weight of task Total weight Total CPU time Preemption point Task #1 Task #2 Total CPU time Time Weight of task #1 = 3 Weight of task #2 = 2 4

5 5 Virtual Runtime Virtual Runtime (vruntime) Approximate the "ideal multitasking" that CFS is modeling To account for how long a process has run how much longer it ought to run VVVV ττ, tt = WW 00 WW ττ PPPP tt WW 00 : the weight of nice value 0 WW(tt): the weight of the task PPPP(tt): actual runtime of the task in time interval [0, t] Scheduler chooses a task with the smallest virtual runtime 5

6 6 Example VVVV ττ, tt = WW 00 WW ττ PPPP tt PPPP tt = 55 WW ττ 11, tt = 33, WW ττ 22, tt = 22 WW 00 = CC Task #1 Task #2 5 seconds Time VVVV ττ 11, tt VVVV ττ 22, tt VVVV ττ 11, tt VVVV ττ 22, tt (1) 1 3 CC 0 (4) 2 CC CC 3 (2) 1 Time (5) 4 Time (3) 2 Time 1 3 CC 1 2 CC 5 Time CC CC 3 Time 2 3 CC 1 2 CC 6

7 7 Task Weight include/linux/sched.c struct load_weight unsigned long weight, inv_weight; ; kernel/sched.c static const int prio_to_weight[40] = /* -20 */ 88761, 71755, 56483, 46273, 36291, /* -15 */ 29154, 23254, 18705, 14949, 11916, /* -10 */ 9548, 7620, 6100, 4904, 3906, /* -5 */ 3121, 2501, 1991, 1586, 1277, /* 0 */ 1024, 820, 655, 526, 423, /* 5 */ 335, 272, 215, 172, 137, /* 10 */ 110, 87, 70, 56, 45, /* 15 */ 36, 29, 23, 18, 15, ; /* Inverse (2^32/x) values of the prio_to_weight[] array, precalculated. */ static const u32 prio_to_wmult[40] = /* -20 */ 48388, 59856, 76040, 92818, , /* -15 */ , , , , , /* -10 */ , , , , , /* -5 */ , , , , , /* 0 */ , , , , , /* 5 */ , , , , , /* 10 */ , , , , , /* 15 */ , , , , , ; 7

8 8 Update Virtual Runtime <kernel/sched/fair.c> /* * Update the current task's runtime statistics. */ static void update_curr(struct cfs_rq *cfs_rq) struct sched_entity *curr = cfs_rq->curr; u64 now = rq_clock_task(rq_of(cfs_rq)); u64 delta_exec; delta_exec = now - curr->exec_start; curr->sum_exec_runtime += delta_exec; curr->vruntime += calc_delta_fair(delta_exec, curr); update_min_vruntime(cfs_rq); /* * delta /= w */ static inline u64 calc_delta_fair(u64 delta, struct sched_entity *se) if (unlikely(se->load.weight!= NICE_0_LOAD)) delta = calc_delta(delta, NICE_0_LOAD, &se->load); Calculate the execution time of the current task Update virtual runtime VVVV ττ, tt = WW 00 WW ττ PPPP tt return delta; 8

9 9 Virtual Runtime Calculation <kernel/sched/fair.c> calc_delta(delta, NICE_0_LOAD, &se->load); static u64 calc_delta(u64 delta_exec, unsigned long weight, struct load_weight *lw) u64 fact = scale_load_down(weight); #define WMULT_CONST int shift = WMULT_SHIFT; #define WMULT_SHIFT 32 update_inv_weight(lw); NNNNNNNN_00_LLLLLLLL WWWWWWWWWW_CCCCCCCCCC wwwwwwwwwwww if (unlikely(fact >> 32)) while (fact >> 32) fact >>= 1; shift--; /* hint to use a 32x32->64 mul */ fact = (u64)(u32)fact * lw->inv_weight; while (fact >> 32) fact >>= 1; shift--; (~0U) static void update_inv_weight(struct load_weight *lw) unsigned long w; if (likely(lw->inv_weight)) return; w = scale_load_down(lw->weight); VVVV ττ, tt = WW 00 WW ττ PPPP tt inv_weight = 0 if se is member of a group if (BITS_PER_LONG > 32 && unlikely(w >= WMULT_CONST)) lw->inv_weight = 1; else if (unlikely(!w)) lw->inv_weight = WMULT_CONST; else lw->inv_weight = WMULT_CONST / w; return mul_u64_u32_shr(delta_exec, fact, shift); dddddddddd NNNNNNNN_00_LLLLLLLL wwwwwwwwwwww static inline u64 mul_u64_u32_shr(u64 a, u32 mul, unsigned int shift) return (u64)(((unsigned int128)a * mul) >> shift); 9

10 10 CFS Algorithm: Red Black Tree CFS maintains a time-ordered red black tree where all runnable tasks are sorted by virtual runtime No path in the tree will ever be more than twice as long as any other (self-balancing) Operations on the tree occur in O(log n) time 10

11 11 Overview of Scheduling Flow On each scheduling tick, CFS 1. Updates the virtual runtime of the currently running task 2. Checks between virtual runtime and time slice If vvvvvvvvvvvvvv rrrrrrrrrrrrrr (tttttttt ssssssssss), then TIF_NEED_RESCHED flag is set (thread information flag) 3. Checks TIF_NEED_RESCHED flag If set, schedules the task with the smallest virtual runtime in the run queue Enqueue the currently running task into the RB tree Dequeue the task at the left-most node in the RB tree 11

12 12 Timeslice Timeslice is the time a task runs before it is preempted It gives each runnable task a slice of the CPU s time The length of timeslice of a task is proportional to its weight TTSS ττ = WW ττ WW tt 12

13 13 Time Slice Calculation <kernel/sched/fair.c> /* * We calculate the wall-time slice from the period by taking a part * proportional to the weight. * * s = p*p[w/rw] */ static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se) u64 slice = sched_period(cfs_rq->nr_running +!se->on_rq); for_each_sched_entity(se) struct load_weight *load; struct load_weight lw; return slice; TTSS ττ = WW ττ WW tt cfs_rq = cfs_rq_of(se); load = &cfs_rq->load; if (unlikely(!se->on_rq)) lw = cfs_rq->load; update_load_add(&lw, se->load.weight); load = &lw; slice = calc_delta(slice, se->load.weight, load); ssssssssss wwwwwwwwwwww wwwwwwwwwwww /* * Minimal preemption granularity for CPU-bound tasks: * (default: 0.75 msec * (1 + ilog(ncpus)), units: nanoseconds) */ unsigned int sysctl_sched_min_granularity = ULL; static unsigned int sched_nr_latency = 8; static u64 sched_period(unsigned long nr_running) if (unlikely(nr_running > sched_nr_latency)) return nr_running * sysctl_sched_min_granularity; else return sysctl_sched_latency; /* * Targeted preemption latency for CPU-bound tasks: * (default: 6ms * (1 + ilog(ncpus)), units: nanoseconds) */ unsigned int sysctl_sched_latency = ULL; 13

14 14 Scheduling Process 1. Timer interrupt 2. IRQ handler 2-1. Setting NEED_RESCHED flag 2-2. Raising softirq for load balancing 3. Return from interrupt : 3-1. Scheduling (if the flag is set) 14

15 15 Setting TIF_NEED_RESCHED Flag 15

16 16 Scheduler Tick Handler <kernel/sched/core.c> void scheduler_tick(void) int cpu = smp_processor_id(); struct rq *rq = cpu_rq(cpu); struct task_struct *curr = rq->curr; sched_clock_tick(); raw_spin_lock(&rq->lock); update_rq_clock(rq); curr->sched_class->task_tick(rq, curr, 0); update_cpu_load_active(rq); calc_global_load_tick(rq); raw_spin_unlock(&rq->lock); Setting the flag for scheduling perf_event_task_tick(); #ifdef CONFIG_SMP rq->idle_balance = idle_cpu(cpu); trigger_load_balance(rq); #endif rq_last_tick_reset(rq); Raising softirq for load balancing 16

17 17 Tick Handler of Scheduling Class <kernel/sched/fair.c> /* * scheduler tick hitting a task of our scheduling class: */ static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued) struct cfs_rq *cfs_rq; struct sched_entity *se = &curr->se; for_each_sched_entity(se) cfs_rq = cfs_rq_of(se); entity_tick(cfs_rq, se, queued); if (static_branch_unlikely(&sched_numa_balancing)) task_tick_numa(rq, curr); For group scheduling static void entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr, int queued) /* * Update run-time statistics of the 'current'. */ update_curr(cfs_rq); /* * Ensure that runnable average is periodically updated. */ update_load_avg(cfs_rq, curr, UPDATE_TG); update_cfs_group(curr); For load balancing For group scheduling if (cfs_rq->nr_running > 1) check_preempt_tick(cfs_rq, curr); 17

18 18 Check The Necessity of Preemption <kernel/sched/fair.c> static void check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr) unsigned long ideal_runtime, delta_exec; struct sched_entity *se; s64 delta; TTSS cccccccc = WW cccccccc WW tt ideal_runtime = sched_slice(cfs_rq, curr); delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime; if (delta_exec > ideal_runtime) resched_curr(rq_of(cfs_rq)); clear_buddies(cfs_rq, curr); return; set TIF_NEED_RESCHED flag Get an entity with minimum vruntime from RB tree /* * Ensure that a task that missed wakeup preemption by a * narrow margin doesn't have to wait for a full slice. * This also mitigates buddy induced latencies under load. */ if (delta_exec < sysctl_sched_min_granularity) return; se = pick_first_entity(cfs_rq); delta = curr->vruntime - se->vruntime; if (delta < 0) return; if (delta > ideal_runtime) resched_curr(rq_of(cfs_rq)); /* * Minimal preemption granularity for CPU-bound tasks: * (default: 0.75 msec * (1 + ilog(ncpus)), units: nanoseconds) */ unsigned int sysctl_sched_min_granularity = ULL; Scheduler guarantees that a task should run during minimum time slice Current task has still minimum vruntime in RB tree If vvvvvvvvvvvvvvee cccccccc > vvvvvvvvvvvvvvee llllllllllllllll + TTSS cccccccc then set TIF_NEED_RESCHED flag 18

19 19 Calling Scheduler <arch/arm/kernel/entry-common.s> slow_work_pending: mov mov bl ENTRY(ret_to_user_from_irq) ldr tst bne r0, 'regs' r2, 'syscall' do_work_pending r1, [tsk, #TI_FLAGS] r1, #_TIF_WORK_MASK slow_work_pending <arch/arm/kernel/signal.c> Return to user from interrupt request asmlinkage int do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall) trace_hardirqs_off(); do if (likely(thread_flags & _TIF_NEED_RESCHED)) schedule(); else 19

20 20 CFS put_prev_entity() set_next_entity() 20

21 21 Scheduling Function <kernel/sched/core.c> asmlinkage visible void sched schedule(void) struct task_struct *tsk = current; sched_submit_work(tsk); do preempt_disable(); schedule(false); sched_preempt_enable_no_resched(); while (need_resched()); EXPORT_SYMBOL(schedule); Scheduling <include/linux/sched.h> static always_inline bool need_resched(void) return unlikely(tif_need_resched()); <include/linux/thread_info.h> #define tif_need_resched() test_thread_flag(tif_need_resched) 21

22 22 schedule() <kernel/sched/core.c> static void sched notrace schedule(bool preempt) struct task_struct *prev, *next; unsigned long *switch_count; struct rq *rq; int cpu; cpu = smp_processor_id(); rq = cpu_rq(cpu); prev = rq->curr; next = pick_next_task(rq, prev); clear_tsk_need_resched(prev); clear_preempt_need_resched(); Current task is set as previous task Dequeue next task & enqueue previous task if (likely(prev!= next)) rq->nr_switches++; rq->curr = next; ++*switch_count; trace_sched_switch(preempt, prev, next); else /* Also unlocks the rq: */ rq = context_switch(rq, prev, next, &rf); rq->clock_update_flags &= ~(RQCF_ACT_SKIP RQCF_REQ_SKIP); rq_unlock_irq(rq, &rf); balance_callback(rq); 22

23 23 Picking Next Task <sched/kernel/core.c> static inline struct task_struct *pick_next_task(struct rq *rq, struct task_struct *prev, struct rq_flags *rf) const struct sched_class *class = &fair_sched_class; struct task_struct *p; if (likely(prev->sched_class == class && rq->nr_running == rq->cfs.h_nr_running)) p = fair_sched_class.pick_next_task(rq, prev, rf); if (unlikely(p == RETRY_TASK)) goto again; Count all task entities (they are not group entities) Count all entities of CFS runqueue (It includes group entities) Pick up next task for scheduling If CPU has only CFS tasks and it doesn t have any group /* assumes fair_sched_class->next == idle_sched_class */ if (unlikely(!p)) p = idle_sched_class.pick_next_task(rq, prev, rf); return p; again: From all of classes for_each_class(class) p = class->pick_next_task(rq, prev, rf); if (p) if (unlikely(p == RETRY_TASK)) goto again; return p; BUG(); /* the idle class will always have a runnable task */ 23

24 24 Picking Next Task (CFS) <kernel/sched/fair.c> static struct task_struct *pick_next_task_fair(struct rq *rq, struct task_struct *prev, struct rq_flags *rf) struct cfs_rq *cfs_rq = &rq->cfs; struct sched_entity *se; struct task_struct *p; int new_tasks; again: #ifdef CONFIG_FAIR_GROUP_SCHED if (!cfs_rq->nr_running) goto idle; if (prev->sched_class!= &fair_sched_class) goto simple; Skip codes for CFS group scheduling simple: cfs_rq = &rq->cfs; #endif if (!cfs_rq->nr_running) goto idle; put_prev_task(rq, prev); Put previous task to its class (some class enqueues the task) do while (cfs_rq); se = pick_next_entity(cfs_rq, NULL); set_next_entity(cfs_rq, se); cfs_rq = group_cfs_rq(se); Find next entity for scheduling For group scheduling p = task_of(se); if (hrtick_enabled(rq)) hrtick_start_fair(rq, p); return p; Set high-resolution timer for setting time slice (It allows for the task to check preemption point before 1/HZ seconds) Skip codes for idle 24

25 25 put_prev_entity <kernel/sched/fair.c> static void put_prev_entity(struct cfs_rq *cfs_rq, struct sched_entity *prev) /* * If still on the runqueue then deactivate_task() * was not called and update_curr() has to be done: */ if (prev->on_rq) update_curr(cfs_rq); if (prev->on_rq) update_stats_wait_start(cfs_rq, prev); /* Put 'current' back into the tree. */ enqueue_entity(cfs_rq, prev); cfs_rq->curr = NULL; /* in!on_rq case, update occurred at dequeue */ update_load_avg(prev, 0); Find the right place to be located static void enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se) struct rb_node **link = &cfs_rq->tasks_timeline.rb_node; struct rb_node *parent = NULL; struct sched_entity *entry; int leftmost = 1; while (*link) parent = *link; entry = rb_entry(parent, struct sched_entity, run_node); if (entity_before(se, entry)) link = &parent->rb_left; else link = &parent->rb_right; leftmost = 0; Insert the task rb_link_node(&se->run_node, parent, link); rb_insert_color_cached(&se->run_node, &cfs_rq->tasks_timeline, leftmost); Update rb_leftmost if the inserted task is located on the leftmost node if (newleft) *leftmost = node; 25

26 26 pick_next_entity <kernel/sched/fair.c> /* * Pick the next process, keeping these things in mind, in this order: * 1) keep things fair between processes/task groups * 2) pick the "next" process, since someone really wants that to run * 3) pick the "last" process, for cache locality * 4) do not run the "skip" process, if something else is available */ static struct sched_entity *pick_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *curr) struct sched_entity *left = pick_first_entity(cfs_rq); struct sched_entity *se; /* * If curr is set we have to see if its left of the leftmost entity * still in the tree, provided there was anything in the tree at all. */ if (!left (curr && entity_before(curr, left))) left = curr; se = left; /* ideally we run the leftmost entity */ Skip codes for (2)~(4) struct sched_entity * pick_first_entity(struct cfs_rq *cfs_rq) struct rb_node *left = cfs_rq->rb_leftmost; return se; if (!left) return NULL; return rb_entry(left, struct sched_entity, run_node); Pick an leftmost entity on the CFS RB tree 26

27 27 set_next_entity <kernel/sched/fair.c> static void set_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *se) /* 'current' is not kept within the tree. */ if (se->on_rq) update_stats_wait_end(cfs_rq, se); dequeue_entity(cfs_rq, se); update_load_avg(se, 1); update_stats_curr_start(cfs_rq, se); cfs_rq->curr = se; se->prev_sum_exec_runtime = se->sum_exec_runtime; Update the rb_leftmost if the task is the leftmost node static void dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se) if (cfs_rq->rb_leftmost == &se->run_node) struct rb_node *next_node; next_node = rb_next(&se->run_node); cfs_rq->rb_leftmost = next_node; Remove the task from the RB tree rb_erase(&se->run_node, &cfs_rq->tasks_timeline); 4.6 codes for easy to understand 27

28 28 Task Attachment Functions enqueue_entity enqueue_entity enqueue_task (call an enqueue function of corresponding class ) Unthrottle activate_task attach_task Load balancing Swap (cross migration between CPUs) Wake up Fork Move between groups Move between classes Move between CPUs Change NICE Change CPU list that task allows to run Put current task back into the tree 28

29 29 Quiz In the following situations, analyze how CFS schedules tasks virtual runtime = 100 running state State of a task virtual runtime =? running state time 10 minutes fork sleep wake up time Running time of tasks 29

30 30 Stride Scheduler HOMEWORK 30

31 31 Complete Stride Scheduler Complete the following functions 1. enqueue_task_stride() 2. dequeue_task_stride() 3. set_curr_task_stride() 4. pick_next_task_stride() 1. put_prev_task_stride() 31

32 32 Restrictions Scheduler has 1,000 tickets <my_stride> = 1,000 <my_tickets> (tickets) < 1,000 Initial pass <initial_pass> = <my_stride> Competition handling If current process has lowest pass, then it is executed continuously ex) If current = P1, P1.pass = 100, P2.pass = 100, then P1 is executed continuously 32

33 33 Result stride_app$./stride_app Child's PID = 1974 ***[OS18] select Stride scheduling class Child's PID = 1975 ***[OS18] select Stride scheduling class Child's PID = 1976 ***[OS18] select Stride scheduling class 3 tasks are created *** DONE *** stride_app$ dmesg grep OS18... [ ] ***[OS18] task is created: pass = 25, stride = 25, tickets = 40 [ ] ***[OS18] Enqueue:::P[1974], nr_running = 1 [ ] ***[OS18] task is created: pass = 50, stride = 50, tickets = 20 [ ] ***[OS18] Enqueue:::P[1975], nr_running = 2 [ ] ***[OS18] task is created: pass = 100, stride = 100, tickets = 10 [ ] ***[OS18] Enqueue:::P[1976], nr_running = 3 [ ] ***[OS18] Pick:::P[1974](stride = 25): pass = 50 [ ] ***[OS18] Tick:::P[1974](stride = 25): pass = 75 [ ] ***[OS18] Pick:::P[1975](stride = 50): pass = 100 [ ] ***[OS18] Pick:::P[1974](stride = 25): pass = 100 [ ] ***[OS18] Tick:::P[1974](stride = 25): pass = 125 [ ] ***[OS18] Pick:::P[1976](stride = 100): pass = 200 [ ] ***[OS18] Pick:::P[1975](stride = 50): pass = 150 [ ] ***[OS18] Pick:::P[1974](stride = 25): pass = 150 [ ] ***[OS18] Tick:::P[1974](stride = 25): pass = 175 [ ] ***[OS18] Pick:::P[1975](stride = 50): pass = 200 [ ] ***[OS18] Pick:::P[1974](stride = 25): pass = 200 [ ] ***[OS18] Tick:::P[1974](stride = 25): pass = 225 [ ] ***[OS18] Pick:::P[1976](stride = 100): pass = 300 [ ] ***[OS18] Pick:::P[1975](stride = 50): pass =

34 34 Remind Scheduler has 1,000 tickets Process #1 (P1): tickets = 40, stride = 25 Process #2 (P2): tickets = 20, stride = 50 Process #3 (P3): tickets = 10, stride = 100 time pass P1.pass P2.pass P3.pass The amount of allocated CPU resources P1 > P2 > P3 The more tickets, the more resources Proportional share scheduling At point Q, P1 get twice than P2, and P2 get twice than P3 Q 34

35 35 35