[Lod][fluid_ops] LegacyLoD (#69822)

Author: co63oc

paddle/common/ddim.h

@@ -243,7 +243,8 @@ TEST_API DDim ComputeCompatibleDim(const DDim& dim1, const DDim& dim2);
 
 namespace pir {
 using DDim = common::DDim;
-using LoD = std::vector<std::vector<size_t>>;
+using LegacyLoD = std::vector<std::vector<size_t>>;
+using LoD = LegacyLoD;
 }  // namespace pir
 
 namespace std {

paddle/fluid/distributed/fleet_executor/dist_model.cc

@@ -125,7 +125,7 @@ bool LoadDataFromDistModelTensor(const DistModelTensor &input_data,
         "DistModel only supports CPU and GPU and XPU and CustomDevice."));
   }
 
-  phi::LoD dst_lod;
+  phi::LegacyLoD dst_lod;
   for (auto &src_lod : input_data.lod) {
     dst_lod.emplace_back(src_lod);
   }

paddle/fluid/distributed/ps/service/brpc_utils.cc

@@ -91,7 +91,7 @@ void SerializeDenseTensor(framework::Variable* var,
                           butil::IOBuf* iobuf) {
   auto* tensor = var->GetMutable<phi::DenseTensor>();
   var_msg->set_type(::paddle::distributed::DENSE_TENSOR);
-  const phi::LoD lod = tensor->lod();
+  const phi::LegacyLoD lod = tensor->lod();
   if (!lod.empty()) {
     var_msg->set_lod_level(lod.size());
     for (auto& each : lod) {
@@ -231,7 +231,7 @@ void DeserializeDenseTensor(framework::Variable* var,
   }
   tensor->Resize(common::make_ddim(vec_dim));
 
-  phi::LoD lod;
+  phi::LegacyLoD lod;
   for (int i = 0; i < msg.lod_level(); ++i) {
     phi::Vector<size_t> v;
     for (int j = 0; j < msg.lod(i).lod_data_size(); ++j) {

paddle/fluid/distributed/ps/wrapper/fleet.cc

@@ -1016,7 +1016,7 @@ std::default_random_engine& FleetWrapper::LocalRandomEngine() {
 size_t FleetWrapper::GetAbsoluteSum(size_t start,
                                     size_t end,
                                     size_t level,
-                                    const phi::LoD& lod) {
+                                    const phi::LegacyLoD& lod) {
   if (level >= lod.size() - 1) {
     return end - start;
   }

paddle/fluid/distributed/ps/wrapper/fleet.h

@@ -335,7 +335,7 @@ class FleetWrapper {
   size_t GetAbsoluteSum(size_t start,
                         size_t end,
                         size_t level,
-                        const phi::LoD& lod);
+                        const phi::LegacyLoD& lod);
 
  protected:
   static bool is_initialized_;

paddle/fluid/distributed/test/brpc_utils_test.cc

@@ -33,7 +33,7 @@ void CreateVarsOnScope(framework::Scope* scope,
   framework::Variable* var1 = scope->Var("x1");
   auto* tensor1 = var1->GetMutable<phi::DenseTensor>();
   tensor1->Resize(common::make_ddim({512, 8, 4, 2}));
-  phi::LoD lod1;
+  phi::LegacyLoD lod1;
   lod1.push_back(phi::Vector<size_t>({1, 3, 8}));
   tensor1->set_lod(lod1);
   tensor1->mutable_data<float>(*place);
@@ -43,7 +43,7 @@ void CreateVarsOnScope(framework::Scope* scope,
   framework::Variable* var2 = scope->Var("x2");
   auto* tensor2 = var2->GetMutable<phi::DenseTensor>();
   tensor2->Resize(common::make_ddim({1000, 64}));
-  phi::LoD lod2;
+  phi::LegacyLoD lod2;
   lod2.push_back(phi::Vector<size_t>({1, 1}));
   tensor2->set_lod(lod2);
   tensor2->mutable_data<int>(*place);

paddle/fluid/framework/data_feed.cc

@@ -1053,7 +1053,7 @@ void MultiSlotDataFeed::PutToFeedVec(
     }
 
     if (!use_slots_is_dense_[i]) {
-      LoD data_lod{offset};
+      LegacyLoD data_lod{offset};
       feed_vec_[i]->set_lod(data_lod);
     }
     if (use_slots_is_dense_[i]) {
@@ -1446,7 +1446,7 @@ void MultiSlotInMemoryDataFeed::PutToFeedVec(const Record* ins_vec, int num) {
     }
     auto& slot_offset = offset_[i];
     if (this->input_type_ == 0) {
-      LoD data_lod{slot_offset};
+      LegacyLoD data_lod{slot_offset};
       feed_vec_[i]->set_lod(data_lod);
     } else if (this->input_type_ == 1) {
       if (!use_slots_is_dense_[i]) {
@@ -1463,7 +1463,7 @@ void MultiSlotInMemoryDataFeed::PutToFeedVec(const Record* ins_vec, int num) {
           tmp_offset.emplace_back(k);
         }
         slot_offset = tmp_offset;
-        LoD data_lod{slot_offset};
+        LegacyLoD data_lod{slot_offset};
         feed_vec_[i]->set_lod(data_lod);
       }
     }
@@ -1545,7 +1545,7 @@ void MultiSlotInMemoryDataFeed::PutToFeedVec(
     auto& slot_offset = offset_[i];
     if (this->input_type_ == 0) {
       if (!use_slots_is_dense_[i]) {
-        LoD data_lod{slot_offset};
+        LegacyLoD data_lod{slot_offset};
         feed_vec_[i]->set_lod(data_lod);
       }
     } else if (this->input_type_ == 1) {
@@ -1563,7 +1563,7 @@ void MultiSlotInMemoryDataFeed::PutToFeedVec(
           tmp_offset.emplace_back(k);
         }
         slot_offset = tmp_offset;
-        LoD data_lod{slot_offset};
+        LegacyLoD data_lod{slot_offset};
         feed_vec_[i]->set_lod(data_lod);
       }
     }
@@ -1600,7 +1600,7 @@ void PrivateInstantDataFeed<T>::PutToFeedVec() {
           tensor_ptr, &feasign[0], total_instance * sizeof(int64_t));
     }
 
-    LoD data_lod{offset};
+    LegacyLoD data_lod{offset};
     feed_vec_[i]->set_lod(data_lod);
     if (use_slots_is_dense_[i]) {
       int64_t total_dims = 1;
@@ -2048,7 +2048,7 @@ void PaddleBoxDataFeed::PutToFeedVec(const std::vector<Record*>& ins_vec) {
       CopyToFeedTensor(tensor_ptr, feasign, total_instance * sizeof(int64_t));
     }
     auto& slot_offset = offset_[i];
-    LoD data_lod{slot_offset};
+    LegacyLoD data_lod{slot_offset};
     feed_vec_[i]->set_lod(data_lod);
     if (use_slots_is_dense_[i]) {
       if (inductive_shape_index_[i] != -1) {
@@ -2704,7 +2704,7 @@ void SlotRecordInMemoryDataFeed::PutToFeedVec(const SlotRecord* ins_vec,
       }
       feed->Resize(common::make_ddim(info.local_shape));
     } else {
-      LoD data_lod{slot_offset};
+      LegacyLoD data_lod{slot_offset};
       feed_vec_[j]->set_lod(data_lod);
     }
   }
@@ -3117,7 +3117,7 @@ void SlotRecordInMemoryDataFeed::PackToScope(MiniBatchGpuPack* pack,
       }
       feed->Resize(common::make_ddim(info.local_shape));
     } else {
-      LoD& lod = (*feed->mutable_lod());
+      LegacyLoD& lod = (*feed->mutable_lod());
       lod.resize(1);
       lod[0].resize(offset_cols_size);
       phi::MixVector<size_t> mixv_lod(&lod[0]);

paddle/fluid/framework/data_feed.cu

@@ -1285,14 +1285,14 @@ int GraphDataGenerator::GenerateBatch() {
     }
     sage_batch_count_ += 1;
   }
-  LoD lod{offset_};
+  LegacyLoD lod{offset_};
 
   if (conf_.accumulate_num >= 2) {
     offset_.clear();
     offset_.push_back(0);
     offset_.push_back(uniq_instance_vec_[sage_batch_count_ * 2]);
   }
-  LoD lod2{offset_};
+  LegacyLoD lod2{offset_};
 
   if (conf_.accumulate_num == 1) {
     for (int tensor_pair_idx = 0; tensor_pair_idx < conf_.tensor_pair_num;

paddle/fluid/framework/downpour_worker.cc

@@ -232,7 +232,7 @@ void DownpourWorker::FillSparseValue(size_t table_idx) {
                                                  phi::CPUPlace());
     memset(ptr, 0, sizeof(float) * len * table.emb_dim());
     auto& tensor_lod = tensor->lod()[0];
-    LoD data_lod{tensor_lod};
+    LegacyLoD data_lod{tensor_lod};
     tensor_emb->set_lod(data_lod);
 
     bool is_nid = (adjust_ins_weight_config_.need_adjust() &&

paddle/fluid/framework/fleet/fleet_wrapper.cc

@@ -1983,7 +1983,7 @@ int32_t FleetWrapper::CopyTableByFeasign(
 size_t FleetWrapper::GetAbsoluteSum(size_t start,
                                     size_t end,
                                     size_t level,
-                                    const phi::LoD& lod) {
+                                    const phi::LegacyLoD& lod) {
   if (level >= lod.size() - 1) {
     return end - start;
   }