scope.cc 6.9 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
Y
Yi Wang 已提交
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. */

Y
Yi Wang 已提交
15
#include "paddle/fluid/framework/scope.h"
Y
Yang Yang 已提交
16

Q
qijun 已提交
17
#include <memory>  // for unique_ptr
18
#include <queue>
19
#include <set>
20
#include <unordered_set>
21
#include "glog/logging.h"
Y
Yi Wang 已提交
22
#include "paddle/fluid/framework/threadpool.h"
23
#include "paddle/fluid/string/printf.h"
Y
Yi Wang 已提交
24

D
dzhwinter 已提交
25
DECLARE_bool(benchmark);
26

Y
Yu Yang 已提交
27 28 29 30 31
DEFINE_bool(
    eager_delete_scope, true,
    "Delete local scope eagerly. It will reduce GPU memory usage but "
    "slow down the destruction of variables.(around 1% performance harm)");

32 33 34 35
// When in inference scenario, the scopes will not be written by two threads in
// a mean time, but a scope may be read by multiple threads concurrently, and
// the mutex will cause serious performance issue.
// So the mutex is disabled when `ON_INFER`.
36
#ifdef PADDLE_ON_INFERENCE
M
minqiyang 已提交
37 38 39 40
#define SCOPE_KIDS_READER_LOCK
#define SCOPE_KIDS_WRITER_LOCK
#define SCOPE_VARS_READER_LOCK
#define SCOPE_VARS_WRITER_LOCK
41
#else
M
minqiyang 已提交
42 43 44 45
#define SCOPE_KIDS_READER_LOCK AutoRDLock auto_lock(&kids_lock_);
#define SCOPE_KIDS_WRITER_LOCK AutoWRLock auto_lock(&kids_lock_);
#define SCOPE_VARS_READER_LOCK AutoRDLock auto_lock(&vars_lock_);
#define SCOPE_VARS_WRITER_LOCK AutoWRLock auto_lock(&vars_lock_);
46 47
#endif

Y
Yi Wang 已提交
48 49 50
namespace paddle {
namespace framework {

51
Scope::~Scope() { DropKids(); }
Y
Yi Wang 已提交
52

Y
Yu Yang 已提交
53
Scope& Scope::NewScope() const {
M
minqiyang 已提交
54 55 56 57 58 59
  Scope* child = new Scope(this);
  {
    SCOPE_KIDS_WRITER_LOCK
    kids_.push_back(child);
  }
  return *child;
Y
Yi Wang 已提交
60 61
}

62 63 64
std::unique_ptr<Scope> Scope::NewTmpScope() const {
  return std::unique_ptr<Scope>(new Scope(this));
}
Q
Qiao Longfei 已提交
65

D
dongzhihong 已提交
66
Variable* Scope::Var(const std::string& name) {
M
minqiyang 已提交
67
  SCOPE_VARS_WRITER_LOCK
T
tensor-tang 已提交
68
  return VarInternal(name);
Y
Yi Wang 已提交
69 70
}

Y
Yu Yang 已提交
71
Variable* Scope::Var(std::string* name) {
S
sneaxiy 已提交
72 73 74
  SCOPE_VARS_WRITER_LOCK
  auto new_name = std::to_string(reinterpret_cast<uintptr_t>(this)) + "." +
                  std::to_string(vars_.size());
Y
Yu Yang 已提交
75
  if (name != nullptr) {
T
tensor-tang 已提交
76
    *name = new_name;
Y
Yu Yang 已提交
77
  }
T
tensor-tang 已提交
78
  return VarInternal(new_name);
Y
Yi Wang 已提交
79 80 81
}

Variable* Scope::FindVar(const std::string& name) const {
M
minqiyang 已提交
82
  SCOPE_VARS_READER_LOCK
T
tensor-tang 已提交
83 84 85
  return FindVarInternal(name);
}

S
sneaxiy 已提交
86
Variable* Scope::FindLocalVar(const std::string& name) const {
M
minqiyang 已提交
87
  SCOPE_VARS_READER_LOCK
S
sneaxiy 已提交
88 89 90
  return FindVarLocally(name);
}

Y
Yu Yang 已提交
91
const Scope* Scope::FindScope(const Variable* var) const {
M
minqiyang 已提交
92
  SCOPE_VARS_READER_LOCK
T
tensor-tang 已提交
93
  return FindScopeInternal(var);
Y
Yi Wang 已提交
94
}
T
tensor-tang 已提交
95

Y
Yu Yang 已提交
96
void Scope::DropKids() {
M
minqiyang 已提交
97
  SCOPE_KIDS_WRITER_LOCK
Y
Yu Yang 已提交
98 99 100
  for (Scope* s : kids_) delete s;
  kids_.clear();
}
Y
Yi Wang 已提交
101

M
minqiyang 已提交
102
bool Scope::HasKid(const Scope* scope) const {
M
minqiyang 已提交
103
  SCOPE_KIDS_READER_LOCK
M
minqiyang 已提交
104 105 106 107
  auto it = std::find(this->kids_.begin(), this->kids_.end(), scope);
  return it != this->kids_.end();
}

Y
Yang Yu 已提交
108 109
std::vector<std::string> Scope::LocalVarNames() const {
  std::vector<std::string> known_vars;
M
minqiyang 已提交
110 111 112 113 114 115
  {
    SCOPE_VARS_READER_LOCK
    known_vars.reserve(this->vars_.size());
    for (auto& p : vars_) {
      known_vars.emplace_back(p.first);
    }
116 117 118 119
  }
  return known_vars;
}

120
void Scope::DeleteScope(Scope* scope) const {
M
minqiyang 已提交
121
  SCOPE_KIDS_WRITER_LOCK
Y
Yu Yang 已提交
122
  auto it = std::find(this->kids_.begin(), this->kids_.end(), scope);
123 124
  PADDLE_ENFORCE(it != this->kids_.end(), "%p Cannot find %p as kid scope",
                 this, scope);
Y
Yu Yang 已提交
125
  this->kids_.erase(it);
126
  // When making memory benchmark on Fluid, we have to delete scope sync.
Y
Yu Yang 已提交
127
  if (FLAGS_benchmark || FLAGS_eager_delete_scope) {
128 129 130 131
    delete scope;
  } else {
    Async([scope] { delete scope; });
  }
Y
Yu Yang 已提交
132 133
}

Y
Yancey1989 已提交
134
void Scope::EraseVars(const std::vector<std::string>& var_names) {
135
  std::set<std::string> var_set(var_names.begin(), var_names.end());
M
minqiyang 已提交
136
  SCOPE_VARS_WRITER_LOCK
137 138 139 140 141 142 143 144 145
  for (auto it = vars_.begin(); it != vars_.end();) {
    if (var_set.find(it->first) != var_set.end()) {
      it = vars_.erase(it);
    } else {
      ++it;
    }
  }
}

Y
Yu Yang 已提交
146 147
void Scope::Rename(const std::string& origin_name,
                   const std::string& new_name) const {
M
minqiyang 已提交
148
  SCOPE_VARS_WRITER_LOCK
T
tensor-tang 已提交
149 150 151 152
  RenameInternal(origin_name, new_name);
}

std::string Scope::Rename(const std::string& origin_name) const {
M
minqiyang 已提交
153
  SCOPE_VARS_WRITER_LOCK
T
tensor-tang 已提交
154 155 156 157 158 159 160 161 162
  auto new_name = string::Sprintf("%p.%d", this, vars_.size());
  RenameInternal(origin_name, new_name);
  return new_name;
}

Variable* Scope::VarInternal(const std::string& name) {
  auto* v = FindVarLocally(name);
  if (v != nullptr) return v;
  v = new Variable();
S
sneaxiy 已提交
163
  vars_.emplace(name, std::unique_ptr<Variable>(v));
M
minqiyang 已提交
164
  VLOG(3) << "Create variable " << name;
T
tensor-tang 已提交
165 166 167 168 169 170 171 172 173 174 175 176 177 178
  return v;
}

const Scope* Scope::FindScopeInternal(const Variable* var) const {
  for (auto& kv : vars_) {
    if (kv.second.get() == var) {
      return this;
    }
  }
  return (parent_ == nullptr) ? nullptr : parent_->FindScope(var);
}

void Scope::RenameInternal(const std::string& origin_name,
                           const std::string& new_name) const {
Y
Yu Yang 已提交
179 180 181 182 183 184
  auto origin_it = vars_.find(origin_name);
  PADDLE_ENFORCE(origin_it != vars_.end(),
                 "Cannot find original variable with name %s", origin_name);
  auto new_it = vars_.find(new_name);
  PADDLE_ENFORCE(new_it == vars_.end(),
                 "The variable with name %s is already in the scope", new_name);
185
  vars_[new_name].reset(origin_it->second.release());
Y
Yu Yang 已提交
186 187 188
  vars_.erase(origin_it);
}

T
tensor-tang 已提交
189 190 191 192 193 194
Variable* Scope::FindVarInternal(const std::string& name) const {
  auto var = FindVarLocally(name);
  if (var != nullptr) {
    return var;
  }
  return (parent_ == nullptr) ? nullptr : parent_->FindVar(name);
Y
Yu Yang 已提交
195
}
196

197 198
Variable* Scope::FindVarLocally(const std::string& name) const {
  auto it = vars_.find(name);
199
  if (it != vars_.end()) return it->second.get();
200 201
  return nullptr;
}
Y
Yu Yang 已提交
202

203 204 205 206 207 208 209 210 211 212 213
void Scope::EraseVarsExcept(const std::unordered_set<Variable*>& vars) {
  SCOPE_VARS_WRITER_LOCK
  for (auto iter = vars_.begin(); iter != vars_.end();) {
    if (vars.count(iter->second.get()) != 0) {
      ++iter;
    } else {
      vars_.erase(iter++);
    }
  }
}

214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
std::string GenScopeTreeDebugInfo(Scope* root) {
  std::stringstream os;

  if (!root) return "";

  // level traversal
  std::queue<Scope*> queue;
  queue.push(root);

  std::vector<Scope*> scopes;

  while (!queue.empty()) {
    auto* end = queue.back();
    Scope* q = nullptr;
    while (q != end) {
      q = queue.front();
      queue.pop();
      os << q << " ";
      scopes.push_back(q);

      for (auto* c : q->kids()) {
        queue.push(c);
      }
    }
    // end of a level
    os << "\n------------------------------------------\n";
  }

  os << "\nDetails:\n\n";

  for (Scope* q : scopes) {
    os << "====\n";
    os << q << ":\n";
    for (auto& var : q->LocalVarNames()) {
      os << "  - " << var << "\n";
    }
  }

  return os.str();
}

Y
Yi Wang 已提交
255 256
}  // namespace framework
}  // namespace paddle