LEC IV

Program
A program is a piece of code which may be a single line or millions of lines.
A computer program is usually written by a computer programmer in a
programming language. For example, here is a simple program written in C
programming language −

#include <stdio.h>

int main() {

printf("Hello, World! \n");

return 0;

A computer program is a collection of instructions that performs a specific

task when executed by a computer. When we compare a program with a
process, we can conclude that a process is a dynamic instance of a
computer program.

A part of a computer program that performs a well-defined task is known as

an algorithm. A collection of computer programs, libraries and related data
are referred to as a software.

Process Life Cycle

When a process executes, it passes through different states. These stages
may differ in different operating systems, and the names of these states are
also not standardized.

In general, a process can have one of the following five states at a time.

S.N. State & Description

1
Start

This is the initial state when a process is first started/created.

2
Ready

The process is waiting to be assigned to a processor. Ready processes are

waiting to have the processor allocated to them by the operating system
so that they can run. Process may come into this state after Start state or
while running it by but interrupted by the scheduler to assign CPU to some
other process.

3
Running

Once the process has been assigned to a processor by the OS scheduler,

the process state is set to running and the processor executes its
instructions.

4
Waiting

Process moves into the waiting state if it needs to wait for a resource, such
as waiting for user input, or waiting for a file to become available.

5
Terminated or Exit

Once the process finishes its execution, or it is terminated by the operating

system, it is moved to the terminated state where it waits to be removed
from main memory.
Process Control Block (PCB)
A Process Control Block is a data structure maintained by the Operating
System for every process. The PCB is identified by an integer process ID
(PID). A PCB keeps all the information needed to keep track of a process as
listed below in the table −

S.N. Information & Description

1
Process State

The current state of the process i.e., whether it is ready, running, waiting,
or whatever.

2
Process privileges

This is required to allow/disallow access to system resources.

3
Process ID

Unique identification for each of the process in the operating system.

4
Pointer

A pointer to parent process.

5
Program Counter

Program Counter is a pointer to the address of the next instruction to be

executed for this process.

6
CPU registers

Various CPU registers where process need to be stored for execution for
running state.

7
CPU Scheduling Information

Process priority and other scheduling information which is required to

 schedule the process.

8
Memory management information

This includes the information of page table, memory limits, Segment table
depending on memory used by the operating system.

9
Accounting information

This includes the amount of CPU used for process execution, time limits,
execution ID etc.

10
IO status information

This includes a list of I/O devices allocated to the process.

The architecture of a PCB is completely dependent on Operating System

and may contain different information in different operating systems. Here
is a simplified diagram of a PCB −
The PCB is maintained for a process throughout its lifetime, and is deleted
once the process terminates.

Operating System - Process Scheduling

Definition
The process scheduling is the activity of the process manager that handles
the removal of the running process from the CPU and the selection of
another process on the basis of a particular strategy.

Process scheduling is an essential part of a Multiprogramming operating

systems. Such operating systems allow more than one process to be loaded
into the executable memory at a time and the loaded process shares the
CPU using time multiplexing.

Process Scheduling Queues

The OS maintains all PCBs in Process Scheduling Queues. The OS maintains
a separate queue for each of the process states and PCBs of all processes in
the same execution state are placed in the same queue. When the state of a
process is changed, its PCB is unlinked from its current queue and moved to
its new state queue.

The Operating System maintains the following important process scheduling

queues −

 Job queue − This queue keeps all the processes in the system.
 Ready queue − This queue keeps a set of all processes residing in main
memory, ready and waiting to execute. A new process is always put in this
queue.
 Device queues − The processes which are blocked due to unavailability of an
I/O device constitute this queue.
The OS can use different policies to manage each queue (FIFO, Round
Robin, Priority, etc.). The OS scheduler determines how to move processes
between the ready and run queues which can only have one entry per
processor core on the system; in the above diagram, it has been merged
with the CPU.

Two-State Process Model

Two-state process model refers to running and non-running states which are
described below −

S.N. State & Description

1
Running

When a new process is created, it enters into the system as in the running
state.

2
Not Running

Processes that are not running are kept in queue, waiting for their turn to
execute. Each entry in the queue is a pointer to a particular process.
Queue is implemented by using linked list. Use of dispatcher is as follows.
When a process is interrupted, that process is transferred in the waiting
 queue. If the process has completed or aborted, the process is discarded.
In either case, the dispatcher then selects a process from the queue to
execute.

Schedulers
Schedulers are special system software which handle process scheduling in
various ways. Their main task is to select the jobs to be submitted into the
system and to decide which process to run. Schedulers are of three types −

 Long-Term Scheduler

 Short-Term Scheduler

 Medium-Term Scheduler

Long Term Scheduler

It is also called a job scheduler. A long-term scheduler determines which
programs are admitted to the system for processing. It selects processes
from the queue and loads them into memory for execution. Process loads
into the memory for CPU scheduling.

The primary objective of the job scheduler is to provide a balanced mix of

jobs, such as I/O bound and processor bound. It also controls the degree of
multiprogramming. If the degree of multiprogramming is stable, then the
average rate of process creation must be equal to the average departure
rate of processes leaving the system.

On some systems, the long-term scheduler may not be available or minimal.

Time-sharing operating systems have no long term scheduler. When a
process changes the state from new to ready, then there is use of long-term
scheduler.

Short Term Scheduler

It is also called as CPU scheduler. Its main objective is to increase system
performance in accordance with the chosen set of criteria. It is the change
of ready state to running state of the process. CPU scheduler selects a
process among the processes that are ready to execute and allocates CPU
to one of them.
Short-term schedulers, also known as dispatchers, make the decision of
which process to execute next. Short-term schedulers are faster than long-
term schedulers.

Medium Term Scheduler

Medium-term scheduling is a part of swapping. It removes the processes
from the memory. It reduces the degree of multiprogramming. The medium-
term scheduler is in-charge of handling the swapped out-processes.

A running process may become suspended if it makes an I/O request. A

suspended processes cannot make any progress towards completion. In this
condition, to remove the process from memory and make space for other
processes, the suspended process is moved to the secondary storage. This
process is called swapping, and the process is said to be swapped out or
rolled out. Swapping may be necessary to improve the process mix.

Comparison among Scheduler

S.N. Long-Term Scheduler Short-Term Medium-Term
Scheduler Scheduler

1 It is a job scheduler It is a CPU scheduler It is a process swapping

scheduler.

2 Speed is lesser than Speed is fastest Speed is in between

short term scheduler among other two both short and long term
scheduler.

3 It controls the degree of It provides lesser It reduces the degree of

multiprogramming control over degree of multiprogramming.
multiprogramming

4 It is almost absent or It is also minimal in It is a part of Time

minimal in time sharing time sharing system sharing systems.
system

5 It selects processes It selects those It can re-introduce the

from pool and loads processes which are process into memory
them into memory for ready to execute and execution can be
 execution continued.

Context Switch
A context switch is the mechanism to store and restore the state or context
of a CPU in Process Control block so that a process execution can be
resumed from the same point at a later time. Using this technique, a
context switcher enables multiple processes to share a single CPU. Context
switching is an essential part of a multitasking operating system features.

When the scheduler switches the CPU from executing one process to
execute another, the state from the current running process is stored into
the process control block. After this, the state for the process to run next is
loaded from its own PCB and used to set the PC, registers, etc. At that point,
the second process can start executing.
Context switches are computationally intensive since register and memory
state must be saved and restored. To avoid the amount of context switching
time, some hardware systems employ two or more sets of processor
registers. When the process is switched, the following information is stored
for later use.

 Program Counter

 Scheduling information

 Base and limit register value

 Currently used register

 Changed State

 I/O State information

 Accounting information

//end of LEC IV
 LEC V

Operating System Scheduling algorithms

A Process Scheduler schedules different processes to be assigned to the
CPU based on particular scheduling algorithms. There are six popular
process scheduling algorithms which we are going to discuss in this chapter

 First-Come, First-Served (FCFS) Scheduling *

 Shortest-Job-Next (SJN) Scheduling *

 Priority Scheduling

 Shortest Remaining Time *

 Round Robin(RR) Scheduling

 Multiple-Level Queues Scheduling

These algorithms are either non-preemptive or preemptive. Non-

preemptive algorithms are designed so that once a process enters the
running state, it cannot be preempted until it completes its allotted time,
whereas the preemptive scheduling is based on priority where a scheduler
may preempt a low priority running process anytime when a high priority
process enters into

a ready state.

*First Come First Serve (FCFS)

 Jobs are executed on first come, first serve basis.

 It is a non-preemptive, pre-emptive scheduling algorithm.

 Easy to understand and implement.

 Its implementation is based on FIFO queue.

 Poor in performance as average wait time is high.

Wait time of each process is as follows −

Process Wait Time : Service Time - Arrival Time

P0 0-0=0

P1 5-1=4

P2 8-2=6

P3 16 - 3 = 13

Average Wait Time: (0+4+6+13) / 4 = 5.75

*Shortest Job Next (SJN)
 This is also known as shortest job first, or SJF

 This is a non-preemptive, pre-emptive scheduling algorithm.

 Best approach to minimize waiting time.

 Easy to implement in Batch systems where required CPU time is known in

advance.

 Impossible to implement in interactive systems where required CPU time is not

known.

 The processer should know in advance how much time process will take.

Process Arrival Time Execute Time Service Time

P0 0 5 3

P1 1 3 0

P2 2 8 14

P3 3 6 8

Gantt Chart
Wait time of each process is as follows −

Process Wait Time : Service Time - Arrival Time

P0 3-0=3

P1 0

P2 14 - 2 = 12

P3 8-3=5

Average Wait Time: (3+12+5) / 4 = 5

Priority Based Scheduling

 Priority scheduling is a non-preemptive algorithm and one of the most common
scheduling algorithms in batch systems.

 Each process is assigned a priority. Process with highest priority is to be

executed first and so on.

 Processes with same priority are executed on first come first served basis.

 Priority can be decided based on memory requirements, time requirements or

any other resource requirement.
Wait time of each process is as follows −

Process Wait Time: Service Time - Arrival Time

P0 9-0=9

P1 6-1=5

P2 14 - 2 = 12

P3 0-0=0

Average Wait Time: (9+5+12+0) / 4 = 6.5

*Shortest Remaining Time

 Shortest remaining time (SRT) is the preemptive version of the SJN algorithm.

 The processor is allocated to the job closest to completion but it can be

preempted by a newer ready job with shorter time to completion.

 Impossible to implement in interactive systems where required CPU time is not

known.

 It is often used in batch environments where short jobs need to give preference.
Round Robin Scheduling
 Round Robin is the preemptive process scheduling algorithm.

 Each process is provided a fix time to execute, it is called a quantum.

 Once a process is executed for a given time period, it is preempted and other
process executes for a given time period.

 Context switching is used to save states of preempted processes.

Process Arrival Time Execute Time Service Time

P0 0 5 3

P1 1 3 0

P2 2 8 14

P3 3 6 8

Q=3
Wait time of each process is as follows −

Process Wait Time: Service Time - Arrival Time

P0 (0 - 0) + (3 - 3) = 0

P1 (0 - 1) = 0

P2 (14 - 2) =12 + (12 - 3) =9 + (9 - 3) =6 + (6-3) =3 + (3-3) =0=30

P3 (8 - 3) =5 + (5 - 3) =2 + (2-3) =0 =7

Average Wait Time: (0+0+30+7= 37)/4 = 9.25

Multiple-Level Queues Scheduling
Multiple-level queues are not an independent scheduling algorithm. They
make use of other existing algorithms to group and schedule jobs with
common characteristics.

 Multiple queues are maintained for processes with common characteristics.

 Each queue can have its own scheduling algorithms.

 Priorities are assigned to each queue.

For example, CPU-bound jobs can be scheduled in one queue and all I/O-
bound jobs in another queue. The Process Scheduler then alternately selects
jobs from each queue and assigns them to the CPU based on the algorithm
assigned to the queue.
 LEC VI

Operating System - Multi-Threading

What is Thread?
A thread is a flow of execution through the process code, with its own
program counter that keeps track of which instruction to execute next,
system registers which hold its current working variables, and a stack which
contains the execution history.

A thread shares with its peer threads few information like code segment,
data segment and open files. When one thread alters a code segment
memory item, all other threads see that.

A thread is also called a lightweight process. Threads provide a way to

improve application performance through parallelism. Threads represent a
software approach to improving performance of operating system by
reducing the overhead thread is equivalent to a classical process.

Each thread belongs to exactly one process and no thread can exist outside
a process. Each thread represents a separate flow of control. Threads have
been successfully used in implementing network servers and web server.
They also provide a suitable foundation for parallel execution of applications
on shared memory multiprocessors. The following figure shows the working
of a single-threaded and a multithreaded process.
Difference between Process and Thread
S.N Process Thread
.

1 Process is heavy weight or resource intensive. Thread is

light
weight,
taking
lesser
resources
than a
process.

2 Process switching needs interaction with operating system. Thread

switching
does not
need to
interact
with
operating
system.

3 In multiple processing environments, each process executes All

the same code but has its own memory and file resources. threads
can share
same set
of open
files, child
processes
.

4 If one process is blocked, then no other process can execute While one
until the first process is unblocked. thread is
blocked
and
waiting, a
second
thread in
the same
task can
run.

5 Multiple processes without using threads use more resources. Multiple

threaded
processes
use fewer
 resources.

6 In multiple processes each process operates independently of One

the others. thread
can read,
write or
change
another
thread's
data.

Advantages of Thread
 Threads minimize the context switching time.

 Use of threads provides concurrency within a process.

 Efficient communication.

 It is more economical to create and context switch threads.

 Threads allow utilization of multiprocessor architectures to a greater scale and

efficiency.

Types of Thread
Threads are implemented in following two ways −

 User Level Threads − User managed threads.

 Kernel Level Threads − Operating System managed thread0s acting on

kernel, an operating system core.

User Level Threads

In this case, the thread management kernel is not aware of the existence of
threads. The thread library contains code for creating and destroying
threads, for passing message and data between threads, for scheduling
thread execution and for saving and restoring thread contexts. The
application starts with a single thread.
Advantages

 Thread switching does not require Kernel mode privileges.

 User level thread can run on any operating system.

 Scheduling can be application specific in the user level thread.

 User level threads are fast to create and manage.

Disadvantages

 In a typical operating system, most system calls are blocking.

 Multithreaded application cannot take advantage of multiprocessing.

Kernel Level Threads

In this case, thread management is done by the Kernel. There is no thread
management code in the application area. Kernel threads are supported
directly by the operating system. Any application can be programmed to be
multithreaded. All of the threads within an application are supported within
a single process.

The Kernel maintains context information for the process as a whole and for
individuals threads within the process. Scheduling by the Kernel is done on
a thread basis. The Kernel performs thread creation, scheduling and
management in Kernel space. Kernel threads are generally slower to create
and manage than the user threads.

Advantages

 Kernel can simultaneously schedule multiple threads from the same process on
multiple processes.

 If one thread in a process is blocked, the Kernel can schedule another thread of
the same process.

 Kernel routines themselves can be multithreaded.

Disadvantages

 Kernel threads are generally slower to create and manage than the user threads.

 Transfer of control from one thread to another within the same process requires
a mode switch to the Kernel.

Multithreading Models
Some operating system provide a combined user level thread and Kernel
level thread facility. Solaris is a good example of this combined approach. In
a combined system, multiple threads within the same application can run in
parallel on multiple processors and a blocking system call need not block
the entire process. Multithreading models are three types

 Many to many relationship.

 Many to one relationship.

 One to one relationship.

Many to Many Model
The many-to-many model multiplexes any number of user threads onto an
equal or smaller number of kernel threads.

The following diagram shows the many-to-many threading model where 6

user level threads are multiplexing with 6 kernel level threads. In this
model, developers can create as many user threads as necessary and the
corresponding Kernel threads can run in parallel on a multiprocessor
machine. This model provides the best accuracy on concurrency and when a
thread performs a blocking system call, the kernel can schedule another
thread for execution.
Many to One Model
Many-to-one model maps many user level threads to one Kernel-level
thread. Thread management is done in user space by the thread library.
When thread makes a blocking system call, the entire process will be
blocked. Only one thread can access the Kernel at a time, so multiple
threads are unable to run in parallel on multiprocessors.

If the user-level thread libraries are implemented in the operating system in

such a way that the system does not support them, then the Kernel threads
use the many-to-one relationship modes.
One to One Model
There is one-to-one relationship of user-level thread to the kernel-level
thread. This model provides more concurrency than the many-to-one model.
It also allows another thread to run when a thread makes a blocking system
call. It supports multiple threads to execute in parallel on microprocessors.

Disadvantage of this model is that creating user thread requires the

corresponding Kernel thread. OS/2, windows NT and windows 2000 use one
to one relationship model.

//CAT 1
Difference between User-Level & Kernel-Level
Thread
S.N User-Level Threads Kernel-Level Thread
.

1 User-level threads are faster to create Kernel-level threads are slower

and manage. to create and manage.

2 Implementation is by a thread library at Operating system supports

the user level. creation of Kernel threads.

3 User-level thread is generic and can run Kernel-level thread is specific to

on any operating system. the operating system.

4 Multi-threaded applications cannot take Kernel routines themselves can

advantage of multiprocessing. be multithreaded.

Operating System - Memory Management

Memory management is the functionality of an operating system which
handles or manages primary memory and moves processes back and forth
between main memory and disk during execution. Memory management
keeps track of each and every memory location, regardless of either it is
allocated to some process or it is free. It checks how much memory is to be
allocated to processes. It decides which process will get memory at what
time. It tracks whenever some memory gets freed or unallocated and
correspondingly it updates the status.

This tutorial will teach you basic concepts related to Memory Management.

*Process Address Space

The process address space is the set of logical addresses that a process
references in its code. For example, when 32-bit addressing is in use,
addresses can range from 0 to 0x7fffffff; that is, 2^31 possible numbers, for
a total theoretical size of 2 gigabytes.

The operating system takes care of mapping the logical addresses to

physical addresses at the time of memory allocation to the program. There
are three types of addresses used in a program before and after memory is
allocated −

S.N Memory Addresses & Description

.

1
Symbolic addresses

The addresses used in a source code. The variable names, constants, and
instruction labels are the basic elements of the symbolic address space.

2
Relative addresses

At the time of compilation, a compiler converts symbolic addresses into

relative addresses.

3
Physical addresses

The loader generates these addresses at the time when a program is

loaded into main memory.
Virtual and physical addresses are the same in compile-time and load-time
address-binding schemes. Virtual and physical addresses differ in execution-
time address-binding scheme.

The set of all logical addresses generated by a program is referred to as

a logical address space. The set of all physical addresses corresponding
to these logical addresses is referred to as a physical address space.

The runtime mapping from virtual to physical address is done by the

memory management unit (MMU) which is a hardware device. MMU uses
following mechanism to convert virtual address to physical address.

 The value in the base register is added to every address generated by a user
process, which is treated as offset at the time it is sent to memory. For example,
if the base register value is 10000, then an attempt by the user to use address
location 100 will be dynamically reallocated to location 10100.

 The user program deals with virtual addresses; it never sees the real physical
addresses.

Static vs Dynamic Loading

The choice between Static or Dynamic Loading is to be made at the time of
computer program being developed. If you have to load your program
statically, then at the time of compilation, the complete programs will be
compiled and linked without leaving any external program or module
dependency. The linker combines the object program with other necessary
object modules into an absolute program, which also includes logical
addresses.

If you are writing a Dynamically loaded program, then your compiler will
compile the program and for all the modules which you want to include
dynamically, only references will be provided and rest of the work will be
done at the time of execution.

At the time of loading, with static loading, the absolute program (and
data) is loaded into memory in order for execution to start.

If you are using dynamic loading, dynamic routines of the library are
stored on a disk in relocatable form and are loaded into memory only when
they are needed by the program.
Static vs Dynamic Linking
As explained above, when static linking is used, the linker combines all
other modules needed by a program into a single executable program to
avoid any runtime dependency.

When dynamic linking is used, it is not required to link the actual module or
library with the program, rather a reference to the dynamic module is
provided at the time of compilation and linking. Dynamic Link Libraries (DLL)
in Windows and Shared Objects in Unix are good examples of dynamic
libraries.

Swapping
Swapping is a mechanism in which a process can be swapped temporarily
out of main memory (or move) to secondary storage (disk) and make that
memory available to other processes. At some later time, the system swaps
back the process from the secondary storage to main memory.

Though performance is usually affected by swapping process but it helps in

running multiple and big processes in parallel and that's the
reason Swapping is also known as a technique for memory
compaction.
The total time taken by swapping process includes the time it takes to move
the entire process to a secondary disk and then to copy the process back to
memory, as well as the time the process takes to regain main memory.

Let us assume that the user process is of size 2048KB and on a standard
hard disk where swapping will take place has a data transfer rate around 1
MB per second. The actual transfer of the 1000K process to or from memory
will take
2048KB / 1024KB per second
= 2 seconds
= 2000 milliseconds

Now considering in and out time, it will take complete 4000 milliseconds
plus other overhead where the process competes to regain main memory.

Memory Allocation
Main memory usually has two partitions −

 Low Memory − Operating system resides in this memory.

 High Memory − User processes are held in high memory.

Operating system uses the following memory allocation mechanism.

S.N Memory Allocation & Description

.

1
Single-partition allocation

In this type of allocation, relocation-register scheme is used to protect user

processes from each other, and from changing operating-system code and
data. Relocation register contains value of smallest physical address
whereas limit register contains range of logical addresses. Each logical
address must be less than the limit register.

2
Multiple-partition allocation

In this type of allocation, main memory is divided into a number of fixed-

sized partitions where each partition should contain only one process.
When a partition is free, a process is selected from the input queue and is
loaded into the free partition. When the process terminates, the partition
becomes available for another process.

Fragmentation
As processes are loaded and removed from memory, the free memory
space is broken into little pieces. It happens after sometimes that processes
cannot be allocated to memory blocks considering their small size and
memory blocks remains unused. This problem is known as Fragmentation.
Fragmentation is of two types −

S.N Fragmentation & Description

.

1
External fragmentation

Total memory space is enough to satisfy a request or to reside a process in

it, but it is not contiguous, so it cannot be used.

2
Internal fragmentation

Memory block assigned to process is bigger. Some portion of memory is

left unused, as it cannot be used by another process.

The following diagram shows how fragmentation can cause waste of

memory and a compaction technique can be used to create more free
memory out of fragmented memory −

External fragmentation can be reduced by compaction or shuffle memory

contents to place all free memory together in one large block. To make
compaction feasible, relocation should be dynamic.
The internal fragmentation can be reduced by effectively assigning the
smallest partition but large enough for the process.

Paging
A computer can address more memory than the amount physically installed
on the system. This extra memory is actually called virtual memory and it is
a section of a hard that's set up to emulate the computer's RAM. Paging
technique plays an important role in implementing virtual memory.

Paging is a memory management technique in which process address space

is broken into blocks of the same size called pages (size is power of 2,
between 512 bytes and 8192 bytes). The size of the process is measured in
the number of pages.

Similarly, main memory is divided into small fixed-sized blocks of (physical)

memory called frames and the size of a frame is kept the same as that of a
page to have optimum utilization of the main memory and to avoid external
fragmentation.
Address Translation
Page address is called logical address and represented by page
numberand the offset.
Logical Address = Page number + page offset

Frame address is called physical address and represented by a frame

number and the offset.
Physical Address = Frame number + page offset

A data structure called page map table is used to keep track of the
relation between a page of a process to a frame in physical memory.
When the system allocates a frame to any page, it translates this logical
address into a physical address and create entry into the page table to be
used throughout execution of the program.

When a process is to be executed, its corresponding pages are loaded into

any available memory frames. Suppose you have a program of 8Kb but your
memory can accommodate only 5Kb at a given point in time, then the
paging concept will come into picture. When a computer runs out of RAM,
the operating system (OS) will move idle or unwanted pages of memory to
secondary memory to free up RAM for other processes and brings them
back when needed by the program.

This process continues during the whole execution of the program where
the OS keeps removing idle pages from the main memory and write them
onto the secondary memory and bring them back when required by the
program.

Advantages and Disadvantages of Paging

Here is a list of advantages and disadvantages of paging −

 Paging reduces external fragmentation, but still suffer from internal

fragmentation.
  Paging is simple to implement and assumed as an efficient memory
management technique.
 Due to equal size of the pages and frames, swapping becomes very easy.
 Page table requires extra memory space, so may not be good for a system
having small RAM.

Segmentation
Segmentation is a memory management technique in which each job is
divided into several segments of different sizes, one for each module that
contains pieces that perform related functions. Each segment is actually a
different logical address space of the program.

When a process is to be executed, its corresponding segmentation are

loaded into non-contiguous memory though every segment is loaded into a
contiguous block of available memory.

Segmentation memory management works very similar to paging but here

segments are of variable-length where as in paging pages are of fixed size.

A program segment contains the program's main function, utility functions,

data structures, and so on. The operating system maintains a segment
map table for every process and a list of free memory blocks along with
segment numbers, their size and corresponding memory locations in main
memory. For each segment, the table stores the starting address of the
segment and the length of the segment. A reference to a memory location
includes a value that identifies a segment and an offset.
 Operating System - Virtual Memory
A computer can address more memory than the amount physically installed
on the system. This extra memory is actually called virtual memory and it
is a section of a hard disk that's set up to emulate the computer's RAM.

The main visible advantage of this scheme is that programs can be larger
than physical memory. Virtual memory serves two purposes. First, it allows
us to extend the use of physical memory by using disk. Second, it allows us
to have memory protection, because each virtual address is translated to a
physical address.

Following are the situations, when entire program is not required to be

loaded fully in main memory.

 User written error handling routines are used only when an error occurred in the
data or computation.
 Certain options and features of a program may be used rarely.
  Many tables are assigned a fixed amount of address space even though only a
small amount of the table is actually used.
 The ability to execute a program that is only partially in memory would counter
many benefits.
 Less number of I/O would be needed to load or swap each user program into
memory.
 A program would no longer be constrained by the amount of physical memory
that is available.
 Each user program could take less physical memory, more programs could be
run the same time, with a corresponding increase in CPU utilization and
throughput.

Modern microprocessors intended for general-purpose use, a memory

management unit, or MMU, is built into the hardware. The MMU's job is to
translate virtual addresses into physical addresses. A basic example is given
below −
Virtual memory is commonly implemented by demand paging. It can also be
implemented in a segmentation system. Demand segmentation can also be
used to provide virtual memory.

Demand Paging
A demand paging system is quite similar to a paging system with swapping
where processes reside in secondary memory and pages are loaded only on
demand, not in advance. When a context switch occurs, the operating
system does not copy any of the old program’s pages out to the disk or any
of the new program’s pages into the main memory Instead, it just begins
executing the new program after loading the first page and fetches that
program’s pages as they are referenced.
While executing a program, if the program references a page which is not
available in the main memory because it was swapped out a little ago, the
processor treats this invalid memory reference as a page fault and
transfers control from the program to the operating system to demand the
page back into the memory.

Advantages
Following are the advantages of Demand Paging −

 Large virtual memory.

 More efficient use of memory.

 There is no limit on degree of multiprogramming.

Disadvantages
 Number of tables and the amount of processor overhead for handling page
interrupts are greater than in the case of the simple paged management
techniques.

Page Replacement Algorithm

Page replacement algorithms are the techniques using which an Operating
System decides which memory pages to swap out, write to disk when a
page of memory needs to be allocated. Paging happens whenever a page
fault occurs and a free page cannot be used for allocation purpose
accounting to reason that pages are not available or the number of free
pages is lower than required pages.

When the page that was selected for replacement and was paged out, is
referenced again, it has to read in from disk, and this requires for I/O
completion. This process determines the quality of the page replacement
algorithm: the lesser the time waiting for page-ins, the better is the
algorithm.

A page replacement algorithm looks at the limited information about

accessing the pages provided by hardware, and tries to select which pages
should be replaced to minimize the total number of page misses, while
balancing it with the costs of primary storage and processor time of the
algorithm itself. There are many different page replacement algorithms. We
evaluate an algorithm by running it on a particular string of memory
reference and computing the number of page faults,

Reference String
The string of memory references is called reference string. Reference
strings are generated artificially or by tracing a given system and recording
the address of each memory reference. The latter choice produces a large
number of data, where we note two things.

 For a given page size, we need to consider only the page number, not the entire
address.
  If we have a reference to a page p, then any immediately following references to
page p will never cause a page fault. Page p will be in memory after the first
reference; the immediately following references will not fault.
 For example, consider the following sequence of addresses −
123,215,600,1234,76,96
 If page size is 100, then the reference string is 1,2,6,12,0,0

First In First Out (FIFO) algorithm

 Oldest page in main memory is the one which will be selected for replacement.
 Easy to implement, keep a list, replace pages from the tail and add new pages at
the head.

*Optimal Page algorithm

 An optimal page-replacement algorithm has the lowest page-fault rate of all
algorithms. An optimal page-replacement algorithm exists, and has been called
OPT or MIN.
 Replace the page that will not be used for the longest period of time. Use the
time when a page is to be used.
Least Recently Used (LRU) algorithm
 Page which has not been used for the longest time in main memory is the one
which will be selected for replacement.
 Easy to implement, keep a list, replace pages by looking back into time.

Page Buffering algorithm

 To get a process start quickly, keep a pool of free frames.
  On page fault, select a page to be replaced.

 Write the new page in the frame of free pool, mark the page table and restart the
process.

 Now write the dirty page out of disk and place the frame holding replaced page
in free pool.

Least frequently Used(LFU) algorithm

 The page with the smallest count is the one which will be selected for
replacement.
 This algorithm suffers from the situation in which a page is used heavily during
the initial phase of a process, but then is never used again.

Most frequently Used(MFU) algorithm

 This algorithm is based on the argument that the page with the smallest count
was probably just brought in and has yet to be used.

Operating System - I/O Hardware

One of the important jobs of an Operating System is to manage various I/O
devices including mouse, keyboards, touch pad, disk drives, display
adapters, USB devices, Bit-mapped screen, LED, Analog-to-digital converter,
On/off switch, network connections, audio I/O, printers etc.

An I/O system is required to take an application I/O request and send it to

the physical device, then take whatever response comes back from the
device and send it to the application. I/O devices can be divided into two
categories −

 Block devices − A block device is one with which the driver communicates by
sending entire blocks of data. For example, Hard disks, USB cameras, Disk-On-
Key etc.
 Character devices − A character device is one with which the driver
communicates by sending and receiving single characters (bytes, octets). For
example, serial ports, parallel ports, sounds cards etc

//END OF LEC VI