cs 325 principles of operating systems

1

Slide 02a-1CS 325, New Mexico Tech

CS 325 Principles of Operating Systems

Dr. Xiao QinNew Mexico Tech

http://www.cs.nmt.edu/[email protected]

Spring, 2007

These slides are adapted from notes by Dr. Gary Nutt (University of Colorado at Boulder)


Review: The OS as a Conductor

The OS coordinates the sharing and use of all the components in the computer

2


Today’s Goal:

1. Multiprogramming

2. Operating Systems Strategies


Multiprogramming

…

AbstractMachine Pi

OS Resource Sharing

Pi MemoryPi Memory

Pk MemoryPk Memory

Pj MemoryPj Memory

…Time-multiplexed Physical Processor

AbstractMachine Pj

AbstractMachine Pk

Space-multiplexed Physical Memory

3


Multiprogramming(2)• Technique for sharing the CPU among

runnable processes– Process may be blocked on I/O– Process may be blocked waiting for other

resource, including the CPU• While one process is blocked, another might

be able to run• Multiprogramming OS accomplishes CPU

sharing “automatically” – scheduling• Reduces time to run all processes


How Multiprogramming Works

Process 1

Process 2

Process 3

Process 4

Space-multiplexed Memory

Time-multiplexed CPU

4


Speeding Up the Car Wash

VacuumInside Wash Dry

VacuumInside

Wash Dry

(a) The Sequential Car Wash

(b) The Parallel Car Wash

Think about pipelining, if you have taken CS331.


Forms of ParallelismProcess-level

–How do we exploit it? What are the challenges?–Examples? CS325 OS

• Thread-level–How do we exploit it? What are the challenges?–Examples?

• Loop-level –What is really loop level parallelism? What percentage of a program’s time is spent inside loops?–CS423 Compilers

• Instruction-level–CS331 Computer Architectures

Coarse grain

Fine Grain

Hum

an in

terv

enti

on?

5


Multiprogramming PerformanceTime

Using the processorI/O operation

0 ti

Pi’s Total Execution Time, ti

(a) Pi’s Use of Machine Resources

Time

P1

P2

Pi

PN

…

…

(a) All Processes’ Use of Machine Resources


OS Strategies

• Batch processing• Timesharing• Personal computer & workstations• Process control & real-time• Network• Distributed• Small computers

6


Batch Processing

Job 19

Input Spooler Output Spooler

Job 3

Input Spool Output Spool


IBM System/360

Source: http://en.wikipedia.org

7


Batch Processing(2)

• Job (file of OS commands) prepared offline• Batch of jobs given to OS at one time• OS processes jobs one-after-the-other• No human-computer interaction• OS optimizes resource utilization (how?)• Batch processing (as an option) still used

today


A Shell Script Batch File

cc -g -c menu.ccc -g -o driver driver.c menu.odriver < test_data > test_outlpr -PthePrinter test_outtar cvf driver_test.tar menu.c driver.c test_data test_outuuencode driver_test.tar driver_test.tar >driver_test.encode

8


Timesharing Systems

PhysicalMachine

AbstractMachines

…Command

Command

Command

Result

Result

Result

1982 A Televideo ASCII character mode terminal made around

A HP T5700 thin client, with flash memory


Timesharing Systems(2)

• Uses multiprogramming• Support interactive computing model

(Illusion of multiple consoles)• Different scheduling & memory allocation

strategies than batch• Considerable attention to resource isolation

(security & protection)• Tend to optimize response time• Tends to propagate processes

9


Personal Computers

• CPU sharing among one person’s processes• Power of computing for personal tasks

– Graphics– Multimedia

• Trend toward very small OS• OS focus on resource abstraction• Rapidly evolved to “personal multitasking”

systems


Process Control & Real-Time

• Computer is dedicated to a single purpose• Classic embedded systems• Must respond to external stimuli in fixed

time• Continuous media popularizing real-time

techniques• An area of growing interest

10


Networks

• LAN (Local Area Network) evolution• 3Mbps (1975) → 10 Mbps (1980) → 100 Mbps

(1990) → 1 Gbps (2000)• High speed communication means new way to do

computing– Shared files– Shared memory– Shared procedures/objects– ???


Distributed OS

• Wave of the future

Distributed OS

App App

App

App

AppApp

Multiple Computers connected by a Network

11


Small Computers

• PDAs, STBs, embedded systems became commercially significant

• Have an OS, but– Not general purpose– Limited hardware resources– Different kinds of devices

• Touch screen, no keyboard• Graffiti

– Evolving & leading to new class of Oses

• PalmOS, Pocket PC (WinCE), VxWorks, …


Evolution of Modern OS

Modern OS

Batch

Timesharing

PC & WkstationNetwork OS

Real-TimeMemory Mgmt

ProtectionScheduling

FilesDevices

Memory Mgmt

ProtectionScheduling

System software

Human-ComputerInterface

Client-Server Model

Protocols

Scheduling

Small ComputerNetwork storage,Resource management

12


Examples of Modern OS

• UNIX variants (e.g. Linux) -- have evolved since 1970

• Windows NT/2K -- has evolved since 1989 (much more modern than UNIX– Win2K = WinNT, V5

• Research OSes – still evolving …• Small computer OSes – still evolving …• Book provides Linux examples• This course will use Windows NT as the

main example


The Microsoft OS FamilyWin32 APIWin32 API

Windows CE(Pocket PC)

Windows CE(Pocket PC)

Windows 95/98/MeWindows 95/98/Me

Windows NT/2000/XPWindows NT/2000/XP

Win32 API SubsetWin32 API Subset

Win32 API SubSetWin32 API SubSet

13


Microsoft Windows NT

• Heavily window-oriented• Foundation behavior is windows-

independent– We will focus on the foundation– Use only the “MS-DOS prompt” -- cmd.exe

OS API

NT Kernel

NT User Interfaceand Graphics

NT Executive


Windows NT (cont)

• OS API has text orientation (like UNIX)• Object-oriented implementation• Heavy use of threads• Broad spectrum of synchronization tools• Modern I/O system

14


Windows CE Organization

Kernel

OEM Abstraction Layer

Win32 API (& Network Extensions)

Graphics,Window Mgr,

andEvent Mgr

Device Drivers

ObjectStore

Networkand

CommServices

Shells and Applications


Using the Operating System

2

15


The Airplane Pilot’s Abstract Machine


Basic Abstractions

ProgramProgram ResultResult

AbstractMachine

AbstractMachine



AbstractMachine

PhysicalMachine

… …Idea

Idea

Idea

16


Abstract Machine Entities

• Process: A sequential program in execution• Resource: Any abstract resource that a

process can request, and which may can cause the process to be blocked if the resource is unavailable.

• File: A special case of a resource. A linearly-addressed sequence of bytes. “A byte stream.”


Algorithms, Programs, and Processes

Data

FilesFilesFiles

OtherResources

AlgorithmAlgorithm

Idea

SourceProgramSource

ProgramBinary

Program

Execution Engine

Process

StackStatus

17


Classic Process

• OS implements {abstract machine} – one per task

• Multiprogramming enables N programs to be space-muxed in executable memory, and time-muxed across the physical machine processor.

• Result: Have an environment in which there can be multiple programs in execution concurrently*, each as a processes

* Concurrently: Programs appear to execute simultaneously


Process Abstraction

Hardware

DataDataProcessProcess

Stac

k

Processor

ExecutableMemory

ProgramProgram

Operating SystemOperating System

18


Processes Sharing a Program

Shared Program Text

P1

P2

P3

P1 P2 P3

FilesFiles

FilesFiles

FilesFiles


Multithreaded Accountant

Purchase Orders

Invoice

Invoice

(a) Separate Processes

Purchase Orders

InvoiceFirst Accountant

Second Accountant

Accountant & Clone

(b) Double Threaded Process

19


Modern Process & Thread• Divide classic process:

– Process is an infrastructure in which execution takes place – address space + resources

– Thread is a program in execution within a process context – each thread has its own stack

DataDataProcessProcess

Stac

k

ProgramProgram

Operating SystemOperating System

ThreadThread

Thread

Stac

k

…

Stac

k


A Process with Multiple Threads

Data

FilesFilesFiles

OtherResources

BinaryProgram

Process

StackStatus

StackStatus

StackStatus

Thread (Execution Engine)

20


More on Processes• Abstraction of processor resource

– Programmer sees an abstract machine environment with spectrum of resources and a set of resource addresses (most of the addresses are memory addresses)

– User perspective is that its program is the only one in execution– OS perspective is that it runs one program with its resources for a

while, then switches to a different process (context switching)

• OS maintains– A process descriptor data structure to implement the process

abstraction• Identity, owner, things it owns/accesses, etc.• Tangible element of a process

– Resource descriptors for each resource


Address Space• Process must be able to reference every

resource in its abstract machine• Assign each unit of resource an address

– Most addresses are for memory locations– Abstract device registers– Mechanisms to manipulate resources

• Addresses used by one process are inaccessible to other processes

• Say that each process has its own address space

21


Shared Address Space

• Classic processes sharing program ⇒ shared address space support

• Thread model simplifies the problem– All threads in a process implicitly use that process’s

address space , but no “unrelated threads” have access to the address space

– Now trivial for threads to share a program and data• If you want sharing, encode your work as threads in a process• If you do not want sharing, place threads in separate processes


Process & Address Space

Address Space

Code ResourcesResources

Abstract Machine Environment

Stack

DataResources

22


Creating a Process

• Here is the classic model for creating processes:

FORK(label): Create another process in the same addressspace beginning execution at instruction labelQUIT(): Terminate the process.JOIN(count):

disableInterrupts();count--;if(count > 0) QUIT();enableInterrupts();


Example

procA() {while(TRUE) {<compute section A1>;update(x);<compute section A2>;retrieve(y);

}}

procB() {while(TRUE) {retrieve(x);<compute section B1>;update(y);<compute section B2>;

}}

Process AProcess A Process BProcess Bx

y

23


Example (cont)

L0: count = 2;<compute section A1>;update(x);FORK(L2);<compute section A2>;

L1: JOIN(count);retrieve(y);goto L0;

L2: retrieve(x);<compute section B1>;update(y);FORK(L3);goto L1;

L3: <compute section B2>QUIT();

cs 325 principles of operating systems

Documents