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 SCHEDULING CLASS 3

4 4 Scheduling Class Since kernel, the Linux scheduler has been made modular The modularity is called scheduler classes Scheduler classes enable different, pluggable algorithms to coexist, scheduling their own types of processes Each scheduler class has a priority The base scheduler code iterates over each scheduler class in order of priority Base Scheduler kernel/sched.c RT scheduler Deadline scheduler CFS scheduler Idle-task scheduler Custom scheduler 4

5 5 Scheduling Class Each task belongs to one specific scheduling class Class Description Policy dl_sched_class for real-time task with deadline SCHED_DEADLINE rt_sched_class fair_sched_class for real-time task for time-sharing task SCHED_FIFO SCHED_RR SCHED_NORMAL SCHED_BATCH idle_sched_class for tasks that avoid to disturb other tasks SCHED_IDLE Each scheduling class is linked with one another in a singly linked list, allowing the classes to be iterated sched_class_highest stop_sched_class.next dl_sched_class.next rt_sched_class.next fair_sched_class.next idle_sched_class.next = NULL 5

6 6 Functions in Scheduling Class Function Operations enqueue_task Put the task into the runqueue dequeue_task Remove the task from the runqueue pick_next_task Choose the most appropriated task eligible to run next put_prev_task Return previous (current) task on the runqueue set_curr_task Set the current task for a given CPU task_tick Do periodic work for scheduling (it is invoked by timer) 6

7 7 Time Sharing Scheduling Class <kernel/sched/fair.c> const struct sched_class fair_sched_class =.next.enqueue_task.dequeue_task.yield_task.yield_to_task.check_preempt_curr.pick_next_task.put_prev_task #ifdef CONFIG_SMP.select_task_rq.migrate_task_rq.rq_online.rq_offline = &idle_sched_class, = enqueue_task_fair, = dequeue_task_fair, = yield_task_fair, = yield_to_task_fair, = check_preempt_wakeup, = pick_next_task_fair, = put_prev_task_fair, = select_task_rq_fair, = migrate_task_rq_fair, = rq_online_fair, = rq_offline_fair, The next class is Idle scheduling class <include/linux/sched.h> struct task_struct const struct sched_class *sched_class; struct sched_entity se; struct sched_rt_entity rt; #endif.task_waking.task_dead.set_cpus_allowed = task_waking_fair, = task_dead_fair, = set_cpus_allowed_common, Scheduling class for this task.set_curr_task.task_tick.task_fork = set_curr_task_fair, = task_tick_fair, = task_fork_fair,.prio_changed.switched_from.switched_to = prio_changed_fair, = switched_from_fair, = switched_to_fair,.get_rr_interval = get_rr_interval_fair,.update_curr = update_curr_fair, #ifdef CONFIG_FAIR_GROUP_SCHED.task_move_group #endif ; = task_move_group_fair, 7

8 8 How to Change Scheduling Class (1) <include/uapi/linux/sched/types.h> struct sched_attr u32 size; <example codes> #define NR_sched_setattr 314 #define SCHED_DEADLINE 6 ; u32 sched_policy; u64 sched_flags; /* SCHED_NORMAL, SCHED_BATCH */ s32 sched_nice; /* SCHED_FIFO, SCHED_RR */ u32 sched_priority; /* SCHED_DEADLINE */ u64 sched_runtime; u64 sched_deadline; u64 sched_period; int sched_setattr(pid_t pid, const struct sched_attr *attr, unsigned int flags) return syscall( NR_sched_setattr, pid, attr, flags); int main(int argc, char** argv)... memset(&attr, 0, sizeof(struct sched_attr)); attr.size = sizeof(attr); attr.sched_policy = SCHED_DEADLINE; attr.sched_runtime = 1000; attr.sched_deadline = 10000; attr.sched_period = 10000; <include/uapi/linux/sched.h> /* * Scheduling policies */ #define SCHED_NORMAL 0 #define SCHED_FIFO 1 #define SCHED_RR 2 #define SCHED_BATCH 3 /* SCHED_ISO: reserved but not implemented yet */ #define SCHED_IDLE 5 #define SCHED_DEADLINE 6 ret = sched_setattr(getpid(), &attr, flags); if (ret!= 0) perror("sched_setattr"); exit(1);... return 0; 8

9 9 How to Change Scheduling Class (2) sys_sched_setattr Kernel level sched_setattr() sched_setscheduler() * setscheduler() * <kernel/sched/core.c: sched_setscheduler()> if (queued) dequeue_task(rq, p, queue_flags); if (running) put_prev_task(rq, p); prev_class = p->sched_class; setscheduler(rq, p, attr, pi); if (queued) if (running) /* * We enqueue to tail when the priority of a task is * increased (user space view). */ if (oldprio < p->prio) queue_flags = ENQUEUE_HEAD; enqueue_task(rq, p, queue_flags); set_curr_task(rq, p); check_class_changed(rq, p, prev_class, oldprio); <kernel/sched/core.c> static void setscheduler(struct rq *rq, struct task_struct *p, const struct sched_attr *attr, bool keep_boost) setscheduler_params(p, attr); <kernel/sched/core.c> /* * Keep a potential priority boosting if called from * sched_setscheduler(). */ p->prio = normal_prio(p); if (keep_boost) p->prio = rt_effective_prio(p, p->prio); if (dl_prio(p->prio)) p->sched_class = &dl_sched_class; else if (rt_prio(p->prio)) p->sched_class = &rt_sched_class; else p->sched_class = &fair_sched_class; static inline void check_class_changed(struct rq *rq, struct task_struct *p, const struct sched_class *prev_class, int oldprio) if (prev_class!= p->sched_class) if (prev_class->switched_from) prev_class->switched_from(rq, p); p->sched_class->switched_to(rq, p); else if (oldprio!= p->prio dl_task(p)) p->sched_class->prio_changed(rq, p, oldprio); 9

10 10 Task Scheduling TASK 10

11 11 Linux Process Descriptor (Robert Love, Linux Kernel Development 3 rd Edition) It is an element of the task list It has type struct task_struct struct task_struct is defined in <linux/shched.h> It contains all the information that the kernel has and needs about a process 11

12 12 Linux Process States (Robert Love, Linux Kernel Development 3 rd Edition) 12

13 13 Linux Process State Flags Flags Description TASK_RUNNING The process is runnable; it is either currently running or on a runqueue waiting to run. TASK_INTERRUPTIBLE The process is sleeping, waiting for some condition to exist. When this condition exists, the kernel sets the process s state to TASK_RUNNING. The process also awakes prematurely and becomes runnable if it receives a signal. TASK_UNINTERRUPTIBLE This state is identical to TASK_INTERRUPTIBLE except that it does not wake up and become runnable if it receives a signal. <include/linux/sched.h> <include/linux/sched.h> /* Used in tsk->state: */ #define TASK_RUNNING #define TASK_INTERRUPTIBLE #define TASK_UNINTERRUPTIBLE #define set_task_state(tsk, state_value) #define set_task_state(tsk, state_value) #define set_current_state(state_value) #define set_current_state(state_value) 0x0000 0x0001 0x0002 struct task_struct volatile long state; 13

14 14 Task and Schedulable Entity <include/linux/sched.h> struct task_struct volatile long state; void *stack; atomic_t usage; unsigned int flags; unsigned int ptrace; #ifdef CONFIG_SMP struct llist_node wake_entry; int on_cpu; unsigned int wakee_flips; unsigned long wakee_flip_decay_ts; struct task_struct *last_wakee; #endif int wake_cpu; int on_rq; int prio, static_prio, normal_prio; unsigned int rt_priority; const struct sched_class *sched_class; struct sched_entity se; struct sched_rt_entity rt; #ifdef CONFIG_CGROUP_SCHED struct task_group *sched_task_group; #endif struct sched_dl_entity dl; <include/linux/sched.h> struct sched_entity struct load_weight /* for load-balancing */ struct rb_node struct list_head unsigned int u64 u64 u64 u64 u64 #ifdef CONFIG_SCHEDSTATS struct sched_statistics statistics; #endif load; run_node; group_node; on_rq; exec_start; sum_exec_runtime; vruntime; prev_sum_exec_runtime; nr_migrations; #ifdef CONFIG_FAIR_GROUP_SCHED int depth; struct sched_entity *parent; /* rq on which this entity is (to be) queued: */ struct cfs_rq *cfs_rq; /* rq "owned" by this entity/group: */ struct cfs_rq *my_q; #endif #ifdef CONFIG_SMP /* Per entity load average tracking */ struct sched_avg avg; #endif ; Schedulable entity, it includes all the information to schedule this task 14

15 15 Task Scheduling RUNQUEUE 15

16 16 Global vs. Partitioned Scheduling Global Scheduling Partitioned Scheduling 16

17 17 CPU Runqueue < kernel/sched/sched.h > <kernel/sched/sched.h> /* * This is the main, per-cpu runqueue data structure. * * Locking rule: those places that want to lock multiple runqueues * (such as the load balancing or the thread migration code), lock * acquire operations must be ordered by ascending &runqueue. */ struct rq /* runqueue lock: */ raw_spinlock_t lock; /* CFS-related fields in a runqueue */ struct cfs_rq struct rb_root tasks_timeline; struct sched_entity *curr, *next, *last, *skip; struct rq *rq; ; unsigned int nr_running; /* capture load from *all* tasks on this cpu: */ struct load_weight load; unsigned long nr_load_updates; u64 nr_switches; ; struct cfs_rq cfs; struct rt_rq rt; struct dl_rq dl; struct task_struct *curr, *idle, *stop; CFS runqueue info. Real-time scheduling class (FIFO and RR) runqueue info. Deadline scheduling class runqueue info. A task for Idle scheduling class A task that is running and is currently allocated CPU 17

18 18 Runqueue for Real-time Scheduling Class <kernel/sched/sched.h> /* Real-Time classes' related field in a runqueue: */ struct rt_rq struct rt_prio_array active; unsigned int rt_nr_running; ; Runqueue for Real-time scheduling class /* * This is the priority-queue data structure of the RT scheduling class: */ struct rt_prio_array DECLARE_BITMAP(bitmap, MAX_RT_PRIO+1); struct list_head queue[max_rt_prio]; ; <include/linux/sched.h> struct sched_rt_entity struct list_head run_list; unsigned long timeout; unsigned long watchdog_stamp; unsigned int time_slice; struct sched_rt_entity *back; #ifdef CONFIG_RT_GROUP_SCHED struct sched_rt_entity *parent; /* rq on which this entity is (to be) queued: */ #endif ; struct rt_rq *rt_rq; /* rq "owned" by this entity/group: */ struct rt_rq *my_q; Run queue Priority 0 1 RT task1 RT task2 2 RT task3 18

19 19 Runqueue for Time-sharing Scheduling Class <kernel/sched/sched.h> /* CFS-related fields in a runqueue */ struct cfs_rq struct load_weight load; unsigned int nr_running, h_nr_running; u64 exec_clock; u64 min_vruntime; struct rb_root tasks_timeline; struct rb_node *rb_leftmost; <include/linux/rbtree.h> struct rb_node unsigned long rb_parent_color; struct rb_node *rb_right; struct rb_node *rb_left; attribute ((aligned(sizeof(long)))); struct rb_root ; struct rb_node *rb_node; struct sched_entity *curr, *next, *last, *skip; #ifdef CONFIG_SMP /* * CFS load tracking */ struct sched_avg avg; u64 runnable_load_sum; unsigned long runnable_load_avg; #ifdef CONFIG_FAIR_GROUP_SCHED unsigned long tg_load_avg_contrib; #endif atomic_long_t removed_load_avg, removed_util_avg; #ifdef CONFIG_FAIR_GROUP_SCHED unsigned long h_load; u64 last_h_load_update; struct sched_entity *h_load_next; #endif /* CONFIG_FAIR_GROUP_SCHED */ #endif /* CONFIG_SMP */ ; Task4 Task2 Task5 Task1 Task3 Task6 Task7 struct sched_entity struct load_weight struct rb_node load; run_node; 19

20 20 Stride Scheduling Class Stride Scheduling Task PRACTICE 20

21 21 Stride Scheduling Class Skeleton Download source file TBD Move $ tar -xvf stride.tar $ cd stride stride $ mv kernel/sched/stride.c linux /kernel/sched/ 21

22 22 Compile Stride Scheduler < kernel/sched/makefile> # SPDX-License-Identifier: GPL-2.0 ifdef CONFIG_FUNCTION_TRACER CFLAGS_REMOVE_clock.o = $(CC_FLAGS_FTRACE) endif # These files are disabled because they produce non-interesting flaky coverage # that is not a function of syscall inputs. E.g. involuntary context switches. KCOV_INSTRUMENT := n ifneq ($(CONFIG_SCHED_OMIT_FRAME_POINTER),y) # According to Alan Modra <alan@linuxcare.com.au>, the -fno-omit-frame-pointer is # needed for x86 only. Why this used to be enabled for all architectures is beyond # me. I suspect most platforms don't need this, but until we know that for sure # I turn this off for IA-64 only. Andreas Schwab says it's also needed on m68k # to get a correct value for the wait-channel (WCHAN in ps). --davidm CFLAGS_core.o := $(PROFILING) -fno-omit-frame-pointer endif obj-y += core.o loadavg.o clock.o cputime.o obj-y += idle_task.o fair.o rt.o deadline.o stride.o obj-y += wait.o wait_bit.o swait.o completion.o idle.o obj-$(config_smp) += cpupri.o cpudeadline.o topology.o stop_task.o obj-$(config_sched_autogroup) += autogroup.o obj-$(config_schedstats) += stats.o obj-$(config_sched_debug) += debug.o 22

23 23 Stride Scheduler Skeleton < kernel/sched/stride.c> #define STRIDE_MIN_SCHED_TASK_NO 3 #define STRIDE_SCHED_CNT 10 static inline struct task_struct *stride_task_of(struct sched_stride_entity *se) return container_of(se, struct task_struct, stride); void init_stride_rq(struct stride_rq *stride_rq) stride_rq->stride_nr_running = 0; stride_rq->tasks_timeline = RB_ROOT_CACHED; stride_rq->curr = 0; stride_rq->remain_tickets = STRIDE_TICKETS; stride_rq->sched_cnt = 0; printk(kern_info "***[OS18] Stride class is online \n"); static void update_curr_stride(struct rq *rq) static void enqueue_task_stride(struct rq *rq, struct task_struct *p, int flags) printk("***[os18] Enqueue:::P[%u], nr_running = %u \n", p->pid, rq->stride.stride_nr_running); static void dequeue_task_stride(struct rq *rq, struct task_struct *p, int flags) printk("***[os18] Dequeue:::P[%u], nr_running = %u \n", p->pid, rq->stride.stride_nr_running); static void check_preempt_curr_stride(struct rq *rq, struct task_struct *p, int flags) resched_curr(rq); static struct task_struct *pick_next_task_stride(struct rq *rq, struct task_struct *prev, struct rq_flags *rf) struct sched_stride_entity *se; struct stride_rq *stride_rq = &rq->stride; static void put_prev_task_stride(struct rq *rq, struct task_struct *p) static int select_task_rq_stride(struct task_struct *p, int cpu, int sd_flag, int flags) return task_cpu(p); static void set_curr_task_stride(struct rq *rq) static void task_tick_stride(struct rq *rq, struct task_struct *p, int queued) struct sched_stride_entity *se = &p->stride; printk(kern_info "***[OS18] Tick:::P[%u](stride = %u): pass = %llu \n", p->pid, se->stride, se->pass); static void prio_changed_stride(struct rq *rq, struct task_struct *p, int oldprio) /* This routine is called when a task migrates between classes */ static void switched_to_stride(struct rq *rq, struct task_struct *p) resched_curr(rq); const struct sched_class stride_sched_class =.next.enqueue_task.dequeue_task = &fair_sched_class, = enqueue_task_stride, = dequeue_task_stride,.check_preempt_curr = check_preempt_curr_stride, if (stride_rq->stride_nr_running < STRIDE_MIN_SCHED_TASK_NO) return NULL;.pick_next_task.put_prev_task = pick_next_task_stride, = put_prev_task_stride, #if 0 #else #endif if (stride_rq->sched_cnt++ > STRIDE_SCHED_CNT) return NULL; printk(kern_info "***[OS18] Pick:::P[%u](stride = %u): pass = %llu \n", stride_task_of(se)->pid, se->stride, se->pass); return stride_task_of(se); return NULL; #ifdef CONFIG_SMP #endif ;.select_task_rq.set_curr_task.task_tick.prio_changed.switched_to.update_curr = select_task_rq_stride, = set_curr_task_stride, = task_tick_stride, = prio_changed_stride, = switched_to_stride, = update_curr_stride, 23

24 24 Add Stride Scheduler <kernel/sched/sched.h> extern const struct sched_class fair_sched_class; extern const struct sched_class idle_sched_class; // <-- OS18 extern const struct sched_class stride_sched_class; // --> OS18 // <-- OS18 extern void init_stride_rq(struct stride_rq *stride_rq); // --> OS18 <kernel/sched/rt.c> const struct sched_class rt_sched_class =.next = &stride_sched_class, sched_class_highest stop_sched_class.next dl_sched_class.next rt_sched_class.next stride_class.next fair_sched_class.next 24

25 25 Stride Scheduling Data Structures <include/linux/sched.h> <kernel/sched/sched.h> //<-- OS18 struct sched_stride_entity unsigned int unsigned int unsigned int s64 on_rq; tickets; stride; pass; //<-- OS18 #define STRIDE_TICKETS 1000 struct stride_rq unsigned int stride_nr_running; int remain_tickets; unsigned int sched_cnt; ; //--> OS18 struct task_struct struct rb_node run_node; const struct sched_class *sched_class; struct sched_entity se; struct sched_rt_entity rt; #ifdef CONFIG_CGROUP_SCHED struct task_group *sched_task_group; #endif struct sched_dl_entity dl; //<-- OS18 struct sched_stride_entity stride; //--> OS18 ; ; //--> OS18 struct rq //<-- OS18 //--> OS18 ; struct sched_stride_entity *curr; struct rb_root_cached tasks_timeline; struct cfs_rq cfs; struct rt_rq rt; struct dl_rq dl; struct stride_rq stride; 25

26 26 To Change Scheduling Class (1) <include/uapi/linux/sched/types.h> <kernel/sched/sched.h> struct sched_attr ; u32 size; u32 sched_policy; u64 sched_flags; /* SCHED_NORMAL, SCHED_BATCH */ s32 sched_nice; /* SCHED_FIFO, SCHED_RR */ u32 sched_priority; /* SCHED_DEADLINE */ u64 sched_runtime; u64 sched_deadline; u64 sched_period; // <-- OS18 u32 tickets; // --> OS18 static inline int dl_policy(int policy) return policy == SCHED_DEADLINE; // <-- OS18 static inline int stride_policy(int policy) return policy == SCHED_STRIDE; // --> OS18 static inline bool valid_policy(int policy) return idle_policy(policy) fair_policy(policy) // <-- OS18 stride_policy(policy) // --> OS18 rt_policy(policy) dl_policy(policy); <include/uapi/linux/sched.h> /* * Scheduling policies */ #define SCHED_NORMAL 0 #define SCHED_FIFO 1 #define SCHED_RR 2 #define SCHED_BATCH 3 /* SCHED_ISO: reserved but not implemented yet */ #define SCHED_IDLE 5 #define SCHED_DEADLINE 6 //<-- OS18 #define SCHED_STRIDE 7 //--> OS18 26

27 27 To Change Scheduling Class (2) <kernel/sched/core.c> <kernel/sched/core.c> static void sched_fork(unsigned long clone_flags, struct task_struct *p) INIT_LIST_HEAD(&p->rt.run_list); p->rt.timeout = 0; p->rt.time_slice = sched_rr_timeslice; p->rt.on_rq = 0; p->rt.on_list = 0; // <-- OS18 RB_CLEAR_NODE(&p->stride.run_node); // --> OS18 void init sched_init(void) init_cfs_rq(&rq->cfs); init_rt_rq(&rq->rt); init_dl_rq(&rq->dl); // <-- OS18 init_stride_rq(&rq->stride); // --> OS18 static void setscheduler(struct rq *rq, struct task_struct *p, const struct sched_attr *attr, bool keep_boost) // <-- OS18 struct sched_stride_entity *se; struct stride_rq *stride_rq = &rq->stride; unsigned int temp; // --> OS18 setscheduler_params(p, attr); p->prio = normal_prio(p); if (keep_boost) p->prio = rt_effective_prio(p, p->prio); if (dl_prio(p->prio)) p->sched_class = &dl_sched_class; else if (rt_prio(p->prio)) p->sched_class = &rt_sched_class; // <-- OS18 else if (stride_policy(attr->sched_policy) && (attr->tickets < stride_rq->remain_tickets)) p->sched_class = &stride_sched_class; se = &p->stride; se->tickets = attr->tickets; se->stride = 0; temp = STRIDE_TICKETS; while(temp >= se->tickets) temp -= se->tickets; se->stride++; se->pass = (u64)se->stride; se->on_rq = 0; stride_rq->remain_tickets -= se->tickets; printk("***[os18] task is created: pass = %llu, stride = %u, tickets = %u \n", se->pass, se->stride, se->tickets); // --> OS18 else p->sched_class = &fair_sched_class; 27

28 28 Apply to Kernel linux $ make -j4 linux $ sudo make modules_install linux $ cd /lib/modules/ lib/modules/4.15.6$ sudo find. -name *.ko -exec strip --strip-unneeded + lib/modules/4.15.6$ cd ~/linux linux $ sudo make install linux $ reboot stride/app$ make gcc -g -static -o stride_app app_src.c stride/app$./stride_app ***[OS18] select Stride scheduling class Child's PID = 1967 Child's PID = 1968 ***[OS18] select Stride scheduling class Child's PID = 1969 ***[OS18] select Stride scheduling class 3 tasks are created *** DONE *** stride/app$ ps -ac PID CLS PRI TTY TIME CMD 1967 #7 19 pts/4 00:00:00 newclass 1968 #7 19 pts/4 00:00:00 newclass 1969 #7 19 pts/4 00:00:00 newclass 1970 TS 19 pts/4 00:00:00 ps stride/app$ dmesg grep OS18 [ ] ***[OS18] Stride class is online [ ] ***[OS18] task is created: pass = 25, stride = 25, tickets = 40 [ ] ***[OS18] task is created: pass = 50, stride = 50, tickets = 20 [ ] ***[OS18] task is created: pass = 100, stride = 100, tickets = 10 28