Linux Scheduler

Scheduling in Linux: Prior to Version 2.5 Traditional Unix Scheduler Processes Classes for Scheduling Purposes So-Called Real-Time are just high priority Priorities 0 - 99 Real-time FIFO Non-preemptible Real-time round robin Preemptible if its quantum expires Timesharing Priorities 100 – 139 Did not support systems with multiple processors well

With Version 2.5 O(1) Scheduler Ready queue organized as two chained hash-tables Active: ready/quantum has not expired Expired: ready/quantum has expired Each list within a category has a different priority and will receive a different size time slice Operation Select task from highest priority queue in Active list If it’s time slice expires, move it to the expired list If it blocks, decrement its time slice counter and put it back on the Active queue Priority is constantly recalculated Reward interactive processes Punish cpu-intensive processes Ran in constant regardless of the number of processes in the system. Had features that favored multiple processors like load balancing. Ran poorly on interactive systems

With Version 2.6 CFS(completely fair scheduler) Selecting Which Process to Run Next Ready queue organized as a red-black tree Each internal node is a task Children on left had less time on CPU Children on right had more time on CPU Schedule task which had least amount of CPU time Selecting a node: O(N) because it’s the left-most node Inserting a node: O(lg(n)) because the tree is balanced Accounts for priorities virtual clock ticks more quickly for low priority processes virtual clock ticks more slowly for high priority processes

CFS Conventional (interactive processes) Setting Static Priority Each interactive process has it own static priority: 100 (highest) – 139 (lowest) A new process inherits the static priority of its parent Determines the base time quantum in milliseconds according to this formula: if static priority < 120 base_time_quantum = (140 – static priority) * 20 else base_time_quantum = (140 – static priority) * 5 Since a higher process is associated with a lower numerical value, high priority processes start off with a longer quantum. Highest static priority is 100: btq = (140 – 100) * 20 = 800 ms Default static priority is 120: btq = (140 – 120) * 5 = 100 ms Lowest static priority is 139: btq = (140 – 139) * 5 = 5 ms Nice values: Older linux/unix systems used nice() which sets priorities from -20 to 19. These correspond 100 to 139

Conventional (interactive processes) Dynamic Priority The priority used in making scheduling decisions dynamic_priority = max(100, min(static_priority – bonus + 5, 139)) Bonus [0 .. 10] < 5 is a penalty for bad behavior > 5 is a premium for good behavior Related to the average sleep time of the process. That is, if the process has blocked several times it has slept more than one that has blocked only once. It is more interactive Example static_priority = 130 (i.e., a low static priority) bonus = 10 (process behaved well) dynamic_priority = max(100, min(125, 139)) = 125