Fix typos output [fluid_ops] (#68718)

co63oc · web-flow · commit 301787876e45 · 2024-10-17T16:42:32.000+08:00
diff --git a/paddle/fluid/pir/dialect/distributed/ir/dist_tools.cc b/paddle/fluid/pir/dialect/distributed/ir/dist_tools.cc
@@ -222,7 +222,7 @@ void GetConnectedSubgraph(pir::Operation* op,
   }
 }
 
-// convert a singe value type to dist type.
+// convert a single value type to dist type.
 pir::Type CvtTypeToDist(pir::Type type, ProcessMeshAttribute mesh_attr) {
   if (!type) return nullptr;
   auto ctx = pir::IrContext::Instance();
diff --git a/paddle/fluid/pir/dialect/distributed/ir/dist_tools.h b/paddle/fluid/pir/dialect/distributed/ir/dist_tools.h
@@ -57,7 +57,7 @@ pir::Type CvtToPirDistType(
 ///    2. The value type's mesh is not equal to mesh_attr argument.
 ///    3. The operation that defines the value contains no inputs and 1 output.
 /// The function first clones the definition operation and replaces the use of
-/// the original value with the cloned ouput， Secondly, the mesh of the
+/// the original value with the cloned output， Secondly, the mesh of the
 /// original operation and value is updated with the 'mesh_attr' argument.
 /// Otherwise, the function does nothing.
 ///
diff --git a/paddle/fluid/pir/dialect/op_generator/cache_grad_op_symbol_shape_gen.py b/paddle/fluid/pir/dialect/op_generator/cache_grad_op_symbol_shape_gen.py
@@ -271,7 +271,7 @@ def gen_cpp_file_code(self, cpp_file_path):
 
 def ParseArguments():
     parser = argparse.ArgumentParser(
-        description='Generate Cache GradOp Symbol Shape Inferface Files By Yaml'
+        description='Generate Cache GradOp Symbol Shape Interface Files By Yaml'
     )
     parser.add_argument('--op_yaml_files', type=str)
     parser.add_argument('--op_compat_yaml_file', type=str)
diff --git a/paddle/fluid/pir/dialect/op_generator/ops_onednn_extra_parser.py b/paddle/fluid/pir/dialect/op_generator/ops_onednn_extra_parser.py
@@ -19,8 +19,8 @@
 
 def parse_plain_list(s: str, sep=",") -> list[str]:
     if sep == ",":
-        patten = re.compile(r',(?![^{]*\})')  # support "int[] a={1,2}"
-        items = re.split(patten, s.strip())
+        pattern = re.compile(r',(?![^{]*\})')  # support "int[] a={1,2}"
+        items = re.split(pattern, s.strip())
         items = [x.strip() for x in items]
         return items
     else:
diff --git a/paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/element_wise_binary.cc b/paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/element_wise_binary.cc
@@ -63,19 +63,19 @@ bool InferSymbolicShapeElementWiseBinary(
         x_shape.shape().size(),
         1,
         common::errors::InvalidArgument("When compute data, the rank of x "
-                                        "should be 0 or 1, but now recevied %d",
+                                        "should be 0 or 1, but now received %d",
                                         x_shape.shape().size()));
     PADDLE_ENFORCE_LE(
         y_shape.shape().size(),
         1,
         common::errors::InvalidArgument("When compute data, the rank of y "
-                                        "should be 0 or 1, but now recevied %d",
+                                        "should be 0 or 1, but now received %d",
                                         y_shape.shape().size()));
     PADDLE_ENFORCE_EQ(x_shape.data()->size(),
                       y_shape.data()->size(),
                       common::errors::InvalidArgument(
                           "When compute data, the size of x and y should be "
-                          "equal, but now recevied %d and %d",
+                          "equal, but now received %d and %d",
                           x_shape.data()->size(),
                           y_shape.data()->size()));
     std::vector<symbol::DimExpr> out_data;
diff --git a/paddle/fluid/pir/dialect/operator/interface/layout_transformation.cc b/paddle/fluid/pir/dialect/operator/interface/layout_transformation.cc
@@ -325,7 +325,7 @@ void RewriteByLayoutImpl<ConcatOp>(pir::Operation* op,
   auto axis = concrete_op.axis();
   if (!axis || !(axis.defining_op()->isa<FullOp>())) {
     PADDLE_THROW(common::errors::InvalidArgument(
-        "Concat's axis must be processed when rewirte by layout."));
+        "Concat's axis must be processed when rewrite by layout."));
   }
 
   // TODO(lyk): we must assert this full int array op has one user which is
diff --git a/paddle/fluid/pir/dialect/operator/ir/manual_op_vjp.cc b/paddle/fluid/pir/dialect/operator/ir/manual_op_vjp.cc
@@ -54,7 +54,7 @@ std::vector<std::vector<pir::Value>> ExpandOp::Vjp(
 
   Tensor shape(std::make_shared<primitive::LazyTensor>(inputs_[1][0]));
 
-  VLOG(6) << "Vjp prepare call expand's vjp inteface";
+  VLOG(6) << "Vjp prepare call expand's vjp interface";
 
   std::vector<std::vector<Tensor>> tensor_res =
       primitive::expand_vjp(x, out_grad, shape, stop_gradients);
@@ -96,7 +96,7 @@ std::vector<std::vector<pir::Value>> IncrementOp::Vjp(
 
   VLOG(6) << "Vjp prepare Prepare attributes of increment_grad";
 
-  VLOG(6) << "Vjp prepare call increment's vjp inteface";
+  VLOG(6) << "Vjp prepare call increment's vjp interface";
 
   pir::Value tensor_res = paddle::dialect::scale(out_grads[0][0]);
 
@@ -128,7 +128,7 @@ std::vector<std::vector<pir::Value>> Increment_Op::Vjp(
 
   float value = op->attribute("value").dyn_cast<pir::FloatAttribute>().data();
 
-  VLOG(6) << "Vjp prepare call increment_'s vjp inteface";
+  VLOG(6) << "Vjp prepare call increment_'s vjp interface";
 
   paddle::dialect::increment_(inputs_[0][0], -value);
 
@@ -203,7 +203,7 @@ std::vector<std::vector<pir::Value>> ArrayWrite_Op::Vjp(
           "ArrayWrite_ op's outputs size should be 1, but now is %d.",
           outputs.size()));
 
-  VLOG(6) << "Vjp prepare call  ArrayWrite_'s vjp inteface";
+  VLOG(6) << "Vjp prepare call  ArrayWrite_'s vjp interface";
   pir::Value x_grad =
       paddle::dialect::array_read(in_grads[0][0], inputs_[2][0]);
   pir::Value zero = paddle::dialect::zeros_like(inputs_[1][0]);
@@ -244,7 +244,7 @@ std::vector<std::vector<pir::Value>> ArrayReadOp::Vjp(
           "Array_read op's outputs size should be 1, but now is %d.",
           out_grads.size()));
 
-  VLOG(6) << "Vjp prepare call  Array_read's vjp inteface";
+  VLOG(6) << "Vjp prepare call  Array_read's vjp interface";
 
   pir::Value array_grad_i_origin =
       paddle::dialect::array_read(out_grads[1][0], inputs_[1][0]);
@@ -287,7 +287,7 @@ std::vector<std::vector<pir::Value>> ArrayToTensorOp::Vjp(
   bool use_stack =
       op->attribute("use_stack").dyn_cast<pir::BoolAttribute>().data();
 
-  VLOG(6) << "Vjp prepare call ArrayToTensor's vjp inteface";
+  VLOG(6) << "Vjp prepare call ArrayToTensor's vjp interface";
 
   pir::Value tensor_res = paddle::dialect::tensor_to_array(
       inputs_[0][0], out_grads[0][0], axis, use_stack);
diff --git a/paddle/fluid/pir/drr/src/pattern_graph.cc b/paddle/fluid/pir/drr/src/pattern_graph.cc
@@ -31,7 +31,7 @@ const drr::OpCall &PatternGraph::AddOpCall(
         id2owned_tensor_.count(tensor_name),
         0,
         common::errors::NotFound("Not found tensor."
-                                 "The intput tensor [%s] must exist "
+                                 "The input tensor [%s] must exist "
                                  "in pattern graph to be obtained.",
                                  tensor_name));
     id2owned_tensor_.at(tensor_name)->AddConsumer(op_call.get());
diff --git a/paddle/fluid/pir/drr/src/rewrite_pattern.cc b/paddle/fluid/pir/drr/src/rewrite_pattern.cc
@@ -315,7 +315,7 @@ bool DrrRewritePattern::MatchFromOutputToInput(
     return source_pattern_match_ctx->tensor_map().count(tensor_name) != 0 &&
            ir_value != source_pattern_match_ctx->tensor_map().at(tensor_name);
   };
-  // Update drr_q et.al information. Return false if faild.
+  // Update drr_q et.al information. Return false if failed.
   const auto& TryUpdateDrrQueue = [&](const OpCall* drr_producer_op,
                                       pir::Operation* ir_producer_op) -> bool {
     // still return true if both visited.
@@ -392,15 +392,15 @@ bool DrrRewritePattern::MatchFromOutputToInput(
       if (drr_input_tensors[i]->consumers().size() !=
           ir_input_values[i].use_count()) {
         matched = false;
-        VLOG(8) << drr_node->name() << " Match failed: consumers of drr intput["
+        VLOG(8) << drr_node->name() << " Match failed: consumers of drr input["
                 << i << "] { " << drr_input_tensors[i]->consumers().size()
-                << " } != consumers of pir intput[" << i << "] { "
+                << " } != consumers of pir input[" << i << "] { "
                 << ir_input_values[i].use_count() << " }.";
         break;
       }
 
       auto* ir_producer_op = ir_input_values[i].defining_op();
-      // Tigger early stop while operand is BlockArgument with
+      // Trigger early stop while operand is BlockArgument with
       // producer_op==nullptr.
       if (drr_producer_op && ir_producer_op == nullptr) {
         matched = false;
diff --git a/paddle/fluid/pir/serialize_deserialize/include/deserialize_utils.h b/paddle/fluid/pir/serialize_deserialize/include/deserialize_utils.h
@@ -87,8 +87,8 @@ T deserializeAttrFromJson(Json* attr_json, pir::IrContext* ctx) {
 template <>
 pir::FloatAttribute deserializeAttrFromJson<pir::FloatAttribute, float>(
     Json* attr_json, pir::IrContext* ctx) {
-  if (attr_json->contains(VOILD_DATA)) {
-    auto string = attr_json->at(VOILD_DATA).template get<std::string>();
+  if (attr_json->contains(VOID_DATA)) {
+    auto string = attr_json->at(VOID_DATA).template get<std::string>();
     if (string == "NAN") {
       return pir::FloatAttribute::get(ctx, std::nanf(""));
     } else if (string == "INF") {
@@ -105,8 +105,8 @@ pir::FloatAttribute deserializeAttrFromJson<pir::FloatAttribute, float>(
 template <>
 pir::DoubleAttribute deserializeAttrFromJson<pir::DoubleAttribute, double>(
     Json* attr_json, pir::IrContext* ctx) {
-  if (attr_json->contains(VOILD_DATA)) {
-    auto string = attr_json->at(VOILD_DATA).template get<std::string>();
+  if (attr_json->contains(VOID_DATA)) {
+    auto string = attr_json->at(VOID_DATA).template get<std::string>();
     if (string == "NAN") {
       return pir::DoubleAttribute::get(ctx, std::nanf(""));
     } else if (string == "INF") {
diff --git a/paddle/fluid/pir/serialize_deserialize/include/schema.h b/paddle/fluid/pir/serialize_deserialize/include/schema.h
@@ -76,7 +76,7 @@ namespace pir {
 // type/attr's contents which is json::array.
 #define DATA "D"
 // float/double data with nan, inf, -inf
-#define VOILD_DATA "VD"
+#define VOID_DATA "VD"
 
 // NULL_TYPE
 #define NULL_TYPE "NULL"
diff --git a/paddle/fluid/pir/serialize_deserialize/include/serialize_utils.h b/paddle/fluid/pir/serialize_deserialize/include/serialize_utils.h
@@ -114,12 +114,12 @@ Json serializeAttrToJson<pir::FloatAttribute>(const pir::FloatAttribute& attr) {
   auto data = attr.data();
 
   if (std::isnan(data)) {
-    json_obj[VOILD_DATA] = "NaN";
+    json_obj[VOID_DATA] = "NaN";
   } else if (std::isinf(data)) {
     if (static_cast<float>(data) > 0.0) {
-      json_obj[VOILD_DATA] = "INF";
+      json_obj[VOID_DATA] = "INF";
     } else {
-      json_obj[VOILD_DATA] = "-INF";
+      json_obj[VOID_DATA] = "-INF";
     }
   } else {
     json_obj[DATA] = data;
@@ -135,12 +135,12 @@ Json serializeAttrToJson<pir::DoubleAttribute>(
   auto data = attr.data();
 
   if (std::isnan(data)) {
-    json_obj[VOILD_DATA] = "NaN";
+    json_obj[VOID_DATA] = "NaN";
   } else if (std::isinf(data)) {
     if (static_cast<double>(data) > 0.0) {
-      json_obj[VOILD_DATA] = "INF";
+      json_obj[VOID_DATA] = "INF";
     } else if (static_cast<double>(data) < 0.0) {
-      json_obj[VOILD_DATA] = "-INF";
+      json_obj[VOID_DATA] = "-INF";
     }
   } else {
     json_obj[DATA] = data;
diff --git a/paddle/fluid/pir/serialize_deserialize/include/version_compat.h b/paddle/fluid/pir/serialize_deserialize/include/version_compat.h
@@ -39,7 +39,7 @@ class PatchBuilder {
   void IR_API BuildPatch(uint64_t pir_version,
                          uint64_t max_version,
                          const std::string& path = "");
-  /* If file_version != pir_vefrsion, set file_version for finding patch yamls.
+  /* If file_version != pir_version, set file_version for finding patch yamls.
    */
   void SetFileVersion(const uint64_t version) { file_version_ = version; }
   bool HasOpPatch(const std::string& name) const {
diff --git a/paddle/fluid/pir/serialize_deserialize/src/ir_deserialize.cc b/paddle/fluid/pir/serialize_deserialize/src/ir_deserialize.cc
@@ -42,7 +42,7 @@ void ProgramReader::ReadProgram(Json* program_json, pir::Program* program) {
       program_json->at(REGIONS).size(),
       1,
       common::errors::InvalidArgument(
-          "The redions size of program module should be 1 but got %d.",
+          "The regions size of program module should be 1 but got %d.",
           program_json->at(REGIONS).size()));
   auto& region_json = program_json->at(REGIONS).at(0);
   auto& block_json = region_json.at(BLOCKS).at(0);
@@ -138,7 +138,7 @@ pir::Operation* ProgramReader::ReadParameterOp(Json* op_json) {
   // attr is_distributed; is_parameter; need_clip; parameter_name; persistable;
   // stop_gradient; trainable;
   if (patch_builder->HasOpPatch(PARAMETEROP)) {
-    VLOG(8) << PARAMETEROP << " brefore: " << *op_json;
+    VLOG(8) << PARAMETEROP << " before: " << *op_json;
     Json op_patch = patch_builder->GetJsonOpPatch(PARAMETEROP);
     VLOG(8) << " get op patch:  " << op_patch;
     patch_builder->ApplyOpPatches(PARAMETEROP, op_json, op_patch);
@@ -231,7 +231,7 @@ pir::Operation* ProgramReader::ReadOp(Json* op_json) {
     return ReadParameterOp(op_json);
   }
   if (patch_builder->HasOpPatch(op_name)) {
-    VLOG(8) << op_name << " brefore: " << *op_json;
+    VLOG(8) << op_name << " before: " << *op_json;
     Json op_patch = patch_builder->GetJsonOpPatch(op_name);
     VLOG(8) << " get op patch:  " << op_patch;
     attr_patch = patch_builder->GetOpAttrPatchMap(op_patch);
@@ -389,7 +389,7 @@ pir::Attribute ProgramReader::ReadAttribute(Json* attr_json) {
   VLOG(6) << "Begin Read Attribute. ";
   auto attr_type = attr_json->at(ATTR_TYPE).at(ID).template get<std::string>();
   if (patch_builder && patch_builder->HasAttrPatch(attr_type)) {
-    VLOG(8) << attr_type << " brefore: " << *attr_json;
+    VLOG(8) << attr_type << " before: " << *attr_json;
     Json attr_patch = patch_builder->GetJsonAttrPatch(attr_type);
     patch_builder->ApplyAttrTypePatches(
         attr_type, &attr_json->at(ATTR_TYPE), attr_patch);
@@ -403,7 +403,7 @@ pir::Type ProgramReader::ReadType(Json* type_json) {
   auto type_name = type_json->at(ID).template get<std::string>();
   VLOG(8) << "Check patches for: " << type_name;
   if (patch_builder && patch_builder->HasTypePatch(type_name)) {
-    VLOG(8) << type_name << " brefore: " << *type_json;
+    VLOG(8) << type_name << " before: " << *type_json;
     Json type_patch = patch_builder->GetJsonTypePatch(type_name);
     patch_builder->ApplyTypePatches(type_name, type_json, type_patch);
     VLOG(8) << type_name << " has been patched: " << *type_json;
diff --git a/paddle/fluid/pir/serialize_deserialize/src/schema.cc b/paddle/fluid/pir/serialize_deserialize/src/schema.cc
@@ -83,7 +83,7 @@ std::string DialectIdMap::GetDecompressDialectId(const std::string& id) {
     PADDLE_ENFORCE(
         false,
         common::errors::InvalidArgument(
-            "Unknown id %s for decompress dialect, pleace check your file",
+            "Unknown id %s for decompress dialect, please check your file",
             id));
   }
   return "";
diff --git a/paddle/fluid/pir/utils/general_functions.cc b/paddle/fluid/pir/utils/general_functions.cc
@@ -224,7 +224,7 @@ Operation* GetDefiningOpForInput(const Operation* op, uint32_t index) {
   PADDLE_ENFORCE_EQ(
       index < op->num_operands() && op->operand_source(index),
       true,
-      common::errors::InvalidArgument("Intput operand's index must be valid."));
+      common::errors::InvalidArgument("Input operand's index must be valid."));
   return op->operand_source(index).defining_op();
 }
 
diff --git a/paddle/fluid/pir/utils/name_analysis.cc b/paddle/fluid/pir/utils/name_analysis.cc
@@ -30,7 +30,7 @@ pir::Value GetOutputValueByName(const pir::Program &program,
       if (op.attribute("output_name") == name_attr) {
         if (value) {
           PADDLE_THROW(common::errors::PreconditionNotMet(
-              "More than one shadow ouput named with %s found.", name));
+              "More than one shadow output named with %s found.", name));
         }
         value = op.operand_source(0);
       }
@@ -107,7 +107,7 @@ std::map<std::string, std::string> RenameValue(Value value,
                                                const std::string &new_name,
                                                Block *block) {
   std::map<std::string, std::string> rename_mapping;
-  VLOG(5) << "Strating to rename value to " << new_name;
+  VLOG(5) << "Starting to rename value to " << new_name;
   // Handle kwarg
   for (auto [name, kwarg] : block->kwargs()) {
     if (kwarg == value) {

Original file line number	Diff line number	Diff line change
`@@ -222,7 +222,7 @@ void GetConnectedSubgraph(pir::Operation* op,`
`222`	`222`	`}`
`223`	`223`	`}`
`224`	`224`
`225`		`-// convert a singe value type to dist type.`
	`225`	`+// convert a single value type to dist type.`
`226`	`226`	`pir::Type CvtTypeToDist(pir::Type type, ProcessMeshAttribute mesh_attr) {`
`227`	`227`	`if (!type) return nullptr;`
`228`	`228`	`auto ctx = pir::IrContext::Instance();`
Original file line number	Diff line number	Diff line change
`@@ -271,7 +271,7 @@ def gen_cpp_file_code(self, cpp_file_path):`
`271`	`271`
`272`	`272`	`def ParseArguments():`
`273`	`273`	`parser = argparse.ArgumentParser(`
`274`		`- description='Generate Cache GradOp Symbol Shape Inferface Files By Yaml'`
	`274`	`+ description='Generate Cache GradOp Symbol Shape Interface Files By Yaml'`
`275`	`275`	`)`
`276`	`276`	`parser.add_argument('--op_yaml_files', type=str)`
`277`	`277`	`parser.add_argument('--op_compat_yaml_file', type=str)`
Original file line number	Diff line number	Diff line change
`@@ -325,7 +325,7 @@ void RewriteByLayoutImpl<ConcatOp>(pir::Operation* op,`
`325`	`325`	`auto axis = concrete_op.axis();`
`326`	`326`	`if (!axis \|\| !(axis.defining_op()->isa<FullOp>())) {`
`327`	`327`	`PADDLE_THROW(common::errors::InvalidArgument(`
`328`		`- "Concat's axis must be processed when rewirte by layout."));`
	`328`	`+ "Concat's axis must be processed when rewrite by layout."));`
`329`	`329`	`}`
`330`	`330`
`331`	`331`	`// TODO(lyk): we must assert this full int array op has one user which is`