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 "tsm/runtime/actor.h"
#include "tsm/runtime/app.h"
#include "tsm/runtime/concepts.h"
#include "tsm/runtime/coroutine.h"
#include "tsm/runtime/executor.h"
#include "tsm/runtime/policy.h"
#include "tsm/runtime/resource_manifest.h"
#include "tsm/runtime/resources.h"
#include "tsm/runtime/runtime.h"
#include "tsm/runtime/static_ring.h"
#include "tsm/runtime/sync.h"
 
namespace tsm {
 
template<typename Definition,
         typename Policy,
         template<typename> class MachinePolicy =
           runtime::detail::default_machine_policy>
using Runtime = runtime::Runtime<Definition, Policy, MachinePolicy>;
 
template<typename Definition,
         typename Policy,
         template<typename> class MachinePolicy =
           runtime::detail::default_machine_policy>
using runtime_for = Runtime<Definition, Policy, MachinePolicy>;
 
template<typename... Tasks>
class cooperative_executor : public runtime::cooperative_executor<Tasks...>
{
    using base = runtime::cooperative_executor<Tasks...>;
 
  public:
    using base::base;
};
 
template<typename... Tasks>
cooperative_executor(Tasks&...) -> cooperative_executor<Tasks...>;
 
template<typename... Tasks>
class priority_cooperative_executor
  : public runtime::priority_cooperative_executor<Tasks...>
{
    using base = runtime::priority_cooperative_executor<Tasks...>;
 
  public:
    using base::base;
};
 
template<typename... Tasks>
priority_cooperative_executor(Tasks&...)
  -> priority_cooperative_executor<Tasks...>;
 
template<typename... Runtimes>
class runtime_group : public runtime::runtime_group<Runtimes...>
{
    using base = runtime::runtime_group<Runtimes...>;
 
  public:
    using base::base;
};
 
template<typename... Runtimes>
runtime_group(Runtimes&...) -> runtime_group<Runtimes...>;
 
template<typename... Actors>
class actor_group : public runtime::actor_group<Actors...>
{
    using base = runtime::actor_group<Actors...>;
 
  public:
    using base::base;
};
 
template<typename... Actors>
actor_group(Actors&...) -> actor_group<Actors...>;
 
using runtime::actor_group_resources;
using runtime::actor_like;
using runtime::actor_link;
using runtime::actor_resources;
using runtime::actor_sink;
using runtime::actor_source;
using runtime::event_sink;
using runtime::event_source;
using runtime::input_port;
using runtime::latest_reader;
using runtime::link_all;
using runtime::make_input_port;
using runtime::make_output_port;
using runtime::output_port;
using runtime::receiver;
using runtime::sender;
 
template<typename Runtime, std::size_t Capacity = 16U>
class tick_executor : public runtime::tick_executor<Runtime, Capacity>
{
    using base = runtime::tick_executor<Runtime, Capacity>;
 
  public:
    using base::base;
};
 
template<typename Runtime>
tick_executor(Runtime&) -> tick_executor<Runtime>;
 
template<typename Runtime, std::size_t Capacity = 16U>
using delayed_event_timer = runtime::delayed_event_timer<Runtime, Capacity>;
 
template<std::size_t Capacity>
using timer_queue = runtime::timer_queue<Capacity>;
 
using inline_executor = runtime::inline_executor;
 
using resource_budget = runtime::resource_budget;
using resource_snapshot = runtime::resource_snapshot;
 
using runtime::fits;
using runtime::write_resource_manifest;
 
template<typename Runtime>
using task_resources = runtime::task_resources<Runtime>;
 
template<typename Runtime, std::size_t TimerSlots = 0U, typename... Groups>
using runtime_resources =
  runtime::runtime_resources<Runtime, TimerSlots, Groups...>;
 
template<typename Runtime,
         resource_budget Budget,
         std::size_t TimerSlots = 0U,
         typename... Groups>
using resource_contract =
  runtime::resource_contract<Runtime, Budget, TimerSlots, Groups...>;
 
template<typename Profile,
         typename Runtime,
         std::size_t TimerSlots = 0U,
         typename... Groups>
using profile_resource_contract =
  runtime::profile_resource_contract<Profile, Runtime, TimerSlots, Groups...>;
 
template<typename Definition>
using direct_runtime = Runtime<
  Definition,
  runtime_policy<dispatch_model::direct, queue_policy<static_storage<2>>>>;
 
template<typename Definition,
         std::size_t Capacity,
         typename Overflow = overflow::reject_newest>
using queued_runtime =
  Runtime<Definition,
          runtime_policy<dispatch_model::queued,
                         queue_policy<target_storage<Capacity>, Overflow>>>;
 
template<typename Definition,
         std::size_t Capacity,
         typename Overflow = overflow::reject_newest>
using per_region_runtime =
  Runtime<Definition,
          runtime_policy<dispatch_model::per_region_queued,
                         queue_policy<target_storage<Capacity>, Overflow>>>;
 
} // namespace tsm