runtime.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.h"
#include "tsm/runtime/policy.h"
#include "tsm/runtime/static_ring.h"
#include "tsm/runtime/transport.h"
 
namespace tsm::runtime::detail {
 
template<typename Definition>
struct default_machine_policy
{
    using type = tsm::detail::make_hsm_t<Definition>;
};
 
template<typename Overflow>
struct overflow_strategy;
 
template<>
struct overflow_strategy<overflow::reject_newest>
{
    template<typename Queue, typename Event>
    [[nodiscard]] static bool push(Queue& queue, Event&& event)
    {
        return queue.try_push(std::forward<Event>(event));
    }
};
 
template<>
struct overflow_strategy<overflow::drop_oldest>
{
    template<typename Queue, typename Event>
    [[nodiscard]] static bool push(Queue& queue, Event&& event)
    {
        if (queue.try_push(std::forward<Event>(event))) {
            return true;
        }
        typename Queue::value_type discarded{};
        if (!queue.try_pop(discarded)) {
            return false;
        }
        return queue.try_push(std::forward<Event>(event));
    }
};
 
template<>
struct overflow_strategy<overflow::overwrite_latest>
{
    template<typename Queue, typename Event>
    [[nodiscard]] static bool push(Queue& queue, Event&& event)
    {
        if (queue.try_push(std::forward<Event>(event))) {
            return true;
        }
        return queue.try_overwrite_latest(std::forward<Event>(event));
    }
};
 
template<typename Definition,
         typename Policy,
         template<typename>
         class MachinePolicy,
         typename Topology = typename Policy::topology>
class runtime_impl;
 
template<typename Definition,
         typename Policy,
         template<typename>
         class MachinePolicy>
class runtime_impl<Definition, Policy, MachinePolicy, topology::direct_dispatch>
{
  public:
    using definition = Definition;
    using policy = Policy;
    using machine_type = typename MachinePolicy<Definition>::type;
    using context_type = typename machine_type::context_type;
    using events = tsm::detail::get_events_t<machine_type>;
 
    [[nodiscard]] machine_type& machine() noexcept
    {
        return machine_;
    }
    [[nodiscard]] machine_type const& machine() const noexcept
    {
        return machine_;
    }
 
    [[nodiscard]] context_type& context() noexcept
    {
        return machine_.context();
    }
    [[nodiscard]] context_type const& context() const noexcept
    {
        return machine_.context();
    }
 
    template<typename Event>
    requires(tsm::detail::contains_type<std::decay_t<Event>>(
      tsm::detail::as_type_list_t<events>{}))
      [[nodiscard]] bool send_event(Event&& event)
    {
        last_event_handled_ = machine_.handle(std::forward<Event>(event));
        return last_event_handled_;
    }
 
    [[nodiscard]] bool step()
    {
        last_event_handled_ = false;
        return false;
    }
 
    std::size_t drain()
    {
        return 0;
    }
 
    [[nodiscard]] bool empty() const
    {
        return true;
    }
    [[nodiscard]] std::size_t pending_events() const
    {
        return 0;
    }
    [[nodiscard]] bool last_event_handled() const
    {
        return last_event_handled_;
    }
 
  private:
    machine_type machine_{};
    bool last_event_handled_{};
};
 
template<typename Definition,
         typename Policy,
         template<typename>
         class MachinePolicy>
class runtime_impl<Definition, Policy, MachinePolicy, topology::composite_queue>
{
  public:
    using definition = Definition;
    using policy = Policy;
    using machine_type = typename MachinePolicy<Definition>::type;
    using context_type = typename machine_type::context_type;
    using events = tsm::detail::get_events_t<machine_type>;
    using queued_event = tsm::detail::erased_event<machine_type, events>;
    using queue_type = typename Policy::storage::template queue<queued_event>;
 
    static_assert(queue_storage<queue_type, queued_event>,
                  "tsm: composite queue storage must satisfy queue_storage");
 
    [[nodiscard]] machine_type& machine() noexcept
    {
        return machine_;
    }
    [[nodiscard]] machine_type const& machine() const noexcept
    {
        return machine_;
    }
 
    [[nodiscard]] context_type& context() noexcept
    {
        return machine_.context();
    }
    [[nodiscard]] context_type const& context() const noexcept
    {
        return machine_.context();
    }
 
    template<typename Event>
    requires(tsm::detail::contains_type<std::decay_t<Event>>(
      tsm::detail::as_type_list_t<events>{}))
      [[nodiscard]] bool send_event(Event&& event)
    {
        queued_event queued(std::forward<Event>(event));
        return overflow_strategy<typename Policy::overflow>::push(
          event_queue_, std::move(queued));
    }
 
    [[nodiscard]] bool step()
    {
        queued_event event{};
        if (!event_queue_.try_pop(event)) {
            last_event_handled_ = false;
            return false;
        }
        last_event_handled_ = event.dispatch(machine_);
        return true;
    }
 
    std::size_t drain()
    {
        std::size_t dispatched{};
        while (!event_queue_.empty()) {
            static_cast<void>(step());
            ++dispatched;
        }
        return dispatched;
    }
 
    [[nodiscard]] bool empty() const
    {
        return event_queue_.empty();
    }
    [[nodiscard]] std::size_t pending_events() const
    {
        return event_queue_.size();
    }
    [[nodiscard]] bool last_event_handled() const
    {
        return last_event_handled_;
    }
 
  private:
    machine_type machine_{};
    queue_type event_queue_{};
    bool last_event_handled_{};
};
 
template<typename Machine, typename RegionDefinition, typename Storage>
class region_queue
{
  public:
    using region_definition = RegionDefinition;
    using region_hsm = typename Machine::template region_hsm<RegionDefinition>;
    using events = tsm::detail::get_events_t<region_hsm>;
    using queued_event = tsm::detail::erased_event<region_hsm, events>;
    using queue_type = typename Storage::template queue<queued_event>;
 
    static_assert(queue_storage<queue_type, queued_event>,
                  "tsm: region queue storage must satisfy queue_storage");
 
    template<typename Event>
    static consteval bool accepts()
    {
        return tsm::detail::contains_type<Event>(
          tsm::detail::as_type_list_t<events>{});
    }
 
    template<typename Event, typename Overflow>
    [[nodiscard]] bool send(Event&& event)
    {
        queued_event queued(std::forward<Event>(event));
        return overflow_strategy<Overflow>::push(queue_, std::move(queued));
    }
 
    [[nodiscard]] bool step(Machine& machine, bool& handled)
    {
        queued_event event{};
        if (!queue_.try_pop(event)) {
            return false;
        }
        handled = event.dispatch(machine.template region<RegionDefinition>());
        return true;
    }
 
    [[nodiscard]] bool empty() const
    {
        return queue_.empty();
    }
    [[nodiscard]] std::size_t pending_events() const
    {
        return queue_.size();
    }
 
  private:
    queue_type queue_{};
};
 
template<typename... RegionDefinitions,
         typename Policy,
         template<typename>
         class MachinePolicy>
class runtime_impl<tsm::detail::OrthogonalExecutionPolicy<RegionDefinitions...>,
                   Policy,
                   MachinePolicy,
                   topology::per_region_queue>
{
  public:
    using definition =
      tsm::detail::OrthogonalExecutionPolicy<RegionDefinitions...>;
    using policy = Policy;
    using machine_type = definition;
    using regions = typename machine_type::regions;
    using queues = std::tuple<region_queue<machine_type,
                                           RegionDefinitions,
                                           typename Policy::storage>...>;
 
    [[nodiscard]] machine_type& machine() noexcept
    {
        return machine_;
    }
    [[nodiscard]] machine_type const& machine() const noexcept
    {
        return machine_;
    }
 
    template<typename RegionDefinition, typename Event>
    [[nodiscard]] bool send_event(Event&& event)
    {
        using event_type = std::decay_t<Event>;
        using queue_holder = region_queue<machine_type,
                                          RegionDefinition,
                                          typename Policy::storage>;
        static_assert(queue_holder::template accepts<event_type>(),
                      "tsm: region queue cannot accept this event type");
        return std::get<queue_holder>(queues_)
          .template send<Event, typename Policy::overflow>(
            std::forward<Event>(event));
    }
 
    template<typename Event>
    [[nodiscard]] bool broadcast_event(Event const& event)
    {
        bool accepted = true;
        bool matched = false;
        broadcast_event_impl<std::decay_t<Event>, 0U>(event, accepted, matched);
        return matched && accepted;
    }
 
    [[nodiscard]] bool step()
    {
        last_event_handled_ = false;
        return step_region<0U>();
    }
 
    std::size_t drain()
    {
        std::size_t dispatched{};
        while (!empty()) {
            static_cast<void>(step());
            ++dispatched;
        }
        return dispatched;
    }
 
    [[nodiscard]] bool empty() const
    {
        return empty_region<0U>();
    }
 
    [[nodiscard]] std::size_t pending_events() const
    {
        return pending_region<0U>();
    }
 
    [[nodiscard]] bool last_event_handled() const
    {
        return last_event_handled_;
    }
 
  private:
    template<std::size_t Index>
    [[nodiscard]] bool step_region()
    {
        if constexpr (Index < sizeof...(RegionDefinitions)) {
            using RegionDefinition = tsm::detail::type_at_t<Index, regions>;
            using queue_holder = region_queue<machine_type,
                                              RegionDefinition,
                                              typename Policy::storage>;
            if (std::get<queue_holder>(queues_).step(machine_,
                                                     last_event_handled_)) {
                return true;
            }
            return step_region<Index + 1U>();
        } else {
            return false;
        }
    }
 
    template<std::size_t Index>
    [[nodiscard]] bool empty_region() const
    {
        if constexpr (Index < sizeof...(RegionDefinitions)) {
            using RegionDefinition = tsm::detail::type_at_t<Index, regions>;
            using queue_holder = region_queue<machine_type,
                                              RegionDefinition,
                                              typename Policy::storage>;
            return std::get<queue_holder>(queues_).empty() &&
                   empty_region<Index + 1U>();
        } else {
            return true;
        }
    }
 
    template<std::size_t Index>
    [[nodiscard]] std::size_t pending_region() const
    {
        if constexpr (Index < sizeof...(RegionDefinitions)) {
            using RegionDefinition = tsm::detail::type_at_t<Index, regions>;
            using queue_holder = region_queue<machine_type,
                                              RegionDefinition,
                                              typename Policy::storage>;
            return std::get<queue_holder>(queues_).pending_events() +
                   pending_region<Index + 1U>();
        } else {
            return 0;
        }
    }
 
    template<typename Event, std::size_t Index>
    void broadcast_event_impl(Event const& event, bool& accepted, bool& matched)
    {
        if constexpr (Index < sizeof...(RegionDefinitions)) {
            using RegionDefinition = tsm::detail::type_at_t<Index, regions>;
            using queue_holder = region_queue<machine_type,
                                              RegionDefinition,
                                              typename Policy::storage>;
            if constexpr (queue_holder::template accepts<Event>()) {
                matched = true;
                accepted =
                  std::get<queue_holder>(queues_)
                    .template send<Event const&, typename Policy::overflow>(
                      event) &&
                  accepted;
            }
            broadcast_event_impl<Event, Index + 1U>(event, accepted, matched);
        }
    }
 
    machine_type machine_{};
    queues queues_{};
    bool last_event_handled_{};
};
 
} // namespace tsm::runtime::detail
 
namespace tsm::runtime {
 
template<typename Definition,
         typename Policy,
         template<typename> class MachinePolicy =
           detail::default_machine_policy>
using Runtime = detail::runtime_impl<Definition, Policy, MachinePolicy>;
 
template<typename Definition,
         typename Policy,
         template<typename> class MachinePolicy =
           detail::default_machine_policy>
using runtime_for = Runtime<Definition, Policy, MachinePolicy>;
 
template<typename Definition,
         template<typename> class MachinePolicy =
           detail::default_machine_policy>
using direct_runtime =
  Runtime<Definition,
          ::tsm::runtime_policy<::tsm::dispatch_model::direct,
                                ::tsm::queue_policy<::tsm::static_storage<2>>>,
          MachinePolicy>;
 
template<typename Definition,
         std::size_t Capacity,
         typename Overflow = overflow::reject_newest,
         template<typename> class MachinePolicy =
           detail::default_machine_policy>
using queued_runtime =
  Runtime<Definition,
          ::tsm::runtime_policy<
            ::tsm::dispatch_model::queued,
            ::tsm::queue_policy<::tsm::target_storage<Capacity>, Overflow>>,
          MachinePolicy>;
 
template<typename Definition,
         std::size_t Capacity,
         typename Overflow = overflow::reject_newest,
         template<typename> class MachinePolicy =
           detail::default_machine_policy>
using per_region_runtime =
  Runtime<Definition,
          ::tsm::runtime_policy<
            ::tsm::dispatch_model::per_region_queued,
            ::tsm::queue_policy<::tsm::target_storage<Capacity>, Overflow>>,
          MachinePolicy>;
 
} // namespace tsm::runtime