├── fcfs_scheduling.cpp
├── nonpreemptive_priority.cpp
├── preemptive_priority_scheduling.cpp
├── roundrobin_scheduling.cpp
├── sjf_scheduling.cpp
└── srtf_scheduling.cpp


/fcfs_scheduling.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <algorithm> 
  3 | #include <iomanip> 
  4 | using namespace std;
  5 | 
  6 | struct process {
  7 |     int pid;
  8 |     int arrival_time;
  9 |     int burst_time;
 10 |     int start_time;
 11 |     int completion_time;
 12 |     int turnaround_time;
 13 |     int waiting_time;
 14 |     int response_time;
 15 | };
 16 | 
 17 | bool compareArrival(process p1, process p2) 
 18 | { 
 19 |     return p1.arrival_time < p2.arrival_time;
 20 | }
 21 | 
 22 | bool compareID(process p1, process p2) 
 23 | {  
 24 |     return p1.pid < p2.pid;
 25 | }
 26 | 
 27 | int main() {
 28 | 
 29 |     int n;
 30 |     struct process p[100];
 31 |     float avg_turnaround_time;
 32 |     float avg_waiting_time;
 33 |     float avg_response_time;
 34 |     float cpu_utilisation;
 35 |     int total_turnaround_time = 0;
 36 |     int total_waiting_time = 0;
 37 |     int total_response_time = 0;
 38 |     int total_idle_time = 0;
 39 |     float throughput;
 40 | 
 41 |     cout << setprecision(2) << fixed;
 42 | 
 43 |     cout<<"Enter the number of processes: ";
 44 |     cin>>n;
 45 | 
 46 |     for(int i = 0; i < n; i++) {
 47 |         cout<<"Enter arrival time of process "<<i+1<<": ";
 48 |         cin>>p[i].arrival_time;
 49 |         cout<<"Enter burst time of process "<<i+1<<": ";
 50 |         cin>>p[i].burst_time;
 51 |         p[i].pid = i+1;
 52 |         cout<<endl;
 53 |     }
 54 | 
 55 |     sort(p,p+n,compareArrival);
 56 | 
 57 |     for(int i = 0; i < n; i++) {
 58 |         p[i].start_time = (i == 0)?p[i].arrival_time:max(p[i-1].completion_time,p[i].arrival_time);
 59 |         p[i].completion_time = p[i].start_time + p[i].burst_time;
 60 |         p[i].turnaround_time = p[i].completion_time - p[i].arrival_time;
 61 |         p[i].waiting_time = p[i].turnaround_time - p[i].burst_time;
 62 |         p[i].response_time = p[i].start_time - p[i].arrival_time;
 63 | 
 64 |         total_turnaround_time += p[i].turnaround_time;
 65 |         total_waiting_time += p[i].waiting_time;
 66 |         total_response_time += p[i].response_time;
 67 |         total_idle_time += (i == 0)?(p[i].arrival_time):(p[i].start_time - p[i-1].completion_time);
 68 |     }
 69 | 
 70 |     avg_turnaround_time = (float) total_turnaround_time / n;
 71 |     avg_waiting_time = (float) total_waiting_time / n;
 72 |     avg_response_time = (float) total_response_time / n;
 73 |     cpu_utilisation = ((p[n-1].completion_time - total_idle_time) / (float) p[n-1].completion_time)*100;
 74 |     throughput = float(n) / (p[n-1].completion_time - p[0].arrival_time);
 75 | 
 76 |     sort(p,p+n,compareID);
 77 | 
 78 |     cout<<endl;
 79 |     cout<<"#P\t"<<"AT\t"<<"BT\t"<<"ST\t"<<"CT\t"<<"TAT\t"<<"WT\t"<<"RT\t"<<"\n"<<endl;
 80 | 
 81 |     for(int i = 0; i < n; i++) {
 82 |         cout<<p[i].pid<<"\t"<<p[i].arrival_time<<"\t"<<p[i].burst_time<<"\t"<<p[i].start_time<<"\t"<<p[i].completion_time<<"\t"<<p[i].turnaround_time<<"\t"<<p[i].waiting_time<<"\t"<<p[i].response_time<<"\t"<<"\n"<<endl;
 83 |     }
 84 |     cout<<"Average Turnaround Time = "<<avg_turnaround_time<<endl;
 85 |     cout<<"Average Waiting Time = "<<avg_waiting_time<<endl;
 86 |     cout<<"Average Response Time = "<<avg_response_time<<endl;
 87 |     cout<<"CPU Utilization = "<<cpu_utilisation<<"%"<<endl;
 88 |     cout<<"Throughput = "<<throughput<<" process/unit time"<<endl;
 89 | 
 90 | 
 91 | }
 92 | 
 93 | /*
 94 | 
 95 | AT - Arrival Time of the process
 96 | BT - Burst time of the process
 97 | ST - Start time of the process
 98 | CT - Completion time of the process
 99 | TAT - Turnaround time of the process
100 | WT - Waiting time of the process
101 | RT - Response time of the process
102 | 
103 | Formulas used:
104 | 
105 | TAT = CT - AT
106 | WT = TAT - BT
107 | RT = ST - AT
108 | 
109 | */


--------------------------------------------------------------------------------
/nonpreemptive_priority.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <algorithm> 
  3 | #include <iomanip>
  4 | #include <string.h> 
  5 | using namespace std;
  6 | 
  7 | struct process {
  8 |     int pid;
  9 |     int arrival_time;
 10 |     int burst_time;
 11 |     int priority;
 12 |     int start_time;
 13 |     int completion_time;
 14 |     int turnaround_time;
 15 |     int waiting_time;
 16 |     int response_time;
 17 | };
 18 | 
 19 | int main() {
 20 | 
 21 |     int n;
 22 |     struct process p[100];
 23 |     float avg_turnaround_time;
 24 |     float avg_waiting_time;
 25 |     float avg_response_time;
 26 |     float cpu_utilisation;
 27 |     int total_turnaround_time = 0;
 28 |     int total_waiting_time = 0;
 29 |     int total_response_time = 0;
 30 |     int total_idle_time = 0;
 31 |     float throughput;
 32 |     int is_completed[100];
 33 |     memset(is_completed,0,sizeof(is_completed));
 34 | 
 35 |     cout << setprecision(2) << fixed;
 36 | 
 37 |     cout<<"Enter the number of processes: ";
 38 |     cin>>n;
 39 | 
 40 |     for(int i = 0; i < n; i++) {
 41 |         cout<<"Enter arrival time of process "<<i+1<<": ";
 42 |         cin>>p[i].arrival_time;
 43 |         cout<<"Enter burst time of process "<<i+1<<": ";
 44 |         cin>>p[i].burst_time;
 45 |         cout<<"Enter priority of the process "<<i+1<<": ";
 46 |         cin>>p[i].priority;
 47 |         p[i].pid = i+1;
 48 |         cout<<endl;
 49 |     }
 50 | 
 51 |     int current_time = 0;
 52 |     int completed = 0;
 53 |     int prev = 0;
 54 | 
 55 |     while(completed != n) {
 56 |         int idx = -1;
 57 |         int mx = -1;
 58 |         for(int i = 0; i < n; i++) {
 59 |             if(p[i].arrival_time <= current_time && is_completed[i] == 0) {
 60 |                 if(p[i].priority > mx) {
 61 |                     mx = p[i].priority;
 62 |                     idx = i;
 63 |                 }
 64 |                 if(p[i].priority == mx) {
 65 |                     if(p[i].arrival_time < p[idx].arrival_time) {
 66 |                         mx = p[i].priority;
 67 |                         idx = i;
 68 |                     }
 69 |                 }
 70 |             }
 71 |         }
 72 |         if(idx != -1) {
 73 |             p[idx].start_time = current_time;
 74 |             p[idx].completion_time = p[idx].start_time + p[idx].burst_time;
 75 |             p[idx].turnaround_time = p[idx].completion_time - p[idx].arrival_time;
 76 |             p[idx].waiting_time = p[idx].turnaround_time - p[idx].burst_time;
 77 |             p[idx].response_time = p[idx].start_time - p[idx].arrival_time;
 78 |             
 79 |             total_turnaround_time += p[idx].turnaround_time;
 80 |             total_waiting_time += p[idx].waiting_time;
 81 |             total_response_time += p[idx].response_time;
 82 |             total_idle_time += p[idx].start_time - prev;
 83 | 
 84 |             is_completed[idx] = 1;
 85 |             completed++;
 86 |             current_time = p[idx].completion_time;
 87 |             prev = current_time;
 88 |         }
 89 |         else {
 90 |             current_time++;
 91 |         }
 92 |         
 93 |     }
 94 | 
 95 |     int min_arrival_time = 10000000;
 96 |     int max_completion_time = -1;
 97 |     for(int i = 0; i < n; i++) {
 98 |         min_arrival_time = min(min_arrival_time,p[i].arrival_time);
 99 |         max_completion_time = max(max_completion_time,p[i].completion_time);
100 |     }
101 | 
102 |     avg_turnaround_time = (float) total_turnaround_time / n;
103 |     avg_waiting_time = (float) total_waiting_time / n;
104 |     avg_response_time = (float) total_response_time / n;
105 |     cpu_utilisation = ((max_completion_time - total_idle_time) / (float) max_completion_time )*100;
106 |     throughput = float(n) / (max_completion_time - min_arrival_time);
107 | 
108 |     cout<<endl<<endl;
109 | 
110 |     cout<<"#P\t"<<"AT\t"<<"BT\t"<<"PRI\t"<<"ST\t"<<"CT\t"<<"TAT\t"<<"WT\t"<<"RT\t"<<"\n"<<endl;
111 | 
112 |     for(int i = 0; i < n; i++) {
113 |         cout<<p[i].pid<<"\t"<<p[i].arrival_time<<"\t"<<p[i].burst_time<<"\t"<<p[i].priority<<"\t"<<p[i].start_time<<"\t"<<p[i].completion_time<<"\t"<<p[i].turnaround_time<<"\t"<<p[i].waiting_time<<"\t"<<p[i].response_time<<"\t"<<"\n"<<endl;
114 |     }
115 |     cout<<"Average Turnaround Time = "<<avg_turnaround_time<<endl;
116 |     cout<<"Average Waiting Time = "<<avg_waiting_time<<endl;
117 |     cout<<"Average Response Time = "<<avg_response_time<<endl;
118 |     cout<<"CPU Utilization = "<<cpu_utilisation<<"%"<<endl;
119 |     cout<<"Throughput = "<<throughput<<" process/unit time"<<endl;
120 | 
121 | 
122 | }
123 | 
124 | /*
125 | 
126 | AT - Arrival Time of the process
127 | BT - Burst time of the process
128 | ST - Start time of the process
129 | CT - Completion time of the process
130 | TAT - Turnaround time of the process
131 | WT - Waiting time of the process
132 | RT - Response time of the process
133 | 
134 | Formulas used:
135 | 
136 | TAT = CT - AT
137 | WT = TAT - BT
138 | RT = ST - AT
139 | 
140 | */


--------------------------------------------------------------------------------
/preemptive_priority_scheduling.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <algorithm> 
  3 | #include <iomanip>
  4 | #include <string.h> 
  5 | using namespace std;
  6 | 
  7 | struct process {
  8 |     int pid;
  9 |     int arrival_time;
 10 |     int burst_time;
 11 |     int priority;
 12 |     int start_time;
 13 |     int completion_time;
 14 |     int turnaround_time;
 15 |     int waiting_time;
 16 |     int response_time;
 17 | };
 18 | 
 19 | int main() {
 20 | 
 21 |     int n;
 22 |     struct process p[100];
 23 |     float avg_turnaround_time;
 24 |     float avg_waiting_time;
 25 |     float avg_response_time;
 26 |     float cpu_utilisation;
 27 |     int total_turnaround_time = 0;
 28 |     int total_waiting_time = 0;
 29 |     int total_response_time = 0;
 30 |     int total_idle_time = 0;
 31 |     float throughput;
 32 |     int burst_remaining[100];
 33 |     int is_completed[100];
 34 |     memset(is_completed,0,sizeof(is_completed));
 35 | 
 36 |     cout << setprecision(2) << fixed;
 37 | 
 38 |     cout<<"Enter the number of processes: ";
 39 |     cin>>n;
 40 | 
 41 |     for(int i = 0; i < n; i++) {
 42 |         cout<<"Enter arrival time of process "<<i+1<<": ";
 43 |         cin>>p[i].arrival_time;
 44 |         cout<<"Enter burst time of process "<<i+1<<": ";
 45 |         cin>>p[i].burst_time;
 46 |         cout<<"Enter priority of the process "<<i+1<<": ";
 47 |         cin>>p[i].priority;
 48 |         p[i].pid = i+1;
 49 |         burst_remaining[i] = p[i].burst_time;
 50 |         cout<<endl;
 51 |     }
 52 | 
 53 |     int current_time = 0;
 54 |     int completed = 0;
 55 |     int prev = 0;
 56 | 
 57 |     while(completed != n) {
 58 |         int idx = -1;
 59 |         int mx = -1;
 60 |         for(int i = 0; i < n; i++) {
 61 |             if(p[i].arrival_time <= current_time && is_completed[i] == 0) {
 62 |                 if(p[i].priority > mx) {
 63 |                     mx = p[i].priority;
 64 |                     idx = i;
 65 |                 }
 66 |                 if(p[i].priority == mx) {
 67 |                     if(p[i].arrival_time < p[idx].arrival_time) {
 68 |                         mx = p[i].priority;
 69 |                         idx = i;
 70 |                     }
 71 |                 }
 72 |             }
 73 |         }
 74 | 
 75 |         if(idx != -1) {
 76 |             if(burst_remaining[idx] == p[idx].burst_time) {
 77 |                 p[idx].start_time = current_time;
 78 |                 total_idle_time += p[idx].start_time - prev;
 79 |             }
 80 |             burst_remaining[idx] -= 1;
 81 |             current_time++;
 82 |             prev = current_time;
 83 |             
 84 |             if(burst_remaining[idx] == 0) {
 85 |                 p[idx].completion_time = current_time;
 86 |                 p[idx].turnaround_time = p[idx].completion_time - p[idx].arrival_time;
 87 |                 p[idx].waiting_time = p[idx].turnaround_time - p[idx].burst_time;
 88 |                 p[idx].response_time = p[idx].start_time - p[idx].arrival_time;
 89 | 
 90 |                 total_turnaround_time += p[idx].turnaround_time;
 91 |                 total_waiting_time += p[idx].waiting_time;
 92 |                 total_response_time += p[idx].response_time;
 93 | 
 94 |                 is_completed[idx] = 1;
 95 |                 completed++;
 96 |             }
 97 |         }
 98 |         else {
 99 |              current_time++;
100 |         }  
101 |     }
102 | 
103 |     int min_arrival_time = 10000000;
104 |     int max_completion_time = -1;
105 |     for(int i = 0; i < n; i++) {
106 |         min_arrival_time = min(min_arrival_time,p[i].arrival_time);
107 |         max_completion_time = max(max_completion_time,p[i].completion_time);
108 |     }
109 | 
110 |     avg_turnaround_time = (float) total_turnaround_time / n;
111 |     avg_waiting_time = (float) total_waiting_time / n;
112 |     avg_response_time = (float) total_response_time / n;
113 |     cpu_utilisation = ((max_completion_time - total_idle_time) / (float) max_completion_time )*100;
114 |     throughput = float(n) / (max_completion_time - min_arrival_time);
115 | 
116 |     cout<<endl<<endl;
117 | 
118 |     cout<<"#P\t"<<"AT\t"<<"BT\t"<<"PRI\t"<<"ST\t"<<"CT\t"<<"TAT\t"<<"WT\t"<<"RT\t"<<"\n"<<endl;
119 | 
120 |     for(int i = 0; i < n; i++) {
121 |         cout<<p[i].pid<<"\t"<<p[i].arrival_time<<"\t"<<p[i].burst_time<<"\t"<<p[i].priority<<"\t"<<p[i].start_time<<"\t"<<p[i].completion_time<<"\t"<<p[i].turnaround_time<<"\t"<<p[i].waiting_time<<"\t"<<p[i].response_time<<"\t"<<"\n"<<endl;
122 |     }
123 |     cout<<"Average Turnaround Time = "<<avg_turnaround_time<<endl;
124 |     cout<<"Average Waiting Time = "<<avg_waiting_time<<endl;
125 |     cout<<"Average Response Time = "<<avg_response_time<<endl;
126 |     cout<<"CPU Utilization = "<<cpu_utilisation<<"%"<<endl;
127 |     cout<<"Throughput = "<<throughput<<" process/unit time"<<endl;
128 | 
129 | 
130 | }
131 | 
132 | /*
133 | 
134 | AT - Arrival Time of the process
135 | BT - Burst time of the process
136 | ST - Start time of the process
137 | CT - Completion time of the process
138 | TAT - Turnaround time of the process
139 | WT - Waiting time of the process
140 | RT - Response time of the process
141 | 
142 | Formulas used:
143 | 
144 | TAT = CT - AT
145 | WT = TAT - BT
146 | RT = ST - AT
147 | 
148 | */


--------------------------------------------------------------------------------
/roundrobin_scheduling.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <algorithm> 
  3 | #include <iomanip>
  4 | #include <queue> 
  5 | #include <string.h>
  6 | using namespace std;
  7 | 
  8 | struct process {
  9 |     int pid;
 10 |     int arrival_time;
 11 |     int burst_time;
 12 |     int start_time;
 13 |     int completion_time;
 14 |     int turnaround_time;
 15 |     int waiting_time;
 16 |     int response_time;
 17 | };
 18 | 
 19 | bool compare1(process p1, process p2) 
 20 | { 
 21 |     return p1.arrival_time < p2.arrival_time;
 22 | }
 23 | 
 24 | bool compare2(process p1, process p2) 
 25 | {  
 26 |     return p1.pid < p2.pid;
 27 | }
 28 | 
 29 | int main() {
 30 | 
 31 |     int n;
 32 |     int tq;
 33 |     struct process p[100];
 34 |     float avg_turnaround_time;
 35 |     float avg_waiting_time;
 36 |     float avg_response_time;
 37 |     float cpu_utilisation;
 38 |     int total_turnaround_time = 0;
 39 |     int total_waiting_time = 0;
 40 |     int total_response_time = 0;
 41 |     int total_idle_time = 0;
 42 |     float throughput;
 43 |     int burst_remaining[100];
 44 |     int idx;
 45 | 
 46 |     cout << setprecision(2) << fixed;
 47 | 
 48 |     cout<<"Enter the number of processes: ";
 49 |     cin>>n;
 50 |     cout<<"Enter time quantum: ";
 51 |     cin>>tq;
 52 | 
 53 |     for(int i = 0; i < n; i++) {
 54 |         cout<<"Enter arrival time of process "<<i+1<<": ";
 55 |         cin>>p[i].arrival_time;
 56 |         cout<<"Enter burst time of process "<<i+1<<": ";
 57 |         cin>>p[i].burst_time;
 58 |         burst_remaining[i] = p[i].burst_time;
 59 |         p[i].pid = i+1;
 60 |         cout<<endl;
 61 |     }
 62 | 
 63 |     sort(p,p+n,compare1);
 64 | 
 65 |     queue<int> q;
 66 |     int current_time = 0;
 67 |     q.push(0);
 68 |     int completed = 0;
 69 |     int mark[100];
 70 |     memset(mark,0,sizeof(mark));
 71 |     mark[0] = 1;
 72 | 
 73 |     while(completed != n) {
 74 |         idx = q.front();
 75 |         q.pop();
 76 | 
 77 |         if(burst_remaining[idx] == p[idx].burst_time) {
 78 |             p[idx].start_time = max(current_time,p[idx].arrival_time);
 79 |             total_idle_time += p[idx].start_time - current_time;
 80 |             current_time = p[idx].start_time;
 81 |         }
 82 | 
 83 |         if(burst_remaining[idx]-tq > 0) {
 84 |             burst_remaining[idx] -= tq;
 85 |             current_time += tq;
 86 |         }
 87 |         else {
 88 |             current_time += burst_remaining[idx];
 89 |             burst_remaining[idx] = 0;
 90 |             completed++;
 91 | 
 92 |             p[idx].completion_time = current_time;
 93 |             p[idx].turnaround_time = p[idx].completion_time - p[idx].arrival_time;
 94 |             p[idx].waiting_time = p[idx].turnaround_time - p[idx].burst_time;
 95 |             p[idx].response_time = p[idx].start_time - p[idx].arrival_time;
 96 | 
 97 |             total_turnaround_time += p[idx].turnaround_time;
 98 |             total_waiting_time += p[idx].waiting_time;
 99 |             total_response_time += p[idx].response_time;
100 |         }
101 | 
102 |         for(int i = 1; i < n; i++) {
103 |             if(burst_remaining[i] > 0 && p[i].arrival_time <= current_time && mark[i] == 0) {
104 |                 q.push(i);
105 |                 mark[i] = 1;
106 |             }
107 |         }
108 |         if(burst_remaining[idx] > 0) {
109 |             q.push(idx);
110 |         }
111 | 
112 |         if(q.empty()) {
113 |             for(int i = 1; i < n; i++) {
114 |                 if(burst_remaining[i] > 0) {
115 |                     q.push(i);
116 |                     mark[i] = 1;
117 |                     break;
118 |                 }
119 |             }
120 |         }
121 | 
122 | 
123 |     }
124 | 
125 |     avg_turnaround_time = (float) total_turnaround_time / n;
126 |     avg_waiting_time = (float) total_waiting_time / n;
127 |     avg_response_time = (float) total_response_time / n;
128 |     cpu_utilisation = ((p[n-1].completion_time - total_idle_time) / (float) p[n-1].completion_time)*100;
129 |     throughput = float(n) / (p[n-1].completion_time - p[0].arrival_time);
130 | 
131 |     sort(p,p+n,compare2);
132 | 
133 |     cout<<endl;
134 |     cout<<"#P\t"<<"AT\t"<<"BT\t"<<"ST\t"<<"CT\t"<<"TAT\t"<<"WT\t"<<"RT\t"<<"\n"<<endl;
135 | 
136 |     for(int i = 0; i < n; i++) {
137 |         cout<<p[i].pid<<"\t"<<p[i].arrival_time<<"\t"<<p[i].burst_time<<"\t"<<p[i].start_time<<"\t"<<p[i].completion_time<<"\t"<<p[i].turnaround_time<<"\t"<<p[i].waiting_time<<"\t"<<p[i].response_time<<"\t"<<"\n"<<endl;
138 |     }
139 |     cout<<"Average Turnaround Time = "<<avg_turnaround_time<<endl;
140 |     cout<<"Average Waiting Time = "<<avg_waiting_time<<endl;
141 |     cout<<"Average Response Time = "<<avg_response_time<<endl;
142 |     cout<<"CPU Utilization = "<<cpu_utilisation<<"%"<<endl;
143 |     cout<<"Throughput = "<<throughput<<" process/unit time"<<endl;
144 | 
145 | 
146 | }
147 | 
148 | /*
149 | 
150 | AT - Arrival Time of the process
151 | BT - Burst time of the process
152 | ST - Start time of the process
153 | CT - Completion time of the process
154 | TAT - Turnaround time of the process
155 | WT - Waiting time of the process
156 | RT - Response time of the process
157 | 
158 | Formulas used:
159 | 
160 | TAT = CT - AT
161 | WT = TAT - BT
162 | RT = ST - AT
163 | 
164 | */
165 | 


--------------------------------------------------------------------------------
/sjf_scheduling.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <algorithm> 
  3 | #include <iomanip>
  4 | #include <string.h> 
  5 | using namespace std;
  6 | 
  7 | struct process {
  8 |     int pid;
  9 |     int arrival_time;
 10 |     int burst_time;
 11 |     int start_time;
 12 |     int completion_time;
 13 |     int turnaround_time;
 14 |     int waiting_time;
 15 |     int response_time;
 16 | };
 17 | 
 18 | int main() {
 19 | 
 20 |     int n;
 21 |     struct process p[100];
 22 |     float avg_turnaround_time;
 23 |     float avg_waiting_time;
 24 |     float avg_response_time;
 25 |     float cpu_utilisation;
 26 |     int total_turnaround_time = 0;
 27 |     int total_waiting_time = 0;
 28 |     int total_response_time = 0;
 29 |     int total_idle_time = 0;
 30 |     float throughput;
 31 |     int is_completed[100];
 32 |     memset(is_completed,0,sizeof(is_completed));
 33 | 
 34 |     cout << setprecision(2) << fixed;
 35 | 
 36 |     cout<<"Enter the number of processes: ";
 37 |     cin>>n;
 38 | 
 39 |     for(int i = 0; i < n; i++) {
 40 |         cout<<"Enter arrival time of process "<<i+1<<": ";
 41 |         cin>>p[i].arrival_time;
 42 |         cout<<"Enter burst time of process "<<i+1<<": ";
 43 |         cin>>p[i].burst_time;
 44 |         p[i].pid = i+1;
 45 |         cout<<endl;
 46 |     }
 47 | 
 48 |     int current_time = 0;
 49 |     int completed = 0;
 50 |     int prev = 0;
 51 | 
 52 |     while(completed != n) {
 53 |         int idx = -1;
 54 |         int mn = 10000000;
 55 |         for(int i = 0; i < n; i++) {
 56 |             if(p[i].arrival_time <= current_time && is_completed[i] == 0) {
 57 |                 if(p[i].burst_time < mn) {
 58 |                     mn = p[i].burst_time;
 59 |                     idx = i;
 60 |                 }
 61 |                 if(p[i].burst_time == mn) {
 62 |                     if(p[i].arrival_time < p[idx].arrival_time) {
 63 |                         mn = p[i].burst_time;
 64 |                         idx = i;
 65 |                     }
 66 |                 }
 67 |             }
 68 |         }
 69 |         if(idx != -1) {
 70 |             p[idx].start_time = current_time;
 71 |             p[idx].completion_time = p[idx].start_time + p[idx].burst_time;
 72 |             p[idx].turnaround_time = p[idx].completion_time - p[idx].arrival_time;
 73 |             p[idx].waiting_time = p[idx].turnaround_time - p[idx].burst_time;
 74 |             p[idx].response_time = p[idx].start_time - p[idx].arrival_time;
 75 |             
 76 |             total_turnaround_time += p[idx].turnaround_time;
 77 |             total_waiting_time += p[idx].waiting_time;
 78 |             total_response_time += p[idx].response_time;
 79 |             total_idle_time += p[idx].start_time - prev;
 80 | 
 81 |             is_completed[idx] = 1;
 82 |             completed++;
 83 |             current_time = p[idx].completion_time;
 84 |             prev = current_time;
 85 |         }
 86 |         else {
 87 |             current_time++;
 88 |         }
 89 |         
 90 |     }
 91 | 
 92 |     int min_arrival_time = 10000000;
 93 |     int max_completion_time = -1;
 94 |     for(int i = 0; i < n; i++) {
 95 |         min_arrival_time = min(min_arrival_time,p[i].arrival_time);
 96 |         max_completion_time = max(max_completion_time,p[i].completion_time);
 97 |     }
 98 | 
 99 |     avg_turnaround_time = (float) total_turnaround_time / n;
100 |     avg_waiting_time = (float) total_waiting_time / n;
101 |     avg_response_time = (float) total_response_time / n;
102 |     cpu_utilisation = ((max_completion_time - total_idle_time) / (float) max_completion_time )*100;
103 |     throughput = float(n) / (max_completion_time - min_arrival_time);
104 | 
105 |     cout<<endl<<endl;
106 | 
107 |     cout<<"#P\t"<<"AT\t"<<"BT\t"<<"ST\t"<<"CT\t"<<"TAT\t"<<"WT\t"<<"RT\t"<<"\n"<<endl;
108 | 
109 |     for(int i = 0; i < n; i++) {
110 |         cout<<p[i].pid<<"\t"<<p[i].arrival_time<<"\t"<<p[i].burst_time<<"\t"<<p[i].start_time<<"\t"<<p[i].completion_time<<"\t"<<p[i].turnaround_time<<"\t"<<p[i].waiting_time<<"\t"<<p[i].response_time<<"\t"<<"\n"<<endl;
111 |     }
112 |     cout<<"Average Turnaround Time = "<<avg_turnaround_time<<endl;
113 |     cout<<"Average Waiting Time = "<<avg_waiting_time<<endl;
114 |     cout<<"Average Response Time = "<<avg_response_time<<endl;
115 |     cout<<"CPU Utilization = "<<cpu_utilisation<<"%"<<endl;
116 |     cout<<"Throughput = "<<throughput<<" process/unit time"<<endl;
117 | 
118 | 
119 | }
120 | 
121 | /*
122 | 
123 | AT - Arrival Time of the process
124 | BT - Burst time of the process
125 | ST - Start time of the process
126 | CT - Completion time of the process
127 | TAT - Turnaround time of the process
128 | WT - Waiting time of the process
129 | RT - Response time of the process
130 | 
131 | Formulas used:
132 | 
133 | TAT = CT - AT
134 | WT = TAT - BT
135 | RT = ST - AT
136 | 
137 | */


--------------------------------------------------------------------------------
/srtf_scheduling.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <algorithm> 
  3 | #include <iomanip>
  4 | #include <string.h> 
  5 | using namespace std;
  6 | 
  7 | struct process {
  8 |     int pid;
  9 |     int arrival_time;
 10 |     int burst_time;
 11 |     int start_time;
 12 |     int completion_time;
 13 |     int turnaround_time;
 14 |     int waiting_time;
 15 |     int response_time;
 16 | };
 17 | 
 18 | int main() {
 19 | 
 20 |     int n;
 21 |     struct process p[100];
 22 |     float avg_turnaround_time;
 23 |     float avg_waiting_time;
 24 |     float avg_response_time;
 25 |     float cpu_utilisation;
 26 |     int total_turnaround_time = 0;
 27 |     int total_waiting_time = 0;
 28 |     int total_response_time = 0;
 29 |     int total_idle_time = 0;
 30 |     float throughput;
 31 |     int burst_remaining[100];
 32 |     int is_completed[100];
 33 |     memset(is_completed,0,sizeof(is_completed));
 34 | 
 35 |     cout << setprecision(2) << fixed;
 36 | 
 37 |     cout<<"Enter the number of processes: ";
 38 |     cin>>n;
 39 | 
 40 |     for(int i = 0; i < n; i++) {
 41 |         cout<<"Enter arrival time of process "<<i+1<<": ";
 42 |         cin>>p[i].arrival_time;
 43 |         cout<<"Enter burst time of process "<<i+1<<": ";
 44 |         cin>>p[i].burst_time;
 45 |         p[i].pid = i+1;
 46 |         burst_remaining[i] = p[i].burst_time;
 47 |         cout<<endl;
 48 |     }
 49 | 
 50 |     int current_time = 0;
 51 |     int completed = 0;
 52 |     int prev = 0;
 53 | 
 54 |     while(completed != n) {
 55 |         int idx = -1;
 56 |         int mn = 10000000;
 57 |         for(int i = 0; i < n; i++) {
 58 |             if(p[i].arrival_time <= current_time && is_completed[i] == 0) {
 59 |                 if(burst_remaining[i] < mn) {
 60 |                     mn = burst_remaining[i];
 61 |                     idx = i;
 62 |                 }
 63 |                 if(burst_remaining[i] == mn) {
 64 |                     if(p[i].arrival_time < p[idx].arrival_time) {
 65 |                         mn = burst_remaining[i];
 66 |                         idx = i;
 67 |                     }
 68 |                 }
 69 |             }
 70 |         }
 71 | 
 72 |         if(idx != -1) {
 73 |             if(burst_remaining[idx] == p[idx].burst_time) {
 74 |                 p[idx].start_time = current_time;
 75 |                 total_idle_time += p[idx].start_time - prev;
 76 |             }
 77 |             burst_remaining[idx] -= 1;
 78 |             current_time++;
 79 |             prev = current_time;
 80 |             
 81 |             if(burst_remaining[idx] == 0) {
 82 |                 p[idx].completion_time = current_time;
 83 |                 p[idx].turnaround_time = p[idx].completion_time - p[idx].arrival_time;
 84 |                 p[idx].waiting_time = p[idx].turnaround_time - p[idx].burst_time;
 85 |                 p[idx].response_time = p[idx].start_time - p[idx].arrival_time;
 86 | 
 87 |                 total_turnaround_time += p[idx].turnaround_time;
 88 |                 total_waiting_time += p[idx].waiting_time;
 89 |                 total_response_time += p[idx].response_time;
 90 | 
 91 |                 is_completed[idx] = 1;
 92 |                 completed++;
 93 |             }
 94 |         }
 95 |         else {
 96 |              current_time++;
 97 |         }  
 98 |     }
 99 | 
100 |     int min_arrival_time = 10000000;
101 |     int max_completion_time = -1;
102 |     for(int i = 0; i < n; i++) {
103 |         min_arrival_time = min(min_arrival_time,p[i].arrival_time);
104 |         max_completion_time = max(max_completion_time,p[i].completion_time);
105 |     }
106 | 
107 |     avg_turnaround_time = (float) total_turnaround_time / n;
108 |     avg_waiting_time = (float) total_waiting_time / n;
109 |     avg_response_time = (float) total_response_time / n;
110 |     cpu_utilisation = ((max_completion_time - total_idle_time) / (float) max_completion_time )*100;
111 |     throughput = float(n) / (max_completion_time - min_arrival_time);
112 | 
113 |     cout<<endl<<endl;
114 | 
115 |     cout<<"#P\t"<<"AT\t"<<"BT\t"<<"ST\t"<<"CT\t"<<"TAT\t"<<"WT\t"<<"RT\t"<<"\n"<<endl;
116 | 
117 |     for(int i = 0; i < n; i++) {
118 |         cout<<p[i].pid<<"\t"<<p[i].arrival_time<<"\t"<<p[i].burst_time<<"\t"<<p[i].start_time<<"\t"<<p[i].completion_time<<"\t"<<p[i].turnaround_time<<"\t"<<p[i].waiting_time<<"\t"<<p[i].response_time<<"\t"<<"\n"<<endl;
119 |     }
120 |     cout<<"Average Turnaround Time = "<<avg_turnaround_time<<endl;
121 |     cout<<"Average Waiting Time = "<<avg_waiting_time<<endl;
122 |     cout<<"Average Response Time = "<<avg_response_time<<endl;
123 |     cout<<"CPU Utilization = "<<cpu_utilisation<<"%"<<endl;
124 |     cout<<"Throughput = "<<throughput<<" process/unit time"<<endl;
125 | 
126 | 
127 | }
128 | 
129 | /*
130 | 
131 | AT - Arrival Time of the process
132 | BT - Burst time of the process
133 | ST - Start time of the process
134 | CT - Completion time of the process
135 | TAT - Turnaround time of the process
136 | WT - Waiting time of the process
137 | RT - Response time of the process
138 | 
139 | Formulas used:
140 | 
141 | TAT = CT - AT
142 | WT = TAT - BT
143 | RT = ST - AT
144 | 
145 | */


--------------------------------------------------------------------------------