resources.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 "tsm.h"
#include "tsm/runtime/coroutine.h"
 
namespace tsm::runtime {
 
struct resource_snapshot
{
    std::size_t max_event_bytes{};
    std::size_t max_event_alignment{};
    std::size_t queue_slots{};
    std::size_t delayed_event_timer_slots{};
    std::size_t task_count{};
    std::size_t task_group_count{};
    std::size_t task_group_entry_count{};
    std::size_t task_arena_bytes{};
    std::size_t task_timer_slots{};
    bool uses_heap{};
};
 
struct resource_budget
{
    std::size_t max_event_bytes{};
    std::size_t max_event_alignment{};
    std::size_t queue_slots{};
    std::size_t delayed_event_timer_slots{};
    std::size_t task_count{};
    std::size_t task_group_count{};
    std::size_t task_group_entry_count{};
    std::size_t task_arena_bytes{};
    std::size_t task_timer_slots{};
    bool allow_heap{};
};
 
[[nodiscard]] consteval bool
fits(resource_snapshot const& snapshot, resource_budget const& budget)
{
    return snapshot.max_event_bytes <= budget.max_event_bytes &&
           snapshot.max_event_alignment <= budget.max_event_alignment &&
           snapshot.queue_slots <= budget.queue_slots &&
           snapshot.delayed_event_timer_slots <=
             budget.delayed_event_timer_slots &&
           snapshot.task_count <= budget.task_count &&
           snapshot.task_group_count <= budget.task_group_count &&
           snapshot.task_group_entry_count <= budget.task_group_entry_count &&
           snapshot.task_arena_bytes <= budget.task_arena_bytes &&
           snapshot.task_timer_slots <= budget.task_timer_slots &&
           (!snapshot.uses_heap || budget.allow_heap);
}
 
namespace detail {
 
template<typename Storage, typename = void>
struct storage_capacity
{
    static constexpr std::size_t value = 0U;
};
 
template<typename Storage>
struct storage_capacity<Storage, std::void_t<decltype(Storage::capacity)>>
{
    static constexpr std::size_t value = Storage::capacity;
};
 
} // namespace detail
 
template<typename... Groups>
struct task_group_resources
{
    static constexpr std::size_t group_count = sizeof...(Groups);
    static constexpr std::size_t entry_count = (Groups::size + ... + 0U);
};
 
template<typename Runtime, std::size_t TimerSlots = 0U, typename... Groups>
struct runtime_resources
{
    using runtime_type = Runtime;
    using events = typename Runtime::events;
    using event_list = tsm::detail::as_type_list_t<events>;
    using task_summary = task_resources<Runtime>;
 
    static constexpr std::size_t max_event_bytes =
      tsm::detail::max_sizeof(event_list{});
    static constexpr std::size_t max_event_alignment =
      tsm::detail::max_alignof(event_list{});
    static constexpr std::size_t queue_slots =
      detail::storage_capacity<typename Runtime::policy::storage>::value;
    static constexpr std::size_t delayed_event_timer_slots = TimerSlots;
    static constexpr std::size_t task_count = task_summary::task_count;
    static constexpr std::size_t task_group_count =
      task_group_resources<Groups...>::group_count;
    static constexpr std::size_t task_group_entry_count =
      task_group_resources<Groups...>::entry_count;
    static constexpr std::size_t task_arena_bytes = task_summary::arena_bytes;
    static constexpr std::size_t task_timer_slots = task_summary::timer_slots;
    static constexpr bool uses_heap = false;
 
    static consteval resource_snapshot snapshot()
    {
        return resource_snapshot{ max_event_bytes,
                                  max_event_alignment,
                                  queue_slots,
                                  delayed_event_timer_slots,
                                  task_count,
                                  task_group_count,
                                  task_group_entry_count,
                                  task_arena_bytes,
                                  task_timer_slots,
                                  uses_heap };
    }
 
    static consteval bool fits_within(resource_budget const& budget)
    {
        return fits(snapshot(), budget);
    }
};
 
template<typename Runtime,
         resource_budget Budget,
         std::size_t TimerSlots = 0U,
         typename... Groups>
struct resource_contract
{
    using resources = runtime_resources<Runtime, TimerSlots, Groups...>;
    static constexpr bool fits = resources::fits_within(Budget);
 
    static_assert(fits,
                  "tsm: runtime resource snapshot exceeds declared budget");
};
 
template<typename Profile,
         typename Runtime,
         std::size_t TimerSlots = 0U,
         typename... Groups>
struct profile_resource_contract
{
    using resources = runtime_resources<Runtime, TimerSlots, Groups...>;
 
    static_assert(Profile::heap_allowed || !resources::uses_heap,
                  "tsm: target profile forbids heap-backed runtime storage");
    static_assert(Profile::tick_driven_time,
                  "tsm: runtime resources require tick-driven time semantics");
};
 
} // namespace tsm::runtime