Replace framework::TransToPhiDataType to phi::TransToPhiDataType [fluid_ops] (#68869)

co63oc · web-flow · commit cea200b2f30c · 2024-10-23T19:11:27.000+08:00
diff --git a/paddle/fluid/distributed/ps/service/brpc_utils.cc b/paddle/fluid/distributed/ps/service/brpc_utils.cc
@@ -242,8 +242,7 @@ void DeserializeLodTensor(framework::Variable* var,
   tensor->set_lod(lod);
 
   void* tensor_data = tensor->mutable_data(
-      place,
-      framework::TransToPhiDataType(VarMessageToVarType(msg.data_type())));
+      place, phi::TransToPhiDataType(VarMessageToVarType(msg.data_type())));
 
   // IO Buffer
   if (phi::is_cpu_place(place)) {
@@ -287,8 +286,7 @@ void DeserializeSelectedRows(
   }
   tensor->Resize(common::make_ddim(vec_dim));
   void* tensor_data = tensor->mutable_data(
-      place,
-      framework::TransToPhiDataType(VarMessageToVarType(msg.data_type())));
+      place, phi::TransToPhiDataType(VarMessageToVarType(msg.data_type())));
   // IO Buffer
   if (phi::is_cpu_place(place)) {
     unsigned long data_len;                                 // NOLINT
diff --git a/paddle/fluid/framework/custom_operator.cc b/paddle/fluid/framework/custom_operator.cc
@@ -685,8 +685,7 @@ static void RunInferDtypeFunc(
       if (ctx->HasInput(in_name)) {  // general inputs
         for (size_t i = 0; i < ctx->InputSize(in_name); ++i) {
           auto dtype = ctx->GetInputDataType(in_name, static_cast<int>(i));
-          vec_custom_dtype.emplace_back(
-              paddle::framework::TransToPhiDataType(dtype));
+          vec_custom_dtype.emplace_back(phi::TransToPhiDataType(dtype));
         }
       } else {  // optional inputs, `vec_custom_dtype` is empty
         PADDLE_ENFORCE(
@@ -701,7 +700,7 @@ static void RunInferDtypeFunc(
     } else {
       if (ctx->HasInput(in_name)) {  // general inputs
         auto dtype = ctx->GetInputDataType(in_name);
-        input_dtypes.emplace_back(paddle::framework::TransToPhiDataType(dtype));
+        input_dtypes.emplace_back(phi::TransToPhiDataType(dtype));
       } else {  // optional inputs
         PADDLE_ENFORCE(
             detail::IsOptionalVar(in_name),
diff --git a/paddle/fluid/framework/fleet/heter_wrapper.cc b/paddle/fluid/framework/fleet/heter_wrapper.cc
@@ -167,7 +167,7 @@ void HeterWrapper::DeSerializeToTensor(Scope* scope,
   tensor->set_lod(lod);
 
   void* tensor_data = tensor->mutable_data(
-      place, framework::TransToPhiDataType(ToVarType(req_var.data_type())));
+      place, phi::TransToPhiDataType(ToVarType(req_var.data_type())));
 
 #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
   memory::Copy(place,
@@ -212,7 +212,7 @@ void HeterWrapper::DeSerializeToTensor(Scope* scope,
   tensor->set_lod(lod);
 
   void* tensor_data = tensor->mutable_data(
-      place, framework::TransToPhiDataType(ToVarType(req_var.data_type())));
+      place, phi::TransToPhiDataType(ToVarType(req_var.data_type())));
 
 #ifdef PADDLE_WITH_XPU
   memory::Copy(place,
diff --git a/paddle/fluid/framework/heter_section_worker.cc b/paddle/fluid/framework/heter_section_worker.cc
@@ -41,7 +41,7 @@ void SetMicroId(paddle::framework::Scope* scope,
   std::vector<int> dims{1};
   tensor->Resize(common::make_ddim(dims));
   void* tensor_data = tensor->mutable_data(
-      place, framework::TransToPhiDataType(framework::proto::VarType::FP32));
+      place, phi::TransToPhiDataType(framework::proto::VarType::FP32));
   if (phi::is_gpu_place(place)) {
 #ifdef PADDLE_WITH_CUDA
     std::vector<char> temp;
diff --git a/paddle/fluid/framework/infershape_utils.cc b/paddle/fluid/framework/infershape_utils.cc
@@ -262,7 +262,7 @@ phi::DataType CompatMetaTensor::dtype() const {
     }
   } else {
     auto* var = PADDLE_GET_CONST(VarDesc*, var_);
-    return paddle::framework::TransToPhiDataType(var->GetDataType());
+    return phi::TransToPhiDataType(var->GetDataType());
   }
 }
 
@@ -813,7 +813,7 @@ CompatInferMetaContext BuildInferMetaContext(InferShapeContext* ctx,
                   PADDLE_GET_CONST(std::vector<int>, attr));
               break;
             case phi::AttributeType::DATA_TYPE: {
-              auto data_type = paddle::framework::TransToPhiDataType(
+              auto data_type = phi::TransToPhiDataType(
                   static_cast<framework::proto::VarType::Type>(
                       PADDLE_GET_CONST(int, attr)));
               infer_meta_context.EmplaceBackAttr(data_type);
diff --git a/paddle/fluid/framework/ir/ipu/inference_dtype_transfer_pass.cc b/paddle/fluid/framework/ir/ipu/inference_dtype_transfer_pass.cc
@@ -83,8 +83,7 @@ void InferenceDtypeTransferPass::ApplyImpl(ir::Graph* graph) const {
             memcpy(reinterpret_cast<void*>(data_ptr),
                    fp16_data.data(),
                    num_elem * sizeof(float16));
-            tensor->set_type(
-                framework::TransToPhiDataType(proto::VarType::FP16));
+            tensor->set_type(phi::TransToPhiDataType(proto::VarType::FP16));
           }
         }
         used_var_names.insert(var_desc->Name());
diff --git a/paddle/fluid/framework/ir/onednn/compute_propagate_scales_onednn_pass_tester.cc b/paddle/fluid/framework/ir/onednn/compute_propagate_scales_onednn_pass_tester.cc
@@ -108,9 +108,8 @@ class ComputePropagateScalesMkldnnPassTest : public testing::Test {
     } else if (var_name == "wh") {
       tensor_size = wh.size();
     }
-    tensor->mutable_data(place,
-                         framework::TransToPhiDataType(proto::VarType::FP32),
-                         tensor_size);
+    tensor->mutable_data(
+        place, phi::TransToPhiDataType(proto::VarType::FP32), tensor_size);
   }
 
   void PrepareGraph(ir::Graph* graph,
diff --git a/paddle/fluid/framework/ir/onednn/cpu_quantize_pass_tester.cc b/paddle/fluid/framework/ir/onednn/cpu_quantize_pass_tester.cc
@@ -132,8 +132,7 @@ void InitTensorHolder(Scope* scope,
                       const char* var_name) {
   auto x = scope->Var(var_name);
   auto tensor = x->GetMutable<phi::DenseTensor>();
-  tensor->mutable_data(
-      place, framework::TransToPhiDataType(proto::VarType::FP32), 1);
+  tensor->mutable_data(place, phi::TransToPhiDataType(proto::VarType::FP32), 1);
 }
 
 void PreparePass(std::unique_ptr<ir::Graph>* graph,
diff --git a/paddle/fluid/framework/ir/onednn/cpu_quantize_squash_pass_tester.cc b/paddle/fluid/framework/ir/onednn/cpu_quantize_squash_pass_tester.cc
@@ -717,8 +717,7 @@ void InitTensorHolder(Scope* scope,
                       const char* var_name) {
   auto x = scope->Var(var_name);
   auto tensor = x->GetMutable<phi::DenseTensor>();
-  tensor->mutable_data(
-      place, framework::TransToPhiDataType(proto::VarType::FP32), 1);
+  tensor->mutable_data(place, phi::TransToPhiDataType(proto::VarType::FP32), 1);
 }
 
 void PrepareGraph(std::unique_ptr<ir::Graph>* graph, const ProgramDesc& prog) {
diff --git a/paddle/fluid/framework/ir/onednn/onednn_placement_pass.cc b/paddle/fluid/framework/ir/onednn/onednn_placement_pass.cc
@@ -54,8 +54,7 @@ inline bool FoundPhiOneDNNKernelWithCorrectDataType(
       if (!op->inputs.empty()) {
         if (op->inputs[0]->IsVar() && op->inputs[0]->Var()->Name() != "feed" &&
             kernel_pair.first.dtype() ==
-                framework::TransToPhiDataType(
-                    op->inputs[0]->Var()->GetDataType()))
+                phi::TransToPhiDataType(op->inputs[0]->Var()->GetDataType()))
           return true;
       } else {
         return true;
diff --git a/paddle/fluid/framework/lod_tensor.cc b/paddle/fluid/framework/lod_tensor.cc
@@ -504,8 +504,7 @@ void MergeLoDTensor(phi::DenseTensor *target,
   target->Resize(new_dim);
   target->set_layout(new_layout);
   target->set_lod(new_lod);
-  target->mutable_data(dst_place,
-                       paddle::framework::TransToPhiDataType(new_type));
+  target->mutable_data(dst_place, phi::TransToPhiDataType(new_type));
 
   int begin = 0;
   for (auto *src : lod_tensors) {
diff --git a/paddle/fluid/framework/new_executor/interpreter/data_transfer.cc b/paddle/fluid/framework/new_executor/interpreter/data_transfer.cc
@@ -597,7 +597,7 @@ void ApplyDataTransform(const OpKernelType& expected_kernel_key,
                     std::make_unique<phi::KernelKey>(
                         def_backend,
                         expected_kernel_key.data_layout_,
-                        framework::TransToPhiDataType(
+                        phi::TransToPhiDataType(
                             expected_kernel_key.data_type_));
 
                 VLOG(6) << "argument " << var_name
diff --git a/paddle/fluid/framework/new_executor/interpreter/static_build.cc b/paddle/fluid/framework/new_executor/interpreter/static_build.cc
@@ -540,8 +540,7 @@ void RunWhileBlockPreStaticBuild(const framework::Scope& scope,
     } else {
       VLOG(10) << "[while op]"
                << "skip backup input " << in_name << " type:"
-               << framework::TransToPhiDataType(
-                      framework::ToVarType(var->Type()));
+               << phi::TransToPhiDataType(framework::ToVarType(var->Type()));
     }
   }
 
diff --git a/paddle/fluid/framework/operator.cc b/paddle/fluid/framework/operator.cc
@@ -1394,11 +1394,10 @@ bool OperatorWithKernel::SupportXPU() const {
           op_kernels.end(),
           [this](OpKernelMap::const_reference kern_pair) {
             bool is_xpu_support1 = phi::backends::xpu::is_xpu_support_op(
-                type_,
-                framework::TransToPhiDataType(kern_pair.first.data_type_));
+                type_, phi::TransToPhiDataType(kern_pair.first.data_type_));
             bool is_xpu_support2 = phi::backends::xpu::is_xpu_support_op(
                 phi::TransToPhiKernelName(type_),
-                framework::TransToPhiDataType(kern_pair.first.data_type_));
+                phi::TransToPhiDataType(kern_pair.first.data_type_));
             return phi::is_xpu_place(kern_pair.first.place_) &&
                    (is_xpu_support1 || is_xpu_support2);
           });
@@ -1552,7 +1551,7 @@ bool OperatorWithKernel::SupportsKernelType(
   if (phi::is_xpu_place(kernel_type.place_)) {
     return kernel_iter != kernels.end() &&
            paddle::platform::is_xpu_support_op(
-               type_, framework::TransToPhiDataType(kernel_type.data_type_));
+               type_, phi::TransToPhiDataType(kernel_type.data_type_));
   }
 #endif
 
@@ -1561,7 +1560,7 @@ bool OperatorWithKernel::SupportsKernelType(
     bool use_xpu_kp_kernel_rt =
         FLAGS_run_kp_kernel &&
         paddle::platform::is_xpu_kp_support_op(
-            type_, framework::TransToPhiDataType(kernel_type.data_type_));
+            type_, phi::TransToPhiDataType(kernel_type.data_type_));
     bool use_xpu_kp_kernel_debug =
         paddle::platform::is_in_xpu_kpwhite_list(type_);
     bool is_xpu_kp_support = (use_xpu_kp_kernel_rt || use_xpu_kp_kernel_debug);
@@ -1572,7 +1571,7 @@ bool OperatorWithKernel::SupportsKernelType(
     }
     return kernel_iter != kernels.end() &&
            paddle::platform::is_xpu_support_op(
-               type_, framework::TransToPhiDataType(kernel_type.data_type_));
+               type_, phi::TransToPhiDataType(kernel_type.data_type_));
   }
 #endif
 
@@ -1704,8 +1703,7 @@ void OperatorWithKernel::CheckWhetherPreparePhiData(
           if (!(HasSameTensorType<phi::DenseTensor>(phi_output, var_output) ||
                 HasSameTensorType<phi::SparseCooTensor>(phi_output,
                                                         var_output) ||
-                HasSameTensorType<framework::Strings>(phi_output,
-                                                      var_output))) {
+                HasSameTensorType<phi::Strings>(phi_output, var_output))) {
             need_prepare_phi_data_ = true;
           }
           phi_tensor_index++;
@@ -1803,7 +1801,7 @@ void OperatorWithKernel::RunImpl(const Scope& scope,
         bool use_xpu_kp_kernel_rt =
             FLAGS_run_kp_kernel &&
             paddle::platform::is_xpu_kp_support_op(
-                type_, framework::TransToPhiDataType(kernel_type_->data_type_));
+                type_, phi::TransToPhiDataType(kernel_type_->data_type_));
         bool use_xpu_kp_kernel_debug =
             paddle::platform::is_in_xpu_kpwhite_list(type_);
         if (use_xpu_kp_kernel_rt) {
@@ -1887,7 +1885,7 @@ void OperatorWithKernel::RunImpl(const Scope& scope,
         bool use_xpu_kp_kernel_rt =
             FLAGS_run_kp_kernel &&
             paddle::platform::is_xpu_kp_support_op(
-                type_, framework::TransToPhiDataType(kernel_type_->data_type_));
+                type_, phi::TransToPhiDataType(kernel_type_->data_type_));
         bool use_xpu_kp_kernel_debug =
             paddle::platform::is_in_xpu_kpwhite_list(type_);
         if (use_xpu_kp_kernel_rt) {
@@ -1929,13 +1927,13 @@ void OperatorWithKernel::RunImpl(const Scope& scope,
     bool is_xpu_unsupport =
         phi::is_xpu_place(kernel_type_->place_) &&
         !paddle::platform::is_xpu_support_op(
-            type_, framework::TransToPhiDataType(kernel_type_->data_type_));
+            type_, phi::TransToPhiDataType(kernel_type_->data_type_));
 #endif
 #ifdef PADDLE_WITH_XPU_KP
     bool use_xpu_kp_kernel_rt =
         phi::is_xpu_place(kernel_type_->place_) && FLAGS_run_kp_kernel &&
         paddle::platform::is_xpu_kp_support_op(
-            type_, framework::TransToPhiDataType(kernel_type_->data_type_));
+            type_, phi::TransToPhiDataType(kernel_type_->data_type_));
     bool use_xpu_kp_kernel_debug =
         phi::is_xpu_place(kernel_type_->place_) &&
         paddle::platform::is_in_xpu_kpwhite_list(type_);
@@ -2363,8 +2361,7 @@ void OperatorWithKernel::ChooseKernel(const ExecutionContext& ctx) const {
   if (phi::is_xpu_place(expected_kernel_key.place_) &&
       (kernel_iter == kernels.end() ||
        !paddle::platform::is_xpu_support_op(
-           type_,
-           framework::TransToPhiDataType(expected_kernel_key.data_type_)))) {
+           type_, phi::TransToPhiDataType(expected_kernel_key.data_type_)))) {
     VLOG(3) << "fluid missing XPU kernel: " << type_
             << ", expected_kernel_key:" << expected_kernel_key
             << ", fallbacking to CPU one!";
@@ -2378,8 +2375,7 @@ void OperatorWithKernel::ChooseKernel(const ExecutionContext& ctx) const {
     bool use_xpu_kp_kernel_rt =
         FLAGS_run_kp_kernel &&
         paddle::platform::is_xpu_kp_support_op(
-            type_,
-            framework::TransToPhiDataType(expected_kernel_key.data_type_));
+            type_, phi::TransToPhiDataType(expected_kernel_key.data_type_));
     bool use_xpu_kp_kernel_debug =
         paddle::platform::is_in_xpu_kpwhite_list(type_);
     if (use_xpu_kp_kernel_rt) {
@@ -2408,7 +2404,7 @@ void OperatorWithKernel::ChooseKernel(const ExecutionContext& ctx) const {
       }
     }
     bool is_xpu_unsupport = (!paddle::platform::is_xpu_support_op(
-        type_, framework::TransToPhiDataType(expected_kernel_key.data_type_)));
+        type_, phi::TransToPhiDataType(expected_kernel_key.data_type_)));
     if (!is_xpu_kp_support &&
         (kernel_iter == kernels.end() || is_xpu_unsupport)) {
       VLOG(3) << "fluid missing XPU kernel: " << type_
@@ -3538,7 +3534,7 @@ void OperatorWithKernel::BuildPhiKernelContext(
                 PADDLE_GET_CONST(std::vector<bool>, attr_iter->second));
             break;
           case phi::AttributeType::DATA_TYPE: {
-            auto data_type = framework::TransToPhiDataType(
+            auto data_type = phi::TransToPhiDataType(
                 static_cast<framework::proto::VarType::Type>(
                     PADDLE_GET_CONST(int, attr_iter->second)));
             phi_kernel_context->EmplaceBackAttr(data_type);
diff --git a/paddle/fluid/framework/phi_utils.cc b/paddle/fluid/framework/phi_utils.cc
@@ -97,7 +97,7 @@ phi::KernelKey TransOpKernelTypeToPhiKernelKey(
   }
   return phi::KernelKey(backend,
                         kernel_type.data_layout_,
-                        framework::TransToPhiDataType(kernel_type.data_type_));
+                        phi::TransToPhiDataType(kernel_type.data_type_));
 }
 
 phi::KernelKey FallBackToCpu(const phi::KernelKey& kernel_key,
diff --git a/paddle/fluid/imperative/basic_engine.cc b/paddle/fluid/imperative/basic_engine.cc
@@ -162,8 +162,8 @@ void BasicEngine::CheckBackwardInputs(const OpBase& op) {
         // correct. var->DataType() returns the default dtype, which is float32.
         // Here, we use the type of the corresponding forward datatype.
 
-        tensor->mutable_data(
-            op.place(), framework::TransToPhiDataType(var->ForwardDataType()));
+        tensor->mutable_data(op.place(),
+                             phi::TransToPhiDataType(var->ForwardDataType()));
         VLOG(6) << "Set ungenerated Grad: " << var->Name()
                 << " as zero with dtype "
                 << framework::DataTypeToString(var->ForwardDataType());
diff --git a/paddle/fluid/imperative/gradient_accumulator.cc b/paddle/fluid/imperative/gradient_accumulator.cc
@@ -672,13 +672,11 @@ void EagerGradientAccumulator::SumGrad(std::shared_ptr<VariableWrapper> var,
         VLOG(6) << "Dims of " << dst_var->Name()
                 << " is set as: " << var->Var().Get<phi::DenseTensor>().dims();
         tensor->Resize(var->Var().Get<phi::DenseTensor>().dims());
-        tensor->mutable_data(place,
-                             framework::TransToPhiDataType(var->DataType()));
+        tensor->mutable_data(place, phi::TransToPhiDataType(var->DataType()));
         phi::funcs::set_constant(*dev_ctx, tensor, 0.0f);
       } else {
         auto* tensor = dst_var->MutableVar()->GetMutable<phi::DenseTensor>();
-        tensor->mutable_data(place,
-                             framework::TransToPhiDataType(var->DataType()));
+        tensor->mutable_data(place, phi::TransToPhiDataType(var->DataType()));
         phi::funcs::set_constant(*dev_ctx, tensor, 0.0f);
       }
     }
@@ -812,13 +810,11 @@ void SortedGradientAccumulator::SumGrad(std::shared_ptr<VariableWrapper> var,
         VLOG(6) << "Dims of " << dst_var->Name()
                 << " is set as: " << var->Var().Get<phi::DenseTensor>().dims();
         tensor->Resize(var->Var().Get<phi::DenseTensor>().dims());
-        tensor->mutable_data(place,
-                             framework::TransToPhiDataType(var->DataType()));
+        tensor->mutable_data(place, phi::TransToPhiDataType(var->DataType()));
         phi::funcs::set_constant(*dev_ctx, tensor, 0.0f);
       } else {
         auto* tensor = dst_var->MutableVar()->GetMutable<phi::DenseTensor>();
-        tensor->mutable_data(place,
-                             framework::TransToPhiDataType(var->DataType()));
+        tensor->mutable_data(place, phi::TransToPhiDataType(var->DataType()));
         phi::funcs::set_constant(*dev_ctx, tensor, 0.0f);
       }
     }
diff --git a/paddle/fluid/imperative/partial_grad_engine.cc b/paddle/fluid/imperative/partial_grad_engine.cc
@@ -331,10 +331,10 @@ static void FillConstantLike(const VariableWrapper &ref_var,
   if (ref_var.ForwardDataType() !=
       static_cast<framework::proto::VarType::Type>(-1)) {
     dst_tensor->mutable_data(
-        place, framework::TransToPhiDataType(ref_var.ForwardDataType()));
+        place, phi::TransToPhiDataType(ref_var.ForwardDataType()));
   } else {
     dst_tensor->mutable_data(place,
-                             framework::TransToPhiDataType(ref_var.DataType()));
+                             phi::TransToPhiDataType(ref_var.DataType()));
   }
   phi::funcs::set_constant(*dev_ctx, dst_tensor, value);
 }
diff --git a/paddle/fluid/imperative/prepared_operator.h b/paddle/fluid/imperative/prepared_operator.h
@@ -596,7 +596,7 @@ void BuildDygraphPhiKernelContext(const phi::KernelSignature& kernel_signature,
                 PADDLE_GET_CONST(std::vector<int>, attr));
             break;
           case phi::AttributeType::DATA_TYPE: {
-            auto data_type = framework::TransToPhiDataType(
+            auto data_type = phi::TransToPhiDataType(
                 static_cast<framework::proto::VarType::Type>(
                     PADDLE_GET_CONST(int, attr)));
             kernel_ctx->EmplaceBackAttr(data_type);
diff --git a/paddle/fluid/imperative/reducer.cc b/paddle/fluid/imperative/reducer.cc
@@ -748,7 +748,7 @@ void Reducer::MarkVarReady(const size_t var_index, const bool is_used_var) {
       if (!group_tensor.IsInitialized()) {
         group_tensor.Resize({static_cast<int64_t>(length)});
         group_tensor.mutable_data(place_,
-                                  framework::TransToPhiDataType(group.dtype_));
+                                  phi::TransToPhiDataType(group.dtype_));
       }
 
 #ifdef PADDLE_WITH_XPU_BKCL
@@ -850,7 +850,7 @@ void Reducer::MarkGroupReady(size_t group_index) {
 
     auto *tensor = group.dense_contents_.GetMutable<phi::DenseTensor>();
     tensor->Resize(common::make_ddim({group.all_length_}))
-        .mutable_data(place_, framework::TransToPhiDataType(group.dtype_));
+        .mutable_data(place_, phi::TransToPhiDataType(group.dtype_));
 
     // For CUDA or XPU, compute_stream --> comm_stream.
     // For CPU, do nothing.
diff --git a/paddle/fluid/inference/tensorrt/plugin/generic_plugin.cu b/paddle/fluid/inference/tensorrt/plugin/generic_plugin.cu
@@ -229,7 +229,7 @@ void BuildPhiKernelContextAttr(const framework::OpDesc& op_desc,
                   PADDLE_GET_CONST(std::vector<int>, attr));
               break;
             case phi::AttributeType::DATA_TYPE: {
-              auto data_type = paddle::framework::TransToPhiDataType(
+              auto data_type = phi::TransToPhiDataType(
                   static_cast<framework::proto::VarType::Type>(
                       PADDLE_GET_CONST(int, attr)));
               kernel_context->EmplaceBackAttr(data_type);
diff --git a/paddle/fluid/operators/controlflow/while_op.cc b/paddle/fluid/operators/controlflow/while_op.cc
@@ -163,8 +163,7 @@ class WhileOp : public framework::OperatorBase {
       } else {
         VLOG(10) << "[while op]"
                  << "skip backup input " << in_name << " type:"
-                 << framework::TransToPhiDataType(
-                        framework::ToVarType(var->Type()));
+                 << phi::TransToPhiDataType(framework::ToVarType(var->Type()));
       }
     }
 
diff --git a/paddle/fluid/operators/controlflow/while_op_helper.cc b/paddle/fluid/operators/controlflow/while_op_helper.cc
diff --git a/paddle/fluid/platform/device/ipu/ipu_executor.cc b/paddle/fluid/platform/device/ipu/ipu_executor.cc
diff --git a/paddle/fluid/prim/utils/static/desc_tensor.h b/paddle/fluid/prim/utils/static/desc_tensor.h
diff --git a/paddle/fluid/pybind/eager_math_op_patch.cc b/paddle/fluid/pybind/eager_math_op_patch.cc
diff --git a/paddle/fluid/pybind/eager_utils.cc b/paddle/fluid/pybind/eager_utils.cc
diff --git a/paddle/fluid/pybind/pybind.cc b/paddle/fluid/pybind/pybind.cc
diff --git a/paddle/fluid/pybind/tensor.cc b/paddle/fluid/pybind/tensor.cc
diff --git a/paddle/fluid/pybind/tensor_py.h b/paddle/fluid/pybind/tensor_py.h
diff --git a/test/cpp/fluid/framework/convert_utils_test.cc b/test/cpp/fluid/framework/convert_utils_test.cc
diff --git a/test/cpp/fluid/framework/data_type_test.cc b/test/cpp/fluid/framework/data_type_test.cc
diff --git a/test/cpp/imperative/test_group.cc b/test/cpp/imperative/test_group.cc

Original file line number	Diff line number	Diff line change
`@@ -262,7 +262,7 @@ phi::DataType CompatMetaTensor::dtype() const {`
`262`	`262`	`}`
`263`	`263`	`} else {`
`264`	`264`	`auto* var = PADDLE_GET_CONST(VarDesc*, var_);`
`265`		`- return paddle::framework::TransToPhiDataType(var->GetDataType());`
	`265`	`+ return phi::TransToPhiDataType(var->GetDataType());`
`266`	`266`	`}`
`267`	`267`	`}`
`268`	`268`
`@@ -813,7 +813,7 @@ CompatInferMetaContext BuildInferMetaContext(InferShapeContext* ctx,`
`813`	`813`	`PADDLE_GET_CONST(std::vector<int>, attr));`
`814`	`814`	`break;`
`815`	`815`	`case phi::AttributeType::DATA_TYPE: {`
`816`		`- auto data_type = paddle::framework::TransToPhiDataType(`
	`816`	`+ auto data_type = phi::TransToPhiDataType(`
`817`	`817`	`static_cast<framework::proto::VarType::Type>(`
`818`	`818`	`PADDLE_GET_CONST(int, attr)));`
`819`	`819`	`infer_meta_context.EmplaceBackAttr(data_type);`
Original file line number	Diff line number	Diff line change
`@@ -83,8 +83,7 @@ void InferenceDtypeTransferPass::ApplyImpl(ir::Graph* graph) const {`
`83`	`83`	`memcpy(reinterpret_cast<void*>(data_ptr),`
`84`	`84`	`fp16_data.data(),`
`85`	`85`	`num_elem * sizeof(float16));`
`86`		`- tensor->set_type(`
`87`		`- framework::TransToPhiDataType(proto::VarType::FP16));`
	`86`	`+ tensor->set_type(phi::TransToPhiDataType(proto::VarType::FP16));`
`88`	`87`	`}`
`89`	`88`	`}`
`90`	`89`	`used_var_names.insert(var_desc->Name());`
Original file line number	Diff line number	Diff line change
`@@ -108,9 +108,8 @@ class ComputePropagateScalesMkldnnPassTest : public testing::Test {`
`108`	`108`	`} else if (var_name == "wh") {`
`109`	`109`	`tensor_size = wh.size();`
`110`	`110`	`}`
`111`		`- tensor->mutable_data(place,`
`112`		`- framework::TransToPhiDataType(proto::VarType::FP32),`
`113`		`- tensor_size);`
	`111`	`+ tensor->mutable_data(`
	`112`	`+ place, phi::TransToPhiDataType(proto::VarType::FP32), tensor_size);`
`114`	`113`	`}`
`115`	`114`
`116`	`115`	`void PrepareGraph(ir::Graph* graph,`
Original file line number	Diff line number	Diff line change
`@@ -132,8 +132,7 @@ void InitTensorHolder(Scope* scope,`
`132`	`132`	`const char* var_name) {`
`133`	`133`	`auto x = scope->Var(var_name);`
`134`	`134`	`auto tensor = x->GetMutable<phi::DenseTensor>();`
`135`		`- tensor->mutable_data(`
`136`		`- place, framework::TransToPhiDataType(proto::VarType::FP32), 1);`
	`135`	`+ tensor->mutable_data(place, phi::TransToPhiDataType(proto::VarType::FP32), 1);`
`137`	`136`	`}`
`138`	`137`
`139`	`138`	`void PreparePass(std::unique_ptr<ir::Graph>* graph,`
Original file line number	Diff line number	Diff line change
`@@ -717,8 +717,7 @@ void InitTensorHolder(Scope* scope,`
`717`	`717`	`const char* var_name) {`
`718`	`718`	`auto x = scope->Var(var_name);`
`719`	`719`	`auto tensor = x->GetMutable<phi::DenseTensor>();`
`720`		`- tensor->mutable_data(`
`721`		`- place, framework::TransToPhiDataType(proto::VarType::FP32), 1);`
	`720`	`+ tensor->mutable_data(place, phi::TransToPhiDataType(proto::VarType::FP32), 1);`
`722`	`721`	`}`
`723`	`722`
`724`	`723`	`void PrepareGraph(std::unique_ptr<ir::Graph>* graph, const ProgramDesc& prog) {`