constructors + method declarations for cache, dram, reponse, storage

10 files changed, 214 insertions, 54 deletions

diff --git a/inc/cache.h b/inc/cache.h
new file mode 100644
index 0000000..e808727
--- /dev/null
+++ b/inc/cache.h
@@ -0,0 +1,25 @@
+#ifndef CACHE_H
+#define CACHE_H
+#include <storage.h>
+
+class Cache : public Storage
+{
+  public:
+  /**
+   * Constructor.
+   * @param The number of `lines` contained in memory. The total number of
+   * words is this number multiplied by 4.
+   * @param The next lowest level in storage. Methods from this object are
+   * called in case of a cache miss.
+   * @param The number of clock cycles each access takes.
+   * @return A new cache object.
+   */
+  Cache(int lines, Storage *lower, int delay);
+  ~Cache();
+
+  Response *write(Accessor accessor, signed int data, int address) override;
+  Response *read(Accessor accessor, int address) override;
+  int **view(int base, int lines) override;
+};
+
+#endif /* CACHE_H_INCLUDED */
diff --git a/inc/dram.h b/inc/dram.h
index 5bc933e..c8782d1 100644
--- a/inc/dram.h
+++ b/inc/dram.h
@@ -5,12 +5,19 @@
 class Dram : public Storage
 {
   public:
-	Dram();
-	~Dram();
+  /**
+   * Constructor.
+   * @param The number of `lines` contained in memory. The total number of
+   * words is this number multiplied by 4.
+   * @param The number of clock cycles each access takes.
+   * @return A new memory object.
+   */
+  Dram(int lines, int delay);
+  ~Dram();
 
-	int *load_line(int);
-
-  private:
+  Response *write(Accessor accessor, signed int data, int address) override;
+  Response *read(Accessor accessor, int address) override;
+  int **view(int base, int lines) override;
 };
 
 #endif /* DRAM_H_INCLUDED */
diff --git a/inc/logger.h b/inc/logger.h
index 5ecdc7e..005e518 100644
--- a/inc/logger.h
+++ b/inc/logger.h
@@ -9,17 +9,32 @@ enum LogLevel { DEBUG, INFO, WARNING, ERROR, CRITICAL };
 class Logger
 {
   public:
-	Logger(const string &);
-	~Logger();
+  /**
+   * Constructor.
+   * @param The file name to log to.
+   * @return A new logger object.
+   */
+  Logger(const string &);
+  ~Logger();
 
-	void setLevel(LogLevel);
-	void log(LogLevel, const string &);
+  /**
+   * Set the log level.
+   * @param the log level to set to.
+   */
+  void setLevel(LogLevel);
+  /**
+   * Log a message at a certain log level.
+   * @param The level to log this message. If the level is lower than the
+   * level set by `setLevel`, then the message is not logged.
+   * @param The message to log.
+   */
+  void log(LogLevel, const string &);
 
   private:
-	LogLevel level = INFO;
-	ofstream logFile;
-	string levelToString(LogLevel);
-	int levelToInt(LogLevel);
+  LogLevel level = INFO;
+  ofstream logFile;
+  string levelToString(LogLevel);
+  int levelToInt(LogLevel);
 };
 
 #endif /* LOGGER_H_INCLUDED */
diff --git a/inc/response.h b/inc/response.h
new file mode 100644
index 0000000..d190953
--- /dev/null
+++ b/inc/response.h
@@ -0,0 +1,16 @@
+#ifndef RESPONSE_H
+#define RESPONSE_H
+
+enum Status {
+        OK,
+        WAIT,
+        BLOCKED,
+};
+
+struct Response {
+        Status status;
+        int *line;
+        int val;
+};
+
+#endif /* RESPONSE_H_INCLUDED */
diff --git a/inc/storage.h b/inc/storage.h
index 8973016..bad9d10 100644
--- a/inc/storage.h
+++ b/inc/storage.h
@@ -1,15 +1,59 @@
 #ifndef STORAGE_H
 #define STORAGE_H
+#include "response.h"
 #include <array>
 #include <vector>
 
+enum Accessor {
+  MEMORY,
+  FETCH,
+  L1CACHE,
+};
+
 class Storage
 {
   public:
-	int **view(int base) { return nullptr; }
-	virtual bool store();
+  /**
+   * Write `data` into `address`.
+   * @param the source making the request.
+   * @param the data (hexadecimal) to write.
+   * @param the address to write to.
+   * @return a status code reflecting the state of the storage level.
+   */
+  virtual Response *
+  write(Accessor accessor, signed int data, int address) = 0;
+  /**
+   * Get the data at `address`.
+   * @param the source making the request.
+   * @param the address being accessed.
+   * @return a status code reflecting the state of the storage level, and the
+   * data being returned.
+   */
+  virtual Response *read(Accessor accessor, int address) = 0;
+  /**
+   * Sidedoor view of `lines` of memory starting at `base`.
+   * @param The base line to start getting memory from.
+   * @param The amount of lines to fetch.
+   * @return A matrix of data values, where each row is a line and each column
+   * is a word.
+   */
+  virtual int **view(int base, int lines) = 0;
 
-	std::vector<std::array<signed int, 4>> address_space;
+  protected:
+  /**
+   * The data currently stored in this level of storage.
+   */
+  std::vector<std::array<unsigned int, 4>> *data;
+  /**
+   * A pointer to the next lowest level of storage.
+   * Used in case of cache misses.
+   */
+  Storage *lower;
+  /**
+   * The number of clock cycles this level of storage takes to complete
+   * requests.
+   */
+  int delay;
 };
 
 #endif /* STORAGE_H_INCLUDED */
diff --git a/src/storage/cache.cc b/src/storage/cache.cc
new file mode 100644
index 0000000..efcaa32
--- /dev/null
+++ b/src/storage/cache.cc
@@ -0,0 +1,21 @@
+#include <cache.h>
+
+Cache::Cache(int lines, Storage *lower, int delay)
+{
+  this->data = new std::vector<std::array<unsigned int, 4>>;
+  this->data->resize(lines);
+  this->lower = lower;
+  this->delay = delay;
+  this->lower = nullptr;
+}
+
+Cache::~Cache() { delete this->data; }
+
+Response *Cache::write(Accessor accessor, signed int data, int address)
+{
+  return new Response();
+}
+
+Response *Cache::read(Accessor accessor, int address) { return nullptr; }
+
+int **Cache::view(int base, int lines) { return nullptr; }
diff --git a/src/storage/dram.cc b/src/storage/dram.cc
index 9e6f6f1..b3b728d 100644
--- a/src/storage/dram.cc
+++ b/src/storage/dram.cc
@@ -1,5 +1,21 @@
 #include <dram.h>
+#include <response.h>
 
-Dram::Dram() {
-	address_space.resize(4096);
+Dram::Dram(int lines, int delay)
+{
+  this->data = new std::vector<std::array<unsigned int, 4>>;
+  this->data->resize(lines);
+  this->delay = delay;
+  this->lower = nullptr;
 }
+
+Dram::~Dram() { delete this->data; }
+
+Response *Dram::write(Accessor accessor, signed int data, int address)
+{
+  return new Response();
+}
+
+Response *Dram::read(Accessor accessor, int address) { return nullptr; }
+
+int **Dram::view(int base, int lines) { return nullptr; }
diff --git a/tests/cache.cc b/tests/cache.cc
new file mode 100644
index 0000000..df5004a
--- /dev/null
+++ b/tests/cache.cc
@@ -0,0 +1,8 @@
+#include "cache.h"
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("Constructor initialize test 1", "[cache]")
+{
+  Cache *c = new Cache(1, nullptr, 4);
+  delete c;
+}
diff --git a/tests/dram.cc b/tests/dram.cc
new file mode 100644
index 0000000..1bde0fd
--- /dev/null
+++ b/tests/dram.cc
@@ -0,0 +1,8 @@
+#include "dram.h"
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("Constructor initialize test 1", "[dram]")
+{
+  Dram *d = new Dram(1, 4);
+  delete d;
+}
diff --git a/tests/logger.cc b/tests/logger.cc
index 18e4fab..e2f72a5 100644
--- a/tests/logger.cc
+++ b/tests/logger.cc
@@ -4,62 +4,62 @@
 #include <regex>
 #include <sstream>
 
-TEST_CASE("Logger logs higher log level")
+TEST_CASE("Logger logs higher log level", "[logger]")
 {
-	std::streambuf *coutBuffer = std::cout.rdbuf();
-	std::ostringstream oss;
-	std::cout.rdbuf(oss.rdbuf());
+  std::streambuf *coutBuffer = std::cout.rdbuf();
+  std::ostringstream oss;
+  std::cout.rdbuf(oss.rdbuf());
 
-	Logger logger("");
-	logger.setLevel(INFO);
+  Logger logger("");
+  logger.setLevel(INFO);
 
-	logger.log(ERROR, "foo bar baz qux");
+  logger.log(ERROR, "foo bar baz qux");
 
-	std::cout.rdbuf(coutBuffer);
+  std::cout.rdbuf(coutBuffer);
 
-	std::string actual = oss.str();
-	std::regex expected(
-		"\\[\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\] ERROR: "
-		"foo bar baz qux\\n");
+  std::string actual = oss.str();
+  std::regex expected(
+    "\\[\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\] ERROR: "
+    "foo bar baz qux\\n");
 
-	REQUIRE(std::regex_match(actual, expected));
+  REQUIRE(std::regex_match(actual, expected));
 }
 
-TEST_CASE("Logger logs equal log level")
+TEST_CASE("Logger logs equal log level", "[logger]")
 {
-	std::streambuf *coutBuffer = std::cout.rdbuf();
-	std::ostringstream oss;
-	std::cout.rdbuf(oss.rdbuf());
+  std::streambuf *coutBuffer = std::cout.rdbuf();
+  std::ostringstream oss;
+  std::cout.rdbuf(oss.rdbuf());
 
-	Logger logger("");
-	logger.setLevel(INFO);
+  Logger logger("");
+  logger.setLevel(INFO);
 
-	logger.log(INFO, "foo bar baz qux");
+  logger.log(INFO, "foo bar baz qux");
 
-	std::cout.rdbuf(coutBuffer);
+  std::cout.rdbuf(coutBuffer);
 
-	std::string actual = oss.str();
-	std::regex expected("\\[\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\] INFO: "
-						"foo bar baz qux\\n");
+  std::string actual = oss.str();
+  std::regex expected("\\[\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}\\] INFO: "
+            "foo bar baz qux\\n");
 
-	REQUIRE(std::regex_match(actual, expected));
+  REQUIRE(std::regex_match(actual, expected));
 }
 
-TEST_CASE("Logger ignores lower log level")
+TEST_CASE("Logger ignores lower log level", "[logger]")
 {
-	std::streambuf *coutBuffer = std::cout.rdbuf();
-	std::ostringstream oss;
-	std::cout.rdbuf(oss.rdbuf());
+  std::streambuf *coutBuffer = std::cout.rdbuf();
+  std::ostringstream oss;
+  std::cout.rdbuf(oss.rdbuf());
 
-	Logger logger("");
-	logger.setLevel(INFO);
+  Logger logger("");
+  logger.setLevel(INFO);
 
-	logger.log(DEBUG, "foo bar baz qux");
+  logger.log(DEBUG, "foo bar baz qux");
 
-	std::cout.rdbuf(coutBuffer);
+  std::cout.rdbuf(coutBuffer);
 
-	std::string actual = oss.str();
-	std::string expected("");
+  std::string actual = oss.str();
+  std::string expected("");
 
-	REQUIRE(actual == expected);
+  REQUIRE(actual == expected);
 }