History of Operating

Systems: Phases
A Short History of Phase 1: Hardware is expensive, humans are cheap

Operating Systems User at console: single-user systems

Batching systems
Multi-programming systems

Hand programmed Batch/Off-line processing

machines (1945-1955) (1955-1965)
Single user systems
Card Reader: Read Job 1 Job 2 Job 3 Sequential
OS = loader + libraries CPU: Execute Job 1 Job 2 Job 3

of common subroutines Printer: Print Job 1 Job 2 Job 3

Problem: low utilization of

expensive components Card Reader: Read Batch 1 Batch 2 Batch 3 Batching
CPU: Execute Batch 1 Batch 2 Batch 3
time device busy Printer: Print Batch 1 Batch 2 Batch 3
= % utilization
observation interval
 Batch Processing Multiprogramming
(1955-1965) (1965-1980)
Operating system = loader +
sequencer + output processor Keep several jobs in memory and multiplex CPU between jobs
program P
User Data begin
User Program n :
User Program Read(var)

...
:
Tape “System Software” Tape
end P
User Program 2
Operating System
User Program 1 system call Read()
Input Output begin

Card
Compute “System Software”
StartIO(input device)
WaitIO(interrupt)
Reader Tape EndIO(input device)
Operating System :
Printer end Read
Tape

Multiprogramming Multiprogramming
(1965-1980) (1965-1980)
Keep several jobs in memory and multiplex CPU between jobs Keep several jobs in memory and multiplex CPU between jobs
Program 1 OS I/O Device Program 1 OS Program 2 I/O Device
main{ main{
User Program n User Program n
read{ read{
...

...
k: read() k: read()

User Program 2 startIO() User Program 2 startIO()

schedule() main{
waitIO()
}
User Program 1 User Program 1
endio() endio{
interrupt interrupt
“System Software” “System Software” schedule()
k+1: k+1:
} }
Operating System Operating System
} }
History of Operating
Systems: Phases Timesharing (1970-)
Phase 1: Hardware is expensive, humans are cheap A timer interrupt is used to multiplex CPU between jobs
User at console: single-user systems
Program 1 OS Program 2
Batching systems
Multi-programming systems main{
User Program n timer
interrupt schedule(){
Phase 2: Hardware is cheap, humans are expensive k:

...
Time sharing: Users use cheap terminals and share servers main{
User Program 2 }

timer
User Program 1 interrupt
schedule(){
“System Software” k+1:
}
timer
interrupt
Operating System schedule(){

History of Operating Operating Systems for

Systems: Phases PCs
Personal computing systems
Phase 1: Hardware is expensive, humans are cheap
User at console: single-user systems Single user
Batching systems Utilization is no longer a concern
Multi-programming systems Emphasis is on user interface and
API
Phase 2: Hardware is cheap, humans are expensive
Time sharing: Users use cheap terminals and share servers Many services & features not
present
Phase 3: Hardware is very cheap, humans are very expensive
Personal computing: One system per user Evolution
Distributed computing: many systems per user Initially: OS as a simple service
Ubiquitous computing: LOTS of systems per users provider (simple libraries)
Now: Multi-application systems
with support for coordination
 Distributed Ubiquitous Computing
Operating Systems
Abstraction: present a multi-processor system appears as a single
processor one.
PDAs, cellular phones, sensors
New challenges in consistency, reliability, resource management,
performance, etc.
Challenges
Examples: SANs, Oracle Parallel Server
Small memory size
User User Slow processor
Program Program
OS Battery concerns
OS OS file system
name services Scale
process process management
management memory management mail services Security
Naming
CPU CPU CPU

LAN/WAN
Network
37

History of Operating Real time

Systems: Phases Operating System
Phase 1: Hardware is expensive, humans are cheap Goal: To cope with rigid time constraints
User at console: single-user systems Hard real time:
Batching systems OS guarantees that application will meet
deadline
Multi-programming systems
Examples: health monitors, factory control, traffic
collision avoidance systems (TCAS)
Phase 2: Hardware is cheap, humans are expensive
Time sharing: Users use cheap terminals and share servers Soft real time
OS provides prioritization, on a best effort basis
Phase 3: Hardware is very cheap, humans are very expensive
No critical failure if time constraint is violated
Personal computing: One system per user
Example: most electronic appliances
Distributed computing: many systems per user
Ubiquitous computing: LOTS of systems per user “Real time” means predictable NOT fast
Richer Services
Real-time operating systems
 Over the years
Not that batch systems were ridiculous
They were exactly right for the tradeoffs at the time

The tradeoffs change

1981 2006 Factor
MIPS 1 6570/CPU 1,000
$/MIPS $100000 $0.11 900,000
DRAM 128KB 2GB 8,000
Disk 10MB 250GB 25,000
Net Bandwidth 9600 b/s 100 Mb/s 10,000
# Users >> 10 <= 1 0.1
#CPU 1 4 4

Need to understand the fundamentals

So you can design better systems for tomorrow’s tradeoffs