actor.h

Go to the documentation of this file.

// Copyright (c) 2026 Tinverse LLC. All rights reserved.
// SPDX-License-Identifier: LicenseRef-Tinverse-Commercial
 
 
#pragma once
 
#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include "tsm/runtime/concepts.h"
#include "tsm/runtime/resources.h"
 
namespace tsm::runtime {
 
template<typename Actor>
struct actor_resources;
 
// clang-format disagrees across the versions used by local toolchains and CI
// for C++20 requires-expressions. Keep this declaration block stable.
// clang-format off
template<typename Actor>
concept actor_like = requires(Actor actor) {
    { actor.step() } -> std::convertible_to<bool>;
    { actor.drain() } -> std::convertible_to<std::size_t>;
    { actor.empty() } -> std::convertible_to<bool>;
    { actor.pending_events() } -> std::convertible_to<std::size_t>;
};
 
template<typename Actor, typename Event>
concept actor_sink = requires(Actor actor, Event event) {
    { actor.send_event(event) } -> std::convertible_to<bool>;
};
 
template<typename Actor, typename Event>
concept actor_source = requires(Actor actor, Event& event) {
    { actor.try_receive(event) } -> std::convertible_to<bool>;
};
 
template<typename Event, typename Sink>
struct input_port
{
    using event_type = Event;
 
    using sink_type = Sink;
 
    explicit constexpr input_port(Sink& sink)
      : sink_(&sink)
    {
    }
 
    [[nodiscard]] bool try_send(Event const& event) const
        requires actor_sink<Sink, Event>
    {
        return sink_->send_event(event);
    }
 
    [[nodiscard]] bool try_send(Event&& event) const
        requires actor_sink<Sink, Event>
    {
        return sink_->send_event(std::move(event));
    }
 
    [[nodiscard]] bool send_event(Event const& event) const
        requires actor_sink<Sink, Event>
    {
        return try_send(event);
    }
 
    [[nodiscard]] bool send_event(Event&& event) const
        requires actor_sink<Sink, Event>
    {
        return try_send(std::move(event));
    }
 
  private:
    Sink* sink_{};
};
 
template<typename Event, typename Source>
struct output_port
{
    using event_type = Event;
 
    using source_type = Source;
 
    explicit constexpr output_port(Source& source)
      : source_(&source)
    {
    }
 
    [[nodiscard]] bool try_receive(Event& event) const
        requires actor_source<Source, Event>
    {
        return source_->try_receive(event);
    }
 
  private:
    Source* source_{};
};
 
template<typename Event, typename Sink>
[[nodiscard]] constexpr input_port<Event, Sink>
make_input_port(Sink& sink)
{
    return input_port<Event, Sink>{ sink };
}
 
template<typename Event, typename Source>
[[nodiscard]] constexpr output_port<Event, Source>
make_output_port(Source& source)
{
    return output_port<Event, Source>{ source };
}
 
template<typename Source, typename Sink>
concept compatible_link = requires {
    typename Source::event_type;
    typename Sink::event_type;
    requires std::same_as<typename Source::event_type,
                          typename Sink::event_type>;
} && requires(Source source, Sink sink, typename Source::event_type event) {
    { source.try_receive(event) } -> std::convertible_to<bool>;
    { sink.try_send(event) } -> std::convertible_to<bool>;
};
 
template<typename Source, typename Sink>
struct actor_link
{
    using event_type = typename Source::event_type;
 
    constexpr actor_link(Source& source, Sink& sink)
      : source_(&source)
      , sink_(&sink)
    {
    }
 
    [[nodiscard]] bool step()
    {
        if (has_pending_) {
            if (!sink_->try_send(pending_)) {
                return false;
            }
            has_pending_ = false;
            return true;
        }
 
        if (!source_->try_receive(pending_)) {
            return false;
        }
        has_pending_ = true;
        if (!sink_->try_send(pending_)) {
            return false;
        }
        has_pending_ = false;
        return true;
    }
 
    [[nodiscard]] bool pending() const noexcept
    {
        return has_pending_;
    }
 
  private:
    Source* source_{};
    Sink* sink_{};
    event_type pending_{};
    bool has_pending_{};
};
 
template<typename Source, typename Sink>
actor_link(Source&, Sink&) -> actor_link<Source, Sink>;
 
template<typename... Links>
[[nodiscard]] bool
link_all(Links&... links)
{
    bool progressed{};
    ((progressed = links.step() || progressed), ...);
    return progressed;
}
 
template<actor_like... Actors>
struct actor_group
{
    explicit constexpr actor_group(Actors&... actors)
      : actors_(&actors...)
    {
    }
 
    [[nodiscard]] bool step()
    {
        bool progressed{};
        std::apply(
          [&progressed](auto*... actor) {
              ((progressed = actor->step() || progressed), ...);
          },
          actors_);
        return progressed;
    }
 
    std::size_t drain()
    {
        std::size_t rounds{};
        while (step()) {
            ++rounds;
        }
        return rounds;
    }
 
    [[nodiscard]] bool empty() const
    {
        bool all_empty{ true };
        std::apply(
          [&all_empty](auto const*... actor) {
              ((all_empty = all_empty && actor->empty()), ...);
          },
          actors_);
        return all_empty;
    }
 
    [[nodiscard]] std::size_t pending_events() const
    {
        std::size_t pending{};
        std::apply(
          [&pending](auto const*... actor) {
              ((pending += actor->pending_events()), ...);
          },
          actors_);
        return pending;
    }
 
  private:
    std::tuple<Actors*...> actors_;
};
 
template<typename... Actors>
actor_group(Actors&...) -> actor_group<Actors...>;
 
namespace detail {
 
template<typename Actor, typename = void>
struct has_runtime_resource_shape : std::false_type
{};
 
template<typename Actor>
struct has_runtime_resource_shape<
  Actor,
  std::void_t<typename Actor::events, typename Actor::policy>> : std::true_type
{};
 
template<typename Actor, typename = void>
struct has_custom_resource_snapshot : std::false_type
{};
 
template<typename Actor>
struct has_custom_resource_snapshot<
  Actor,
  std::void_t<decltype(Actor::resource_snapshot())>> : std::true_type
{};
// clang-format on
 
[[nodiscard]] consteval resource_snapshot
add_resource_snapshots(resource_snapshot lhs, resource_snapshot rhs)
{
    return resource_snapshot{
        lhs.max_event_bytes > rhs.max_event_bytes ? lhs.max_event_bytes
                                                  : rhs.max_event_bytes,
        lhs.max_event_alignment > rhs.max_event_alignment
          ? lhs.max_event_alignment
          : rhs.max_event_alignment,
        lhs.queue_slots + rhs.queue_slots,
        lhs.delayed_event_timer_slots + rhs.delayed_event_timer_slots,
        lhs.task_count + rhs.task_count,
        lhs.task_group_count + rhs.task_group_count,
        lhs.task_group_entry_count + rhs.task_group_entry_count,
        lhs.task_arena_bytes + rhs.task_arena_bytes,
        lhs.task_timer_slots + rhs.task_timer_slots,
        lhs.uses_heap || rhs.uses_heap
    };
}
 
} // namespace detail
 
template<typename Actor>
struct actor_resources
{
    static consteval resource_snapshot snapshot()
    {
        if constexpr (detail::has_runtime_resource_shape<Actor>::value) {
            return runtime_resources<Actor>::snapshot();
        } else if constexpr (detail::has_custom_resource_snapshot<
                               Actor>::value) {
            return Actor::resource_snapshot();
        } else {
            return resource_snapshot{};
        }
    }
};
 
template<typename... Actors>
struct actor_group_resources
{
    static consteval resource_snapshot snapshot()
    {
        resource_snapshot total{};
        ((total = detail::add_resource_snapshots(
            total, actor_resources<Actors>::snapshot())),
         ...);
        return total;
    }
 
    static consteval bool fits_within(resource_budget const& budget)
    {
        return fits(snapshot(), budget);
    }
};
 
} // namespace tsm::runtime