path: root/runtime/neurun/core/src/compiler/OperationValidator.cc

/*
 * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "OperationValidator.h"

#include <typeinfo>

#include "ir/Graph.h"
#include "ir/operation/LowerInfo.h"

#include "util/logging.h"
#include "util/Utils.h"

namespace neurun
{
namespace compiler
{

OperationValidator::OperationValidator(const ir::Graph &graph)
    : _graph{graph}, _ctx{graph.operands()}, _current_subg_layout{ir::Layout::UNKNOWN}
{
}

void OperationValidator::operator()()
{
  // TODO Get frontend layout from graph
  _current_subg_layout = ir::Layout::NHWC;

  _graph.operations().iterate(
      [&](const ir::OperationIndex &, const ir::Operation &node) { node.accept(*this); });
}

void OperationValidator::visit(const ir::operation::BatchToSpaceND &node)
{
  const auto ofm_index{node.getOutputs().at(0)};
  const auto ifm_index{node.getInputs().at(ir::operation::BatchToSpaceND::Input::INPUT)};
  const auto block_size_index{
      node.getInputs().at(ir::operation::BatchToSpaceND::Input::BLOCK_SIZE)};

  const auto frontend_layout = _current_subg_layout;
  const auto input_shape = _ctx.at(ifm_index).shape().asFeature(frontend_layout);
  const auto output_shape = _ctx.at(ofm_index).shape().asFeature(frontend_layout);

  UNUSED_RELEASE(input_shape);
  UNUSED_RELEASE(output_shape);

  // All assertions as per NNAPI specification.
  assert(_ctx.at(ifm_index).shape().rank() == 4);
  assert(_ctx.at(ofm_index).shape().rank() == 4);
  assert(_ctx.at(block_size_index).shape().rank() == 1);

  assert(_ctx.at(block_size_index).shape().dim(0) == 2);

  assert(_ctx.at(block_size_index).isConstant());

  assert(input_shape.C == output_shape.C);
}

void OperationValidator::visit(const ir::operation::Cast &node)
{
  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(0)};

  UNUSED_RELEASE(output_index);
  UNUSED_RELEASE(input_index);

  assert(_ctx.at(output_index).shape() == _ctx.at(input_index).shape());
}

void OperationValidator::visit(const ir::operation::Comparison &node)
{
  const auto output_index{node.getOutputs().at(0)};
  const auto lhs_index{node.getInputs().at(ir::operation::Comparison::Input::INPUT0)};
  const auto rhs_index{node.getInputs().at(ir::operation::Comparison::Input::INPUT1)};

  UNUSED_RELEASE(output_index);
  UNUSED_RELEASE(lhs_index);
  UNUSED_RELEASE(rhs_index);

  assert(_ctx.at(lhs_index).typeInfo().type() == _ctx.at(rhs_index).typeInfo().type());
  assert(_ctx.at(output_index).typeInfo().type() == ir::DataType::BOOL8);
}

void OperationValidator::visit(const ir::operation::Softmax &node)
{
  VERBOSE(Softmax) << "Configure SOFTMAX operation" << std::endl;

  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(0)};

  UNUSED_RELEASE(output_index);
  UNUSED_RELEASE(input_index);

  assert(_ctx.at(output_index).shape().rank() == _ctx.at(input_index).shape().rank());
}

void OperationValidator::visit(const ir::operation::InstanceNorm &node)
{
  const auto ofm_index{node.getOutputs().at(0)};
  const auto ifm_index{node.getInputs().at(ir::operation::InstanceNorm::Input::INPUT)};
  const auto gamma_index{node.getInputs().at(ir::operation::InstanceNorm::Input::GAMMA)};
  const auto beta_index{node.getInputs().at(ir::operation::InstanceNorm::Input::BETA)};

  UNUSED_RELEASE(ofm_index);
  UNUSED_RELEASE(ifm_index);
  UNUSED_RELEASE(gamma_index);
  UNUSED_RELEASE(beta_index);

  assert(_ctx.at(ifm_index).shape().rank() == 4);
  assert(_ctx.at(ifm_index).shape() == _ctx.at(ofm_index).shape());
  assert(_ctx.at(gamma_index).shape().rank() == 1);
  assert(_ctx.at(beta_index).shape().rank() == 1);
}

void OperationValidator::visit(const ir::operation::Permute &node)
{
  VERBOSE(Permute) << "Configure Permute operation" << std::endl;

  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(0)};

  UNUSED_RELEASE(output_index);
  UNUSED_RELEASE(input_index);

  assert(_ctx.at(output_index).shape().rank() == _ctx.at(input_index).shape().rank());
}

void OperationValidator::visit(const ir::operation::ReduceSum &node)
{
  VERBOSE(Permute) << "Configure ReduceSum operation" << std::endl;

  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(ir::operation::ReduceSum::Input::INPUT)};
  const auto &axes = node.param().axes;

  UNUSED_RELEASE(output_index);
  UNUSED_RELEASE(input_index);
  UNUSED_RELEASE(axes);

  const auto input_shape = _ctx.at(input_index).shape();
  const auto output_shape = _ctx.at(output_index).shape();

  UNUSED_RELEASE(output_shape);
  UNUSED_RELEASE(input_shape);

  assert(input_shape.rank() <= 4);
  assert(output_shape.rank() <= input_shape.rank());

  // NOTE For the 4-dimensions, if the rank of input and output are different, this runtime only
  // supports cases reducing height and width or reducing depth.
  // TODO We have to support all cases of dimensions up to 4.
  // For correct permuting, we have to set output's shape to be equal in dimension position of the
  // input. But the positions of the same dimensions in the input and output may be set differently.
  // For example {2,3,4,5}(input's shape) can be reduced to {3,5}(output's shape). The original
  // output shape should be {1,3,1,5}, but real output shape may be {3,5}. If you simply try to
  // extend it in 4 dimensions, it should be {1,1,3,5}.
  // Even if output shape is changed to {1,3,1,5}, there is another problem. It is that shape of
  // output tensor used at next operation is changed to {1,3,1,5} after this operation even if the
  // next operation is not desired.
  if (input_shape.rank() == 4 && input_shape.rank() != output_shape.rank())
  {
    if (output_shape.rank() == 2)
    {
      // Reducing HW
      assert(input_shape.dim(0) == output_shape.dim(0) &&
             input_shape.dim(3) == output_shape.dim(1));
    }
    else if (output_shape.rank() == 3)
    {
      // Reducing C or
      // (Reducing H and C(input and output) == 1) or (Reducing W and C(input and output) == 1)
      assert((input_shape.dim(0) == output_shape.dim(0) &&
              input_shape.dim(1) == output_shape.dim(1) &&
              input_shape.dim(2) == output_shape.dim(2)) ||
             (input_shape.dim(0) == output_shape.dim(0) &&
              (input_shape.dim(1) == output_shape.dim(1) ||
               input_shape.dim(2) == output_shape.dim(1)) &&
              input_shape.dim(3) == 1 && output_shape.dim(2) == 1));
    }
  }
}

void OperationValidator::visit(const ir::operation::Transpose &node)
{
  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(ir::operation::Transpose::Input::INPUT)};
  const auto &perm{node.param().perm};

  const auto &output_shape = _ctx.at(output_index).shape();
  const auto &input_shape = _ctx.at(input_index).shape();

  UNUSED_RELEASE(output_shape);
  UNUSED_RELEASE(input_shape);
  UNUSED_RELEASE(perm);

  assert(input_shape.rank() == static_cast<int>(perm.size()));
  assert(input_shape.rank() == output_shape.rank());
}

void OperationValidator::visit(const ir::operation::ReduceMax &node)
{
  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(ir::operation::ReduceMax::Input::INPUT)};
  const auto &axes = node.param().axes;

  auto output_shape = _ctx.at(output_index).shape();
  auto input_shape = _ctx.at(input_index).shape();

  UNUSED_RELEASE(output_shape);
  UNUSED_RELEASE(input_shape);
  UNUSED_RELEASE(axes);

  assert(input_shape.rank() <= 4);
  assert(output_shape.rank() <= input_shape.rank());

  // NOTE For the 4-dimensions, if the rank of input and output are different, this runtime only
  // supports cases reducing height and width or reducing depth.
  // TODO We have to support all cases of dimensions up to 4.
  // For correct permuting, we have to set output's shape to be equal in dimension position of the
  // input. But the positions of the same dimensions in the input and output may be set differently.
  // For example {2,3,4,5}(input's shape) can be reduced to {3,5}(output's shape). The original
  // output shape should be {1,3,1,5}, but real output shape may be {3,5}. If you simply try to
  // extend it in 4 dimensions, it should be {1,1,3,5}.
  // Even if output shape is changed to {1,3,1,5}, there is another problem. It is that shape of
  // output tensor used at next operation is changed to {1,3,1,5} after this operation even if the
  // next operation is not desired.
  if (input_shape.rank() == 4 && input_shape.rank() != output_shape.rank())
  {
    if (output_shape.rank() == 2)
    {
      // Reducing HW
      assert(input_shape.dim(0) == output_shape.dim(0) &&
             input_shape.dim(3) == output_shape.dim(1));
    }
    else if (output_shape.rank() == 3)
    {
      // Reducing C or
      // (Reducing H and C(ifm and ofm) == 1) or (Reducing W and C(ifm and ofm) == 1)
      assert((input_shape.dim(0) == output_shape.dim(0) &&
              input_shape.dim(1) == output_shape.dim(1) &&
              input_shape.dim(2) == output_shape.dim(2)) ||
             (input_shape.dim(0) == output_shape.dim(0) &&
              (input_shape.dim(1) == output_shape.dim(1) ||
               input_shape.dim(2) == output_shape.dim(1)) &&
              input_shape.dim(3) == 1 && output_shape.dim(2) == 1));
    }
  }
}

void OperationValidator::visit(const ir::operation::RNN &node)
{
  // NOTE This validation is for static rnn(non-dynamic shape), but not for dynamic rnn
  // TODO Support dynamic rnn
  const auto output_index{node.getOutputs().at(ir::operation::RNN::Output::OUTPUT)};
  const auto hidden_state_out_index{
      node.getOutputs().at(ir::operation::RNN::Output::HIDDEN_STATE_OUT)};

  const auto input_index{node.getInputs().at(ir::operation::RNN::Input::INPUT)};
  const auto weights_index{node.getInputs().at(ir::operation::RNN::Input::WEIGHTS)};
  const auto recurrent_weights_index{
      node.getInputs().at(ir::operation::RNN::Input::RECURRENT_WEIGHTS)};
  const auto bias_index{node.getInputs().at(ir::operation::RNN::Input::BIAS)};
  const auto hidden_state_in_index{node.getInputs().at(ir::operation::RNN::Input::HIDDEN_STATE_IN)};

  const auto batch_size = _ctx.at(output_index).shape().dim(0);
  const auto num_units = _ctx.at(output_index).shape().dim(1);

  UNUSED_RELEASE(output_index);
  UNUSED_RELEASE(hidden_state_out_index);
  UNUSED_RELEASE(input_index);
  UNUSED_RELEASE(weights_index);
  UNUSED_RELEASE(recurrent_weights_index);
  UNUSED_RELEASE(bias_index);
  UNUSED_RELEASE(hidden_state_in_index);
  UNUSED_RELEASE(batch_size);
  UNUSED_RELEASE(num_units);

  assert(_ctx.at(output_index).shape().rank() == 2 &&
         _ctx.at(hidden_state_out_index).shape().rank() == 2 &&
         _ctx.at(input_index).shape().rank() == 2 && _ctx.at(weights_index).shape().rank() == 2 &&
         _ctx.at(recurrent_weights_index).shape().rank() == 2 &&
         _ctx.at(hidden_state_in_index).shape().rank() == 2);
  assert(_ctx.at(bias_index).shape().rank() == 1);

  assert(batch_size == _ctx.at(input_index).shape().dim(0) &&
         batch_size == _ctx.at(hidden_state_in_index).shape().dim(0) &&
         batch_size == _ctx.at(hidden_state_out_index).shape().dim(0));
  assert(_ctx.at(input_index).shape().dim(1) == _ctx.at(weights_index).shape().dim(1));

  assert(num_units == _ctx.at(weights_index).shape().dim(0) &&
         num_units == _ctx.at(recurrent_weights_index).shape().dim(0) &&
         num_units == _ctx.at(bias_index).shape().dim(0));
  assert(num_units == _ctx.at(output_index).shape().dim(1) &&
         num_units == _ctx.at(recurrent_weights_index).shape().dim(1) &&
         num_units == _ctx.at(hidden_state_in_index).shape().dim(1) &&
         num_units == _ctx.at(hidden_state_out_index).shape().dim(1));
}

void OperationValidator::visit(const ir::operation::SpaceToBatchND &node)
{
  const auto ofm_index{node.getOutputs().at(0)};
  const auto ifm_index{node.getInputs().at(ir::operation::SpaceToBatchND::Input::INPUT)};
  const auto block_size_index{
      node.getInputs().at(ir::operation::SpaceToBatchND::Input::BLOCK_SIZE)};
  const auto paddings_index{node.getInputs().at(ir::operation::SpaceToBatchND::Input::PADDINGS)};

  const auto frontend_layout = _current_subg_layout;
  const auto input_shape = _ctx.at(ifm_index).shape().asFeature(frontend_layout);
  const auto output_shape = _ctx.at(ofm_index).shape().asFeature(frontend_layout);

  UNUSED_RELEASE(input_shape);
  UNUSED_RELEASE(output_shape);

  // All assertions as per NNAPI specification.
  assert(_ctx.at(ifm_index).shape().rank() == 4);
  assert(_ctx.at(ofm_index).shape().rank() == 4);
  assert(_ctx.at(block_size_index).shape().rank() == 1);
  assert(_ctx.at(paddings_index).shape().rank() == 2);

  assert(_ctx.at(block_size_index).shape().dim(0) == 2);
  assert(_ctx.at(paddings_index).shape().dim(0) == 2);
  assert(_ctx.at(paddings_index).shape().dim(1) == 2);

  assert(_ctx.at(block_size_index).isConstant());
  assert(_ctx.at(paddings_index).isConstant());

  assert(input_shape.C == output_shape.C);
}

void OperationValidator::visit(const ir::operation::SpaceToDepth &node)
{
  const auto ofm_index{node.getOutputs().at(0)};
  const auto ifm_index{node.getInputs().at(ir::operation::SpaceToDepth::Input::INPUT)};

  const auto frontend_layout = _current_subg_layout;
  const auto input_shape = _ctx.at(ifm_index).shape().asFeature(frontend_layout);
  const auto output_shape = _ctx.at(ofm_index).shape().asFeature(frontend_layout);
  const auto block_size = node.param().block_size;

  UNUSED_RELEASE(input_shape);
  UNUSED_RELEASE(output_shape);
  UNUSED_RELEASE(block_size);

  // All assertions as per NNAPI specification.
  assert(_ctx.at(ifm_index).shape().rank() == 4);
  assert(_ctx.at(ofm_index).shape().rank() == 4);
  assert((block_size >= 1) && (input_shape.H % block_size == 0) &&
         (input_shape.W % block_size == 0));
  assert(input_shape.N == output_shape.N);
  assert(input_shape.C * block_size * block_size == output_shape.C);
}

void OperationValidator::visit(const ir::operation::EmbeddingLookup &node)
{
  const auto output_index{node.getOutputs().at(0)};
  const auto lookups_index{node.getInputs().at(ir::operation::EmbeddingLookup::Input::LOOKUPS)};
  const auto values_index{node.getInputs().at(ir::operation::EmbeddingLookup::Input::VALUES)};

  const auto &output_obj = _ctx.at(output_index);
  const auto &lookups_obj = _ctx.at(lookups_index);
  const auto &values_obj = _ctx.at(values_index);

  UNUSED_RELEASE(output_obj);
  UNUSED_RELEASE(lookups_obj);
  UNUSED_RELEASE(values_obj);

  // Verify operand here, not at SimpleEmbeddingLookup::configure() to avoid acl's modifying
  // TensorShape sometimes(Issue: https://github.sec.samsung.net/STAR/nnfw/issues/729)
  {
    assert(lookups_obj.typeInfo().type() == ir::DataType::INT32);

    const auto &output_shape = output_obj.shape();
    const auto &lookups_shape = lookups_obj.shape();
    const auto &values_shape = values_obj.shape();

    UNUSED_RELEASE(output_shape);
    UNUSED_RELEASE(lookups_shape);
    UNUSED_RELEASE(values_shape);

    assert(lookups_shape.rank() == 1);
    assert(values_shape.rank() >= 2);

    // output should be a n-D tensor with the same rank and shape as the values tensor, except for
    // the first dimension which has the same size as lookups' only dimension.
    assert(output_shape.rank() == values_shape.rank());
    assert(output_shape.dim(0) == lookups_shape.dim(0));
    for (int n = 1; n < output_shape.rank(); ++n)
    {
      assert(output_shape.dim(n) == values_shape.dim(n));
    }
  }
}

void OperationValidator::visit(const ir::operation::Exp &node)
{
  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(ir::operation::Exp::Input::INPUT)};

  UNUSED_RELEASE(output_index);
  UNUSED_RELEASE(input_index);

  assert(_ctx.at(output_index).shape() == _ctx.at(input_index).shape());
  assert(_ctx.at(output_index).typeInfo().type() == _ctx.at(input_index).typeInfo().type());
}

void OperationValidator::visit(const ir::operation::Floor &node)
{
  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(ir::operation::Floor::Input::INPUT)};

  UNUSED_RELEASE(output_index);
  UNUSED_RELEASE(input_index);

  assert(_ctx.at(output_index).shape() == _ctx.at(input_index).shape());
  assert(_ctx.at(output_index).typeInfo().type() == _ctx.at(input_index).typeInfo().type());
}

void OperationValidator::visit(const ir::operation::HashtableLookup &node)
{
  const auto output_index{node.getOutputs().at(ir::operation::HashtableLookup::Output::OUTPUT)};
  const auto hits_index{node.getOutputs().at(ir::operation::HashtableLookup::Output::HITS)};

  const auto lookups_index{node.getInputs().at(ir::operation::HashtableLookup::Input::LOOKUPS)};
  const auto keys_index{node.getInputs().at(ir::operation::HashtableLookup::Input::KEYS)};
  const auto values_index{node.getInputs().at(ir::operation::HashtableLookup::Input::VALUES)};

  const auto &output_obj = _ctx.at(output_index);
  const auto &hits_obj = _ctx.at(hits_index);

  const auto &lookups_obj = _ctx.at(lookups_index);
  const auto &keys_obj = _ctx.at(keys_index);
  const auto &values_obj = _ctx.at(values_index);

  assert(lookups_obj.typeInfo().type() == ir::DataType::INT32);
  assert(keys_obj.typeInfo().type() == ir::DataType::INT32);
  assert(hits_obj.typeInfo().type() == ir::DataType::QUANT8_ASYMM);

  const auto &output_shape = output_obj.shape();
  const auto &hits_shape = hits_obj.shape();

  const auto &lookups_shape = lookups_obj.shape();
  const auto &keys_shape = keys_obj.shape();
  const auto &values_shape = values_obj.shape();

  UNUSED_RELEASE(output_shape);
  UNUSED_RELEASE(hits_shape);
  UNUSED_RELEASE(lookups_shape);
  UNUSED_RELEASE(keys_shape);
  UNUSED_RELEASE(values_shape);

  assert(values_shape.rank() == output_shape.rank());
  assert(lookups_shape.rank() == 1);
  assert(keys_shape.rank() == 1);
  assert(values_shape.dim(0) == keys_shape.dim(0));
  assert(lookups_shape.dim(0) == output_shape.dim(0));
}

void OperationValidator::visit(const ir::operation::TransposeConv &node)
{
  const auto ofm_index{node.getOutputs().at(0)};
  const auto ifm_index{node.getInputs().at(ir::operation::TransposeConv::Input::INPUT)};
  const auto ker_index{node.getInputs().at(ir::operation::TransposeConv::Input::KERNEL)};

  // Only 4D tensors are supported
  assert(_ctx.at(ofm_index).shape().rank() == 4);
  assert(_ctx.at(ofm_index).shape().rank() == _ctx.at(ifm_index).shape().rank());
  assert(_ctx.at(ofm_index).shape().rank() == _ctx.at(ker_index).shape().rank());

  const auto frontend_layout = _current_subg_layout;
  const auto ofm_shape = _ctx.at(ofm_index).shape().asFeature(frontend_layout);
  const auto ifm_shape = _ctx.at(ifm_index).shape().asFeature(frontend_layout);
  // The kernel has only IHWO layout on frontend
  // So ker_shape is treated here below
  // I -> N
  // H -> H
  // W -> W
  // O -> C
  const auto ker_shape = _ctx.at(ker_index).shape().asFeature(ir::Layout::NHWC);

  UNUSED_RELEASE(ofm_shape);
  UNUSED_RELEASE(ifm_shape);
  UNUSED_RELEASE(ker_shape);

  assert((node.param().padding.type == ir::PaddingType::SAME) ||
         (node.param().padding.type == ir::PaddingType::VALID));
  assert(ifm_shape.N == ofm_shape.N);
  assert(ifm_shape.C == ker_shape.C);
  assert(ker_shape.N == ofm_shape.C);
}

void OperationValidator::visit(const ir::operation::Gather &node)
{
  const auto ofm_index{node.getOutputs().at(0)};

  const auto ifm_index{node.getInputs().at(ir::operation::Gather::Input::INPUT)};
  const auto indices_index{node.getInputs().at(ir::operation::Gather::Input::INDICES)};

  const auto axis = node.param().axis;

  const auto ifm_shape = _ctx.at(ifm_index).shape();
  const auto indices_shape = _ctx.at(indices_index).shape();
  const auto ofm_shape = _ctx.at(ofm_index).shape();

  UNUSED_RELEASE(ifm_shape);
  UNUSED_RELEASE(indices_shape);
  UNUSED_RELEASE(ofm_shape);
  UNUSED_RELEASE(axis);

  assert(ifm_shape.rank() <= 4);
  assert(indices_shape.rank() <= 3);
  assert(ofm_shape.rank() <= 4);
}

void OperationValidator::visit(const ir::operation::Dequantize &node)
{
  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(ir::operation::Dequantize::Input::INPUT)};

  UNUSED_RELEASE(output_index);
  UNUSED_RELEASE(input_index);

  assert(_ctx.at(input_index).shape().rank() <= 4);
  assert(_ctx.at(input_index).shape() == _ctx.at(output_index).shape());
  assert(_ctx.at(input_index).typeInfo().type() == ir::DataType::QUANT8_ASYMM);
  assert(_ctx.at(output_index).typeInfo().type() == ir::DataType::FLOAT32);
}

void OperationValidator::visit(const ir::operation::Mean &node)
{
  const auto ofm_index{node.getOutputs().at(0)};
  const auto ifm_index{node.getInputs().at(ir::operation::Mean::Input::INPUT)};

  const auto ifm_shape = _ctx.at(ifm_index).shape();
  const auto ofm_shape = _ctx.at(ofm_index).shape();

  // NOTE For the 4-dimensions, if the rank of input and output are different, this runtime only
  // supports cases reducing height and width or reducing depth.
  // TODO We have to support all cases of dimensions up to 4.
  // For correct permuting, we have to set output's shape to be equal in dimension position of the
  // input. But the positions of the same dimensions in the input and output may be set differently.
  // For example {2,3,4,5}(input's shape) can be reduced to {3,5}(output's shape). The original
  // output shape should be {1,3,1,5}, but real output shape may be {3,5}. If you simply try to
  // extend it in 4 dimensions, it should be {1,1,3,5}.
  // Even if output shape is changed to {1,3,1,5}, there is another problem. It is that shape of
  // output tensor used at next operation is changed to {1,3,1,5} after this operation even if the
  // next operation is not desired.
  if (ifm_shape.rank() == 4 && ifm_shape.rank() != ofm_shape.rank())
  {
    if (ofm_shape.rank() == 2)
    {
      // Reducing HW
      assert(ifm_shape.dim(0) == ofm_shape.dim(0) && ifm_shape.dim(3) == ofm_shape.dim(1));
    }
    else if (ofm_shape.rank() == 3)
    {
      // Reducing C or
      // (Reducing H and C(ifm and ofm) == 1) or (Reducing W and C(ifm and ofm) == 1)
      assert((ifm_shape.dim(0) == ofm_shape.dim(0) && ifm_shape.dim(1) == ofm_shape.dim(1) &&
              ifm_shape.dim(2) == ofm_shape.dim(2)) ||
             (ifm_shape.dim(0) == ofm_shape.dim(0) &&
              (ifm_shape.dim(1) == ofm_shape.dim(1) || ifm_shape.dim(2) == ofm_shape.dim(1)) &&
              ifm_shape.dim(3) == 1 && ofm_shape.dim(2) == 1));
    }
  }
}

void OperationValidator::visit(const ir::operation::DepthToSpace &node)
{
  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(ir::operation::DepthToSpace::Input::INPUT)};

  const auto frontend_layout = _current_subg_layout;
  const auto output_shape = _ctx.at(output_index).shape().asFeature(frontend_layout);
  const auto input_shape = _ctx.at(input_index).shape().asFeature(frontend_layout);

  UNUSED_RELEASE(output_shape);
  UNUSED_RELEASE(input_shape);

  assert(_ctx.at(input_index).shape().rank() == 4);
  assert(_ctx.at(output_index).shape().rank() == 4);

  int32_t block_size = node.param().block_size;

  UNUSED_RELEASE(block_size);

  assert(block_size > 0);

  { // assertions block
    assert(output_shape.N == input_shape.N);
    assert(output_shape.H == input_shape.H * block_size);
    assert(output_shape.W == input_shape.W * block_size);
    assert(input_shape.C % (block_size * block_size) == 0);
    assert(output_shape.C == input_shape.C / (block_size * block_size));
  }
}

void OperationValidator::visit(const ir::operation::Pack &node)
{
  const auto output_index{node.getOutputs().at(0)};
  const auto num{node.param().num};
  const auto axis{node.param().axis};

  const auto &output_shape = _ctx.at(output_index).shape();
  const auto output_rank = static_cast<int32_t>(output_shape.rank());

  const auto input1_index{node.getInputs().at(0)};
  const auto input_shape = _ctx.at(input1_index).shape();

  UNUSED_RELEASE(num);
  UNUSED_RELEASE(axis);
  UNUSED_RELEASE(output_rank);

  assert(num == static_cast<int32_t>(node.getInputs().size()));
  assert(axis >= -output_rank && axis < output_rank);
  for (const auto &index : node.getInputs())
  {
    UNUSED_RELEASE(index);
    assert(input_shape == _ctx.at(index).shape());
  }
}

void OperationValidator::visit(const ir::operation::ReduceMin &node)
{
  const auto ofm_index{node.getOutputs().at(0)};
  const auto ifm_index{node.getInputs().at(ir::operation::ReduceMin::Input::INPUT)};
  const auto &axes = node.param().axes;

  auto ifm_shape = _ctx.at(ifm_index).shape();
  auto ofm_shape = _ctx.at(ofm_index).shape();

  UNUSED_RELEASE(ifm_shape);
  UNUSED_RELEASE(ofm_shape);
  UNUSED_RELEASE(axes);

  assert(ifm_shape.rank() <= 4);
  assert(ofm_shape.rank() <= ifm_shape.rank());

  // NOTE For the 4-dimensions, if the rank of input and output are different, this runtime only
  // supports cases reducing height and width or reducing depth.
  // TODO We have to support all cases of dimensions up to 4.
  // For correct permuting, we have to set output's shape to be equal in dimension position of the
  // input. But the positions of the same dimensions in the input and output may be set differently.
  // For example {2,3,4,5}(input's shape) can be reduced to {3,5}(output's shape). The original
  // output shape should be {1,3,1,5}, but real output shape may be {3,5}. If you simply try to
  // extend it in 4 dimensions, it should be {1,1,3,5}.
  // Even if output shape is changed to {1,3,1,5}, there is another problem. It is that shape of
  // output tensor used at next operation is changed to {1,3,1,5} after this operation even if the
  // next operation is not desired.
  if (ifm_shape.rank() == 4 && ifm_shape.rank() != ofm_shape.rank())
  {
    if (ofm_shape.rank() == 2)
    {
      // Reducing HW
      assert(ifm_shape.dim(0) == ofm_shape.dim(0) && ifm_shape.dim(3) == ofm_shape.dim(1));
    }
    else if (ofm_shape.rank() == 3)
    {
      // Reducing C or
      // (Reducing H and C(ifm and ofm) == 1) or (Reducing W and C(ifm and ofm) == 1)
      assert((ifm_shape.dim(0) == ofm_shape.dim(0) && ifm_shape.dim(1) == ofm_shape.dim(1) &&
              ifm_shape.dim(2) == ofm_shape.dim(2)) ||
             (ifm_shape.dim(0) == ofm_shape.dim(0) &&
              (ifm_shape.dim(1) == ofm_shape.dim(1) || ifm_shape.dim(2) == ofm_shape.dim(1)) &&
              ifm_shape.dim(3) == 1 && ofm_shape.dim(2) == 1));
    }
  }
}

void OperationValidator::visit(const ir::operation::LSTM &node)
{
  // NOTE This validation is for static rnn(non-dynamic shape), but not for dynamic rnn
  // TODO Support dynamic rnn
  const auto scratch_buffer_index{
      node.getOutputs().at(ir::operation::LSTM::Output::SCRATCH_BUFFER)};
  const auto output_state_out_index{
      node.getOutputs().at(ir::operation::LSTM::Output::OUTPUT_STATE_OUT)};
  const auto cell_state_out_index{
      node.getOutputs().at(ir::operation::LSTM::Output::CELL_STATE_OUT)};
  const auto output_index{node.getOutputs().at(ir::operation::LSTM::Output::OUTPUT)};

  const auto input_index{node.getInputs().at(ir::operation::LSTM::Input::INPUT)};
  const auto input_to_input_weights_index{
      node.getInputs().at(ir::operation::LSTM::Input::INPUT_TO_INPUT_WEIGHTS)};
  const auto input_to_forget_weights_index{
      node.getInputs().at(ir::operation::LSTM::Input::INPUT_TO_FORGET_WEIGHTS)};
  const auto input_to_cell_weights_index{
      node.getInputs().at(ir::operation::LSTM::Input::INPUT_TO_CELL_WEIGHTS)};
  const auto input_to_output_weights_index{
      node.getInputs().at(ir::operation::LSTM::Input::INPUT_TO_OUTPUT_WEIGHTS)};
  const auto recurrent_to_input_weights_index{
      node.getInputs().at(ir::operation::LSTM::Input::RECURRENT_TO_INPUT_WEIGHTS)};
  const auto recurrent_to_forget_weights_index{
      node.getInputs().at(ir::operation::LSTM::Input::RECURRENT_TO_FORGET_WEIGHTS)};
  const auto recurrent_to_cell_weights_index{
      node.getInputs().at(ir::operation::LSTM::Input::RECURRENT_TO_CELL_WEIGHTS)};
  const auto recurrent_to_output_weights_index{
      node.getInputs().at(ir::operation::LSTM::Input::RECURRENT_TO_OUTPUT_WEIGHTS)};
  const auto cell_to_input_weights_index{
      node.getInputs().at(ir::operation::LSTM::Input::CELL_TO_INPUT_WEIGHTS)};
  const auto cell_to_forget_weights_index{
      node.getInputs().at(ir::operation::LSTM::Input::CELL_TO_FORGET_WEIGHTS)};
  const auto cell_to_output_weights_index{
      node.getInputs().at(ir::operation::LSTM::Input::CELL_TO_OUTPUT_WEIGHTS)};
  const auto input_gate_bias_index{
      node.getInputs().at(ir::operation::LSTM::Input::INPUT_GATE_BIAS)};
  const auto forget_gate_bias_index{
      node.getInputs().at(ir::operation::LSTM::Input::FORGET_GATE_BIAS)};
  const auto cell_bias_index{node.getInputs().at(ir::operation::LSTM::Input::CELL_BIAS)};
  const auto output_gate_bias_index{
      node.getInputs().at(ir::operation::LSTM::Input::OUTPUT_GATE_BIAS)};
  const auto projection_weights_index{
      node.getInputs().at(ir::operation::LSTM::Input::PROJECTION_WEIGHTS)};
  const auto projection_bias_index{
      node.getInputs().at(ir::operation::LSTM::Input::PROJECTION_BIAS)};
  const auto output_state_in_index{
      node.getInputs().at(ir::operation::LSTM::Input::OUTPUT_STATE_IN)};
  const auto cell_state_in_index{node.getInputs().at(ir::operation::LSTM::Input::CELL_STATE_IN)};

  UNUSED_RELEASE(scratch_buffer_index);
  UNUSED_RELEASE(output_state_out_index);
  UNUSED_RELEASE(cell_state_out_index);
  UNUSED_RELEASE(output_index);

  UNUSED_RELEASE(input_index);
  UNUSED_RELEASE(input_to_input_weights_index);
  UNUSED_RELEASE(input_to_forget_weights_index);
  UNUSED_RELEASE(input_to_cell_weights_index);
  UNUSED_RELEASE(input_to_output_weights_index);
  UNUSED_RELEASE(recurrent_to_input_weights_index);
  UNUSED_RELEASE(recurrent_to_forget_weights_index);
  UNUSED_RELEASE(recurrent_to_cell_weights_index);
  UNUSED_RELEASE(recurrent_to_output_weights_index);
  UNUSED_RELEASE(cell_to_input_weights_index);
  UNUSED_RELEASE(cell_to_forget_weights_index);
  UNUSED_RELEASE(cell_to_output_weights_index);
  UNUSED_RELEASE(input_gate_bias_index);
  UNUSED_RELEASE(forget_gate_bias_index);
  UNUSED_RELEASE(cell_bias_index);
  UNUSED_RELEASE(output_gate_bias_index);
  UNUSED_RELEASE(projection_weights_index);
  UNUSED_RELEASE(projection_bias_index);
  UNUSED_RELEASE(output_state_in_index);
  UNUSED_RELEASE(cell_state_in_index);

  assert(_ctx.at(scratch_buffer_index).shape().rank() == 2 &&
         _ctx.at(output_state_out_index).shape().rank() == 2 &&
         _ctx.at(cell_state_out_index).shape().rank() == 2 &&
         _ctx.at(output_index).shape().rank() == 2 && _ctx.at(input_index).shape().rank() == 2 &&
         _ctx.at(input_to_input_weights_index).shape().rank() == 2 &&
         _ctx.at(input_to_forget_weights_index).shape().rank() == 2 &&
         _ctx.at(input_to_cell_weights_index).shape().rank() == 2 &&
         _ctx.at(input_to_output_weights_index).shape().rank() == 2 &&
         _ctx.at(recurrent_to_input_weights_index).shape().rank() == 2 &&
         _ctx.at(recurrent_to_forget_weights_index).shape().rank() == 2 &&
         _ctx.at(recurrent_to_cell_weights_index).shape().rank() == 2 &&
         _ctx.at(recurrent_to_output_weights_index).shape().rank() == 2 &&
         _ctx.at(projection_weights_index).shape().rank() == 2 &&
         _ctx.at(output_state_in_index).shape().rank() == 2 &&
         _ctx.at(cell_state_in_index).shape().rank() == 2);

  assert(_ctx.at(cell_to_input_weights_index).shape().rank() == 1 &&
         _ctx.at(cell_to_forget_weights_index).shape().rank() == 1 &&
         _ctx.at(cell_to_output_weights_index).shape().rank() == 1 &&
         _ctx.at(input_gate_bias_index).shape().rank() == 1 &&
         _ctx.at(forget_gate_bias_index).shape().rank() == 1 &&
         _ctx.at(cell_bias_index).shape().rank() == 1 &&
         _ctx.at(output_gate_bias_index).shape().rank() == 1 &&
         _ctx.at(projection_bias_index).shape().rank() == 1);

  // CIFG assertion
  assert((_ctx.at(input_to_input_weights_index).shape().dim(0) == 0 &&
          _ctx.at(input_to_input_weights_index).shape().dim(1) == 0 &&
          _ctx.at(recurrent_to_input_weights_index).shape().dim(0) == 0 &&
          _ctx.at(recurrent_to_input_weights_index).shape().dim(1) == 0 &&
          _ctx.at(input_gate_bias_index).shape().dim(0) == 0 &&
          _ctx.at(cell_to_input_weights_index).shape().dim(0) == 0) ||
         (_ctx.at(input_to_input_weights_index).shape().dim(0) != 0 &&
          _ctx.at(input_to_input_weights_index).shape().dim(1) != 0 &&
          _ctx.at(recurrent_to_input_weights_index).shape().dim(0) != 0 &&
          _ctx.at(recurrent_to_input_weights_index).shape().dim(1) != 0 &&
          _ctx.at(input_gate_bias_index).shape().dim(0) != 0));

  // Peephole assertion
  assert((_ctx.at(cell_to_forget_weights_index).shape().dim(0) == 0 &&
          _ctx.at(cell_to_output_weights_index).shape().dim(0) == 0) ||
         (_ctx.at(cell_to_forget_weights_index).shape().dim(0) != 0 &&
          _ctx.at(cell_to_output_weights_index).shape().dim(0) != 0));

  bool has_input_to_input_weights = _ctx.at(input_to_input_weights_index).shape().dim(0) != 0 &&
                                    _ctx.at(input_to_input_weights_index).shape().dim(1) != 0;
  bool has_recurrent_to_input_weights =
      _ctx.at(recurrent_to_input_weights_index).shape().dim(0) != 0 &&
      _ctx.at(recurrent_to_input_weights_index).shape().dim(1) != 0;
  bool has_input_gate_bias = _ctx.at(input_gate_bias_index).shape().dim(0) != 0;
  bool has_cell_to_input_weights = _ctx.at(cell_to_input_weights_index).shape().dim(0) != 0;
  bool has_cell_to_forget_weights = _ctx.at(cell_to_forget_weights_index).shape().dim(0) != 0;
  bool has_cell_to_output_weights = _ctx.at(cell_to_output_weights_index).shape().dim(0) != 0;
  bool has_projection_weights = _ctx.at(projection_weights_index).shape().dim(0) != 0 &&
                                _ctx.at(projection_weights_index).shape().dim(1) != 0;
  bool has_projection_bias = _ctx.at(projection_bias_index).shape().dim(0);

  // NOTE The cell_to_input_weights do not exist in non-peephole although regular LSTM(non-CIFG).
  // true: no CIFG
  // false: CIFG
  bool has_cifg_param = has_input_to_input_weights && has_recurrent_to_input_weights;

  // NOTE The cell_to_input_weights do not exist in regular CIFG although peephole.
  // true: peephole
  // false: no peephole
  bool has_peephole_param = has_cell_to_forget_weights && has_cell_to_output_weights;

  // NOTE The projection weights may have data but the projection bias may not.
  bool has_projection_param = has_projection_weights;

  UNUSED_RELEASE(has_input_to_input_weights);
  UNUSED_RELEASE(has_recurrent_to_input_weights);
  UNUSED_RELEASE(has_input_gate_bias);
  UNUSED_RELEASE(has_cell_to_input_weights);
  UNUSED_RELEASE(has_cell_to_forget_weights);
  UNUSED_RELEASE(has_cell_to_output_weights);
  UNUSED_RELEASE(has_projection_weights);
  UNUSED_RELEASE(has_projection_bias);
  UNUSED_RELEASE(has_cifg_param);
  UNUSED_RELEASE(has_peephole_param);
  UNUSED_RELEASE(has_projection_param);

  const auto batch_size = _ctx.at(input_index).shape().dim(0);
  UNUSED_RELEASE(batch_size);
  assert(batch_size == _ctx.at(output_state_in_index).shape().dim(0) &&
         batch_size == _ctx.at(cell_state_in_index).shape().dim(0) &&
         batch_size == _ctx.at(scratch_buffer_index).shape().dim(0) &&
         batch_size == _ctx.at(output_state_out_index).shape().dim(0) &&
         batch_size == _ctx.at(cell_state_out_index).shape().dim(0) &&
         batch_size == _ctx.at(output_index).shape().dim(0));

  const auto input_size = _ctx.at(input_index).shape().dim(1);
  UNUSED_RELEASE(input_size);
  assert(input_size == _ctx.at(input_to_forget_weights_index).shape().dim(1) &&
         input_size == _ctx.at(input_to_cell_weights_index).shape().dim(1) &&
         input_size == _ctx.at(input_to_output_weights_index).shape().dim(1));

  const auto num_units = _ctx.at(cell_state_out_index).shape().dim(1);
  UNUSED_RELEASE(num_units);
  assert(num_units == _ctx.at(input_to_forget_weights_index).shape().dim(0) &&
         num_units == _ctx.at(input_to_cell_weights_index).shape().dim(0) &&
         num_units == _ctx.at(input_to_output_weights_index).shape().dim(0) &&
         num_units == _ctx.at(recurrent_to_forget_weights_index).shape().dim(0) &&
         num_units == _ctx.at(recurrent_to_cell_weights_index).shape().dim(0) &&
         num_units == _ctx.at(recurrent_to_output_weights_index).shape().dim(0) &&
         num_units == _ctx.at(forget_gate_bias_index).shape().dim(0) &&
         num_units == _ctx.at(cell_bias_index).shape().dim(0) &&
         num_units == _ctx.at(output_gate_bias_index).shape().dim(0) &&
         num_units == _ctx.at(cell_state_in_index).shape().dim(1) &&
         (((num_units * 3) == _ctx.at(scratch_buffer_index).shape().dim(1)) ||
          ((num_units * 4) == _ctx.at(scratch_buffer_index).shape().dim(1))));

  const auto output_size = _ctx.at(output_index).shape().dim(1);
  UNUSED_RELEASE(output_size);
  assert(output_size == _ctx.at(recurrent_to_forget_weights_index).shape().dim(1) &&
         output_size == _ctx.at(recurrent_to_cell_weights_index).shape().dim(1) &&
         output_size == _ctx.at(recurrent_to_output_weights_index).shape().dim(1) &&
         output_size == _ctx.at(output_state_in_index).shape().dim(1) &&
         output_size == _ctx.at(output_state_out_index).shape().dim(1));

  if (has_cifg_param)
  {
    assert(input_size == _ctx.at(input_to_input_weights_index).shape().dim(1));
    assert(num_units == _ctx.at(input_to_input_weights_index).shape().dim(0) &&
           num_units == _ctx.at(recurrent_to_input_weights_index).shape().dim(0) &&
           (num_units == _ctx.at(cell_to_input_weights_index).shape().dim(0) ||
            _ctx.at(cell_to_input_weights_index).shape().dim(0) == 0 /* non-peephole */) &&
           num_units == _ctx.at(input_gate_bias_index).shape().dim(0));
    assert(output_size == _ctx.at(recurrent_to_input_weights_index).shape().dim(1));
    assert(has_input_to_input_weights && has_recurrent_to_input_weights && has_input_gate_bias);
    if (has_cell_to_input_weights)
    {
      // NOTE The cell_to_input_weights exist only in case of non-CIFG and peephole.
      assert(has_peephole_param);
    }
    assert(_ctx.at(scratch_buffer_index).shape().dim(1) == num_units * 4);
  }
  else
  {
    assert(_ctx.at(scratch_buffer_index).shape().dim(1) == num_units * 3);
  }

  if (has_peephole_param)
  {
    assert(num_units == _ctx.at(cell_to_forget_weights_index).shape().dim(0) &&
           num_units == _ctx.at(cell_to_output_weights_index).shape().dim(0) &&
           (num_units == _ctx.at(cell_to_input_weights_index).shape().dim(0) ||
            _ctx.at(cell_to_input_weights_index).shape().dim(0) == 0 /* CIFG */));
  }

  if (has_projection_param)
  {
    assert(num_units == _ctx.at(projection_weights_index).shape().dim(1));
    assert(output_size == _ctx.at(projection_weights_index).shape().dim(0));
    if (has_projection_bias)
    {
      assert(output_size == _ctx.at(projection_bias_index).shape().dim(0));
    }
  }
}

void OperationValidator::visit(const ir::operation::Unpack &node)
{
  const auto input_index{node.getInputs().at(ir::operation::Unpack::Input::INPUT)};
  const auto num{node.param().num};
  const auto axis{node.param().axis};

  const auto &input_shape = _ctx.at(input_index).shape();
  const auto input_rank = static_cast<int32_t>(input_shape.rank());

  UNUSED_RELEASE(num);
  UNUSED_RELEASE(axis);
  UNUSED_RELEASE(input_rank);

  assert(num == static_cast<int32_t>(node.getOutputs().size()));
  assert(axis >= -input_rank && axis < input_rank);
}

void OperationValidator::visit(const ir::operation::Pad &node)
{
  const auto input_index{node.getInputs().at(ir::operation::Pad::Input::INPUT)};
  const auto pad_index{node.getInputs().at(ir::operation::Pad::Input::PAD)};
  const auto output_index{node.getInputs().at(0)};

  const auto &pad_shape = _ctx.at(pad_index).shape();
  const auto input_rank = static_cast<int32_t>(_ctx.at(input_index).shape().rank());

  UNUSED_RELEASE(pad_shape);
  UNUSED_RELEASE(input_rank);
  UNUSED_RELEASE(output_index);

  assert(pad_shape.rank() == 2);
  assert(pad_shape.dim(0) == input_rank);
  assert(pad_shape.dim(1) == 2);
  assert(_ctx.at(pad_index).typeInfo().type() == ir::DataType::INT32);
  assert(_ctx.at(input_index).shape().rank() == _ctx.at(output_index).shape().rank());
}

void OperationValidator::visit(const ir::operation::Min &node)
{
  const auto output_index{node.getOutputs().at(0)};
  const auto lhs_index{node.getInputs().at(ir::operation::Min::Input::LHS)};
  const auto rhs_index{node.getInputs().at(ir::operation::Min::Input::RHS)};

  UNUSED_RELEASE(output_index);
  UNUSED_RELEASE(lhs_index);
  UNUSED_RELEASE(rhs_index);

  assert(_ctx.at(lhs_index).typeInfo().type() == _ctx.at(rhs_index).typeInfo().type());
  assert(_ctx.at(lhs_index).typeInfo().type() == _ctx.at(output_index).typeInfo().type());
}

void OperationValidator::visit(const ir::operation::Max &node)
{
  const auto output_index{node.getOutputs().at(0)};
  const auto lhs_index{node.getInputs().at(ir::operation::Max::Input::LHS)};
  const auto rhs_index{node.getInputs().at(ir::operation::Max::Input::RHS)};

  UNUSED_RELEASE(output_index);
  UNUSED_RELEASE(lhs_index);
  UNUSED_RELEASE(rhs_index);

  assert(_ctx.at(lhs_index).typeInfo().type() == _ctx.at(rhs_index).typeInfo().type());
  assert(_ctx.at(lhs_index).typeInfo().type() == _ctx.at(output_index).typeInfo().type());
}

} // namespace compiler
} // namespace neurun