99.34% Lines (150/151) 100.00% Functions (28/28)
TLA Baseline Branch
Line Hits Code Line Hits Code
1   // 1   //
2   // Copyright (c) 2025 Vinnie Falco (vinnie.falco@gmail.com) 2   // Copyright (c) 2025 Vinnie Falco (vinnie.falco@gmail.com)
3   // Copyright (c) 2026 Michael Vandeberg 3   // Copyright (c) 2026 Michael Vandeberg
4   // 4   //
5   // Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 6   // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7   // 7   //
8   // Official repository: https://github.com/boostorg/capy 8   // Official repository: https://github.com/boostorg/capy
9   // 9   //
10   10  
11   #include <boost/capy/ex/thread_pool.hpp> 11   #include <boost/capy/ex/thread_pool.hpp>
12   #include <boost/capy/continuation.hpp> 12   #include <boost/capy/continuation.hpp>
13   #include <boost/capy/detail/thread_local_ptr.hpp> 13   #include <boost/capy/detail/thread_local_ptr.hpp>
14   #include <boost/capy/ex/abandon.hpp> 14   #include <boost/capy/ex/abandon.hpp>
15   #include <boost/capy/ex/frame_allocator.hpp> 15   #include <boost/capy/ex/frame_allocator.hpp>
16   #include <boost/capy/test/thread_name.hpp> 16   #include <boost/capy/test/thread_name.hpp>
17   #include <algorithm> 17   #include <algorithm>
18   #include <atomic> 18   #include <atomic>
19   #include <condition_variable> 19   #include <condition_variable>
20   #include <cstdio> 20   #include <cstdio>
21   #include <mutex> 21   #include <mutex>
22   #include <thread> 22   #include <thread>
23   #include <vector> 23   #include <vector>
24   24  
25   /* 25   /*
26   Thread pool implementation using a shared work queue. 26   Thread pool implementation using a shared work queue.
27   27  
28   Work items are continuations linked via their intrusive next pointer, 28   Work items are continuations linked via their intrusive next pointer,
29   stored in a single queue protected by a mutex. No per-post heap 29   stored in a single queue protected by a mutex. No per-post heap
30   allocation: the continuation is owned by the caller and linked 30   allocation: the continuation is owned by the caller and linked
31   directly. Worker threads wait on a condition_variable until work 31   directly. Worker threads wait on a condition_variable until work
32   is available or stop is requested. 32   is available or stop is requested.
33   33  
34   Threads are started lazily on first post(), under mutex_, to avoid 34   Threads are started lazily on first post(), under mutex_, to avoid
35   spawning threads for pools that are constructed but never used. A 35   spawning threads for pools that are constructed but never used. A
36   stopped pool starts none. Each thread is named 36   stopped pool starts none. Each thread is named
37   with a configurable prefix plus index for debugger visibility. 37   with a configurable prefix plus index for debugger visibility.
38   38  
39   Work tracking: on_work_started/on_work_finished maintain the atomic 39   Work tracking: on_work_started/on_work_finished maintain the atomic
40   outstanding_work_ counter. on_work_started is lock-free, and so is 40   outstanding_work_ counter. on_work_started is lock-free, and so is
41   on_work_finished while the count stays above one. The release that 41   on_work_finished while the count stays above one. The release that
42   may take it to zero is made under mutex_, so join() can't see zero, 42   may take it to zero is made under mutex_, so join() can't see zero,
43   return and let the pool be destroyed while that call still uses it. 43   return and let the pool be destroyed while that call still uses it.
44   join() blocks until this counter reaches zero, then signals workers 44   join() blocks until this counter reaches zero, then signals workers
45   to stop and joins threads. 45   to stop and joins threads.
46   46  
47   Two shutdown paths: 47   Two shutdown paths:
48   - join(): waits for outstanding work to drain, then stops workers. 48   - join(): waits for outstanding work to drain, then stops workers.
49   - stop(): immediately signals workers to exit; queued work stays queued. 49   - stop(): immediately signals workers to exit; queued work stays queued.
50   - Destructor: stop() then join(), then queued work is abandoned. 50   - Destructor: stop() then join(), then queued work is abandoned.
51   */ 51   */
52   52  
53   namespace boost { 53   namespace boost {
54   namespace capy { 54   namespace capy {
55   55  
56   //------------------------------------------------------------------------------ 56   //------------------------------------------------------------------------------
57   57  
58   class thread_pool::impl 58   class thread_pool::impl
59   { 59   {
60   // Identifies the pool owning the current worker thread, or 60   // Identifies the pool owning the current worker thread, or
61   // nullptr if the calling thread is not a pool worker. Checked 61   // nullptr if the calling thread is not a pool worker. Checked
62   // by dispatch() to decide between symmetric transfer (inline 62   // by dispatch() to decide between symmetric transfer (inline
63   // resume) and post. 63   // resume) and post.
64   static inline detail::thread_local_ptr<impl const> current_; 64   static inline detail::thread_local_ptr<impl const> current_;
65   65  
66   // Intrusive queue of continuations: the next link is stored in 66   // Intrusive queue of continuations: the next link is stored in
67   // continuation::reserved (typed continuation* round-tripped through 67   // continuation::reserved (typed continuation* round-tripped through
68   // void*). No per-post allocation: the continuation is owned by the caller. 68   // void*). No per-post allocation: the continuation is owned by the caller.
69   continuation* head_ = nullptr; 69   continuation* head_ = nullptr;
70   continuation* tail_ = nullptr; 70   continuation* tail_ = nullptr;
71   71  
HITCBC 72   22211 void push(continuation* c) noexcept 72   22158 void push(continuation* c) noexcept
73   { 73   {
HITCBC 74   22211 c->reserved = nullptr; 74   22158 c->reserved = nullptr;
HITCBC 75   22211 if(tail_) 75   22158 if(tail_)
HITCBC 76   5851 tail_->reserved = c; 76   2083 tail_->reserved = c;
77   else 77   else
HITCBC 78   16360 head_ = c; 78   20075 head_ = c;
HITCBC 79   22211 tail_ = c; 79   22158 tail_ = c;
HITCBC 80   22211 } 80   22158 }
81   81  
HITCBC 82   25075 continuation* pop() noexcept 82   25050 continuation* pop() noexcept
83   { 83   {
HITCBC 84   25075 if(!head_) 84   25050 if(!head_)
HITCBC 85   2864 return nullptr; 85   2892 return nullptr;
HITCBC 86   22211 continuation* c = head_; 86   22158 continuation* c = head_;
HITCBC 87   22211 head_ = static_cast<continuation*>(head_->reserved); 87   22158 head_ = static_cast<continuation*>(head_->reserved);
HITCBC 88   22211 if(!head_) 88   22158 if(!head_)
HITCBC 89   16360 tail_ = nullptr; 89   20075 tail_ = nullptr;
HITCBC 90   22211 return c; 90   22158 return c;
91   } 91   }
92   92  
HITCBC 93   38338 bool empty() const noexcept 93   42311 bool empty() const noexcept
94   { 94   {
HITCBC 95   38338 return head_ == nullptr; 95   42311 return head_ == nullptr;
96   } 96   }
97   97  
98   std::mutex mutex_; 98   std::mutex mutex_;
99   std::condition_variable work_cv_; 99   std::condition_variable work_cv_;
100   std::condition_variable done_cv_; 100   std::condition_variable done_cv_;
101   std::vector<std::thread> threads_; 101   std::vector<std::thread> threads_;
102   std::atomic<std::size_t> outstanding_work_{0}; 102   std::atomic<std::size_t> outstanding_work_{0};
103   bool stop_{false}; 103   bool stop_{false};
104   bool joined_{false}; 104   bool joined_{false};
105   std::size_t num_threads_; 105   std::size_t num_threads_;
106   char thread_name_prefix_[13]{}; // 12 chars max + null terminator 106   char thread_name_prefix_[13]{}; // 12 chars max + null terminator
107   std::atomic<bool> started_{false}; 107   std::atomic<bool> started_{false};
108   108  
109   public: 109   public:
HITCBC 110   1432 ~impl() = default; 110   1446 ~impl() = default;
111   111  
112   bool 112   bool
HITCBC 113   3210 running_in_this_thread() const noexcept 113   3224 running_in_this_thread() const noexcept
114   { 114   {
HITCBC 115   3210 return current_.get() == this; 115   3224 return current_.get() == this;
116   } 116   }
117   117  
118   // Abandon queued coroutines. Each is taken under the lock, as other 118   // Abandon queued coroutines. Each is taken under the lock, as other
119   // threads may still post, and abandoned outside it, as abandoning 119   // threads may still post, and abandoned outside it, as abandoning
120   // can post. 120   // can post.
121   void 121   void
HITCBC 122   2864 drain_abandoned() noexcept 122   2892 drain_abandoned() noexcept
123   { 123   {
124   for(;;) 124   for(;;)
125   { 125   {
126   continuation* c; 126   continuation* c;
127   { 127   {
HITCBC 128   3447 std::lock_guard<std::mutex> lock(mutex_); 128   3415 std::lock_guard<std::mutex> lock(mutex_);
HITCBC 129   3447 c = pop(); 129   3415 c = pop();
HITCBC 130   3447 } 130   3415 }
HITCBC 131   3447 if(!c) 131   3415 if(!c)
HITCBC 132   2864 return; 132   2892 return;
HITCBC 133   583 if(c->h && c->h != std::noop_coroutine()) 133   523 if(c->h && c->h != std::noop_coroutine())
HITCBC 134   330 capy::abandon(*c); 134   270 capy::abandon(*c);
HITCBC 135   583 } 135   523 }
136   } 136   }
137   137  
HITCBC 138   1432 impl(std::size_t num_threads, std::string_view thread_name_prefix) 138   1446 impl(std::size_t num_threads, std::string_view thread_name_prefix)
HITCBC 139   1432 : num_threads_(num_threads) 139   1446 : num_threads_(num_threads)
140   { 140   {
HITCBC 141   1432 if(num_threads_ == 0) 141   1446 if(num_threads_ == 0)
HITCBC 142   8 num_threads_ = std::max( 142   8 num_threads_ = std::max(
HITCBC 143   4 std::thread::hardware_concurrency(), 1u); 143   4 std::thread::hardware_concurrency(), 1u);
144   144  
145   // Truncate prefix to 12 chars, leaving room for up to 3-digit index. 145   // Truncate prefix to 12 chars, leaving room for up to 3-digit index.
HITCBC 146   1432 auto n = thread_name_prefix.copy(thread_name_prefix_, 12); 146   1446 auto n = thread_name_prefix.copy(thread_name_prefix_, 12);
HITCBC 147   1432 thread_name_prefix_[n] = '\0'; 147   1446 thread_name_prefix_[n] = '\0';
HITCBC 148   1432 } 148   1446 }
149   149  
150   void 150   void
HITCBC 151   22213 post(continuation& c) 151   22160 post(continuation& c)
152   { 152   {
HITCBC 153   22213 if(!started_.load(std::memory_order_acquire)) 153   22160 if(!started_.load(std::memory_order_acquire))
154   { 154   {
155   { 155   {
HITCBC 156   597 std::lock_guard<std::mutex> lock(mutex_); 156   611 std::lock_guard<std::mutex> lock(mutex_);
HITCBC 157   597 if(stop_) 157   611 if(stop_)
158   { 158   {
159   // Stopped before any thread started: nothing will 159   // Stopped before any thread started: nothing will
160   // run it, and the destructor's drain abandons it. 160   // run it, and the destructor's drain abandons it.
HITCBC 161   220 push(&c); 161   220 push(&c);
HITCBC 162   220 return; 162   220 return;
163   } 163   }
HITCBC 164   597 } 164   611 }
HITCBC 165   377 ensure_started(); 165   391 ensure_started();
166   } 166   }
HITCBC 167   21991 std::lock_guard<std::mutex> lock(mutex_); 167   21938 std::lock_guard<std::mutex> lock(mutex_);
HITCBC 168   21991 push(&c); 168   21938 push(&c);
169   // Under the lock so the pool cannot drain, join, and 169   // Under the lock so the pool cannot drain, join, and
170   // destroy the condition variable mid-signal. 170   // destroy the condition variable mid-signal.
HITCBC 171   21991 work_cv_.notify_one(); 171   21938 work_cv_.notify_one();
HITCBC 172   21991 } 172   21938 }
173   173  
174   void 174   void
HITCBC 175   4090 on_work_started() noexcept 175   4104 on_work_started() noexcept
176   { 176   {
HITCBC 177   4090 outstanding_work_.fetch_add(1, std::memory_order_acq_rel); 177   4104 outstanding_work_.fetch_add(1, std::memory_order_acq_rel);
HITCBC 178   4090 } 178   4104 }
179   179  
180   void 180   void
HITCBC 181   3790 on_work_finished() noexcept 181   3804 on_work_finished() noexcept
182   { 182   {
HITCBC 183   3790 auto n = outstanding_work_.load(std::memory_order_relaxed); 183   3804 auto n = outstanding_work_.load(std::memory_order_relaxed);
HITCBC 184   3799 while(n > 1) 184   3813 while(n > 1)
185   { 185   {
HITCBC 186   2338 if(outstanding_work_.compare_exchange_weak( 186   2342 if(outstanding_work_.compare_exchange_weak(
187   n, n - 1, std::memory_order_acq_rel)) 187   n, n - 1, std::memory_order_acq_rel))
HITCBC 188   1160 return; 188   1162 return;
189   } 189   }
HITCBC 190   2630 std::lock_guard<std::mutex> lock(mutex_); 190   2642 std::lock_guard<std::mutex> lock(mutex_);
HITCBC 191   2630 outstanding_work_.fetch_sub(1, std::memory_order_acq_rel); 191   2642 outstanding_work_.fetch_sub(1, std::memory_order_acq_rel);
192   // Re-read: a concurrent on_work_started() may have raised it. 192   // Re-read: a concurrent on_work_started() may have raised it.
HITCBC 193   2630 if(outstanding_work_.load( 193   2642 if(outstanding_work_.load(
HITCBC 194   2630 std::memory_order_acquire) == 0 && joined_ && !stop_) 194   2642 std::memory_order_acquire) == 0 && joined_ && !stop_)
195   { 195   {
HITCBC 196   701 stop_ = true; 196   705 stop_ = true;
HITCBC 197   701 done_cv_.notify_all(); 197   705 done_cv_.notify_all();
HITCBC 198   701 work_cv_.notify_all(); 198   705 work_cv_.notify_all();
199   } 199   }
HITCBC 200   2630 } 200   2642 }
201   201  
202   void 202   void
HITCBC 203   2725 join() noexcept 203   2753 join() noexcept
204   { 204   {
205   { 205   {
HITCBC 206   2725 std::unique_lock<std::mutex> lock(mutex_); 206   2753 std::unique_lock<std::mutex> lock(mutex_);
HITCBC 207   2725 if(joined_) 207   2753 if(joined_)
HITCBC 208   1293 return; 208   1307 return;
HITCBC 209   1432 joined_ = true; 209   1446 joined_ = true;
210   210  
HITCBC 211   1432 if(outstanding_work_.load( 211   1446 if(outstanding_work_.load(
HITCBC 212   1432 std::memory_order_acquire) == 0) 212   1446 std::memory_order_acquire) == 0)
213   { 213   {
HITCBC 214   375 stop_ = true; 214   385 stop_ = true;
HITCBC 215   375 work_cv_.notify_all(); 215   385 work_cv_.notify_all();
216   } 216   }
217   else 217   else
218   { 218   {
HITCBC 219   1057 done_cv_.wait(lock, [this]{ 219   1061 done_cv_.wait(lock, [this]{
HITCBC 220   2059 return stop_; 220   2067 return stop_;
221   }); 221   });
222   } 222   }
HITCBC 223   2725 } 223   2753 }
224   224  
HITCBC 225   1931 for(auto& t : threads_) 225   1959 for(auto& t : threads_)
HITCBC 226   499 if(t.joinable()) 226   513 if(t.joinable())
HITCBC 227   499 t.join(); 227   513 t.join();
228   } 228   }
229   229  
230   void 230   void
HITCBC 231   1735 stop() noexcept 231   1749 stop() noexcept
232   { 232   {
233   // Under the lock: the join() this releases may return and let 233   // Under the lock: the join() this releases may return and let
234   // the pool be destroyed as soon as the lock is free. 234   // the pool be destroyed as soon as the lock is free.
HITCBC 235   1735 std::lock_guard<std::mutex> lock(mutex_); 235   1749 std::lock_guard<std::mutex> lock(mutex_);
HITCBC 236   1735 stop_ = true; 236   1749 stop_ = true;
HITCBC 237   1735 work_cv_.notify_all(); 237   1749 work_cv_.notify_all();
HITCBC 238   1735 done_cv_.notify_all(); 238   1749 done_cv_.notify_all();
HITCBC 239   1735 } 239   1749 }
240   240  
241   private: 241   private:
242   void 242   void
HITCBC 243   377 ensure_started() 243   391 ensure_started()
244   { 244   {
245   // Under the lock, so join() either sees every thread started 245   // Under the lock, so join() either sees every thread started
246   // here or makes this start none. A joined pool still starts them: 246   // here or makes this start none. A joined pool still starts them:
247   // join() may be waiting on work that needs them. 247   // join() may be waiting on work that needs them.
HITCBC 248   377 std::lock_guard<std::mutex> lock(mutex_); 248   391 std::lock_guard<std::mutex> lock(mutex_);
HITCBC 249   377 if(started_.load(std::memory_order_relaxed) || stop_) 249   391 if(started_.load(std::memory_order_relaxed) || stop_)
MISUBC 250   ✗ return; 250   ✗ return;
251   // Start at the threads already running: if an earlier call 251   // Start at the threads already running: if an earlier call
252   // threw partway, this one adds only the missing ones. 252   // threw partway, this one adds only the missing ones.
HITCBC 253   377 threads_.reserve(num_threads_); 253   391 threads_.reserve(num_threads_);
HITCBC 254   876 for(std::size_t i = threads_.size(); i < num_threads_; ++i) 254   904 for(std::size_t i = threads_.size(); i < num_threads_; ++i)
HITCBC 255   1000 threads_.emplace_back([this, i]{ run(i); }); 255   1028 threads_.emplace_back([this, i]{ run(i); });
HITCBC 256   375 started_.store(true, std::memory_order_release); 256   389 started_.store(true, std::memory_order_release);
HITCBC 257   377 } 257   391 }
258   258  
259   void 259   void
HITCBC 260   499 run(std::size_t index) 260   513 run(std::size_t index)
261   { 261   {
262   // Build name; set_current_thread_name truncates to platform limits. 262   // Build name; set_current_thread_name truncates to platform limits.
263   char name[16]; 263   char name[16];
HITCBC 264   499 std::snprintf(name, sizeof(name), "%s%zu", thread_name_prefix_, index); 264   513 std::snprintf(name, sizeof(name), "%s%zu", thread_name_prefix_, index);
HITCBC 265   499 set_current_thread_name(name); 265   513 set_current_thread_name(name);
266   266  
267   // Mark this thread as a worker of this pool so dispatch() 267   // Mark this thread as a worker of this pool so dispatch()
268   // can symmetric-transfer when called from within pool work. 268   // can symmetric-transfer when called from within pool work.
269   struct scoped_pool 269   struct scoped_pool
270   { 270   {
HITCBC 271   499 scoped_pool(impl const* p) noexcept { current_.set(p); } 271   513 scoped_pool(impl const* p) noexcept { current_.set(p); }
HITCBC 272   499 ~scoped_pool() noexcept { current_.set(nullptr); } 272   513 ~scoped_pool() noexcept { current_.set(nullptr); }
HITCBC 273   499 } guard(this); 273   513 } guard(this);
274   274  
275   for(;;) 275   for(;;)
276   { 276   {
HITCBC 277   22127 continuation* c = nullptr; 277   22148 continuation* c = nullptr;
278   { 278   {
HITCBC 279   22127 std::unique_lock<std::mutex> lock(mutex_); 279   22148 std::unique_lock<std::mutex> lock(mutex_);
HITCBC 280   22127 work_cv_.wait(lock, [this]{ 280   22148 work_cv_.wait(lock, [this]{
HITCBC 281   54945 return !empty() || 281   62890 return !empty() ||
HITCBC 282   54945 stop_; 282   62890 stop_;
283   }); 283   });
HITCBC 284   22127 if(stop_) 284   22148 if(stop_)
HITCBC 285   998 return; 285   1026 return;
HITCBC 286   21628 c = pop(); 286   21635 c = pop();
HITCBC 287   22127 } 287   22148 }
HITCBC 288   21628 if(c) 288   21635 if(c)
HITCBC 289   21628 safe_resume(c->h); 289   21635 safe_resume(c->h);
HITCBC 290   21628 } 290   21635 }
HITCBC 291   499 } 291   513 }
292   }; 292   };
293   293  
294   //------------------------------------------------------------------------------ 294   //------------------------------------------------------------------------------
295   295  
HITCBC 296   1432 thread_pool:: 296   1446 thread_pool::
297   ~thread_pool() 297   ~thread_pool()
298   { 298   {
HITCBC 299   1432 impl_->stop(); 299   1446 impl_->stop();
HITCBC 300   1432 impl_->join(); 300   1446 impl_->join();
HITCBC 301   1432 shutdown(); 301   1446 shutdown();
302   // Takes what the unwinds post too, and the work of any service they 302   // Takes what the unwinds post too, and the work of any service they
303   // create, which is shut down as it is created. 303   // create, which is shut down as it is created.
HITCBC 304   1432 impl_->drain_abandoned(); 304   1446 impl_->drain_abandoned();
HITCBC 305   1432 destroy(); 305   1446 destroy();
306   // Services give up their work in shutdown(), but anything a 306   // Services give up their work in shutdown(), but anything a
307   // destructor posts anyway is still destroyed. 307   // destructor posts anyway is still destroyed.
HITCBC 308   1432 impl_->drain_abandoned(); 308   1446 impl_->drain_abandoned();
HITCBC 309   1432 delete impl_; 309   1446 delete impl_;
HITCBC 310   1432 } 310   1446 }
311   311  
HITCBC 312   1432 thread_pool:: 312   1446 thread_pool::
HITCBC 313   1432 thread_pool(std::size_t num_threads, std::string_view thread_name_prefix) 313   1446 thread_pool(std::size_t num_threads, std::string_view thread_name_prefix)
HITCBC 314   1432 : impl_(new impl(num_threads, thread_name_prefix)) 314   1446 : impl_(new impl(num_threads, thread_name_prefix))
315   { 315   {
HITCBC 316   1432 this->set_frame_allocator(std::allocator<void>{}); 316   1446 this->set_frame_allocator(std::allocator<void>{});
HITCBC 317   1432 } 317   1446 }
318   318  
319   void 319   void
HITCBC 320   1293 thread_pool:: 320   1307 thread_pool::
321   join() noexcept 321   join() noexcept
322   { 322   {
HITCBC 323   1293 impl_->join(); 323   1307 impl_->join();
HITCBC 324   1293 } 324   1307 }
325   325  
326   void 326   void
HITCBC 327   303 thread_pool:: 327   303 thread_pool::
328   stop() noexcept 328   stop() noexcept
329   { 329   {
HITCBC 330   303 impl_->stop(); 330   303 impl_->stop();
HITCBC 331   303 } 331   303 }
332   332  
333   //------------------------------------------------------------------------------ 333   //------------------------------------------------------------------------------
334   334  
335   thread_pool::executor_type 335   thread_pool::executor_type
HITCBC 336   15351 thread_pool:: 336   15365 thread_pool::
337   get_executor() const noexcept 337   get_executor() const noexcept
338   { 338   {
HITCBC 339   15351 return executor_type( 339   15365 return executor_type(
HITCBC 340   15351 const_cast<thread_pool&>(*this)); 340   15365 const_cast<thread_pool&>(*this));
341   } 341   }
342   342  
343   void 343   void
HITCBC 344   4090 thread_pool::executor_type:: 344   4104 thread_pool::executor_type::
345   on_work_started() const noexcept 345   on_work_started() const noexcept
346   { 346   {
HITCBC 347   4090 pool_->impl_->on_work_started(); 347   4104 pool_->impl_->on_work_started();
HITCBC 348   4090 } 348   4104 }
349   349  
350   void 350   void
HITCBC 351   3790 thread_pool::executor_type:: 351   3804 thread_pool::executor_type::
352   on_work_finished() const noexcept 352   on_work_finished() const noexcept
353   { 353   {
HITCBC 354   3790 pool_->impl_->on_work_finished(); 354   3804 pool_->impl_->on_work_finished();
HITCBC 355   3790 } 355   3804 }
356   356  
357   void 357   void
HITCBC 358   19007 thread_pool::executor_type:: 358   18940 thread_pool::executor_type::
359   post(continuation& c) const 359   post(continuation& c) const
360   { 360   {
HITCBC 361   19007 pool_->impl_->post(c); 361   18940 pool_->impl_->post(c);
HITCBC 362   19005 } 362   18938 }
363   363  
364   std::coroutine_handle<> 364   std::coroutine_handle<>
HITCBC 365   3210 thread_pool::executor_type:: 365   3224 thread_pool::executor_type::
366   dispatch(continuation& c) const 366   dispatch(continuation& c) const
367   { 367   {
HITCBC 368   3210 if(pool_->impl_->running_in_this_thread()) 368   3224 if(pool_->impl_->running_in_this_thread())
HITCBC 369   4 return c.h; 369   4 return c.h;
HITCBC 370   3206 pool_->impl_->post(c); 370   3220 pool_->impl_->post(c);
HITCBC 371   3206 return std::noop_coroutine(); 371   3220 return std::noop_coroutine();
372   } 372   }
373   373  
374   } // capy 374   } // capy
375   } // boost 375   } // boost