. /include/boost/corosio /detail /timer_service.hpp
97.05% Lines (230/237) 100.00% Functions (27/27)
[ ] prev/next file n p prev/next uncovered line
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 Steve Gerbino 3   // Copyright (c) 2026 Steve Gerbino
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/cppalliance/corosio 8   // Official repository: https://github.com/cppalliance/corosio
9   // 9   //
10   10  
11   #ifndef BOOST_COROSIO_DETAIL_TIMER_SERVICE_HPP 11   #ifndef BOOST_COROSIO_DETAIL_TIMER_SERVICE_HPP
12   #define BOOST_COROSIO_DETAIL_TIMER_SERVICE_HPP 12   #define BOOST_COROSIO_DETAIL_TIMER_SERVICE_HPP
13   13  
14   #include <boost/corosio/detail/timer.hpp> 14   #include <boost/corosio/detail/timer.hpp>
15   #include <boost/corosio/detail/scheduler.hpp> 15   #include <boost/corosio/detail/scheduler.hpp>
16   #include <boost/corosio/detail/scheduler_op.hpp> 16   #include <boost/corosio/detail/scheduler_op.hpp>
17   #include <boost/corosio/detail/intrusive.hpp> 17   #include <boost/corosio/detail/intrusive.hpp>
18   #include <boost/corosio/detail/thread_local_ptr.hpp> 18   #include <boost/corosio/detail/thread_local_ptr.hpp>
19   #include <boost/capy/error.hpp> 19   #include <boost/capy/error.hpp>
20   #include <boost/capy/ex/execution_context.hpp> 20   #include <boost/capy/ex/execution_context.hpp>
21   #include <boost/capy/ex/executor_ref.hpp> 21   #include <boost/capy/ex/executor_ref.hpp>
22   #include <system_error> 22   #include <system_error>
23   23  
24   #include <atomic> 24   #include <atomic>
25   #include <chrono> 25   #include <chrono>
26   #include <coroutine> 26   #include <coroutine>
27   #include <cstddef> 27   #include <cstddef>
28   #include <limits> 28   #include <limits>
29   #include <mutex> 29   #include <mutex>
30   #include <stop_token> 30   #include <stop_token>
31   #include <utility> 31   #include <utility>
32   #include <vector> 32   #include <vector>
33   33  
34   namespace boost::corosio::detail { 34   namespace boost::corosio::detail {
35   35  
36   struct scheduler; 36   struct scheduler;
37   37  
38   /* 38   /*
39   Timer Service 39   Timer Service
40   ============= 40   =============
41   41  
42   Data Structures 42   Data Structures
43   --------------- 43   ---------------
44   waiter_node (defined in timer.hpp) holds per-waiter state: 44   waiter_node (defined in timer.hpp) holds per-waiter state:
45   coroutine handle, executor, error output, embedded 45   coroutine handle, executor, error output, embedded
46   completion_op. Each concurrent co_await t.wait() embeds one 46   completion_op. Each concurrent co_await t.wait() embeds one
47   waiter_node in the awaitable on the suspended coroutine's 47   waiter_node in the awaitable on the suspended coroutine's
48   frame — waits perform no allocation. 48   frame — waits perform no allocation.
49   49  
50   timer::implementation holds per-timer state: expiry, heap 50   timer::implementation holds per-timer state: expiry, heap
51   index, and the single published waiter. Each timer holds 51   index, and the single published waiter. Each timer holds
52   at most one waiter; process_expired's local cross-timer drain 52   at most one waiter; process_expired's local cross-timer drain
53   list still threads waiters through their intrusive hooks when 53   list still threads waiters through their intrusive hooks when
54   collecting several timers' waiters past the lock. 54   collecting several timers' waiters past the lock.
55   55  
56   timer_service owns a min-heap of active timers and a free list 56   timer_service owns a min-heap of active timers and a free list
57   of recycled impls. The heap is ordered by expiry time; the 57   of recycled impls. The heap is ordered by expiry time; the
58   scheduler queries nearest_expiry() to set the epoll/timerfd 58   scheduler queries nearest_expiry() to set the epoll/timerfd
59   timeout. 59   timeout.
60   60  
61   Optimization Strategy 61   Optimization Strategy
62   --------------------- 62   ---------------------
63   1. Deferred heap insertion — expires_after() stores the expiry 63   1. Deferred heap insertion — expires_after() stores the expiry
64   but does not insert into the heap. Insertion happens in wait(). 64   but does not insert into the heap. Insertion happens in wait().
65   2. Thread-local impl cache — single-slot per-thread cache. 65   2. Thread-local impl cache — single-slot per-thread cache.
66   3. Frame-resident waiter_node with embedded completion_op — 66   3. Frame-resident waiter_node with embedded completion_op —
67   eliminates heap allocation per wait/fire/cancel. 67   eliminates heap allocation per wait/fire/cancel.
68   4. Cached nearest expiry — atomic avoids mutex in nearest_expiry(). 68   4. Cached nearest expiry — atomic avoids mutex in nearest_expiry().
69   5. might_have_pending_waits_ flag — skips lock when no wait issued. 69   5. might_have_pending_waits_ flag — skips lock when no wait issued.
70   70  
71   Concurrency 71   Concurrency
72   ----------- 72   -----------
73   stop_token callbacks can fire from any thread. The impl_ 73   stop_token callbacks can fire from any thread. The impl_
74   pointer on waiter_node is used as a "still in list" marker. 74   pointer on waiter_node is used as a "still in list" marker.
75   A waiter_node's storage is the suspended coroutine's frame: 75   A waiter_node's storage is the suspended coroutine's frame:
76   every completion path must finish touching the node before 76   every completion path must finish touching the node before
77   posting the continuation or destroying the handle. 77   posting the continuation or destroying the handle.
78   */ 78   */
79   79  
80   inline void timer_service_invalidate_cache() noexcept; 80   inline void timer_service_invalidate_cache() noexcept;
81   81  
82   // timer_service class body — member function definitions are 82   // timer_service class body — member function definitions are
83   // out-of-class (after implementation and waiter_node are complete) 83   // out-of-class (after implementation and waiter_node are complete)
84   class BOOST_COROSIO_DECL timer_service final 84   class BOOST_COROSIO_DECL timer_service final
85   : public capy::execution_context::service 85   : public capy::execution_context::service
86   , public io_object::io_service 86   , public io_object::io_service
87   { 87   {
88   public: 88   public:
89   using clock_type = std::chrono::steady_clock; 89   using clock_type = std::chrono::steady_clock;
90   using time_point = clock_type::time_point; 90   using time_point = clock_type::time_point;
91   91  
92   /// Type-erased callback for earliest-expiry-changed notifications. 92   /// Type-erased callback for earliest-expiry-changed notifications.
93   class callback 93   class callback
94   { 94   {
95   void* ctx_ = nullptr; 95   void* ctx_ = nullptr;
96   void (*fn_)(void*) = nullptr; 96   void (*fn_)(void*) = nullptr;
97   97  
98   public: 98   public:
99   /// Construct an empty callback. 99   /// Construct an empty callback.
HITCBC 100   2106 callback() = default; 100   2106 callback() = default;
101   101  
102   /// Construct a callback with the given context and function. 102   /// Construct a callback with the given context and function.
HITCBC 103   2106 callback(void* ctx, void (*fn)(void*)) noexcept : ctx_(ctx), fn_(fn) {} 103   2106 callback(void* ctx, void (*fn)(void*)) noexcept : ctx_(ctx), fn_(fn) {}
104   104  
105   /// Return true if the callback is non-empty. 105   /// Return true if the callback is non-empty.
106   explicit operator bool() const noexcept 106   explicit operator bool() const noexcept
107   { 107   {
108   return fn_ != nullptr; 108   return fn_ != nullptr;
109   } 109   }
110   110  
111   /// Invoke the callback. 111   /// Invoke the callback.
HITCBC 112   6862 void operator()() const 112   6806 void operator()() const
113   { 113   {
HITCBC 114   6862 if (fn_) 114   6806 if (fn_)
HITCBC 115   6862 fn_(ctx_); 115   6806 fn_(ctx_);
HITCBC 116   6862 } 116   6806 }
117   }; 117   };
118   118  
119   private: 119   private:
120   struct heap_entry 120   struct heap_entry
121   { 121   {
122   time_point time_; 122   time_point time_;
123   timer::implementation* timer_; 123   timer::implementation* timer_;
124   }; 124   };
125   125  
126   scheduler* sched_ = nullptr; 126   scheduler* sched_ = nullptr;
127   BOOST_COROSIO_MSVC_WARNING_PUSH 127   BOOST_COROSIO_MSVC_WARNING_PUSH
128   BOOST_COROSIO_MSVC_WARNING_DISABLE(4251) // std:: members, dll-interface 128   BOOST_COROSIO_MSVC_WARNING_DISABLE(4251) // std:: members, dll-interface
129   mutable std::mutex mutex_; 129   mutable std::mutex mutex_;
130   std::vector<heap_entry> heap_; 130   std::vector<heap_entry> heap_;
131   timer::implementation* free_list_ = nullptr; 131   timer::implementation* free_list_ = nullptr;
132   callback on_earliest_changed_; 132   callback on_earliest_changed_;
133   bool shutting_down_ = false; 133   bool shutting_down_ = false;
134   // Avoids mutex in nearest_expiry() and empty() 134   // Avoids mutex in nearest_expiry() and empty()
135   mutable std::atomic<std::int64_t> cached_nearest_ns_{ 135   mutable std::atomic<std::int64_t> cached_nearest_ns_{
136   (std::numeric_limits<std::int64_t>::max)()}; 136   (std::numeric_limits<std::int64_t>::max)()};
137   BOOST_COROSIO_MSVC_WARNING_POP 137   BOOST_COROSIO_MSVC_WARNING_POP
138   138  
139   public: 139   public:
140   /// Construct the timer service bound to a scheduler. 140   /// Construct the timer service bound to a scheduler.
HITCBC 141   2106 inline timer_service(capy::execution_context&, scheduler& sched) 141   2106 inline timer_service(capy::execution_context&, scheduler& sched)
HITCBC 142   2106 : sched_(&sched) 142   2106 : sched_(&sched)
143   { 143   {
HITCBC 144   2106 } 144   2106 }
145   145  
146   /// Return the associated scheduler. 146   /// Return the associated scheduler.
HITCBC 147   28571 inline scheduler& get_scheduler() noexcept 147   28803 inline scheduler& get_scheduler() noexcept
148   { 148   {
HITCBC 149   28571 return *sched_; 149   28803 return *sched_;
150   } 150   }
151   151  
152   /// Destroy the timer service. 152   /// Destroy the timer service.
HITCBC 153   4212 ~timer_service() override = default; 153   4212 ~timer_service() override = default;
154   154  
155   timer_service(timer_service const&) = delete; 155   timer_service(timer_service const&) = delete;
156   timer_service& operator=(timer_service const&) = delete; 156   timer_service& operator=(timer_service const&) = delete;
157   157  
158   /// Register a callback invoked when the earliest expiry changes. 158   /// Register a callback invoked when the earliest expiry changes.
HITCBC 159   2106 inline void set_on_earliest_changed(callback cb) 159   2106 inline void set_on_earliest_changed(callback cb)
160   { 160   {
HITCBC 161   2106 on_earliest_changed_ = cb; 161   2106 on_earliest_changed_ = cb;
HITCBC 162   2106 } 162   2106 }
163   163  
164   /// Return true if no timers are in the heap. 164   /// Return true if no timers are in the heap.
165   inline bool empty() const noexcept 165   inline bool empty() const noexcept
166   { 166   {
167   return cached_nearest_ns_.load(std::memory_order_acquire) == 167   return cached_nearest_ns_.load(std::memory_order_acquire) ==
168   (std::numeric_limits<std::int64_t>::max)(); 168   (std::numeric_limits<std::int64_t>::max)();
169   } 169   }
170   170  
171   /// Return the nearest timer expiry without acquiring the mutex. 171   /// Return the nearest timer expiry without acquiring the mutex.
HITCBC 172   292490 inline time_point nearest_expiry() const noexcept 172   303252 inline time_point nearest_expiry() const noexcept
173   { 173   {
HITCBC 174   292490 auto ns = cached_nearest_ns_.load(std::memory_order_acquire); 174   303252 auto ns = cached_nearest_ns_.load(std::memory_order_acquire);
HITCBC 175   292490 return time_point(time_point::duration(ns)); 175   303252 return time_point(time_point::duration(ns));
176   } 176   }
177   177  
178   /// Cancel all pending timers and free cached resources. 178   /// Cancel all pending timers and free cached resources.
179   inline void shutdown() override; 179   inline void shutdown() override;
180   180  
181   /// Construct a new timer implementation. 181   /// Construct a new timer implementation.
182   inline io_object::implementation* construct() override; 182   inline io_object::implementation* construct() override;
183   183  
184   /// Destroy a timer implementation, cancelling pending waiters. 184   /// Destroy a timer implementation, cancelling pending waiters.
185   inline void destroy(io_object::implementation* p) override; 185   inline void destroy(io_object::implementation* p) override;
186   186  
187   /// Cancel and recycle a timer implementation. 187   /// Cancel and recycle a timer implementation.
188   inline void destroy_impl(timer::implementation& impl); 188   inline void destroy_impl(timer::implementation& impl);
189   189  
190   /// Publish the timer's waiter and insert the timer into the heap. 190   /// Publish the timer's waiter and insert the timer into the heap.
191   inline void insert_waiter(timer::implementation& impl, waiter_node* w); 191   inline void insert_waiter(timer::implementation& impl, waiter_node* w);
192   192  
193   /// Cancel the timer's published waiter, if any. 193   /// Cancel the timer's published waiter, if any.
194   inline void cancel_timer(timer::implementation& impl); 194   inline void cancel_timer(timer::implementation& impl);
195   195  
196   /// Cancel one specific waiter ( stop_token callback path ). 196   /// Cancel one specific waiter ( stop_token callback path ).
197   inline void cancel_waiter(waiter_node* w); 197   inline void cancel_waiter(waiter_node* w);
198   198  
199   /// Complete all waiters whose timers have expired. 199   /// Complete all waiters whose timers have expired.
200   inline std::size_t process_expired(); 200   inline std::size_t process_expired();
201   201  
202   private: 202   private:
HITCBC 203   333883 inline void refresh_cached_nearest() noexcept 203   342917 inline void refresh_cached_nearest() noexcept
204   { 204   {
HITCBC 205   333883 auto ns = heap_.empty() ? (std::numeric_limits<std::int64_t>::max)() 205   342917 auto ns = heap_.empty() ? (std::numeric_limits<std::int64_t>::max)()
HITCBC 206   329184 : heap_[0].time_.time_since_epoch().count(); 206   338292 : heap_[0].time_.time_since_epoch().count();
HITCBC 207   333883 cached_nearest_ns_.store(ns, std::memory_order_release); 207   342917 cached_nearest_ns_.store(ns, std::memory_order_release);
HITCBC 208   333883 } 208   342917 }
209   209  
210   inline void remove_timer_impl(timer::implementation& impl); 210   inline void remove_timer_impl(timer::implementation& impl);
211   inline void up_heap(std::size_t index); 211   inline void up_heap(std::size_t index);
212   inline void down_heap(std::size_t index); 212   inline void down_heap(std::size_t index);
213   inline void swap_heap(std::size_t i1, std::size_t i2); 213   inline void swap_heap(std::size_t i1, std::size_t i2);
214   }; 214   };
215   215  
216   // Thread-local cache avoids hot-path mutex acquisitions: 216   // Thread-local cache avoids hot-path mutex acquisitions:
217   // single-slot impl cache, validated by comparing svc_. Cleared by 217   // single-slot impl cache, validated by comparing svc_. Cleared by
218   // timer_service_invalidate_cache() during shutdown. 218   // timer_service_invalidate_cache() during shutdown.
219   219  
220   inline thread_local_ptr<timer::implementation> tl_cached_impl; 220   inline thread_local_ptr<timer::implementation> tl_cached_impl;
221   221  
222   // The POD TLS slot above never runs destructors, so a short-lived 222   // The POD TLS slot above never runs destructors, so a short-lived
223   // run() thread would leak its cached impl. Each push arms this 223   // run() thread would leak its cached impl. Each push arms this
224   // owner, whose destructor frees the slot at thread exit. A cached 224   // owner, whose destructor frees the slot at thread exit. A cached
225   // entry is a quiescent heap object (nothing in the heap or free 225   // entry is a quiescent heap object (nothing in the heap or free
226   // list) and deletion touches no service state, so it is safe after 226   // list) and deletion touches no service state, so it is safe after
227   // the owning service is gone (the stale-entry path in 227   // the owning service is gone (the stale-entry path in
228   // try_pop_tl_cache deletes the same way). 228   // try_pop_tl_cache deletes the same way).
229   struct tl_cache_owner 229   struct tl_cache_owner
230   { 230   {
HITCBC 231   44 ~tl_cache_owner() 231   45 ~tl_cache_owner()
232   { 232   {
HITCBC 233   44 delete tl_cached_impl.get(); 233   45 delete tl_cached_impl.get();
HITCBC 234   44 tl_cached_impl.set(nullptr); 234   45 tl_cached_impl.set(nullptr);
HITCBC 235   44 } 235   45 }
236   }; 236   };
237   237  
238   inline void 238   inline void
HITCBC 239   13774 arm_tl_cache_cleanup() noexcept 239   13768 arm_tl_cache_cleanup() noexcept
240   { 240   {
HITCBC 241   13774 [[maybe_unused]] thread_local tl_cache_owner owner; 241   13768 [[maybe_unused]] thread_local tl_cache_owner owner;
HITCBC 242   13774 } 242   13768 }
243   243  
244   inline timer::implementation* 244   inline timer::implementation*
HITCBC 245   15153 try_pop_tl_cache(timer_service* svc) noexcept 245   15270 try_pop_tl_cache(timer_service* svc) noexcept
246   { 246   {
HITCBC 247   15153 auto* impl = tl_cached_impl.get(); 247   15270 auto* impl = tl_cached_impl.get();
HITCBC 248   15153 if (impl) 248   15270 if (impl)
249   { 249   {
HITCBC 250   13369 tl_cached_impl.set(nullptr); 250   13362 tl_cached_impl.set(nullptr);
HITCBC 251   13369 if (impl->svc_ == svc) 251   13362 if (impl->svc_ == svc)
HITCBC 252   13369 return impl; 252   13362 return impl;
253   // Stale impl from a destroyed service 253   // Stale impl from a destroyed service
MISUBC 254   ✗ delete impl; 254   ✗ delete impl;
255   } 255   }
HITCBC 256   1784 return nullptr; 256   1908 return nullptr;
257   } 257   }
258   258  
259   inline bool 259   inline bool
HITCBC 260   15124 try_push_tl_cache(timer::implementation* impl) noexcept 260   15241 try_push_tl_cache(timer::implementation* impl) noexcept
261   { 261   {
HITCBC 262   15124 if (!tl_cached_impl.get()) 262   15241 if (!tl_cached_impl.get())
263   { 263   {
HITCBC 264   13774 arm_tl_cache_cleanup(); 264   13768 arm_tl_cache_cleanup();
HITCBC 265   13774 tl_cached_impl.set(impl); 265   13768 tl_cached_impl.set(impl);
HITCBC 266   13774 return true; 266   13768 return true;
267   } 267   }
HITCBC 268   1350 return false; 268   1473 return false;
269   } 269   }
270   270  
271   inline void 271   inline void
HITCBC 272   2106 timer_service_invalidate_cache() noexcept 272   2106 timer_service_invalidate_cache() noexcept
273   { 273   {
HITCBC 274   2106 delete tl_cached_impl.get(); 274   2106 delete tl_cached_impl.get();
HITCBC 275   2106 tl_cached_impl.set(nullptr); 275   2106 tl_cached_impl.set(nullptr);
HITCBC 276   2106 } 276   2106 }
277   277  
278   // timer_service out-of-class member function definitions 278   // timer_service out-of-class member function definitions
279   279  
280   inline void 280   inline void
HITCBC 281   2106 timer_service::shutdown() 281   2106 timer_service::shutdown()
282   { 282   {
HITCBC 283   2106 timer_service_invalidate_cache(); 283   2106 timer_service_invalidate_cache();
HITCBC 284   2106 shutting_down_ = true; 284   2106 shutting_down_ = true;
285   285  
286   // Snapshot impls and detach them from the heap so that 286   // Snapshot impls and detach them from the heap so that
287   // coroutine-owned timer destructors (triggered by h.destroy() 287   // coroutine-owned timer destructors (triggered by h.destroy()
288   // below) cannot re-enter remove_timer_impl() and mutate the 288   // below) cannot re-enter remove_timer_impl() and mutate the
289   // vector during iteration. 289   // vector during iteration.
HITCBC 290   2106 std::vector<timer::implementation*> impls; 290   2106 std::vector<timer::implementation*> impls;
HITCBC 291   2106 impls.reserve(heap_.size()); 291   2106 impls.reserve(heap_.size());
HITCBC 292   2135 for (auto& entry : heap_) 292   2135 for (auto& entry : heap_)
293   { 293   {
HITCBC 294   29 entry.timer_->heap_index_.store( 294   29 entry.timer_->heap_index_.store(
295   (std::numeric_limits<std::size_t>::max)(), 295   (std::numeric_limits<std::size_t>::max)(),
296   std::memory_order_relaxed); 296   std::memory_order_relaxed);
HITCBC 297   29 impls.push_back(entry.timer_); 297   29 impls.push_back(entry.timer_);
298   } 298   }
HITCBC 299   2106 heap_.clear(); 299   2106 heap_.clear();
HITCBC 300   2106 cached_nearest_ns_.store( 300   2106 cached_nearest_ns_.store(
301   (std::numeric_limits<std::int64_t>::max)(), std::memory_order_release); 301   (std::numeric_limits<std::int64_t>::max)(), std::memory_order_release);
302   302  
303   // Cancel waiting timers. Each waiter called work_started() 303   // Cancel waiting timers. Each waiter called work_started()
304   // in implementation::wait(). On IOCP the scheduler shutdown 304   // in implementation::wait(). On IOCP the scheduler shutdown
305   // loop exits when outstanding_work_ reaches zero, so we must 305   // loop exits when outstanding_work_ reaches zero, so we must
306   // call work_finished() here to balance it. On other backends 306   // call work_finished() here to balance it. On other backends
307   // this is harmless. 307   // this is harmless.
HITCBC 308   2135 for (auto* impl : impls) 308   2135 for (auto* impl : impls)
309   { 309   {
HITCBC 310   29 if (auto* w = std::exchange(impl->waiter_, nullptr)) 310   29 if (auto* w = std::exchange(impl->waiter_, nullptr))
311   { 311   {
HITCBC 312   29 w->reset_stop_cb(); 312   29 w->reset_stop_cb();
HITCBC 313   29 auto h = std::exchange(w->h_, {}); 313   29 auto h = std::exchange(w->h_, {});
HITCBC 314   29 sched_->work_finished(); 314   29 sched_->work_finished();
315   // Destroying the frame also ends the node's storage 315   // Destroying the frame also ends the node's storage
HITCBC 316   29 if (h) 316   29 if (h)
HITCBC 317   29 h.destroy(); 317   29 h.destroy();
318   } 318   }
HITCBC 319   29 delete impl; 319   29 delete impl;
320   } 320   }
321   321  
322   // Delete free-listed impls 322   // Delete free-listed impls
HITCBC 323   3454 while (free_list_) 323   3577 while (free_list_)
324   { 324   {
HITCBC 325   1348 auto* next = free_list_->next_free_; 325   1471 auto* next = free_list_->next_free_;
HITCBC 326   1348 delete free_list_; 326   1471 delete free_list_;
HITCBC 327   1348 free_list_ = next; 327   1471 free_list_ = next;
328   } 328   }
HITCBC 329   2106 } 329   2106 }
330   330  
331   inline io_object::implementation* 331   inline io_object::implementation*
HITCBC 332   15153 timer_service::construct() 332   15270 timer_service::construct()
333   { 333   {
HITCBC 334   15153 timer::implementation* impl = try_pop_tl_cache(this); 334   15270 timer::implementation* impl = try_pop_tl_cache(this);
HITCBC 335   15153 if (impl) 335   15270 if (impl)
336   { 336   {
HITCBC 337   13369 impl->svc_ = this; 337   13362 impl->svc_ = this;
338   // Reset expiry_ too: a recycled impl must behave like a fresh 338   // Reset expiry_ too: a recycled impl must behave like a fresh
339   // one, whose default expiry reads as already elapsed 339   // one, whose default expiry reads as already elapsed
HITCBC 340   13369 impl->expiry_ = {}; 340   13362 impl->expiry_ = {};
HITCBC 341   13369 impl->heap_index_.store( 341   13362 impl->heap_index_.store(
342   (std::numeric_limits<std::size_t>::max)(), 342   (std::numeric_limits<std::size_t>::max)(),
343   std::memory_order_relaxed); 343   std::memory_order_relaxed);
HITCBC 344   13369 impl->might_have_pending_waits_.store(false, std::memory_order_relaxed); 344   13362 impl->might_have_pending_waits_.store(false, std::memory_order_relaxed);
HITCBC 345   13369 BOOST_COROSIO_ASSERT(impl->waiter_ == nullptr); 345   13362 BOOST_COROSIO_ASSERT(impl->waiter_ == nullptr);
HITCBC 346   13369 return impl; 346   13362 return impl;
347   } 347   }
348   348  
HITCBC 349   1784 std::lock_guard lock(mutex_); 349   1908 std::lock_guard lock(mutex_);
HITCBC 350   1784 if (free_list_) 350   1908 if (free_list_)
351   { 351   {
HITCBC 352   2 impl = free_list_; 352   2 impl = free_list_;
HITCBC 353   2 free_list_ = impl->next_free_; 353   2 free_list_ = impl->next_free_;
HITCBC 354   2 impl->next_free_ = nullptr; 354   2 impl->next_free_ = nullptr;
HITCBC 355   2 impl->svc_ = this; 355   2 impl->svc_ = this;
HITCBC 356   2 impl->expiry_ = {}; 356   2 impl->expiry_ = {};
HITCBC 357   2 impl->heap_index_.store( 357   2 impl->heap_index_.store(
358   (std::numeric_limits<std::size_t>::max)(), 358   (std::numeric_limits<std::size_t>::max)(),
359   std::memory_order_relaxed); 359   std::memory_order_relaxed);
HITCBC 360   2 impl->might_have_pending_waits_.store(false, std::memory_order_relaxed); 360   2 impl->might_have_pending_waits_.store(false, std::memory_order_relaxed);
HITCBC 361   2 BOOST_COROSIO_ASSERT(impl->waiter_ == nullptr); 361   2 BOOST_COROSIO_ASSERT(impl->waiter_ == nullptr);
362   } 362   }
363   else 363   else
364   { 364   {
HITCBC 365   1782 impl = new timer::implementation(*this); 365   1906 impl = new timer::implementation(*this);
366   } 366   }
HITCBC 367   1784 return impl; 367   1908 return impl;
HITCBC 368   1784 } 368   1908 }
369   369  
370   inline void 370   inline void
HITCBC 371   15153 timer_service::destroy(io_object::implementation* p) 371   15270 timer_service::destroy(io_object::implementation* p)
372   { 372   {
373   // During shutdown the drain loop owns every impl and deletes 373   // During shutdown the drain loop owns every impl and deletes
374   // them directly. A frame destroyed by that loop can unwind a 374   // them directly. A frame destroyed by that loop can unwind a
375   // handle whose impl was freed in an earlier iteration (a 375   // handle whose impl was freed in an earlier iteration (a
376   // timeout's parent frame owns the timeout timer while 376   // timeout's parent frame owns the timeout timer while
377   // suspended on the inner delay's timer), so bail out before 377   // suspended on the inner delay's timer), so bail out before
378   // even downcasting the pointer. 378   // even downcasting the pointer.
HITCBC 379   15153 if (shutting_down_) 379   15270 if (shutting_down_)
HITCBC 380   29 return; 380   29 return;
HITCBC 381   15124 destroy_impl(static_cast<timer::implementation&>(*p)); 381   15241 destroy_impl(static_cast<timer::implementation&>(*p));
382   } 382   }
383   383  
384   inline void 384   inline void
HITCBC 385   15124 timer_service::destroy_impl(timer::implementation& impl) 385   15241 timer_service::destroy_impl(timer::implementation& impl)
386   { 386   {
387   // During shutdown the impl is owned by the shutdown loop. 387   // During shutdown the impl is owned by the shutdown loop.
388   // Re-entering here (from a coroutine-owned timer destructor 388   // Re-entering here (from a coroutine-owned timer destructor
389   // triggered by h.destroy()) must not modify the heap or 389   // triggered by h.destroy()) must not modify the heap or
390   // recycle the impl — shutdown deletes it directly. 390   // recycle the impl — shutdown deletes it directly.
HITCBC 391   15124 if (shutting_down_) 391   15241 if (shutting_down_)
HITCBC 392   13774 return; 392   13768 return;
393   393  
HITCBC 394   15124 cancel_timer(impl); 394   15241 cancel_timer(impl);
395   395  
HITCBC 396   30248 if (impl.heap_index_.load(std::memory_order_relaxed) != 396   30482 if (impl.heap_index_.load(std::memory_order_relaxed) !=
HITCBC 397   15124 (std::numeric_limits<std::size_t>::max)()) 397   15241 (std::numeric_limits<std::size_t>::max)())
398   { 398   {
MISUBC 399   ✗ std::lock_guard lock(mutex_); 399   ✗ std::lock_guard lock(mutex_);
MISUBC 400   ✗ remove_timer_impl(impl); 400   ✗ remove_timer_impl(impl);
MISUBC 401   ✗ refresh_cached_nearest(); 401   ✗ refresh_cached_nearest();
MISUBC 402   ✗ } 402   ✗ }
403   403  
HITCBC 404   15124 if (try_push_tl_cache(&impl)) 404   15241 if (try_push_tl_cache(&impl))
HITCBC 405   13774 return; 405   13768 return;
406   406  
HITCBC 407   1350 std::lock_guard lock(mutex_); 407   1473 std::lock_guard lock(mutex_);
HITCBC 408   1350 impl.next_free_ = free_list_; 408   1473 impl.next_free_ = free_list_;
HITCBC 409   1350 free_list_ = &impl; 409   1473 free_list_ = &impl;
HITCBC 410   1350 } 410   1473 }
411   411  
412   inline void 412   inline void
HITCBC 413   18548 timer_service::insert_waiter(timer::implementation& impl, waiter_node* w) 413   18495 timer_service::insert_waiter(timer::implementation& impl, waiter_node* w)
414   { 414   {
HITCBC 415   18548 bool notify = false; 415   18495 bool notify = false;
HITCBC 416   18548 bool lost_cancel = false; 416   18495 bool lost_cancel = false;
417   { 417   {
HITCBC 418   18548 std::lock_guard lock(mutex_); 418   18495 std::lock_guard lock(mutex_);
419   // Grow before publishing anything, so the push_back below 419   // Grow before publishing anything, so the push_back below
420   // cannot throw: a failure here leaves the waiter untouched, 420   // cannot throw: a failure here leaves the waiter untouched,
421   // the strong guarantee rearm_wait's recovery relies on. 421   // the strong guarantee rearm_wait's recovery relies on.
HITCBC 422   18548 if (impl.heap_index_.load(std::memory_order_relaxed) == 422   18495 if (impl.heap_index_.load(std::memory_order_relaxed) ==
HITCBC 423   37096 (std::numeric_limits<std::size_t>::max)() && 423   36990 (std::numeric_limits<std::size_t>::max)() &&
HITCBC 424   18548 heap_.size() == heap_.capacity()) 424   18495 heap_.size() == heap_.capacity())
HITCBC 425   424 heap_.reserve(heap_.capacity() == 0 ? 16 : 2 * heap_.capacity()); 425   427 heap_.reserve(heap_.capacity() == 0 ? 16 : 2 * heap_.capacity());
426   // Publish: from here the waiter is visible to the fire path and 426   // Publish: from here the waiter is visible to the fire path and
427   // to its own stop callback (impl_ non-null enables cancel_waiter). 427   // to its own stop callback (impl_ non-null enables cancel_waiter).
HITCBC 428   18548 w->impl_ = &impl; 428   18495 w->impl_ = &impl;
HITCBC 429   37096 if (impl.heap_index_.load(std::memory_order_relaxed) == 429   36990 if (impl.heap_index_.load(std::memory_order_relaxed) ==
HITCBC 430   18548 (std::numeric_limits<std::size_t>::max)()) 430   18495 (std::numeric_limits<std::size_t>::max)())
431   { 431   {
HITCBC 432   18548 impl.heap_index_.store(heap_.size(), std::memory_order_relaxed); 432   18495 impl.heap_index_.store(heap_.size(), std::memory_order_relaxed);
HITCBC 433   18548 heap_.push_back({impl.expiry_, &impl}); 433   18495 heap_.push_back({impl.expiry_, &impl});
HITCBC 434   18548 up_heap(heap_.size() - 1); 434   18495 up_heap(heap_.size() - 1);
HITCBC 435   18548 notify = (impl.heap_index_.load(std::memory_order_relaxed) == 0); 435   18495 notify = (impl.heap_index_.load(std::memory_order_relaxed) == 0);
HITCBC 436   18548 refresh_cached_nearest(); 436   18495 refresh_cached_nearest();
437   } 437   }
HITCBC 438   18548 BOOST_COROSIO_ASSERT(impl.waiter_ == nullptr); 438   18495 BOOST_COROSIO_ASSERT(impl.waiter_ == nullptr);
HITCBC 439   18548 impl.waiter_ = w; 439   18495 impl.waiter_ = w;
440   440  
441   // Lost-cancel re-check: a stop requested after the canceller was 441   // Lost-cancel re-check: a stop requested after the canceller was
442   // armed in wait() but before this publication found impl_ null 442   // armed in wait() but before this publication found impl_ null
443   // and returned a no-op. Observe it now and undo the insertion. 443   // and returned a no-op. Observe it now and undo the insertion.
HITCBC 444   18548 if (w->token_->stop_requested()) 444   18495 if (w->token_->stop_requested())
445   { 445   {
HITCBC 446   4 w->impl_ = nullptr; 446   4 w->impl_ = nullptr;
HITCBC 447   4 impl.waiter_ = nullptr; 447   4 impl.waiter_ = nullptr;
HITCBC 448   4 remove_timer_impl(impl); 448   4 remove_timer_impl(impl);
HITCBC 449   4 impl.might_have_pending_waits_.store( 449   4 impl.might_have_pending_waits_.store(
450   false, std::memory_order_relaxed); 450   false, std::memory_order_relaxed);
HITCBC 451   4 refresh_cached_nearest(); 451   4 refresh_cached_nearest();
HITCBC 452   4 lost_cancel = true; 452   4 lost_cancel = true;
HITCBC 453   4 notify = false; // insertion undone; nearest unchanged 453   4 notify = false; // insertion undone; nearest unchanged
454   } 454   }
HITCBC 455   18548 } 455   18495 }
HITCBC 456   18548 if (notify) 456   18495 if (notify)
HITCBC 457   6862 on_earliest_changed_(); 457   6806 on_earliest_changed_();
HITCBC 458   18548 if (lost_cancel) 458   18495 if (lost_cancel)
459   { 459   {
HITCBC 460   4 w->ec_ = make_error_code(capy::error::canceled); 460   4 w->ec_ = make_error_code(capy::error::canceled);
HITCBC 461   4 sched_->post(&w->op_); 461   4 sched_->post(&w->op_);
462   } 462   }
HITCBC 463   18548 } 463   18495 }
464   464  
465   inline void 465   inline void
HITCBC 466   15124 timer_service::cancel_timer(timer::implementation& impl) 466   15241 timer_service::cancel_timer(timer::implementation& impl)
467   { 467   {
HITCBC 468   15124 if (!impl.might_have_pending_waits_.load(std::memory_order_relaxed)) 468   15241 if (!impl.might_have_pending_waits_.load(std::memory_order_relaxed))
HITCBC 469   15122 return; 469   15239 return;
470   470  
471   // No unlocked already-done fast-out here: it would need the 471   // No unlocked already-done fast-out here: it would need the
472   // non-atomic waiter_ (a race with concurrent drains), and an 472   // non-atomic waiter_ (a race with concurrent drains), and an
473   // index-only check is lifetime-unsafe because npos is stored 473   // index-only check is lifetime-unsafe because npos is stored
474   // before the drain finishes touching the impl. A stale-true 474   // before the drain finishes touching the impl. A stale-true
475   // flag is rare with the stateless API; the locked path below 475   // flag is rare with the stateless API; the locked path below
476   // re-validates. 476   // re-validates.
477   477  
HITCBC 478   2 waiter_node* canceled = nullptr; 478   2 waiter_node* canceled = nullptr;
479   479  
480   { 480   {
HITCBC 481   2 std::lock_guard lock(mutex_); 481   2 std::lock_guard lock(mutex_);
HITCBC 482   2 remove_timer_impl(impl); 482   2 remove_timer_impl(impl);
HITCBC 483   2 canceled = std::exchange(impl.waiter_, nullptr); 483   2 canceled = std::exchange(impl.waiter_, nullptr);
HITCBC 484   2 if (canceled) 484   2 if (canceled)
HITCBC 485   2 canceled->impl_ = nullptr; 485   2 canceled->impl_ = nullptr;
486   // Store false as the final touch of the impl under the lock so 486   // Store false as the final touch of the impl under the lock so
487   // a pre-lock false-flag check trusts it unqualified. 487   // a pre-lock false-flag check trusts it unqualified.
HITCBC 488   2 impl.might_have_pending_waits_.store(false, std::memory_order_relaxed); 488   2 impl.might_have_pending_waits_.store(false, std::memory_order_relaxed);
HITCBC 489   2 refresh_cached_nearest(); 489   2 refresh_cached_nearest();
HITCBC 490   2 } 490   2 }
491   491  
HITCBC 492   2 if (canceled) 492   2 if (canceled)
493   { 493   {
HITCBC 494   2 canceled->ec_ = make_error_code(capy::error::canceled); 494   2 canceled->ec_ = make_error_code(capy::error::canceled);
HITCBC 495   2 sched_->post(&canceled->op_); 495   2 sched_->post(&canceled->op_);
496   } 496   }
497   } 497   }
498   498  
499   inline void 499   inline void
HITCBC 500   1739 timer_service::cancel_waiter(waiter_node* w) 500   1828 timer_service::cancel_waiter(waiter_node* w)
501   { 501   {
502   { 502   {
HITCBC 503   1739 std::lock_guard lock(mutex_); 503   1828 std::lock_guard lock(mutex_);
504   // Already removed by another drain: cancel_timer, 504   // Already removed by another drain: cancel_timer,
505   // process_expired, or insert_waiter's lost-cancel recheck 505   // process_expired, or insert_waiter's lost-cancel recheck
HITCBC 506   1739 if (!w->impl_) 506   1828 if (!w->impl_)
HITCBC 507   5 return; 507   115 return;
HITCBC 508   1734 auto* impl = w->impl_; 508   1713 auto* impl = w->impl_;
HITCBC 509   1734 w->impl_ = nullptr; 509   1713 w->impl_ = nullptr;
HITCBC 510   1734 impl->waiter_ = nullptr; 510   1713 impl->waiter_ = nullptr;
HITCBC 511   1734 remove_timer_impl(*impl); 511   1713 remove_timer_impl(*impl);
HITCBC 512   1734 impl->might_have_pending_waits_.store(false, std::memory_order_relaxed); 512   1713 impl->might_have_pending_waits_.store(false, std::memory_order_relaxed);
HITCBC 513   1734 refresh_cached_nearest(); 513   1713 refresh_cached_nearest();
HITCBC 514   1739 } 514   1828 }
515   515  
HITCBC 516   1734 w->ec_ = make_error_code(capy::error::canceled); 516   1713 w->ec_ = make_error_code(capy::error::canceled);
HITCBC 517   1734 sched_->post(&w->op_); 517   1713 sched_->post(&w->op_);
518   } 518   }
519   519  
520   inline std::size_t 520   inline std::size_t
HITCBC 521   313595 timer_service::process_expired() 521   322703 timer_service::process_expired()
522   { 522   {
HITCBC 523   313595 intrusive_list<waiter_node> expired; 523   322703 intrusive_list<waiter_node> expired;
524   524  
525   { 525   {
HITCBC 526   313595 std::lock_guard lock(mutex_); 526   322703 std::lock_guard lock(mutex_);
HITCBC 527   313595 auto now = clock_type::now(); 527   322703 auto now = clock_type::now();
528   528  
HITCBC 529   330374 while (!heap_.empty() && heap_[0].time_ <= now) 529   339450 while (!heap_.empty() && heap_[0].time_ <= now)
530   { 530   {
HITCBC 531   16779 timer::implementation* t = heap_[0].timer_; 531   16747 timer::implementation* t = heap_[0].timer_;
HITCBC 532   16779 remove_timer_impl(*t); 532   16747 remove_timer_impl(*t);
HITCBC 533   16779 if (auto* w = std::exchange(t->waiter_, nullptr)) 533   16747 if (auto* w = std::exchange(t->waiter_, nullptr))
534   { 534   {
HITCBC 535   16779 w->impl_ = nullptr; 535   16747 w->impl_ = nullptr;
HITCBC 536   16779 w->ec_ = {}; 536   16747 w->ec_ = {};
HITCBC 537   16779 expired.push_back(w); 537   16747 expired.push_back(w);
538   } 538   }
HITCBC 539   16779 t->might_have_pending_waits_.store( 539   16747 t->might_have_pending_waits_.store(
540   false, std::memory_order_relaxed); 540   false, std::memory_order_relaxed);
541   } 541   }
542   542  
HITCBC 543   313595 refresh_cached_nearest(); 543   322703 refresh_cached_nearest();
HITCBC 544   313595 } 544   322703 }
545   545  
HITCBC 546   313595 std::size_t count = 0; 546   322703 std::size_t count = 0;
HITCBC 547   330374 while (auto* w = expired.pop_front()) 547   339450 while (auto* w = expired.pop_front())
548   { 548   {
HITCBC 549   16779 sched_->post(&w->op_); 549   16747 sched_->post(&w->op_);
HITCBC 550   16779 ++count; 550   16747 ++count;
HITCBC 551   16779 } 551   16747 }
552   552  
HITCBC 553   313595 return count; 553   322703 return count;
554   } 554   }
555   555  
556   inline void 556   inline void
HITCBC 557   18519 timer_service::remove_timer_impl(timer::implementation& impl) 557   18466 timer_service::remove_timer_impl(timer::implementation& impl)
558   { 558   {
HITCBC 559   18519 std::size_t index = impl.heap_index_.load(std::memory_order_relaxed); 559   18466 std::size_t index = impl.heap_index_.load(std::memory_order_relaxed);
HITCBC 560   18519 if (index >= heap_.size()) 560   18466 if (index >= heap_.size())
MISUBC 561   ✗ return; // Not in heap 561   ✗ return; // Not in heap
562   562  
HITCBC 563   18519 if (index == heap_.size() - 1) 563   18466 if (index == heap_.size() - 1)
564   { 564   {
565   // Last element, just pop 565   // Last element, just pop
HITCBC 566   2454 impl.heap_index_.store( 566   2406 impl.heap_index_.store(
567   (std::numeric_limits<std::size_t>::max)(), 567   (std::numeric_limits<std::size_t>::max)(),
568   std::memory_order_relaxed); 568   std::memory_order_relaxed);
HITCBC 569   2454 heap_.pop_back(); 569   2406 heap_.pop_back();
570   } 570   }
571   else 571   else
572   { 572   {
573   // Swap with last and reheapify 573   // Swap with last and reheapify
HITCBC 574   16065 swap_heap(index, heap_.size() - 1); 574   16060 swap_heap(index, heap_.size() - 1);
HITCBC 575   16065 impl.heap_index_.store( 575   16060 impl.heap_index_.store(
576   (std::numeric_limits<std::size_t>::max)(), 576   (std::numeric_limits<std::size_t>::max)(),
577   std::memory_order_relaxed); 577   std::memory_order_relaxed);
HITCBC 578   16065 heap_.pop_back(); 578   16060 heap_.pop_back();
579   579  
HITCBC 580   16065 if (index > 0 && heap_[index].time_ < heap_[(index - 1) / 2].time_) 580   16060 if (index > 0 && heap_[index].time_ < heap_[(index - 1) / 2].time_)
MISUBC 581   ✗ up_heap(index); 581   ✗ up_heap(index);
582   else 582   else
HITCBC 583   16065 down_heap(index); 583   16060 down_heap(index);
584   } 584   }
585   } 585   }
586   586  
587   inline void 587   inline void
HITCBC 588   18548 timer_service::up_heap(std::size_t index) 588   18495 timer_service::up_heap(std::size_t index)
589   { 589   {
HITCBC 590   25567 while (index > 0) 590   25695 while (index > 0)
591   { 591   {
HITCBC 592   18701 std::size_t parent = (index - 1) / 2; 592   18885 std::size_t parent = (index - 1) / 2;
HITCBC 593   18701 if (!(heap_[index].time_ < heap_[parent].time_)) 593   18885 if (!(heap_[index].time_ < heap_[parent].time_))
HITCBC 594   11682 break; 594   11685 break;
HITCBC 595   7019 swap_heap(index, parent); 595   7200 swap_heap(index, parent);
HITCBC 596   7019 index = parent; 596   7200 index = parent;
597   } 597   }
HITCBC 598   18548 } 598   18495 }
599   599  
600   inline void 600   inline void
HITCBC 601   16065 timer_service::down_heap(std::size_t index) 601   16060 timer_service::down_heap(std::size_t index)
602   { 602   {
HITCBC 603   16065 std::size_t child = index * 2 + 1; 603   16060 std::size_t child = index * 2 + 1;
HITCBC 604   34468 while (child < heap_.size()) 604   34851 while (child < heap_.size())
605   { 605   {
HITCBC 606   20359 std::size_t min_child = (child + 1 == heap_.size() || 606   21169 std::size_t min_child = (child + 1 == heap_.size() ||
HITCBC 607   16802 heap_[child].time_ < heap_[child + 1].time_) 607   17445 heap_[child].time_ < heap_[child + 1].time_)
HITCBC 608   37161 ? child 608   38614 ? child
HITCBC 609   20359 : child + 1; 609   21169 : child + 1;
610   610  
HITCBC 611   20359 if (heap_[index].time_ < heap_[min_child].time_) 611   21169 if (heap_[index].time_ < heap_[min_child].time_)
HITCBC 612   1956 break; 612   2378 break;
613   613  
HITCBC 614   18403 swap_heap(index, min_child); 614   18791 swap_heap(index, min_child);
HITCBC 615   18403 index = min_child; 615   18791 index = min_child;
HITCBC 616   18403 child = index * 2 + 1; 616   18791 child = index * 2 + 1;
617   } 617   }
HITCBC 618   16065 } 618   16060 }
619   619  
620   inline void 620   inline void
HITCBC 621   41487 timer_service::swap_heap(std::size_t i1, std::size_t i2) 621   42051 timer_service::swap_heap(std::size_t i1, std::size_t i2)
622   { 622   {
HITCBC 623   41487 heap_entry tmp = heap_[i1]; 623   42051 heap_entry tmp = heap_[i1];
HITCBC 624   41487 heap_[i1] = heap_[i2]; 624   42051 heap_[i1] = heap_[i2];
HITCBC 625   41487 heap_[i2] = tmp; 625   42051 heap_[i2] = tmp;
HITCBC 626   41487 heap_[i1].timer_->heap_index_.store(i1, std::memory_order_relaxed); 626   42051 heap_[i1].timer_->heap_index_.store(i1, std::memory_order_relaxed);
HITCBC 627   41487 heap_[i2].timer_->heap_index_.store(i2, std::memory_order_relaxed); 627   42051 heap_[i2].timer_->heap_index_.store(i2, std::memory_order_relaxed);
HITCBC 628   41487 } 628   42051 }
629   629  
630   // waiter_node's completion_op and canceller members are defined in 630   // waiter_node's completion_op and canceller members are defined in
631   // timer.cpp alongside implementation::wait(), for the same reason 631   // timer.cpp alongside implementation::wait(), for the same reason
632   // wait() lives there (see below). 632   // wait() lives there (see below).
633   633  
634   // timer::implementation::wait() is defined in timer.cpp, not here. 634   // timer::implementation::wait() is defined in timer.cpp, not here.
635   // It must be a non-inline definition in a translation unit that is 635   // It must be a non-inline definition in a translation unit that is
636   // always pulled into the link whenever detail::timer is used (every 636   // always pulled into the link whenever detail::timer is used (every
637   // consumer needs timer's constructors from that same object file). 637   // consumer needs timer's constructors from that same object file).
638   // An inline definition in this header would only be emitted in 638   // An inline definition in this header would only be emitted in
639   // translation units that happen to also include this header, which 639   // translation units that happen to also include this header, which
640   // is not guaranteed for every caller of wait_awaitable::await_suspend 640   // is not guaranteed for every caller of wait_awaitable::await_suspend
641   // in timer.hpp (e.g. code that only reaches timer.hpp through 641   // in timer.hpp (e.g. code that only reaches timer.hpp through
642   // delay.hpp, without transitively including a scheduler header). 642   // delay.hpp, without transitively including a scheduler header).
643   643  
644   // Free functions 644   // Free functions
645   645  
646   inline timer_service& 646   inline timer_service&
HITCBC 647   2106 get_timer_service(capy::execution_context& ctx, scheduler& sched) 647   2106 get_timer_service(capy::execution_context& ctx, scheduler& sched)
648   { 648   {
HITCBC 649   2106 return ctx.make_service<timer_service>(sched); 649   2106 return ctx.make_service<timer_service>(sched);
650   } 650   }
651   651  
652   } // namespace boost::corosio::detail 652   } // namespace boost::corosio::detail
653   653  
654   #endif 654   #endif