TLA Line data Source code
1 : //
2 : // Copyright (c) 2025 Vinnie Falco (vinnie.falco@gmail.com)
3 : // Copyright (c) 2026 Michael Vandeberg
4 : //
5 : // Distributed under the Boost Software License, Version 1.0. (See accompanying
6 : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7 : //
8 : // Official repository: https://github.com/boostorg/capy
9 : //
10 :
11 : #include <boost/capy/ex/thread_pool.hpp>
12 : #include <boost/capy/continuation.hpp>
13 : #include <boost/capy/detail/thread_local_ptr.hpp>
14 : #include <boost/capy/ex/frame_allocator.hpp>
15 : #include <boost/capy/test/thread_name.hpp>
16 : #include <algorithm>
17 : #include <atomic>
18 : #include <condition_variable>
19 : #include <cstdio>
20 : #include <mutex>
21 : #include <thread>
22 : #include <vector>
23 :
24 : /*
25 : Thread pool implementation using a shared work queue.
26 :
27 : Work items are continuations linked via their intrusive next pointer,
28 : stored in a single queue protected by a mutex. No per-post heap
29 : allocation: the continuation is owned by the caller and linked
30 : directly. Worker threads wait on a condition_variable until work
31 : is available or stop is requested.
32 :
33 : Threads are started lazily on first post() via std::call_once to avoid
34 : spawning threads for pools that are constructed but never used. Each
35 : thread is named with a configurable prefix plus index for debugger
36 : visibility.
37 :
38 : Work tracking: on_work_started/on_work_finished maintain the atomic
39 : outstanding_work_ counter. on_work_started is lock-free; the worker
40 : that drives the count to zero takes mutex_ and re-reads the count
41 : before deciding to stop, so the count and the stop decision stay
42 : consistent even if work is started in between. join() blocks until
43 : this counter reaches zero, then signals workers to stop and joins
44 : threads.
45 :
46 : Two shutdown paths:
47 : - join(): waits for outstanding work to drain, then stops workers.
48 : - stop(): immediately signals workers to exit; queued work is abandoned.
49 : - Destructor: stop() then join() (abandon + wait for threads).
50 : */
51 :
52 : namespace boost {
53 : namespace capy {
54 :
55 : //------------------------------------------------------------------------------
56 :
57 : class thread_pool::impl
58 : {
59 : // Identifies the pool owning the current worker thread, or
60 : // nullptr if the calling thread is not a pool worker. Checked
61 : // by dispatch() to decide between symmetric transfer (inline
62 : // resume) and post.
63 : static inline detail::thread_local_ptr<impl const> current_;
64 :
65 : // Intrusive queue of continuations: the next link is stored in
66 : // continuation::reserved (typed continuation* round-tripped through
67 : // void*). No per-post allocation: the continuation is owned by the caller.
68 : continuation* head_ = nullptr;
69 : continuation* tail_ = nullptr;
70 :
71 HIT 17268 : void push(continuation* c) noexcept
72 : {
73 17268 : c->reserved = nullptr;
74 17268 : if(tail_)
75 5557 : tail_->reserved = c;
76 : else
77 11711 : head_ = c;
78 17268 : tail_ = c;
79 17268 : }
80 :
81 17663 : continuation* pop() noexcept
82 : {
83 17663 : if(!head_)
84 395 : return nullptr;
85 17268 : continuation* c = head_;
86 17268 : head_ = static_cast<continuation*>(head_->reserved);
87 17268 : if(!head_)
88 11711 : tail_ = nullptr;
89 17268 : return c;
90 : }
91 :
92 29018 : bool empty() const noexcept
93 : {
94 29018 : return head_ == nullptr;
95 : }
96 :
97 : std::mutex mutex_;
98 : std::condition_variable work_cv_;
99 : std::condition_variable done_cv_;
100 : std::vector<std::thread> threads_;
101 : std::atomic<std::size_t> outstanding_work_{0};
102 : bool stop_{false};
103 : bool joined_{false};
104 : std::size_t num_threads_;
105 : char thread_name_prefix_[13]{}; // 12 chars max + null terminator
106 : std::once_flag start_flag_;
107 :
108 : public:
109 395 : ~impl() = default;
110 :
111 : bool
112 683 : running_in_this_thread() const noexcept
113 : {
114 683 : return current_.get() == this;
115 : }
116 :
117 : // Destroy abandoned coroutine frames. Must be called
118 : // before execution_context::shutdown()/destroy() so
119 : // that suspended-frame destructors touching services
120 : // (e.g. cancelling registrations) run while those
121 : // services are still valid.
122 : void
123 395 : drain_abandoned() noexcept
124 : {
125 596 : while(auto* c = pop())
126 : {
127 201 : auto h = c->h;
128 201 : if(h && h != std::noop_coroutine())
129 151 : h.destroy();
130 201 : }
131 395 : }
132 :
133 395 : impl(std::size_t num_threads, std::string_view thread_name_prefix)
134 395 : : num_threads_(num_threads)
135 : {
136 395 : if(num_threads_ == 0)
137 8 : num_threads_ = std::max(
138 4 : std::thread::hardware_concurrency(), 1u);
139 :
140 : // Truncate prefix to 12 chars, leaving room for up to 3-digit index.
141 395 : auto n = thread_name_prefix.copy(thread_name_prefix_, 12);
142 395 : thread_name_prefix_[n] = '\0';
143 395 : }
144 :
145 : void
146 17268 : post(continuation& c)
147 : {
148 17268 : ensure_started();
149 : {
150 17268 : std::lock_guard<std::mutex> lock(mutex_);
151 17268 : push(&c);
152 : // Under the lock so the pool cannot drain, join, and
153 : // destroy the condition variable mid-signal.
154 17268 : work_cv_.notify_one();
155 17268 : }
156 17268 : }
157 :
158 : void
159 682 : on_work_started() noexcept
160 : {
161 682 : outstanding_work_.fetch_add(1, std::memory_order_acq_rel);
162 682 : }
163 :
164 : void
165 682 : on_work_finished() noexcept
166 : {
167 682 : if(outstanding_work_.fetch_sub(
168 682 : 1, std::memory_order_acq_rel) == 1)
169 : {
170 : // fetch_sub's result can be stale: a concurrent
171 : // on_work_started() may raise the count before we take the
172 : // lock, so re-read it here rather than trust the decrement.
173 319 : std::lock_guard<std::mutex> lock(mutex_);
174 319 : if(outstanding_work_.load(
175 319 : std::memory_order_acquire) == 0 && joined_ && !stop_)
176 : {
177 179 : stop_ = true;
178 179 : done_cv_.notify_all();
179 179 : work_cv_.notify_all();
180 : }
181 319 : }
182 682 : }
183 :
184 : void
185 656 : join() noexcept
186 : {
187 : {
188 656 : std::unique_lock<std::mutex> lock(mutex_);
189 656 : if(joined_)
190 261 : return;
191 395 : joined_ = true;
192 :
193 395 : if(outstanding_work_.load(
194 395 : std::memory_order_acquire) == 0)
195 : {
196 160 : stop_ = true;
197 160 : work_cv_.notify_all();
198 : }
199 : else
200 : {
201 235 : done_cv_.wait(lock, [this]{
202 415 : return stop_;
203 : });
204 : }
205 656 : }
206 :
207 844 : for(auto& t : threads_)
208 449 : if(t.joinable())
209 449 : t.join();
210 : }
211 :
212 : void
213 397 : stop() noexcept
214 : {
215 : {
216 397 : std::lock_guard<std::mutex> lock(mutex_);
217 397 : stop_ = true;
218 397 : }
219 397 : work_cv_.notify_all();
220 397 : done_cv_.notify_all();
221 397 : }
222 :
223 : private:
224 : void
225 17268 : ensure_started()
226 : {
227 17268 : std::call_once(start_flag_, [this]{
228 345 : threads_.reserve(num_threads_);
229 794 : for(std::size_t i = 0; i < num_threads_; ++i)
230 898 : threads_.emplace_back([this, i]{ run(i); });
231 345 : });
232 17268 : }
233 :
234 : void
235 449 : run(std::size_t index)
236 : {
237 : // Build name; set_current_thread_name truncates to platform limits.
238 : char name[16];
239 449 : std::snprintf(name, sizeof(name), "%s%zu", thread_name_prefix_, index);
240 449 : set_current_thread_name(name);
241 :
242 : // Mark this thread as a worker of this pool so dispatch()
243 : // can symmetric-transfer when called from within pool work.
244 : struct scoped_pool
245 : {
246 449 : scoped_pool(impl const* p) noexcept { current_.set(p); }
247 449 : ~scoped_pool() noexcept { current_.set(nullptr); }
248 449 : } guard(this);
249 :
250 : for(;;)
251 : {
252 17516 : continuation* c = nullptr;
253 : {
254 17516 : std::unique_lock<std::mutex> lock(mutex_);
255 17516 : work_cv_.wait(lock, [this]{
256 40875 : return !empty() ||
257 40875 : stop_;
258 : });
259 17516 : if(stop_)
260 898 : return;
261 17067 : c = pop();
262 17516 : }
263 17067 : if(c)
264 17067 : safe_resume(c->h);
265 17067 : }
266 449 : }
267 : };
268 :
269 : //------------------------------------------------------------------------------
270 :
271 395 : thread_pool::
272 : ~thread_pool()
273 : {
274 395 : impl_->stop();
275 395 : impl_->join();
276 395 : impl_->drain_abandoned();
277 395 : shutdown();
278 395 : destroy();
279 395 : delete impl_;
280 395 : }
281 :
282 395 : thread_pool::
283 395 : thread_pool(std::size_t num_threads, std::string_view thread_name_prefix)
284 395 : : impl_(new impl(num_threads, thread_name_prefix))
285 : {
286 395 : this->set_frame_allocator(std::allocator<void>{});
287 395 : }
288 :
289 : void
290 261 : thread_pool::
291 : join() noexcept
292 : {
293 261 : impl_->join();
294 261 : }
295 :
296 : void
297 2 : thread_pool::
298 : stop() noexcept
299 : {
300 2 : impl_->stop();
301 2 : }
302 :
303 : //------------------------------------------------------------------------------
304 :
305 : thread_pool::executor_type
306 11807 : thread_pool::
307 : get_executor() const noexcept
308 : {
309 11807 : return executor_type(
310 11807 : const_cast<thread_pool&>(*this));
311 : }
312 :
313 : void
314 682 : thread_pool::executor_type::
315 : on_work_started() const noexcept
316 : {
317 682 : pool_->impl_->on_work_started();
318 682 : }
319 :
320 : void
321 682 : thread_pool::executor_type::
322 : on_work_finished() const noexcept
323 : {
324 682 : pool_->impl_->on_work_finished();
325 682 : }
326 :
327 : void
328 16592 : thread_pool::executor_type::
329 : post(continuation& c) const
330 : {
331 16592 : pool_->impl_->post(c);
332 16592 : }
333 :
334 : std::coroutine_handle<>
335 683 : thread_pool::executor_type::
336 : dispatch(continuation& c) const
337 : {
338 683 : if(pool_->impl_->running_in_this_thread())
339 7 : return c.h;
340 676 : pool_->impl_->post(c);
341 676 : return std::noop_coroutine();
342 : }
343 :
344 : } // capy
345 : } // boost
|
