policy.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 <type_traits>
 
#include "tsm/runtime/concepts.h"
 
namespace tsm {
 
namespace dispatch_model {
 
struct direct
{};
struct queued
{};
struct per_region_queued
{};
 
} // namespace dispatch_model
 
namespace overflow {
 
struct reject_newest
{};
struct drop_oldest
{};
struct overwrite_latest
{};
 
} // namespace overflow
 
template<typename Storage, typename Overflow>
struct queue_policy
{
    static_assert(overflow_policy<Overflow>,
                  "tsm: queue policy requires a known overflow policy");
 
    using storage = Storage;
    using overflow = Overflow;
};
 
namespace detail {
 
template<typename QueueOrStorage, typename Overflow>
struct select_runtime_queue_policy
{
    using type = queue_policy<QueueOrStorage, Overflow>;
};
 
template<typename QueuePolicy, typename Overflow>
requires runtime::runtime_queue_policy<QueuePolicy>
struct select_runtime_queue_policy<QueuePolicy, Overflow>
{
    using type = QueuePolicy;
};
 
} // namespace detail
 
template<typename DispatchModel,
         typename QueueOrStorage,
         typename Scheduler,
         typename Overflow,
         typename Transport>
struct runtime_policy
{
  private:
    using selected_overflow =
      std::conditional_t<overflow_policy<Scheduler>, Scheduler, Overflow>;
    using selected_queue =
      typename detail::select_runtime_queue_policy<QueueOrStorage,
                                                   selected_overflow>::type;
 
  public:
    static_assert(dispatch_model_policy<DispatchModel>,
                  "tsm: runtime policy requires a known dispatch model");
    static_assert(runtime::runtime_queue_policy<selected_queue>,
                  "tsm: runtime policy requires a known queue policy");
 
    using dispatch_model = DispatchModel;
    using queue = selected_queue;
 
    using topology = DispatchModel;
    using storage = typename selected_queue::storage;
    using overflow = typename selected_queue::overflow;
};
 
namespace runtime {
 
template<typename Topology,
         typename Storage,
         typename Scheduler = void,
         typename Overflow = ::tsm::overflow::reject_newest,
         typename Transport = void>
using policy =
  ::tsm::runtime_policy<Topology, Storage, Scheduler, Overflow, Transport>;
 
} // namespace runtime
 
} // namespace tsm