PaddlePaddle
diff --git a/‎paddle/fluid/pir/transforms/pd_op_to_kernel_pass.cc
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions b/‎paddle/fluid/pir/transforms/pd_op_to_kernel_pass.cc
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions
diff --git a/‎paddle/pir/core/op_base.h
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎paddle/pir/core/op_base.h
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎paddle/pir/dialect/control_flow/ir/cf_dialect.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/pir/dialect/control_flow/ir/cf_dialect.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎paddle/pir/dialect/control_flow/ir/cf_dialect.h
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎paddle/pir/dialect/control_flow/ir/cf_dialect.h
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎paddle/pir/dialect/control_flow/ir/cf_interface.cc
Copy file name to clipboard
+34Lines changed: 34 additions & 0 deletions b/‎paddle/pir/dialect/control_flow/ir/cf_interface.cc
Copy file name to clipboard
+34Lines changed: 34 additions & 0 deletions
diff --git a/‎paddle/pir/dialect/control_flow/ir/cf_interface.h
Copy file name to clipboard
+88Lines changed: 88 additions & 0 deletions b/‎paddle/pir/dialect/control_flow/ir/cf_interface.h
Copy file name to clipboard
+88Lines changed: 88 additions & 0 deletions
@@ -78,9 +78,9 @@ const std::unordered_set<std::string> SpecialLowerOps = {
     pir::YieldOp::name(),
     IfOp::name(),
     WhileOp::name(),
-    pir::CreateStackOp::name(),
-    pir::PushBackOp::name(),
-    pir::PopBackOp::name(),
+    pir::StackCreateOp::name(),
+    pir::TuplePushOp::name(),
+    pir::TuplePopOp::name(),
     "cinn_runtime.jit_kernel"};
 
 static bool NeedFallBackCpu(const pir::Operation* op,
@@ -1038,8 +1038,8 @@ void HandleForSpecialOp(
     }
   }
 
-  if (op_item->isa<::pir::CreateStackOp>() ||
-      op_item->isa<::pir::PushBackOp>()) {
+  if (op_item->isa<::pir::StackCreateOp>() ||
+      op_item->isa<::pir::TuplePushOp>()) {
     for (size_t i = 0; i < op_item->num_operands(); ++i) {
       auto cur_in = op_item->operand_source(i);
       if (!cur_in) {
@@ -1055,15 +1055,15 @@ void HandleForSpecialOp(
     }
   }
 
-  if (op_item->isa<::pir::PopBackOp>()) {
+  if (op_item->isa<::pir::TuplePopOp>()) {
     for (size_t i = 0; i < op_item->num_operands(); ++i) {
       auto cur_in = op_item->operand_source(i);
       auto new_in = GetNewInput(
           cur_in, *map_value_pair, static_cast<int>(i), op_item->name());
       vec_inputs.push_back(new_in);
     }
 
-    auto pop_back_op = op_item->dyn_cast<::pir::PopBackOp>();
+    auto pop_back_op = op_item->dyn_cast<::pir::TuplePopOp>();
     for (size_t i = 0; i < op_item->num_results(); ++i) {
       auto cur_inlet_element = pop_back_op.inlet_element(i);
       PADDLE_ENFORCE_EQ(map_value_pair->count(cur_inlet_element),
 
@@ -70,7 +70,7 @@ class IR_API OpBase {
 
   void VerifyRegion() {}
 
- private:
+ protected:
   Operation *operation_;  // Not owned
 };
 
 
@@ -19,7 +19,7 @@
 namespace pir {
 void ControlFlowDialect::initialize() {
   RegisterTypes<StackType, InletType, OutletType>();
-  RegisterOps<YieldOp, CreateStackOp, PushBackOp, PopBackOp, HasElementsOp>();
+  RegisterOps<YieldOp, StackCreateOp, TuplePushOp, TuplePopOp, HasElementsOp>();
 }
 
 void ControlFlowDialect::PrintType(pir::Type type, std::ostream &os) const {
@@ -38,7 +38,7 @@ void ControlFlowDialect::PrintType(pir::Type type, std::ostream &os) const {
 
 void ControlFlowDialect::PrintOperation(pir::Operation *op,
                                         pir::IrPrinter &printer) const {
-  if (auto create_op = op->dyn_cast<CreateStackOp>()) {
+  if (auto create_op = op->dyn_cast<StackCreateOp>()) {
     create_op.Print(printer);
   } else {
     printer.PrintGeneralOperation(op);
 
@@ -24,9 +24,9 @@ class ControlFlowDialect : public Dialect {
     initialize();
   }
   static const char *name() { return "cf"; }
-  void PrintType(pir::Type type, std::ostream &os) const override;
-  void PrintOperation(pir::Operation *op,
-                      pir::IrPrinter &printer) const override;  // NOLINT
+  void PrintType(Type type, std::ostream &os) const override;
+  void PrintOperation(Operation *op,
+                      IrPrinter &printer) const override;  // NOLINT
  private:
   void initialize();
 };
 
@@ -0,0 +1,34 @@
+// 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/pir/dialect/control_flow/ir/cf_interface.h"
+#include "paddle/pir/dialect/control_flow/ir/cf_op.h"
+
+namespace pir {
+TuplePushOp ContainerOpInterface::tuple_push_op() {
+  auto value = inlet();
+  IR_ENFORCE(value.HasOneUse(),
+             "The inlet value of container op can only be used once.");
+  return value.first_use().owner()->dyn_cast<TuplePushOp>();
+}
+TuplePopOp ContainerOpInterface::tuple_pop_op() {
+  auto value = outlet();
+  IR_ENFORCE(value.HasOneUse(),
+             "The outlet value of container op can only be used once.");
+  return value.first_use().owner()->dyn_cast<TuplePopOp>();
+}
+
+}  // namespace pir
+
+IR_DEFINE_EXPLICIT_TYPE_ID(pir::ContainerOpInterface)
@@ -0,0 +1,88 @@
+// 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/pir/core/op_base.h"
+
+namespace pir {
+
+class TuplePushOp;
+class TuplePopOp;
+///
+/// \brief This interface marks the op can create a container.
+///
+class ContainerOpInterface : public OpInterfaceBase<ContainerOpInterface> {
+ public:
+  struct Concept {
+    Value (*container_)(Operation* op);
+    Value (*inlet_)(Operation* op);
+    Value (*outlet_)(Operation* op);
+    size_t (*tuple_size_)(Operation* op);
+    Value (*inlet_element_)(Operation* op, size_t index);
+    Value (*outlet_element_)(Operation* op, size_t index);
+  };
+
+  template <class ConcreteOp>
+  struct Model : public Concept {
+    Model()
+        : Concept{container,
+                  inlet,
+                  outlet,
+                  tuple_size,
+                  inlet_element,
+                  inlet_element} {}
+    static Value container(Operation* op) {
+      return op->dyn_cast<ConcreteOp>().container();
+    }
+    static Value inlet(Operation* op) {
+      return op->dyn_cast<ConcreteOp>().inlet();
+    }
+    static Value outlet(Operation* op) {
+      return op->dyn_cast<ConcreteOp>().outlet();
+    }
+    static size_t tuple_size(Operation* op) {
+      return op->dyn_cast<ConcreteOp>().tuple_size();
+    }
+    static Value inlet_element(Operation* op, size_t index) {
+      return op->dyn_cast<ConcreteOp>().container();
+    }
+    static Value outlet_element(Operation* op, size_t index) {
+      return op->dyn_cast<ConcreteOp>().container();
+    }
+  };
+
+  Value container() { return impl_->container_(operation()); }
+  Value inlet() { return impl_->inlet_(operation()); }
+  Value outlet() { return impl_->outlet_(operation()); }
+  size_t tuple_size() { return impl_->tuple_size_(operation()); }
+  Value inlet_element(size_t index) {
+    return impl_->inlet_element_(operation(), index);
+  }
+  Value outlet_element(size_t index) {
+    return impl_->outlet_element_(operation(), index);
+  }
+
+  TuplePushOp tuple_push_op();
+  TuplePopOp tuple_pop_op();
+  /// Constructor
+  ContainerOpInterface(pir::Operation* op, Concept* impl)
+      : OpInterfaceBase<ContainerOpInterface>(op), impl_(impl) {}
+
+ private:
+  Concept* impl_;
+};
+}  // namespace pir
+
+IR_EXPORT_DECLARE_EXPLICIT_TYPE_ID(pir::ContainerOpInterface)