Professional Documents
Culture Documents
i) LRU
#include <bits/stdc++.h>
using namespace std;
if (it == v.end()) {
// If memory is full
if (v.size() == c) {
return count;
}
int main()
{
int n,c;
cout<<"Enter the number of pages: ";
cin>>n;
cout<<endl;
cout<<"Enter the capacity: ";
cin>>c;
int pages[n];
Output:
Source code:
ii) FIFO:
#include <bits/stdc++.h>
using namespace std;
int pageFaults(int pages[], int n, int capacity)
{
unordered_set<int> s;
queue<int> indexes;
int page_faults = 0;
for (int i = 0; i < n; i++)
{
if (s.size() < capacity)
{
if (s.find(pages[i]) == s.end())
{
s.insert(pages[i]);
page_faults++;
indexes.push(pages[i]);
}
}
else
{
if (s.find(pages[i]) == s.end())
{
int val = indexes.front();
indexes.pop();
s.erase(val);
s.insert(pages[i]);
indexes.push(pages[i]);
page_faults++;
}
}
}
return page_faults;
}
int main()
{
int n;
cout << "Enter number of pages : ";
cin >> n;
int pages[n], capacity;
cout << "Enter pages : ";
for (int i = 0; i < n; i++)
{
cin >> pages[i];
}
cout << "Enter capacity : ";
cin >> capacity;
cout << "Page faults : " << pageFaults(pages, n, capacity);
return 0;
}
Output:
Source code:
iii) Optimal Page Replacement:
#include <bits/stdc++.h>
using namespace std;
bool find(int key, vector<int> &frames)
{
for (int i = 0; i < frames.size(); i++)
if (frames[i] == key)
return true;
return false;
}
int predict(int pages[], vector<int> &frames, int n, int idx)
{
int res = -1, end = idx;
for (int i = 0; i < frames.size(); i++)
{
int j;
for (j = idx; j < n; j++)
{
if (frames[i] == pages[j])
{
if (j > end)
{
end = j;
res = i;
}
break;
}
}
if (j == n) return i;
}
return (res == -1) ? 0 : res;
}
int optimalPage(int pages[], int n, int capacity)
{
vector<int> frames;
int hit = 0;
for (int i = 0; i < n; i++)
{
if (find(pages[i], frames))
{
hit++;
continue;
}
if (frames.size() < capacity)
frames.push_back(pages[i]);
else
{
int j = predict(pages, frames, n, i + 1);
frames[j] = pages[i];
}
}
return n-hit;
}
int main()
{
// int pages[] = {4, 7, 6, 1, 7, 6, 1, 2, 7, 2};
int n;
cout << "Enter number of pages : ";
cin >> n;
int pages[n], capacity;
cout << "Enter pages : ";
for (int i = 0; i < n; i++)
{
cin >> pages[i];
}
cout << "Enter capacity : ";
cin >> capacity;
cout << "Page faults : " << optimalPage(pages, n, capacity);
}
Output:
Source code:
i)First Fit:
#include <bits/stdc++.h>
using namespace std;
break;
}
}
}
cout << "\t\tFirst Fit" << endl;
cout << "\nProcess No.\tProcess Size\tBlock no.\n";
for (int i = 0; i < n; i++)
{
cout << " " << i + 1 << "\t\t" << processSize[i] << "\t\t";
if (allocation[i] != -1)
cout << allocation[i] + 1;
else
cout << "Not Allocated";
cout << endl;
}
}
int main()
{
int memSize[] = {300, 50, 200, 350, 70};
int processSize[] = {200, 47, 212, 426, 10};
int m = sizeof(memSize) / sizeof(memSize[0]);
int n = sizeof(processSize) / sizeof(processSize[0]);
return 0;
}
Output:
Source code:
ii)Best Fit:
#include <bits/stdc++.h>
using namespace std;
void bestFit(int memSize[], int m, int processSize[], int n)
{
int allocation[n];
memset(allocation, -1, sizeof(allocation));
for (int i = 0; i < n; i++)
{
int bestIdx = -1;
for (int j = 0; j < m; j++)
{
if (memSize[j] >= processSize[i])
{
if (bestIdx == -1)
{
bestIdx = j;
}
else if (memSize[bestIdx] > memSize[j])
{
bestIdx = j;
}
}
}
if (bestIdx != -1)
{
allocation[i] = bestIdx;
memSize[bestIdx] -= processSize[i];
}
}
cout << "\tBest Fit" << endl;
cout << "\nProcess No.\tProcess Size\tBlock no.\n";
for (int i = 0; i < n; i++)
{
cout << " " << i + 1 << "\t\t" << processSize[i] << "\t\t";
if (allocation[i] != -1)
{
cout << allocation[i] + 1;
}
else
{
cout << "Not Allocated";
}
int main()
{
int memSize[] = {10, 20, 7, 10, 40};
int processSize[] = {6, 10, 20, 30, 20};
int m = sizeof(memSize) / sizeof(memSize[0]);
int n = sizeof(processSize) / sizeof(processSize[0]);
Output:
Source code:
iii) Worst Fit:
#include <bits/stdc++.h>
using namespace std;
memSize[idx] -= processSize[i];
}
}
cout << "\t\tWorst Fit" << endl;
cout << "\nProcess No.\tProcess Size\tBlock no.\n";
for (int i = 0; i < n; i++)
{
cout << " " << i + 1 << "\t\t" << processSize[i] << "\t\t";
if (allocation[i] != -1)
cout << allocation[i] + 1;
else
cout << "Not Allocated";
cout << endl;
}
}
int main()
{
int memSize[] = {100, 200, 300, 400, 500};
int processSize[] = {212, 417, 112, 426};
int m = sizeof(memSize) / sizeof(memSize[0]);
int n = sizeof(processSize) / sizeof(processSize[0]);
worstFit(memSize, m, processSize, n);
return 0;
}
Output:
Source code:
#include <iostream>
using namespace std;
int main()
{
// P0, P1, P2, P3, P4 are the Process names here
int n, m, i, j, k;
n = 5; // Number of processes
m = 3; // Number of resources
int alloc[5][3] = { { 0, 1, 0 }, // P0 // Allocation Matrix
{ 2, 0, 0 }, // P1
{ 3, 0, 2 }, // P2
{ 2, 1, 1 }, // P3
{ 0, 0, 2 } }; // P4
if (flag == 0) {
ans[ind++] = i;
for (y = 0; y < m; y++)
avail[y] += alloc[i][y];
f[i] = 1;
}
}
}
}
int flag = 1;
if(flag==1)
{
cout << "Following is the SAFE Sequence" << endl;
for (i = 0; i < n - 1; i++)
cout << " P" << ans[i] << " ->";
cout << " P" << ans[n - 1] <<endl;
}
return (0);
}
Output:
Source code:
#include <stdio.h>
int main() {
int n, m, i, j, k;
n = 5; // Number of processes
m = 3; // Number of resources
// Allocation Matrix
int alloc[5][3] = { { 0, 1, 0 }, // P0
{ 2, 0, 0 }, // P1
{ 3, 0, 2 }, // P2
{ 2, 1, 1 }, // P3
{ 0, 0, 2 } }; // P4
// MAX Matrix
int max[5][3] = { { 7, 5, 3 }, // P0
{ 3, 2, 2 }, // P1
{ 9, 0, 2 }, // P2
{ 2, 2, 2 }, // P3
{ 4, 3, 3 } }; // P4
// Available Resources
int avail[3] = { 3, 3, 2 };
// Printing details
printf("\nProcess\t\tAllocation\t\t\tMax\t\n");
printf("\t\t\tA\tB\tC\t\tA\tB\tC\n");
printf("-------------------------------------");
for(int i=0; i<n; i++) {
printf("\n P%d\t", i);
printf("\t%d\t%d\t%d\t",
alloc[i][0],
alloc[i][1],
alloc[i][2]
);
printf("\t%d\t%d\t%d",
max[i][0],
max[i][1],
max[i][2]
);
}
printf("\nAvailable: A = %d | B = %d | C = %d",
avail[0],
avail[1],
avail[2]
);
int flag = 0;
for (j = 0; j < m; j++) {
if (need[i][j] > avail[j]){
flag = 1;
break;
}
}
if (flag == 0) {
ans[ind++] = i;
for (y = 0; y < m; y++)
avail[y] += alloc[i][y];
f[i] = 1;
}
}
}
}
int flag = 1;
if(flag == 1) {
printf("\n\nFollowing is the SAFE Sequence\n");
for (i = 0; i < n - 1; i++)
printf(" P%d ->", ans[i]);
printf(" P%d", ans[n - 1]);
}
return (0);
}
Output: