PaddlePaddle
diff --git a/‎paddle/fluid/eager/custom_operator/custom_operator_node.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎paddle/fluid/eager/custom_operator/custom_operator_node.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎paddle/fluid/eager/to_static/run_program_op_node.h
Copy file name to clipboard
+75-86Lines changed: 75 additions & 86 deletions b/‎paddle/fluid/eager/to_static/run_program_op_node.h
Copy file name to clipboard
+75-86Lines changed: 75 additions & 86 deletions
diff --git a/‎paddle/fluid/framework/block_desc.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎paddle/fluid/framework/block_desc.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎paddle/fluid/framework/data_transform.cc
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎paddle/fluid/framework/data_transform.cc
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎paddle/fluid/framework/device_worker.cc
Copy file name to clipboard
+11-11Lines changed: 11 additions & 11 deletions b/‎paddle/fluid/framework/device_worker.cc
Copy file name to clipboard
+11-11Lines changed: 11 additions & 11 deletions
diff --git a/‎paddle/fluid/framework/executor_cache.cc
Copy file name to clipboard
+6-8Lines changed: 6 additions & 8 deletions b/‎paddle/fluid/framework/executor_cache.cc
Copy file name to clipboard
+6-8Lines changed: 6 additions & 8 deletions
@@ -436,7 +436,7 @@ RunCustomOpDoubleGradNode::operator()(
               << " to tmp_outputs: " << grad_output_idx;
       for (size_t j = 0; j < OutputMeta()[grad_output_idx].size(); j++) {
         outs[grad_output_idx]
-            .emplace_back(/* init it incase of copy nullptr of shared_ptr */
+            .emplace_back(/* init it in case of copy nullptr of shared_ptr */
                           std::make_shared<phi::DenseTensor>(
                               phi::DataType::UNDEFINED),
                           egr::Controller::Instance().GenerateUniqueName(
 
@@ -482,15 +482,14 @@ inline void PirRunProgramAPI(
 
   VLOG(10) << is_test << program_id;
 
-  auto &interpretercore_info_cache =
-      paddle::framework::InterpreterCoreInfoCache::Instance();
+  auto &cache = paddle::framework::InterpreterCoreInfoCache::Instance();
   std::shared_ptr<paddle::framework::InterpreterCore> interpreter_core =
       nullptr;
-  if (!interpretercore_info_cache.Has(program_id,
-                                      global_inner_scope,
-                                      place_hash_key,
-                                      /*is_grad=*/false,
-                                      /*in_pir_mode=*/true)) {
+  if (!cache.Has(program_id,
+                 global_inner_scope,
+                 place_hash_key,
+                 /*is_grad=*/false,
+                 /*in_pir_mode=*/true)) {
     paddle::platform::RecordEvent record_event(
         "create_new_interpretercore",
         paddle::platform::TracerEventType::UserDefined,
@@ -547,7 +546,7 @@ inline void PirRunProgramAPI(
     // input_vars.insert(input_names.begin(), input_names.end());
     // interpreter_core->SetJitInputVars(input_vars);
 
-    // interpretercore_info_cache.UpdateSkipEagerDeleteVars(
+    // cache.UpdateSkipEagerDeleteVars(
     // program_id, global_inner_scope, false, skip_eager_delete_vars);
   } else {
     paddle::platform::RecordEvent record_event(
@@ -556,12 +555,11 @@ inline void PirRunProgramAPI(
         1);
     VLOG(2) << "Get interpretercore cache by program:" << program_id;
     // Step 1. get cache interpretercore
-    auto &cached_value =
-        interpretercore_info_cache.GetMutable(program_id,
-                                              global_inner_scope,
-                                              place_hash_key,
-                                              /*is_grad=*/false,
-                                              /*in_pir_mode=*/true);
+    auto &cached_value = cache.GetMutable(program_id,
+                                          global_inner_scope,
+                                          place_hash_key,
+                                          /*is_grad=*/false,
+                                          /*in_pir_mode=*/true);
     interpreter_core = cached_value.core_;
     // Step 2. update scope for cache interpretercore
     details::ShareTensorsIntoScopeByValue(
@@ -695,15 +693,14 @@ inline void RunProgramAPI(
     backward_program = backward_global_block->Program();
   }
 
-  auto &interpretercore_info_cache =
-      paddle::framework::InterpreterCoreInfoCache::Instance();
+  auto &cache = paddle::framework::InterpreterCoreInfoCache::Instance();
   std::shared_ptr<paddle::framework::InterpreterCore> interpreter_core =
       nullptr;
-  if (!interpretercore_info_cache.Has(program_id,
-                                      global_inner_scope,
-                                      place_hash_key,
-                                      /*is_grad=*/false,
-                                      /*in_pir_mode=*/in_pir_pt_mode)) {
+  if (!cache.Has(program_id,
+                 global_inner_scope,
+                 place_hash_key,
+                 /*is_grad=*/false,
+                 /*in_pir_mode=*/in_pir_pt_mode)) {
     paddle::platform::RecordEvent record_event(
         "create_new_interpretercore",
         paddle::platform::TracerEventType::UserDefined,
@@ -769,13 +766,12 @@ inline void RunProgramAPI(
       VLOG(6) << s.str();
     }
 
-    interpretercore_info_cache.UpdateSkipEagerDeleteVars(
-        program_id,
-        global_inner_scope,
-        place_hash_key,
-        false,
-        in_pir_pt_mode,
-        skip_eager_delete_vars);
+    cache.UpdateSkipEagerDeleteVars(program_id,
+                                    global_inner_scope,
+                                    place_hash_key,
+                                    false,
+                                    in_pir_pt_mode,
+                                    skip_eager_delete_vars);
     VLOG(2) << "Get skip GC vars size is: " << skip_eager_delete_vars.size();
   } else {
     paddle::platform::RecordEvent record_event(
@@ -784,12 +780,11 @@ inline void RunProgramAPI(
         1);
     VLOG(2) << "Get interpretercore cache by program:" << program_id;
     // Step 1. get cache interpretercore
-    auto &cached_value =
-        interpretercore_info_cache.GetMutable(program_id,
-                                              global_inner_scope,
-                                              place_hash_key,
-                                              /*is_grad=*/false,
-                                              /*in_pir_mode=*/in_pir_pt_mode);
+    auto &cached_value = cache.GetMutable(program_id,
+                                          global_inner_scope,
+                                          place_hash_key,
+                                          /*is_grad=*/false,
+                                          /*in_pir_mode=*/in_pir_pt_mode);
     interpreter_core = cached_value.core_;
     // Step 2. update scope for cache interpretercore
     details::ShareTensorsIntoScopeWithName(x, input_names, global_inner_scope);
@@ -874,15 +869,14 @@ inline void RunProgramGradAPI(
   details::Trans2ContiguousTensorsInplace(out_grad);
 
   auto out_grad_names = details::GetTensorsName(out_grad);
-  auto &interpretercore_info_cache =
-      paddle::framework::InterpreterCoreInfoCache::Instance();
+  auto &cache = paddle::framework::InterpreterCoreInfoCache::Instance();
   std::shared_ptr<paddle::framework::InterpreterCore> interpreter_core =
       nullptr;
-  if (!interpretercore_info_cache.Has(program_id,
-                                      global_inner_scope,
-                                      place_hash_key,
-                                      /*is_grad=*/true,
-                                      /*in_pir_mode=*/in_pir_pt_mode)) {
+  if (!cache.Has(program_id,
+                 global_inner_scope,
+                 place_hash_key,
+                 /*is_grad=*/true,
+                 /*in_pir_mode=*/in_pir_pt_mode)) {
     paddle::platform::RecordEvent record_event(
         "create_new_interpretercore",
         paddle::platform::TracerEventType::UserDefined,
@@ -922,13 +916,13 @@ inline void RunProgramGradAPI(
     // share threadpool
     // NOTE(zhiqiu): this only works interpreter_core is executed strictly
     // after the related fwd_interpreter_core.
-    if (interpretercore_info_cache.Has(program_id,
-                                       global_inner_scope,
-                                       place_hash_key,
-                                       /*is_grad=*/false,
-                                       /*in_pir_mode=*/in_pir_pt_mode)) {
+    if (cache.Has(program_id,
+                  global_inner_scope,
+                  place_hash_key,
+                  /*is_grad=*/false,
+                  /*in_pir_mode=*/in_pir_pt_mode)) {
       auto fwd_interpreter_core =
-          interpretercore_info_cache
+          cache
               .GetMutable(program_id,
                           global_inner_scope,
                           place_hash_key,
@@ -956,26 +950,24 @@ inline void RunProgramGradAPI(
     paddle::framework::details::AppendSkipDeletionVars(param_grad_names,
                                                        &skip_eager_delete_vars);
     interpreter_core->SetSkipGcVars(skip_eager_delete_vars);
-    interpretercore_info_cache.UpdateSkipEagerDeleteVars(
-        program_id,
-        global_inner_scope,
-        place_hash_key,
-        /*is_grad=*/true,
-        in_pir_pt_mode,
-        skip_eager_delete_vars);
+    cache.UpdateSkipEagerDeleteVars(program_id,
+                                    global_inner_scope,
+                                    place_hash_key,
+                                    /*is_grad=*/true,
+                                    in_pir_pt_mode,
+                                    skip_eager_delete_vars);
     VLOG(2) << "Get skip GC vars size is: " << skip_eager_delete_vars.size();
   } else {
     paddle::platform::RecordEvent record_event(
         "get_interpretercore_cache",
         paddle::platform::TracerEventType::UserDefined,
         1);
     VLOG(2) << "Get interpretercore cache by program:" << program_id;
-    auto &cached_value =
-        interpretercore_info_cache.GetMutable(program_id,
-                                              global_inner_scope,
-                                              place_hash_key,
-                                              /*is_grad=*/true,
-                                              /*in_pir_mode=*/in_pir_pt_mode);
+    auto &cached_value = cache.GetMutable(program_id,
+                                          global_inner_scope,
+                                          place_hash_key,
+                                          /*is_grad=*/true,
+                                          /*in_pir_mode=*/in_pir_pt_mode);
     interpreter_core = cached_value.core_;
 
     // update scope
@@ -1084,15 +1076,14 @@ inline void PirRunProgramGradAPI(
   out.clear();
   middles.clear();
 
-  auto &interpretercore_info_cache =
-      paddle::framework::InterpreterCoreInfoCache::Instance();
+  auto &cache = paddle::framework::InterpreterCoreInfoCache::Instance();
   std::shared_ptr<paddle::framework::InterpreterCore> interpreter_core =
       nullptr;
-  if (!interpretercore_info_cache.Has(program_id,
-                                      global_inner_scope,
-                                      place_hash_key,
-                                      /*is_grad=*/true,
-                                      /*in_pir_mode=*/true)) {
+  if (!cache.Has(program_id,
+                 global_inner_scope,
+                 place_hash_key,
+                 /*is_grad=*/true,
+                 /*in_pir_mode=*/true)) {
     paddle::platform::RecordEvent record_event(
         "create_new_interpretercore",
         paddle::platform::TracerEventType::UserDefined,
@@ -1117,12 +1108,12 @@ inline void PirRunProgramGradAPI(
     // share threadpool
     // NOTE(zhiqiu): this only works interpreter_core is executed strictly
     // after the related fwd_interpreter_core.
-    if (interpretercore_info_cache.Has(program_id,
-                                       global_inner_scope,
-                                       place_hash_key,
-                                       /*is_grad=*/false,
-                                       /*in_pir_mode=*/true)) {
-      auto fwd_interpreter_core = interpretercore_info_cache
+    if (cache.Has(program_id,
+                  global_inner_scope,
+                  place_hash_key,
+                  /*is_grad=*/false,
+                  /*in_pir_mode=*/true)) {
+      auto fwd_interpreter_core = cache
                                       .GetMutable(program_id,
                                                   global_inner_scope,
                                                   place_hash_key,
@@ -1143,13 +1134,12 @@ inline void PirRunProgramGradAPI(
         details::GetNameFromValue(backward_global_block, p_grad_values, false);
     skip_eager_delete_vars.insert(skip_names.begin(), skip_names.end());
     interpreter_core->SetSkipGcVars(skip_eager_delete_vars);
-    interpretercore_info_cache.UpdateSkipEagerDeleteVars(
-        program_id,
-        global_inner_scope,
-        place_hash_key,
-        /*is_grad=*/true,
-        /*in_pir_mode=*/true,
-        skip_eager_delete_vars);
+    cache.UpdateSkipEagerDeleteVars(program_id,
+                                    global_inner_scope,
+                                    place_hash_key,
+                                    /*is_grad=*/true,
+                                    /*in_pir_mode=*/true,
+                                    skip_eager_delete_vars);
     VLOG(2) << "Get skip GC vars size is: " << skip_eager_delete_vars.size();
     details::print_collection(skip_eager_delete_vars);
   } else {
@@ -1158,12 +1148,11 @@ inline void PirRunProgramGradAPI(
         paddle::platform::TracerEventType::UserDefined,
         1);
     VLOG(2) << "Get interpretercore cache by program:" << program_id;
-    auto &cached_value =
-        interpretercore_info_cache.GetMutable(program_id,
-                                              global_inner_scope,
-                                              place_hash_key,
-                                              /*is_grad=*/true,
-                                              /*in_pir_mode=*/true);
+    auto &cached_value = cache.GetMutable(program_id,
+                                          global_inner_scope,
+                                          place_hash_key,
+                                          /*is_grad=*/true,
+                                          /*in_pir_mode=*/true);
     interpreter_core = cached_value.core_;
 
     if (interpreter_core->GetVariableScope()->GetMutableScope() !=
 
@@ -320,7 +320,7 @@ void BlockDesc::MoveFrom(BlockDesc *block) {
         std::vector<framework::BlockDesc *> old_block_desc;
         // NOTE(GhostScreaming): don't use program->proto()->blocks_size(),
         // previous assignment of new Variable in vars_ use std::move,
-        // which makes 'var_ptr' which holded by 'block' a nullptr.
+        // which makes 'var_ptr' which held by 'block' a nullptr.
         // block->Program()->proto() will calls Flush() at first,
         // a null var_ptr will cause segmentation fault.
         int block_size = static_cast<int>(program->Size());
 
@@ -82,7 +82,7 @@ void TransformData(const phi::KernelKey &expected_kernel_type,
             phi::funcs::make_memory_desc(out, lin);
         out.set_mem_desc(out_mem_desc);
       } else {
-        // Case2 - transfrom from ONEDNN OPKernel to Non-ONEDNN OPKernel
+        // Case2 - transform from ONEDNN OPKernel to Non-ONEDNN OPKernel
         // Do transform via ONEDNN lib
         PADDLE_ENFORCE(lin == DataLayout::ONEDNN && lout != DataLayout::ONEDNN,
                        platform::errors::InvalidArgument(
@@ -97,12 +97,12 @@ void TransformData(const phi::KernelKey &expected_kernel_type,
             place);
       }
     } else {
-      // Case3 - transfrom between Non-ONEDNN OPKernels
+      // Case3 - transform between Non-ONEDNN OPKernels
       TransDataLayout(
           kernel_type_for_var, expected_kernel_type, in, &out, place);
     }
 #else
-    // Case3 - transfrom between Non-ONEDNN OPKernels
+    // Case3 - transform between Non-ONEDNN OPKernels
     TransDataLayout(kernel_type_for_var, expected_kernel_type, in, &out, place);
 #endif
     transformed = true;
 
@@ -387,31 +387,31 @@ void DeviceWorker::DumpField(const Scope& scope,
         VLOG(3) << dims.size() << " " << dims[0] << " * " << dims[1];
         continue;
       }
-      size_t acutal_thread_num =
+      size_t actual_thread_num =
           std::min(static_cast<size_t>(batch_size), tensor_iterator_thread_num);
-      for (size_t i = 0; i < acutal_thread_num; i++) {
-        size_t average_size = batch_size / acutal_thread_num;
+      for (size_t i = 0; i < actual_thread_num; i++) {
+        size_t average_size = batch_size / actual_thread_num;
         size_t begin =
-            average_size * i + std::min(batch_size % acutal_thread_num, i);
+            average_size * i + std::min(batch_size % actual_thread_num, i);
         size_t end =
-            begin + average_size + (i < batch_size % acutal_thread_num ? 1 : 0);
+            begin + average_size + (i < batch_size % actual_thread_num ? 1 : 0);
         threads[i] = std::thread(set_output_str, begin, end, tensor);
       }
-      for (size_t i = 0; i < acutal_thread_num; i++) threads[i].join();
+      for (size_t i = 0; i < actual_thread_num; i++) threads[i].join();
     }
     auto end1 = std::chrono::steady_clock::now();
     auto tt =
         std::chrono::duration_cast<std::chrono::microseconds>(end1 - start1);
     VLOG(2) << "writing a batch takes " << tt.count() << " us";
 
-    size_t acutal_thread_num =
+    size_t actual_thread_num =
         std::min(static_cast<size_t>(batch_size), tensor_iterator_thread_num);
-    for (size_t i = 0; i < acutal_thread_num; i++) {
-      size_t average_size = batch_size / acutal_thread_num;
+    for (size_t i = 0; i < actual_thread_num; i++) {
+      size_t average_size = batch_size / actual_thread_num;
       size_t begin =
-          average_size * i + std::min(batch_size % acutal_thread_num, i);
+          average_size * i + std::min(batch_size % actual_thread_num, i);
       size_t end =
-          begin + average_size + (i < batch_size % acutal_thread_num ? 1 : 0);
+          begin + average_size + (i < batch_size % actual_thread_num ? 1 : 0);
       for (size_t j = begin + 1; j < end; j++) {
         if (!ars[begin].empty() && !ars[j].empty()) ars[begin] += "\n";
         ars[begin] += ars[j];
 
@@ -312,9 +312,8 @@ std::shared_ptr<InterpreterCore> CreateProgramInterpreterCoreInfoToCache(
     int64_t program_id,
     framework::Scope *scope,
     const int64_t &place_hash_key) {
-  auto &interpretercore_info_cache =
-      framework::InterpreterCoreInfoCache::Instance();
-  if (interpretercore_info_cache.Size() > 256000u /* max_cached_size*/) {
+  auto &cache = framework::InterpreterCoreInfoCache::Instance();
+  if (cache.Size() > 256000u /* max_cached_size*/) {
     PADDLE_THROW(platform::errors::Fatal(
         "The cached info size has exceeded max_cached_size: 256000, "
         "which will cause error. "));
@@ -328,7 +327,7 @@ std::shared_ptr<InterpreterCore> CreateProgramInterpreterCoreInfoToCache(
   core.reset(new InterpreterCore(
       place, program_desc.Block(0), scope, execution_config));
 
-  auto &cached_value = interpretercore_info_cache.GetMutable(
+  auto &cached_value = cache.GetMutable(
       program_id, scope, place_hash_key, is_grad, /*in_pir_mode=*/false);
   cached_value.core_ = core;
   return core;
@@ -341,9 +340,8 @@ std::shared_ptr<InterpreterCore> CreatePirInterpreterCoreInfoToCache(
     int64_t program_id,
     framework::Scope *scope,
     const int64_t &place_hash_key) {
-  auto &interpretercore_info_cache =
-      framework::InterpreterCoreInfoCache::Instance();
-  if (interpretercore_info_cache.Size() > 256000u /* max_cached_size*/) {
+  auto &cache = framework::InterpreterCoreInfoCache::Instance();
+  if (cache.Size() > 256000u /* max_cached_size*/) {
     PADDLE_THROW(platform::errors::Fatal(
         "The cached info size has exceeded max_cached_size: 256000, "
         "which will cause error. "));
@@ -357,7 +355,7 @@ std::shared_ptr<InterpreterCore> CreatePirInterpreterCoreInfoToCache(
   core.reset(new InterpreterCore(
       place, {}, ir_program->block(), scope, execution_config));
 
-  auto &cached_value = interpretercore_info_cache.GetMutable(
+  auto &cached_value = cache.GetMutable(
       program_id, scope, place_hash_key, is_grad, /*in_pir_mode=*/true);
   cached_value.core_ = core;
   cached_value.ir_prog_ = std::move(ir_program);