Chapter 2: Processes & Threads
Chapter 2
Processes and threads
Processes
Threads
Scheduling
Interprocess communication
Classical IPC problems
CS 1550, cs.pitt.edu (origin 2
aly modified by Ethan L. Mil Chapter 2
What is a process?
Code, data, and stack
Usually (but not always) has its own address space
Program state
CPU registers
Program counter (current location in the code)
Stack pointer
Only one process can be running in the CPU at any
given time!
CS 1550, cs.pitt.edu (origin 3
aly modified by Ethan L. Mil Chapter 2
The process model
Single PC Multiple PCs Multiprogramming of four
(CPU’s point of view) (process point of view) programs
Conceptual model
A 4 independent processes
B A D Processes run sequentially
C
B Only one program active at any
C instant!
B That instant can be very short…
D
D
C
B
A
Time
CS 1550, cs.pitt.edu (origin 4
aly modified by Ethan L. Mil Chapter 2
When is a process created?
Processes can be created in two ways
System initialization: one or more processes created when
the OS starts up
Execution of a process creation system call: something
explicitly asks for a new process
System calls can come from
User request to create a new process (system call executed
from user shell)
Already running processes
User programs
System daemons
CS 1550, cs.pitt.edu (origin 5
aly modified by Ethan L. Mil Chapter 2
When do processes end?
Conditions that terminate processes can be
Voluntary
Involuntary
Voluntary
Normal exit
Error exit
Involuntary
Fatal error (only sort of involuntary)
Killed by another process
CS 1550, cs.pitt.edu (origin 6
aly modified by Ethan L. Mil Chapter 2
Process hierarchies
Parent creates a child process
Child processes can create their own children
Forms a hierarchy
UNIX calls this a “process group”
If a process exits, its children are “inherited” by the
exiting process’s parent
Windows has no concept of process hierarchy
All processes are created equal
CS 1550, cs.pitt.edu (origin 7
aly modified by Ethan L. Mil Chapter 2
Process states
Process in one of 5 states
Created Created
Ready
1 Running
Blocked
Ready Exit
2 Transitions between states
5 1 - Process enters ready queue
3 2 - Scheduler picks this process
Blocked 3 - Scheduler picks a different
Running
(waiting) process
4 4 - Process waits for event (such as
I/O)
5 - Event occurs
7 6 - Process exits
6 7 - Process ended by another
7
process
Exit
CS 1550, cs.pitt.edu (origin 8
aly modified by Ethan L. Mil Chapter 2
Processes in the OS
Two “layers” for processes
Lowest layer of process-structured OS handles interrupts,
scheduling
Above that layer are sequential processes
Processes tracked in the process table
Each process has a process table entry
Processes
0 1 … N-2 N-1
Scheduler
CS 1550, cs.pitt.edu (origin 9
aly modified by Ethan L. Mil Chapter 2
What’s in a process table entry?
Process management File management
May be Registers Root directory
stored Program counter Working (current) directory
on stack CPU status word File descriptors
Stack pointer User ID
Process state Group ID
Priority / scheduling parameters
Process ID
Parent process ID
Memory management
Signals
Pointers to text, data, stack
Process start time
or
Total CPU usage
Pointer to page table
CS 1550, cs.pitt.edu (origin 10
aly modified by Ethan L. Mil Chapter 2
What happens on a trap/interrupt?
1. Hardware saves program counter (on stack or in a
special register)
2. Hardware loads new PC, identifies interrupt
3. Assembly language routine saves registers
4. Assembly language routine sets up stack
5. Assembly language calls C to run service routine
6. Service routine calls scheduler
7. Scheduler selects a process to run next (might be
the one interrupted…)
8. Assembly language routine loads PC & registers
for the selected process
CS 1550, cs.pitt.edu (origin 11
aly modified by Ethan L. Mil Chapter 2
Threads: “processes” sharing memory
Process == address space
Thread == program counter / stream of instructions
Two examples
Three processes, each with one thread
One process with three threads
Process 1 Process 2 Process 3 Process 1
User
space
Threads Threads
System Kernel Kernel
space
CS 1550, cs.pitt.edu (origin 12
aly modified by Ethan L. Mil Chapter 2
Process & thread information
Per process items
Address space
Open files
Child processes
Signals & handlers
Accounting info
Global variables
Per thread items Per thread items Per thread items
Program counter Program counter Program counter
Registers Registers Registers
Stack & stack pointer Stack & stack pointer Stack & stack pointer
State State State
CS 1550, cs.pitt.edu (origin 13
aly modified by Ethan L. Mil Chapter 2
Threads & Stacks
Thread 1 Thread 2 Thread 3
User space
Process
Thread 1’s
stack
Thread 3’s
stack
Thread 2’s
stack
Kernel
=> Each thread has its own stack!
CS 1550, cs.pitt.edu (origin 14
aly modified by Ethan L. Mil Chapter 2
Why use threads?
Allow a single application When in the Course of human events, it
becomes necessary for one people to
dissolve the political bands which have
We hold these truths to be self-evident,
that all men are created equal, that they
are endowed by their Creator with
destructive of these ends, it is the Right
of the People to alter or to abolish it,
and to institute new Government,
to do many things at once connected them with another, and to
assume among the powers of the earth,
the separate and equal station to which
the Laws of Nature and of Nature's God
certain unalienable Rights, that among
these are Life, Liberty and the pursuit
of Happiness.--That to secure these
rights, Governments are instituted
laying its foundation on such principles
and organizing its powers in such form,
as to them shall seem most likely to
effect their Safety and Happiness.
Simpler programming model
entitle them, a decent respect to the among Men, deriving their just powers Prudence, indeed, will dictate that
opinions of mankind requires that they
should declare the causes which impel
from the consent of the governed, --
That whenever any Form of
Governments long established should
not be changed for light and transient
them to the separation. Government becomes causes; and accordingly all
Less waiting
Threads are faster to create
or destroy
No separate address space
Overlap computation and
I/O
Could be done without
threads, but it’s harder
Kernel
Example: word processor
Thread to read from keyboard
Thread to format document
Thread to write to disk
CS 1550, cs.pitt.edu (origin 15
aly modified by Ethan L. Mil Chapter 2
Multithreaded Web server
Dispatcher while(TRUE) {
thread getNextRequest(&buf);
Worker handoffWork(&buf);
thread }
while(TRUE) {
waitForWork(&buf);
lookForPageInCache(&buf,&page);
if(pageNotInCache(&page)) {
Kernel
readPageFromDisk(&buf,&page);
Web page }
cache returnPage(&page);
Network
connection }
CS 1550, cs.pitt.edu (origin 16
aly modified by Ethan L. Mil Chapter 2
Three ways to build a server
Thread model
Parallelism
Blocking system calls
Single-threaded process: slow, but easier to do
No parallelism
Blocking system calls
Finite-state machine
Each activity has its own state
States change when system calls complete or interrupts
occur
Parallelism
Nonblocking system calls
Interrupts
CS 1550, cs.pitt.edu (origin 17
aly modified by Ethan L. Mil Chapter 2
Implementing threads
Process
Thread
Kernel Kernel
Run-time Thread Process Process Thread
system table table table table
User-level threads Kernel-level threads
+ No need for kernel support + More flexible scheduling
- May be slower than kernel threads + Non-blocking I/O
- Harder to do non-blocking I/O - Not portable
CS 1550, cs.pitt.edu (origin 18
aly modified by Ethan L. Mil Chapter 2
Scheduling
What is scheduling?
Goals
Mechanisms
Scheduling on batch systems
Scheduling on interactive systems
Other kinds of scheduling
Real-time scheduling
CS 1550, cs.pitt.edu (origin 19
aly modified by Ethan L. Mil Chapter 2
Why schedule processes?
Bursts of CPU usage alternate with periods of I/O wait
Some processes are CPU-bound: they don’t make many I/O
requests
Other processes are I/O-bound and make many kernel
requests
Total CPU usage
CPU bound
CPU bursts I/O waits
I/O bound
Total CPU usage
Time
CS 1550, cs.pitt.edu (origin 20
aly modified by Ethan L. Mil Chapter 2
When are processes scheduled?
At the time they enter the system
Common in batch systems
Two types of batch scheduling
Submission of a new job causes the scheduler to run
Scheduling only done when a job voluntarily gives up the CPU
(i.e., while waiting for an I/O request)
At relatively fixed intervals (clock interrupts)
Necessary for interactive systems
May also be used for batch systems
Scheduling algorithms at each interrupt, and picks the next
process from the pool of “ready” processes
CS 1550, cs.pitt.edu (origin 21
aly modified by Ethan L. Mil Chapter 2
Scheduling goals
All systems
Fairness: give each process a fair share of the CPU
Enforcement: ensure that the stated policy is carried out
Balance: keep all parts of the system busy
Batch systems
Throughput: maximize jobs per unit time (hour)
Turnaround time: minimize time users wait for jobs
CPU utilization: keep the CPU as busy as possible
Interactive systems
Response time: respond quickly to users’ requests
Proportionality: meet users’ expectations
Real-time systems
Meet deadlines: missing deadlines is a system failure!
Predictability: same type of behavior for each time slice
CS 1550, cs.pitt.edu (origin 22
aly modified by Ethan L. Mil Chapter 2
Measuring scheduling performance
Throughput
Amount of work completed per second (minute, hour)
Higher throughput usually means better utilized system
Response time
Response time is time from when a command is submitted until
results are returned
Can measure average, variance, minimum, maximum, …
May be more useful to measure time spent waiting
Turnaround time
Like response time, but for batch jobs (response is the completion of
the process)
Usually not possible to optimize for all metrics with the same
scheduling algorithm
CS 1550, cs.pitt.edu (origin 23
aly modified by Ethan L. Mil Chapter 2
First Come, First Served (FCFS)
Goal: do jobs in the order
Current job queue
they arrive
4 3 6 3 Fair in the same way a bank
teller line is fair
A B C D Simple algorithm!
Problem: long jobs delay
FCFS scheduler
every job after them
Many processes may wait for
Execution order a single long job
4 3 6 3
A B C D
CS 1550, cs.pitt.edu (origin 24
aly modified by Ethan L. Mil Chapter 2
Shortest Job First (SJF)
Goal: do the shortest job
Current job queue first
4 3 6 3
Short jobs complete first
Long jobs delay every job
A B C D after them
Jobs sorted in increasing
SJF scheduler
order of execution time
Ordering of ties doesn’t
matter
Execution order Shortest Remaining Time
3 3 4 6 First (SRTF): preemptive
form of SJF
B D A C Problem: how does the
scheduler know how long a
job will take?
CS 1550, cs.pitt.edu (origin 25
aly modified by Ethan L. Mil Chapter 2
Three-level scheduling
CPU
CPU scheduler
Arriving
jobs
Main
memory
Input Admission Memory
queue scheduler scheduler
Jobs held in input queue until moved into memory
Pick “complementary jobs”: small & large, CPU- & I/O-intensive
Jobs move into memory when admitted
CPU scheduler picks next job to run
Memory scheduler picks some jobs from main memory and
moves them to disk if insufficient memory space
CS 1550, cs.pitt.edu (origin 26
aly modified by Ethan L. Mil Chapter 2
Round Robin (RR) scheduling
Round Robin scheduling
Give each process a fixed A B C D E
time slot (quantum)
Rotate through “ready”
processes
Each process makes some E
progress D
What’s a good quantum? C
Too short: many process B
switches hurt efficiency A
Too long: poor response to
interactive requests Time
Typical length: 10–50 ms
CS 1550, cs.pitt.edu (origin 27
aly modified by Ethan L. Mil Chapter 2
Priority scheduling
Assign a priority to each process High “Ready” processes
“Ready” process with highest
priority allowed to run Priority 4
Running process may be
interrupted after its quantum Priority 3
expires
Priority 2
Priorities may be assigned
dynamically Priority 1
Reduced when a process uses
CPU time Low
Increased when a process waits
for I/O
Often, processes grouped into
multiple queues based on
priority, and run round-robin per
queue
CS 1550, cs.pitt.edu (origin 28
aly modified by Ethan L. Mil Chapter 2
Shortest process next
Run the process that will finish the soonest
In interactive systems, job completion time is unknown!
Guess at completion time based on previous runs
Update estimate each time the job is run
Estimate is a combination of previous estimate and most
recent run time
Not often used because round robin with priority
works so well!
CS 1550, cs.pitt.edu (origin 29
aly modified by Ethan L. Mil Chapter 2
Lottery scheduling
Give processes “tickets” for CPU time
More tickets => higher share of CPU
Each quantum, pick a ticket at random
If there are n tickets, pick a number from 1 to n
Process holding the ticket gets to run for a quantum
Over the long run, each process gets the CPU m/n of
the time if the process has m of the n existing tickets
Tickets can be transferred
Cooperating processes can exchange tickets
Clients can transfer tickets to server so it can have a
higher priority
CS 1550, cs.pitt.edu (origin 30
aly modified by Ethan L. Mil Chapter 2
Policy versus mechanism
Separate what may be done from how it is done
Mechanism allows
Priorities to be assigned to processes
CPU to select processes with high priorities
Policy set by what priorities are assigned to processes
Scheduling algorithm parameterized
Mechanism in the kernel
Priorities assigned in the kernel or by users
Parameters may be set by user processes
Don’t allow a user process to take over the system!
Allow a user process to voluntarily lower its own priority
Allow a user process to assign priority to its threads
CS 1550, cs.pitt.edu (origin 31
aly modified by Ethan L. Mil Chapter 2
Scheduling user-level threads
Process A Process B
Kernel picks a process to
run next
Run-time system (at user
level) schedules threads
Run each thread for less than
process quantum
Example: processes get 40ms
each, threads get 10ms each
Kernel
Example schedule:
Run-time Thread Process A1,A2,A3,A1,B1,B3,B2,B3
system table table Not possible:
A1,A2,B1,B2,A3,B3,A2,B1
CS 1550, cs.pitt.edu (origin 32
aly modified by Ethan L. Mil Chapter 2
Scheduling kernel-level threads
Process A Process B
Kernel schedules each
thread
No restrictions on ordering
May be more difficult for
each process to specify
priorities
Example schedule:
A1,A2,A3,A1,B1,B3,B2,B3
Kernel Also possible:
Process A1,A2,B1,B2,A3,B3,A2,B1
Thread
table table
CS 1550, cs.pitt.edu (origin 33
aly modified by Ethan L. Mil Chapter 2
