1 // Copyright 2017 The Abseil Authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 // This file is a no-op if the required LowLevelAlloc support is missing.
16 #include "absl/base/internal/low_level_alloc.h"
17 #ifndef ABSL_LOW_LEVEL_ALLOC_MISSING
18
19 #include "absl/synchronization/internal/per_thread_sem.h"
20
21 #include <atomic>
22
23 #include "absl/base/attributes.h"
24 #include "absl/base/internal/thread_identity.h"
25 #include "absl/synchronization/internal/waiter.h"
26
27 namespace absl {
28 ABSL_NAMESPACE_BEGIN
29 namespace synchronization_internal {
30
SetThreadBlockedCounter(std::atomic<int> * counter)31 void PerThreadSem::SetThreadBlockedCounter(std::atomic<int> *counter) {
32 base_internal::ThreadIdentity *identity;
33 identity = GetOrCreateCurrentThreadIdentity();
34 identity->blocked_count_ptr = counter;
35 }
36
GetThreadBlockedCounter()37 std::atomic<int> *PerThreadSem::GetThreadBlockedCounter() {
38 base_internal::ThreadIdentity *identity;
39 identity = GetOrCreateCurrentThreadIdentity();
40 return identity->blocked_count_ptr;
41 }
42
Init(base_internal::ThreadIdentity * identity)43 void PerThreadSem::Init(base_internal::ThreadIdentity *identity) {
44 new (Waiter::GetWaiter(identity)) Waiter();
45 identity->ticker.store(0, std::memory_order_relaxed);
46 identity->wait_start.store(0, std::memory_order_relaxed);
47 identity->is_idle.store(false, std::memory_order_relaxed);
48 }
49
Tick(base_internal::ThreadIdentity * identity)50 void PerThreadSem::Tick(base_internal::ThreadIdentity *identity) {
51 const int ticker =
52 identity->ticker.fetch_add(1, std::memory_order_relaxed) + 1;
53 const int wait_start = identity->wait_start.load(std::memory_order_relaxed);
54 const bool is_idle = identity->is_idle.load(std::memory_order_relaxed);
55 if (wait_start && (ticker - wait_start > Waiter::kIdlePeriods) && !is_idle) {
56 // Wakeup the waiting thread since it is time for it to become idle.
57 Waiter::GetWaiter(identity)->Poke();
58 }
59 }
60
61 } // namespace synchronization_internal
62 ABSL_NAMESPACE_END
63 } // namespace absl
64
65 extern "C" {
66
ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)67 ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(
68 absl::base_internal::ThreadIdentity *identity) {
69 absl::synchronization_internal::Waiter::GetWaiter(identity)->Post();
70 }
71
ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)72 ABSL_ATTRIBUTE_WEAK bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
73 absl::synchronization_internal::KernelTimeout t) {
74 bool timeout = false;
75 absl::base_internal::ThreadIdentity *identity;
76 identity = absl::synchronization_internal::GetOrCreateCurrentThreadIdentity();
77
78 // Ensure wait_start != 0.
79 int ticker = identity->ticker.load(std::memory_order_relaxed);
80 identity->wait_start.store(ticker ? ticker : 1, std::memory_order_relaxed);
81 identity->is_idle.store(false, std::memory_order_relaxed);
82
83 if (identity->blocked_count_ptr != nullptr) {
84 // Increment count of threads blocked in a given thread pool.
85 identity->blocked_count_ptr->fetch_add(1, std::memory_order_relaxed);
86 }
87
88 timeout =
89 !absl::synchronization_internal::Waiter::GetWaiter(identity)->Wait(t);
90
91 if (identity->blocked_count_ptr != nullptr) {
92 identity->blocked_count_ptr->fetch_sub(1, std::memory_order_relaxed);
93 }
94
95 identity->is_idle.store(false, std::memory_order_relaxed);
96 identity->wait_start.store(0, std::memory_order_relaxed);
97 return !timeout;
98 }
99
100 } // extern "C"
101
102 #endif // ABSL_LOW_LEVEL_ALLOC_MISSING
103