Introduction to Systems Programming Lecture 2

Avishai Woollecture 2 1

Introduction to Systems Programming

Lecture 2

Processes & Scheduling


Categories of System Calls

System calls provide API: language spoken by the virtual machines (processes) applications run on.

Process management: creation, destruction, Process management: creation, destruction, contentscontents

I/O devices management:» File system: file creation/deletion, reading/writing, access

rights» Network devices: opening/closing, reading/writing,

standing by Virtual memory management Inter-process communication


Why Multiple Processes?

Tool for parallelism: e.g., read input while producing output

Better utilization of resources Concurrent independent programs Modularity Many users can share the system


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

Windows 98:» Alt+Ctrl+Del» Start Programs Accessories System Tools System

Monitor


How is a process realized?

Process Control Block (PCB): a data structure in OS. CPU state: registers Memory maps Static info: PID, owner, file… Resources in use (devices, files) Accounting (CPU usage, memory usage...)


process table

Why so? Allow preemption and resumption Enforce security policy Resources are used only via handles

» check once, save credentials for later» handles can’t be used by another process

pid resourcestruct

process OS


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


Unix Processes

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

Resource sharing» Parent and children usually share some resources

Execution» Parent and children execute concurrently.» Parent waits until children terminate.


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.

Near one-to-one relationship between system call and C library function that issues the system call.


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

execv(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)» Block until child exits» Return exit code of dead process.


Simple Example

int pid, ret_val;

char* args[10];

// ...

if ((pid = fork()) == 0) { // child process args[0] = “17”; args[1] = “Moshe”;

args[2] = (char*) 0; // end of argsexecv(“a.out”, args);

}// only parent reaches hereif (waitpid(-1, &ret_val, 0) == pid) //...


Fork Example: Chain#include <stdio.h>

void main(void)

{

int i;

for (i = 0; i < 6; i++)

{

if (fork() != 0)

break; // parent exits the loop}

fprintf(stderr,

“Process: %ld Parent: %ld\n",

(long)getpid(), (long)getppid());

}


Fork Example: Fanvoid main(void){ int i; pid_t childpid; for (i = 0; i < 6; i++)

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

} fprintf(stderr,

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


Win32 API Process Management

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

Not all functions result in system calls.

CreateProcess() – Create a new process (fork+execve)

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

» Can wait for many other events

There is no separation into fork and execv in Win32 No Parent-Child relationship.


event: an interrupt or a signal from another process

Process Life Cycle

new

ready running

terminated

waiting

admitted

interrupt/yield

scheduled

wait for eventeventoccurrence

exit, kill


OS maintains lists of processes.1. current process runs, until either

» an interrupt occurs, or» it makes a system call, or» it runs for too long (interrupt: timer expired)

2. OS gets control, handles the interrupt/syscall 3. OS places current process in appropriate list4. Dispatcher/scheduler (a part of the OS):

» chooses new “current process” from the ready list

» loads registers from PCB activates the process

Process Scheduling Basics

context switch


Schematic Scheduling


CPU scheduling by OS CPU scheduling decisions when a process:

1. Switches from running to waiting state. (syscall)2. Switches from running to ready state. (interrupt)3. Switches from waiting to ready. (interrupt)4. Terminates. (syscall)

Dispatcher: Module in OS to execute scheduling decisions. This is done by: » switching context» switching to user mode» jumping to the proper location in the user

program to restart that program


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: continuedWhat if arrival order is P2 , P3 , P1 ? Gantt chart:

Average waiting time: (6 + 0 + 3)/3 = 3Much 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 least 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.

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.

Performance» 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 in CPU scheduling Associate with each process the length of its next

CPU burst. Use these lengths to schedule the process with the shortest time.

Two alternatives: » 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. Aka Shortest-Remaining-Time-First (SRTF).

But: OS does not know length of next CPU burst!


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

=0n+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 SchedulingIdea: 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 PrioritiesExample: multilevel feedback


Dynamic Priorities: Unix Initially: base priority (kernel/user) While waiting: fixed Count running time (clock interrupts, PCB) Priority of a process is lowered if its CPU usage is high CPU counter is reduced by ½ every second User can lower priority by calling “nice”

2

)1()(

iCPUiCPU j

j

jj

jj niceiCPU

BaseiP

2

)1()(

Introduction to Systems Programming Lecture 2

Documents

Transcript of Introduction to Systems Programming Lecture 2