Fix typos splitted split (#71780)

co63oc · web-flow · commit 90f3f4cd977e · 2025-03-20T20:08:26.000+08:00
diff --git a/paddle/fluid/pir/transforms/gpu/horizontal_fuse_pass.cc b/paddle/fluid/pir/transforms/gpu/horizontal_fuse_pass.cc
@@ -306,12 +306,12 @@ class HorizontalFusePattern : public pir::RewritePattern {
                                         fused_matmul_op_attrs,
                                         w_from_source_index);
 
-    pir::Value xw_splitted = InsertOpAfter<paddle::dialect::SplitOp>(
+    pir::Value xw_split = InsertOpAfter<paddle::dialect::SplitOp>(
         &prev_op, rewriter, xw_fused, w_shapes, x_last_axis);
 
     rewriter->SetInsertionPointAfter(prev_op);
 
-    auto split_builtin_op = rewriter->Build<pir::SplitOp>(xw_splitted);
+    auto split_builtin_op = rewriter->Build<pir::SplitOp>(xw_split);
 
     std::vector<pir::Value> xw = split_builtin_op.outputs();
 
diff --git a/paddle/phi/infermeta/spmd_rules/dim_trans.cc b/paddle/phi/infermeta/spmd_rules/dim_trans.cc
@@ -92,10 +92,10 @@ Split::Split(const std::shared_ptr<DimTrans> dim,
     : DimTrans(DimTrans::Type::SPLIT) {
   input_dim_trans_ = dim;
   split_id_ = id;
-  splitted_shape_.assign(shape.begin(), shape.end());
+  split_shape_.assign(shape.begin(), shape.end());
 }
 
-Split::~Split() { std::vector<int64_t>().swap(splitted_shape_); }
+Split::~Split() { std::vector<int64_t>().swap(split_shape_); }
 
 const std::shared_ptr<DimTrans>& Split::input() const {
   return input_dim_trans_;
@@ -107,15 +107,13 @@ void Split::set_input(const std::shared_ptr<DimTrans> dim) {
 
 int64_t Split::split_id() const { return split_id_; }
 
-int64_t Split::local_splitted_shape_value() {
-  return splitted_shape_[split_id_];
-}
+int64_t Split::local_split_shape_value() { return split_shape_[split_id_]; }
 
 std::string Split::to_string() {
   std::string ret_str("Split(");
   ret_str += input_dim_trans_->to_string() + ", (";
-  for (int i = 0, n = static_cast<int>(splitted_shape_.size()); i < n; ++i) {
-    ret_str += std::to_string(splitted_shape_[i]);
+  for (int i = 0, n = static_cast<int>(split_shape_.size()); i < n; ++i) {
+    ret_str += std::to_string(split_shape_[i]);
     if (i < n - 1) {
       ret_str += ",";
     }
@@ -239,7 +237,7 @@ std::shared_ptr<DimTrans> GetDimTrans(
                                                 sharded_input_dims,
                                                 shardable,
                                                 seen_dims);
-    int64_t ret_size = split->local_splitted_shape_value();
+    int64_t ret_size = split->local_split_shape_value();
 
     if (split->split_id() == 0) {
       if (dim != nullptr) {
diff --git a/paddle/phi/infermeta/spmd_rules/dim_trans.h b/paddle/phi/infermeta/spmd_rules/dim_trans.h
@@ -35,7 +35,7 @@ namespace distributed {
 // [Flatten(Dim(0), Dim(1)), Split(Dim(2), (6,8), 0), Split(Dim(2), (6,8), 1)]
 // meaning that dim0 in output is flattened from dim0 and dim1 in input,
 // dim1 and dim2 in output are obtained by splitting dim2 in input, the
-// splitted shape is (6, 8), dim1 refers to the first shape value in (6, 8)
+// split shape is (6, 8), dim1 refers to the first shape value in (6, 8)
 // and dim2 refers to the second shape value in (6, 8).
 class DimTrans {
  public:
@@ -123,14 +123,14 @@ class Split : public DimTrans {
 
   int64_t split_id() const;
 
-  // get the splitted shape value of the split_id_ dimension
-  int64_t local_splitted_shape_value();
+  // get the split shape value of the split_id_ dimension
+  int64_t local_split_shape_value();
 
   std::string to_string() override;
 
  private:
   std::shared_ptr<DimTrans> input_dim_trans_;
-  std::vector<int64_t> splitted_shape_;
+  std::vector<int64_t> split_shape_;
   int64_t split_id_;
 };
 
diff --git a/paddle/phi/infermeta/spmd_rules/flatten.cc b/paddle/phi/infermeta/spmd_rules/flatten.cc
@@ -68,9 +68,9 @@ std::vector<std::shared_ptr<DimTrans>> MakeFlattenDimTransReverse(
     const std::vector<int64_t>& src_shape, int start_axis, int stop_axis) {
   std::vector<std::shared_ptr<DimTrans>> ret;
 
-  std::vector<int64_t> tgt_splitted_shape;
+  std::vector<int64_t> tgt_split_shape;
   for (int i = start_axis; i <= stop_axis; i++) {
-    tgt_splitted_shape.emplace_back(src_shape[i]);
+    tgt_split_shape.emplace_back(src_shape[i]);
   }
 
   for (int64_t i = 0; i < static_cast<int64_t>(src_shape.size()); i++) {
@@ -81,7 +81,7 @@ std::vector<std::shared_ptr<DimTrans>> MakeFlattenDimTransReverse(
           std::make_shared<InputDim>(i - (stop_axis - start_axis)));
     } else {
       ret.emplace_back(make_split(std::make_shared<InputDim>(start_axis),
-                                  tgt_splitted_shape,
+                                  tgt_split_shape,
                                   i - start_axis));
     }
   }
diff --git a/paddle/phi/infermeta/spmd_rules/reshape.cc b/paddle/phi/infermeta/spmd_rules/reshape.cc
@@ -85,7 +85,7 @@ std::vector<std::shared_ptr<DimTrans>> MakeReshapeDimTrans(
   src_len = static_cast<int>(src_shape.size());
   tgt_len = static_cast<int>(inferred_tgt_shape.size());
   while (src_idx < src_len || tgt_idx < tgt_len) {
-    std::vector<int64_t> src_dims, tgt_splitted_shape;
+    std::vector<int64_t> src_dims, tgt_split_shape;
     if (src_idx >= src_len) {
       s = 1;
     } else {
@@ -97,15 +97,15 @@ std::vector<std::shared_ptr<DimTrans>> MakeReshapeDimTrans(
       t = 1;
     } else {
       t = static_cast<int>(inferred_tgt_shape[tgt_idx]);
-      tgt_splitted_shape.emplace_back(t);
+      tgt_split_shape.emplace_back(t);
       tgt_idx++;
     }
 
     // deal with the singleton case
     if (s == 1 && t != 1) {
       // case [1] [a]
       tgt_idx--;
-      tgt_splitted_shape.clear();
+      tgt_split_shape.clear();
     } else if (s != 1 && t == 1) {
       src_idx--;
       src_dims.clear();
@@ -116,14 +116,14 @@ std::vector<std::shared_ptr<DimTrans>> MakeReshapeDimTrans(
           s *= static_cast<int>(src_shape[src_idx]);
           src_idx++;
         } else {
-          tgt_splitted_shape.emplace_back(inferred_tgt_shape[tgt_idx]);
+          tgt_split_shape.emplace_back(inferred_tgt_shape[tgt_idx]);
           t *= static_cast<int>(inferred_tgt_shape[tgt_idx]);
           tgt_idx++;
         }
       }
     }
 
-    if (!tgt_splitted_shape.empty()) {
+    if (!tgt_split_shape.empty()) {
       std::vector<std::shared_ptr<DimTrans>> input_dims;
       for (auto in_dim : src_dims) {
         if (src_shape[in_dim] > 1) {
@@ -143,10 +143,10 @@ std::vector<std::shared_ptr<DimTrans>> MakeReshapeDimTrans(
       }
       std::shared_ptr<DimTrans> flatten = make_flatten(input_dims);
 
-      for (int64_t i = 0, n = static_cast<int64_t>(tgt_splitted_shape.size());
+      for (int64_t i = 0, n = static_cast<int64_t>(tgt_split_shape.size());
            i < n;
            i++) {
-        ret.emplace_back(make_split(flatten, tgt_splitted_shape, i));
+        ret.emplace_back(make_split(flatten, tgt_split_shape, i));
       }
     }
   }
diff --git a/paddle/phi/infermeta/spmd_rules/split.cc b/paddle/phi/infermeta/spmd_rules/split.cc
@@ -46,13 +46,13 @@ SpmdInfo SplitWithNumInferSpmd(const DistMetaTensor& x, int num, int axis) {
   }
 
   // get einsum notation for input, use a special
-  // notation 'k' to mark the splitted axis in input
+  // notation 'k' to mark the split axis in input
   std::string x_axes = alphabet.substr(0, x_ndim);
   x_axes[axis] = 'k';
 
   // get einsum notation for output
   std::string out_axes(x_axes);
-  // the splitted axis cannot be sharded, set its notation
+  // the split axis cannot be sharded, set its notation
   // with the special '1' to set its dim mapping to -1.
   out_axes[axis] = '1';
 
@@ -73,7 +73,7 @@ SpmdInfo SplitWithNumInferSpmd(const DistMetaTensor& x, int num, int axis) {
     out_dist_attrs[i].set_dims_mapping(out_dims_mapping);
   }
 
-  // Step2.3 get new dist attribute for input. the splitted
+  // Step2.3 get new dist attribute for input. the split
   // cannot be sharded, if it is sharded, set it to replicated.
   TensorDistAttr x_dist_attr_dst = CopyTensorDistAttrForOutput(x_dist_attr_src);
   x_dims_mapping[axis] = -1;
@@ -145,7 +145,7 @@ SpmdInfo SplitWithNumInferSpmdReverse(
   std::string alphabet = "abcdefghijlmnopqrstuvwxyz";
 
   // get einsum notation for input, use a special
-  // notation 'k' to mark the splitted axis in input
+  // notation 'k' to mark the split axis in input
   std::string x_axes = alphabet.substr(0, x_ndim);
   x_axes[axis] = 'k';
 
@@ -171,7 +171,7 @@ SpmdInfo SplitWithNumInferSpmdReverse(
   auto x_dist_attr_dst = CopyTensorDistAttrForOutput(x_dist_attr);
   x_dist_attr_dst.set_dims_mapping(x_dims_mapping);
 
-  // step2.3 get new dist attribute for output. the splitted
+  // step2.3 get new dist attribute for output. the split
   // cannot be sharded, if it is sharded, set it to replicated.
   std::vector<TensorDistAttr> out_dist_attrs;
   for (int i = 0; i < nouts; i++) {
diff --git a/paddle/phi/infermeta/spmd_rules/unbind.cc b/paddle/phi/infermeta/spmd_rules/unbind.cc
@@ -138,7 +138,7 @@ SpmdInfo UnbindInferSpmdReverse(const DistMetaTensor& x,
   TensorDistAttr x_dist_attr_dst = CopyTensorDistAttrForOutput(x_dist_attr_src);
   x_dist_attr_dst.set_dims_mapping(x_dims_mapping);
 
-  // step2.3 get new dist attribute for output. the splitted
+  // step2.3 get new dist attribute for output. the split
   // cannot be sharded, if it is sharded, set it to replicated.
   std::vector<TensorDistAttr> out_dist_attrs_dst;
   for (int i = 0; i < nouts; i++) {
diff --git a/paddle/phi/kernels/onednn/split_kernel.cc b/paddle/phi/kernels/onednn/split_kernel.cc
@@ -33,10 +33,10 @@ const std::vector<int64_t> get_slice_strides(
   auto strides = full_md.get_strides();
   auto ndims = full_md.get_dims().size();
   auto full_dims = full_md.get_dims();
-  auto splitted_stride = strides[axis];
-  std::vector<int64_t> slice_strides(ndims, splitted_stride);
+  auto split_stride = strides[axis];
+  std::vector<int64_t> slice_strides(ndims, split_stride);
   for (size_t i = 0; i < ndims; ++i) {
-    slice_strides[i] = strides[i] > splitted_stride
+    slice_strides[i] = strides[i] > split_stride
                            ? (strides[i] / full_dims[axis]) * out_vec_dims[axis]
                            : strides[i];
   }

Original file line number	Diff line number	Diff line change
`@@ -68,9 +68,9 @@ std::vector<std::shared_ptr<DimTrans>> MakeFlattenDimTransReverse(`
`68`	`68`	`const std::vector<int64_t>& src_shape, int start_axis, int stop_axis) {`
`69`	`69`	`std::vector<std::shared_ptr<DimTrans>> ret;`
`70`	`70`
`71`		`- std::vector<int64_t> tgt_splitted_shape;`
	`71`	`+ std::vector<int64_t> tgt_split_shape;`
`72`	`72`	`for (int i = start_axis; i <= stop_axis; i++) {`
`73`		`- tgt_splitted_shape.emplace_back(src_shape[i]);`
	`73`	`+ tgt_split_shape.emplace_back(src_shape[i]);`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`for (int64_t i = 0; i < static_cast<int64_t>(src_shape.size()); i++) {`
`@@ -81,7 +81,7 @@ std::vector<std::shared_ptr<DimTrans>> MakeFlattenDimTransReverse(`
`81`	`81`	`std::make_shared<InputDim>(i - (stop_axis - start_axis)));`
`82`	`82`	`} else {`
`83`	`83`	`ret.emplace_back(make_split(std::make_shared<InputDim>(start_axis),`
`84`		`- tgt_splitted_shape,`
	`84`	`+ tgt_split_shape,`
`85`	`85`	`i - start_axis));`
`86`	`86`	`}`
`87`	`87`	`}`