Forking & Process Scheduling
Vivek Pai / Kai Li
Princeton University
Mechanics
Exams not graded
– Hopefully, this week
– Quick scan looked fine
Printed slides don’t exactly match
– Notebook problems, time limited
Finish forking, start scheduling
2
A Quick Review
What have we covered
– How to store data via files
– How to virtualize memory
• Every process gets uniform address space
• Lots of tricks can be played to share memory
What’s left
– How to share/virtualize the processor
– Having processes communicate/cooperate
3
Who’s Happy Right Now
4
How To Launch a New Process?
 Obvious choice: “start process” system call
 But not all processes start the same
– “testprogram” versus “testprogram >& outfile” versus
“testprogram arg1 arg2 >& outfile”
 The “parent” process wants to specify various
aspects of the child’s “environment”
– Next step: add more parameters to specify
environment
5
Can We Generalize?
 What happens as more information gets added to
the process’s “environment” – more parameters?
New system calls? This gets ugly
 What’s the most general way of setting up all of
the environment?
 So, why not allow process setup at any point?
– This is the exec( ) system call (and its variants)
6
But We Want a Parent and a
Child
 The exec call “destroys” the current process
 So, instead, destroy a copy of the process
– The fork( ) call duplicates the current process
– Better yet, don’t tightly couple fork and exec
• This way, you can customize the child’s environment
 So what does fork( ) entail?
– Making a copy of everything about the process
– Ouch!
7
What Gets Copied
 So far, we’ve covered the following:
– VM system
– File system
– Signals
 How do we go about copying this information?
 What parts are easy to copy, and what’s hard?
 What’s the common case with fork/exec?
– What needs to get preserved in this scenario?
8
Shared Memory
 How to destroy a virtual
address space?
w
– Link all PTEs
– Reference count
.
.
.
 How to swap out/in?
Process 1
..
.
Page table
– Link all PTEs
– Operation on all entries
w
 How to pin/unpin?
– Link all PTEs
– Reference count
.
.
.
..
.
.
.
.
Physical
pages
Page table
Process 2
9
Copy-On-Write
 Child’s virtual address




space uses the same page
mapping as parent’s
.
.
Make all pages read-only
.
Make child process ready
Parent process
On a read, nothing
happens
On a write, generates an
access fault
.
– map to a new page frame
.
– copy the page over
.
– restart the instruction
r
r
..
.
Page table
r
r
..
.
.
.
.
Physical
pages
Page table
Child process
10
Issues of Copy-On-Write
How to destroy an address space
– Same as shared memory case?
How to swap in/out?
– Same as shared memory
How to pin/unpin
– Same as shared memory
11
Process Creation & Termination
Four primitives:
 Fork – create a copy of this process
 Exec – replace this process with this program
 Wait – wait for child process to finish
 Kill – (potentially) end a running process
Processes form a tree – what happens when parent
disappears?
12
Signals
Asynchronous event delivery
mechanism
Examples – FPE, segv, ctrlc, hang up, resume
Default actions – ignore,
abort, core dump
Handler – programspecified routine for signal
13
A Signaling Sidebar
 What’s wrong with this program:
int randVal;
void SigHand(void)
{
printf(“your rand val is %d\n”, randVal);
}
int main(int argc, char *argv[])
{
set up ctrl-c handler;
while (1) {
randVal = 0;
randVal = 1;
…
randVal = 9;
}
}
14
Scheduling Primitives
 Block – wait on some event/resource
– Network packet arrival
– Keyboard, mouse input
– Disk activity completion
 Yield – give up running for now
– Directed (let my friend run)
– Undirected (let any process run)
 Synchronization
– We will talk about this later
15
Our Friend, The Transition Diagram
terminate
Running
Create
a process
Ready
Blocked
Resource becomes
available
16
Process State Transition of
Non-Preemptive Scheduling
Terminate
(call scheduler)
Scheduler
dispatch
Create
a process
Running
Block for resource
(call scheduler)
Yield
(call scheduler)
Ready
Blocked
Resource becomes available
(move to ready queue)
17
Scheduler
 A non-preemptive scheduler invoked by
explicit block or yield calls
 The simplest form
Scheduler:
save current process state (into PCB)
choose next process to run
dispatch (load PCB and run)
 Does this work?
More on Scheduler
 Should the scheduler use a special stack?
– Yes, because a user process can overflow and it would
require another stack to deal with stack overflow
 Should the scheduler simply be a kernel process?
– You can view it that way because it has a stack, code
and its data structure
– This process always runs when there is no user
process
Where Should PCB Be Saved?
 Save the PCB on its user stack
– Many processors have a special instruction to do it
efficiently
– But, need to deal with the overflow problem
– When the process terminates, the PCB vanishes
 Save the PCB on the kernel heap data structure
– May not be as efficient as saving it on stack
– But, it is very flexible and no other problems
20
Physical Memory &
Multiprogramming
Memory is a scarce resource
Want to run many programs
Programs need memory to run
What happens when
M(a) + M(b) + M(c) > physical mem?
21
Job Swapping
Swap in
Partially executed
swapped-out processes
Ready Queue
Swap out
CPU
Terminate
I/O
I/O Waiting
queues
22
Add Job Swapping to
State Transition Diagram
Swap out
Swap
Scheduler
dispatch
Swap in
Create
a process
Terminate
(call scheduler)
Running
Block for resource
(call scheduler)
Yield
(call scheduler)
Ready
Blocked
Resource becomes available
(move to ready queue)
23
Think About Swapping
Is swapping
 Necessary
 Desirable
 Good
 Ideal
Things to consider
 Performance
 Complexity
 Efficiency
24