include/boost/corosio/native/native_io_context.hpp

100.0% Lines (45/45) 100.0% List of functions (22/22)

[ ] prev/next file

native_io_context.hpp

f(x) Functions (22)

Function Calls Lines Blocks

Line	Hits	Source Code
1		//
2		// Copyright (c) 2026 Steve Gerbino
3		//
4		// Distributed under the Boost Software License, Version 1.0. (See accompanying
5		// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6		//
7		// Official repository: https://github.com/cppalliance/corosio
8		//
9
10		#ifndef BOOST_COROSIO_NATIVE_NATIVE_IO_CONTEXT_HPP
11		#define BOOST_COROSIO_NATIVE_NATIVE_IO_CONTEXT_HPP
12
13		#include <boost/corosio/io_context.hpp>
14		#include <boost/corosio/backend.hpp>
15
16		#ifndef BOOST_COROSIO_MRDOCS
17		#if BOOST_COROSIO_HAS_EPOLL
18		#include <boost/corosio/native/detail/epoll/epoll_scheduler.hpp>
19		#endif
20
21		#if BOOST_COROSIO_HAS_SELECT
22		#include <boost/corosio/native/detail/select/select_scheduler.hpp>
23		#endif
24
25		#if BOOST_COROSIO_HAS_KQUEUE
26		#include <boost/corosio/native/detail/kqueue/kqueue_scheduler.hpp>
27		#endif
28
29		#if BOOST_COROSIO_HAS_IOCP
30		#include <boost/corosio/native/detail/iocp/win_scheduler.hpp>
31		#endif
32
33		#if BOOST_COROSIO_HAS_IO_URING
34		#include <boost/corosio/native/detail/io_uring/io_uring_scheduler.hpp>
35		#endif
36		#endif // !BOOST_COROSIO_MRDOCS
37
38		namespace boost::corosio {
39
40		/** An I/O context with devirtualized event loop methods.
41
42		This class template inherits from @ref io_context and shadows
43		all public methods with versions that call the concrete
44		scheduler directly, bypassing virtual dispatch. No new state
45		is added.
46
47		A `native_io_context` IS-A `io_context` and can be passed
48		anywhere an `io_context&` is accepted, in which case virtual
49		dispatch is used transparently.
50
51		@tparam Backend A backend tag value (e.g., `epoll`,
52		`iocp`) whose type provides `scheduler_type`.
53
54		@par Thread Safety
55		Same as the underlying context type.
56
57		@par Example
58		@code
59		#include <boost/corosio/native/native_io_context.hpp>
60
61		native_io_context<epoll> ctx;
62		ctx.poll(); // devirtualized call
63		@endcode
64
65		@see io_context, epoll_t, iocp_t
66		*/
67		template<auto Backend>
68		class native_io_context : public io_context
69		{
70		using backend_type = decltype(Backend);
71		using scheduler_type = typename backend_type::scheduler_type;
72
73	42x	scheduler_type& sched() noexcept
74		{
75	42x	return static_cast<scheduler_type>(this->sched_);
76		}
77
78		public:
79		/** Construct with default concurrency. */
80	18x	native_io_context() : io_context(Backend) {}
81
82		/** Construct with a concurrency hint.
83
84		@param concurrency_hint Hint for the number of threads that
85		will call `run()`.
86		*/
87	2x	explicit native_io_context(unsigned concurrency_hint)
88	2x	: io_context(Backend, concurrency_hint)
89		{
90	2x	}
91
92		/** Construct with runtime tuning options.
93
94		@param opts Runtime options controlling scheduler and
95		service behavior.
96		@param concurrency_hint Hint for the number of threads that
97		will call `run()`.
98		*/
99	2x	explicit native_io_context(
100		io_context_options const& opts,
101		unsigned concurrency_hint = std::thread::hardware_concurrency())
102	2x	: io_context(Backend, opts, concurrency_hint)
103		{
104	2x	}
105
106		// Non-copyable, non-movable
107		native_io_context(native_io_context const&) = delete;
108		native_io_context& operator=(native_io_context const&) = delete;
109
110		/// Signal the context to stop processing.
111	2x	void stop()
112		{
113	2x	sched().stop();
114	2x	}
115
116		/// Return whether the context has been stopped.
117	22x	bool stopped() const noexcept
118		{
119	22x	return const_cast<native_io_context*>(this)->sched().stopped();
120		}
121
122		/// Restart the context after being stopped.
123	2x	void restart()
124		{
125	2x	sched().restart();
126	2x	}
127
128		/** Process all pending work items.
129
130		@return The number of handlers executed.
131		*/
132	2x	std::size_t run()
133		{
134	2x	return sched().run();
135		}
136
137		/** Process at most one pending work item.
138
139		@return The number of handlers executed (0 or 1).
140		*/
141		std::size_t run_one()
142		{
143		return sched().run_one();
144		}
145
146		/** Process work items for the specified duration.
147
148		@param rel_time The duration for which to process work.
149
150		@return The number of handlers executed.
151		*/
152		template<class Rep, class Period>
153	4x	std::size_t run_for(std::chrono::duration<Rep, Period> const& rel_time)
154		{
155	4x	return run_until(std::chrono::steady_clock::now() + rel_time);
156		}
157
158		/** Process work items until the specified time.
159
160		@param abs_time The time point until which to process work.
161
162		@return The number of handlers executed.
163		*/
164		template<class Clock, class Duration>
165		std::size_t
166	4x	run_until(std::chrono::time_point<Clock, Duration> const& abs_time)
167		{
168	4x	std::size_t n = 0;
169	6x	while (run_one_until(abs_time))
170	2x	if (n != (std::numeric_limits<std::size_t>::max)())
171	2x	++n;
172	4x	return n;
173		}
174
175		/** Process at most one work item for the specified duration.
176
177		@param rel_time The duration for which the call may block.
178
179		@return The number of handlers executed (0 or 1).
180		*/
181		template<class Rep, class Period>
182		std::size_t run_one_for(std::chrono::duration<Rep, Period> const& rel_time)
183		{
184		return run_one_until(std::chrono::steady_clock::now() + rel_time);
185		}
186
187		/** Process at most one work item until the specified time.
188
189		@param abs_time The time point until which the call may block.
190
191		@return The number of handlers executed (0 or 1).
192		*/
193		template<class Clock, class Duration>
194		std::size_t
195	10x	run_one_until(std::chrono::time_point<Clock, Duration> const& abs_time)
196		{
197	10x	typename Clock::time_point now = Clock::now();
198	2x	for (;;)
199		{
200	12x	auto rel_time = abs_time - now;
201		using rel_type = decltype(rel_time);
202	12x	if (rel_time < rel_type::zero())
203	2x	rel_time = rel_type::zero();
204	10x	else if (rel_time > std::chrono::seconds(1))
205	2x	rel_time = std::chrono::seconds(1);
206
207	24x	std::size_t s = sched().wait_one(
208		static_cast<long>(
209	12x	std::chrono::duration_cast<std::chrono::microseconds>(
210		rel_time)
211	12x	.count()));
212
213	12x	if (s \|\| stopped())
214	10x	return s;
215
216	4x	now = Clock::now();
217	4x	if (now >= abs_time)
218	2x	return 0;
219		}
220		}
221
222		/** Process all ready work items without blocking.
223
224		@return The number of handlers executed.
225		*/
226	2x	std::size_t poll()
227		{
228	2x	return sched().poll();
229		}
230
231		/** Process at most one ready work item without blocking.
232
233		@return The number of handlers executed (0 or 1).
234		*/
235		std::size_t poll_one()
236		{
237		return sched().poll_one();
238		}
239		};
240
241		} // namespace boost::corosio
242
243		#endif // BOOST_COROSIO_NATIVE_NATIVE_IO_CONTEXT_HPP
244