From 1aaec571c27be217ae7cc72df1bb01b3130fdead Mon Sep 17 00:00:00 2001 From: tensor-tang Date: Thu, 20 Dec 2018 09:36:08 +0000 Subject: [PATCH] fix enum style test=develop --- paddle/fluid/operators/crf_decoding_op.h | 2 +- .../elementwise/elementwise_mul_mkldnn_op.cc | 2 +- paddle/fluid/operators/fused/fusion_gru_op.cc | 46 ++++---- .../fluid/operators/fused/fusion_lstm_op.cc | 52 ++++----- paddle/fluid/operators/jit/benchmark.cc | 36 +++---- paddle/fluid/operators/jit/gen/CMakeLists.txt | 34 +++--- paddle/fluid/operators/jit/gen/act.cc | 10 +- paddle/fluid/operators/jit/gen/blas.cc | 14 +-- paddle/fluid/operators/jit/gen/gru.cc | 6 +- paddle/fluid/operators/jit/gen/gru.h | 8 +- paddle/fluid/operators/jit/gen/lstm.cc | 4 +- paddle/fluid/operators/jit/gen/lstm.h | 8 +- paddle/fluid/operators/jit/helper.cc | 51 +++++---- paddle/fluid/operators/jit/kernel_base.h | 40 +++---- .../jit/more/intrinsic/CMakeLists.txt | 4 +- .../jit/more/intrinsic/crf_decoding.cc | 2 +- .../jit/more/intrinsic/layer_norm.cc | 2 +- .../operators/jit/more/mix/CMakeLists.txt | 14 +-- paddle/fluid/operators/jit/more/mix/mix.cc | 52 ++++----- .../operators/jit/more/mkl/CMakeLists.txt | 12 +-- paddle/fluid/operators/jit/more/mkl/mkl.cc | 12 +-- .../fluid/operators/jit/refer/CMakeLists.txt | 38 +++---- paddle/fluid/operators/jit/refer/refer.cc | 38 +++---- paddle/fluid/operators/jit/refer/refer.h | 8 +- paddle/fluid/operators/jit/test.cc | 102 +++++++++--------- paddle/fluid/operators/layer_norm_op.h | 2 +- paddle/fluid/operators/math/fc_compute.h | 4 +- 27 files changed, 301 insertions(+), 302 deletions(-) diff --git a/paddle/fluid/operators/crf_decoding_op.h b/paddle/fluid/operators/crf_decoding_op.h index 9b90ba749bd..72774a878d9 100644 --- a/paddle/fluid/operators/crf_decoding_op.h +++ b/paddle/fluid/operators/crf_decoding_op.h @@ -82,7 +82,7 @@ class CRFDecodingOpKernel : public framework::OpKernel { Tensor track; int* track_value = track.mutable_data(emission_dims, platform::CPUPlace()); - auto ker = jit::Get, + auto ker = jit::Get, platform::CPUPlace>(tag_num); ker(static_cast(seq_len), x, w, alpha_value, track_value, tag_num); T max_score = -std::numeric_limits::max(); diff --git a/paddle/fluid/operators/elementwise/elementwise_mul_mkldnn_op.cc b/paddle/fluid/operators/elementwise/elementwise_mul_mkldnn_op.cc index 2ade5818a99..ec85fb80f48 100644 --- a/paddle/fluid/operators/elementwise/elementwise_mul_mkldnn_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_mul_mkldnn_op.cc @@ -108,7 +108,7 @@ class ElementwiseMulMKLDNNKernel : public framework::OpKernel { constexpr int simd_width = 16; int C = c / simd_width; - auto multiply = jit::Get, + auto multiply = jit::Get, platform::CPUPlace>(0); #pragma omp parallel for collapse(2) for (int ni = 0; ni < n; ni++) { diff --git a/paddle/fluid/operators/fused/fusion_gru_op.cc b/paddle/fluid/operators/fused/fusion_gru_op.cc index 87a4341a823..66acba49e5a 100644 --- a/paddle/fluid/operators/fused/fusion_gru_op.cc +++ b/paddle/fluid/operators/fused/fusion_gru_op.cc @@ -182,29 +182,29 @@ class FusionGRUKernel : public framework::OpKernel { const int total_T = x_dims[0]; \ const int D3 = wh_dims[1] -#define INIT_OTHER_DEFINES \ - auto* h0 = ctx.Input("H0"); \ - auto* wx = ctx.Input("WeightX"); \ - auto* bias = ctx.Input("Bias"); \ - auto* hidden_out = ctx.Output("Hidden"); \ - bool is_reverse = ctx.Attr("is_reverse"); \ - const int M = x_dims[1]; \ - const int D = wh_dims[0]; \ - const int D2 = D * 2; \ - const jit::gru_attr_t attr( \ - D, jit::to_kerneltype(ctx.Attr("gate_activation")), \ - jit::to_kerneltype(ctx.Attr("activation"))); \ - jit::gru_t one_step; \ - auto ComputeH1 = \ - jit::Get, platform::CPUPlace>(attr); \ - auto ComputeHtPart1 = \ - jit::Get, platform::CPUPlace>(attr); \ - auto ComputeHtPart2 = \ - jit::Get, platform::CPUPlace>(attr); \ - const T* x_data = x->data(); \ - const T* wx_data = wx->data(); \ - const T* wh_data = wh->data(); \ - auto place = ctx.GetPlace(); \ +#define INIT_OTHER_DEFINES \ + auto* h0 = ctx.Input("H0"); \ + auto* wx = ctx.Input("WeightX"); \ + auto* bias = ctx.Input("Bias"); \ + auto* hidden_out = ctx.Output("Hidden"); \ + bool is_reverse = ctx.Attr("is_reverse"); \ + const int M = x_dims[1]; \ + const int D = wh_dims[0]; \ + const int D2 = D * 2; \ + const jit::gru_attr_t attr( \ + D, jit::to_kerneltype(ctx.Attr("gate_activation")), \ + jit::to_kerneltype(ctx.Attr("activation"))); \ + jit::gru_t one_step; \ + auto ComputeH1 = \ + jit::Get, platform::CPUPlace>(attr); \ + auto ComputeHtPart1 = \ + jit::Get, platform::CPUPlace>(attr); \ + auto ComputeHtPart2 = \ + jit::Get, platform::CPUPlace>(attr); \ + const T* x_data = x->data(); \ + const T* wx_data = wx->data(); \ + const T* wh_data = wh->data(); \ + auto place = ctx.GetPlace(); \ T* xx_data = xx->mutable_data(place) void SeqCompute(const framework::ExecutionContext& ctx) const { diff --git a/paddle/fluid/operators/fused/fusion_lstm_op.cc b/paddle/fluid/operators/fused/fusion_lstm_op.cc index d20a860e2ba..b11b7c11bfe 100644 --- a/paddle/fluid/operators/fused/fusion_lstm_op.cc +++ b/paddle/fluid/operators/fused/fusion_lstm_op.cc @@ -235,32 +235,32 @@ class FuisonLSTMKernel : public framework::OpKernel { const int D = wh_dims[0]; \ const int D4 = wh_dims[1] -#define INIT_OTHER_DEFINES \ - const T* x_data = x->data(); \ - const T* wx_data = wx->data(); \ - const T* wh_data = wh->data(); \ - /* diagonal weight*/ \ - const T* wp_data = bias->data() + D4; \ - /* for peephole only*/ \ - T* checked_cell_data = nullptr; \ - auto place = ctx.GetPlace(); \ - if (use_peepholes) { \ - /* w_ic * Ct-1, w_fc * Ct-1 ; w_oc * Ct => ih*/ \ - auto* checked_cell = ctx.Output("CheckedCell"); \ - checked_cell_data = checked_cell->mutable_data(place); \ - } \ - const jit::lstm_attr_t attr( \ - D, jit::to_kerneltype(ctx.Attr("gate_activation")), \ - jit::to_kerneltype(ctx.Attr("candidate_activation")), \ - jit::to_kerneltype(ctx.Attr("cell_activation")), \ - use_peepholes); \ - jit::lstm_t one_step; \ - one_step.wp = wp_data; \ - one_step.checked = checked_cell_data; \ - auto ComputeC1H1 = \ - jit::Get, platform::CPUPlace>(attr); \ - auto ComputeCtHt = \ - jit::Get, platform::CPUPlace>(attr) +#define INIT_OTHER_DEFINES \ + const T* x_data = x->data(); \ + const T* wx_data = wx->data(); \ + const T* wh_data = wh->data(); \ + /* diagonal weight*/ \ + const T* wp_data = bias->data() + D4; \ + /* for peephole only*/ \ + T* checked_cell_data = nullptr; \ + auto place = ctx.GetPlace(); \ + if (use_peepholes) { \ + /* w_ic * Ct-1, w_fc * Ct-1 ; w_oc * Ct => ih*/ \ + auto* checked_cell = ctx.Output("CheckedCell"); \ + checked_cell_data = checked_cell->mutable_data(place); \ + } \ + const jit::lstm_attr_t attr( \ + D, jit::to_kerneltype(ctx.Attr("gate_activation")), \ + jit::to_kerneltype(ctx.Attr("candidate_activation")), \ + jit::to_kerneltype(ctx.Attr("cell_activation")), \ + use_peepholes); \ + jit::lstm_t one_step; \ + one_step.wp = wp_data; \ + one_step.checked = checked_cell_data; \ + auto ComputeC1H1 = \ + jit::Get, platform::CPUPlace>(attr); \ + auto ComputeCtHt = \ + jit::Get, platform::CPUPlace>(attr) // Wh GEMM #define GEMM_WH_ADDON(bs, prev, out) \ diff --git a/paddle/fluid/operators/jit/benchmark.cc b/paddle/fluid/operators/jit/benchmark.cc index 67563ffb0e0..437005825db 100644 --- a/paddle/fluid/operators/jit/benchmark.cc +++ b/paddle/fluid/operators/jit/benchmark.cc @@ -146,7 +146,7 @@ template void BenchLSTMKernel() { for (bool use_peephole : {true, false}) { for (int d : TestSizes()) { - const jit::lstm_attr_t attr(d, jit::vsigmoid, jit::vtanh, jit::vtanh, + const jit::lstm_attr_t attr(d, jit::kVSigmoid, jit::kVTanh, jit::kVTanh, use_peephole); std::vector x(4 * d), ct_1(d), ct(d), ht(d), wp(3 * d), checked(2 * d); RandomVec(4 * d, x.data(), -2.f, 2.f); @@ -175,7 +175,7 @@ void BenchLSTMKernel() { template void BenchGRUKernel() { for (int d : TestSizes()) { - const jit::gru_attr_t attr(d, jit::vsigmoid, jit::vtanh); + const jit::gru_attr_t attr(d, jit::kVSigmoid, jit::kVTanh); std::vector x(3 * d), ht_1(d), ht(d); RandomVec(3 * d, x.data(), -2.f, 2.f); RandomVec(d, ht_1.data(), -2.f, 2.f); @@ -204,28 +204,28 @@ int main(int argc, char* argv[]) { using T = float; using PlaceType = paddle::platform::CPUPlace; // xyzn - BenchXYZNKernel(); - BenchXYZNKernel(); - BenchXYZNKernel(); - BenchXYZNKernel(); + BenchXYZNKernel(); + BenchXYZNKernel(); + BenchXYZNKernel(); + BenchXYZNKernel(); // axyn - BenchAXYNKernel(); - BenchAXYNKernel(); + BenchAXYNKernel(); + BenchAXYNKernel(); // xyn - BenchXYNKernel(); - BenchXYNKernel(); - BenchXYNKernel(); - BenchXYNKernel(); - BenchXYNKernel(); + BenchXYNKernel(); + BenchXYNKernel(); + BenchXYNKernel(); + BenchXYNKernel(); + BenchXYNKernel(); // lstm and peephole - BenchLSTMKernel(); - BenchLSTMKernel(); + BenchLSTMKernel(); + BenchLSTMKernel(); // gru functions - BenchGRUKernel(); - BenchGRUKernel(); - BenchGRUKernel(); + BenchGRUKernel(); + BenchGRUKernel(); + BenchGRUKernel(); } diff --git a/paddle/fluid/operators/jit/gen/CMakeLists.txt b/paddle/fluid/operators/jit/gen/CMakeLists.txt index a7f9e18318d..8a540108302 100644 --- a/paddle/fluid/operators/jit/gen/CMakeLists.txt +++ b/paddle/fluid/operators/jit/gen/CMakeLists.txt @@ -9,20 +9,20 @@ function(USE_JITKERNEL_GEN TARGET) endfunction() # use gen jitcode kernel by name -USE_JITKERNEL_GEN(vmul) -USE_JITKERNEL_GEN(vadd) -#USE_JITKERNEL_GEN(vsub) # TODO(TJ): enable me -USE_JITKERNEL_GEN(vaddrelu) -USE_JITKERNEL_GEN(vscal) -USE_JITKERNEL_GEN(vaddbias) -USE_JITKERNEL_GEN(vrelu) -USE_JITKERNEL_GEN(videntity) -USE_JITKERNEL_GEN(vexp) -USE_JITKERNEL_GEN(vsigmoid) -USE_JITKERNEL_GEN(vtanh) -USE_JITKERNEL_GEN(lstmctht) -USE_JITKERNEL_GEN(lstmc1h1) -USE_JITKERNEL_GEN(gruh1) -USE_JITKERNEL_GEN(gruhtpart1) -USE_JITKERNEL_GEN(gruhtpart2) -USE_JITKERNEL_GEN(nchw16cmulnc) +USE_JITKERNEL_GEN(kVMul) +USE_JITKERNEL_GEN(kVAdd) +#USE_JITKERNEL_GEN(kVSub) # TODO(TJ): enable me +USE_JITKERNEL_GEN(kVAddRelu) +USE_JITKERNEL_GEN(kVScal) +USE_JITKERNEL_GEN(kVAddBias) +USE_JITKERNEL_GEN(kVRelu) +USE_JITKERNEL_GEN(kVIdentity) +USE_JITKERNEL_GEN(kVExp) +USE_JITKERNEL_GEN(kVSigmoid) +USE_JITKERNEL_GEN(kVTanh) +USE_JITKERNEL_GEN(kLSTMCtHt) +USE_JITKERNEL_GEN(kLSTMC1H1) +USE_JITKERNEL_GEN(kGRUH1) +USE_JITKERNEL_GEN(kGRUHtPart1) +USE_JITKERNEL_GEN(kGRUHtPart2) +USE_JITKERNEL_GEN(kNCHW16CMulNC) diff --git a/paddle/fluid/operators/jit/gen/act.cc b/paddle/fluid/operators/jit/gen/act.cc index 391cf57d8a7..3ea076f217d 100644 --- a/paddle/fluid/operators/jit/gen/act.cc +++ b/paddle/fluid/operators/jit/gen/act.cc @@ -128,8 +128,8 @@ size_t VTanhCreator::CodeSize(const int& d) const { namespace gen = paddle::operators::jit::gen; -REGISTER_JITKERNEL_GEN(vrelu, gen::VReluCreator); -REGISTER_JITKERNEL_GEN(videntity, gen::VIdentityCreator); -REGISTER_JITKERNEL_GEN(vexp, gen::VExpCreator); -REGISTER_JITKERNEL_GEN(vsigmoid, gen::VSigmoidCreator); -REGISTER_JITKERNEL_GEN(vtanh, gen::VTanhCreator); +REGISTER_JITKERNEL_GEN(kVRelu, gen::VReluCreator); +REGISTER_JITKERNEL_GEN(kVIdentity, gen::VIdentityCreator); +REGISTER_JITKERNEL_GEN(kVExp, gen::VExpCreator); +REGISTER_JITKERNEL_GEN(kVSigmoid, gen::VSigmoidCreator); +REGISTER_JITKERNEL_GEN(kVTanh, gen::VTanhCreator); diff --git a/paddle/fluid/operators/jit/gen/blas.cc b/paddle/fluid/operators/jit/gen/blas.cc index 42bf3c3f119..c1198773088 100644 --- a/paddle/fluid/operators/jit/gen/blas.cc +++ b/paddle/fluid/operators/jit/gen/blas.cc @@ -176,11 +176,11 @@ DECLARE_BLAS_CREATOR(VAddBias); namespace gen = paddle::operators::jit::gen; -REGISTER_JITKERNEL_GEN(vmul, gen::VMulCreator); -REGISTER_JITKERNEL_GEN(vadd, gen::VAddCreator); +REGISTER_JITKERNEL_GEN(kVMul, gen::VMulCreator); +REGISTER_JITKERNEL_GEN(kVAdd, gen::VAddCreator); // TODO(TJ): enable sub -// REGISTER_JITKERNEL_GEN(vsub, gen::VSubCreator); -REGISTER_JITKERNEL_GEN(vaddrelu, gen::VAddReluCreator); -REGISTER_JITKERNEL_GEN(vscal, gen::VScalCreator); -REGISTER_JITKERNEL_GEN(vaddbias, gen::VAddBiasCreator); -REGISTER_JITKERNEL_GEN(nchw16cmulnc, gen::NCHW16CMulNCCreator); +// REGISTER_JITKERNEL_GEN(kVSub, gen::VSubCreator); +REGISTER_JITKERNEL_GEN(kVAddRelu, gen::VAddReluCreator); +REGISTER_JITKERNEL_GEN(kVScal, gen::VScalCreator); +REGISTER_JITKERNEL_GEN(kVAddBias, gen::VAddBiasCreator); +REGISTER_JITKERNEL_GEN(kNCHW16CMulNC, gen::NCHW16CMulNCCreator); diff --git a/paddle/fluid/operators/jit/gen/gru.cc b/paddle/fluid/operators/jit/gen/gru.cc index ec89880a0c3..13f7a14111a 100644 --- a/paddle/fluid/operators/jit/gen/gru.cc +++ b/paddle/fluid/operators/jit/gen/gru.cc @@ -111,6 +111,6 @@ DECLARE_GRU_CREATOR(GRUHtPart2); namespace gen = paddle::operators::jit::gen; -REGISTER_JITKERNEL_GEN(gruh1, gen::GRUH1Creator); -REGISTER_JITKERNEL_GEN(gruhtpart1, gen::GRUHtPart1Creator); -REGISTER_JITKERNEL_GEN(gruhtpart2, gen::GRUHtPart2Creator); +REGISTER_JITKERNEL_GEN(kGRUH1, gen::GRUH1Creator); +REGISTER_JITKERNEL_GEN(kGRUHtPart1, gen::GRUHtPart1Creator); +REGISTER_JITKERNEL_GEN(kGRUHtPart2, gen::GRUHtPart2Creator); diff --git a/paddle/fluid/operators/jit/gen/gru.h b/paddle/fluid/operators/jit/gen/gru.h index 8ac5b13b3b6..a4d7222a345 100644 --- a/paddle/fluid/operators/jit/gen/gru.h +++ b/paddle/fluid/operators/jit/gen/gru.h @@ -30,13 +30,13 @@ class GRUJitCode : public VActFunc { void* code_ptr = nullptr) : VActFunc(code_size, code_ptr), id_(id), num_(attr.d) { auto typeExchange = [](KernelType type) -> gen::operand_type { - if (type == KernelType::vsigmoid) { + if (type == KernelType::kVSigmoid) { return operand_type::SIGMOID; - } else if (type == KernelType::vrelu) { + } else if (type == KernelType::kVRelu) { return operand_type::RELU; - } else if (type == KernelType::vtanh) { + } else if (type == KernelType::kVTanh) { return operand_type::TANH; - } else if (type == KernelType::videntity) { + } else if (type == KernelType::kVIdentity) { return operand_type::IDENTITY; } else { LOG(FATAL) << "Do not support this jit::KernelType: " << type; diff --git a/paddle/fluid/operators/jit/gen/lstm.cc b/paddle/fluid/operators/jit/gen/lstm.cc index 7e5a7773f83..08bafb5a818 100644 --- a/paddle/fluid/operators/jit/gen/lstm.cc +++ b/paddle/fluid/operators/jit/gen/lstm.cc @@ -138,5 +138,5 @@ DECLARE_LSTM_CREATOR(LSTMC1H1); namespace gen = paddle::operators::jit::gen; -REGISTER_JITKERNEL_GEN(lstmctht, gen::LSTMCtHtCreator); -REGISTER_JITKERNEL_GEN(lstmc1h1, gen::LSTMC1H1Creator); +REGISTER_JITKERNEL_GEN(kLSTMCtHt, gen::LSTMCtHtCreator); +REGISTER_JITKERNEL_GEN(kLSTMC1H1, gen::LSTMC1H1Creator); diff --git a/paddle/fluid/operators/jit/gen/lstm.h b/paddle/fluid/operators/jit/gen/lstm.h index f570648a0e7..d4753bca23d 100644 --- a/paddle/fluid/operators/jit/gen/lstm.h +++ b/paddle/fluid/operators/jit/gen/lstm.h @@ -33,13 +33,13 @@ class LSTMJitCode : public VActFunc { compute_c1h1_(compute_c1h1), use_peephole_(attr.use_peephole) { auto typeExchange = [](KernelType type) -> gen::operand_type { - if (type == KernelType::vsigmoid) { + if (type == KernelType::kVSigmoid) { return operand_type::SIGMOID; - } else if (type == KernelType::vrelu) { + } else if (type == KernelType::kVRelu) { return operand_type::RELU; - } else if (type == KernelType::vtanh) { + } else if (type == KernelType::kVTanh) { return operand_type::TANH; - } else if (type == KernelType::videntity) { + } else if (type == KernelType::kVIdentity) { return operand_type::IDENTITY; } else { LOG(FATAL) << "Do not support this jit::KernelType: " << type; diff --git a/paddle/fluid/operators/jit/helper.cc b/paddle/fluid/operators/jit/helper.cc index a1bb51fa666..d00584baa08 100644 --- a/paddle/fluid/operators/jit/helper.cc +++ b/paddle/fluid/operators/jit/helper.cc @@ -26,25 +26,25 @@ namespace jit { const char* to_string(KernelType kt) { switch (kt) { - ONE_CASE(vmul); - ONE_CASE(vadd); - ONE_CASE(vaddrelu); - ONE_CASE(vsub); - ONE_CASE(vscal); - ONE_CASE(vaddbias); - ONE_CASE(vrelu); - ONE_CASE(videntity); - ONE_CASE(vexp); - ONE_CASE(vsigmoid); - ONE_CASE(vtanh); - ONE_CASE(lstmctht); - ONE_CASE(lstmc1h1); - ONE_CASE(gruh1); - ONE_CASE(gruhtpart1); - ONE_CASE(gruhtpart2); - ONE_CASE(crfdecoding); - ONE_CASE(layernorm); - ONE_CASE(nchw16cmulnc); + ONE_CASE(kVMul); + ONE_CASE(kVAdd); + ONE_CASE(kVAddRelu); + ONE_CASE(kVSub); + ONE_CASE(kVScal); + ONE_CASE(kVAddBias); + ONE_CASE(kVRelu); + ONE_CASE(kVIdentity); + ONE_CASE(kVExp); + ONE_CASE(kVSigmoid); + ONE_CASE(kVTanh); + ONE_CASE(kLSTMCtHt); + ONE_CASE(kLSTMC1H1); + ONE_CASE(kGRUH1); + ONE_CASE(kGRUHtPart1); + ONE_CASE(kGRUHtPart2); + ONE_CASE(kCRFDecoding); + ONE_CASE(kLayerNorm); + ONE_CASE(kNCHW16CMulNC); default: PADDLE_THROW("Not support type: %d, or forget to add it.", kt); return "NOT JITKernel"; @@ -57,19 +57,18 @@ KernelType to_kerneltype(const std::string& act) { std::string lower = act; std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower); if (lower == "relu" || lower == "vrelu") { - return vrelu; + return kVRelu; } else if (lower == "identity" || lower == "videntity" || lower == "") { - return videntity; + return kVIdentity; } else if (lower == "exp" || lower == "vexp") { - return vexp; + return kVExp; } else if (lower == "sigmoid" || lower == "vsigmoid") { - return vsigmoid; + return kVSigmoid; } else if (lower == "tanh" || lower == "vtanh") { - return vtanh; + return kVTanh; } PADDLE_THROW("Not support type: %s, or forget to add this case", act); - - return non_kernel; + return kNone; } } // namespace jit diff --git a/paddle/fluid/operators/jit/kernel_base.h b/paddle/fluid/operators/jit/kernel_base.h index ae8f3d68fa3..b4a2d5d4730 100644 --- a/paddle/fluid/operators/jit/kernel_base.h +++ b/paddle/fluid/operators/jit/kernel_base.h @@ -21,26 +21,26 @@ namespace operators { namespace jit { typedef enum { - non_kernel = 0, - vmul = 1, - vadd = 2, - vaddrelu, - vsub, - vscal, - vaddbias, - vrelu, - videntity, - vexp, - vsigmoid, - vtanh, - lstmctht, - lstmc1h1, - gruh1, - gruhtpart1, - gruhtpart2, - crfdecoding, - layernorm, - nchw16cmulnc, + kNone = 0, + kVMul = 1, + kVAdd = 2, + kVAddRelu, + kVSub, + kVScal, + kVAddBias, + kVRelu, + kVIdentity, + kVExp, + kVSigmoid, + kVTanh, + kLSTMCtHt, + kLSTMC1H1, + kGRUH1, + kGRUHtPart1, + kGRUHtPart2, + kCRFDecoding, + kLayerNorm, + kNCHW16CMulNC, } KernelType; template diff --git a/paddle/fluid/operators/jit/more/intrinsic/CMakeLists.txt b/paddle/fluid/operators/jit/more/intrinsic/CMakeLists.txt index c4a50138636..468937a4f6b 100644 --- a/paddle/fluid/operators/jit/more/intrinsic/CMakeLists.txt +++ b/paddle/fluid/operators/jit/more/intrinsic/CMakeLists.txt @@ -5,5 +5,5 @@ cc_library(jit_kernel_intrinsic SRCS ${jit_kernel_cc_intrinsic} DEPS jit_kernel_ set(JIT_KERNEL_DEPS ${JIT_KERNEL_DEPS} jit_kernel_intrinsic PARENT_SCOPE) # use mkl kernels by name and type -USE_JITKERNEL_MORE(crfdecoding, intrinsic) -USE_JITKERNEL_MORE(layernorm, intrinsic) +USE_JITKERNEL_MORE(kCRFDecoding, intrinsic) +USE_JITKERNEL_MORE(kLayerNorm, intrinsic) diff --git a/paddle/fluid/operators/jit/more/intrinsic/crf_decoding.cc b/paddle/fluid/operators/jit/more/intrinsic/crf_decoding.cc index f446226c935..16c91f8246d 100644 --- a/paddle/fluid/operators/jit/more/intrinsic/crf_decoding.cc +++ b/paddle/fluid/operators/jit/more/intrinsic/crf_decoding.cc @@ -178,4 +178,4 @@ bool CRFDecodingKernel::UseMe(const int& d) const { namespace intrinsic = paddle::operators::jit::more::intrinsic; -REGISTER_JITKERNEL_MORE(crfdecoding, intrinsic, intrinsic::CRFDecodingKernel); +REGISTER_JITKERNEL_MORE(kCRFDecoding, intrinsic, intrinsic::CRFDecodingKernel); diff --git a/paddle/fluid/operators/jit/more/intrinsic/layer_norm.cc b/paddle/fluid/operators/jit/more/intrinsic/layer_norm.cc index 4b502fbf6bc..e9b6e401c68 100644 --- a/paddle/fluid/operators/jit/more/intrinsic/layer_norm.cc +++ b/paddle/fluid/operators/jit/more/intrinsic/layer_norm.cc @@ -165,4 +165,4 @@ bool LayerNormKernel::UseMe(const int& d) const { namespace intrinsic = paddle::operators::jit::more::intrinsic; -REGISTER_JITKERNEL_MORE(layernorm, intrinsic, intrinsic::LayerNormKernel); +REGISTER_JITKERNEL_MORE(kLayerNorm, intrinsic, intrinsic::LayerNormKernel); diff --git a/paddle/fluid/operators/jit/more/mix/CMakeLists.txt b/paddle/fluid/operators/jit/more/mix/CMakeLists.txt index 56765f874a6..e05f204b1ee 100644 --- a/paddle/fluid/operators/jit/more/mix/CMakeLists.txt +++ b/paddle/fluid/operators/jit/more/mix/CMakeLists.txt @@ -5,10 +5,10 @@ cc_library(jit_kernel_mix SRCS ${jit_kernel_mix_cc} DEPS jit_kernel_base) set(JIT_KERNEL_DEPS ${JIT_KERNEL_DEPS} jit_kernel_mix PARENT_SCOPE) -USE_JITKERNEL_MORE(vsigmoid, mix) -USE_JITKERNEL_MORE(vtanh, mix) -USE_JITKERNEL_MORE(lstmctht, mix) -USE_JITKERNEL_MORE(lstmc1h1, mix) -USE_JITKERNEL_MORE(gruh1, mix) -USE_JITKERNEL_MORE(gruhtpart1, mix) -USE_JITKERNEL_MORE(gruhtpart2, mix) +USE_JITKERNEL_MORE(kVSigmoid, mix) +USE_JITKERNEL_MORE(kVTanh, mix) +USE_JITKERNEL_MORE(kLSTMCtHt, mix) +USE_JITKERNEL_MORE(kLSTMC1H1, mix) +USE_JITKERNEL_MORE(kGRUH1, mix) +USE_JITKERNEL_MORE(kGRUHtPart1, mix) +USE_JITKERNEL_MORE(kGRUHtPart2, mix) diff --git a/paddle/fluid/operators/jit/more/mix/mix.cc b/paddle/fluid/operators/jit/more/mix/mix.cc index d9ecd7672e8..df0a85256b1 100644 --- a/paddle/fluid/operators/jit/more/mix/mix.cc +++ b/paddle/fluid/operators/jit/more/mix/mix.cc @@ -30,7 +30,7 @@ void VSigmoid(const T* x, T* y, int n) { y[i] = (x[i] < min) ? min : ((x[i] > max) ? max : x[i]); y[i] = static_cast(0) - y[i]; } - auto compute = Get, platform::CPUPlace>(n); + auto compute = Get, platform::CPUPlace>(n); compute(y, y, n); for (int i = 0; i < n; ++i) { y[i] = static_cast(1) / (static_cast(1) + y[i]); @@ -39,9 +39,9 @@ void VSigmoid(const T* x, T* y, int n) { void VTanh(const T* x, T* y, int n) { const T a = 2, b = -1; - auto compute_scal = Get, platform::CPUPlace>(n); - auto compute_addbias = Get, platform::CPUPlace>(n); - auto compute_sigmoid = Get, platform::CPUPlace>(n); + auto compute_scal = Get, platform::CPUPlace>(n); + auto compute_addbias = Get, platform::CPUPlace>(n); + auto compute_sigmoid = Get, platform::CPUPlace>(n); compute_scal(&a, x, y, n); compute_sigmoid(y, y, n); compute_scal(&a, y, y, n); @@ -49,14 +49,14 @@ void VTanh(const T* x, T* y, int n) { } void (*getActFunc(KernelType type, int d))(const T*, T*, int) { // NOLINT - if (type == vsigmoid) { - return Get, platform::CPUPlace>(d); - } else if (type == vrelu) { - return Get, platform::CPUPlace>(d); - } else if (type == vtanh) { - return Get, platform::CPUPlace>(d); - } else if (type == videntity) { - return Get, platform::CPUPlace>(d); + if (type == kVSigmoid) { + return Get, platform::CPUPlace>(d); + } else if (type == kVRelu) { + return Get, platform::CPUPlace>(d); + } else if (type == kVTanh) { + return Get, platform::CPUPlace>(d); + } else if (type == kVIdentity) { + return Get, platform::CPUPlace>(d); } PADDLE_THROW("Not support type: %s", type); return nullptr; @@ -72,9 +72,9 @@ void LSTMCtHt(lstm_t* step, const lstm_attr_t* attr) { const int d = attr->d; const int d2 = d * 2; const int d3 = d * 3; - auto vmul_d = Get, platform::CPUPlace>(d); - auto vadd_d = Get, platform::CPUPlace>(d); - auto vadd_d2 = Get, platform::CPUPlace>(d2); + auto vmul_d = Get, platform::CPUPlace>(d); + auto vadd_d = Get, platform::CPUPlace>(d); + auto vadd_d2 = Get, platform::CPUPlace>(d2); auto act_gate_d = getActFunc(attr->act_gate, d); auto act_gate_d2 = getActFunc(attr->act_gate, d2); auto act_gate_d3 = getActFunc(attr->act_gate, d3); @@ -114,8 +114,8 @@ void LSTMC1H1(lstm_t* step, const lstm_attr_t* attr) { int d = attr->d; int d2 = d * 2; int d3 = d * 3; - auto vmul_d = Get, platform::CPUPlace>(d); - auto vadd_d = Get, platform::CPUPlace>(d); + auto vmul_d = Get, platform::CPUPlace>(d); + auto vadd_d = Get, platform::CPUPlace>(d); auto act_gate_d = getActFunc(attr->act_gate, d); auto act_cand_d = getActFunc(attr->act_cand, d); auto act_cell_d = getActFunc(attr->act_cell, d); @@ -143,7 +143,7 @@ void GRUH1(gru_t* step, const gru_attr_t* attr) { int d2 = d * 2; auto act_gate = getActFunc(attr->act_gate, d); auto act_cand = getActFunc(attr->act_cand, d); - auto vmul_d = Get, platform::CPUPlace>(d); + auto vmul_d = Get, platform::CPUPlace>(d); act_gate(gates, gates, d); act_cand(gates + d2, gates + d2, d); vmul_d(gates, gates + d2, ht, d); @@ -156,7 +156,7 @@ void GRUHtPart1(gru_t* step, const gru_attr_t* attr) { T* ht = reinterpret_cast(step->ht); const T* ht_1 = reinterpret_cast(step->ht_1); auto act_gate = getActFunc(attr->act_gate, attr->d); - auto vmul_d = Get, platform::CPUPlace>(attr->d); + auto vmul_d = Get, platform::CPUPlace>(attr->d); act_gate(gates + attr->d, gates + attr->d, attr->d); vmul_d(ht_1, gates + attr->d, ht, attr->d); } @@ -205,12 +205,12 @@ namespace mix = paddle::operators::jit::more::mix; #define REGISTER_MORE_KERNEL(key, func) \ REGISTER_JITKERNEL_MORE(key, mix, mix::func##Kernel) -REGISTER_MORE_KERNEL(vsigmoid, VSigmoid); -REGISTER_MORE_KERNEL(vtanh, VTanh); -REGISTER_MORE_KERNEL(lstmctht, LSTMCtHt); -REGISTER_MORE_KERNEL(lstmc1h1, LSTMC1H1); -REGISTER_MORE_KERNEL(gruh1, GRUH1); -REGISTER_MORE_KERNEL(gruhtpart1, GRUHtPart1); -REGISTER_MORE_KERNEL(gruhtpart2, GRUHtPart2); +REGISTER_MORE_KERNEL(kVSigmoid, VSigmoid); +REGISTER_MORE_KERNEL(kVTanh, VTanh); +REGISTER_MORE_KERNEL(kLSTMCtHt, LSTMCtHt); +REGISTER_MORE_KERNEL(kLSTMC1H1, LSTMC1H1); +REGISTER_MORE_KERNEL(kGRUH1, GRUH1); +REGISTER_MORE_KERNEL(kGRUHtPart1, GRUHtPart1); +REGISTER_MORE_KERNEL(kGRUHtPart2, GRUHtPart2); #undef REGISTER_MORE_KERNEL diff --git a/paddle/fluid/operators/jit/more/mkl/CMakeLists.txt b/paddle/fluid/operators/jit/more/mkl/CMakeLists.txt index 3ecb520392e..863cc720d68 100644 --- a/paddle/fluid/operators/jit/more/mkl/CMakeLists.txt +++ b/paddle/fluid/operators/jit/more/mkl/CMakeLists.txt @@ -3,9 +3,9 @@ cc_library(jit_kernel_mkl SRCS mkl.cc DEPS jit_kernel_base dynload_mklml) set(JIT_KERNEL_DEPS ${JIT_KERNEL_DEPS} dynload_mklml jit_kernel_mkl PARENT_SCOPE) # use mkl kernels by name and type -USE_JITKERNEL_MORE(vmul, mkl) -USE_JITKERNEL_MORE(vadd, mkl) -USE_JITKERNEL_MORE(vscal, mkl) -USE_JITKERNEL_MORE(vexp, mkl) -USE_JITKERNEL_MORE(vsigmoid, mkl) -USE_JITKERNEL_MORE(vtanh, mkl) +USE_JITKERNEL_MORE(kVMul, mkl) +USE_JITKERNEL_MORE(kVAdd, mkl) +USE_JITKERNEL_MORE(kVScal, mkl) +USE_JITKERNEL_MORE(kVExp, mkl) +USE_JITKERNEL_MORE(kVSigmoid, mkl) +USE_JITKERNEL_MORE(kVTanh, mkl) diff --git a/paddle/fluid/operators/jit/more/mkl/mkl.cc b/paddle/fluid/operators/jit/more/mkl/mkl.cc index f4e334d88d4..a5b088d4812 100644 --- a/paddle/fluid/operators/jit/more/mkl/mkl.cc +++ b/paddle/fluid/operators/jit/more/mkl/mkl.cc @@ -129,11 +129,11 @@ namespace mkl = paddle::operators::jit::more::mkl; REGISTER_JITKERNEL_MORE(key, mkl, mkl::func##Kernel, \ mkl::func##Kernel) -REGISTER_MKL_KERNEL(vmul, VMul); -REGISTER_MKL_KERNEL(vadd, VAdd); -REGISTER_MKL_KERNEL(vscal, VScal); -REGISTER_MKL_KERNEL(vexp, VExp); -REGISTER_MKL_KERNEL(vsigmoid, VSigmoid); -REGISTER_MKL_KERNEL(vtanh, VTanh); +REGISTER_MKL_KERNEL(kVMul, VMul); +REGISTER_MKL_KERNEL(kVAdd, VAdd); +REGISTER_MKL_KERNEL(kVScal, VScal); +REGISTER_MKL_KERNEL(kVExp, VExp); +REGISTER_MKL_KERNEL(kVSigmoid, VSigmoid); +REGISTER_MKL_KERNEL(kVTanh, VTanh); #undef REGISTER_MKL_KERNEL diff --git a/paddle/fluid/operators/jit/refer/CMakeLists.txt b/paddle/fluid/operators/jit/refer/CMakeLists.txt index 86432bfffe7..07497b73205 100644 --- a/paddle/fluid/operators/jit/refer/CMakeLists.txt +++ b/paddle/fluid/operators/jit/refer/CMakeLists.txt @@ -7,22 +7,22 @@ function(USE_JITKERNEL_REFER TARGET) endfunction() # use refer kernel by name -USE_JITKERNEL_REFER(vmul) -USE_JITKERNEL_REFER(vadd) -USE_JITKERNEL_REFER(vaddrelu) -USE_JITKERNEL_REFER(vsub) -USE_JITKERNEL_REFER(vscal) -USE_JITKERNEL_REFER(vaddbias) -USE_JITKERNEL_REFER(vrelu) -USE_JITKERNEL_REFER(videntity) -USE_JITKERNEL_REFER(vexp) -USE_JITKERNEL_REFER(vsigmoid) -USE_JITKERNEL_REFER(vtanh) -USE_JITKERNEL_REFER(lstmctht) -USE_JITKERNEL_REFER(lstmc1h1) -USE_JITKERNEL_REFER(gruh1) -USE_JITKERNEL_REFER(gruhtpart1) -USE_JITKERNEL_REFER(gruhtpart2) -USE_JITKERNEL_REFER(crfdecoding) -USE_JITKERNEL_REFER(layernorm) -USE_JITKERNEL_REFER(nchw16cmulnc) +USE_JITKERNEL_REFER(kVMul) +USE_JITKERNEL_REFER(kVAdd) +USE_JITKERNEL_REFER(kVAddRelu) +USE_JITKERNEL_REFER(kVSub) +USE_JITKERNEL_REFER(kVScal) +USE_JITKERNEL_REFER(kVAddBias) +USE_JITKERNEL_REFER(kVRelu) +USE_JITKERNEL_REFER(kVIdentity) +USE_JITKERNEL_REFER(kVExp) +USE_JITKERNEL_REFER(kVSigmoid) +USE_JITKERNEL_REFER(kVTanh) +USE_JITKERNEL_REFER(kLSTMCtHt) +USE_JITKERNEL_REFER(kLSTMC1H1) +USE_JITKERNEL_REFER(kGRUH1) +USE_JITKERNEL_REFER(kGRUHtPart1) +USE_JITKERNEL_REFER(kGRUHtPart2) +USE_JITKERNEL_REFER(kCRFDecoding) +USE_JITKERNEL_REFER(kLayerNorm) +USE_JITKERNEL_REFER(kNCHW16CMulNC) diff --git a/paddle/fluid/operators/jit/refer/refer.cc b/paddle/fluid/operators/jit/refer/refer.cc index 1aee6ff9500..d196266326b 100644 --- a/paddle/fluid/operators/jit/refer/refer.cc +++ b/paddle/fluid/operators/jit/refer/refer.cc @@ -21,30 +21,30 @@ namespace refer = paddle::operators::jit::refer; REGISTER_JITKERNEL_REFER(key, refer::func##Kernel, \ refer::func##Kernel) -REGISTER_REFER_KERNEL(vmul, VMul); -REGISTER_REFER_KERNEL(vadd, VAdd); -REGISTER_REFER_KERNEL(vaddrelu, VAddRelu); -REGISTER_REFER_KERNEL(vsub, VSub); +REGISTER_REFER_KERNEL(kVMul, VMul); +REGISTER_REFER_KERNEL(kVAdd, VAdd); +REGISTER_REFER_KERNEL(kVAddRelu, VAddRelu); +REGISTER_REFER_KERNEL(kVSub, VSub); -REGISTER_REFER_KERNEL(vscal, VScal); -REGISTER_REFER_KERNEL(vaddbias, VAddBias); +REGISTER_REFER_KERNEL(kVScal, VScal); +REGISTER_REFER_KERNEL(kVAddBias, VAddBias); -REGISTER_REFER_KERNEL(vrelu, VRelu); -REGISTER_REFER_KERNEL(videntity, VIdentity); -REGISTER_REFER_KERNEL(vexp, VExp); -REGISTER_REFER_KERNEL(vsigmoid, VSigmoid); -REGISTER_REFER_KERNEL(vtanh, VTanh); +REGISTER_REFER_KERNEL(kVRelu, VRelu); +REGISTER_REFER_KERNEL(kVIdentity, VIdentity); +REGISTER_REFER_KERNEL(kVExp, VExp); +REGISTER_REFER_KERNEL(kVSigmoid, VSigmoid); +REGISTER_REFER_KERNEL(kVTanh, VTanh); -REGISTER_REFER_KERNEL(lstmctht, LSTMCtHt); -REGISTER_REFER_KERNEL(lstmc1h1, LSTMC1H1); +REGISTER_REFER_KERNEL(kLSTMCtHt, LSTMCtHt); +REGISTER_REFER_KERNEL(kLSTMC1H1, LSTMC1H1); -REGISTER_REFER_KERNEL(gruh1, GRUH1); -REGISTER_REFER_KERNEL(gruhtpart1, GRUHtPart1); -REGISTER_REFER_KERNEL(gruhtpart2, GRUHtPart2); +REGISTER_REFER_KERNEL(kGRUH1, GRUH1); +REGISTER_REFER_KERNEL(kGRUHtPart1, GRUHtPart1); +REGISTER_REFER_KERNEL(kGRUHtPart2, GRUHtPart2); -REGISTER_REFER_KERNEL(crfdecoding, CRFDecoding); -REGISTER_REFER_KERNEL(layernorm, LayerNorm); +REGISTER_REFER_KERNEL(kCRFDecoding, CRFDecoding); +REGISTER_REFER_KERNEL(kLayerNorm, LayerNorm); -REGISTER_REFER_KERNEL(nchw16cmulnc, NCHW16CMulNC); +REGISTER_REFER_KERNEL(kNCHW16CMulNC, NCHW16CMulNC); #undef REGISTER_REFER_KERNEL diff --git a/paddle/fluid/operators/jit/refer/refer.h b/paddle/fluid/operators/jit/refer/refer.h index 6f72c2b724b..0fd1b89dfdb 100644 --- a/paddle/fluid/operators/jit/refer/refer.h +++ b/paddle/fluid/operators/jit/refer/refer.h @@ -115,13 +115,13 @@ void VTanh(const T* x, T* y, int n) { template void (*getActFunc(KernelType type))(const T*, T*, int) { // NOLINT - if (type == vsigmoid) { + if (type == kVSigmoid) { return VSigmoid; - } else if (type == vrelu) { + } else if (type == kVRelu) { return VRelu; - } else if (type == vtanh) { + } else if (type == kVTanh) { return VTanh; - } else if (type == videntity) { + } else if (type == kVIdentity) { return VIdentity; } PADDLE_THROW("Not support type: %s", type); diff --git a/paddle/fluid/operators/jit/test.cc b/paddle/fluid/operators/jit/test.cc index c9194ec6b1f..a73e2a60aeb 100644 --- a/paddle/fluid/operators/jit/test.cc +++ b/paddle/fluid/operators/jit/test.cc @@ -469,111 +469,111 @@ void TestNCHW16CMulNCKernel() { } // XYZNTuple -TEST(JITKernel, vmul) { +TEST(JITKernel, kVMul) { namespace jit = paddle::operators::jit; - TestXYZNKernel(); - TestXYZNKernel(); + TestXYZNKernel(); + TestXYZNKernel(); } -TEST(JITKernel, vadd) { +TEST(JITKernel, kVAdd) { namespace jit = paddle::operators::jit; - TestXYZNKernel(); - TestXYZNKernel(); + TestXYZNKernel(); + TestXYZNKernel(); } -TEST(JITKernel, vaddrelu) { +TEST(JITKernel, kVAddRelu) { namespace jit = paddle::operators::jit; - TestXYZNKernel(); - TestXYZNKernel(); + TestXYZNKernel(); + TestXYZNKernel(); } -TEST(JITKernel, vsub) { +TEST(JITKernel, kVSub) { namespace jit = paddle::operators::jit; - TestXYZNKernel(); - TestXYZNKernel(); + TestXYZNKernel(); + TestXYZNKernel(); } // AXYNTuples -TEST(JITKernel, vscal) { +TEST(JITKernel, kVScal) { namespace jit = paddle::operators::jit; - TestAXYNKernel(); - TestAXYNKernel(); + TestAXYNKernel(); + TestAXYNKernel(); } -TEST(JITKernel, vaddbias) { +TEST(JITKernel, kVAddBias) { namespace jit = paddle::operators::jit; - TestAXYNKernel(); - TestAXYNKernel(); + TestAXYNKernel(); + TestAXYNKernel(); } // XYNTuples -TEST(JITKernel, vrelu) { +TEST(JITKernel, kVRelu) { namespace jit = paddle::operators::jit; - TestXYNKernel(); - TestXYNKernel(); + TestXYNKernel(); + TestXYNKernel(); } -TEST(JITKernel, videntity) { +TEST(JITKernel, kVIdentity) { namespace jit = paddle::operators::jit; - TestXYNKernel(); - TestXYNKernel(); + TestXYNKernel(); + TestXYNKernel(); } -TEST(JITKernel, vexp) { +TEST(JITKernel, kVExp) { namespace jit = paddle::operators::jit; - TestXYNKernel(); - TestXYNKernel(); + TestXYNKernel(); + TestXYNKernel(); } -TEST(JITKernel, vsigmoid) { +TEST(JITKernel, kVSigmoid) { namespace jit = paddle::operators::jit; - TestXYNKernel(); - TestXYNKernel(); + TestXYNKernel(); + TestXYNKernel(); } -TEST(JITKernel, vtanh) { +TEST(JITKernel, kVTanh) { namespace jit = paddle::operators::jit; - TestXYNKernel(); - TestXYNKernel(); + TestXYNKernel(); + TestXYNKernel(); } // LSTM -TEST(JITKernel, lstmctht) { +TEST(JITKernel, kLSTMCtHt) { namespace jit = paddle::operators::jit; - TestLSTMKernel(); - TestLSTMKernel(); + TestLSTMKernel(); + TestLSTMKernel(); } -TEST(JITKernel, lstmc1h1) { +TEST(JITKernel, kLSTMC1H1) { namespace jit = paddle::operators::jit; - TestLSTMKernel(); - TestLSTMKernel(); + TestLSTMKernel(); + TestLSTMKernel(); } // GRU -TEST(JITKernel, gruh1) { +TEST(JITKernel, kGRUH1) { namespace jit = paddle::operators::jit; - TestGRUKernel(); - TestGRUKernel(); + TestGRUKernel(); + TestGRUKernel(); } -TEST(JITKernel, gruhtpart1) { +TEST(JITKernel, kGRUHtPart1) { namespace jit = paddle::operators::jit; - TestGRUKernel(); - TestGRUKernel(); + TestGRUKernel(); + TestGRUKernel(); } -TEST(JITKernel, gruhtpart2) { +TEST(JITKernel, kGRUHtPart2) { namespace jit = paddle::operators::jit; - TestGRUKernel(); - TestGRUKernel(); + TestGRUKernel(); + TestGRUKernel(); } -TEST(JITKernel, nchw16cmulnc) { +TEST(JITKernel, kNCHW16CMulNC) { namespace jit = paddle::operators::jit; - TestNCHW16CMulNCKernel(); - TestNCHW16CMulNCKernel(); } diff --git a/paddle/fluid/operators/layer_norm_op.h b/paddle/fluid/operators/layer_norm_op.h index 0651dbf6a93..f564a103963 100644 --- a/paddle/fluid/operators/layer_norm_op.h +++ b/paddle/fluid/operators/layer_norm_op.h @@ -230,7 +230,7 @@ class LayerNormKernel : public framework::OpKernel { PADDLE_ENFORCE_EQ(bias->numel(), right); auto ker = - jit::Get, platform::CPUPlace>( + jit::Get, platform::CPUPlace>( right); ker(x.data(), out.data(), mean->data(), var->data(), scale->data(), bias->data(), static_cast(left), diff --git a/paddle/fluid/operators/math/fc_compute.h b/paddle/fluid/operators/math/fc_compute.h index bdb0d8511c9..cddd0a18db5 100644 --- a/paddle/fluid/operators/math/fc_compute.h +++ b/paddle/fluid/operators/math/fc_compute.h @@ -31,14 +31,14 @@ inline void FCCompute(const BlasT& blas, const int M, } if (relu) { auto compute = - jit::Get, platform::CPUPlace>(N); + jit::Get, platform::CPUPlace>(N); for (int i = 0; i < M; i++) { T* dst = Y + i * N; compute(B, dst, dst, N); } } else { auto compute = - jit::Get, platform::CPUPlace>(N); + jit::Get, platform::CPUPlace>(N); #ifdef PADDLE_WITH_MKLML #pragma omp parallel for #endif -- GitLab