// Copyright (c) 2022 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.

#include "paddle/phi/kernels/gelu_kernel.h"

#include "paddle/phi/backends/gpu/gpu_context.h"
#include "paddle/phi/common/amp_type_traits.h"
#include "paddle/phi/core/dense_tensor.h"
#include "paddle/phi/core/kernel_registry.h"
#include "paddle/phi/kernels/funcs/broadcast_function.h"
#include "paddle/phi/kernels/gpu/gelu_funcs.h"

COMMON_DECLARE_bool(use_fast_math);
COMMON_DECLARE_bool(use_accuracy_compatible_kernel);

namespace phi {

template <typename T>
struct GeluWithApproximateGradFunctor {
  using MT = typename MPTypeTrait<T>::Type;
  inline HOSTDEVICE T operator()(T arg_x, T arg_dout) {
    MT x = static_cast<MT>(arg_x);
    MT dout = static_cast<MT>(arg_dout);
    MT kBeta = M_SQRT2 * M_2_SQRTPI * static_cast<MT>(0.5);
    MT kKappa = static_cast<MT>(GELU_CONSTANT);
    auto x_sq = x * x;
    auto x_cube = x_sq * x;
    auto inner = kBeta * (x + kKappa * x_cube);
    auto tanh_inner = tanh(inner);

    auto left = static_cast<MT>(0.5) * x;
    auto right = static_cast<MT>(1) + tanh_inner;

    auto left_derivative = static_cast<MT>(0.5) * right;
    auto tanh_derivative = static_cast<MT>(1) - tanh_inner * tanh_inner;
    auto inner_derivative =
        kBeta * (static_cast<MT>(1) + static_cast<MT>(3) * kKappa * x_sq);
    auto right_derivative = left * tanh_derivative * inner_derivative;

    return static_cast<T>(dout * (left_derivative + right_derivative));
  }
};

template <typename T>
struct GeluWithoutApproximateGradFunctor {
  using MT = typename MPTypeTrait<T>::Type;
  inline HOSTDEVICE T operator()(T arg_x, T arg_dout) {
    MT x = static_cast<MT>(arg_x);
    MT dout = static_cast<MT>(arg_dout);
    constexpr MT kBeta = M_2_SQRTPI * M_SQRT1_2 * MT(0.5);
    constexpr MT kAlpha = M_SQRT1_2;
    const MT cdf = MT(0.5) * (MT(1) + std::erf(x * kAlpha));
    const MT pdf = exp(static_cast<MT>(-0.5) * x * x) * kBeta;
    return static_cast<T>(dout * (cdf + x * pdf));
  }
};

template <typename T, typename Context>
void GeluGradKernel(const Context& dev_ctx,
                    const DenseTensor& x,
                    const DenseTensor& out_grad,
                    bool approximate,
                    DenseTensor* x_grad) {
  dev_ctx.template Alloc<T>(x_grad);
  if (x_grad && x_grad->numel() == 0) {
    return;
  }
  std::vector<const DenseTensor*> ins = {&x, &out_grad};
  std::vector<DenseTensor*> outs = {x_grad};
  if (approximate) {
#if defined(__NVCC__) || defined(__HIPCC__)
    if (std::is_same<T, dtype::float16>::value &&
        !FLAGS_use_accuracy_compatible_kernel) {
      size_t n = x.numel();
      const auto* x_ptr = reinterpret_cast<const __half*>(x.data<T>());
      const auto* y_g_ptr = reinterpret_cast<const __half*>(out_grad.data<T>());
      auto* x_g_ptr = reinterpret_cast<__half*>(x_grad->data<T>());
      if (TryLaunchFP16FastGeluBwdVectorizeCUDAKernel(
              dev_ctx, x_ptr, y_g_ptr, x_g_ptr, n)) {
        return;
      }
    }
#endif
    using Functor = GeluWithApproximateGradFunctor<T>;
    funcs::ElementwiseKernel<T, Functor, 1>(dev_ctx, ins, &outs, Functor());
  } else {
    using Functor = GeluWithoutApproximateGradFunctor<T>;
    funcs::ElementwiseKernel<T, Functor, 1>(dev_ctx, ins, &outs, Functor());
  }
}

}  // namespace phi

PD_REGISTER_KERNEL(gelu_grad,
                   GPU,
                   ALL_LAYOUT,
                   phi::GeluGradKernel,
                   float,
                   double,
                   phi::float16,
                   phi::bfloat16) {}