PaddlePaddle
diff --git a/‎paddle/fluid/framework/lod_tensor.cc
Copy file name to clipboard
-309Lines changed: 0 additions & 309 deletions b/‎paddle/fluid/framework/lod_tensor.cc
Copy file name to clipboard
-309Lines changed: 0 additions & 309 deletions
@@ -27,71 +27,6 @@ std::string LoDToString(const LoD &lod) {
   return stream.str();
 }
 
-LoD SliceInLevel(const LoD &in,
-                 size_t level,
-                 size_t elem_begin,
-                 size_t elem_end) {
-  PADDLE_ENFORCE_LT(
-      level,
-      in.size(),
-      common::errors::InvalidArgument(
-          "The input phi::DenseTensor's lod level should be less than "
-          "the LoD size, but received level is %d, LoD is %s.",
-          level,
-          in));
-  PADDLE_ENFORCE_LT(
-      elem_begin,
-      elem_end,
-      common::errors::InvalidArgument(
-          "The index to start slicing should be less than the index to end "
-          "slicing, but received start index is %d, end index is %d.",
-          elem_begin,
-          elem_end));
-  PADDLE_ENFORCE_LT(
-      elem_end,
-      in[level].size(),
-      common::errors::InvalidArgument(
-          "The index to end slicing should be less than the input LoD size, "
-          "but received end index is %d, LoD size is %d.",
-          elem_end,
-          in[level].size()));
-
-  LoD res;
-  res.resize(in.size() - level);
-  // copy the first level
-  res[0].assign(in[level].begin() + elem_begin,     // NOLINT
-                in[level].begin() + elem_end + 1);  // NOLINT
-  for (size_t lvl = 1; lvl < res.size(); lvl++) {
-    const auto &in_level = in[level + lvl];
-    const auto &above_level = res[lvl - 1];
-    auto &out_level = res[lvl];
-    out_level.assign(in_level.begin() + above_level.front(),      // NOLINT
-                     in_level.begin() + above_level.back() + 1);  // NOLINT
-  }
-  for (auto &item : res) {
-    // to make the first offset equals 0, all the elements minus the first
-    // element
-    size_t front = item.front();
-    for (auto &ele : item) {
-      ele -= front;
-    }
-  }
-  return res;
-}
-
-LoD ToAbsOffset(const LoD &in) {
-  // the lowest level stores relative offsets
-  if (in.empty() || in.size() == 1) return in;
-  LoD result = in;
-  for (auto level = static_cast<int>(in.size() - 2); level >= 0; level--) {
-    for (size_t i = 0; i < in[level].size(); ++i) {
-      size_t index = in[level][i];
-      result[level][i] = result[level + 1][index];
-    }
-  }
-  return result;
-}
-
 bool operator==(const LoD &a, const LoD &b) {
   if (a.size() != b.size()) {
     return false;
@@ -140,68 +75,6 @@ bool CheckLoD(const LoD &in, int tensor_height) {
   return true;
 }
 
-bool CheckAbsLoD(const LoD &in, int tensor_height) {
-  if (in.empty()) return true;
-  for (const auto &level : in) {
-    // check: all the offsets in a level should be ascending(no same items
-    // allowed).
-    if (!std::is_sorted(level.begin(), level.begin(), [](size_t a, size_t b) {
-          if (a < b) return true;
-          return false;
-        })) {
-      return false;
-    }
-
-    // check: there should be more than 2 offsets existing in each level.
-    if (level.size() < 2) return false;
-
-    // check: the first offset of each level should be 0, and the last should be
-    // the same(the height of underlying tensor).
-    if (level.front() != 0) return false;
-    if (tensor_height < 0) {
-      tensor_height = static_cast<int>(level.back());
-    } else if (static_cast<size_t>(tensor_height) != level.back()) {
-      return false;
-    }
-  }
-  return true;
-}
-
-using LoDAndOffset = std::pair<LoD, std::pair<size_t, size_t>>;
-LoDAndOffset GetSubLoDAndAbsoluteOffset(const LoD &lod,
-                                        size_t start_idx,
-                                        size_t end_idx,
-                                        size_t start_level) {
-  LoD sub_lod;
-
-  for (size_t level_idx = start_level; level_idx < lod.size(); ++level_idx) {
-    PADDLE_ENFORCE_LE(start_idx,
-                      end_idx,
-                      common::errors::InvalidArgument(
-                          "The start index should be less than the end index, "
-                          "but received start index is %d, end index is %d.",
-                          start_idx,
-                          end_idx));
-    PADDLE_ENFORCE_LT(
-        end_idx,
-        lod[level_idx].size(),
-        common::errors::InvalidArgument(
-            "The end index should be less than the LoD level size, but "
-            "received end index is %d, LoD level size is %d.",
-            end_idx,
-            lod[level_idx].size()));
-    std::vector<size_t> level_lens;
-    for (size_t i = start_idx; i < end_idx; ++i) {
-      level_lens.push_back(lod[level_idx][i + 1] - lod[level_idx][i]);
-    }
-    sub_lod.emplace_back(level_lens);
-    start_idx = lod[level_idx][start_idx];
-    end_idx = lod[level_idx][end_idx];
-  }
-
-  return LoDAndOffset{sub_lod, {start_idx, end_idx}};
-}
-
 void SerializeToStream(std::ostream &os,
                        const phi::DenseTensor &tensor,
                        const phi::DeviceContext &dev_ctx) {
@@ -330,186 +203,4 @@ LoD ConvertToOffsetBasedLoD(const LoD &length_lod) {
   return offset_lod;
 }
 
-std::vector<phi::DenseTensor> SplitLoDTensor(
-    const phi::DenseTensor &src, const std::vector<phi::Place> places) {
-  PADDLE_ENFORCE_GT(places.size(),
-                    0,
-                    common::errors::InvalidArgument(
-                        "Place number cannot be empty when splitting."));
-  src.check_memory_size();
-  auto rank = src.dims().size();
-  // if rank is 0, just return #places.size() copys of src
-  if (rank == 0) {
-    phi::DenseTensor dst;
-    framework::TensorCopy(src, src.place(), &dst);
-    std::vector<phi::DenseTensor> ret;
-    ret.emplace_back(std::move(dst));
-    return ret;
-  }
-
-  size_t batch_size = src.lod().empty() ? static_cast<size_t>(src.dims()[0])
-                                        : src.lod()[0].size() - 1;
-
-  // if batch_size is 0, just return #places.size() copys of empty
-  // tensors.
-  if (batch_size == 0) {
-    std::vector<phi::DenseTensor> empty_results;
-    empty_results.reserve(places.size());
-    for (auto item : places) {
-      phi::DenseTensor dst;
-      dst.Resize(src.dims());
-      dst.mutable_data(item, src.dtype());
-      if (!src.lod().empty()) {
-        dst.set_lod(src.lod());
-      }
-      empty_results.emplace_back(std::move(dst));
-    }
-    return empty_results;
-  }
-
-  auto step_width = (batch_size + places.size() - 1) / places.size();
-  auto result_size = (batch_size + step_width - 1) / step_width;
-  std::vector<phi::DenseTensor> results;
-  results.reserve(result_size);
-
-  for (size_t i = 0; i < result_size; ++i) {
-    auto begin = i * step_width;
-    auto end = std::min<size_t>((i + 1) * step_width, batch_size);
-    PADDLE_ENFORCE_LT(begin,
-                      end,
-                      common::errors::InvalidArgument(
-                          "The begin index must be less than the end index, "
-                          "but received begin index is %d, end index is %d.",
-                          begin,
-                          end));
-
-    phi::DenseTensor dst;
-    if (src.lod().empty()) {
-      auto sliced_src =
-          src.Slice(static_cast<int64_t>(begin), static_cast<int64_t>(end));
-      auto &dst_place = places[i];
-      framework::TensorCopy(sliced_src, dst_place, &dst);
-    } else {
-      auto lod_and_offset =
-          GetSubLoDAndAbsoluteOffset(src.lod(), begin, end, 0);
-
-      auto &offset = lod_and_offset.second;
-      auto sliced_src = src.Slice(static_cast<int64_t>(offset.first),
-                                  static_cast<int64_t>(offset.second));
-      auto &dst_place = places[i];
-      framework::TensorCopy(sliced_src, dst_place, &dst);
-
-      LoD my_lod;
-      for (auto &l : lod_and_offset.first) {
-        std::vector<size_t> v{0};
-        for (auto &ll : l) {
-          v.push_back(ll + v.back());
-        }
-        my_lod.emplace_back(v);
-      }
-      dst.set_lod(my_lod);
-    }
-    results.emplace_back(std::move(dst));
-  }
-
-  return results;
-}
-
-void MergeLoDTensor(phi::DenseTensor *target,
-                    const std::vector<const phi::DenseTensor *> &lod_tensors,
-                    phi::Place dst_place) {
-  PADDLE_ENFORCE_EQ(lod_tensors.empty(),
-                    false,
-                    common::errors::InvalidArgument(
-                        "The LoDTensors to be merged are empty."));
-
-  phi::DDim new_dim = lod_tensors[0]->dims();
-  proto::VarType::Type new_type = proto::VarType::FP32;
-  phi::DataLayout new_layout = lod_tensors[0]->layout();
-  for (auto *t : lod_tensors) {
-    if (t->numel() && t->IsInitialized()) {
-      new_dim = t->dims();
-      new_type = framework::TransToProtoVarType(t->dtype());
-      new_layout = t->layout();
-      break;
-    }
-  }
-
-  LoD new_lod = lod_tensors[0]->lod();
-  auto rank = lod_tensors[0]->dims().size();
-
-  for (size_t i = 1; i < lod_tensors.size(); ++i) {
-    auto *t = lod_tensors[i];
-    if (t->numel() && t->IsInitialized()) {
-      PADDLE_ENFORCE_EQ(
-          new_type,
-          framework::TransToProtoVarType(t->dtype()),
-          common::errors::InvalidArgument(
-              "phi::DenseTensor data type does not match, expected type is %s, "
-              "actual "
-              "type is %s.",
-              DataTypeToString(new_type),
-              DataTypeToString(framework::TransToProtoVarType(t->dtype()))));
-      PADDLE_ENFORCE_EQ(
-          new_layout,
-          t->layout(),
-          common::errors::InvalidArgument(
-              "phi::DenseTensor layout does not match, expected layout is %s, "
-              "actual layout is %s.",
-              common::DataLayoutToString(new_layout),
-              common::DataLayoutToString(t->layout())));
-      auto tensor_dims = t->dims();
-      PADDLE_ENFORCE_EQ(tensor_dims.size(),
-                        new_dim.size(),
-                        common::errors::InvalidArgument(
-                            "dimensions of DenseTensor does not match"));
-      for (int j = 1; j < t->dims().size(); j++) {
-        PADDLE_ENFORCE_EQ(
-            tensor_dims[j],
-            new_dim[j],
-            common::errors::InvalidArgument(
-                "DenseTensor.ddim[%d] should equal to %d, but is %d",
-                j,
-                new_dim[j],
-                tensor_dims[j]));
-      }
-      if (rank > 0) {
-        new_dim[0] += t->dims()[0];
-      }
-    }
-
-    auto &lod = t->lod();
-    PADDLE_ENFORCE_EQ(
-        new_lod.size(),
-        lod.size(),
-        common::errors::InvalidArgument(
-            "The LoD information of phi::DenseTensor does not match, "
-            "expected LoD is %s, actual LoD is %s.",
-            new_lod,
-            lod));
-    for (size_t j = 0; j < lod.size(); ++j) {
-      auto &sub_lod = new_lod[j];
-      size_t offset = sub_lod.back();
-      for (size_t k = 1; k < lod[j].size(); ++k) {
-        sub_lod.push_back(lod[j][k] + offset);
-      }
-    }
-  }
-  target->Resize(new_dim);
-  target->set_layout(new_layout);
-  target->set_lod(new_lod);
-  target->mutable_data(dst_place, phi::TransToPhiDataType(new_type));
-
-  int begin = 0;
-  for (auto *src : lod_tensors) {
-    int end = static_cast<int>(begin + src->dims()[0]);
-    if (end == begin) {
-      continue;
-    }
-    auto dst = target->Slice(begin, end);
-    framework::TensorCopy(*src, dst_place, &dst);
-    begin = end;
-  }
-}
-
 }  // namespace paddle::framework