// Copyright 2017 The Abseil Authors. // // 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 // // https://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. #include <stdint.h> #include <new> // This file is a no-op if the required LowLevelAlloc support is missing. #include "absl/base/internal/low_level_alloc.h" #ifndef ABSL_LOW_LEVEL_ALLOC_MISSING #include <string.h> #include "absl/base/attributes.h" #include "absl/base/internal/spinlock.h" #include "absl/base/internal/thread_identity.h" #include "absl/synchronization/internal/per_thread_sem.h" namespace absl { ABSL_NAMESPACE_BEGIN namespace synchronization_internal { // ThreadIdentity storage is persistent, we maintain a free-list of previously // released ThreadIdentity objects. ABSL_CONST_INIT static base_internal::SpinLock freelist_lock( absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY); ABSL_CONST_INIT static base_internal::ThreadIdentity* thread_identity_freelist; // A per-thread destructor for reclaiming associated ThreadIdentity objects. // Since we must preserve their storage we cache them for re-use. void ReclaimThreadIdentity(void* v) { base_internal::ThreadIdentity* identity = static_cast<base_internal::ThreadIdentity*>(v); // all_locks might have been allocated by the Mutex implementation. // We free it here when we are notified that our thread is dying. if (identity->per_thread_synch.all_locks != nullptr) { base_internal::LowLevelAlloc::Free(identity->per_thread_synch.all_locks); } PerThreadSem::Destroy(identity); // We must explicitly clear the current thread's identity: // (a) Subsequent (unrelated) per-thread destructors may require an identity. // We must guarantee a new identity is used in this case (this instructor // will be reinvoked up to PTHREAD_DESTRUCTOR_ITERATIONS in this case). // (b) ThreadIdentity implementations may depend on memory that is not // reinitialized before reuse. We must allow explicit clearing of the // association state in this case. base_internal::ClearCurrentThreadIdentity(); { base_internal::SpinLockHolder l(&freelist_lock); identity->next = thread_identity_freelist; thread_identity_freelist = identity; } } // Return value rounded up to next multiple of align. // Align must be a power of two. static intptr_t RoundUp(intptr_t addr, intptr_t align) { return (addr + align - 1) & ~(align - 1); } static void ResetThreadIdentity(base_internal::ThreadIdentity* identity) { base_internal::PerThreadSynch* pts = &identity->per_thread_synch; pts->next = nullptr; pts->skip = nullptr; pts->may_skip = false; pts->waitp = nullptr; pts->suppress_fatal_errors = false; pts->readers = 0; pts->priority = 0; pts->next_priority_read_cycles = 0; pts->state.store(base_internal::PerThreadSynch::State::kAvailable, std::memory_order_relaxed); pts->maybe_unlocking = false; pts->wake = false; pts->cond_waiter = false; pts->all_locks = nullptr; identity->blocked_count_ptr = nullptr; identity->ticker.store(0, std::memory_order_relaxed); identity->wait_start.store(0, std::memory_order_relaxed); identity->is_idle.store(false, std::memory_order_relaxed); identity->next = nullptr; } static base_internal::ThreadIdentity* NewThreadIdentity() { base_internal::ThreadIdentity* identity = nullptr; { // Re-use a previously released object if possible. base_internal::SpinLockHolder l(&freelist_lock); if (thread_identity_freelist) { identity = thread_identity_freelist; // Take list-head. thread_identity_freelist = thread_identity_freelist->next; } } if (identity == nullptr) { // Allocate enough space to align ThreadIdentity to a multiple of // PerThreadSynch::kAlignment. This space is never released (it is // added to a freelist by ReclaimThreadIdentity instead). void* allocation = base_internal::LowLevelAlloc::Alloc( sizeof(*identity) + base_internal::PerThreadSynch::kAlignment - 1); // Round up the address to the required alignment. identity = reinterpret_cast<base_internal::ThreadIdentity*>( RoundUp(reinterpret_cast<intptr_t>(allocation), base_internal::PerThreadSynch::kAlignment)); } ResetThreadIdentity(identity); return identity; } // Allocates and attaches ThreadIdentity object for the calling thread. Returns // the new identity. // REQUIRES: CurrentThreadIdentity(false) == nullptr base_internal::ThreadIdentity* CreateThreadIdentity() { base_internal::ThreadIdentity* identity = NewThreadIdentity(); PerThreadSem::Init(identity); // Associate the value with the current thread, and attach our destructor. base_internal::SetCurrentThreadIdentity(identity, ReclaimThreadIdentity); return identity; } } // namespace synchronization_internal ABSL_NAMESPACE_END } // namespace absl #endif // ABSL_LOW_LEVEL_ALLOC_MISSING