os-scheduler/PRI.cpp at main · OmarAbdelSamea/os-scheduler · 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
113
114
115
116
117
118
119
120
121
122
123
124
#include "PRI.h"


void PRI::get_input_burst_arrival_time_priority(QVector<process> &pri_process, int num_of_proceses)
{
    for (size_t i = 0; i < num_of_proceses; i++)
    {
        int burst_time, arrival_time, priority_num;
        cout << "Enter burst time for process " << i + 1 << ": \n";
        cin >> burst_time;
        cout << "Enter arrival time for process " << i + 1 << ": \n";
        cin >> arrival_time;
        cout << "Enter priority number for process " << i + 1 << ": \n";
        cin >> priority_num;
        pri_process[i].process_num = i + 1;
        pri_process[i].burst_time = burst_time;
        pri_process[i].arrival_time = arrival_time;
        pri_process[i].stop_time = arrival_time;
        pri_process[i].priority_num = priority_num;
    }
}

void PRI::calc_new_order_np(QVector<process> &pri_process, QVector<process> &pri_process_new, int num_of_proceses)
{
    int current_time = 0, min_index = -1;
    // sort wrt arrival time
    sort(pri_process.begin(), pri_process.end(), [](process a, process b) { return a.arrival_time < b.arrival_time; });
    current_time = pri_process[0].arrival_time;
    while (!pri_process.empty())
    {
        int highest_pri = -1, min_index = -1;
        for (size_t i = 0; i < pri_process.size(); i++)
        {
            if (pri_process[i].arrival_time <= current_time)
            {
                if (highest_pri == -1)
                {
                    highest_pri = pri_process[i].priority_num;
                    min_index = i;
                }
                else
                {
                    if (pri_process[i].priority_num < highest_pri)
                    {
                        highest_pri = pri_process[i].priority_num;
                        min_index = i;
                    }
                }
            }
        }
        if (min_index == -1)
            current_time = pri_process[0].arrival_time;
        else
        {
            pri_process[min_index].start_time = current_time;
            pri_process_new.push_back(pri_process[min_index]);
            current_time += pri_process[min_index].burst_time;
            pri_process.erase(pri_process.begin() + min_index);
        }
    }
}

void PRI::calc_new_order_p(QVector<process> &pri_process, QVector<process> &pri_process_new, int num_of_proceses)
{
    int current_time = 0, min_index = -1;
    // sort wrt arrival time
    sort(pri_process.begin(), pri_process.end(), [](process a, process b) { return a.arrival_time < b.arrival_time; });
    current_time = pri_process[0].arrival_time;
    while (!pri_process.empty())
    {
        int highest_pri = -1, min_index = -1;
        for (size_t i = 0; i < pri_process.size(); i++)
        {
            if (pri_process[i].arrival_time <= current_time)
            {
                if (highest_pri == -1)
                {
                    highest_pri = pri_process[i].priority_num;
                    min_index = i;
                }
                else
                {
                    if (pri_process[i].priority_num < highest_pri)
                    {
                        highest_pri = pri_process[i].priority_num;
                        min_index = i;
                    }
                }
            }
        }
        if (min_index == -1)
            current_time = pri_process[0].arrival_time;
        else
        {
            process current = pri_process[min_index];
            current.start_time = current_time;
            current_time += pri_process[min_index].burst_time;
            int highest_pri_p = current.priority_num, min_index_p = -1;
            for (size_t i = 0; i < pri_process.size(); i++)
            {
                if (pri_process[i].arrival_time <= current_time && i != min_index)
                {
                    if (pri_process[i].priority_num < highest_pri_p)
                    {
                        highest_pri_p = pri_process[i].priority_num;
                        min_index_p = i;
                    }
                }
            }
            if (min_index_p == -1)
            {
                pri_process_new.push_back(current);
                pri_process.erase(pri_process.begin() + min_index);
            }
            else
            {
                current_time = pri_process[min_index_p].arrival_time;
                current.burst_time = pri_process[min_index_p].arrival_time - current.start_time;
                pri_process_new.push_back(current);
                pri_process[min_index].burst_time -= current.burst_time;
            }
        }
    }
}