PaddlePaddle
diff --git a/‎paddle/fluid/framework/type_info.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/fluid/framework/type_info.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎paddle/fluid/pir/dialect/op_generator/op_build_gen.py
Copy file name to clipboard
+21-21Lines changed: 21 additions & 21 deletions b/‎paddle/fluid/pir/dialect/op_generator/op_build_gen.py
Copy file name to clipboard
+21-21Lines changed: 21 additions & 21 deletions
diff --git a/‎paddle/fluid/pir/dialect/op_generator/op_gen.py
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion b/‎paddle/fluid/pir/dialect/op_generator/op_gen.py
Copy file name to clipboard
+2-1Lines changed: 2 additions & 1 deletion
diff --git a/‎paddle/fluid/pir/dialect/operator/ir/ir_meta_tensor.cc
Copy file name to clipboard
+92Lines changed: 92 additions & 0 deletions b/‎paddle/fluid/pir/dialect/operator/ir/ir_meta_tensor.cc
Copy file name to clipboard
+92Lines changed: 92 additions & 0 deletions
diff --git a/‎paddle/fluid/pir/dialect/operator/ir/ir_meta_tensor.h
Copy file name to clipboard
+63Lines changed: 63 additions & 0 deletions b/‎paddle/fluid/pir/dialect/operator/ir/ir_meta_tensor.h
Copy file name to clipboard
+63Lines changed: 63 additions & 0 deletions
diff --git a/‎paddle/fluid/pir/dialect/operator/ir/meta_tensor.cc renamed to ‎paddle/fluid/pir/dialect/operator/ir/ir_tensor.cc
Copy file name to clipboard
+17-17Lines changed: 17 additions & 17 deletions b/‎paddle/fluid/pir/dialect/operator/ir/meta_tensor.cc renamed to ‎paddle/fluid/pir/dialect/operator/ir/ir_tensor.cc
Copy file name to clipboard
+17-17Lines changed: 17 additions & 17 deletions
@@ -16,7 +16,7 @@ limitations under the License. */
 #include "paddle/fluid/framework/feed_fetch_type.h"
 #include "paddle/fluid/framework/raw_tensor.h"
 #include "paddle/fluid/framework/string_array.h"
-#include "paddle/fluid/pir/dialect/operator/ir/meta_tensor.h"
+#include "paddle/fluid/pir/dialect/operator/ir/ir_tensor.h"
 #include "paddle/fluid/prim/utils/static/desc_tensor.h"
 #include "paddle/fluid/primitive/type/lazy_tensor.h"
 
@@ -45,6 +45,6 @@ template class TypeInfoTraits<phi::TensorBase, paddle::prim::DescTensor>;
 template class TypeInfoTraits<phi::TensorBase, paddle::primitive::LazyTensor>;
 template class TypeInfoTraits<phi::TensorBase,
                               paddle::framework::VariableRefArray>;
-template class TypeInfoTraits<phi::TensorBase, paddle::dialect::IrMetaTensor>;
+template class TypeInfoTraits<phi::TensorBase, paddle::dialect::IrTensor>;
 
 }  // namespace phi
@@ -313,43 +313,43 @@ def GenBuildOutputs(
     build_output_str = '  VLOG(4) << "Builder construction outputs";\n'
     CREATE_INPUT_METATENSOR_TEMPLATE = """
   VLOG(4) << "Builder construction  dense_{name}";
-  paddle::dialect::IrMetaTensor ir_meta_tensor_{name}(paddle::dialect::TransToPhiDataType({name}.dtype()),
+  paddle::dialect::IrTensor ir_tensor_{name}(paddle::dialect::TransToPhiDataType({name}.dtype()),
                                                       {name}.dims(),
                                                       {name}.data_layout(),
                                                       {name}.lod(),
                                                       {name}.offset());
   VLOG(4) << "Builder construction  meta_{name}";
-  phi::MetaTensor meta_{name}(&ir_meta_tensor_{name});
+  paddle::dialect::IrMetaTensor meta_{name}(&ir_tensor_{name});
 """
 
     CREATE_OPTIONAL_INPUT_METATENSOR_TEMPLATE = """
-  phi::MetaTensor meta_{name};
-  paddle::dialect::IrMetaTensor ir_meta_tensor_{name};
+  paddle::dialect::IrMetaTensor meta_{name};
+  paddle::dialect::IrTensor ir_tensor_{name};
   if ({name}_.impl() != nullptr) {{
     paddle::dialect::DenseTensorType {name} = {name}_.type().dyn_cast<paddle::dialect::DenseTensorType>();
     VLOG(4) << "Builder construction  dense_{name}";
-    ir_meta_tensor_{name} = paddle::dialect::IrMetaTensor(paddle::dialect::TransToPhiDataType({name}.dtype()),
+    ir_tensor_{name} = paddle::dialect::IrTensor(paddle::dialect::TransToPhiDataType({name}.dtype()),
                                                         {name}.dims(),
                                                         {name}.data_layout(),
                                                         {name}.lod(),
                                                         {name}.offset());
     VLOG(4) << "Builder construction  meta_{name}";
-    meta_{name} = phi::MetaTensor(&ir_meta_tensor_{name});
+    meta_{name} = paddle::dialect::IrMetaTensor(&ir_tensor_{name});
   }}
 
 """
 
-    CREATE_INPUT_VEC_METATENSOR_TEMPLATE = """  std::vector<paddle::dialect::IrMetaTensor> vec_ir_meta_tensor_{name};
+    CREATE_INPUT_VEC_METATENSOR_TEMPLATE = """  std::vector<paddle::dialect::IrTensor> vec_ir_tensor_{name};
   for (size_t i=0; i < static_cast<size_t>({name}.size()); i++) {{
-    vec_ir_meta_tensor_{name}.push_back(paddle::dialect::IrMetaTensor(paddle::dialect::TransToPhiDataType({name}[i].dyn_cast<paddle::dialect::DenseTensorType>().dtype()),
+    vec_ir_tensor_{name}.push_back(paddle::dialect::IrTensor(paddle::dialect::TransToPhiDataType({name}[i].dyn_cast<paddle::dialect::DenseTensorType>().dtype()),
                                                                      {name}[i].dyn_cast<paddle::dialect::DenseTensorType>().dims(),
                                                                      {name}[i].dyn_cast<paddle::dialect::DenseTensorType>().data_layout(),
                                                                      {name}[i].dyn_cast<paddle::dialect::DenseTensorType>().lod(),
                                                                      {name}[i].dyn_cast<paddle::dialect::DenseTensorType>().offset()));
   }}
-  std::vector<phi::MetaTensor> vec_meta_{name};
-  for (size_t i=0; i < vec_ir_meta_tensor_{name}.size(); i++) {{
-    vec_meta_{name}.push_back(phi::MetaTensor(&vec_ir_meta_tensor_{name}[i]));
+  std::vector<paddle::dialect::IrMetaTensor> vec_meta_{name};
+  for (size_t i=0; i < vec_ir_tensor_{name}.size(); i++) {{
+    vec_meta_{name}.push_back(paddle::dialect::IrMetaTensor(&vec_ir_tensor_{name}[i]));
   }}
 
   std::vector<const phi::MetaTensor*> meta_{name};
@@ -358,21 +358,21 @@ def GenBuildOutputs(
   }}
  """
 
-    CREATE_OPTIONAL_INPUT_VEC_METATENSOR_TEMPLATE = """  std::vector<paddle::dialect::IrMetaTensor> vec_ir_meta_tensor_{name};
+    CREATE_OPTIONAL_INPUT_VEC_METATENSOR_TEMPLATE = """  std::vector<paddle::dialect::IrTensor> vec_ir_tensor_{name};
   if ({name}_.impl() != nullptr) {{
     pir::VectorType {name} = {name}_.type().dyn_cast<pir::VectorType>();
     for (size_t i=0; i < static_cast<size_t>({name}.size()); i++) {{
-        vec_ir_meta_tensor_{name}.push_back(paddle::dialect::IrMetaTensor(paddle::dialect::TransToPhiDataType({name}[i].dyn_cast<paddle::dialect::DenseTensorType>().dtype()),
+        vec_ir_tensor_{name}.push_back(paddle::dialect::IrTensor(paddle::dialect::TransToPhiDataType({name}[i].dyn_cast<paddle::dialect::DenseTensorType>().dtype()),
                                                                         {name}[i].dyn_cast<paddle::dialect::DenseTensorType>().dims(),
                                                                         {name}[i].dyn_cast<paddle::dialect::DenseTensorType>().data_layout(),
                                                                         {name}[i].dyn_cast<paddle::dialect::DenseTensorType>().lod(),
                                                                         {name}[i].dyn_cast<paddle::dialect::DenseTensorType>().offset()));
     }}
   }}
 
-  std::vector<phi::MetaTensor> vec_meta_{name};
-  for (size_t i=0; i < vec_ir_meta_tensor_{name}.size(); i++) {{
-    vec_meta_{name}.push_back(phi::MetaTensor(&vec_ir_meta_tensor_{name}[i]));
+  std::vector<paddle::dialect::IrMetaTensor> vec_meta_{name};
+  for (size_t i=0; i < vec_ir_tensor_{name}.size(); i++) {{
+    vec_meta_{name}.push_back(paddle::dialect::IrMetaTensor(&vec_ir_tensor_{name}[i]));
   }}
 
   std::vector<const phi::MetaTensor*> meta_{name};
@@ -430,13 +430,13 @@ def GenBuildOutputs(
     {name}.SetFromTensor(true);
   }}\n"""
 
-    CREATE_OUTPUT_METATENSOR_TEMPLATE = """  paddle::dialect::IrMetaTensor dense_{name};
-  phi::MetaTensor meta_{name}(&dense_{name});
+    CREATE_OUTPUT_METATENSOR_TEMPLATE = """  paddle::dialect::IrTensor dense_{name};
+  paddle::dialect::IrMetaTensor meta_{name}(&dense_{name});
 """
-    CREATE_OUTPUT_VEC_METATENSOR_TEMPLATE = """  std::vector<paddle::dialect::IrMetaTensor> vec_dense_{name}(({output_size}), paddle::dialect::IrMetaTensor());
-  std::vector<phi::MetaTensor> vec_meta_{name};
+    CREATE_OUTPUT_VEC_METATENSOR_TEMPLATE = """  std::vector<paddle::dialect::IrTensor> vec_dense_{name}(({output_size}), paddle::dialect::IrTensor());
+  std::vector<paddle::dialect::IrMetaTensor> vec_meta_{name};
   for (size_t i=0; i < static_cast<size_t>({output_size}); i++) {{
-    vec_meta_{name}.push_back(phi::MetaTensor(&vec_dense_{name}[i]));
+    vec_meta_{name}.push_back(paddle::dialect::IrMetaTensor(&vec_dense_{name}[i]));
   }}
   std::vector<phi::MetaTensor*> meta_{name};
   for (size_t i=0; i < static_cast<size_t>(vec_meta_{name}.size()); i++) {{
 
@@ -128,7 +128,8 @@ class {op_name} : public pir::Op<{op_name}{interfaces}{traits}> {{
 #include "{h_file}"
 #include "paddle/fluid/pir/dialect/operator/ir/op_type.h"
 #include "paddle/fluid/pir/dialect/operator/ir/op_attribute.h"
-#include "paddle/fluid/pir/dialect/operator/ir/meta_tensor.h"
+#include "paddle/fluid/pir/dialect/operator/ir/ir_tensor.h"
+#include "paddle/fluid/pir/dialect/operator/ir/ir_meta_tensor.h"
 #include "paddle/pir/core/builtin_attribute.h"
 #include "paddle/pir/core/builtin_type.h"
 #include "paddle/pir/core/builtin_op.h"
 
@@ -0,0 +1,92 @@
+// Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "paddle/fluid/pir/dialect/operator/ir/ir_meta_tensor.h"
+#include "paddle/fluid/pir/dialect/operator/ir/ir_tensor.h"
+
+namespace paddle {
+namespace dialect {
+static inline void ValidCheck(const IrMetaTensor& meta_tensor) {
+  PADDLE_ENFORCE_EQ(meta_tensor.initialized(),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "The current MetaTensor is not initialized."));
+}
+
+int64_t IrMetaTensor::numel() const {
+  ValidCheck(*this);
+  return tensor_->numel();
+}
+
+phi::DDim IrMetaTensor::dims() const {
+  ValidCheck(*this);
+  return tensor_->dims();
+}
+
+phi::DataType IrMetaTensor::dtype() const {
+  ValidCheck(*this);
+  return tensor_->dtype();
+}
+
+phi::DataLayout IrMetaTensor::layout() const {
+  ValidCheck(*this);
+  return tensor_->layout();
+}
+
+const phi::LoD& IrMetaTensor::lod() const {
+  ValidCheck(*this);
+  return static_cast<paddle::dialect::IrTensor*>(tensor_)->lod();
+}
+
+void IrMetaTensor::set_dims(const phi::DDim& dims) {
+  static_cast<paddle::dialect::IrTensor*>(tensor_)->SetDims(dims);
+}
+
+void IrMetaTensor::set_dtype(phi::DataType dtype) {
+  static_cast<paddle::dialect::IrTensor*>(tensor_)->SetDtype(dtype);
+}
+
+void IrMetaTensor::set_layout(phi::DataLayout layout) {
+  static_cast<paddle::dialect::IrTensor*>(tensor_)->SetLayout(layout);
+}
+
+void IrMetaTensor::share_lod(const MetaTensor& meta_tensor) {
+  auto& ir_meta_tensor = static_cast<const IrMetaTensor&>(meta_tensor);
+  static_cast<paddle::dialect::IrTensor*>(tensor_)->SetLod(
+      ir_meta_tensor.lod());
+}
+
+void IrMetaTensor::share_dims(const MetaTensor& meta_tensor) {
+  auto& ir_meta_tensor = static_cast<const IrMetaTensor&>(meta_tensor);
+  set_dims(ir_meta_tensor.dims());
+}
+
+void IrMetaTensor::share_meta(const MetaTensor& meta_tensor) {
+  auto& ir_meta_tensor = static_cast<const IrMetaTensor&>(meta_tensor);
+  share_dims(ir_meta_tensor);
+  set_dtype(ir_meta_tensor.dtype());
+  set_layout(ir_meta_tensor.layout());
+  share_lod(ir_meta_tensor);
+}
+
+bool IrMetaTensor::initialized() const { return tensor_ != nullptr; }
+
+bool IrMetaTensor::is_selected_rows() const { return false; }
+
+bool IrMetaTensor::is_tensor_array() const { return false; }
+
+bool IrMetaTensor::is_dense() const { return false; }
+
+}  // namespace dialect
+}  // namespace paddle
@@ -0,0 +1,63 @@
+// Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "paddle/phi/core/meta_tensor.h"
+
+namespace paddle {
+namespace dialect {
+class IrMetaTensor : public phi::MetaTensor {
+ public:
+  using MetaTensor::MetaTensor;
+
+  int64_t numel() const override;
+
+  phi::DDim dims() const override;
+
+  phi::DataType dtype() const override;
+
+  phi::DataLayout layout() const override;
+
+  const phi::LoD& lod() const;
+
+  void set_dims(const phi::DDim& dims) override;
+
+  void set_dtype(phi::DataType dtype) override;
+
+  void set_layout(phi::DataLayout layout) override;
+
+  void share_lod(const MetaTensor& meta_tensor) override;
+
+  void share_dims(const MetaTensor& meta_tensor) override;
+
+  void share_meta(const MetaTensor& meta_tensor) override;
+
+  bool initialized() const override;
+
+  bool is_selected_rows() const override;
+  bool is_tensor_array() const override;
+  bool is_dense() const override;
+
+  operator unspecified_bool_type() const override {
+    return initialized() ? unspecified_bool_true : 0;
+  }
+
+  bool operator!() const override { return tensor_ == nullptr; }
+
+  static void unspecified_bool_true() {}
+};
+
+}  // namespace dialect
+}  // namespace paddle
@@ -12,28 +12,28 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "paddle/fluid/pir/dialect/operator/ir/meta_tensor.h"
+#include "paddle/fluid/pir/dialect/operator/ir/ir_tensor.h"
 
 #include "paddle/pir/core/enforce.h"
 
 namespace paddle {
 namespace dialect {
-IrMetaTensor::IrMetaTensor(phi::DataType dtype,
-                           const phi::DDim& dims,
-                           phi::DataLayout layout,
-                           const LoD& lod,
-                           size_t offset)
+IrTensor::IrTensor(phi::DataType dtype,
+                   const phi::DDim& dims,
+                   phi::DataLayout layout,
+                   const LoD& lod,
+                   size_t offset)
     : dims_(dims), dtype_(dtype), layout_(layout), lod_(lod), offset_(offset) {}
 
-IrMetaTensor::IrMetaTensor(const IrMetaTensor& other) {
+IrTensor::IrTensor(const IrTensor& other) {
   dims_ = other.dims();
   dtype_ = other.dtype();
   layout_ = other.layout();
   lod_ = other.lod();
   offset_ = other.offset();
 }
 
-IrMetaTensor& IrMetaTensor::operator=(const IrMetaTensor& other) {
+IrTensor& IrTensor::operator=(const IrTensor& other) {
   dims_ = other.dims();
   dtype_ = other.dtype();
   layout_ = other.layout();
@@ -42,7 +42,7 @@ IrMetaTensor& IrMetaTensor::operator=(const IrMetaTensor& other) {
   return *this;
 }
 
-IrMetaTensor& IrMetaTensor::operator=(IrMetaTensor&& other) noexcept {
+IrTensor& IrTensor::operator=(IrTensor&& other) noexcept {
   dims_ = std::move(other.dims());
   dtype_ = other.dtype();
   layout_ = other.layout();
@@ -51,17 +51,17 @@ IrMetaTensor& IrMetaTensor::operator=(IrMetaTensor&& other) noexcept {
   return *this;
 }
 
-int64_t IrMetaTensor::numel() const { return phi::product(dims_); }
+int64_t IrTensor::numel() const { return phi::product(dims_); }
 
-const phi::Place& IrMetaTensor::place() const {
-  IR_THROW("Don't use IrMetaTensor::place method.");
+const phi::Place& IrTensor::place() const {
+  IR_THROW("Don't use IrTensor::place method.");
 }
 
-void* IrMetaTensor::AllocateFrom(phi::Allocator* allocator,
-                                 phi::DataType dtype,
-                                 size_t requested_size,
-                                 bool fake_alloc) {
-  IR_THROW("Don't use IrMetaTensor::AllocateFrom method.");
+void* IrTensor::AllocateFrom(phi::Allocator* allocator,
+                             phi::DataType dtype,
+                             size_t requested_size,
+                             bool fake_alloc) {
+  IR_THROW("Don't use IrTensor::AllocateFrom method.");
 }
 
 }  // namespace dialect