node.h 5.1 KB
Newer Older
X
Xin Pan 已提交
1
/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
X
start  
Xin Pan 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

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. */

#pragma once

17
#include <memory>
X
Xin Pan 已提交
18
#include <string>
X
Xin Pan 已提交
19 20
#include <typeindex>
#include <typeinfo>
X
Xin Pan 已提交
21
#include <vector>
22 23
#include "paddle/fluid/framework/op_desc.h"
#include "paddle/fluid/framework/var_desc.h"
X
Xin Pan 已提交
24 25
#include "paddle/fluid/platform/macros.h"

X
start  
Xin Pan 已提交
26
namespace paddle {
X
Xin Pan 已提交
27
namespace framework {
X
tmp  
Xin Pan 已提交
28
namespace ir {
X
Xin Pan 已提交
29

X
Xin Pan 已提交
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
// Node should only created by Graph::CreateXXXNode().
// 1. Every Node should be part of a graph. No dangling Node exists.
// 2. Node only contains members necessary for building graph structure.
//    It doesn't contain other unrelated members, such as device, etc.
//
// Sometimes, for specific usages, Node needs to have additional members,
// such as device_placement, version in order to be executed. It is suggested
// to use composition pattern.
//
// class RunnableOp {
//    RunnableOp(ir::Node* n) : n_(n) { n_.WrappedBy(this); }
//
//    int any_thing_;
// }
//
// RunnableOp is owned by the ir::Node that composes it. In other words.
// ir::Node will be responsible for deleting RunnableOp, say, when ir::Node
// is deleted from the graph.
X
Xin Pan 已提交
48 49
class Node {
 public:
X
Xin Pan 已提交
50 51
  virtual ~Node() {
    if (!wrapper_.empty()) {
52
      VLOG(10) << "ir::Node deleting a wrapper node " << Name();
X
Xin Pan 已提交
53 54 55
      wrapper_deleter_();
    }
  }
X
clean1  
Xin Pan 已提交
56

X
polish  
Xin Pan 已提交
57
  enum class Type { kOperation, kVariable };
D
dzhwinter 已提交
58
#if !defined(_WIN32)  // msvc not support constexpr correctly.
P
peizhilin 已提交
59
  static constexpr char kControlDepVarName[] = "__control_var";
D
dzhwinter 已提交
60
#else
P
peizhilin 已提交
61
  static const char kControlDepVarName[];
D
dzhwinter 已提交
62
#endif
X
better  
Xin Pan 已提交
63

X
Xin Pan 已提交
64 65
  Type NodeType() const { return type_; }

X
Xin Pan 已提交
66
  std::string Name() const { return name_; }
X
tmp  
Xin Pan 已提交
67

Y
Yan Chunwei 已提交
68
  VarDesc* Var() const {
X
fix  
Xin Pan 已提交
69
    PADDLE_ENFORCE(IsVar());
70
    return var_desc_.get();
X
Xin Pan 已提交
71
  }
X
Xin Pan 已提交
72

73
  OpDesc* Op() const {
74 75
    PADDLE_ENFORCE(IsOp());
    return op_desc_.get();
X
tmp  
Xin Pan 已提交
76
  }
77

X
Xin Pan 已提交
78
  // Set the `wrapper` that wraps the Node. `wrapper` is owned by Node.
X
clean1  
Xin Pan 已提交
79 80 81 82 83 84 85
  template <typename T>
  void WrappedBy(T* wrapper) {
    if (!wrapper_.empty()) {
      wrapper_deleter_();
    }
    wrapper_ = wrapper;
    wrapper_deleter_ = [wrapper]() { delete wrapper; };
X
Xin Pan 已提交
86
    wrapper_type_ = std::type_index(typeid(T));
X
clean1  
Xin Pan 已提交
87 88
  }

X
Xin Pan 已提交
89
  // Return a reference to the `wrapper`.
X
clean1  
Xin Pan 已提交
90 91
  template <typename T>
  T& Wrapper() {
92 93 94 95 96 97
    try {
      return *boost::any_cast<T*>(wrapper_);
    } catch (boost::bad_any_cast&) {
      PADDLE_THROW("Invalid wrapper type error, expected %s, actual %s",
                   typeid(T).name(), wrapper_type_.name());
    }
X
clean1  
Xin Pan 已提交
98 99
  }

X
Xin Pan 已提交
100
  // Test if the Node is wrapped by type T.
X
Xin Pan 已提交
101
  template <typename T>
102
  bool IsWrappedBy() const {
X
Xin Pan 已提交
103 104 105
    return std::type_index(typeid(T)) == wrapper_type_;
  }

X
Xin Pan 已提交
106
  // Please don't use this API!
107 108
  int id() const { return id_; }

109 110
  bool IsOp() const { return type_ == Type::kOperation; }
  bool IsVar() const { return type_ == Type::kVariable; }
C
chengduo 已提交
111 112 113 114
  bool IsCtrlVar() const {
    return type_ == Type::kVariable &&
           Name().find(ir::Node::kControlDepVarName) != std::string::npos;
  }
115

116 117 118 119 120 121 122
  void RenameVar(const std::string& new_name) {
    PADDLE_ENFORCE(type_ == Type::kVariable && var_desc_,
                   "Must be type of variable");
    name_ = new_name;
    var_desc_->SetName(new_name);
  }

123 124
  std::vector<Node*> inputs;
  std::vector<Node*> outputs;
X
Xin Pan 已提交
125 126

 protected:
127
  std::string name_;
128 129
  std::unique_ptr<VarDesc> var_desc_;
  std::unique_ptr<OpDesc> op_desc_;
X
Xin Pan 已提交
130
  Type type_;
131
  int id_;
X
Xin Pan 已提交
132

X
tmp  
Xin Pan 已提交
133
 private:
134 135 136
  // ID can only set by a Graph.
  void SetId(int id) { id_ = id; }

137
  friend class Graph;
X
Xin Pan 已提交
138 139
  friend std::unique_ptr<Node> CreateNodeForTest(const std::string& name,
                                                 Node::Type type);
D
dzhwinter 已提交
140 141
  friend std::unique_ptr<Node> CreateNodeForTest(VarDesc* var_desc);
  friend std::unique_ptr<Node> CreateNodeForTest(OpDesc* op_desc);
X
Xin Pan 已提交
142 143

  explicit Node(const std::string& name, Type type)
144
      : name_(name), var_desc_(nullptr), op_desc_(nullptr), type_(type) {}
X
Xin Pan 已提交
145 146 147 148 149

  explicit Node(VarDesc* var_desc)
      : name_(var_desc->Name()),
        var_desc_(new VarDesc(*var_desc)),
        op_desc_(nullptr),
150
        type_(Type::kVariable) {}
X
Xin Pan 已提交
151 152 153 154 155

  explicit Node(OpDesc* op_desc)
      : name_(op_desc->Type()),
        var_desc_(nullptr),
        op_desc_(new OpDesc(*op_desc, op_desc->Block())),
156
        type_(Type::kOperation) {}
X
Xin Pan 已提交
157 158 159

  Node() = delete;

X
clean1  
Xin Pan 已提交
160 161
  boost::any wrapper_;
  std::function<void(void)> wrapper_deleter_;
X
Xin Pan 已提交
162
  std::type_index wrapper_type_ = std::type_index(typeid(void));
X
clean1  
Xin Pan 已提交
163

X
Xin Pan 已提交
164 165 166
  DISABLE_COPY_AND_ASSIGN(Node);
};

X
Xin Pan 已提交
167 168
std::unique_ptr<Node> CreateNodeForTest(const std::string& name,
                                        Node::Type type);
D
dzhwinter 已提交
169
std::unique_ptr<Node> CreateNodeForTest(VarDesc* var_desc);
X
Xin Pan 已提交
170

D
dzhwinter 已提交
171
std::unique_ptr<Node> CreateNodeForTest(OpDesc* op_desc);
X
tmp  
Xin Pan 已提交
172
}  // namespace ir
X
Xin Pan 已提交
173
}  // namespace framework
X
start  
Xin Pan 已提交
174
}  // namespace paddle