[Phi] Delete xpu kernel of fill_any_like and fill_constant in fluid (#45420)

* delete fill xpu op in fluid

* delete fill_constant header, test=kunlun

* fix npu header, test=kunlun

paddle/fluid/operators/fill_any_like_op_xpu.cc

-/* Copyright (c) 2021 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. */
-
-#ifdef PADDLE_WITH_XPU
-
-#include "paddle/fluid/framework/op_registry.h"
-#include "paddle/phi/kernels/full_kernel.h"
-
-namespace paddle {
-namespace operators {
-
-template <typename T>
-class FillAnyLikeXPUKernel : public framework::OpKernel<T> {
- public:
-  using CommonType = typename std::common_type<
-      float,
-      typename std::conditional<std::is_same<T, platform::float16>::value,
-                                float,
-                                T>::type>::type;
-  using XPUInTDType = typename XPUTypeTrait<T>::Type;
-
-  void Compute(const framework::ExecutionContext& context) const override {
-    auto* x = context.Input<framework::Tensor>("X");
-    auto* out = context.Output<framework::Tensor>("Out");
-    out->mutable_data<T>(context.GetPlace());
-
-    float value = context.Attr<float>("value");
-
-    auto common_type_value = static_cast<CommonType>(value);
-
-    PADDLE_ENFORCE_EQ(
-        (common_type_value >=
-         static_cast<CommonType>(std::numeric_limits<T>::lowest())) &&
-            (common_type_value <=
-             static_cast<CommonType>(std::numeric_limits<T>::max())),
-        true,
-        platform::errors::InvalidArgument(
-            "The filled value is out of range for target type, "
-            "current kernel type is %s, the range should between %f "
-            "and %f, but now value is %f.",
-            typeid(T).name(),
-            static_cast<CommonType>(std::numeric_limits<T>::lowest()),
-            static_cast<CommonType>(std::numeric_limits<T>::max()),
-            value));
-
-    PADDLE_ENFORCE_EQ(
-        std::isnan(value),
-        false,
-        platform::errors::InvalidArgument("The filled value is NaN."));
-
-    auto& dev_ctx =
-        context.template device_context<paddle::platform::XPUDeviceContext>();
-
-    // call phi kernel
-    phi::FullLikeKernel<T>(
-        static_cast<const typename paddle::framework::ConvertToPhiContext<
-            paddle::platform::XPUDeviceContext>::TYPE&>(dev_ctx),
-        *x,
-        value,
-        phi::DataType::UNDEFINED,
-        out);
-  }
-};
-
-}  // namespace operators
-}  // namespace paddle
-
-namespace ops = paddle::operators;
-
-REGISTER_OP_XPU_KERNEL(fill_any_like,
-                       ops::FillAnyLikeXPUKernel<int>,
-                       ops::FillAnyLikeXPUKernel<int64_t>,
-                       ops::FillAnyLikeXPUKernel<float>,
-                       ops::FillAnyLikeXPUKernel<paddle::platform::float16>);
-
-#endif

paddle/fluid/operators/fill_constant_batch_size_like_op_mlu.cc

@@ -13,7 +13,6 @@ See the License for the specific language governing permissions and
 limitations under the License. */
 
 #include "paddle/fluid/framework/op_registry.h"
-#include "paddle/fluid/operators/fill_constant_op.h"
 #include "paddle/fluid/operators/mlu/mlu_baseop.h"
 #include "paddle/fluid/operators/utils.h"
 

paddle/fluid/operators/fill_constant_batch_size_like_op_npu.cc

@@ -12,9 +12,10 @@ 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/fluid/operators/fill_constant_op.h"
+#include "paddle/fluid/framework/op_registry.h"
 #include "paddle/fluid/operators/utils.h"
 #include "paddle/fluid/platform/device/npu/npu_op_runner.h"
+#include "paddle/phi/kernels/funcs/math_function.h"
 
 namespace paddle {
 namespace operators {

paddle/fluid/operators/fill_constant_op.cc

@@ -12,11 +12,11 @@ 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/fluid/operators/fill_constant_op.h"
-
 #include <string>
 
+#include "paddle/fluid/framework/op_registry.h"
 #include "paddle/fluid/framework/op_version_registry.h"
+
 namespace paddle {
 namespace operators {
 

paddle/fluid/operators/fill_constant_op.h

-/* 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 <limits>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#include "paddle/fluid/framework/convert_utils.h"
-#include "paddle/fluid/framework/data_type.h"
-#include "paddle/fluid/framework/op_registry.h"
-#include "paddle/fluid/operators/utils.h"
-#include "paddle/phi/kernels/funcs/math_function.h"
-
-namespace paddle {
-namespace operators {
-
-using Tensor = framework::Tensor;
-
-template <typename T>
-class FillConstantKernel : public framework::OpKernel<T> {
- public:
-  void Compute(const paddle::framework::ExecutionContext &ctx) const override {
-    auto data_type =
-        static_cast<framework::proto::VarType::Type>(ctx.Attr<int>("dtype"));
-
-    auto str_value = ctx.Attr<std::string>("str_value");
-    auto float_value = ctx.Attr<float>("value");
-    auto force_cpu = ctx.Attr<bool>("force_cpu");
-    auto place_type = ctx.Attr<int>("place_type");
-    framework::Tensor *tensor = nullptr;
-
-    framework::Variable *out_var = ctx.OutputVar("Out");
-
-    T value;
-    if (str_value.empty()) {
-      value = static_cast<T>(float_value);
-    } else {
-      // handle NaN/Inf first, which cannot be read from stream.
-      if (str_value == "inf") {
-        value = static_cast<T>(std::numeric_limits<double>::infinity());
-      } else if (str_value == "-inf") {
-        value = static_cast<T>(-std::numeric_limits<double>::infinity());
-      } else if (str_value == "nan") {
-        value = static_cast<T>(std::numeric_limits<double>::quiet_NaN());
-      } else {
-        std::stringstream convert_stream(str_value);
-        if (std::is_same<int64_t, T>::value) {
-          int64_t tmp_value;
-          convert_stream >> tmp_value;
-          value = static_cast<T>(tmp_value);
-        } else {
-          double tmp_value;
-          convert_stream >> tmp_value;
-          value = static_cast<T>(tmp_value);
-        }
-      }
-    }
-    if (ctx.HasInput("ValueTensor")) {
-      auto *value_tensor = ctx.Input<framework::Tensor>("ValueTensor");
-      PADDLE_ENFORCE_EQ(
-          value_tensor->numel(),
-          1,
-          platform::errors::InvalidArgument(
-              "When use Tensor as value to set Tensor value in fill_cosntant, "
-              "value input(ValueTensor) size must be 1, but get %d",
-              value_tensor->numel()));
-      const T *tensor_data = value_tensor->data<T>();
-      framework::Tensor cpu_tensor;
-      auto tmp_place = value_tensor->place();
-      if (platform::is_gpu_place(tmp_place) ||
-          platform::is_xpu_place(tmp_place)) {
-        paddle::framework::TensorCopySync(
-            *value_tensor, platform::CPUPlace(), &cpu_tensor);
-        tensor_data = cpu_tensor.data<T>();
-      }
-      value = tensor_data[0];
-    }
-    auto shape = GetShape(ctx);
-
-    if (out_var->IsType<framework::LoDTensor>()) {
-      tensor = out_var->GetMutable<framework::LoDTensor>();
-      tensor->Resize(shape);
-    } else if (out_var->IsType<phi::SelectedRows>()) {
-      tensor = out_var->GetMutable<phi::SelectedRows>()->mutable_value();
-      tensor->Resize(shape);
-    } else {
-      PADDLE_THROW(platform::errors::Unimplemented(
-          "In fill constant Op, the output only supports SelectedRows and "
-          "LoDTensor."));
-    }
-
-    platform::DeviceContextPool &pool = platform::DeviceContextPool::Instance();
-    int actual_place = place_type;
-
-    if (actual_place == -1) {
-      bool cpu_place = (force_cpu || ctx.GetPlace() == platform::CPUPlace() ||
-                        data_type == framework::proto::VarType::BF16);
-      if (cpu_place) {
-        actual_place = 0;
-      } else if (platform::is_gpu_place(ctx.GetPlace())) {
-        actual_place = 1;
-      } else if (platform::is_xpu_place(ctx.GetPlace())) {
-        actual_place = 3;
-      }
-    }
-
-    if (actual_place == 0) {
-      VLOG(4) << "[CPU] FillConstantKernel"
-              << ((data_type == framework::proto::VarType::BF16) ? "<bfloat16>"
-                                                                 : "<T>");
-      tensor->mutable_data(platform::CPUPlace(),
-                           framework::TransToPhiDataType(data_type));
-      phi::funcs::SetConstant<phi::CPUContext, T> functor;
-      auto &dev_ctx = *pool.Get(platform::CPUPlace());
-      functor(reinterpret_cast<const phi::CPUContext &>(dev_ctx),
-              tensor,
-              static_cast<T>(value));
-    } else if (actual_place == 1) {
-#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
-      tensor->mutable_data(ctx.GetPlace(),
-                           framework::TransToPhiDataType(data_type));
-      phi::funcs::SetConstant<phi::GPUContext, T> functor;
-      auto &dev_ctx = *pool.Get(ctx.GetPlace());
-      functor(reinterpret_cast<const phi::GPUContext &>(dev_ctx),
-              tensor,
-              static_cast<T>(value));
-#else
-      PADDLE_THROW(platform::errors::PreconditionNotMet(
-          "PaddlePaddle should compile with GPU."));
-#endif
-    } else if (actual_place == 2) {
-#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
-      tensor->mutable_data(platform::CUDAPinnedPlace(),
-                           framework::TransToPhiDataType(data_type));
-      phi::funcs::SetConstant<platform::CUDAPinnedDeviceContext, T> functor;
-      auto &dev_ctx = *pool.Get(platform::CUDAPinnedPlace());
-      functor(
-          reinterpret_cast<const platform::CUDAPinnedDeviceContext &>(dev_ctx),
-          tensor,
-          static_cast<T>(value));
-#else
-      PADDLE_THROW(platform::errors::PreconditionNotMet(
-          "PaddlePaddle should compile with GPU."));
-#endif
-    } else if (actual_place == 3) {
-#ifdef PADDLE_WITH_XPU
-      tensor->mutable_data(ctx.GetPlace(),
-                           framework::TransToPhiDataType(data_type));
-      phi::funcs::SetConstant<platform::XPUDeviceContext, T> functor;
-      auto &dev_ctx = *pool.Get(ctx.GetPlace());
-      functor(reinterpret_cast<const platform::XPUDeviceContext &>(dev_ctx),
-              tensor,
-              static_cast<T>(value));
-#else
-      PADDLE_THROW(platform::errors::PreconditionNotMet(
-          "PaddlePaddle should compile with XPU."));
-#endif
-    } else {
-      PADDLE_THROW(platform::errors::Unimplemented(
-          "Could NOT determine the place of variable, place_type = %d .",
-          actual_place));
-    }
-  }
-};
-}  // namespace operators
-}  // namespace paddle

paddle/fluid/operators/fill_constant_op_mlu.cc

@@ -12,7 +12,7 @@ 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/fluid/operators/fill_constant_op.h"
+#include "paddle/fluid/framework/op_registry.h"
 #include "paddle/fluid/operators/mlu/mlu_baseop.h"
 
 namespace paddle {

paddle/fluid/operators/fill_constant_op_npu.cc

@@ -12,7 +12,7 @@ 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/fluid/operators/fill_constant_op.h"
+#include "paddle/fluid/framework/op_registry.h"
 #include "paddle/fluid/operators/utils.h"
 #include "paddle/fluid/platform/device/npu/npu_op_runner.h"
 

paddle/fluid/operators/fill_constant_op_xpu.cc

-/* Copyright (c) 2020 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/fluid/operators/fill_constant_op.h"
-
-namespace ops = paddle::operators;
-#ifdef PADDLE_WITH_XPU
-REGISTER_OP_XPU_KERNEL(
-    fill_constant,
-    ops::FillConstantKernel<float>,
-    ops::FillConstantKernel<double>,
-    ops::FillConstantKernel<uint8_t>,
-    ops::FillConstantKernel<int16_t>,
-    ops::FillConstantKernel<int>,
-    ops::FillConstantKernel<int64_t>,
-    ops::FillConstantKernel<bool>,
-    ops::FillConstantKernel<paddle::platform::float16>,
-    ops::FillConstantKernel<paddle::platform::complex<float>>,
-    ops::FillConstantKernel<paddle::platform::complex<double>>);
-#endif

paddle/fluid/operators/gaussian_random_op.cc

@@ -18,7 +18,6 @@ limitations under the License. */
 #include "paddle/fluid/framework/infershape_utils.h"
 #include "paddle/fluid/framework/op_registry.h"
 #include "paddle/fluid/framework/op_version_registry.h"
-#include "paddle/fluid/operators/fill_constant_op.h"
 #ifdef PADDLE_WITH_MKLDNN
 #include "paddle/fluid/platform/mkldnn_helper.h"
 #endif

paddle/fluid/operators/gaussian_random_op.cu

@@ -17,7 +17,6 @@ limitations under the License. */
 #include "paddle/fluid/framework/op_registry.h"
 #include "paddle/fluid/framework/operator.h"
 #include "paddle/fluid/operators/amp/fp16_type_traits.h"
-#include "paddle/fluid/operators/fill_constant_op.h"
 #include "paddle/phi/kernels/funcs/index_impl.cu.h"
 
 namespace paddle {

paddle/fluid/operators/gaussian_random_op_npu.cc

@@ -18,7 +18,6 @@ limitations under the License. */
 #include "paddle/fluid/framework/generator.h"
 #include "paddle/fluid/framework/op_registry.h"
 #include "paddle/fluid/framework/op_version_registry.h"
-#include "paddle/fluid/operators/fill_constant_op.h"
 #ifdef PADDLE_WITH_MKLDNN
 #include "paddle/fluid/platform/mkldnn_helper.h"
 #endif

paddle/fluid/operators/index_impl.cu.h

@@ -20,7 +20,6 @@ limitations under the License. */
 #include "paddle/fluid/framework/op_registry.h"
 #include "paddle/fluid/framework/operator.h"
 #include "paddle/fluid/operators/amp/fp16_type_traits.h"
-#include "paddle/fluid/operators/fill_constant_op.h"
 #include "paddle/phi/backends/gpu/gpu_launch_config.h"
 #include "paddle/phi/core/hostdevice.h"
 #include "paddle/phi/kernels/funcs/aligned_vector.h"

paddle/fluid/operators/mkldnn/gaussian_random_mkldnn_op.cc

@@ -15,7 +15,8 @@ limitations under the License. */
 #include <string>
 
 #include "paddle/fluid/framework/generator.h"
-#include "paddle/fluid/operators/fill_constant_op.h"
+#include "paddle/fluid/framework/op_registry.h"
+#include "paddle/fluid/operators/utils.h"
 #include "paddle/fluid/platform/mkldnn_reuse.h"
 
 namespace paddle {