Ping Multi Port

1
  #include <holoscan/holoscan.hpp>
2
   
3
  class ValueData {
4
   public:
5
    ValueData() = default;
6
    explicit ValueData(int value) : data_(value) {
7
      HOLOSCAN_LOG_TRACE("ValueData::ValueData(): {}", data_);
8
    }
9
    ~ValueData() { HOLOSCAN_LOG_TRACE("ValueData::~ValueData(): {}", data_); }
10
   
11
    void data(int value) { data_ = value; }
12
   
13
    int data() const { return data_; }
14
   
15
   private:
16
    int data_;
17
  };

1
  namespace holoscan::ops {
2
   
3
  class PingTxOp : public Operator {
4
   public:
5
    HOLOSCAN_OPERATOR_FORWARD_ARGS(PingTxOp)
6
   
7
    PingTxOp() = default;
8
   
9
    void setup(OperatorSpec& spec) override {
10
      spec.output<std::shared_ptr<ValueData>>("out1");
11
      spec.output<std::shared_ptr<ValueData>>("out2");
12
    }
13
   
14
    void compute(InputContext&, OutputContext& op_output, ExecutionContext&) override {
15
      auto value1 = std::make_shared<ValueData>(index_++);
16
      op_output.emit(value1, "out1");
17
   
18
      auto value2 = std::make_shared<ValueData>(index_++);
19
      op_output.emit(value2, "out2");
20
    };
21
    int index_ = 1;
22
  };

1
  class PingMxOp : public Operator {
2
   public:
3
    HOLOSCAN_OPERATOR_FORWARD_ARGS(PingMxOp)
4
   
5
    PingMxOp() = default;
6
   
7
    void setup(OperatorSpec& spec) override {
8
      spec.input<std::shared_ptr<ValueData>>("in1");
9
      spec.input<std::shared_ptr<ValueData>>("in2");
10
      spec.output<std::shared_ptr<ValueData>>("out1");
11
      spec.output<std::shared_ptr<ValueData>>("out2");
12
      spec.param(multiplier_, "multiplier", "Multiplier", "Multiply the input by this value", 2);
13
    }
14
   
15
    void compute(InputContext& op_input, OutputContext& op_output, ExecutionContext&) override {
16
      auto value1 = op_input.receive<std::shared_ptr<ValueData>>("in1").value();
17
      auto value2 = op_input.receive<std::shared_ptr<ValueData>>("in2").value();
18
   
19
      HOLOSCAN_LOG_INFO("Middle message received (count: {})", count_++);
20
   
21
      HOLOSCAN_LOG_INFO("Middle message value1: {}", value1->data());
22
      HOLOSCAN_LOG_INFO("Middle message value2: {}", value2->data());
23
   
24
      // Multiply the values by the multiplier parameter
25
      value1->data(value1->data() * multiplier_);
26
      value2->data(value2->data() * multiplier_);
27
   
28
      op_output.emit(value1, "out1");
29
      op_output.emit(value2, "out2");
30
    };
31
   
32
   private:
33
    int count_ = 1;
34
    Parameter<int> multiplier_;
35
  };

1
  class PingRxOp : public Operator {
2
   public:
3
    HOLOSCAN_OPERATOR_FORWARD_ARGS(PingRxOp)
4
   
5
    PingRxOp() = default;
6
   
7
    void setup(OperatorSpec& spec) override {
8
      // // Since Holoscan SDK v2.3, users can define a multi-receiver input port using 'spec.input()'
9
      // // with 'IOSpec::kAnySize'.
10
      // // The old way is to use 'spec.param()' with 'Parameter<std::vector<IOSpec*>> receivers_;'.
11
      // spec.param(receivers_, "receivers", "Input Receivers", "List of input receivers.", {});
12
      spec.input<std::vector<std::shared_ptr<ValueData>>>("receivers", IOSpec::kAnySize);
13
    }
14
   
15
    void compute(InputContext& op_input, OutputContext&, ExecutionContext&) override {
16
      auto value_vector =
17
          op_input.receive<std::vector<std::shared_ptr<ValueData>>>("receivers").value();
18
   
19
      HOLOSCAN_LOG_INFO("Rx message received (count: {}, size: {})", count_++, value_vector.size());
20
   
21
      HOLOSCAN_LOG_INFO("Rx message value1: {}", value_vector[0]->data());
22
      HOLOSCAN_LOG_INFO("Rx message value2: {}", value_vector[1]->data());
23
    };
24
   
25
   private:
26
    // // Since Holoscan SDK v2.3, the following line is no longer needed.
27
    // Parameter<std::vector<IOSpec*>> receivers_;
28
    int count_ = 1;
29
  };

1
  class MyPingApp : public holoscan::Application {
2
   public:
3
    void compose() override {
4
      using namespace holoscan;
5
   
6
      // Define the tx, mx, rx operators, allowing the tx operator to execute 10 times
7
      auto tx = make_operator&lt;ops::PingTxOp&gt;("tx", make_condition<CountCondition>(10));
8
      auto mx = make_operator&lt;ops::PingMxOp&gt;("mx", Arg("multiplier", 3));
9
      auto rx = make_operator&lt;ops::PingRxOp&gt;("rx");
10
   
11
      // Define the workflow
12
      add_flow(tx, mx, {{"out1", "in1"}, {"out2", "in2"}});
13
      add_flow(mx, rx, {{"out1", "receivers"}, {"out2", "receivers"}});
14
    }
15
  };
16
   
17
  int main(int argc, char** argv) {
18
    auto app = holoscan::make_application<MyPingApp>();
19
    app->run();
20
   
21
    return 0;
22
  }