host_loop.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <runtime/host.h>
 
#include <asio/any_io_executor.hpp>
#include <asio/awaitable.hpp>
#include <asio/co_spawn.hpp>
#include <asio/execution_context.hpp>
#include <asio/io_context.hpp>
#include <asio/prefer.hpp>
#include <asio/query.hpp>
#include <asio/require.hpp>
 
#include <chrono>
#include <cstddef>
#include <exception>
#include <functional>
#include <memory>
#include <type_traits>
#include <utility>
 
namespace neograph::async {
 
namespace detail {
class HostLoopCore;
NEOGRAPH_API void host_loop_wake(HostLoopCore* core) noexcept;
 
template <typename Executor>
class PumpedExecutor {
public:
    PumpedExecutor(Executor executor, HostLoopCore* core) noexcept
        : executor_(std::move(executor)), core_(core) {}
 
    template <typename Function>
    void execute(Function&& function) const {
        executor_.execute(std::forward<Function>(function));
        host_loop_wake(core_);
    }
 
    template <typename Property>
    auto query(const Property& property) const
        noexcept(noexcept(asio::query(std::declval<const Executor&>(), property)))
        -> decltype(asio::query(std::declval<const Executor&>(), property)) {
        return asio::query(executor_, property);
    }
 
    template <typename Property>
        requires asio::can_require<const Executor&, const Property&>::value
    auto require(const Property& property) const
        -> PumpedExecutor<std::decay_t<asio::require_result_t<const Executor&, const Property&>>> {
        return {asio::require(executor_, property), core_};
    }
 
    template <typename Property>
        requires asio::can_prefer<const Executor&, const Property&>::value
    auto prefer(const Property& property) const
        -> PumpedExecutor<std::decay_t<asio::prefer_result_t<const Executor&, const Property&>>> {
        return {asio::prefer(executor_, property), core_};
    }
 
    friend bool operator==(const PumpedExecutor& left, const PumpedExecutor& right) noexcept {
        return left.core_ == right.core_ && left.executor_ == right.executor_;
    }
    friend bool operator!=(const PumpedExecutor& left, const PumpedExecutor& right) noexcept {
        return !(left == right);
    }
 
private:
    Executor executor_;
    HostLoopCore* core_;
};
}  // namespace detail
 
struct HostLoopOptions {
    std::size_t turn_handlers = 256;
    std::function<void(std::exception_ptr)> on_error;
};
 
class NEOGRAPH_API HostLoop {
public:
    using Options = HostLoopOptions;
 
    explicit HostLoop(std::shared_ptr<sp::runtime::Executor> host, Options options = {});
    ~HostLoop();
    HostLoop(const HostLoop&) = delete;
    HostLoop& operator=(const HostLoop&) = delete;
 
    asio::any_io_executor executor();
 
    template <typename T, typename Done>
    void spawn(asio::awaitable<T> work, Done done) {
        asio::co_spawn(executor(), std::move(work), std::move(done));
        wake();
    }
 
    void wake() noexcept;
    void wake_at(sp::runtime::SteadyTime at) noexcept;
    void forget_at(sp::runtime::SteadyTime at) noexcept;
 
    bool idle() const noexcept;
 
private:
    std::shared_ptr<detail::HostLoopCore> core_;
};
 
NEOGRAPH_API void note_deadline(const asio::any_io_executor& executor,
                                std::chrono::steady_clock::time_point at) noexcept;
 
NEOGRAPH_API void forget_deadline(const asio::any_io_executor& executor,
                                  std::chrono::steady_clock::time_point at) noexcept;
 
NEOGRAPH_API bool is_host_pumped(const asio::any_io_executor& executor) noexcept;
 
NEOGRAPH_API bool in_host_turn() noexcept;
 
}  // namespace neograph::async