Fedora 12 scheduling criteria & algorithms

Fedora 12 SpecificationsFedora 12 is a 0s based on the Linux kernel, developed by the community-supported Fedora Project and sponsored by Red Hat.

Fedora 12 uses Fedora Core 6 development environment

Fedora core 6 uses the 2.6.18 based Linux kernel

History of Linux kernelThe Linux kernel was initially conceived and created by] Linus Torvalds in 1991

He was influenced by the operating system MINIX written by Andrew S. Tanenbaum

Linux kernel specificationLinux is a monolithic kernel

Preemptive kernel

Support symmetric multi processing

Written in C using GCC compiler

Linux kernel versionsThe Linux Kernel Archives is the official site toDownload standard Linux kernel.

3.0.1 is the latest stable kernel release

It was released in 05-08-2011But we are talking about 2.6.37.6 kernel in Fedora 12

We are going to talk more about scheduling• Selecting processes one by one from the ready queue and allocate CPU for them.• The decisions may occur on

Process Switches from running to waiting state Switches from running to ready state Switches from waiting to ready Terminates

Scheduling Policy• Process Preemption

• When the dynamic priority of the currently running process is lower than the process waiting in the ready queue

• A process may also be preempted when its time quantum expires

• How Long Must a Time Quantum Last?• Quantum duration too short - system overhead caused by task

switching becomes excessively high• Quantum duration too long - processes no longer appear to be

executed concurrently, degrades the response time of interactive applications, and degrades the responsiveness of the system

• The rule of thumb adopted by Linux is: choose a duration as long as possible, while keeping good system response time

What is Scheduling Criteria• CPU utilization – keep the CPU as busy as possible• Throughput – Number of processes that complete

their execution per time unit• Turnaround time – amount of time to execute a

particular process• Waiting time – amount of time a process has been

waiting in the ready queue• Response time – amount of time it takes from when

a request was submitted until the first response is produced, not output (for time-sharing environment)

Scheduling Algorithems• First Come First Serve Scheduling • Shortest Job First Scheduling • Priority Scheduling • Round-Robin Scheduling •Multilevel Queue Scheduling •Multilevel Feedback-Queue Scheduling

First Come First Serve Scheduling (FCFS)Process Burst timeP1 24P2 3P2 3

First Come First Serve Scheduling• The average of waiting time in this policy is usually quite long

•Waiting time for P1=0; P2=24; P3=27• Average waiting time= (0+24+27)/3=17

First Come First Serve Scheduling• Suppose we change the order of arriving job P2, P3, P1

First Come First Serve Scheduling• Consider if we have a CPU-bound process and many

I/O-bound processes

• There is a convoy effect as all the other processes waiting for one of the big process to get off the CPU

• FCFS scheduling algorithm is non-preemptive

Short job first scheduling (SJF)• This algorithm associates with each process the length of the processes’ next CPU burst

• If there is a tie, FCFS is used• In other words, this algorithm can be also regard as shortest-next-cpu-burst algorithm

Short job first scheduling• SJF is optimal – gives minimum average waiting time for a given set of processes

ExampleProcesses Burst timeP1 6P2 8P3 7P4 3

FCFS average waiting time: (0+6+14+21)/4=10.25SJF average waiting time: (3+16+9+0)/4=7

Short job first scheduling

Two schemes:Non-preemptive – once CPU given to the process it

cannot be preempted until completes its CPU burst

Preemptive – if a new process arrives with CPU burst length less than remaining time of current executing process, preempt. This scheme is know as the Shortest-Remaining-Time-First (SRTF)

Short job first scheduling- Non-preemptive

Short job first scheduling- Preemptive

Priority Scheduling

A priority number (integer) is associated with each processThe CPU is allocated to the process with the highest priority(smallest integer ≡ highest priority)• Preemptive• Non-preemptive

SJF is a special priority scheduling where priority is the predicted next CPU burst time, so that it can decide the priority

Priority SchedulingProcesses Burst time Priority Arrival time P1 10 3P2 1 1P3 2 4P4 1 5 P5 5 2The average waiting time=(6+0+16+18+1)/5=8.2

Priority SchedulingProcesses Burst time Priority Arrival time P1 10 3 0.0P2 1 1 1.0P3 2 4 2.0P4 1 5 3.0P5 5 2 4.0

Gantt chart for both preemptive and non-preemptive, also waiting time

Priority SchedulingProblem : Starvation – low priority processes may never execute

Solution : Aging – as time progresses increase the priority of the process

Round-Robin Scheduling• The Round-Robin is designed especially for time sharing systems. • It is similar FCFS but add preemption concept• A small unit of time, called time quantum, is defined

Round-Robin Scheduling• Each process gets a small unit of CPU time (time quantum), usually 10-100 milliseconds. After this time has elapsed, the process is preempted and added to the end of the ready queue.

Round-Robin Scheduling

Round-Robin Scheduling• If there are n processes in the ready queue and the time quantum is q, then each process gets 1/n of the CPU time in chunks of at most q time units at once. No process waits more than

(n-1)q time units.

Round-Robin SchedulingPerformance• q large => FIFO• q small => q must be large with respect to context switch, otherwise overhead is too high

• Typically, higher average turnaround than SJF, but better response

Round-Robin Scheduling

Linux Version Scheduler

Linux pre 2.5 Multilevel Feedback Queue

Linux 2.5-2.6.23 O(1) Scheduler

Linux Post 2.6.23 Completely Fair Scheduler

Linux Scheduler History

Linux schedulers’ history is short but the popularity and its development achieved makes it impossible to say that this was introduced in the later part of the 19th century.

Below are some the schedulers' through its brief history

LINUX Schedulers… • Linux operating system is a time sharing system thus the

concept of short and long term schedulers is taken to higher level,

• introducing an additional intermediary level of scheduling or commonly known as medium term scheduling.

• Key ideas behind medium term scheduling

• Remove processes from memory for a while• Later the process is reintroduced into memory and

executed

Linux 1.2 Scheduler• Linux 1.2 scheduler used a circular queue for runnable task

management that operated with a round-robin scheduling policy.

.Features of 1.2 scheduler

Efficient for adding and removing processes (with a lock to protect the structure ).

Simple and fast .

Not complex to handle .

2.2 and 2.4 Schedulers • Linux 2.2 scheduler

• Linux 2.2 schedulers introduced the idea of scheduling classes, permitting scheduling policies for real-time tasks, non-preemptive tasks, and non-real-time tasks.

• Linux 2.4 scheduler

• Includes a relatively simple scheduler that operated in O(N) time.

• 2.4 scheduler divided time into epochs, and within each epoch, every task was allowed to execute up to its time slice

Linux 2.6 O(1) SchedulerReReducing scheduling algorithm complexity to O(1)from O(n).Better support for SMP system.Single run queue lockCache problem

Preemptive: A higher priority process can preempt a running process with lower priority.

Priority and interactivity effect on time slice

Nice Value vs. static priority and Quantum

Static Priority NICE Quantum

High Priority 100 -20 800 ms

110 -10 600 ms

120 0 100 ms

120 +10 50 ms

Low Priority 139 +19 5 ms

•Con Kolivas introduced this scheduler• introduced the concept of fair scheduling•Borrowed from queuing theory

Rotating staircase Deadline Scheduler

What is Fair Scheduling

• A scheduling strategy for time sharing systems

• the CPU usage is equally distributed among system users or groups,• Not Among the processers

•For example, if four users (A,B,C,D) are concurrently executing one process each one will get 25% of whole cpu power(cpu cycles)

Time sharing continues

I’m the CpuMY power is 100%

A25%

B25%

C25%

D25%

•What if user B has two processes

I’m the CpuMY power is 100%

A25%

B25%

C25%

D25%

B.112.5

%

B.212.5

%

Where Did We Come From?Pre 2.6 Schedulers•Didn’t utilize SMP very well

• Single run queue lock meant idle processors awaiting lock release

• Preemption not possible• Lower priority task can execute while high priority

task waits•O(n) complexity

• Slows down with larger input.

CFS – The Future is Now!• Completely Fair Scheduler

• Merged into the 2.6.23 kernel• Runs task with the “gravest need”• Guarantees fairness (CPU usage)

•No run queues!• Uses a time-ordered red-black binary tree• Leftmost node is the next process to run

Red/Black Tree Rules

•19

•27

•NL

•NL

•NL

•NL

•NL

•NL

•NL

•NL

•NL

•98

•49

•2

•34

•65

•31

•AA25

•7•NL

Red/Black Continues…….1. Every node has two children, each colored

either red or black.

2. Every tree leaf node is colored black.

3. Every red node has both of its children colored black.

4. Every path from root to a tree leaf contains same number of black nodes

CPUDispatcher Scheduler

How CFS Works

• The scheduler stores the records about the planned tasks in a red-black tree, using the spent processor time as a key.

• This allows it to pick efficiently the process that has used the least amount of time (it is stored in the leftmost node of the tree).

• The spent execution time is updated and the process is then returned to the tree where it normally takes some other location

• The new leftmost node is then picked from the tree, repeating the iteration.

CFS Features (cont)•No timeslices!... sort of

• Uses wait_runtime (individual) and fair_clock (queue-wide)• Processes build up CPU debt• Different priorities “spend” time differently• Half priority task sees time pass twice as fast

•O(log n) complexity• Only marginally slower than O(1) at very large

numbers of inputs

Digging in – CFS Data Structures CFS has three primary structures –

task_struct, sched_entity, and cfs_rq. task_struct is the top-level entity, containing

things such as task priorities, scheduling class, and the sched_entity struct. (sched.h, L1117)

sched_entity includes a node for the RB tree and the vruntime statistic, among others. (sched.h, L1041)

cfs_rq contains the root node, task group (more on this later), etc. (sched.c, L424)

Priorities and more While CFS does not directly use priorities or priority

queues, it does use them to modulate vruntime buildup.

In this version, priority is inverse to its effect – a higher priority task will accumulate vruntime more slowly, since it needs more CPU time.

Likewise, a low-priority task will have its vruntime increase more quickly, causing it to be preempted earlier.

“Nice” value – lower value means higher priority. Relative priority, not absolute...

...that's it? The CFS algorithm is, as stated, a lot simpler

than the previous one, and does not require many of the old variables.

Preemption time is variable, depending on priorities and actual running time. So we don't need assign tasks a given timeslice.

Other additions CFS introduced group scheduling in release

2.6.24, adding another level of fairness. Tasks can be grouped together, such as by the

user which owns them. CFS can then be applied to the group level as well as the individual task level.

So, for three groups, it would give each about a third of the CPU time, and then divide that time up among the tasks in each group.

Modular scheduling Alongside the initial CFS release came the notion

of “modular scheduling”, and scheduling classes. This allows various scheduling policies to be implemented, independent of the generic scheduler.

sched.c, which we have seen, contains that generic code. When schedule() is called, it will call pick_next_task(), which will look at the task's class and call the class-appropriate method.

Let's look at the sched_class struct...(sched.h L976)

Scheduling classes! Two scheduling classes are currently

implemented: sched_fair, and sched_rt. sched_fair is CFS, which We are talking about

this whole time. sched_rt handles real-time processes, and

does not use CFS – it's basically the same as the previous scheduler.

CFS is mainly used for non-real-time tasks.