-
Notifications
You must be signed in to change notification settings - Fork 13
/
OITraceCode.cpp
222 lines (183 loc) · 6.1 KB
/
OITraceCode.cpp
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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define NDEBUG 1
// Required for compatibility with new glibc headers
#define __malloc__(x, y) __malloc__
#if !__has_builtin(__builtin_free)
#define __builtin_free(x) free(x)
#endif
#pragma clang diagnostic ignored "-Wunknown-attributes"
// clang-format off
// The header xmmintrin.h must come first. Otherwise it results in errors
// jemalloc during JIT compilation
#include <xmmintrin.h>
#include <cstdint>
#include <utility>
#include <unistd.h>
// clang-format on
#define C10_USING_CUSTOM_GENERATED_MACROS
constexpr int oidMagicId = 0x01DE8;
#include <array>
namespace {
template <typename T, size_t N>
constexpr std::array<T, N + 1> arrayPrepend(std::array<T, N> a, T t);
template <typename T, size_t N, size_t... I>
constexpr std::array<T, N + 1> arrayPrependHelper(std::array<T, N> a,
T t,
std::index_sequence<I...>);
template <size_t Size = (1 << 20) / sizeof(uintptr_t)>
class PointerHashSet {
private:
// 1 MiB of pointers
std::array<uintptr_t, Size> data;
size_t numEntries;
/*
* twang_mix64 hash function, taken from Folly where it is used as the
* default hash function for 64-bit integers.
*/
constexpr static uint64_t twang_mix64(uint64_t key) noexcept {
key = (~key) + (key << 21); // key *= (1 << 21) - 1; key -= 1;
key = key ^ (key >> 24);
key = key + (key << 3) + (key << 8); // key *= 1 + (1 << 3) + (1 << 8)
key = key ^ (key >> 14);
key = key + (key << 2) + (key << 4); // key *= 1 + (1 << 2) + (1 << 4)
key = key ^ (key >> 28);
key = key + (key << 31); // key *= 1 + (1 << 31)
return key;
}
public:
void initialize() noexcept {
data.fill(0);
numEntries = 0;
}
/*
* Adds the pointer to the set.
* Returns `true` if the value was newly added. `false` may be returned if
* the value was already present, a null pointer was passed or if there are
* no entries left in the array.
*/
bool add(uintptr_t pointer) noexcept {
if (pointer == 0) {
return false;
}
uint64_t index = twang_mix64(pointer) % data.size();
while (true) {
uintptr_t entry = data[index];
if (entry == 0) {
data[index] = pointer;
++numEntries;
return true;
}
if (entry == pointer || numEntries >= data.size()) {
return false;
}
index = (index + 1) % data.size();
}
}
size_t size(void) {
return numEntries;
}
size_t capacity(void) {
return data.size();
}
bool add(const auto* p) {
return add((uintptr_t)p);
}
};
} // namespace
// alignas(0) is ignored according to docs so can be default
template <unsigned int N, unsigned int align = 0, int32_t Id = 0>
struct alignas(align) DummySizedOperator {
char c[N];
};
// The empty class specialization is, unfortunately, necessary. When this
// operator is passed as a template parameter to something like unordered_map,
// even though an empty class and a class with a single character have size one,
// there is some empty class optimization that changes the static size of the
// container if an empty class is passed.
template <int32_t Id>
struct DummySizedOperator<0, 0, Id> {};
template <int32_t Id>
struct DummySizedOperator<0, 1, Id> {};
template <template <typename, size_t, size_t, int32_t> typename DerivedT,
typename T,
size_t N,
size_t Align,
int32_t Id>
struct DummyAllocatorBase {
using value_type = T;
T* allocate(std::size_t n) {
return nullptr;
}
void deallocate(T* p, std::size_t n) noexcept {
}
template <typename U>
struct rebind {
using other = DerivedT<U, N, Align, Id>;
};
};
template <typename T, size_t N, size_t Align = 0, int32_t Id = 0>
struct alignas(Align) DummyAllocator
: DummyAllocatorBase<DummyAllocator, T, N, Align, Id> {
char c[N];
};
template <typename T, int32_t Id>
struct DummyAllocator<T, 0, 0, Id>
: DummyAllocatorBase<DummyAllocator, T, 0, 0, Id> {};
template <typename T, int32_t Id>
struct DummyAllocator<T, 0, 1, Id>
: DummyAllocatorBase<DummyAllocator, T, 0, 1, Id> {};
template <typename Type, size_t ExpectedSize, size_t ActualSize>
struct validate_size_eq {
static constexpr bool value = true;
static_assert(ExpectedSize == ActualSize);
};
template <typename Type, size_t ExpectedSize>
struct validate_size : validate_size_eq<Type, ExpectedSize, sizeof(Type)> {};
template <size_t ExpectedOffset, size_t ActualOffset>
struct validate_offset {
static constexpr bool value = true;
static_assert(ExpectedOffset == ActualOffset);
};
enum class StubbedPointer : uintptr_t {};
bool isStorageInline(const auto& c) {
return (uintptr_t)std::data(c) < (uintptr_t)(&c + sizeof(c)) &&
(uintptr_t)std::data(c) >= (uintptr_t)&c;
}
namespace {
template <typename T, size_t N, size_t... I>
constexpr std::array<T, N + 1> arrayPrependHelper(std::array<T, N> a,
T t,
std::index_sequence<I...>) {
return {t, a[I]...};
}
template <typename T, size_t N>
constexpr std::array<T, N + 1> arrayPrepend(std::array<T, N> a, T t) {
return arrayPrependHelper(a, t, std::make_index_sequence<N>());
}
} // namespace
namespace OIInternal {
namespace {
template <typename T>
struct Incomplete;
template <typename T>
constexpr bool oi_is_complete = true;
template <>
constexpr bool oi_is_complete<void> = false;
template <typename T>
constexpr bool oi_is_complete<Incomplete<T>> = false;
} // namespace
} // namespace OIInternal