Optional input ports

[JohnMoon-Voyager]

Please describe your question

Is there a concept of an optional input port in Holoscan? I tried defining a port and then conditionally doing an op_input.receive(), but it seemed regardless of the condition, the operator was still expecting input on the port and the app would deadlock.

I would think an optional port would work similarly to GNU Radio: if the port is not connected in the application, it is essentially ignored, but if it is connected, the operator blocks until input is received on both ports.
 

Please specify what Holoscan SDK version you are using

v2.9.0

[gigony]

Thank you for your detailed report about optional input ports in Holoscan. This is actually a good feature request that would align Holoscan with other node-based execution frameworks.

While we don't currently have a built-in concept of optional input ports exactly as described, we would like to support this feature in the future (possibly with 'optional output port' feature). We'll create a JIRA task to track this enhancement, as it would provide a more intuitive experience similar to what you'd find in GNU Radio, Unreal Engine's Blueprint, or ComfyUI.

Current Workaround

For now, you can use ConditionType.NONE with a conditional check in your operator's compute method:
(C++, Python)

  void setup(OperatorSpec& spec) override {
    spec.input<std::shared_ptr<ValueData>>("mandatory_input_name");
    ...
    spec.input<std::shared_ptr<ValueData>>("optional_input_name")
        .condition(ConditionType::kNone);
    ...
  }

  void compute(holoscan::InputContext& op_input, holoscan::OutputContext&,
               holoscan::ExecutionContext&) override {
    auto mandatory_value = op_input.receive<std::shared_ptr<ValueData>>("mandatory_input_name");
    ...
    auto maybe_value = op_input.receive<std::shared_ptr<ValueData>>("optional_input_name");

    if (maybe_value) {
        // If the optional input is available, use it.

        // This assumes that the operator that provides the optional input also provides the mandatory input.
        // to make sure that compute() is called only when
        // 1) No optional input is connected but mandatory input is provided
        // 2) Or, both optional and mandatory inputs are provided
    }
    // process with mandatory_value
  }

The key difference is that with ConditionType::kNone, the compute method will still be called even if no message is available on that port, whereas the default behavior would block until a message is available.

Thank you for bringing this up. We appreciate your input as we continue to improve Holoscan SDK!

[DanaKimball-Voyager]

An additional workaround that I found is to manually expand the HOLOSCAN_OPERATOR_FORWARD_ARGS() macro (see the operator header) and add flags to constructor that enable or disable the port.

class ExampleOp : public Operator {
 public:
    HOLOSCAN_OPERATOR_FORWARD_TEMPLATE()
    explicit ExampleOp (bool enable_port, ArgT&& arg, ArgsT&&... args)
      : Operator(std::forward<ArgT>(arg), std::forward<ArgsT>(args)...) {
        use_optional_port = enable_thresh_port;
    }

    void setup(OperatorSpec& spec) override {
        if (use_optional_port) {
            spec.input<input_type>("optional_port");
        }
    }

 private:
    bool use_optional_port = false;
}

Then you can add the extra parameters to calls to make_operator (see the fragment header).

auto exampleOp = make_operator<ops::ExampleOp>(
    "exampleOp",
    enable_optional_port,
    from_config("example_op_config"));

You still need to have at least one port enabled, and you have to explicitly enable or disable ports at the point where you instantiate the operator, but it worked fairly well for my use case.