What is Segmentation with Paging?
Learn segmentation with paging — segment tables, per-segment page tables, and x86 examples — OS interview question answered.
Expected Interview Answer
Segmentation with paging is a hybrid memory management scheme where a process's address space is first divided into logically meaningful, variable-sized segments (like code, stack, and heap), and each segment is then internally divided into fixed-size pages, combining segmentation's logical structure with paging's efficient physical allocation.
Pure segmentation gives each logical unit of a program its own variable-sized segment with natural protection and sharing boundaries, but variable-sized segments cause external fragmentation in physical memory as segments are allocated and freed. Pure paging solves fragmentation by dividing memory into fixed-size frames, but a flat page table has no notion of logical program structure, so it cannot naturally express per-segment protection or sharing. Segmentation with paging addresses both problems: a virtual address is split into a segment number, a page number within that segment, and an offset within that page; the segment number indexes a segment table that points to a separate page table for that segment, and that page table then translates the page number to a physical frame. This gives each segment logical protection and independent growth (e.g., stack and heap can grow without colliding) while each segment’s own pages are allocated in fixed-size, non-fragmenting frames — Intel's x86 protected mode segmentation-plus-paging architecture is a well-known real-world example of this scheme.
- Combines logical program structure (segments) with fragmentation-free allocation (paging)
- Allows per-segment protection bits, e.g., read-only code vs writable data
- Lets segments like stack and heap grow independently without colliding
- Real hardware precedent: x86 protected-mode segmentation plus paging
AI Mentor Explanation
Segmentation with paging is like a cricket board first dividing operations into logical departments — batting academy, bowling academy, fitness unit (segments) — each with its own rules and access levels, and then within each academy, dividing the physical training ground into fixed-size numbered pitches (pages) so scheduling is simple and collision-free. A visiting analyst first looks up which academy they need (segment number), then which specific pitch within that academy (page number), then the exact spot on it (offset). This gives each academy its own logical identity and access rules while still allocating ground space in tidy, uniform pitch-sized chunks rather than irregular ad hoc plots.
Step-by-Step Explanation
Step 1
Address split
A virtual address is decomposed into a segment number, a page number within that segment, and a byte offset.
Step 2
Segment table lookup
The segment number indexes a segment table entry that gives the base of that segment's own page table and protection bits.
Step 3
Page table lookup
The page number indexes that segment's page table to find the physical frame number, exactly as in pure paging.
Step 4
Physical address formed
The frame number is combined with the offset to produce the final physical address, with the segment's protection bits enforced throughout.
What Interviewer Expects
- A correct description of the two-level translation: segment table then page table
- Why pure segmentation causes external fragmentation and pure paging lacks logical structure
- How this hybrid gives per-segment protection while keeping fixed-size frame allocation
- A real-world example, such as x86 protected-mode segmentation plus paging
Common Mistakes
- Describing it as just paging with a fancy name, missing the per-segment page tables
- Not explaining why pure segmentation alone causes external fragmentation
- Confusing segment number with page number in the address translation order
- Failing to mention per-segment protection as a key benefit over flat paging
Best Answer (HR Friendly)
“Segmentation with paging first splits a program's memory into logical pieces like code, stack, and heap, each with its own rules, and then further splits each of those pieces into small, fixed-size blocks so the operating system can allocate physical memory efficiently without wasted gaps. It gives you the best of both worlds — meaningful, protectable chunks of memory, and efficient, fragmentation-free physical allocation underneath.”
Code Example
struct segment_entry {
struct page_table_entry *page_table;
int protection; /* e.g., read-only, read-write */
};
unsigned translate(unsigned seg_no, unsigned page_no, unsigned offset,
struct segment_entry *segment_table) {
struct segment_entry seg = segment_table[seg_no];
struct page_table_entry pte = seg.page_table[page_no];
if (!pte.present) {
handle_page_fault(seg_no, page_no); /* fetch page into a free frame */
}
return pte.frame * PAGE_SIZE + offset; /* final physical address */
}Follow-up Questions
- Why does pure segmentation cause external fragmentation but pure paging does not?
- How does segmentation with paging enable per-segment protection?
- How does x86 protected mode implement segmentation combined with paging?
- What is the tradeoff of the extra segment table lookup versus pure paging?
MCQ Practice
1. In segmentation with paging, what does the segment number index?
The segment number looks up the segment table, which gives the base of a page table specific to that segment along with its protection bits.
2. What problem does pure segmentation have that paging solves?
Variable-sized segments being allocated and freed leave irregular gaps in physical memory — external fragmentation — which fixed-size paging avoids.
3. What does segmentation add on top of pure paging?
Segmentation groups pages into logically meaningful, independently protected units like code, stack, and heap, which flat paging alone cannot express.
Flash Cards
What is segmentation with paging? — A hybrid scheme where each logical segment has its own page table, combining logical structure with fixed-size frame allocation.
How is a virtual address split in this scheme? — Into a segment number, a page number within that segment, and an offset within the page.
What problem does paging solve within each segment? — External fragmentation, by allocating physical memory in fixed-size frames.
Name a real-world example of segmentation with paging. — x86 protected-mode architecture, which supports segmentation combined with paging.