include/boost/corosio/native/native_io_context.hpp

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