operator.h 18.5 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 14 15 16

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. */

#pragma once

D
dongzhihong 已提交
17
#include <algorithm>
18
#include <atomic>
Q
Qiao Longfei 已提交
19
#include <string>
D
dzhwinter 已提交
20
#include <tuple>
Q
Qiao Longfei 已提交
21 22 23
#include <unordered_map>
#include <vector>

Y
Yu Yang 已提交
24
#include "glog/logging.h"  // For VLOG
Y
Yi Wang 已提交
25 26 27 28 29 30
#include "paddle/fluid/framework/attribute.h"
#include "paddle/fluid/framework/block_desc.h"
#include "paddle/fluid/framework/framework.pb.h"
#include "paddle/fluid/framework/lod_tensor.h"
#include "paddle/fluid/framework/op_info.h"
#include "paddle/fluid/framework/op_kernel_type.h"
X
polish  
Xin Pan 已提交
31
#include "paddle/fluid/framework/operator_kernel_configs.h"
Y
Yi Wang 已提交
32 33 34 35 36
#include "paddle/fluid/framework/scope.h"
#include "paddle/fluid/framework/selected_rows.h"
#include "paddle/fluid/framework/tensor.h"
#include "paddle/fluid/platform/device_context.h"
#include "paddle/fluid/platform/variant.h"
Q
Qiao Longfei 已提交
37

Q
Qiao Longfei 已提交
38 39
DECLARE_int32(inner_op_parallelism);

Q
Qiao Longfei 已提交
40 41 42
namespace paddle {
namespace framework {

43
/// If a variable is a empty variable, that name will be used.
44
constexpr char kEmptyVarName[] = "@EMPTY@";
45 46 47

/// If a variable is a temporary variable, that name will be set in Python,
/// but it will be convert to a unique name in scope after OpCreator.
48
constexpr char kTempVarName[] = "@TEMP@";
49 50 51 52

/// If a variable's name has a certain suffix, it means that the
/// variable is the gradient of another varibale.
/// e.g. Variable "x@GRAD" is the gradient of varibale "x".
53
constexpr char kGradVarSuffix[] = "@GRAD";
54

M
minqiyang 已提交
55 56
constexpr size_t kGradVarSuffixSize = 5U;

57
/// Variables with this suffix are supposed to be filled up with zeros.
58
constexpr char kZeroVarSuffix[] = "@ZERO";
59

C
chengduo 已提交
60 61 62
/// Variables with this suffix are the new Gradient.
constexpr char kNewGradSuffix[] = "@NEWGRAD@";

D
dzhwinter 已提交
63
// define some kernel priority
64
/* Define multiple kernel type fallback order*/
D
dzhwinter 已提交
65 66
extern std::vector<std::tuple<platform::Place, LibraryType>> kKernelPriority;

67
inline std::string GradVarName(const std::string& var_name) {
M
minqiyang 已提交
68 69 70 71 72
  std::string result;
  result.reserve(var_name.size() + kGradVarSuffixSize);
  result += var_name;
  result += kGradVarSuffix;
  return result;
73 74
}

M
minqiyang 已提交
75
inline std::string GradOriginalVarName(const std::string& grad_var_name) {
M
minqiyang 已提交
76
  std::size_t pos = grad_var_name.rfind(kGradVarSuffix);
77 78 79 80 81
  if (pos == std::string::npos) {
    return grad_var_name;
  } else {
    return grad_var_name.substr(0, pos);
  }
82 83
}

Q
qiaolongfei 已提交
84
proto::VarType::Type GetDataTypeOfVar(const Variable* var);
C
chengduo 已提交
85 86
const Tensor* GetLoDTensorOrSelectedRowsValueFromVar(const Variable& var);
Tensor* GetMutableLoDTensorOrSelectedRowsValueFromVar(Variable* var);
Q
qiaolongfei 已提交
87

Q
Qiao Longfei 已提交
88
class OperatorBase;
89
class ExecutionContext;
90

X
Xin Pan 已提交
91 92
class RuntimeContext {
 public:
X
Xin Pan 已提交
93 94
  RuntimeContext(const VariableNameMap& innames,
                 const VariableNameMap& outnames, const Scope& scope);
X
Xin Pan 已提交
95

X
Xin Pan 已提交
96 97 98 99
  RuntimeContext(const VariableValueMap& invars,
                 const VariableValueMap& outvars)
      : inputs(invars), outputs(outvars) {}

X
Xin Pan 已提交
100 101 102 103
  VariableValueMap inputs;
  VariableValueMap outputs;
};

Q
Qiao Longfei 已提交
104
/**
X
Xin Pan 已提交
105
 * OperatorBase has the basic elements that Net will call to do computation.
Q
Qiao Longfei 已提交
106 107 108 109 110 111
 * Only CreateOperator from OpRegistry will new Operator directly. User
 * should always construct a proto message OpDesc and call
 * OpRegistry::CreateOp(op_desc) to get an Operator instance.
 */
class OperatorBase {
 public:
Y
Yu Yang 已提交
112 113
  OperatorBase(const std::string& type, const VariableNameMap& inputs,
               const VariableNameMap& outputs, const AttributeMap& attrs);
114

Q
Qiao Longfei 已提交
115 116
  virtual ~OperatorBase() {}

117
  /// Executor will call this interface function to Run an op.
118 119
  //  The implementation should be written at RunImpl
  void Run(const Scope& scope, const platform::Place& place);
Y
Yu Yang 已提交
120

T
typhoonzero 已提交
121 122 123
  // FIXME(typhoonzero): this is only used for recv_op to stop event_loop.
  virtual void Stop() {}

124 125 126
  /// if scope is not null, also show dimensions of arguments
  virtual std::string DebugStringEx(const Scope* scope) const;
  std::string DebugString() const { return DebugStringEx(nullptr); }
Y
Yu Yang 已提交
127

128 129
  virtual bool SupportGPU() const { return false; }

130 131
  const std::string& Type() const { return type_; }

M
Michal Gallus 已提交
132
  bool HasAttr(const std::string& name) const { return attrs_.count(name); }
133 134
  template <typename T>
  inline const T& Attr(const std::string& name) const {
M
minqiyang 已提交
135 136
    PADDLE_ENFORCE(attrs_.find(name) != attrs_.end(),
                   "%s should be in AttributeMap", name);
137 138 139
    return boost::get<T>(attrs_.at(name));
  }
  const AttributeMap& Attrs() const { return attrs_; }
D
dongzhihong 已提交
140

Y
Yu Yang 已提交
141 142
  const VariableNameMap& Inputs() const { return inputs_; }
  const VariableNameMap& Outputs() const { return outputs_; }
143

144
  bool HasInputs(const std::string& name) const;
Y
Yu Yang 已提交
145
  //! Get a input with argument's name described in `op_proto`
146
  std::string Input(const std::string& name) const;
Y
Yu Yang 已提交
147
  //! Get a input which has multiple variables.
Y
Yu Yang 已提交
148
  const std::vector<std::string>& Inputs(const std::string& name) const;
149
  //! Get all inputs variable names
Q
qijun 已提交
150 151
  std::vector<std::string> InputVars() const;

152
  bool HasOutputs(const std::string& name) const;
Y
Yu Yang 已提交
153
  //! Get a output with argument's name described in `op_proto`
154
  std::string Output(const std::string& name) const;
Y
Yu Yang 已提交
155 156
  //! Get an output which has multiple variables.
  //! TODO add a vector_view to prevent memory copy.
Y
Yu Yang 已提交
157
  const std::vector<std::string>& Outputs(const std::string& name) const;
158
  //! Get all outputs variable names
Y
Yu Yang 已提交
159
  virtual std::vector<std::string> OutputVars(bool has_intermediate) const;
160

161
  void SetIsCalledByExecutor(bool x) { run_by_executor_ = x; }
B
baojun-nervana 已提交
162
  virtual void RuntimeInferShape(const Scope& scope,
X
Xin Pan 已提交
163 164
                                 const platform::Place& place,
                                 const RuntimeContext& ctx) const {}
165

Q
qiaolongfei 已提交
166
 protected:
Q
Qiao Longfei 已提交
167
  std::string type_;
D
dongzhihong 已提交
168
  // NOTE: in case of OpGrad, inputs_ contains:
169
  // I (Inputs)
D
dongzhihong 已提交
170 171
  // O (Outputs)
  // OG (Output Gradients)
Y
Yu Yang 已提交
172
  VariableNameMap inputs_;
Y
Yu Yang 已提交
173

D
dongzhihong 已提交
174 175
  // NOTE: in case of OpGrad, outputs_ contains
  // IG (Inputs Gradients)
Y
Yu Yang 已提交
176
  VariableNameMap outputs_;
Q
Qiao Longfei 已提交
177
  AttributeMap attrs_;
178 179
  // Whether this operator executes in an Executor.
  bool run_by_executor_{true};
180 181 182 183

 private:
  void GenerateTemporaryNames();
  void CheckAllInputOutputSet() const;
184 185
  virtual void RunImpl(const Scope& scope,
                       const platform::Place& place) const = 0;
Y
Yan Chunwei 已提交
186 187
};

188 189 190 191 192 193 194 195 196 197 198 199 200
#ifdef PADDLE_WITH_CUDA
using KernelConfig = boost::variant<
    std::shared_ptr<AlgorithmsCache<cudnnConvolutionFwdAlgo_t>>,
    std::shared_ptr<AlgorithmsCache<cudnnConvolutionBwdDataAlgo_t>>,
    std::shared_ptr<AlgorithmsCache<cudnnConvolutionBwdFilterAlgo_t>>>;
#else
using KernelConfig = boost::variant<boost::blank>;
#endif

using OpKernelConfigsMap =
    std::unordered_map<OpKernelType, std::vector<KernelConfig>,
                       OpKernelType::Hash>;

201
class ExecutionContext {
Y
Yan Chunwei 已提交
202
 public:
203
  ExecutionContext(const OperatorBase& op, const Scope& scope,
X
Xin Pan 已提交
204
                   const platform::DeviceContext& device_context,
205 206 207 208 209 210 211
                   const RuntimeContext& ctx,
                   std::vector<KernelConfig>* configs)
      : op_(op),
        scope_(scope),
        device_context_(device_context),
        ctx_(ctx),
        kernel_configs_(configs) {}
212

Q
qiaolongfei 已提交
213 214 215 216
  const OperatorBase& op() const { return op_; }

  const Scope& scope() const { return scope_; }

Q
qiaolongfei 已提交
217
  template <typename T>
Y
Yu Yang 已提交
218 219
  inline const T& Attr(const std::string& name) const {
    return op_.Attr<T>(name);
Q
qiaolongfei 已提交
220 221
  }

222
  bool HasInput(const std::string& name) const;
223

224
  bool HasOutput(const std::string& name) const;
225

Y
Yu Yang 已提交
226
  size_t InputSize(const std::string& name) const {
Y
Yu Yang 已提交
227
    return op_.Inputs(name).size();
Y
Yan Chunwei 已提交
228 229
  }

Y
Yu Yang 已提交
230
  size_t OutputSize(const std::string& name) const {
Y
Yu Yang 已提交
231
    return op_.Outputs(name).size();
Y
Yan Chunwei 已提交
232 233
  }

X
Xin Pan 已提交
234
  const Variable* InputVar(const std::string& name) const;
Y
Yan Chunwei 已提交
235

X
Xin Pan 已提交
236
  Variable* OutputVar(const std::string& name) const;
Y
Yan Chunwei 已提交
237

238 239
  const std::vector<const Variable*> MultiInputVar(
      const std::string& name) const {
X
Xin Pan 已提交
240 241 242 243
    auto it = ctx_.inputs.find(name);
    if (it == ctx_.inputs.end()) {
      return {};
    }
G
Gabor Buella 已提交
244
    return {it->second.begin(), it->second.end()};
X
Xin Pan 已提交
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
  }

  std::vector<Variable*> MultiOutputVar(const std::string& name) const {
    auto names = op_.Outputs(name);
    auto it = ctx_.outputs.find(name);
    if (it == ctx_.outputs.end()) {
      return {};
    }
    return it->second;
  }

  const std::vector<Variable*> LegacyMultiInputVar(
      const std::string& name) const {
    auto names = op_.Inputs(name);
    std::vector<Variable*> res;
260
    res.reserve(names.size());
261 262
    std::transform(names.begin(), names.end(), std::back_inserter(res),
                   [this](const std::string& name) {
Y
Yu Yang 已提交
263 264
                     return name == kEmptyVarName ? nullptr
                                                  : scope_.FindVar(name);
265
                   });
Y
Yan Chunwei 已提交
266 267 268
    return res;
  }

X
Xin Pan 已提交
269
  std::vector<Variable*> LegacyMultiOutputVar(const std::string& name) const {
Y
Yan Chunwei 已提交
270
    auto names = op_.Outputs(name);
271
    std::vector<Variable*> res;
272
    res.reserve(names.size());
273 274
    std::transform(names.begin(), names.end(), std::back_inserter(res),
                   [this](const std::string& name) {
Y
Yu Yang 已提交
275 276
                     return name == kEmptyVarName ? nullptr
                                                  : scope_.FindVar(name);
277
                   });
Y
Yan Chunwei 已提交
278 279 280
    return res;
  }

281 282
  template <typename T>
  const T* Input(const std::string& name) const {
Y
Yu Yang 已提交
283
    auto* var = InputVar(name);
284
    return var == nullptr ? nullptr : &var->Get<T>();
285 286 287 288
  }

  template <typename T>
  T* Output(const std::string& name) const {
289
    auto var = OutputVar(name);
290
    return var == nullptr ? nullptr : var->GetMutable<T>();
291 292
  }

X
Xin Pan 已提交
293
  template <typename T>
X
clean  
Xin Pan 已提交
294 295
  const T* LegacyInput(const std::string& name) const {
    auto* var = LegacyInputVar(name);
X
Xin Pan 已提交
296 297 298 299
    return var == nullptr ? nullptr : &var->Get<T>();
  }

  template <typename T>
X
clean  
Xin Pan 已提交
300 301
  T* LegacyOutput(const std::string& name) const {
    auto var = LegacyOutputVar(name);
X
Xin Pan 已提交
302 303 304
    return var == nullptr ? nullptr : var->GetMutable<T>();
  }

X
clean  
Xin Pan 已提交
305
  const Variable* LegacyInputVar(const std::string& name) const;
X
Xin Pan 已提交
306

X
clean  
Xin Pan 已提交
307
  Variable* LegacyOutputVar(const std::string& name) const;
X
Xin Pan 已提交
308

309 310
  template <typename T>
  const std::vector<const T*> MultiInput(const std::string& name) const {
X
Xin Pan 已提交
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
    auto it = ctx_.inputs.find(name);
    if (it == ctx_.inputs.end()) {
      return {};
    }
    const std::vector<Variable*>& vars = it->second;
    std::vector<const T*> res;
    res.reserve(vars.size());
    std::transform(vars.begin(), vars.end(), std::back_inserter(res),
                   [&](Variable* var) -> const T* {
                     return var == nullptr ? nullptr : &var->Get<T>();
                   });
    return res;
  }

  template <typename T>
  std::vector<T*> MultiOutput(const std::string& name) const {
    auto it = ctx_.outputs.find(name);
    if (it == ctx_.outputs.end()) {
      return {};
    }
    const std::vector<Variable*>& vars = it->second;
    std::vector<T*> res;
    res.reserve(vars.size());
    std::transform(vars.begin(), vars.end(), std::back_inserter(res),
                   [&](Variable* var) -> T* {
                     return var == nullptr ? nullptr : var->GetMutable<T>();
                   });
    return res;
  }

  template <typename T>
  const std::vector<const T*> LegacyMultiInput(const std::string& name) const {
343 344 345 346
    auto names = op_.Inputs(name);
    std::vector<const T*> res;
    res.reserve(names.size());
    std::transform(names.begin(), names.end(), std::back_inserter(res),
C
chengduo 已提交
347
                   [&](const std::string& sub_name) -> const T* {
348
                     auto var = scope_.FindVar(sub_name);
349
                     return var == nullptr ? nullptr : &var->Get<T>();
350 351 352 353 354
                   });
    return res;
  }

  template <typename T>
X
Xin Pan 已提交
355
  std::vector<T*> LegacyMultiOutput(const std::string& name) const {
356
    auto names = op_.Outputs(name);
357
    std::vector<T*> res;
358 359
    res.reserve(names.size());
    std::transform(names.begin(), names.end(), std::back_inserter(res),
C
chengduo 已提交
360
                   [&](const std::string& sub_name) -> T* {
361
                     auto var = scope_.FindVar(sub_name);
362
                     return var == nullptr ? nullptr : var->GetMutable<T>();
363 364 365 366
                   });
    return res;
  }

367
  platform::Place GetPlace() const { return device_context_.GetPlace(); }
Q
qijun 已提交
368

Q
QI JUN 已提交
369 370 371 372 373
  template <typename DeviceContextType>
  const DeviceContextType& device_context() const {
    return *reinterpret_cast<const DeviceContextType*>(&device_context_);
  }

374
  const platform::DeviceContext& device_context() const {
Q
qijun 已提交
375
    return device_context_;
Q
qijun 已提交
376
  }
Q
qijun 已提交
377

Q
QI JUN 已提交
378 379 380 381 382 383 384 385
#ifdef PADDLE_WITH_CUDA
  const inline platform::CUDADeviceContext& cuda_device_context() const {
    PADDLE_ENFORCE(platform::is_gpu_place(device_context_.GetPlace()));
    return *reinterpret_cast<const platform::CUDADeviceContext*>(
        &device_context_);
  }
#endif

D
dzhwinter 已提交
386
  //! Get actual name vector for this input.
D
Dong Zhihong 已提交
387 388 389
  const std::vector<std::string>& Inputs(const std::string& name) const {
    return op_.Inputs(name);
  }
D
Dong Zhihong 已提交
390

D
dzhwinter 已提交
391
  //! Get actual name vector for this output.
D
Dong Zhihong 已提交
392 393 394 395
  const std::vector<std::string>& Outputs(const std::string& name) const {
    return op_.Outputs(name);
  }

X
Xin Pan 已提交
396 397 398 399 400 401 402 403 404 405 406 407 408 409
  template <typename T, typename DevContext>
  Tensor AllocateTmpTensor(const framework::DDim& dim,
                           const DevContext& dev_ctx) const {
    auto tmp_allocation_ptr = platform::DeviceTemporaryAllocator::Instance()
                                  .Get<DevContext>(dev_ctx)
                                  .Allocate(product(dim) * sizeof(T));
    auto& deleter = tmp_allocation_ptr.get_deleter();
    auto* allocation_ptr = tmp_allocation_ptr.release();
    auto shared_allocation = std::shared_ptr<memory::allocation::Allocation>(
        allocation_ptr, deleter);

    PADDLE_ENFORCE(
        dynamic_cast<platform::TemporaryAllocation*>(allocation_ptr) != nullptr,
        "The AllocationPtr must be TemporaryAllocation.");
410
    PADDLE_ENFORCE_GE(allocation_ptr->size(),
X
Xin Pan 已提交
411 412 413 414 415 416 417 418 419
                      framework::product(dim) * sizeof(T));

    paddle::framework::Tensor temp_tensor(
        framework::ToDataType(std::type_index(typeid(T))));
    temp_tensor.Resize(dim);
    temp_tensor.ResetHolder(std::move(shared_allocation));
    return temp_tensor;
  }

420 421 422 423 424 425 426 427
  template <typename T>
  T& GetKernelConfig(int idx) const {
    PADDLE_ENFORCE(kernel_configs_ && kernel_configs_->size() > idx,
                   "%s selected kernel doesn't have kernel config %lu <= %d",
                   op_.Type().c_str(), kernel_configs_->size(), idx);
    return *boost::get<std::shared_ptr<T>>(kernel_configs_->at(idx));
  }

428
 private:
429 430
  const OperatorBase& op_;
  const Scope& scope_;
431
  const platform::DeviceContext& device_context_;
X
Xin Pan 已提交
432
  const RuntimeContext& ctx_;
433
  mutable std::vector<KernelConfig>* kernel_configs_;
Q
Qiao Longfei 已提交
434 435
};

436 437 438
template <>
const Tensor* ExecutionContext::Input<Tensor>(const std::string& name) const;

X
Xin Pan 已提交
439
template <>
X
clean  
Xin Pan 已提交
440
const Tensor* ExecutionContext::LegacyInput<Tensor>(
X
Xin Pan 已提交
441 442
    const std::string& name) const;

443 444 445 446
template <>
const std::vector<const Tensor*> ExecutionContext::MultiInput<Tensor>(
    const std::string& name) const;

X
Xin Pan 已提交
447 448 449 450
template <>
const std::vector<const Tensor*> ExecutionContext::LegacyMultiInput<Tensor>(
    const std::string& name) const;

451 452 453
template <>
Tensor* ExecutionContext::Output<Tensor>(const std::string& name) const;

X
Xin Pan 已提交
454
template <>
X
clean  
Xin Pan 已提交
455
Tensor* ExecutionContext::LegacyOutput<Tensor>(const std::string& name) const;
X
Xin Pan 已提交
456

457 458 459 460
template <>
std::vector<Tensor*> ExecutionContext::MultiOutput<Tensor>(
    const std::string& name) const;

Y
Yu Yang 已提交
461
class OpKernelBase {
Q
qijun 已提交
462
 public:
Q
qijun 已提交
463
  /**
464
   * ExecutionContext is the only parameter of Kernel Run function.
Q
qijun 已提交
465 466
   * Run will get input/output variables, state such as momentum and
   * device resource such as CUDA stream, cublas handle, etc. from
467
   * ExecutionContext. User should construct it before run the Operator.
Q
qijun 已提交
468 469
   */

470
  virtual void Compute(const ExecutionContext& context) const = 0;
Y
Yu Yang 已提交
471

Y
Yu Yang 已提交
472 473 474 475 476 477 478
  virtual ~OpKernelBase() = default;
};

template <typename T>
class OpKernel : public OpKernelBase {
 public:
  using ELEMENT_TYPE = T;
Y
Yu Yang 已提交
479 480
};

Y
Yu Yang 已提交
481 482
class OperatorWithKernel : public OperatorBase {
 public:
Y
yuyang18 已提交
483
  using OpKernelFunc = std::function<void(const ExecutionContext&)>;
Y
Yu Yang 已提交
484
  using OpKernelMap =
Y
yuyang18 已提交
485
      std::unordered_map<OpKernelType, OpKernelFunc, OpKernelType::Hash>;
Q
Qiao Longfei 已提交
486

Y
Yu Yang 已提交
487 488
  OperatorWithKernel(const std::string& type, const VariableNameMap& inputs,
                     const VariableNameMap& outputs, const AttributeMap& attrs)
Y
Yu Yang 已提交
489 490
      : OperatorBase(type, inputs, outputs, attrs) {}

Y
Yu Yang 已提交
491 492 493 494
  static std::unordered_map<std::string /* op_type */, OpKernelMap>&
  AllOpKernels() {
    static std::unordered_map<std::string, OpKernelMap> g_all_op_kernels;
    return g_all_op_kernels;
Y
Yu Yang 已提交
495
  }
Y
Yan Chunwei 已提交
496

497
  bool SupportGPU() const override {
Y
Yu Yang 已提交
498 499 500 501 502
    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_gpu_place(kern_pair.first.place_);
                       });
503 504
  }

505 506 507
  virtual void InferShape(InferShapeContext* ctx) const {
    OpInfoMap::Instance().Get(Type()).infer_shape_(ctx);
  }
Y
Yu Yang 已提交
508

X
Xin Pan 已提交
509 510
  void RuntimeInferShape(const Scope& scope, const platform::Place& place,
                         const RuntimeContext& ctx) const override;
B
baojun-nervana 已提交
511

512
  virtual OpKernelType GetExpectedKernelType(const ExecutionContext& ctx) const;
X
Xin Pan 已提交
513

X
polish  
Xin Pan 已提交
514 515
  std::vector<KernelConfig>* GetKernelConfig(const OpKernelType& key) const;

X
Xin Pan 已提交
516
 protected:
517 518 519
  virtual OpKernelType GetKernelTypeForVar(
      const std::string& var_name, const Tensor& tensor,
      const OpKernelType& expected_kernel_type) const;
Y
Yu Yang 已提交
520 521

 private:
522
  // indicate kernel DataType by input data. By default all input data must be
Y
Yu Yang 已提交
523
  // same.
524
  proto::VarType::Type IndicateDataType(const ExecutionContext& ctx) const;
525
  void RunImpl(const Scope& scope, const platform::Place& place) const final;
Y
yuyang18 已提交
526 527 528 529 530 531 532

  /**
   * Transfer data from scope to a transfered scope. If there is no data need to
   * be tranfered, it returns nullptr.
   *
   * * transfered_inplace_vars is a output vector.
   */
X
Xin Pan 已提交
533 534 535 536
  Scope* PrepareData(const Scope& scope,
                     const OpKernelType& expected_kernel_key,
                     std::vector<std::string>* transfered_inplace_vars,
                     RuntimeContext* ctx) const;
Y
yuyang18 已提交
537 538 539 540

  void TransferInplaceVarsBack(const Scope& scope,
                               const std::vector<std::string>& inplace_vars,
                               const Scope& exec_scope) const;
541 542 543

 protected:
  mutable OpKernelConfigsMap kernel_configs_map_;
L
luotao1 已提交
544
  mutable RuntimeContext* runtime_ctx_ = nullptr;
Q
Qiao Longfei 已提交
545 546
};

Y
Yu Yang 已提交
547 548
extern bool OpSupportGPU(const std::string& op_type);

Q
Qiao Longfei 已提交
549 550
}  // namespace framework
}  // namespace paddle