Scribd
Upload
2 views29 pages

Module 2

The document contains multiple code snippets for various disk scheduling and page replacement algorithms, including SCAN, C-SCAN, LOOK, C-LOOK, FCFS, SSTF, FIFO, and Optimal Page Replacement. Each section outlines the aim of the algorithm and provides the corresponding C code implementation. The algorithms are designed to manage disk scheduling and memory page replacement efficiently.

Uploaded by

varaprasadsetty2005
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
2 views29 pages

Module 2

The document contains multiple code snippets for various disk scheduling and page replacement algorithms, including SCAN, C-SCAN, LOOK, C-LOOK, FCFS, SSTF, FIFO, and Optimal Page Replacement. Each section outlines the aim of the algorithm and provides the corresponding C code implementation. The algorithms are designed to manage disk scheduling and memory page replacement efficiently.

Uploaded by

varaprasadsetty2005
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 29

1.

Aim :- scan
Code :-
#include <stdio.h>

#include <stdlib.h>

void sort(int arr[], int n) {

for (int i = 0; i < n - 1; i++) {

for (int j = 0; j < n - i - 1; j++) {

if (arr[j] > arr[j + 1]) {

int temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

void scan(int requests[], int n, int head, int direction) {

int seek_sequence[100], index = 0, distance, total_head_movement = 0;

sort(requests, n);

seek_sequence[index++] = head;

if (direction == 1) {

for (int i = 0; i < n; i++) {

if (requests[i] >= head) {

seek_sequence[index++] = requests[i];

}
seek_sequence[index++] = 199;

for (int i = n - 1; i >= 0; i--) {

if (requests[i] < head) {

seek_sequence[index++] = requests[i];

} else {

for (int i = n - 1; i >= 0; i--) {

if (requests[i] <= head) {

seek_sequence[index++] = requests[i];

seek_sequence[index++] = 0;

for (int i = 0; i < n; i++) {

if (requests[i] > head) {

seek_sequence[index++] = requests[i];

for (int i = 0; i < index - 1; i++) {

distance = abs(seek_sequence[i + 1] - seek_sequence[i]);

total_head_movement += distance;

printf("Seek Sequence: ");

for (int i = 0; i < index; i++) {

printf("%d ", seek_sequence[i]);

printf("\nTotal Head Movement: %d\n", total_head_movement);

}
int main() {

int requests[] = { 98, 183, 37, 122, 14, 124, 65, 67 };

int n = sizeof(requests) / sizeof(requests[0]);

int head = 53;

int direction = 1;

scan(requests, n, head, direction);

return 0;

Output:-

2
Aim :- c-scan
Code :-
#include <stdio.h>
#include <stdlib.h>
void sort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
void cscan(int requests[], int n, int head, int direction) {
int seek_sequence[100], index = 0, distance, total_head_movement = 0;
sort(requests, n);
seek_sequence[index++] = head;
if (direction == 1) {
for (int i = 0; i < n; i++) {
if (requests[i] >= head) {
seek_sequence[index++] = requests[i];
}
}
seek_sequence[index++] = 199;
seek_sequence[index++] = 0;
for (int i = 0; i < n; i++) {
if (requests[i] < head) {
seek_sequence[index++] = requests[i];
}
}
} else {
for (int i = n - 1; i >= 0; i--) {
if (requests[i] <= head) {
seek_sequence[index++] = requests[i];
}
}
seek_sequence[index++] = 0;
seek_sequence[index++] = 199;
for (int i = n - 1; i >= 0; i--) {
if (requests[i] > head) {
seek_sequence[index++] = requests[i];
}
}
}

for (int i = 0; i < index - 1; i++) {


distance = abs(seek_sequence[i + 1] - seek_sequence[i]);
total_head_movement += distance;
}
printf("Seek Sequence: ");
for (int i = 0; i < index; i++) {
printf("%d ", seek_sequence[i]);
}
printf("\nTotal Head Movement: %d\n", total_head_movement);
}
int main() {
int requests[] = { 98, 183, 37, 122, 14, 124, 65, 67 };
int n = sizeof(requests) / sizeof(requests[0]);
int head = 53;
int direction = 1;
cscan(requests, n, head, direction);
return 0;
}
Output:-

3
Aim :- look
Code :-
#include <stdio.h>
#include <stdlib.h>
void sort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
void look(int requests[], int n, int head, int direction) {
int seek_sequence[100], index = 0, distance, total_head_movement = 0;
sort(requests, n);
seek_sequence[index++] = head;
if (direction == 1) {
for (int i = 0; i < n; i++) {
if (requests[i] >= head) {
seek_sequence[index++] = requests[i];
}
}
for (int i = n - 1; i >= 0; i--) {
if (requests[i] < head) {
seek_sequence[index++] = requests[i];
}
}
} else {
for (int i = n - 1; i >= 0; i--) {
if (requests[i] <= head) {
seek_sequence[index++] = requests[i];
}
}
for (int i = 0; i < n; i++) {
if (requests[i] > head) {
seek_sequence[index++] = requests[i];
}
}
}
for (int i = 0; i < index - 1; i++) {
distance = abs(seek_sequence[i + 1] - seek_sequence[i]);
total_head_movement += distance;
}
printf("Seek Sequence: ");
for (int i = 0; i < index; i++) {
printf("%d ", seek_sequence[i]);
}
printf("\nTotal Head Movement: %d\n", total_head_movement);
}
int main() {
int requests[] = { 98, 183, 37, 122, 14, 124, 65, 67 };
int n = sizeof(requests) / sizeof(requests[0]);
int head = 53;
int direction = 1;
look(requests, n, head, direction);
return 0;
}
Output:-

4.
Aim :- c-look
Code :-
#include <stdio.h>
#include <stdlib.h>
void sort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
void clook(int requests[], int n, int head, int direction) {
int seek_sequence[100], index = 0, distance, total_head_movement = 0;
sort(requests, n);
seek_sequence[index++] = head;
if (direction == 1) {
for (int i = 0; i < n; i++) {
if (requests[i] >= head) {
seek_sequence[index++] = requests[i];
}
}
if (index == 1) {
seek_sequence[index++] = requests[0];
} else {
seek_sequence[index++] = requests[n - 1];
for (int i = 0; i < n; i++) {
if (requests[i] < head) {
seek_sequence[index++] = requests[i];
}
}
}
} else {
for (int i = n - 1; i >= 0; i--) {
if (requests[i] <= head) {
seek_sequence[index++] = requests[i];
}
}
if (index == 1) {
seek_sequence[index++] = requests[n - 1];
} else {
seek_sequence[index++] = requests[0];
for (int i = n - 1; i >= 0; i--) {
if (requests[i] > head) {
seek_sequence[index++] = requests[i];
}
}
}
}
for (int i = 0; i < index - 1; i++) {
distance = abs(seek_sequence[i + 1] - seek_sequence[i]);
total_head_movement += distance;
}
printf("Seek Sequence: ");
for (int i = 0; i < index; i++) {
printf("%d ", seek_sequence[i]);
}
printf("\nTotal Head Movement: %d\n", total_head_movement);
}
int main() {
int requests[] = { 98, 183, 37, 122, 14, 124, 65, 67 };
int n = sizeof(requests) / sizeof(requests[0]);
int head = 53;
int direction = 1;
clook(requests, n, head, direction);
return 0;
}
Output:-

5.
Aim :- FCFS
Code :-
#include <stdio.h>
#include <stdlib.h>
void fcfs(int requests[], int n, int head) {
int seek_sequence[100], index = 0, distance, total_head_movement = 0;
seek_sequence[index++] = head;
for (int i = 0; i < n; i++) {
seek_sequence[index++] = requests[i];
}
for (int i = 0; i < index - 1; i++) {
distance = abs(seek_sequence[i + 1] - seek_sequence[i]);
total_head_movement += distance;
}
printf("Seek Sequence: ");
for (int i = 0; i < index; i++) {
printf("%d ", seek_sequence[i]);
}
printf("\nTotal Head Movement: %d\n", total_head_movement);
}
int main() {
int requests[] = { 98, 183, 37, 122, 14, 124, 65, 67 };
int n = sizeof(requests) / sizeof(requests[0]);
int head = 53;
fcfs(requests, n, head);
return 0;
}
Output:-
6.
Aim :- sstf
Code :-
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
void sstf(int requests[], int n, int head) {
bool visited[100] = {false};
int seek_sequence[100], index = 0, total_head_movement = 0;
int current_position = head;
seek_sequence[index++] = current_position;

for (int i = 0; i < n; i++) {


int min_distance = 1000;
int min_index = -1;
for (int j = 0; j < n; j++) {
if (!visited[j]) {
int distance = abs(requests[j] - current_position);
if (distance < min_distance) {
min_distance = distance;
min_index = j;
}
}
}
if (min_index != -1) {
visited[min_index] = true;
current_position = requests[min_index];
seek_sequence[index++] = current_position;
total_head_movement += min_distance;
}
}
printf("Seek Sequence: ");
for (int i = 0; i < index; i++) {
printf("%d ", seek_sequence[i]);
}
printf("\nTotal Head Movement: %d\n", total_head_movement);
}
int main() {
int requests[] = { 98, 183, 37, 122, 14, 124, 65, 67 };
int n = sizeof(requests) / sizeof(requests[0]);
int head = 53;
sstf(requests, n, head);
return 0;
}
Output:-
Page replacement

7.
Aim :- FIFO
Code :-
#include <stdio.h>
int isPageInFrames(int frames[], int capacity, int page) {
for (int i = 0; i < capacity; i++) {
if (frames[i] == page) return 1;
}
return 0;
}
int fifoPageReplacement(int pages[], int n, int capacity) {
int frames[capacity];
int front = 0;
int page_faults = 0;
for (int i = 0; i < capacity; i++) {
frames[i] = -1;
}
for (int i = 0; i < n; i++) {
if (!isPageInFrames(frames, capacity, pages[i])) {
frames[front] = pages[i];
front = (front + 1) % capacity;
page_faults++;
}
printf("\nStep %d: ", i + 1);
for (int j = 0; j < capacity; j++) {
if (frames[j] != -1)
printf("%d ", frames[j]);
else
printf("- ");
}
}
return page_faults;
}
int main() {
int pages[] = {1, 3, 0, 3, 5, 6, 3, 5, 1, 3, 6, 3};
int n = sizeof(pages) / sizeof(pages[0]);
int capacity = 3;
printf(" FIFO Page Replacement Simulation\n");
printf("===================================\n");
int page_faults = fifoPageReplacement(pages, n, capacity);
printf("\n\nTotal Page Faults: %d\n", page_faults);
return 0;
}

Output:-
8.
Aim :- optimal page replacement
Code :-
#include <stdio.h>
#define MAX_FRAMES 10
#define MAX_PAGES 50
int isPageInFrame(int frames[], int num_frames, int page) {
for (int i = 0; i < num_frames; i++) {
if (frames[i] == page) {
return 1;
}
}
return 0;
}
int findOptimalReplacement(int frames[], int num_frames, int
pages[], int num_pages, int current_index) {
int farthest = -1, replace_index = -1;

for (int i = 0; i < num_frames; i++) {


int j;
for (j = current_index + 1; j < num_pages; j++) {
if (frames[i] == pages[j]) {
if (j > farthest) {
farthest = j;
replace_index = i;
}
break;
}
}
if (j == num_pages) {
return i;
}
}
return (replace_index == -1) ? 0 : replace_index;
}
int main() {
int num_frames, num_pages;
int pages[MAX_PAGES], frames[MAX_FRAMES];
int page_faults = 0;
printf("Enter number of frames: ");
scanf("%d", &num_frames);
printf("Enter number of pages: ");
scanf("%d", &num_pages);
printf("Enter page reference string: ");
for (int i = 0; i < num_pages; i++) {
scanf("%d", &pages[i]);
}
for (int i = 0; i < num_frames; i++) {
frames[i] = -1;
}
for (int i = 0; i < num_pages; i++) {
int page = pages[i];
if (!isPageInFrame(frames, num_frames, page)) {
int replace_index;
for (replace_index = 0; replace_index < num_frames;
replace_index++) {
if (frames[replace_index] == -1) {
break;
}
}
if (replace_index == num_frames) {
replace_index = findOptimalReplacement(frames,
num_frames, pages, num_pages, i);
}
frames[replace_index] = page;
page_faults++;
printf("Step %d: Frames: ", i + 1);
for (int j = 0; j < num_frames; j++) {
if (frames[j] == -1)
printf("[ ] ");
else
printf("[%d] ", frames[j]);
}
printf("\n");
}
}
printf("Total Page Faults: %d\n", page_faults);
return 0;
}
Output:-

9.
Aim :- LRU
Code :- #include <stdio.h>
int isPageInFrames(int frames[], int capacity, int page) {
for (int i = 0; i < capacity; i++) {
if (frames[i] == page) return i;
}
return -1;
}
int findLRU(int time[], int capacity) {
int min = time[0], pos = 0;
for (int i = 1; i < capacity; i++) {
if (time[i] < min) {
min = time[i];
pos = i;
}
}
return pos;
}
int lruPageReplacement(int pages[], int n, int capacity) {
int frames[capacity], time[capacity];
int page_faults = 0, count = 0;

for (int i = 0; i < capacity; i++) {


frames[i] = -1;
}
for (int i = 0; i < n; i++) {
int pos = isPageInFrames(frames, capacity, pages[i]);
if (pos == -1) {
if (count < capacity) {
frames[count] = pages[i];
time[count] = i;
count++;
} else {
int lru_pos = findLRU(time, capacity);
frames[lru_pos] = pages[i];
time[lru_pos] = i;
}
page_faults++;
} else {
time[pos] = i;
}
printf("\nStep %d: ", i + 1);
for (int j = 0; j < capacity; j++) {
if (frames[j] != -1)
printf("%d ", frames[j]);
else
printf("- ");
}
}
return page_faults;
}
int main() {
int pages[] = {1, 3, 0, 3, 5, 6, 3, 5, 1, 3, 6, 3};
int n = sizeof(pages) / sizeof(pages[0]);
int capacity = 3;
printf("?? LRU Page Replacement Simulation\n");
printf("===================================\n");
int page_faults = lruPageReplacement(pages, n, capacity);
printf("\n\nTotal Page Faults: %d\n", page_faults);
return 0;
}
Output:-

10.
Aim :- second chance algorithm
Code :-
#include <stdio.h>
#define MAX_FRAMES 3
struct Page {
int pageNumber;
int referenceBit;
};
struct Page frames[MAX_FRAMES];
int findPage(int page, int frameCount) {
for (int i = 0; i < frameCount; i++) {
if (frames[i].pageNumber == page) {
frames[i].referenceBit = 1;
return 1;
}
}
return 0;
}
void secondChance(int pages[], int n) {
int frameCount = 0, pointer = 0, pageFaults = 0;
for (int i = 0; i < n; i++) {
if (!findPage(pages[i], frameCount)) {
pageFaults++;

if (frameCount < MAX_FRAMES) {


frames[frameCount].pageNumber = pages[i];
frames[frameCount].referenceBit = 1;
frameCount++;
} else {
while (frames[pointer].referenceBit == 1) {
frames[pointer].referenceBit = 0;
pointer = (pointer + 1) % MAX_FRAMES;
}
frames[pointer].pageNumber = pages[i];
frames[pointer].referenceBit = 1;
pointer = (pointer + 1) % MAX_FRAMES;
}
}
printf("Step %d: Frames: ", i + 1);
for (int j = 0; j < frameCount; j++) {
printf("[%d, %d] ", frames[j].pageNumber,
frames[j].referenceBit);
}
printf("\n");
}
printf("Total Page Faults: %d\n", pageFaults);
}
int main() {
int pages[] = {2,3,2,1,5,2,4,5,3,2,3,5};
int n = sizeof(pages) / sizeof(pages[0]);
secondChance(pages, n);
return 0;
}
Output:-

You might also like