executor.cc 18.7 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
#include "paddle/fluid/framework/feed_fetch_method.h"
#include "paddle/fluid/framework/lod_rank_table.h"
#include "paddle/fluid/framework/lod_tensor_array.h"
B
baojun-nervana 已提交
20
#include "paddle/fluid/framework/ngraph_operator.h"
Y
Yi Wang 已提交
21 22
#include "paddle/fluid/framework/op_registry.h"
#include "paddle/fluid/framework/reader.h"
23
#include "paddle/fluid/framework/transfer_scope_cache.h"
W
Wang Guibao 已提交
24
#include "paddle/fluid/framework/variable_helper.h"
G
gongweibao 已提交
25
#include "paddle/fluid/operators/detail/macros.h"
Y
Yi Wang 已提交
26
#include "paddle/fluid/platform/place.h"
X
Xin Pan 已提交
27
#include "paddle/fluid/platform/profiler.h"
Y
Yang Yu 已提交
28

D
dzhwinter 已提交
29
DECLARE_bool(benchmark);
30
DEFINE_bool(use_mkldnn, false, "Use MKLDNN to run");
B
baojun-nervana 已提交
31
DEFINE_bool(use_ngraph, false, "Use NGRAPH to run");
Q
qijun 已提交
32 33 34

namespace paddle {
namespace framework {
X
Xin Pan 已提交
35 36 37 38 39
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 已提交
40

S
fix bug  
sneaxiy 已提交
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
static std::unordered_map<std::string, size_t> GetNonPersistableReferenceCounts(
    const BlockDesc& block, const std::vector<std::string>& skip_var_list) {
  std::unordered_map<std::string, size_t> ref_cnts;
  std::unordered_set<std::string> skip_vars(skip_var_list.begin(),
                                            skip_var_list.end());

  auto update_ref_cnts = [&](OpDesc* op_desc, const VariableNameMap& name_map) {
    for (auto& name_pair : name_map) {
      for (auto& name : name_pair.second) {
        if (skip_vars.count(name)) continue;
        auto* var_desc = block.FindVar(name);
        if (var_desc == nullptr || var_desc->Persistable()) continue;
        auto type = var_desc->Proto()->type().type();
        if (type != proto::VarType::LOD_TENSOR &&
            type != proto::VarType::SELECTED_ROWS &&
            type != proto::VarType::LOD_TENSOR_ARRAY) {
          continue;
        }

        auto it = ref_cnts.find(name);
        if (it != ref_cnts.end()) {
          ++it->second;
        } else {
          ref_cnts[name] = 1;
        }
      }
    }
  };

  for (auto op_desc : block.AllOps()) {
    update_ref_cnts(op_desc, op_desc->Inputs());
    update_ref_cnts(op_desc, op_desc->Outputs());
  }
  return ref_cnts;
}

Q
Qiao Longfei 已提交
77
ExecutorPrepareContext::ExecutorPrepareContext(
S
fix bug  
sneaxiy 已提交
78 79
    const framework::ProgramDesc& prog, size_t block_id,
    const std::vector<std::string>& skip_ref_cnt_vars)
S
sneaxiy 已提交
80 81
    : prog_(prog), block_id_(block_id) {
  if (GetEagerDeletionThreshold() >= 0) {
S
fix bug  
sneaxiy 已提交
82 83
    ref_cnts_ = GetNonPersistableReferenceCounts(prog.Block(block_id),
                                                 skip_ref_cnt_vars);
S
sneaxiy 已提交
84 85
  }
}
Y
Yu Yang 已提交
86

Q
Qiao Longfei 已提交
87
ExecutorPrepareContext::~ExecutorPrepareContext() {
M
minqiyang 已提交
88
  VLOG(5) << "destroy ExecutorPrepareContext";
Q
Qiao Longfei 已提交
89
}
Y
Yu Yang 已提交
90

S
fix bug  
sneaxiy 已提交
91 92 93
static void DeleteUnusedTensors(
    const Scope& scope, const OperatorBase* op, GarbageCollector<Tensor>* gc,
    std::unordered_map<std::string, size_t>* ref_cnts) {
S
sneaxiy 已提交
94 95 96 97 98 99 100
  std::unordered_set<Tensor*> erase_tensors;

  auto handler = [&](const VariableNameMap& name_map) {
    for (auto& name_pair : name_map) {
      for (auto& name : name_pair.second) {
        auto it = ref_cnts->find(name);
        if (it == ref_cnts->end()) continue;
S
fix bug  
sneaxiy 已提交
101
        if (--(it->second) == 0) {
S
sneaxiy 已提交
102 103
          auto* var = scope.FindVar(name);
          if (var != nullptr) {
M
minqiyang 已提交
104
            VLOG(10) << "Erase tensor \'" << name << "\'";
S
sneaxiy 已提交
105 106 107 108 109
            if (var->IsType<LoDTensor>()) {
              erase_tensors.insert(var->GetMutable<LoDTensor>());
            } else if (var->IsType<SelectedRows>()) {
              erase_tensors.insert(
                  var->GetMutable<SelectedRows>()->mutable_value());
S
fix bug  
sneaxiy 已提交
110 111 112 113 114
            } else if (var->IsType<LoDTensorArray>()) {
              auto* lod_tensor_arr = var->GetMutable<LoDTensorArray>();
              for (auto& t : *lod_tensor_arr) {
                erase_tensors.insert(&t);
              }
S
sneaxiy 已提交
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
            }
          }
        }
      }
    }
  };

  handler(op->Inputs());
  handler(op->Outputs());

  if (!erase_tensors.empty()) {
    gc->Add(erase_tensors);
  }
}

B
baojun-nervana 已提交
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
static void EnableFusedOp(ExecutorPrepareContext* ctx) {
#ifdef PADDLE_WITH_NGRAPH
  VLOG(3) << "use_ngraph=True";
  auto intervals = FusedOperator::FusedOpIntervals(&ctx->ops_);
  for (auto& interval : intervals) {
    auto* fused_op = new FusedOperator(ctx->prog_, ctx->block_id_,
                                       interval.at(0), interval.at(1));
    *interval[0] = std::unique_ptr<OperatorBase>(fused_op);
  }
  for (auto it = intervals.rbegin(); it != intervals.rend(); ++it) {
    ctx->ops_.erase(it->at(0) + 1, it->at(1));
  }
#else
  LOG(WARNING)
      << "'NGRAPH' is not supported, Please re-compile with WITH_NGRAPH option";
#endif
}

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

Y
Yancey1989 已提交
150
void Executor::Close() {
W
Wu Yi 已提交
151
#ifdef PADDLE_WITH_DISTRIBUTE
W
Wu Yi 已提交
152 153
  // TODO(typhoonzero): complete message will need to use real trainer_id,
  // except 0.
Y
Yancey1989 已提交
154
  ::paddle::operators::distributed::RPCClient::GetInstance<
W
Wu Yi 已提交
155
      ::paddle::operators::distributed::GRPCClient>(0)
Y
Yancey1989 已提交
156
      ->SendComplete();
W
Wu Yi 已提交
157
#endif
Y
Yancey1989 已提交
158
}
W
Wu Yi 已提交
159

L
Liu Yiqun 已提交
160 161 162
void Executor::CreateVariables(const ProgramDesc& pdesc, Scope* scope,
                               int block_id) {
  auto& global_block = pdesc.Block(block_id);
163 164 165 166 167 168 169 170 171 172 173 174 175 176

  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());
177
        InitializeVariable(ptr, var->GetType());
M
minqiyang 已提交
178 179
        VLOG(3) << "Create Variable " << var->Name()
                << " global, which pointer is " << ptr;
180 181
      } else {
        auto* ptr = scope->Var(var->Name());
182
        InitializeVariable(ptr, var->GetType());
M
minqiyang 已提交
183 184
        VLOG(3) << "Create Variable " << var->Name()
                << " locally, which pointer is " << ptr;
185 186 187 188 189
      }
    }
  } else {
    for (auto& var : global_block.AllVars()) {
      auto* ptr = scope->Var(var->Name());
190
      InitializeVariable(ptr, var->GetType());
M
minqiyang 已提交
191 192
      VLOG(3) << "Create variable " << var->Name() << ", which pointer is "
              << ptr;
193 194 195 196
    }
  }
}

Y
Yu Yang 已提交
197
void Executor::Run(const ProgramDesc& pdesc, Scope* scope, int block_id,
T
typhoonzero 已提交
198
                   bool create_local_scope, bool create_vars) {
X
Xin Pan 已提交
199
  platform::RecordBlock b(block_id);
200
  if (FLAGS_use_mkldnn) EnableMKLDNN(pdesc);
Q
Qiao Longfei 已提交
201 202
  auto ctx = Prepare(pdesc, block_id);
  RunPreparedContext(ctx.get(), scope, create_local_scope, create_vars);
Q
qijun 已提交
203 204
}

205 206 207 208 209 210 211
// 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(
212
    const BlockDesc& block,
L
Liu Yiqun 已提交
213
    const std::map<std::string, const LoDTensor*>& feed_targets,
214 215
    const std::string& feed_holder_name) {
  size_t feed_count = 0;
216
  for (auto* op : block.AllOps()) {
217 218
    if (op->Type() == kFeedOpType) {
      feed_count++;
L
Liu Yiqun 已提交
219
      // The input variable's name of feed_op should be feed_holder_name.
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
      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'");

235
    if (!feed_holder_name.empty()) {
L
Liu Yiqun 已提交
236
      // When feed operator are present, so should be feed_holder.
237 238 239 240 241 242 243
      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);
    }
244 245 246 247 248 249 250 251 252 253 254 255
  }

  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 已提交
256 257
    const BlockDesc& block,
    const std::map<std::string, LoDTensor*>& fetch_targets,
258 259
    const std::string& fetch_holder_name) {
  size_t fetch_count = 0;
260
  for (auto* op : block.AllOps()) {
261 262
    if (op->Type() == kFetchOpType) {
      fetch_count++;
L
Liu Yiqun 已提交
263
      // The output variable's name of fetch_op should be fetch_holder_name.
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
      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'");

279
    if (!fetch_holder_name.empty()) {
L
Liu Yiqun 已提交
280
      // When fetch operator are present, so should be fetch_holder.
281 282 283 284 285 286 287
      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);
    }
288 289 290 291 292 293
  }

  return fetch_count > 0;
}

void Executor::Run(const ProgramDesc& program, Scope* scope,
294 295
                   std::map<std::string, const LoDTensor*>* feed_targets,
                   std::map<std::string, LoDTensor*>* fetch_targets,
W
Wu Yi 已提交
296 297
                   bool create_local_scope, bool create_vars,
                   const std::string& feed_holder_name,
298
                   const std::string& fetch_holder_name) {
X
Xin Pan 已提交
299
  platform::RecordBlock b(kProgramId);
300
  if (FLAGS_use_mkldnn) EnableMKLDNN(program);
301
  bool has_feed_ops =
302
      has_feed_operators(program.Block(0), *feed_targets, feed_holder_name);
303
  bool has_fetch_ops =
304
      has_fetch_operators(program.Block(0), *fetch_targets, fetch_holder_name);
305 306

  ProgramDesc* copy_program = const_cast<ProgramDesc*>(&program);
S
sneaxiy 已提交
307
  std::unique_ptr<ProgramDesc> unique_ptr_of_copy_program;
308
  if (!has_feed_ops || !has_fetch_ops) {
S
sneaxiy 已提交
309 310
    unique_ptr_of_copy_program.reset(new ProgramDesc(program));
    copy_program = unique_ptr_of_copy_program.get();
311
  }
312 313
  auto* global_block = copy_program->MutableBlock(0);

314
  if (!has_feed_ops) {
315 316
    // create feed_holder variable
    auto* feed_holder = global_block->Var(feed_holder_name);
317
    feed_holder->SetType(proto::VarType::FEED_MINIBATCH);
318 319 320
    feed_holder->SetPersistable(true);

    int i = 0;
321
    for (auto& feed_target : (*feed_targets)) {
322
      std::string var_name = feed_target.first;
M
minqiyang 已提交
323
      VLOG(3) << "feed target's name: " << var_name;
324 325 326 327 328 329 330 331 332 333 334 335 336

      // 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++;
    }
  }

337
  if (!has_fetch_ops) {
338 339
    // create fetch_holder variable
    auto* fetch_holder = global_block->Var(fetch_holder_name);
340
    fetch_holder->SetType(proto::VarType::FETCH_LIST);
341 342 343
    fetch_holder->SetPersistable(true);

    int i = 0;
344
    for (auto& fetch_target : (*fetch_targets)) {
345
      std::string var_name = fetch_target.first;
M
minqiyang 已提交
346
      VLOG(3) << "fetch target's name: " << var_name;
347 348 349 350 351 352 353 354 355 356 357 358 359

      // 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++;
    }
  }

360
  auto ctx = Prepare(*copy_program, 0);
W
Wu Yi 已提交
361 362 363
  RunPreparedContext(ctx.get(), scope, feed_targets, fetch_targets,
                     create_local_scope, create_vars, feed_holder_name,
                     fetch_holder_name);
364 365
}

Q
Qiao Longfei 已提交
366
std::unique_ptr<ExecutorPrepareContext> Executor::Prepare(
S
fix bug  
sneaxiy 已提交
367 368
    const ProgramDesc& program, int block_id,
    const std::vector<std::string>& skip_ref_cnt_vars) {
Q
Qiyang Min 已提交
369
  std::unique_ptr<ExecutorPrepareContext> ctx(
S
fix bug  
sneaxiy 已提交
370
      new ExecutorPrepareContext(program, block_id, skip_ref_cnt_vars));
Y
Yu Yang 已提交
371 372 373 374 375
  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));
  }
B
baojun-nervana 已提交
376
  if (FLAGS_use_ngraph) EnableFusedOp(ctx.get());
Q
Qiyang Min 已提交
377
  return ctx;
Y
Yu Yang 已提交
378 379
}

T
refine  
typhoonzero 已提交
380
std::vector<std::shared_ptr<ExecutorPrepareContext>> Executor::Prepare(
S
fix bug  
sneaxiy 已提交
381 382 383 384 385 386
    const ProgramDesc& program, const std::vector<int>& block_ids,
    const std::vector<std::vector<std::string>>& skip_ref_cnt_vars) {
  PADDLE_ENFORCE(
      skip_ref_cnt_vars.empty() || skip_ref_cnt_vars.size() == block_ids.size(),
      "skip_ref_cnt_vars should be either empty or equals to block number %d",
      block_ids.size());
T
typhoonzero 已提交
387
  std::vector<std::shared_ptr<ExecutorPrepareContext>> result;
S
fix bug  
sneaxiy 已提交
388
  size_t idx = 0;
T
typhoonzero 已提交
389
  for (auto& bid : block_ids) {
S
fix bug  
sneaxiy 已提交
390 391 392 393 394 395
    ExecutorPrepareContext* ctx;
    if (skip_ref_cnt_vars.empty()) {
      ctx = new ExecutorPrepareContext(program, bid);
    } else {
      ctx = new ExecutorPrepareContext(program, bid, skip_ref_cnt_vars[idx]);
    }
T
typhoonzero 已提交
396 397 398 399 400 401
    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));
S
fix bug  
sneaxiy 已提交
402
    ++idx;
T
typhoonzero 已提交
403 404 405 406
  }
  return result;
}

Y
Yu Yang 已提交
407
void Executor::RunPreparedContext(ExecutorPrepareContext* ctx, Scope* scope,
Q
qiaolongfei 已提交
408 409
                                  bool create_local_scope, bool create_vars,
                                  bool keep_kids) {
410
  PADDLE_ENFORCE_NOT_NULL(scope);
Y
Yu Yang 已提交
411 412 413 414
  Scope* local_scope = scope;
  if (create_vars) {
    if (create_local_scope) {
      local_scope = &scope->NewScope();
415 416
    }
    CreateVariables(ctx->prog_, local_scope, ctx->block_id_);
L
Liu Yiqun 已提交
417
  }
Y
Yu Yang 已提交
418

S
sneaxiy 已提交
419 420
  int64_t max_memory_size = GetEagerDeletionThreshold();
  std::unique_ptr<GarbageCollector<Tensor>> gc;
S
fix bug  
sneaxiy 已提交
421
  if (max_memory_size >= 0) {
S
sneaxiy 已提交
422
    ctx->ResetReferenceCount();
S
sneaxiy 已提交
423 424
#ifdef PADDLE_WITH_CUDA
    if (platform::is_gpu_place(place_)) {
S
fix bug  
sneaxiy 已提交
425 426 427 428 429 430 431 432
      if (IsFastEagerDeletionModeEnabled()) {
        gc.reset(new UnsafeFastGPUGarbageCollector<Tensor>(
            boost::get<platform::CUDAPlace>(place_), max_memory_size));
      } else {
        gc.reset(new DefaultStreamGarbageCollector<Tensor>(
            boost::get<platform::CUDAPlace>(place_), max_memory_size));
      }
    } else if (platform::is_cpu_place(place_)) {
S
sneaxiy 已提交
433 434 435 436 437 438 439 440
#endif
      gc.reset(new CPUGarbageCollector<Tensor>(
          boost::get<platform::CPUPlace>(place_), max_memory_size));
#ifdef PADDLE_WITH_CUDA
    }
#endif
  }

Y
Yu Yang 已提交
441
  for (auto& op : ctx->ops_) {
442
    op->Run(*local_scope, place_);
S
sneaxiy 已提交
443

S
fix bug  
sneaxiy 已提交
444
    if (gc) {
S
sneaxiy 已提交
445 446
      DeleteUnusedTensors(*local_scope, op.get(), gc.get(),
                          &(ctx->cur_ref_cnts_));
S
sneaxiy 已提交
447
    }
Y
Yu Yang 已提交
448
  }
S
sneaxiy 已提交
449

S
fix bug  
sneaxiy 已提交
450 451
  platform::DeviceContextPool::Instance().Get(place_)->Wait();
  if (gc) gc->Wait();
S
sneaxiy 已提交
452

Q
qiaolongfei 已提交
453
  if (local_scope != scope) {
Y
Yu Yang 已提交
454
    scope->DeleteScope(local_scope);
455
  } else {
Q
qiaolongfei 已提交
456 457 458 459 460
    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 已提交
461 462
      // 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 已提交
463 464
      scope->DropKids();
    }
Y
Yu Yang 已提交
465 466 467
  }
}

468 469
void Executor::RunPreparedContext(
    ExecutorPrepareContext* ctx, Scope* scope,
470
    std::map<std::string, const LoDTensor*>* feed_targets,
W
Wu Yi 已提交
471 472 473
    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) {
474 475
  auto& global_block = ctx->prog_.Block(ctx->block_id_);

476
  PADDLE_ENFORCE(
477
      has_feed_operators(global_block, *feed_targets, feed_holder_name),
478 479
      "Program in ExecutorPrepareContext should has feed_ops.");
  PADDLE_ENFORCE(
480
      has_fetch_operators(global_block, *fetch_targets, fetch_holder_name),
481 482
      "Program in the prepared context should has fetch_ops.");

483 484 485 486 487
  // 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"));
488 489
      SetFeedVariable(scope, *(*feed_targets)[feed_target_name],
                      feed_holder_name, idx);
490 491 492
    }
  }

W
Wu Yi 已提交
493
  RunPreparedContext(ctx, scope, create_local_scope, create_vars);
494 495 496 497 498 499

  // 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"));
500
      *(*fetch_targets)[fetch_target_name] =
501 502 503 504 505
          GetFetchVariable(*scope, fetch_holder_name, idx);
    }
  }
}

506 507
void Executor::EnableMKLDNN(const ProgramDesc& program) {
#ifdef PADDLE_WITH_MKLDNN
M
minqiyang 已提交
508
  VLOG(3) << "use_mkldnn=True";
509 510 511 512 513 514 515 516
  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);
      }
    }
  }
517 518 519
#else
  LOG(WARNING)
      << "'MKLDNN' is not supported, Please re-compile with WITH_MKLDNN option";
520 521
#endif
}
Q
qijun 已提交
522 523
}  // namespace framework
}  // namespace paddle