Transcript Operating Systems

Operating Systems: Intro
Operating Systems
• Concepts and Principles
– monolithic and micro kernels
– processes and threads
» their management and synchronisation
» interprocess communication
– interrupts and signals
– virtual memory - paging and segmentation
• Implementation Techniques
– resource allocation
– time management - process scheduling
– memory management - usage models and page allocation
– file systems
– case studies - Kops, Linux, NT etc.
1
Operating Systems: Intro
Coursework
• To Be Announced
– probably involving some programming
– deadline - mid-term
• Essay - in-depth comparison of PDA Operating Systems
– structure, scheduling, memory management, security etc.
– deadline - end of term
Tutorials only when needed
2
Operating Systems: Intro
Textbooks
• William Stallings, Operating Systems, Internals & Design Principles, 4th
edition, Prentice-Hall, 2001.
• Abraham Silberschatz & Peter Galvin, Operating System Concepts, 5th
edition, Addison-Wesley, 1998.
• Gary Nutt, Operating Systems, A Modern Perspective, 2nd edition,
Addison-Wesley, 2000.
• D.A.Solomon & M.E.Russinovitch, Inside Windows 2000, 3rd edition,
MicroSoft Press, 2000.
• D.Boling, Programming MicroSoft Windows CE, MicroSoft Press, 1998.
• Michael Beck et al., Linux Kernel Internals, 2nd edition, Addison-Wesley,
1997.
• John O’Gorman, Operating Systems with Linux, Palgrave, 2001.
3
Operating Systems: Intro
Motivation
• An Automated Teller Machine (ATM) process
– process to deposit an amount into an account:
deposit (account, amount) {
read ( account, balance );
// read balance from database
balance = balance + amount;
// add deposit amount
write (account, balance );
// update database
}
– process to withdraw an amount from an account:
withdraw ( account, amount ) {
read (account, balance);
// read balance from database
balance = balance - amount;
// subtract withdrawal amount
write ( account, balance);
// update database
}
– concurrent processes?
4
Operating Systems: Intro
• To sum the elements of a matrix
– in row order:
sum = 0;
for (row=0; row<row_max; row++) {
for (col=0; col<col_max; col++) {
sum = sum + array[row,col];
}}
cout << “Array Sum =“ << sum << endl;
– in column order:
sum = 0;
for (col=0; col<cp;_max; col++) {
for (row=0; row<row_max; row++) {
sum = sum + array[row,col];
}}
cout << “Array Sum =“ << sum << endl;
– any difference?
5
Operating Systems: Intro
Operating Systems
• Main purpose is to facilitate the execution of user application programs
– bare hardware is extremely messy and difficult for users to program
» processors
» memory
» peripheral devices
» concurrency
» interrupts
» files
» networks
6
Operating Systems: Intro
• Modern operating systems structured around concept of a process
process = “program in execution”
– a process is not the same as a program
– programs are passive, processes are active
– a process consists of an executable program, associated data and its
execution context
• A process runs in a framework which provides a Virtual Machine for it
– a Virtual Machine is a simplified machine with:
» user-level processor
» virtual memory
» high-level facilities
» a machine with one user
7
Operating Systems: Intro
• An OS supports execution of many concurrent processes
– many co-existing virtual machines
– each run alternately - pseudo-concurrently
– OS issues revolve around process management
» how and when to create & destroy processes
» how to avoid interference between processes
» how to achieve cooperation between processes
8
Operating Systems: Intro
• An OS manages resource requirements of processes
– time
– memory
– files
– I/O device access
– processors
• An OS aims to be efficient
– for user
– for system manager
9
Operating Systems: Intro
• A process can be in one of several states
– newly created
– running
– blocked
» waiting for some event to occur
» in main memory
» moved out to disc
– ready to run
– terminated
10
Operating Systems: Intro
• Overheads in swapping execution between processes
– saving and restoring contexts
– loss of cache contents
• Places limits on how often execution should be swapped
– performance will plummet if too frequent
11
Operating Systems: Intro
• A relatively new mechanism to improve overheads is the Thread
– a lightweight process
– several threads within one process or virtual machine
– much smaller context to preserve
– must cooperate
– must not compete
– can be separately scheduled
– can run concurrently on multiprocessor systems
– often also a very convenient programming paradigm
12
Operating Systems: Intro
Interfaces
user
user
user
user
user
application application application application application
process
process
process
process
process
Operating System
Hardware
13
Operating Systems: Intro
• Communications between OS and processes
– from process to OS - system calls
– from OS to process - signals
14
Operating Systems: Intro
• Communications between OS and Hardware
– from OS to hardware - register & status settings
– from hardware to OS - interrupts and exceptions
15
Operating Systems: Intro
• Communications between processes
– signals
– message passing
– via buffers
– shared virtual memory
– pipes
– sockets
• Communications between users and processes
– keyboard, mouse, touch-screen
– bit-mapped text and graphics display screens with windows
– printers, plotters
16
Operating Systems: Intro
Interrupts
• An interruption in the normal execution flow of a processor
– a mechanism for causing the processor to suspend its current computation
and take up some new task
» old context must be preserved
» control can be returned to the original task at some later time
» new context started
• Reasons:
– control of asynchronous I/O devices
– exceptional conditions arising from execution
17
Operating Systems: Intro
• OS sets up an Interrupt Vector with service routine entry points
– one entry per I/O device or I/O channel
– a dormant context set up for each routine which can be activated on demand
– further interrupts usually switched off during initial interrupt servicing
• Example: Intel x86 interrupt vector entries:
0:
...
14:
32:
33:
...
36:
37:
38:
...
46:
divide error
page fault
timer
keyboard
serial port 1
parallel port 2
floppy controller
hard disc
18
Operating Systems: Intro
• An OS can be viewed as an event-driven system
– just reacts to events as they occur
• Interrupts need to be serviced carefully and quickly by the OS
– cost similar to a process switch
– too many interrupts will kill performance
• Alternative to interrupts is Polling
– process (or OS) continually polls I.e. inspects, device status registers
awaiting some condition e.g. transfer completed
– wastes time looping until condition occurs
– much simpler to program than using interrupts but inefficient
19
Operating Systems: Intro
Privilege
• Processors run at various levels of privilege
– user-level
» only the types of instruction needed by applications programs
» only access to permitted areas of virtual memory
– supervisor or kernel level
» all types of instruction including I/O instructions
» access to system registers
- virtual memory registers
- interrupt vectors
» access to all areas of virtual memory
» ability to switch interrupts on and off
– may be intermediate levels on some architectures
– each level may have its own processor registers to speed context switching
20
Operating Systems: Intro
What’s part of an Operating System?
• Process management
• Interrupt handling
• Device drivers
• File system
• Networking
• Applications?
– Web browser?
– Email?
• Windows?
• Command interpreters?
21
Operating Systems: Intro
Kinds of Operating System
• For single-user workstation
• For multiple-user server
– file,compute, mail, web servers etc.
• For mainframe systems
– transaction processing
– database systems
• For real-time systems
– time-critical applications
» industrial process control
– hard rather than soft deadlines
22
Operating Systems: Intro
• All built with the same concurrent multi-process organisation
• Main difference is in process scheduling
– single user system needs only to meet one user’s expectations
» overall efficiency less important
– multiple user system needs to be equitable between users
» efficiency important
– transaction processing system needs to give good response
» database queries
– real-time system may need to pre-allocate processor time to guarantee
meeting deadlines
» overall efficiency may need to suffer
23
Operating Systems: Intro
• Only exception to multiple-process organisation is embedded systems
– dedicated single-purpose processors
» multi-media, telecoms
- MPEG decoders, GSM phones, portable web browsers
- washing machine controllers!
» avionics
- FADECs, GPS, FMS
– absolute reliability required
– very conservatively programmed
• System Level Integrated circuits
– usually have a processing core which requires a real-time OS
– often multiprocessors with a general-purpose CPU plus a DSP processor
» ARM + OAK
24
Operating Systems: Intro
Operating System Structure
• How to partition OS functions?
– process management and scheduling, memory management, interrupt
handling, device drivers etc.
• Monolithic OS
– each function coded as a separate procedure
– linked into one executable code object
– event-driven core which calls appropriate procedures when required
» driven by interrupts and system calls from processes
– Linux
» modules can be dynamically linked and unlinked as required
25
Operating Systems: Intro
• Micro-kernel OS
– each function coded as a separate process
» system processes
– only the minimum possible function in the core kernel
» virtual memory organising
» interrupt handling
» process dispatching
– appropriate system process activated as soon as possible to deal with all
other functions
» system processes will have higher privilege and usually higher priority than
user processes
– Windows NT
• Intermediate flavours
– some system processes but not a minimal micro-kernel
26
Operating Systems: Intro
Windows NT Structure
Hardware
27
Operating Systems: Intro
• Advantages and disadvantages
– monolithic:
» faster switching to kernel functions
» simple interfaces between functions i.e. procedure calls
» easier access to data structures shared between functions
» larger memory resident core
» may become too large to maintain easily
– micro-kernel
» better partitioning - should be easier to implement and maintain
» smaller memory resident core
» slower switching to system processes
» inter-system-process communications may be slower
28