scope.cc 7.4 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

17
#include "glog/logging.h"
Y
Yi Wang 已提交
18
#include "paddle/fluid/framework/threadpool.h"
Y
Yi Wang 已提交
19

D
dzhwinter 已提交
20
DECLARE_bool(benchmark);
21

Y
Yu Yang 已提交
22 23 24 25 26
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)");

27 28 29 30
// 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`.
31
#ifdef PADDLE_ON_INFERENCE
M
minqiyang 已提交
32 33 34 35
#define SCOPE_KIDS_READER_LOCK
#define SCOPE_KIDS_WRITER_LOCK
#define SCOPE_VARS_READER_LOCK
#define SCOPE_VARS_WRITER_LOCK
36
#else
M
minqiyang 已提交
37 38 39 40
#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_);
41 42
#endif

Y
Yi Wang 已提交
43 44 45
namespace paddle {
namespace framework {

46
Scope::~Scope() { DropKids(); }
Y
Yi Wang 已提交
47

Y
Yu Yang 已提交
48
Scope& Scope::NewScope() const {
M
minqiyang 已提交
49 50 51 52 53 54
  Scope* child = new Scope(this);
  {
    SCOPE_KIDS_WRITER_LOCK
    kids_.push_back(child);
  }
  return *child;
Y
Yi Wang 已提交
55 56
}

57 58 59
std::unique_ptr<Scope> Scope::NewTmpScope() const {
  return std::unique_ptr<Scope>(new Scope(this));
}
Q
Qiao Longfei 已提交
60

D
dongzhihong 已提交
61
Variable* Scope::Var(const std::string& name) {
M
minqiyang 已提交
62
  SCOPE_VARS_WRITER_LOCK
T
tensor-tang 已提交
63
  return VarInternal(name);
Y
Yi Wang 已提交
64 65
}

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

Variable* Scope::FindVar(const std::string& name) const {
M
minqiyang 已提交
77
  SCOPE_VARS_READER_LOCK
T
tensor-tang 已提交
78 79 80
  return FindVarInternal(name);
}

81 82 83 84 85 86 87
Variable* Scope::GetVar(const std::string& name) const {
  auto* var = FindVar(name);
  PADDLE_ENFORCE_NOT_NULL(
      var, platform::errors::NotFound("Cannot find %s in scope.", name));
  return var;
}

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

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

98 99 100 101 102
const Scope* Scope::FindScope(const std::string& name) const {
  SCOPE_VARS_READER_LOCK
  return FindScopeInternal(name);
}

Y
Yu Yang 已提交
103
void Scope::DropKids() {
M
minqiyang 已提交
104
  SCOPE_KIDS_WRITER_LOCK
Y
Yu Yang 已提交
105 106 107
  for (Scope* s : kids_) delete s;
  kids_.clear();
}
Y
Yi Wang 已提交
108

M
minqiyang 已提交
109
bool Scope::HasKid(const Scope* scope) const {
M
minqiyang 已提交
110
  SCOPE_KIDS_READER_LOCK
M
minqiyang 已提交
111 112 113 114
  auto it = std::find(this->kids_.begin(), this->kids_.end(), scope);
  return it != this->kids_.end();
}

Y
Yang Yu 已提交
115 116
std::vector<std::string> Scope::LocalVarNames() const {
  std::vector<std::string> known_vars;
M
minqiyang 已提交
117 118 119 120 121 122
  {
    SCOPE_VARS_READER_LOCK
    known_vars.reserve(this->vars_.size());
    for (auto& p : vars_) {
      known_vars.emplace_back(p.first);
    }
123 124 125 126
  }
  return known_vars;
}

127
void Scope::DeleteScope(Scope* scope) const {
M
minqiyang 已提交
128
  SCOPE_KIDS_WRITER_LOCK
Y
Yu Yang 已提交
129
  auto it = std::find(this->kids_.begin(), this->kids_.end(), scope);
130 131 132
  PADDLE_ENFORCE_NE(it, this->kids_.end(),
                    platform::errors::NotFound(
                        "%p is not found in %p as kid scope", scope, this));
Y
Yu Yang 已提交
133
  this->kids_.erase(it);
134
  // When making memory benchmark on Fluid, we have to delete scope sync.
Y
Yu Yang 已提交
135
  if (FLAGS_benchmark || FLAGS_eager_delete_scope) {
136 137 138 139
    delete scope;
  } else {
    Async([scope] { delete scope; });
  }
Y
Yu Yang 已提交
140 141
}

Y
Yancey1989 已提交
142
void Scope::EraseVars(const std::vector<std::string>& var_names) {
143
  std::set<std::string> var_set(var_names.begin(), var_names.end());
M
minqiyang 已提交
144
  SCOPE_VARS_WRITER_LOCK
145 146 147 148 149 150 151 152 153
  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 已提交
154 155
void Scope::Rename(const std::string& origin_name,
                   const std::string& new_name) const {
M
minqiyang 已提交
156
  SCOPE_VARS_WRITER_LOCK
T
tensor-tang 已提交
157 158 159 160
  RenameInternal(origin_name, new_name);
}

std::string Scope::Rename(const std::string& origin_name) const {
M
minqiyang 已提交
161
  SCOPE_VARS_WRITER_LOCK
T
tensor-tang 已提交
162 163 164 165 166 167 168 169 170
  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 已提交
171
  vars_.emplace(name, std::unique_ptr<Variable>(v));
M
minqiyang 已提交
172
  VLOG(3) << "Create variable " << name;
T
tensor-tang 已提交
173 174 175 176 177 178 179 180 181 182 183 184
  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);
}

185 186 187 188 189 190 191
const Scope* Scope::FindScopeInternal(const std::string& name) const {
  if (vars_.find(name) != vars_.end()) {
    return this;
  }
  return (parent_ == nullptr) ? nullptr : parent_->FindScope(name);
}

T
tensor-tang 已提交
192 193
void Scope::RenameInternal(const std::string& origin_name,
                           const std::string& new_name) const {
Y
Yu Yang 已提交
194
  auto origin_it = vars_.find(origin_name);
195 196 197 198 199
  PADDLE_ENFORCE_NE(
      origin_it, vars_.end(),
      platform::errors::NotFound(
          "Original variable with name %s is not found in the scope.",
          origin_name));
Y
Yu Yang 已提交
200
  auto new_it = vars_.find(new_name);
201 202 203 204
  PADDLE_ENFORCE_EQ(
      new_it, vars_.end(),
      platform::errors::AlreadyExists(
          "The variable with name %s already exists in the scope.", new_name));
205
  vars_[new_name].reset(origin_it->second.release());
Y
Yu Yang 已提交
206 207 208
  vars_.erase(origin_it);
}

T
tensor-tang 已提交
209 210 211 212 213 214
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 已提交
215
}
216

217 218
Variable* Scope::FindVarLocally(const std::string& name) const {
  auto it = vars_.find(name);
219 220 221
  if (it != vars_.end()) {
    return it->second.get();
  }
222 223
  return nullptr;
}
Y
Yu Yang 已提交
224

225 226 227 228 229 230 231 232 233 234 235
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++);
    }
  }
}

236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
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 已提交
277 278
}  // namespace framework
}  // namespace paddle