avishai wool lecture 2 - 1 introduction to systems programming lecture 2 processes & scheduling

Avishai Woollecture 2 - 1

Introduction to Systems Programming Lecture 2

Processes & Scheduling


Multi-Programming

• A computer can do “several things at once”– Browse the net– Write an email– Listen to net radio– Print a document

• … but CPU only does one thing at a time

• CPU switches between running programs


What is a process?

A process is an executing program

• When we double click on icon linked to “iexplore.exe”, the OS creates a new process:– Allocates some memory for the program– loads instructions from the disk into RAM– Does some book-keeping– Gives control to the new process


What does a process have?

1. Resources– Address space: the RAM allocated to the program– Program image: machine instructions– file handles, child processes, accounting info…

2. Thread of execution– Instruction address (program counter)– Registers and CPU state– Stack of called procedures


Analogy: Baking a Cake

• Baker• Recipe instructions• Ingredients (flour, sugar,…)• Cake

Program != Process

CPU Program Input Output


Analogy cont.

• Child is injured• Baker marks place in recipe• Switches to “medical help”• Return to recipe in same place

Interrupt Save process state higher priority process Resume process


Which processes are running?• Unix: the ps command shows the active processes. To see all

processes type “ps –aux” (linux) or “ps –ef” (Sun)

• Lots of output so use “ps –aux | more”• Alternative: the “top” command

• Windows 2000 / XP:– Alt+Ctrl+Del Task Manager


What the OS knows about a process

Process Control Block (PCB): a data structure in OS.

• Static info: PID, owner, file…

• Resources in use (devices, files)

• Memory maps

• CPU state: (place for content of) registers

• Accounting (CPU usage, memory usage...)


How are processes created?

• An existing process issues a system call to create a new process.

• The creating process can be:– An OS process (Windows Explorer, Desktop process

that handles “double click”, the “cmd” shell,….)

– A regular user process


Process Management System Calls• Create a process

– allocate initial memory– allocate process ID– loads initial binary image– optionally: send arguments to process

• Destroy a process– terminate the process– free resources associated with it– optionally: return value

• Wait for a process: block until specified process terminates, optionally obtain returned value


Process management in Unix and Windows


Unix Processes

• Parent process creates children processes (recursively: get a tree of processes)

• OS maintains information about which process is the parent of each process

• Execution– Parent and children execute concurrently.– Parent waits until children terminate (sort of).


Unix Process Creation

• Address space– Child duplicate of parent.– Child has a program loaded into it.

• Two system calls needed– fork system call creates new process– exec system calls replaces process’ memory space

with a new program.


Unix Process Management• fork: (return TWICE if successful)

– Create a copy of the current process – Return 0 to the “child” process– Return child’s pid to the “parent” process

• exec(file,argv): (NEVER return if successful)– Make current process run file with given arguments argv

• exit(code): (NEVER return if successful)– Terminate current process with given return code (0 means

OK)• waitpid(pid, &code, options): (return only when

appropriate)– wait until child exits


int pid, ret_val; // pid == process ID

...

if ((pid = fork()) == 0) { // pid is 0 only child process exec(command, parameters, …);}else{ // pid is not 0 only parent reaches here waitpid(-1, &ret_val, 0);}

Simple Example

Wait for any child to exit

Child’s return value


Fork Example: Chain#include <stdio.h>void main(void){ int i; for (i = 0; i < 6; i++)

{ if (0 != fork()) break; // parent exits the loop

} fprintf(stderr, “Process: %ld Parent: %ld\n", (long)getpid(), (long)getppid()); sleep(1);

}


Fork Example: Fan#include <stdio.h> void main(void){ int i; for (i = 0; i < 6; i++)

{ if (0 == fork()) break; // child exits the loop

} fprintf(stderr,

“Process: %ld Parent: %ld\n", (long)getpid(), (long)getppid()); sleep(1);}


Win32 processes

• In Windows there is a huge library of “system” functions called the Win32 API.

• Not all functions result in system calls (many are not executed in kernel mode)

• No Parent-Child relationship between processes.


Win32 Process Management API

• CreateProcess() – Create a new process (fork+exec)

• ExitProcess() – Terminate Execution• WaitForSingleObject() – Wait for termination

– Can wait for many other events

• There is no separation into fork and exec in Win32


Process scheduling


• current process runs, until either

– an interrupt occurs, or

– it makes a system call, or

– it runs for too long (interrupt: timer expired)

• OS gets control, handles the interrupt/syscall …

… But OS does NOT immediately “return” to the process that was running before !

Process Scheduling Basics - 1


• OS maintains several lists of processes.

• OS saves current process’ registers in PCB• Place (PCB of) current process in appropriate list• Dispatcher/scheduler (a part of the OS):

– chooses new “current process” from the Ready list– loads its registers from PCB – activates the process context switch

Process Scheduling Basics - 2


Schematic Scheduling


Process Life Cycle

event: an interrupt, or a signal (system call) from another process

new

ready running

terminated

waiting

admitted

interrupt/yield

scheduled

wait for eventeventoccurrence

exit, kill


When does CPU scheduling occur?• The OS makes a CPU scheduling decision when:

1. A process switches from running to ready state. (interrupt)

2. A process switches from running to waiting state. (syscall)

3. A process switches from waiting to ready. (interrupt)

4. A process terminates. (syscall)


The Dispatcher• A module in OS to execute scheduling decisions. • This is done by:

– switching context • (loading stored register values from PCB)

– switching to user mode

– jumping to the proper location in the user program to restart that program

• Small, tricky to write, assembly function


Scheduling Policies

Who’s turn is it now?


To Preempt or not to Preempt?• Preemptive: A Process can be suspended and resumed• Non-preemptive: A process runs until it voluntarily

gives up the CPU (wait for event or terminate).• Most modern OSs use preemptive CPU scheduling,

implemented via timer interrupt.

• Non-preemptive is used when suspending a process is impossible or very expensive: e.g., can’t “replace” a flight crew in middle of flight.


Typical CPU burst distribution


Scheduling Criteria• Abstract scheduling terminology

– CPU == Server– CPU burst == job

• System view:– Utilization: percentage of the time server is busy– Throughput: number of jobs done per time unit

• Individual job view:– Turnaround time: how long does it take for a job to finish– Waiting time: turnaround time minus “solo” execution time


Example: FCFS Scheduling

• First Come, First Served. Natural, fair, simple to implement

• Assume non-preemptive version

• Example: Jobs are P1 (duration: 24 units); P2 (3); and P3 (3), arriving in this order at time 0

• Gantt Chart for FCFS schedule:

• Average waiting time: (0 + 24 + 27)/3 = 17

P1 P2 P3

24 27 300


FCFS: continued

What if execution order is P2 , P3 , P1 ?• Gantt chart:

• Average waiting time: (6 + 0 + 3)/3 = 3• Much better!• Convoy effect: many short jobs stuck behind one long job

P1P3P2

63 300


Scheduling policy: SJF• “Shortest Job First”:

– Assume each job has a known execution time– Schedule the shortest job first

• Can prove: SJF ensures minimal average waiting time!

• In pure form, mostly theoretical:

OS does not know in advance how long the next CPU burst will last


Preemptive Scheduling: Round Robin

• 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.

• Then the process at head of queue is scheduled.


Performance of Round Robin

• n processes in the ready queue

• time quantum is q,

• 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.

• Performance– If q too large FCFS– But q must be large with respect to context switch,

otherwise overhead is too high.


Round Robin: ExampleProcess Burst Time

P1 53

P2 17

P3 68

P4 24

• Gantt chart for time quantum 20:

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

P1 P2 P3 P4 P1 P3 P4 P1 P3 P3

0 20 37 57 77 97 117 121 134 154 162


SJF for CPU Scheduling

• Associate with each process the (estimated) length of its next CPU burst. Use these lengths to schedule the process with the shortest time.

• if a new process arrives with CPU burst length less than remaining time of current executing process, preempt. A.k.a. Shortest-Remaining-Time-First (SRTF).


Estimating length of CPU burst• Idea: use length of previous CPU bursts

• Heuristic: use exponential averaging (aging).

.1 :Define 4.

10 , 3.

burst CPUnext for the valuepredicted 2.

burst CPU oflength actual 1.

1

1

nnn

n

thn

t

nt


Exponential AveragingExpanding the formula, we get:

n+1 = tn+(1 - ) tn-1 + …

+(1 - )j tn-j + …

+(1 - )n 0

• Since both and (1 - ) are less than or equal to 1, each successive term has less weight than its predecessor.

=0 n+1 = n = … = 0

– Recent history does not count. =1

– n+1 = tn

– Only the actual last CPU burst counts.


Exponential Averaging: Example

=0.5


Priority Scheduling

Idea: Jobs are assigned priorities.Always, the job with the highest priority runs.

Note: All scheduling policies are priority scheduling!

Question: How to assign priorities?

priority 1

priority 2

priority M


Example for Priorities

Static priorities can lead to starvation!


Dynamic Priorities

Example: multilevel feedback


Concepts for review• Process

• Process Control Block (PCB)

• Unix process creation: fork / exec

• Context switch

• Dispatcher

• Preemption

• CPU Burst

• FCFS

• SJF

• Round-Robin

• Exponential aging

• Starvation

avishai wool lecture 2 - 1 introduction to systems programming lecture 2 processes & scheduling

Documents