Merge pull request #13 from bdunahu/bdunahu

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

11 files changed, 199 insertions, 3 deletions

diff --git a/inc/cache.h b/inc/cache.h
new file mode 100644
index 0000000..101cd6e
--- /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
new file mode 100644
index 0000000..41dd7de
--- /dev/null
+++ b/inc/dram.h
@@ -0,0 +1,23 @@
+#ifndef DRAM_H
+#define DRAM_H
+#include <storage.h>
+
+class Dram : 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 number of clock cycles each access takes.
+	 * @return A new memory object.
+	 */
+	Dram(int lines, int delay);
+	~Dram();
+
+	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..7ab3051 100644
--- a/inc/logger.h
+++ b/inc/logger.h
@@ -9,10 +9,25 @@ enum LogLevel { DEBUG, INFO, WARNING, ERROR, CRITICAL };
 class Logger
 {
   public:
+	/**
+	 * Constructor.
+	 * @param The file name to log to.
+	 * @return A new logger object.
+	 */
 	Logger(const string &);
 	~Logger();
 
+	/**
+	 * 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:
diff --git a/inc/response.h b/inc/response.h
new file mode 100644
index 0000000..c8141fd
--- /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
new file mode 100644
index 0000000..1e512e2
--- /dev/null
+++ b/inc/storage.h
@@ -0,0 +1,59 @@
+#ifndef STORAGE_H
+#define STORAGE_H
+#include "response.h"
+#include <array>
+#include <vector>
+
+enum Accessor {
+	MEMORY,
+	FETCH,
+	L1CACHE,
+};
+
+class Storage
+{
+  public:
+	/**
+	 * 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;
+
+  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/memory/driver.cc b/src/memory/driver.cc
deleted file mode 100644
index e69de29..0000000
--- a/src/memory/driver.cc
+++ /dev/null
diff --git a/src/storage/cache.cc b/src/storage/cache.cc
new file mode 100644
index 0000000..34bdc5f
--- /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
new file mode 100644
index 0000000..20858cd
--- /dev/null
+++ b/src/storage/dram.cc
@@ -0,0 +1,21 @@
+#include <dram.h>
+#include <response.h>
+
+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..6580563
--- /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..21182f8
--- /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..711dd0e 100644
--- a/tests/logger.cc
+++ b/tests/logger.cc
@@ -4,7 +4,7 @@
 #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;
@@ -25,7 +25,7 @@ TEST_CASE("Logger logs higher log level")
 	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;
@@ -45,7 +45,7 @@ TEST_CASE("Logger logs equal log level")
 	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;