Fix cadidate candidate, etc (#62163)

co63oc · web-flow · commit eee170a56f00 · 2024-02-29T23:38:28.000+08:00
diff --git a/paddle/cinn/backends/codegen_c_test.cc b/paddle/cinn/backends/codegen_c_test.cc
@@ -61,9 +61,9 @@ TEST(CodeGenC, module) {
   LOG(INFO) << "C.body: " << C->get_compute_op()->body.front();
 
   Target target;
-  target.arch = Target::Arch ::X86;
-  target.bits = Target::Bit ::k32;
-  target.os = Target::OS ::Linux;
+  target.arch = Target::Arch::X86;
+  target.bits = Target::Bit::k32;
+  target.os = Target::OS::Linux;
   Module::Builder builder("module1", target);
 
   ast_gen_ius::TensorGroup tensor_group({A, B, C});
diff --git a/paddle/cinn/ir/schedule/impl/base.cc b/paddle/cinn/ir/schedule/impl/base.cc
@@ -428,7 +428,7 @@ Expr DyScheduleImpl::SampleCategorical(
   std::string primitive = "SampleCategorical";
   std::ostringstream os;
   if (candidates.size() != probs.size()) {
-    os << "vector<int> params(candidates) and vector<int> prama(probs) must "
+    os << "vector<int> params(candidates) and vector<int> params(probs) must "
           "have same size in SampleCategorical!\n";
     throw IRScheduleErrorHandler(primitive, os.str(), module_expr_);
   }
diff --git a/paddle/cinn/ir/schedule/impl/compute_location.cc b/paddle/cinn/ir/schedule/impl/compute_location.cc
@@ -42,11 +42,11 @@ void DyScheduleImpl::ComputeAt(const Expr& block,
   std::string primitive = "ComputeAt";
   std::ostringstream os;
   if (!block.As<ir::ScheduleBlockRealize>()) {
-    os << "Expr prama(block) should be a ScheduleBlockRealize!\n";
+    os << "Expr param(block) should be a ScheduleBlockRealize!\n";
     throw IRScheduleErrorHandler(primitive, os.str(), module_expr_);
   }
   if (!loop.As<ir::For>()) {
-    os << "Expr prama(loop) should be a For node!\n";
+    os << "Expr param(loop) should be a For node!\n";
     throw IRScheduleErrorHandler(primitive, os.str(), module_expr_);
   }
   Expr root = this->GetRootBlock(block);
diff --git a/paddle/cinn/ir/schedule/ir_schedule_error.cc b/paddle/cinn/ir/schedule/ir_schedule_error.cc
@@ -21,7 +21,7 @@ namespace ir {
 
 std::string IRScheduleErrorHandler::GeneralErrorMessage() const {
   std::ostringstream os;
-  os << "[IRScheduleError] An error occurred in the scheduel primitive < "
+  os << "[IRScheduleError] An error occurred in the schedule primitive < "
      << this->primitive_ << " >. " << std::endl;
   os << indent_str_ << "[Error info] " << this->err_msg_;
   return os.str();
diff --git a/paddle/cinn/ir/schedule/ir_schedule_util.cc b/paddle/cinn/ir/schedule/ir_schedule_util.cc
@@ -207,7 +207,7 @@ void ReplaceExpr(Expr* source,
                  const std::vector<Expr>& candidates) {
   CHECK_EQ(replaced.size(), candidates.size())
       << "In ReplaceExpr, the size of Vars to be replaced must be equal to the "
-         "size of cadidate Exprs! Please check.";
+         "size of candidate Exprs! Please check.";
   if (replaced.empty()) return;
   std::map<Var, Expr, CompVar> replacing_map;
   for (int i = 0; i < replaced.size(); ++i) {
@@ -764,7 +764,7 @@ Expr ConstructNewLoopChain(const std::vector<Expr>& chain,
   //   }                                             }
   // }                                             }
   //
-  // We go throuph origin loop and check other body stmts, adding it as another
+  // We go through origin loop and check other body stmts, adding it as another
   // chain, such as:
   //
   // for (i, 0, 32) {
@@ -1022,7 +1022,7 @@ void InsertBlock(Expr& for_loop, const Expr& insertion, int index) {  // NOLINT
     auto dst_it = dst_block->stmts.begin() + index;
     if (dst_it->As<IfThenElse>()) {
       auto* inserted_block = dst_it->As<IfThenElse>()->true_case.As<Block>();
-      CHECK(inserted_block) << "the IfThenElse node to be inserted shuold "
+      CHECK(inserted_block) << "the IfThenElse node to be inserted should "
                                "contain a true_case block";
       inserted_block->stmts.insert(inserted_block->stmts.begin(), insertion);
     } else {
@@ -1060,7 +1060,7 @@ std::vector<IterRange> CalculateRequiredRegions(
   }
 
   std::vector<IterRange> required_buffer_range;
-  // deduce accessed regions of the provided tensor in block by itering each
+  // deduce accessed regions of the provided tensor in block by iterating each
   // required block
   for (const Expr& pro_node : provided_nodes) {
     std::string provided_tensor_name =
diff --git a/paddle/cinn/ir/schedule/schedule_desc.cc b/paddle/cinn/ir/schedule/schedule_desc.cc
@@ -27,7 +27,7 @@
 namespace cinn {
 namespace ir {
 
-// ------ Following codes are about `Apply` functions registry of variaous types
+// ------ Following codes are about `Apply` functions registry of various types
 // of ScheduleDesc::Step
 class PackedStepContext;
 // uniformed function prototype of a scheduling operation in IRSchedule
@@ -118,7 +118,7 @@ class PackedStepContext {
       return absl::get<AttrType>(attrs_.at(idx));
     } catch (absl::bad_variant_access& ex) {
       LOG(FATAL) << "Attribute cast error, idx:" << idx
-                 << ", get tpye:" << typeid(AttrType).name()
+                 << ", get type:" << typeid(AttrType).name()
                  << ", real index:" << attrs_.at(idx).index();
       throw ex;
     }
@@ -197,7 +197,7 @@ struct FreeFuncConverter<Return (IRSchedule::*)(Args...) const, impl_fn> {
   }
 };
 
-// used for formatting scheduling functions with variaous function signatures to
+// used for formatting scheduling functions with various function signatures to
 // be uniformed form
 template <typename F, F f>
 struct ApplyFuncImpl;
@@ -689,8 +689,8 @@ proto::ScheduleDesc ScheduleDesc::ToProto() const {
       }
     }
 
-    // each output Expr is represented by a formatted name, to be refered by
-    // suceeding steps
+    // each output Expr is represented by a formatted name, to be referred by
+    // succeeding steps
     for (auto&& expr : step.outputs) {
       std::string local_name = "e" + std::to_string(expr2name.size());
       expr2name.emplace(expr, local_name);
@@ -722,7 +722,7 @@ std::vector<Expr> ScheduleDesc::ReplayWithProto(
   absl::flat_hash_map<std::string, Expr> name2expr;
   std::vector<Expr> last_outputs;
 
-  // resotre each scheduling step and apply to the new IRSchedule object
+  // restore each scheduling step and apply to the new IRSchedule object
   for (auto&& step_proto : desc_proto.steps()) {
     VLOG(4) << "Replay step:\n" << step_proto.DebugString();
     ScheduleDesc::Step step;
diff --git a/paddle/cinn/ir/test/tensor_test.cc b/paddle/cinn/ir/test/tensor_test.cc
@@ -144,7 +144,7 @@ TEST(Tensor, ReshapeCopied) {
 
   stages->InsertLazily(B);
 
-  ir::Module::Builder builder("some_modue", cinn::common::DefaultHostTarget());
+  ir::Module::Builder builder("some_module", cinn::common::DefaultHostTarget());
   auto func = lang::Lower("fn", stages, {A, B}, {}, {}, &builder);
 
   backends::CodeGenC codegenc(cinn::common::DefaultHostTarget());
diff --git a/paddle/cinn/lang/lower_impl.h b/paddle/cinn/lang/lower_impl.h
@@ -150,8 +150,8 @@ class LowerImpl {
   std::vector<Tensor> CollectTemporaryTensors();
 
   /**
-   * \brief Check both the tensor_args and sclar_args not contain duplication
-   * (different arguemnt with the same name).
+   * \brief Check both the tensor_args and scalar_args not contain duplication
+   * (different argument with the same name).
    */
   void CheckArgsUnique();
 
@@ -304,7 +304,7 @@ struct MarkParallelMutator : public ir::IRMutator<Expr*> {
     auto it = parallels.find(tensor_n->name);
     if (it != parallels.end()) {
       for (int level : it->second) {
-        VLOG(1) << "Mark " << level << " Paralled";
+        VLOG(1) << "Mark " << level << " Parallelled";
         CHECK_LT(level, stack.size());
         stack[level]->set_parallel();
       }
diff --git a/paddle/cinn/optim/insert_debug_log_callee.cc b/paddle/cinn/optim/insert_debug_log_callee.cc
@@ -139,7 +139,7 @@ struct InsertDebugLogCalleeMutator : public ir::IRMutator<> {
     ir::IRMutator<>::Visit(&node->body, &node->body);
 
     auto deal_with_exprs =
-        [&](std::vector<Expr> *exprs) {  // deal with op->argument_preapre_exprs
+        [&](std::vector<Expr> *exprs) {  // deal with op->argument_prepare_exprs
           std::vector<Expr> new_stmts;
           for (auto &expr : *exprs) {
             auto msg =
diff --git a/paddle/cinn/optim/unroll_loops.cc b/paddle/cinn/optim/unroll_loops.cc
@@ -62,7 +62,7 @@ struct UnrollMutator : public ir::IRMutator<Expr*> {
   void Visit(const ir::For* op, Expr* expr) override {
     IRMutator<>::Visit(op, expr);
     if (op->extent.As<ir::IntImm>() == nullptr) {
-      VLOG(5) << "loop to be unrolled should have a contant extent";
+      VLOG(5) << "loop to be unrolled should have a constant extent";
       return;
     }
     int64_t extent = op->extent.as_int64();
diff --git a/paddle/cinn/runtime/cuda/cuda_intrinsics_reduce.cc b/paddle/cinn/runtime/cuda/cuda_intrinsics_reduce.cc
@@ -146,22 +146,22 @@ CINN_REGISTER_HELPER(cuda_intrinsics_reduce) {
 
 #undef REGISTER_BLOCK_REDUCE_FUNC_IMPL
 
-#define REGISTER_BLOCK_SHUFLLE_FUNC_IMPL(REDUCE_TYPE, DTYPE)              \
+#define REGISTER_BLOCK_SHUFFLE_FUNC_IMPL(REDUCE_TYPE, DTYPE)              \
   REGISTER_FACKED_EXTERN_FUNC_HELPER(block_shuffle_##REDUCE_TYPE, target) \
       .SetRetType<DTYPE>()                                                \
       .AddInputType<cinn_buffer_t *>()                                    \
       .AddInputType<int>()                                                \
       .End();
 
-  EXPAND_REDUCE_INT32_REGISTER_MARCO(REGISTER_BLOCK_SHUFLLE_FUNC_IMPL)
-  EXPAND_REDUCE_INT64_REGISTER_MARCO(REGISTER_BLOCK_SHUFLLE_FUNC_IMPL)
-  EXPAND_REDUCE_BF16_REGISTER_MACRO(REGISTER_BLOCK_SHUFLLE_FUNC_IMPL)
-  EXPAND_REDUCE_FP16_REGISTER_MACRO(REGISTER_BLOCK_SHUFLLE_FUNC_IMPL)
-  EXPAND_REDUCE_FP32_REGISTER_MACRO(REGISTER_BLOCK_SHUFLLE_FUNC_IMPL)
-  EXPAND_REDUCE_FP64_REGISTER_MACRO(REGISTER_BLOCK_SHUFLLE_FUNC_IMPL)
-  EXPAND_REDUCE_BOOL_REGISTER_MACRO(REGISTER_BLOCK_SHUFLLE_FUNC_IMPL)
+  EXPAND_REDUCE_INT32_REGISTER_MARCO(REGISTER_BLOCK_SHUFFLE_FUNC_IMPL)
+  EXPAND_REDUCE_INT64_REGISTER_MARCO(REGISTER_BLOCK_SHUFFLE_FUNC_IMPL)
+  EXPAND_REDUCE_BF16_REGISTER_MACRO(REGISTER_BLOCK_SHUFFLE_FUNC_IMPL)
+  EXPAND_REDUCE_FP16_REGISTER_MACRO(REGISTER_BLOCK_SHUFFLE_FUNC_IMPL)
+  EXPAND_REDUCE_FP32_REGISTER_MACRO(REGISTER_BLOCK_SHUFFLE_FUNC_IMPL)
+  EXPAND_REDUCE_FP64_REGISTER_MACRO(REGISTER_BLOCK_SHUFFLE_FUNC_IMPL)
+  EXPAND_REDUCE_BOOL_REGISTER_MACRO(REGISTER_BLOCK_SHUFFLE_FUNC_IMPL)
 
-#undef REGISTER_BLOCK_SHUFLLE_FUNC_IMPL
+#undef REGISTER_BLOCK_SHUFFLE_FUNC_IMPL
 
 #undef EXPAND_REDUCE_INT32_REGISTER_MARCO
 #undef EXPAND_REDUCE_INT64_REGISTER_MARCO
diff --git a/paddle/cinn/runtime/cuda/cuda_util.cc b/paddle/cinn/runtime/cuda/cuda_util.cc
@@ -481,7 +481,7 @@ void cinn_call_batched_cublas(void *v_args,
     void *B = args[1 + g].operator cinn_buffer_t *()->memory;
     void *C = args[1 + num_gemm + g].operator cinn_buffer_t *()->memory;
 
-    // if opside is 1, exhange A,B.
+    // if opside is 1, exchange A,B.
     if (opside) {
       auto tmp = A;
       A = B;
@@ -703,7 +703,7 @@ std::string debug_cudnn_pool_mode(cudnnPoolingMode_t pool_mode) {
     case CUDNN_POOLING_AVERAGE_COUNT_INCLUDE_PADDING:
       return "avg_include_padding";
     case CUDNN_POOLING_AVERAGE_COUNT_EXCLUDE_PADDING:
-      return "avg_exclulude_padding";
+      return "avg_exclude_padding";
     default:
       LOG(FATAL) << "Pool only support max and avg now!";
   }

Original file line number	Diff line number	Diff line change
`@@ -428,7 +428,7 @@ Expr DyScheduleImpl::SampleCategorical(`
`428`	`428`	`std::string primitive = "SampleCategorical";`
`429`	`429`	`std::ostringstream os;`
`430`	`430`	`if (candidates.size() != probs.size()) {`
`431`		`- os << "vector<int> params(candidates) and vector<int> prama(probs) must "`
	`431`	`+ os << "vector<int> params(candidates) and vector<int> params(probs) must "`
`432`	`432`	`"have same size in SampleCategorical!\n";`
`433`	`433`	`throw IRScheduleErrorHandler(primitive, os.str(), module_expr_);`
`434`	`434`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,11 +42,11 @@ void DyScheduleImpl::ComputeAt(const Expr& block,`
`42`	`42`	`std::string primitive = "ComputeAt";`
`43`	`43`	`std::ostringstream os;`
`44`	`44`	`if (!block.As<ir::ScheduleBlockRealize>()) {`
`45`		`- os << "Expr prama(block) should be a ScheduleBlockRealize!\n";`
	`45`	`+ os << "Expr param(block) should be a ScheduleBlockRealize!\n";`
`46`	`46`	`throw IRScheduleErrorHandler(primitive, os.str(), module_expr_);`
`47`	`47`	`}`
`48`	`48`	`if (!loop.As<ir::For>()) {`
`49`		`- os << "Expr prama(loop) should be a For node!\n";`
	`49`	`+ os << "Expr param(loop) should be a For node!\n";`
`50`	`50`	`throw IRScheduleErrorHandler(primitive, os.str(), module_expr_);`
`51`	`51`	`}`
`52`	`52`	`Expr root = this->GetRootBlock(block);`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ struct UnrollMutator : public ir::IRMutator<Expr*> {`
`62`	`62`	`void Visit(const ir::For* op, Expr* expr) override {`
`63`	`63`	`IRMutator<>::Visit(op, expr);`
`64`	`64`	`if (op->extent.As<ir::IntImm>() == nullptr) {`
`65`		`- VLOG(5) << "loop to be unrolled should have a contant extent";`
	`65`	`+ VLOG(5) << "loop to be unrolled should have a constant extent";`
`66`	`66`	`return;`
`67`	`67`	`}`
`68`	`68`	`int64_t extent = op->extent.as_int64();`