Paging and Segmentation

BY,
Shubha B.
1PI08LDS16
 Logical vs. Physical Address Space
• Logical address – generated by the CPU; also referred to as
virtual address.

• Physical address – address seen by the memory unit

• Logical and physical addresses are the same in compile-time

and load-time; logical (virtual) and physical addresses differ in
execution-time.

• The user program deals with logical addresses; it never sees

the real physical addresses.
 Paging
• Memory-management technique that permits the physical
address space of a process to be non-contiguous.

• Each process is divided into a number of small, fixed-size

partitions called pages or Divide logical memory into blocks of
same size called pages.

• Physical memory is divided into a large number of small, fixed-size

partitions called frames.

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

available memory frames.

• Some internal fragmentation , but no external fragmentation.

 Address Translation Scheme
• Operating system maintains a page
table for each process
– Contains the frame number for
each process page
– To translate logical to physical
addresses

• A logical address is divided into:

– Page number (p) – used as an index
into a page table which contains
base address of each page in
physical memory.
– Page offset (d) – combined with
base address to define the physical
memory address that is sent to the
memory.
• Paging Model of memory is shown:

• To run a program of size n pages, need to find n free frames and

load program.

• Set up a page table to translate logical to physical addresses

Address translation in paging
• The following steps are needed for address Translation:

• Given a (page #, offset), find (frame #, offset).

• Assuming the size of a page/frame is 2m bytes , m bits to

determine the offset within a page

• 2n > number of pages in process => n bits to hold the page number

• 2k > number of frames in memory => k bits to hold the frame

number

• Logical address is nm
• Physical address is simply km where k is the frame that stores
page “n”
Paging Example
 Paging Example
• Page size 4 bytes.

• Physical memory 32bytes.

• Logical address 0 maps to physical

address 20 (=(5*4)+0).

• Logical address 3 maps to physical

address 23 (=(5*4)+3).

• Page1 is mapped to frame6.It maps to

physical address 24(=(6*4)+0)

• Logical address 13 maps to physical

address 9.
 Page Table Implementation
• Implemented as a set of registers.(if Page table is less).
– Problem: If page table is large, it is not applicable.

• Page table kept in main memory. PTBR register points to the

Page table. Page-table length register (PRLR) indicates size of
the page table.
– Problem: In this scheme every data/instruction access
requires two memory accesses. One for the page table and
one for the data/instruction.

• Using Translation look aside buffer or associative registers.

– Very fast, very expensive.
 Memory Protection
• Memory protection implemented by associating protection bit
with each frame.

• Valid-invalid bit attached to each entry in the page table:

– “valid” indicates that the associated page is in the process’
logical address space, and is thus a legal page
– “invalid” indicates that the page is not in the process’ logical
address space
 Shared Pages
• Shared code
– One copy of read-only (reentrant) code shared among processes
(i.e., text editors, compilers, window systems).
– Shared code must appear in same location in the logical address
space of all processes

• Private code and data

– Each process keeps a separate
copy of the code and data
– The pages for the private code
and data can appear anywhere
in the logical address space
 Two-Level Page Table

• A logical address (on 32-bit machine with 4K page size) is

divided into:
– a page offset consisting of 12 bits.
– a page number consisting of 20 bits; further divided into:
• a 10-bit level-2 page number.
• a 10-bit level-1 page number.
• Thus, a logical address look likes
– p1 is an index into the outer page table
– p2 is the displacement within the page of the outer page
table

• Address translation scheme

 Advantages
• Easy to allocate memory — keep a list of available frames, and
simple grab first one that’s free.

• Easy to swap — pages, frames, and often disk blocks as well,

all are same size.

• No external fragmentation
• Any page can be placed in any frame in physical memory

• Sharing of the common code is possible.

 Disadvantages
• Internal fragmentation: Page size may not match size needed
by process
– Wasted memory grows with larger pages

• Page tables are fairly large , so page tables are too big to fit in
registers, so they must live in physical Memory.

• This table lookup adds an extra memory reference for every

address translation.
 Segmentation
• A segment can be defined as a logical grouping of instructions,
such as a subroutine, array, or a data area.

• A program is a collection of segments.

• Segmentation is t technique for managing these segments.

• Divide a process into unequal size blocks called segments.

• Each segment has a name and a length.

• Memory Management Scheme that supports user view of

memory.
• A segment is a logical unit such as
– main program, procedure, function
– local variables, global variables, common block
– stack, symbol table, arrays
• Protect each entity independently
• Allow each segment to grow independently
• Share each segment independently

• Each of these segments are of variable

length and length will be defined in the
program.
 Segmentation Architecture
• Segment Table
– Maps two-dimensional user-defined addresses into one-
dimensional physical addresses. Each table entry has
• Base - contains the starting physical address where the
segments reside in memory.
• Limit - specifies the length of the segment.

• A logical address consists of two parts.

– A segment number, s, and an offset, d.
• Segment number used as index into the segment table.
• The offset d is between 0 and the segment limit.
• The offset is added to the base to produce the physical
address.
• If the offset is not within the limit, trap to the operating system.
(logical address beyond end of segment).

• Segmentation Example:
Address Translation
 Sharing of Segments
• Segments are shared when entries in the segment tables of
two different processes point to the same physical locations.

• It is possible to share only the parts of the programs.

• Subroutine packages are shared

among many users.
 Advantages and Disadvantages

• Advantages:
– Each segment can be
• located independently
• separately protected
• grow independently
– Segments can be shared between processes.
– Eliminate the fragmentation.

• Disadvantages:
– Allocation algorithms as for memory partitions
– External fragmentation, back to compaction problem.
• Solution: combine segmentation and paging.
 Segmentation vs. Paging

• Segment is good logical unit of information

– sharing, protection
• Segmentation
– Break process up into logical segments
• Segments are generally of different sizes

• Page is good physical unit of information

– simple memory management
• Paging
– Break process up into physical pages
– Pages are the same size
Paging Segmentation
The main memory partitioned into frames The main memory partitioned into
or blocks. segments.
The logical address space divided into The logical address space divided into
pages by compiler or MMU segment specified by the programmer.
Suffers from internal fragmentation or Suffers from external fragmentation.
page break
Operating system maintains the page Operating system maintains the segment
table. table.

Does not supports the user view of Supports the user view of memory
memory

Processor uses the page number and Processor uses the segment number and
displacement to calculate absolute displacement to calculate absolute
address. address.
Multilevel paging is possible Multilevel segmentation is possible. But
no use.
• Similarity:
– Address space can exceed size of real memory.

• Differences:
– Programmer is aware of segmentation. Paging is hidden.
– Segmentation maintains multiple address spaces per
process. Paging maintains one address space.
– Segmentation allows procedures and data to be separately
protected. This is hard with paging.

• Segmentation easily permits tables whose size varies.

• Segmentation facilitates sharing of procedures between

processes. This is hard with paging.

• Pure segmentation suffers from memory fragmentation.

Thank you