[IR] New IR access InterpreterCore：add local scope logic (#55112)

zhangbo9674 · web-flow · commit 85831c32ed71 · 2023-07-05T17:23:16.000+08:00
* add local scope

* refine code

* refien code

* refine code

* support local scope for BuildFuncList

* fix bug

* add log

* fix bug

* polish code

* fix bug
diff --git a/paddle/fluid/framework/new_executor/interpreter/interpreter_util.cc b/paddle/fluid/framework/new_executor/interpreter/interpreter_util.cc
@@ -940,6 +940,7 @@ void BuildOpFuncList(
     ::ir::Block* block,
     std::vector<OpFuncNode>* vec_func_list,
     framework::Scope* scope,
+    framework::Scope* local_scope,
     const std::unordered_map<::ir::Value, std::string>& value_2_name_map,
     const ExecutionConfig& execution_config) {
   vec_func_list->reserve(block->size());
@@ -979,6 +980,7 @@ void BuildOpFuncList(
         false>((*it),
                value_2_name_map,
                scope,
+               local_scope,
                op_yaml_info_parser,
                &(op_func_node.infer_meta_context_));
 
@@ -1004,6 +1006,7 @@ void BuildOpFuncList(
                           true>((*it),
                                 value_2_name_map,
                                 scope,
+                                local_scope,
                                 op_yaml_info_parser,
                                 &(op_func_node.kernel_context_),
                                 &(op_func_node.input_index),
diff --git a/paddle/fluid/framework/new_executor/interpreter/interpreter_util.h b/paddle/fluid/framework/new_executor/interpreter/interpreter_util.h
@@ -98,6 +98,7 @@ void BuildOpFuncList(
     ::ir::Block* block,
     std::vector<OpFuncNode>* vec_func_list,
     framework::Scope* scope,
+    framework::Scope* local_scope,
     const std::unordered_map<::ir::Value, std::string>& value_2_name_map,
     const ExecutionConfig& execution_config);
 
diff --git a/paddle/fluid/framework/new_executor/interpreter_base_impl.h b/paddle/fluid/framework/new_executor/interpreter_base_impl.h
@@ -86,6 +86,8 @@ class InterpreterBaseImpl {
 
   virtual void reset_scope(Scope* new_scope) = 0;
 
+  virtual const Scope* local_scope() const = 0;
+
   virtual const platform::Place& GetPlace() const = 0;
 
   virtual void SetOutputHooks(const std::vector<HookFunc>& hookfuncs) = 0;
diff --git a/paddle/fluid/framework/new_executor/interpretercore.cc b/paddle/fluid/framework/new_executor/interpretercore.cc
@@ -101,6 +101,10 @@ void InterpreterCore::reset_scope(Scope* new_scope) {
   impl_->reset_scope(new_scope);
 }
 
+const Scope* InterpreterCore::local_scope() const {
+  return impl_->local_scope();
+}
+
 const platform::Place& InterpreterCore::GetPlace() const {
   return impl_->GetPlace();
 }
diff --git a/paddle/fluid/framework/new_executor/interpretercore.h b/paddle/fluid/framework/new_executor/interpretercore.h
@@ -65,6 +65,8 @@ class InterpreterCore {
 
   void reset_scope(Scope* new_scope);
 
+  const Scope* local_scope() const;
+
   const platform::Place& GetPlace() const;
 
   void SetOutputHooks(const std::vector<HookFunc>& hookfuncs);
diff --git a/paddle/fluid/framework/new_executor/new_ir_interpreter.cc b/paddle/fluid/framework/new_executor/new_ir_interpreter.cc
@@ -49,34 +49,34 @@ NewIRInterpreter::NewIRInterpreter(const platform::Place& place,
       stream_analyzer_(place),
       execution_config_(execution_config),
       var_scope_(scope),
+      scope_(scope),
       ir_program_(std::move(ir_prog)) {
   VLOG(4) << "NewIRInterpreter(): " << this << " on " << place_;
   static_build_ = FLAGS_new_executor_static_build &&
                   !FLAGS_new_executor_use_cuda_graph &&
                   !execution_config.used_for_control_flow_op;
   //    &&interpreter::BlockCanBeStaticBuilt(block);
+  static_build_ = true;
 
   exception_notifier_ = main_thread_blocker_.RegisterEvent(kExceptionCaught);
   completion_notifier_ = main_thread_blocker_.RegisterEvent(kTaskCompletion);
 
   if (!FLAGS_new_executor_use_local_scope) {
     execution_config_.create_local_scope = false;
   }
-  execution_config_.AnalyzeThreadPoolConfig(place,
-                                            ir_program_->block()->size());
-  execution_config_.Log(/*log_level=*/8);
-
   if (execution_config_.create_local_scope) {
-    auto local_scope = &var_scope_.GetMutableScope()->NewScope();
+    auto local_scope = &scope_->NewScope();
     local_scope_ = local_scope;
+    VLOG(6) << "new ir interpretercore scope: " << scope_ << "\t"
+            << "; local scope: " << local_scope_;
   }
-
-  // force use outer scope for now
-  local_scope_ = scope;
-  static_build_ = true;
-
+  // TODO(zhangbo): delete var_scope
   var_scope_.SetLocalScope(local_scope_);
 
+  execution_config_.AnalyzeThreadPoolConfig(place,
+                                            ir_program_->block()->size());
+  execution_config_.Log(/*log_level=*/8);
+
   instruction_scheduling_priority_less = [this](size_t lhs, size_t rhs) {
     SchedulingPriority lhs_scheduling_priority =
         vec_instruction_[lhs].GetSchedulingPriority();
@@ -185,12 +185,13 @@ FetchList NewIRInterpreter::Run(const std::vector<std::string>& feed_names,
   if (!is_build_) {
     LOG_FIRST_N(INFO, 1) << "New Executor is Running.";
     ::ir::BuildScope(
-        ir_program_->block(), local_scope_, &value_2_var_name_map_);
+        ir_program_->block(), scope_, local_scope_, &value_2_var_name_map_);
 
     std::vector<paddle::framework::OpFuncNode> op_func_nodes;
     interpreter::BuildOpFuncList(place_,
                                  ir_program_->block(),
                                  &op_func_nodes,
+                                 scope_,
                                  local_scope_,
                                  value_2_var_name_map_,
                                  execution_config_);
@@ -212,8 +213,7 @@ FetchList NewIRInterpreter::Run(const std::vector<std::string>& feed_names,
   }
 
   // return Fetch Tensors
-  Scope* inner_scope =
-      HasLocalScope() ? local_scope_ : var_scope_.GetMutableScope();
+  Scope* inner_scope = HasLocalScope() ? local_scope_ : scope_;
   auto* fetch_var = inner_scope->FindVar(interpreter::kFetchVarName);
   if (fetch_var && need_fetch) {
     auto fetch_list = std::move(*fetch_var->GetMutable<framework::FetchList>());
@@ -287,6 +287,8 @@ void NewIRInterpreter::reset_scope(Scope* new_scope) {
   }
 }
 
+const Scope* NewIRInterpreter::local_scope() const { return local_scope_; }
+
 void NewIRInterpreter::ShareWorkQueueFrom(InterpreterBaseImpl* src) {
   async_work_queue_ = reinterpret_cast<NewIRInterpreter*>(src)->GetWorkQueue();
   VLOG(8) << "Share AsyncWorkQueue from InterpreterCore(" << src
@@ -321,8 +323,7 @@ std::shared_ptr<interpreter::AsyncWorkQueue> NewIRInterpreter::GetWorkQueue() {
 }
 
 void NewIRInterpreter::BuildAndCacheInstructionCtx(Instruction* instr_node) {
-  Scope* inner_scope =
-      HasLocalScope() ? local_scope_ : var_scope_.GetMutableScope();
+  Scope* inner_scope = HasLocalScope() ? local_scope_ : scope_;
   VariableValueMap ins_map;
   for (auto& var_name_item : instr_node->Inputs()) {
     std::vector<Variable*> input_vars;
@@ -349,8 +350,7 @@ void NewIRInterpreter::BuildAndCacheInstructionCtx(Instruction* instr_node) {
   if (instr_node->OpBase()->Type() == "cinn_launch" ||
       instr_node->OpBase()->Type() == "cinn_instruction_run") {  // OP use scope
                                                                  // in kernel
-    Scope* local_scope = HasLocalScope() ? var_scope_.GetMutableLocalScope()
-                                         : var_scope_.GetMutableScope();
+    Scope* local_scope = HasLocalScope() ? local_scope_ : scope_;
     instr_node->ResetContextWithScope(ins_map, outs_map, *local_scope);
   } else {
     instr_node->ResetContext(ins_map, outs_map);
@@ -380,8 +380,7 @@ void NewIRInterpreter::BuildInplace() {
     }
   }
 
-  Scope* local_scope = HasLocalScope() ? var_scope_.GetMutableLocalScope()
-                                       : var_scope_.GetMutableScope();
+  Scope* local_scope = HasLocalScope() ? local_scope_ : scope_;
   std::vector<std::vector<size_t>> input_var2op(var_scope_.VarSize());
   for (Instruction& instr : vec_instruction_) {
     for (auto& item : instr.Inputs()) {
@@ -799,8 +798,7 @@ void NewIRInterpreter::BuildSkipShareLoDInfo() {
 void NewIRInterpreter::RunOperator(const Instruction& instr_node) {
   auto* op = instr_node.OpBase();
   auto place = instr_node.DeviceContext().GetPlace();
-  Scope* local_scope = HasLocalScope() ? var_scope_.GetMutableLocalScope()
-                                       : var_scope_.GetMutableScope();
+  Scope* local_scope = HasLocalScope() ? local_scope_ : scope_;
   VLOG(4) << "Start run " << place << " " << op->DebugStringEx(local_scope);
 
   auto op_with_kernel = dynamic_cast<const framework::OperatorWithKernel*>(op);
@@ -1047,7 +1045,7 @@ void NewIRInterpreter::ExecuteInstructionList(
             if (cancel) {
               break;
             }
-            VLOG(0) << "deps:\n" << GetDepsString();
+            VLOG(6) << "deps:\n" << GetDepsString();
             times++;
           }
           return times;
diff --git a/paddle/fluid/framework/new_executor/new_ir_interpreter.h b/paddle/fluid/framework/new_executor/new_ir_interpreter.h
@@ -60,6 +60,8 @@ class NewIRInterpreter : public InterpreterBaseImpl {
 
   void reset_scope(Scope* new_scope) override;
 
+  const Scope* local_scope() const override;
+
   const platform::Place& GetPlace() const override { return place_; }
 
   void SetOutputHooks(const std::vector<HookFunc>& hookfuncs) override {
@@ -143,6 +145,7 @@ class NewIRInterpreter : public InterpreterBaseImpl {
   ExecutionConfig execution_config_;
 
   VariableScope var_scope_;
+  Scope* scope_{nullptr};
   Scope* local_scope_{nullptr};  // not owned
 
   EventsWaiter main_thread_blocker_;
diff --git a/paddle/fluid/framework/new_executor/program_interpreter.cc b/paddle/fluid/framework/new_executor/program_interpreter.cc
@@ -275,6 +275,7 @@ void ProgramInterpreter::reset_scope(Scope* new_scope) {
   }
 }
 
+const Scope* ProgramInterpreter::local_scope() const { return local_scope_; }
 void ProgramInterpreter::ShareWorkQueueFrom(InterpreterBaseImpl* src) {
   async_work_queue_ =
       reinterpret_cast<ProgramInterpreter*>(src)->GetWorkQueue();
diff --git a/paddle/fluid/framework/new_executor/program_interpreter.h b/paddle/fluid/framework/new_executor/program_interpreter.h
@@ -62,6 +62,8 @@ class ProgramInterpreter : public InterpreterBaseImpl {
 
   void reset_scope(Scope* new_scope) override;
 
+  const Scope* local_scope() const override;
+
   const platform::Place& GetPlace() const override { return place_; }
 
   void SetOutputHooks(const std::vector<HookFunc>& hookfuncs) override {
diff --git a/paddle/fluid/ir/phi_kernel_adaptor/phi_kernel_adaptor.h b/paddle/fluid/ir/phi_kernel_adaptor/phi_kernel_adaptor.h
@@ -56,7 +56,7 @@ class PhiKernelAdaptor {
   void run_kernel_prog(ir::Program* program) {
     auto block = program->block();
     std::unordered_map<ir::Value, std::string> name_map;
-    BuildScope(block, scope_, &name_map);
+    BuildScope(block, scope_, nullptr, &name_map);
     ir::IrContext* ctx = ir::IrContext::Instance();
 
     ctx->GetOrRegisterDialect<paddle::dialect::PaddleDialect>();
@@ -87,7 +87,7 @@ class PhiKernelAdaptor {
           phi::MetaTensor,
           phi::MetaTensor,
           paddle::small_vector<phi::MetaTensor, phi::kInputSmallVectorSize>,
-          false>((*it), name_map, scope_, op_yaml_info_parser, &ctx);
+          false>((*it), name_map, scope_, nullptr, op_yaml_info_parser, &ctx);
 
       infer_meta_impl->infer_meta_(&ctx);
 
@@ -107,7 +107,7 @@ class PhiKernelAdaptor {
                           phi::TensorBase*,
                           paddle::small_vector<const phi::TensorBase*>,
                           true>(
-          (*it), name_map, scope_, op_yaml_info_parser, &kernel_ctx);
+          (*it), name_map, scope_, nullptr, op_yaml_info_parser, &kernel_ctx);
       kernel_fn(&kernel_ctx);
 
       auto out_value = (*it)->result(0);
diff --git a/paddle/fluid/ir/phi_kernel_adaptor/phi_kernel_util.cc b/paddle/fluid/ir/phi_kernel_adaptor/phi_kernel_util.cc
diff --git a/paddle/fluid/ir/phi_kernel_adaptor/phi_kernel_util.h b/paddle/fluid/ir/phi_kernel_adaptor/phi_kernel_util.h
diff --git a/test/cpp/new_executor/standalone_executor_new_ir_test.cc b/test/cpp/new_executor/standalone_executor_new_ir_test.cc

Original file line number	Diff line number	Diff line change
`@@ -101,6 +101,10 @@ void InterpreterCore::reset_scope(Scope* new_scope) {`
`101`	`101`	`impl_->reset_scope(new_scope);`
`102`	`102`	`}`
`103`	`103`
	`104`	`+const Scope* InterpreterCore::local_scope() const {`
	`105`	`+ return impl_->local_scope();`
	`106`	`+}`
	`107`	`+`
`104`	`108`	`const platform::Place& InterpreterCore::GetPlace() const {`
`105`	`109`	`return impl_->GetPlace();`
`106`	`110`	`}`
Original file line number	Diff line number	Diff line change
`@@ -275,6 +275,7 @@ void ProgramInterpreter::reset_scope(Scope* new_scope) {`
`275`	`275`	`}`
`276`	`276`	`}`
`277`	`277`
	`278`	`+const Scope* ProgramInterpreter::local_scope() const { return local_scope_; }`
`278`	`279`	`void ProgramInterpreter::ShareWorkQueueFrom(InterpreterBaseImpl* src) {`
`279`	`280`	`async_work_queue_ =`
`280`	`281`	`reinterpret_cast<ProgramInterpreter*>(src)->GetWorkQueue();`