Initial commit

P2/VirtualMemory.cpp

@@ -0,0 +1,136 @@
+#include <iostream>
+
+#include "VirtualMemory.h"
+#include "ChainingHashTable.h"
+#include "DoubleHashTable.h"
+
+VirtualMemory::VirtualMemory(int n, int p, bool chaining)
+{
+    if (chaining)
+    {
+        ht = new ChainingHashTable(n / p);
+    }
+    else
+    {
+        ht = new DoubleHashTable(n / p);
+    }
+
+    this->chaining = chaining;
+    this->memorySize = n;
+    this->pageSize = p;
+    this->memory = new int[n];
+
+    // push the indices onto the free memory
+    for (int i = 0; i < n / p; i++)
+    {
+        freeMemory.push_back(i);
+    }
+}
+
+VirtualMemory::~VirtualMemory()
+{
+    if (chaining)
+    {
+        delete (ChainingHashTable *)ht;
+    }
+    else
+    {
+        delete (DoubleHashTable *)ht;
+    }
+
+    delete[] memory;
+}
+
+/// @brief Allocate memory for process PID
+/// @param PID the PID to allocate memory for
+/// @return true if successful, false otherwise
+bool VirtualMemory::Insert(unsigned int PID)
+{
+    if (freeMemory.size() <= 0)
+        return false;
+
+    int memoryIndex = freeMemory.back();
+    freeMemory.pop_back();
+
+    Process *p = new Process(PID, memoryIndex);
+    if (!ht->Insert(p))
+    {
+        delete p;
+        freeMemory.push_back(memoryIndex);
+        return false;
+    }
+
+    return true;
+}
+
+/// @brief Search the hash table for the index of PID
+/// @param PID the PID of the process to search for
+/// @return the index of the process object, -1 if the object does not exist
+int VirtualMemory::Search(unsigned int PID)
+{
+    return ht->Search(PID);
+}
+
+/// @brief Write to a process's memory
+/// @param PID The PID of the memory to write to
+/// @param addr The virtual address of the memory to write to
+/// @param x The value to write into memory
+/// @return true if successful, false otherwise
+bool VirtualMemory::Write(unsigned int PID, int addr, int x)
+{
+    if (addr >= pageSize || addr < 0)
+        return false;
+
+    Process *p = ht->Get(PID);
+
+    // if we do not have any memory allocated to PID
+    if (p == nullptr)
+        return false;
+
+    memory[p->getStartingIndex() * pageSize + addr] = x;
+    return true;
+}
+
+/// @brief Read the memory
+/// @param PID The PID of the process to read memory of
+/// @param addr The virtual address of memory to read from
+void VirtualMemory::Read(unsigned int PID, int addr)
+{
+    if (addr >= pageSize)
+    {
+        std::cout << "failure" << std::endl;
+        return;
+    }
+
+    Process *p = ht->Get(PID);
+    // if we do not have any memory allocated to PID
+    if (p == nullptr)
+    {
+        std::cout << "failure" << std::endl;
+        return;
+    }
+
+    std::cout << addr << " " << memory[p->getStartingIndex() * pageSize + addr] << std::endl;
+}
+
+/// @brief Deallocate memory from process PID.
+/// @param PID The PID of the process to dealocate memory from
+/// @return true if successful, false otherwise
+bool VirtualMemory::Delete(unsigned int PID)
+{
+    Process *p = ht->Get(PID);
+
+    if (p == nullptr)
+        return false;
+
+    freeMemory.push_back(p->getStartingIndex());
+
+    return ht->Remove(PID);
+}
+
+/// @brief Print the chain of the hash table at index m
+/// @param m the index of the chain to print
+void VirtualMemory::Print(int m)
+{
+    ht->Print(m);
+}