node.h 4.4 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

X
Xin Pan 已提交
17
#include <string>
X
Xin Pan 已提交
18 19
#include <typeindex>
#include <typeinfo>
X
Xin Pan 已提交
20
#include <vector>
X
Xin Pan 已提交
21

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()) {
X
Xin Pan 已提交
52
      VLOG(4) << "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.
59
        static constexpr char kControlDepVarName[] = "__control_var";
D
dzhwinter 已提交
60
#else
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

X
Xin Pan 已提交
68
  VarDesc* Var() {
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 92 93 94
  template <typename T>
  T& Wrapper() {
    return *boost::any_cast<T*>(wrapper_);
  }

X
Xin Pan 已提交
95
  // Test if the Node is wrapped by type T.
X
Xin Pan 已提交
96 97 98 99 100
  template <typename T>
  bool IsWrappedBy() {
    return std::type_index(typeid(T)) == wrapper_type_;
  }

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

104 105
  bool IsOp() const { return type_ == Type::kOperation; }
  bool IsVar() const { return type_ == Type::kVariable; }
C
chengduo 已提交
106 107 108 109
  bool IsCtrlVar() const {
    return type_ == Type::kVariable &&
           Name().find(ir::Node::kControlDepVarName) != std::string::npos;
  }
110

111 112
  std::vector<Node*> inputs;
  std::vector<Node*> outputs;
X
Xin Pan 已提交
113 114

 protected:
X
Xin Pan 已提交
115
  const std::string name_;
116 117
  std::unique_ptr<VarDesc> var_desc_;
  std::unique_ptr<OpDesc> op_desc_;
X
Xin Pan 已提交
118
  Type type_;
119
  int id_;
X
Xin Pan 已提交
120

X
tmp  
Xin Pan 已提交
121
 private:
122 123 124
  // ID can only set by a Graph.
  void SetId(int id) { id_ = id; }

125
  friend class Graph;
X
Xin Pan 已提交
126 127 128 129
  friend std::unique_ptr<Node> CreateNodeForTest(const std::string& name,
                                                 Node::Type type);

  explicit Node(const std::string& name, Type type)
130
      : name_(name), var_desc_(nullptr), op_desc_(nullptr), type_(type) {}
X
Xin Pan 已提交
131 132 133 134 135

  explicit Node(VarDesc* var_desc)
      : name_(var_desc->Name()),
        var_desc_(new VarDesc(*var_desc)),
        op_desc_(nullptr),
136
        type_(Type::kVariable) {}
X
Xin Pan 已提交
137 138 139 140 141

  explicit Node(OpDesc* op_desc)
      : name_(op_desc->Type()),
        var_desc_(nullptr),
        op_desc_(new OpDesc(*op_desc, op_desc->Block())),
142
        type_(Type::kOperation) {}
X
Xin Pan 已提交
143 144 145

  Node() = delete;

X
clean1  
Xin Pan 已提交
146 147
  boost::any wrapper_;
  std::function<void(void)> wrapper_deleter_;
X
Xin Pan 已提交
148
  std::type_index wrapper_type_ = std::type_index(typeid(void));
X
clean1  
Xin Pan 已提交
149

X
Xin Pan 已提交
150 151 152
  DISABLE_COPY_AND_ASSIGN(Node);
};

X
Xin Pan 已提交
153 154 155
std::unique_ptr<Node> CreateNodeForTest(const std::string& name,
                                        Node::Type type);

X
tmp  
Xin Pan 已提交
156
}  // namespace ir
X
Xin Pan 已提交
157
}  // namespace framework
X
start  
Xin Pan 已提交
158
}  // namespace paddle