Add files via upload

Author: M-aboelsafa

boohmeed.cpp

@@ -0,0 +1,100 @@
+#include "scheduler.h"
+
+int calculateTickets(process p)
+{
+    int time = 0;
+    int execution_requests = 0;
+    int io_requests = 0;
+    for (int j = 0; j < p.n_phases; ++j)
+    {
+        time += p.phases[j].first;
+        if (p.phases[j].second == 1)
+        {
+            execution_requests++;
+        }
+        else
+        {
+            io_requests++;
+        }
+    }
+    return time + execution_requests * 20 + io_requests * 30;
+}
+
+void strideScheduler(int size, process processes[])
+{
+    int finished_processes = 0, processor[4], WillGoToTheQ[4], i = 0, pr;
+    memset(processor, -1, sizeof processor);
+    memset(WillGoToTheQ, -1, sizeof WillGoToTheQ);
+    CompareProcessstride cmp(processes);
+    priority_queue<int, vector<int>, CompareProcessstride> waiting(cmp);
+    for (int t = 0;; t++)
+    {
+        int idx_p = 0;
+        for (idx_p = 0; idx_p < 4 && i < size && processes[i].arrive_time <= t; ++idx_p) // if processor is ideal and processes
+        {
+            if (processor[idx_p] == -1)
+            {
+                processor[idx_p] = i;
+                processes[i].current_brust_time = processes[i].phases[processes[i].phase_idx].first;
+                processes[i].state = processes[i].phases[processes[i].phase_idx].second;
+                processes[i].last_processor = idx_p;
+                i++;
+            }
+        }
+        while (i < size && processes[i].arrive_time <= t) // processes arrived but there is no place at cpu so it will go in waiting queue
+        {
+            processes[i].state = processes[i].phases[processes[i].phase_idx].second;
+            processes[i].current_brust_time = processes[i].phases[processes[i].phase_idx].first;
+            waiting.push(i);
+            i++;
+        }
+        for (idx_p = 0; idx_p < 4; idx_p++)
+        {
+            if (processor[idx_p] == -1) // means that , that processor is ideal
+            {
+                output[t][idx_p] = "i";
+                if (!waiting.empty())
+                {
+                    WillGoToTheQ[idx_p] = waiting.top();
+                    waiting.pop();
+                }
+                continue;
+            }
+            pr = processor[idx_p]; // index of the process in the processor
+            output[t][idx_p] = processes[pr].process_name;
+            processes[pr].time_consumed++;
+            processes[pr].pass_value += processes[pr].stride;
+            if (processes[pr].time_consumed == processes[pr].current_brust_time) // proceses finished exec
+            {
+                processes[pr].phase_idx++;
+                processes[pr].time_consumed = 0;
+                if (processes[pr].phase_idx < processes[pr].n_phases) // still want more ?
+                {
+                    processes[pr].state = processes[pr].phases[processes[pr].phase_idx].second;
+                    processes[pr].current_brust_time = processes[pr].phases[processes[pr].phase_idx].first;
+                }
+                else // process finished
+                {
+                    finished_processes++;
+                    processes[pr].state = 2;
+                    processes[pr].complete_time = t;
+                    processes[pr].turn_around_time = t - processes[pr].arrive_time;
+                }
+                if (!waiting.empty())
+                {
+                    WillGoToTheQ[idx_p] = waiting.top();
+                    waiting.pop();
+                }
+                processor[idx_p] = -1;
+            }
+        }
+        match_prefrences(processor, WillGoToTheQ, processes);
+        IO_handler_bypq_stride(size, processes, waiting, finished_processes, t);
+
+        if (finished_processes == size)
+        {
+            print(t, processes, size);
+            return;
+        }
+    }
+}

scheduler.cpp

@@ -1,6 +1,6 @@
 #include "scheduler.h"
 
-vector<vector<string>> output(N, vector<string>(4));// string V[N][4];
+vector<vector<string>> output(N, vector<string>(4)); // string V[N][4];
 
 bool comparedByBurst(const process &p1, const process &p2)
 {
@@ -24,7 +24,7 @@ void print(int endtime, process processes[], int n)
             cout << output[i][j] << " | ";
             cout << i << " ";
             cout << " ";
-            this_thread::sleep_for(std::chrono::seconds(1));
+            // this_thread::sleep_for(std::chrono::seconds(1));
         }
         cout << output[endtime][j] << "\n\n";
     }
@@ -175,6 +175,41 @@ void IO_handler_bypq_priority(int n, process processes[], priority_queue<int, ve
         }
     }
 }
+void IO_handler_bypq_stride(int n, process processes[], priority_queue<int, vector<int>, CompareProcessstride> &my_queue, int &finised_processes, int t)
+{
+    for (int i = 0; i < n; i++)
+    {
+        if (processes[i].state == 0) // state IO
+        {
+            // cout << "IO handler " << i << "\n";
+            processes[i].time_consumed++;
+            if (processes[i].time_consumed == processes[i].current_brust_time) // IO Finished
+            {
+                processes[i].time_consumed = 0;
+                processes[i].phase_idx++;
+                if (processes[i].phase_idx < processes[i].n_phases)
+                {
+                    processes[i].state = processes[i].phases[processes[i].phase_idx].second;
+                    processes[i].current_brust_time = processes[i].phases[processes[i].phase_idx].first;
+                    if (processes[i].state)
+                    {
+                        // cout << "PUSH\n";
+                        my_queue.push(i);
+                    }
+                }
+                else
+                {
+                    // cout << "DONE\n";
+                    processes[i].state = 2;
+                    (finised_processes)++;
+                    processes[i].complete_time = t;
+                    processes[i].turn_around_time = t - processes[i].arrive_time;
+                }
+            }
+        }
+    }
+}
+
 void match_prefrences(int processor[], int WillGoToTheQ[], process processes[])
 {
     // First loop: Assign processes to processors if the processor is available

scheduler.h

@@ -44,13 +44,23 @@ struct CompareProcesspriority
         return data[a].priority > data[b].priority;
     }
 };
+struct CompareProcessstride
+{
+    const process *data;
+    CompareProcessstride(const process *d) : data(d) {}
+    bool operator()(int a, int b) const
+    {
+        return data[a].pass_value > data[b].pass_value;
+    }
+};
 bool comareByPriority(const process &p1, const process &p2); // ascending order
 bool comparedByBurst(const process &p1, const process &p2);
 void print(int endtime, process processes[], int n);
 void IO_handler(int n, process processes[], queue<int> &my_queue, int &finised_processes, int t);
 void IO_handler_MLFQ(int n, process processes[], queue<int> my_queue[], int &finised_processes, int t);
 void IO_handler_bypq(int n, process processes[], priority_queue<int, vector<int>, CompareProcess> &my_queue, int &finised_processes, int t);
 void IO_handler_bypq_priority(int n, process processes[], priority_queue<int, vector<int>, CompareProcesspriority> &my_queue, int &finised_processes, int t);
+void IO_handler_bypq_stride(int n, process processes[], priority_queue<int, vector<int>, CompareProcessstride> &my_queue, int &finised_processes, int t);
 void match_prefrences(int processor[], int WillGoToTheQ[], process processes[]);
 
 void changeThePriorty(int n, process processes[]);