CacheSimulator/simple.hpp at master · BryanDClark/CacheSimulator · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
#ifndef SIMPLE
#define SIMPLE

#include "cache.hpp"
#include <map>
#include <vector>
#include <queue>
#include <stdlib.h>

class SimpleCache : public Cache
{
public:
	std::map<ulong, page> pageTable;
	SimpleCache(ulong cacheSize, ulong blockSize) : Cache(cacheSize, blockSize) {}

	virtual void onMiss(ulong )	{}
	virtual void onHit(ulong ) {}

	void handleEviction(Cache *upperCache, Cache *lowerCache, page& replacedPage)
	{
		if(replacedPage.state == 'M')
		{
			//messy state, need to writeback
			if(upperCache)
				upperCache->write(replacedPage.addr);
			else
				memWriteCount++;
		}
	}

	virtual void evict(ulong ) {}
	virtual void insert(ulong , cacheState ) {}

	bool replace(ulong address, cacheState state)
	{
		if(pageTable.find(address) == pageTable.end() || pageTable[address].state == INVALID)
		{
			//not currently in the cache
			missCount++;
			onMiss(address);
			insert(address, state);
			return false;
		}
		else
		{
			hitCount++;
			onHit(address);
			return true;
		}
	}

	virtual void read(ulong address)
	{
		readCount++;
		replace(address, CLEAN);
	}

	virtual void write(ulong address)
	{
		writeCount++;
		replace(address, MESSY);
	}
};

class RandomCache : public SimpleCache
{
private:
	std::vector<page> pageVector;

public:
	RandomCache(ulong cacheSize, ulong blockSize) : SimpleCache(cacheSize, blockSize)
	{
		srand(time(NULL));
	}

	void evict(ulong index)
	{
		page replacedPage = pageVector[index];
		//no need to erase from the vector; this is a swap
		pageTable.erase(replacedPage.addr);
		handleEviction(upperCache, lowerCache, replacedPage);
		currentSize_--;
	}

	void insert(ulong address, cacheState state)
	{
		page newPage(address, state);
		pageTable[address] = newPage;

		if(cacheSize_ == currentSize_)
		{
			//something has to be replaced
			ulong index = rand() % cacheSize_;
			evict(index);
			pageVector[index] = newPage;
		}
		else
		{
			pageVector.push_back(newPage);
		}
		currentSize_++;
	}
};

class FIFOCache : public SimpleCache
{
private:
	std::queue<page> pageQueue;

public:
	FIFOCache(ulong cacheSize, ulong blockSize) : SimpleCache(cacheSize, blockSize) {}

	void evict(ulong )
	{
		page replacedPage = pageQueue.front();
		pageQueue.pop();
		pageTable.erase(replacedPage.addr);
		handleEviction(upperCache, lowerCache, replacedPage);
		currentSize_--;
	}

	void insert(ulong address, cacheState state)
	{
		page newPage(address, state);
		pageTable[address] = newPage;

		if(cacheSize_ == currentSize_)
		{
			//something has to be replaced
			evict(0);
		}
		pageQueue.push(newPage);
		currentSize_++;
	}
};

#endif