Fix some typos (force_persisable, SolvePersisableVarNames, etc.) (#61690)

co63oc · web-flow · commit 4ea3d22842e3 · 2024-02-19T15:44:37.000+08:00
diff --git a/paddle/fluid/framework/new_executor/pir_adaptor/pir_adaptor_util.cc b/paddle/fluid/framework/new_executor/pir_adaptor/pir_adaptor_util.cc
@@ -240,22 +240,22 @@ const std::unordered_set<std::string> SpecialOps = {
 
 Variable* CreateVar(pir::Value value,
                     const std::string& var_name_prefix,
-                    bool force_persisable,
+                    bool force_persistable,
                     ValueExecutionInfo* value_exe_info) {
   pir::Operation* def_op = value.defining_op();
-  bool is_persisable = false;
+  bool is_persistable = false;
   if (def_op->isa<::pir::ParameterOp>()) {
-    is_persisable = true;
+    is_persistable = true;
   } else if (auto attr =
-                 value.attribute<pir::BoolAttribute>(kAttrIsPersisable)) {
-    is_persisable = attr.data();
+                 value.attribute<pir::BoolAttribute>(kAttrIsPersistable)) {
+    is_persistable = attr.data();
   }
 
   Variable* var = nullptr;
   std::string name = var_name_prefix + "_inner_var_" +
                      std::to_string(value_exe_info->GetVar2VarName().size());
 
-  if (force_persisable || is_persisable) {
+  if (force_persistable || is_persistable) {
     VLOG(6) << "Create var: " << name << " in scope "
             << value_exe_info->GetScope()->root();
     var = const_cast<Scope*>(value_exe_info->GetScope()->root())->Var(name);
@@ -554,8 +554,8 @@ void HandleForSpecialOp(pir::Operation* op,
 
     auto value = op->operand_source(0);
     Scope* scope = const_cast<Scope*>(value_exe_info->GetScope());
-    if (value.defining_op()->HasAttribute(kAttrIsPersisable) &&
-        value.attribute<pir::BoolAttribute>(kAttrIsPersisable).data()) {
+    if (value.defining_op()->HasAttribute(kAttrIsPersistable) &&
+        value.attribute<pir::BoolAttribute>(kAttrIsPersistable).data()) {
       VLOG(6) << "Handle for builtin.shadow_ouptut persistable value:"
               << var_name;
       scope = const_cast<Scope*>(value_exe_info->GetScope()->root());
diff --git a/paddle/fluid/framework/new_executor/pir_adaptor/pir_adaptor_util.h b/paddle/fluid/framework/new_executor/pir_adaptor/pir_adaptor_util.h
@@ -126,7 +126,7 @@ inline bool IsInvalid(pir::Value value) {
 
 Variable* CreateVar(pir::Value value,
                     const std::string& var_name_prefix,
-                    bool force_persisable,
+                    bool force_persistable,
                     ValueExecutionInfo* value_exe_info);
 
 void BuildScope(const pir::Block& block,
diff --git a/paddle/fluid/framework/new_executor/pir_interpreter.cc b/paddle/fluid/framework/new_executor/pir_interpreter.cc
@@ -1305,7 +1305,7 @@ paddle::framework::FetchList PirInterpreter::Run(
     LOG_FIRST_N(INFO, 1) << "New Executor is Running ...";
     VLOG(4) << DebugValueInfo();
 
-    SolvePersisableVarNames();
+    SolvePersistableVarNames();
 
     if (VLOG_IS_ON(6)) {
       std::stringstream ss;
@@ -1395,7 +1395,7 @@ FetchList PirInterpreter::Run(const std::vector<std::string>& feed_names,
     LOG_FIRST_N(INFO, 1) << "New Executor is Running ...";
     VLOG(4) << DebugValueInfo();
 
-    SolvePersisableVarNames();
+    SolvePersistableVarNames();
 
     if (VLOG_IS_ON(6)) {
       std::stringstream ss;
@@ -1836,12 +1836,12 @@ ::pir::Value PirInterpreter::GetValueByName(const std::string& var_name) {
   return nullptr;
 }
 
-void PirInterpreter::SolvePersisableVarNames() {
-  VLOG(6) << "SolvePersisableVarNames";
+void PirInterpreter::SolvePersistableVarNames() {
+  VLOG(6) << "SolvePersistableVarNames";
   for (auto kv : value_exe_info_->GetValue2VarName()) {
     ::pir::Value value = kv.first;
     const std::string& var_name = kv.second;
-    auto bool_attr = value.attribute<::pir::BoolAttribute>(kAttrIsPersisable);
+    auto bool_attr = value.attribute<::pir::BoolAttribute>(kAttrIsPersistable);
     if (bool_attr && bool_attr.data()) {
       parameter_var_names_.insert(var_name);
     }
diff --git a/paddle/fluid/framework/new_executor/pir_interpreter.h b/paddle/fluid/framework/new_executor/pir_interpreter.h
@@ -245,7 +245,7 @@ class PirInterpreter : public InterpreterBaseImpl {
 
   void RecordStreamForGC(InstructionBase* instr);
 
-  void SolvePersisableVarNames();
+  void SolvePersistableVarNames();
 
   const interpreter::PirDependencyBuilder& GetPirDependencyBuilder() const;
 
diff --git a/paddle/fluid/ir_adaptor/translator/program_translator.cc b/paddle/fluid/ir_adaptor/translator/program_translator.cc
@@ -185,7 +185,7 @@ void ProgramTranslator::Translate() {
 
   for (size_t block_idx = 0; block_idx < legacy_program_->Size(); block_idx++) {
     const BlockDesc& block = legacy_program_->Block(block_idx);
-    SetIsPersisableAttributeForAllValue(block);
+    SetIsPersistableAttributeForAllValue(block);
   }
 }
 
@@ -768,13 +768,13 @@ const VariableDefiningInfo& ProgramTranslator::CreateUndefinedVariable(
   return param_map_.at(var_name);
 }
 
-void ProgramTranslator::SetIsPersisableAttributeForAllValue(
+void ProgramTranslator::SetIsPersistableAttributeForAllValue(
     const BlockDesc& block) {
-  // Currently we set is persisable for operation that generated a value
+  // Currently we set is persistable for operation that generated a value
   // connected with VarDesc
   for (const auto& [var_name, value_list] : param_map_) {
     if (no_cast_var_names.count(var_name) != 0) continue;
-    VLOG(10) << "[op translated][is persisable]" << var_name;
+    VLOG(10) << "[op translated][is persistable]" << var_name;
     VarDesc* var = block.FindVarRecursive(var_name);
     if (var == nullptr) {
       continue;
@@ -787,21 +787,21 @@ void ProgramTranslator::SetIsPersisableAttributeForAllValue(
           defining_op,
           phi::errors::PreconditionNotMet(
               "Defining operator of [%s] can not be nullptr", var_name));
-      VLOG(8) << "[op translated][is persisable]" << var_name
+      VLOG(8) << "[op translated][is persistable]" << var_name
               << " from: " << defining_op->name();
-      std::vector<pir::Attribute> is_persisable;
-      if (defining_op->HasAttribute(kAttrIsPersisable)) {
-        is_persisable = defining_op->attribute(kAttrIsPersisable)
-                            .dyn_cast<pir::ArrayAttribute>()
-                            .AsVector();
+      std::vector<pir::Attribute> is_persistable;
+      if (defining_op->HasAttribute(kAttrIsPersistable)) {
+        is_persistable = defining_op->attribute(kAttrIsPersistable)
+                             .dyn_cast<pir::ArrayAttribute>()
+                             .AsVector();
       } else {
-        is_persisable = std::vector<pir::Attribute>(
+        is_persistable = std::vector<pir::Attribute>(
             defining_op->num_results(), pir::BoolAttribute::get(ctx_, false));
       }
-      is_persisable[value.index()] =
+      is_persistable[value.index()] =
           pir::BoolAttribute::get(ctx_, var->Persistable());
-      defining_op->set_attribute(kAttrIsPersisable,
-                                 pir::ArrayAttribute::get(ctx_, is_persisable));
+      defining_op->set_attribute(
+          kAttrIsPersistable, pir::ArrayAttribute::get(ctx_, is_persistable));
     }
   }
 }
diff --git a/paddle/fluid/ir_adaptor/translator/program_translator.h b/paddle/fluid/ir_adaptor/translator/program_translator.h
@@ -124,7 +124,7 @@ class ProgramTranslator {
   void GetParameterForSingleBlock(const BlockDesc& block);
   void SetParameterFromSingleBlock(const BlockDesc& block);
   void SetStopGradientAttributeForAllValue(const BlockDesc& block);
-  void SetIsPersisableAttributeForAllValue(const BlockDesc& block);
+  void SetIsPersistableAttributeForAllValue(const BlockDesc& block);
 
   const VariableDefiningInfo& GetValueOrCreateInTop(
       const std::string& var_name, TranslationContext* translation_ctx);
diff --git a/paddle/fluid/pir/transforms/constant_folding_pass.cc b/paddle/fluid/pir/transforms/constant_folding_pass.cc
@@ -200,7 +200,8 @@ class ConstantFoldingPattern : public pir::RewritePattern {
         auto parameter_op = rewriter.Build<pir::ParameterOp>(
             output_var_name, op->result(i).type());
         parameter_op->set_attribute(
-            kAttrIsPersisable, rewriter.array_attr({rewriter.bool_attr(true)}));
+            kAttrIsPersistable,
+            rewriter.array_attr({rewriter.bool_attr(true)}));
 
         rewriter.ReplaceAllUsesWith(op->result(i), parameter_op->result(0));
 
@@ -221,7 +222,8 @@ class ConstantFoldingPattern : public pir::RewritePattern {
         auto constant_op = rewriter.Build<pir::ConstantTensorOp>(
             output_var_name, op->result(i).type());
         constant_op->set_attribute(
-            kAttrIsPersisable, rewriter.array_attr({rewriter.bool_attr(true)}));
+            kAttrIsPersistable,
+            rewriter.array_attr({rewriter.bool_attr(true)}));
 
         rewriter.ReplaceAllUsesWith(op->result(i), constant_op->result(0));
       }
@@ -290,15 +292,16 @@ class ConstantFoldingPattern : public pir::RewritePattern {
     const auto& var_name =
         pir::GetParameterNameFromValue(op->operand_source(index));
     auto* var = scope_->FindVar(var_name);
-    PADDLE_ENFORCE_NOT_NULL(var,
-                            phi::errors::InvalidArgument(
-                                "Persisable var [%s] not in scope.", var_name));
+    PADDLE_ENFORCE_NOT_NULL(
+        var,
+        phi::errors::InvalidArgument("Persistable var [%s] not in scope.",
+                                     var_name));
     auto from_op =
         builder.Build<Op>(var_name, op->operand_source(index).type());
     if (op->operand_source(index).use_count() <= 1) {
       deleted_vars_->push_back(var_name);
     } else {
-      from_op->set_attribute(kAttrIsPersisable,
+      from_op->set_attribute(kAttrIsPersistable,
                              rewriter.array_attr({rewriter.bool_attr(true)}));
     }
     return from_op;
@@ -446,7 +449,7 @@ class ConstantFoldingPatternForTrain : public ConstantFoldingPattern {
       auto constant_op = rewriter.Build<pir::ConstantTensorOp>(
           output_var_name, op->result(i).type());
       constant_op->set_attribute(
-          kAttrIsPersisable, rewriter.array_attr({rewriter.bool_attr(true)}));
+          kAttrIsPersistable, rewriter.array_attr({rewriter.bool_attr(true)}));
 
       rewriter.ReplaceAllUsesWith(op->result(i), constant_op->result(0));
     }
diff --git a/paddle/fluid/pir/transforms/inplace_pass.cc b/paddle/fluid/pir/transforms/inplace_pass.cc
@@ -54,7 +54,7 @@ std::unordered_set<std::string> RelaxShapeCheckOps = {
 
 // NOTE(zhangbo): Which kind of value can be deleted?
 // (1) Value's type needs to be AllocatedDenseTensorType or
-// AllocatedSelectedRowsType; (2) Value's is not persisable.
+// AllocatedSelectedRowsType; (2) Value's is not persistable.
 bool CanBeDeleted(pir::Value value) {
   if (!value.type()) {
     return false;
@@ -63,7 +63,7 @@ bool CanBeDeleted(pir::Value value) {
       !value.type().isa<paddle::dialect::AllocatedSelectedRowsType>()) {
     return false;
   }
-  auto persist_attr = value.attribute<pir::BoolAttribute>(kAttrIsPersisable);
+  auto persist_attr = value.attribute<pir::BoolAttribute>(kAttrIsPersistable);
   return !(persist_attr && persist_attr.data());
 }
 
diff --git a/paddle/fluid/pir/transforms/pd_op_to_kernel_pass.cc b/paddle/fluid/pir/transforms/pd_op_to_kernel_pass.cc
@@ -249,7 +249,7 @@ static phi::Backend DeriveBackend(const std::string& op,
                                   const OpYamlInfoParser* op_info_parser,
                                   phi::Backend kernel_backend,
                                   size_t input_index) {
-  // NOTE: Paramters are initilizered on executor place defined
+  // NOTE: Parameters are initilizered on executor place defined
   if ((op.compare(pir::SetParameterOp::name()) == 0 ||
        op.compare(pir::ShadowOutputOp::name()) == 0) &&
       place.GetType() == phi::AllocationType::GPU) {
@@ -395,8 +395,8 @@ static pir::Value AddPlaceTransferOp(pir::Value in,
   pir::Operation* op =
       pir::Operation::Create({in}, op_attribute, {out_type}, kernel_op_info);
   auto in_op = in.defining_op();
-  if (in_op && in_op->HasAttribute(kAttrIsPersisable)) {
-    op->set_attribute(kAttrIsPersisable, in_op->attribute(kAttrIsPersisable));
+  if (in_op && in_op->HasAttribute(kAttrIsPersistable)) {
+    op->set_attribute(kAttrIsPersistable, in_op->attribute(kAttrIsPersistable));
   }
   block->push_back(op);
   auto new_in = op->result(0);
@@ -435,8 +435,8 @@ static pir::Value AddOneDNN2PaddleLayoutTransferOp(
       pir::Operation::Create({in}, op_attribute, {out_type}, kernel_op_info);
 
   auto in_op = in.defining_op();
-  if (in_op && in_op->HasAttribute(kAttrIsPersisable)) {
-    op->set_attribute(kAttrIsPersisable, in_op->attribute(kAttrIsPersisable));
+  if (in_op && in_op->HasAttribute(kAttrIsPersistable)) {
+    op->set_attribute(kAttrIsPersistable, in_op->attribute(kAttrIsPersistable));
   }
 
   block->push_back(op);
@@ -625,8 +625,8 @@ pir::Value AddDtypeTransferOp(pir::Value in,
       {in}, op_attribute, {output_types}, kernel_op_info);
 
   auto in_op = in.defining_op();
-  if (in_op && in_op->HasAttribute(kAttrIsPersisable)) {
-    op->set_attribute(kAttrIsPersisable, in_op->attribute(kAttrIsPersisable));
+  if (in_op && in_op->HasAttribute(kAttrIsPersistable)) {
+    op->set_attribute(kAttrIsPersistable, in_op->attribute(kAttrIsPersistable));
   }
   block->push_back(op);
   pir::Value new_in = op->result(0);
diff --git a/paddle/fluid/pybind/pir.cc b/paddle/fluid/pybind/pir.cc
@@ -446,8 +446,8 @@ void BindBlock(py::module *m) {
              py::list param_list;
              for (auto &op : self) {
                if (op.name() == "builtin.parameter" &&
-                   op.HasAttribute(kAttrIsPersisable)) {
-                 auto attrs = op.attribute(kAttrIsPersisable)
+                   op.HasAttribute(kAttrIsPersistable)) {
+                 auto attrs = op.attribute(kAttrIsPersistable)
                                   .dyn_cast<pir::ArrayAttribute>()
                                   .AsVector();
                  for (uint32_t i = 0; i < attrs.size(); i++) {
@@ -776,12 +776,13 @@ void BindValue(py::module *m) {
       .def_property(
           "persistable",
           [](Value self) {
-            auto persistable = self.attribute<BoolAttribute>(kAttrIsPersisable);
+            auto persistable =
+                self.attribute<BoolAttribute>(kAttrIsPersistable);
             return !persistable || persistable.data();
           },
           [](Value self, bool persistable) {
             self.set_attribute(
-                kAttrIsPersisable,
+                kAttrIsPersistable,
                 BoolAttribute::get(pir::IrContext::Instance(), persistable));
           })
       .def("all_used_ops",
@@ -1438,10 +1439,10 @@ void BindUtils(pybind11::module *m) {
 
                 >>> print(pir_program)
                 {
-                 (%0) = "pd_op.data" () {dtype:(pd_op.DataType)float32,is_persisable:[false],name:"x",place:(pd_op.Place)Place(undefined:0),shape:(pd_op.IntArray)[4,4],stop_gradient:[false]} : () -> pd_op.tensor<4x4xf32>
-                 (%1) = "pd_op.matmul" (%0, %0) {is_persisable:[false],stop_gradient:[false],transpose_x:false,transpose_y:false} : (pd_op.tensor<4x4xf32>, pd_op.tensor<4x4xf32>) -> pd_op.tensor<4x4xf32>
-                 (%2) = "pd_op.add" (%1, %1) {is_persisable:[false],stop_gradient:[false]} : (pd_op.tensor<4x4xf32>, pd_op.tensor<4x4xf32>) -> pd_op.tensor<4x4xf32>
-                 (%3) = "pd_op.tanh" (%2) {is_persisable:[false],stop_gradient:[false]} : (pd_op.tensor<4x4xf32>) -> pd_op.tensor<4x4xf32>
+                 (%0) = "pd_op.data" () {dtype:(pd_op.DataType)float32,is_persistable:[false],name:"x",place:(pd_op.Place)Place(undefined:0),shape:(pd_op.IntArray)[4,4],stop_gradient:[false]} : () -> pd_op.tensor<4x4xf32>
+                 (%1) = "pd_op.matmul" (%0, %0) {is_persistable:[false],stop_gradient:[false],transpose_x:false,transpose_y:false} : (pd_op.tensor<4x4xf32>, pd_op.tensor<4x4xf32>) -> pd_op.tensor<4x4xf32>
+                 (%2) = "pd_op.add" (%1, %1) {is_persistable:[false],stop_gradient:[false]} : (pd_op.tensor<4x4xf32>, pd_op.tensor<4x4xf32>) -> pd_op.tensor<4x4xf32>
+                 (%3) = "pd_op.tanh" (%2) {is_persistable:[false],stop_gradient:[false]} : (pd_op.tensor<4x4xf32>) -> pd_op.tensor<4x4xf32>
                 }
 
 
@@ -1513,10 +1514,10 @@ void BindUtils(pybind11::module *m) {
 
                 >>> print(pir_program)
                 {
-                 (%0) = "pd_op.data" () {dtype:(pd_op.DataType)float32,is_persisable:[false],name:"x",place:(pd_op.Place)Place(undefined:0),shape:(pd_op.IntArray)[4,4],stop_gradient:[false]} : () -> pd_op.tensor<4x4xf32>
-                 (%1) = "pd_op.matmul" (%0, %0) {is_persisable:[false],stop_gradient:[false],transpose_x:false,transpose_y:false} : (pd_op.tensor<4x4xf32>, pd_op.tensor<4x4xf32>) -> pd_op.tensor<4x4xf32>
-                 (%2) = "pd_op.add" (%1, %1) {is_persisable:[false],stop_gradient:[false]} : (pd_op.tensor<4x4xf32>, pd_op.tensor<4x4xf32>) -> pd_op.tensor<4x4xf32>
-                 (%3) = "pd_op.tanh" (%2) {is_persisable:[false],stop_gradient:[false]} : (pd_op.tensor<4x4xf32>) -> pd_op.tensor<4x4xf32>
+                 (%0) = "pd_op.data" () {dtype:(pd_op.DataType)float32,is_persistable:[false],name:"x",place:(pd_op.Place)Place(undefined:0),shape:(pd_op.IntArray)[4,4],stop_gradient:[false]} : () -> pd_op.tensor<4x4xf32>
+                 (%1) = "pd_op.matmul" (%0, %0) {is_persistable:[false],stop_gradient:[false],transpose_x:false,transpose_y:false} : (pd_op.tensor<4x4xf32>, pd_op.tensor<4x4xf32>) -> pd_op.tensor<4x4xf32>
+                 (%2) = "pd_op.add" (%1, %1) {is_persistable:[false],stop_gradient:[false]} : (pd_op.tensor<4x4xf32>, pd_op.tensor<4x4xf32>) -> pd_op.tensor<4x4xf32>
+                 (%3) = "pd_op.tanh" (%2) {is_persistable:[false],stop_gradient:[false]} : (pd_op.tensor<4x4xf32>) -> pd_op.tensor<4x4xf32>
                 }
 
                 >>> print(mappings)
diff --git a/paddle/pir/include/core/attribute.h b/paddle/pir/include/core/attribute.h
@@ -18,7 +18,7 @@
 #include "paddle/pir/include/core/type_id.h"
 
 constexpr char kAttrStopGradients[] = "stop_gradient";
-constexpr char kAttrIsPersisable[] = "is_persisable";
+constexpr char kAttrIsPersistable[] = "is_persistable";
 
 namespace pir {
 class AttributeStorage;
diff --git a/python/paddle/autograd/backward_mode.py b/python/paddle/autograd/backward_mode.py
@@ -84,7 +84,7 @@ def check_tensors(in_out_list, name):
         assert in_out_list is not None, f"{name} should not be None"
 
         if isinstance(in_out_list, (list, tuple)):
-            assert len(in_out_list) > 0, f"{name} connot be empty"
+            assert len(in_out_list) > 0, f"{name} cannot be empty"
             for each_var in in_out_list:
                 assert isinstance(
                     each_var, (paddle.Tensor, core.eager.Tensor)
diff --git a/python/paddle/autograd/backward_utils.py b/python/paddle/autograd/backward_utils.py
@@ -168,7 +168,7 @@ def __repr__(self) -> str:
 class State:
     """
     record relationship of forward op/value and backward op/value
-    one state must be bining with a block, if block has parent block,
+    one state must be binding with a block, if block has parent block,
     state will include parent block info.
 
     """
@@ -319,7 +319,7 @@ def inverse_sort_op(ops):
 
     '''
 
-    # init pending_count[op] which descibes number of
+    # init pending_count[op] which describes number of
     # pending edges for its grad_op
 
     pending_count = collections.defaultdict(int)
@@ -381,7 +381,7 @@ def inverse_sort_op(ops):
 
 def is_inplace_net(op_list):
     '''
-    when program has inpalce op , it's difficult to find the actual pending_count.
+    when program has inplace op , it's difficult to find the actual pending_count.
     '''
     for op in op_list:
         if op.name() in ["pd_op.array_write_", "pd_op.assign_out_"]:
@@ -442,7 +442,7 @@ def all_stop_gradient_true(block):
 def parent_total_ops(block):
     '''
     when block is sub_block, forward op should include its parent block ops
-    (sub block nest should Add on demand to aviod block copy)
+    (sub block nest should Add on demand to avoid block copy)
     '''
     total_ops = []
     if block.parent_block is not None:
diff --git a/python/paddle/autograd/ir_backward.py b/python/paddle/autograd/ir_backward.py
diff --git a/test/cpp/pir/core/TestParserText.txt b/test/cpp/pir/core/TestParserText.txt
