optimize phi::CPUPlace in paddle/fluid/inference/ (#77208)

Author: co63oc

paddle/fluid/inference/analysis/passes/convert_to_mixed_precision.cc

@@ -74,7 +74,7 @@ ConvertToMixedPrecisionPass::ConvertToMixedPrecisionPass(
 }
 
 void ConvertToMixedPrecisionPass::LoadModel() {
-  framework::Executor exe{phi::CPUPlace{}};
+  framework::Executor exe{CPUPlace{}};
   // If we did not find the provided weight path,
   // we assume that the model to be converted only has a model file and no
   // params file, we believe this situation is reasonable. In this case, weight
@@ -177,7 +177,7 @@ void ConvertToMixedPrecisionPass::SaveMixedModel() {
     op->SetAttr("file_path", save_params_path);
     op->CheckAttrs();
 
-    framework::Executor exe(phi::CPUPlace{});
+    framework::Executor exe(CPUPlace{});
     exe.Run(save_program, &scope_, 0, true, true);
   };
 

paddle/fluid/inference/analysis/passes/ir_graph_build_pass.cc

@@ -42,7 +42,7 @@ void IrGraphBuildPass::RunImpl(Argument *argument) {
   // so that the parameters will on the same device, or they will keep copying
   // between difference devices.
   phi::Place place;
-  place = phi::CPUPlace();
+  place = CPUPlace();
 
   if (argument->model_dir_valid()) {
     auto program =

paddle/fluid/inference/analysis/passes/ir_params_sync_among_devices_pass.cc

@@ -53,7 +53,7 @@ void IrParamsSyncAmongDevicesPass::CopyParamsToGpu(Argument *argument) {
                     true,
                     common::errors::PreconditionNotMet(
                         "The gpu_device_id field should be valid"));
-  phi::Place place = phi::GPUPlace(argument->gpu_device_id());
+  phi::Place place = GPUPlace(argument->gpu_device_id());
   auto *scope = argument->scope_ptr();
   std::vector<std::string> all_vars = scope->LocalVarNames();
 
@@ -130,7 +130,7 @@ void IrParamsSyncAmongDevicesPass::CopyParamsToGpu(Argument *argument) {
       dst_ptr = dev_ctx->Alloc(t, t->dtype());
       phi::memory_utils::Copy(place,
                               dst_ptr,
-                              phi::CPUPlace(),
+                              CPUPlace(),
                               src_ptr,
                               t->numel() * phi::SizeOf(t->dtype()),
                               stream);
@@ -269,7 +269,7 @@ void IrParamsSyncAmongDevicesPass::RunImpl(Argument *argument) {
     CopyParamsToXpu(argument);
   }
 #endif
-  paddle::memory::Release(phi::CPUPlace());
+  paddle::memory::Release(CPUPlace());
 }
 
 std::string IrParamsSyncAmongDevicesPass::repr() const {

paddle/fluid/inference/analysis/passes/save_optimized_model_pass.cc

@@ -91,7 +91,7 @@ void SaveOptimizedModelPass::SaveOptimizedModel(Argument* argument) {
     op->SetAttr("file_path", save_params_path);
     op->CheckAttrs();
 
-    framework::Executor exe(phi::CPUPlace{});
+    framework::Executor exe(CPUPlace{});
     exe.Run(save_program, &scope, 0, true, true);
   };
   // TODO(shentanyue01): Setting hardware and version identification for

paddle/fluid/inference/io.cc

@@ -273,7 +273,7 @@ void SaveVars(const framework::Scope& scope,
   op->SetAttr("file_path", dirname + "/param");
   op->CheckAttrs();
 
-  phi::CPUPlace place;
+  CPUPlace place;
   framework::Executor exe(place);
   exe.Run(prog, const_cast<framework::Scope*>(&scope), 0, true, true);
 }

paddle/fluid/inference/tensorrt/convert/batch_norm_op.cc

@@ -70,18 +70,18 @@ class BatchNormOpConverter : public OpConverter {
     scale_tensor.Resize(Scale_t->dims());
     variance_tensor.Resize(Variance_t->dims());
 
-    phi::CPUPlace cpu_place;
+    CPUPlace cpu_place;
     // copy data from gpu to cpu
     paddle::framework::TensorCopySync((*Bias_t), cpu_place, &bias_tensor);
     paddle::framework::TensorCopySync((*Mean_t), cpu_place, &mean_tensor);
     paddle::framework::TensorCopySync((*Scale_t), cpu_place, &scale_tensor);
     paddle::framework::TensorCopySync(
         (*Variance_t), cpu_place, &variance_tensor);
 
-    auto* bias_data = bias_tensor.mutable_data<float>(phi::CPUPlace());
-    auto* mean_data = mean_tensor.mutable_data<float>(phi::CPUPlace());
-    auto* scale_data = scale_tensor.mutable_data<float>(phi::CPUPlace());
-    auto* variance_data = variance_tensor.mutable_data<float>(phi::CPUPlace());
+    auto* bias_data = bias_tensor.mutable_data<float>(CPUPlace());
+    auto* mean_data = mean_tensor.mutable_data<float>(CPUPlace());
+    auto* scale_data = scale_tensor.mutable_data<float>(CPUPlace());
+    auto* variance_data = variance_tensor.mutable_data<float>(CPUPlace());
 
     std::unique_ptr<phi::DenseTensor> combine_scale_tensor(
         new phi::DenseTensor());
@@ -92,9 +92,9 @@ class BatchNormOpConverter : public OpConverter {
     combine_bias_tensor->Resize(bias_tensor.dims());
 
     auto* combine_scale_data =
-        combine_scale_tensor->mutable_data<float>(phi::CPUPlace());
+        combine_scale_tensor->mutable_data<float>(CPUPlace());
     auto* combine_bias_data =
-        combine_bias_tensor->mutable_data<float>(phi::CPUPlace());
+        combine_bias_tensor->mutable_data<float>(CPUPlace());
 
     size_t ele_num = combine_scale_tensor->memory_size() / sizeof(float);
 

paddle/fluid/inference/tensorrt/convert/dropout_op.cc

@@ -45,10 +45,10 @@ class DropoutOpConverter : public OpConverter {
       return;
     }
 
-    phi::CPUPlace cpu_place;
+    CPUPlace cpu_place;
     std::unique_ptr<phi::DenseTensor> weight_tensor(new phi::DenseTensor());
     weight_tensor->Resize(common::make_ddim({1}));
-    auto* weight_data = weight_tensor->mutable_data<float>(phi::CPUPlace());
+    auto* weight_data = weight_tensor->mutable_data<float>(CPUPlace());
     weight_data[0] = 1 - dropout_prob;
 
     TensorRTEngine::Weight scale_weights{

paddle/fluid/inference/tensorrt/convert/fill_constant_op.cc

@@ -95,13 +95,13 @@ class FillConstantOpConverter : public OpConverter {
       void* trt_data = nullptr;
       size_t trt_num;
       if (dtype == 2 || dtype == 3) {  // int,int64
-        auto* tmp_ptr = out_tensor->mutable_data<int>(phi::CPUPlace());
+        auto* tmp_ptr = out_tensor->mutable_data<int>(CPUPlace());
         for (int64_t i = 0; i < out_tensor->numel(); i++)
           tmp_ptr[i] = std::stoi(str_value);
         trt_dtype = nvinfer1::DataType::kINT32;
         trt_data = static_cast<void*>(tmp_ptr);
       } else if (dtype == 5) {  // float
-        auto* tmp_ptr = out_tensor->mutable_data<float>(phi::CPUPlace());
+        auto* tmp_ptr = out_tensor->mutable_data<float>(CPUPlace());
         for (int64_t i = 0; i < out_tensor->numel(); i++)
           tmp_ptr[i] = std::stof(str_value);
         trt_data = static_cast<void*>(tmp_ptr);

paddle/fluid/inference/tensorrt/convert/gelu_op.cc

@@ -45,7 +45,7 @@ class GeluOpConverter : public OpConverter {
       auto create_weights = [&](float data, std::string type) -> float* {
         std::unique_ptr<phi::DenseTensor> tmp_tensor(new phi::DenseTensor());
         tmp_tensor->Resize({1});
-        auto* tmp_data = tmp_tensor->mutable_data<float>(phi::CPUPlace());
+        auto* tmp_data = tmp_tensor->mutable_data<float>(CPUPlace());
         tmp_data[0] = data;
         engine_->SetWeights(out_name + "_gelu_op_" + type,
                             std::move(tmp_tensor));
@@ -146,7 +146,7 @@ class GeluOpConverter : public OpConverter {
       auto create_weights = [&](float data, std::string type) -> float* {
         std::unique_ptr<phi::DenseTensor> tmp_tensor(new phi::DenseTensor());
         tmp_tensor->Resize({1});
-        auto* tmp_data = tmp_tensor->mutable_data<float>(phi::CPUPlace());
+        auto* tmp_data = tmp_tensor->mutable_data<float>(CPUPlace());
         tmp_data[0] = data;
         engine_->SetWeights(out_name + "_gelu_op_" + type,
                             std::move(tmp_tensor));

paddle/fluid/inference/tensorrt/convert/leaky_relu_op.cc

@@ -47,7 +47,7 @@ class LeakyReluOpConverter : public OpConverter {
       engine_->SetTensorDynamicRange(input, in_scale);
     }
 #else
-    phi::CPUPlace place;
+    CPUPlace place;
     std::unique_ptr<phi::DenseTensor> alpha_tensor(new phi::DenseTensor());
     alpha_tensor->Resize(common::make_ddim({2}));
     float* alpha_data = alpha_tensor->mutable_data<float>(place);