“0fc42012a0073a0614e2c0b2634ab9ef7e337916”上不存在“paddle/legacy/optimizer/serialization.h”
graph.cc 7.8 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

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

X
Xin Pan 已提交
15 16 17
#include <algorithm>
#include <unordered_set>

X
start  
Xin Pan 已提交
18
#include "paddle/fluid/framework/ir/graph.h"
X
Xin Pan 已提交
19
#include "paddle/fluid/framework/op_proto_maker.h"
20 21
#include "paddle/fluid/framework/program_desc.h"
#include "paddle/fluid/framework/var_desc.h"
X
start  
Xin Pan 已提交
22 23

namespace paddle {
X
Xin Pan 已提交
24
namespace framework {
X
Xin Pan 已提交
25
namespace ir {
X
Xin Pan 已提交
26
namespace {
X
Xin Pan 已提交
27

X
Xin Pan 已提交
28 29 30 31 32 33
void CheckProgram(const ProgramDesc &program) {
  std::map<int, bool> visit;
#define _INT(role) static_cast<int>(role)

  for (size_t i = 0; i < program.Size(); ++i) {
    for (OpDesc *op : program.Block(i).AllOps()) {
X
Xin Pan 已提交
34 35
      // For backward compatibility, some program doesn't have role added.
      if (!op->HasAttr(OpProtoAndCheckerMaker::OpRoleAttrName())) continue;
X
Xin Pan 已提交
36 37 38 39 40 41 42
      int role_id = boost::get<int>(
          op->GetAttr(OpProtoAndCheckerMaker::OpRoleAttrName()));
      visit[role_id] = true;
      switch (role_id) {
        case _INT(OpRole::kForward):
          PADDLE_ENFORCE(
              visit.find(_INT(OpRole::kBackward)) == visit.end(),
X
Xin Pan 已提交
43 44
              "Cannot add backward operator before forward operator %s.",
              op->Type());
X
Xin Pan 已提交
45 46 47 48 49
          break;
        case _INT(OpRole::kBackward):
        case _INT(OpRole::kBackward) | _INT(OpRole::kLoss):
          PADDLE_ENFORCE(
              visit.find(_INT(OpRole::kOptimize)) == visit.end(),
X
Xin Pan 已提交
50 51
              "Cannot add backward operator %s before optimize operator.",
              op->Type());
X
Xin Pan 已提交
52 53 54 55 56
          break;
        case _INT(OpRole::kForward) | _INT(OpRole::kLoss):
          PADDLE_ENFORCE(visit.find(_INT(OpRole::kBackward) |
                                    _INT(OpRole::kLoss)) == visit.end(),
                         "Cannot add backward|loss operator before "
X
Xin Pan 已提交
57 58
                         "forward|loss operator %s.",
                         op->Type());
X
Xin Pan 已提交
59 60
          PADDLE_ENFORCE(
              visit.find(_INT(OpRole::kOptimize)) == visit.end(),
X
Xin Pan 已提交
61 62
              "Cannot add forward|loss operator %s after optimize operator.",
              op->Type());
X
Xin Pan 已提交
63 64 65 66
          break;
        case _INT(OpRole::kOptimize):
        case _INT(OpRole::kOptimize) | _INT(OpRole::kLRSched):
          PADDLE_ENFORCE(visit.find(_INT(OpRole::kBackward)) != visit.end(),
X
Xin Pan 已提交
67 68
                         "Optimize operators %s must follow backward operator.",
                         op->Type());
X
Xin Pan 已提交
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
          break;
        case _INT(OpRole::kLRSched):
        case _INT(OpRole::kDist):
        case _INT(OpRole::kRPC):
        case _INT(OpRole::kNotSpecified):
          break;
        default:
          LOG(FATAL) << "Unknown operator role. Don't add new role because "
                        "you don't know what you are doing.";
      }
    }
  }
#undef _INT
}
}  // namespace
X
Xin Pan 已提交
84

X
clean  
Xin Pan 已提交
85
Graph::Graph(const ProgramDesc &program) : program_(program) {
X
Xin Pan 已提交
86
  CheckProgram(program_);
87 88
  // Make the nodes id start from 0.
  Node::ResetId();
89 90 91
  auto var_nodes = InitFromProgram(program_);
  ResolveHazard(var_nodes);
}
92

93 94
std::map<std::string, std::vector<ir::Node *>> Graph::InitFromProgram(
    const ProgramDesc &program) {
Q
qiaolongfei 已提交
95
  VLOG(3) << "block in program:" << program_.Size();
96
  std::unordered_map<std::string, VarDesc *> all_vars;
97 98
  // var nodes for each var name, will have multiple versions in SSA
  std::map<std::string, std::vector<ir::Node *>> var_nodes;
99 100 101 102 103
  for (auto *var : program.Block(0).AllVars()) {
    all_vars.emplace(var->Name(), var);
  }

  for (auto *op : program.Block(0).AllOps()) {
X
clean  
Xin Pan 已提交
104
    ir::Node *node = CreateOpNode(op);
X
Xin Pan 已提交
105 106
    // For input args, reuse the same var name if it was created before.
    // Otherwise, create a new one.
107 108
    for (auto &each_var_name : op->InputArgumentNames()) {
      ir::Node *var = nullptr;
X
Xin Pan 已提交
109
      if (var_nodes.find(each_var_name) != var_nodes.end()) {
X
Xin Pan 已提交
110
        var = var_nodes.at(each_var_name).back();
X
Xin Pan 已提交
111
      } else if (all_vars.count(each_var_name) != 0) {
X
clean  
Xin Pan 已提交
112
        var = CreateVarNode(all_vars.at(each_var_name));
X
Xin Pan 已提交
113
        var_nodes[each_var_name].push_back(var);
114
      } else {
X
Xin Pan 已提交
115 116 117
        // Operation input var can be optional (dispensable). Which means
        // the operation doesn't really need the var at runtime. In this
        // case, the no-existed var is ready at the beginning.
X
polish  
Xin Pan 已提交
118
        var = CreateEmptyNode(each_var_name, ir::Node::Type::kVariable);
X
Xin Pan 已提交
119
        var_nodes[each_var_name].push_back(var);
120 121 122 123
      }
      node->inputs.push_back(var);
      var->outputs.push_back(node);
    }
X
Xin Pan 已提交
124
    // For output args, always create a new var.
125
    for (auto &each_var_name : op->OutputArgumentNames()) {
X
Xin Pan 已提交
126 127 128 129 130 131 132 133 134
      ir::Node *var = nullptr;
      if (all_vars.count(each_var_name) != 0) {
        var = CreateVarNode(all_vars.at(each_var_name));
      } else {
        // Operation output vars can be @EMPTY@. For example, while_grad
        // can have multi @EMPTY@ outputs with no VarDesc.
        // TODO(panyx0718): Add a test.
        var = CreateEmptyNode(each_var_name, ir::Node::Type::kVariable);
      }
X
Xin Pan 已提交
135
      var_nodes[each_var_name].push_back(var);
136 137 138 139
      node->outputs.push_back(var);
      var->inputs.push_back(node);
    }
  }
140 141
  return std::move(var_nodes);
}
X
Xin Pan 已提交
142

143 144
void Graph::ResolveHazard(
    const std::map<std::string, std::vector<ir::Node *>> &var_nodes) {
X
polish  
Xin Pan 已提交
145
  /**
146 147 148 149 150
   * We should handle write after read(WAR) and write after write(WAW) here.
   * Because some of the operators of the program can be executed parallelly.
   * So, to make the program running in the right order, we should add the
   * dependence of WAR and WAW.
   *
X
polish  
Xin Pan 已提交
151 152 153
   *
   * https://en.wikipedia.org/wiki/Hazard_(computer_architecture)#Write_after_read_(WAR)
   */
X
Xin Pan 已提交
154

X
Xin Pan 已提交
155 156 157 158 159 160 161 162
  for (auto &var : var_nodes) {
    auto &versions = var.second;
    if (versions.size() <= 1) continue;

    auto it_new = versions.rbegin();
    auto it_old = versions.rbegin();
    ++it_old;
    for (; it_old != versions.rend(); it_new = it_old, ++it_old) {
163
      VLOG(3) << "deal with var: " << (*it_new)->Name();
X
Xin Pan 已提交
164 165 166 167
      ir::Node *write_op =
          (*it_new)->inputs.empty() ? nullptr : (*it_new)->inputs[0];
      const auto &read_ops = (*it_old)->outputs;

168 169 170 171 172
      PADDLE_ENFORCE(write_op, "The write_op should not be empty.");

      // Add write after write dependence
      ir::Node *upstream_op =
          (*it_old)->inputs.empty() ? nullptr : (*it_old)->inputs[0];
X
Xin Pan 已提交
173 174
      // TODO(zcd): Add a test.
      if (upstream_op && upstream_op != write_op) {
175 176 177 178 179 180 181
        ir::Node *dep_var = CreateControlDepVar();
        write_op->inputs.push_back(dep_var);
        upstream_op->outputs.push_back(dep_var);
        dep_var->outputs.push_back(write_op);
        dep_var->inputs.push_back(upstream_op);
      }

X
Xin Pan 已提交
182 183 184 185 186 187
      for (auto *read_op : read_ops) {
        // Manually add a dependency var from read_op to write_op;
        if (read_op == write_op) {
          // Read Write is the same op.
          continue;
        }
X
Xin Pan 已提交
188 189 190 191 192 193 194 195 196 197 198
        // 2 ops might have been connected via other vars.
        bool has_dep = false;
        for (ir::Node *r_out : read_op->outputs) {
          for (ir::Node *w_in : write_op->inputs) {
            if (r_out == w_in) {
              has_dep = true;
              break;
            }
          }
        }
        if (has_dep) continue;
X
Xin Pan 已提交
199

X
Xin Pan 已提交
200
        ir::Node *dep_var = CreateControlDepVar();
X
Xin Pan 已提交
201 202 203 204 205 206 207
        read_op->outputs.push_back(dep_var);
        dep_var->inputs.push_back(read_op);
        write_op->inputs.push_back(dep_var);
        dep_var->outputs.push_back(write_op);
      }
    }
  }
X
better  
Xin Pan 已提交
208
}
X
Xin Pan 已提交
209 210 211 212

bool IsControlDepVar(const ir::Node &var) {
  return var.Name().find(ir::Node::kControlDepVarName) != std::string::npos;
}
X
Xin Pan 已提交
213
}  // namespace ir
X
Xin Pan 已提交
214
}  // namespace framework
X
start  
Xin Pan 已提交
215
}  // namespace paddle