Introduction

What is an Operating System?

A program that acts as an intermediary between a user of a computer

and the computer hardware

Operating system goals:

Execute user programs and make solving user problems easier
Make the computer system convenient to use
Use the computer hardware in an efficient manner
 Computer System Structure

Computer system can be divided into four components:

Hardware – provides basic computing resources
 CPU, memory, I/O devices
Operating system
 Controls and coordinates use of hardware among various
applications and users
Application programs – define the ways in which the system
resources are used to solve the computing problems of the
users
 Word processors, compilers, web browsers, database
systems, video games
Users
 People, machines, other computers
Four Components of a Computer System
 What Operating Systems Do
Depends on the point of view
Users want convenience, ease of use
Don’t care about resource utilization
But shared computer such as mainframe or minicomputer must keep all
users happy
Users of dedicate systems such as workstations have dedicated resources
but frequently use shared resources from servers
Handheld computers are resource poor, optimized for usability and battery
life
Some computers have little or no user interface, such as embedded
computers in devices and automobiles
 Operating System Definition

OS is a resource allocator
Manages all resources
Decides between conflicting requests for efficient and fair resource
use

OS is a control program
Controls execution of programs to prevent errors and improper use
of the computer
 Operating System Definition (Cont.)

No universally accepted definition

“Everything a vendor ships when you order an operating system” is

good approximation
But varies wildly

“The one program running at all times on the computer” is the

kernel. Everything else is either a system program (ships with the
operating system) or an application program.
 Computer Startup
bootstrap program is loaded at power-up or reboot
Typically stored in ROM or EPROM, generally known as firmware
Initializes all aspects of system
Loads operating system kernel and starts execution
 Computer System Organization
Computer-system operation
One or more CPUs, device controllers connect through common
bus providing access to shared memory
Concurrent execution of CPUs and devices competing for
memory cycles
 Computer-System Operation
I/O devices and the CPU can execute concurrently

Each device controller is in charge of a particular device type

Each device controller has a local buffer

CPU moves data from/to main memory to/from local buffers

I/O is from the device to local buffer of controller

Device controller informs CPU that it has finished its operation by

causing an interrupt
 Common Functions of Interrupts
Interrupt transfers control to the interrupt service routine generally,
through the interrupt vector, which contains the addresses of all the
service routines

Interrupt architecture must save the address of the interrupted

instruction

Incoming interrupts are disabled while another interrupt is being

processed to prevent a lost interrupt

A trap is a software-generated interrupt caused either by an error or a

user request

An operating system is interrupt driven

 Interrupt Handling
The operating system preserves the state of the CPU by storing
registers and the program counter

Determines which type of interrupt has occurred:

polling
vectored interrupt system

Separate segments of code determine what action should be taken for

each type of interrupt
Interrupt Timeline
 I/O Structure
After I/O starts, control returns to user program only upon I/O
completion
Wait instruction idles the CPU until the next interrupt
Wait loop (contention for memory access)
At most one I/O request is outstanding at a time, no
simultaneous I/O processing

After I/O starts, control returns to user program without waiting for
I/O completion
System call – request to the operating system to allow user to
wait for I/O completion
Device-status table contains entry for each I/O device
indicating its type, address, and state
Operating system indexes into I/O device table to determine
device status and to modify table entry to include interrupt
 Direct Memory Access Structure
Used for high-speed I/O devices able to transmit information at close
to memory speeds

Device controller transfers blocks of data from buffer storage directly to

main memory without CPU intervention

Only one interrupt is generated per block, rather than the one interrupt
per byte
 Storage Structure
Main memory – only large storage media that the CPU can access
directly
Random access
Typically volatile
Secondary storage – extension of main memory that provides large
nonvolatile storage capacity

Magnetic disks – rigid metal or glass platters covered with magnetic

recording material
Disk surface is logically divided into tracks, which are subdivided
into sectors
The disk controller determines the logical interaction between the
device and the computer
 Storage Hierarchy
Storage systems organized in hierarchy
Speed
Cost
Volatility

Caching – copying information into faster storage system; main

memory can be viewed as a cache for secondary storage
Storage-Device Hierarchy
 Caching
Important principle, performed at many levels in a computer (in
hardware, operating system, software)

Information in use copied from slower to faster storage temporarily

Faster storage (cache) checked first to determine if information is

there
If it is, information used directly from the cache (fast)
If not, data copied to cache and used there

Cache smaller than storage being cached

Cache management important design problem
Cache size and replacement policy
 Computer-System Architecture
Most systems use a single general-purpose processor (PDAs through
mainframes)
Most systems have special-purpose processors as well

Multiprocessors systems growing in use and importance

Also known as parallel systems, tightly-coupled systems
Advantages include:
1. Increased throughput
2. Economy of scale
3. Increased reliability – graceful degradation or fault tolerance
Two types:
1. Asymmetric Multiprocessing
2. Symmetric Multiprocessing
How a Modern Computer Works

A von Neumann architecture

Symmetric Multiprocessing Architecture
A Dual-Core Design
 Clustered Systems
Like multiprocessor systems, but multiple systems working together
Usually sharing storage via a storage-area network (SAN)
Provides a high-availability service which survives failures
 Asymmetric clustering has one machine in hot-standby mode
 Symmetric clustering has multiple nodes running applications,
monitoring each other
Some clusters are for high-performance computing (HPC)
 Applications must be written to use parallelization
Clustered Systems
 Operating System Structure

Multiprogramming needed for efficiency

Single user cannot keep CPU and I/O devices busy at all times
Multiprogramming organizes jobs (code and data) so CPU always has one
to execute
A subset of total jobs in system is kept in memory
One job selected and run via job scheduling
When it has to wait (for I/O for example), OS switches to another job

Timesharing (multitasking) is logical extension in which CPU switches jobs

so frequently that users can interact with each job while it is running, creating
interactive computing
Response time should be < 1 second
Each user has at least one program executing in memory process
If several jobs ready to run at the same time  CPU scheduling
If processes don’t fit in memory, swapping moves them in and out to run
Virtual memory allows execution of processes not completely in memory
Memory Layout for Multiprogrammed System
 Operating-System Operations
Interrupt driven by hardware
Software error or request creates exception or trap
Division by zero, request for operating system service
Other process problems include infinite loop, processes modifying each
other or the operating system
Dual-mode operation allows OS to protect itself and other system
components
User mode and kernel mode
Mode bit provided by hardware
 Provides ability to distinguish when system is running user code
or kernel code
 Some instructions designated as privileged, only executable in
kernel mode
 System call changes mode to kernel, return from call resets it to
user
 Transition from User to Kernel Mode
Timer to prevent infinite loop / process hogging resources
Set interrupt after specific period
Operating system decrements counter
When counter zero generate an interrupt
Set up before scheduling process to regain control or terminate
program that exceeds allotted time
 Process Management
A process is a program in execution. It is a unit of work within the
system. Program is a passive entity, process is an active entity.
Process needs resources to accomplish its task
CPU, memory, I/O, files
Initialization data
Process termination requires reclaim of any reusable resources
Single-threaded process has one program counter specifying
location of next instruction to execute
Process executes instructions sequentially, one at a time, until
completion
Multi-threaded process has one program counter per thread
Typically system has many processes, some user, some operating
system running concurrently on one or more CPUs
Concurrency by multiplexing the CPUs among the processes /
threads
 Process Management Activities
The operating system is responsible for the following activities in
connection with process management:

Creating and deleting both user and system processes

Suspending and resuming processes
Providing mechanisms for process synchronization
Providing mechanisms for process communication
Providing mechanisms for deadlock handling
 Memory Management
All data in memory before and after processing

All instructions in memory in order to execute

Memory management determines what is in memory when

Optimizing CPU utilization and computer response to users

Memory management activities

Keeping track of which parts of memory are currently being used
and by whom
Deciding which processes (or parts thereof) and data to move into
and out of memory
Allocating and deallocating memory space as needed
 Storage Management

OS provides uniform, logical view of information storage

Abstracts physical properties to logical storage unit - file
Each medium is controlled by device (i.e., disk drive, tape drive)
 Varying properties include access speed, capacity, data-
transfer rate, access method (sequential or random)

File-System management
Files usually organized into directories
Access control on most systems to determine who can access
what
OS activities include
 Creating and deleting files and directories
 Primitives to manipulate files and dirs
 Mapping files onto secondary storage
 Backup files onto stable (non-volatile) storage media
 Mass-Storage Management
Usually disks used to store data that does not fit in main memory or
data that must be kept for a “long” period of time
Proper management is of central importance
Entire speed of computer operation hinges on disk subsystem and its
algorithms
OS activities
Free-space management
Storage allocation
Disk scheduling
Some storage need not be fast
Tertiary storage includes optical storage, magnetic tape
Still must be managed – by OS or applications
Varies between WORM (write-once, read-many-times) and RW
(read-write)
Performance of Various Levels of Storage

Movement between levels of storage hierarchy can be explicit or

implicit
Migration of Integer A from Disk to Register

Multitasking environments must be careful to use most recent value, no

matter where it is stored in the storage hierarchy

Multiprocessor environment must provide cache coherency in hardware

such that all CPUs have the most recent value in their cache

Distributed environment situation even more complex

Several copies of a datum can exist
Various solutions covered in Chapter 17
 I/O Subsystem
One purpose of OS is to hide peculiarities of hardware devices from
the user

I/O subsystem responsible for

Memory management of I/O including buffering (storing data
temporarily while it is being transferred), caching (storing parts of
data in faster storage for performance), spooling (the overlapping
of output of one job with input of other jobs)
General device-driver interface
Drivers for specific hardware devices
 Protection and Security
Protection – any mechanism for controlling access of processes or
users to resources defined by the OS

Security – defense of the system against internal and external attacks

Huge range, including denial-of-service, worms, viruses, identity
theft, theft of service

Systems generally first distinguish among users, to determine who

can do what
User identities (user IDs, security IDs) include name and
associated number, one per user
User ID then associated with all files, processes of that user to
determine access control
Group identifier (group ID) allows set of users to be defined and
controls managed, then also associated with each process, file
Privilege escalation allows user to change to effective ID with
more rights
 Distributed Computing
Collection of separate, possibly heterogeneous, systems networked
together
Network is a communications path
– Local Area Network (LAN)
– Wide Area Network (WAN)
– Metropolitan Area Network (MAN)
Network Operating System provides features between systems across
network
Communication scheme allows systems to exchange messages
Illusion of a single system
 Special-Purpose Systems
Real-time embedded systems most prevalent form of computers
Vary considerable, special purpose, limited purpose OS, real-time OS
Multimedia systems
Streams of data must be delivered according to time restrictions
Handheld systems
PDAs, smart phones, limited CPU, memory, power
Reduced feature set OS, limited I/O
 Computing Environments
Traditional computer
Blurring over time
Office environment
 PCs connected to a network, terminals attached to
mainframe or minicomputers providing batch and
timesharing
 Now portals allowing networked and remote systems
access to same resources
Home networks
 Used to be single system, then modems
 Now firewalled, networked
 Computing Environments (Cont.)
Client-Server Computing
Dumb terminals supplanted by smart PCs
Many systems now servers, responding to requests generated
by clients
 Compute-server provides an interface to client to request
services (i.e., database)
 File-server provides interface for clients to store and
retrieve files
 Peer-to-Peer Computing
Another model of distributed system

P2P does not distinguish clients and servers

Instead all nodes are considered peers
May each act as client, server or both
Node must join P2P network
 Registers its service with central lookup service on network, or
 Broadcast request for service and respond to requests for
service via discovery protocol
Examples include Napster and Gnutella
 Web-Based Computing
Web has become ubiquitous

PCs most prevalent devices

More devices becoming networked to allow web access

New category of devices to manage web traffic among similar servers:

load balancers

Use of operating systems like Windows 95, client-side, have evolved

into Linux and Windows XP, which can be clients and servers
 Open-Source Operating Systems
Operating systems made available in source-code format rather than
just binary closed-source

Counter to the copy protection and Digital Rights Management

(DRM) movement

Started by Free Software Foundation (FSF), which has “copyleft”

GNU Public License (GPL)

Examples include GNU/Linux and BSD UNIX (including core of Mac

OS X), and many more
Operating-System Structures
 Operating System Services
Operating systems provide an environment for execution of programs and
services to programs and users
One set of operating-system services provides functions that are helpful to the
user:
User interface - Almost all operating systems have a user interface (UI).
 Varies between Command-Line (CLI), Graphics User Interface (GUI),
Batch
Program execution - The system must be able to load a program into
memory and to run that program, end execution, either normally or
abnormally (indicating error)
I/O operations - A running program may require I/O, which may involve a
file or an I/O device
File-system manipulation - The file system is of particular interest.
Programs need to read and write files and directories, create and delete
them, search them, list file Information, permission management.
Operating System Services (Cont.)
Communications – Processes may exchange information, on the
same computer or between computers over a network
 Communications may be via shared memory or through
message passing (packets moved by the OS)
Error detection – OS needs to be constantly aware of possible
errors
 May occur in the CPU and memory hardware, in I/O devices, in
user program
 For each type of error, OS should take the appropriate action to
ensure correct and consistent computing
 Debugging facilities can greatly enhance the user’s and
programmer’s abilities to efficiently use the system
 Operating System Services (Cont.)

Another set of OS functions exists for ensuring the efficient operation of the
system itself via resource sharing
Resource allocation - When multiple users or multiple jobs running
concurrently, resources must be allocated to each of them
 Many types of resources - Some (such as CPU cycles, main memory,
and file storage) may have special allocation code, others (such as I/O
devices) may have general request and release code
Accounting - To keep track of which users use how much and what kinds
of computer resources
Protection and security - The owners of information stored in a multiuser
or networked computer system may want to control use of that information,
concurrent processes should not interfere with each other
 Protection involves ensuring that all access to system resources is
controlled
 Security of the system from outsiders requires user authentication,
extends to defending external I/O devices from invalid access attempts
 If a system is to be protected and secure, precautions must be
instituted throughout it. A chain is only as strong as its weakest link.
A View of Operating System Services
 User Operating System Interface - CLI

Command Line Interface (CLI) or command interpreter allows direct

command entry
 Sometimes implemented in kernel, sometimes by systems
program
 Sometimes multiple flavors implemented – shells
 Primarily fetches a command from user and executes it
– Sometimes commands built-in, sometimes just names of
programs
» If the latter, adding new features doesn’t require shell
modification
 User Operating System Interface - GUI

User-friendly desktop metaphor interface

Usually mouse, keyboard, and monitor
Icons represent files, programs, actions, etc
Various mouse buttons over objects in the interface cause various
actions (provide information, options, execute function, open directory
(known as a folder)
Invented at Xerox PARC

Many systems now include both CLI and GUI interfaces

Microsoft Windows is GUI with CLI “command” shell
Apple Mac OS X as “Aqua” GUI interface with UNIX kernel underneath
and shells available
Solaris is CLI with optional GUI interfaces (Java Desktop, KDE)
Bourne Shell Command Interpreter
The Mac OS X GUI
 System Calls
Programming interface to the services provided by the OS

Typically written in a high-level language (C or C++)

Mostly accessed by programs via a high-level Application Program

Interface (API) rather than direct system call use

Three most common APIs are Win32 API for Windows, POSIX API
for POSIX-based systems (including virtually all versions of UNIX,
Linux, and Mac OS X), and Java API for the Java virtual machine
(JVM)

Why use APIs rather than system calls?

(Note that the system-call names used throughout this text are
generic)
 Example of System Calls
System call sequence to copy the contents of one file to another file
 Example of Standard API
Consider the ReadFile() function in the
Win32 API—a function for reading from a file

A description of the parameters passed to ReadFile()

HANDLE file—the file to be read
LPVOID buffer—a buffer where the data will be read into and written from
DWORD bytesToRead—the number of bytes to be read into the buffer
LPDWORD bytesRead—the number of bytes read during the last read
LPOVERLAPPED ovl—indicates if overlapped I/O is being used
 System Call Implementation
Typically, a number associated with each system call
System-call interface maintains a table indexed according to these
numbers

The system call interface invokes intended system call in OS kernel

and returns status of the system call and any return values

The caller need know nothing about how the system call is
implemented
Just needs to obey API and understand what OS will do as a
result call
Most details of OS interface hidden from programmer by API
 Managed by run-time support library (set of functions built into
libraries included with compiler)
API – System Call – OS Relationship
 Standard C Library Example
C program invoking printf() library call, which calls write() system call
 System Call Parameter Passing
Often, more information is required than simply identity of desired
system call
Exact type and amount of information vary according to OS and
call

Three general methods used to pass parameters to the OS

Simplest: pass the parameters in registers
 In some cases, may be more parameters than registers
Parameters stored in a block, or table, in memory, and address of
block passed as a parameter in a register
 This approach taken by Linux and Solaris
Parameters placed, or pushed, onto the stack by the program and
popped off the stack by the operating system
Block and stack methods do not limit the number or length of
parameters being passed
Parameter Passing via Table
 Types of System Calls
Process control
end, abort
load, execute
create process, terminate process
get process attributes, set process attributes
wait for time
wait event, signal event
allocate and free memory
File management
create file, delete file
open, close file
read, write, reposition
get and set file attributes
 Types of System Calls (Cont.)
Device management
request device, release device
read, write, reposition
get device attributes, set device attributes
logically attach or detach devices
Information maintenance
get time or date, set time or date
get system data, set system data
get and set process, file, or device attributes
Communications
create, delete communication connection
send, receive messages
transfer status information
attach and detach remote devices
Examples of Windows and
Unix System Calls
 Example: MS-DOS
Single-tasking
Shell invoked when system booted
Simple method to run program
No process created
Single memory space
Loads program into memory, overwriting all but the kernel
Program exit -> shell reloaded
 MS-DOS execution

(a) At system startup (b) running a program

 Example: FreeBSD
Unix variant
Multitasking
User login -> invoke user’s choice of shell
Shell executes fork() system call to create process
Executes exec() to load program into process
Shell waits for process to terminate or continues with user commands
Process exits with code of 0 – no error or > 0 – error code
FreeBSD Running Multiple Programs
 System Programs

System programs provide a convenient environment for program

development and execution. They can be divided into:
File manipulation
Status information
File modification
Programming language support
Program loading and execution
Communications
Application programs

Most users’ view of the operation system is defined by system

programs, not the actual system calls
 System Programs
Provide a convenient environment for program development and
execution
Some of them are simply user interfaces to system calls; others
are considerably more complex

File management - Create, delete, copy, rename, print, dump, list,

and generally manipulate files and directories

Status information
Some ask the system for info - date, time, amount of available
memory, disk space, number of users
Others provide detailed performance, logging, and debugging
information
Typically, these programs format and print the output to the
terminal or other output devices
Some systems implement a registry - used to store and retrieve
configuration information
 System Programs (Cont.)
File modification
Text editors to create and modify files
Special commands to search contents of files or perform
transformations of the text

Programming-language support - Compilers, assemblers,

debuggers and interpreters sometimes provided

Program loading and execution- Absolute loaders, relocatable

loaders, linkage editors, and overlay-loaders, debugging systems for
higher-level and machine language

Communications - Provide the mechanism for creating virtual

connections among processes, users, and computer systems
Allow users to send messages to one another’s screens, browse
web pages, send electronic-mail messages, log in remotely,
transfer files from one machine to another
 Operating System Design
and Implementation

Design and Implementation of OS not “solvable”, but some

approaches have proven successful

Internal structure of different Operating Systems can vary widely

Start by defining goals and specifications

Affected by choice of hardware, type of system

User goals and System goals

User goals – operating system should be convenient to use, easy
to learn, reliable, safe, and fast
System goals – operating system should be easy to design,
implement, and maintain, as well as flexible, reliable, error-free,
and efficient
 Operating System Design and
Implementation (Cont.)

Important principle to separate

Policy: What will be done?
Mechanism: How to do it?

Mechanisms determine how to do something, policies decide what will

be done
The separation of policy from mechanism is a very important
principle, it allows maximum flexibility if policy decisions are to be
changed later
 Simple Structure
MS-DOS – written to provide the most functionality in the least space
Not divided into modules
Although MS-DOS has some structure, its interfaces and levels of
functionality are not well separated
MS-DOS Layer Structure
 Layered Approach
The operating system is divided into a number of layers (levels), each
built on top of lower layers. The bottom layer (layer 0), is the
hardware; the highest (layer N) is the user interface.

With modularity, layers are selected such that each uses functions
(operations) and services of only lower-level layers
Traditional UNIX System Structure
 UNIX

UNIX – limited by hardware functionality, the original UNIX operating

system had limited structuring. The UNIX OS consists of two
separable parts
Systems programs
The kernel
 Consists of everything below the system-call interface and
above the physical hardware
 Provides the file system, CPU scheduling, memory
management, and other operating-system functions; a large
number of functions for one level
Layered Operating System
 Virtual Machines

A virtual machine takes the layered approach to its logical

conclusion. It treats hardware and the operating system kernel as
though they were all hardware.

A virtual machine provides an interface identical to the underlying bare

hardware.

The operating system host creates the illusion that a process has its
own processor and (virtual memory).

Each guest provided with a (virtual) copy of underlying computer.

Virtual Machines (Cont.)

(a) Nonvirtual machine (b) virtual machine

 Para-virtualization

Presents guest with system similar but not identical to hardware

Guest must be modified to run on paravirtualized hardware

Guest can be an OS, or in the case of Solaris 10 applications running in

containers
 Virtualization Implementation
Difficult to implement – must provide an exact duplicate of underlying
machine
Typically runs in user mode, creates virtual user mode and virtual kernel
mode
Timing can be an issue – slower than real machine
Hardware support needed
More support-> better virtualization
i.e. AMD provides “host” and “guest” modes
VMware Architecture
The Java Virtual Machine
 System Boot
Operating system must be made available to hardware so hardware
can start it
Small piece of code – bootstrap loader, locates the kernel,
loads it into memory, and starts it
Sometimes two-step process where boot block at fixed location
loads bootstrap loader
When power initialized on system, execution starts at a fixed
memory location
 Firmware used to hold initial boot code
Processes
 Processes
Process Concept
Process Scheduling
Operations on Processes
Interprocess Communication
Examples of IPC Systems
Communication in Client-Server Systems
 Process Concept
An operating system executes a variety of programs:
Batch system – jobs
Time-shared systems – user programs or tasks

Textbook uses the terms job and process almost interchangeably

Process – a program in execution; process execution must progress in

sequential fashion

A process includes:
program counter
stack
data section
 The Process
Multiple parts
The program code, also called text section
Current activity including program counter, processor registers
Stack containing temporary data
 Function parameters, return addresses, local variables
Data section containing global variables
Heap containing memory dynamically allocated during run time
Program is passive entity, process is active
Program becomes process when executable file loaded into memory
Execution of program started via GUI mouse clicks, command line entry of its name,
etc
One program can be several processes
Consider multiple users executing the same program
Process in Memory
 Process State
As a process executes, it changes state
new: The process is being created
running: Instructions are being executed
waiting: The process is waiting for some event to occur
ready: The process is waiting to be assigned to a processor
terminated: The process has finished execution
Diagram of Process State
 Process Control Block (PCB)
Information associated with each process
Process state
Program counter
CPU registers
CPU scheduling information
Memory-management information
Accounting information
I/O status information
Process Control Block (PCB)
CPU Switch From Process to Process
 Process Scheduling

Maximize CPU use, quickly switch processes onto CPU for time
sharing
Process scheduler selects among available processes for next
execution on CPU
Maintains scheduling queues of processes
Job queue – set of all processes in the system
Ready queue – set of all processes residing in main memory,
ready and waiting to execute
Device queues – set of processes waiting for an I/O device
Processes migrate among the various queues
 Process Representation in Linux
Represented by the C structure task_struct
pid t pid; /* process identifier */
long state; /* state of the process */
unsigned int time slice /* scheduling information */ struct task struct
*parent; /* this process’s parent */ struct list head children; /* this
process’s children */ struct files struct *files; /* list of open files
*/ struct mm struct *mm; /* address space of this pro */
Ready Queue And Various
I/O Device Queues
Representation of Process Scheduling
 Schedulers

Long-term scheduler (or job scheduler) – selects which processes should be

brought into the ready queue
Short-term scheduler (or CPU scheduler) – selects which process should be
executed next and allocates CPU
Sometimes the only scheduler in a system
 Schedulers (Cont.)

Short-term scheduler is invoked very frequently (milliseconds)  (must be fast)

Long-term scheduler is invoked very infrequently (seconds, minutes)  (may be slow)

The long-term scheduler controls the degree of multiprogramming

Processes can be described as either:

I/O-bound process – spends more time doing I/O than computations, many short
CPU bursts
CPU-bound process – spends more time doing computations; few very long CPU
bursts
Addition of Medium Term Scheduling
 Context Switch
When CPU switches to another process, the system must save the state of the old
process and load the saved state for the new process via a context switch.

Context of a process represented in the PCB

Context-switch time is overhead; the system does no useful work while switching
The more complex the OS and the PCB -> longer the context switch

Time dependent on hardware support

Some hardware provides multiple sets of registers per CPU -> multiple contexts
loaded at once
 Process Creation
Parent process create children processes, which, in turn create other processes, forming
a tree of processes

Generally, process identified and managed via a process identifier (pid)

Resource sharing
Parent and children share all resources
Children share subset of parent’s resources
Parent and child share no resources

Execution
Parent and children execute concurrently
Parent waits until children terminate
Address space
Child duplicate of parent
Child has a program loaded into it
UNIX examples
fork system call creates new process
exec system call used after a fork to replace the process’ memory space with a new
program
Process Creation
 Process Termination
Process executes last statement and asks the operating system to delete it (exit)
Output data from child to parent (via wait)
Process’ resources are deallocated by operating system

Parent may terminate execution of children processes (abort)

Child has exceeded allocated resources
Task assigned to child is no longer required
If parent is exiting
 Some operating systems do not allow child to continue if its parent
terminates
– All children terminated - cascading termination
 Interprocess Communication
Processes within a system may be independent or cooperating
Cooperating process can affect or be affected by other processes, including
sharing data
Reasons for cooperating processes:
Information sharing
Computation speedup
Modularity
Convenience
Cooperating processes need interprocess communication (IPC)
Two models of IPC
Shared memory
Message passing
Communications Models
 Cooperating Processes
Independent process cannot affect or be affected by the execution of
another process

Cooperating process can affect or be affected by the execution of another

process

Advantages of process cooperation

Information sharing
Computation speed-up
Modularity
Convenience
 Producer-Consumer Problem

Paradigm for cooperating processes, producer process produces information that is

consumed by a consumer process
unbounded-buffer places no practical limit on the size of the buffer
bounded-buffer assumes that there is a fixed buffer size
 Bounded-Buffer –
Shared-Memory Solution

Shared data

#define BUFFER_SIZE 10
typedef struct {
...
} item;

item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
Solution is correct, but can only use BUFFER_SIZE-1 elements
 Bounded-Buffer – Producer

while (true) {
/* Produce an item */
while (((in = (in + 1) % BUFFER SIZE count) == out)
; /* do nothing -- no free buffers */
buffer[in] = item;
in = (in + 1) % BUFFER SIZE;
}
Bounded Buffer – Consumer

while (true) {
while (in == out)
; // do nothing -- nothing to consume

// remove an item from the buffer

item = buffer[out];
out = (out + 1) % BUFFER SIZE;
return item;
}
 Interprocess Communication –
Message Passing

Mechanism for processes to communicate and to synchronize their actions

Message system – processes communicate with each other without resorting to shared variables
IPC facility provides two operations:
send(message) – message size fixed or variable
receive(message)
If P and Q wish to communicate, they need to:
establish a communication link between them
exchange messages via send/receive
Implementation of communication link
physical (e.g., shared memory, hardware bus)
logical (e.g., logical properties)
 Implementation Questions
How are links established?
Can a link be associated with more than two processes?
How many links can there be between every pair of communicating processes?
What is the capacity of a link?
Is the size of a message that the link can accommodate fixed or variable?
Is a link unidirectional or bi-directional?
 Direct Communication

Processes must name each other explicitly:

send (P, message) – send a message to process P
receive(Q, message) – receive a message from process Q

Properties of communication link

Links are established automatically
A link is associated with exactly one pair of communicating processes
Between each pair there exists exactly one link
The link may be unidirectional, but is usually bi-directional
 Indirect Communication

Messages are directed and received from mailboxes (also referred to as ports)
Each mailbox has a unique id
Processes can communicate only if they share a mailbox

Properties of communication link

Link established only if processes share a common mailbox
A link may be associated with many processes
Each pair of processes may share several communication links
Link may be unidirectional or bi-directional
 Indirect Communication

Operations
create a new mailbox
send and receive messages through mailbox
destroy a mailbox

Primitives are defined as:

send(A, message) – send a message to mailbox A
receive(A, message) – receive a message from mailbox A
 Indirect Communication
Mailbox sharing
P1, P2, and P3 share mailbox A
P1, sends; P2 and P3 receive
Who gets the message?

Solutions
Allow a link to be associated with at most two processes
Allow only one process at a time to execute a receive operation
Allow the system to select arbitrarily the receiver. Sender is notified who the receiver was.
 Synchronization

Message passing may be either blocking or non-blocking

Blocking is considered synchronous

Blocking send has the sender block until the message is received
Blocking receive has the receiver block until a message is available

Non-blocking is considered asynchronous

Non-blocking send has the sender send the message and continue
Non-blocking receive has the receiver receive a valid message or null
 Buffering

Queue of messages attached to the link; implemented in one of three ways

1. Zero capacity – 0 messages
Sender must wait for receiver (rendezvous)
2. Bounded capacity – finite length of n messages
Sender must wait if link full
3. Unbounded capacity – infinite length
Sender never waits
 Examples of IPC Systems - POSIX
POSIX Shared Memory
Process first creates shared memory segment
segment id = shmget(IPC PRIVATE, size, S IRUSR | S IWUSR);
Process wanting access to that shared memory must attach to it
shared memory = (char *) shmat(id, NULL, 0);
Now the process could write to the shared memory
sprintf(shared memory, "Writing to shared memory");
When done a process can detach the shared memory from its address space
shmdt(shared memory);
 Examples of IPC Systems - Mach
Mach communication is message based
Even system calls are messages
Each task gets two mailboxes at creation- Kernel and Notify
Only three system calls needed for message transfer
msg_send(), msg_receive(), msg_rpc()
Mailboxes needed for commuication, created via
port_allocate()
 Examples of IPC Systems – Windows XP
Message-passing centric via local procedure call (LPC) facility
Only works between processes on the same system
Uses ports (like mailboxes) to establish and maintain communication channels
Communication works as follows:
 The client opens a handle to the subsystem’s connection port object.
 The client sends a connection request.
 The server creates two private communication ports and returns the handle to one of them to
the client.
 The client and server use the corresponding port handle to send messages or callbacks and
to listen for replies.
Local Procedure Calls in Windows XP
 Communications in Client-Server Systems
Sockets

Remote Procedure Calls

Pipes

Remote Method Invocation (Java)

 Sockets

A socket is defined as an endpoint for communication

Concatenation of IP address and port

The socket 161.25.19.8:1625 refers to port 1625 on host 161.25.19.8

Communication consists between a pair of sockets

Socket Communication
 Remote Procedure Calls

Remote procedure call (RPC) abstracts procedure calls between processes on networked systems

Stubs – client-side proxy for the actual procedure on the server

The client-side stub locates the server and marshalls the parameters

The server-side stub receives this message, unpacks the marshalled parameters, and performs the
procedure on the server
Execution of RPC