Ping Custom Op

In this section, we will modify the previous ping_simple example to add a custom operator into the workflow. We’ve already seen a custom operator defined in the hello_world example but skipped over some of the details.

In this example we will cover:

• The details of creating your own custom operator class.
• How to add input and output ports to your operator.
• How to add parameters to your operator.
• The data type of the messages being passed between operators.

Operators and Workflow

Here is the diagram of the operators and workflow used in this example.

Compared to the previous example, we are adding a new PingMxOp operator between the PingTxOp and PingRxOp operators. This new operator takes as input an integer, multiplies it by a constant factor, and then sends the new value to PingRxOp. You can think of this custom operator as doing some data processing on an input stream before sending the result to downstream operators.

Configuring Operator Input and Output Ports

Our custom operator needs 1 input and 1 output port and can be added by calling spec.input() and spec.output() methods within the operator’s setup() method. This requires providing the data type and name of the port as arguments (for C++ API), or just the port name (for Python API). We will see an example of this in the code snippet below. For more details, see specifying-operator-inputs-and-outputs-cpp or Specifying Operator Inputs and Outputs Python.

Configuring Operator Parameters

Operators can be made more reusable by customizing their parameters during initialization. The custom parameters can be provided either directly as arguments or accessed from the application’s YAML configuration file. We will show how to use the former in this example to customize the “multiplier” factor of our PingMxOp custom operator. Configuring operators using a YAML configuration file will be shown in a subsequent example. For more details, see Configuring App Operator Parameters.

The code snippet below shows how to define the PingMxOp class.

1
  #include <holoscan/holoscan.hpp>
2
  #include <holoscan/operators/ping_tx/ping_tx.hpp>
3
  #include <holoscan/operators/ping_rx/ping_rx.hpp>
4
   
5
  namespace holoscan::ops {
6
   
7
  class PingMxOp : public Operator {
8
   public:
9
    HOLOSCAN_OPERATOR_FORWARD_ARGS(PingMxOp)
10
   
11
    PingMxOp() = default;
12
   
13
    void setup(OperatorSpec& spec) override {
14
      spec.input<int>("in");
15
      spec.output<int>("out");
16
      spec.param(multiplier_, "multiplier", "Multiplier", "Multiply the input by this value", 2);
17
    }
18
   
19
    void compute(InputContext& op_input, OutputContext& op_output, ExecutionContext&) override {
20
      auto value = op_input.receive<int>("in");
21
   
22
      std::cout << "Middle message value: " << value << std::endl;
23
   
24
      // Multiply the value by the multiplier parameter
25
      value *= multiplier_;
26
   
27
      op_output.emit(value);
28
    };
29
   
30
   private:
31
    Parameter<int> multiplier_;
32
  };
33
   
34
  }  // namespace holoscan::ops

Now that the custom operator has been defined, we create the application, operators, and define the workflow.

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

Message Data Types

For the C++ API, the messages that are passed between the operators are the objects of the data type at the inputs and outputs, so the value variable from lines 20 and 25 of the example above has the type int. For the Python API, the messages passed between operators can be arbitrary Python objects so no special consideration is needed since it is not restricted to the stricter parameter typing used for C++ API operators.

Let’s look at the code snippet for the built-in PingTxOp class and see if this helps to make it clearer.

1
  #include <holoscan/operators/ping_tx/ping_tx.hpp>
2
   
3
  namespace holoscan::ops {
4
   
5
  void PingTxOp::setup(OperatorSpec& spec) {
6
    spec.output<int>("out");
7
  }
8
   
9
  void PingTxOp::compute(InputContext&, OutputContext& op_output, ExecutionContext&) {
10
    auto value = index_++;
11
    op_output.emit(value, "out");
12
  }
13
   
14
  }  // namespace holoscan::ops

Running the Application

Running the application should give you the following output in your terminal:

Middle message value: 1
Rx message value: 3
Middle message value: 2
Rx message value: 6
Middle message value: 3
Rx message value: 9
Middle message value: 4
Rx message value: 12
Middle message value: 5
Rx message value: 15
Middle message value: 6
Rx message value: 18
Middle message value: 7
Rx message value: 21
Middle message value: 8
Rx message value: 24
Middle message value: 9
Rx message value: 27
Middle message value: 10
Rx message value: 30