Avishai Wool lecture 2 - 1

1
Introduction to Systems Programming Lecture 2

• Processes Scheduling

2
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

3
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

4
What does a process have?

• Resources
• Address space the RAM allocated to the program
• Program image machine instructions
• file handles, child processes, accounting info
• Thread of execution
• Instruction address (program counter)
• Registers and CPU state
• Stack of called procedures

5
Analogy Baking a Cake

• Baker
• Recipe instructions
• Ingredients (flour, sugar,)
• Cake
• Program ! Process

• CPU
• Program
• Input
• Output

6
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

7
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
• AltCtrlDel ? Task Manager

8
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...)

9
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

10
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

11
Process management in Unix and Windows
12
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).

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

14
Unix Process Management

• fork (return TWICE if successful)
• Create a copy of the current process
• Return 0 to the child process
• Return childs 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

15
Simple Example

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

Wait for any child to exit
Childs return value
16
Fork Example Chain

• include ltstdio.hgt
• void main(void)
• int i
• for (i 0 i lt 6 i)
• if (0 ! fork())
• break // parent exits the loop
• fprintf(stderr,
• Process ld Parent ld\n",
• (long)getpid(), (long)getppid())
  sleep(1)

17
Fork Example Fan

• include ltstdio.hgt
• void main(void)
• int i
• for (i 0 i lt 6 i)
• if (0 fork())
• break // child exits the loop
• fprintf(stderr,
• Process ld Parent ld\n",
• (long)getpid(), (long)getppid())
• sleep(1)

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

19
Win32 Process Management API

• CreateProcess() Create a new process
  (forkexec)
• ExitProcess() Terminate Execution
• WaitForSingleObject() Wait for termination
• Can wait for many other events
• There is no separation into fork and exec in
  Win32

20
Process scheduling
21
Process Scheduling Basics - 1

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

22
Process Scheduling Basics - 2

• 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

23
Schematic Scheduling
24
Process Life Cycle
new
terminated
scheduled
admitted
exit, kill
ready
running
interrupt/yield
event occurrence
wait for event
waiting
event an interrupt, or a signal (system call)
from another process
25
When does CPU scheduling occur?

• The OS makes a CPU scheduling decision when
• A process switches from running to ready state.
  (interrupt)
• A process switches from running to waiting state.
  (syscall)
• A process switches from waiting to ready.
  (interrupt)
• A process terminates. (syscall)

26
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

27
Scheduling Policies

• Whos turn is it now?

28
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., cant
  replace a flight crew in middle of flight.

29
Typical CPU burst distribution
30
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

31
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

32
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

33
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

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

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

36
Round Robin Example

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

37
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).

38
Estimating length of CPU burst

• Idea use length of previous CPU bursts
• Heuristic use exponential averaging (aging).

39
Exponential Averaging

• Expanding the formula, we get
• ?n1 ? 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
• ?n1 ?n ?0
• Recent history does not count.
• ? 1
• ?n1 tn
• Only the actual last CPU burst counts.

40
Exponential Averaging Example
?0.5
41
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
42
Example for Priorities
Static priorities can lead to starvation!
43
Dynamic Priorities

• Example multilevel feedback

44
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