[CINN] Reconstruct shape_analysis (PaddlePaddle#63790)

* reconstruct shape_analysis * fix input value shape infer * fix merge bugs * fix concat and gather op InferSymbolicShape * fix merge bug * fix value_to_shape_or_data hash error and add some checks * fix set shape for null value * fix group op lazy infer * add IsStaticShape check * fix merge bug * support static dim check and set for VectorType * change auto to detail type
yinfan98 · May 7, 2024 · e7120fb · e7120fb
1 parent a1c6e5c
commit e7120fb
Show file tree

Hide file tree

Showing 43 changed files with 1,053 additions and 857 deletions.
diff --git a/paddle/cinn/hlir/dialect/operator/ir/manual_op.cc b/paddle/cinn/hlir/dialect/operator/ir/manual_op.cc
@@ -116,14 +116,14 @@ void GroupOp::Print(pir::IrPrinter& printer) {
 }
 
 bool GroupOp::InferSymbolicShape(
-    ::pir::ShapeConstraintIRAnalysis* shape_analysis) {
-  ::pir::InferSymExprForBlock(*block(), shape_analysis);
+    ::pir::InferSymbolicShapeContext* infer_context) {
+  ::pir::InferSymExprForBlock(*block(), infer_context);
 
   for (uint32_t rst_idx = 0; rst_idx < num_results(); rst_idx++) {
     auto inner_yield_value = block()->back().operand_source(rst_idx);
     const auto& shape =
-        shape_analysis->GetShapeOrDataForValue(inner_yield_value);
-    shape_analysis->SetShapeOrDataForValue(result(rst_idx), shape);
+        infer_context->GetShapeOrDataForValue(inner_yield_value);
+    infer_context->SetShapeOrDataForValue(result(rst_idx), shape);
   }
 
   if (VLOG_IS_ON(4)) {
@@ -204,16 +204,16 @@ void YieldStoreOp::Build(pir::Builder& builder,
 void YieldStoreOp::VerifySig() {}
 
 bool YieldStoreOp::InferSymbolicShape(
-    pir::ShapeConstraintIRAnalysis* shape_analysis) {
-  shape_analysis->SetShapeOrDataForValue(
-      result(0), shape_analysis->GetShapeOrDataForValue(operand_source(0)));
+    pir::InferSymbolicShapeContext* infer_context) {
+  infer_context->SetShapeOrDataForValue(
+      result(0), infer_context->GetShapeOrDataForValue(operand_source(0)));
   return true;
 }
 
 bool ConcatOp::InferSymbolicShape(
-    pir::ShapeConstraintIRAnalysis* shape_analysis) {
+    pir::InferSymbolicShapeContext* infer_context) {
   VLOG(4) << "Infer symbolic shape for cinn_op.concat";
-  return ConcatOpInferSymbolicShape(this->operation(), shape_analysis);
+  return ConcatOpInferSymbolicShape(this->operation(), infer_context);
 }
 
 void ConcatOp::Build(pir::Builder& builder,             // NOLINT
@@ -476,7 +476,7 @@ GenerateShapeOp::ConvertAttributeToSymbolBindings(
 }
 
 bool GenerateShapeOp::InferSymbolicShape(
-    pir::ShapeConstraintIRAnalysis* shape_analysis) {
+    pir::InferSymbolicShapeContext* infer_context) {
   const auto attr_dim_exprs = [&] {
     std::vector<symbol::DimExpr> dim_exprs{};
     pir::Attribute dim_expr_attr = this->attributes().at("output_dim_exprs");
@@ -505,7 +505,7 @@ bool GenerateShapeOp::InferSymbolicShape(
   }();
   auto DimExprs4InputDim =
       [&](int input_idx) -> const symbol::ShapeOrDataDimExprs& {
-    return shape_analysis->GetShapeOrDataForValue(
+    return infer_context->GetShapeOrDataForValue(
         this->operand_source(input_idx));
   };
   auto DimExprs4SymbolName =
@@ -527,7 +527,7 @@ bool GenerateShapeOp::InferSymbolicShape(
   symbol::ShapeOrDataDimExprs shape_or_data_dim_exprs{
       symbol::TensorShapeOrDataDimExprs(shape, substituted_dim_exprs)};
 
-  shape_analysis->SetShapeOrDataForValue(this->out(), shape_or_data_dim_exprs);
+  infer_context->SetShapeOrDataForValue(this->out(), shape_or_data_dim_exprs);
 
   return true;
 }

diff --git a/paddle/cinn/hlir/dialect/operator/ir/manual_op.h b/paddle/cinn/hlir/dialect/operator/ir/manual_op.h
@@ -53,7 +53,7 @@ class IR_API GroupOp
   pir::Block *block() const;
   std::vector<pir::Operation *> GetOperators() const;
 
-  bool InferSymbolicShape(pir::ShapeConstraintIRAnalysis *shape_analysis);
+  bool InferSymbolicShape(pir::InferSymbolicShapeContext *infer_context);
 
   void VerifySig();
   void Print(pir::IrPrinter &printer);  // NOLINT
@@ -102,7 +102,7 @@ class IR_API YieldStoreOp
 
   void VerifySig();
 
-  bool InferSymbolicShape(pir::ShapeConstraintIRAnalysis *shape_analysis);
+  bool InferSymbolicShape(pir::InferSymbolicShapeContext *infer_context);
 };
 
 class IR_API ConcatOp
@@ -123,7 +123,7 @@ class IR_API ConcatOp
 
   void VerifySig() const {}
 
-  bool InferSymbolicShape(pir::ShapeConstraintIRAnalysis *shape_analysis);
+  bool InferSymbolicShape(pir::InferSymbolicShapeContext *infer_context);
 };
 
 class IR_API SplitOp : public pir::Op<SplitOp> {
@@ -177,7 +177,7 @@ class IR_API GenerateShapeOp
 
   pir::Value out() { return result(0); }
 
-  bool InferSymbolicShape(pir::ShapeConstraintIRAnalysis *shape_analysis);
+  bool InferSymbolicShape(pir::InferSymbolicShapeContext *infer_context);
 
   static pir::Attribute ConvertSymbolBindingsToAttribute(
       pir::Builder &builder, const SymbolBindings &symbol_bindings);  // NOLINT

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
@@ -45,11 +45,9 @@ class AddYieldStoreInFusionOpPattern
       auto orignal_base = op->operand_source(i);
       op->operand(i).set_source(store_op.result(0));
 
-      if (shape_analysis.HasShapeOrDataForValue(orignal_base)) {
-        shape_analysis.SetShapeOrDataForValue(
-            store_op.result(0),
-            shape_analysis.GetShapeOrDataForValue(orignal_base));
-      }
+      shape_analysis.SetShapeOrDataForValue(
+          store_op.result(0),
+          shape_analysis.GetShapeOrDataForValue(orignal_base));
     }
 
     return true;

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/check_infer_symbolic_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/check_infer_symbolic_pass.cc
@@ -144,7 +144,10 @@ class BlockDimExprsAsserter {
       PADDLE_THROW(phi::errors::Unimplemented(
           op->name() + " DOES NOT have InferSymbolicShapeInterface!"));
     } else {
-      bool infer_result = interface.InferSymbolicShape(shape_analysis.get());
+      // TODO(Hongqing-work): delete this after the shape analysis reconstruct
+      // is done.
+      bool infer_result = interface.InferSymbolicShape(
+          shape_analysis->GetInferSymbolicShapeContext());
       PADDLE_ENFORCE_EQ(infer_result,
                         true,
                         ::common::errors::PreconditionNotMet(

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
@@ -182,11 +182,9 @@ ::pir::GroupOpsVec CloneOps(
         pir::ShapeAnalysisManager::Instance().Get(op->GetParentProgram());
 
     for (size_t i = 0; i < op->num_results(); ++i) {
-      if (shape_analysis.HasShapeOrDataForValue(op->result(i))) {
-        shape_analysis.SetShapeOrDataForValue(
-            new_op->result(i),
-            shape_analysis.GetShapeOrDataForValue(op->result(i)));
-      }
+      shape_analysis.SetShapeOrDataForValue(
+          new_op->result(i),
+          shape_analysis.GetShapeOrDataForValue(op->result(i)));
     }
 
     vec_new_op_list.push_back(new_op);
@@ -357,11 +355,9 @@ class CinnGroupClusterPattern
       // update ir mapping
       for (size_t i = 0; i < output_values.size(); ++i) {
         ir_mapping.Add(output_values[i], new_group_op->result(i));
-        if (shape_analysis.HasShapeOrDataForValue(output_values[i])) {
-          shape_analysis.SetShapeOrDataForValue(
-              new_group_op->result(i),
-              shape_analysis.GetShapeOrDataForValue(output_values[i]));
-        }
+        shape_analysis.SetShapeOrDataForValue(
+            new_group_op->result(i),
+            shape_analysis.GetShapeOrDataForValue(output_values[i]));
       }
       for (size_t i = 0; i < output_values.size(); ++i) {
         auto find_it = all_output_values.find(output_values[i]);

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/dynamic_reshape_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/dynamic_reshape_pass.cc
@@ -33,18 +33,16 @@ bool ReplaceOpWithReshapeOp(pir::Operation* op,
     std::vector<int> shape = phi::vectorize<int>(
         output.type().dyn_cast<pir::DenseTensorType>().dims());
 
-    if (shape_analysis->HasShapeOrDataForValue(op->result(0))) {
-      const auto& shape_info =
-          shape_analysis->GetShapeOrDataForValue(op->result(0)).shape();
-      int temp_dim = -1;
-
-      for (size_t i = 0; i < shape_info.size(); ++i) {
-        if (shape_info[i].isa<int64_t>()) {
-          shape[i] = shape_info[i].Get<int64_t>();
-        } else {
-          shape[i] = temp_dim;
-          temp_dim = 1;
-        }
+    const auto& shape_info =
+        shape_analysis->GetShapeOrDataForValue(op->result(0)).shape();
+    int temp_dim = -1;
+
+    for (size_t i = 0; i < shape_info.size(); ++i) {
+      if (shape_info[i].isa<int64_t>()) {
+        shape[i] = shape_info[i].Get<int64_t>();
+      } else {
+        shape[i] = temp_dim;
+        temp_dim = 1;
       }
     }
     return shape;

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/fold_manipulation_ops_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/fold_manipulation_ops_pass.cc
@@ -53,15 +53,11 @@ bool RemoveOp(pir::Operation* op, pir::PatternRewriter* rewriter) {
     if (has_dynamic_shape) {
       auto& shape_analysis =
           pir::ShapeAnalysisManager::Instance().Get(op->GetParentProgram());
-      if (shape_analysis.HasShapeOrDataForValue(input) &&
-          shape_analysis.HasShapeOrDataForValue(output)) {
-        auto input_sym_shape =
-            GetExprVecFromShape(shape_analysis.GetShapeOrDataForValue(input));
-        auto output_sym_shape =
-            GetExprVecFromShape(shape_analysis.GetShapeOrDataForValue(output));
-        return input_sym_shape == output_sym_shape;
-      }
-      return false;
+      auto input_sym_shape =
+          GetExprVecFromShape(shape_analysis.GetShapeOrDataForValue(input));
+      auto output_sym_shape =
+          GetExprVecFromShape(shape_analysis.GetShapeOrDataForValue(output));
+      return input_sym_shape == output_sym_shape;
     }
     return GetDims(input) == GetDims(output);
   };

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/fuse_shape_ops_into_generate_shape_op_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/fuse_shape_ops_into_generate_shape_op_pass.cc
@@ -214,7 +214,10 @@ void InferSymbolicShapeForSubgraph(
     auto infer_symbolic_shape_interface =
         op->dyn_cast<paddle::dialect::InferSymbolicShapeInterface>();
     if (infer_symbolic_shape_interface) {
-      infer_symbolic_shape_interface.InferSymbolicShape(shape_analysis);
+      // TODO(Hongqing-work): delete this after the shape analysis reconstruct
+      // is done.
+      infer_symbolic_shape_interface.InferSymbolicShape(
+          shape_analysis->GetInferSymbolicShapeContext());
     } else {
       PADDLE_THROW(phi::errors::Unimplemented(
           op->name() + " DOES NOT have InferSymbolicShapeInterface!"));
@@ -348,7 +351,6 @@ bool ReplaceShapeOpsToGenerateShape(
   auto ShapeOrDataDimExprs4Value =
       [&shape_analysis](
           pir::Value value) -> const symbol::ShapeOrDataDimExprs& {
-    CHECK(shape_analysis->HasShapeOrDataForValue(value));
     return shape_analysis->GetShapeOrDataForValue(value);
   };
   std::optional<pir::Value> opt_generated_shape =

diff --git a/...e/cinn/hlir/dialect/operator/transforms/group_merge/convert_dynamic_to_static_dim_pass.cc b/...e/cinn/hlir/dialect/operator/transforms/group_merge/convert_dynamic_to_static_dim_pass.cc
@@ -104,9 +104,6 @@ class DynamicToStaticConverter {
   }
 
   bool Convert() {
-    if (!IsSymbolFullyInfered()) {
-      return false;
-    }
     bool updated = false;
     VisitEachValue(fusion_op_, [&](pir::Value value) {
       updated |= UpdateValueShape(value);
@@ -116,16 +113,6 @@ class DynamicToStaticConverter {
   }
 
  private:
-  bool IsSymbolFullyInfered() {
-    bool is_infered = true;
-    VisitEachValue(fusion_op_, [&](pir::Value value) {
-      if (!shape_analysis_->HasShapeOrDataForValue(value)) {
-        is_infered = false;
-      }
-    });
-    return is_infered;
-  }
-
   DimExpr4SymbolName InitDimExpr4SymbolName() {
     const auto* map = GetGlobalDynamicToStaticDimMap();
     CHECK(map->has_value());
@@ -178,7 +165,6 @@ class DynamicToStaticConverter {
 
   bool UpdateValueShape(pir::Value value) {
     bool update = false;
-    CHECK(shape_analysis_->HasShapeOrDataForValue(value));
     const auto& origin_shape = GetOriginValueShape(value);
     const auto& target_shape = GetTargetValueShape(value);
     PADDLE_ENFORCE_EQ(

diff --git a/...e/cinn/hlir/dialect/operator/transforms/group_merge/convert_static_dim_to_dynamic_pass.cc b/...e/cinn/hlir/dialect/operator/transforms/group_merge/convert_static_dim_to_dynamic_pass.cc
@@ -150,7 +150,6 @@ struct StaticDimToDynamicConverter {
         &pir::ShapeAnalysisManager::Instance().Get(
             this->fusion_op->GetParentProgram());
     ForEachValue([&](pir::Value value) {
-      CHECK(shape_analysis->HasShapeOrDataForValue(value));
       const auto& origin_shape = GetOriginValueShape(value);
       const auto& target_shape = GetTargetValueShape(
           shape_analysis->GetShapeOrDataForValue(value).shape());
@@ -369,26 +368,8 @@ struct StaticDimToDynamicConverter {
       pir::Value value,
       int64_t constant,
       const std::string& symbol) {
-    if (shape_analysis->HasShapeOrDataForValue(value)) {
-      const auto& old = shape_analysis->GetShapeOrDataForValue(value).shape();
-      return ConvertShapeOrDataDimExprs(Converter, old, constant, symbol);
-    } else {
-      auto& dims = value.type().dyn_cast<::pir::DenseTensorType>().dims();
-      const auto& int_dims = ::common::vectorize<int>(dims);
-      std::vector<symbol::DimExpr> old{};
-      for (int dim : int_dims) {
-        old.emplace_back(static_cast<std::int64_t>(dim));
-      }
-      const auto& opt_exprs =
-          ConvertShapeOrDataDimExprs(Converter, old, constant, symbol);
-      if (opt_exprs.has_value()) {
-        return opt_exprs.value();
-      } else {
-        return symbol::ShapeOrDataDimExprs{
-            symbol::TensorShapeOrDataDimExprs(old)};
-      }
-    }
-    PADDLE_THROW(phi::errors::Fatal("Dead code"));
+    const auto& old = shape_analysis->GetShapeOrDataForValue(value).shape();
+    return ConvertShapeOrDataDimExprs(Converter, old, constant, symbol);
   }
 
   template <typename ConverterT>

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/group_merge/simplify_dim_expr_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/group_merge/simplify_dim_expr_pass.cc
@@ -101,20 +101,14 @@ void SimplifyDimExpr(pir::Operation* module_op) {
 
   VisitEachOp(module_op, [&](pir::Operation& op) {
     VisitEachValue(op, [&](pir::Value value) {
-      if (!shape_analysis->HasShapeOrDataForValue(value)) {
-        VLOG(4) << "SimplifyDimExpr: shape_analysis can't find ShapeOrData for "
-                   "value of the op:"
-                << op.name();
-      } else {
-        const symbol::ShapeOrDataDimExprs& shape_or_data =
-            shape_analysis->GetShapeOrDataForValue(value);
-        VLOG(8) << op.name() << "     origin_shape_or_data: " << shape_or_data;
-        symbol::ShapeOrDataDimExprs simplified_shape_or_data =
-            SimplifyShapeOrData(shape_or_data);
-        VLOG(8) << op.name()
-                << " simplified_shape_or_data: " << simplified_shape_or_data;
-        shape_analysis->SetShapeOrDataForValue(value, simplified_shape_or_data);
-      }
+      const symbol::ShapeOrDataDimExprs& shape_or_data =
+          shape_analysis->GetShapeOrDataForValue(value);
+      VLOG(8) << op.name() << "     origin_shape_or_data: " << shape_or_data;
+      symbol::ShapeOrDataDimExprs simplified_shape_or_data =
+          SimplifyShapeOrData(shape_or_data);
+      VLOG(8) << op.name()
+              << " simplified_shape_or_data: " << simplified_shape_or_data;
+      shape_analysis->SetShapeOrDataForValue(value, simplified_shape_or_data);
     });
     if (op.num_results() > 0) {
       pir::shape::SetShapeAttrForOp(

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/group_merge/single_op_fallback_to_phi.cc b/paddle/cinn/hlir/dialect/operator/transforms/group_merge/single_op_fallback_to_phi.cc
@@ -64,15 +64,9 @@ class FusionOpPattern : public pir::OpRewritePattern<cinn::dialect::FusionOp> {
     for (size_t i = 0; i < fusion_op.num_results(); ++i) {
       rewriter.ReplaceAllUsesWith(fusion_op.result(i),
                                   paddle_op.value()->result(i));
-      if (shape_analysis.HasShapeOrDataForValue(fusion_op.result(i))) {
-        shape_analysis.SetShapeOrDataForValue(
-            paddle_op.value()->result(i),
-            shape_analysis.GetShapeOrDataForValue(fusion_op.result(i)));
-      } else {
-        LOG(WARNING) << "No shape_data for "
-                     << fusion_op.result(i).defining_op()->name() << "_result_"
-                     << i << ", this may cause error in dynamic shape";
-      }
+      shape_analysis.SetShapeOrDataForValue(
+          paddle_op.value()->result(i),
+          shape_analysis.GetShapeOrDataForValue(fusion_op.result(i)));
     }
 
     rewriter.EraseOp(fusion_op);

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/insert_broadcast_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/insert_broadcast_pass.cc
@@ -46,7 +46,10 @@ pir::Value GetOutputDimTensor(pir::PatternRewriter* rewriter,
   for (auto* op : std::vector{x_shape_op, y_shape_op, shape_broadcast_op}) {
     auto infer_symbolic_shape_interface =
         op->dyn_cast<paddle::dialect::InferSymbolicShapeInterface>();
-    infer_symbolic_shape_interface.InferSymbolicShape(shape_analysis);
+    // TODO(Hongqing-work): delete this after the shape analysis reconstruct is
+    // done.
+    infer_symbolic_shape_interface.InferSymbolicShape(
+        shape_analysis->GetInferSymbolicShapeContext());
   }
   return shape_broadcast_op->result(0);
 }