Analysis of algorithms viva questions / Interview questions - set1 /sorting algorithms

Top 20 Viva Questions and Answers on Page Fault, Segmentation, Fragmentation, and Paging

Are you preparing for your Operating Systems viva? This article covers the top 20 frequently asked questions about Page Fault, Segmentation, Fragmentation, and Paging. Each answer is explained clearly in about 10 lines to help you grasp the concept better. Let's get started!

1. What is a page fault?

A page fault occurs when a program tries to access a page not currently in the main memory. The operating system must bring the required page from secondary storage into RAM. This process causes a delay in program execution. Page faults are common in systems that use virtual memory. There are two types: minor and major faults. A minor fault is handled quickly if the page is already in memory. A major fault requires loading from disk, taking more time. Frequent page faults can degrade system performance. Techniques like increasing RAM or optimizing programs help reduce page faults. Page replacement algorithms also play a key role.

2. What happens after a page fault?

When a page fault occurs, the operating system pauses the program's execution. It checks if the memory access was valid. If valid, the OS finds a free frame in RAM. Then, it reads the required page from secondary storage (like hard disk). The page is loaded into the frame. The page table is updated with the new frame information. The program’s instruction is restarted. If the access was invalid, the OS terminates the program. Efficient handling of page faults is crucial for system performance. Disk I/O operations during page faults are relatively slow.

3. What is segmentation in memory management?

Segmentation is a memory management technique where memory is divided into variable-sized segments. Each segment represents a logical unit like a function, array, or stack. Programs see memory as a collection of these segments. Every segment has a segment number and offset. Segmentation helps with program modularity and security. It also allows easier memory protection by isolating segments. The segment table keeps track of each segment’s base and limit. Segmentation can suffer from external fragmentation. Unlike paging, segments are not of fixed size. Operating systems like Multics used segmentation heavily.

4. What is fragmentation?

Fragmentation happens when memory blocks are wasted. It occurs when free memory is divided into small pieces. There are two types: internal and external fragmentation. Internal fragmentation happens inside allocated memory blocks. External fragmentation happens when free spaces exist between allocated blocks. Fragmentation reduces memory utilization and system efficiency. Memory compaction techniques help reduce external fragmentation. Fixed-sized partitions can cause internal fragmentation. Variable-sized partitions can cause external fragmentation. Efficient memory management minimizes fragmentation issues.

5. What is paging?

Paging is a memory management scheme that eliminates the need for contiguous allocation of memory. In paging, memory is divided into fixed-size blocks called pages (for processes) and frames (for memory). Each page maps to a frame. The page table keeps track of page-to-frame mappings. Paging helps solve external fragmentation. It provides efficient memory use without needing large contiguous blocks. The size of pages and frames is typically the same. Address translation involves the page number and page offset. Logical addresses are converted to physical addresses using the page table. Modern operating systems widely use paging, often with virtual memory.

6. What are the types of fragmentation?

Fragmentation can be broadly classified into internal and external. Internal fragmentation happens when fixed-size memory blocks are partially unused. External fragmentation occurs when there’s enough total memory but it’s scattered. Internal fragmentation wastes memory within allocated space. External fragmentation wastes memory between allocations. Paging helps to avoid external fragmentation. Segmentation suffers from external fragmentation. Compaction techniques can reduce external fragmentation. Memory allocation strategies affect the type and amount of fragmentation. Both types degrade memory performance if not managed properly.

7. How does paging solve the fragmentation problem?

Paging breaks memory into fixed-size blocks. Since blocks (frames) are of fixed size, external fragmentation is avoided. No need for large continuous memory spaces. Only the last page may suffer from slight internal fragmentation. Each page fits exactly into a frame. Paging allows better memory utilization. Programs can be spread across different areas of physical memory. This improves flexibility and efficiency. Logical addresses are mapped using page tables. Thus, paging effectively handles fragmentation issues.

8. What is a page table?

A page table is a data structure used in paging systems. It maps logical pages to physical frames in memory. Each entry in the table contains the frame number for the corresponding page. The CPU uses the page table during address translation. The base address of the page table is stored in a special register. Page tables can become large for big programs. Multi-level paging reduces page table size. Every memory access requires accessing the page table first. Translation Lookaside Buffer (TLB) speeds up page table lookups. Page tables are critical for virtual memory management.

9. What causes a page fault?

A page fault occurs when a process accesses a page not present in RAM. It can happen if the page was never loaded. Or, it may have been swapped out to make room for other pages. Accessing an invalid memory address can also cause a fault. Sometimes pages are loaded on demand (lazy loading). If a referenced page is missing, the OS loads it from disk. Insufficient physical memory increases page faults. Efficient memory management reduces page faults. Thrashing occurs if page faults happen excessively. Proper allocation and prefetching strategies help minimize faults.

10. What is thrashing?

Thrashing happens when a system spends more time swapping pages than executing processes. It occurs due to excessive page faults. Processes are continuously loaded and unloaded from memory. CPU utilization drops significantly during thrashing. System performance becomes extremely poor. It usually happens if there are too many processes with insufficient RAM. Working set models can help control thrashing. Reducing the degree of multiprogramming can prevent thrashing. Page replacement algorithms also play an important role. Monitoring page fault rates helps detect thrashing early.

11. What is internal fragmentation?

Internal fragmentation happens when memory is allocated in fixed-size blocks. If a process doesn't fully use the block, the leftover space is wasted. This unused space inside an allocated block is internal fragmentation. It occurs mainly in systems with fixed memory partitions. Smaller block sizes reduce internal fragmentation but increase overhead. Memory managers try to balance between block size and fragmentation. This type of waste is often hidden from the user. It leads to inefficient memory utilization. Compacting memory doesn't fix internal fragmentation. Efficient allocation policies are necessary to reduce it.

12. What is external fragmentation?

External fragmentation occurs when free memory is divided into small scattered blocks. Even though the total free memory is enough, it cannot be allocated because it's not contiguous. This happens in systems using variable-sized memory allocation. External fragmentation makes it hard to fit large processes. Compaction techniques can rearrange memory to reduce it. Memory compaction involves moving data blocks together. Segmentation suffers heavily from external fragmentation. Paging helps avoid external fragmentation completely. First-fit and best-fit allocation strategies influence fragmentation levels. Efficient allocation can minimize external fragmentation issues.

13. What is the difference between segmentation and paging?

Segmentation divides memory into logical segments like code, data, and stack. Paging divides memory into fixed-size blocks. Segments are of variable size, while pages are of fixed size. Segmentation supports logical structuring of a program. Paging mainly solves fragmentation issues. In segmentation, addresses are defined by segment number and offset. In paging, addresses are defined by page number and page offset. Segmentation suffers from external fragmentation; paging suffers from internal fragmentation. Both methods improve memory management efficiency. Some systems combine both segmentation and paging.

14. What is a segmentation fault?

A segmentation fault happens when a program accesses memory it’s not allowed to. This could mean accessing memory outside the allocated segment. Segmentation faults usually cause the program to crash. Operating systems protect memory using segmentation boundaries. Any violation triggers a fault. Common reasons include buffer overflows and dereferencing null pointers. Programmers need to write safe code to avoid segmentation faults. Languages like C are more prone to segmentation faults. Proper memory management and checks help prevent them. Segfaults are critical errors that indicate serious bugs.

15. What is demand paging?

Demand paging loads a page into memory only when it is needed. Initially, no pages are loaded into RAM. When a page is referenced, a page fault occurs. The OS then loads that specific page. This saves memory space by not loading unused pages. It reduces system load at program startup. Demand paging makes virtual memory systems efficient. However, too much paging can cause thrashing. Prefetching techniques predict and load required pages in advance. Demand paging is widely used in modern operating systems.

16. What is memory compaction?

Memory compaction is the process of rearranging memory contents. It moves all allocated memory blocks together. This creates one large block of free memory space. Compaction helps reduce external fragmentation. It is typically done during system idle time. Operating systems like Unix use compaction techniques. However, compaction is time-consuming and costly. It's usually used in systems with long-running processes. Paging reduces the need for compaction. Compaction improves memory utilization but adds overhead.

17. What are page replacement algorithms?

Page replacement algorithms decide which memory page to replace. They come into play when memory is full and a new page is needed. Common algorithms include FIFO, LRU, and Optimal. FIFO replaces the oldest page first. LRU replaces the least recently used page. Optimal replaces the page that won’t be used for the longest future time. Efficient page replacement reduces page faults. LRU is closer to Optimal but harder to implement. Good replacement policies improve system performance. Selection of the right algorithm depends on system requirements.

18. What is the working set model?

The working set model defines a set of pages a process needs at a given time. It keeps track of the most recently used pages. If the working set fits into memory, fewer page faults occur. Otherwise, thrashing can happen. The working set changes dynamically as the program runs. Operating systems monitor the working set to optimize paging. It balances memory use among multiple processes. A proper working set size ensures efficient memory use. Algorithms like WSClock are based on the working set model. The model improves performance in demand-paged systems.

19. What is the Translation Lookaside Buffer (TLB)?

The TLB is a small, fast cache used in paging systems. It stores recent page table entries. When the CPU needs a page table lookup, it first checks the TLB. If found (TLB hit), the address translation is fast. If not found (TLB miss), the page table is accessed normally. TLB significantly speeds up memory access. It reduces the overhead of accessing page tables in RAM. Modern processors have multi-level TLBs. Efficient TLB management improves overall system performance. TLB miss rates are kept low for better efficiency.

20. How does virtual memory work?

Virtual memory allows programs to use more memory than physically available. It uses disk space as an extension of RAM. When physical memory is full, pages are swapped between RAM and disk. Virtual addresses are translated to physical addresses. This provides isolation between processes. It also enables large applications to run on limited memory. Virtual memory relies on paging and segmentation. Page tables and TLBs help manage virtual memory efficiently. Proper management ensures minimal performance degradation. All modern operating systems implement virtual memory.