operator.cc 55.6 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
Q
Qiao Longfei 已提交
2 3 4 5 6 7 8 9 10 11 12 13

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. */
D
dzhwinter 已提交
14

15 16
#include "paddle/fluid/framework/operator.h"

17 18
#include <gflags/gflags.h>
#include <glog/logging.h>
19

20
#include <algorithm>
P
peizhilin 已提交
21 22
#include <sstream>
#include <string>
S
sneaxiy 已提交
23
#include <unordered_set>
P
peizhilin 已提交
24
#include <vector>
25

Y
Yi Wang 已提交
26
#include "paddle/fluid/framework/data_transform.h"
W
WangXi 已提交
27
#include "paddle/fluid/framework/details/nan_inf_utils.h"
Y
Yi Wang 已提交
28
#include "paddle/fluid/framework/executor.h"
29
#include "paddle/fluid/framework/lod_tensor.h"
30
#include "paddle/fluid/framework/op_call_stack.h"
31
#include "paddle/fluid/framework/op_proto_maker.h"
Y
Yi Wang 已提交
32
#include "paddle/fluid/framework/shape_inference.h"
33
#include "paddle/fluid/framework/transfer_scope_cache.h"
34
#include "paddle/fluid/framework/unused_var_check.h"
Y
Yi Wang 已提交
35
#include "paddle/fluid/framework/var_type.h"
36
#include "paddle/fluid/platform/profiler.h"
37 38 39
#ifdef PADDLE_WITH_XPU
#include "paddle/fluid/platform/xpu_info.h"
#endif
Q
Qiao Longfei 已提交
40

41 42 43 44
#ifdef PADDLE_WITH_MKLDNN
#include "paddle/fluid/platform/mkldnn_helper.h"
#endif

D
dzhwinter 已提交
45
DECLARE_bool(benchmark);
46
DECLARE_bool(check_nan_inf);
47
DECLARE_bool(enable_unused_var_check);
Q
Qiao Longfei 已提交
48
DEFINE_int32(inner_op_parallelism, 0, "number of threads for inner op");
P
pkpk 已提交
49 50 51
DEFINE_bool(fast_check_nan_inf, false,
            "Fast checking NAN/INF after each operation. It will be a little"
            "bit slow, much faster than check_nan_inf");
D
dzhwinter 已提交
52

Q
Qiao Longfei 已提交
53 54 55
namespace paddle {
namespace framework {

56 57 58 59 60 61
std::vector<std::tuple<platform::Place, LibraryType>> kKernelPriority = {
    std::make_tuple(platform::CUDAPlace(0), LibraryType::kCUDNN),
    std::make_tuple(platform::CUDAPlace(0), LibraryType::kPlain),
    std::make_tuple(platform::CPUPlace(), LibraryType::kMKLDNN),
    std::make_tuple(platform::CPUPlace(), LibraryType::kPlain),
};
D
dzhwinter 已提交
62

63 64
static DDim GetDimsDebug(const Scope& scope, const std::string& name,
                         bool get_actual_dim = false) {
65
  Variable* var = scope.FindVar(name);
Q
qiaolongfei 已提交
66 67
  if (var == nullptr) {
    return DDim({-1});
Q
Qiao Longfei 已提交
68 69
  }

M
minqiyang 已提交
70 71 72 73 74 75 76 77 78
  if (var->IsType<LoDTensor>()) {
    const LoDTensor& tensor = var->Get<LoDTensor>();
    return tensor.dims();
  } else if (var->IsType<SelectedRows>()) {
    if (get_actual_dim) {
      return var->Get<SelectedRows>().value().dims();
    } else {
      return var->Get<SelectedRows>().GetCompleteDims();
    }
79 80 81 82 83
  } else {
    return DDim({-1});
  }
}

Q
Qiao Longfei 已提交
84 85 86 87 88 89
static bool VarInited(const Scope& scope, const std::string& name) {
  Variable* var = scope.FindVar(name);
  if (var == nullptr) return false;
  return var->IsInitialized();
}

D
dzhwinter 已提交
90 91 92 93 94
static std::string GetDtype(const Scope& scope, const std::string& name) {
  Variable* var = scope.FindVar(name);
  if (var == nullptr) {
    return "";
  }
95

M
minqiyang 已提交
96 97 98
  if (var->IsType<LoDTensor>()) {
    const LoDTensor& tensor = var->Get<LoDTensor>();
    if (UNLIKELY(!tensor.IsInitialized())) {
99 100
      return "";
    }
Y
Yu Yang 已提交
101
    return DataTypeToString(tensor.type());
M
minqiyang 已提交
102
  } else if (var->IsType<SelectedRows>()) {
Q
Qiao Longfei 已提交
103 104 105 106
    auto tensor = var->Get<SelectedRows>().value();
    if (UNLIKELY(!tensor.IsInitialized())) {
      return "uninited";
    } else {
Y
Yu Yang 已提交
107
      return DataTypeToString(tensor.type());
Q
Qiao Longfei 已提交
108
    }
D
dzhwinter 已提交
109 110 111 112 113
  } else {
    return "";
  }
}

114 115 116 117 118 119
static int GetRowSize(const Scope& scope, const std::string& name) {
  Variable* var = scope.FindVar(name);
  if (var == nullptr) {
    return -1;
  }

M
minqiyang 已提交
120 121
  if (var->IsType<SelectedRows>()) {
    return var->Get<SelectedRows>().rows().size();
122 123 124 125 126
  }

  return -1;
}

127
static LoD GetLoDDebug(const Scope& scope, const std::string& name) {
Q
Qiao Longfei 已提交
128 129 130 131 132 133 134
  Variable* var = scope.FindVar(name);
  auto default_lod = LoD({{}});

  if (var == nullptr) {
    return default_lod;
  }

M
minqiyang 已提交
135 136 137
  if (var->IsType<LoDTensor>()) {
    const LoDTensor& tensor = var->Get<LoDTensor>();
    return tensor.lod();
Q
Qiao Longfei 已提交
138 139 140 141 142
  } else {
    return default_lod;
  }
}

X
Xin Pan 已提交
143 144 145 146 147
RuntimeContext::RuntimeContext(const VariableNameMap& innames,
                               const VariableNameMap& outnames,
                               const Scope& scope) {
  for (auto& var_name_item : innames) {
    std::vector<Variable*>& input_vars = inputs[var_name_item.first];
X
Xin Pan 已提交
148
    input_vars.reserve(var_name_item.second.size());
X
Xin Pan 已提交
149 150 151 152 153 154
    for (auto& var_name : var_name_item.second) {
      input_vars.push_back(scope.FindVar(var_name));
    }
  }
  for (auto& var_name_item : outnames) {
    std::vector<Variable*>& output_vars = outputs[var_name_item.first];
X
Xin Pan 已提交
155
    output_vars.reserve(var_name_item.second.size());
X
Xin Pan 已提交
156 157 158 159 160 161
    for (auto& var_name : var_name_item.second) {
      output_vars.push_back(scope.FindVar(var_name));
    }
  }
}

162
void OperatorBase::Run(const Scope& scope, const platform::Place& place) {
P
peizhilin 已提交
163 164 165
  try {
    VLOG(4) << place << " " << DebugStringEx(&scope);
    if (platform::is_gpu_place(place)) {
166
#ifndef PADDLE_WITH_CUDA
167 168 169 170
      PADDLE_THROW(platform::errors::Unavailable(
          "Cannot run operator on place %s, please recompile paddle or "
          "reinstall Paddle with CUDA support.",
          place));
171
#else
172
      auto dev_id = BOOST_GET_CONST(platform::CUDAPlace, place).device;
P
peizhilin 已提交
173
      platform::SetDeviceId(dev_id);
174 175 176
#endif
    } else if (platform::is_xpu_place(place)) {
#ifndef PADDLE_WITH_XPU
177 178 179 180
      PADDLE_THROW(platform::errors::Unavailable(
          "Cannot run operator on place %s, please recompile paddle or "
          "reinstall Paddle with XPU support.",
          place));
181 182 183
#else
      auto dev_id = BOOST_GET_CONST(platform::XPUPlace, place).device;
      platform::SetXPUDeviceId(dev_id);
184
#endif
P
peizhilin 已提交
185
    }
P
peizhilin 已提交
186

187
    {
188 189 190 191 192 193
      // TODO(wangchaochaohu) : refine code to use only one RecordEvent)
      // in order to record different op type cost time
      // and different op name cost time,we set two event.
      platform::RecordEvent op_type_record_event(Type());
      auto op_name = platform::OpName(outputs_, Type());
      platform::RecordEvent op_name_record_event(
194
          op_name, platform::EventRole::kUniqueOp);
P
peizhilin 已提交
195 196
      RunImpl(scope, place);
    }
197

Z
Zhang Ting 已提交
198
    VLOG(3) << GetExecutionPlace(place) << " " << DebugStringEx(&scope);
199
  } catch (platform::EnforceNotMet& exception) {
200
    framework::InsertCallStackInfo(Type(), Attrs(), &exception);
201
    throw std::move(exception);
202 203 204 205 206 207
  } catch (platform::EOFException&) {
    std::rethrow_exception(std::current_exception());
  } catch (std::exception& ex) {
    LOG(WARNING) << Type() << " raises an exception "
                 << platform::demangle(typeid(ex).name()) << ", " << ex.what();
    std::rethrow_exception(std::current_exception());
P
peizhilin 已提交
208
  } catch (...) {
209
    LOG(WARNING) << Type() << " raises an unknown exception";
P
peizhilin 已提交
210
    std::rethrow_exception(std::current_exception());
211
  }
212 213
}

214
bool OperatorBase::HasInputs(const std::string& name) const {
M
minqiyang 已提交
215
  return inputs_.find(name) != inputs_.end();
216 217
}

218
std::string OperatorBase::Input(const std::string& name) const {
Y
Yu Yang 已提交
219
  auto& ins = Inputs(name);
220 221
  PADDLE_ENFORCE_LE(
      ins.size(), 1UL,
222
      platform::errors::InvalidArgument(
223 224
          "Operator %s's input %s should contain only one variable.", type_,
          name));
Y
Yu Yang 已提交
225
  return ins.empty() ? kEmptyVarName : ins[0];
Y
Yan Chunwei 已提交
226 227
}

Y
Yu Yang 已提交
228 229
const std::vector<std::string>& OperatorBase::Inputs(
    const std::string& name) const {
Y
Yu Yang 已提交
230
  auto it = inputs_.find(name);
231 232 233 234
  PADDLE_ENFORCE_NE(
      it, inputs_.end(),
      platform::errors::NotFound("Operator %s does not have the input %s.",
                                 type_, name));
Y
Yu Yang 已提交
235
  return it->second;
Y
Yan Chunwei 已提交
236 237
}

238
bool OperatorBase::HasOutputs(const std::string& name) const {
239
  if (outputs_.find(name) != outputs_.end()) {
240 241 242 243 244 245
    return true;
  } else {
    return false;
  }
}

246
std::string OperatorBase::Output(const std::string& name) const {
Y
Yu Yang 已提交
247
  auto& outs = Outputs(name);
248 249 250 251 252
  PADDLE_ENFORCE_LE(
      outs.size(), 1UL,
      platform::errors::InvalidArgument(
          "Operator %s's output %s should contain only one variable.", type_,
          name));
Y
Yu Yang 已提交
253
  return outs.empty() ? kEmptyVarName : outs[0];
Y
Yan Chunwei 已提交
254 255
}

Y
Yu Yang 已提交
256 257
const std::vector<std::string>& OperatorBase::Outputs(
    const std::string& name) const {
Y
Yu Yang 已提交
258
  auto it = outputs_.find(name);
259 260 261 262
  PADDLE_ENFORCE_NE(
      it, outputs_.end(),
      platform::errors::NotFound(
          "Operator %s does not have an output called %s.", type_, name));
Y
Yu Yang 已提交
263
  return it->second;
Y
Yan Chunwei 已提交
264 265
}

266
std::string OperatorBase::DebugStringEx(const Scope* scope) const {
Q
Qiao Longfei 已提交
267
  std::stringstream ss;
Y
Yu Yang 已提交
268
  ss << "Op(" << type_ << "), inputs:{";
269

270
  const std::unordered_set<std::string>* no_need_buffer_vars = nullptr;
271 272
  if (info_ && info_->NoNeedBufferVarsInferer()) {
    no_need_buffer_vars =
273 274
        &(Info().NoNeedBufferVarsInferer()(Inputs(), Outputs(), Attrs()));
    if (no_need_buffer_vars->empty()) no_need_buffer_vars = nullptr;
275 276
  }

Y
Yu Yang 已提交
277 278
  for (auto it = inputs_.begin(); it != inputs_.end();) {
    auto& input = *it;
279 280
    bool is_no_need_buffer_var =
        (no_need_buffer_vars && no_need_buffer_vars->count(input.first) > 0);
Y
Yu Yang 已提交
281 282
    ss << input.first << "[";
    for (size_t i = 0; i < input.second.size(); ++i) {
Q
Qiao Longfei 已提交
283 284
      auto var_name = input.second[i];
      ss << var_name;
285
      if (scope) {
Q
Qiao Longfei 已提交
286 287 288 289 290 291 292
        if (!VarInited(*scope, var_name)) {
          ss << "[uninited]";
        } else {
          int row_size = GetRowSize(*scope, var_name);
          if (row_size >= 0) {
            ss << "[row_size=" << row_size << "]";
          }
293 294 295
          std::string dtype = is_no_need_buffer_var
                                  ? "unknown_dtype"
                                  : GetDtype(*scope, var_name);
Q
Qiao Longfei 已提交
296
          ss << ":" << dtype;
297 298
          ss << "[" << GetDimsDebug(*scope, var_name, true) << "]";
          ss << "(" << GetLoDDebug(*scope, var_name) << ")";
299
        }
300
      }
Y
Yu Yang 已提交
301 302 303
      if (i != input.second.size() - 1) {
        ss << ", ";
      }
304
    }
Y
Yu Yang 已提交
305
    ss << "]";
Y
Yu Yang 已提交
306 307
    ++it;
    if (it != inputs_.end()) {
308 309
      ss << ", ";
    }
Q
Qiao Longfei 已提交
310
  }
Y
Yu Yang 已提交
311
  ss << "}, outputs:{";
Y
Yu Yang 已提交
312 313
  for (auto it = outputs_.begin(); it != outputs_.end();) {
    auto& output = *it;
Y
Yu Yang 已提交
314 315
    ss << output.first << "[";
    for (size_t i = 0; i < output.second.size(); ++i) {
Q
Qiao Longfei 已提交
316 317
      auto var_name = output.second[i];
      ss << var_name;
318
      if (scope) {
Q
Qiao Longfei 已提交
319 320 321 322 323 324 325
        if (!VarInited(*scope, var_name)) {
          ss << "[uninited]";
        } else {
          int row_size = GetRowSize(*scope, output.second[i]);
          if (row_size >= 0) {
            ss << "[row_size=" << row_size << "]";
          }
C
chengduo 已提交
326 327
          std::string dtype = GetDtype(*scope, output.second[i]);
          ss << ":" << dtype;
328 329
          ss << "[" << GetDimsDebug(*scope, var_name, true) << "]";
          ss << "(" << GetLoDDebug(*scope, var_name) << ")";
330
        }
331
      }
Y
Yu Yang 已提交
332 333 334
      if (i != output.second.size() - 1) {
        ss << ", ";
      }
335
    }
Y
Yu Yang 已提交
336
    ss << "]";
Y
Yu Yang 已提交
337 338
    ++it;
    if (it != outputs_.end()) {
339 340
      ss << ", ";
    }
Q
Qiao Longfei 已提交
341
  }
Y
Yu Yang 已提交
342
  ss << "}.";
Q
Qiao Longfei 已提交
343 344 345
  return ss.str();
}

Y
Yu Yang 已提交
346
OperatorBase::OperatorBase(const std::string& type,
Y
Yu Yang 已提交
347 348
                           const VariableNameMap& inputs,
                           const VariableNameMap& outputs,
Y
Yu Yang 已提交
349
                           const AttributeMap& attrs)
S
sneaxiy 已提交
350 351 352 353 354 355
    : type_(type),
      inputs_(inputs),
      outputs_(outputs),
      attrs_(attrs),
      // NOTE(zjl): why op_info may be nullptr?
      info_(OpInfoMap::Instance().GetNullable(type)) {
H
hong 已提交
356 357 358 359 360 361 362 363
  // In dygraph mode, all the OperatorBase will be constructed by function:
  // framework::OpRegistry::CreateOp(type, {}, {}, {}, false).
  // Inputs, outputs and attrs will be set to empty map
  // to improve the execution efficiency of dygraph.
  if (inputs_.size() > 0 || outputs_.size() > 0) {
    GenerateTemporaryNames();
    CheckAllInputOutputSet();
  }
Y
Yu Yang 已提交
364
}
365

Q
qijun 已提交
366 367
std::vector<std::string> OperatorBase::InputVars() const {
  std::vector<std::string> ret_val;
Y
Yu Yang 已提交
368
  for (auto& o : inputs_) {
Q
qijun 已提交
369 370 371 372 373 374
    ret_val.reserve(ret_val.size() + o.second.size());
    ret_val.insert(ret_val.end(), o.second.begin(), o.second.end());
  }
  return ret_val;
}

Y
Yu Yang 已提交
375 376 377 378 379 380 381 382 383 384
std::vector<std::string> OperatorBase::OutputVars(bool has_intermediate) const {
  std::vector<std::string> ret_val;
  if (has_intermediate) {
    // push all outputs into ret_val
    for (auto& o : outputs_) {
      ret_val.reserve(ret_val.size() + o.second.size());
      ret_val.insert(ret_val.end(), o.second.begin(), o.second.end());
    }
    return ret_val;
  }
S
sneaxiy 已提交
385
  auto& info = Info();
Y
Yu Yang 已提交
386 387

  // get all OpProto::Var for outputs
Y
Yu Yang 已提交
388
  for (auto& o : info.Proto().outputs()) {
Y
Yu Yang 已提交
389 390 391 392 393 394 395 396 397
    // ignore all intermediate output
    if (o.intermediate()) continue;
    auto out = outputs_.find(o.name());
    if (out != outputs_.end()) {
      ret_val.reserve(ret_val.size() + out->second.size());
      ret_val.insert(ret_val.end(), out->second.begin(), out->second.end());
    }
  }
  return ret_val;
D
dongzhihong 已提交
398 399
}

400
void OperatorBase::CheckAllInputOutputSet() const {
S
sneaxiy 已提交
401
  if (info_ == nullptr || info_->proto_ == nullptr) return;
402

S
sneaxiy 已提交
403
  for (auto& in : info_->Proto().inputs()) {
404
    if (!in.dispensable()) {
405 406 407 408
      PADDLE_ENFORCE_NE(
          inputs_.find(in.name()), inputs_.end(),
          platform::errors::NotFound("Operator %s's input (%s) is not set.",
                                     Type(), in.name()));
409
    }
410 411
  }

S
sneaxiy 已提交
412
  for (auto& out : info_->Proto().outputs()) {
413
    if (!out.dispensable()) {
414 415 416 417
      PADDLE_ENFORCE_NE(
          outputs_.find(out.name()), outputs_.end(),
          platform::errors::NotFound("Operator %s's output (%s) is not set.",
                                     Type(), out.name()));
418
    }
419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
  }
}

void OperatorBase::GenerateTemporaryNames() {
  static std::atomic<size_t> gUniqId(0UL);
  for (auto& output : outputs_) {
    for (auto& output_name : output.second) {
      if (output_name == kTempVarName) {
        output_name += type_;
        output_name += "@";
        output_name += std::to_string(gUniqId.fetch_add(1));
      }
    }
  }
}

B
baojun-nervana 已提交
435
static bool VarIsTensor(const Variable& var) {
C
chengduo 已提交
436
  return var.IsType<LoDTensor>() || var.IsType<SelectedRows>();
437 438
}

C
chengduo 已提交
439
const Tensor* GetLoDTensorOrSelectedRowsValueFromVar(const Variable& var) {
C
chengduo 已提交
440 441 442 443
  if (var.IsType<LoDTensor>()) {
    return static_cast<const Tensor*>(&(var.Get<LoDTensor>()));
  } else if (var.IsType<SelectedRows>()) {
    return &(var.Get<SelectedRows>().value());
Q
QI JUN 已提交
444
  } else {
445 446 447
    PADDLE_THROW(platform::errors::InvalidArgument(
        "Variable type is %s, expect LoDTensor or SelectedRows.",
        ToTypeName(var.Type())));
Q
QI JUN 已提交
448 449 450
  }
}

C
chengduo 已提交
451
Tensor* GetMutableLoDTensorOrSelectedRowsValueFromVar(Variable* var) {
Q
QI JUN 已提交
452
  if (var->IsType<LoDTensor>()) {
453
    return var->GetMutable<LoDTensor>();
Q
QI JUN 已提交
454
  } else if (var->IsType<SelectedRows>()) {
455
    return var->GetMutable<SelectedRows>()->mutable_value();
Q
QI JUN 已提交
456
  } else {
457 458 459
    PADDLE_THROW(platform::errors::InvalidArgument(
        "Variable type is %s, expect LoDTensor or SelectedRows.",
        ToTypeName(var->Type())));
Q
QI JUN 已提交
460 461 462
  }
}

463
bool ExecutionContext::HasInput(const std::string& name) const {
464
  auto* var = InputVar(name);
465 466 467 468
  return var != nullptr;
}

bool ExecutionContext::HasOutput(const std::string& name) const {
469
  auto* var = OutputVar(name);
470 471 472
  return var != nullptr;
}

X
Xin Pan 已提交
473
const Variable* ExecutionContext::InputVar(const std::string& name) const {
474 475
  LogVarUsageIfUnusedVarCheckEnabled(name);

X
Xin Pan 已提交
476 477 478
  auto it = ctx_.inputs.find(name);
  if (it == ctx_.inputs.end()) return nullptr;

479 480
  PADDLE_ENFORCE_LE(
      it->second.size(), 1UL,
481
      platform::errors::InvalidArgument(
482 483
          "Operator %s's input %s should contain only one variable.",
          op_.Type(), name));
X
Xin Pan 已提交
484 485 486
  return it->second.empty() ? nullptr : it->second[0];
}

X
clean  
Xin Pan 已提交
487
Variable* ExecutionContext::OutputVar(const std::string& name) const {
X
Xin Pan 已提交
488 489 490
  auto it = ctx_.outputs.find(name);
  if (it == ctx_.outputs.end()) return nullptr;

491 492 493 494 495
  PADDLE_ENFORCE_LE(
      it->second.size(), 1UL,
      platform::errors::InvalidArgument(
          "Operator %s's output %s should contain only one variable.",
          op_.Type(), name));
X
Xin Pan 已提交
496 497 498
  return it->second.empty() ? nullptr : it->second[0];
}

499
template <>
500
const Tensor* ExecutionContext::Input<Tensor>(const std::string& name) const {
C
chengduo 已提交
501
  return Input<LoDTensor>(name);
502 503 504
}

template <>
505
const std::vector<const Tensor*> ExecutionContext::MultiInput<Tensor>(
506
    const std::string& name) const {
507 508
  LogVarUsageIfUnusedVarCheckEnabled(name);

H
hong 已提交
509 510
  auto vars = MultiInputVar(name);
  if (vars.size() == 0) {
X
Xin Pan 已提交
511 512 513 514 515
    return {};
  }
  std::vector<const Tensor*> res;
  res.reserve(vars.size());
  std::transform(vars.begin(), vars.end(), std::back_inserter(res),
H
hong 已提交
516
                 [&](const Variable* var) -> const Tensor* {
X
Xin Pan 已提交
517
                   if (var == nullptr) return nullptr;
518 519 520 521 522
                   PADDLE_ENFORCE_EQ(var->IsType<LoDTensor>(), true,
                                     platform::errors::InvalidArgument(
                                         "Input variable should be LoDTensor, "
                                         "but the received type is %s.",
                                         ToTypeName(var->Type())));
X
Xin Pan 已提交
523 524 525 526 527
                   return &(var->Get<LoDTensor>());
                 });
  return res;
}

528
template <>
529
Tensor* ExecutionContext::Output<Tensor>(const std::string& name) const {
C
chengduo 已提交
530
  return Output<LoDTensor>(name);
531 532 533
}

template <>
534
std::vector<Tensor*> ExecutionContext::MultiOutput<Tensor>(
535
    const std::string& name) const {
H
hong 已提交
536 537 538
  auto vars = MultiOutputVar(name);

  if (vars.size() == 0) {
539 540
    return {};
  }
541
  std::vector<Tensor*> res;
542 543 544 545 546
  res.reserve(vars.size());
  std::transform(vars.begin(), vars.end(), std::back_inserter(res),
                 [&](Variable* var) -> Tensor* {
                   return var == nullptr ? nullptr
                                         : var->GetMutable<LoDTensor>();
547
                 });
548 549 550
  return res;
}

Y
Yu Yang 已提交
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
bool OpSupportGPU(const std::string& op_type) {
  auto& all_kernels = OperatorWithKernel::AllOpKernels();
  auto it = all_kernels.find(op_type);
  if (it == all_kernels.end()) {
    // All control operator must support GPU
    return true;
  }
  for (auto& kern_pair : it->second) {
    if (platform::is_gpu_place(kern_pair.first.place_)) {
      return true;
    }
  }
  return false;
}

566 567
class RuntimeInferShapeContext : public InferShapeContext {
 public:
568
  RuntimeInferShapeContext(const OperatorBase& op, const RuntimeContext& ctx)
G
Gabor Buella 已提交
569
      : op_(op), ctx_(ctx) {}
570 571

  bool HasInput(const std::string& name) const override {
572
    // has only one input
X
Xin Pan 已提交
573
    const auto& ins = ctx_.inputs;
574 575
    auto it = ins.find(name);
    if (it == ins.end()) {
576 577
      return false;
    }
578
    const auto& in = it->second;
X
Xin Pan 已提交
579
    if (in.size() == 0) return false;
580 581 582 583
    PADDLE_ENFORCE_EQ(
        in.size(), 1UL,
        platform::errors::InvalidArgument(
            "Input %s should not contain more than one inputs.", name));
X
Xin Pan 已提交
584
    return in[0] != nullptr;
585 586 587
  }

  bool HasOutput(const std::string& name) const override {
588
    // has only one output
X
Xin Pan 已提交
589
    const auto& outs = ctx_.outputs;
590 591
    auto it = outs.find(name);
    if (it == outs.end()) {
592 593
      return false;
    }
594
    const auto& out = it->second;
X
Xin Pan 已提交
595
    if (out.size() == 0) {
596 597
      return false;
    }
598 599 600 601
    PADDLE_ENFORCE_EQ(
        out.size(), 1UL,
        platform::errors::InvalidArgument(
            "Output %s should not contain more than one outputs.", name));
X
Xin Pan 已提交
602
    return out[0] != nullptr;
603 604 605
  }

  bool HasInputs(const std::string& name) const override {
X
Xin Pan 已提交
606 607
    const auto& ins = ctx_.inputs;
    auto it = ins.find(name);
X
fix  
Xin Pan 已提交
608
    if (it == ins.end() || it->second.empty()) {
609 610
      return false;
    }
X
Xin Pan 已提交
611 612
    for (auto& input : it->second) {
      if (input == nullptr) {
613 614 615 616 617 618 619
        return false;
      }
    }
    return true;
  }

  bool HasOutputs(const std::string& name) const override {
X
Xin Pan 已提交
620 621
    const auto& outs = ctx_.outputs;
    auto it = outs.find(name);
X
fix  
Xin Pan 已提交
622
    if (it == outs.end() || it->second.empty()) {
623 624
      return false;
    }
X
Xin Pan 已提交
625 626
    for (auto& output : it->second) {
      if (output == nullptr) {
627 628 629 630 631 632 633 634
        return false;
      }
    }
    return true;
  }

  AttrReader Attrs() const override { return AttrReader(op_.Attrs()); }

H
hong 已提交
635
  std::vector<std::string> Inputs(const std::string& name) const override {
636 637 638
    return op_.Inputs(name);
  }

H
hong 已提交
639
  std::vector<std::string> Outputs(const std::string& name) const override {
640 641 642
    return op_.Outputs(name);
  }

643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665
  std::string GetInputNameByIdx(size_t idx) const override {
    auto& op_proto =
        paddle::framework::OpInfoMap::Instance().Get(op_.Type()).proto_;
    PADDLE_ENFORCE_LT(idx, op_proto->inputs().size(),
                      platform::errors::OutOfRange(
                          "The index should be less than the size of inputs of "
                          "operator %s, but got index is %d and size is %d",
                          op_.Type(), idx, op_proto->inputs().size()));
    return op_proto->inputs()[idx].name();
  }

  std::string GetOutputNameByIdx(size_t idx) const override {
    auto& op_proto =
        paddle::framework::OpInfoMap::Instance().Get(op_.Type()).proto_;
    PADDLE_ENFORCE_LT(
        idx, op_proto->outputs().size(),
        platform::errors::OutOfRange(
            "The index should be less than the size of outputs of "
            "operator %s, but got index is %d and size is %d",
            op_.Type(), idx, op_proto->outputs().size()));
    return op_proto->outputs()[idx].name();
  }

666 667
  void ShareDim(const std::string& in, const std::string& out, size_t i = 0,
                size_t j = 0) override {
X
Xin Pan 已提交
668 669
    auto in_it = ctx_.inputs.find(in);
    auto out_it = ctx_.outputs.find(out);
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
    PADDLE_ENFORCE_NE(
        in_it, ctx_.inputs.end(),
        platform::errors::NotFound("Input %s does not exist.", in));
    PADDLE_ENFORCE_NE(
        out_it, ctx_.outputs.end(),
        platform::errors::NotFound("Output %s does not exist.", out));
    PADDLE_ENFORCE_LT(i, in_it->second.size(),
                      platform::errors::InvalidArgument(
                          "The index of input dimension is out of range, "
                          "excepted index less than %zu, but received %zu.",
                          in_it->second.size(), i));
    PADDLE_ENFORCE_LT(j, out_it->second.size(),
                      platform::errors::InvalidArgument(
                          "The index of output dimension is out of range, "
                          "excepted index less than %zu, but received %zu.",
                          out_it->second.size(), j));
X
Xin Pan 已提交
686 687 688

    Variable* in_var = in_it->second[i];
    Variable* out_var = out_it->second[j];
689

690 691 692 693 694
    PADDLE_ENFORCE_EQ(
        in_var->Type(), out_var->Type(),
        platform::errors::InvalidArgument(
            "The type of input (%s) and output (%s) are inconsistent.", in,
            out));
695 696 697 698 699 700 701 702 703 704 705 706

    if (in_var->IsType<framework::SelectedRows>()) {
      auto& in_sele_rows = in_var->Get<framework::SelectedRows>();
      auto out_sele_rows = out_var->GetMutable<framework::SelectedRows>();
      out_sele_rows->mutable_value()->Resize(in_sele_rows.value().dims());
      out_sele_rows->set_rows(in_sele_rows.rows());
      out_sele_rows->set_height(in_sele_rows.height());
    } else if (in_var->IsType<framework::LoDTensor>()) {
      auto& in_lod_tensor = in_var->Get<framework::LoDTensor>();
      auto* out_lod_tensor = out_var->GetMutable<framework::LoDTensor>();
      out_lod_tensor->Resize(in_lod_tensor.dims());
    } else {
707
      PADDLE_THROW(platform::errors::Unimplemented(
708
          "Currently, the input type of ShareDim only can be LoDTensor "
709
          "or SelectedRows."));
710 711 712
    }
  }

H
hong 已提交
713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730
  void ShareAllLoD(const std::string& in,
                   const std::string& out) const override {
    auto in_it = ctx_.inputs.find(in);
    auto out_it = ctx_.outputs.find(out);
    PADDLE_ENFORCE_NE(in_it, ctx_.inputs.end(),
                      platform::errors::NotFound(
                          "Input [%s] found error in Op [%s]", in, op_.Type()));
    PADDLE_ENFORCE_NE(
        out_it, ctx_.outputs.end(),
        platform::errors::NotFound("Output [%s] found error in Op [%s]", out,
                                   op_.Type()));

    auto& in_var_list = in_it->second;
    auto& out_var_list = out_it->second;

    PADDLE_ENFORCE_EQ(
        in_var_list.size(), out_var_list.size(),
        platform::errors::PreconditionNotMet(
T
tianshuo78520a 已提交
731
            "Op [%s]: Input var size should be equal with output var size",
H
hong 已提交
732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757
            op_.Type()));

    auto& out_var_names = op_.Outputs(out);

    for (size_t i = 0; i < in_var_list.size(); ++i) {
      if (out_var_names[i] == framework::kEmptyVarName) {
        continue;
      }

      Variable* in_var = in_var_list[i];
      if (!in_var->IsType<LoDTensor>()) return;
      Variable* out_var = out_var_list[i];
      PADDLE_ENFORCE_EQ(out_var->IsType<LoDTensor>(), true,
                        platform::errors::PreconditionNotMet(
                            "The %d-th output of Output(%s) must be LoDTensor.",
                            i, out_var_names[i]));
      auto& in_tensor = in_var->Get<LoDTensor>();
      auto* out_tensor = out_var->GetMutable<LoDTensor>();
      out_tensor->set_lod(in_tensor.lod());
#ifdef PADDLE_WITH_MKLDNN
      if (in_tensor.layout() != DataLayout::kMKLDNN)
#endif
        out_tensor->set_layout(in_tensor.layout());
    }
  }

Q
Qiao Longfei 已提交
758 759
  void ShareLoD(const std::string& in, const std::string& out, size_t i = 0,
                size_t j = 0) const override {
X
Xin Pan 已提交
760 761
    auto in_it = ctx_.inputs.find(in);
    auto out_it = ctx_.outputs.find(out);
762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777
    PADDLE_ENFORCE_NE(
        in_it, ctx_.inputs.end(),
        platform::errors::NotFound("Input %s does not exist.", in));
    PADDLE_ENFORCE_NE(
        out_it, ctx_.outputs.end(),
        platform::errors::NotFound("Output %s does not exist.", out));
    PADDLE_ENFORCE_LT(i, in_it->second.size(),
                      platform::errors::InvalidArgument(
                          "The index of input dimension is out of range, "
                          "excepted index less than %zu, but received %zu.",
                          in_it->second.size(), i));
    PADDLE_ENFORCE_LT(j, out_it->second.size(),
                      platform::errors::InvalidArgument(
                          "The index of output dimension is out of range, "
                          "excepted index less than %zu, but received %zu.",
                          out_it->second.size(), j));
X
Xin Pan 已提交
778 779

    Variable* in_var = in_it->second.at(i);
Q
Qiao Longfei 已提交
780
    if (!in_var->IsType<LoDTensor>()) return;
X
Xin Pan 已提交
781
    Variable* out_var = out_it->second.at(j);
782 783 784 785
    PADDLE_ENFORCE_EQ(
        out_var->IsType<LoDTensor>(), true,
        platform::errors::InvalidArgument(
            "The %zu-th output of Output(%s) must be LoDTensor.", j, out));
786
    auto& in_tensor = in_var->Get<LoDTensor>();
Q
Qiao Longfei 已提交
787 788
    auto* out_tensor = out_var->GetMutable<LoDTensor>();
    out_tensor->set_lod(in_tensor.lod());
D
dzhwinter 已提交
789

M
mozga-intel 已提交
790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
// TODO(dzhwinter) : reuse ShareLoD in most operators.
// Need to call ShareLayout explicitly in sequence related ops.
// Shall we have a better method to shared info between in/out Tensor?
#ifdef PADDLE_WITH_MKLDNN
    // Fix me: ugly workaround below
    // Correct solution:
    //    set_layout() should NOT be called here (i.e. ShareLoD). Instead,
    //    layout of output tensor should be set "manually" in Compute()
    //    of each OPKernel. The reason layout should NOT be shared between
    //    input and output "automatically" (now by InferShape()->ShareLoD())
    //    is that layout transform may occur after InferShape().
    // Workaround:
    //    Skip set_layout() when input layout is kMKLDNN
    //    This is to avoid kMKLDNN is populated wrongly into a non-MKLDNN
    //    OPKernel. In all MKLDNN OPkernel, set_layout(kMKLDNN) should be called
    //    in Compute()
    if (in_tensor.layout() != DataLayout::kMKLDNN)
#endif
      out_tensor->set_layout(in_tensor.layout());
D
dzhwinter 已提交
809 810
  }

811
  int32_t GetLoDLevel(const std::string& in, size_t i = 0) const override {
812
    PADDLE_THROW(platform::errors::PreconditionNotMet(
813
        "GetLoDLevel is only used in compile time. The calculation of "
814
        "output's actual lod is different among operators so that should be "
815
        "set in the runtime kernel."));
816 817
  }

818 819
  void SetLoDLevel(const std::string& out, int32_t lod_level,
                   size_t j = 0) const override {
820
    PADDLE_THROW(platform::errors::PreconditionNotMet(
821
        "SetLoDLevel is only used in compile time. The calculation of "
822
        "output's actual lod is different among operators so that should be "
823
        "set in the runtime kernel."));
C
chengduo 已提交
824 825
  }

826 827
  bool IsRuntime() const override { return true; }

828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846
  // TODO(paddle-dev): Can this be template?
  std::vector<InferShapeVarPtr> GetInputVarPtrs(
      const std::string& name) override {
    const std::vector<Variable*>& vars = InputVars(name);
    std::vector<InferShapeVarPtr> res;
    res.reserve(vars.size());
    res.insert(res.begin(), vars.begin(), vars.end());
    return res;
  }

  std::vector<InferShapeVarPtr> GetOutputVarPtrs(
      const std::string& name) override {
    const std::vector<Variable*>& vars = OutputVars(name);
    std::vector<InferShapeVarPtr> res;
    res.reserve(vars.size());
    res.insert(res.begin(), vars.begin(), vars.end());
    return res;
  }

X
Xin Pan 已提交
847 848
  DDim GetInputDim(const std::string& name) const override {
    const std::vector<Variable*>& vars = InputVars(name);
849 850 851 852 853
    PADDLE_ENFORCE_EQ(
        vars.size(), 1UL,
        platform::errors::InvalidArgument(
            "Input(%s) should hold one element, but now it holds %zu elements.",
            name, vars.size()));
X
Xin Pan 已提交
854 855 856 857 858 859 860 861
    return this->GetDim(vars[0]);
  }

  std::vector<DDim> GetInputsDim(const std::string& name) const override {
    const std::vector<Variable*>& vars = InputVars(name);
    return GetDims(vars);
  }

X
Xin Pan 已提交
862 863 864 865 866 867 868 869 870 871
  std::vector<proto::VarType::Type> GetInputsVarType(
      const std::string& name) const override {
    return GetVarTypes(InputVars(name));
  }

  std::vector<proto::VarType::Type> GetOutputsVarType(
      const std::string& name) const override {
    return GetVarTypes(OutputVars(name));
  }

X
Xin Pan 已提交
872 873
  void SetOutputDim(const std::string& name, const DDim& dim) override {
    auto& vars = OutputVars(name);
874 875 876 877 878
    PADDLE_ENFORCE_EQ(
        vars.size(), 1UL,
        platform::errors::InvalidArgument("Output(%s) should hold one element, "
                                          "but now it holds %zu elements.",
                                          name, vars.size()));
X
Xin Pan 已提交
879 880 881 882 883 884 885 886 887
    SetDim(vars[0], dim);
  }

  void SetOutputsDim(const std::string& name,
                     const std::vector<DDim>& dims) override {
    auto& vars = OutputVars(name);
    SetDims(vars, dims);
  }

888
 protected:
X
Xin Pan 已提交
889
  DDim GetDim(Variable* var) const {
890 891
    PADDLE_ENFORCE_NOT_NULL(
        var, platform::errors::InvalidArgument("Input variable is nullptr."));
892 893 894 895 896
    if (var->IsType<LoDTensor>()) {
      return var->Get<LoDTensor>().dims();
    } else if (var->IsType<SelectedRows>()) {
      return var->Get<SelectedRows>().GetCompleteDims();
    } else {
897 898 899 900
      PADDLE_THROW(platform::errors::InvalidArgument(
          "Only LoDTensor or SelectedRows support 'GetDim', but input "
          "Variable's type is %s.",
          ToTypeName(var->Type())));
F
fengjiayi 已提交
901 902 903
    }
  }

X
Xin Pan 已提交
904 905 906 907 908 909 910 911
  std::vector<DDim> GetDims(const std::vector<Variable*>& vars) const {
    std::vector<DDim> ret;
    ret.reserve(vars.size());
    std::transform(vars.begin(), vars.end(), std::back_inserter(ret),
                   [this](Variable* var) { return this->GetDim(var); });
    return ret;
  }

F
fengjiayi 已提交
912
  std::vector<DDim> GetRepeatedDims(const std::string& name) const override {
913 914
    PADDLE_THROW(platform::errors::PreconditionNotMet(
        "GetRepeatedDims method only ban be used in compile time."));
915 916
  }

X
Xin Pan 已提交
917
  void SetDim(Variable* var, const DDim& dim) {
918 919 920 921 922
    if (var->IsType<LoDTensor>()) {
      var->GetMutable<LoDTensor>()->Resize(dim);
    } else if (var->IsType<SelectedRows>()) {
      var->GetMutable<SelectedRows>()->set_height(dim[0]);
    } else {
923 924 925 926
      PADDLE_THROW(platform::errors::Unimplemented(
          "Variable type error, expect LoDTensor or SelectedRows, but received "
          "(%s).",
          ToTypeName(var->Type())));
X
Xin Pan 已提交
927 928 929 930 931 932
    }
  }

  void SetDims(const std::vector<Variable*>& vars,
               const std::vector<DDim>& dims) {
    size_t length = vars.size();
933 934 935 936 937 938
    PADDLE_ENFORCE_EQ(length, dims.size(),
                      platform::errors::InvalidArgument(
                          "The number of input variables do not match the "
                          "number of input dimensions, the number of variables "
                          "is %zu, the number of dimensions is %zu.",
                          length, dims.size()));
X
Xin Pan 已提交
939 940 941 942 943
    for (size_t i = 0; i < length; ++i) {
      if (vars[i] == nullptr) {
        continue;
      }
      SetDim(vars[i], dims[i]);
944 945 946
    }
  }

F
fengjiayi 已提交
947 948
  void SetRepeatedDims(const std::string& name,
                       const std::vector<DDim>& dims) override {
949 950
    PADDLE_THROW(platform::errors::PreconditionNotMet(
        "SetRepeatedDims method only can be used in compile time."));
F
fengjiayi 已提交
951 952
  }

X
Xin Pan 已提交
953 954 955 956 957 958 959 960 961 962 963
  std::vector<proto::VarType::Type> GetVarTypes(
      const std::vector<Variable*>& vars) const {
    std::vector<proto::VarType::Type> retv;
    retv.resize(vars.size());
    std::transform(vars.begin(), vars.end(), retv.begin(),
                   std::bind(std::mem_fn(&RuntimeInferShapeContext::GetVarType),
                             this, std::placeholders::_1));
    return retv;
  }

  proto::VarType::Type GetVarType(Variable* var) const {
964 965 966
    return ToVarType(var->Type());
  }

967 968 969
 private:
  const std::vector<Variable*>& InputVars(const std::string& name) const {
    auto it = ctx_.inputs.find(name);
970 971 972 973
    PADDLE_ENFORCE_NE(
        it, ctx_.inputs.end(),
        platform::errors::NotFound(
            "Operator (%s) does not have the input (%s).", op_.Type(), name));
974 975 976 977 978
    return it->second;
  }

  const std::vector<Variable*>& OutputVars(const std::string& name) const {
    auto it = ctx_.outputs.find(name);
979 980 981 982
    PADDLE_ENFORCE_NE(
        it, ctx_.outputs.end(),
        platform::errors::NotFound(
            "Operator (%s) does not have the outputs (%s).", op_.Type(), name));
983
    return it->second;
F
fengjiayi 已提交
984 985
  }

986
  const OperatorBase& op_;
X
Xin Pan 已提交
987
  const RuntimeContext& ctx_;
988 989
};

990 991
static void CheckTensorNANOrInf(const std::string& op_type,
                                const std::string& name,
C
chengduoZH 已提交
992 993 994 995
                                const framework::Tensor& tensor) {
  if (tensor.memory_size() == 0) {
    return;
  }
Y
Yu Yang 已提交
996 997
  if (tensor.type() != proto::VarType::FP32 &&
      tensor.type() != proto::VarType::FP64) {
C
chengduoZH 已提交
998 999
    return;
  }
1000 1001 1002 1003 1004 1005 1006 1007
  PADDLE_ENFORCE_NE(
      framework::TensorContainsInf(tensor), true,
      platform::errors::Fatal("Operator %s output Tensor %s contains Inf.",
                              op_type, name));
  PADDLE_ENFORCE_NE(
      framework::TensorContainsNAN(tensor), true,
      platform::errors::Fatal("Operator %s output Tensor %s contains NAN.",
                              op_type, name));
C
chengduoZH 已提交
1008 1009
}

1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
bool OperatorWithKernel::SupportsMKLDNN() const {
  auto& op_kernels = OperatorWithKernel::AllOpKernels().at(type_);
  return std::any_of(op_kernels.begin(), op_kernels.end(),
                     [](OpKernelMap::const_reference kern_pair) {
                       return platform::is_cpu_place(kern_pair.first.place_) &&
                              kern_pair.first.library_type_ ==
                                  LibraryType::kMKLDNN;
                     });
}

bool OperatorWithKernel::CanMKLDNNBeUsed(
    const framework::ExecutionContext& ctx) const {
  bool use_mkldnn_ctx =
      ctx.Attr<bool>("use_mkldnn") && platform::is_cpu_place(ctx.GetPlace());
  return use_mkldnn_ctx && this->SupportsMKLDNN();
}

B
baojun-nervana 已提交
1027
void OperatorWithKernel::RuntimeInferShape(const Scope& scope,
X
Xin Pan 已提交
1028 1029
                                           const platform::Place& place,
                                           const RuntimeContext& ctx) const {
1030
  RuntimeInferShapeContext infer_shape_ctx(*this, ctx);
B
baojun-nervana 已提交
1031 1032 1033
  this->InferShape(&infer_shape_ctx);
}

L
luotao1 已提交
1034 1035
void OperatorWithKernel::RunImpl(const Scope& scope,
                                 const platform::Place& place) const {
L
luotao1 已提交
1036 1037
  // To reduce the elapsed time of HasAttr, we use bool variable to record the
  // result of HasAttr.
1038 1039 1040
  if (!enable_cache_runtime_context_ && HasAttr(kEnableCacheRuntimeContext))
    enable_cache_runtime_context_ = true;
  if (!all_kernels_must_compute_runtime_shape_ &&
L
luotao1 已提交
1041
      HasAttr(kAllKernelsMustComputeRuntimeShape))
1042
    all_kernels_must_compute_runtime_shape_ = true;
1043
  const Scope* cur_scope = &scope;
1044
  if (!enable_cache_runtime_context_) {
L
luotao1 已提交
1045 1046
    RuntimeContext ctx(Inputs(), Outputs(), scope);
    RunImpl(scope, place, &ctx);
1047
    pre_scope_ = cur_scope;
L
luotao1 已提交
1048
  } else {
1049 1050 1051 1052 1053 1054
    if (runtime_ctx_.get() == nullptr || pre_scope_ != cur_scope) {
      std::lock_guard<std::mutex> lock(cache_update_mutex_);
      if (runtime_ctx_.get() == nullptr || pre_scope_ != cur_scope) {
        runtime_ctx_.reset(new RuntimeContext(Inputs(), Outputs(), scope));
        pre_scope_ = cur_scope;
      }
L
luotao1 已提交
1055 1056 1057 1058 1059 1060 1061 1062
    }
    RunImpl(scope, place, runtime_ctx_.get());
  }
}

void OperatorWithKernel::RunImpl(const Scope& scope,
                                 const platform::Place& place,
                                 RuntimeContext* runtime_ctx) const {
Y
Yu Yang 已提交
1063
  platform::DeviceContextPool& pool = platform::DeviceContextPool::Instance();
1064
  auto* dev_ctx = pool.Get(place);
1065

1066
  if (kernel_type_.get() == nullptr || kernel_func_.get() == nullptr) {
1067
    ChooseKernel(*runtime_ctx, scope, place);
1068 1069
  }

Y
yuyang18 已提交
1070 1071
  // do data transformScope &transfer_scope;
  std::vector<std::string> transfered_inplace_vars;
1072 1073
  Scope* transfer_scope = nullptr;
  {
1074
    platform::RecordEvent record_event("prepare_data",
1075
                                       platform::EventRole::kInnerOp);
1076 1077 1078 1079
    if (need_prepare_data_) {
      transfer_scope = PrepareData(scope, *kernel_type_,
                                   &transfered_inplace_vars, runtime_ctx);
    }
1080
  }
Y
yuyang18 已提交
1081 1082 1083 1084
  // exec scope is the scope that kernel actually executed on.
  const Scope& exec_scope =
      (transfer_scope == nullptr ? scope : *transfer_scope);

1085 1086
  if (!(kernel_type_->place_ == dev_ctx->GetPlace())) {
    dev_ctx = pool.Get(kernel_type_->place_);
1087
  }
Q
QI JUN 已提交
1088

1089
  if (!all_kernels_must_compute_runtime_shape_) {
1090
    platform::RecordEvent record_event("infer_shape",
1091
                                       platform::EventRole::kInnerOp);
1092
    RuntimeInferShapeContext infer_shape_ctx(*this, *runtime_ctx);
1093 1094
    this->InferShape(&infer_shape_ctx);
  }
1095 1096 1097 1098 1099

  if (FLAGS_enable_unused_var_check) {
    GetThreadLocalUsedVarNameSet()->clear();
  }

X
clean  
Xin Pan 已提交
1100 1101
  // TODO(panyx0718): ExecutionContext should only depend on RuntimeContext
  // not Scope. Imperative mode only pass inputs and get outputs.
1102
  {
1103
    platform::RecordEvent record_event("compute",
1104
                                       platform::EventRole::kInnerOp);
1105 1106
    (*kernel_func_)(
        ExecutionContext(*this, exec_scope, *dev_ctx, *runtime_ctx));
1107
  }
D
dzhwinter 已提交
1108

Y
yuyang18 已提交
1109
  if (!transfered_inplace_vars.empty()) {
T
tianshuo78520a 已提交
1110
    // there is inplace variable has been transferred.
Y
yuyang18 已提交
1111
    TransferInplaceVarsBack(scope, transfered_inplace_vars, *transfer_scope);
1112
  }
1113 1114 1115 1116 1117 1118 1119 1120
  if (FLAGS_enable_unused_var_check) {
    // skip op that uses mkldnn because it has different memory reuse strategy.
    // use attr here because some GradMakers (like ActivationGradOpMaker) add
    // input when use_mkldnn=true;
    if (!(HasAttr("use_mkldnn") && Attr<bool>("use_mkldnn"))) {
      CheckUnusedVar(*this, scope);
    }
  }
1121

D
dzhwinter 已提交
1122
  /*For profiling/benchmark only*/
D
dzhwinter 已提交
1123
  if (FLAGS_benchmark) {
Y
yuyang18 已提交
1124
    dev_ctx->Wait();
D
dzhwinter 已提交
1125
  }
C
chengduoZH 已提交
1126

P
pkpk 已提交
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
  if (FLAGS_fast_check_nan_inf) {
    for (auto& vname : OutputVars(true)) {
      // only check inserted vars,
      // please see executor.py for details of fast_check_nan_inf
      if (vname.rfind("debug_var") == 0) {
        VLOG(3) << "debugging nan/inf in var " << vname;

        auto* var = exec_scope.FindVar(vname);
        if (var == nullptr) continue;
        if (var->IsType<framework::LoDTensor>()) {
          CheckTensorNANOrInf(type_, vname, var->Get<framework::LoDTensor>());
        } else if (var->IsType<framework::SelectedRows>()) {
          CheckTensorNANOrInf(type_, vname,
                              var->Get<framework::SelectedRows>().value());
        }
      }
    }
  }

C
chengduoZH 已提交
1146
  if (FLAGS_check_nan_inf) {
W
WangXi 已提交
1147
    framework::details::CheckOpHasNanOrInf(*this, exec_scope, place);
C
chengduoZH 已提交
1148
  }
1149 1150 1151 1152 1153 1154 1155

  // To solve issue #15032, have a discussion with @Luotao for cpu inference,
  // do not cache transfer scope, hence in this case delete transfer scope
  // after run to avoid memory leak
  if (transfer_scope && !run_by_executor_ && !enable_cache_transfer_scope_) {
    scope.DeleteScope(transfer_scope);
  }
Q
Qiao Longfei 已提交
1156
}
X
Xin Pan 已提交
1157

L
Liu Yiqun 已提交
1158 1159 1160 1161 1162 1163 1164 1165 1166
void OperatorWithKernel::ChooseKernel(const RuntimeContext& ctx,
                                      const Scope& scope,
                                      const platform::Place& place) const {
  platform::DeviceContextPool& pool = platform::DeviceContextPool::Instance();
  auto* dev_ctx = pool.Get(place);

  // check if op[type] has kernel registered.
  auto& all_op_kernels = AllOpKernels();
  auto kernels_iter = all_op_kernels.find(type_);
1167 1168 1169 1170 1171
  PADDLE_ENFORCE_NE(
      kernels_iter, all_op_kernels.end(),
      platform::errors::Unavailable(
          "There are no kernels which are registered in the %s operator.",
          type_));
L
Liu Yiqun 已提交
1172 1173 1174 1175

  OpKernelMap& kernels = kernels_iter->second;

  auto expected_kernel_key = this->GetExpectedKernelType(
1176
      ExecutionContext(*this, scope, *dev_ctx, ctx));
1177 1178 1179
  if (HasAttr("op_device")) {
    if (Attr<std::string>("op_device") == "cpu") {
      expected_kernel_key.place_ = platform::CPUPlace();
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
    } else if (Attr<std::string>("op_device").find("gpu") !=
               std::string::npos) {
      auto device = Attr<std::string>("op_device");
      size_t pos = device.find(':');
      if (pos != std::string::npos) {
        device = device.substr(0, pos);
        LOG_FIRST_N(WARNING, 1)
            << "Device index is only supported under pipeline parallelism, "
            << "so it will be ignored.";
      }
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
      // when the Op that only has CPUKernel is assigned to GPU, the CPUKernel
      // will be executed and a warning will be given at the same time.
      if (SupportGPU()) {
        expected_kernel_key.place_ = dev_ctx->GetPlace();
      } else {
        expected_kernel_key.place_ = platform::CPUPlace();
        LOG_FIRST_N(WARNING, 1)
            << "Op(" << type_
            << ") has no CUDA implementation. It will be assigned to CPUPlace.";
      }
    }
  }
L
Liu Yiqun 已提交
1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
  VLOG(3) << "expected_kernel_key:" << expected_kernel_key;

  auto kernel_iter = kernels.find(expected_kernel_key);
#ifdef PADDLE_WITH_MKLDNN
  // workaround for missing MKLDNN kernel when FLAGS_use_mkldnn env var is set
  if (kernel_iter == kernels.end() &&
      expected_kernel_key.library_type_ == LibraryType::kMKLDNN) {
    VLOG(3) << "missing MKLDNN kernel: fallbacking to PLAIN one";
    expected_kernel_key.library_type_ = LibraryType::kPlain;
    expected_kernel_key.data_layout_ = DataLayout::kAnyLayout;
    kernel_iter = kernels.find(expected_kernel_key);
  }
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
#endif
#ifdef PADDLE_WITH_XPU
  if (kernel_iter == kernels.end() &&
      is_xpu_place(expected_kernel_key.place_)) {
    VLOG(3) << "missing XPU kernel: " << type_
            << ", expected_kernel_key:" << expected_kernel_key
            << ", fallbacking to CPU one!";
    expected_kernel_key.place_ = platform::CPUPlace();
    kernel_iter = kernels.find(expected_kernel_key);
  }
L
Liu Yiqun 已提交
1224
#endif
1225 1226 1227 1228
  PADDLE_ENFORCE_NE(kernel_iter, kernels.end(),
                    platform::errors::NotFound(
                        "Operator (%s) does not have kernel for %s.", type_,
                        KernelTypeToString(expected_kernel_key)));
L
Liu Yiqun 已提交
1229

1230 1231 1232 1233 1234
  std::lock_guard<std::mutex> lock(cache_update_mutex_);
  if (kernel_type_.get() == nullptr || kernel_func_.get() == nullptr) {
    kernel_type_.reset(new OpKernelType(expected_kernel_key));
    kernel_func_.reset(new OpKernelFunc(kernel_iter->second));
  }
L
Liu Yiqun 已提交
1235 1236
}

Y
yuyang18 已提交
1237 1238 1239 1240
void OperatorWithKernel::TransferInplaceVarsBack(
    const Scope& scope, const std::vector<std::string>& inplace_vars,
    const Scope& transfer_scope) const {
  for (auto& var_name : inplace_vars) {
M
minqiyang 已提交
1241
    VLOG(3) << "share inplace var " + var_name + " back to it's original scope";
C
chengduo 已提交
1242
    auto* origin_var = scope.FindVar(var_name);
1243 1244 1245
    PADDLE_ENFORCE_NOT_NULL(origin_var,
                            platform::errors::InvalidArgument(
                                "The variable[%s] is nullptr.", var_name));
C
chengduo 已提交
1246
    auto* original_tensor =
C
chengduo 已提交
1247
        GetMutableLoDTensorOrSelectedRowsValueFromVar(origin_var);
C
chengduo 已提交
1248
    auto* var = transfer_scope.FindVar(var_name);
1249 1250
    PADDLE_ENFORCE_NOT_NULL(var, platform::errors::InvalidArgument(
                                     "The variable[%s] is nullptr.", var_name));
C
chengduo 已提交
1251
    auto* transformed_tensor = GetLoDTensorOrSelectedRowsValueFromVar(*var);
1252
    auto original_dims = original_tensor->dims();
Y
yuyang18 已提交
1253
    original_tensor->ShareDataWith(*transformed_tensor);
1254
    original_tensor->Resize(original_dims);
Y
yuyang18 已提交
1255 1256 1257
  }
}

X
Xin Pan 已提交
1258
Scope* OperatorWithKernel::PrepareData(
Y
yuyang18 已提交
1259
    const Scope& scope, const OpKernelType& expected_kernel_key,
X
Xin Pan 已提交
1260 1261
    std::vector<std::string>* transfered_inplace_vars,
    RuntimeContext* ctx) const {
Y
yuyang18 已提交
1262
  Scope* new_scope = nullptr;
S
sneaxiy 已提交
1263

1264
  const std::unordered_set<std::string>* no_buffer_ins = nullptr;
S
sneaxiy 已提交
1265 1266 1267 1268
  if (info_) {
    auto& no_buffer_inferer = info_->NoNeedBufferVarsInferer();
    // Some op may not register NoNeedBufferVarsInferer
    if (no_buffer_inferer) {
1269 1270
      no_buffer_ins = &(no_buffer_inferer(Inputs(), Outputs(), Attrs()));
      if (no_buffer_ins->empty()) no_buffer_ins = nullptr;
S
sneaxiy 已提交
1271 1272 1273
    }
  }

Y
yuyang18 已提交
1274
  for (auto& var_name_item : Inputs()) {
1275 1276
    bool should_skip_input =
        no_buffer_ins && no_buffer_ins->count(var_name_item.first) > 0;
S
sneaxiy 已提交
1277

X
Xin Pan 已提交
1278 1279 1280 1281
    std::vector<Variable*>& input_vars = ctx->inputs[var_name_item.first];

    for (size_t i = 0; i < var_name_item.second.size(); ++i) {
      auto& var_name = var_name_item.second[i];
X
Xin Pan 已提交
1282
      auto* var = input_vars[i];
X
Xin Pan 已提交
1283

Y
yuyang18 已提交
1284
      // Only tensor can be tranfer to another device.
C
chengduo 已提交
1285
      if (var == nullptr || !VarIsTensor(*var)) {
Y
yuyang18 已提交
1286 1287 1288
        continue;
      }

C
chengduo 已提交
1289
      auto* tensor_in = GetLoDTensorOrSelectedRowsValueFromVar(*var);
1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304

      // When no_buffer_ins then checking of Tensor::holder_ is
      // not a thread safe. And for infershape scenario checks
      // to be omitted are not really needed
      if (should_skip_input == true) {
#ifdef PADDLE_WITH_MKLDNN
        // Var without buffer may be needed
        // for some situation like InferShape().
        // In this situation We cannot skip Var analysis, as
        // MKL-DNN shape of Var may differ from kNHWC Var
        // In such situation corressponding resized Var
        // has to be created and registered
        if ((tensor_in->layout() == DataLayout::kMKLDNN) &&
            (var->IsType<LoDTensor>() == true) &&
            (expected_kernel_key.data_layout_ != DataLayout::kMKLDNN) &&
1305 1306
            (paddle::platform::MKLDNNDeviceContext::tls()
                 .get_cur_paddle_data_layout() == DataLayout::kNHWC)) {
1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327
          // Mixed execution : MKL-DNN and GPU is not supported!
          if (!new_scope) {
            new_scope = &scope.NewScope();
          }
          auto* trans_var = new_scope->Var(var_name);
          input_vars[i] = trans_var;
          auto out = trans_var->GetMutable<LoDTensor>();
          out->Resize(tensor_in->dims());
          platform::MatchShapeToLayout(out, tensor_in->layout(),
                                       DataLayout::kNHWC);
          VLOG(7) << "Created reshaped dummy input based on MKL-DNN Tensor , "
                     "but kNHWC layout"
                  << var_name_item.first << " in Operator " << type_;
        } else {
          VLOG(7) << "Skip scanning input " << var_name_item.first
                  << " in Operator " << type_;
        }
#endif
        continue;
      }

Y
yuyang18 已提交
1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
      if (!tensor_in->IsInitialized()) {
        continue;
      }

      auto kernel_type_for_var = GetKernelTypeForVar(
          var_name_item.first, *tensor_in, expected_kernel_key);

      if (!NeedTransform(kernel_type_for_var, expected_kernel_key)) {
        continue;
      }

      auto out_var_names = OutputVars(true);
      if (std::find(out_var_names.begin(), out_var_names.end(), var_name) !=
          out_var_names.end()) {
        transfered_inplace_vars->emplace_back(var_name);
      }

M
minqiyang 已提交
1345 1346
      VLOG(3) << "Transform Variable " << var_name << " from "
              << kernel_type_for_var << " to " << expected_kernel_key;
Y
yuyang18 已提交
1347

1348 1349 1350
      // In the inference scenerio, the scopes will be reused across the
      // batches, so the `new_scope` here will result in GPU memroy explosion
      // over the  running of operators.
1351
      // We use a thread_local cache to fix that issue, the key in the cache is
1352 1353 1354 1355 1356
      // the combination of the `scope` argument, from_kernel_type,
      // target_kernel_type.
      // Have a discussion with @Superjomn or the inference developers if some
      // changes on this logic for this macro might not tested on the other
      // scenerios.
1357 1358
      // If this op is not called by an Executor or ParallelExecutor, it should
      // called by a NaiveExecutor, the NaiveExecutor will cache the scopes and
1359
      // variables, that behavior a lot different.
1360 1361 1362 1363 1364 1365 1366 1367 1368
      //
      // To solve issue #15032, have a discussion with @Luotao for cpu
      // inference, for all cpu kernels cases without GPU participation, here
      // not do transfer scope caching, and cpu inference performance is not
      // impacted by test.
      enable_cache_transfer_scope_ = false;
      if (!run_by_executor_ &&
          (platform::is_gpu_place(kernel_type_for_var.place_) ||
           platform::is_gpu_place(expected_kernel_key.place_))) {
1369 1370
        new_scope = TryCreateTransferScope(kernel_type_for_var,
                                           expected_kernel_key, &scope);
1371
        enable_cache_transfer_scope_ = true;
1372
      }
1373
      if (!new_scope) {
Y
yuyang18 已提交
1374 1375
        new_scope = &scope.NewScope();
      }
1376 1377 1378 1379
      // For inference, if a gpu model has an op which could only run on CPU,
      // each result of different input will be the same with the first one.
      // The reason is that if a gpu tensor is the input of a cpu kernel,
      // we will create a new cpu tensor in new scope.
1380
      // However, if enable_cache_runtime_context_, we get the cpu tensor each
1381 1382
      // time, not the gpu tensor. Thus, we set pre_scope_ = nullptr
      // to trigger `new RuntimeContext()` in RunImpl().
1383
      if (enable_cache_runtime_context_) {
1384 1385
        pre_scope_ = nullptr;
      }
Y
yuyang18 已提交
1386
      auto* trans_var = new_scope->Var(var_name);
X
fix  
Xin Pan 已提交
1387
      input_vars[i] = trans_var;
Y
yuyang18 已提交
1388
      Tensor out;
Y
yuyang18 已提交
1389
      TransformData(expected_kernel_key, kernel_type_for_var, *tensor_in, &out);
Y
yuyang18 已提交
1390 1391 1392
      SetTensorToVariable(*var, out, trans_var);
    }
  }
1393 1394 1395 1396 1397 1398 1399 1400 1401
  // If pre_scope = &scope, it means that scope is cached and the op is not in
  // while block. If new_scope = nullptr, it means that for each input of this
  // Op, there is no need to do PrepareData. So PrepareData could be skipped at
  // the rest iterations to save the elapsed time.
  // We do not support skipping PrepareData in while block, because the Op's
  // input may be changed by subsequent Ops, which may cause an error.
  if (pre_scope_ == &scope && new_scope == nullptr) {
    need_prepare_data_ = false;
  }
Y
yuyang18 已提交
1402 1403 1404

  return new_scope;
}
Q
Qiao Longfei 已提交
1405

1406 1407 1408
void OperatorWithKernel::ParseInputDataType(
    const ExecutionContext& ctx, const std::string& name,
    proto::VarType::Type* data_type) const {
1409
  proto::VarType::Type default_data_type =
1410
      static_cast<proto::VarType::Type>(-1);
H
hong 已提交
1411
  const std::vector<Variable*> vars = ctx.MultiInputVar(name);
1412 1413 1414 1415 1416 1417 1418 1419 1420 1421
  for (size_t i = 0; i < vars.size(); ++i) {
    const Variable* var = vars[i];
    if (var != nullptr) {
      const Tensor* t = nullptr;
      if (var->IsType<Tensor>()) {
        t = &var->Get<Tensor>();
      } else if (var->IsType<LoDTensor>()) {
        t = &var->Get<LoDTensor>();
      } else if (var->IsType<SelectedRows>()) {
        t = &(var->Get<SelectedRows>().value());
1422 1423 1424 1425 1426 1427 1428
      } else if (var->IsType<LoDTensorArray>()) {
        auto t_arr = var->Get<LoDTensorArray>();
        for (size_t j = 0; j < t_arr.size(); j++) {
          if (t_arr[j].IsInitialized()) {
            t = &(t_arr[j]);
          }
        }
1429 1430
      }
      if (t != nullptr) {
1431 1432 1433 1434 1435
        PADDLE_ENFORCE_EQ(
            t->IsInitialized(), true,
            platform::errors::InvalidArgument(
                "The Tensor in the %s Op's Input Variable %s(%s) is "
                "not initialized.",
H
hong 已提交
1436
                Type(), name, ctx.InputNames(name).at(i)));
1437
        proto::VarType::Type tmp = t->type();
1438
        PADDLE_ENFORCE(
1439
            tmp == *data_type || *data_type == default_data_type,
1440 1441 1442 1443 1444 1445
            platform::errors::InvalidArgument(
                "The DataType of %s Op's duplicable Variable %s must be "
                "consistent. The current variable type is (%s), but the "
                "previous variable type is (%s).",
                Type(), name, DataTypeToString(tmp),
                DataTypeToString(*data_type)));
1446 1447 1448 1449 1450 1451
        *data_type = tmp;
      }
    }
  }
}

1452
proto::VarType::Type OperatorWithKernel::IndicateDataType(
Y
Yu Yang 已提交
1453
    const ExecutionContext& ctx) const {
1454 1455 1456
  proto::VarType::Type dafault_data_type =
      static_cast<proto::VarType::Type>(-1);
  proto::VarType::Type data_type = dafault_data_type;
H
hong 已提交
1457 1458
  for (auto& input : ctx.InNameList()) {
    ParseInputDataType(ctx, input, &data_type);
Y
Yu Yang 已提交
1459
  }
1460 1461 1462 1463
  PADDLE_ENFORCE_NE(
      data_type, dafault_data_type,
      platform::errors::NotFound(
          "DataType should be indicated by input Variable at %s.", Type()));
1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
  return data_type;
}

proto::VarType::Type OperatorWithKernel::IndicateVarDataType(
    const ExecutionContext& ctx, const std::string& name) const {
  proto::VarType::Type dafault_data_type =
      static_cast<proto::VarType::Type>(-1);
  proto::VarType::Type data_type = dafault_data_type;
  ParseInputDataType(ctx, name, &data_type);
  PADDLE_ENFORCE_NE(
      data_type, dafault_data_type,
1475 1476 1477 1478 1479
      platform::errors::InvalidArgument(
          "The Input Variable(%s) of (%s) Operator used to determine kernel "
          "data type is empty or not LoDTensor or SelectedRows or "
          "LoDTensorArray.",
          name, Type()));
1480
  return data_type;
Y
Yu Yang 已提交
1481
}
1482

1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542
Tensor* OperatorWithKernel::GetTensorFormInputSafely(
    const ExecutionContext& ctx, const std::string& name) const {
  // 1. get variable and check
  // NOTE: only supports signal input var now
  // NOTE: using const_cast is because we don't have method
  // can get single mutable var, and here will not change
  // the var's data, only use some attribute
  Variable* var = const_cast<Variable*>(ctx.InputVar(name));
  PADDLE_ENFORCE_NOT_NULL(
      var,
      platform::errors::NotFound(
          "The variable %s is not found when promote complex types.", name));
  // 2. get tensor and check
  Tensor* t = nullptr;
  if (var->IsType<Tensor>()) {
    t = var->GetMutable<Tensor>();
  } else if (var->IsType<LoDTensor>()) {
    t = var->GetMutable<LoDTensor>();
  } else if (var->IsType<SelectedRows>()) {
    t = var->GetMutable<SelectedRows>()->mutable_value();
  } else {
    PADDLE_THROW(platform::errors::Unimplemented(
        "Unsupported input variable type in complex type promotion."));
  }
  PADDLE_ENFORCE_NOT_NULL(
      t,
      platform::errors::InvalidArgument(
          "The Tensor of variable %s is nullptr when promote complex types."));
  PADDLE_ENFORCE_EQ(t->IsInitialized(), true,
                    platform::errors::InvalidArgument(
                        "The Tensor in the %s Op's Input Variable %s(%s) is "
                        "not initialized.",
                        Type(), name, ctx.InputName(name)));
  return t;
}

/** NOTE(chenweihang): For safety reasons, we now only
 * perform type promotes for binary operations with
 * complex type inputs, which is used to support the
 * paddle quantum function.
 * In other cases, the first input data type is used as
 * the kernel data type.
 */
proto::VarType::Type OperatorWithKernel::IndicateOrPromoteVarDataTypes(
    const ExecutionContext& ctx, const std::string& name1,
    const std::string& name2) const {
  // 1. Get tensor
  auto* tensor_a = GetTensorFormInputSafely(ctx, name1);
  auto* tensor_b = GetTensorFormInputSafely(ctx, name2);

  // 2. Get two input types
  auto type_a = tensor_a->type();
  auto type_b = tensor_b->type();

  // 3. Get first input type or promote complex types
  auto target_type = PromoteTypesIfComplexExists(type_a, type_b);

  return target_type;
}

1543 1544 1545 1546 1547 1548 1549 1550
OpKernelType OperatorWithKernel::GetExpectedKernelType(
    const ExecutionContext& ctx) const {
  return OpKernelType(IndicateDataType(ctx), ctx.GetPlace());
}

OpKernelType OperatorWithKernel::GetKernelTypeForVar(
    const std::string& var_name, const Tensor& tensor,
    const OpKernelType& expected_kernel_type) const {
M
mozga-intel 已提交
1551 1552
  return OpKernelType(expected_kernel_type.data_type_, tensor.place(),
                      tensor.layout());
1553 1554
}

Q
Qiao Longfei 已提交
1555
}  // namespace framework
L
liaogang 已提交
1556
}  // namespace paddle