catch up to tizen_5.5 and remove unness dir

- update to tizen_5.5
- remove dirs

12 files changed, 949 insertions, 0 deletions

diff --git a/runtimes/neurun/core/src/dumper/dot/DotBuilder.cc b/runtimes/neurun/core/src/dumper/dot/DotBuilder.cc
new file mode 100644
index 000000000..8563b4cf0
--- /dev/null
+++ b/runtimes/neurun/core/src/dumper/dot/DotBuilder.cc
@@ -0,0 +1,83 @@
+/*
+ * 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 "DotBuilder.h"
+
+namespace neurun
+{
+namespace dumper
+{
+namespace dot
+{
+
+// DotDumper
+DotBuilder::DotBuilder() {}
+
+void DotBuilder::update(const Node &node_info)
+{
+  addNode(node_info);
+  for (auto edge : node_info.edges())
+  {
+    addEdge(node_info, *edge);
+  }
+}
+
+void DotBuilder::addSubgraph(const DotSubgraphInfo &subgraph_info)
+{
+  _dot << "subgraph cluster_" << subgraph_info.index().value() << " {\n";
+  _dot << "  label=\"" << subgraph_info.label() << "\";\n";
+  _dot << "  style=filled;\n";
+  _dot << "  color=lightgrey;\n";
+  _dot << "  ";
+  for (auto op : subgraph_info.operations())
+  {
+    _dot << "operation" << op.value() << "; ";
+  }
+  for (auto op : subgraph_info.operands())
+  {
+    _dot << "operand" << op.value() << "; ";
+  }
+  _dot << "\n";
+  _dot << "}\n";
+}
+
+void DotBuilder::writeDot(std::ostream &os)
+{
+  os << "digraph D {\n"
+     << _dot.str() << "\n"
+     << "}\n";
+}
+
+void DotBuilder::addNode(const Node &node)
+{
+  _dot << node.id();
+  std::stringstream ss;
+  _dot << "[";
+  for (auto attr : node.attributes())
+  {
+    _dot << attr.first << "=\"" << attr.second << "\" ";
+  }
+  _dot << "];\n";
+}
+
+void DotBuilder::addEdge(const Node &node1, const Node &node2)
+{
+  _dot << node1.id() << " -> " << node2.id() << ";\n";
+}
+
+} // namespace dot
+} // namespace dumper
+} // namespace neurun
diff --git a/runtimes/neurun/core/src/dumper/dot/DotBuilder.h b/runtimes/neurun/core/src/dumper/dot/DotBuilder.h
new file mode 100644
index 000000000..b78fd4469
--- /dev/null
+++ b/runtimes/neurun/core/src/dumper/dot/DotBuilder.h
@@ -0,0 +1,62 @@
+/*
+ * 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 __NEURUN_DUMPER_DOT_DOT_BUILDER_H__
+#define __NEURUN_DUMPER_DOT_DOT_BUILDER_H__
+
+#include <sstream>
+
+#include "model/Index.h"
+#include "model/Operation.h"
+#include "model/Operand.h"
+
+#include "OperationNode.h"
+#include "OperandNode.h"
+#include "DotSubgraphInfo.h"
+
+using Operation = neurun::model::Operation;
+using Object = neurun::model::Operand;
+
+namespace neurun
+{
+namespace dumper
+{
+namespace dot
+{
+
+class DotBuilder
+{
+public:
+  DotBuilder();
+
+public:
+  void update(const Node &dotinfo);
+  void addSubgraph(const DotSubgraphInfo &subgraph_info);
+
+  void writeDot(std::ostream &os);
+
+private:
+  void addNode(const Node &dotinfo);
+  void addEdge(const Node &dotinfo1, const Node &dotinfo2);
+
+  std::stringstream _dot;
+};
+
+} // namespace dot
+} // namespace dumper
+} // namespace neurun
+
+#endif // __NEURUN_DUMPER_DOT_DOT_BUILDER_H__
diff --git a/runtimes/neurun/core/src/dumper/dot/DotDumper.cc b/runtimes/neurun/core/src/dumper/dot/DotDumper.cc
new file mode 100644
index 000000000..d01b472c3
--- /dev/null
+++ b/runtimes/neurun/core/src/dumper/dot/DotDumper.cc
@@ -0,0 +1,198 @@
+/*
+ * 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 <fstream>
+#include <unordered_map>
+
+#include "DotDumper.h"
+#include "DotBuilder.h"
+#include "DotSubgraphInfo.h"
+#include "model/Subgraph.h"
+#include "model/OperationIndexMap.h"
+#include "backend/Backend.h"
+#include "backend/BackendManager.h"
+#include "backend/IConfig.h"
+
+namespace neurun
+{
+namespace dumper
+{
+namespace dot
+{
+
+using namespace neurun::graph;
+
+void DotDumper::dump(const std::string &tag)
+{
+  if (_level == Level::OFF)
+  {
+    return;
+  }
+
+  neurun::dumper::dot::DotBuilder dot_builder;
+
+  auto &operations = _graph.operations();
+  auto &operands = _graph.operands();
+
+  model::OperationIndexMap<std::unique_ptr<OperationNode>> operation_nodes;
+  std::unordered_map<model::OperandIndex, std::unique_ptr<OperandNode>> operand_nodes;
+
+  operations.iterate([&](const model::OperationIndex &index, const model::Operation &op) {
+    auto node = nnfw::cpp14::make_unique<OperationNode>(index, op);
+
+    for (auto output : op.getOutputs())
+    {
+      using neurun::dumper::dot::OperandNode;
+      auto child = std::make_shared<OperandNode>(output, OperandNode::Type::MODEL_OUTPUT);
+      node->addEdge(child);
+    }
+
+    operation_nodes.emplace(index, std::move(node));
+  });
+
+  auto backend_to_fillcolor = [](const backend::Backend *backend) {
+    static const auto map = []() {
+      std::unordered_map<const backend::Backend *, std::string> ret;
+      uint32_t index = 1; // Start from 1 to avoid 0(red) which is too dark :(
+      for (const auto backend : backend::BackendManager::instance().getAll())
+      {
+        ret.emplace(backend, Node::BG_COLORS[index]);
+        index = (index + 1) % (sizeof(Node::BG_COLORS) / sizeof(Node::BG_COLORS[0]));
+      }
+      return ret;
+    }();
+
+    auto itr = map.find(backend);
+    if (itr == map.end())
+    {
+      return Node::DEFAULT_FILLCOLOR;
+    }
+    else
+    {
+      return itr->second;
+    }
+  };
+
+  util::Set<model::OperandIndex> shown_operand_set;
+
+  operands.iterate([&](const model::OperandIndex &index, const model::Operand &object) {
+    bool showing_cond = false;
+    if (_level == Level::ALL)
+    {
+      showing_cond = true;
+    }
+    else
+    {
+      showing_cond = !object.isConstant();
+    }
+    if (object.isConstant() || _graph.getInputs().contains(index))
+    {
+      showing_cond = showing_cond && (object.getUses().size() > 0);
+    }
+    if (showing_cond)
+    {
+      shown_operand_set.add(index);
+
+      auto type = [&]() {
+        using neurun::dumper::dot::OperandNode;
+        if (_graph.getInputs().contains(index))
+          return OperandNode::Type::MODEL_INPUT;
+        if (_graph.getOutputs().contains(index))
+          return OperandNode::Type::MODEL_OUTPUT;
+        return OperandNode::Type::INTERNAL;
+      }();
+
+      auto lower_info = _graph.getLowerInfo(index);
+      auto node = nnfw::cpp14::make_unique<OperandNode>(index, type);
+
+      {
+        // Display LowerInfo attributes
+        std::string label = std::to_string(index.value());
+        std::string fillcolor = "";
+        if (lower_info)
+        {
+          const auto &def_factors = lower_info->def_factors();
+          label += "\\n[";
+          label += def_factors.getOnlyElement().backend()->config()->id();
+          label += "]";
+
+          fillcolor = backend_to_fillcolor(lower_info->def_factors().getOnlyElement().backend());
+        }
+        node->setAttribute("label", label);
+        node->setAttribute("fillcolor", fillcolor);
+      }
+
+      for (auto operation_index : object.getUses().list())
+      {
+        auto &operation = operations.at(operation_index);
+        auto child = std::make_shared<OperationNode>(operation_index, operation);
+        node->addEdge(child);
+      }
+
+      operand_nodes.emplace(index, std::move(node));
+    }
+  });
+
+  const auto subgraphs = _graph.subgraphs();
+  if (subgraphs)
+  {
+    subgraphs->iterate([&](const model::SubgraphIndex &index, const model::Subgraph &subgraph) {
+      const auto lower_info = _graph.getLowerInfo(index);
+      auto fillcolor = backend_to_fillcolor(lower_info->backend());
+      std::string label =
+          std::to_string(index.value()) + " [" + lower_info->backend()->config()->id() + "]";
+      DotSubgraphInfo subgraph_info{index, subgraph, shown_operand_set};
+      subgraph_info.label(label);
+      subgraph_info.fillcolor(fillcolor);
+      dot_builder.addSubgraph(subgraph_info);
+
+      // Set fillcolor of all operations in the subgraph
+      for (const auto &op : subgraph.operations())
+      {
+        auto found = operation_nodes.find(op.index);
+        if (found != operation_nodes.end())
+        {
+          auto &&op = found->second;
+          op->setAttribute("fillcolor", fillcolor);
+        }
+      }
+    });
+  }
+
+  for (const auto &e : operation_nodes)
+    dot_builder.update(*e.second);
+  for (const auto &e : operand_nodes)
+    dot_builder.update(*e.second);
+
+  // Dump to file
+  {
+    std::string file_name;
+    file_name += tag;
+    file_name += ".dot";
+    std::filebuf fb;
+
+    fb.open(file_name, std::ios::out);
+    std::ostream os(&fb);
+
+    dot_builder.writeDot(os);
+
+    fb.close();
+  }
+}
+
+} // namespace dot
+} // namespace dumper
+} // namespace neurun
diff --git a/runtimes/neurun/core/src/dumper/dot/DotDumper.h b/runtimes/neurun/core/src/dumper/dot/DotDumper.h
new file mode 100644
index 000000000..4ccaac882
--- /dev/null
+++ b/runtimes/neurun/core/src/dumper/dot/DotDumper.h
@@ -0,0 +1,60 @@
+/*
+ * 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 "graph/Graph.h"
+
+#ifndef __NEURUN_DUMPER_DOT_DOT_DUMPER_H__
+#define __NEURUN_DUMPER_DOT_DOT_DUMPER_H__
+
+namespace neurun
+{
+namespace dumper
+{
+namespace dot
+{
+
+class DotDumper
+{
+public:
+  enum Level
+  {
+    OFF = 0,               //< Do not dump
+    ALL_BUT_CONSTANTS = 1, //< Emit all operations and operands but constants
+    ALL = 2                //< Emit all operations and operands
+  };
+
+public:
+  DotDumper(const neurun::graph::Graph &graph, Level level) : _graph(graph), _level{level} {}
+
+public:
+  /**
+   * @brief Dump to dot file as tag name if "GRAPH_DOT_DUMP" is set
+   *
+   * @param[in] tag    The name of dot file that would be created
+   * @return N/A
+   */
+  void dump(const std::string &tag);
+
+private:
+  const neurun::graph::Graph &_graph;
+  Level _level;
+};
+
+} // namespace dot
+} // namespace dumper
+} // namespace neurun
+
+#endif // __NEURUN_DUMPER_DOT_DOT_DUMPER_H__
diff --git a/runtimes/neurun/core/src/dumper/dot/DotSubgraphInfo.cc b/runtimes/neurun/core/src/dumper/dot/DotSubgraphInfo.cc
new file mode 100644
index 000000000..1ea681bdb
--- /dev/null
+++ b/runtimes/neurun/core/src/dumper/dot/DotSubgraphInfo.cc
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2019 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 "DotSubgraphInfo.h"
+
+#include <sstream>
+
+namespace neurun
+{
+namespace dumper
+{
+namespace dot
+{
+
+DotSubgraphInfo::DotSubgraphInfo(const model::SubgraphIndex &index, const model::Subgraph &subgraph,
+                                 const util::Set<model::OperandIndex> &shown_operands)
+    : _index{index}
+{
+  for (const auto &element : subgraph.operations())
+  {
+    _operations.insert(element.index);
+    for (auto o : element.node->getInputs())
+    {
+      // Must be a shown operand, not subgraph's inputs
+      if (shown_operands.contains(o) && !subgraph.getInputs().contains(o))
+      {
+        _operands.insert(o);
+      }
+    }
+    for (auto o : element.node->getOutputs())
+    {
+      // Must be a shown operand, not subgraph's inputs
+      if (shown_operands.contains(o) && !subgraph.getOutputs().contains(o))
+      {
+        _operands.insert(o);
+      }
+    }
+  }
+}
+
+} // namespace dot
+} // namespace dumper
+} // namespace neurun
diff --git a/runtimes/neurun/core/src/dumper/dot/DotSubgraphInfo.h b/runtimes/neurun/core/src/dumper/dot/DotSubgraphInfo.h
new file mode 100644
index 000000000..771c5552e
--- /dev/null
+++ b/runtimes/neurun/core/src/dumper/dot/DotSubgraphInfo.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2019 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 __NEURUN_CORE_DUMPER_DOT_DOT_SUBGRAPH_INFO_H__
+#define __NEURUN_CORE_DUMPER_DOT_DOT_SUBGRAPH_INFO_H__
+
+#include <unordered_set>
+
+#include "model/Index.h"
+#include "model/Subgraph.h"
+#include "util/Set.h"
+
+namespace neurun
+{
+namespace dumper
+{
+namespace dot
+{
+
+class DotSubgraphInfo
+{
+public:
+  DotSubgraphInfo(const model::SubgraphIndex &index, const model::Subgraph &subgraph,
+                  const util::Set<model::OperandIndex> &shown_operands);
+
+  model::SubgraphIndex index() const { return _index; }
+  std::string label() const { return _label; }
+  void label(const std::string &val) { _label = val; }
+  std::string fillcolor() const { return _fillcolor; }
+  void fillcolor(const std::string &val) { _fillcolor = val; }
+  const std::unordered_set<model::OperationIndex> &operations() const { return _operations; }
+  const std::unordered_set<model::OperandIndex> &operands() const { return _operands; }
+
+private:
+  model::SubgraphIndex _index;
+  std::string _label;
+  std::string _fillcolor;
+  std::unordered_set<model::OperationIndex> _operations;
+  std::unordered_set<model::OperandIndex> _operands;
+};
+
+} // namespace dot
+} // namespace dumper
+} // namespace neurun
+
+#endif // __NEURUN_CORE_DUMPER_DOT_DOT_SUBGRAPH_INFO_H__
diff --git a/runtimes/neurun/core/src/dumper/dot/Node.cc b/runtimes/neurun/core/src/dumper/dot/Node.cc
new file mode 100644
index 000000000..166f0f40f
--- /dev/null
+++ b/runtimes/neurun/core/src/dumper/dot/Node.cc
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2019 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 "Node.h"
+
+namespace neurun
+{
+namespace dumper
+{
+namespace dot
+{
+
+const std::string Node::DEFAULT_COLORSCHEME = "x11";
+const std::string Node::DEFAULT_FILLCOLOR = "white";
+// RED, BLUE, GREEN, PURPLE, ORANGE, YELLOW, BROWN, PINK
+const std::string Node::BG_COLORS[8] = {"1", "2", "3", "4", "5", "6", "7", "8"};
+
+Node::Node(const std::string &id) : _id{id}
+{
+  // Set default values
+  _attributes["style"] = "filled";
+  _attributes["colorscheme"] = DEFAULT_COLORSCHEME;
+  _attributes["fillcolor"] = DEFAULT_FILLCOLOR;
+}
+
+void Node::setAttribute(const std::string &key, const std::string &val) { _attributes[key] = val; }
+
+std::string Node::getAttribute(const std::string &key)
+{
+  auto itr = _attributes.find(key);
+  if (itr == _attributes.end())
+  {
+    return "";
+  }
+  else
+  {
+    return itr->second;
+  }
+}
+
+} // namespace dot
+} // namespace dumper
+} // namespace neurun
diff --git a/runtimes/neurun/core/src/dumper/dot/Node.h b/runtimes/neurun/core/src/dumper/dot/Node.h
new file mode 100644
index 000000000..364cb08a4
--- /dev/null
+++ b/runtimes/neurun/core/src/dumper/dot/Node.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2019 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.
+ */
+
+/**
+ * @file Node.h
+ * @brief    This file contains Node class
+ * @ingroup  COM_AI_RUNTIME
+ *
+ */
+
+#ifndef __NEURUN_DUMPER_DOT_NODE_H__
+#define __NEURUN_DUMPER_DOT_NODE_H__
+
+#include <string>
+#include <memory>
+#include <vector>
+#include <unordered_map>
+
+namespace neurun
+{
+namespace dumper
+{
+namespace dot
+{
+
+enum BGCOLORS : int
+{
+  RED,
+  BLUE,
+  GREEN,
+  PUPLE,
+  ORANGE,
+  YELLOW,
+  BROWN,
+  PINK
+};
+
+/**
+ * @brief Class that represents a Node in "dot" format
+ *
+*/
+class Node
+{
+public:
+  const static std::string DEFAULT_FILLCOLOR;
+  const static std::string DEFAULT_COLORSCHEME;
+  const static std::string BG_COLORS[8];
+
+public:
+  /**
+   * @brief Destroy the Node object
+   *
+  */
+  virtual ~Node() = default;
+
+  /**
+   * @brief Construct a new Node object
+   *
+   * @param id
+  */
+  Node(const std::string &id);
+
+  /**
+   * @brief return id
+   *
+   * @return id
+  */
+  std::string id() const { return _id; }
+
+  /**
+   * @brief return attributes
+   *
+   * @return const reference of attributes object
+  */
+  const std::unordered_map<std::string, std::string> &attributes() const { return _attributes; }
+  /**
+   * @brief Store an attribute with key-value pair
+   *
+   * @param[in] key attribute's key
+   * @param[in] val attribute's value that is associated with the key
+  */
+  void setAttribute(const std::string &key, const std::string &val);
+  /**
+   * @brief Get the attributte value that is associated with key
+   *
+   * @param[in] key key of the attribute
+   * @return value that is associated with the key
+  */
+  std::string getAttribute(const std::string &key);
+
+  /**
+   * @brief Add an edge in the graph, which is an outgoing edge
+   *
+   * @param[in] dotinfo A node that the new edge will be connected to
+  */
+  void addEdge(std::shared_ptr<Node> dotinfo) { _children.emplace_back(dotinfo); }
+  /**
+   * @brief Return list of edges
+   *
+   * @return Edges
+  */
+  const std::vector<std::shared_ptr<Node>> &edges() const { return _children; }
+
+private:
+  std::string _id;
+  std::unordered_map<std::string, std::string> _attributes;
+  std::vector<std::shared_ptr<Node>> _children;
+};
+
+} // namespace dot
+} // namespace dumper
+} // namespace neurun
+
+#endif // __NEURUN_DUMPER_DOT_NODE_H__
diff --git a/runtimes/neurun/core/src/dumper/dot/OperandNode.cc b/runtimes/neurun/core/src/dumper/dot/OperandNode.cc
new file mode 100644
index 000000000..338dfc4b6
--- /dev/null
+++ b/runtimes/neurun/core/src/dumper/dot/OperandNode.cc
@@ -0,0 +1,60 @@
+/*
+ * 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 <sstream>
+
+#include "OperandNode.h"
+#include "graph/Graph.h"
+#include "graph/operand/LowerInfo.h"
+
+namespace neurun
+{
+namespace dumper
+{
+namespace dot
+{
+
+const std::string OperandNode::INPUT_SHAPE = "doublecircle";
+const std::string OperandNode::OUTPUT_SHAPE = "doublecircle";
+const std::string OperandNode::OPERAND_SHAPE = "ellipse";
+const std::string OperandNode::BG_COLOR_SCHEME = "set18";
+
+OperandNode::OperandNode(const neurun::model::OperandIndex &index, Type type)
+    : Node{"operand" + std::to_string(index.value())}
+{
+  {
+    auto type_to_shape = [](Type type) {
+      switch (type)
+      {
+        case Type::MODEL_INPUT:
+          return INPUT_SHAPE;
+        case Type::MODEL_OUTPUT:
+          return OUTPUT_SHAPE;
+        case Type::UNDEFINED:
+        case Type::INTERNAL:
+        default:
+          return OPERAND_SHAPE;
+      }
+    };
+    setAttribute("shape", type_to_shape(type));
+  }
+
+  setAttribute("colorscheme", BG_COLOR_SCHEME);
+}
+
+} // namespace dot
+} // namespace dumper
+} // namespace neurun
diff --git a/runtimes/neurun/core/src/dumper/dot/OperandNode.h b/runtimes/neurun/core/src/dumper/dot/OperandNode.h
new file mode 100644
index 000000000..40f715eac
--- /dev/null
+++ b/runtimes/neurun/core/src/dumper/dot/OperandNode.h
@@ -0,0 +1,79 @@
+/*
+ * 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.
+ */
+
+/**
+ * @file OperandNode.h
+ * @brief    This file contains OperandNode
+ * @ingroup  COM_AI_RUNTIME
+ *
+ */
+
+#ifndef __NEURUN_DUMPER_DOT_DOT_OPERAND_INFO_H__
+#define __NEURUN_DUMPER_DOT_DOT_OPERAND_INFO_H__
+
+#include <vector>
+
+#include "Node.h"
+#include "model/Operand.h"
+#include "model/Index.h"
+
+namespace neurun
+{
+namespace dumper
+{
+namespace dot
+{
+
+/**
+ * @brief Class that represents an Operand
+ *
+ */
+class OperandNode : public Node
+{
+public:
+  enum class Type
+  {
+    UNDEFINED,
+    MODEL_INPUT,
+    MODEL_OUTPUT,
+    INTERNAL
+  };
+
+public:
+  static const std::string INPUT_SHAPE;
+  static const std::string OUTPUT_SHAPE;
+  static const std::string OPERAND_SHAPE;
+  static const std::string BG_COLOR_SCHEME;
+
+public:
+  /**
+   * @brief Construct a new Operand Node object
+   *
+   * @param[in] index Operand index
+   * @param[in] type Operand type
+   * @param[in] lower_info Operand LowerInfo
+   */
+  OperandNode(const neurun::model::OperandIndex &index, Type type);
+
+private:
+  void addBackendLabel();
+};
+
+} // namespace dot
+} // namespace dumper
+} // namespace neurun
+
+#endif // __NEURUN_DUMPER_DOT_DOT_OPERAND_INFO_H__
diff --git a/runtimes/neurun/core/src/dumper/dot/OperationNode.cc b/runtimes/neurun/core/src/dumper/dot/OperationNode.cc
new file mode 100644
index 000000000..040241daa
--- /dev/null
+++ b/runtimes/neurun/core/src/dumper/dot/OperationNode.cc
@@ -0,0 +1,47 @@
+/*
+ * 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 <sstream>
+
+#include "OperationNode.h"
+#include "graph/Graph.h"
+#include "graph/operation/LowerInfo.h"
+#include "backend/IConfig.h"
+#include "backend/Backend.h"
+
+namespace neurun
+{
+namespace dumper
+{
+namespace dot
+{
+
+const std::string OperationNode::OPERATION_SHAPE = "rect";
+const std::string OperationNode::BG_COLOR_SCHEME = "pastel18";
+
+OperationNode::OperationNode(const neurun::model::OperationIndex &index,
+                             const neurun::model::Operation &node)
+    : Node{"operation" + std::to_string(index.value())}
+{
+  setAttribute("label", std::to_string(index.value()) + " : " + node.getName());
+  setAttribute("shape", OPERATION_SHAPE);
+  setAttribute("colorscheme", BG_COLOR_SCHEME);
+  setAttribute("fillcolor", DEFAULT_FILLCOLOR);
+}
+
+} // namespace dot
+} // namespace dumper
+} // namespace neurun
diff --git a/runtimes/neurun/core/src/dumper/dot/OperationNode.h b/runtimes/neurun/core/src/dumper/dot/OperationNode.h
new file mode 100644
index 000000000..6b8dede2d
--- /dev/null
+++ b/runtimes/neurun/core/src/dumper/dot/OperationNode.h
@@ -0,0 +1,62 @@
+/*
+ * 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.
+ */
+
+/**
+ * @file OperationNode.h
+ * @brief    This file contains OperationNode
+ * @ingroup  COM_AI_RUNTIME
+ *
+ */
+
+#ifndef __NEURUN_DUMPER_DOT_DOT_NODE_INFO_H__
+#define __NEURUN_DUMPER_DOT_DOT_NODE_INFO_H__
+
+#include "Node.h"
+#include "model/Operation.h"
+#include "model/Index.h"
+
+namespace neurun
+{
+namespace dumper
+{
+namespace dot
+{
+
+/**
+ * @brief Class that represents an Operation
+ *
+ */
+class OperationNode : public Node
+{
+public:
+  static const std::string OPERATION_SHAPE;
+  static const std::string BG_COLOR_SCHEME;
+
+public:
+  /**
+   * @brief Construct a new Operation Node object
+   *
+   * @param[in] index operation index
+   * @param[in] node operation object
+  */
+  OperationNode(const neurun::model::OperationIndex &index, const neurun::model::Operation &node);
+};
+
+} // namespace dot
+} // namespace dumper
+} // namespace neurun
+
+#endif // __NEURUN_DUMPER_DOT_DOT_NODE_INFO_H__