@@ -0,0 +1,237 @@
|
||||
#pragma once
|
||||
#include "channel.hpp"
|
||||
#include "diagnostics.hpp"
|
||||
#include "fanout.hpp"
|
||||
#include "node.hpp"
|
||||
#include "port.hpp"
|
||||
#include "tmp/fanout_groups.hpp"
|
||||
#include "tmp/topo_sort.hpp"
|
||||
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <tuple>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
namespace kpn {
|
||||
|
||||
// ── Edge descriptor ───────────────────────────────────────────────────────────
|
||||
//
|
||||
// Carries compile-time type info and runtime references to the two endpoints.
|
||||
// Constructed by the edge() factory; consumed by make_network().
|
||||
|
||||
template<typename SrcNode, std::size_t SrcIdx,
|
||||
typename DstNode, std::size_t DstIdx>
|
||||
struct Edge {
|
||||
using src_node_t = SrcNode;
|
||||
using dst_node_t = DstNode;
|
||||
static constexpr std::size_t src_idx = SrcIdx;
|
||||
static constexpr std::size_t dst_idx = DstIdx;
|
||||
|
||||
SrcNode& src;
|
||||
DstNode& dst;
|
||||
};
|
||||
|
||||
template<typename SrcNode, std::size_t SrcIdx,
|
||||
typename DstNode, std::size_t DstIdx>
|
||||
auto edge(OutputPort<SrcNode, SrcIdx>, InputPort<DstNode, DstIdx> in)
|
||||
-> Edge<SrcNode, SrcIdx, DstNode, DstIdx>; // deduction only; defined below
|
||||
|
||||
template<typename SrcNode, std::size_t SrcIdx,
|
||||
typename DstNode, std::size_t DstIdx>
|
||||
Edge<SrcNode, SrcIdx, DstNode, DstIdx>
|
||||
edge(OutputPort<SrcNode, SrcIdx> out, InputPort<DstNode, DstIdx> in) {
|
||||
return {out.node, in.node};
|
||||
}
|
||||
|
||||
// ── StaticNetwork ─────────────────────────────────────────────────────────────
|
||||
|
||||
// node_label<NodeT>: returns Label NTTP as string_view if present, else empty.
|
||||
template<typename NodeT, typename = void>
|
||||
struct node_label_helper {
|
||||
static constexpr std::string_view value = "";
|
||||
};
|
||||
template<typename NodeT>
|
||||
struct node_label_helper<NodeT, std::void_t<decltype(NodeT::label())>> {
|
||||
static constexpr std::string_view value = NodeT::label();
|
||||
};
|
||||
|
||||
template<typename NodeT>
|
||||
inline constexpr std::string_view node_label_v = node_label_helper<NodeT>::value;
|
||||
|
||||
// node_display_name<NodeT, UniqueTag>: Label if non-empty, else "node[UniqueTag]"
|
||||
// Returned as std::string at runtime (called once at StaticNetwork construction).
|
||||
template<typename NodeT>
|
||||
std::string node_display_name() {
|
||||
constexpr std::string_view lbl = node_label_v<NodeT>;
|
||||
if constexpr (!lbl.empty()) {
|
||||
return std::string(lbl);
|
||||
} else if constexpr (requires { NodeT::unique_tag; }) {
|
||||
return "node[" + std::to_string(NodeT::unique_tag) + "]";
|
||||
} else {
|
||||
return "node[?]";
|
||||
}
|
||||
}
|
||||
|
||||
template<typename FanoutStorage, typename TopoNodeList>
|
||||
class StaticNetwork : public INode {
|
||||
public:
|
||||
// FanoutStorage = std::tuple<FanoutNode<T0,N0>, ...> (owned, heap-allocated)
|
||||
// TopoNodeList = tmp::TypeList<NodeA, NodeB, ...> sources-first
|
||||
|
||||
StaticNetwork(std::unique_ptr<FanoutStorage> fanouts,
|
||||
std::vector<INode*> user_nodes_topo,
|
||||
std::vector<INode*> fanout_ptrs,
|
||||
std::vector<std::string> user_node_names)
|
||||
: fanouts_(std::move(fanouts))
|
||||
, user_nodes_topo_(std::move(user_nodes_topo))
|
||||
, fanout_nodes_ptr_(std::move(fanout_ptrs))
|
||||
, user_node_names_(std::move(user_node_names))
|
||||
{}
|
||||
|
||||
~StaticNetwork() override { stop(); }
|
||||
|
||||
void start() override {
|
||||
stop_flag_ = false;
|
||||
for (auto* n : user_nodes_topo_) n->start();
|
||||
for (auto* n : fanout_nodes_ptr_) n->start();
|
||||
}
|
||||
|
||||
void stop() override {
|
||||
stop_flag_ = true;
|
||||
for (auto it = fanout_nodes_ptr_.rbegin(); it != fanout_nodes_ptr_.rend(); ++it)
|
||||
(*it)->stop();
|
||||
for (auto it = user_nodes_topo_.rbegin(); it != user_nodes_topo_.rend(); ++it)
|
||||
(*it)->stop();
|
||||
}
|
||||
|
||||
bool running() const override { return !stop_flag_; }
|
||||
|
||||
void set_name(std::string name) override { name_ = std::move(name); }
|
||||
const NodeStats& stats() const override { static NodeStats dummy; return dummy; }
|
||||
NodeSnapshot node_snapshot(const std::string& n, double) const override {
|
||||
return {n, 0, 0, 0, 0, 0, 0, 0};
|
||||
}
|
||||
|
||||
// Print diagnostics using compile-time node labels
|
||||
void print_diagnostics(std::ostream& os = std::cerr) const {
|
||||
os << "\n┌─ KPN++ StaticNetwork diagnostics ─────────────────────────────\n";
|
||||
for (std::size_t i = 0; i < user_nodes_topo_.size(); ++i) {
|
||||
auto snap = user_nodes_topo_[i]->node_snapshot(user_node_names_[i], 0.0);
|
||||
os << "│ " << snap.name
|
||||
<< " frames=" << snap.frames_processed
|
||||
<< " ema=" << snap.ema_exec_ms << "ms\n";
|
||||
}
|
||||
os << "└────────────────────────────────────────────────────────────────\n";
|
||||
}
|
||||
|
||||
FanoutStorage& fanouts_storage() { return *fanouts_; }
|
||||
|
||||
private:
|
||||
std::string name_;
|
||||
bool stop_flag_{false};
|
||||
std::unique_ptr<FanoutStorage> fanouts_;
|
||||
std::vector<INode*> user_nodes_topo_;
|
||||
std::vector<INode*> fanout_nodes_ptr_;
|
||||
std::vector<std::string> user_node_names_; // parallel to user_nodes_topo_
|
||||
};
|
||||
|
||||
// ── make_network ──────────────────────────────────────────────────────────────
|
||||
|
||||
template<typename... Edges>
|
||||
auto make_network(Edges&&... edges) {
|
||||
// 1. Expand edges — detect fan-outs, splice FanoutNodes
|
||||
using FanoutSto = tmp::fanout_storage_t<std::decay_t<Edges>...>;
|
||||
using ExpandedEdges = tmp::expanded_edges_t<std::decay_t<Edges>...>;
|
||||
|
||||
// 2. Duplicate-tag check — fires before cycle check for a cleaner error message
|
||||
using UserNodes = typename tmp::all_node_types<tmp::TypeList<std::decay_t<Edges>...>>::type;
|
||||
static_assert(!tmp::has_duplicate_tags_v<std::decay_t<Edges>...>,
|
||||
"make_network: two nodes have the same (Func, UniqueTag) — they are "
|
||||
"indistinguishable as graph vertices. Add a UniqueTag: "
|
||||
"make_node<func, \"label\", 1>(capacity)");
|
||||
|
||||
// 3. Cycle check
|
||||
using Topo = tmp::topo_sort<ExpandedEdges>;
|
||||
constexpr bool has_cycle = Topo::has_cycle;
|
||||
static_assert(!has_cycle,
|
||||
"make_network: graph contains a directed cycle");
|
||||
|
||||
// 4. Construct owned fanout storage on the heap (FanoutNode has jthread — not moveable)
|
||||
auto fanout_storage = std::make_unique<FanoutSto>();
|
||||
|
||||
// 5. Collect unique user node pointers + their display names, in edge-declaration order
|
||||
std::vector<INode*> user_node_ptrs;
|
||||
std::vector<std::string> user_node_names;
|
||||
auto collect = [&](auto& e) {
|
||||
using SrcT = std::decay_t<decltype(e.src)>;
|
||||
using DstT = std::decay_t<decltype(e.dst)>;
|
||||
auto* s = static_cast<INode*>(&e.src);
|
||||
auto* d = static_cast<INode*>(&e.dst);
|
||||
if (std::find(user_node_ptrs.begin(), user_node_ptrs.end(), s) == user_node_ptrs.end()) {
|
||||
user_node_ptrs.push_back(s);
|
||||
user_node_names.push_back(node_display_name<SrcT>());
|
||||
}
|
||||
if (std::find(user_node_ptrs.begin(), user_node_ptrs.end(), d) == user_node_ptrs.end()) {
|
||||
user_node_ptrs.push_back(d);
|
||||
user_node_names.push_back(node_display_name<DstT>());
|
||||
}
|
||||
};
|
||||
(collect(edges), ...);
|
||||
|
||||
// 5. Wire all expanded SimpleEdges.
|
||||
// find_node<NodeT>: searches fanout storage then user edge pack, returns NodeT*.
|
||||
// Uses if constexpr in a fold so mismatched types never reach assignment.
|
||||
auto find_node = [&]<typename NodeT>() -> NodeT* {
|
||||
NodeT* ptr = nullptr;
|
||||
std::apply([&](auto&... fn) {
|
||||
([&](auto& node) {
|
||||
if constexpr (std::is_same_v<std::decay_t<decltype(node)>, NodeT>)
|
||||
if (!ptr) ptr = &node;
|
||||
}(fn), ...);
|
||||
}, *fanout_storage);
|
||||
if (!ptr) {
|
||||
([&](auto& e) {
|
||||
if (!ptr) {
|
||||
if constexpr (std::is_same_v<std::decay_t<decltype(e.src)>, NodeT>)
|
||||
ptr = &e.src;
|
||||
else if constexpr (std::is_same_v<std::decay_t<decltype(e.dst)>, NodeT>)
|
||||
ptr = &e.dst;
|
||||
}
|
||||
}(edges), ...);
|
||||
}
|
||||
return ptr;
|
||||
};
|
||||
|
||||
auto wire_one = [&]<typename SE>(SE) {
|
||||
using SrcNode = typename SE::src_node_t;
|
||||
using DstNode = typename SE::dst_node_t;
|
||||
constexpr std::size_t SrcIdx = SE::src_idx;
|
||||
constexpr std::size_t DstIdx = SE::dst_idx;
|
||||
|
||||
auto* src = find_node.template operator()<SrcNode>();
|
||||
auto* dst = find_node.template operator()<DstNode>();
|
||||
if (src && dst)
|
||||
src->template set_output_channel<SrcIdx>(
|
||||
&dst->template input_channel<DstIdx>());
|
||||
};
|
||||
|
||||
[&]<typename... SEs>(tmp::TypeList<SEs...>) {
|
||||
(wire_one(SEs{}), ...);
|
||||
}(ExpandedEdges{});
|
||||
|
||||
// 6. Collect fanout node pointers
|
||||
std::vector<INode*> fanout_ptrs;
|
||||
std::apply([&](auto&... fn) {
|
||||
(fanout_ptrs.push_back(static_cast<INode*>(&fn)), ...);
|
||||
}, *fanout_storage);
|
||||
|
||||
// 7. Construct and return the StaticNetwork
|
||||
using Net = StaticNetwork<FanoutSto, typename Topo::topo>;
|
||||
return Net(std::move(fanout_storage),
|
||||
std::move(user_node_ptrs),
|
||||
std::move(fanout_ptrs),
|
||||
std::move(user_node_names));
|
||||
}
|
||||
|
||||
} // namespace kpn
|
||||
Reference in New Issue
Block a user