Graph.h

Go to the documentation of this file.

/*
 * 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.
 */
 
#ifndef __ONERT_IR_GRAPH_H__
#define __ONERT_IR_GRAPH_H__
 
#include <functional>
#include <unordered_map>
 
#include "ir/IGraph.h"
#include "ir/Model.h"
#include "ir/Operands.h"
#include "ir/Operations.h"
 
namespace onert::ir
{
 
class Graph : public IGraph
{
private:
  enum class Phase
  {
    BUILDING,
    MODEL
  };
 
public:
  explicit Graph(void);
  explicit Graph(const Graph &);
 
  ~Graph(void);
 
  // Graph Building
public:
  OperandIndex addOperand(const Shape &shape, const TypeInfo &type);
  OperandIndex addOperand(OperandIndex index, std::unique_ptr<Operand> &&operand);
  OperationIndex addOperation(std::unique_ptr<IOperation> &&node);
  OperationIndex addOperation(OperationIndex index, std::unique_ptr<IOperation> &&operation);
  OperationIndex replaceOperation(OperationIndex index, std::unique_ptr<IOperation> &&operation);
  void setOperandValue(const OperandIndex &ind, std::shared_ptr<Data> data);
  void changeShape(const OperandIndex &ind, const ir::Shape &new_shape) override;
  void addInput(const OperandIndex &ind, const std::string &name = "");
  void addOutput(const OperandIndex &ind, const std::string &name = "");
  void verify(void) const;
  void removeOperand(const OperandIndex &ind) { _operands.remove(ind); }
 
private:
  bool checkOperandsForOperation(const IOperation &operation);
  void linkOperandToOperation(OperationIndex index, const IOperation &operation);
  void initializeUseDef();
  // TODO Rename to `sweepUnusedOperands`
  // TODO Make this public
  void sweepGarbageOperands();
 
  // Accessors
public:
  const OperandIndexSequence &getInputs() const override { return _inputs; }
  OperandIndexSequence &getInputs() { return _inputs; }
  const OperandIndexSequence &getOutputs() const override { return _outputs; }
  OperandIndexSequence &getOutputs() { return _outputs; }
  IOIndex getInputIndex(const std::string &name) const override;
  IOIndex getOutputIndex(const std::string &name) const override;
  const Operands &operands() const override { return _operands; }
  Operands &operands() { return _operands; } // TODO Remove this non-const accessor
  const Operations &operations() const override { return _operations; }
  Operations &operations() { return _operations; }
 
  // Topological sort
public:
  std::vector<ir::OperationIndex> topolSortOperations() const;
 
private:
  Operations _operations;
  Operands _operands;
  OperandIndexSequence _inputs;
  OperandIndexSequence _outputs;
  // TODO: Apply Heterogeneous lookup for unordered containers (transparent hashing) since C++20
  //       to use `std::string_view` with lookup functions in unordered containers
  std::unordered_map<std::string, IOIndex> _name_to_input;
  std::unordered_map<std::string, IOIndex> _name_to_output;
};
class Graph : public IGraph {…};
 
} // namespace onert::ir
 
#endif // __ONERT_IR_GRAPH_H__