Ques. 14.

Write a program to implement priority scheduling algorithm with context

switching time. Prompt to user to enter the number of processes and then enter their
priority, burst time and arrival time also. Now whenever operating system preempts a
process and shifts cpu’s control to some another process of higher priority assume that
it takes 2 seconds for context switching(dispatcher latency).Form a scenario, where we
can give the processes are assigned with priority where the lower integer number is
higher priority and then context switch .. as the process waits the priority of the process
increase at rate of one per 2 time units of wait. Calculate waiting time and turnaround
time for each process.

Sol:- #include<iostream>

#include<iostream>
#include<algorithm>
#include<map>
#include<array>//Make pair
#include<queue>
#include<set>
#include<stack>
#include<tuple>
using namespace std;

int main()
{
int Burst_Time[20],Process_no[20],WaitinG_TimE[20],Turn_Around_Time[20];
int
Arrival_time[20],PrioritY[20],i,j,Number_of_Process,total=0,pos,temp,Average_Waiting
_Time,Average_Turn_Around_time;
 cout<<"Enter Total Number of Process:";
cin>>Number_of_Process;//Number of process

// cout<<"\nEnter Burst Time and Priority\n";

for(i=0;i<Number_of_Process;i++)
{
cout<<"\nProcess "<<i+1<<" \n";
cout<<"Enter Burst Time for Process:"<<i+1<<endl;//Burst time for each Process
cin>>Burst_Time[i];
cout<<"Enter Arrival Time for Process:"<<i+1<<endl;
cin>>Arrival_time[i];//Arrival time for each process
cout<<"Enter Priority for Process:"<<i+1<<endl;
cin>>PrioritY[i];
Process_no[i]=i+1; //contains process number
}

//sorting burst time, priority and process number in ascending order using selection
sort
for(i=0;i<Number_of_Process;i++)
{
pos=i;
for(j=i+1;j<Number_of_Process;j++)
{
if(PrioritY[j]<PrioritY[pos])
pos=j;
}
 swap(PrioritY[i],PrioritY[pos]);

swap(Burst_Time[i],Burst_Time[pos]);

swap(Process_no[i],Process_no[pos]);

WaitinG_TimE[0]=0; //waiting time for first process is zero

//calculate waiting time

for(i=1;i<Number_of_Process;i++)
{
WaitinG_TimE[i]=0;
for(j=0;j<i;j++)
WaitinG_TimE[i]+=Burst_Time[j];

total+=WaitinG_TimE[i];
}

Average_Waiting_Time=total/Number_of_Process; //average waiting time

total=0;

cout<<"____________________________________________________________
___";
 cout<<"\nProcess\t Burst Time Waiting Time Turnaround Time";
for(i=0;i<Number_of_Process;i++)
{
Turn_Around_Time[i]=Burst_Time[i]+WaitinG_TimE[i]; //calculate turnaround
time
total+=Turn_Around_Time[i];
cout<<"\nProcess "<<Process_no[i]<<" \t "<<Burst_Time[i]<<"\t \t
"<<WaitinG_TimE[i]<<"\t\t"<<Turn_Around_Time[i];
}

cout<<"\n__________________________________________________________
_____";
Average_Turn_Around_time=total/Number_of_Process; //average turnaround time
cout<<"\n\nAvg Waiting Time ="<<Average_Waiting_Time;
cout<<"\nAvg Turnaround Time="<<Average_Turn_Around_time;

return 0;
}

Ques. 21. Consider a scenario of demand paged memory. Page table is held in registers. It takes 8
milliseconds to service a page fault if an empty page is available or the replaced page is not modified
and 20 milliseconds if the replaced page is modified. Memory access time is 100 nanoseconds. Assume
that the page to be replaced is modified 70 percent of the time. Generate a solution to find maximum
acceptable page-fault rate for access time that is not more than 200 nanoseconds

Sol:- #include<iostream>

using namespace std;

int main()

float Effective_Access_Time,Page_Fault_Rate=100/16.4e6,Time_To_Modify=8/1e3;

float Time_To_Replace=20/1e3,Memory_Access_Time=100/1e9,Page_mod_per=.7;

Effective_Access_Time=(1-
Page_Fault_Rate)*(Memory_Access_Time)+(Page_Fault_Rate)*(Memory_Access_Time + (1-
Page_mod_per)*(Time_To_Modify)+(Page_mod_per)*(Time_To_Replace));

cout<<Effective_Access_Time;

return 0;

/*

Effective_Access_Time= (1-Page_Fault_Rate)*(100) + (Page_Fault_Rate)*(100 + (1-.7)*(8msec) +

(.7)*(20msec))

= 100 - 100Page_Fault_Rate + 100Page_Fault_Rate + (2.4e6)*Page_Fault_Rate +

(14e6)*Page_Fault_Rate

= 100 + (16.4e6)*Page_Fault_Rate

200 = 100 + (16.4e6)*Page_Fault_Rate

Page_Fault_Rate = 100/16.4e6

*/