PaddlePaddle
diff --git a/‎paddle/fluid/framework/ir/delete_remove_padding_recover_padding_pass.cc
Copy file name to clipboard
+6-4Lines changed: 6 additions & 4 deletions b/‎paddle/fluid/framework/ir/delete_remove_padding_recover_padding_pass.cc
Copy file name to clipboard
+6-4Lines changed: 6 additions & 4 deletions
diff --git a/‎paddle/fluid/framework/ir/quantize_helper.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/fluid/framework/ir/quantize_helper.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎paddle/fluid/framework/program_desc.cc
Copy file name to clipboard
+14-13Lines changed: 14 additions & 13 deletions b/‎paddle/fluid/framework/program_desc.cc
Copy file name to clipboard
+14-13Lines changed: 14 additions & 13 deletions
diff --git a/‎paddle/fluid/pir/dialect/operator/utils/op_yaml_info_parser.cc
Copy file name to clipboard
+5-5Lines changed: 5 additions & 5 deletions b/‎paddle/fluid/pir/dialect/operator/utils/op_yaml_info_parser.cc
Copy file name to clipboard
+5-5Lines changed: 5 additions & 5 deletions
diff --git a/‎paddle/fluid/pir/transforms/inplace_pass.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/fluid/pir/transforms/inplace_pass.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎paddle/fluid/pir/transforms/pd_op_to_kernel_pass.cc
Copy file name to clipboard
+2-4Lines changed: 2 additions & 4 deletions b/‎paddle/fluid/pir/transforms/pd_op_to_kernel_pass.cc
Copy file name to clipboard
+2-4Lines changed: 2 additions & 4 deletions
diff --git a/‎paddle/fluid/platform/profiler/dump/serialization_logger.cc
Copy file name to clipboard
+10-14Lines changed: 10 additions & 14 deletions b/‎paddle/fluid/platform/profiler/dump/serialization_logger.cc
Copy file name to clipboard
+10-14Lines changed: 10 additions & 14 deletions
diff --git a/‎paddle/fluid/platform/profiler/dump/test_serialization_logger.cc
Copy file name to clipboard
+38-38Lines changed: 38 additions & 38 deletions b/‎paddle/fluid/platform/profiler/dump/test_serialization_logger.cc
Copy file name to clipboard
+38-38Lines changed: 38 additions & 38 deletions
diff --git a/‎paddle/fluid/platform/profiler/event_node.cc
Copy file name to clipboard
+2-4Lines changed: 2 additions & 4 deletions b/‎paddle/fluid/platform/profiler/event_node.cc
Copy file name to clipboard
+2-4Lines changed: 2 additions & 4 deletions
diff --git a/‎paddle/fluid/platform/profiler/event_python.cc
Copy file name to clipboard
+12-14Lines changed: 12 additions & 14 deletions b/‎paddle/fluid/platform/profiler/event_python.cc
Copy file name to clipboard
+12-14Lines changed: 12 additions & 14 deletions
@@ -66,14 +66,16 @@ void DeleteRemovePaddingRecoverPaddingPass::ApplyImpl(ir::Graph *graph) const {
     std::unordered_set<const Node *> del_node_set;
 
     bool delete_recover_padding = true;
-    for (size_t i = 0; i < recover_padding_out->outputs.size(); ++i) {
+    for (size_t i = 0; i < recover_padding_out->outputs.size();
+         ++i) {  // NOLINT
       if (recover_padding_out->outputs[i]->Name() ==
           "remove_padding") {  // op_node
         auto *remove_padding_out_node =
-            recover_padding_out->outputs[i]->outputs[0];          // var_node
-        auto *out_op_node = remove_padding_out_node->outputs[0];  // op_node
+            recover_padding_out->outputs[i]->outputs[0];  // NOLINT // var_node
+        auto *out_op_node =
+            remove_padding_out_node->outputs[0];  // NOLINT // op_node
         IR_NODE_LINK_TO(recover_padding_input, out_op_node);
-        del_node_set.insert(recover_padding_out->outputs[i]);
+        del_node_set.insert(recover_padding_out->outputs[i]);  // NOLINT
         del_node_set.insert(remove_padding_out_node);
         out_op_node->Op()->RenameInput(remove_padding_out_node->Name(),
                                        recover_padding_input->Name());
 
@@ -27,8 +27,8 @@ void SaveQuantInfoInTheGraph(
   if (!graph->Has(flag)) {
     graph->Set(flag, new bool(true));
   }
-  for (auto iter = info_map.begin(); iter != info_map.end(); ++iter) {
-    graph->Set(iter->first + suffix, new std::vector<float>(iter->second));
+  for (const auto& iter : info_map) {
+    graph->Set(iter.first + suffix, new std::vector<float>(iter.second));
   }
 }
 
 
@@ -78,8 +78,8 @@ ProgramDesc::ProgramDesc(const ProgramDesc &o) {
     // record all block desc's ptr from origin program
     old_block_desc.emplace_back(o.blocks_[i].get());
   }
-  for (size_t block_id = 0; block_id < blocks_.size(); ++block_id) {
-    auto all_ops = blocks_[block_id]->AllOps();
+  for (size_t block_id = 0; block_id < blocks_.size(); ++block_id) {  // NOLINT
+    auto all_ops = blocks_[block_id]->AllOps();                       // NOLINT
     for (size_t op_id = 0; op_id < all_ops.size(); ++op_id) {
       auto &op = all_ops[op_id];
 
@@ -92,7 +92,7 @@ ProgramDesc::ProgramDesc(const ProgramDesc &o) {
                         block_desc) != old_block_desc.end()) {
             // The block is owned by the origin program. Just use id to get
             // the corresponding block.
-            int sub_block_id = o.Block(block_id)
+            int sub_block_id = o.Block(block_id)  // NOLINT
                                    .Op(static_cast<int>(op_id))
                                    ->GetBlockAttrId(attr_name);
             op->SetBlockAttr(attr_name, MutableBlock(sub_block_id));
@@ -103,7 +103,7 @@ ProgramDesc::ProgramDesc(const ProgramDesc &o) {
             op->SetBlockAttr(attr_name, block_desc);
           }
         } else if (op->GetAttrType(attr_name) == proto::AttrType::BLOCKS) {
-          std::vector<int> sub_block_ids = o.Block(block_id)
+          std::vector<int> sub_block_ids = o.Block(block_id)  // NOLINT
                                                .Op(static_cast<int>(op_id))
                                                ->GetBlocksAttrIds(attr_name);
           std::vector<BlockDesc *> block_descs;
@@ -114,19 +114,20 @@ ProgramDesc::ProgramDesc(const ProgramDesc &o) {
         } else if (op->GetAttrType(attr_name, true) == proto::AttrType::VAR) {
           VarDesc *var_desc =
               PADDLE_GET_CONST(VarDesc *, op->GetAttr(attr_name, true));
-          op->SetVarAttr(attr_name,
-                         o.Block(block_id).FindVarRecursive(var_desc->Name()));
+          op->SetVarAttr(
+              attr_name,
+              o.Block(block_id).FindVarRecursive(var_desc->Name()));  // NOLINT
         } else if (op->GetAttrType(attr_name, true) == proto::AttrType::VARS) {
           std::vector<VarDesc *> vars_desc = PADDLE_GET_CONST(
               std::vector<VarDesc *>, op->GetAttr(attr_name, true));
           std::vector<VarDesc *> new_vars_desc;
-          std::transform(
-              vars_desc.begin(),
-              vars_desc.end(),
-              std::back_inserter(new_vars_desc),
-              [&](VarDesc *var_desc) {
-                return o.Block(block_id).FindVarRecursive(var_desc->Name());
-              });
+          std::transform(vars_desc.begin(),
+                         vars_desc.end(),
+                         std::back_inserter(new_vars_desc),
+                         [&](VarDesc *var_desc) {
+                           return o.Block(block_id).FindVarRecursive(
+                               var_desc->Name());  // NOLINT
+                         });
           op->SetVarsAttr(attr_name, new_vars_desc);
         }
       }
 
@@ -153,8 +153,8 @@ std::unordered_map<uint32_t, uint32_t> OpYamlInfoParser::GetInplaceIdMap()
 
 bool OpYamlInfoParser::HasView(const std::string& out_name) const {
   auto& view_info = std::get<3>(op_info_tuple_).view;
-  for (size_t i = 0; i < view_info.size(); i++) {
-    if (out_name == view_info[i].first) {
+  for (const auto& i : view_info) {
+    if (out_name == i.first) {
       return true;
     }
   }
@@ -164,9 +164,9 @@ bool OpYamlInfoParser::HasView(const std::string& out_name) const {
 const std::string& OpYamlInfoParser::ViewName(
     const std::string& out_name) const {
   auto& view_info = std::get<3>(op_info_tuple_).view;
-  for (size_t i = 0; i < view_info.size(); i++) {
-    if (out_name == view_info[i].first) {
-      return view_info[i].second;
+  for (const auto& i : view_info) {
+    if (out_name == i.first) {
+      return i.second;
     }
   }
   PADDLE_THROW(phi::errors::PreconditionNotMet(
 
@@ -184,8 +184,8 @@ bool IsNoNeedBuffer(pir::Operation* op, pir::Value value) {
           info_interface->get_op_info_(op_name),
           paddle::dialect::IsLegacyOp(op_name));
       auto& no_need_buffer_ids = info_parser.NoNeedBufferIds();
-      for (size_t id = 0; id < no_need_buffer_ids.size(); id++) {
-        if (value == op->operand_source(no_need_buffer_ids[id])) {
+      for (auto no_need_buffer_id : no_need_buffer_ids) {
+        if (value == op->operand_source(no_need_buffer_id)) {
           return true;
         }
       }
 
@@ -643,8 +643,7 @@ static phi::DataType GetKernelDtypeByYaml(
   auto& data_type_info = op_info_parser->OpRuntimeInfo().kernel_key_dtype;
   phi::DataType kernel_data_type = phi::DataType::UNDEFINED;
 
-  for (size_t i = 0; i < data_type_info.size(); ++i) {
-    auto slot_name = data_type_info[i];
+  for (auto slot_name : data_type_info) {
     auto& input_map = op_info_parser->InputName2Id();
 
     bool is_complex_tag = false;
@@ -729,8 +728,7 @@ static phi::Backend GetKernelBackendByYaml(
   auto& backend_info = op_info_parser->OpRuntimeInfo().kernel_key_backend;
   phi::Backend kernel_backend = phi::Backend::UNDEFINED;
 
-  for (size_t i = 0; i < backend_info.size(); ++i) {
-    auto slot_name = backend_info[i];
+  for (auto slot_name : backend_info) {
     auto& input_map = op_info_parser->InputName2Id();
 
     if (input_map.count(slot_name)) {
 
@@ -103,37 +103,33 @@ void SerializationLogger::LogNodeTrees(const NodeTrees& node_trees) {
     current_thread_node_tree_proto_ =
         node_trees_proto_->add_thread_trees();  // add ThreadNodeTreeProto
     current_thread_node_tree_proto_->set_thread_id(event_node.first);
-    for (auto hostnode = event_node.second.begin();
-         hostnode != event_node.second.end();
-         ++hostnode) {
+    for (auto hostnode : event_node.second) {
       HostTraceEventNodeProto* host_node_proto =
           current_thread_node_tree_proto_
               ->add_host_nodes();  // add HostTraceEventNodeProto
-      host_node_proto->set_id(node_index_map[(*hostnode)]);
-      host_node_proto->set_parentid(node_parent_map[(*hostnode)]);
+      host_node_proto->set_id(node_index_map[hostnode]);
+      host_node_proto->set_parentid(node_parent_map[hostnode]);
       current_host_trace_event_node_proto_ =
-          host_node_proto;       // set current HostTraceEventNodeProto
-      (*hostnode)->LogMe(this);  // fill detail information
+          host_node_proto;    // set current HostTraceEventNodeProto
+      hostnode->LogMe(this);  // fill detail information
 
-      for (auto runtimenode : (*hostnode)->GetRuntimeTraceEventNodes()) {
+      for (auto runtimenode : hostnode->GetRuntimeTraceEventNodes()) {
         CudaRuntimeTraceEventNodeProto* runtime_node_proto =
             current_host_trace_event_node_proto_
                 ->add_runtime_nodes();  // add CudaRuntimeTraceEventNodeProto
         current_runtime_trace_event_node_proto_ =
             runtime_node_proto;    // set current CudaRuntimeTraceEventNodeProto
         runtimenode->LogMe(this);  // fill detail information
-        for (auto devicenode = runtimenode->GetDeviceTraceEventNodes().begin();
-             devicenode != runtimenode->GetDeviceTraceEventNodes().end();
-             ++devicenode) {
+        for (auto devicenode : runtimenode->GetDeviceTraceEventNodes()) {
           DeviceTraceEventNodeProto* device_node_proto =
               current_runtime_trace_event_node_proto_
                   ->add_device_nodes();  // add DeviceTraceEventNodeProto
           current_device_trace_event_node_proto_ =
-              device_node_proto;       // set current DeviceTraceEventNodeProto
-          (*devicenode)->LogMe(this);  // fill detail information
+              device_node_proto;    // set current DeviceTraceEventNodeProto
+          devicenode->LogMe(this);  // fill detail information
         }
       }
-      for (auto memnode : (*hostnode)->GetMemTraceEventNodes()) {
+      for (auto memnode : hostnode->GetMemTraceEventNodes()) {
         MemTraceEventNodeProto* mem_node_proto =
             current_host_trace_event_node_proto_->add_mem_nodes();
         current_mem_trace_event_node_proto_ = mem_node_proto;
 
@@ -152,21 +152,21 @@ TEST(SerializationLoggerTest, dump_case0) {
   EXPECT_EQ(nodes[11].size(), 2u);
   std::vector<HostTraceEventNode*> thread1_nodes = nodes[10];
   std::vector<HostTraceEventNode*> thread2_nodes = nodes[11];
-  for (auto it = thread1_nodes.begin(); it != thread1_nodes.end(); it++) {
-    if ((*it)->Name() == "root node") {
-      EXPECT_EQ((*it)->GetChildren().size(), 3u);
+  for (auto& thread1_node : thread1_nodes) {
+    if (thread1_node->Name() == "root node") {
+      EXPECT_EQ(thread1_node->GetChildren().size(), 3u);
     }
-    if ((*it)->Name() == "op1") {
-      EXPECT_EQ((*it)->GetChildren().size(), 0u);
-      EXPECT_EQ((*it)->GetRuntimeTraceEventNodes().size(), 2u);
-      EXPECT_EQ((*it)->GetMemTraceEventNodes().size(), 2u);
-      EXPECT_NE((*it)->GetOperatorSupplementEventNode(), nullptr);
+    if (thread1_node->Name() == "op1") {
+      EXPECT_EQ(thread1_node->GetChildren().size(), 0u);
+      EXPECT_EQ(thread1_node->GetRuntimeTraceEventNodes().size(), 2u);
+      EXPECT_EQ(thread1_node->GetMemTraceEventNodes().size(), 2u);
+      EXPECT_NE(thread1_node->GetOperatorSupplementEventNode(), nullptr);
     }
   }
-  for (auto it = thread2_nodes.begin(); it != thread2_nodes.end(); it++) {
-    if ((*it)->Name() == "op3") {
-      EXPECT_EQ((*it)->GetChildren().size(), 0u);
-      EXPECT_EQ((*it)->GetRuntimeTraceEventNodes().size(), 2u);
+  for (auto& thread2_node : thread2_nodes) {
+    if (thread2_node->Name() == "op3") {
+      EXPECT_EQ(thread2_node->GetChildren().size(), 0u);
+      EXPECT_EQ(thread2_node->GetRuntimeTraceEventNodes().size(), 2u);
     }
   }
   tree.LogMe(&logger);
@@ -247,15 +247,15 @@ TEST(SerializationLoggerTest, dump_case1) {
   EXPECT_EQ(nodes[11].size(), 1u);
   std::vector<HostTraceEventNode*> thread1_nodes = nodes[10];
   std::vector<HostTraceEventNode*> thread2_nodes = nodes[11];
-  for (auto it = thread1_nodes.begin(); it != thread1_nodes.end(); it++) {
-    if ((*it)->Name() == "root node") {
-      EXPECT_EQ((*it)->GetRuntimeTraceEventNodes().size(), 3u);
+  for (auto& thread1_node : thread1_nodes) {
+    if (thread1_node->Name() == "root node") {
+      EXPECT_EQ(thread1_node->GetRuntimeTraceEventNodes().size(), 3u);
     }
   }
-  for (auto it = thread2_nodes.begin(); it != thread2_nodes.end(); it++) {
-    if ((*it)->Name() == "root node") {
-      EXPECT_EQ((*it)->GetChildren().size(), 0u);
-      EXPECT_EQ((*it)->GetRuntimeTraceEventNodes().size(), 2u);
+  for (auto& thread2_node : thread2_nodes) {
+    if (thread2_node->Name() == "root node") {
+      EXPECT_EQ(thread2_node->GetChildren().size(), 0u);
+      EXPECT_EQ(thread2_node->GetRuntimeTraceEventNodes().size(), 2u);
     }
   }
   tree.LogMe(&logger);
@@ -272,21 +272,21 @@ TEST(DeserializationReaderTest, restore_case0) {
   EXPECT_EQ(nodes[11].size(), 2u);
   std::vector<HostTraceEventNode*> thread1_nodes = nodes[10];
   std::vector<HostTraceEventNode*> thread2_nodes = nodes[11];
-  for (auto it = thread1_nodes.begin(); it != thread1_nodes.end(); it++) {
-    if ((*it)->Name() == "root node") {
-      EXPECT_EQ((*it)->GetChildren().size(), 3u);
+  for (auto& thread1_node : thread1_nodes) {
+    if (thread1_node->Name() == "root node") {
+      EXPECT_EQ(thread1_node->GetChildren().size(), 3u);
     }
-    if ((*it)->Name() == "op1") {
-      EXPECT_EQ((*it)->GetChildren().size(), 0u);
-      EXPECT_EQ((*it)->GetRuntimeTraceEventNodes().size(), 2u);
-      EXPECT_EQ((*it)->GetMemTraceEventNodes().size(), 2u);
-      EXPECT_NE((*it)->GetOperatorSupplementEventNode(), nullptr);
+    if (thread1_node->Name() == "op1") {
+      EXPECT_EQ(thread1_node->GetChildren().size(), 0u);
+      EXPECT_EQ(thread1_node->GetRuntimeTraceEventNodes().size(), 2u);
+      EXPECT_EQ(thread1_node->GetMemTraceEventNodes().size(), 2u);
+      EXPECT_NE(thread1_node->GetOperatorSupplementEventNode(), nullptr);
     }
   }
-  for (auto it = thread2_nodes.begin(); it != thread2_nodes.end(); it++) {
-    if ((*it)->Name() == "op3") {
-      EXPECT_EQ((*it)->GetChildren().size(), 0u);
-      EXPECT_EQ((*it)->GetRuntimeTraceEventNodes().size(), 2u);
+  for (auto& thread2_node : thread2_nodes) {
+    if (thread2_node->Name() == "op3") {
+      EXPECT_EQ(thread2_node->GetChildren().size(), 0u);
+      EXPECT_EQ(thread2_node->GetRuntimeTraceEventNodes().size(), 2u);
     }
   }
 }
@@ -301,15 +301,15 @@ TEST(DeserializationReaderTest, restore_case1) {
   EXPECT_EQ(nodes[11].size(), 1u);
   std::vector<HostTraceEventNode*> thread1_nodes = nodes[10];
   std::vector<HostTraceEventNode*> thread2_nodes = nodes[11];
-  for (auto it = thread1_nodes.begin(); it != thread1_nodes.end(); it++) {
-    if ((*it)->Name() == "root node") {
-      EXPECT_EQ((*it)->GetRuntimeTraceEventNodes().size(), 3u);
+  for (auto& thread1_node : thread1_nodes) {
+    if (thread1_node->Name() == "root node") {
+      EXPECT_EQ(thread1_node->GetRuntimeTraceEventNodes().size(), 3u);
     }
   }
-  for (auto it = thread2_nodes.begin(); it != thread2_nodes.end(); it++) {
-    if ((*it)->Name() == "root node") {
-      EXPECT_EQ((*it)->GetChildren().size(), 0u);
-      EXPECT_EQ((*it)->GetRuntimeTraceEventNodes().size(), 2u);
+  for (auto& thread2_node : thread2_nodes) {
+    if (thread2_node->Name() == "root node") {
+      EXPECT_EQ(thread2_node->GetChildren().size(), 0u);
+      EXPECT_EQ(thread2_node->GetRuntimeTraceEventNodes().size(), 2u);
     }
   }
 }
@@ -434,10 +434,8 @@ void NodeTrees::HandleTrees(
       }
       for (auto event_node : (*hostnode)->GetRuntimeTraceEventNodes()) {
         runtime_event_node_handle(event_node);
-        for (auto devicenode = event_node->GetDeviceTraceEventNodes().begin();
-             devicenode != event_node->GetDeviceTraceEventNodes().end();
-             ++devicenode) {
-          device_event_node_handle(*devicenode);
+        for (auto devicenode : event_node->GetDeviceTraceEventNodes()) {
+          device_event_node_handle(devicenode);
         }
       }
       for (auto event_node : (*hostnode)->GetMemTraceEventNodes()) {
 
@@ -63,20 +63,18 @@ HostPythonNode* ProfilerResult::CopyTree(HostTraceEventNode* root) {
     runtime_python_node->correlation_id = runtimenode->CorrelationId();
     host_python_node->runtime_node_ptrs.push_back(runtime_python_node);
     // copy DeviceTraceEventNode
-    for (auto devicenode = runtimenode->GetDeviceTraceEventNodes().begin();
-         devicenode != runtimenode->GetDeviceTraceEventNodes().end();
-         ++devicenode) {
+    for (auto devicenode : runtimenode->GetDeviceTraceEventNodes()) {
       DevicePythonNode* device_python_node = new DevicePythonNode();
-      device_python_node->name = (*devicenode)->Name();
-      device_python_node->type = (*devicenode)->Type();
-      device_python_node->start_ns = (*devicenode)->StartNs();
-      device_python_node->end_ns = (*devicenode)->EndNs();
-      device_python_node->device_id = (*devicenode)->DeviceId();
-      device_python_node->context_id = (*devicenode)->ContextId();
-      device_python_node->stream_id = (*devicenode)->StreamId();
-      device_python_node->correlation_id = (*devicenode)->CorrelationId();
+      device_python_node->name = devicenode->Name();
+      device_python_node->type = devicenode->Type();
+      device_python_node->start_ns = devicenode->StartNs();
+      device_python_node->end_ns = devicenode->EndNs();
+      device_python_node->device_id = devicenode->DeviceId();
+      device_python_node->context_id = devicenode->ContextId();
+      device_python_node->stream_id = devicenode->StreamId();
+      device_python_node->correlation_id = devicenode->CorrelationId();
       if (device_python_node->type == TracerEventType::Kernel) {
-        KernelEventInfo kernel_info = (*devicenode)->KernelInfo();
+        KernelEventInfo kernel_info = devicenode->KernelInfo();
         device_python_node->block_x = kernel_info.block_x;
         device_python_node->block_y = kernel_info.block_y;
         device_python_node->block_z = kernel_info.block_z;
@@ -91,10 +89,10 @@ HostPythonNode* ProfilerResult::CopyTree(HostTraceEventNode* root) {
         device_python_node->warps_per_sm = kernel_info.warps_per_sm;
         device_python_node->occupancy = kernel_info.occupancy;
       } else if (device_python_node->type == TracerEventType::Memcpy) {
-        MemcpyEventInfo memcpy_info = (*devicenode)->MemcpyInfo();
+        MemcpyEventInfo memcpy_info = devicenode->MemcpyInfo();
         device_python_node->num_bytes = memcpy_info.num_bytes;
       } else if (device_python_node->type == TracerEventType::Memset) {
-        MemsetEventInfo memset_info = (*devicenode)->MemsetInfo();
+        MemsetEventInfo memset_info = devicenode->MemsetInfo();
         device_python_node->num_bytes = memset_info.num_bytes;
         device_python_node->value = memset_info.value;
       }
Original file line number	Diff line number	Diff line change
`@@ -27,8 +27,8 @@ void SaveQuantInfoInTheGraph(`
`27`	`27`	`if (!graph->Has(flag)) {`
`28`	`28`	`graph->Set(flag, new bool(true));`
`29`	`29`	`}`
`30`		`- for (auto iter = info_map.begin(); iter != info_map.end(); ++iter) {`
`31`		`- graph->Set(iter->first + suffix, new std::vector<float>(iter->second));`
	`30`	`+ for (const auto& iter : info_map) {`
	`31`	`+ graph->Set(iter.first + suffix, new std::vector<float>(iter.second));`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`
Original file line number	Diff line number	Diff line change
`@@ -153,8 +153,8 @@ std::unordered_map<uint32_t, uint32_t> OpYamlInfoParser::GetInplaceIdMap()`
`153`	`153`
`154`	`154`	`bool OpYamlInfoParser::HasView(const std::string& out_name) const {`
`155`	`155`	`auto& view_info = std::get<3>(op_info_tuple_).view;`
`156`		`- for (size_t i = 0; i < view_info.size(); i++) {`
`157`		`- if (out_name == view_info[i].first) {`
	`156`	`+ for (const auto& i : view_info) {`
	`157`	`+ if (out_name == i.first) {`
`158`	`158`	`return true;`
`159`	`159`	`}`
`160`	`160`	`}`
`@@ -164,9 +164,9 @@ bool OpYamlInfoParser::HasView(const std::string& out_name) const {`
`164`	`164`	`const std::string& OpYamlInfoParser::ViewName(`
`165`	`165`	`const std::string& out_name) const {`
`166`	`166`	`auto& view_info = std::get<3>(op_info_tuple_).view;`
`167`		`- for (size_t i = 0; i < view_info.size(); i++) {`
`168`		`- if (out_name == view_info[i].first) {`
`169`		`- return view_info[i].second;`
	`167`	`+ for (const auto& i : view_info) {`
	`168`	`+ if (out_name == i.first) {`
	`169`	`+ return i.second;`
`170`	`170`	`}`
`171`	`171`	`}`
`172`	`172`	`PADDLE_THROW(phi::errors::PreconditionNotMet(`
Original file line number	Diff line number	Diff line change
`@@ -184,8 +184,8 @@ bool IsNoNeedBuffer(pir::Operation* op, pir::Value value) {`
`184`	`184`	`info_interface->get_op_info_(op_name),`
`185`	`185`	`paddle::dialect::IsLegacyOp(op_name));`
`186`	`186`	`auto& no_need_buffer_ids = info_parser.NoNeedBufferIds();`
`187`		`- for (size_t id = 0; id < no_need_buffer_ids.size(); id++) {`
`188`		`- if (value == op->operand_source(no_need_buffer_ids[id])) {`
	`187`	`+ for (auto no_need_buffer_id : no_need_buffer_ids) {`
	`188`	`+ if (value == op->operand_source(no_need_buffer_id)) {`
`189`	`189`	`return true;`
`190`	`190`	`}`
`191`	`191`	`}`
Original file line number	Diff line number	Diff line change
`@@ -434,10 +434,8 @@ void NodeTrees::HandleTrees(`
`434`	`434`	`}`
`435`	`435`	`for (auto event_node : (*hostnode)->GetRuntimeTraceEventNodes()) {`
`436`	`436`	`runtime_event_node_handle(event_node);`
`437`		`- for (auto devicenode = event_node->GetDeviceTraceEventNodes().begin();`
`438`		`- devicenode != event_node->GetDeviceTraceEventNodes().end();`
`439`		`- ++devicenode) {`
`440`		`- device_event_node_handle(*devicenode);`
	`437`	`+ for (auto devicenode : event_node->GetDeviceTraceEventNodes()) {`
	`438`	`+ device_event_node_handle(devicenode);`
`441`	`439`	`}`
`442`	`440`	`}`
`443`	`441`	`for (auto event_node : (*hostnode)->GetMemTraceEventNodes()) {`