Output

Enter the number of processes: 3
Enter details for process 1
Process ID: 1
Arrival time: 0
Burst time: 3
Predicted time: 2
Enter details for process 2
Process ID: 3
Arrival time: 4
Burst time: 9
Predicted time: 6
Enter details for process 3
Process ID: 2
Arrival time: 4
Burst time: 10
Predicted time: 7

Process Arrival Time    Burst Time      Predicted Time  Completion Time Turnaround Time Waiting Time
1       0       3       2       3       3       0
3       4       9       6       13      9       0
2       4       10      7       23      19      9

Average Turnaround Time: 10.333333333333334
Process ID: 4
Arrival time: 5
Burst time: 12
Predicted time: 9

Process Arrival Time    Burst Time      Predicted Time  Completion Time Turnaround Time Waiting Time
1       0       5               4               5               5               0
2       3       9               6               14              11              2
3       4       10              7               24              20              10
4       5       12              9               36              31              19

Average Turnaround Time: 16.75
Average Waiting Time: 7.75

Shortest Remaining Time First (SRTF) With predicted Time

CPU scheduling algorithms are essential components of operating systems that determine the order in which processes are executed on a computer’s central processing unit (CPU). These algorithms aim to optimize CPU utilization, reduce waiting times, and enhance system performance by efficiently managing the execution of tasks in a multi-tasking environment. Various algorithms, such as First-Come, First-Served (FCFS), Shortest Job Next (SJN), Round Robin (RR), and Priority Scheduling, are employed to achieve these objectives, each with its own set of advantages and limitations. In this article, we study about Shortest Remaining Time First CPU Scheduling algorithm.

Similar Reads

C #include #include #define MAX_PROCESSES 100 //declaring the stucture struct process { int pid; int arrival_time; int burst_time; int remaining_time; }; int main() { int n; struct process processes[MAX_PROCESSES]; bool completed[MAX_PROCESSES] = {false}; int current_time = 0; int shortest_time = 0; int shortest_index = 0; printf("Enter the number of processes: "); scanf("%d", &n); for (int i = 0; i < n; i++) { printf("Enter arrival time and burst time for process %d: ", i+1); scanf("%d %d", &processes[i].arrival_time, &processes[i].burst_time); processes[i].pid = i+1; processes[i].remaining_time = processes[i].burst_time; } printf("\n"); while (true) { bool completed_all = true; for (int i = 0; i < n; i++) { if (!completed[i]) { int all_completed = false; if (processes[i].arrival_time <= current_time && processes[i].remaining_time < processes[shortest_index].remaining_time) { shortest_index = i; } } } if (completed_all) { break; } if (shortest_index != -1) { processes[shortest_index].remaining_time--; if (processes[shortest_index].remaining_time == 0) { completed[shortest_index] = true; } } current_time++; shortest_index = -1; } printf("Process\tArrival Time\tBurst Time\tWaiting Time\tTurnAround Time\n"); int total_waiting_time = 0; int total_turnaround_time = 0; for (int i = 0; i < n; i++) { int waiting_time = 0; int turnaround_time = 0; waiting_time = current_time - processes[i].burst_time - processes[i].arrival_time; turnaround_time = current_time - processes[i].arrival_time; total_waiting_time += waiting_time; total_turnaround_time += turnaround_time; printf("%d\t%d\t\t%d\t\t%d\t\t%d\n", processes[i].pid, processes[i].arrival_time, processes[i].burst_time, waiting_time, turnaround_time); } float avg_waiting_time = (float) total_waiting_time / n; float avg_turnaround_time = (float) total_turnaround_time / n; printf("The Average Waiting Time: %.2f\n", avg_waiting_time); printf("The Average Turnaround Time: %.2f\n", avg_turnaround_time); return 0; }...

C++ #include using namespace std; struct process { int pid, arrival_time, burst_time, remaining_time, predicted_time; }; bool cmp(process a, process b) { if (a.arrival_time == b.arrival_time) { if (a.predicted_time == b.predicted_time) { return a.pid < b.pid; } return a.predicted_time < b.predicted_time; } return a.arrival_time < b.arrival_time; } void SRTF(vector& processes) { int n = processes.size(); int current_time = 0, completed = 0; vector waiting_time(n, 0); priority_queue, vector>, greater>> pq; while (completed < n) { for (int i = 0; i < n; i++) { if (processes[i].arrival_time <= current_time && processes[i].remaining_time > 0) { pq.push(make_pair(processes[i].predicted_time, processes[i].pid)); } } if (pq.empty()) { current_time++; continue; } int pid = pq.top().second; pq.pop(); processes[pid].remaining_time--; current_time++; if (processes[pid].remaining_time == 0) { completed++; waiting_time[pid] = current_time - processes[pid].arrival_time - processes[pid].burst_time; } else { processes[pid].predicted_time = processes[pid].remaining_time + current_time; } } cout << "PID\tArrival Time\tBurst Time\tWaiting Time\n"; int total_waiting_time = 0; for (int i = 0; i < n; i++) { cout << processes[i].pid << "\t" << processes[i].arrival_time << "\t\t" << processes[i].burst_time << "\t\t" << waiting_time[i] << "\n"; total_waiting_time += waiting_time[i]; } cout << "Average waiting time = " << (float)total_waiting_time / n << "\n"; } int main() { int n; cout << "Enter the number of processes: "; cin >> n; vector processes(n); for (int i = 0; i < n; i++) { processes[i].pid = i; cout << "Enter the arrival time and burst time of process " << i << ": "; cin >> processes[i].arrival_time >> processes[i].burst_time; processes[i].remaining_time = processes[i].burst_time; processes[i].predicted_time = processes[i].burst_time; } sort(processes.begin(), processes.end(), cmp); SRTF(processes); return 0; }...

Javascript class Process { constructor(id, arrivalTime, burstTime, predictedTime) { this.id = id; this.arrivalTime = arrivalTime; this.burstTime = burstTime; this.predictedTime = predictedTime; this.remainingTime = burstTime; } } function SRTF(processes) { let currentTime = 0; let completedProcesses = []; let readyQueue = []; let runningProcess = null; while (completedProcesses.length < processes.length) { // Check if there are any processes that have arrived for (let i = 0; i < processes.length; i++) { if (processes[i].arrivalTime <= currentTime && !completedProcesses.includes(processes[i])) { readyQueue.push(processes[i]); } } // Sort readyQueue by remaining time readyQueue.sort((a, b) => { if (a.remainingTime === b.remainingTime) { return a.predictedTime - b.predictedTime; } return a.remainingTime - b.remainingTime; }); // If runningProcess has completed, add it to completedProcesses and set runningProcess to null if (runningProcess && runningProcess.remainingTime === 0) { completedProcesses.push(runningProcess); runningProcess = null; } // If there are processes in the readyQueue, start the one with the shortest remaining time if (readyQueue.length > 0) { const shortestProcess = readyQueue.shift(); if (runningProcess !== shortestProcess) { runningProcess = shortestProcess; } } // Decrement remaining time of runningProcess and increment currentTime if (runningProcess) { runningProcess.remainingTime--; currentTime++; } else { currentTime++; } } return completedProcesses; } // Example usage const processes = [ new Process(1, 0, 6, 4), new Process(2, 2, 4, 2), new Process(3, 4, 2, 1), new Process(4, 5, 3, 3) ]; const completedProcesses = SRTF(processes); console.log(completedProcesses);...

Tags:

#Operating Systems-CPU Scheduling #Operating Systems

Java Code

JavaScript Code

Output

Shortest Remaining Time First (SRTF) With predicted Time

Similar Reads

Contact Us