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
|
//===--- Definitions of common thread items ---------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "src/__support/threads/thread.h"
#include "src/__support/macros/config.h"
#include "src/__support/threads/mutex.h"
#include "src/__support/CPP/array.h"
#include "src/__support/CPP/mutex.h" // lock_guard
#include "src/__support/CPP/optional.h"
#include "src/__support/fixedvector.h"
#include "src/__support/macros/attributes.h"
namespace LIBC_NAMESPACE_DECL {
namespace {
using AtExitCallback = void(void *);
struct AtExitUnit {
AtExitCallback *callback = nullptr;
void *obj = nullptr;
constexpr AtExitUnit() = default;
constexpr AtExitUnit(AtExitCallback *cb, void *o) : callback(cb), obj(o) {}
};
constexpr size_t TSS_KEY_COUNT = 1024;
struct TSSKeyUnit {
// Indicates whether is unit is active. Presence of a non-null dtor
// is not sufficient to indicate the same information as a TSS key can
// have a null destructor.
bool active = false;
TSSDtor *dtor = nullptr;
constexpr TSSKeyUnit() = default;
constexpr TSSKeyUnit(TSSDtor *d) : active(true), dtor(d) {}
void reset() {
active = false;
dtor = nullptr;
}
};
class TSSKeyMgr {
Mutex mtx;
cpp::array<TSSKeyUnit, TSS_KEY_COUNT> units;
public:
constexpr TSSKeyMgr()
: mtx(/*timed=*/false, /*recursive=*/false, /*robust=*/false,
/*pshared=*/false) {}
cpp::optional<unsigned int> new_key(TSSDtor *dtor) {
cpp::lock_guard lock(mtx);
for (unsigned int i = 0; i < TSS_KEY_COUNT; ++i) {
TSSKeyUnit &u = units[i];
if (!u.active) {
u = {dtor};
return i;
}
}
return cpp::optional<unsigned int>();
}
TSSDtor *get_dtor(unsigned int key) {
if (key >= TSS_KEY_COUNT)
return nullptr;
cpp::lock_guard lock(mtx);
return units[key].dtor;
}
bool remove_key(unsigned int key) {
if (key >= TSS_KEY_COUNT)
return false;
cpp::lock_guard lock(mtx);
units[key].reset();
return true;
}
bool is_valid_key(unsigned int key) {
cpp::lock_guard lock(mtx);
return units[key].active;
}
};
TSSKeyMgr tss_key_mgr;
struct TSSValueUnit {
bool active = false;
void *payload = nullptr;
TSSDtor *dtor = nullptr;
constexpr TSSValueUnit() = default;
constexpr TSSValueUnit(void *p, TSSDtor *d)
: active(true), payload(p), dtor(d) {}
};
static LIBC_THREAD_LOCAL cpp::array<TSSValueUnit, TSS_KEY_COUNT> tss_values;
} // anonymous namespace
class ThreadAtExitCallbackMgr {
Mutex mtx;
// TODO: Use a BlockStore when compiled for production.
FixedVector<AtExitUnit, 1024> callback_list;
public:
constexpr ThreadAtExitCallbackMgr()
: mtx(/*timed=*/false, /*recursive=*/false, /*robust=*/false,
/*pshared=*/false) {}
int add_callback(AtExitCallback *callback, void *obj) {
cpp::lock_guard lock(mtx);
if (callback_list.push_back({callback, obj}))
return 0;
return -1;
}
void call() {
mtx.lock();
while (!callback_list.empty()) {
auto atexit_unit = callback_list.back();
callback_list.pop_back();
mtx.unlock();
atexit_unit.callback(atexit_unit.obj);
mtx.lock();
}
}
};
static LIBC_THREAD_LOCAL ThreadAtExitCallbackMgr atexit_callback_mgr;
// The function __cxa_thread_atexit is provided by C++ runtimes like libcxxabi.
// It is used by thread local object runtime to register destructor calls. To
// actually register destructor call with the threading library, it calls
// __cxa_thread_atexit_impl, which is to be provided by the threading library.
// The semantics are very similar to the __cxa_atexit function except for the
// fact that the registered callback is thread specific.
extern "C" int __cxa_thread_atexit_impl(AtExitCallback *callback, void *obj,
void *) {
return atexit_callback_mgr.add_callback(callback, obj);
}
namespace internal {
ThreadAtExitCallbackMgr *get_thread_atexit_callback_mgr() {
return &atexit_callback_mgr;
}
void call_atexit_callbacks(ThreadAttributes *attrib) {
attrib->atexit_callback_mgr->call();
for (size_t i = 0; i < TSS_KEY_COUNT; ++i) {
TSSValueUnit &unit = tss_values[i];
// Both dtor and value need to nonnull to call dtor
if (unit.dtor != nullptr && unit.payload != nullptr)
unit.dtor(unit.payload);
}
}
extern "C" void __cxa_thread_finalize() { call_atexit_callbacks(self.attrib); }
} // namespace internal
cpp::optional<unsigned int> new_tss_key(TSSDtor *dtor) {
return tss_key_mgr.new_key(dtor);
}
bool tss_key_delete(unsigned int key) { return tss_key_mgr.remove_key(key); }
bool set_tss_value(unsigned int key, void *val) {
if (!tss_key_mgr.is_valid_key(key))
return false;
tss_values[key] = {val, tss_key_mgr.get_dtor(key)};
return true;
}
void *get_tss_value(unsigned int key) {
if (key >= TSS_KEY_COUNT)
return nullptr;
auto &u = tss_values[key];
if (!u.active)
return nullptr;
return u.payload;
}
} // namespace LIBC_NAMESPACE_DECL
|
