include/boost/corosio/native/native_io_context.hpp

100.0% Lines (45 / 45) 100.0% 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		// 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		/** Runs asynchronous operations, calling the backend event loop directly.
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 that 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	171x	scheduler_type& sched() noexcept
70		{
71	171x	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		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		call `run()`.
94		*/
95	5x	explicit native_io_context(
96		io_context_options const& opts,
97		unsigned concurrency_hint = std::thread::hardware_concurrency())
98	5x	: io_context(Backend, opts, concurrency_hint)
99		{
100	5x	}
101
102		// Non-copyable, non-movable
103		/// Copy construction is disabled; the context owns its services.
104		native_io_context(native_io_context const&) = delete;
105		/// Copy assignment is disabled; the context owns its services.
106		native_io_context& operator=(native_io_context const&) = delete;
107
108		/// Signal the context to stop processing.
109	2x	void stop()
110		{
111	2x	sched().stop();
112	2x	}
113
114		/** Return whether the context stopped.
115
116		@return `true` if the context has stopped.
117		*/
118	22x	bool stopped() const noexcept
119		{
120	22x	return const_cast<native_io_context*>(this)->sched().stopped();
121		}
122
123		/// Restart the context after being stopped.
124	16x	void restart()
125		{
126	16x	sched().restart();
127	16x	}
128
129		/** Process all pending work items.
130
131		@return The number of handlers executed.
132		*/
133	117x	std::size_t run()
134		{
135	117x	return sched().run();
136		}
137
138		/** Process at most one pending work item.
139
140		@return The number of handlers executed (0 or 1).
141		*/
142		std::size_t run_one()
143		{
144		return sched().run_one();
145		}
146
147		/** Process work items for the specified duration.
148
149		@param rel_time The duration for which to process work.
150
151		@return The number of handlers executed.
152		*/
153		template<class Rep, class Period>
154	4x	std::size_t run_for(std::chrono::duration<Rep, Period> const& rel_time)
155		{
156	4x	return run_until(std::chrono::steady_clock::now() + rel_time);
157		}
158
159		/** Process work items until the specified time.
160
161		@param abs_time The time point until which to process work.
162
163		@return The number of handlers executed.
164		*/
165		template<class Clock, class Duration>
166		std::size_t
167	4x	run_until(std::chrono::time_point<Clock, Duration> const& abs_time)
168		{
169	4x	std::size_t n = 0;
170	6x	while (run_one_until(abs_time))
171	2x	if (n != (std::numeric_limits<std::size_t>::max)())
172	2x	++n;
173	4x	return n;
174		}
175
176		/** Process at most one work item for the specified duration.
177
178		@param rel_time The duration for which the call may block.
179
180		@return The number of handlers executed (0 or 1).
181		*/
182		template<class Rep, class Period>
183		std::size_t run_one_for(std::chrono::duration<Rep, Period> const& rel_time)
184		{
185		return run_one_until(std::chrono::steady_clock::now() + rel_time);
186		}
187
188		/** Process at most one work item until the specified time.
189
190		@param abs_time The time point until which the call may block.
191
192		@return The number of handlers executed (0 or 1).
193		*/
194		template<class Clock, class Duration>
195		std::size_t
196	10x	run_one_until(std::chrono::time_point<Clock, Duration> const& abs_time)
197		{
198	10x	typename Clock::time_point now = Clock::now();
199	2x	for (;;)
200		{
201	12x	auto rel_time = abs_time - now;
202		using rel_type = decltype(rel_time);
203	12x	if (rel_time < rel_type::zero())
204	2x	rel_time = rel_type::zero();
205	10x	else if (rel_time > std::chrono::seconds(1))
206	2x	rel_time = std::chrono::seconds(1);
207
208	24x	std::size_t s = sched().wait_one(
209		static_cast<long>(
210	12x	std::chrono::duration_cast<std::chrono::microseconds>(
211		rel_time)
212	12x	.count()));
213
214	12x	if (s \|\| stopped())
215	10x	return s;
216
217	4x	now = Clock::now();
218	4x	if (now >= abs_time)
219	2x	return 0;
220		}
221		}
222
223		/** Process all ready work items without blocking.
224
225		@return The number of handlers executed.
226		*/
227	2x	std::size_t poll()
228		{
229	2x	return sched().poll();
230		}
231
232		/** Process at most one ready work item without blocking.
233
234		@return The number of handlers executed (0 or 1).
235		*/
236		std::size_t poll_one()
237		{
238		return sched().poll_one();
239		}
240		};
241
242		} // namespace boost::corosio
243
244		#endif // BOOST_COROSIO_NATIVE_NATIVE_IO_CONTEXT_HPP
245