0% found this document useful (0 votes)
27 views38 pages

Operating System Assignment - DHANANJAY SINGHAL

The document provides code solutions in C++ and Python to operating system related questions on process scheduling algorithms like FCFS and Round Robin, using system calls like fork() and exec(), and getting system information using platform and psutil modules. It includes programs to copy files, get memory details and implement process scheduling.

Uploaded by

Shubh Sharma
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
27 views38 pages

Operating System Assignment - DHANANJAY SINGHAL

The document provides code solutions in C++ and Python to operating system related questions on process scheduling algorithms like FCFS and Round Robin, using system calls like fork() and exec(), and getting system information using platform and psutil modules. It includes programs to copy files, get memory details and implement process scheduling.

Uploaded by

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

UNIVERSITY OF DELHI

HANSRAJ COLLEGE
BSC (HONS) COMPUTER SCIENCE
SEMESTER - 3

OPERATING SYSTEM

DHANANJAY SINGHAL
21CS/13
Question 1 :

Write a program (using fork() and/or exec() commands) where parent and child execute:
a) same program, same code.
b) same program, different code.
c) before terminating, the parent waits for the child to finish its task.

Solution 1(a) :

"""
os.fork() is used to create child process Returns 0 in child process and child's
process id in parent process

"""
# This code won't work on Windows, use online compiler to execute

# Created by - DHANANJAY SINGHAL

# a) same program, same code.

import os
pid = os.fork()

if pid < 0:
print("Fork failed")
quit()

print(f"p(Returned value of os.fork()) : {pid}")


print(f"Process id : {os.getpid()}")
# If returned value of os.fork() is 0, child process has been executed
# Returned value of os.fork() in parent process will match os.getpid() of child
process

Output 1(a) :
Solution 1(b) :

# Created by - DHANANJAY SINGHAL

# b) same program, different code.

import os
pid = os.fork()
# p > 0 ---> Parent process
if pid > 0:
print(f"I am parent process. Actual process id : {os.getpid()} ")
print("Exiting the parent process")

# p == 0 ---> Child process


elif pid == 0:
print(f"I am child process. Actual process id : {os.getpid()}")
newCode = 'a = 10\nb=20\nprint("Sum =", a+b)'
exec(newCode)

else:
print("Forking Error")
quit()

Output 1(b) :
Solution 1(c) :

# Created by - DHANANJAY SINGHAL

# c) before terminating, the parent waits for the child to finish its task.

import os
pid = os.fork()
# p > 0 ---> Parent process
if pid > 0:
print(f"I am parent process. Actual process id : {os.getpid()} ")
os.waitpid(-1, 0)
print("Exiting the parent process")

# p == 0 ---> Child process


elif pid == 0:
print(f"I am child process. Actual process id : {os.getpid()}")
print("Exiting the child process")

else:
print("Forking Error")
quit()

Output 1(c) :
Question 2 :

Write a program to report behaviour of Linux kernel including kernel version, CPU type and
model. (CPU information)

Solution 2 :

# Created by - DHANANJAY SINGHAL

import platform

print(f"Operating System name : {platform.system()}")


print(f"Operating System version : {platform.version()}")
print(f"Operating System release : {platform.release()}")
print(f"Machine type: {platform.machine()}")
print(f"Processor type: {platform.processor()}")

Output 2 :
Question 3 :

Write a program to report behaviour of Linux kernel including information on 19 configured


memory, amount of free and used memory. (memory information)

Solution 3 :

# Created by - DHANANJAY SINGHAL

import psutil
print(f"Total memory : {psutil.virtual_memory()}")
print(f"Total memory (in GB) : {psutil.virtual_memory().total / (1024.0 **
3):.3f}")
print(f"Used memory (in GB) : {psutil.virtual_memory().used / (1024.0 ** 3):.3f}")
print(f"Available memory (in GB) : {psutil.virtual_memory().available / (1024.0 **
3):.3f}")
print(f"Percentage : {psutil.virtual_memory().percent}")

Output 3 :
Question 4 :

Write a program to print file details including owner access permissions, file access time,
where file name is given as argument

Solution 4 :

# Created by - DHANANJAY SINGHAL

import os
from stat import *

statinfo = os.stat('Downloads')

mode = statinfo.st_mode

if S_ISDIR(mode):
print("Directory")

elif S_ISREG(mode):
print("Regular File")

if (mode & S_IXUSR):


print("Executable User")
elif (mode & S_IWUSR):
print("Writable User")
elif (mode & S_IRUSR):
print("Readable User")

if (mode & S_IXOTH):


print("Executable Others")
elif (mode & S_IWOTH):
print("Writable Others")
elif (mode & S_IROTH):
print("Readable Others")

filePerm = filemode(mode)

print(f"File Permissions are {filePerm}")

print(f"File access time is {statinfo.st_atime}")


Output 4 :

Question 5 :

Write a program to copy files using system calls.

Solution 5 :

# Created by - DHANANJAY SINGHAL

file1 = "file1.txt"
file2 = "file2.txt"

lines=" "
with open(file1,'r',encoding='utf8') as src:
lines = src.readlines()

with open(file2,'a',encoding='utf8') as dest :


dest.writelines(lines)

print(f"Content copied from {file1} to {file2}")

Output 5 :

file1.txt (before) executing the code : file2.txt (before) executing the code :
file2.txt (after) executing the code :

Question 6 :

Write a program to implement FCFS scheduling algorithm.

Solution 6 :

/* Created by - DHANANJAY SINGHAL */

#include <iostream>
using namespace std;

void findWaitingTime(int processes[], int n, int bt[], int wt[])


{
// waiting time for first process is 0
wt[0] = 0;

// calculating waiting time


for (int i = 1; i < n; i++)
{
wt[i] = bt[i - 1] + wt[i - 1];
}
}

void findTurnAroundTime(int processes[], int n, int bt[], int wt[], int tat[])
{
// calculating turnaround time by adding bt[i] + wt[i]
for (int i = 0; i < n; i++)
{
tat[i] = bt[i] + wt[i];
}
}

void findavgTime(int processes[], int n, int bt[])


{
int wt[n], tat[n], total_wt = 0, total_tat = 0;

findWaitingTime(processes, n, bt, wt);


findTurnAroundTime(processes, n, bt, wt, tat);
cout << "Processes "
<< " Burst time "
<< " Waiting time "
<< " Turn around time\n";

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


{
total_wt = total_wt + wt[i];
total_tat = total_tat + tat[i];
cout << " " << i + 1 << "\t\t" << bt[i] << "\t "
<< wt[i] << "\t\t " << tat[i] << endl;
}

cout << "Average waiting time = "


<< (float)total_wt / (float)n;
cout << "\nAverage turn around time = "
<< (float)total_tat / (float)n;
}

int main()
{
int n;
cout << "Enter number of processes : ";
cin >> n;
int processes[n];
for (int i = 0; i < n; i++)
{
processes[i] = i + 1;
}

int burst_time[n];
cout << "Enter burst time of processes :- " << endl;
for (int i = 0; i < n; i++)

{
cout << i + 1 << " : ";
cin >> burst_time[i];
}

findavgTime(processes, n, burst_time);
return 0;
}
Output 6 :
Question 7 :

Write a program to implement Round Robin scheduling algorithm.

Solution 7 :

/* Created by - DHANANJAY SINGHAL */

#include <iostream>
using namespace std;

void findWaitingTime(int processes[], int n,


int bt[], int wt[], int quantum)
{
int rem_bt[n];
for (int i = 0; i < n; i++)
rem_bt[i] = bt[i];

int t = 0; // Current time

while (1)
{
bool done = true;

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


{
// If burst time of a process is greater than 0
// then only need to process further
if (rem_bt[i] > 0)
{
done = false; // There is a pending process

if (rem_bt[i] > quantum)


{
// Increase the value of t i.e. shows
// how much time a process has been processed
t += quantum;

// Decrease the burst_time of current process


// by quantum
rem_bt[i] -= quantum;
}

// If burst time is smaller than or equal to


// quantum. Last cycle for this process
else
{
// Increase the value of t i.e. shows
// how much time a process has been processed
t = t + rem_bt[i];

// Waiting time is current time minus time


// used by this process
wt[i] = t - bt[i];

// As the process gets fully executed


// make its remaining burst time = 0
rem_bt[i] = 0;
}
}
}

// If all processes are done


if (done == true)
break;
}
}

// Function to calculate turn around time


void findTurnAroundTime(int processes[], int n,
int bt[], int wt[], int tat[])
{
// calculating turnaround time by adding
// bt[i] + wt[i]
for (int i = 0; i < n; i++)
tat[i] = bt[i] + wt[i];
}

// Function to calculate average time


void findavgTime(int processes[], int n, int bt[],
int quantum)
{
int wt[n], tat[n], total_wt = 0, total_tat = 0;

// Function to find waiting time of all processes


findWaitingTime(processes, n, bt, wt, quantum);

// Function to find turn around time for all processes


findTurnAroundTime(processes, n, bt, wt, tat);

// Display processes along with all details


cout << " PN "
<< " \tBT "
<< " \tWT "
<< " \tTAT\n";

// Calculate total waiting time and total turn


// around time
for (int i = 0; i < n; i++)
{
total_wt = total_wt + wt[i];
total_tat = total_tat + tat[i];
cout << " " << i + 1 << "\t" << bt[i] << "\t "
<< wt[i] << "\t " << tat[i] << endl;
}

cout << "Average waiting time = "


<< (float)total_wt / (float)n;
cout << "\nAverage turn around time = "
<< (float)total_tat / (float)n;
}

// Driver code
int main()
{
int n;
cout << "Enter number of processes : ";
cin >> n;
int processes[n];
for (int i = 0; i < n; i++)
{
processes[i] = i + 1;
}

int burst_time[n];
cout << "Enter burst time of processes :- " << endl;
for (int i = 0; i < n; i++)
{
cout << i + 1 << " : ";
cin >> burst_time[i];
}

// Time quantum
int quantum = 2;
findavgTime(processes, n, burst_time, quantum);
return 0;
}
Output 7 :

Question 8 :

Write a program to implement SJF scheduling algorithm.

Solution 8 :

/* Created by - DHANANJAY SINGHAL */

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;

typedef struct proccess


{
int at, bt, ct, ta, wt, btt;
string pro_id;

/*
at = Arrival time,
bt = Burst time,
ct = Completion time,
ta = Turn around time,
wt = Waiting time
*/

} Schedule;

bool compare(Schedule a, Schedule b)


{
return a.at < b.at;

/* This Schedule will always return TRUE


if above condition comes*/
}
bool compare2(Schedule a, Schedule b)
{
return a.bt < b.bt;

/* This Schedule will always return TRUE


if above condition comes*/
}

int main()
{
Schedule pro[10];
// An array of Processes
int n, i, j, pcom;
// n = number of processes, i= iteration variable

cout << "Enter the number of Process::";


cin >> n;

cout << "Enter the Process id, arrival time and burst time of " << n << "
processes :::" << endl;

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


{
cout << "\nProcess id " << i + 1 << " : ";
cin >> pro[i].pro_id;
cout << "Arrival Time " << i + 1 << " : ";
cin >> pro[i].at;
cout << "Burst Time " << i + 1 << " : ";
cin >> pro[i].bt;
pro[i].btt = pro[i].bt;
}

sort(pro, pro + n, compare);

/*sort is a predefined funcion defined in algorithm.h header file,


it will sort the processes according to their arrival time*/

i = 0;
pcom = 0;
while (pcom < n)
{
for (j = 0; j < n; j++)
{
if (pro[j].at > i)
break;
}

sort(pro, pro + j, compare2);

/*sort is a predefined funcion defined in algorithm.h header file,


it will sort the processes according to their burst time*/

if (j > 0)
{

for (j = 0; j < n; j++)


{
if (pro[j].bt != 0)
break;
}
if (pro[j].at > i)

{
i = pro[j].at;
}
pro[j].ct = i + 1;
pro[j].bt--;
}
i++;
pcom = 0;
for (j = 0; j < n; j++)
{
if (pro[j].bt == 0)
pcom++;
}
}

cout << "ProID\tAtime\tBtime\tCtime\tTtime\tWtime\n";

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


{
pro[i].ta = pro[i].ct - pro[i].at;
pro[i].wt = pro[i].ta - pro[i].btt;

/*Printing the Process id, arrival time, burst time,


completion time, turn around time, waiting time*/
cout << pro[i].pro_id << "\t" << pro[i].at << "\t" << pro[i].btt << "\t" <<
pro[i].ct << "\t" << pro[i].ta << "\t" << pro[i].wt;
cout << endl;
}
return 0;
}

Output 8 :

Question 9 :

Write a program to implement non-preemptive priority based scheduling algorithm.

Solution 9 :

/* Created by - DHANANJAY SINGHAL */

#include <iostream>
#include <stdlib.h>
using namespace std;

struct Process
{
int pID;
int priority;
float arrivalTime;
float burstTime;
float completionTime;
float waitingTime;
float turnAroundTime;
};

void swapProcess(struct Process *a, struct Process *b)


{
struct Process temp = *a;
*a = *b;
*b = temp;
}

void sortForExec(struct Process *p, int n)


{
for (int i = 0; i < n - 1; ++i)
{
if (p[i].arrivalTime > p[i + 1].arrivalTime)
{
swapProcess(&p[i], &p[i + 1]);
}
else if (p[i].arrivalTime == p[i + 1].arrivalTime)
{
if (p[i].priority > p[i + 1].priority)
swapProcess(&p[i], &p[i + 1]);
else if (p[i].priority == p[i + 1].priority)
{
if (p[i].pID > p[i + 1].pID)
swapProcess(&p[i], &p[i + 1]);
}
}
}
return;
}

void sortAccPID(struct Process *p, int n)


{
for (int i = 0; i < n - 1; ++i)
{
if (p[i].pID > p[i + 1].pID)
{
swapProcess(&p[i], &p[i + 1]);
}
}
return;
}

void calcCompletionTime(struct Process *p, int n)


{
p[0].completionTime = p[0].burstTime;
for (int i = 1; i < n; ++i)
{
p[i].completionTime = p[i - 1].completionTime + p[i].burstTime;
}
return;
}

void calcTurnAroundTime(struct Process *p, int n)


{
for (int i = 0; i < n; ++i)
{
p[i].turnAroundTime = p[i].completionTime - p[i].arrivalTime;
}
return;
}

void calcWaitingTime(struct Process *p, int n)


{
for (int i = 0; i < n; ++i)
{
p[i].waitingTime = p[i].turnAroundTime - p[i].burstTime;
}
return;
}

void printAvgTime(struct Process *p, int n)


{
sortForExec(p, n);
calcCompletionTime(p, n);
sortAccPID(p, n);
calcTurnAroundTime(p, n);
calcWaitingTime(p, n);

// Printing Process Info


cout << " Non-preemptive Priority Based CPU Scheduling" << endl;
cout << " ------------------------------------------------" << endl;
cout << "\n process -> { priority, arrivalTime, burstTime, completionTime,
turnAroundTime, waitingTime }\n";
for (int i = 0; i < n; ++i)
{
cout << " P" << p[i].pID << " -> { " << p[i].priority << " , " <<
p[i].arrivalTime << " , " << p[i].burstTime << " , " << p[i].completionTime << " ,
" << p[i].turnAroundTime << " , " << p[i].waitingTime << " }\n";
}

// Calculating sum of waitingTime and turnAroundTime


float sumW = 0.0;
float sumT = 0.0;
for (int i = 0; i < n; ++i)
{
sumW += p[i].waitingTime;
sumT += p[i].turnAroundTime;
}

// Printing average waitingTime and turnAroundTime


cout << "\n Average Waiting Time: " << sumW / n;
cout << "\n Average Turn Around Time: " << sumT / n << endl;

return;
}

int main()
{
int n;

cout << "\n Enter number of Processes: ";


cin >> n;
cout << endl;

struct Process p[n];


for (int i = 0; i < n; ++i)
{
p[i].pID = i + 1;
cout << " Enter Priority of Process " << i + 1 << ": ";
cin >> p[i].priority;
cout << " Enter Arrival Time of Process " << i + 1 << ": ";
cin >> p[i].arrivalTime;
cout << " Enter Burst Time of Process " << i + 1 << ": ";
cin >> p[i].burstTime;
cout << endl;
}

printAvgTime(p, n);
cout << endl;

return 0;
}
Output 9 :

Question 10 :

Write a program to implement a preemptive priority based scheduling algorithm.

Solution 10 :

/* Created by - DHANANJAY SINGHAL */

#include <iostream>
#include <stdlib.h>
using namespace std;

struct Process
{
int pID;
int priority;
int arrivalTime;
int burstTime;
int completionTime;
int waitingTime;
int turnAroundTime;
};
void swapProcess(struct Process *a, struct Process *b)
{
struct Process temp = *a;
*a = *b;
*b = temp;
}

void sortForExec(struct Process *p, int n)


{
for (int i = 0; i < n - 1; ++i)
{
if (p[i].arrivalTime > p[i + 1].arrivalTime)
{
swapProcess(&p[i], &p[i + 1]);
}
else if (p[i].arrivalTime == p[i + 1].arrivalTime)
{
if (p[i].priority > p[i + 1].priority)
swapProcess(&p[i], &p[i + 1]);
else if (p[i].priority == p[i + 1].priority)
{
if (p[i].pID > p[i + 1].pID)
swapProcess(&p[i], &p[i + 1]);
}
}
}
return;
}

void sortAccPID(struct Process *p, int n)


{
for (int i = 0; i < n - 1; ++i)
{
if (p[i].pID > p[i + 1].pID)
{
swapProcess(&p[i], &p[i + 1]);
}
}
return;
}

void calcCompletionTime(struct Process *p, int n)


{
int remainingTime[n];
for (int i = 0; i < n; ++i)
remainingTime[i] = p[i].burstTime;
int minIndex, time = 0, count = 0;

for (time = 0; count != n; time++)


{
remainingTime[9] = 999;
minIndex = 9;

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


{
if (p[i].arrivalTime <= time && remainingTime[i] > 0 && p[i].priority
<= p[minIndex].priority)
{
minIndex = i;
}
}

if (remainingTime[minIndex] <= 0)
continue;

remainingTime[minIndex]--;

if (remainingTime[minIndex] == 0)
{
count++;
p[minIndex].completionTime = time + 1;
}
}
return;
}

void calcTurnAroundTime(struct Process *p, int n)


{
for (int i = 0; i < n; ++i)
{
p[i].turnAroundTime = p[i].completionTime - p[i].arrivalTime;
}
return;
}

void calcWaitingTime(struct Process *p, int n)


{
for (int i = 0; i < n; ++i)
{
p[i].waitingTime = p[i].turnAroundTime - p[i].burstTime;
}
return;
}
void printAvgTime(struct Process *p, int n)
{
sortForExec(p, n);
calcCompletionTime(p, n);
calcTurnAroundTime(p, n);
calcWaitingTime(p, n);
sortAccPID(p, n);

// Printing Process Info


cout << " Preemptive Priority Based CPU Scheduling" << endl;
cout << " ------------------------------" << endl;
cout << "\n process -> { priority, arrivalTime, burstTime, completionTime,
turnAroundTime, waitingTime }\n";
for (int i = 0; i < n; ++i)
{
cout << " P" << p[i].pID << " -> { " << p[i].priority << " , " <<
p[i].arrivalTime << " , " << p[i].burstTime << " , " << p[i].completionTime << " ,
" << p[i].turnAroundTime << " , " << p[i].waitingTime << " }\n";
}

// Calculating sum of waitingTime and turnAroundTime


int sumW = 0.0;
int sumT = 0.0;
for (int i = 0; i < n; ++i)
{
sumW += p[i].waitingTime;
sumT += p[i].turnAroundTime;
}

// Printing average waitingTime and turnAroundTime


cout << "\n Average Waiting Time: " << sumW / n;
cout << "\n Average Turn Around Time: " << sumT / n << endl;

return;
}

int main()
{
int n;

cout << "\n Enter number of Processes: ";


cin >> n;
cout << endl;

struct Process p[n];


for (int i = 0; i < n; ++i)
{
p[i].pID = i + 1;
cout << " Enter Priority of Process " << i + 1 << ": ";
cin >> p[i].priority;
cout << " Enter Arrival Time of Process " << i + 1 << ": ";
cin >> p[i].arrivalTime;
cout << " Enter Burst Time of Process " << i + 1 << ": ";
cin >> p[i].burstTime;
cout << endl;
}

printAvgTime(p, n);
cout << endl;

return 0;
}

Output 10 :
Question 11 :

Write a program to implement SRJF scheduling algorithm.

Solution 11 :

/* Created by - DHANANJAY SINGHAL */

#include <bits/stdc++.h>
using namespace std;

struct Process
{
int pid; // Process ID
int bt; // Burst Time
int art; // Arrival Time
};

// Function to find the waiting time for all processes


void findWaitingTime(Process proc[], int n, int wt[])
{
int rt[n];

// Copy the burst time into rt[]


for (int i = 0; i < n; i++)
rt[i] = proc[i].bt;

int complete = 0, t = 0, minm = INT_MAX;


int shortest = 0, finish_time;
bool check = false;

// Process until all processes gets


// completed
while (complete != n)
{

// Find process with minimum


// remaining time among the
// processes that arrives till the
// current time`
for (int j = 0; j < n; j++)
{
if ((proc[j].art <= t) &&
(rt[j] < minm) && rt[j] > 0)
{
minm = rt[j];
shortest = j;
check = true;
}
}

if (check == false)
{
t++;
continue;
}

// Reduce remaining time by one


rt[shortest]--;

// Update minimum
minm = rt[shortest];
if (minm == 0)
minm = INT_MAX;

// If a process gets completely


// executed
if (rt[shortest] == 0)
{

// Increment complete
complete++;
check = false;

// Find finish time of current


// process
finish_time = t + 1;

// Calculate waiting time


wt[shortest] = finish_time -
proc[shortest].bt -
proc[shortest].art;

if (wt[shortest] < 0)
wt[shortest] = 0;
}
// Increment time
t++;
}
}

// Function to calculate turn around time


void findTurnAroundTime(Process proc[], int n,
int wt[], int tat[])
{
// calculating turnaround time by adding
// bt[i] + wt[i]
for (int i = 0; i < n; i++)
tat[i] = proc[i].bt + wt[i];
}

// Function to calculate average time


void findavgTime(Process proc[], int n)
{
int wt[n], tat[n], total_wt = 0,
total_tat = 0;

// Function to find waiting time of all


// processes
findWaitingTime(proc, n, wt);

// Function to find turn around time for


// all processes
findTurnAroundTime(proc, n, wt, tat);

// Display processes along with all


// details
cout << " P\t\t"
<< "BT\t\t"
<< "WT\t\t"
<< "TAT\t\t\n";

// Calculate total waiting time and


// total turnaround time
for (int i = 0; i < n; i++)
{
total_wt = total_wt + wt[i];
total_tat = total_tat + tat[i];
cout << " " << proc[i].pid << "\t\t"
<< proc[i].bt << "\t\t " << wt[i]
<< "\t\t " << tat[i] << endl;
}

cout << "\nAverage waiting time = "


<< (float)total_wt / (float)n;
cout << "\nAverage turn around time = "
<< (float)total_tat / (float)n;
}

// Driver code
int main()
{
Process proc[] = {{1, 6, 2}, {2, 2, 5}, {3, 8, 1}, {4, 3, 0}, {5, 4, 4}};
int n = sizeof(proc) / sizeof(proc[0]);

findavgTime(proc, n);
return 0;
}

Output 11 :
Question 12 :

Write a program to calculate sum of n numbers using thread library.

Solution 12 :

# Created by - DHANANJAY SINGHAL

from threading import Thread

# function to create threads


def callThread(arg):
sumVal = 0
for i in range(1, arg+1):
print("Running")
sumVal += i
print(f"Sum is : {sumVal}")

if __name__ == "__main__":
thread = Thread(target=callThread, args=(10, ))
thread.start()
thread.join()
print("Parent thread")
print("Thread finished... Exiting")

Output 12 :
Question 13 :

Write a program to implement first-fit, best-fit and worst-fit allocation strategies.

Solution 13 :

/* Created by - DHANANJAY SINGHAL */

#include <iostream>
using namespace std;

class MemoryManagementAlgo
{
public:
int *block_size;
int total_blocks;
int *process_size;
int total_process;
MemoryManagementAlgo(int blkSize[], int tBlocks, int prSize[], int tProcess)
{
block_size = blkSize;
total_blocks = tBlocks;
process_size = prSize;
total_process = tProcess;
}
void First_Fit()
{
int allocation[total_process];
for (int i = 0; i < total_process; i++)
{
allocation[i] = -1;
}

for (int i = 0; i < total_process; i++)


{
for (int j = 0; j < total_blocks; j++)
{
if (block_size[j] >= process_size[i])
{
allocation[i] = j;
block_size[j] -= process_size[i];
break;
}
}
}
cout << "Process No.\t\tProcess Size\t\tBlock no." << endl;
for (int i = 0; i < total_process; i++)
{
cout << " " << i + 1 << " \t\t\t" << process_size[i] << " \t\t\t";
if (allocation[i] != -1)
{
cout << allocation[i] + 1;
}
else
{
cout << "Not Allocated";
}
cout << endl;
}
}

void Best_Fit()
{
int allocation[total_process];
for (int i = 0; i < total_process; i++)
{
allocation[i] = -1;
}

for (int i = 0; i < total_process; i++)


{
// Find the best fit block for current process
int bestIdx = -1;
for (int j = 0; j < total_blocks; j++)
{
if (block_size[j] >= process_size[i])
{
if (bestIdx == -1)
{
bestIdx = j;
}
else if (block_size[bestIdx] > block_size[j])
{
bestIdx = j;
}
}
}
if (bestIdx != -1)
{
// allocate block j to p[i] process
allocation[i] = bestIdx;
// Reduce available memory in this block.
block_size[bestIdx] -= process_size[i];
}
}
cout << "Process No.\t\tProcess Size\t\tBlock no." << endl;
for (int i = 0; i < total_process; i++)
{
cout << " " << i + 1 << " \t\t\t" << process_size[i] << " \t\t\t";
if (allocation[i] != -1)
{
cout << allocation[i] + 1;
}
else
{
cout << "Not Allocated";
}
cout << endl;
}
}

void Worst_Fit()
{
int allocation[total_process];
for (int i = 0; i < total_process; i++)
{
allocation[i] = -1;
}

for (int i = 0; i < total_process; i++)


{
// Find the best fit block for current process
int worstIdx = -1;
for (int j = 0; j < total_blocks; j++)
{
if (block_size[j] >= process_size[i])
{
if (worstIdx == -1)
{
worstIdx = j;
}
else if (block_size[worstIdx] < block_size[j])
{
worstIdx = j;
}
}
}
if (worstIdx != -1)
{
// allocate block j to p[i] process
allocation[i] = worstIdx;
// Reduce available memory in this block.
block_size[worstIdx] -= process_size[i];
}
}
cout << "Process No.\t\tProcess Size\t\tBlock no." << endl;
for (int i = 0; i < total_process; i++)
{
cout << " " << i + 1 << " \t\t\t" << process_size[i] << " \t\t\t";
if (allocation[i] != -1)
{
cout << allocation[i] + 1;
}
else
{
cout << "Not Allocated";
}
cout << endl;
}
}
};

int main()
{
/*
blkSize - Array to store Block Sizes
prcSize - Array to store Process Size
tblocks - Total number of blocks
tprc - Total number of process
*/

int tblocks, tprc;


cout << "Enter the number of blocks available ::: ";
cin >> tblocks;

int blkSize[tblocks];
cout << "Enter block sizes :::" << endl;
for (int i = 0; i < tblocks; i++)
{
cout << i + 1 << " - ";
cin >> blkSize[i];
}

cout << "Enter the number of processes available ::: ";


cin >> tprc;

int prcSize[tprc];
cout << "Enter process sizes :::" << endl;
for (int i = 0; i < tprc; i++)
{
cout << i + 1 << " - ";
cin >> prcSize[i];
}

cout << "\nEnter choice : \n1 - First Fit \n2 - Best Fit \n3 - Worst Fit\n";
int choice;
cin >> choice;
MemoryManagementAlgo ob(blkSize, tblocks, prcSize, tprc);
switch (choice)
{
case 1:
{
cout << "Your choice : First Fit" << endl;
ob.First_Fit();
break;
}
case 2:
{
cout << "Your choice : Best Fit" << endl;
ob.Best_Fit();
break;
}
case 3:
{
cout << "Your choice : Worst Fit" << endl;
ob.Worst_Fit();
break;
}
default:
{
cout << "Invalid choice" << endl;
break;
}
}

return 0;
}
Output 13 :
END OF ASSIGNMENT

You might also like