GraphBuilder.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2020 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 "luci/Import/GraphBuilder.h"
 
#include <luci/Log.h>
 
namespace luci
{
 
CircleNode *GraphBuilder::build(const circle::OperatorT &op, GraphBuilderContext *context) const
{
  LOGGER(l);
 
  assert(context != nullptr);
 
  const std::vector<int32_t> &inputs = op.inputs;
  const std::vector<int32_t> &outputs = op.outputs;
  const auto tensors = context->reader()->tensors();
  const auto opcodes = context->reader()->opcodes();
  assert(!tensors.null());
 
  std::vector<CircleNode *> input_nodes;
  for (const int32_t input_tensor_index : inputs)
  {
    if (input_tensor_index >= 0)
    {
      auto input = context->nodefinder()->node(input_tensor_index);
      if (input == nullptr)
        INFO(l) << "[luci] Warning: input node is null " << input_tensor_index << std::endl;
      input_nodes.push_back(input);
    }
    else
    {
      // If there is no tensor, insert CircleOutputExclude.
      auto *node = context->graph()->nodes()->create<luci::CircleOutputExclude>();
      input_nodes.push_back(node);
    }
  }
 
  CircleNode *node = build_node(op, input_nodes, context->graph());
 
  // Set up node parameters.
  assert(outputs.size() == 1);
  {
    const auto output_tensor = tensors[outputs[0]];
    assert(output_tensor != nullptr);
    copy_tensor_attributes(output_tensor, node);
    // mark shape_status
    if (output_tensor->shape() == nullptr)
      node->shape_status(ShapeStatus::NOSHAPE);
    else
      node->shape_status(ShapeStatus::VALID);
 
    // mark operator version
    assert(opcodes[op.opcode_index] != nullptr);
    node->op_version(opcodes[op.opcode_index]->version());
  }
 
  // Register node's only output.
  assert(outputs.size() == 1);
  {
    context->nodefinder()->enroll(outputs[0], node);
  }
 
  return node;
}
 
} // namespace luci