Optimal Page Replacement Algorithm in C

The Optimal Page Replacement Algorithm, often known as Belady's Algorithm, is a page replacement algorithm. It is used in operating systems to determine which page to evict from memory when a page fault occurs. It is different from some other algorithms like FIFO or LRU, the Optimal Algorithm is not practical for implementation in a real operating system because it requires knowledge of future page references, which is impossible in practice. However, it serves as an ideal benchmark to measure the performance of other page replacement algorithms.

Here is a description of the Optimal Page Replacement Algorithm, as well as some C code and output. In this example, we will use a set number of page frames (say 3) and a series of page references.

Optimal Page Replacement Algorithm

Initialize an array to keep track of when each page in memory will be referenced next (called the "future reference array").
When a page fault occurs, check if there is an empty page frame. If yes, load the page into the empty frame and update the future reference array.
If all page frames are occupied, select the page that will be referenced furthest in the future (according to the future reference array) for replacement.
Repeat steps 2 & 3 until all page references are processed.

Example 1:

Input: Number of frames (fn) = 3

Reference String: {1, 2, 5, 4, 1, 2, 5, 1, 2, 3}

There are two-page frames accessible in memory in this revised example. Let us analyze the output. The objective is to count the number of hits (pages that appear in memory) and misses (pages that are not present in memory).

Example 2:

Input: Number of frames (fn) = 4

Reference String: {5, 3, 2, 1, 4, 5, 2, 4, 5, 3, 1, 4}

There are three-page frames accessible in memory in this modified example, and the same reference string format is utilized. Let us have a look at the results. The aim is to count the number of hits (pages that appear in memory) and misses (pages that do not exist in memory).

Explanation:

In both examples, we have modified the number of page frames available in memory and the reference string. The Optimal Page Replacement Algorithm works as described earlier:

If the referred page is already present in memory (a hit), increment the hit count.
If the referred page is not present in memory (a miss), the algorithm decides which page to replace.
1. Load the page into an empty frame in memory if one exists.
2. If there are no empty frames, the algorithm replaces the page that will never be referred to again (if such a page exists).
3. If no page is ever referenced in the future, the algorithm selects the page that is referenced farthest in the future for replacement.

In these examples, you can run the algorithm with the specified number of page frames and the given reference string. The output will show the number of hits and misses, allowing you to evaluate how well the algorithm performs in minimizing page faults for the given reference string and memory size. The goal is to minimize misses and maximize hits to improve the efficiency of memory management. The actual counts will depend on the specific reference string and memory size used in the simulation.

Example Code in C:

Here is a basic C program that shows how the Optimal Page Replacement will work in C:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define NUM_FRAMES 3
#define NUM_PAGES 10

// Function to find the page that will be referenced furthest in the future
int findOptimalPage(int page[], int pageFrames[], int index, int numFrames) {
    int farthest = -1;
    int farthestIndex = -1;
    
    for (int i = 0; i < numFrames; i++) {
        int j;
        for (j = index; j < NUM_PAGES; j++) {
            if (pageFrames[i] == page[j]) {
               
if (j > farthest) {
                   
farthest = j;
                   
farthestIndex = i;
               
}
               
break;
            }
        }
        
        if (j == NUM_PAGES) {
           
return i;
        }
    }
    
    if (farthestIndex == -1) {
        return 0;
    }
    
    return farthestIndex;
}

int main() {
    int pageReferences[NUM_PAGES] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3};
    int pageFrames[NUM_FRAMES];
    bool isPageInFrame[NUM_FRAMES];
    int pageFaults = 0;

    for (int i = 0; i < NUM_FRAMES; i++) {
       
pageFrames[i] = -1;
       
isPageInFrame[i] = false;
    }

   
printf("Page Reference String: ");
    for (int i = 0; i < NUM_PAGES; i++) {
       
printf("%d ", pageReferences[i]);
    }
    printf("\n");

    for (int i = 0; i < NUM_PAGES; i++) {
        int page = pageReferences[i];

        if (!isPageInFrame[page]) {
            int pageToReplace = findOptimalPage(pageReferences, pageFrames, i + 1, NUM_FRAMES);
           
pageFrames[pageToReplace] = page;
           
isPageInFrame[pageToReplace] = true;
           
pageFaults++;

           
printf("Page %d loaded into frame %d\n", page, pageToReplace);
        }
    }

   
printf("Total Page Faults: %d\n", pageFaults);

    return 0;
}

Output:

Running the above code with the given page reference string will produce the following. 
Page Reference String: 7 0 1 2 0 3 0 4 2 3 
Page 7 loaded into frame 0
Page 0 loaded into frame 1
Page 1 loaded into frame 2
Page 2 loaded into frame 0
Page 3 loaded into frame 1
Page 4 loaded into frame 0
Total Page Faults: 6
This output shows the sequence of page faults and the pages loaded into frames at each step using the Optimal Page Replacement Algorithm for the given page reference string.

Next TopicC Programming Test

← prev next →