-
Notifications
You must be signed in to change notification settings - Fork 0
/
history.hpp
110 lines (87 loc) · 2.78 KB
/
history.hpp
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
#include <cstring>
#include <algorithm>
#include <memory>
#include "util.hpp"
#include "large_atomic.hpp"
#include "counter.hpp"
#define ATOMIC(x) std::atomic< x >
class raw_history {
public:
typedef intptr_t version_t;
typedef intptr_t data_t;
typedef intptr_t tid_t;
private:
const int element_size_;
const int history_size_;
const int thread_count_;
struct latest_t {
std::unique_ptr<ATOMIC(uintptr_t)[]> contents;
ATOMIC(uintptr_t)& version() {
return contents[0];
}
ATOMIC(uintptr_t)& data(int i) {
return contents[i+1];
}
};
large_atomic<version_t, tid_t> current_version_;
std::unique_ptr<std::unique_ptr<large_atomic<version_t, data_t>[]>[]> buffer_;
std::unique_ptr<latest_t[]> latest_;
bool get_from_latest(version_t ver, tid_t creator, data_t* output);
bool get_from_buffer(version_t ver, data_t* output);
public:
version_t get_version() {
USING_MEMORY_ORDERS;
return current_version_.load_1(memory_order_seq_cst);
}
bool get(version_t ver, data_t* output);
bool publish(tid_t me, version_t ver, const data_t* input);
raw_history(int element_size, int history_size, int thread_count);
};
class raw_locked_history {
public:
typedef intptr_t version_t;
typedef intptr_t data_t;
typedef intptr_t tid_t;
private:
const int element_size_;
const int history_size_;
const int thread_count_;
std::mutex m_;
std::unique_ptr<VAR_T(bool)[]> thread_checks_; // we try to cause a race here if two threads use the same tid simultaneously
std::unique_ptr<std::unique_ptr<VAR_T(intptr_t)[]>[]> buffer_;
VAR_T(intptr_t) current_version_;
public:
version_t get_version();
bool get(version_t ver, data_t* output);
bool publish(tid_t me, version_t ver, const data_t* input);
raw_locked_history(int element_size, int history_size, int thread_count);
};
template<typename T, typename Raw = raw_history> class history {
private:
Raw hist;
typedef typename Raw::data_t data_t;
static constexpr size_t element_size = (sizeof(T) + sizeof(data_t) - 1) / sizeof(data_t);
public:
typedef typename Raw::version_t version_t;
typedef typename Raw::tid_t tid_t;
history(int history_size, int thread_count) : hist(element_size, history_size, thread_count) { }
version_t get_version() {
return hist.get_version();
}
bool get(version_t ver, T* output) {
intptr_t buffer[element_size];
bool ok = hist.get(ver, buffer);
if (ok)
memcpy(output, buffer, sizeof(T));
return ok;
}
bool publish(tid_t me, version_t ver, const T* input) {
intptr_t buffer[element_size];
memcpy(buffer, input, sizeof(T));
counter::inc_counter(counter::History_PublishCall, 1);
bool result = hist.publish(me, ver, buffer);
if (result)
counter::inc_counter(counter::History_PublishSucc, 1);
return result;
}
};