22548904004

Committed 01 Mar 2026 05:43PM UTC coverage: 86.397%. First build

Build # 22548904004

Build Type

Pull #444

github

Committed by

web-flow

Commit Message

Merge b8063b6c5 into 0161911f2

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

Run Details

28 of 37 new or added lines in 4 files covered. (75.68%)

1880 of 2176 relevant lines covered (86.4%)

4843416.29 hits per line

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

89.77

/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);
        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(schedule_operation*);
    std::array<schedule_operation*, READ_COUNT> ops{};
    const ssize_t bytes_read = m_schedule_pipe.read(reinterpret_cast<void*>(ops.data()), READ_COUNT_BYTES);

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

    auto count = bytes_read / sizeof(schedule_operation*);
    for (uint64_t i = 0; i < count; ++i)
    {
        auto* op = ops[i];
        m_handles_to_resume.emplace_back(op->m_awaiting_coroutine);

        // Concern: the coroutine isn't resumed until it returns in the prior
        // function, should this delete be moved there as well?
        if (op->m_allocated)
        {
            delete op;
        }
    }
}

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(); });	191✔
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,636✔
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,329,584✔
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,771,688✔
160
161	auto scheduler::resume(std::coroutine_handle<> handle) -> bool	200,376✔
162	{
163	if (handle == nullptr \|\| handle.done())	200,376✔
164	{
165	return false;	×
166	}
167
168	if (m_shutdown_requested.load(std::memory_order::acquire))	200,376✔
169	{
170	return false;	×
171	}
172
173	if (m_opts.execution_strategy == execution_strategy_t::process_tasks_inline)	200,376✔
174	{
175	auto* schedule_op = new schedule_operation{*this};	99✔
176	schedule_op->m_allocated = true;	101✔
177	schedule_op->await_suspend(handle);	101✔
178	return true;	101✔
179	}
180	else
181	{
182	return m_thread_pool->resume(handle);	200,277✔
183	}
184	}
185
186	auto scheduler::shutdown() noexcept -> void	142✔
187	{
188	// Only allow shutdown to occur once.
189	if (m_shutdown_requested.exchange(true, std::memory_order::acq_rel) == false)	142✔
190	{
191	// Signal the event loop to stop asap.
192	const int value{1};	98✔
193	ssize_t written = ::write(m_shutdown_pipe.write_fd(), reinterpret_cast<const void*>(&value), sizeof(value));	98✔
194	if (written != sizeof(value))	98✔
195	{
NEW 196	std::cerr << "libcoro::scheduler::shutdown() failed to write to shutdown pipe, bytes written=" << written	×
NEW 197	<< "\n";	×
198	}
199
200	if (m_io_thread.joinable())	98✔
201	{
202	m_io_thread.join();	96✔
203	}
204
205	if (m_thread_pool != nullptr)	98✔
206	{
207	m_thread_pool->shutdown();	55✔
208	}
209	}
210	}	142✔
211
212	auto scheduler::yield_for_internal(std::chrono::nanoseconds amount) -> coro::task<void>	5,000,174✔
213	{
214	if (amount <= 0ms)
215	{
216	co_await schedule();
217	}
218	else
219	{
220	// Yield/timeout tasks are considered live in the scheduler and must be accounted for. Note
221	// that if the user gives an invalid amount and schedule() is directly called it will account
222	// for the scheduled task there.
223	m_size.fetch_add(1, std::memory_order::release);
224
225	// Yielding does not require setting the timer position on the poll info since
226	// it doesn't have a corresponding 'event' that can trigger, it always waits for
227	// the timeout to occur before resuming.
228
229	detail::poll_info pi{};
230	add_timer_token(clock::now() + amount, pi);
231	co_await pi;
232	}
233	co_return;
234	}	10,000,348✔
235
236	auto scheduler::process_events_manual(std::chrono::milliseconds timeout) -> void	4✔
237	{
238	bool expected{false};	4✔
239	if (m_io_processing.compare_exchange_strong(expected, true, std::memory_order::release, std::memory_order::relaxed))	4✔
240	{
241	process_events_execute(timeout);	4✔
242	m_io_processing.exchange(false, std::memory_order::release);	4✔
243	}
244	}	4✔
245
246	auto scheduler::process_events_dedicated_thread() -> void	96✔
247	{
248	if (m_opts.on_io_thread_start_functor != nullptr)	96✔
249	{
250	m_opts.on_io_thread_start_functor();	×
251	}
252
253	m_io_processing.exchange(true, std::memory_order::release);	96✔
254	// Execute tasks until stopped or there are no more tasks to complete.
255	while (!m_shutdown_requested.load(std::memory_order::acquire) \|\| size() > 0)	1,276,947✔
256	{
257	process_events_execute(m_default_timeout);	1,279,430✔
258	}
259	m_io_processing.exchange(false, std::memory_order::release);
260
261	if (m_opts.on_io_thread_stop_functor != nullptr)	96✔
262	{
263	m_opts.on_io_thread_stop_functor();	×
264	}
265	}	96✔
266
267	auto scheduler::process_events_execute(std::chrono::milliseconds timeout) -> void	1,281,866✔
268	{
269	// Clear the recent events without decreasing the allocated capacity to reduce allocations
270	m_recent_events.clear();	1,281,866✔
271	m_io_notifier.next_events(m_recent_events, timeout);	1,277,749✔
272
273	for (auto& [handle_ptr, poll_status] : m_recent_events)	4,717,286✔
274	{
275	if (handle_ptr == m_timer_ptr)	3,438,550✔
276	{
277	// Process all events that have timed out.
278	process_timeout_execute();	889,453✔
279	}
280	else if (handle_ptr == m_schedule_ptr)	2,549,097✔
281	{
282	// Process scheduled coroutines.
283	process_scheduled_execute_inline();	60✔
284	}
285	else if (handle_ptr == m_shutdown_ptr) [[unlikely]]	2,549,037✔
286	{
287	// Nothing to do, just needed to wake-up and smell the flowers
288	}
289	else
290	{
291	// Individual poll task wake-up.
292	process_event_execute(static_cast<detail::poll_info*>(handle_ptr), poll_status);	2,548,944✔
293	}
294	}
295
296	// Its important to not resume any handles until the full set is accounted for. If a timeout
297	// and an event for the same handle happen in the same epoll_wait() call then inline processing
298	// will destruct the poll_info object before the second event is handled. This is also possible
299	// with thread pool processing, but probably has an extremely low chance of occuring due to
300	// the thread switch required. If m_max_events == 1 this would be unnecessary.
301
302	if (!m_handles_to_resume.empty())	1,283,095✔
303	{
304	if (m_opts.execution_strategy == execution_strategy_t::process_tasks_inline)	1,282,738✔
305	{
306	std::size_t resumed{0};	237,920✔
307	for (auto& handle : m_handles_to_resume)	1,955,917✔
308	{
309	handle.resume();	1,741,140✔
310	++resumed;	1,947,331✔
311	}
312	if (resumed > 0)	167,167✔
313	{
314	m_size.fetch_sub(resumed, std::memory_order::release);	232,343✔
315	}
316	}
317	else
318	{
319	m_thread_pool->resume(m_handles_to_resume);	1,044,818✔
320	m_size.fetch_sub(m_handles_to_resume.size(), std::memory_order::release);	1,044,847✔
321	}
322
323	m_handles_to_resume.clear();	1,212,060✔
324	}
325	}	1,275,992✔
326
327	auto scheduler::process_scheduled_execute_inline() -> void	60✔
328	{
329	// This could pull until the pipe is drained, however we want to pull a discreet
330	// amount of work on each pass, 16 tasks should be a good chunk to pull each time.
331	// Pulling until the pipe is drained could result in infinite growth if scheduling
332	// of tasks is faster than this scheduler can pull.
333
334	const constexpr std::size_t READ_COUNT{16};	60✔
335	const constexpr ssize_t READ_COUNT_BYTES = READ_COUNT * sizeof(schedule_operation*);	60✔
336	std::array<schedule_operation*, READ_COUNT> ops{};	60✔
337	const ssize_t bytes_read = m_schedule_pipe.read(reinterpret_cast<void*>(ops.data()), READ_COUNT_BYTES);	60✔
338
339	// Error or nothing to read.
340	if (bytes_read <= 0)	60✔
341	{
NEW 342	return;	×
343	}
344
345	auto count = bytes_read / sizeof(schedule_operation*);	60✔
346	for (uint64_t i = 0; i < count; ++i)	296✔
347	{
348	auto* op = ops[i];	236✔
349	m_handles_to_resume.emplace_back(op->m_awaiting_coroutine);	236✔
350
351	// Concern: the coroutine isn't resumed until it returns in the prior
352	// function, should this delete be moved there as well?
353	if (op->m_allocated)	236✔
354	{
355	delete op;	101✔
356	}
357	}
358	}
359
360	auto scheduler::process_event_execute(detail::poll_info* pi, poll_status status) -> void	2,549,439✔
361	{
362	if (!pi->m_processed)	2,549,439✔
363	{
364	std::atomic_thread_fence(std::memory_order::acquire);
365	// Its possible the event and the timeout occurred in the same epoll, make sure only one
366	// is ever processed, the other is discarded.
367	pi->m_processed = true;	2,554,111✔
368
369	// Given a valid fd always remove it from epoll so the next poll can blindly EPOLL_CTL_ADD.
370	if (pi->m_fd != -1)	2,554,111✔
371	{
372	m_io_notifier.unwatch(*pi);	2,578,654✔
373	}
374
375	// Since this event triggered, remove its corresponding timeout if it has one.
376	if (pi->m_timer_pos.has_value())	2,548,763✔
377	{
378	remove_timer_token(pi->m_timer_pos.value());	100,435✔
379	}
380
381	pi->m_poll_status = status;	2,537,981✔
382
383	while (pi->m_awaiting_coroutine == nullptr)	102,669,195✔
384	{
385	std::atomic_thread_fence(std::memory_order::acquire);
386	}
387
388	m_handles_to_resume.emplace_back(pi->m_awaiting_coroutine);	2,543,377✔
389	}
390	}	2,521,515✔
391
392	auto scheduler::process_timeout_execute() -> void	889,453✔
393	{
394	std::vector<detail::poll_info*> poll_infos{};	889,453✔
395	auto now = clock::now();	889,453✔
396
397	{
398	std::scoped_lock lk{m_timed_events_mutex};	889,453✔
399	while (!m_timed_events.empty())	5,889,645✔
400	{
401	auto first = m_timed_events.begin();	5,889,585✔
402	auto [tp, pi] = *first;	5,889,585✔
403
404	if (tp <= now)	5,889,585✔
405	{
406	m_timed_events.erase(first);	5,000,192✔
407	poll_infos.emplace_back(pi);	5,000,192✔
408	}
409	else
410	{
411	break;	889,393✔
412	}
413	}
414	}	889,453✔
415
416	for (auto pi : poll_infos)	5,889,645✔
417	{
418	if (!pi->m_processed)	5,000,192✔
419	{
420	// Its possible the event and the timeout occurred in the same epoll, make sure only one
421	// is ever processed, the other is discarded.
422	pi->m_processed = true;	5,000,192✔
423
424	// Since this timed out, remove its corresponding event if it has one.
425	if (pi->m_fd != -1)	5,000,192✔
426	{
427	m_io_notifier.unwatch(*pi);	17✔
428	}
429
430	while (pi->m_awaiting_coroutine == nullptr)	5,000,192✔
431	{
432	std::atomic_thread_fence(std::memory_order::acquire);
433	}
434
435	m_handles_to_resume.emplace_back(pi->m_awaiting_coroutine);	5,000,192✔
436	pi->m_poll_status = coro::poll_status::timeout;	5,000,192✔
437	}
438	}
439
440	// Update the time to the next smallest time point, re-take the current now time
441	// since updating and resuming tasks could shift the time.
442	update_timeout(clock::now());	889,453✔
443	}	889,453✔
444
445	auto scheduler::add_timer_token(time_point tp, detail::poll_info& pi) -> timed_events::iterator	5,100,333✔
446	{
447	std::scoped_lock lk{m_timed_events_mutex};	5,100,333✔
448	auto pos = m_timed_events.emplace(tp, &pi);	5,100,626✔
449
450	// If this item was inserted as the smallest time point, update the timeout.
451	if (pos == m_timed_events.begin())	5,100,627✔
452	{
453	update_timeout(clock::now());	585✔
454	}
455
456	return pos;	5,100,619✔
457	}	5,100,627✔
458
459	auto scheduler::remove_timer_token(timed_events::iterator pos) -> void	100,435✔
460	{
461	{
462	std::scoped_lock lk{m_timed_events_mutex};	100,435✔
463	auto is_first = (m_timed_events.begin() == pos);	100,435✔
464
465	m_timed_events.erase(pos);	100,435✔
466
467	// If this was the first item, update the timeout. It would be acceptable to just let it
468	// also fire the timeout as the event loop will ignore it since nothing will have timed
469	// out but it feels like the right thing to do to update it to the correct timeout value.
470	if (is_first)	100,435✔
471	{
472	update_timeout(clock::now());	40,046✔
473	}
474	}	100,435✔
475	}	100,435✔
476
477	auto scheduler::update_timeout(time_point now) -> void	930,084✔
478	{
479	if (!m_timed_events.empty())	930,084✔
480	{
481	auto& [tp, pi] = *m_timed_events.begin();	929,648✔
482
483	auto amount = tp - now;	929,648✔
484
485	if (!m_io_notifier.watch_timer(m_timer, amount))	929,648✔
486	{
487	std::cerr << "Failed to set timerfd errorno=[" << std::string{strerror(errno)} << "].";	×
488	}
489	}
490	else
491	{
492	m_io_notifier.unwatch_timer(m_timer);	437✔
493	}
494	}	930,085✔
495
496	} // namespace coro

jbaldwin / libcoro / 22548904004

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