operator.h 13.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

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

59 60 61 62
inline std::string GradVarName(const std::string& var_name) {
  return var_name + kGradVarSuffix;
}

Q
qiaolongfei 已提交
63 64
proto::VarType::Type GetDataTypeOfVar(const Variable* var);

Q
Qiao Longfei 已提交
65
class OperatorBase;
66
class ExecutionContext;
67

Q
Qiao Longfei 已提交
68 69 70 71 72 73 74 75
/**
 * OperatorBase has the basic element that Net will call to do computation.
 * 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 已提交
76 77
  OperatorBase(const std::string& type, const VariableNameMap& inputs,
               const VariableNameMap& outputs, const AttributeMap& attrs);
78

Q
Qiao Longfei 已提交
79 80
  virtual ~OperatorBase() {}

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

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

88 89 90
  /// 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 已提交
91

92 93
  virtual bool SupportGPU() const { return false; }

94 95 96 97 98 99 100 101 102
  const std::string& Type() const { return type_; }

  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 已提交
103

Y
Yu Yang 已提交
104 105
  const VariableNameMap& Inputs() const { return inputs_; }
  const VariableNameMap& Outputs() const { return outputs_; }
106

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

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

Y
Yu Yang 已提交
124
  // Return a new operator instance, which is as same as this.
Y
Yu Yang 已提交
125 126
  // Use unique_ptr to prevent caller forget to delete this pointer.
  virtual std::unique_ptr<OperatorBase> Clone() const = 0;
Y
Yu Yang 已提交
127

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

D
dongzhihong 已提交
136 137
  // NOTE: in case of OpGrad, outputs_ contains
  // IG (Inputs Gradients)
Y
Yu Yang 已提交
138
  VariableNameMap outputs_;
Q
Qiao Longfei 已提交
139
  AttributeMap attrs_;
140 141 142 143

 private:
  void GenerateTemporaryNames();
  void CheckAllInputOutputSet() const;
144 145
  virtual void RunImpl(const Scope& scope,
                       const platform::Place& place) const = 0;
Y
Yan Chunwei 已提交
146 147
};

Y
Yu Yang 已提交
148 149
// Macro for define a clone method.
// If you are writing an kernel operator, `Clone` will be defined when you
150
// register it. i.e. `Clone` method is not needed to define by yourself.
151 152 153
#define DEFINE_OP_CLONE_METHOD(cls)                                            \
  std::unique_ptr<::paddle::framework::OperatorBase> Clone() const final {     \
    return std::unique_ptr<::paddle::framework::OperatorBase>(new cls(*this)); \
Y
Yu Yang 已提交
154
  }
Y
Yu Yang 已提交
155

Y
Yu Yang 已提交
156 157 158 159
// Macro for define a default constructor for Operator.
// You can also use
//   using PARENT_CLASS::PARENT_CLASS;
// to use parent's constructor.
Y
Yu Yang 已提交
160 161
#define DEFINE_OP_CONSTRUCTOR(cls, parent_cls)             \
  cls(const std::string& type,                             \
Y
Yu Yang 已提交
162 163 164
      const ::paddle::framework::VariableNameMap& inputs,  \
      const ::paddle::framework::VariableNameMap& outputs, \
      const paddle::framework::AttributeMap& attrs)        \
Y
Yu Yang 已提交
165
      : parent_cls(type, inputs, outputs, attrs) {}
Y
Yu Yang 已提交
166

167 168
class NOP : public OperatorBase {
 public:
169
  using OperatorBase::OperatorBase;
170 171 172
  std::unique_ptr<OperatorBase> Clone() const override {
    return std::unique_ptr<OperatorBase>(new NOP(*this));
  }
173 174 175 176

 private:
  void RunImpl(const Scope& scope,
               const platform::Place& place) const override {}
177 178
};

179
class ExecutionContext {
Y
Yan Chunwei 已提交
180
 public:
181 182 183
  ExecutionContext(const OperatorBase& op, const Scope& scope,
                   const platform::DeviceContext& device_context)
      : op_(op), scope_(scope), device_context_(device_context) {}
184

Q
qiaolongfei 已提交
185 186 187 188
  const OperatorBase& op() const { return op_; }

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

Q
qiaolongfei 已提交
189
  template <typename T>
Y
Yu Yang 已提交
190 191
  inline const T& Attr(const std::string& name) const {
    return op_.Attr<T>(name);
Q
qiaolongfei 已提交
192 193
  }

194
  bool HasInput(const std::string& name) const;
195

196
  bool HasOutput(const std::string& name) const;
197

Y
Yu Yang 已提交
198
  size_t InputSize(const std::string& name) const {
Y
Yu Yang 已提交
199
    return op_.Inputs(name).size();
Y
Yan Chunwei 已提交
200 201
  }

Y
Yu Yang 已提交
202
  size_t OutputSize(const std::string& name) const {
Y
Yu Yang 已提交
203
    return op_.Outputs(name).size();
Y
Yan Chunwei 已提交
204 205
  }

206
  const Variable* InputVar(const std::string& name) const {
207
    auto ipt = op_.Input(name);
Y
Yu Yang 已提交
208
    return ipt == kEmptyVarName ? nullptr : scope_.FindVar(ipt);
Y
Yan Chunwei 已提交
209 210
  }

211
  Variable* OutputVar(const std::string& name) const {
212
    auto opt = op_.Output(name);
Y
Yu Yang 已提交
213
    return opt == kEmptyVarName ? nullptr : scope_.FindVar(opt);
Y
Yan Chunwei 已提交
214 215
  }

216 217
  const std::vector<const Variable*> MultiInputVar(
      const std::string& name) const {
Y
Yan Chunwei 已提交
218 219
    auto names = op_.Inputs(name);
    std::vector<const Variable*> res;
220
    res.reserve(names.size());
221 222
    std::transform(names.begin(), names.end(), std::back_inserter(res),
                   [this](const std::string& name) {
Y
Yu Yang 已提交
223 224
                     return name == kEmptyVarName ? nullptr
                                                  : scope_.FindVar(name);
225
                   });
Y
Yan Chunwei 已提交
226 227 228
    return res;
  }

229
  std::vector<Variable*> MultiOutputVar(const std::string& name) const {
Y
Yan Chunwei 已提交
230
    auto names = op_.Outputs(name);
231
    std::vector<Variable*> res;
232
    res.reserve(names.size());
233 234
    std::transform(names.begin(), names.end(), std::back_inserter(res),
                   [this](const std::string& name) {
Y
Yu Yang 已提交
235 236
                     return name == kEmptyVarName ? nullptr
                                                  : scope_.FindVar(name);
237
                   });
Y
Yan Chunwei 已提交
238 239 240
    return res;
  }

241 242
  template <typename T>
  const T* Input(const std::string& name) const {
Y
Yu Yang 已提交
243
    auto* var = InputVar(name);
244
    return var == nullptr ? nullptr : &var->Get<T>();
245 246 247 248
  }

  template <typename T>
  T* Output(const std::string& name) const {
249
    auto var = OutputVar(name);
250
    return var == nullptr ? nullptr : var->GetMutable<T>();
251 252 253 254 255 256 257 258
  }

  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),
259
                   [&](const std::string& sub_name) {
260
                     auto var = scope_.FindVar(sub_name);
261
                     return var == nullptr ? nullptr : &var->Get<T>();
262 263 264 265 266
                   });
    return res;
  }

  template <typename T>
267
  std::vector<T*> MultiOutput(const std::string& name) const {
268
    auto names = op_.Outputs(name);
269
    std::vector<T*> res;
270 271
    res.reserve(names.size());
    std::transform(names.begin(), names.end(), std::back_inserter(res),
272
                   [&](const std::string& sub_name) {
273
                     auto var = scope_.FindVar(sub_name);
274
                     return var == nullptr ? nullptr : var->GetMutable<T>();
275 276 277 278
                   });
    return res;
  }

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

Q
QI JUN 已提交
281 282 283 284 285
  template <typename DeviceContextType>
  const DeviceContextType& device_context() const {
    return *reinterpret_cast<const DeviceContextType*>(&device_context_);
  }

286
  const platform::DeviceContext& device_context() const {
Q
qijun 已提交
287
    return device_context_;
Q
qijun 已提交
288
  }
Q
qijun 已提交
289

Q
QI JUN 已提交
290 291 292 293 294 295 296 297
#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 已提交
298
  //! Get actual name vector for this input.
D
Dong Zhihong 已提交
299 300 301
  const std::vector<std::string>& Inputs(const std::string& name) const {
    return op_.Inputs(name);
  }
D
Dong Zhihong 已提交
302

D
dzhwinter 已提交
303
  //! Get actual name vector for this output.
D
Dong Zhihong 已提交
304 305 306 307
  const std::vector<std::string>& Outputs(const std::string& name) const {
    return op_.Outputs(name);
  }

308
 private:
309 310
  const OperatorBase& op_;
  const Scope& scope_;
311
  const platform::DeviceContext& device_context_;
Q
Qiao Longfei 已提交
312 313
};

314 315 316 317 318 319 320 321 322 323 324 325 326 327
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 已提交
328
class OpKernelBase {
Q
qijun 已提交
329
 public:
Q
qijun 已提交
330
  /**
331
   * ExecutionContext is the only parameter of Kernel Run function.
Q
qijun 已提交
332 333
   * Run will get input/output variables, state such as momentum and
   * device resource such as CUDA stream, cublas handle, etc. from
334
   * ExecutionContext. User should construct it before run the Operator.
Q
qijun 已提交
335 336
   */

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

Y
Yu Yang 已提交
339 340 341 342 343 344 345
  virtual ~OpKernelBase() = default;
};

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

Y
Yu Yang 已提交
348 349
class OperatorWithKernel : public OperatorBase {
 public:
Y
yuyang18 已提交
350
  using OpKernelFunc = std::function<void(const ExecutionContext&)>;
Y
Yu Yang 已提交
351
  using OpKernelMap =
Y
yuyang18 已提交
352
      std::unordered_map<OpKernelType, OpKernelFunc, OpKernelType::Hash>;
Q
Qiao Longfei 已提交
353

Y
Yu Yang 已提交
354 355
  OperatorWithKernel(const std::string& type, const VariableNameMap& inputs,
                     const VariableNameMap& outputs, const AttributeMap& attrs)
Y
Yu Yang 已提交
356 357
      : OperatorBase(type, inputs, outputs, attrs) {}

Y
Yu Yang 已提交
358 359 360 361
  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 已提交
362
  }
Y
Yan Chunwei 已提交
363

364
  bool SupportGPU() const override {
Y
Yu Yang 已提交
365 366 367 368 369
    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_);
                       });
370 371
  }

372 373 374
  virtual void InferShape(InferShapeContext* ctx) const {
    OpInfoMap::Instance().Get(Type()).infer_shape_(ctx);
  }
Y
Yu Yang 已提交
375

Q
qiaolongfei 已提交
376
 protected:
377 378 379 380
  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 已提交
381 382

 private:
383
  // indicate kernel DataType by input data. By default all input data must be
Y
Yu Yang 已提交
384
  // same.
385
  proto::VarType::Type IndicateDataType(const ExecutionContext& ctx) const;
386
  void RunImpl(const Scope& scope, const platform::Place& place) const final;
Y
yuyang18 已提交
387 388 389 390 391 392 393 394 395 396 397 398 399 400

  /**
   * 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 已提交
401 402
};

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

Q
Qiao Longfei 已提交
405 406
}  // namespace framework
}  // namespace paddle