readyqueue up to date

eventNode.h

@@ -1,9 +1,9 @@
 #ifndef EVENT_NODE_H
 #define EVENT_NODE_H
-//Header file for node funciton prototypes.
+//Header file for node function prototypes.
 struct Node{
     int processID;
-    double arrivalTime;
+    double eventTime;
     int eventType;
     //Enum:
     //CPU Arrival = 1
@@ -18,9 +18,9 @@ struct Node{
     Node* next;
 
     //Constructor:
-    Node(int ID, double arrival, int type, double Ts){
+    Node(int ID, double time, int type, double Ts){
         processID = ID;
-        arrivalTime = arrival;
+        eventTime = time;
         eventType = type;
         burst = Ts;
         waitTime = 0;

eventQueue.cpp

@@ -27,14 +27,20 @@ class EventQueue {
     }
 
     // Method to insert a new node at the beginning of the list
-    void insert(int ID, double arrival, int type, double Ts) {
-        Node* newNode = new Node(ID, arrival, type, Ts);
-        Node* current = head;
-        while(!(current->next == nullptr))
-        {
-            current = current->next;
+    void insert(int ID, double time, int type, double Ts = 0.0) {
+        Node* newNode = new Node(ID, time, type, Ts);
+        //Node* current = head;
+        if (head == nullptr)
+            head = newNode;
+        else{
+            //newNode->next = head;
+            //head = newNode;
+            Node* temp = head;
+            while (temp->next != nullptr){
+                temp = temp->next;
+            }
+            temp->next = newNode;
         }
-        current->next = newNode;
 
     }
 
@@ -45,10 +51,13 @@ class EventQueue {
         cout << endl;
         while (current) {
             std::cout << "PID: " << current->processID << ", Process Type:  " << current->eventType 
-            << ", Arrival Time: " << current->arrivalTime << ", Ts: " << current->burst << endl;
+            << ", Arrival Time: " << current->eventTime << ", Ts: " << current->burst << endl;
             current = current->next;
         }
         std::cout << std::endl;
     }
-
+
+    Node* get_head() {
+        return head;
+    }
 };

main.cpp

@@ -1,18 +1,82 @@
 #include "eventQueue.cpp"
-#include "readyQueue.h"
+#include "readyQueue.cpp"
 #include <iostream>
 #include <cstdlib>
 #include <ctime>
 using namespace std;
 
+void handle_ARR(double, bool, Node*, EventQueue);
+void handle_DEP(Node*);
+
+
 int main(){
     double lambda = 0;
+    double clock = 0.0;
+    bool CPU_idle = true;
+    int eventID = 0;
     EventQueue eventQueue;
+    ReadyQueue readyQueue_CPU;
+    ReadyQueue readyQueue_Disk;
 
     eventQueue.insert(11, 0.0, 1, 3.3);
     eventQueue.insert(12, 3.3, 1, 3.0);
     eventQueue.insert(13, 4.0, 1, 3.0);
     eventQueue.insert(14, 6.2, 1, 2.9);
+    readyQueue_CPU.insert(20);
+
+    //create a loop that creates events. must create arrivals with poisson distributions.
+    while(!(eventID == 10000)) {
+        //begin running the simulation processes on the CPU and each time a process starts
+        //create a departure event, time = clock + Ts, calculate probability of exit vs. disk
+        Node* event = eventQueue.get_head(); //returns head of event queue
+        clock = event->eventTime;
+        switch(event->eventType) {
+            case 1:
+                handle_ARR(clock, CPU_idle, event, eventQueue);
+            case 2:
+                handle_DEP(event);
+        }
+    }
+
+
+    //eventQueue.display();
+}
+
+void handle_ARR(double clock, bool &idle, Node* event, EventQueue &queue,  ReadyQueue &rqCPU){
+    bool CPU_idle = idle;
+    EventQueue eventQueue = queue;
+    ReadyQueue readyQueue_CPU = rqCPU;
+    int pID = event->processID;
+    double time = event->eventTime;
+    double burst = event->burst;
+
+    if(CPU_idle){
+        eventQueue.insert(pID, clock + burst, 2);
+        CPU_idle = false;
+        idle = CPU_idle;
+    }
+    else
+        //enqueue PID into ready queue
+        readyQueue_CPU.insert(pID)
+
+    eventQueue.insert(100, random, 1, clock + burst);
+}
+
+void handle_DEP(double clock, bool &idle, Node* event, EventQueue &queue, ReadyQueue &rqCPU){
+    bool CPU_idle = idle;
+    EventQueue eventQueue = queue;
+    ReadyQueue readyQueue_CPU = rqCPU;
+    int pID = event->processID;
+    double time = event->eventTime;
+    double burst = event->burst;
 
-    eventQueue.display();
+    if (readyQueue_CPU.isEmpty()) {
+        CPU_idle = true;
+        idle = CPU_idle;
+    }
+    else{
+        //pop pid from ReadyQueue
+        //...^^
+        eventQueue.insert(pID, clock + burst, 2);
+    }
 }

readyQueue.cpp

@@ -1,3 +1,41 @@
 #include "readyQueue.h"
 //Definitions for the Ready Queue, Disk Queue,
-//and Event queue.
+#include <iostream>
+using namespace std;
+
+class ReadyQueue{
+private:
+    ReadyNode* head;
+
+public:
+    ReadyQueue() : head(nullptr) {}
+
+    ~ReadyQueue() {
+        while (head) {
+            ReadyNode* temp = head;
+            head = head->next;
+            delete temp;
+        }
+    }
+
+    void insert(int PID){
+        ReadyNode* newNode = new ReadyNode(PID);
+        if (head == nullptr)
+            head = newNode;
+        else{
+            //newNode->next = head;
+            //head = newNode;
+            ReadyNode* temp = head;
+            while (temp->next != nullptr){
+                temp = temp->next;
+            }
+            temp->next = newNode;
+        }
+    }
+
+    void pop(){}
+
+    bool isEmpty() {
+        return (head == nullptr);
+    }
+};

readyQueue.h

@@ -1,6 +1,15 @@
 #ifndef EVENT_NODE_H
 #define EVENT_NODE_H
 //Header file for queue function prototypes.
+struct ReadyNode{
+    int processID;
+    ReadyNode* next;
 
+    //Constructor:
+    explicit ReadyNode(int PID){
+        processID = PID;
+        next = nullptr;
+    }
+};
 
 #endif