Understanding Page Faults in OS
Uploaded by
MATHAVAN A L KRISHNANUnderstanding Page Faults in OS
Uploaded by
MATHAVAN A L KRISHNANCommon questions
Powered by AIIn demand-paged systems, stacks are highly effective due to their sequential access pattern, which creates a high degree of locality in memory access. This minimizes page faults and optimizes the use of available memory, thus improving overall system performance .
A system administrator might opt to increase multiprogramming when CPU utilization is high and disk utilization is low, indicating that available memory frames are sufficient to handle additional processes without increasing page faults, which would help maintain efficient CPU usage .
In a scenario where CPU utilization is low and disk utilization is high, increasing multiprogramming can exacerbate thrashing. Since processes would receive even fewer frames, page fault frequency increases, thus lowering CPU efficiency further. It is advisable to decrease multiprogramming to alleviate thrashing, allowing fewer processes more memory frames .
Installing more main memory can ameliorate performance issues during thrashing by increasing the number of available frames for each process, thus reducing page faults. This directly enhances CPU utilization as processes spend less time waiting for page swaps and more time executing instructions .
The effective access time is calculated using the formula: Effective access time = (TLB hit rate x (TLB search time + memory access time)) + (TLB miss rate x (TLB search time + page table search time + memory access time)). Given that the TLB hit rate is 85%, the TLB search takes 20 nanoseconds, and memory access takes 100 nanoseconds, the effective access time is 0.85 x 120 + 0.15 x 220 = 135 nanoseconds .
Increasing page size affects system performance in demand-paging environments based on data locality. If data locality is good, a larger page size can reduce the frequency of page faults. Contrarily, poor locality means larger pages hold more irrelevant data, increasing the frequency of page faults and swap times, thereby degrading performance .
In a demand-paged environment, techniques that enhance data locality are preferred. Good techniques include using stacks, sequential searches, pure code, and vector operations, as they access data sequentially. Conversely, using hashed symbol tables, binary searches, and indirect addressing can be suboptimal because data access is scattered, thus potentially increasing page faults .
A page fault occurs when an access is made to a page that is not in main memory. Upon detecting a page fault, the operating system checks if the memory access is valid. If it is invalid, the program is aborted. If valid, the OS locates a free frame, requests I/O to read the needed page into this frame, updates the process and page tables, and restarts the instruction .
Pure code contributes to efficient memory management because it can be shared among processes, which reduces memory demands. Furthermore, pure code typically exhibits good locality, minimizing page faults and capitalizing on the efficiencies of demand-paging .
Thrashing can be caused by under-allocation of pages needed by a process, leading to continuous page faults. The system detects thrashing by comparing CPU utilization against the degree of multiprogramming and disk utilization. To resolve thrashing, the system can reduce the level of multiprogramming, thereby increasing available frames for each process, which reduces page faults .