Resolve compilation issues with gcc 13.2 on CPU (#69061)

0x3878f · web-flow · commit 55786110c19b · 2024-11-04T14:10:59.000+08:00
* Resolve compilation issues with gcc 13.2

* Fix: data == nullptr in Parameter

* fix: compilation on mac
diff --git a/cmake/external/eigen.cmake b/cmake/external/eigen.cmake
@@ -65,6 +65,12 @@ if(NOT WIN32)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-error=uninitialized")
   endif()
 endif()
+if(NOT WIN32
+   AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU"
+   AND ${CMAKE_CXX_COMPILER_VERSION} VERSION_GREATER_EQUAL 13.0)
+  message(STATUS "GCC version is >= 13.0, adding -Wno-error=stringop-overflow.")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=stringop-overflow ")
+endif()
 ExternalProject_Add(
   extern_eigen3
   ${EXTERNAL_PROJECT_LOG_ARGS}
diff --git a/cmake/external/gtest.cmake b/cmake/external/gtest.cmake
@@ -71,6 +71,12 @@ if(NOT WIN32 AND ${CMAKE_CXX_COMPILER_VERSION} VERSION_GREATER 12.0)
       git checkout -- . && git checkout ${GTEST_TAG} && patch -Nd
       ${SOURCE_DIR}/googletest/src < ${native_src})
 endif()
+if(NOT WIN32
+   AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU"
+   AND ${CMAKE_CXX_COMPILER_VERSION} VERSION_GREATER_EQUAL 13.0)
+  message(STATUS "GCC version is >= 13.0, adding -Wno-dangling-pointer")
+  set(GTEST_CMAKE_CXX_FLAGS "${GTEST_CMAKE_CXX_FLAGS} -Wno-dangling-pointer")
+endif()
 if(WIN32)
   ExternalProject_Add(
     extern_gtest
diff --git a/cmake/external/rocksdb.cmake b/cmake/external/rocksdb.cmake
@@ -37,10 +37,24 @@ set(ROCKSDB_SHARED_LINKER_FLAGS "-Wl,--no-as-needed -ldl")
 
 if(WITH_ARM)
   file(TO_NATIVE_PATH ${PADDLE_SOURCE_DIR}/patches/rocksdb/libaio.h.patch
-       native_src)
-  set(ROCKSDB_PATCH_COMMAND
-      git checkout -- . && git checkout ${ROCKSDB_TAG} && patch -Nd
-      ${PADDLE_SOURCE_DIR}/third_party/rocksdb/env/ < ${native_src})
+       libaio_h_patch)
+  set(ROCKSDB_PATCH_COMMAND_ARM
+      patch -Nd ${PADDLE_SOURCE_DIR}/third_party/rocksdb/env/ <
+      ${libaio_h_patch})
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND ${CMAKE_CXX_COMPILER_VERSION}
+                                            VERSION_GREATER_EQUAL 13.0)
+  message(
+    STATUS
+      "GCC version is ${CMAKE_CXX_COMPILER_VERSION}, adding some patches for gcc13+"
+  )
+  file(TO_NATIVE_PATH ${PADDLE_SOURCE_DIR}/patches/rocksdb/include.patch
+       include_patch)
+  file(TO_NATIVE_PATH ${PADDLE_SOURCE_DIR}/patches/rocksdb/redundant_move.patch
+       redundant_move_patch)
+  set(ROCKSDB_PATCH_COMMAND_GCC13 git apply ${include_patch}
+                                  ${redundant_move_patch})
 endif()
 
 ExternalProject_Add(
@@ -49,7 +63,10 @@ ExternalProject_Add(
   PREFIX ${ROCKSDB_PREFIX_DIR}
   SOURCE_DIR ${ROCKSDB_SOURCE_DIR}
   UPDATE_COMMAND ""
-  PATCH_COMMAND ${ROCKSDB_PATCH_COMMAND}
+  PATCH_COMMAND
+  COMMAND git checkout -- . && git checkout ${ROCKSDB_TAG}
+  COMMAND ${ROCKSDB_PATCH_COMMAND_ARM}
+  COMMAND ${ROCKSDB_PATCH_COMMAND_GCC13}
   CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
              -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
              -DWITH_BZ2=OFF
diff --git a/paddle/fluid/distributed/ps/service/coordinator_client.h b/paddle/fluid/distributed/ps/service/coordinator_client.h
@@ -187,6 +187,7 @@ class CoordinatorClient : public BrpcPsClient {
 
   virtual ~CoordinatorClient() {}
 
+  using BrpcPsClient::Initialize;
   int32_t Initialize(const std::vector<std::string>& trainer_endpoints);
 
   void SetTotalFLClientsNum(uint32_t all_fl_clients_num) {
diff --git a/paddle/fluid/eager/eager_layout_transformer.h b/paddle/fluid/eager/eager_layout_transformer.h
@@ -204,15 +204,16 @@ class EagerHeavilyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {
   }
 
   paddle::Tensor TransInTensor(const std::string& in_name,
-                               const paddle::Tensor& in) {
+                               const paddle::Tensor& in) override {
     if (heavily_input_.count(in_name) != 0 && in.layout() != desired_layout_) {
       auto out_tensor = EagerTraceTransposeOp(desired_layout_, in);
       return out_tensor;
     }
     return in;
   }
 
-  void SetOutTensorLayout(paddle::Tensor* out_tensor) {
+  using EagerLayoutTransformer::SetOutTensorLayout;
+  void SetOutTensorLayout(paddle::Tensor* out_tensor) override {
     UpdateLayout(out_tensor, desired_layout_);
   }
 
@@ -222,7 +223,7 @@ class EagerHeavilyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {
     }
   }
 
-  void SetOutTensorLayout(std::vector<paddle::Tensor>* out_tensor) {
+  void SetOutTensorLayout(std::vector<paddle::Tensor>* out_tensor) override {
     for (size_t i = 0; i < out_tensor->size(); i++) {
       if ((*out_tensor)[i].layout() != desired_layout_) {
         VLOG(4) << "Update out_tensor's layout from "
@@ -252,7 +253,7 @@ class EagerLightlyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {
 
   // transpose from desired to default
   paddle::Tensor TransInTensor(const std::string& in_name UNUSED,
-                               const paddle::Tensor& in) {
+                               const paddle::Tensor& in) override {
     std::string input_layout = common::DataLayoutToString(in.layout());
     auto default_layout = DefaultLayout();
     if (final_layout_ == input_layout && in.shape().size() == 4) {
@@ -265,9 +266,9 @@ class EagerLightlyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {
     return in;
   }
 
-  virtual std::vector<paddle::Tensor> TransInTensors(
+  std::vector<paddle::Tensor> TransInTensors(
       const std::string& in_name UNUSED,
-      const std::vector<paddle::Tensor>& in) {
+      const std::vector<paddle::Tensor>& in) override {
     std::vector<paddle::Tensor> result;
     auto desired_layout = DesiredLayout();
     auto default_layout = DefaultLayout();
@@ -287,7 +288,8 @@ class EagerLightlyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {
     return result;
   }
 
-  void SetOutTensorLayout(paddle::Tensor* out_tensor) {
+  using EagerLayoutTransformer::SetOutTensorLayout;
+  void SetOutTensorLayout(paddle::Tensor* out_tensor) override {
     UpdateLayout(out_tensor, DefaultLayout());
   }
 
@@ -297,7 +299,7 @@ class EagerLightlyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {
     }
   }
 
-  void SetOutTensorLayout(std::vector<paddle::Tensor>* out_tensor) {
+  void SetOutTensorLayout(std::vector<paddle::Tensor>* out_tensor) override {
     auto default_layout = DefaultLayout();
     for (size_t i = 0; i < out_tensor->size(); i++) {
       phi::DenseTensorUtils::GetMutableMeta(
@@ -330,11 +332,11 @@ class EagerTransposeOpTransformer
   }
 
   paddle::Tensor TransInTensor(const std::string& in_name UNUSED,
-                               const paddle::Tensor& in) {
+                               const paddle::Tensor& in) override {
     return in;
   }
 
-  void SetOutTensorLayout(paddle::Tensor* out_tensor) {
+  void SetOutTensorLayout(paddle::Tensor* out_tensor) override {
     UpdateLayout(out_tensor, DefaultLayout());
   }
 };
@@ -355,7 +357,7 @@ class EagerArgmaxOpTransformer
     (*axis) = static_cast<paddle::experimental::Scalar>(perm[axes]);
   }
 
-  void SetOutTensorLayout(paddle::Tensor* out_tensor) {
+  void SetOutTensorLayout(paddle::Tensor* out_tensor) override {
     UpdateLayout(out_tensor, DesiredLayout());
   }
 };
@@ -370,11 +372,11 @@ class EagerFlattenOpTransformer
 
   // transpose from NHWC to NCHW
   paddle::Tensor TransInTensor(const std::string& in_name UNUSED,
-                               const paddle::Tensor& in) {
+                               const paddle::Tensor& in) override {
     return in;
   }
 
-  void SetOutTensorLayout(paddle::Tensor* out_tensor) {
+  void SetOutTensorLayout(paddle::Tensor* out_tensor) override {
     UpdateLayout(out_tensor, DefaultLayout());
   }
 };
@@ -396,13 +398,13 @@ class EagerConcatOpTransformer
     (*axis) = static_cast<paddle::experimental::Scalar>(perm[axes]);
   }
 
-  virtual std::vector<paddle::Tensor> TransInTensors(
+  std::vector<paddle::Tensor> TransInTensors(
       const std::string& in_name UNUSED,
-      const std::vector<paddle::Tensor>& in) {
+      const std::vector<paddle::Tensor>& in) override {
     return in;
   }
 
-  void SetOutTensorLayout(paddle::Tensor* out_tensor) {
+  void SetOutTensorLayout(paddle::Tensor* out_tensor) override {
     UpdateLayout(out_tensor, DesiredLayout());
   }
 };
diff --git a/paddle/fluid/framework/ir/inplace_op_var_pass.h b/paddle/fluid/framework/ir/inplace_op_var_pass.h
@@ -24,6 +24,7 @@ class Graph;
 
 class InplaceOpVarPass : public FusePassBase {
  protected:
+  using FusePassBase::ApplyImpl;
   void ApplyImpl(ir::Graph* graph) const override;
 
  private:
diff --git a/paddle/fluid/inference/analysis/passes/memory_optimize_pass.cc b/paddle/fluid/inference/analysis/passes/memory_optimize_pass.cc
@@ -66,9 +66,8 @@ void MemoryOptimizePass::CollectLifeCycle(
     auto reads = op_node->inputs;
     auto writes = op_node->outputs;
 
-    std::vector<Node*>
-    requires(reads.begin(), reads.end());
-    requires.insert(requires.end(), writes.begin(), writes.end());
+    std::vector<Node*> req(reads.begin(), reads.end());
+    req.insert(req.end(), writes.begin(), writes.end());
 
     // Disable reuse of feed variables.
     if (op_node->Name() == "feed") {
@@ -79,7 +78,7 @@ void MemoryOptimizePass::CollectLifeCycle(
       }
     } else {
       // Normal operators.
-      for (const Node* node : requires) {
+      for (const Node* node : req) {
         if (!node->Var()) continue;
         if (node->Var()->Persistable()) {
           // "Getting 'tensor_desc' is not supported by the fetch type
diff --git a/paddle/fluid/pir/dialect/distributed/ir/dist_attribute.cc b/paddle/fluid/pir/dialect/distributed/ir/dist_attribute.cc
@@ -137,7 +137,8 @@ OperationDistAttribute OperationDistAttribute::get(
   auto check_dist_attr = [=](pir::Attribute attr) {
     auto dist_attr = attr.dyn_cast<TensorDistAttribute>();
     auto ids = mesh.process_ids();
-    for (const auto& id : dist_attr.process_mesh_attr().process_ids()) {
+    const ProcessMeshAttribute& dist_mesh = dist_attr.process_mesh_attr();
+    for (const auto& id : dist_mesh.process_ids()) {
       PADDLE_ENFORCE_EQ(std::find(ids.begin(), ids.end(), id) != ids.end(),
                         true,
                         common::errors::PreconditionNotMet(
diff --git a/paddle/fluid/pir/dialect/distributed/ir/dist_type.cc b/paddle/fluid/pir/dialect/distributed/ir/dist_type.cc
@@ -43,7 +43,8 @@ common::DDim InferLocalDDim(const common::DDim& global_ddim,
   if (global_ddim.size() == -1 || global_ddim.size() == 0) {
     return global_ddim;
   }
-  auto& mesh_dim = dist_attr.process_mesh_attr().shape();
+  const ProcessMeshAttribute& mesh_attr = dist_attr.process_mesh_attr();
+  auto& mesh_dim = mesh_attr.shape();
   auto& dim_mapping = dist_attr.dims_mapping();
   PADDLE_ENFORCE_EQ(global_ddim.size(),
                     dim_mapping.size(),
diff --git a/paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/infer_sym_slice_utils.h b/paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/infer_sym_slice_utils.h
@@ -249,8 +249,9 @@ inline ShapeOrData SliceRawInferSymbolicShape(
                               ? GetDataDimExprs()
                               : GetShapeDimExprs();
   if (out_shape.data().has_value() && out_shape.shape().empty()) {  // 0D tensor
-    const auto &out_ddim =
-        out.type().dyn_cast<paddle::dialect::DenseTensorType>().dims();
+    const paddle::dialect::DenseTensorType &tensor_type =
+        out.type().dyn_cast<paddle::dialect::DenseTensorType>();
+    const auto &out_ddim = tensor_type.dims();
     if (out_ddim.size() == 1 && out_ddim[0] == 1) {  // value is 1D
       return symbol::ShapeOrDataDimExprs{symbol::TensorShapeOrDataDimExprs(
           std::vector<symbol::DimExpr>{1}, out_shape.data().value())};
diff --git a/paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/infer_sym_utils.cc b/paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/infer_sym_utils.cc
@@ -201,8 +201,9 @@ std::vector<symbol::DimExpr> GetSymShapeForInputValue(
     const std::string &input_name,
     const pir::Value &value,
     pir::InferSymbolicShapeContext *infer_context) {
-  const common::DDim &result_dims =
-      value.type().dyn_cast<pir::DenseTensorType>().dims();
+  const pir::DenseTensorType &value_type =
+      value.type().dyn_cast<pir::DenseTensorType>();
+  const common::DDim &result_dims = value_type.dims();
   const auto &predefined_dim_index_to_expr = [&]() {
     std::unordered_map<int, symbol::DimExpr> index_to_expr;
     if (infer_context->HasPredefinedDimExprForInputName(input_name)) {
diff --git a/paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/nullary_infer_sym.cc b/paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/nullary_infer_sym.cc
@@ -171,7 +171,9 @@ bool DataOpInferSymbolicShape(pir::Operation *op,
       details::GetSymShapeForInputValue(name, op->result(0), infer_context);
 
   auto IsNumelLEKMaxRank = [](pir::Value value) {
-    const auto &dims = value.type().dyn_cast<pir::DenseTensorType>().dims();
+    const pir::DenseTensorType &tensor_type =
+        value.type().dyn_cast<pir::DenseTensorType>();
+    const auto &dims = tensor_type.dims();
     if (dims.size() == 0) return true;
     if (dims.size() != 1) return false;
     if (dims[0] >= 1 && dims[0] <= ::common::DDim::kMaxRank) {
@@ -186,7 +188,9 @@ bool DataOpInferSymbolicShape(pir::Operation *op,
   };
 
   auto CreateSymForEachNumel = [&](pir::Value value) -> decltype(auto) {
-    const auto &dims = value.type().dyn_cast<pir::DenseTensorType>().dims();
+    const pir::DenseTensorType &tensor_type =
+        value.type().dyn_cast<pir::DenseTensorType>();
+    const auto &dims = tensor_type.dims();
     const int64_t numel = ::common::product(dims);
     std::vector<symbol::DimExpr> data;
     for (int64_t i = 0; i < numel; ++i) {
@@ -309,10 +313,9 @@ bool FullOpInferSymbolicShape(pir::Operation *op,
 
   const std::vector<symbol::DimExpr> shape = [&] {
     pir::Attribute attr_shape = attributes.at("shape");
-    const auto &shape_vec =
-        attr_shape.dyn_cast<paddle::dialect::IntArrayAttribute>()
-            .data()
-            .GetData();
+    const paddle::dialect::IntArrayAttribute &attr =
+        attr_shape.dyn_cast<paddle::dialect::IntArrayAttribute>();
+    const auto &shape_vec = attr.data().GetData();
     std::vector<symbol::DimExpr> shape(shape_vec.begin(), shape_vec.end());
     return shape;
   }();
diff --git a/paddle/fluid/pir/transforms/pd_op_to_kernel_pass.cc b/paddle/fluid/pir/transforms/pd_op_to_kernel_pass.cc
@@ -3322,7 +3322,8 @@ void ProcessBlock(
   auto inputs_by_data_op = GetInputsByDataOp(block);
   for (auto& [keyword, arg] : block->kwargs()) {
     auto new_arg = new_block->AddKwarg(keyword, arg.type());
-    for (auto& [name, attr] : arg.dyn_cast<pir::BlockArgument>().attributes()) {
+    const pir::BlockArgument& block_arg = arg.dyn_cast<pir::BlockArgument>();
+    for (auto& [name, attr] : block_arg.attributes()) {
       new_arg.set_attribute(name, attr);
     }
     if (auto dense_tensor_type = arg.type().dyn_cast<DenseTensorType>()) {
diff --git a/paddle/phi/api/profiler/trace_event.h b/paddle/phi/api/profiler/trace_event.h
@@ -14,6 +14,7 @@ limitations under the License. */
 
 #pragma once
 
+#include <cstdint>
 #include <map>
 #include <string>
 #include <vector>
diff --git a/paddle/phi/kernels/cpu/rnn_grad_kernel.cc b/paddle/phi/kernels/cpu/rnn_grad_kernel.cc
@@ -691,6 +691,7 @@ struct SingleGradLayer : GradLayer<T, GradCellType> {
   explicit SingleGradLayer(const GradCellType& cell)
       : GradLayer<T, GradCellType>(cell) {}
   ~SingleGradLayer() override = default;
+  using GradLayer<T, GradCellType>::operator();
   void operator()(const CPUContext& dev_ctx,
                   const DenseTensor* input,
                   const DenseTensor* output,
@@ -803,6 +804,7 @@ struct BidirGradLayer : GradLayer<T, GradCellType> {
   explicit BidirGradLayer(const GradCellType& cell)
       : GradLayer<T, GradCellType>(cell) {}
   ~BidirGradLayer() override = default;
+  using GradLayer<T, GradCellType>::operator();
   void operator()(const CPUContext& dev_ctx,
                   const DenseTensor* input,
                   const DenseTensor* output,
diff --git a/paddle/pir/include/core/parameter.h b/paddle/pir/include/core/parameter.h
@@ -16,6 +16,7 @@
 
 #include <cstring>
 
+#include "paddle/common/enforce.h"
 #include "paddle/pir/include/core/type.h"
 
 namespace pir {
@@ -25,6 +26,12 @@ namespace pir {
 class IR_API Parameter {
  public:
   Parameter(void* data, size_t size, pir::Type type) {
+    PADDLE_ENFORCE_EQ(
+        data == nullptr && size > 0,
+        false,
+        ::common::errors::InvalidArgument(
+            "[PIR] The data of parameter cannot be nullptr when size is: %d\n.",
+            size));
     data_ = malloc(size);
     memcpy(data_, data, size);
     size_ = size;
diff --git a/paddle/pir/src/core/region.cc b/paddle/pir/src/core/region.cc
@@ -57,7 +57,8 @@ void Region::CloneInto(Region &other, IrMapping &ir_mapping) const {
     for (const auto &arg : block.args()) {
       auto new_arg = new_block->AddArg(arg.type());
       ir_mapping.Add(arg, new_arg);
-      for (auto &attr : arg.dyn_cast<BlockArgument>().attributes()) {
+      const BlockArgument &block_arg = arg.dyn_cast<BlockArgument>();
+      for (auto &attr : block_arg.attributes()) {
         new_arg.set_attribute(attr.first, attr.second);
       }
     }
diff --git a/patches/rocksdb/include.patch b/patches/rocksdb/include.patch
diff --git a/patches/rocksdb/redundant_move.patch b/patches/rocksdb/redundant_move.patch

Original file line number	Diff line number	Diff line change
`@@ -204,15 +204,16 @@ class EagerHeavilyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`paddle::Tensor TransInTensor(const std::string& in_name,`
`207`		`- const paddle::Tensor& in) {`
	`207`	`+ const paddle::Tensor& in) override {`
`208`	`208`	`if (heavily_input_.count(in_name) != 0 && in.layout() != desired_layout_) {`
`209`	`209`	`auto out_tensor = EagerTraceTransposeOp(desired_layout_, in);`
`210`	`210`	`return out_tensor;`
`211`	`211`	`}`
`212`	`212`	`return in;`
`213`	`213`	`}`
`214`	`214`
`215`		`- void SetOutTensorLayout(paddle::Tensor* out_tensor) {`
	`215`	`+ using EagerLayoutTransformer::SetOutTensorLayout;`
	`216`	`+ void SetOutTensorLayout(paddle::Tensor* out_tensor) override {`
`216`	`217`	`UpdateLayout(out_tensor, desired_layout_);`
`217`	`218`	`}`
`218`	`219`
`@@ -222,7 +223,7 @@ class EagerHeavilyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {`
`222`	`223`	`}`
`223`	`224`	`}`
`224`	`225`
`225`		`- void SetOutTensorLayout(std::vector<paddle::Tensor>* out_tensor) {`
	`226`	`+ void SetOutTensorLayout(std::vector<paddle::Tensor>* out_tensor) override {`
`226`	`227`	`for (size_t i = 0; i < out_tensor->size(); i++) {`
`227`	`228`	`if ((*out_tensor)[i].layout() != desired_layout_) {`
`228`	`229`	`VLOG(4) << "Update out_tensor's layout from "`
`@@ -252,7 +253,7 @@ class EagerLightlyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {`
`252`	`253`
`253`	`254`	`// transpose from desired to default`
`254`	`255`	`paddle::Tensor TransInTensor(const std::string& in_name UNUSED,`
`255`		`- const paddle::Tensor& in) {`
	`256`	`+ const paddle::Tensor& in) override {`
`256`	`257`	`std::string input_layout = common::DataLayoutToString(in.layout());`
`257`	`258`	`auto default_layout = DefaultLayout();`
`258`	`259`	`if (final_layout_ == input_layout && in.shape().size() == 4) {`
`@@ -265,9 +266,9 @@ class EagerLightlyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {`
`265`	`266`	`return in;`
`266`	`267`	`}`
`267`	`268`
`268`		`- virtual std::vector<paddle::Tensor> TransInTensors(`
	`269`	`+ std::vector<paddle::Tensor> TransInTensors(`
`269`	`270`	`const std::string& in_name UNUSED,`
`270`		`- const std::vector<paddle::Tensor>& in) {`
	`271`	`+ const std::vector<paddle::Tensor>& in) override {`
`271`	`272`	`std::vector<paddle::Tensor> result;`
`272`	`273`	`auto desired_layout = DesiredLayout();`
`273`	`274`	`auto default_layout = DefaultLayout();`
`@@ -287,7 +288,8 @@ class EagerLightlyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {`
`287`	`288`	`return result;`
`288`	`289`	`}`
`289`	`290`
`290`		`- void SetOutTensorLayout(paddle::Tensor* out_tensor) {`
	`291`	`+ using EagerLayoutTransformer::SetOutTensorLayout;`
	`292`	`+ void SetOutTensorLayout(paddle::Tensor* out_tensor) override {`
`291`	`293`	`UpdateLayout(out_tensor, DefaultLayout());`
`292`	`294`	`}`
`293`	`295`
`@@ -297,7 +299,7 @@ class EagerLightlyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {`
`297`	`299`	`}`
`298`	`300`	`}`
`299`	`301`
`300`		`- void SetOutTensorLayout(std::vector<paddle::Tensor>* out_tensor) {`
	`302`	`+ void SetOutTensorLayout(std::vector<paddle::Tensor>* out_tensor) override {`
`301`	`303`	`auto default_layout = DefaultLayout();`
`302`	`304`	`for (size_t i = 0; i < out_tensor->size(); i++) {`
`303`	`305`	`phi::DenseTensorUtils::GetMutableMeta(`
`@@ -330,11 +332,11 @@ class EagerTransposeOpTransformer`
`330`	`332`	`}`
`331`	`333`
`332`	`334`	`paddle::Tensor TransInTensor(const std::string& in_name UNUSED,`
`333`		`- const paddle::Tensor& in) {`
	`335`	`+ const paddle::Tensor& in) override {`
`334`	`336`	`return in;`
`335`	`337`	`}`
`336`	`338`
`337`		`- void SetOutTensorLayout(paddle::Tensor* out_tensor) {`
	`339`	`+ void SetOutTensorLayout(paddle::Tensor* out_tensor) override {`
`338`	`340`	`UpdateLayout(out_tensor, DefaultLayout());`
`339`	`341`	`}`
`340`	`342`	`};`
`@@ -355,7 +357,7 @@ class EagerArgmaxOpTransformer`
`355`	`357`	`(*axis) = static_cast<paddle::experimental::Scalar>(perm[axes]);`
`356`	`358`	`}`
`357`	`359`
`358`		`- void SetOutTensorLayout(paddle::Tensor* out_tensor) {`
	`360`	`+ void SetOutTensorLayout(paddle::Tensor* out_tensor) override {`
`359`	`361`	`UpdateLayout(out_tensor, DesiredLayout());`
`360`	`362`	`}`
`361`	`363`	`};`
`@@ -370,11 +372,11 @@ class EagerFlattenOpTransformer`
`370`	`372`
`371`	`373`	`// transpose from NHWC to NCHW`
`372`	`374`	`paddle::Tensor TransInTensor(const std::string& in_name UNUSED,`
`373`		`- const paddle::Tensor& in) {`
	`375`	`+ const paddle::Tensor& in) override {`
`374`	`376`	`return in;`
`375`	`377`	`}`
`376`	`378`
`377`		`- void SetOutTensorLayout(paddle::Tensor* out_tensor) {`
	`379`	`+ void SetOutTensorLayout(paddle::Tensor* out_tensor) override {`
`378`	`380`	`UpdateLayout(out_tensor, DefaultLayout());`
`379`	`381`	`}`
`380`	`382`	`};`
`@@ -396,13 +398,13 @@ class EagerConcatOpTransformer`
`396`	`398`	`(*axis) = static_cast<paddle::experimental::Scalar>(perm[axes]);`
`397`	`399`	`}`
`398`	`400`
`399`		`- virtual std::vector<paddle::Tensor> TransInTensors(`
	`401`	`+ std::vector<paddle::Tensor> TransInTensors(`
`400`	`402`	`const std::string& in_name UNUSED,`
`401`		`- const std::vector<paddle::Tensor>& in) {`
	`403`	`+ const std::vector<paddle::Tensor>& in) override {`
`402`	`404`	`return in;`
`403`	`405`	`}`
`404`	`406`
`405`		`- void SetOutTensorLayout(paddle::Tensor* out_tensor) {`
	`407`	`+ void SetOutTensorLayout(paddle::Tensor* out_tensor) override {`
`406`	`408`	`UpdateLayout(out_tensor, DesiredLayout());`
`407`	`409`	`}`
`408`	`410`	`};`