[Lod][fluid_ops] LoDTensor2BatchFunctor (#70007)

co63oc · web-flow · commit 1a38fee97df2 · 2024-12-09T11:43:58.000+08:00
* Fix

* Fix
diff --git a/paddle/fluid/framework/new_executor/interpreter/data_transfer.cc b/paddle/fluid/framework/new_executor/interpreter/data_transfer.cc
@@ -238,7 +238,7 @@ void DataTransferHelper::RunAndConstructOpFuncNode(
 bool IsTensorOfVarInitialized(Variable* var) {
   if (var->IsInitialized()) {
     if (var->IsType<phi::DenseTensor>() || var->IsType<phi::SelectedRows>()) {
-      return GetLoDTensorOrSelectedRowsValueFromVar(*var)->IsInitialized();
+      return GetDenseTensorOrSelectedRowsValueFromVar(*var)->IsInitialized();
     } else if (var->IsType<phi::TensorArray>()) {
       return static_cast<const phi::DenseTensor*>(
                  &(var->Get<phi::TensorArray>()[0]))
@@ -509,7 +509,7 @@ void ApplyDataTransform(const OpKernelType& expected_kernel_key,
           const phi::DenseTensor* tensor_in = nullptr;
           if (var->IsType<phi::DenseTensor>() ||
               var->IsType<phi::SelectedRows>()) {
-            tensor_in = GetLoDTensorOrSelectedRowsValueFromVar(*var);
+            tensor_in = GetDenseTensorOrSelectedRowsValueFromVar(*var);
           } else if (var->IsType<phi::TensorArray>()) {
             if (var->Get<phi::TensorArray>().empty()) {
               continue;
@@ -800,7 +800,7 @@ void HandleComplexGradToRealGrad(const OpFuncNode& op_func_node,
         continue;
       }
       const auto* tensor =
-          framework::GetLoDTensorOrSelectedRowsValueFromVar(*var);
+          framework::GetDenseTensorOrSelectedRowsValueFromVar(*var);
       PADDLE_ENFORCE_NOT_NULL(
           tensor,
           common::errors::Unavailable(
diff --git a/paddle/fluid/framework/operator.cc b/paddle/fluid/framework/operator.cc
@@ -1094,7 +1094,7 @@ void OperatorBase::GenerateTemporaryNames() {
   }
 }
 
-const phi::DenseTensor* GetLoDTensorOrSelectedRowsValueFromVar(
+const phi::DenseTensor* GetDenseTensorOrSelectedRowsValueFromVar(
     const Variable& var) {
   if (var.IsType<phi::DenseTensor>()) {
     return static_cast<const phi::DenseTensor*>(&(var.Get<phi::DenseTensor>()));
@@ -2467,7 +2467,7 @@ void OperatorWithKernel::TransferInplaceVarsBack(
     PADDLE_ENFORCE_NOT_NULL(var,
                             common::errors::InvalidArgument(
                                 "The variable[%s] is nullptr.", var_name));
-    auto* transformed_tensor = GetLoDTensorOrSelectedRowsValueFromVar(*var);
+    auto* transformed_tensor = GetDenseTensorOrSelectedRowsValueFromVar(*var);
     original_tensor->ShareDataWith(*transformed_tensor);
   }
 }
@@ -2515,7 +2515,7 @@ void OperatorWithKernel::HandleComplexGradToRealGrad(
       if (!VarIsTensor(*var)) {
         continue;
       }
-      const auto* tensor = GetLoDTensorOrSelectedRowsValueFromVar(*var);
+      const auto* tensor = GetDenseTensorOrSelectedRowsValueFromVar(*var);
       PADDLE_ENFORCE_NOT_NULL(
           tensor,
           common::errors::Unavailable(
@@ -2582,7 +2582,7 @@ Scope* OperatorWithKernel::PrepareData(
         continue;
       }
 
-      auto* tensor_in = GetLoDTensorOrSelectedRowsValueFromVar(*var);
+      auto* tensor_in = GetDenseTensorOrSelectedRowsValueFromVar(*var);
 
       // When no_buffer_ins then checking of phi::DenseTensor::holder_ is
       // not a thread safe. And for infershape scenario checks
diff --git a/paddle/fluid/framework/operator.h b/paddle/fluid/framework/operator.h
@@ -131,7 +131,7 @@ inline bool VarIsTensor(const Variable& var) {
   return var.IsType<phi::DenseTensor>() || var.IsType<phi::SelectedRows>();
 }
 
-const phi::DenseTensor* GetLoDTensorOrSelectedRowsValueFromVar(
+const phi::DenseTensor* GetDenseTensorOrSelectedRowsValueFromVar(
     const Variable& var);
 phi::DenseTensor* GetMutableLoDTensorOrSelectedRowsValueFromVar(Variable* var);
 
diff --git a/paddle/fluid/operators/sum_op.cc b/paddle/fluid/operators/sum_op.cc
@@ -53,7 +53,7 @@ class SumOp : public framework::OperatorWithKernel {
             common::errors::NotFound("Input var[%s] should not be nullptr",
                                      x_vars_name[idx]));
         auto tensor =
-            framework::GetLoDTensorOrSelectedRowsValueFromVar(*x_vars[idx]);
+            framework::GetDenseTensorOrSelectedRowsValueFromVar(*x_vars[idx]);
         if (!tensor->IsInitialized()) {
           continue;
         }
diff --git a/paddle/fluid/operators/tensor_array_to_tensor_op.cc b/paddle/fluid/operators/tensor_array_to_tensor_op.cc
@@ -73,7 +73,7 @@ void DenseTensorArrayCreateFromDenseTensorArray(
   }
 }
 
-class LoDTensorArray2TensorOp : public framework::OperatorBase {
+class DenseTensorArray2TensorOp : public framework::OperatorBase {
  public:
   using OperatorBase::OperatorBase;
 
@@ -128,7 +128,8 @@ class LoDTensorArray2TensorOp : public framework::OperatorBase {
   }
 };
 
-class LoDTensorArray2TensorOpMaker : public framework::OpProtoAndCheckerMaker {
+class DenseTensorArray2TensorOpMaker
+    : public framework::OpProtoAndCheckerMaker {
  public:
   void Make() override {
     AddInput("X", "Input phi::TensorArray of tensor_array_to_tensor operator.");
@@ -170,7 +171,7 @@ the output Tensor.
   }
 };
 
-class LoDTensorArray2TensorOpInferShape : public framework::InferShapeBase {
+class DenseTensorArray2TensorOpInferShape : public framework::InferShapeBase {
  public:
   void operator()(framework::InferShapeContext *ctx) const override {
     // in runtime, shape is determined by RunImpl
@@ -195,14 +196,14 @@ class LoDTensorArray2TensorOpInferShape : public framework::InferShapeBase {
   }
 };
 
-class LoDTensorArray2TensorGradInferShape : public framework::InferShapeBase {
+class DenseTensorArray2TensorGradInferShape : public framework::InferShapeBase {
  public:
   void operator()(framework::InferShapeContext *ctx) const override {
     ctx->SetOutputDim(framework::GradVarName("X"), ctx->GetInputDim("X"));
   }
 };
 
-class LoDTensorArray2TensorGradInferVarType
+class DenseTensorArray2TensorGradInferVarType
     : public framework::VarTypeInference {
  public:
   void operator()(framework::InferVarTypeContext *ctx) const override {
@@ -212,7 +213,7 @@ class LoDTensorArray2TensorGradInferVarType
   }
 };
 
-class LoDTensorArray2TensorGradOp : public framework::OperatorBase {
+class DenseTensorArray2TensorGradOp : public framework::OperatorBase {
  public:
   using OperatorBase::OperatorBase;
 
@@ -298,12 +299,12 @@ USE_OP_ITSELF(concat);
 namespace ops = paddle::operators;
 REGISTER_OPERATOR(
     tensor_array_to_tensor,
-    ops::LoDTensorArray2TensorOp,
-    ops::LoDTensorArray2TensorOpMaker,
-    ops::LoDTensorArray2TensorOpInferShape,
+    ops::DenseTensorArray2TensorOp,
+    ops::DenseTensorArray2TensorOpMaker,
+    ops::DenseTensorArray2TensorOpInferShape,
     ops::TensorArrayToTensorGradOpMaker<paddle::framework::OpDesc>,
     ops::TensorArrayToTensorGradOpMaker<paddle::imperative::OpBase>);
 REGISTER_OPERATOR(tensor_array_to_tensor_grad,
-                  ops::LoDTensorArray2TensorGradOp,
-                  ops::LoDTensorArray2TensorGradInferShape,
-                  ops::LoDTensorArray2TensorGradInferVarType);
+                  ops::DenseTensorArray2TensorGradOp,
+                  ops::DenseTensorArray2TensorGradInferShape,
+                  ops::DenseTensorArray2TensorGradInferVarType);
diff --git a/paddle/phi/kernels/cpu/gru_kernel.cc b/paddle/phi/kernels/cpu/gru_kernel.cc
@@ -69,7 +69,7 @@ void GRUCPUKernel(const Context &dev_ctx,
   dev_ctx.template Alloc<T>(batch_reset_hidden_prev);
   dev_ctx.template Alloc<T>(batch_hidden);
 
-  phi::funcs::LoDTensor2BatchFunctor<Context, T> to_batch;
+  phi::funcs::DenseTensor2BatchFunctor<Context, T> to_batch;
   to_batch(dev_ctx, input, batch_gate, true, is_reverse);
 
   if (bias) {
@@ -231,7 +231,7 @@ void GRUCPUKernel(const Context &dev_ctx,
 #ifdef PADDLE_WITH_MKLML
   }
 #endif
-  phi::funcs::Batch2LoDTensorFunctor<Context, T> to_seq;
+  phi::funcs::Batch2DenseTensorFunctor<Context, T> to_seq;
   batch_hidden->set_lod(batch_gate->lod());
   to_seq(dev_ctx, *batch_hidden, hidden);
 }
diff --git a/paddle/phi/kernels/funcs/sequence2batch.cc b/paddle/phi/kernels/funcs/sequence2batch.cc
@@ -70,9 +70,9 @@ class CopyMatrixRowsFunctor<phi::CPUContext, T> {
 template class CopyMatrixRowsFunctor<phi::CPUContext, float>;
 template class CopyMatrixRowsFunctor<phi::CPUContext, double>;
 
-template class LoDTensor2BatchFunctor<phi::CPUContext, float>;
-template class LoDTensor2BatchFunctor<phi::CPUContext, double>;
-template class Batch2LoDTensorFunctor<phi::CPUContext, float>;
-template class Batch2LoDTensorFunctor<phi::CPUContext, double>;
+template class DenseTensor2BatchFunctor<phi::CPUContext, float>;
+template class DenseTensor2BatchFunctor<phi::CPUContext, double>;
+template class Batch2DenseTensorFunctor<phi::CPUContext, float>;
+template class Batch2DenseTensorFunctor<phi::CPUContext, double>;
 
 }  // namespace phi::funcs
diff --git a/paddle/phi/kernels/funcs/sequence2batch.cu b/paddle/phi/kernels/funcs/sequence2batch.cu
@@ -93,10 +93,10 @@ class CopyMatrixRowsFunctor<phi::GPUContext, T> {
 template class CopyMatrixRowsFunctor<phi::GPUContext, float>;
 template class CopyMatrixRowsFunctor<phi::GPUContext, double>;
 
-template class LoDTensor2BatchFunctor<phi::GPUContext, float>;
-template class LoDTensor2BatchFunctor<phi::GPUContext, double>;
-template class Batch2LoDTensorFunctor<phi::GPUContext, float>;
-template class Batch2LoDTensorFunctor<phi::GPUContext, double>;
+template class DenseTensor2BatchFunctor<phi::GPUContext, float>;
+template class DenseTensor2BatchFunctor<phi::GPUContext, double>;
+template class Batch2DenseTensorFunctor<phi::GPUContext, float>;
+template class Batch2DenseTensorFunctor<phi::GPUContext, double>;
 
 }  // namespace funcs
 }  // namespace phi
diff --git a/paddle/phi/kernels/funcs/sequence2batch.h b/paddle/phi/kernels/funcs/sequence2batch.h
@@ -44,7 +44,7 @@ class CopyMatrixRowsFunctor {
 };
 
 template <typename DeviceContext, typename T>
-class LoDTensor2BatchFunctor {
+class DenseTensor2BatchFunctor {
   // Calculate the length of each sequence and
   // sort sequence index by the length.
   // example:  sequences = {s0, s1, s2}
@@ -174,7 +174,7 @@ class LoDTensor2BatchFunctor {
 };
 
 template <typename DeviceContext, typename T>
-class Batch2LoDTensorFunctor {
+class Batch2DenseTensorFunctor {
  public:
   void operator()(const DeviceContext& context,
                   const phi::DenseTensor& batch,
diff --git a/paddle/phi/kernels/fusion/cpu/fused_embedding_fc_lstm_kernel.cc b/paddle/phi/kernels/fusion/cpu/fused_embedding_fc_lstm_kernel.cc
@@ -288,7 +288,7 @@ class FusedEmbeddingFCLSTMKernel {
     dev_ctx.template Alloc<T>(hidden_out);
     dev_ctx.template Alloc<T>(cell_out);
 
-    phi::funcs::LoDTensor2BatchFunctor<Context, T> to_batch;
+    phi::funcs::DenseTensor2BatchFunctor<Context, T> to_batch;
     auto blas = phi::funcs::GetBlas<Context, T>(dev_ctx);
 
     for (int64_t i = 0; i < ids_numel; ++i) {
@@ -410,7 +410,7 @@ class FusedEmbeddingFCLSTMKernel {
 #undef MOVE_ONE_BATCH
 #undef DEFINE_CUR
 
-    phi::funcs::Batch2LoDTensorFunctor<Context, T> to_seq;
+    phi::funcs::Batch2DenseTensorFunctor<Context, T> to_seq;
     batched_h_out->set_lod(batched_lod);
     to_seq(dev_ctx, *batched_h_out, hidden_out);
     batched_c_out->set_lod(batched_lod);
diff --git a/paddle/phi/kernels/fusion/cpu/fusion_gru_kernel.cc b/paddle/phi/kernels/fusion/cpu/fusion_gru_kernel.cc
@@ -205,7 +205,7 @@ void BatchCompute(const Context& dev_ctx,
   T* batched_out_data = dev_ctx.template Alloc<T>(batched_out);
   dev_ctx.template Alloc<T>(hidden);
   auto blas = phi::funcs::GetBlas<Context, T>(dev_ctx);
-  phi::funcs::LoDTensor2BatchFunctor<Context, T> to_batch;
+  phi::funcs::DenseTensor2BatchFunctor<Context, T> to_batch;
 
   phi::funcs::FCFunctor<Context, T> fc;
   if (M > D3) {
@@ -333,7 +333,7 @@ void BatchCompute(const Context& dev_ctx,
     batched_input_data = cur_batched_data;
   }
 
-  phi::funcs::Batch2LoDTensorFunctor<Context, T> to_seq;
+  phi::funcs::Batch2DenseTensorFunctor<Context, T> to_seq;
   batched_out->set_lod(batched_lod);
   to_seq(dev_ctx, *batched_out, hidden);
 }
diff --git a/paddle/phi/kernels/fusion/cpu/fusion_lstm_kernel.cc b/paddle/phi/kernels/fusion/cpu/fusion_lstm_kernel.cc
@@ -243,7 +243,7 @@ void BatchCompute(const Context &dev_ctx,
   dev_ctx.template Alloc<T>(hidden_out);
   dev_ctx.template Alloc<T>(cell_out);
 
-  phi::funcs::LoDTensor2BatchFunctor<Context, T> to_batch;
+  phi::funcs::DenseTensor2BatchFunctor<Context, T> to_batch;
   auto blas = phi::funcs::GetBlas<Context, T>(dev_ctx);
   phi::funcs::FCFunctor<Context, T> fc;
   if (M > D4) {
@@ -342,7 +342,7 @@ void BatchCompute(const Context &dev_ctx,
     batched_input_data = cur_in_data;
   }
 
-  phi::funcs::Batch2LoDTensorFunctor<Context, T> to_seq;
+  phi::funcs::Batch2DenseTensorFunctor<Context, T> to_seq;
   batched_h_out->set_lod(batched_lod);
   to_seq(dev_ctx, *batched_h_out, hidden_out);
   batched_c_out->set_lod(batched_lod);
diff --git a/paddle/phi/kernels/gpu/gru_kernel.cu b/paddle/phi/kernels/gpu/gru_kernel.cu
@@ -61,7 +61,7 @@ void GRUKernel(const Context &dev_ctx,
   dev_ctx.template Alloc<T>(batch_reset_hidden_prev);
   dev_ctx.template Alloc<T>(batch_hidden);
 
-  phi::funcs::LoDTensor2BatchFunctor<Context, T> to_batch;
+  phi::funcs::DenseTensor2BatchFunctor<Context, T> to_batch;
   to_batch(dev_ctx, input, batch_gate, true, is_reverse);
 
   if (bias) {
@@ -113,7 +113,7 @@ void GRUKernel(const Context &dev_ctx,
     gru_value.prev_out_value = gru_value.output_value;
   }
 
-  phi::funcs::Batch2LoDTensorFunctor<Context, T> to_seq;
+  phi::funcs::Batch2DenseTensorFunctor<Context, T> to_seq;
   batch_hidden->set_lod(batch_gate->lod());
   to_seq(dev_ctx, *batch_hidden, hidden);
 }
diff --git a/paddle/phi/kernels/impl/gru_kernel_impl.h b/paddle/phi/kernels/impl/gru_kernel_impl.h
@@ -63,7 +63,7 @@ void GRUGradKernel(const Context &dev_ctx,
   auto hidden_dims = hidden.dims();
   int frame_size = hidden_dims[1];
 
-  phi::funcs::LoDTensor2BatchFunctor<Context, T> to_batch;
+  phi::funcs::DenseTensor2BatchFunctor<Context, T> to_batch;
   phi::DenseTensor batch_hidden_grad, batch_gate_grad,
       batch_reset_hidden_prev_grad;
   batch_hidden_grad.Resize(hidden_dims);
@@ -156,7 +156,7 @@ void GRUGradKernel(const Context &dev_ctx,
   }
   if (input_grad) {
     dev_ctx.template Alloc<T>(input_grad);
-    phi::funcs::Batch2LoDTensorFunctor<Context, T> to_seq;
+    phi::funcs::Batch2DenseTensorFunctor<Context, T> to_seq;
     batch_gate_grad.set_lod(batch_gate.lod());
     to_seq(dev_ctx, batch_gate_grad, input_grad);
   }
diff --git a/paddle/phi/kernels/impl/lstm_kernel_impl.h b/paddle/phi/kernels/impl/lstm_kernel_impl.h
@@ -56,7 +56,7 @@ void LSTMKernel(const Context& dev_ctx,
   dev_ctx.template Alloc<T>(hidden);
   dev_ctx.template Alloc<T>(cell);
 
-  phi::funcs::LoDTensor2BatchFunctor<Context, T> to_batch;
+  phi::funcs::DenseTensor2BatchFunctor<Context, T> to_batch;
   to_batch(dev_ctx, input, batch_gate_new, true, is_reverse);
 
   auto in_dims = input.dims();
@@ -177,7 +177,7 @@ void LSTMKernel(const Context& dev_ctx,
     lstm_value.prev_state_value = lstm_value.state_value;
   }
 
-  phi::funcs::Batch2LoDTensorFunctor<Context, T> to_seq;
+  phi::funcs::Batch2DenseTensorFunctor<Context, T> to_seq;
   batch_hidden.set_lod(batch_gate_new->lod());
   // restore the output hidden in phi::DenseTensor from the batch hidden
   to_seq(dev_ctx, batch_hidden, hidden);
@@ -292,7 +292,7 @@ void LSTMGradKernel(const Context& dev_ctx,
     lstm_grad.check_og_grad = nullptr;
   }
 
-  phi::funcs::LoDTensor2BatchFunctor<Context, T> to_batch;
+  phi::funcs::DenseTensor2BatchFunctor<Context, T> to_batch;
 
   auto ToBatch = [&batch_gate, &to_batch](const Context& ctx,
                                           const phi::DenseTensor& src,
@@ -418,7 +418,7 @@ void LSTMGradKernel(const Context& dev_ctx,
     }
   }
 
-  phi::funcs::Batch2LoDTensorFunctor<Context, T> to_seq;
+  phi::funcs::Batch2DenseTensorFunctor<Context, T> to_seq;
   if (in_g) {
     /* backward data */
     dev_ctx.template Alloc<T>(in_g);

Original file line number	Diff line number	Diff line change
`@@ -1094,7 +1094,7 @@ void OperatorBase::GenerateTemporaryNames() {`
`1094`	`1094`	`}`
`1095`	`1095`	`}`
`1096`	`1096`
`1097`		`-const phi::DenseTensor* GetLoDTensorOrSelectedRowsValueFromVar(`
	`1097`	`+const phi::DenseTensor* GetDenseTensorOrSelectedRowsValueFromVar(`
`1098`	`1098`	`const Variable& var) {`
`1099`	`1099`	`if (var.IsType<phi::DenseTensor>()) {`
`1100`	`1100`	`return static_cast<const phi::DenseTensor*>(&(var.Get<phi::DenseTensor>()));`
`@@ -2467,7 +2467,7 @@ void OperatorWithKernel::TransferInplaceVarsBack(`
`2467`	`2467`	`PADDLE_ENFORCE_NOT_NULL(var,`
`2468`	`2468`	`common::errors::InvalidArgument(`
`2469`	`2469`	`"The variable[%s] is nullptr.", var_name));`
`2470`		`- auto* transformed_tensor = GetLoDTensorOrSelectedRowsValueFromVar(*var);`
	`2470`	`+ auto* transformed_tensor = GetDenseTensorOrSelectedRowsValueFromVar(*var);`
`2471`	`2471`	`original_tensor->ShareDataWith(*transformed_tensor);`
`2472`	`2472`	`}`
`2473`	`2473`	`}`
`@@ -2515,7 +2515,7 @@ void OperatorWithKernel::HandleComplexGradToRealGrad(`
`2515`	`2515`	`if (!VarIsTensor(*var)) {`
`2516`	`2516`	`continue;`
`2517`	`2517`	`}`
`2518`		`- const auto* tensor = GetLoDTensorOrSelectedRowsValueFromVar(*var);`
	`2518`	`+ const auto* tensor = GetDenseTensorOrSelectedRowsValueFromVar(*var);`
`2519`	`2519`	`PADDLE_ENFORCE_NOT_NULL(`
`2520`	`2520`	`tensor,`
`2521`	`2521`	`common::errors::Unavailable(`
`@@ -2582,7 +2582,7 @@ Scope* OperatorWithKernel::PrepareData(`
`2582`	`2582`	`continue;`
`2583`	`2583`	`}`
`2584`	`2584`
`2585`		`- auto* tensor_in = GetLoDTensorOrSelectedRowsValueFromVar(*var);`
	`2585`	`+ auto* tensor_in = GetDenseTensorOrSelectedRowsValueFromVar(*var);`
`2586`	`2586`
`2587`	`2587`	`// When no_buffer_ins then checking of phi::DenseTensor::holder_ is`
`2588`	`2588`	`// not a thread safe. And for infershape scenario checks`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ inline bool VarIsTensor(const Variable& var) {`
`131`	`131`	`return var.IsType<phi::DenseTensor>() \|\| var.IsType<phi::SelectedRows>();`
`132`	`132`	`}`
`133`	`133`
`134`		`-const phi::DenseTensor* GetLoDTensorOrSelectedRowsValueFromVar(`
	`134`	`+const phi::DenseTensor* GetDenseTensorOrSelectedRowsValueFromVar(`
`135`	`135`	`const Variable& var);`
`136`	`136`	`phi::DenseTensor* GetMutableLoDTensorOrSelectedRowsValueFromVar(Variable* var);`
`137`	`137`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ class SumOp : public framework::OperatorWithKernel {`
`53`	`53`	`common::errors::NotFound("Input var[%s] should not be nullptr",`
`54`	`54`	`x_vars_name[idx]));`
`55`	`55`	`auto tensor =`
`56`		`- framework::GetLoDTensorOrSelectedRowsValueFromVar(*x_vars[idx]);`
	`56`	`+ framework::GetDenseTensorOrSelectedRowsValueFromVar(*x_vars[idx]);`
`57`	`57`	`if (!tensor->IsInitialized()) {`
`58`	`58`	`continue;`
`59`	`59`	`}`