现代操作系统中分页与分段的性能差异及应用：为何分页取代分段成为主流？

Great question—this is one of those classic OS design tradeoffs that seems trivial on paper but gets messy when you dive into real-world implementation headaches at scale. Let’s break down why paging won out, even though both approaches have fragmentation quirks:

1. Memory Allocation is Way Simpler (and Cheaper) #

• Paging uses fixed-size pages (usually 4KB, 2MB, or 1GB on modern systems), so finding free memory just means locating an unused page frame. Algorithms like bitmaps or simple free lists work perfectly here, with minimal overhead.
• Segmentation deals with variable-size segments, which leads to external fragmentation: over time, free memory gets split into tiny, unusable chunks between allocated segments. Fixing this requires compaction—shuffling all in-use memory to coalesce free space—which is extremely expensive. Imagine pausing every running process to move gigabytes of data around; that’s a non-starter for modern interactive systems.
• The internal fragmentation of paging (wasted space at the end of a page that’s not fully used) is negligible compared to the cost of compaction. For a 4KB page, the worst-case waste is ~4KB, which is trivial when systems have tens of gigabytes of RAM.

2. Virtual Memory Implementation is Far More Efficient #

• Paging was built for demand paging (loading pages into memory only when needed), the backbone of modern virtual memory. Fixed-size pages make it easy to implement page replacement algorithms (LRU, FIFO, etc.)—you just track page usage and swap out the least useful one when memory runs low.
• Segmentation struggles here: variable-length segments mean swapping out a segment could require moving a huge chunk of data to disk, and deciding which segment to evict is far more complex. There’s no clean, standardized way to track "usage" for arbitrary-sized segments like there is for pages.

3. Hardware & Address Translation Consistency #

• Modern CPUs are optimized for paging. Virtual addresses split cleanly into page number and offset, and address translation follows a uniform path (even with multi-level page tables). Switching between processes is as simple as updating a single register pointing to the process’s page table.
• Segmentation requires hardware to handle variable-length segments, boundary checks, and per-segment permissions—adding extra complexity to the CPU’s memory management unit (MMU). While x86 still has segment registers, modern OSes use "flat mode" (treating the entire address space as one giant segment) to bypass segmentation entirely, relying on paging for all actual memory management.

4. Better Flexibility for Sharing & Isolation #

• Paging lets you share memory at a granular level: you can share a single page between processes (great for shared libraries, for example) without having to share an entire segment. Permissions can also be set per-page, giving you fine-grained control over read/write/execute access.
• Segmentation’s coarse-grained sharing means you often end up sharing more memory than necessary, or can’t share small, specific chunks. Isolation is also harder to enforce consistently across variable-sized segments.

Even when ignoring TLBs, paging’s table lookup is more predictable: multi-level page tables are designed to be memory-efficient (only allocating table entries for pages that are actually used), whereas segment tables can become bloated or require more complex lookup structures to handle sparse address spaces.

内容的提问来源于stack exchange，提问作者Satyam Dwivedi