executor.cc 17.3 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
Q
qijun 已提交
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/executor.h"
Y
Yang Yang 已提交
16

Y
Yi Wang 已提交
17 18 19 20 21
#include "paddle/fluid/framework/feed_fetch_method.h"
#include "paddle/fluid/framework/lod_rank_table.h"
#include "paddle/fluid/framework/lod_tensor_array.h"
#include "paddle/fluid/framework/op_registry.h"
#include "paddle/fluid/framework/reader.h"
G
gongweibao 已提交
22
#include "paddle/fluid/operators/detail/macros.h"
Y
Yi Wang 已提交
23
#include "paddle/fluid/platform/place.h"
X
Xin Pan 已提交
24
#include "paddle/fluid/platform/profiler.h"
Y
Yang Yu 已提交
25

D
dzhwinter 已提交
26
DECLARE_bool(benchmark);
27
DEFINE_bool(use_mkldnn, false, "Use MKLDNN to run");
Q
qijun 已提交
28 29 30

namespace paddle {
namespace framework {
X
Xin Pan 已提交
31 32 33 34 35
namespace {
// block id starts from 0. This id is used to represent the codeblock
// wrapping the first block 0.
int kProgramId = -1;
}  // namespace
Q
qijun 已提交
36

Q
Qiao Longfei 已提交
37 38
ExecutorPrepareContext::ExecutorPrepareContext(
    const framework::ProgramDesc& prog, size_t block_id)
S
sneaxiy 已提交
39 40 41 42 43
    : prog_(prog), block_id_(block_id) {
  if (GetEagerDeletionThreshold() >= 0) {
    ref_cnts_ = GetNonPersistableReferenceCount<int>(prog_, block_id_);
  }
}
Y
Yu Yang 已提交
44

Q
Qiao Longfei 已提交
45 46 47
ExecutorPrepareContext::~ExecutorPrepareContext() {
  VLOG(5) << "destroy ExecutorPrepareContext";
}
Y
Yu Yang 已提交
48

D
dzhwinter 已提交
49
Executor::Executor(const platform::Place& place) : place_(place) {}
Q
qijun 已提交
50

Y
Yancey1989 已提交
51
void Executor::Close() {
W
Wu Yi 已提交
52
#ifdef PADDLE_WITH_DISTRIBUTE
Y
Yancey1989 已提交
53 54
  ::paddle::operators::distributed::RPCClient::GetInstance<
      ::paddle::operators::distributed::GRPCClient>()
Y
Yancey1989 已提交
55
      ->SendComplete();
W
Wu Yi 已提交
56
#endif
Y
Yancey1989 已提交
57
}
W
Wu Yi 已提交
58

Y
Stash  
Yu Yang 已提交
59
void InitializeVariable(Variable* var, proto::VarType::Type var_type) {
60
  if (var_type == proto::VarType::LOD_TENSOR) {
Q
QI JUN 已提交
61
    var->GetMutable<LoDTensor>();
62
  } else if (var_type == proto::VarType::SELECTED_ROWS) {
Q
QI JUN 已提交
63
    var->GetMutable<SelectedRows>();
64
  } else if (var_type == proto::VarType::FEED_MINIBATCH) {
Q
QI JUN 已提交
65
    var->GetMutable<FeedFetchList>();
66
  } else if (var_type == proto::VarType::FETCH_LIST) {
Q
QI JUN 已提交
67
    var->GetMutable<FeedFetchList>();
68
  } else if (var_type == proto::VarType::STEP_SCOPES) {
Y
Yu Yang 已提交
69
    var->GetMutable<std::vector<framework::Scope>>();
70
  } else if (var_type == proto::VarType::LOD_RANK_TABLE) {
Y
Yu Yang 已提交
71
    var->GetMutable<LoDRankTable>();
72
  } else if (var_type == proto::VarType::LOD_TENSOR_ARRAY) {
Y
Yu Yang 已提交
73
    var->GetMutable<LoDTensorArray>();
74
  } else if (var_type == proto::VarType::PLACE_LIST) {
Y
Yang Yu 已提交
75
    var->GetMutable<platform::PlaceList>();
76
  } else if (var_type == proto::VarType::READER) {
F
fengjiayi 已提交
77
    var->GetMutable<ReaderHolder>();
T
typhoonzero 已提交
78 79
  } else if (var_type == proto::VarType::RAW) {
    // GetMutable will be called in operator
Q
QI JUN 已提交
80 81
  } else {
    PADDLE_THROW(
Y
Yu Yang 已提交
82
        "Variable type %d is not in "
F
fengjiayi 已提交
83
        "[LOD_TENSOR, SELECTED_ROWS, FEED_MINIBATCH, FETCH_LIST, "
84
        "LOD_RANK_TABLE, PLACE_LIST, READER, RAW]",
Y
Yu Yang 已提交
85
        var_type);
Q
QI JUN 已提交
86 87 88
  }
}

L
Liu Yiqun 已提交
89 90 91
void Executor::CreateVariables(const ProgramDesc& pdesc, Scope* scope,
                               int block_id) {
  auto& global_block = pdesc.Block(block_id);
92 93 94 95 96 97 98 99 100 101 102 103 104 105

  const Scope* ancestor_scope = scope;
  while (ancestor_scope->parent()) {
    ancestor_scope = ancestor_scope->parent();
  }

  if (ancestor_scope != scope) {
    for (auto& var : global_block.AllVars()) {
      if (var->Name() == framework::kEmptyVarName) {
        continue;
      }

      if (var->Persistable()) {
        auto* ptr = const_cast<Scope*>(ancestor_scope)->Var(var->Name());
106
        InitializeVariable(ptr, var->GetType());
107 108 109 110
        VLOG(3) << "Create Variable " << var->Name()
                << " global, which pointer is " << ptr;
      } else {
        auto* ptr = scope->Var(var->Name());
111
        InitializeVariable(ptr, var->GetType());
112 113 114 115 116 117 118
        VLOG(3) << "Create Variable " << var->Name()
                << " locally, which pointer is " << ptr;
      }
    }
  } else {
    for (auto& var : global_block.AllVars()) {
      auto* ptr = scope->Var(var->Name());
119
      InitializeVariable(ptr, var->GetType());
120 121 122 123 124 125
      VLOG(3) << "Create variable " << var->Name() << ", which pointer is "
              << ptr;
    }
  }
}

Y
Yu Yang 已提交
126
void Executor::Run(const ProgramDesc& pdesc, Scope* scope, int block_id,
T
typhoonzero 已提交
127
                   bool create_local_scope, bool create_vars) {
X
Xin Pan 已提交
128
  platform::RecordBlock b(block_id);
129
  if (FLAGS_use_mkldnn) EnableMKLDNN(pdesc);
Q
Qiao Longfei 已提交
130 131
  auto ctx = Prepare(pdesc, block_id);
  RunPreparedContext(ctx.get(), scope, create_local_scope, create_vars);
Q
qijun 已提交
132 133
}

134 135 136 137 138 139 140
// Check whether the block already has feed operators and feed_holder.
// Return false if the block does not have any feed operators.
// If some feed operators have been prepended to the block, check that
// the info contained in these feed operators matches the feed_targets
// and feed_holder_name. Raise exception when any mismatch is found.
// Return true if the block has feed operators and holder of matching info.
static bool has_feed_operators(
141
    const BlockDesc& block,
L
Liu Yiqun 已提交
142
    const std::map<std::string, const LoDTensor*>& feed_targets,
143 144
    const std::string& feed_holder_name) {
  size_t feed_count = 0;
145
  for (auto* op : block.AllOps()) {
146 147
    if (op->Type() == kFeedOpType) {
      feed_count++;
L
Liu Yiqun 已提交
148
      // The input variable's name of feed_op should be feed_holder_name.
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
      PADDLE_ENFORCE_EQ(op->Input("X")[0], feed_holder_name,
                        "Input to feed op should be '%s'", feed_holder_name);
      std::string feed_target_name = op->Output("Out")[0];
      PADDLE_ENFORCE(
          feed_targets.find(feed_target_name) != feed_targets.end(),
          "Feed operator output name '%s' cannot be found in 'feed_targets'",
          feed_target_name);
    }
  }

  if (feed_count > 0) {
    PADDLE_ENFORCE_EQ(
        feed_count, feed_targets.size(),
        "The number of feed operators should match 'feed_targets'");

164
    if (!feed_holder_name.empty()) {
L
Liu Yiqun 已提交
165
      // When feed operator are present, so should be feed_holder.
166 167 168 169 170 171 172
      auto var = block.FindVar(feed_holder_name);
      PADDLE_ENFORCE_NOT_NULL(var, "Block should already have a '%s' variable",
                              feed_holder_name);
      PADDLE_ENFORCE_EQ(var->GetType(), proto::VarType::FEED_MINIBATCH,
                        "'%s' variable should be 'FEED_MINIBATCH' type",
                        feed_holder_name);
    }
173 174 175 176 177 178 179 180 181 182 183 184
  }

  return feed_count > 0;
}

// Check whether the block already has fetch operators and fetch_holder.
// Return false if the block does not have any fetch operators.
// If some fetch operators have been appended to the block, check that
// the info contained in these fetch operators matches the fetch_targets
// and fetch_holder_name. Raise exception when any mismatch is found.
// Return true if the block has fetch operators and holder of matching info.
static bool has_fetch_operators(
L
Liu Yiqun 已提交
185 186
    const BlockDesc& block,
    const std::map<std::string, LoDTensor*>& fetch_targets,
187 188
    const std::string& fetch_holder_name) {
  size_t fetch_count = 0;
189
  for (auto* op : block.AllOps()) {
190 191
    if (op->Type() == kFetchOpType) {
      fetch_count++;
L
Liu Yiqun 已提交
192
      // The output variable's name of fetch_op should be fetch_holder_name.
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
      PADDLE_ENFORCE_EQ(op->Output("Out")[0], fetch_holder_name,
                        "Output of fetch op should be '%s'", fetch_holder_name);
      std::string fetch_target_name = op->Input("X")[0];
      PADDLE_ENFORCE(
          fetch_targets.find(fetch_target_name) != fetch_targets.end(),
          "Fetch operator input name '%s' cannot be found in 'fetch_targets'",
          fetch_target_name);
    }
  }

  if (fetch_count > 0) {
    PADDLE_ENFORCE_EQ(
        fetch_count, fetch_targets.size(),
        "The number of fetch operators should match 'fetch_targets'");

208
    if (!fetch_holder_name.empty()) {
L
Liu Yiqun 已提交
209
      // When fetch operator are present, so should be fetch_holder.
210 211 212 213 214 215 216
      auto var = block.FindVar(fetch_holder_name);
      PADDLE_ENFORCE_NOT_NULL(var, "Block should already have a '%s' variable",
                              fetch_holder_name);
      PADDLE_ENFORCE_EQ(var->GetType(), proto::VarType::FETCH_LIST,
                        "'%s' variable should be 'FETCH_LIST' type",
                        fetch_holder_name);
    }
217 218 219 220 221 222
  }

  return fetch_count > 0;
}

void Executor::Run(const ProgramDesc& program, Scope* scope,
223 224
                   std::map<std::string, const LoDTensor*>* feed_targets,
                   std::map<std::string, LoDTensor*>* fetch_targets,
W
Wu Yi 已提交
225 226
                   bool create_local_scope, bool create_vars,
                   const std::string& feed_holder_name,
227
                   const std::string& fetch_holder_name) {
X
Xin Pan 已提交
228
  platform::RecordBlock b(kProgramId);
229
  if (FLAGS_use_mkldnn) EnableMKLDNN(program);
230
  bool has_feed_ops =
231
      has_feed_operators(program.Block(0), *feed_targets, feed_holder_name);
232
  bool has_fetch_ops =
233
      has_fetch_operators(program.Block(0), *fetch_targets, fetch_holder_name);
234 235

  ProgramDesc* copy_program = const_cast<ProgramDesc*>(&program);
S
sneaxiy 已提交
236
  std::unique_ptr<ProgramDesc> unique_ptr_of_copy_program;
237
  if (!has_feed_ops || !has_fetch_ops) {
S
sneaxiy 已提交
238 239
    unique_ptr_of_copy_program.reset(new ProgramDesc(program));
    copy_program = unique_ptr_of_copy_program.get();
240
  }
241 242
  auto* global_block = copy_program->MutableBlock(0);

243
  if (!has_feed_ops) {
244 245
    // create feed_holder variable
    auto* feed_holder = global_block->Var(feed_holder_name);
246
    feed_holder->SetType(proto::VarType::FEED_MINIBATCH);
247 248 249
    feed_holder->SetPersistable(true);

    int i = 0;
250
    for (auto& feed_target : (*feed_targets)) {
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
      std::string var_name = feed_target.first;
      VLOG(3) << "feed target's name: " << var_name;

      // prepend feed op
      auto* op = global_block->PrependOp();
      op->SetType(kFeedOpType);
      op->SetInput("X", {feed_holder_name});
      op->SetOutput("Out", {var_name});
      op->SetAttr("col", {static_cast<int>(i)});
      op->CheckAttrs();

      i++;
    }
  }

266
  if (!has_fetch_ops) {
267 268
    // create fetch_holder variable
    auto* fetch_holder = global_block->Var(fetch_holder_name);
269
    fetch_holder->SetType(proto::VarType::FETCH_LIST);
270 271 272
    fetch_holder->SetPersistable(true);

    int i = 0;
273
    for (auto& fetch_target : (*fetch_targets)) {
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
      std::string var_name = fetch_target.first;
      VLOG(3) << "fetch target's name: " << var_name;

      // append fetch op
      auto* op = global_block->AppendOp();
      op->SetType(kFetchOpType);
      op->SetInput("X", {var_name});
      op->SetOutput("Out", {fetch_holder_name});
      op->SetAttr("col", {static_cast<int>(i)});
      op->CheckAttrs();

      i++;
    }
  }

289
  auto ctx = Prepare(*copy_program, 0);
W
Wu Yi 已提交
290 291 292
  RunPreparedContext(ctx.get(), scope, feed_targets, fetch_targets,
                     create_local_scope, create_vars, feed_holder_name,
                     fetch_holder_name);
293 294
}

Q
Qiao Longfei 已提交
295 296
std::unique_ptr<ExecutorPrepareContext> Executor::Prepare(
    const ProgramDesc& program, int block_id) {
Q
Qiyang Min 已提交
297 298
  std::unique_ptr<ExecutorPrepareContext> ctx(
      new ExecutorPrepareContext(program, block_id));
Y
Yu Yang 已提交
299 300 301 302 303
  PADDLE_ENFORCE_LT(static_cast<size_t>(block_id), program.Size());
  auto& block = program.Block(block_id);
  for (auto& op_desc : block.AllOps()) {
    ctx->ops_.push_back(OpRegistry::CreateOp(*op_desc));
  }
Q
Qiyang Min 已提交
304
  return ctx;
Y
Yu Yang 已提交
305 306
}

T
refine  
typhoonzero 已提交
307
std::vector<std::shared_ptr<ExecutorPrepareContext>> Executor::Prepare(
T
typhoonzero 已提交
308 309 310 311 312 313 314 315 316 317 318 319 320 321
    const ProgramDesc& program, const std::vector<int>& block_ids) {
  std::vector<std::shared_ptr<ExecutorPrepareContext>> result;
  for (auto& bid : block_ids) {
    auto* ctx = new ExecutorPrepareContext(program, bid);
    PADDLE_ENFORCE_LT(static_cast<size_t>(bid), program.Size());
    auto& block = program.Block(bid);
    for (auto& op_desc : block.AllOps()) {
      ctx->ops_.push_back(OpRegistry::CreateOp(*op_desc));
    }
    result.push_back(std::shared_ptr<ExecutorPrepareContext>(ctx));
  }
  return result;
}

Y
Yu Yang 已提交
322
void Executor::RunPreparedContext(ExecutorPrepareContext* ctx, Scope* scope,
Q
qiaolongfei 已提交
323 324
                                  bool create_local_scope, bool create_vars,
                                  bool keep_kids) {
Y
Yu Yang 已提交
325 326 327 328
  Scope* local_scope = scope;
  if (create_vars) {
    if (create_local_scope) {
      local_scope = &scope->NewScope();
329 330
    }
    CreateVariables(ctx->prog_, local_scope, ctx->block_id_);
L
Liu Yiqun 已提交
331
  }
Y
Yu Yang 已提交
332

S
sneaxiy 已提交
333 334 335 336
  int64_t max_memory_size = GetEagerDeletionThreshold();

  std::unique_ptr<GarbageCollector<Tensor>> gc;
  if (max_memory_size >= 0) {
S
sneaxiy 已提交
337
    ctx->ResetReferenceCount();
S
sneaxiy 已提交
338 339 340 341 342 343 344 345 346 347 348 349 350
#ifdef PADDLE_WITH_CUDA
    if (platform::is_gpu_place(place_)) {
      gc.reset(new DefaultStreamGarbageCollector<Tensor>(
          boost::get<platform::CUDAPlace>(place_), max_memory_size));
    } else {
#endif
      gc.reset(new CPUGarbageCollector<Tensor>(
          boost::get<platform::CPUPlace>(place_), max_memory_size));
#ifdef PADDLE_WITH_CUDA
    }
#endif
  }

Y
Yu Yang 已提交
351
  for (auto& op : ctx->ops_) {
352
    op->Run(*local_scope, place_);
S
sneaxiy 已提交
353 354 355 356 357

    if (gc != nullptr) {
      std::vector<std::string> erase_vars;
      for (auto& input : op->Inputs()) {
        for (auto& input_name : input.second) {
S
sneaxiy 已提交
358 359
          auto it = ctx->cur_ref_cnts_.find(input_name);
          if (it == ctx->cur_ref_cnts_.end()) continue;
S
sneaxiy 已提交
360 361
          if (it->second == 1) {  // should delete it
            erase_vars.emplace_back(input_name);
S
sneaxiy 已提交
362
            ctx->cur_ref_cnts_.erase(input_name);
S
sneaxiy 已提交
363 364 365 366 367 368 369 370
          } else {
            --(it->second);
          }
        }
      }

      for (auto& output : op->Outputs()) {
        for (auto& output_name : output.second) {
S
sneaxiy 已提交
371 372
          auto it = ctx->cur_ref_cnts_.find(output_name);
          if (it == ctx->cur_ref_cnts_.end()) continue;
S
sneaxiy 已提交
373 374
          if (it->second == 1) {
            erase_vars.emplace_back(output_name);
S
sneaxiy 已提交
375
            ctx->cur_ref_cnts_.erase(output_name);
S
sneaxiy 已提交
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
          } else {
            --(it->second);
          }
        }
      }

      if (!erase_vars.empty()) {
        std::vector<framework::LoDTensor*> erase_tensors;
        for (auto& name : erase_vars) {
          auto* var = local_scope->FindVar(name);
          if (var == nullptr) continue;
          if (var->IsType<framework::LoDTensor>()) {
            auto* tensor = var->GetMutable<framework::LoDTensor>();
            erase_tensors.push_back(tensor);
          }
        }
        if (!erase_tensors.empty()) gc->Add(erase_tensors);
      }
    }
Y
Yang Yang 已提交
395

Y
Yu Yang 已提交
396 397 398 399 400
    if (FLAGS_benchmark) {
      VLOG(2) << "Memory used after operator " + op->Type() + " running: "
              << memory::memory_usage(place_);
    }
  }
S
sneaxiy 已提交
401

S
sneaxiy 已提交
402
  if (gc != nullptr) {
S
sneaxiy 已提交
403
    gc->Wait();
S
sneaxiy 已提交
404
  } else {
S
sneaxiy 已提交
405
    platform::DeviceContextPool::Instance().Get(place_)->Wait();
S
sneaxiy 已提交
406
  }
S
sneaxiy 已提交
407

Q
qiaolongfei 已提交
408
  if (local_scope != scope) {
Y
Yu Yang 已提交
409
    scope->DeleteScope(local_scope);
410
  } else {
Q
qiaolongfei 已提交
411 412 413 414 415
    if (!keep_kids) {
      // By default, we should delete all kid scopes after run executor because
      // some operators may create local scope when running, such as while_op.
      // But when while_op also create a local executor to run it's sub block,
      // the sub scopes it created should not be dropped immediately, because
Q
qiaolongfei 已提交
416 417
      // while_grad_op will use some variables created during while_op run, so
      // we need to keep the kids and wait for the outer executor to drop them.
Q
qiaolongfei 已提交
418 419
      scope->DropKids();
    }
Y
Yu Yang 已提交
420
  }
Q
qiaolongfei 已提交
421

Y
Yu Yang 已提交
422 423 424 425 426 427 428 429
  if (FLAGS_benchmark) {
    VLOG(2) << "-------------------------------------------------------";
    VLOG(2) << "Memory used after deleting local scope: "
            << memory::memory_usage(place_);
    VLOG(2) << "-------------------------------------------------------";
  }
}

430 431
void Executor::RunPreparedContext(
    ExecutorPrepareContext* ctx, Scope* scope,
432
    std::map<std::string, const LoDTensor*>* feed_targets,
W
Wu Yi 已提交
433 434 435
    std::map<std::string, LoDTensor*>* fetch_targets, bool create_local_scope,
    bool create_vars, const std::string& feed_holder_name,
    const std::string& fetch_holder_name) {
436 437
  auto& global_block = ctx->prog_.Block(ctx->block_id_);

438
  PADDLE_ENFORCE(
439
      has_feed_operators(global_block, *feed_targets, feed_holder_name),
440 441
      "Program in ExecutorPrepareContext should has feed_ops.");
  PADDLE_ENFORCE(
442
      has_fetch_operators(global_block, *fetch_targets, fetch_holder_name),
443 444
      "Program in the prepared context should has fetch_ops.");

445 446 447 448 449
  // map the data of feed_targets to feed_holder
  for (auto* op : global_block.AllOps()) {
    if (op->Type() == kFeedOpType) {
      std::string feed_target_name = op->Output("Out")[0];
      int idx = boost::get<int>(op->GetAttr("col"));
450 451
      SetFeedVariable(scope, *(*feed_targets)[feed_target_name],
                      feed_holder_name, idx);
452 453 454
    }
  }

W
Wu Yi 已提交
455
  RunPreparedContext(ctx, scope, create_local_scope, create_vars);
456 457 458 459 460 461

  // obtain the data of fetch_targets from fetch_holder
  for (auto* op : global_block.AllOps()) {
    if (op->Type() == kFetchOpType) {
      std::string fetch_target_name = op->Input("X")[0];
      int idx = boost::get<int>(op->GetAttr("col"));
462
      *(*fetch_targets)[fetch_target_name] =
463 464 465 466 467
          GetFetchVariable(*scope, fetch_holder_name, idx);
    }
  }
}

468 469 470 471 472 473 474 475 476 477 478
void Executor::EnableMKLDNN(const ProgramDesc& program) {
#ifdef PADDLE_WITH_MKLDNN
  VLOG(3) << "use_mkldnn=True";
  for (size_t bid = 0; bid < program.Size(); ++bid) {
    auto* block = const_cast<ProgramDesc&>(program).MutableBlock(bid);
    for (auto* op : block->AllOps()) {
      if (op->HasAttr("use_mkldnn")) {
        op->SetAttr("use_mkldnn", true);
      }
    }
  }
479 480 481
#else
  LOG(WARNING)
      << "'MKLDNN' is not supported, Please re-compile with WITH_MKLDNN option";
482 483 484
#endif
}

Q
qijun 已提交
485 486
}  // namespace framework
}  // namespace paddle