Skip to main content
Link
Menu
Expand
(external link)
Document
Search
Copy
Copied
Search cs492-stevens
Lectures
Lecture 10 Annotated
10 - Processes (3)
Outline
Process Termination
Kernel Data Structures
Process Switching (again)
Modeling Multiprogramming
Announcements
Reading: MOS 2.1
Process Termination
Processes can terminate in 2 ways:
Killing Processes
UNIX: Child processes do not die with parent.
Process Control Block (PCB)
Typical PCB fields:
We'll take a look at Linux PCB in the next lecture
In short:
Timing:
A little bit of math to calculate CPU utilization.
CPU utilization information helps business make
decisions about how many machines to purchase,
quality of service, etc.
Big assumptions:
How to increase utilization?
Oversimplified Example:
Remember:
Process Table
Huge struct that holds all information about a
process
Array of PCBs maintained in kernel memory
kernel called (interrupt or syscall)
PIDs are indices into process table
kernel saves state to PCB
kernel handles interrupt/does syscall
scheduler runs and selects process
kernel restores selected process from PCB
Kernel switching should be as fast as possible!
Single-core CPU
Run more processes (increase n)
All processes identical characteristics
Minimize I/O-bound tasks in program
hardware support is necessary to save
the program counter.
Multiple cores => less process switching
aka. "Process Table Entry"
Aside:
Modeling Multiprogramming
Kernel Data Structures
Process Switching
Working on autograder still, sit tight.
Planning to release PA3 late next week.
1)
2)
3)
4)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
>
>
>
>
Voluntary: using exit syscall
Child processes must be killed separately
(or via process groups)
Orphan processes are adopted by init
Involuntary: signals using kill syscall
Windows has some equivalent syscalls.
Signals are integer codes that are delivered to a process by the
kernel for basic inter-process communication.
Process can register handlers for some of these, but most
automatically kill the process.
- Kernel should run for microseconds, user process for milliseconds.
- Maximize the amount of useful work (kernel only manages).
- Kernel fast enough that people don't notice delays
User program calls exit to voluntarily terminate execution.
Normal exit (status code zero)
(return 0 from main automatically calls exit)
Fatal errors (e.g. segfault, invalid instruction) cause trap to
kernel, kernel sends signal that kills process
Requires ownership by same user, or admin privileges
Kernel sends signal
Error exit (status code non-zero)
Process sends signal
man signal
UNIX-based:
Zombie process is a dead child that hasn't
been acknowledged by parent.
(parent must call wait() to receive status)
see MOS Figure 2-4
Process Management
Memory Management
File Management
- Registers
- Program Counter
- Stack pointer
- Program status word
- Process state
- Priority
- Scheduling params
- Process ID
- Parent process
- Process group
- Signals
- Start time
- CPU time
- Child CPU time
- Next alarm
Segment info pointers:
- Text info pointer
- Data info pointer
- Stack info pointer
- Root directory
- Working directory
- File descriptors
- User ID
- Group ID
save state to PCB 0
save state to PCB 1
load state from PCB 1
load state from PCB 0
P0
Kernel
P1
handle interrupt/
do syscall;
scheduler runs
handle interrupt/
do syscall;
scheduler runs
interrupt
or syscall
interrupt
or syscall
running
running
running
ready
ready
ready or blocked
ready or blocked
CPU Utilization:
% CPU time spent doing useful
work.
probability that a process is waiting on
I/O at any give point in time
degree of multiprogramming (number of user
processes simultaneously alive)
- OS requires 128 MB memory
- Processes also require 128 MB memory
- Processes have 80% I/O wait time
- 512 MB RAM => 3 processes => 48.8%
- 1024 MB RAM => 7 processes => 79.0%
- 2048 MB RAM => 15 processes => 96.5%
- 4096 MB RAM => ...
For a machine with:
- Machine has 4 GB RAM
- OS requires 512 MB memory
- Identical processes require 256 MB memory
- Target: 99% CPU utilization
What is the maximum tolerable I/O wait time
for a process?
approximated as measured percent of time waiting on I/O
in practice, a lot of statistics need to be collected to get
a good estimate of p and n
this hurts performance of individual processes -> QoS issue
fundamental limitations based on the nature of the process
approximated from probability that the CPU is doing useful work
at any given point in time.
MOS Figure 2-6
p
PollEv
Exercise
n
assume:
- processes act the same
- single core cpu
exit(status)
wait(&status)
return value