主講人：虞台文

Operating Systems PrinciplesProcess Management and Coordination

Lecture 5:Process and Thread Scheduling

主講人：虞台文

Content

Organization of Schedulers – Embedded and Autonomous Schedulers – Priority Scheduling

Scheduling Methods – A Framework for Scheduling – Common Scheduling Algorithms – Comparison of Methods

Priority Inversion



Organization of Schedulers

Process Scheduling/Dispatching

Process scheduling– Long term scheduling– Move process to Ready List (“RL”) after

creation (When and in which order?)

Process Dispatching– Short term scheduling– Select process from Ready List to run

We use “scheduling” to refer to both.


Embedded– Called as function at

end of kernel call– Runs as part of calling

process

Autonomous– Separate process– May have dedicated

CPU on a multiprocessor– On single-processor,

run at every quantum:scheduler and other processes alternate

pi: processS : scheduler


Embedded– Called as function at

end of kernel call– Runs as part of calling

process

Autonomous– Separate process– May have dedicated

CPU on a multiprocessor– On single-processor,

run at every quantum:scheduler and other processes alternate

OSOS

p1p1

SOSOS

p2p2

SOSOS

p3p3

SOSOS

p4p4

S

OSOS

p1p1

OSOS

p2p2

OSOS

p3p3

OSOS

p4p4

OSOS

SSUnixUnix

Windows 2000Windows 2000

Priority Scheduling

Priority function returns numerical value P for process p:

P = Priority(p)

Static priority: unchanged for lifetime of p Dynamic priority: changes at runtime

Who runs next?Based on priority

Priority-Leveled Processes

Priority divides processes into levels Implemented as multilevel ready list, say, RL

– p at RL[i] run before q at RL[j] if i > j– p, q at same level are ordered by other criteria, e.g., the o

rder of arrival.

RL[n]1

2

n 1

nf rontrear

1

2

n 1

nf rontrearf rontrearf rontrear

1

2

n 1

nf rontrear

1

2

n 1


Lowest

Highest

Lowest

Highest

The Processes in Ready List

Status.Type {running, ready_a, ready_s}

1

2

n 1

nf rontrear

1

2

n 1


1

2

n 1

nf rontrear

1

2

n 1


The Scheduler

The Scheduler

The scheduler may be invoked

periodically

when some events affect the priorities of existing processes, e.g.,

– a process is blocked/suspended

– a process is destroyed

– a new process created

– a process is activated


periodically






The Scheduler


periodically







periodically






Some processes in RL can get

CPU.

Some processes in RL can get

CPU.

Running processes may be

preempted.

Running processes may be

preempted.

The scheduler/dispatcher should always keep the np (#processors) highest-priority active processes running.

Invoking the Scheduler

Request(res) {if (Free(res))Allocate(res, self)

else {Block(self, res);Scheduler();

}}

Release(res) {Deallocate(res, self);if (Process_Blocked_in(res,pr)) {Allocate(res, pr);Unblock(pr, res);Scheduler();

}}

The caller to the scheduler may be a process to be• blocked/suspended or• awakened/activated

Invoking the Scheduler

Create(s0, m0, pi, pid) { p = Get_New_PCB(); pid = Get_New_PID(); p->ID = pid; p->CPU_State = s0; p->Memory = m0; p->Priority = pi; p->Status.Type = ’ready_s’; p->Status.List = RL; p->Creation_Tree.Parent = self; p->Creation_Tree.Child = NULL; insert(self-> Creation_Tree.Child, p); insert(RL, p);Activate(); Scheduler();

}

Create(s0, m0, pi, pid) { p = Get_New_PCB(); pid = Get_New_PID(); p->ID = pid; p->CPU_State = s0; p->Memory = m0; p->Priority = pi; p->Status.Type = ’ready_s’; p->Status.List = RL; p->Creation_Tree.Parent = self; p->Creation_Tree.Child = NULL; insert(self-> Creation_Tree.Child, p); insert(RL, p);Activate(); Scheduler();

}

Suspend(pid) { p = Get_PCB(pid); s = p->Status.Type; if ((s==’blocked_a’)||(s==’blocked_s’))p->Status.Type = ’blocked_s’;

elsep->Status.Type = ’ready_s’;

if (s==’running’) {cpu = p->Processor_ID; p->CPU_State = Interrupt(cpu);Scheduler();

} }

Suspend(pid) { p = Get_PCB(pid); s = p->Status.Type; if ((s==’blocked_a’)||(s==’blocked_s’))p->Status.Type = ’blocked_s’;

elsep->Status.Type = ’ready_s’;

if (s==’running’) {cpu = p->Processor_ID; p->CPU_State = Interrupt(cpu);Scheduler();

} }

Activate(pid) {

p = Get_PCB(pid);

if (p->Status.Type == ’ready_s’) {

p->Status.Type = ’ready_a’;

Scheduler();

}

else

p->Status.Type = ’blocked_a’;

}

Activate(pid) {

p = Get_PCB(pid);

if (p->Status.Type == ’ready_s’) {

p->Status.Type = ’ready_a’;

Scheduler();

}

else

p->Status.Type = ’blocked_a’;

}

Destroy(pid) {

p = Get_PCB(pid);

Kill_Tree(p);

Scheduler();

}

Destroy(pid) {

p = Get_PCB(pid);

Kill_Tree(p);

Scheduler();

}


An Embedded Scheduler

Scheduler() {

do {

Find highest priority ready_a process p;

Find a free cpu;

if (cpu != NIL) Allocate_CPU(p,cpu);

} while (cpu != NIL);

do {


Find lowest priority running process q;

if (Priority(p) > Priority(q)) Preempt(p,q);

} while (Priority(p) > Priority(q));

if (self->Status.Type!=’running’) Preempt(p,self);

}


If free CPUs are available, allocate these free CPUs to high-priority processes in ready_a state

If free CPUs are available, allocate these free CPUs to high-priority processes in ready_a state

To preempt low-priority running processes by high-priority ready_a ones.


If the caller is going to be idled, preempt itself.If the caller is going to be idled, preempt itself.


Scheduler() {

do {


Find a free cpu;



do {






}






Scheduler() {

do {


Find a free cpu;



do {






}

How to simplify the scheduler for a uniprocessor system?



Scheduling Methods

Scheduling Policy

Scheduling based on certain criteria.

For examples:– batch jobs vs. interactive users– System processes vs. user processes– I/O bound processes vs. CPU bound

processes

The General Framework

When to schedule?– Preemptive– Nonpreemptive

Who to schedule?– Priority evaluation– Arbitration to break ties

Decision Mode

• Decision mode• Priority function• Arbitration Rule

A scheduling policy is determined by:

The Decision Modes

Preemptive: scheduler called– periodically (quantum-oriented) or – when system state changes

More costly

Nonpreemptive: scheduler called– when process terminates or blocks

Not adequate in real-time or time-shared systems



The Priority Function



Possible parameters:– Attained service time (a)– Real time in system (r)– Total service time (t)– Period (d)– Deadline (explicit or implied by period)– External priority (e)– Memory requirements (mostly for batch)– System load (not process-specific)

The Arbitration Rules



Break ties among processes of the same priority– Random– Chronological (First In First Out = FIFO)– Cyclic (Round Robin = RR)

Common Scheduling Algorithms

First-In/First-Out (FIFO) Shortest-Job-First (SJF) Shortest-Remaining-Time (SRT) Round-Robin (RR) Multilevel Priority (ML) Multilevel Feedback (MLF) Rate Monotonic (RM) Earliest Deadline (EDF)

Example Processesfor Scheduling


0 1 2 3 4 5 6 7 8 9

p1

p2

FIFO


0 1 2 3 4 5 6 7 8 9

p1

p2

CPU does other things

StartScheduling

p1

p2

SJF


0 1 2 3 4 5 6 7 8 9

p1

p2


StartScheduling

p1

p2

SRT


0 1 2 3 4 5 6 7 8 9

p1

p2


StartScheduling

p1

p2

p1

RR


0 1 2 3 4 5 6 7 8 9

p1

p2


StartScheduling

p1 p1

Assume a time-quantum of 0.1 time units.

p2

p1

ML


1

2

n 1

n frontrear

ML


Lowest

Highest

Each process has a fixed priority.

1

2

n 1

n frontrear

ML (Nonpreemptive)


Lowest

Highest


1

2

n 1

n frontrear

ML (Preemptive)


Lowest

Highest


ML (Nonpreemptive)


0 1 2 3 4 5 6 7 8 9

p1

p2

ep1 = 15

ep2 = 14


StartScheduling

p1

p2

MLF• Like ML, but priority chang

es dynamically• Every process enters at hig

hest level n• Each level P prescribes ma

ximum time tP

• tP increases as P decreases

• Typically: tn = T (constant)

tP = 2 tP+1


MLF• The priority of a process is a

function of a.

• Find P for given a:

priority attained timen a<Tn – 1 a<T+2Tn – 2 a<T+2T+4T. . . . . .n – i a<(2i+1–1)T


a: attained service time

P = n – i = n – lg2(a/T+1)

RM & EDF


RM– Intended for periodic (real-time) processes– Preemptive – Highest priority: shortest period: P = –d

EDF– Intended for periodic (real-time) processes– Preemptive – Highest priority: shortest time to next deadline

r d number of completed periods

r % d time in current period

d – r % d time remaining in current period

P = –(d – r % d)

Common Scheduling Algorithms

Comparison of Methods

• FIFO, SJF, SRT: Primarily for batch systems

• FIFO is the simplest

• SJF & SRT have better average turnaround times:

1

1 n

ii

AVT rn

ri: the real time that the ith process spends in the system.

Example 1

1 n

ii

AVT rn

arrival servicep1

p2

p3

t

t

t 3

4

2

1

Comparison ofaverage turnaround time


Time-sharing systems• Response time is critical• RR or MLF with RR within each queue are suitable

Time-sharing systems• Response time is critical• RR or MLF with RR within each queue are suitable


Time-sharing systems– Response time is critical– RR or MLF with RR within each queue are suitable

Choice of quantum determines overhead– When q , RR approaches FIFO– When q 0, context switch overhead 100%– When q >> context switch overhead,

n processes run concurrently at 1/n CPU speed

Interactive Systems

1

2

n 1

nf rontrear

1

2

n 1


Most dynamic schemes tend to move interactive and I/O-bound processes to the top of the priority queues and to let CPU-bound processes drift to lower levels.

MLF puts I/O-completed processes into highest priority queue.


• Real-time systems– Feasible = All deadlines are met– CPU utilization is defined as: U=∑ ti/di

– Schedule is feasible if U 1– EDF always yields feasible schedule (if U 1)– RM yields feasible schedule if U 0.7

• Real-time systems– Feasible = All deadlines are met– CPU utilization is defined as: U=∑ ti/di

– Schedule is feasible if U 1– EDF always yields feasible schedule (if U 1)– RM yields feasible schedule if U 0.7

Example: RM and EDF

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4

1 2

1 2

1 30.85

4 5

t tU

d d

p1

p2

CPU Utilization

p1

p2

RM

p1

p2

EDF

Example: RM and EDF

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4

1 2

1 2

1.5 30.975

4 5

t tU

d d

p2

CPU Utilization

p1

p2

RM

p1

p2

EDF

p1

fail



Priority Inversion

Priority Inversion Problem

p1

P(mutex)

CS_1

V(mutex)

Program1

p2

Program2

p3

P(mutex)

CS_3

V(mutex)

Program3

• Assume priority order p1 > p2 > p3.• p1 and p3 share common resource.• p2 is independent of p1 and p3 .



p1

P(mutex)

CS_1

V(mutex)

Program1

p1

P(mutex)

CS_1

V(mutex)

Program1

p2

Program2

p2

Program2

p3

P(mutex)

CS_3

V(mutex)

Program3

p3

P(mutex)

CS_3

V(mutex)

Program3

p1

P(mutex)

CS_1

V(mutex)

Program1

p1

P(mutex)

CS_1

V(mutex)

Program1

p2

Program2

p2

Program2

p3

P(mutex)

CS_3

V(mutex)

Program3

p3

P(mutex)

CS_3

V(mutex)

Program3



p1

P(mutex)

CS_1

V(mutex)

Program1

p1

P(mutex)

CS_1

V(mutex)

Program1

p2

Program2

p2

Program2

p3

P(mutex)

CS_3

V(mutex)

Program3

p3

P(mutex)

CS_3

V(mutex)

Program3

p1

P(mutex)

CS_1

V(mutex)

Program1

p1

P(mutex)

CS_1

V(mutex)

Program1

p2

Program2

p2

Program2

p3

P(mutex)

CS_3

V(mutex)

Program3

p3

P(mutex)

CS_3

V(mutex)

Program3

(Unrelated) p2 may delay p1 indefinitely.

(Unrelated) p2 may delay p1 indefinitely.

Solutions

1. Make CSs nonpreemptable Practical is CSs are short and few Unsatisfactory if high-priority process often found themselves

waiting for lower-priority process, especially unrelated ones.

2. Naïve “solution”: Always run CS at priority of highest process that shares the CS

Problem: p1 cannot preempt lower-priority process inside CS, even when it does not try to enter CS -- a different form of priority inversion.

3. Dynamic Priority Inheritance See Next

Dynamic Priority Inheritance

p3 is in its CS

p1 attempts to enter its CS

p3 inherits p1’s (higher) priority for the duration of CS

Sha, Rajkumar, and Lehocsky 1990


p1

P(mutex)

CS_1

V(mutex)

Program1

p1

P(mutex)

CS_1

V(mutex)

Program1

p2

Program2

p2

Program2

p3

P(mutex)

CS_3

V(mutex)

Program3

p3

P(mutex)

CS_3

V(mutex)

Program3

p1

P(mutex)

CS_1

V(mutex)

Program1

p1

P(mutex)

CS_1

V(mutex)

Program1

p2

Program2

p2

Program2

p3

P(mutex)

CS_3

V(mutex)

Program3

p3

P(mutex)

CS_3

V(mutex)

Program3

Dynamic Priority Inheritance

p3 is in its CS

p1 attempts to enter its CS

p3 inherits p1’s (higher) priority for the duration of CS


p1

P(mutex)

CS_1

V(mutex)

Program1

p1

P(mutex)

CS_1

V(mutex)

Program1

p2

Program2

p2

Program2

p3

P(mutex)

CS_3

V(mutex)

Program3

p3

P(mutex)

CS_3

V(mutex)

Program3

p1

P(mutex)

CS_1

V(mutex)

Program1

p1

P(mutex)

CS_1

V(mutex)

Program1

p2

Program2

p2

Program2

p3

P(mutex)

CS_3

V(mutex)

Program3

p3

P(mutex)

CS_3

V(mutex)

Program3

References Rensselaer Polytechnic Institute

http://www.cs.rpi.edu/academics/courses/fall04/os/c8/ University of east London Inside the Windows NT Scheduler, Part 1 Inside the Windows NT Scheduler, Part 2

主講人：虞台文

Documents

Transcript of 主講人：虞台文