22549277350

Committed 01 Mar 2026 06:03PM UTC coverage: 86.142%. First build

Build # 22549277350

Build Type

Pull #444

github

Committed by

web-flow

Commit Message

Merge 020d34b2f into 0161911f2

Pull Request Pull Request #444: scheduler remove lock for scheduled|resumed tasks

Run Details

22 of 31 new or added lines in 4 files covered. (70.97%)

1871 of 2172 relevant lines covered (86.14%)

4825825.96 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.53

/src/scheduler.cpp

#include "coro/scheduler.hpp"
#include "coro/detail/task_self_deleting.hpp"

#include <atomic>
#include <cstring>
#include <iostream>
#include <optional>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

using namespace std::chrono_literals;

namespace coro
{

namespace detail
{
static auto
    make_spawned_joinable_wait_task(std::unique_ptr<coro::task_group<coro::scheduler>> group_ptr) -> coro::task<void>
{
    co_await *group_ptr;
    co_return;
}

} // namespace detail

scheduler::scheduler(options&& opts, private_constructor)
    : m_opts(opts),
      m_io_notifier(),
      m_timer(static_cast<const void*>(&m_timer_object), m_io_notifier)
{
    if (!m_io_notifier.watch(m_shutdown_pipe.read_fd(), coro::poll_op::read, const_cast<void*>(m_shutdown_ptr), true))
    {
        throw std::runtime_error("Failed to register m_shutdown_pipe.read_fd() for read events.");
    }

    if (!m_io_notifier.watch(m_schedule_pipe.read_fd(), coro::poll_op::read, const_cast<void*>(m_schedule_ptr), true))
    {
        throw std::runtime_error("Failed to register m_schedule.pipe.read_rd() for read events.");
    }

    m_recent_events.reserve(m_max_events);

    if (m_opts.execution_strategy == execution_strategy_t::process_tasks_on_thread_pool)
    {
        m_thread_pool = thread_pool::make_unique(std::move(m_opts.pool));
    }
}

auto scheduler::make_unique(options opts) -> std::unique_ptr<scheduler>
{
    auto s = std::make_unique<scheduler>(std::move(opts), private_constructor{});

    // Spawn the dedicated event loop thread once the scheduler is fully constructed
    // so it has a full object to work with.
    if (s->m_opts.thread_strategy == thread_strategy_t::spawn)
    {
        s->m_io_thread = std::thread([s = s.get()]() { s->process_events_dedicated_thread(); });
    }
    // else manual mode, the user must call process_events.

    return s;
}

scheduler::~scheduler()
{
    shutdown();

    if (m_io_thread.joinable())
    {
        m_io_thread.join();
    }

    m_shutdown_pipe.close();
    m_schedule_pipe.close();
}

auto scheduler::process_events(std::chrono::milliseconds timeout) -> std::size_t
{
    process_events_manual(timeout);
    return size();
}

auto scheduler::spawn_detached(coro::task<void>&& task) -> bool
{
    m_size.fetch_add(1, std::memory_order::release);
    auto wrapper_task = detail::make_task_self_deleting(std::move(task));
    wrapper_task.promise().user_final_suspend([this]() -> void { m_size.fetch_sub(1, std::memory_order::release); });
    return resume(wrapper_task.handle());
}

auto scheduler::spawn_joinable(coro::task<void>&& task) -> coro::task<void>
{
    auto group_ptr = std::make_unique<coro::task_group<coro::scheduler>>(this, std::move(task));
    return detail::make_spawned_joinable_wait_task(std::move(group_ptr));
}

auto scheduler::schedule_at(time_point time) -> coro::task<void>
{
    return yield_until(time);
}

auto scheduler::yield_until(time_point time) -> coro::task<void>
{
    auto now = clock::now();

    // If the requested time is in the past (or now!) bail out!
    if (time <= now)
    {
        co_await schedule();
    }
    else
    {
        m_size.fetch_add(1, std::memory_order::release);

        auto amount = std::chrono::duration_cast<std::chrono::milliseconds>(time - now);

        detail::poll_info pi{};
        add_timer_token(now + amount, pi);
        co_await pi;
    }
    co_return;
}

auto scheduler::poll(
    fd_t                           fd,
    coro::poll_op                  op,
    std::chrono::milliseconds      timeout,
    std::optional<poll_stop_token> cancel_trigger) -> coro::task<poll_status>
{
    // Because the size will drop when this coroutine suspends every poll needs to undo the subtraction
    // on the number of active tasks in the scheduler.  When this task is resumed by the event loop.
    m_size.fetch_add(1, std::memory_order::release);

    // Setup two events, a timeout event and the actual poll for op event.
    // Whichever triggers first will delete the other to guarantee only one wins.
    // The resume token will be set by the scheduler to what the event turned out to be.

    bool timeout_requested = (timeout > 0ms);

    auto pi = detail::poll_info{fd, op, cancel_trigger};

    if (timeout_requested)
    {
        pi.m_timer_pos = add_timer_token(clock::now() + timeout, pi);
    }

    if (!m_io_notifier.watch(pi))
    {
        std::cerr << "Failed to add " << fd << " to watch list\n";
    }

    // The event loop will 'clean-up' whichever event didn't win since the coroutine is scheduled
    // onto the thread poll its possible the other type of event could trigger while its waiting
    // to execute again, thus restarting the coroutine twice, that would be quite bad.
    auto result = co_await pi;
    co_return result;
}

auto scheduler::resume(std::coroutine_handle<> handle) -> bool
{
    if (handle == nullptr || handle.done())
    {
        return false;
    }

    if (m_shutdown_requested.load(std::memory_order::acquire))
    {
        return false;
    }

    if (m_opts.execution_strategy == execution_strategy_t::process_tasks_inline)
    {
        // auto* schedule_op        = new schedule_operation{*this};
        // schedule_op->m_allocated = true;
        // schedule_op->await_suspend(handle);
        schedule_operation op{*this};
        op.await_suspend(handle);
        return true;
    }
    else
    {
        return m_thread_pool->resume(handle);
    }
}

auto scheduler::shutdown() noexcept -> void
{
    // Only allow shutdown to occur once.
    if (m_shutdown_requested.exchange(true, std::memory_order::acq_rel) == false)
    {
        // Signal the event loop to stop asap.
        const int value{1};
        ssize_t   written = ::write(m_shutdown_pipe.write_fd(), reinterpret_cast<const void*>(&value), sizeof(value));
        if (written != sizeof(value))
        {
            std::cerr << "libcoro::scheduler::shutdown() failed to write to shutdown pipe, bytes written=" << written
                      << "\n";
        }

        if (m_io_thread.joinable())
        {
            m_io_thread.join();
        }

        if (m_thread_pool != nullptr)
        {
            m_thread_pool->shutdown();
        }
    }
}

auto scheduler::yield_for_internal(std::chrono::nanoseconds amount) -> coro::task<void>
{
    if (amount <= 0ms)
    {
        co_await schedule();
    }
    else
    {
        // Yield/timeout tasks are considered live in the scheduler and must be accounted for. Note
        // that if the user gives an invalid amount and schedule() is directly called it will account
        // for the scheduled task there.
        m_size.fetch_add(1, std::memory_order::release);

        // Yielding does not require setting the timer position on the poll info since
        // it doesn't have a corresponding 'event' that can trigger, it always waits for
        // the timeout to occur before resuming.

        detail::poll_info pi{};
        add_timer_token(clock::now() + amount, pi);
        co_await pi;
    }
    co_return;
}

auto scheduler::process_events_manual(std::chrono::milliseconds timeout) -> void
{
    bool expected{false};
    if (m_io_processing.compare_exchange_strong(expected, true, std::memory_order::release, std::memory_order::relaxed))
    {
        process_events_execute(timeout);
        m_io_processing.exchange(false, std::memory_order::release);
    }
}

auto scheduler::process_events_dedicated_thread() -> void
{
    if (m_opts.on_io_thread_start_functor != nullptr)
    {
        m_opts.on_io_thread_start_functor();
    }

    m_io_processing.exchange(true, std::memory_order::release);
    // Execute tasks until stopped or there are no more tasks to complete.
    while (!m_shutdown_requested.load(std::memory_order::acquire) || size() > 0)
    {
        process_events_execute(m_default_timeout);
    }
    m_io_processing.exchange(false, std::memory_order::release);

    if (m_opts.on_io_thread_stop_functor != nullptr)
    {
        m_opts.on_io_thread_stop_functor();
    }
}

auto scheduler::process_events_execute(std::chrono::milliseconds timeout) -> void
{
    // Clear the recent events without decreasing the allocated capacity to reduce allocations
    m_recent_events.clear();
    m_io_notifier.next_events(m_recent_events, timeout);

    for (auto& [handle_ptr, poll_status] : m_recent_events)
    {
        if (handle_ptr == m_timer_ptr)
        {
            // Process all events that have timed out.
            process_timeout_execute();
        }
        else if (handle_ptr == m_schedule_ptr)
        {
            // Process scheduled coroutines.
            process_scheduled_execute_inline();
        }
        else if (handle_ptr == m_shutdown_ptr) [[unlikely]]
        {
            // Nothing to do, just needed to wake-up and smell the flowers
        }
        else
        {
            // Individual poll task wake-up.
            process_event_execute(static_cast<detail::poll_info*>(handle_ptr), poll_status);
        }
    }

    // Its important to not resume any handles until the full set is accounted for.  If a timeout
    // and an event for the same handle happen in the same epoll_wait() call then inline processing
    // will destruct the poll_info object before the second event is handled.  This is also possible
    // with thread pool processing, but probably has an extremely low chance of occuring due to
    // the thread switch required.  If m_max_events == 1 this would be unnecessary.

    if (!m_handles_to_resume.empty())
    {
        if (m_opts.execution_strategy == execution_strategy_t::process_tasks_inline)
        {
            std::size_t resumed{0};
            for (auto& handle : m_handles_to_resume)
            {
                handle.resume();
                ++resumed;
            }
            if (resumed > 0)
            {
                m_size.fetch_sub(resumed, std::memory_order::release);
            }
        }
        else
        {
            m_thread_pool->resume(m_handles_to_resume);
            m_size.fetch_sub(m_handles_to_resume.size(), std::memory_order::release);
        }

        m_handles_to_resume.clear();
    }
}

auto scheduler::process_scheduled_execute_inline() -> void
{
    // This could pull until the pipe is drained, however we want to pull a discreet
    // amount of work on each pass, 16 tasks should be a good chunk to pull each time.
    // Pulling until the pipe is drained could result in infinite growth if scheduling
    // of tasks is faster than this scheduler can pull.

    const constexpr std::size_t READ_COUNT{16};
    const constexpr ssize_t     READ_COUNT_BYTES = READ_COUNT * sizeof(std::coroutine_handle<>);

    std::array<std::coroutine_handle<>, READ_COUNT> ops{};
    const ssize_t                                   bytes_read = m_schedule_pipe.read(ops.data(), READ_COUNT_BYTES);

    // Error or nothing to read.
    if (bytes_read <= 0)
    {
        return;
    }

    auto count = bytes_read / sizeof(std::coroutine_handle<>);
    for (uint64_t i = 0; i < count; ++i)
    {
        m_handles_to_resume.emplace_back(ops[i]);
    }
}

auto scheduler::process_event_execute(detail::poll_info* pi, poll_status status) -> void
{
    if (!pi->m_processed)
    {
        std::atomic_thread_fence(std::memory_order::acquire);
        // Its possible the event and the timeout occurred in the same epoll, make sure only one
        // is ever processed, the other is discarded.
        pi->m_processed = true;

        // Given a valid fd always remove it from epoll so the next poll can blindly EPOLL_CTL_ADD.
        if (pi->m_fd != -1)
        {
            m_io_notifier.unwatch(*pi);
        }

        // Since this event triggered, remove its corresponding timeout if it has one.
        if (pi->m_timer_pos.has_value())
        {
            remove_timer_token(pi->m_timer_pos.value());
        }

        pi->m_poll_status = status;

        while (pi->m_awaiting_coroutine == nullptr)
        {
            std::atomic_thread_fence(std::memory_order::acquire);
        }

        m_handles_to_resume.emplace_back(pi->m_awaiting_coroutine);
    }
}

auto scheduler::process_timeout_execute() -> void
{
    std::vector<detail::poll_info*> poll_infos{};
    auto                            now = clock::now();

    {
        std::scoped_lock lk{m_timed_events_mutex};
        while (!m_timed_events.empty())
        {
            auto first    = m_timed_events.begin();
            auto [tp, pi] = *first;

            if (tp <= now)
            {
                m_timed_events.erase(first);
                poll_infos.emplace_back(pi);
            }
            else
            {
                break;
            }
        }
    }

    for (auto pi : poll_infos)
    {
        if (!pi->m_processed)
        {
            // Its possible the event and the timeout occurred in the same epoll, make sure only one
            // is ever processed, the other is discarded.
            pi->m_processed = true;

            // Since this timed out, remove its corresponding event if it has one.
            if (pi->m_fd != -1)
            {
                m_io_notifier.unwatch(*pi);
            }

            while (pi->m_awaiting_coroutine == nullptr)
            {
                std::atomic_thread_fence(std::memory_order::acquire);
            }

            m_handles_to_resume.emplace_back(pi->m_awaiting_coroutine);
            pi->m_poll_status = coro::poll_status::timeout;
        }
    }

    // Update the time to the next smallest time point, re-take the current now time
    // since updating and resuming tasks could shift the time.
    update_timeout(clock::now());
}

auto scheduler::add_timer_token(time_point tp, detail::poll_info& pi) -> timed_events::iterator
{
    std::scoped_lock lk{m_timed_events_mutex};
    auto             pos = m_timed_events.emplace(tp, &pi);

    // If this item was inserted as the smallest time point, update the timeout.
    if (pos == m_timed_events.begin())
    {
        update_timeout(clock::now());
    }

    return pos;
}

auto scheduler::remove_timer_token(timed_events::iterator pos) -> void
{
    {
        std::scoped_lock lk{m_timed_events_mutex};
        auto             is_first = (m_timed_events.begin() == pos);

        m_timed_events.erase(pos);

        // If this was the first item, update the timeout.  It would be acceptable to just let it
        // also fire the timeout as the event loop will ignore it since nothing will have timed
        // out but it feels like the right thing to do to update it to the correct timeout value.
        if (is_first)
        {
            update_timeout(clock::now());
        }
    }
}

auto scheduler::update_timeout(time_point now) -> void
{
    if (!m_timed_events.empty())
    {
        auto& [tp, pi] = *m_timed_events.begin();

        auto amount = tp - now;

        if (!m_io_notifier.watch_timer(m_timer, amount))
        {
            std::cerr << "Failed to set timerfd errorno=[" << std::string{strerror(errno)} << "].";
        }
    }
    else
    {
        m_io_notifier.unwatch_timer(m_timer);
    }
}

} // namespace coro

1	#include "coro/scheduler.hpp"
2	#include "coro/detail/task_self_deleting.hpp"
3
4	#include <atomic>
5	#include <cstring>
6	#include <iostream>
7	#include <optional>
8	#include <sys/socket.h>
9	#include <sys/types.h>
10	#include <unistd.h>
11
12	using namespace std::chrono_literals;
13
14	namespace coro
15	{
16
17	namespace detail
18	{
19	static auto
20	make_spawned_joinable_wait_task(std::unique_ptr<coro::task_group<coro::scheduler>> group_ptr) -> coro::task<void>	×
21	{
22	co_await *group_ptr;
23	co_return;
24	}	×
25
26	} // namespace detail
27
28	scheduler::scheduler(options&& opts, private_constructor)	98✔
29	: m_opts(opts),	98✔
30	m_io_notifier(),	98✔
31	m_timer(static_cast<const void*>(&m_timer_object), m_io_notifier)	196✔
32	{
33	if (!m_io_notifier.watch(m_shutdown_pipe.read_fd(), coro::poll_op::read, const_cast<void*>(m_shutdown_ptr), true))	98✔
34	{
35	throw std::runtime_error("Failed to register m_shutdown_pipe.read_fd() for read events.");	×
36	}
37
38	if (!m_io_notifier.watch(m_schedule_pipe.read_fd(), coro::poll_op::read, const_cast<void*>(m_schedule_ptr), true))	98✔
39	{
40	throw std::runtime_error("Failed to register m_schedule.pipe.read_rd() for read events.");	×
41	}
42
43	m_recent_events.reserve(m_max_events);	98✔
44
45	if (m_opts.execution_strategy == execution_strategy_t::process_tasks_on_thread_pool)	98✔
46	{
47	m_thread_pool = thread_pool::make_unique(std::move(m_opts.pool));	55✔
48	}
49	}	98✔
50
51	auto scheduler::make_unique(options opts) -> std::unique_ptr<scheduler>	98✔
52	{
53	auto s = std::make_unique<scheduler>(std::move(opts), private_constructor{});	98✔
54
55	// Spawn the dedicated event loop thread once the scheduler is fully constructed
56	// so it has a full object to work with.
57	if (s->m_opts.thread_strategy == thread_strategy_t::spawn)	98✔
58	{
59	s->m_io_thread = std::thread([s = s.get()]() { s->process_events_dedicated_thread(); });	192✔
60	}
61	// else manual mode, the user must call process_events.
62
63	return s;	98✔
64	}	×
65
66	scheduler::~scheduler()	196✔
67	{
68	shutdown();	98✔
69
70	if (m_io_thread.joinable())	98✔
71	{
72	m_io_thread.join();	×
73	}
74
75	m_shutdown_pipe.close();	98✔
76	m_schedule_pipe.close();	98✔
77	}	196✔
78
79	auto scheduler::process_events(std::chrono::milliseconds timeout) -> std::size_t	4✔
80	{
81	process_events_manual(timeout);	4✔
82	return size();	4✔
83	}
84
85	auto scheduler::spawn_detached(coro::task<void>&& task) -> bool	200,318✔
86	{
87	m_size.fetch_add(1, std::memory_order::release);	200,318✔
88	auto wrapper_task = detail::make_task_self_deleting(std::move(task));	200,318✔
89	wrapper_task.promise().user_final_suspend([this]() -> void { m_size.fetch_sub(1, std::memory_order::release); });	400,635✔
90	return resume(wrapper_task.handle());	200,318✔
91	}
92
93	auto scheduler::spawn_joinable(coro::task<void>&& task) -> coro::task<void>	×
94	{
95	auto group_ptr = std::make_unique<coro::task_group<coro::scheduler>>(this, std::move(task));	×
96	return detail::make_spawned_joinable_wait_task(std::move(group_ptr));	×
97	}	×
98
99	auto scheduler::schedule_at(time_point time) -> coro::task<void>	3✔
100	{
101	return yield_until(time);	3✔
102	}
103
104	auto scheduler::yield_until(time_point time) -> coro::task<void>	4✔
105	{
106	auto now = clock::now();
107
108	// If the requested time is in the past (or now!) bail out!
109	if (time <= now)
110	{
111	co_await schedule();
112	}
113	else
114	{
115	m_size.fetch_add(1, std::memory_order::release);
116
117	auto amount = std::chrono::duration_cast<std::chrono::milliseconds>(time - now);
118
119	detail::poll_info pi{};
120	add_timer_token(now + amount, pi);
121	co_await pi;
122	}
123	co_return;
124	}	8✔
125
126	auto scheduler::poll(	2,416,501✔
127	fd_t fd,
128	coro::poll_op op,
129	std::chrono::milliseconds timeout,
130	std::optional<poll_stop_token> cancel_trigger) -> coro::task<poll_status>
131	{
132	// Because the size will drop when this coroutine suspends every poll needs to undo the subtraction
133	// on the number of active tasks in the scheduler. When this task is resumed by the event loop.
134	m_size.fetch_add(1, std::memory_order::release);
135
136	// Setup two events, a timeout event and the actual poll for op event.
137	// Whichever triggers first will delete the other to guarantee only one wins.
138	// The resume token will be set by the scheduler to what the event turned out to be.
139
140	bool timeout_requested = (timeout > 0ms);
141
142	auto pi = detail::poll_info{fd, op, cancel_trigger};
143
144	if (timeout_requested)
145	{
146	pi.m_timer_pos = add_timer_token(clock::now() + timeout, pi);
147	}
148
149	if (!m_io_notifier.watch(pi))
150	{
151	std::cerr << "Failed to add " << fd << " to watch list\n";
152	}
153
154	// The event loop will 'clean-up' whichever event didn't win since the coroutine is scheduled
155	// onto the thread poll its possible the other type of event could trigger while its waiting
156	// to execute again, thus restarting the coroutine twice, that would be quite bad.
157	auto result = co_await pi;
158	co_return result;
159	}	4,859,636✔
160
161	auto scheduler::resume(std::coroutine_handle<> handle) -> bool	200,379✔
162	{
163	if (handle == nullptr \|\| handle.done())	200,379✔
164	{
165	return false;	×
166	}
167
168	if (m_shutdown_requested.load(std::memory_order::acquire))	200,379✔
169	{
170	return false;	×
171	}
172
173	if (m_opts.execution_strategy == execution_strategy_t::process_tasks_inline)	200,379✔
174	{
175	// auto* schedule_op = new schedule_operation{*this};
176	// schedule_op->m_allocated = true;
177	// schedule_op->await_suspend(handle);
178	schedule_operation op{*this};	101✔
179	op.await_suspend(handle);	101✔
180	return true;	101✔
181	}
182	else
183	{
184	return m_thread_pool->resume(handle);	200,278✔
185	}
186	}
187
188	auto scheduler::shutdown() noexcept -> void	142✔
189	{
190	// Only allow shutdown to occur once.
191	if (m_shutdown_requested.exchange(true, std::memory_order::acq_rel) == false)	142✔
192	{
193	// Signal the event loop to stop asap.
194	const int value{1};	98✔
195	ssize_t written = ::write(m_shutdown_pipe.write_fd(), reinterpret_cast<const void*>(&value), sizeof(value));	98✔
196	if (written != sizeof(value))	98✔
197	{
NEW 198	std::cerr << "libcoro::scheduler::shutdown() failed to write to shutdown pipe, bytes written=" << written	×
NEW 199	<< "\n";	×
200	}
201
202	if (m_io_thread.joinable())	98✔
203	{
204	m_io_thread.join();	96✔
205	}
206
207	if (m_thread_pool != nullptr)	98✔
208	{
209	m_thread_pool->shutdown();	55✔
210	}
211	}
212	}	142✔
213
214	auto scheduler::yield_for_internal(std::chrono::nanoseconds amount) -> coro::task<void>	5,000,175✔
215	{
216	if (amount <= 0ms)
217	{
218	co_await schedule();
219	}
220	else
221	{
222	// Yield/timeout tasks are considered live in the scheduler and must be accounted for. Note
223	// that if the user gives an invalid amount and schedule() is directly called it will account
224	// for the scheduled task there.
225	m_size.fetch_add(1, std::memory_order::release);
226
227	// Yielding does not require setting the timer position on the poll info since
228	// it doesn't have a corresponding 'event' that can trigger, it always waits for
229	// the timeout to occur before resuming.
230
231	detail::poll_info pi{};
232	add_timer_token(clock::now() + amount, pi);
233	co_await pi;
234	}
235	co_return;
236	}	10,000,350✔
237
238	auto scheduler::process_events_manual(std::chrono::milliseconds timeout) -> void	4✔
239	{
240	bool expected{false};	4✔
241	if (m_io_processing.compare_exchange_strong(expected, true, std::memory_order::release, std::memory_order::relaxed))	4✔
242	{
243	process_events_execute(timeout);	4✔
244	m_io_processing.exchange(false, std::memory_order::release);	4✔
245	}
246	}	4✔
247
248	auto scheduler::process_events_dedicated_thread() -> void	96✔
249	{
250	if (m_opts.on_io_thread_start_functor != nullptr)	96✔
251	{
252	m_opts.on_io_thread_start_functor();	×
253	}
254
255	m_io_processing.exchange(true, std::memory_order::release);	96✔
256	// Execute tasks until stopped or there are no more tasks to complete.
257	while (!m_shutdown_requested.load(std::memory_order::acquire) \|\| size() > 0)	1,249,903✔
258	{
259	process_events_execute(m_default_timeout);	1,246,384✔
260	}
261	m_io_processing.exchange(false, std::memory_order::release);
262
263	if (m_opts.on_io_thread_stop_functor != nullptr)	96✔
264	{
265	m_opts.on_io_thread_stop_functor();	×
266	}
267	}	96✔
268
269	auto scheduler::process_events_execute(std::chrono::milliseconds timeout) -> void	1,246,650✔
270	{
271	// Clear the recent events without decreasing the allocated capacity to reduce allocations
272	m_recent_events.clear();	1,246,650✔
273	m_io_notifier.next_events(m_recent_events, timeout);	1,248,569✔
274
275	for (auto& [handle_ptr, poll_status] : m_recent_events)	4,689,097✔
276	{
277	if (handle_ptr == m_timer_ptr)	3,438,582✔
278	{
279	// Process all events that have timed out.
280	process_timeout_execute();	871,983✔
281	}
282	else if (handle_ptr == m_schedule_ptr)	2,566,599✔
283	{
284	// Process scheduled coroutines.
285	process_scheduled_execute_inline();	47✔
286	}
287	else if (handle_ptr == m_shutdown_ptr) [[unlikely]]	2,566,552✔
288	{
289	// Nothing to do, just needed to wake-up and smell the flowers
290	}
291	else
292	{
293	// Individual poll task wake-up.
294	process_event_execute(static_cast<detail::poll_info*>(handle_ptr), poll_status);	2,566,458✔
295	}
296	}
297
298	// Its important to not resume any handles until the full set is accounted for. If a timeout
299	// and an event for the same handle happen in the same epoll_wait() call then inline processing
300	// will destruct the poll_info object before the second event is handled. This is also possible
301	// with thread pool processing, but probably has an extremely low chance of occuring due to
302	// the thread switch required. If m_max_events == 1 this would be unnecessary.
303
304	if (!m_handles_to_resume.empty())	1,249,972✔
305	{
306	if (m_opts.execution_strategy == execution_strategy_t::process_tasks_inline)	1,251,987✔
307	{
308	std::size_t resumed{0};	238,448✔
309	for (auto& handle : m_handles_to_resume)	2,169,513✔
310	{
311	handle.resume();	1,803,871✔
312	++resumed;	1,965,146✔
313	}
314	if (resumed > 0)	197,363✔
315	{
316	m_size.fetch_sub(resumed, std::memory_order::release);	235,435✔
317	}
318	}
319	else
320	{
321	m_thread_pool->resume(m_handles_to_resume);	1,013,539✔
322	m_size.fetch_sub(m_handles_to_resume.size(), std::memory_order::release);	1,013,559✔
323	}
324
325	m_handles_to_resume.clear();	1,210,943✔
326	}
327	}	1,247,987✔
328
329	auto scheduler::process_scheduled_execute_inline() -> void	47✔
330	{
331	// This could pull until the pipe is drained, however we want to pull a discreet
332	// amount of work on each pass, 16 tasks should be a good chunk to pull each time.
333	// Pulling until the pipe is drained could result in infinite growth if scheduling
334	// of tasks is faster than this scheduler can pull.
335
336	const constexpr std::size_t READ_COUNT{16};	47✔
337	const constexpr ssize_t READ_COUNT_BYTES = READ_COUNT * sizeof(std::coroutine_handle<>);	47✔
338
339	std::array<std::coroutine_handle<>, READ_COUNT> ops{};	47✔
340	const ssize_t bytes_read = m_schedule_pipe.read(ops.data(), READ_COUNT_BYTES);	47✔
341
342	// Error or nothing to read.
343	if (bytes_read <= 0)	47✔
344	{
NEW 345	return;	×
346	}
347
348	auto count = bytes_read / sizeof(std::coroutine_handle<>);	47✔
349	for (uint64_t i = 0; i < count; ++i)	281✔
350	{
351	m_handles_to_resume.emplace_back(ops[i]);	236✔
352	}
353	}
354
355	auto scheduler::process_event_execute(detail::poll_info* pi, poll_status status) -> void	2,563,122✔
356	{
357	if (!pi->m_processed)	2,563,122✔
358	{
359	std::atomic_thread_fence(std::memory_order::acquire);
360	// Its possible the event and the timeout occurred in the same epoll, make sure only one
361	// is ever processed, the other is discarded.
362	pi->m_processed = true;	2,565,475✔
363
364	// Given a valid fd always remove it from epoll so the next poll can blindly EPOLL_CTL_ADD.
365	if (pi->m_fd != -1)	2,565,475✔
366	{
367	m_io_notifier.unwatch(*pi);	2,581,221✔
368	}
369
370	// Since this event triggered, remove its corresponding timeout if it has one.
371	if (pi->m_timer_pos.has_value())	2,565,898✔
372	{
373	remove_timer_token(pi->m_timer_pos.value());	100,425✔
374	}
375
376	pi->m_poll_status = status;	2,571,014✔
377
378	while (pi->m_awaiting_coroutine == nullptr)	36,430,907✔
379	{
380	std::atomic_thread_fence(std::memory_order::acquire);
381	}
382
383	m_handles_to_resume.emplace_back(pi->m_awaiting_coroutine);	2,566,047✔
384	}
385	}	2,556,776✔
386
387	auto scheduler::process_timeout_execute() -> void	871,983✔
388	{
389	std::vector<detail::poll_info*> poll_infos{};	871,983✔
390	auto now = clock::now();	871,983✔
391
392	{
393	std::scoped_lock lk{m_timed_events_mutex};	871,983✔
394	while (!m_timed_events.empty())	5,872,176✔
395	{
396	auto first = m_timed_events.begin();	5,872,118✔
397	auto [tp, pi] = *first;	5,872,118✔
398
399	if (tp <= now)	5,872,118✔
400	{
401	m_timed_events.erase(first);	5,000,193✔
402	poll_infos.emplace_back(pi);	5,000,193✔
403	}
404	else
405	{
406	break;	871,925✔
407	}
408	}
409	}	871,983✔
410
411	for (auto pi : poll_infos)	5,872,176✔
412	{
413	if (!pi->m_processed)	5,000,193✔
414	{
415	// Its possible the event and the timeout occurred in the same epoll, make sure only one
416	// is ever processed, the other is discarded.
417	pi->m_processed = true;	5,000,193✔
418
419	// Since this timed out, remove its corresponding event if it has one.
420	if (pi->m_fd != -1)	5,000,193✔
421	{
422	m_io_notifier.unwatch(*pi);	17✔
423	}
424
425	while (pi->m_awaiting_coroutine == nullptr)	5,000,193✔
426	{
427	std::atomic_thread_fence(std::memory_order::acquire);
428	}
429
430	m_handles_to_resume.emplace_back(pi->m_awaiting_coroutine);	5,000,193✔
431	pi->m_poll_status = coro::poll_status::timeout;	5,000,193✔
432	}
433	}
434
435	// Update the time to the next smallest time point, re-take the current now time
436	// since updating and resuming tasks could shift the time.
437	update_timeout(clock::now());	871,983✔
438	}	871,983✔
439
440	auto scheduler::add_timer_token(time_point tp, detail::poll_info& pi) -> timed_events::iterator	5,100,527✔
441	{
442	std::scoped_lock lk{m_timed_events_mutex};	5,100,527✔
443	auto pos = m_timed_events.emplace(tp, &pi);	5,100,617✔
444
445	// If this item was inserted as the smallest time point, update the timeout.
446	if (pos == m_timed_events.begin())	5,100,616✔
447	{
448	update_timeout(clock::now());	695✔
449	}
450
451	return pos;	5,100,616✔
452	}	5,100,618✔
453
454	auto scheduler::remove_timer_token(timed_events::iterator pos) -> void	100,425✔
455	{
456	{
457	std::scoped_lock lk{m_timed_events_mutex};	100,425✔
458	auto is_first = (m_timed_events.begin() == pos);	100,425✔
459
460	m_timed_events.erase(pos);	100,425✔
461
462	// If this was the first item, update the timeout. It would be acceptable to just let it
463	// also fire the timeout as the event loop will ignore it since nothing will have timed
464	// out but it feels like the right thing to do to update it to the correct timeout value.
465	if (is_first)	100,425✔
466	{
467	update_timeout(clock::now());	46,822✔
468	}
469	}	100,425✔
470	}	100,425✔
471
472	auto scheduler::update_timeout(time_point now) -> void	919,501✔
473	{
474	if (!m_timed_events.empty())	919,501✔
475	{
476	auto& [tp, pi] = *m_timed_events.begin();	918,998✔
477
478	auto amount = tp - now;	918,997✔
479
480	if (!m_io_notifier.watch_timer(m_timer, amount))	918,996✔
481	{
482	std::cerr << "Failed to set timerfd errorno=[" << std::string{strerror(errno)} << "].";	×
483	}
484	}
485	else
486	{
487	m_io_notifier.unwatch_timer(m_timer);	503✔
488	}
489	}	919,502✔
490
491	} // namespace coro

jbaldwin / libcoro / 22549277350

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous