11#ifndef EIGEN_THREADPOOL_THREAD_LOCAL_H
12#define EIGEN_THREADPOOL_THREAD_LOCAL_H
14#include <forward_list>
16#ifdef EIGEN_AVOID_THREAD_LOCAL
18#ifdef EIGEN_THREAD_LOCAL
19#undef EIGEN_THREAD_LOCAL
24#define EIGEN_THREAD_LOCAL static thread_local
30#include <Availability.h>
31#include <TargetConditionals.h>
34#if EIGEN_COMP_CLANGAPPLE && TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_9_0
36#undef EIGEN_THREAD_LOCAL
42#include "./InternalHeaderCheck.h"
48struct ThreadLocalNoOpInitialize {
49 void operator()(T&)
const {}
53struct ThreadLocalNoOpRelease {
54 void operator()(T&)
const {}
91template <
typename T,
typename Initialize =
internal::ThreadLocalNoOpInitialize<T>,
92 typename Release =
internal::ThreadLocalNoOpRelease<T>>
95 static_assert(std::is_default_constructible<T>::value,
"ThreadLocal data type must be default constructible");
98 explicit ThreadLocal(
int capacity)
99 : ThreadLocal(capacity, internal::ThreadLocalNoOpInitialize<T>(), internal::ThreadLocalNoOpRelease<T>()) {}
101 ThreadLocal(
int capacity, Initialize initialize)
102 : ThreadLocal(capacity, std::move(initialize), internal::ThreadLocalNoOpRelease<T>()) {}
104 ThreadLocal(
int capacity, Initialize initialize, Release release)
105 : initialize_(std::move(initialize)),
106 release_(std::move(release)),
111 eigen_assert(capacity_ >= 0);
112 data_.resize(capacity_);
113 for (
int i = 0; i < capacity_; ++i) {
114 ptr_.emplace_back(
nullptr);
119 std::thread::id this_thread = std::this_thread::get_id();
120 if (capacity_ == 0)
return InsertOrSpill(this_thread, 0);
122 std::size_t h = std::hash<std::thread::id>()(this_thread);
123 const int start_idx = h % capacity_;
134 while (ThreadIdAndValue* record = ptr_[idx].load()) {
135 if (record->thread_id == this_thread)
return record->value;
138 if (idx >= capacity_) idx -= capacity_;
139 if (idx == start_idx)
break;
142 return InsertOrSpill(this_thread, idx);
146 void ForEach(std::function<
void(std::thread::id, T&)> f) {
149 for (
auto& ptr : ptr_) {
150 ThreadIdAndValue* record = ptr.load();
151 if (record ==
nullptr)
continue;
152 f(record->thread_id, record->value);
156 if (filled_records_.load(std::memory_order_relaxed) < capacity_)
return;
159 EIGEN_MUTEX_LOCK lock(mu_);
160 for (
auto& record : spilled_) {
161 f(record.thread_id, record.value);
169 for (
auto& ptr : ptr_) {
170 ThreadIdAndValue* record = ptr.load();
171 if (record ==
nullptr)
continue;
172 release_(record->value);
176 if (filled_records_.load(std::memory_order_relaxed) < capacity_)
return;
179 EIGEN_MUTEX_LOCK lock(mu_);
180 for (
auto& record : spilled_) {
181 release_(record.value);
186 struct ThreadIdAndValue {
187 std::thread::id thread_id;
191 EIGEN_DONT_INLINE T& InsertOrSpill(std::thread::id this_thread,
int idx) {
200 if (filled_records_.load() < capacity_) {
201 int insertion_index = filled_records_.fetch_add(1, std::memory_order_relaxed);
202 if (insertion_index < capacity_) {
205 data_[insertion_index].thread_id = this_thread;
206 initialize_(data_[insertion_index].value);
209 ThreadIdAndValue* inserted = &data_[insertion_index];
215 const int insertion_idx = idx;
216 ThreadIdAndValue* empty;
221 while (ptr_[idx].load() !=
nullptr) {
223 if (idx >= capacity_) idx -= capacity_;
227 eigen_assert(idx != insertion_idx);
234 }
while (!ptr_[idx].compare_exchange_weak(empty, inserted));
236 return inserted->value;
241 EIGEN_MUTEX_LOCK lock(mu_);
242 for (
auto& record : spilled_) {
243 if (record.thread_id == this_thread)
return record.value;
245 spilled_.emplace_front();
246 ThreadIdAndValue& inserted = spilled_.front();
247 inserted.thread_id = this_thread;
248 initialize_(inserted.value);
249 return inserted.value;
252 Initialize initialize_;
258 MaxSizeVector<ThreadIdAndValue> data_;
262 MaxSizeVector<std::atomic<ThreadIdAndValue*>> ptr_;
265 std::atomic<int> filled_records_;
271 std::forward_list<ThreadIdAndValue> spilled_;