OperatingSystemsFileSystem/MemoryModule.h at master · jovan-djukic/OperatingSystemsFileSystem · 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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
#ifndef _MEMORY_MODULE_H_
#define _MEMORY_MODULE_H_

#include "SwapAlgorithm.h"
#include "TagMemory.h"
#include "Monitor.h"
#include "BoundedBuffer.h"
#include "part.h"

class MemoryInterface {
public:
	virtual int read(unsigned long, char*) = 0;
	virtual int write(unsigned long, const char*) = 0;
	virtual ~MemoryInterface() = 0;
};

class MemoryModule : public MemoryInterface {
public:
	virtual void flush() = 0;
	virtual ~MemoryModule() = 0;
};

class CacheMemory : public MemoryModule {
public:
	CacheMemory(int, int, SwapAlgorithm*, MemoryInterface*);
	virtual void flush() override;
	virtual ~CacheMemory();
protected:
	int preOperation(unsigned long);
	virtual int getNewBlock(unsigned long);

	char ***data;
	int numOfEntries, sizeOfEntry;
	char *D, *V;
	int Vcapacity, Dcapacity;
	TagMemory *tagMemory;
	SwapAlgorithm * swapAlgorithm;
	MemoryInterface *memoryModule;
};

class ByteCacheMemory : public CacheMemory {
public:
	ByteCacheMemory(int, int, MemoryInterface*);
	ByteCacheMemory(int, int, SwapAlgorithm*, MemoryInterface*);
	virtual int read(unsigned long, char*) override;
	virtual int write(unsigned long, const char*) override;
private:
	unsigned long lastAccessedBlock, lastAccessedEntry;
};

class BlockCacheMemory : public CacheMemory {
public:
	BlockCacheMemory(int, int, MemoryInterface*);
	BlockCacheMemory(int, int, SwapAlgorithm*, MemoryInterface*);
	virtual int read(unsigned long, char*) override;
	virtual int write(unsigned long, const char*) override;
};

class ThreadSafeBlockCache : public BlockCacheMemory {
public:
	ThreadSafeBlockCache(int, int, int, MemoryInterface*);
	int read(unsigned long, char*) override;
	int write(unsigned long, const char*) override;
	void flush() override;
	~ThreadSafeBlockCache();
protected:
	int getNewBlock(unsigned long) override;
private:
	ReadersWritersMonitor *monitor;
};

struct WriteRequest {
	unsigned long blockNo;
	const char *buffer;
	WriteRequest(unsigned long, const char*);
	~WriteRequest();
};

typedef BoundedBuffer<WriteRequest*> BlockBuffer;

class WriteRequestHandler : public RequestHandler {
public:
	WriteRequestHandler(BlockBuffer*, MemoryInterface*, ModuleMonitor*);
	~WriteRequestHandler();
protected:
	void handleRequest() override;
private:
	BlockBuffer *buffer;
	MemoryInterface *memoryModule;
	ModuleMonitor *monitor;
};

class BufferedWriter : public MemoryInterface {
public:
	BufferedWriter(int, MemoryInterface*);
	int read(unsigned long, char*) override;
	int write(unsigned long, const char*) override;
	~BufferedWriter();
private:
	BlockBuffer *buffer;
	RequestHandler *handler;
	MemoryInterface *memoryModule;
	ModuleMonitor *monitor;
};

class PartitionWrapper : public MemoryInterface {
public:
	PartitionWrapper(Partition*, unsigned long);
	int read(unsigned long, char*) override;
	int write(unsigned long, const char*) override;
private:
	unsigned long numOfClusters;
	Partition *partition;
};

class MemoryMapper : public MemoryInterface {
public:
	MemoryMapper(MemoryInterface*, CacheMemory*, unsigned long);
	int read(unsigned long, char*) override;
	int write(unsigned long, const char*) override;
	void setIndexCluster(unsigned long);
private:
	unsigned long LogToPh(unsigned long);

	unsigned long indexCluster;
	CacheMemory *indexCache;
	MemoryInterface *memoryModule;
};

class DataMemoryChecker : public MemoryInterface {
public:
	DataMemoryChecker(MemoryInterface*);
	int read(unsigned long, char*) override;
	int write(unsigned long, const char*) override;
private:
	MemoryInterface *memoryModule;
};

class IndexMemoryChecker : public MemoryInterface {
public:
	IndexMemoryChecker(MemoryInterface*);
	int read(unsigned long, char *) override;
	int write(unsigned long, const char *) override;
private:
	MemoryInterface *memoryModule;
};

namespace utilities {
	int getBitFromBitvector(char*, int);
	void setBitInBitvector(char*, int, int);
}


#endif