operator.h 12.8 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 31 32 33 34 35
#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"
#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 已提交
36 37 38 39

namespace paddle {
namespace framework {

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

/// 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.
45
constexpr char kTempVarName[] = "@TEMP@";
46 47 48 49

/// 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".
50
constexpr char kGradVarSuffix[] = "@GRAD";
51 52

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

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

D
dzhwinter 已提交
58
// define some kernel priority
59
/* Define multiple kernel type fallback order*/
D
dzhwinter 已提交
60 61
extern std::vector<std::tuple<platform::Place, LibraryType>> kKernelPriority;

62 63 64 65
inline std::string GradVarName(const std::string& var_name) {
  return var_name + kGradVarSuffix;
}

Q
qiaolongfei 已提交
66
proto::VarType::Type GetDataTypeOfVar(const Variable* var);
C
chengduo 已提交
67 68
const Tensor* GetLoDTensorOrSelectedRowsValueFromVar(const Variable& var);
Tensor* GetMutableLoDTensorOrSelectedRowsValueFromVar(Variable* var);
Q
qiaolongfei 已提交
69

Q
Qiao Longfei 已提交
70
class OperatorBase;
71
class ExecutionContext;
72

Q
Qiao Longfei 已提交
73
/**
X
Xin Pan 已提交
74
 * OperatorBase has the basic elements that Net will call to do computation.
Q
Qiao Longfei 已提交
75 76 77 78 79 80
 * 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 已提交
81 82
  OperatorBase(const std::string& type, const VariableNameMap& inputs,
               const VariableNameMap& outputs, const AttributeMap& attrs);
83

Q
Qiao Longfei 已提交
84 85
  virtual ~OperatorBase() {}

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

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

93 94 95
  /// 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 已提交
96

97 98
  virtual bool SupportGPU() const { return false; }

99 100
  const std::string& Type() const { return type_; }

M
Michal Gallus 已提交
101
  bool HasAttr(const std::string& name) const { return attrs_.count(name); }
102 103 104 105 106 107 108
  template <typename T>
  inline const T& Attr(const std::string& name) const {
    PADDLE_ENFORCE(attrs_.count(name) != 0, "%s should be in AttributeMap",
                   name);
    return boost::get<T>(attrs_.at(name));
  }
  const AttributeMap& Attrs() const { return attrs_; }
D
dongzhihong 已提交
109

Y
Yu Yang 已提交
110 111
  const VariableNameMap& Inputs() const { return inputs_; }
  const VariableNameMap& Outputs() const { return outputs_; }
112

113
  bool HasInputs(const std::string& name) const;
Y
Yu Yang 已提交
114
  //! Get a input with argument's name described in `op_proto`
115
  std::string Input(const std::string& name) const;
Y
Yu Yang 已提交
116
  //! Get a input which has multiple variables.
Y
Yu Yang 已提交
117
  const std::vector<std::string>& Inputs(const std::string& name) const;
118
  //! Get all inputs variable names
Q
qijun 已提交
119 120
  std::vector<std::string> InputVars() const;

121
  bool HasOutputs(const std::string& name) const;
Y
Yu Yang 已提交
122
  //! Get a output with argument's name described in `op_proto`
123
  std::string Output(const std::string& name) const;
Y
Yu Yang 已提交
124 125
  //! Get an output which has multiple variables.
  //! TODO add a vector_view to prevent memory copy.
Y
Yu Yang 已提交
126
  const std::vector<std::string>& Outputs(const std::string& name) const;
127
  //! Get all outputs variable names
Y
Yu Yang 已提交
128
  virtual std::vector<std::string> OutputVars(bool has_intermediate) const;
129

130 131
  void SetIsCalledByExecutor(bool x) { run_by_executor_ = x; }

Q
qiaolongfei 已提交
132
 protected:
Q
Qiao Longfei 已提交
133
  std::string type_;
D
dongzhihong 已提交
134
  // NOTE: in case of OpGrad, inputs_ contains:
135
  // I (Inputs)
D
dongzhihong 已提交
136 137
  // O (Outputs)
  // OG (Output Gradients)
Y
Yu Yang 已提交
138
  VariableNameMap inputs_;
Y
Yu Yang 已提交
139

D
dongzhihong 已提交
140 141
  // NOTE: in case of OpGrad, outputs_ contains
  // IG (Inputs Gradients)
Y
Yu Yang 已提交
142
  VariableNameMap outputs_;
Q
Qiao Longfei 已提交
143
  AttributeMap attrs_;
144 145
  // Whether this operator executes in an Executor.
  bool run_by_executor_{true};
146 147 148 149

 private:
  void GenerateTemporaryNames();
  void CheckAllInputOutputSet() const;
150 151
  virtual void RunImpl(const Scope& scope,
                       const platform::Place& place) const = 0;
Y
Yan Chunwei 已提交
152 153
};

154
class ExecutionContext {
Y
Yan Chunwei 已提交
155
 public:
156 157 158
  ExecutionContext(const OperatorBase& op, const Scope& scope,
                   const platform::DeviceContext& device_context)
      : op_(op), scope_(scope), device_context_(device_context) {}
159

Q
qiaolongfei 已提交
160 161 162 163
  const OperatorBase& op() const { return op_; }

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

Q
qiaolongfei 已提交
164
  template <typename T>
Y
Yu Yang 已提交
165 166
  inline const T& Attr(const std::string& name) const {
    return op_.Attr<T>(name);
Q
qiaolongfei 已提交
167 168
  }

169
  bool HasInput(const std::string& name) const;
170

171
  bool HasOutput(const std::string& name) const;
172

Y
Yu Yang 已提交
173
  size_t InputSize(const std::string& name) const {
Y
Yu Yang 已提交
174
    return op_.Inputs(name).size();
Y
Yan Chunwei 已提交
175 176
  }

Y
Yu Yang 已提交
177
  size_t OutputSize(const std::string& name) const {
Y
Yu Yang 已提交
178
    return op_.Outputs(name).size();
Y
Yan Chunwei 已提交
179 180
  }

181
  const Variable* InputVar(const std::string& name) const {
182
    auto ipt = op_.Input(name);
Y
Yu Yang 已提交
183
    return ipt == kEmptyVarName ? nullptr : scope_.FindVar(ipt);
Y
Yan Chunwei 已提交
184 185
  }

186
  Variable* OutputVar(const std::string& name) const {
187
    auto opt = op_.Output(name);
Y
Yu Yang 已提交
188
    return opt == kEmptyVarName ? nullptr : scope_.FindVar(opt);
Y
Yan Chunwei 已提交
189 190
  }

191 192
  const std::vector<const Variable*> MultiInputVar(
      const std::string& name) const {
Y
Yan Chunwei 已提交
193 194
    auto names = op_.Inputs(name);
    std::vector<const Variable*> res;
195
    res.reserve(names.size());
196 197
    std::transform(names.begin(), names.end(), std::back_inserter(res),
                   [this](const std::string& name) {
Y
Yu Yang 已提交
198 199
                     return name == kEmptyVarName ? nullptr
                                                  : scope_.FindVar(name);
200
                   });
Y
Yan Chunwei 已提交
201 202 203
    return res;
  }

204
  std::vector<Variable*> MultiOutputVar(const std::string& name) const {
Y
Yan Chunwei 已提交
205
    auto names = op_.Outputs(name);
206
    std::vector<Variable*> res;
207
    res.reserve(names.size());
208 209
    std::transform(names.begin(), names.end(), std::back_inserter(res),
                   [this](const std::string& name) {
Y
Yu Yang 已提交
210 211
                     return name == kEmptyVarName ? nullptr
                                                  : scope_.FindVar(name);
212
                   });
Y
Yan Chunwei 已提交
213 214 215
    return res;
  }

216 217
  template <typename T>
  const T* Input(const std::string& name) const {
Y
Yu Yang 已提交
218
    auto* var = InputVar(name);
219
    return var == nullptr ? nullptr : &var->Get<T>();
220 221 222 223
  }

  template <typename T>
  T* Output(const std::string& name) const {
224
    auto var = OutputVar(name);
225
    return var == nullptr ? nullptr : var->GetMutable<T>();
226 227 228 229 230 231 232 233
  }

  template <typename T>
  const std::vector<const T*> MultiInput(const std::string& name) const {
    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 已提交
234
                   [&](const std::string& sub_name) -> const T* {
235
                     auto var = scope_.FindVar(sub_name);
236
                     return var == nullptr ? nullptr : &var->Get<T>();
237 238 239 240 241
                   });
    return res;
  }

  template <typename T>
242
  std::vector<T*> MultiOutput(const std::string& name) const {
243
    auto names = op_.Outputs(name);
244
    std::vector<T*> res;
245 246
    res.reserve(names.size());
    std::transform(names.begin(), names.end(), std::back_inserter(res),
C
chengduo 已提交
247
                   [&](const std::string& sub_name) -> T* {
248
                     auto var = scope_.FindVar(sub_name);
249
                     return var == nullptr ? nullptr : var->GetMutable<T>();
250 251 252 253
                   });
    return res;
  }

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

Q
QI JUN 已提交
256 257 258 259 260
  template <typename DeviceContextType>
  const DeviceContextType& device_context() const {
    return *reinterpret_cast<const DeviceContextType*>(&device_context_);
  }

261
  const platform::DeviceContext& device_context() const {
Q
qijun 已提交
262
    return device_context_;
Q
qijun 已提交
263
  }
Q
qijun 已提交
264

Q
QI JUN 已提交
265 266 267 268 269 270 271 272
#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 已提交
273
  //! Get actual name vector for this input.
D
Dong Zhihong 已提交
274 275 276
  const std::vector<std::string>& Inputs(const std::string& name) const {
    return op_.Inputs(name);
  }
D
Dong Zhihong 已提交
277

D
dzhwinter 已提交
278
  //! Get actual name vector for this output.
D
Dong Zhihong 已提交
279 280 281 282
  const std::vector<std::string>& Outputs(const std::string& name) const {
    return op_.Outputs(name);
  }

283
 private:
284 285
  const OperatorBase& op_;
  const Scope& scope_;
286
  const platform::DeviceContext& device_context_;
Q
Qiao Longfei 已提交
287 288
};

289 290 291 292 293 294 295 296 297 298 299 300 301 302
template <>
const Tensor* ExecutionContext::Input<Tensor>(const std::string& name) const;

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

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

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

Y
Yu Yang 已提交
303
class OpKernelBase {
Q
qijun 已提交
304
 public:
Q
qijun 已提交
305
  /**
306
   * ExecutionContext is the only parameter of Kernel Run function.
Q
qijun 已提交
307 308
   * Run will get input/output variables, state such as momentum and
   * device resource such as CUDA stream, cublas handle, etc. from
309
   * ExecutionContext. User should construct it before run the Operator.
Q
qijun 已提交
310 311
   */

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

Y
Yu Yang 已提交
314 315 316 317 318 319 320
  virtual ~OpKernelBase() = default;
};

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

Y
Yu Yang 已提交
323 324
class OperatorWithKernel : public OperatorBase {
 public:
Y
yuyang18 已提交
325
  using OpKernelFunc = std::function<void(const ExecutionContext&)>;
Y
Yu Yang 已提交
326
  using OpKernelMap =
Y
yuyang18 已提交
327
      std::unordered_map<OpKernelType, OpKernelFunc, OpKernelType::Hash>;
Q
Qiao Longfei 已提交
328

Y
Yu Yang 已提交
329 330
  OperatorWithKernel(const std::string& type, const VariableNameMap& inputs,
                     const VariableNameMap& outputs, const AttributeMap& attrs)
Y
Yu Yang 已提交
331 332
      : OperatorBase(type, inputs, outputs, attrs) {}

Y
Yu Yang 已提交
333 334 335 336
  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 已提交
337
  }
Y
Yan Chunwei 已提交
338

339
  bool SupportGPU() const override {
Y
Yu Yang 已提交
340 341 342 343 344
    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_);
                       });
345 346
  }

347 348 349
  virtual void InferShape(InferShapeContext* ctx) const {
    OpInfoMap::Instance().Get(Type()).infer_shape_(ctx);
  }
Y
Yu Yang 已提交
350

Q
qiaolongfei 已提交
351
 protected:
352 353 354 355
  virtual OpKernelType GetExpectedKernelType(const ExecutionContext& ctx) const;
  virtual OpKernelType GetKernelTypeForVar(
      const std::string& var_name, const Tensor& tensor,
      const OpKernelType& expected_kernel_type) const;
Y
Yu Yang 已提交
356 357

 private:
358
  // indicate kernel DataType by input data. By default all input data must be
Y
Yu Yang 已提交
359
  // same.
360
  proto::VarType::Type IndicateDataType(const ExecutionContext& ctx) const;
361
  void RunImpl(const Scope& scope, const platform::Place& place) const final;
Y
yuyang18 已提交
362 363 364 365 366 367 368 369 370 371 372 373 374 375

  /**
   * 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.
   */
  Scope* TryTransferData(
      const Scope& scope, const OpKernelType& expected_kernel_key,
      std::vector<std::string>* transfered_inplace_vars) const;

  void TransferInplaceVarsBack(const Scope& scope,
                               const std::vector<std::string>& inplace_vars,
                               const Scope& exec_scope) const;
Q
Qiao Longfei 已提交
376 377
};

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

Q
Qiao Longfei 已提交
380 381
}  // namespace framework
}  // namespace paddle