Operating_System/priority_preemptive.cpp at main · codewithRiC/Operating_System · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;
int tbt=0;
struct Process {
    int id;
    int arrivalTime;
    int tempBT;
    int burstTime;
    int priority;
    int startTime;
    int completionTime;
    int waitingTime;
    int turnaroundTime;
    bool executed;
    int tempst;
    Process(int id, int arrivalTime, int burstTime, int priority)
        : id(id), arrivalTime(arrivalTime), burstTime(burstTime),
          tempBT(burstTime), priority(priority), startTime(0),
          completionTime(0), waitingTime(0), turnaroundTime(0),
          executed(false)
    {}
};

int main() {
    int n;
    cout << "Enter the number of processes: ";
    cin >> n;

    vector<Process> processes;

    cout << "Enter Arrival, Burst, Priority: " << endl;
    for (int i = 0; i < n; i++) {
        cout << "For process " << (i + 1) << ":" << endl;

        int arrivalTime, burstTime, priority;
        cin >> arrivalTime >> burstTime >> priority;
          tbt+=burstTime;
        Process process(i + 1, arrivalTime, burstTime, priority);
        processes.push_back(process);
    }

    // Sort processes based on arrival time
    sort(processes.begin(), processes.end(),
         [](const Process& p1, const Process& p2) {
             return p1.arrivalTime < p2.arrivalTime;
         });

    int currentTime = 0;
    int completedProcesses = 0;

    while (completedProcesses < n) {
        int highestPriority = INT_MAX;
        int selectedProcessIndex = -1;

        for (int i = 0; i < n; i++) {
            Process& process = processes[i];

            if (!process.executed && process.arrivalTime <= currentTime && process.priority < highestPriority) {
                highestPriority = process.priority;
                selectedProcessIndex = i;
            }
        }

        if (selectedProcessIndex == -1) {
            currentTime++;
            continue;
        }

        Process& selectedProcess = processes[selectedProcessIndex];
        selectedProcess.executed = true;
        selectedProcess.startTime = currentTime;
        selectedProcess.tempst=selectedProcess.startTime;
        selectedProcess.completionTime = currentTime + 1;

        selectedProcess.turnaroundTime = selectedProcess.completionTime - selectedProcess.arrivalTime;
        selectedProcess.waitingTime = selectedProcess.turnaroundTime - selectedProcess.tempBT;

        currentTime++;

        if (selectedProcess.burstTime > 1) {
            selectedProcess.burstTime--;
            selectedProcess.executed = false;
        } else {
            completedProcesses++;
        }
    }

    float AverageWaitingTime = 0.0, AverageTurnaroundTime = 0.0;
    for (const Process& p : processes) {
        AverageTurnaroundTime += p.turnaroundTime;
        AverageWaitingTime += p.waitingTime;

    }

    cout << "\nProcess\t\tArrival\t\tBurst\t\tStart\t\tCompletion\t\tWaiting\t\tTurnaround" << endl;
    cout << "----------------------------------------------------------------------------------------------" << endl;
    for (const Process& process : processes) {
        cout << process.id << "\t\t" << process.arrivalTime << "\t\t" << process.tempBT << "\t\t" <<
            process.tempst << "\t\t" << process.completionTime << "\t\t\t" << process.waitingTime <<
            "\t\t\t" << process.turnaroundTime << endl;
    }

       cout << "Average Waiting time: " << AverageWaitingTime/n << endl;
    cout << "Average Turnaround Time: " << AverageTurnaroundTime/n << endl;
    cout<<"Throughput:"<<(float)n/tbt ;


    return 0;
}