PaddlePaddle
diff --git a/‎paddle/fluid/eager/to_static/run_program_op_node.h
Copy file name to clipboard
+7-3Lines changed: 7 additions & 3 deletions b/‎paddle/fluid/eager/to_static/run_program_op_node.h
Copy file name to clipboard
+7-3Lines changed: 7 additions & 3 deletions
diff --git a/‎paddle/fluid/framework/executor_cache.cc
Copy file name to clipboard
+49-20Lines changed: 49 additions & 20 deletions b/‎paddle/fluid/framework/executor_cache.cc
Copy file name to clipboard
+49-20Lines changed: 49 additions & 20 deletions
diff --git a/‎paddle/fluid/framework/executor_cache.h
Copy file name to clipboard
+4-2Lines changed: 4 additions & 2 deletions b/‎paddle/fluid/framework/executor_cache.h
Copy file name to clipboard
+4-2Lines changed: 4 additions & 2 deletions
diff --git a/‎paddle/fluid/framework/new_executor/interpretercore.cc
Copy file name to clipboard
+7-5Lines changed: 7 additions & 5 deletions b/‎paddle/fluid/framework/new_executor/interpretercore.cc
Copy file name to clipboard
+7-5Lines changed: 7 additions & 5 deletions
diff --git a/‎paddle/fluid/framework/new_executor/interpretercore.h
Copy file name to clipboard
+3Lines changed: 3 additions & 0 deletions b/‎paddle/fluid/framework/new_executor/interpretercore.h
Copy file name to clipboard
+3Lines changed: 3 additions & 0 deletions
@@ -377,7 +377,7 @@ inline void RunProgramAPI(
     if (FLAGS_enable_new_ir_in_executor) {
       // build new ir program
       auto ir_program = paddle::framework::ConstructFowardIrProgram(
-          forward_global_block, backward_global_block, output_names, x);
+          forward_global_block, backward_global_block, output_names, x, params);
       interpreter_core =
           paddle::framework::CreateNewIRInterpreterCoreInfoToCache(
               std::move(ir_program),
@@ -529,8 +529,12 @@ inline void RunProgramGradAPI(
     details::ShareTensorsIntoScope(out_grad, global_inner_scope);
 
     if (FLAGS_enable_new_ir_in_executor) {
-      auto res = paddle::framework::ConstructBackwardIrProgram(
-          backward_global_block, out_grad, x_grad, params_grad);
+      auto res =
+          paddle::framework::ConstructBackwardIrProgram(backward_global_block,
+                                                        out_grad,
+                                                        x_grad,
+                                                        params_grad,
+                                                        global_inner_scope);
 
       interpreter_core =
           paddle::framework::CreateNewIRInterpreterCoreInfoToCache(
 
@@ -338,7 +338,7 @@ std::shared_ptr<InterpreterCore> CreateNewIRInterpreterCoreInfoToCache(
   std::shared_ptr<InterpreterCore> core = nullptr;
 
   core.reset(new InterpreterCore(
-      place, std::move(ir_program), scope, execution_config));
+      place, {}, std::move(ir_program), scope, execution_config));
 
   auto &cached_value =
       interpretercore_info_cache.GetMutable(program_id, is_grad);
@@ -350,7 +350,8 @@ std::unique_ptr<::ir::Program> ConstructFowardIrProgram(
     const paddle::framework::BlockDesc *forward_global_block,
     const paddle::framework::BlockDesc *backward_global_block,
     const std::vector<std::string> output_names,
-    const std::vector<paddle::Tensor> &x) {
+    const std::vector<paddle::Tensor> &x,
+    const std::vector<paddle::Tensor> &params) {
   auto ir_ctx = ::ir::IrContext::Instance();
   auto program = std::make_unique<::ir::Program>(ir_ctx);
 
@@ -386,6 +387,20 @@ std::unique_ptr<::ir::Program> ConstructFowardIrProgram(
     op_desc->SetOutput("out", {name});
   }
 
+  for (auto &param : params) {
+    auto name = param.name();
+    auto place = param.place().GetType();
+
+    auto op_desc = local_program.MutableBlock(0)->PrependOp();
+    op_desc->SetType("feed_with_place");
+    op_desc->SetAttr("index", 0);
+    // TODO(phlrain) : using tensor dtype
+    op_desc->SetAttr("dtype", 0);
+    op_desc->SetAttr("place", static_cast<int>(place));
+    op_desc->SetAttr("name", name);
+    op_desc->SetOutput("out", {name});
+  }
+
   std::set<std::string> set_parameter_names;
   for (auto op_desc : backward_global_block->Program()->Block(0).AllOps()) {
     for (const auto &n : op_desc->Inputs()) {
@@ -426,31 +441,45 @@ std::unique_ptr<::ir::Program> ConstructBackwardIrProgram(
     const paddle::framework::BlockDesc *backward_global_block,
     const std::vector<paddle::Tensor> &out_grad,
     const std::vector<paddle::Tensor *> &x_grad,
-    const std::vector<paddle::Tensor *> &params_grad) {
+    const std::vector<paddle::Tensor *> &params_grad,
+    const paddle::framework::Scope *scope) {
   auto ir_ctx = ::ir::IrContext::Instance();
   auto program = std::make_unique<::ir::Program>(ir_ctx);
 
   auto local_program =
       paddle::framework::ProgramDesc(*(backward_global_block->Program()));
-  // add feed kernel
-  auto *block = local_program.MutableBlock(0);
-  for (auto &out_grad_t : out_grad) {
-    auto name = out_grad_t.name();
-    if (block->FindVarRecursive(name) == nullptr) {
-      continue;
+
+  // get feed with data
+  std::set<std::string> set_parameter_names;
+  for (auto op_desc : backward_global_block->Program()->Block(0).AllOps()) {
+    for (const auto &n : op_desc->Inputs()) {
+      const auto &input_var_names = n.second;
+      for (const auto &var_name : input_var_names) {
+        set_parameter_names.insert(var_name);
+      }
     }
-    auto place = out_grad_t.place().GetType();
-    if (name == "@EMPTY@") {
-      continue;
+  }
+
+  for (auto &var_name : set_parameter_names) {
+    if (scope->FindVar(var_name)) {
+      auto tensor = scope->FindVar(var_name)->Get<phi::DenseTensor>();
+      phi::AllocationType place(phi::AllocationType::UNDEFINED);
+      if (tensor.initialized()) {
+        place = tensor.place().GetType();
+      }
+
+      if (var_name == "@EMPTY@") {
+        continue;
+      }
+      auto op_desc = local_program.MutableBlock(0)->PrependOp();
+      op_desc->SetType("feed_with_place");
+      op_desc->SetAttr("index", 0);
+      // TODO(phlrain) : using tensor dtype
+      op_desc->SetAttr("dtype", 0);
+      op_desc->SetAttr("place", static_cast<int>(place));
+      op_desc->SetAttr("name", var_name);
+      op_desc->SetOutput("out", {var_name});
     }
-    auto op_desc = block->PrependOp();
-    op_desc->SetType("feed_with_place");
-    op_desc->SetAttr("index", 0);
-    // TODO(phlrain) : using tensor dtype
-    op_desc->SetAttr("dtype", 0);
-    op_desc->SetAttr("place", static_cast<int>(place));
-    op_desc->SetAttr("name", name);
-    op_desc->SetOutput("out", {name});
   }
 
   std::vector<std::string> param_grad_names;
 
@@ -241,13 +241,15 @@ std::unique_ptr<::ir::Program> ConstructFowardIrProgram(
     const paddle::framework::BlockDesc* forward_global_block,
     const paddle::framework::BlockDesc* backward_global_block,
     const std::vector<std::string> output_names,
-    const std::vector<paddle::Tensor>& x);
+    const std::vector<paddle::Tensor>& x,
+    const std::vector<paddle::Tensor>& params);
 
 std::unique_ptr<::ir::Program> ConstructBackwardIrProgram(
     const paddle::framework::BlockDesc* backward_global_block,
     const std::vector<paddle::Tensor>& out_grad,
     const std::vector<paddle::Tensor*>& x_grad,
-    const std::vector<paddle::Tensor*>& params_grad);
+    const std::vector<paddle::Tensor*>& params_grad,
+    const paddle::framework::Scope* scope);
 
 }  // namespace framework
 }  // namespace paddle
@@ -47,13 +47,15 @@ InterpreterCore::InterpreterCore(const platform::Place& place,
       place, block, scope, execution_config);
 }
 
-InterpreterCore::InterpreterCore(const platform::Place& place,
-                                 std::unique_ptr<::ir::Program> ir_prog,
-                                 framework::Scope* scope,
-                                 const ExecutionConfig& execution_config) {
+InterpreterCore::InterpreterCore(
+    const platform::Place& place,
+    const std::vector<std::string>& fetch_var_names,
+    std::unique_ptr<::ir::Program> ir_prog,
+    framework::Scope* scope,
+    const ExecutionConfig& execution_config) {
   VLOG(4) << "InterpreterCore(): " << this << " on " << place;
   impl_ = std::make_unique<NewIRInterpreter>(
-      place, std::move(ir_prog), scope, execution_config);
+      place, fetch_var_names, std::move(ir_prog), scope, execution_config);
 }
 
 InterpreterCore::~InterpreterCore() {
 
@@ -37,6 +37,7 @@ class InterpreterCore {
                   const ExecutionConfig& execution_config = ExecutionConfig());
   // This constructor is for New IR.
   InterpreterCore(const platform::Place& place,
+                  const std::vector<std::string>& fetch_var_names,
                   std::unique_ptr<::ir::Program> ir_prog,
                   Scope* scope,
                   const ExecutionConfig& execution_config = ExecutionConfig());
@@ -80,6 +81,8 @@ class InterpreterCore {
   DISABLE_COPY_AND_ASSIGN(InterpreterCore);
 
   std::unique_ptr<InterpreterBaseImpl> impl_;
+
+  std::vector<std::string> fetch_var_names_;
 };
 
 }  // namespace framework