Add all 5 assignments

Author: xiaoyu12

assign1/Makefile

@@ -3,17 +3,20 @@
 # 
 ###################################
 CC = g++			# use g++ for compiling c++ code or gcc for c code
-CFLAGS = -g -Wall -std=c++11		# compilation flags: -g for debugging. Change to -O or -O2 for optimized code.
+CFLAGS = -g -Wall -std=c++11		# compilation flags: -g for debugging. Change to -O3 for optimized code.
 LIB = -lm			# linked libraries	
 LDFLAGS = -L.			# link flags
-PROG = prog1			# target executable (output)
-SRCS = main.cpp ReadyQueue.cpp        # .c or .cpp source files.
+PROG = test1 test2			# target executables (output)
+SRCS = test1.cpp test2.cpp pcbtable.cpp readyqueue.cpp        # .c or .cpp source files.
 OBJ = $(SRCS:.cpp=.o) 	# object files for the target. Add more to this and next lines if there are more than one source files.
 
-all : $(PROG) depend
+all : $(PROG)
 
-$(PROG): $(OBJ) 
-	$(CC) -o $(PROG) $(OBJ) $(LDFLAGS) $(LIB)
+test1:  test1.o pcbtable.o readyqueue.o
+	$(CC) -o test1 test1.o pcbtable.o readyqueue.o $(LDFLAGS) $(LIB)
+
+test2:  test2.o pcbtable.o readyqueue.o
+	$(CC) -o test2 test2.o pcbtable.o readyqueue.o $(LDFLAGS) $(LIB)
 
 .cpp.o:
 	$(CC) -c $(CFLAGS) $< -o $@

assign1/PCB.cpp

@@ -1,17 +1,27 @@
-#pragma once
+/**
+ * Assignment 1: priority queue of processes
+ * @file pcb.h
+ * @author ??? (TODO: your name)
+ * @brief This is the header file for the PCB class, a process control block.
+ * @version 0.1
+ */
+//You must complete the all parts marked as "TODO". Delete "TODO" after you are done.
+// Remember to addPCB sufficient comments to your code
 
-// Remember to add comments to your code
-// ...
+#pragma once
+#include <iostream>
+using namespace std;
 
 // enum class of process state
 // A process (PCB) in ready queue should be in READY state
 enum class ProcState {NEW, READY, RUNNING, WAITING, TERMINATED};
 
-/* 
-Process control block(PCB) is a data structure representing a process in the system.
-A process should have at least an ID and a state(i.e.NEW, READY, RUNNING, WAITING or TERMINATED).
-It may also have other attributes, such as scheduling information (e.g. priority)
-*/
+/**
+ * @brief A process control block (PCB) Process control block(PCB) is a data structure representing a process in the system.
+   A process should have at least an ID and a state(i.e.NEW, READY, RUNNING, WAITING or TERMINATED).
+   It may also have other attributes, such as scheduling information (e.g. priority)
+ *
+ */
 class PCB {
 public:
     // The unique process ID
@@ -22,5 +32,92 @@ class PCB {
 	// A process in the ReadyQueue should be in READY state
 	ProcState state;
 
-	// TODO: Add constructor and other necessary functions for the PCB class
+	/**
+	 * @brief Construct a new PCB object
+	 * @param id: each process has a unique ID
+	 * @param priority: the priority of the process in the range 1-50. Larger number represents higher priority
+	 * @param state the state of the process.
+     */
+    PCB(unsigned int id = 0, unsigned int priority = 1, ProcState state = ProcState::NEW) {
+        this->id = id;
+        this->priority = priority;
+        this->state = state;
+    }
+
+    /**
+     * @brief Destroy the PCB object.
+     *
+     */
+    ~PCB() {}
+
+    /**
+     * @brief Get the ID of the PCB.
+     *
+     * @return unsigned int: the ID of the PCB
+     */
+    unsigned int getID() {
+        return id;
+    }
+
+    /**
+     * @brief Get the priority of the PCB.
+     *
+     * @return unsigned int: the priority of the PCB
+     */
+    unsigned int getPriority() {
+        return priority;
+    }
+
+    /**
+     * @brief Get the state of the PCB.
+     *
+     * @return ProcState: the state of the PCB
+     */
+    ProcState getState() {
+        return state;
+    }
+
+    /**
+     * @brief Change the state of the PCB.
+     * @param state
+     */
+    void setState(ProcState state) {
+        // TODO: addPCB your code here
+    }
+
+    /**
+     * @brief Change the priority of the PCB.
+     * @param priority
+     */
+    void setPriority(unsigned int priority) {
+        // TODO: addPCB your code here
+    }
+
+    /**
+     * @brief Print the PCB.
+     *
+     */
+    void display() const {
+        cout << "ID: " << id;
+        cout << ", Priority: " << priority;
+        cout << ", State: " ;
+        switch(state) {
+            case ProcState::NEW:
+                cout << "NEW";
+                break;
+            case ProcState::READY:
+                cout << "READY";
+                break;
+            case ProcState::RUNNING:
+                cout << "RUNNING";
+                break;
+            case ProcState::WAITING:
+                cout << "WAITING";
+                break;
+            case ProcState::TERMINATED:
+                cout << "TERMINATED";
+                break;
+        } 
+        cout << endl;
+    }
 };

assign1/PCB.h

@@ -1,4 +1,51 @@
 #include <iostream>
-#include "ReadyQueue.h"
+#include "readyqueue.h"
 
-// TODO: Add your implementation of ReadyQueue functions here
+using namespace std;
+
+//You must complete the all parts marked as "TODO". Delete "TODO" after you are done.
+// Remember to add sufficient comments to your code
+
+
+/**
+ * @brief Constructor for the ReadyQueue class.
+ */
+ ReadyQueue::ReadyQueue()  {
+     //TODO: add your code here
+ }
+
+/**
+ * @brief Add a PCB representing a process into the ready queue.
+ *
+ * @param pcbPtr: the pointer to the PCB to be added
+ */
+void ReadyQueue::addPCB(PCB *pcbPtr) {
+    //TODO: add your code here
+    // When adding a PCB to the queue, you must change its state to READY.
+}
+
+/**
+ * @brief Remove and return the PCB with the highest priority from the queue
+ *
+ * @return PCB*: the pointer to the PCB with the highest priority
+ */
+PCB* ReadyQueue::removePCB() {
+    //TODO: add your code here
+    // When removing a PCB from the queue, you must change its state to RUNNING.
+}
+
+/**
+ * @brief Returns the number of elements in the queue.
+ *
+ * @return int: the number of PCBs in the queue
+ */
+int ReadyQueue::size() {
+    //TODO: add your code here
+}
+
+/**
+ * @brief Display the PCBs in the queue.
+ */
+void ReadyQueue::displayAll() {
+    //TODO: add your code here
+}

assign1/ReadyQueue.cpp

@@ -1,30 +1,64 @@
-// Remember to add comments to your code
-// ...
-
+/**
+ * Assignment 1: priority queue of processes
+ * @file readyqueue.h
+ * @author ??? (TODO: your name)
+ * @brief ReadyQueue is a queue of PCB's that are in the READY state to be scheduled to run.
+ * It should be a priority queue such that the process with the highest priority can be selected next.
+ * @version 0.1
+ */
+//You must complete the all parts marked as "TODO". Delete "TODO" after you are done.
+// Remember to add sufficient comments to your code
 #pragma once
 
-#include "PCB.h"
+#include "pcb.h"
 
 /**
- * ReadyQueue is a queue of PCB's that are in the READY state to be scheduled to run.
- * It should be a priority queue here uch that the process with the highest priority
- * can be selected next.
+ * @brief A queue of PCB's that are in the READY state to be scheduled to run.
+ * It should be a priority queue such that the process with the highest priority can be selected next.
  */
 class ReadyQueue {
+private:
+    // TODO: add your private member variables here
+    // choose a data structure for the ReadyQueue. No STL class is allowed.
+
 public:
-	// TODO: Implement the required functions. Add necessary member fields and functions
-	// You may use different parameter signatures from the example below
+    /**
+     * @brief Construct a new ReadyQueue object
+     *
+     */
+    ReadyQueue();
+
+    /**
+     * @brief Destructor
+     */
+    ~ReadyQueue() {}
+
+	// You may add additional member functions, but don't change the definitions of the following four member functions.
 
-	// add a PCB representing a process into the ready queue.
-	void add(PCB* pcbPtr);
+    /**
+     * @brief Add a PCB representing a process into the ready queue.
+     *
+     * @param pcbPtr: the pointer to the PCB to be added
+     */
+	void addPCB(PCB* pcbPtr);
 
-	// remove and return the PCB with the highest priority from the queue
-	PCB* removeHighest();
+    /**
+     * @brief Remove and return the PCB with the highest priority from the queue
+     *
+     * @return PCB*: the pointer to the PCB with the highest priority
+     */
+	PCB* removePCB();
 
-	// Returns the number of elements in the queue.
+    /**
+     * @brief Returns the number of elements in the queue.
+     *
+     * @return int: the number of PCBs in the queue
+     */
 	int size();
 
-	// Prints the queue contents to standard output.
-	void display();
+     /**
+      * @brief Display the PCBs in the queue.
+      */
+	void displayAll();
 
 };

assign1/ReadyQueue.h

@@ -1,4 +1,4 @@
-// Remember to add comments to your code
+// Remember to addPCB comments to your code
 
 #include <iostream>
 #include <cstdlib>

assign1/main.cpp

@@ -0,0 +1,46 @@
+/**
+ * Assignment 1: priority queue of processes
+ * @file pcbtable.h
+ * @author ??? (TODO: your name)
+ * @brief This is the implementation file for the PCBTable class.
+ * //You must complete the all parts marked as "TODO". Delete "TODO" after you are done.
+ * // Remember to add sufficient comments to your code
+ */
+
+#include "pcbtable.h"
+
+/**
+ * @brief Construct a new PCBTable object of the given size (number of PCBs)
+ *
+ * @param size: the capacity of the PCBTable
+ */
+PCBTable::PCBTable(int size) {
+   // TODO: add your code here
+}
+
+/**
+ * @brief Destroy the PCBTable object. Make sure to delete all the PCBs in the table.
+ *
+ */
+PCBTable::~PCBTable() {
+   // TODO: add your code here
+}
+
+/**
+ * @brief Get the PCB at index "idx" of the PCBTable.
+ *
+ * @param idx: the index of the PCB to get
+ * @return PCB*: pointer to the PCB at index "idx"
+ */
+PCB* PCBTable::getPCB(unsigned int idx) {
+    // TODO: add your code here
+}
+
+/**
+ * @brief Add a PCB to the PCBTable.
+ *
+ * @param pcb: the PCB to add
+ */
+void PCBTable::addPCB(PCB *pcb, unsigned int idx) {
+    // TODO: add your code here
+}