[onert] Negative testcase added for BROADCAST_TO operation.

- Added OperationValidator and ShapeValidator for BROADCAST_TO
- Added negative testcases for BROADCAST_TO

ONE-DCO-1.0-Signed-off-by: Seockho Kim seockho.kim@samsung.com

Author: seockho-kim

runtime/onert/core/src/compiler/ShapeValidator.cc

@@ -158,6 +158,41 @@ void ShapeValidator::visit(const ir::operation::BCQGather &node)
   // more shape validation will be done inside kernel.
 }
 
+void ShapeValidator::visit(const ir::operation::BroadcastTo &node)
+{
+  const auto &operands = _graph.operands();
+  const auto output_index{node.getOutputs().at(0)};
+  if (operands.at(output_index).info().isDynamic())
+    return;
+
+  const auto input_index{node.getInputs().at(ir::operation::BroadcastTo::Input::INPUT)};
+  const auto shape_index{node.getInputs().at(ir::operation::BroadcastTo::Input::SHAPE)};
+
+  std::vector<int32_t> input_shape = operands.at(input_index).shape().dims();
+  std::vector<int32_t> target_shape = operands.at(shape_index).asVector<int32_t>();
+
+  int in_len = input_shape.size();
+  int tgt_len = target_shape.size();
+  int max_len = std::max(in_len, tgt_len);
+
+  std::vector<int32_t> in_shape_padded(max_len, 1);
+  std::vector<int32_t> tgt_shape_padded(max_len, 1);
+
+  for (int i = 0; i < in_len; i++)
+  {
+    in_shape_padded[max_len - in_len + i] = input_shape[i];
+  }
+  for (int i = 0; i < tgt_len; i++)
+  {
+    tgt_shape_padded[max_len - tgt_len + i] = target_shape[i];
+  }
+
+  for (int i = max_len - 1; i >= 0; --i)
+  {
+    OP_REQUIRES((in_shape_padded[i] == tgt_shape_padded[i]) || (in_shape_padded[i] == 1));
+  }
+}
+
 void ShapeValidator::visit(const ir::operation::Conv2D &node)
 {
   const auto &operands = _graph.operands();

runtime/onert/core/src/compiler/ShapeValidator.h

@@ -48,6 +48,7 @@ class ShapeValidator : public ir::OperationVisitor
   void visit(const ir::operation::BatchToSpaceND &node) override;
   void visit(const ir::operation::BCQFullyConnected &node) override;
   void visit(const ir::operation::BCQGather &node) override;
+  void visit(const ir::operation::BroadcastTo &node) override;
   void visit(const ir::operation::Conv2D &node) override;
   void visit(const ir::operation::Comparison &node) override;
   void visit(const ir::operation::DepthwiseConv2D &node) override;

runtime/onert/core/src/ir/OperationValidator.cc

@@ -149,6 +149,14 @@ void OperationValidator::visit(const operation::BinaryArithmetic &node)
   OP_REQUIRES(isSameType(lhs_index, output_index));
 }
 
+void OperationValidator::visit(const operation::BroadcastTo &node)
+{
+  const auto input_index(node.getInputs().at(operation::BroadcastTo::Input::INPUT));
+  const auto output_index(node.getOutputs().at(0));
+
+  OP_REQUIRES(isSameType(input_index, output_index));
+}
+
 void OperationValidator::visit(const operation::Comparison &node)
 {
   const auto output_index{node.getOutputs().at(0)};

runtime/onert/core/src/ir/OperationValidator.h

@@ -45,6 +45,7 @@ class OperationValidator : public OperationVisitor
   void visit(const operation::BatchMatMul &node) override;
   void visit(const operation::BatchToSpaceND &node) override;
   void visit(const operation::BinaryArithmetic &node) override;
+  void visit(const operation::BroadcastTo &node) override;
   void visit(const operation::Comparison &node) override;
   void visit(const operation::Concat &node) override;
   void visit(const operation::Conv2D &node) override;

runtime/tests/nnfw_api/src/GenModelTests/one_op_tests/BroadcastTo.test.cc

@@ -66,3 +66,76 @@ TEST_F(GenModelTest, OneOp_BroadcastTo_3D_to_3D)
 
   SUCCEED();
 }
+
+TEST_F(GenModelTest, OneOp_BroadcastTo_InputOutputDifferentType)
+{
+  CircleGen cgen;
+  const uint32_t shape_buf = cgen.addBuffer(std::vector<int32_t>{3, 3});
+  int shape = cgen.addTensor({{2}, circle::TensorType::TensorType_INT32, shape_buf});
+  int in = cgen.addTensor({{3}, circle::TensorType::TensorType_INT32});
+  int out = cgen.addTensor({{3, 3}, circle::TensorType::TensorType_FLOAT32});
+  cgen.addOperatorBroadcastTo({{in, shape}, {out}});
+  cgen.setInputsAndOutputs({in}, {out});
+
+  _context = std::make_unique<GenModelTestContext>(cgen.finish());
+  _context->addTestCase(uniformTCD<float>({{1, 2, 3}}, {{1, 2, 3, 1, 2, 3, 1, 2, 3}}));
+  _context->setBackends({"cpu"});
+  _context->expectFailModelLoad();
+
+  SUCCEED();
+}
+
+TEST_F(GenModelTest, OneOp_BroadcastTo_1D_to_2D_InvalidShape)
+{
+  CircleGen cgen;
+  const uint32_t shape_buf = cgen.addBuffer(std::vector<int32_t>{3, 2});
+  int shape = cgen.addTensor({{2}, circle::TensorType::TensorType_INT32, shape_buf});
+  int in = cgen.addTensor({{3}, circle::TensorType::TensorType_FLOAT32});
+  int out = cgen.addTensor({{3, 2}, circle::TensorType::TensorType_FLOAT32});
+  cgen.addOperatorBroadcastTo({{in, shape}, {out}});
+  cgen.setInputsAndOutputs({in}, {out});
+
+  _context = std::make_unique<GenModelTestContext>(cgen.finish());
+  _context->addTestCase(uniformTCD<float>({{1, 2, 3}}, {{1, 2, 3, 1, 2, 3}}));
+  _context->setBackends({"cpu"});
+  _context->expectFailCompile();
+
+  SUCCEED();
+}
+
+TEST_F(GenModelTest, OneOp_BroadcastTo_2D_to_3D_InvalidShape)
+{
+  CircleGen cgen;
+  const uint32_t shape_buf = cgen.addBuffer(std::vector<int32_t>{2, 1, 3});
+  int shape = cgen.addTensor({{3}, circle::TensorType::TensorType_INT32, shape_buf});
+  int in = cgen.addTensor({{2, 3}, circle::TensorType::TensorType_FLOAT32});
+  int out = cgen.addTensor({{2, 1, 3}, circle::TensorType::TensorType_FLOAT32});
+  cgen.addOperatorBroadcastTo({{in, shape}, {out}});
+  cgen.setInputsAndOutputs({in}, {out});
+
+  _context = std::make_unique<GenModelTestContext>(cgen.finish());
+  _context->addTestCase(uniformTCD<float>({{1, 2, 3, 1, 2, 3}}, {{1, 2, 3, 1, 2, 3}}));
+  _context->setBackends({"cpu"});
+  _context->expectFailCompile();
+
+  SUCCEED();
+}
+
+TEST_F(GenModelTest, OneOp_BroadcastTo_3D_to_3D_InvalidShape)
+{
+  CircleGen cgen;
+  const uint32_t shape_buf = cgen.addBuffer(std::vector<int32_t>{2, 3, 2});
+  int shape = cgen.addTensor({{3}, circle::TensorType::TensorType_INT32, shape_buf});
+  int in = cgen.addTensor({{2, 2, 2}, circle::TensorType::TensorType_FLOAT32});
+  int out = cgen.addTensor({{2, 3, 2}, circle::TensorType::TensorType_FLOAT32});
+  cgen.addOperatorBroadcastTo({{in, shape}, {out}});
+  cgen.setInputsAndOutputs({in}, {out});
+
+  _context = std::make_unique<GenModelTestContext>(cgen.finish());
+  _context->addTestCase(
+    uniformTCD<float>({{1, 2, 1, 2, 1, 2, 1, 2}}, {{1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2}}));
+  _context->setBackends({"cpu"});
+  _context->expectFailCompile();
+
+  SUCCEED();
+}