/*
- * Copyright 2016 Facebook, Inc.
+ * Copyright 2017 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-#include <folly/ThreadLocal.h>
+#include <folly/detail/ThreadLocalDetail.h>
#include <list>
#include <mutex>
#else
std::unique_ptr<ThreadEntry> threadEntry(static_cast<ThreadEntry*>(ptr));
#endif
- DCHECK_GT(threadEntry->elementsCapacity, 0);
+ DCHECK_GT(threadEntry->elementsCapacity, 0u);
auto& meta = *threadEntry->meta;
// Make sure this ThreadEntry is available if ThreadLocal A is accessed in
};
{
- SharedMutex::ReadHolder rlock;
+ SharedMutex::ReadHolder rlock(nullptr);
if (meta.strict_) {
rlock = SharedMutex::ReadHolder(meta.accessAllThreadsLock_);
}
void StaticMetaBase::destroy(EntryID* ent) {
try {
auto& meta = *this;
+
// Elements in other threads that use this id.
std::vector<ElementWrapper> elements;
+
{
- std::lock_guard<std::mutex> g(meta.lock_);
- uint32_t id = ent->value.exchange(kEntryIDInvalid);
- if (id == kEntryIDInvalid) {
- return;
+ SharedMutex::WriteHolder wlock(nullptr);
+ if (meta.strict_) {
+ /*
+ * In strict mode, the logic guarantees per-thread instances are
+ * destroyed by the moment ThreadLocal<> dtor returns.
+ * In order to achieve that, we should wait until concurrent
+ * onThreadExit() calls (that might acquire ownership over per-thread
+ * instances in order to destroy them) are finished.
+ */
+ wlock = SharedMutex::WriteHolder(meta.accessAllThreadsLock_);
}
- for (ThreadEntry* e = meta.head_.next; e != &meta.head_; e = e->next) {
- if (id < e->elementsCapacity && e->elements[id].ptr) {
- elements.push_back(e->elements[id]);
+ {
+ std::lock_guard<std::mutex> g(meta.lock_);
+ uint32_t id = ent->value.exchange(kEntryIDInvalid);
+ if (id == kEntryIDInvalid) {
+ return;
+ }
- /*
- * Writing another thread's ThreadEntry from here is fine;
- * the only other potential reader is the owning thread --
- * from onThreadExit (which grabs the lock, so is properly
- * synchronized with us) or from get(), which also grabs
- * the lock if it needs to resize the elements vector.
- *
- * We can't conflict with reads for a get(id), because
- * it's illegal to call get on a thread local that's
- * destructing.
- */
- e->elements[id].ptr = nullptr;
- e->elements[id].deleter1 = nullptr;
- e->elements[id].ownsDeleter = false;
+ for (ThreadEntry* e = meta.head_.next; e != &meta.head_; e = e->next) {
+ if (id < e->elementsCapacity && e->elements[id].ptr) {
+ elements.push_back(e->elements[id]);
+
+ /*
+ * Writing another thread's ThreadEntry from here is fine;
+ * the only other potential reader is the owning thread --
+ * from onThreadExit (which grabs the lock, so is properly
+ * synchronized with us) or from get(), which also grabs
+ * the lock if it needs to resize the elements vector.
+ *
+ * We can't conflict with reads for a get(id), because
+ * it's illegal to call get on a thread local that's
+ * destructing.
+ */
+ e->elements[id].ptr = nullptr;
+ e->elements[id].deleter1 = nullptr;
+ e->elements[id].ownsDeleter = false;
+ }
}
+ meta.freeIds_.push_back(id);
}
- meta.freeIds_.push_back(id);
}
- // Delete elements outside the lock
+ // Delete elements outside the locks.
for (ElementWrapper& elem : elements) {
elem.dispose(TLPDestructionMode::ALL_THREADS);
}
free(reallocated);
}
-namespace {
-
-struct AtForkTask {
- folly::Function<void()> prepare;
- folly::Function<void()> parent;
- folly::Function<void()> child;
-};
-
-class AtForkList {
- public:
- static AtForkList& instance() {
- static auto instance = new AtForkList();
- return *instance;
- }
-
- static void prepare() noexcept {
- instance().tasksLock.lock();
- auto& tasks = instance().tasks;
- for (auto task = tasks.rbegin(); task != tasks.rend(); ++task) {
- task->prepare();
- }
- }
-
- static void parent() noexcept {
- auto& tasks = instance().tasks;
- for (auto& task : tasks) {
- task.parent();
- }
- instance().tasksLock.unlock();
- }
-
- static void child() noexcept {
- auto& tasks = instance().tasks;
- for (auto& task : tasks) {
- task.child();
- }
- instance().tasksLock.unlock();
- }
-
- std::mutex tasksLock;
- std::list<AtForkTask> tasks;
-
- private:
- AtForkList() {
-#if FOLLY_HAVE_PTHREAD_ATFORK
- int ret = pthread_atfork(
- &AtForkList::prepare, &AtForkList::parent, &AtForkList::child);
- checkPosixError(ret, "pthread_atfork failed");
-#elif !__ANDROID__ && !defined(_MSC_VER)
-// pthread_atfork is not part of the Android NDK at least as of n9d. If
-// something is trying to call native fork() directly at all with Android's
-// process management model, this is probably the least of the problems.
-//
-// But otherwise, this is a problem.
-#warning pthread_atfork unavailable
-#endif
- }
-};
-}
-
-void StaticMetaBase::initAtFork() {
- AtForkList::instance();
-}
-
-void StaticMetaBase::registerAtFork(
- folly::Function<void()> prepare,
- folly::Function<void()> parent,
- folly::Function<void()> child) {
- std::lock_guard<std::mutex> lg(AtForkList::instance().tasksLock);
- AtForkList::instance().tasks.push_back(
- {std::move(prepare), std::move(parent), std::move(child)});
-}
FOLLY_STATIC_CTOR_PRIORITY_MAX
PthreadKeyUnregister PthreadKeyUnregister::instance_;
-}}
+} // namespace threadlocal_detail
+} // namespace folly
projects / folly.git / blobdiff