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