0% found this document useful (0 votes)

90 views

Softdot Hi - Tech Educational & Training Institute Unit-1 Operating System Overview

The document discusses operating systems and their role in facilitating communication between hardware and users. It defines operating systems as software that acts as an interface, translating between the languages used by hardware and humans. It also describes the basic components of a computer system, including hardware, operating system, application programs, and users. Finally, it classifies operating systems as single-user or multi-user and discusses characteristics like single-tasking versus multi-tasking.

Uploaded by

Uma Maheswari

Available Formats

Download as DOC, PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

90 views

Softdot Hi - Tech Educational & Training Institute Unit-1 Operating System Overview

Uploaded by

Uma Maheswari

Available Formats

Download as DOC, PDF, TXT or read online on Scribd

You are on page 1/ 67

SoftDot Hi –Tech Educational & Training Institute

(A unit of De Unique Educational Society)

UNIT-1
Operating System Overview
DEFINITION

Operating system acts as interface between the user and the computer hardware. They
sit between the user and the hardware of the computer providing an operational
environment to the users and application programs. For a user, therefore, a computer
is nothing but the operating system running on it. It is an extended machine.

User does not interact with the hardware of a computer directly but through the
services offered by OS. This is because the language that users employ is different
from that of the hardware where as users prefer to use natural language or near
natural language for interaction, the hardware uses machine language. Os takes
instruction in the form of commands from the user and translates into machine
understandable instructions, gets these instructions executed by CPU and translates
the result back into user understandable form.

• OS is a resource allocate
• 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

COMPUTER SYSTEM SATRT UP

• Bootstrap program is loaded at power-up or reboot.

• Typically stored in ROM or EPROM, generally known as firmware.
• Initialized all aspects of system
• Loads operating system kernel and starts execution

COMPUTER SYSTEM ORGANIZATION

• 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.
• 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.

Fig Computer System Organization

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

Operating system goals

• Execute user programs and make solving user problems easier.

• Make the computer system convenient to use.
• Application programs :
o It define the ways in which the system resources are used to solve the
computing problems of the users
o Word processors, compilers, web browsers, database systems, video
games
• Users: People, machines, other computers

Four Components of a Computer System

Fig Extended machine view of operating system

OPERATING SYSTEM CLASSIFICATION

• All operating system contain the same components whose functionalities are almost
the same. For instance, all the operating systems perform the functions of storage
management, process management, protection of users from one-another, etc.
• Operating system in general, performs similar functions but may have
__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
3
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
distinguishing features. Therefore, they can be classified into different categories on
different bases.

Different types of operating system

• Single user- Single Processing System:-

• It has a single processor, runs a single program and interacts with a single user at a
time. The OS for this system is very simple to design and implement. Example: -
MS-DOS
• Only one program resides in computer memory and it remains that till it is
executed. It is also called uni-program OS. In this OS, the whole, memory space is
allocated to one program to memory management’s not very difficult task to do.
The CPU has to execute only 1 program at a time, so that CPU management also
does not have any problem.
• In a single user OS, a single user can access the computer at a particular time. The
computer which are based on this OS have a single processor and able to execute
only a single program at a particular time. This system provides all the resources to
the users all the time. The single user OS into following categories: -

Single user, single tasking:

• In a single user, single tasking OS, There is a single user to execute a program at a
particular system.
• Example – MS-DOS

Single user, multitasking OS:

• In single user, multitasking OS a single user can execute multiple programs.
• Example – A user can program different programs such as making calculations in
excel sheet, printing a word document & downloading into the file from internet at
the same time.

USER Application Programs

Operating System

Hardware

• Advantages of single user OS:-

o The CPU has to handle only one application program at a time so that
process management is easy in this environment.
o Due to the limited number of programs allocation of memory to the
process & allocation of resources to the process becomes any easy task to
handle.

• Disadvantages of single user OS:-

o As the OS is handling one application at a time most of the CPU time is
wasted, because it has to sit idle most of the time while executing a single
program.
o Resources like memory, CPU are not utilized at the maximum.

Batch Processing Systems

• The main function of a batch processing system is to automatically keep executing

one job to the next in batch. The main idea behind that batch processing system is to
reduce the interface of the operator during the processor or execution of jobs by
computer system. All functioned of batch processing system are carried out by
program is known as batch monitor.
• The batch monitor is a permanent program that resides in the main memory. In
other words, a batch monitor is responsible for controlling the environment of the
system for smooth execution of the process. In batch processing system, turn
around time is use to define the total time taken by a job in the execution. This time
includes batch formation, time taken to print result 7the time required to physically
sort the printed outputs that belongs to a different jobs. Another important terms
used in batch processing system is job scheduling. It is a process of sequencing jobs
to that.

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.

__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
5
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
• 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.

Operating System and System Calls

• 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.

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 deal locating memory space as needed
__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
6
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)

Memory Layout for Multiprogrammed System

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, and 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 directories.
• Mapping files onto secondary storage.
• Backup files onto stable (non-volatile) storage media.

SYSTEM CALL

• 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.

Operating System Structures

• Operating System Services

• User Operating System Interface
• System Calls
• Types of System Calls
• System Programs
• Operating System Design and Implementation
• Operating System Structure
• Virtual Machines
• Operating System Generation
• System Boot

OBJECTIVE

• To describe the services an operating system provides to users, processes, and other
systems
• To discuss the various ways of structuring an operating system
• To explain how operating systems are installed and customized and how they boot

SERVICES OF OS

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) and 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. Obviously,
programs need to read and write files and directories, create and delete them, search
__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
8
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
them, list file Information, permission management.

• 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. It 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.
• 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 multi-user 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.

SYSTEM CALL

• 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)

TYPE OF SYSTEM CALL

• Process control
• File management
• Device management
• Information maintenance
• Communications

SYSTEM PROGRAM

• 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,
and 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 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.

UNIT – 2
Operating System Functions

Process Concept

• An operating system executes a variety of programs:

o Batch system – jobs
o 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:
o program counter
o stack
o data section

Process in Memory

Process State
• As a process executes, it changes state
o new: The process is being created
o running: Instructions are being executed
o waiting: The process is waiting for some event to occur
o ready: The process is waiting to be assigned to a processor

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)

Process Scheduling Queues

• 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

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

• 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.

Process Creation

• Parent process create children processes, which, in turn create other processes,
forming a tree of processes
• Resource sharing
o Parent and children share all resources
o Children share subset of parent’s resources
o Parent and child share no resources
• Execution
o Parent and children execute concurrently
o 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

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
o Information sharing
o Computation speed-up
o Modularity
o Convenience

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
• Context-switch time is overhead; the system does no useful work while switching
• Time dependent on hardware support

CPU Scheduling

Basic Concepts
• Maximum CPU utilization obtained with multiprogramming
• CPU–I/O Burst Cycle – Process execution consists of a cycle of CPU execution
and I/O wait
• CPU burst distribution

• Selects from among the processes in memory that are ready to execute, and
allocates the CPU to one of them
• CPU scheduling decisions may take place when a process:
1. Switches from running to waiting state
2. Switches from running to ready state
3. Switches from waiting to ready
4. Terminates
• Scheduling under 1 and 4 is non-preemptive
• All other scheduling is preemptive

Dispatcher

• Dispatcher module gives control of the CPU to the process selected by the short-
term scheduler; this involves:
o switching context
o switching to user mode
o jumping to the proper location in the user program to restart that program
• Dispatch latency – time it takes for the dispatcher to stop one process and start
another running

Scheduling Criteria

• CPU utilization – keep the CPU as busy as possible

• Throughput – No. of processes that complete their execution per time unit
• Turnaround time – amount of time to execute a particular process
• Waiting time – amount of time a process has been waiting in the ready queue
• Response time – amount of time it takes from when a request was submitted until
the first response is produced, not output (for time-sharing environment)

Optimization Criteria

• Max CPU utilization

• Max throughput
• Min turnaround time
• Min waiting time
• Min response time
__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
16
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)

First-Come, First-Served (FCFS) Scheduling

• Waiting time for P1 = 0; P2 = 24; P3 = 27

• Average waiting time: (0 + 24 + 27)/3 = 17

Shortest-Job-First (SJF) Scheduling

• Associate with each process the length of its next CPU burst. Use these lengths to
schedule the process with the shortest time
• Two schemes:
o no preemptive – once CPU given to the process it cannot be preempted
until completes its CPU burst
o Preemptive – if a new process arrives with CPU burst length less than
remaining time of current executing process, preempt. This scheme is
know as the
Shortest-Remaining-Time-First (SRTF)
• SJF is optimal – gives minimum average waiting time for a given set of processes

Example of Non-Preemptive SJF

Process Arrival Time Burst Time

P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
• SJF (non-preemptive)

P1 P3 P2 P4

0 3 7 8 12 16
• Average waiting time = (0 + 6 + 3 + 7)/4 = 4

Example of Preemptive SJF

Process Arrival Time Burst Time

P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
• SJF (preemptive)

P1 P2 P3 P2 P4 P1

0 2 4 5 7 11 16
• Average waiting time = (9 + 1 + 0 +2)/4 = 3

Priority Scheduling

• A priority number (integer) is associated with each process

• The CPU is allocated to the process with the highest priority (smallest integer ≡
highest priority)
• Preemptive
• no preemptive
• SJF is a priority scheduling where priority is the predicted next CPU burst time
• Problem ≡ Starvation – low priority processes may never execute
• Solution ≡ Aging – as time progresses increase the priority of the process

Round Robin (RR)

• Each process gets a small unit of CPU time (time quantum), usually 10-100
milliseconds. After this time has elapsed, the process is preempted and added to
the end of the ready queue.
• If there are n processes in the ready queue and the time quantum is q, then each
process gets 1/n of the CPU time in chunks of at most q time units at once. No
process waits more than (n-1)q time units.
• Performance
o q large ⇒ FIFO

Example of RR with Time Quantum = 20

Process Burst Time
P1 53
P2 17
P3 68
P4 24

The Gantt chart is

P1 P2 P3 P4 P1 P3 P4 P1 P3 P3
2 3 5 7 9 11 12 13 15 16
0
0 7 7 7 7 7 1 4 4 2
Typically, higher average turnaround than SJF, but better response

Multilevel Queue

• Ready queue is partitioned into separate queues:

foreground(interactive)background (batch).
• Each queue has its own scheduling algorithm
o foreground – RR
o background – FCFS
• Scheduling must be done between the queues
o Fixed priority scheduling; (i.e., serve all from foreground then from
background). Possibility of starvation.
o Time slice – each queue gets a certain amount of CPU time which it can
schedule amongst its processes; i.e., 80% to foreground in RR
o 20% to background in FCFS

Multilevel Queue Scheduling

Multilevel Feedback Queue

• A process can move between the various queues; aging can be implemented this
way
• Multilevel-feedback-queue scheduler defined by the following parameters:
• Number of queues.
• Scheduling algorithms for each queue.

• Method used to determine when to upgrade a process.

• Method used to determine when to demote a process.
• Method used to determine which queue a process will enter when that process
needs service.

Example of Multilevel Feedback Queue

• Three queues:
o Q0 – RR with time quantum 8 milliseconds
o Q1 – RR time quantum 16 milliseconds
o Q2 – FCFS

Multilevel Feedback Queues

Multiple-Processor Scheduling

• CPU scheduling more complex when multiple CPUs are available.

• Homogeneous processors within a multiprocessor.
• Load sharing.
• Asymmetric multiprocessing – only one processor accesses the system data
structures, alleviating the need for data sharing.

Deadlock handling

Bridge Crossing Example

• Traffic only in one direction.

• Each section of a bridge can be viewed as a resource.
• If a deadlock occurs, it can be resolved if one car backs up (preempt resources and
rollback).
• Several cars may have to be backed up if a deadlock occurs.
• Starvation is possible.

System model
• Resource types R1, R2, . . ., Rm.
• CPU cycles, memory space, I/O devices.
• Each resource type Ri has Wi instances.
• Each process utilizes a resource as follows:
o request
o use
o release

Deadlock Characterization Deadlock

Deadlock can arise if four conditions hold simultaneously.

• Mutual exclusion: only one process at a time can use a resource.
• Hold and wait: a process holding at least one resource is waiting to acquire
additional resources held by other processes.
• No preemption: a resource can be released only voluntarily by the process
holding it, after that process has completed its task.
• Circular wait: there exists a set {P0, P1, …, P0} of waiting processes such that
P0 is waiting for a resource that is held by P1, P1 is waiting for a resource that is
held by
• P2, …, Pn–1 is waiting for a resource that is held by
Pn, and P0 is waiting for a resource that is held by P0.

Resource-Allocation Graph
A set of vertices V and a set of edges E.

• V is partitioned into two types:

o P = {P1, P2, …, Pn}, the set consisting of all the processes in the system.
o R = {R1, R2, …, Rm}, the set consisting of all resource types in the
system.
• request edge – directed edge P1 → Rj
• assignment edge – directed edge Rj → Pi
__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
22
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)

Process

Resource Type with 4 instances

• Pi requests instance of Rj

• Pi is holding an instance of Rj

Rj
Pi

Resources Allocation Graph

Resource Allocation Graph With A Deadlock

Graph with A Cycle But No Deadlock

Basic facts-:
• If graph contains no cycles ⇒ no deadlock.
• If graph contains a cycle ⇒ deadlock.
• If only one instance per resource type, then deadlock.
• If several instances per resource type, possibility of deadlock.

Methods for Handling Deadlocks

• Ensure that the system will never enter a deadlock state.

• Allow the system to enter a deadlock state and then recover.
• Ignore the problem and pretend that deadlocks never occur in the system; used by
most operating systems, including UNIX.

Deadlock Prevention

Restrain the ways request can be made.

• Mutual Exclusion – not required for sharable resources; must hold for non-
sharable resources.
• Hold and Wait – must guarantee that whenever a process requests a resource, it
does not hold any other resources.
o Require process to request and be allocated all its resources before it
begins execution, or allow process to request resources only when the
process has none.
o Low resource utilization; starvation possible.

No Preemption –
1. If a process that is holding some resources requests another resource that
cannot be immediately allocated to it, then all resources currently being held
are released.
2. Preempted resources are added to the list of resources for which the process is
waiting.
3. Process will be restarted only when it can regain its old resources, as well as
the new ones that it is requesting.
4. Circular Wait – impose a total ordering of all resource types, and require that
each process requests resources in an increasing order of enumeration.

Safe State
• When a process requests an available resource, system must decide if immediate
allocation leaves the system in a safe state.
• System is in safe state if there exists a sequence <P1, P2, …, Pn> of ALL the
processes is the systems such that for each Pi, the resources that Pi can still
request can be satisfied by currently available resources + resources held by all
the Pj, with j < i.
• That is:
o If Pi resource needs are not immediately available, then Pi can wait until
all Pj have finished.
o When Pj is finished, Pi can obtain needed resources, execute, return
allocated resources, and terminate.
o When Pi terminates, Pi +1 can obtain its needed resources, and so on.
Basic facts
• If a system is in safe state ⇒ no deadlocks.
• If a system is in unsafe state ⇒ possibility of deadlock.
• Avoidance ⇒ Ensure that a system will never enter an unsafe state.

Safe, Unsafe and Deadlock State

Resource-Allocation Graph Scheme

• Claim edge Pi → Rj indicated that process Pj may request resource Rj; represented
by a dashed line.
• Claim edge converts to request edge when a process requests a resource.
• Request edge converted to an assignment edge when the resource is allocated to
the process.
• When a resource is released by a process, assignment edge reconverts to a claim
edge.
• Resources must be claimed a priori in the system.

Resource-Allocation Graph

Unsafe State In Resource-Allocation Graph

Banker’s Algorithm
• Multiple instances.
• Each process must a priori claim maximum use.
• When a process requests a resource it may have to wait.
• When a process gets all its resources it must return them in a finite amount of
time.

Data Structures for the Banker’s Algorithm

Let n = number of processes, and m = number of resources types.

• Available: Vector of length m. If available [j] = k, there are k instances of
resource type Rj available.
• Max: n x m matrix. If Max [i,j] = k, then process Pi may request at most k
instances of resource type Rj.
• Allocation: n x m matrix. If Allocation [i,j] = k then Pi is currently allocated
k instances of Rj.
• Need: n x m matrix. If Need [i,j] = k, then Pi may need k more instances of Rj
to complete its task.

Need [i,j] = Max[i,j] – Allocation [i,j].

Safety Algorithm

Let Work and Finish be vectors of length m and n, respectively.

1. Initialize:
Work = Available
Finish [i] = false for i = 0, 1, …, n- 1.
2. Find and i such that both:
(a) Finish [i] = false
(b) Need i ≤ Work
If no such i exists, go to step 4.

3. Work = Work + Allocation

Finish[i] = true
go to step 2.
__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
28
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
4. If Finish [i] == true for all i, then the system is in a safe state.

Resource-Request Algorithm for Process Pi

Request = request vector for process Pi. If Request i [j] = k then process Pi wants
k instances of resource type Rj.
1. If Request i ≤ Need i go to step 2. Otherwise, raise error condition, since process
has exceeded its maximum claim.
2. If Request i ≤ Available, go to step 3. Otherwise Pi must wait, since resources
are not available.
3. Pretend to allocate requested resources to Pi by modifying the state as follows:
Available = Available – Request;
Allocation i = Allocation i + Request i;
Need i = Need i – Request i;
 If safe ⇒ the resources are allocated to Pi.
 If unsafe ⇒ Pi must wait, and the old resource-allocation state is
restored

Example of Banker’s Algorithm

• 5 processes - P0 through P4;
• 3 resource types:
o A (10 instances),
o B (5instances), and
o C (7 instances).
• Snapshot at time T0:
Allocation Max Available
ABC ABC ABC
P0 0 1 0 753 332
P1 2 0 0 322
P2 3 0 2 902
P3 2 1 1 222
P4 0 0 2 433

• The content of the matrix Need is defined to be Max – Allocation.

• The system is in a safe state since the sequence < P1, P3, P4, P2, P0> satisfies
safety criteria.

Example: P1 Request (1,0,2)

• Check that Request ≤ Available (that is, (1,0,2) ≤ (3,3,2) ⇒ true.

Allocation Need Available
ABC ABC ABC
P0 010 743 230
P1 302 020
P2 301 600
P3 211 011
P4 002 431
• Executing safety algorithm shows that sequence < P1, P3, P4, P0, P2> satisfies
safety requirement.
• Can request for (3,3,0) by P4 be granted?
• Can request for (0,2,0) by P0 be granted?

Deadlock Detection
• Allow system to enter deadlock state
• Detection algorithm
• Recovery scheme

Unit-3
__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
30
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
INTRODUCTION, BASIC OF
MEMORY MANAGEMENT

Objectives

In the last two lectures, you learnt about deadlocks, their characterization and various
Deadlock-handling techniques. At the end of this lecture, you will learn about Memory
management, swapping and concept of contiguous memory allocation. Memory
Management is also known as Storage or Space Management.

Memory management involves

• Subdividing memory to accommodate multiple processes.
• Allocating memory efficiently to pack as many processes into memory as possible.

When is address translation performed?

1. At compile time.
• Primitive.
• Compiler generates physical addresses.
• Requires knowledge of where the compilation unit will be loaded.
• Rarely used (MSDOS .COM files).

2. At link-edit time (the “linker lab”)

• Compiler
• Generates relocatable addresses for each compilation unit.
• References external addresses.
• Linkage editor
• Converts the relocatable addr to absolute.
• Resolves external references.
• Misnamed ld by UNIX.
• Also converts virtual to physical addresses by knowing where the linked program will
be loaded. Linker lab “does” this, but it is trivial since we assume the linked program
will be loaded at 0.
• Loader is simple.

• Hardware requirements are small.

3. At load time
• Similar to at link-edit time, but do not fix the starting address.
• Program can be loaded anywhere.
• Program can move but cannot be split.
• Need modest hardware: base/limit registers.
• Loader sets the base/limit registers.

4. At execution time
• Addresses translated dynamically during execution.
• Hardware needed to perform the virtual to physical address translation quickly.
• Currently dominates.
• Much more information later.

MMU - Logical vs. Physical Address Space

• Concept of logical address space bound to a separate physical address space - central
to proper memory management
• Logical (virtual) address – generated by the CPU
• Physical address – address seen by the memory unit
• Logical and physical addresses:
• Same in compile-time and load-time address-binding schemes
• Different in execution-time address-binding scheme
• Memory Management Unit: HW device that maps virtual to physical address
• Simplest scheme: add relocation register value to every address generated by process
when sent to memory

Dynamic Loading
• Routine is not loaded until it is called.
• Better memory-space utilization; unused routine is never loaded.
• Useful when large amounts of code are needed to handle infrequently occurring
cases.
• No special support from the operating system is required; implemented through
program design.

Dynamic Linking
• Linking postponed until execution time.
• Small piece of code, stub, used to locate the appropriate memory-resident library
routine.
• Stub replaces itself with the address of the routine, and executes the routine.
• Operating system needed to check if routine is in processes’ memory address.

Overlays
• To handle processes larger than their allocated memory.
• Keep in memory only instructions and data needed at any given time.
Implemented by user, no special support needed from OS, programming design is
Complex. Overlay for a two-pass assembler:
Pass 1 70KB
Pass 2 80KB
Symbol Table 20KB
Common Routines 30KB
Total 200KB
Two overlays: 120 + 130KB

The Need for Memory Management

Main memory is generally the most critical resource in a computer system in terms of the
speed at which programs run and hence it is important to manage it as efficiently as
possible.

The requirements of memory management are

• Relocation
• Protection
• Sharing
• Logical Organization
• Physical Organization

What is meant by relocation?

• Programmer does not know where the program will be placed in memory when it is
executed
• While the program is executing, it may be swapped to disk and returned to main
memory at a different location (relocated)
• Memory references must be translated in the code to actual physical memory address

What is meant by protection?

• Processes should not be able to reference memory locations in another process
without permission
• Impossible to check absolute addresses in programs since the program could be
relocated
• Must be checked during execution
Operating system cannot anticipate all of the memory references a program will make

What does sharing mean?

• Allow several processes to access the same portion of memory
• Better to allow each process (person) access to the same copy of the program rather
than have their own separate copy

What does logical organization of memory mean?

• Programs are written in modules
• Modules can be written and compiled independently
• Different degrees of protection given to modules (read-only, execute-only)
• Share modules

What does physical organization of memory mean?

• Memory available for a program plus its data may be insufficient
• Overlaying allows various modules to be assigned the same region of memory
• Programmer does not know how much space will be available

Swapping
Swapping is the act of moving processes between memory and a backing store. This is
done to free up available memory. Swapping is necessary when there are more processes
than available memory. At the coarsest level, swapping is done a process at a time. That
is, an entire process is swapped in/out.

The various memory management schemes available

There are many different memory management schemes. Selection of a memory
management scheme for a specific system depends on many factors, especially the
hardware design of the system. A few of the schemes are given here:
• Contiguous, Real Memory Management System
• Non-contiguous Real Memory Management System
• Non-contiguous, Virtual Memory Management System

OPERATING SYSTEM
In this lecture, you will learn about the contiguous memory management scheme. You
will also learn about virtual memory and concept of swapping.
First let me explain what swapping means. You are all aware by now that for a process to
be executed, it must be in the memory. Sometimes, however, a process can be swapped
(removed) temporarily out of the memory to a backing store (such as a hard disk) and
then brought back into memory for continued execution.
Let me explain with an example:

Consider a multiprogramming environment with a round robin CPU scheduling

algorithm. When a quantum (time-slice) expires, the memory manger will start to swap
out processes that just finished, and to swap in another process to the memory space that
has been freed. In the meantime, the CPU scheduler will allocate a time slice to some
other process in memory. Thus when each process finishes its quantum, it will be
swapped with another process.

Are there any constraints on swapping?

Yes, there are. If you want to swap a process, you must be sure that it is completely idle.
If a process is waiting for an I/O operation that is asynchronously accessing the user
memory for I/O buffers, then it cannot be swapped. Having learnt about the basics of
memory management and concept of swapping, we will now turn our attention to the
contiguous memory management scheme.

What is the meaning of the term contiguous?

Contiguous literally means adjacent. Here it means that the program is loaded into a
series of adjacent (contiguous) memory locations.
In contiguous memory allocation, the memory is usually divided into two partitions, one
for the OS and the other for the user process.

At any time, only one user process is in memory and it is run to completion and then the
next process is brought into the Memory. This scheme is sometimes referred to as the
Single Contiguous Memory Management.

What are the advantages and disadvantages of this Scheme?

First, let us look at the advantages:
• Starting physical address of program is known at compile time
• Executable machine code has absolute addresses only. They need not be
changed/translated at execution time
• Fast access time as there is no need for address translation
• Does not have large wasted memory
• Time complexity is small
The disadvantage is that, it does not support multiprogramming and hence no concept of
sharing.

What about protection?

Since there is one user process and the OS in the memory, it is necessary to protect the
OS code from the user code. This is achieved through two mechanisms:
• Use of Protection Bits
• Use of Fence Register

Protection Bits:
• One bit for each memory block
• The memory block may belong to either user process or the OS
• Size of memory block should be known
• The bit is 0 if the word belongs to OS
• The bit is 1 if the word belongs to user process

A mode bit in the h/w indicates if system is executing in

Privileged mode or user mode.
• If mode changes, the h/w mode bit is also changed automatically.
• If user process refers to memory locations inside OS area, then the protection bit for
the referred word is 0 and the h/w mode bit is ‘user mode’. Thus user process is
prevented from accessing OS area.
• If OS makes a reference to memory locations being used by a user process then the
mode bit = ‘privileged’ and the protection bit is not checked at all.

Current mode bit prot. Bit access status

Process
USER u-mode 0 OS N
USER u-mode 1 user Y
OS p-mode 1 user Y
OS p-mode 0 OS Y

Fence Register
Similar to any other register in the CPU
Contains address of the ‘fence’ between OS and the user process (see Fig. 2)
Fence Register value = P
For every memory reference, when final address is in MAR (Memory Address
Register), it is compared with Fence Register value by h/w thereby detecting
protection violations.

OPERATING SYSTEM

FENCE
In a multi-programming environment, where more than one process is in the memory, we
have the fixed-partition scheme. In this scheme,
• Main memory is divided into multiple partitions
• Partitions could be of different sizes but ‘fixed’ at the time of system generation
• Could be used with or without ‘swapping’ and ‘relocation’
• To change partition sizes, system needs to be shut down and generated again with a
new partition size

Objectives
In the last lecture, you have learned about memory management, swapping and concept
of contiguous memory allocation. In this lecturer you are going to learn about how OS
manage the memory partitions.
So how does the OS manage or keep track of all these partitions?
In order to manage all the partitions,
The OS creates a Partition Description Table (PDT)Initially all the entries in PDT are
marked as ‘FREE’, When a partition is loaded into one of the partitions, the PCB of
each process contains the Id of the partition in which the process is running.

‘Status’ column is changed to ‘ALLOC’

How are the partitions allocated to various processes?

The sequence of steps leading to allocation of partitions to processes is given below:
• The long-term scheduler of the process manager decides which process is to be
brought into memory next.
• It finds out the size of the program to be loaded by consulting the Information
Manager of the OS (the compiler keeps the size of the program in the header of the
executable code).
• It then makes a request to the ‘partition allocate routine’ of the memory manager to
allocate free partition of appropriate size.
• It now loads the binary program in the allocated partition
(address translation may be necessary).
• It then makes an entry of the partition-id in the PCB before the PCB is linked to chain
of ready processes by using the Process Manager module.
• The routine in the Memory Manager now marks the status of that partition as
allocated.
• The Process Manager eventually schedules the process can a process be allocated to
any partition? The processes are allocated to the partitions based on the allocation
policy of the system. The allocation policies are:
• First Fit
• Best Fit
• Worst Fit
• Next Fit

Let me explain this with a simple example:

Refer to figure above.Free partitions are 1 and 4.So, which partition should be
allocated to a new process of size 50K?
First Fit and Worst Fit will allocate Partition 1 while Best Fit will allocate
Partition 4.

Do you know why?

In first fit policy, the memory manager will choose the first available partition that can
accommodate the process even though its size is more than that of the process. In worst
fit policy, the memory manager will choose the largest available partition that can
accommodate the process.
In best-fit policy, the memory manager will choose the partition
That is just big enough to accommodate the process

Are there any disadvantages of this scheme?

Yes. This scheme causes wastage of memory, referred to as fragmentation.
Let me explain with an example:
Suppose there is a process, which requires 20K of memory. There is a partition of size
40K available. Assuming that the system is following the First-fit policy, then this
partition would be allocated to the process. As a result, 20K of memory within the
partition is unused. This is called internal fragmentation.

Now consider the same 20K process. This time, though there are three partitions of 10K,
5K and 16K available. None of them are large enough to accommodate the 20K process.
There are no other smaller processes in the queue. Hence these three partitions remain
unused. This is waste of memory and is referred to as external fragmentation.

How do you ensure protection of processes in such a scheme?

Protection can be achieved in two ways:

• Protection Bits (used by IBM 360/370 systems).
• Limit Register.
Protection Bits:
• Divide the memory into 2 KB blocks.
• Each block has 4 bits reserved for protection called the ‘key’.
• Size of each partition had to be multiple of such 2K blocks.
• All the blocks associated with a partition allocated to a process are given the same
key.

So how does this mechanism work?

Let me explain with the following example:
Consider a physical memory of 64 KB. Assume each block is of 2KB.
• Total No. of blocks = 64/2 = 32 blocks
• ‘Key’ associated with each block is 4 bits long
• ‘Key string’ for 32 blocks is therefore 128 bits long
• System administrator defines a max of 16 partitions of different sizes (out of the
available 32 blocks)
• Each partition is then given a protection key in the range
0000 to 1111
Now a process is loaded into a partition

What are the disadvantages of this mechanism?

• Memory wastage due to internal fragmentation
• Limits maximum number of partitions (due to key length)
• Hardware malfunction may generate a different address but in the same partition -
scheme fails!!

Limit Register
The Limit Register for each process can be stored in the PCB and can be saved/restored
during context switch.
• If the program size were 1000, logical addresses generated would be 0 to 999
• The Limit Register therefore is set to 999
• Every ‘logical’ or ‘virtual’ address is checked to ensure that it is <= 999 and then
added to base register. If not, then hardware generates an error and process is aborted

VIRTUAL MEMORY- INTRODUCTION, PAGING

Objectives
In the last lecture, you learnt about memory management, Swapping and the contiguous
memory management scheme. In this lecture, you will get to know about non-contiguous
Memory management scheme and the concept of Paging and Segmentation.

Why Segmentation?

1. Pages are of a fixed size

In the paging scheme we have discussed, pages are of a fixed size, and the division of a
process’s address space into pages is of little interest to the programmer. The beginning
of a new page comes logically just after the end of the previous page.

2. Segments are of variable sizes

An alternate approach, called segmentation, divides the process’s address space into a
number of segments - each of variable size. A logical address is conceived of as
containing a segment number and offset within segment. Mapping is done through a
segment table, which is like a page table except that each entry must now store both a
physical mapping address and a segment length (i.e. a base register and a bounds register)
since segment size varies from segment to segment.

No (or little) internal fragmentation, but we now have external

fragmentation
Whereas paging suffers from the problem of internal fragmentation due to the fixed size
pages, a segmented scheme can allocate each process exactly the memory it needs (or
very close to it - segment sizes are often constrained to be multiples of some small unit
such as 16 bytes.) However, the problem of external fragmentation now comes back,
since the available spaces between allocated segments may not be of the right sizes to
satisfy the needs of an incoming process. Since this is a more difficult problem to cope
with, it may seem, at first glance, to make segmentation a less desirable approach than
paging.

4. Segments can correspond to logical program units

However, segmentation has one crucial advantage that pure paging does not.
Conceptually, a program is composed of a number of logical units: procedures, data
structures etc. In a paging scheme, there is no relationship between the page boundaries

1. Example with shared segments

Example: A Pascal program consists of three procedures plus a main program. It uses the
standard Pascal IO library for read, write etc. At runtime, a stack is used for procedure
activation records. This program might be allocated memory in seven segments:
• One segment for the main routine.
• Three segments, one for each procedure.
• One segment for Pascal library routines.
• One segment for global data.
• One segment for the runtime stack.

2. Several user programs can reference the same segment

Some of the segments of a program may consist of library code shareable with other
users. In this case, several users could simultaneously access the same copy of the code.
For example, in the above, the Pascal library could be allocated as a shared segment. In
this case, each of the processes using the shared code would contain a pointer the same
physical memory location.
Segment table
user A
Segment table
user B
Segment table
user C
Ptr to private code Ptr to private code Ptr to private code
Ptr to private code Ptr to shared code Ptr to private code
Ptr to shared code Ptr to private code Ptr to private code
Ptr to private code Ptr to shared code
Ptr to private code Ptr to private code
This would not be possible with pure paging, since there is no one-to-one correspondence
between page table entries and logical program units.

3. Protection issues
Of course, the sharing of code raises protection issues. This is most easily handled by
associating with each segment table entry an access control field - perhaps a single bit. If
set, this bit might allow a process to read from the segment in question, but not to write to
it. If clear, both read and write access might be allowed. Now, segments that correspond
to pure code (user written or library) are mapped read only. Data is normally mapped

What is segmentation?
In paging, the user’s view of memory and the actual physical memory are separated.
They are not the same. The user’s view is mapped onto the physical memory.
A program is program is a collection of segments. A segment is a logical unit such as:
main program,
procedure,
function,
method,
object,
local variables, global variables,
common block,
stack,
symbol table, arrays

Segmentation Architecture
Logical address consists of a two tuple:

<Segment-number, offset>
• Segment table – maps two-dimensional physical addresses; each table entry has: base
– starting physical address of segments in memory limit – length of the segment
• Segment-table base register (STBR) points to the segment table’s location in memory
• Segment-table length register (STLR) indicates number of segments used by a
program; segment number s is legal if s < STLR.
• Allocation: first fit/best fit and get external fragmentation.
• Protection – easier to map; associated with each entry in segment table: validation bit
= 0 Þ illegal segment
• Read/write/execute privileges.
• Protection bits associated with segments; code sharing occurs at segment level.
• Since segments vary in length, memory allocation is a dynamic storage-allocation
problem.
• A segmentation example is shown in the following diagram.

What is user’s view of memory?

The user of a system does not perceive memory as a linear array of bytes. The user
prefers to view memory as a collection of variable sized segments with no necessary
ordering among segments.

__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
47
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
Let me explain this with an example:
Consider how you think of a program when you are writing it. You think of it as a main
program with set of subroutines, procedures, functions, or variables. Each of these
modules is referred to by a name. You are not concerned about where in memory these
modules are placed. Each of these segments is of variable length and is intrinsically
defined by the purpose of the segment in the program.
Thus segmentation is a memory management scheme that supports this user view of
memory. Thus a logical address space is a collection of segments with each segment
having a name and length.

What is a 2-d address?

• In paging, a 1-d virtual address and a 2-d address would be exactly same in binary
form as page size is an exact power of
• In segmentation, segment size is unpredictable. Hence we need to express the address
in 2-d form explicitly.
• A system implementing segmentation needs to have a different address format and a
different architecture to decode the address

Segmentation with Paging

• The Intel Pentium uses segmentation with paging for memory management, with a
two-level paging scheme.

What are the advantages and disadvantages of segmentation?

We will first look at the advantages:
1. The page faults are minimized as the entire segment is present in the memory. Only
access violations need to be trapped.
2. No internal fragmentation as the segment size is customized for each process.
And now the disadvantages:
1. Allocation/reallocations sequences result in external fragmentation that needs a
periodic pause for compaction to take place

Review Questions
1. How does paging differ from segmentation?
2. Describe the mechanism of translating a logical address to physical address in
segmentation.

VIRTUAL MEMORY- INTRODUCTION, PAGING

Objectives
In the last lecture, you learnt about memory management, swapping and the contiguous
memory management scheme. In this lecture, you will get to know about Virtual Memory
Virtual memory is a memory management technique that allows the execution of
processes that may not be completely in main memory and do not require contiguous
memory allocation. The address space of virtual memory can be larger than that physical
memory.
Advantages:
• Programs are no longer constrained by the amount of physical memory that is
available
• Increased degree of multiprogramming
• Less overhead due to swapping

Why Do We Need Virtual Memory?

Storage allocation has always been an important consideration in computer programming
due to the high cost of main memory and the relative abundance and lower cost of
secondary storage. Program code and data required for execution of a process must reside
in main memory to be executed, but main memory may not be large enough to
accommodate the needs of an entire process. Early computer programmers divided
programs into sections that were transferred into main memory for a period of processing
time. As the program proceeded, new sections moved into main memory and replaced
sections that were not needed at that time. In this early era of computing, the programmer
was responsible for devising this overlay system.
As higher level languages became popular for writing more complex programs and the
programmer became less familiar with the machine, the efficiency of complex programs
suffered from poor overlay systems. The problem of storage allocation became more
complex.
Two theories for solving the problem of inefficient memory management emerged —
static and dynamic allocation. Static allocation assumes that the availability of memory
resources and the memory reference string of a program can be predicted. Dynamic
allocation relies on memory usage increasing and decreasing with actual program needs,
not on predicting memory needs.

__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
49
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
Program objectives and machine advancements in the ’60s made the predictions required
for static allocation difficult, if not impossible. Therefore, the dynamic allocation solution
was generally accepted, but opinions about implementation were still divided. One group
believed the programmer should continue to be responsible for storage allocation, which
would be accomplished by system calls to allocate or dellocate memory. The second
group supported automatic storage allocation performed by the operating system,
because of increasing complexity of storage allocation and emerging importance of
multiprogramming. In 1961, two groups proposed a one-level memory store. One
proposal called for a very large main memory to alleviate any need for storage allocation.
This solution was not possible due to very high cost.
The second proposal is known as virtual memory

Definition
Virtual memory is a technique that allows processes that may not be entirely in the
memory to execute by means of automatic storage allocation upon request. The term
virtual memory refers to the abstraction of separating LOGICAL memory—memory as
seen by the process—from PHYSICAL memory—memory as seen by the processor.
Because of this separation, the programmer needs to be aware of only the logical memory
space while the operating system maintains two or more levels of physical memory
space.
The virtual memory abstraction is implemented by using secondary storage to augment
the processor’s main memory.
Data is transferred from secondary to main storage as and when
necessary and the data replaced is written back to the secondary
Storage according to a predetermined replacement algorithm. If the data swapped is
designated a fixed size, this swapping is called paging; if variable sizes are permitted and
the data is split along logical lines such as subroutines or matrices, it is called
Segmentation. Some operating systems combine segmentation and paging. The diagram
illustrates that a program generated address ( 1 ) or” logical address” consisting of a
logical page number plus the location within that page (x) must be interpreted or
“mapped” onto an actual (physical) main memory address by the operating System using
an address translation function or mapper (2). If the page is present in the main memory,
the mapper substitutes.
The physical page frame number for the logical number (3). If the mapper detects that the
page requested is not present in main memory, a fault occurs and the page must be read
into a frame in main memory from secondary storage (4, 5).

__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
50
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
What does the Mapper do?
The mapper is the part of the operating system that translates the logical page number
generated by the program into the physical page frame number where the main memory
holds the page. This translation is accomplished by using a directly indexed table called
the page table which identifies the location of all the program’s pages in the main store. If
the page table reveals that the page is, in fact, not resident in the main memory, the
mapper issues a page fault to the operating system so that execution is suspended on the
process until the desired page can be read in from the secondary store and placed in main
memory.
The mapper function must be very fast if it is not to substantially increase the running
time of the program. With efficiency in mind, where is the page table kept and how is it
accessed by the mapper? The answer involves associative memory.

Virtual memory can be implemented via:

• Demand paging
• Demand segmentation

What is demand paging?

Demand paging is similar to paging with swapping. Processes normally reside on the disk
(secondary memory). When we want to execute a process, we swap it into memory.
Other than swapping the entire process into memory, however, we use lazy swapper.

What is a lazy swapper?

A lazy swapper never swaps a page into memory unless that page will be needed. Since
we are now viewing a process as a sequence of pages rather than one large contiguous
address space, the use of the term swap is technically incorrect. A swapper manipulates
entire processes whereas a pager is concerned with the individual pages of a process. It is
correct to use the term pager in connection with demand paging.

So how does demand paging work?

Whenever a process is to be swapped in, the pager guesses which pages will be used
before the process is swapped out again. So instead of swapping in the whole process, the
pager brings only those necessary pages into memory. Here, I would like to add that
demand paging requires hardware support to distinguish between those pages that are in
memory and those that are on the disk.
Let me give you an example. Suppose you need white paper for doing your assignment.
You could get it in two ways. In the first method, you will purchase about 500 sheets of
paper. By the time you complete your assignment, you would have used only 100 sheets!
So you are wasting 400 sheets of paper. In the second method, you could get 10 sheets of

__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
51
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
paper to start with and later on, as and when required, you could demand additional
sheets of paper. This way, you will not be wasting money.
You talked about hardware support being required for demand paging. How does
this support work?
An extra bit called the valid-invalid bit is attached to each entry in the page table. This bit
indicates whether the page is in memory or not. If the bit is set to invalid, then it means
that the page is not in memory. On the other hand, if the bit is set to valid, it means that
the page is in memory. The following figure illustrates this:
What happens if a process tries to use a page that was not brought into memory?
If you try to access a page that is marked invalid (not in memory), then page fault occurs.

How do you handle such page faults?

Upon page fault, the required page brought into memory by executing the following
steps:
1. Check an internal table to determine whether the reference was valid or invalid
memory access.
2. If invalid, terminate the process. If valid, page in the required page
3. Find a free frame (from the free frame list).
4. Schedule the disk to read the required page into the newly allocated frame
5. Modify the internal table to indicate that the page is in memory
6. Restart the instruction interrupted by page fault

What is the advantage of demand paging?

Demand paging avoids reading into memory pages that will not be used anyway. This
decreases the swap time and also the physical memory needed.
We saw that whenever the referenced page is not in memory, it needs to be paged in. To
start with, a certain number of frames in main memory are allocated to each process.
Pages (through demand paging) are loaded into these frames. What happens when a new
page needs to be loaded into memory and there are no free frames available? Well, the
answer is simple. Replace one of the pages in memory with the new one. This process is
called page replacement.

Virtual memory basics

A. Virtual memory is an extension of paging and/or segmentation
The basic implementation of virtual memory is very much like paging or segmentation.
In fact, from a hardware standpoint, virtual memory can be thought of as a slight
modification to one of these techniques. For the sake of simplicity, we will discuss virtual
memory as an extension of paging; but the same concepts would apply if virtual memory
were implemented as an extension of segmentation.

B. Page table used to translate logical to physical addresses

Recall that in a paging scheme each process has a page table which serves to map logical
addresses generated by the process to actual physical addresses. The address translation
process can be described as follows:
1. Break the logical address down into a page number and an offset.
2. Use the page number as an index into the page table to find the corresponding
frame number.
3. Using the frame number found there, generate a physical address by concatenating
the frame number and the offset from the original address.
Example: suppose the page table for a process looks like this. Assume that the page size
is 256 bytes, that logical addresses are 16 bits long, and that physical addresses are 24
bits long. (All numbers in the table are hexadecimal):
A logical address 02FE would be translated into the physical address 01A0FE.

C .Security in a paging system

In a paging system, one security provision that is needed is a check to be sure that the
page number portion of a logical address corresponds to a page that has been allocated to
the process. This can be handled either by comparing it against a maximum page number
or by storing a validity indication in the page table. This can be done by providing an
additional bit in the page table entry in addition to the frame number. In a paging system,
an attempt to access an invalid page causes a hardware trap, which passes control to the
operating system. The OS in turn aborts the process.

D Situations that cause traps to the Operating System

In a virtual memory system, we no longer require that all of the pages belonging to a
process be physically resident in memory at one time. Thus, there are two reasons why a
logical address generated by a process might give rise to a hardware trap:

1. Violations

2. Page Faults
The logical address is in the range of valid addresses, but the corresponding page is not
currently present in memory, but rather is stored on disk. The operating system must
bring it into memory before the process can continue to execute. (We will call this
condition a page fault).

E. Need a paging device to store pages not in memory

In a paging system, a program is read into memory from disk all at once. Further, if
swapping is used, then the entire process is swapped out or in as a unit. In a virtual
memory system, processes are paged in/out in a piece-wise fashion. Thus, the operating
system will need a paging device (typically a disk) where it can store those portions of a
process which are not currently resident.
1. When a fault for a given page occurs, the operating system will read the page in from
the paging device.
2. Further, if a certain page must be moved out of physical memory to make room for
another being brought in, then the page being removed may need to be written out to
the

Paging
Paging device first. (It need not be written out if it has not been altered since it was
brought into memory from the paging device.)
3. When a page is on the paging device rather than in physical memory, the page table
entry is used to store a pointer to the page’s location on a the paging device.

F. Virtual memory has an impact on CPU scheduling

In a virtual memory system, the hardware can behave in basically the same way as for
paging. However, the operating system no longer simply aborts the process when the
process accesses an invalid page. Instead, it determines which of the above two reasons
caused the trap. If it is the latter, then the operating system must initiate the process of
bringing in the appropriate page. The process, of course, must be placed into a wait state
until this is completed. So our set of possible process states must be extended from:

RUNNING
READY
WAITING for IO to complete
to:
__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
54
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
RUNNING
READY
WAITING for IO to complete
WAITING for a page to be brought in
(Note, though, that a page wait is in reality just another form of IO wait, except that here
the reason for the wait is not an explicit IO instruction in the process.)

G. Hardware support beyond that for paging along is required for virtual
memory
Though the burden of recognizing and handling page faults falls on the operating system,
certain provisions must be present in the hardware that are not needed with simple
paging:

1. A page fault could occur while a single instruction is being carried out
The ability to restart an instruction that caused a fault in midstream. This can be tricky if
the instruction accesses large blocks of memory - e.g. a block move that copies a
character string en masse.

2. Page table entry should include a “dirty” bit

Though it is not strictly necessary, it is desirable to include a “written-in” bit in the page
table entry, along with the valid bit noted above. This bit is set if any location in the page
has been modified since it was brought into physical memory. This bit comes into play
when the operating system finds it necessary to take the frame away from a page to make
room for a new page being faulted in. If the old page has not been written in, then it need
not be written back to disk, since it is the same as the copy on disk that was brought in
originally.

3. May want a bit to indicate that a page has been accessed

Some implementations also require a per-page accessed bit that is set whenever any
access (read or write) to the page occurs. This can be used to help decide which pages are
no longer being actively used and so can be paged out to make room for new pages
coming in. Not all memory management strategies require this, however.

Virtual memory design issues

A. Policy for bringing pages into memory
1. When does the OS decide to bring a page in?
We have already noted that, in general, only a portion of the pages belonging to a given
process will actually be resident in physical memory at any given time. Under what
circumstances is a given page brought in from the paging device?

__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
55
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
2. Demand paging
The simplest policy is demand paging. Simply stated, under demand paging, a given
page is only brought into memory when the process it belongs to attempts to access it.
Thus, the number of page faults generated by a process will at least be equal to the
number of pages it uses. (The number of faults will be higher if a page that has been used
is removed from memory and then is used again.) In particular, when a process starts
running a program there will be a period of time when the number of faults generated by
the process is very high:

a. Page faults occur one-by-one as program begins running

To start running the program, the CPU PC register is set to the first address in the
program. Immediately, a page fault occurs and the first page of the program is brought in.
Once control leaves this page (due either to running off the end or to a subroutine call)
another fault occurs etc. Further, any access to data will also generate a fault.

b. Startup and post-swapped time can be slow

An implication of pure demand paging is that the initial startup of a new program may
take a significant amount of time, since each page needed will require a disk access to get
it. Likewise, if a process is ever swapped out of memory due to a long IO wait then when
it is brought back in it will be paged in one page at a time.

c. No pages are brought into memory unnecessarily

The chief advantage of demand paging is that no pages are ever brought into memory
unnecessarily. For example, if a program contains code for handling a large number of
different kinds of input data, only the code needed for the actual data presented to it will
ever be brought in.

3. Anticipatory or Pre-paging
Some systems combine demand paging with some form of anticipatory paging or pre-
paging. Here, the idea is to bring a page in before it is accessed because it is felt that there
is good reason to expect that it will be accessed. This will reduce the number of page
faults a process generates, and thus speed up its startup at the expense of possibly wasting
physical memory space on unneeded pages. Anticipatory paging becomes increasingly
attractive as physical memory costs go down.

a. Pages known to be initially required can all be loaded at once

When initially loading a program, there may be a certain minimum set of pages that have
to be accessed for program initialization before branching based on the input data begins
to occur. These can all be read in at once.

b. All pages swapped out can later be swapped back in at once

c. Structure of page device may make it advantageous to read several pages at once
Another form of anticipatory paging is based on the clustering of the paging device. If
several pages reside in the same cluster on the paging device, then it may be
advantageous to read all of them in if any one of them is demanded, since the added
transfer time is only a small fraction of the total time needed for a disk access. This is
especially advantageous if the pages correspond to logically-adjacent memory locations.

B. Page replacement policies: What page do we remove from memory?

Over time, the number of pages physically resident in memory on a system under any
significant load will eventually equals the number of available frames. At this point,
before any new page can be faulted in a currently resident page must be moved out to
make room for it. The question of how to select a page to be replaced is a very important
one. In general, there are two kinds of page replacement policies.

1. Global policies
When process X needs to fault in a new page, the set of
Candidates for replacement includes all pages belonging to all
Processes on the system. Note that unless a page belonging
to X already happens to be chosen, this will result in an
Increase in the total amount of physical memory allocated to
X.

2. Local policies
When process X needs to fault in a new page, the set of candidates for replacement
includes only those pages currently belonging to process X. Note that this means that the
total amount of physical memory allocated to X will not change.

3. In general, a system will have to incorporate both kinds of policy:

a. At startup, we must use a global policy

When a process is just starting up, a global policy will have to be used since the new
process has few pages available as replacement candidates.

b. Local paging may be used to keep a particular process from using too much
memory

4. The working set of a process

Many of the policies to be discussed below can be applied either locally or globally. The
notion of a process’s working set can be used to help decide whether the process should
be allowed to grow by taking pages from other processes or should be required to page
against itself.

a. The working set is the set of pages that a process has accessed in the time interval
[T - T, T]
The working set for a process is defined in terms of some interval T back from the
current time T. Building on the principle of locality of reference, it is assumed that this
is a good approximation to the set of pages that the process must have physically resident
in order to run for an interval T into the future without a page fault. (The interval T is
chosen to keep the percentage of memory accesses resulting in a fault to an acceptable
level. A time corresponding to around 10,000 memory accesses being a good rule of
thumb.)

b. During the life of a process, there are times when the working set changes slowly
and other times when it changes rapidly
Studies of the memory access behavior of processes show that typically there are periods
of time during which the working set of a given process changes very little. During these
periods, if sufficient physical memory is allocated to the process then it can page locally
against itself with an acceptably low rate of page faults. These periods are separated by
bursts of paging activity when the process’s working set is changing rapidly. These
correspond to major stages in the program execution - e.g. the termination of one top
level subroutine and the starting up of another. When this happens performance is
improved if the global paging is used.

c. Maintaining a working set requires some system overhead

Of course, determining what the actual working set of a process is requires a certain
amount of overhead - notably keeping track of what pages have been referenced during a
past interval. (This is one of the places that a hardware referenced bit comes in.) One way
to keep track of a process’s working set involves using a timer that interrupts at the
chosen interval T:
• At the start of the interval, turn off all of the referenced bits in the page table for the
currently running process.
• When the timer interrupts, include in the working set only those pages whose
referenced bit is now on.

__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
58
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
d. The working set concept can also be applied without going to all of the effort
needed to determine the exact working set:
• If the page fault rate for a process lies within a certain empirically determined
range, then assume that it has sufficient physical memory allocated to it to hold its
(slowly evolving) working set and page it locally.
• If the page fault rate increases above the upper limit, assume its working set is
expanding and page it globally, allowing its physical memory allocation to grow to
keep pace with its presumably growing working set.
• If the page fault rate drops too low, then consider reducing its physical memory
allocation by not only paging it against itself but also allowing other processes to
take page frames from it. This corresponds to an assumption that the size of its
working set is less than the amount of physical memory currently allocated to it.

5. We defer detailed discussion of page replacement policies until we briefly note one
further issue.

C. The degree of memory over allocation.

1. It is unusual in today’s multi programmed systems for a single process to exceed the
limits of the system’s physical memory
We have seen that, under a virtual memory system, it is possible for the logical memory
allocated to any one process to exceed the amount of physical memory available. In
practice, however, this does not often occur, since virtual memories systems are generally
multi programmed and thus are configured with sufficient physical memory to allow
portions of many processes to be resident at once.

2. However, the sum of memory required by all processes on the system often exceeds
the amount of physical memory
However, the sum total of the logical address spaces allocated to all the processes on the
system will generally be far greater than the total amount of physical memory available.
(If this were not so, then virtual memory would be of no benefit.) When memory is over
allocated, each page faulted in will result in another page having to be moved out to make
room for it. In general:
a. Too little over allocation (or none at all)
This means that the resource of physical memory is not really being used well. Pages
that could be moved out to the paging device without harm are being kept in physical
memory needlessly.
b. But too much over allocation can lead to a serious performance problem known
as thrashing occurs when all of the pages that are memory resident are high-demand
pages that will be referenced in the near future. Thus, when a page fault occurs, the
page that is removed from memory will soon give rise to a new fault, which in turn
__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
59
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
removes a page that will soon give rise to a new fault ... In a system that is thrashing,
a high percentage of the system’s resources is devoted to paging, and overall CPU
utilization and throughput drop dramatically.
c. The only way to prevent thrashing is to limit the number of processes that are
actively competing for physical memory.
This can be done by using a form of intermediate scheduling, with certain processes
being swapped out wholesale as in a non virtual memory system.
Ex: VMS has the concept of the balance set - which is the set of processes currently
allowed to compete for physical memory. The size of the balance set is determined by the
criterion: sum total of the working sets of all processes in the balance set <= available
physical memory

PAGING ALGORITHMS AND SEGMENTATION

Objectives
In the last lecture, you learnt about paging and segmentation
Which are two methods of implementing virtual memory? You
Also saw the advantages and disadvantages of these two
Methods. In this lecture, we will study about a method which is
the combination of paging and segmentation.

Paged Segmentation
In this model, the logical memory is composed of segments.
Each segment is composed of pages. The per process segment
Table is in memory pointed to by register. Entries map segment
Number to page table base. The page table is as described in the
previous lecture.
How is the mapping from the logical address to?
Physical address done in this combined approach?
The Logical address now consists of segment number, page
Number, and offset. The segment number is indexed into
Segment table to get base of page table. The page number is
Then used to index into page table to get the frame number.

__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
60
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
The frame number is then concatenated with the offset to get
the physical address. The figure below gives an example of this
mapping.
What are the main advantages of this combined
approach?
The advantages stem out from the fact that it combines the
individual advantages of paging and segmentation.
• Reduces external fragmentation (due to paging within a
• segment)
• Multiple address spaces available (for various segments)
• Distinguishes between access violations and page faults
• Swapping can occur incrementally
• Instructions can have smaller address fields
What are the main disadvantages of this combined
approach?
• Two memory accesses per translation. First the SMT and
• then PMT.
• More tables to manage (SMT and PMT)

How can you minimize the memory access?

This can be done by providing something called as TLB
(Translation Look-aside Buffer). The TLB is like a cache. It
keeps the most recent translations. Only when there is a miss in
the TLB will the memory is accessed.

How does the TLB work?

When a reference to a page is made, the TLB is checked to see if
there is an entry. If yes, then the frame number is retrieved from
the TLB. If not, there is a TLB miss and the PMT is accessed. If
the page is in the PMT, then it is loaded from there into the
TLB and the physical address is computed. If the page is not
there in the PMT also, then a page fault occurs and the required

What is a page fault?

When a page is referenced and it is not in the PMT (and hence
in memory), then it needs to be fetched from the virtual
Memory. This is called as page fault.

INTRODUCTION TO INFORMATION
MANAGEMENT-CONCEPT OF FILE
STRUCTURES
• By going thru you will come across basic concepts related to
• files
• Basic file structures
• Various file operations

Introduction
Whatever the objectives of the applications, it involves the
generation and use of information. As you know the input of
the application is by means of a file, and in virtually all
Applications, output is saved in a file for long-term storage.
You should be aware of the objectives such as accessing of files,
saving the information and maintaining the integrity of the
contents, virtually all computer systems provide file management
services. Hence a file management system needs special
services from the operating system.
1. Files
__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
62
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
The following are the commonly discussed with respect to files:
• Field: Basic element of data. Its length and data type
• characterizes it. They can be of fixed or variable length.
• Record: Collection of related fields. Depending on the
• design, records may be of fixed or variable length. Ex: In
• sequential file organization the records are of fixed length
• where as in Line sequential file organization the records are
• of variable length.
• File: Collection of similar records and is referenced by name.
They have unique file names. Restrictions on access control
usually apply at the file level. But in some systems, such
controls are enforced at the record or even at the field level
also.
• Database: Collection of related data. The essential aspects of
• a database are that the relationships that exists among
• elements of data. The database itself consists of one or
• more types of files.
Files are managed by the operating system. How they are
structured, named, accessed, used, protected and implemented
are the major issues in operating system design. As a whole, the
part of the operating system deals with files is known as the file
system. The linked lists and bitmaps are used to keep track of
free storage and how many sectors there are in a logical block are
important to the designers of the file system.
1.1 File Naming: Files are an abstraction mechanism. The main
characteristic feature of abstraction mechanism is the way the
objects being managed are name. The exact rules for the file
naming vary from system to system, but all current operating
system allows strings of one to eight letters as legal file names.
Many file systems support names as long as 255 characters with
a distinguish in upper and lower case. Many operating systems
support two-part file names, with the two parts separated by a
period. The first part is called primary file name and the second
part is called secondary or extension file name.
1.2 File Structure: File can be structured in any of several ways.

__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
63
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
Three common possibilities are depicted (a) is an unstructured
sequence of bytes (b) record sequence (c) tree structure.
a) Unstructured sequence of bytes: It provide the maximum
flexibility. User programs can put anything they want in their
files and name them any way that is convenient.
b) Record sequence: In this model, a file is a sequence of fixed
length records each with some internal structure. Central idea
of a file being a sequence of records is the idea that the read
operation returns and the write operation overwrites or
appends one record.
c) Tree structure: In this organization, a file consists of a tree of
records, not necessarily all the same length, each containing a
key field in a fixed position in the record. The tree is sorted
on the key field, to allow rapid searching for a particular key.

File System components

• Device Drivers:
• Communicates directly with peripherals devices (disks,
• tapes, etc)
• Responsible for starting physical I/O operations on the
• device
• Processes the completion of an I/O request
• Schedule access to the device in order to optimize
• performance
• Basic File System:
• Uses the specific device driver
• Deals with blocks of data that are exchanged with the
• physical device
• Concerned with the placement of blocks on the disk
• Concerned with buffering blocks in main memory
• Logical File System
• Responsible for providing the previously discussed
• interface to the user including:
• File access
• Directory operations
• Security and protection.
File Types : Many operating systems support several types
of files. Unix and Windows, have regular files and directories.
Regular files are the ones that contain user information generally
__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
64
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
in ASCII form. Directories are system files for maintaining the
Structure of the file system. Character special files are related to
input/output and used to model serial I/O devices such as
terminals, printers and networks. Block special files are used to
Model disks.

File Access: Early operating systems provided only one

kind of file access: sequential access. In these system, a process
could read all the bytes or records in a file in order, starting at
the beginning, but could not skip around and read them our of
order. Sequential files were convenient when the storage
medium was magnetic tape, rather than disk. Files whose bytes
or records can be read in any order are called random access files.
Two methods are used form specifying where to start reading.
In the first one, every read operation gives the position in the
file to start reading at. In the second one, a special operation,
seek, is provided to set the current position. This allows the
system to use different storage techniques for the two classes.
Where as in modern operating systems all the files are
automatically random access.

File Attributes: Every file has a name and its data. In

addition all operating systems associate other information with
each file such as the date and time the file was created and the
file’s size. The list of attributes varies considerably from system
to system. Attributes such as protection, password, creator and
owner tell who may access it and who may not. The flags are
bits or short fields that control or enable some specific property.
The record length, key, position and key length fields are only
present in files whose records can be looked up using a key. The
various times keep track of when the file was created, most
recently accessed and most recently modified. These are useful
for a variety of purpose. The current size tells how big the file is
at present.
• File operations: Files exist to store information and allow
• it to be retrieved later. Different systems provide different
• operations to allow storage and retrieval. The few of them of
• the most common system calls relating to files are:
• Create: The file is created with no data. The purpose of
• the call is to announce that the file is coming and to set some
• of the attributes.
__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
65
SoftDot Hi –Tech Educational & Training Institute
(A unit of De Unique Educational Society)
• Delete: When the file is no longer needed, it has to be
• deleted to free up disk space.
• Open: Before using a file, a process must open, the
• purpose of the open call is to allow the system to fetch the
• attributes and list of disk addresses into main memory for
• rapid access on later calls.
• Close: When all the accesses are finished, the attributes
• and disk addresses are no longer needed, so the file should
• be closed to free up internal table space.
• Read: Data re read from file. Usually, the bytes a come
• from the current position. The caller must specify how much
• data are needed and must also provide a buffer to put them
• in.
• Write: Data are written to the file, again, usually at the
• current position. If the current position is end of the file
• then the file size gets increased.
• Append: This call is a restricted from of write. It can
• only add data to the end of the file.
• Seek: For random access files, a method is needed to
• specify from where to take the data.
• Get attributes: Processes often need to read file attributes
• to do their work.
• Set attributes: Some of the attributes are user settable
• and can be changed after the file has been created. This
• system call makes that possible. The protection mode
• information is an obvious example.
• Rename: It frequently happens that a user needs to
• change the name of an existing file.

__________________________________________________
SoftDot Hi –Tech Educational & Training Institute
South–Extension PitamPura Preet Vihar Janakpuri
New Delhi New Delhi New Delhi New Delhi
67

Solid Starts - First 100 Days
94% (18)
Solid Starts - First 100 Days
287 pages
Hourglass Workout Program by Luisagiuliet 2
76% (21)
Hourglass Workout Program by Luisagiuliet 2
51 pages
12 Week Program: Summer Body Starts Now
89% (45)
12 Week Program: Summer Body Starts Now
70 pages
Read People Like A Book by Patrick King-Edited
62% (66)
Read People Like A Book by Patrick King-Edited
12 pages
Livingood, Blake - Livingood Daily Your 21-Day Guide To Experience Real Health
77% (13)
Livingood, Blake - Livingood Daily Your 21-Day Guide To Experience Real Health
260 pages
Facial Gains Guide (001 081)
91% (45)
Facial Gains Guide (001 081)
81 pages
Cheat Code To The Universe
94% (77)
Cheat Code To The Universe
34 pages
Curse of Strahd
95% (467)
Curse of Strahd
258 pages
The Psychiatric Interview - Daniel Carlat
91% (34)
The Psychiatric Interview - Daniel Carlat
473 pages
The Borax Conspiracy
91% (57)
The Borax Conspiracy
14 pages
The Secret Language of Attraction
86% (107)
The Secret Language of Attraction
278 pages
How To Develop and Write A Grant Proposal
83% (541)
How To Develop and Write A Grant Proposal
17 pages
Workbook For The Body Keeps The Score
88% (52)
Workbook For The Body Keeps The Score
111 pages
Donald Trump & Jeffrey Epstein Rape Lawsuit and Affidavits
83% (1016)
Donald Trump & Jeffrey Epstein Rape Lawsuit and Affidavits
13 pages
KamaSutra Positions
78% (69)
KamaSutra Positions
55 pages
KamaSutra Positions
69% (83)
KamaSutra Positions
55 pages
7 Hermetic Principles
93% (28)
7 Hermetic Principles
3 pages
27 Feedback Mechanisms Pogil Key
75% (12)
27 Feedback Mechanisms Pogil Key
6 pages
36 Questions That Lead To Love
91% (35)
36 Questions That Lead To Love
3 pages
Sample Mental Health Progress Note
96% (47)
Sample Mental Health Progress Note
3 pages
How 2 Setup Trust
97% (307)
How 2 Setup Trust
3 pages
The 36 Questions That Lead To Love - The New York Times
94% (34)
The 36 Questions That Lead To Love - The New York Times
3 pages
100 Questions To Ask Your Partner
80% (35)
100 Questions To Ask Your Partner
2 pages
Satanic Calendar
25% (55)
Satanic Calendar
4 pages
The 36 Questions That Lead To Love - The New York Times
95% (21)
The 36 Questions That Lead To Love - The New York Times
3 pages
Jeffrey Epstein39s Little Black Book Unredacted PDF
75% (12)
Jeffrey Epstein39s Little Black Book Unredacted PDF
95 pages
ALCHEMIST
64% (14)
ALCHEMIST
4 pages
1001 Songs
71% (69)
1001 Songs
1,798 pages
The 4 Hour Workweek, Expanded and Updated by Timothy Ferriss - Excerpt
23% (954)
The 4 Hour Workweek, Expanded and Updated by Timothy Ferriss - Excerpt
38 pages
Zodiac Sign & Their Most Common Addictions
63% (30)
Zodiac Sign & Their Most Common Addictions
9 pages
OpenWrt USB Print Storage
No ratings yet
OpenWrt USB Print Storage
2 pages
Unit 1
No ratings yet
Unit 1
33 pages
CF Notes - Unit 5
No ratings yet
CF Notes - Unit 5
30 pages
Operating System - Module I
No ratings yet
Operating System - Module I
12 pages
Lecture Notes Operating System
No ratings yet
Lecture Notes Operating System
83 pages
Unit 1
No ratings yet
Unit 1
9 pages
Operating System Notes: Index
No ratings yet
Operating System Notes: Index
32 pages
Chapter-3-Computer-Peripherals-and-Software
No ratings yet
Chapter-3-Computer-Peripherals-and-Software
28 pages
Cse V Operating Systems (10cs53) Solution
No ratings yet
Cse V Operating Systems (10cs53) Solution
63 pages
OS Notes
No ratings yet
OS Notes
86 pages
OS Notes
No ratings yet
OS Notes
83 pages
Os Overview 4 13
No ratings yet
Os Overview 4 13
10 pages
OS Notes Unit2
No ratings yet
OS Notes Unit2
33 pages
OS_Chapter 1
No ratings yet
OS_Chapter 1
37 pages
Operating System - 3rd Sem
No ratings yet
Operating System - 3rd Sem
85 pages
OS NOTES (1)
No ratings yet
OS NOTES (1)
137 pages
CH1_2.pptx
No ratings yet
CH1_2.pptx
55 pages
Os Notes Final
No ratings yet
Os Notes Final
145 pages
Operating System Notes
No ratings yet
Operating System Notes
86 pages
Operating System Notes
No ratings yet
Operating System Notes
86 pages
Operatig System
100% (1)
Operatig System
29 pages
What Is An Operating System?
No ratings yet
What Is An Operating System?
15 pages
IntroductiontoOS_complete
No ratings yet
IntroductiontoOS_complete
70 pages
Operating Sysytem Notes
No ratings yet
Operating Sysytem Notes
86 pages
Installing and Optimizes Operating
No ratings yet
Installing and Optimizes Operating
80 pages
OS Unit 1 Notes
No ratings yet
OS Unit 1 Notes
23 pages
E CONTENT - OS
No ratings yet
E CONTENT - OS
22 pages
OS Lecture 1
No ratings yet
OS Lecture 1
27 pages
ch1 os last
No ratings yet
ch1 os last
43 pages
OS Notes
No ratings yet
OS Notes
8 pages
OS-Module I
No ratings yet
OS-Module I
20 pages
01. OS- Introduction
No ratings yet
01. OS- Introduction
24 pages
Unit-1 Python New 2020
No ratings yet
Unit-1 Python New 2020
17 pages
Operating System
No ratings yet
Operating System
117 pages
OS Unit 1
No ratings yet
OS Unit 1
36 pages
CSC 212 - Operating System
No ratings yet
CSC 212 - Operating System
115 pages
Module 1
No ratings yet
Module 1
59 pages
Introduction To Operating Systems
No ratings yet
Introduction To Operating Systems
155 pages
4 GOAT Computer Awareness PDF - Operating System
No ratings yet
4 GOAT Computer Awareness PDF - Operating System
15 pages
Chapter1 Unit1
No ratings yet
Chapter1 Unit1
105 pages
Introduction To Operating Systems, System Structures
No ratings yet
Introduction To Operating Systems, System Structures
35 pages
OS_3_lyst1732519927680
No ratings yet
OS_3_lyst1732519927680
460 pages
01
No ratings yet
01
33 pages
Operating System: Digital Notes by
No ratings yet
Operating System: Digital Notes by
86 pages
Oslecture1423726024 PDF
No ratings yet
Oslecture1423726024 PDF
86 pages
Introduction To Operating System
No ratings yet
Introduction To Operating System
4 pages
Design and Analysis of Algorithms
No ratings yet
Design and Analysis of Algorithms
59 pages
Os 1-5 Units Complete Notes
No ratings yet
Os 1-5 Units Complete Notes
190 pages
Case Study Aos
No ratings yet
Case Study Aos
15 pages
OS Unit 1
No ratings yet
OS Unit 1
41 pages
Os Module-1 Notes
No ratings yet
Os Module-1 Notes
60 pages
1.Operating System-1
No ratings yet
1.Operating System-1
62 pages
Os 1 5 86
No ratings yet
Os 1 5 86
82 pages
Computer Software1
No ratings yet
Computer Software1
67 pages
Module 1 Os
No ratings yet
Module 1 Os
32 pages
M 1
No ratings yet
M 1
59 pages
module 1 os
No ratings yet
module 1 os
19 pages
Chapter-1 OSY
No ratings yet
Chapter-1 OSY
19 pages
Fund'S of Operating Systems: Prakash K
No ratings yet
Fund'S of Operating Systems: Prakash K
97 pages
Touchpad Modular Ver. 1.1 Class 7: Windows 7 & MS Office 2010
From Everand
Touchpad Modular Ver. 1.1 Class 7: Windows 7 & MS Office 2010
Team Orange
No ratings yet
Software Design And Development in your pocket
From Everand
Software Design And Development in your pocket
David Chen
5/5 (1)
Python Unit 1
No ratings yet
Python Unit 1
8 pages
Chapter 5 Python
No ratings yet
Chapter 5 Python
7 pages
Scribleindia TN 10th Maths Eng Imp Qa PDF
No ratings yet
Scribleindia TN 10th Maths Eng Imp Qa PDF
10 pages
MC
No ratings yet
MC
11 pages
Cs 2 Marks TM
No ratings yet
Cs 2 Marks TM
36 pages
Iibca Java
No ratings yet
Iibca Java
1 page
Cluster Computing: A Paper Presentation On
No ratings yet
Cluster Computing: A Paper Presentation On
16 pages
Frontier Series: Di Print/Data Writing Service Software Ver.5.5
No ratings yet
Frontier Series: Di Print/Data Writing Service Software Ver.5.5
78 pages
Xapp 870
No ratings yet
Xapp 870
16 pages
US6779151
No ratings yet
US6779151
16 pages
End-User License Agreement ("EULA") For AIMP Last Revised 15.09.2019
No ratings yet
End-User License Agreement ("EULA") For AIMP Last Revised 15.09.2019
5 pages
Simatic: STEP 7 Professional 2010 SR4 Engineering Software For SIMATIC S7 / M7 / C7
No ratings yet
Simatic: STEP 7 Professional 2010 SR4 Engineering Software For SIMATIC S7 / M7 / C7
16 pages
Enterprise Summary
No ratings yet
Enterprise Summary
4 pages
InspireComputing Y8 WB Answers
No ratings yet
InspireComputing Y8 WB Answers
55 pages
ManualOperacio - CX-Programmer 5.0 Function Blocks PDF
No ratings yet
ManualOperacio - CX-Programmer 5.0 Function Blocks PDF
184 pages
Unit 1 of 4 Class Computer Q & A
No ratings yet
Unit 1 of 4 Class Computer Q & A
3 pages
Aspire 5541/5241 Series: Quick Guide
No ratings yet
Aspire 5541/5241 Series: Quick Guide
11 pages
Troubleshooting Acsls
No ratings yet
Troubleshooting Acsls
12 pages
Windows Command Line Cheat Sheet PDF Hackr - Io
100% (1)
Windows Command Line Cheat Sheet PDF Hackr - Io
27 pages
VSE+BackupExec Linux Oracle Support 2019 06
No ratings yet
VSE+BackupExec Linux Oracle Support 2019 06
12 pages
Block Diagram of Computer
No ratings yet
Block Diagram of Computer
4 pages
SRAM Design: Memory
No ratings yet
SRAM Design: Memory
36 pages
Features: 256Kb Bytewide FRAM Memory
No ratings yet
Features: 256Kb Bytewide FRAM Memory
12 pages
Computer Arithmetic Practice Exercises Programming
No ratings yet
Computer Arithmetic Practice Exercises Programming
213 pages
Seth 740 Fall13 Module3.5 Main Memory Part1
No ratings yet
Seth 740 Fall13 Module3.5 Main Memory Part1
69 pages
DDCA Ch5
No ratings yet
DDCA Ch5
101 pages
Rhcsa Full Doc CSL
100% (1)
Rhcsa Full Doc CSL
134 pages
RHCE Rec
No ratings yet
RHCE Rec
110 pages
Allama Iqbal Scholarship Aptitude Test Model Paper Final by 4th Batch of AIS
100% (1)
Allama Iqbal Scholarship Aptitude Test Model Paper Final by 4th Batch of AIS
22 pages