graph.h 5.3 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 18 19 20 21 22
#include <map>
#include <memory>
#include <string>
#include <vector>

#include "paddle/fluid/framework/ir/node.h"
X
Xin Pan 已提交
23
#include "paddle/fluid/framework/program_desc.h"
X
Xin Pan 已提交
24
#include "paddle/fluid/platform/enforce.h"
X
Xin Pan 已提交
25 26
#include "paddle/fluid/platform/variant.h"

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

X
Xin Pan 已提交
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
/*
 * The graph is a Directed Acyclic Single Static Assignment Graph.
 *
 * In more detail, the following properties must hold:
 *
 *   The graph shouldn't contain cycle. Each node is a black-box to the graph
 *   so the node itself could be a loop operator.
 *
 *   Each Variable-type node has only one input (thus single static assignment).
 *
 *   The output/input of operator is variable and the output/input of variable
 *   is operator.
 *
 * The following data harzards in Program are addressed in the Graph:
 *
 *   Write-After-Read
 *     a = op1(x)
 *     x = op2(b)
 *     A control-dependency connection is created bettwen op1 and op2 such that
 *     op1->op2, so as to ensure correct order.
 *
 *   Write-After-Write
 *     x = op1(a)
 *     x = op2(b)
 *     A control-dependency connection is created between op1 and op2 such that
 *     op1->op2, so as to ensure correct order.
 *
 * Other properties currently hold, but is not enforced yet:
 *
 *   Variable-type node (not control dep) with the same variable name share
 *   the same underlying VarDesc.
 */
X
Xin Pan 已提交
63 64
class Graph {
 public:
X
Xin Pan 已提交
65
  explicit Graph(const ProgramDesc &program);
X
Xin Pan 已提交
66

X
Xin Pan 已提交
67
  virtual ~Graph() {
X
Xin Pan 已提交
68
    for (auto &attr : attrs_) {
X
Xin Pan 已提交
69
      attr_dels_[attr.first]();
X
Xin Pan 已提交
70
    }
X
Xin Pan 已提交
71 72
    attrs_.clear();
    attr_dels_.clear();
X
Xin Pan 已提交
73 74
  }

X
Xin Pan 已提交
75 76 77 78
  bool Has(const std::string &attr_name) const {
    return attrs_.find(attr_name) != attrs_.end();
  }

X
Xin Pan 已提交
79
  template <typename AttrType>
X
Xin Pan 已提交
80
  AttrType &Get(const std::string &attr_name) const {
X
Xin Pan 已提交
81 82
    PADDLE_ENFORCE(Has(attr_name), "%s attr not registered for graph.",
                   attr_name);
X
Xin Pan 已提交
83
    return *boost::any_cast<AttrType *>(attrs_.at(attr_name));
X
Xin Pan 已提交
84 85 86
  }

  template <typename AttrType>
X
Xin Pan 已提交
87
  void Set(const std::string &attr_name, AttrType *attr) {
X
Xin Pan 已提交
88 89
    PADDLE_ENFORCE(attrs_.count(attr_name) == 0, "%s already set in the graph",
                   attr_name);
X
Xin Pan 已提交
90 91 92 93 94
    attrs_[attr_name] = attr;
    attr_dels_[attr_name] = [attr, attr_name]() {
      VLOG(3) << "deleting " << attr_name;
      delete attr;
    };
X
Xin Pan 已提交
95
  }
X
Xin Pan 已提交
96

X
Xin Pan 已提交
97 98
  const std::unordered_set<ir::Node *> &Nodes() const { return node_set_; }

X
Xin Pan 已提交
99
  // Create a normal variable with non-null VarDesc.
X
Xin Pan 已提交
100
  ir::Node *CreateVarNode(VarDesc *var_desc) {
101
    PADDLE_ENFORCE(var_desc);
102
    return AddNode(new ir::Node(var_desc));
103 104
  }

X
Xin Pan 已提交
105
  // Create a normal runnable operator with OpDesc.
X
Xin Pan 已提交
106
  ir::Node *CreateOpNode(OpDesc *op_desc) {
107
    PADDLE_ENFORCE(op_desc);
108
    return AddNode(new ir::Node(op_desc));
X
Xin Pan 已提交
109 110
  }

X
Xin Pan 已提交
111 112 113
  // Create a control dependency var that connects 2 operations. The
  // var doesn't hold any data. Other than that, it's no different from
  // other var, considering dependency analysis.
X
Xin Pan 已提交
114
  ir::Node *CreateControlDepVar() {
X
Xin Pan 已提交
115
    // TODO(panyx0718): control var name should be really unique.
X
Xin Pan 已提交
116 117
    const std::string name = string::Sprintf(
        "%s@%llu", ir::Node::kControlDepVarName, node_set_.size());
118
    return AddNode(new ir::Node(name, ir::Node::Type::kVariable));
119 120
  }

X
Xin Pan 已提交
121 122
  // A more free style way of creating a graph node. Mostly use for test
  // or "copy" from another node. Avoid using it if possible.
X
Xin Pan 已提交
123
  ir::Node *CreateEmptyNode(const std::string &name, ir::Node::Type type) {
124
    return AddNode(new ir::Node(name, type));
125 126
  }

X
Xin Pan 已提交
127 128
  // Clear all node information of the graph and return the ownership of the
  // nodes.
X
Xin Pan 已提交
129 130 131 132 133 134 135 136 137
  std::vector<std::unique_ptr<ir::Node>> ReleaseNodes() {
    std::vector<std::unique_ptr<ir::Node>> ret;
    for (auto &n : nodes_) {
      ret.emplace_back(n.second.release());
    }
    nodes_.clear();
    node_set_.clear();
    return ret;
  }
X
Xin Pan 已提交
138

139 140 141 142 143 144
  void RemoveNode(ir::Node *node) {
    PADDLE_ENFORCE(node_set_.find(node) != node_set_.end());
    node_set_.erase(node);
    nodes_.erase(node);
  }

145
  // NOTE low performance, but simple and secure.
146
  Node *RetriveNode(int id) {
147 148 149 150 151
    for (auto &node : nodes_) {
      if (node.second->id() == id) {
        return node.second.get();
      }
    }
152 153 154
    return nullptr;
  }

X
Xin Pan 已提交
155
 private:
X
Xin Pan 已提交
156 157 158 159 160 161 162 163
  // This method takes ownership of `node`.
  ir::Node *AddNode(ir::Node *node) {
    PADDLE_ENFORCE(node_set_.find(node) == node_set_.end());
    nodes_[node].reset(node);
    node_set_.insert(node);
    return node;
  }

164
  // NOTE: program_ shouldn't be exposed to user.
X
Xin Pan 已提交
165
  const ProgramDesc program_;
X
Xin Pan 已提交
166 167
  std::map<std::string, boost::any> attrs_;
  std::map<std::string, std::function<void(void)>> attr_dels_;
X
Xin Pan 已提交
168 169
  std::map<ir::Node *, std::unique_ptr<ir::Node>> nodes_;
  std::unordered_set<ir::Node *> node_set_;
170
  int node_count_{0};
X
Xin Pan 已提交
171
};
X
Xin Pan 已提交
172 173

bool IsControlDepVar(const ir::Node &var);
X
Xin Pan 已提交
174
}  // namespace ir
X
Xin Pan 已提交
175
}  // namespace framework
X
start  
Xin Pan 已提交
176
}  // namespace paddle