PaddlePaddle
diff --git a/‎paddle/fluid/pybind/eager_utils.cc
Copy file name to clipboard
+53-50Lines changed: 53 additions & 50 deletions b/‎paddle/fluid/pybind/eager_utils.cc
Copy file name to clipboard
+53-50Lines changed: 53 additions & 50 deletions
diff --git a/‎paddle/fluid/pybind/pybind.cc
Copy file name to clipboard
+1-9Lines changed: 1 addition & 9 deletions b/‎paddle/fluid/pybind/pybind.cc
Copy file name to clipboard
+1-9Lines changed: 1 addition & 9 deletions
@@ -2005,48 +2005,52 @@ PyObject* GetEmptyTensorsWithVarDesc(PyObject* self, PyObject* args) {
 
 paddle::Tensor CreateTensorFromValue(const pir::Value& value) {
   auto tensor = paddle::Tensor();
-
-  auto dims = phi::vectorize(GetValueDims(value));
-  auto ddims = phi::make_ddim(dims);
-  if (auto name = pir::utils::name_analysis::TryGetValueFirstName(value)) {
-    tensor.set_name(name.value());
-  }
   auto autograd_meta = egr::EagerUtils::autograd_meta(&tensor);
   autograd_meta->SetPersistable(false);
   autograd_meta->SetStopGradient(GetValueBoolAttr(value, kAttrStopGradients));
 
-  if (value.type().isa<paddle::dialect::DenseTensorType>()) {
-    // TODO(jiabin): Maybe support LegacyLoD later
-    std::shared_ptr<phi::DenseTensor> dense_tensor = nullptr;
-    auto dtype = paddle::dialect::TransToPhiDataType(
-        value.type().dyn_cast<paddle::dialect::DenseTensorType>().dtype());
-
-    if (dims.size() == 1 && dims[0] == 0) {
-      std::shared_ptr<phi::Allocation> allocation_ptr = nullptr;
-      dense_tensor = std::make_shared<phi::DenseTensor>(
-          allocation_ptr, phi::DenseTensorMeta(dtype, ddims));
-    } else {
-      // TODO(dev): we need enhance check for ddims.
-      dense_tensor = std::make_shared<phi::DenseTensor>(
-          std::make_shared<phi::Allocation>(),
-          phi::DenseTensorMeta(dtype, ddims));
-    }
+  if (value.impl() == nullptr || !value.type()) {
+    // do-nothing, just skip the Value with nullptr
+  } else {
+    auto dims = phi::vectorize(GetValueDims(value));
+    auto ddims = phi::make_ddim(dims);
+    if (auto name = pir::utils::name_analysis::TryGetValueFirstName(value)) {
+      tensor.set_name(name.value());
+    }
+
+    if (value.type().isa<paddle::dialect::DenseTensorType>()) {
+      // TODO(jiabin): Maybe support LegacyLoD later
+      std::shared_ptr<phi::DenseTensor> dense_tensor = nullptr;
+      auto dtype = paddle::dialect::TransToPhiDataType(
+          value.type().dyn_cast<paddle::dialect::DenseTensorType>().dtype());
+
+      if (dims.size() == 1 && dims[0] == 0) {
+        std::shared_ptr<phi::Allocation> allocation_ptr = nullptr;
+        dense_tensor = std::make_shared<phi::DenseTensor>(
+            allocation_ptr, phi::DenseTensorMeta(dtype, ddims));
+      } else {
+        // TODO(dev): we need enhance check for ddims.
+        dense_tensor = std::make_shared<phi::DenseTensor>(
+            std::make_shared<phi::Allocation>(),
+            phi::DenseTensorMeta(dtype, ddims));
+      }
 
-    if (value.type().isa<paddle::dialect::DistDenseTensorType>()) {
-      paddle::dialect::DistDenseTensorType value_type =
-          value.type().dyn_cast<paddle::dialect::DistDenseTensorType>();
-      auto pir_attr = value_type.tensor_dist_attr();
-      auto mesh = pir_attr.process_mesh_attr().process_mesh();
-      auto placements = pir_attr.placements();
-      tensor.set_impl(std::make_shared<phi::distributed::DistTensor>(
-          dense_tensor, mesh, placements));
-    } else {
-      tensor.set_impl(dense_tensor);
+      if (value.type().isa<paddle::dialect::DistDenseTensorType>()) {
+        paddle::dialect::DistDenseTensorType value_type =
+            value.type().dyn_cast<paddle::dialect::DistDenseTensorType>();
+        auto pir_attr = value_type.tensor_dist_attr();
+        auto mesh = pir_attr.process_mesh_attr().process_mesh();
+        auto placements = pir_attr.placements();
+        tensor.set_impl(std::make_shared<phi::distributed::DistTensor>(
+            dense_tensor, mesh, placements));
+      } else {
+        tensor.set_impl(dense_tensor);
+      }
+    } else if (value.type().isa<paddle::dialect::SelectedRowsType>()) {
+      std::shared_ptr<phi::SelectedRows> selected_rows_tensor =
+          std::make_shared<phi::SelectedRows>();
+      tensor.set_impl(selected_rows_tensor);
     }
-  } else if (value.type().isa<paddle::dialect::SelectedRowsType>()) {
-    std::shared_ptr<phi::SelectedRows> selected_rows_tensor =
-        std::make_shared<phi::SelectedRows>();
-    tensor.set_impl(selected_rows_tensor);
   }
 
   if (!autograd_meta->GetMutableGradNode()) {
@@ -2063,29 +2067,28 @@ PyObject* GetEmptyTensorsWithValue(PyObject* self, PyObject* args) {
 
   auto value_list = PyTuple_GetItem(args, 0);
 
+  auto CreateTensorFromValueWithCache =
+      [&out_tensor_map](const pir::Value& value) {
+        if (out_tensor_map.find(value) == out_tensor_map.end()) {
+          paddle::Tensor tensor = CreateTensorFromValue(value);
+          out_tensor_map[value] = tensor;
+          return tensor;
+        } else {
+          return out_tensor_map[value];
+        }
+      };
+
   if (PyList_Check(value_list)) {
     Py_ssize_t len = PyList_Size(value_list);
     for (Py_ssize_t i = 0; i < len; i++) {
       auto value = PyObjectCast<pir::Value>(PyList_GetItem(value_list, i));
-      if (out_tensor_map.find(value) == out_tensor_map.end()) {
-        paddle::Tensor tensor = CreateTensorFromValue(value);
-        out_tensor_map[value] = tensor;
-        result.emplace_back(tensor);
-      } else {
-        result.emplace_back(out_tensor_map[value]);
-      }
+      result.emplace_back(CreateTensorFromValueWithCache(value));
     }
   } else if (PyTuple_Check(value_list)) {
     Py_ssize_t len = PyTuple_Size(value_list);
     for (Py_ssize_t i = 0; i < len; i++) {
       auto value = PyObjectCast<pir::Value>(PyTuple_GetItem(value_list, i));
-      if (out_tensor_map.find(value) == out_tensor_map.end()) {
-        paddle::Tensor tensor = CreateTensorFromValue(value);
-        out_tensor_map[value] = tensor;
-        result.emplace_back(tensor);
-      } else {
-        result.emplace_back(out_tensor_map[value]);
-      }
+      result.emplace_back(CreateTensorFromValueWithCache(value));
     }
   } else if (value_list != Py_None) {
     PADDLE_THROW(common::errors::InvalidArgument(
 
@@ -1030,24 +1030,16 @@ void BindDecompRule(pybind11::module *m) {
          int start_index,
          int end_index) {
         VLOG(4) << "[Prim] Bind Decomp sinking_decomp begin.";
-        py::list res;
         auto original_insertion_point =
             paddle::dialect::ApiBuilder::Instance().GetCurrentInsertionPoint();
         DecompProgram decomp_object(
             program, src_vars, blacklist, whitelist, start_index, end_index);
         decomp_object.decomp_program();
         std::vector<pir::Value> tar_vars = decomp_object.get_dst_vars();
-        for (size_t i = 0; i < tar_vars.size(); ++i) {
-          if (!tar_vars[i]) {
-            res.append(nullptr);
-          } else {
-            res.append(tar_vars[i]);
-          }
-        }
         paddle::dialect::ApiBuilder::Instance().SetInsertionPoint(
             original_insertion_point);
         VLOG(4) << "[Prim] Bind Decomp sinking_decomp end.";
-        return res;
+        return tar_vars;
       });
 
   m->def("call_decomp_rule", [](pir::Operation &fwd_op) {