StageNode.h File

Stage-backed graph node wrapper. More...

Included Headers

#include "graph/GraphTypes.h" #include "graph/Node.h" #include <cstddef> #include <functional> #include <memory> #include <string> #include <utility> #include <vector>

Namespaces Index

namespace	simaai
namespace	neat
namespace	graph
namespace	nodes

Classes Index

struct	StageNodeOptions
	Options controlling how a StageNode is instantiated and scheduled by the runtime. More...
class	StageNode
	Generic runtime-graph node that adapts a StageExecutor factory into a Node. More...

Description

Stage-backed graph node wrapper.

File Listing

The file content with the documentation metadata removed is:

1

6#pragma once

7

8#include "graph/GraphTypes.h"

9#include "graph/Node.h"

10

11#include <cstddef>

12#include <functional>

13#include <memory>

14#include <string>

15#include <utility>

16#include <vector>

17

18namespace simaai::neat::graph {

19class StageExecutor;

20} // namespace simaai::neat::graph

21

22namespace simaai::neat::graph::nodes {

23

32enum class StageKeyBy {

33 None = 0,

34 StreamId,

35};

36

42struct StageNodeOptions {

43 int instances = 1;

44 StageKeyBy key_by = StageKeyBy::None;

45 std::size_t max_inflight =

46 0;

47};

48

61class StageNode final : public simaai::neat::graph::Node {

62public:

64 using StageExecutorFactory = std::function<std::unique_ptr<simaai::neat::graph::StageExecutor>()>;

66 using OutputSpecFn = std::function<OutputSpec(const std::vector<OutputSpec>&, PortId)>;

67

69 StageNode(std::string kind, StageExecutorFactory factory, std::vector<PortDesc> inputs,

70 std::vector<PortDesc> outputs, std::string label = {}, OutputSpecFn out_fn = {},

71 StageNodeOptions options = {})

72 : kind_(std::move(kind)), label_(std::move(label)), inputs_(std::move(inputs)),

73 outputs_(std::move(outputs)), factory_(std::move(factory)),

74 output_spec_fn_(std::move(out_fn)), options_(std::move(options)) {}

75

77 Backend backend() const override {

78 return Backend::Stage;

79 }

80

82 std::string kind() const override {

83 return kind_;

84 }

85

87 std::string user_label() const override {

88 return label_;

89 }

90

92 std::vector<PortDesc> input_ports() const override {

93 return inputs_;

94 }

95

97 std::vector<PortDesc> output_ports() const override {

98 return outputs_;

99 }

100

103 OutputSpec output_spec(const std::vector<OutputSpec>& inputs, PortId out_port) const override {

104 if (output_spec_fn_)

105 return output_spec_fn_(inputs, out_port);

106 if (outputs_.size() == 1)

107 return outputs_.front().spec;

108 return OutputSpec{};

109 }

110

112 const StageExecutorFactory& factory() const {

113 return factory_;

114 }

116 const StageNodeOptions& options() const {

117 return options_;

118 }

119

120private:

121 std::string kind_;

122 std::string label_;

123 std::vector<PortDesc> inputs_;

124 std::vector<PortDesc> outputs_;

125 StageExecutorFactory factory_;

126 OutputSpecFn output_spec_fn_;

127 StageNodeOptions options_;

128};

129

130} // namespace simaai::neat::graph::nodes

---

Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.9.8.