Fix axies -> axes (#62481)

co63oc · web-flow · commit be55c7b6aa03 · 2024-03-07T10:59:55.000+08:00
diff --git a/paddle/cinn/hlir/framework/pir/op_lowering_util.cc b/paddle/cinn/hlir/framework/pir/op_lowering_util.cc
@@ -727,7 +727,7 @@ void LoopAssignReduceWithoutLast(ir::IRSchedule& ir_sch,  // NOLINT
           // the loop size at axis is 1, need remove
           axes_shift_num[j] = -1;
         } else if (axes[j] > idx) {
-          // the axies value need left shift
+          // the axes value need left shift
           axes_shift_num[j]++;
         }
       }
diff --git a/paddle/cinn/hlir/pe/ir_schedule_pe.cc b/paddle/cinn/hlir/pe/ir_schedule_pe.cc
@@ -200,7 +200,7 @@ std::vector<cinn::common::CINNValue> IRCudaScheduleMatMul(
   ir_sch.MergeExprs();
   // Generally, there are 2 ScheduleBlocks in the lowered function,
   // the first is for reduce_init and the second is the real compute block,
-  // here we use loops of the first block to Bind GPU index in top spatial axies
+  // here we use loops of the first block to Bind GPU index in top spatial axes
   auto init_block = ir_sch.GetAllBlocks().front();
   VLOG(3) << "Matmul lowered expr:\n" << ir_sch.GetModule().GetExprs().front();
 
diff --git a/paddle/cinn/hlir/pe/schedule.cc b/paddle/cinn/hlir/pe/schedule.cc
@@ -290,7 +290,7 @@ void MatmulScheduleCPU(poly::StageMap stages,
   for (int i = 0; i < all_axes_inner.size(); ++i) {
     all_axes.push_back(all_axes_inner[i]);
   }
-  // int axies
+  // int axes
   CHECK_EQ(all_axes.size(), out_axis_dims);
   if (is_k_splited) {
     if (is_m_splited || is_n_splited) {
diff --git a/paddle/cinn/ir/tensor.cc b/paddle/cinn/ir/tensor.cc
@@ -359,7 +359,7 @@ ir::Tensor _Tensor_::InitReduction(poly::StageMap stages,
   std::vector<std::string> reduce_axis_input =
       stages[this]->origin_reduce_axis_names();
   auto origin_domain = stages[this]->domain();
-  auto reduce_axis_output = poly::GetRelatedOutputAxies(
+  auto reduce_axis_output = poly::GetRelatedOutputAxes(
       temp_transform, origin_domain, reduce_axis_input);
   std::set<std::string> reduce_axis_output_set;
   for (auto &i : reduce_axis_output) {
@@ -374,7 +374,7 @@ ir::Tensor _Tensor_::InitReduction(poly::StageMap stages,
     }
   }
 
-  temp_transform = poly::RemoveAxiesByOutputNames(
+  temp_transform = poly::RemoveAxesByOutputNames(
       temp_transform, origin_domain, reduce_axis_output);
 
   //! When the first axis is not reduce axis, do ComputeAt.
@@ -386,7 +386,7 @@ ir::Tensor _Tensor_::InitReduction(poly::StageMap stages,
     init_tensor->shape = shape;
     return init_tensor;
   }
-  //! When reduce axies are reordered to front, ComputeAt is illegal.
+  //! When reduce axes are reordered to front, ComputeAt is illegal.
   //! So we just copy transform and forloopInfo.
   isl_map_set_tuple_name(
       temp_transform.get(), isl_dim_in, init_reduce_tensor_name.c_str());
diff --git a/paddle/cinn/poly/isl_utils.cc b/paddle/cinn/poly/isl_utils.cc
@@ -422,14 +422,14 @@ isl::set isl_set_dim_name_if_null(
   return isl::manage(set);
 }
 
-isl::map RemoveAxiesByInputNames(const isl::map &x,
-                                 const isl::set &origin_domain,
-                                 const std::vector<std::string> &dim_in_names) {
+isl::map RemoveAxesByInputNames(const isl::map &x,
+                                const isl::set &origin_domain,
+                                const std::vector<std::string> &dim_in_names) {
   std::string map_str = isl_map_to_str(x.get());
   isl::ctx this_ctx = x.ctx();
   isl::map temp_transform(this_ctx, map_str);
   auto related_output_names =
-      GetRelatedOutputAxies(x, origin_domain, dim_in_names);
+      GetRelatedOutputAxes(x, origin_domain, dim_in_names);
   if (dim_in_names.empty()) return temp_transform;
   for (auto &i : dim_in_names) {
     temp_transform = isl::manage(isl_remove_axis_by_name(
@@ -442,15 +442,15 @@ isl::map RemoveAxiesByInputNames(const isl::map &x,
   return temp_transform;
 }
 
-isl::map RemoveAxiesByOutputNames(
+isl::map RemoveAxesByOutputNames(
     const isl::map &x,
     const isl::set &origin_domain,
     const std::vector<std::string> &dim_out_names) {
   std::string map_str = isl_map_to_str(x.get());
   isl::ctx this_ctx = x.ctx();
   isl::map temp_transform(this_ctx, map_str);
   auto related_input_names =
-      GetRelatedInputAxies(x, origin_domain, dim_out_names);
+      GetRelatedInputAxes(x, origin_domain, dim_out_names);
   if (dim_out_names.empty()) return temp_transform;
   for (auto &i : dim_out_names) {
     temp_transform = isl::manage(isl_remove_axis_by_name(
@@ -463,24 +463,24 @@ isl::map RemoveAxiesByOutputNames(
   return temp_transform;
 }
 
-std::vector<std::string> GetRelatedOutputAxies(
+std::vector<std::string> GetRelatedOutputAxes(
     const isl::map &x,
     const isl::set &origin_domain,
     const std::vector<std::string> &dim_in_names) {
   std::string map_str = isl_map_to_str(x.get());
-  VLOG(1) << "GetRelatedOutputAxies map_str is : " << map_str;
+  VLOG(1) << "GetRelatedOutputAxes map_str is : " << map_str;
   isl::ctx this_ctx = x.ctx();
   isl::map temp_transform(this_ctx, map_str);
   auto dim_out_names = isl_get_dim_names(temp_transform, isl_dim_out);
   std::set<std::string> dim_in_set;
   for (auto &i : dim_in_names) {
-    VLOG(1) << "GetRelatedOutputAxies dim_in_names is : " << i;
+    VLOG(1) << "GetRelatedOutputAxes dim_in_names is : " << i;
     dim_in_set.insert(i);
   }
   std::set<std::string> res_set;
   for (auto &i : dim_out_names) {
     auto related_in_dim =
-        GetRelatedInputAxies(temp_transform, origin_domain, {i});
+        GetRelatedInputAxes(temp_transform, origin_domain, {i});
     for (auto &j : related_in_dim) {
       if (dim_in_set.count(j) > 0) {
         res_set.insert(i);
@@ -489,24 +489,24 @@ std::vector<std::string> GetRelatedOutputAxies(
   }
   std::vector<std::string> res;
   for (auto &i : res_set) {
-    VLOG(1) << "GetRelatedOutputAxies res is : " << i;
+    VLOG(1) << "GetRelatedOutputAxes res is : " << i;
     res.push_back(i);
   }
   return res;
 }
 
-std::vector<std::string> GetRelatedInputAxies(
+std::vector<std::string> GetRelatedInputAxes(
     const isl::map &x,
     const isl::set &origin_domain,
     const std::vector<std::string> &dim_out_names,
     bool strict) {
   std::string map_str = isl_map_to_str(x.get());
-  VLOG(1) << "GetRelatedInputAxies map_str is : " << map_str;
+  VLOG(1) << "GetRelatedInputAxes map_str is : " << map_str;
   isl::ctx this_ctx = x.ctx();
   isl::map temp_transform(this_ctx, map_str);
   auto dim_in_names = isl_get_dim_names(temp_transform, isl_dim_in);
   for (auto &i : dim_out_names) {
-    VLOG(1) << "GetRelatedInputAxies dim_out_names is : " << i;
+    VLOG(1) << "GetRelatedInputAxes dim_out_names is : " << i;
     temp_transform = isl::manage(isl_remove_axis_by_name(
         temp_transform.release(), isl_dim_out, i.c_str()));
   }
@@ -526,10 +526,10 @@ std::vector<std::string> GetRelatedInputAxies(
   }
   for (auto &i : dim_in_names) {
     if (utils::Count(&map_str, i) != utils::Count(&deleted_map, i)) {
-      VLOG(1) << "GetRelatedInputAxies res is : " << i;
+      VLOG(1) << "GetRelatedInputAxes res is : " << i;
       res.push_back(i);
     } else if (out_set_without_suffix.count(i) > 0 && !strict) {
-      VLOG(1) << "GetRelatedInputAxies res is : " << i;
+      VLOG(1) << "GetRelatedInputAxes res is : " << i;
       res.push_back(i);
     } else if (out_set.count(i) > 0) {
       auto range1 = isl_set_get_axis_range_by_name(origin_domain.get(), i);
diff --git a/paddle/cinn/poly/isl_utils.h b/paddle/cinn/poly/isl_utils.h
@@ -122,9 +122,9 @@ isl::set SetGetDims(isl::set set, const std::vector<int>& dims);
  * @param dim_in_names The names of input dims to remove.
  * @return The edited map.
  */
-isl::map RemoveAxiesByInputNames(const isl::map& x,
-                                 const isl::set& origin_domain,
-                                 const std::vector<std::string>& dim_in_names);
+isl::map RemoveAxesByInputNames(const isl::map& x,
+                                const isl::set& origin_domain,
+                                const std::vector<std::string>& dim_in_names);
 
 /**
  * Given an isl::map and a vector of names of dim_out,
@@ -133,22 +133,21 @@ isl::map RemoveAxiesByInputNames(const isl::map& x,
  * @param dim_in_names The names of output dims to remove.
  * @return The edited map.
  */
-isl::map RemoveAxiesByOutputNames(
-    const isl::map& x,
-    const isl::set& origin_domain,
-    const std::vector<std::string>& dim_out_names);
+isl::map RemoveAxesByOutputNames(const isl::map& x,
+                                 const isl::set& origin_domain,
+                                 const std::vector<std::string>& dim_out_names);
 
 /**
  * Given an isl::map and a vector of names of dim_out,
  * get the names of related input dims.
  * @param x The input map.
  * @param dim_out_names The names of output dims.
- * @param strict Indicates whether computes the strictly related input axies.
+ * @param strict Indicates whether computes the strictly related input axes.
  * For example, if strict == true, then input 'j' is related to output
  * 'j_outer_inner_outer'
  * @return The vector of names of related input dims.
  */
-std::vector<std::string> GetRelatedInputAxies(
+std::vector<std::string> GetRelatedInputAxes(
     const isl::map& x,
     const isl::set& origin_domain,
     const std::vector<std::string>& dim_out_names,
@@ -161,7 +160,7 @@ std::vector<std::string> GetRelatedInputAxies(
  * @param dim_in_names The names of input dims.
  * @return The vector of names of related output dims.
  */
-std::vector<std::string> GetRelatedOutputAxies(
+std::vector<std::string> GetRelatedOutputAxes(
     const isl::map& x,
     const isl::set& origin_domain,
     const std::vector<std::string>& dim_in_names);
diff --git a/paddle/cinn/poly/stage.cc b/paddle/cinn/poly/stage.cc
@@ -441,7 +441,7 @@ void Stage::EditTempTensor(Stage *other, int level) {
       }
     }
     // Iterators of loop within level will be erased.
-    auto related_dim_in = GetRelatedInputAxies(
+    auto related_dim_in = GetRelatedInputAxes(
         this->transform(), this->domain(), {transform_domain_names[i]});
     for (auto &j : related_dim_in) {
       erase_var.insert(j);
@@ -460,27 +460,27 @@ void Stage::EditTempTensor(Stage *other, int level) {
       if (bind_info[new_i].for_type == ir::ForType::GPUBlock &&
           (this->scope() == ScopeKind::kShared ||
            this->scope() == ScopeKind::kLocal)) {
-        auto related_dim_in = GetRelatedInputAxies(
+        auto related_dim_in = GetRelatedInputAxes(
             this->transform(), this->domain(), {transform_domain_names[i]});
         for (auto &j : related_dim_in) {
           erase_var.insert(j);
         }
       } else if (bind_info[new_i].for_type == ir::ForType::GPUThread &&
                  (this->scope() == ScopeKind::kLocal)) {
-        auto related_dim_in = GetRelatedInputAxies(
+        auto related_dim_in = GetRelatedInputAxes(
             this->transform(), this->domain(), {transform_domain_names[i]});
         for (auto &j : related_dim_in) {
           erase_var.insert(j);
         }
       } else {
-        auto related_dim_in = GetRelatedInputAxies(
+        auto related_dim_in = GetRelatedInputAxes(
             this->transform(), this->domain(), {transform_domain_names[i]});
         for (auto &j : related_dim_in) {
           undo_erase_var.insert(j);
         }
       }
     } else {
-      auto related_dim_in = GetRelatedInputAxies(
+      auto related_dim_in = GetRelatedInputAxes(
           this->transform(), this->domain(), {transform_domain_names[i]});
       for (auto &j : related_dim_in) {
         undo_erase_var.insert(j);
@@ -608,9 +608,9 @@ void Stage::ComputeAt(Stage *other, int level) {
     level_out_dims.push_back(target_map_dims[i]);
     related_output_dims_set.insert(target_map_dims[i]);
   }
-  auto related_input_dims = GetRelatedInputAxies(
+  auto related_input_dims = GetRelatedInputAxes(
       new_target_transform, other->domain(), level_out_dims);
-  auto related_output_dims = GetRelatedOutputAxies(
+  auto related_output_dims = GetRelatedOutputAxes(
       new_target_transform, other->domain(), related_input_dims);
   for (auto &i : related_output_dims) {
     related_output_dims_set.insert(i);
@@ -708,7 +708,7 @@ void Stage::ComputeAt(Stage *other, int level) {
       int max_iv = maxv.get_num_si();
       int min_iv = minv.get_num_si();
       auto related_input_dims =
-          GetRelatedInputAxies(trans_res, domain_, {trans_dim_out[i]}, true);
+          GetRelatedInputAxes(trans_res, domain_, {trans_dim_out[i]}, true);
       if (max_iv != min_iv && related_input_dims.empty()) {
         trans_res = isl::manage(isl_remove_axis_by_name(
             trans_res.release(), isl_dim_out, trans_dim_out[i].c_str()));
@@ -1627,7 +1627,7 @@ void Stage::AddForloopInfo(int level, const StageForloopInfo &info) {
 }
 
 void Stage::CopyTransform(Stage *other, int level) {
-  auto target_transform = RemoveAxiesByInputNames(
+  auto target_transform = RemoveAxesByInputNames(
       other->transform(), other->domain(), other->origin_reduce_axis_names());
   isl::set target_origin_domain(other->domain().ctx(),
                                 isl_set_to_str(other->domain().get()));
@@ -1654,9 +1654,9 @@ void Stage::CopyTransform(Stage *other, int level) {
       dim_out_level.push_back(
           isl_map_get_dim_name(temp_target_trans.get(), isl_dim_out, i));
     }
-    auto related_dim_in = GetRelatedInputAxies(
+    auto related_dim_in = GetRelatedInputAxes(
         temp_target_trans, target_origin_domain, dim_out_level);
-    auto related_dim_out = GetRelatedOutputAxies(
+    auto related_dim_out = GetRelatedOutputAxes(
         temp_target_trans, target_origin_domain, related_dim_in);
     for (auto &i : related_dim_out) {
       if (i == pivot_dim_out) {

Original file line number	Diff line number	Diff line change
`@@ -727,7 +727,7 @@ void LoopAssignReduceWithoutLast(ir::IRSchedule& ir_sch, // NOLINT`
`727`	`727`	`// the loop size at axis is 1, need remove`
`728`	`728`	`axes_shift_num[j] = -1;`
`729`	`729`	`} else if (axes[j] > idx) {`
`730`		`- // the axies value need left shift`
	`730`	`+ // the axes value need left shift`
`731`	`731`	`axes_shift_num[j]++;`
`732`	`732`	`}`
`733`	`733`	`}`
Original file line number	Diff line number	Diff line change
`@@ -290,7 +290,7 @@ void MatmulScheduleCPU(poly::StageMap stages,`
`290`	`290`	`for (int i = 0; i < all_axes_inner.size(); ++i) {`
`291`	`291`	`all_axes.push_back(all_axes_inner[i]);`
`292`	`292`	`}`
`293`		`- // int axies`
	`293`	`+ // int axes`
`294`	`294`	`CHECK_EQ(all_axes.size(), out_axis_dims);`
`295`	`295`	`if (is_k_splited) {`
`296`	`296`	`if (is_m_splited \|\| is_n_splited) {`