Update pop/push instruction for nulltype (PaddlePaddle#71133)

* update pop/push instruction

* delete std::cout

Author: HydrogenSulfate

paddle/fluid/framework/new_executor/instruction/control_flow/tuple_pop_instruction.cc

@@ -41,8 +41,12 @@ TuplePopInstruction::TuplePopInstruction(size_t id,
   std::unordered_map<pir::Value, std::vector<int>> outputs;
   for (size_t i = 0; i < tuple_pop_op_.tuple_size(); ++i) {
     auto outlet_element_value = tuple_pop_op_.outlet_element(i);
-    outputs.emplace(outlet_element_value,
-                    GetValueIds(outlet_element_value, *value_exe_info_));
+    if (outlet_element_value.type()) {
+      outputs.emplace(outlet_element_value,
+                      GetValueIds(outlet_element_value, *value_exe_info_));
+    } else {
+      outputs.emplace(outlet_element_value, std::vector<int>{});
+    }
   }
 
   // NOTE(zhangbo): TuplePop will change the variables corresponding to the
@@ -136,6 +140,9 @@ void TuplePopInstruction::Run() {
       VLOG(6) << "pop back var: " << front_var;
       auto outlet_element_value = tuple_pop_op_.outlet_element(i);
       auto grad_var = value_exe_info_->GetVarByValue(outlet_element_value);
+      if (front_var == nullptr && grad_var == nullptr) {
+        continue;
+      }
       ShareVarData(front_var, grad_var);
       Variable* gc_front_var = const_cast<Variable*>(front_var);
       AddEagerGCVar(gc_front_var);

paddle/fluid/framework/new_executor/instruction/control_flow/tuple_push_instruction.cc

@@ -65,8 +65,12 @@ TuplePushInstruction::TuplePushInstruction(size_t id,
   std::unordered_map<pir::Value, std::vector<int>> inputs;
   for (size_t i = 0; i < tuple_push_op_.tuple_size(); ++i) {
     auto inlet_element_value = tuple_push_op_.inlet_element(i);
-    inputs.emplace(inlet_element_value,
-                   GetValueIds(inlet_element_value, *value_exe_info_));
+    if (inlet_element_value.type()) {
+      inputs.emplace(inlet_element_value,
+                     GetValueIds(inlet_element_value, *value_exe_info_));
+    } else {
+      inputs.emplace(inlet_element_value, std::vector<int>{});
+    }
   }
   SetInputs(inputs);
 
@@ -99,14 +103,22 @@ void TuplePushInstruction::Run() {
     for (size_t i = 0; i < tuple_push_op_.tuple_size(); i++) {
       auto inlet_element_value = tuple_push_op_.inlet_element(i);
       Variable* var = value_exe_info_->GetVarByValue(inlet_element_value);
-
-      auto var_name = value_2_var_name.at(inlet_element_value);
+      bool is_optional = (inlet_element_value.impl() == nullptr ||
+                          !inlet_element_value.type());
       auto num_str = std::to_string(stack_element_var_array_->size());
+      if (!value_2_var_name.count(inlet_element_value)) {
+        if (!is_optional) {
+          PADDLE_THROW(common::errors::PermissionDenied(
+              "Cannot find corresbonding DenseTensor"));
+        }
+        stack_element_var_array_->emplace_back(nullptr);
+        continue;
+      }
+      std::string var_name = value_2_var_name.at(inlet_element_value);
       std::string new_name = var_name + "_copied_" + num_str + "_in_tuple_" +
                              std::to_string(op_->id());
       auto* copy_var = value_exe_info_->GetScope()->Var(new_name);
-      bool is_optional = (inlet_element_value.impl() == nullptr ||
-                          !inlet_element_value.type());
+
       DeepCopyVariable(var,
                        &copy_var,
                        value_exe_info_,

paddle/fluid/pir/transforms/pd_op_to_kernel_pass.cc

@@ -101,6 +101,8 @@ pir::Type ConvertOpTypeToKernelType(pir::IrContext* ctx,
           ConvertOpTypeToKernelType(ctx, vec_type[i], place));
     }
     return pir::VectorType::get(ctx, vec_target_type);
+  } else if (!op_type) {
+    return pir::Type();
   }
   PADDLE_THROW(common::errors::Unimplemented(
       "Not support op type %s in ConvertOpTypeToKernelType.", op_type));
@@ -1731,6 +1733,8 @@ void AddShadowFeedForValue(
     block->push_back(shadow_tensors_op);
     (*map_op_pair)[op_item] = shadow_tensors_op;
     (*map_value_pair)[op_item->result(index)] = shadow_tensors_op->result(0);
+  } else if (!op_item->result(index).type()) {
+    return;
   } else {
     PADDLE_THROW(
         common::errors::Unimplemented("AddShadowFeed for value only support "