PartitonSort/Simulation.h at master · sorrachai/PartitonSort · 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
#ifndef  SIMULATION_H
#define  SIMULATION_H

#include "ElementaryClasses.h"
#include "Utilities/MapExtensions.h"

#include <map>
#include <unordered_map>

typedef uint32_t Memory;

class PartitionPacketClassifier {
public:
	virtual int ComputeNumberOfBuckets(const std::vector<Rule>& rules) = 0;
};

class ClassifierTable {
public:
	virtual int ClassifyAPacket(const Packet& packet) const = 0;
	virtual void Insertion(const Rule& rule, bool& priorityChange) = 0;
	virtual void Deletion(const Rule& rule, bool& priorityChange) = 0;
	virtual bool CanInsertRule(const Rule& rule) const = 0;

	virtual size_t NumRules() const = 0;
	virtual int MaxPriority() const = 0;

	virtual Memory MemSizeBytes(Memory ruleSize) const = 0;
	virtual std::vector<Rule> GetRules() const = 0;
};

class PacketClassifier {
public:
	virtual void ConstructClassifier(const std::vector<Rule>& rules) = 0;
	virtual int ClassifyAPacket(const Packet& packet) = 0;
	virtual void DeleteRule(size_t index) = 0;
	virtual void InsertRule(const Rule& rule) = 0;
	virtual Memory MemSizeBytes() const = 0;
	virtual int MemoryAccess() const = 0;
	virtual size_t NumTables() const = 0;
	virtual size_t RulesInTable(size_t tableIndex) const = 0;

	int TablesQueried() const {	return queryCount; }
	int NumPacketsQueriedNTables(int n) const { return GetOrElse<int, int>(packetHistogram, n, 0); };

protected:
	void QueryUpdate(int query) {
		packetHistogram[query]++;
		queryCount += query;
	}

private:
	int queryCount = 0;
	std::unordered_map<int, int> packetHistogram;
};

class ListClassifier : public PacketClassifier {
public:
	virtual void ConstructClassifier(const std::vector<Rule>& rules) {
		this->rules = rules;
	}
	virtual int ClassifyAPacket(const Packet& packet) {
		for (const Rule& r : rules) {
			if (r.MatchesPacket(packet)) {
				return r.priority;
			}
		}
		return -1;
	}
	virtual void DeleteRule(size_t index) {};
	virtual void InsertRule(const Rule& rule) {};
	virtual Memory MemSizeBytes() const {
		return 0;
	};
	virtual int MemoryAccess() const {
		return rules.size();
	}
	virtual size_t NumTables() const {
		return 1;
	};
	virtual size_t RulesInTable(size_t tableIndex) const {
		return rules.size();
	};

private:
	std::vector<Rule> rules;
};


enum RequestType{
	ClassifyPacket,
	Insertion,
	Deletion
};
struct Request {
	Request(RequestType request_type) : request_type(request_type) {}
	RequestType request_type;
	int random_index_trace;
};

struct Bookkeeper {
	Bookkeeper(){}
	Bookkeeper(const std::vector<Rule> rules) : rules(rules) {}
	Rule GetOneRuleAndPop(int i) {
		if (rules.size() == 0) {
			printf("warning: Bookeeper has no rule");
			return Rule();
		}
		Rule to_return = rules[i];
		if (i != rules.size() - 1) rules[i] = std::move(rules[rules.size() - 1]);
		rules.pop_back();
		return to_return;
	}
	std::vector<Rule> GetRules() const {
		return rules;
	}
	void InsertRule(const Rule& r) {
		rules.push_back(r);
	}
	int size() const { return rules.size(); }
private:
	std::vector<Rule> rules;
};
class Simulator{
public:
	Simulator(){}
	~Simulator(){}
	Simulator(const std::vector<Rule>& ruleset) :ruleset(ruleset) {}
	Simulator(const std::vector<Rule>& ruleset, const std::vector<Packet>& packets) :ruleset(ruleset), packets(packets) {}

	static int PerformPartitioning(PartitionPacketClassifier& ppc, const std::vector<Rule>& ruleset, std::map<std::string, std::string>& summary);

	std::vector<Request> SetupComputation(int num_packet, int num_insert, int num_delete);
	std::vector<int>  PerformOnlyPacketClassification(PacketClassifier& classifier, std::map<std::string, std::string>& summary) const;
	std::vector<int>  PerformPacketClassification( PacketClassifier& classifier, const std::vector<Request>& sequence, std::map<std::string, double>& trial) const;

private:

	std::vector<Request> GenerateRequests(int num_packet, int num_insert, int num_delete) const;

	std::vector<Rule> ruleset;
	std::vector<Packet> packets;
	Bookkeeper rules_in_use;
	Bookkeeper available_pool;
};

#endif