jit_kernel.h 4.2 KB
Newer Older
T
tensor-tang 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.

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
#include <functional>
#include <memory>  // for shared_ptr
#include <string>
T
tensor-tang 已提交
19
#include <unordered_map>
T
tensor-tang 已提交
20
#include "paddle/fluid/platform/cpu_info.h"
T
tensor-tang 已提交
21 22 23 24 25 26 27 28
#include "paddle/fluid/platform/macros.h"

// Note: Only support on CPU yet.
namespace paddle {
namespace operators {
namespace math {
namespace jitkernel {

T
tensor-tang 已提交
29 30
#define SIGMOID_THRESHOLD_MIN -40.0
#define SIGMOID_THRESHOLD_MAX 13.0
T
tensor-tang 已提交
31
#define EXP_MAX_INPUT 40.0
T
tensor-tang 已提交
32 33 34 35
#define AVX_FLOAT_BLOCK 8
#define AVX2_FLOAT_BLOCK 8
#define AVX512_FLOAT_BLOCK 16

T
tensor-tang 已提交
36
typedef enum { kLT8, kEQ8, kGT8LT16, kEQ16, kGT16 } jit_block;
T
tensor-tang 已提交
37

T
tensor-tang 已提交
38
class Kernel {
T
tensor-tang 已提交
39
 public:
T
tensor-tang 已提交
40
  Kernel() = default;
T
tensor-tang 已提交
41
  virtual ~Kernel() = default;
T
tensor-tang 已提交
42
  // TODO(TJ): below members should be deprecated.
T
tensor-tang 已提交
43 44 45
  int num_{0};
  int end_{0};
  int rest_{0};
T
tensor-tang 已提交
46 47 48 49 50
  DISABLE_COPY_AND_ASSIGN(Kernel);
};

class KernelPool {
 public:
T
tensor-tang 已提交
51
  static KernelPool &Instance();
T
tensor-tang 已提交
52 53

  template <typename Ker, typename... ARGS>
T
tensor-tang 已提交
54
  std::shared_ptr<const Ker> Get(ARGS... args);
T
tensor-tang 已提交
55

T
tensor-tang 已提交
56
  std::shared_ptr<const Kernel> Get(const std::string &key) const;
T
tensor-tang 已提交
57

T
tensor-tang 已提交
58 59
 private:
  KernelPool() = default;
T
tensor-tang 已提交
60
  std::unordered_map<std::string, std::shared_ptr<const Kernel>> kers_;
T
tensor-tang 已提交
61 62 63 64

  DISABLE_COPY_AND_ASSIGN(KernelPool);
};

T
tensor-tang 已提交
65 66 67
template <typename T>
class VMulKernel : public Kernel {
 public:
T
tensor-tang 已提交
68
  void (*Compute)(const T *, const T *, T *, int);
T
tensor-tang 已提交
69 70
};

T
tensor-tang 已提交
71 72 73
template <typename T>
class VAddKernel : public Kernel {
 public:
T
tensor-tang 已提交
74
  void (*Compute)(const T *, const T *, T *, int);
T
tensor-tang 已提交
75 76
};

T
tensor-tang 已提交
77 78 79
template <typename T>
class VScalKernel : public Kernel {
 public:
T
tensor-tang 已提交
80 81
  virtual void Compute(const T a, const T *x, T *y) const = 0;
  virtual void Compute(const T a, T *x) const = 0;
T
tensor-tang 已提交
82 83
};

T
tensor-tang 已提交
84 85 86
template <typename T>
class VAddBiasKernel : public Kernel {
 public:
T
tensor-tang 已提交
87
  virtual void Compute(const T a, const T *x, T *y) const = 0;
T
tensor-tang 已提交
88 89
};

T
tensor-tang 已提交
90 91 92 93 94 95
template <typename T>
class VAddReluKernel : public Kernel {
 public:
  virtual void Compute(const T *x, const T *y, T *z) const = 0;
};

T
tensor-tang 已提交
96
template <typename T>
T
tensor-tang 已提交
97
class VActKernel : public Kernel {
T
tensor-tang 已提交
98
 public:
T
tensor-tang 已提交
99
  virtual void Compute(const T *x, T *y) const = 0;
T
tensor-tang 已提交
100 101 102
};

template <typename T>
T
tensor-tang 已提交
103
class VReluKernel : public VActKernel<T> {
T
tensor-tang 已提交
104
 public:
T
tensor-tang 已提交
105
  virtual void Compute(const T *x, T *y) const = 0;
T
tensor-tang 已提交
106 107 108
};

template <typename T>
T
tensor-tang 已提交
109
class VIdentityKernel : public VActKernel<T> {
T
tensor-tang 已提交
110
 public:
T
tensor-tang 已提交
111
  virtual void Compute(const T *x, T *y) const = 0;
T
tensor-tang 已提交
112 113
};

T
tensor-tang 已提交
114
template <typename T>
T
tensor-tang 已提交
115
class VExpKernel : public VActKernel<T> {
T
tensor-tang 已提交
116
 public:
T
tensor-tang 已提交
117 118
  virtual void Compute(const T *x, T *y) const = 0;
};
T
tensor-tang 已提交
119

T
tensor-tang 已提交
120 121 122 123 124
template <typename T>
class VSigmoidKernel : public VActKernel<T> {
 public:
  virtual void Compute(const T *x, T *y) const = 0;
};
T
tensor-tang 已提交
125

T
tensor-tang 已提交
126 127 128 129 130 131 132 133 134
template <typename T>
class VTanhKernel : public VActKernel<T> {
 public:
  virtual void Compute(const T *x, T *y) const = 0;
};

template <typename T>
class LSTMKernel : public Kernel {
 public:
T
tensor-tang 已提交
135
  virtual void ComputeCtHt(T *gates, const T *ct_1, T *ct, T *ht,
136 137
                           /* below only used in peephole*/
                           const T *wp_data = nullptr,
T
tensor-tang 已提交
138
                           T *checked = nullptr) const = 0;
139 140 141 142 143

  // compute c1 and h1 without c0 or h0
  virtual void ComputeC1H1(T *gates, T *ct, T *ht,
                           /* below only used in peephole*/
                           const T *wp_data = nullptr) const = 0;
T
tensor-tang 已提交
144 145
};

T
tensor-tang 已提交
146 147 148 149 150 151 152 153 154
template <typename T>
class GRUKernel : public Kernel {
 public:
  // compute h1 without h0
  virtual void ComputeH1(T *gates, T *ht) const = 0;
  virtual void ComputeHtPart1(T *gates, const T *ht_1, T *ht) const = 0;
  virtual void ComputeHtPart2(T *gates, const T *ht_1, T *ht) const = 0;
};

T
tensor-tang 已提交
155 156 157 158 159 160 161
template <typename T>
class CRFDecodeKernel : public Kernel {
 public:
  virtual void Compute(const int seq_len, const T *x, const T *w, T *alpha,
                       int *track) const = 0;
};

T
tensor-tang 已提交
162 163 164 165
}  // namespace jitkernel
}  // namespace math
}  // namespace operators
}  // namespace paddle