[NewIR]Refine IrPrinter and basic Concept Interface for const Object (#55209)

Aurelius84 · web-flow · commit 4fa3e149fec2 · 2023-07-11T09:12:02.000+08:00
* [NewIR]Refine IrPrinter and basic Concept Interface for const Object
diff --git a/paddle/fluid/pybind/ir.cc b/paddle/fluid/pybind/ir.cc
@@ -37,7 +37,12 @@ namespace pybind {
 void BindProgram(py::module *m) {
   py::class_<Program> program(*m, "Program");
   program.def("parameters_num", &Program::parameters_num)
-      .def("block", &Program::block, return_value_policy::reference)
+      .def("block",
+           py::overload_cast<>(&Program::block),
+           return_value_policy::reference)
+      .def("block",
+           py::overload_cast<>(&Program::block, py::const_),
+           return_value_policy::reference)
       .def("print", [](Program &self) {
         std::ostringstream print_stream;
         self.Print(print_stream);
diff --git a/paddle/ir/core/builtin_op.cc b/paddle/ir/core/builtin_op.cc
@@ -52,7 +52,7 @@ void ModuleOp::Destroy() {
   }
 }
 
-void ModuleOp::Verify() {
+void ModuleOp::Verify() const {
   VLOG(4) << "Verifying inputs, outputs and attributes for: ModuleOp.";
   // Verify inputs:
   IR_ENFORCE(num_operands() == 0u, "The size of inputs must be equal to 0.");
@@ -79,7 +79,7 @@ void GetParameterOp::Build(Builder &builder,
   argument.output_types.emplace_back(type);
 }
 
-void GetParameterOp::Verify() {
+void GetParameterOp::Verify() const {
   VLOG(4) << "Verifying inputs, outputs and attributes for: GetParameterOp.";
   // Verify inputs:
   IR_ENFORCE(num_operands() == 0u, "The size of inputs must be equal to 0.");
@@ -105,7 +105,7 @@ void SetParameterOp::Build(Builder &builder,             // NOLINT
   argument.AddAttribute(attributes_name[0],
                         ir::StrAttribute::get(builder.ir_context(), name));
 }
-void SetParameterOp::Verify() {
+void SetParameterOp::Verify() const {
   VLOG(4) << "Verifying inputs, outputs and attributes for: SetParameterOp.";
   // Verify inputs:
   IR_ENFORCE(num_operands() == 1, "The size of outputs must be equal to 1.");
@@ -132,7 +132,7 @@ void CombineOp::Build(Builder &builder,
       ir::VectorType::get(builder.ir_context(), inputs_type));
 }
 
-void CombineOp::Verify() {
+void CombineOp::Verify() const {
   // outputs.size() == 1
   IR_ENFORCE(num_results() == 1u, "The size of outputs must be equal to 1.");
 
@@ -162,7 +162,7 @@ void CombineOp::Verify() {
 }
 
 const char *SliceOp::attributes_name[attributes_num] = {"index"};
-void SliceOp::Verify() {
+void SliceOp::Verify() const {
   // inputs.size() == 1
   auto input_size = num_operands();
   IR_ENFORCE(
@@ -217,13 +217,13 @@ void ConstantOp::Build(Builder &builder,
   argument.output_types.push_back(output_type);
 }
 
-void ConstantOp::Verify() {
+void ConstantOp::Verify() const {
   IR_ENFORCE(num_operands() == 0, "The size of inputs must be equal to 0.");
   IR_ENFORCE(num_results() == 1, "The size of outputs must be equal to 1.");
   IR_ENFORCE(attributes().count("value") > 0, "must has value attribute");
 }
 
-Attribute ConstantOp::value() { return attributes().at("value"); }
+Attribute ConstantOp::value() const { return attributes().at("value"); }
 
 }  // namespace ir
 
diff --git a/paddle/ir/core/builtin_op.h b/paddle/ir/core/builtin_op.h
@@ -30,7 +30,7 @@ class IR_API ModuleOp : public ir::Op<ModuleOp> {
   static const char *name() { return "builtin.module"; }
   static constexpr uint32_t attributes_num = 1;
   static const char *attributes_name[attributes_num];
-  void Verify();
+  void Verify() const;
   Program *program();
   Block *block();
 
@@ -55,7 +55,7 @@ class IR_API GetParameterOp : public ir::Op<GetParameterOp> {
                     OperationArgument &argument,  // NOLINT
                     const std::string &name,
                     Type type);
-  void Verify();
+  void Verify() const;
 };
 
 ///
@@ -72,7 +72,7 @@ class IR_API SetParameterOp : public ir::Op<SetParameterOp> {
                     OperationArgument &argument,  // NOLINT
                     OpResult parameter,
                     const std::string &name);
-  void Verify();
+  void Verify() const;
 };
 
 ///
@@ -92,7 +92,7 @@ class IR_API CombineOp : public ir::Op<CombineOp> {
                     OperationArgument &argument,  // NOLINT
                     const std::vector<ir::OpResult> &inputs);
 
-  void Verify();
+  void Verify() const;
 };
 
 ///
@@ -107,7 +107,7 @@ class IR_API SliceOp : public ir::Op<SliceOp> {
   static constexpr uint32_t attributes_num = 1;
 
   static const char *attributes_name[attributes_num];
-  void Verify();
+  void Verify() const;
 };
 
 class IR_API ConstantLikeTrait : public OpTraitBase<ConstantLikeTrait> {
@@ -132,9 +132,9 @@ class IR_API ConstantOp : public Op<ConstantOp, ConstantLikeTrait> {
                     Attribute value,
                     Type output_type);
 
-  void Verify();
+  void Verify() const;
 
-  Attribute value();
+  Attribute value() const;
 };
 
 }  // namespace ir
diff --git a/paddle/ir/core/dialect.h b/paddle/ir/core/dialect.h
@@ -145,7 +145,7 @@ class IR_API Dialect {
     IR_THROW("dialect has no registered attribute printing hook");
   }
 
-  virtual void PrintOperation(Operation *op,
+  virtual void PrintOperation(const Operation *op,
                               IrPrinter &printer) const;  // NOLINT
 
  private:
diff --git a/paddle/ir/core/ir_printer.cc b/paddle/ir/core/ir_printer.cc
@@ -115,15 +115,15 @@ void BasicIrPrinter::PrintAttribute(Attribute attr) {
   }
 }
 
-void IrPrinter::PrintProgram(Program* program) {
+void IrPrinter::PrintProgram(const Program* program) {
   auto top_level_op = program->module_op();
   for (size_t i = 0; i < top_level_op->num_regions(); ++i) {
     auto& region = top_level_op->region(i);
     PrintRegion(region);
   }
 }
 
-void IrPrinter::PrintOperation(Operation* op) {
+void IrPrinter::PrintOperation(const Operation* op) {
   if (auto* dialect = op->dialect()) {
     dialect->PrintOperation(op, *this);
     return;
@@ -132,7 +132,7 @@ void IrPrinter::PrintOperation(Operation* op) {
   PrintGeneralOperation(op);
 }
 
-void IrPrinter::PrintGeneralOperation(Operation* op) {
+void IrPrinter::PrintGeneralOperation(const Operation* op) {
   // TODO(lyk): add API to get opresults directly
   PrintOpResult(op);
   os << " =";
@@ -153,7 +153,7 @@ void IrPrinter::PrintGeneralOperation(Operation* op) {
   PrintOpReturnType(op);
 }
 
-void IrPrinter::PrintFullOperation(Operation* op) {
+void IrPrinter::PrintFullOperation(const Operation* op) {
   PrintOperation(op);
   if (op->num_regions() > 0) {
     os << newline;
@@ -171,7 +171,7 @@ void IrPrinter::PrintRegion(const Region& region) {
   }
 }
 
-void IrPrinter::PrintBlock(Block* block) {
+void IrPrinter::PrintBlock(const Block* block) {
   os << "{\n";
   for (auto it = block->begin(); it != block->end(); ++it) {
     PrintOperation(*it);
@@ -180,7 +180,7 @@ void IrPrinter::PrintBlock(Block* block) {
   os << "}\n";
 }
 
-void IrPrinter::PrintValue(Value v) {
+void IrPrinter::PrintValue(const Value& v) {
   if (!v) {
     os << "<<NULL VALUE>>";
     return;
@@ -198,7 +198,7 @@ void IrPrinter::PrintValue(Value v) {
   os << new_name;
 }
 
-void IrPrinter::PrintOpResult(Operation* op) {
+void IrPrinter::PrintOpResult(const Operation* op) {
   os << " (";
   auto num_op_result = op->num_results();
   std::vector<OpResult> op_results;
@@ -214,7 +214,7 @@ void IrPrinter::PrintOpResult(Operation* op) {
   os << ")";
 }
 
-void IrPrinter::PrintAttributeMap(Operation* op) {
+void IrPrinter::PrintAttributeMap(const Operation* op) {
   os << " {";
 
   PrintInterleave(
@@ -230,7 +230,7 @@ void IrPrinter::PrintAttributeMap(Operation* op) {
   os << "}";
 }
 
-void IrPrinter::PrintOpOperands(Operation* op) {
+void IrPrinter::PrintOpOperands(const Operation* op) {
   os << " (";
   auto num_op_operands = op->num_operands();
   std::vector<Value> op_operands;
@@ -246,7 +246,7 @@ void IrPrinter::PrintOpOperands(Operation* op) {
   os << ")";
 }
 
-void IrPrinter::PrintOperandsType(Operation* op) {
+void IrPrinter::PrintOperandsType(const Operation* op) {
   auto num_op_operands = op->num_operands();
   std::vector<Type> op_operand_types;
   op_operand_types.reserve(num_op_operands);
@@ -267,7 +267,7 @@ void IrPrinter::PrintOperandsType(Operation* op) {
   os << ")";
 }
 
-void IrPrinter::PrintOpReturnType(Operation* op) {
+void IrPrinter::PrintOpReturnType(const Operation* op) {
   auto num_op_result = op->num_results();
   std::vector<Type> op_result_types;
   op_result_types.reserve(num_op_result);
@@ -286,16 +286,16 @@ void IrPrinter::PrintOpReturnType(Operation* op) {
       [this]() { this->os << ", "; });
 }
 
-void Dialect::PrintOperation(Operation* op, IrPrinter& printer) const {
+void Dialect::PrintOperation(const Operation* op, IrPrinter& printer) const {
   printer.PrintGeneralOperation(op);
 }
 
-void Program::Print(std::ostream& os) {
+void Program::Print(std::ostream& os) const {
   IrPrinter printer(os);
   printer.PrintProgram(this);
 }
 
-void Operation::Print(std::ostream& os) {
+void Operation::Print(std::ostream& os) const {
   IrPrinter printer(os);
   printer.PrintFullOperation(this);
 }
diff --git a/paddle/ir/core/ir_printer.h b/paddle/ir/core/ir_printer.h
@@ -46,29 +46,29 @@ class IR_API IrPrinter : public BasicIrPrinter {
 
   /// @brief print program
   /// @param program
-  void PrintProgram(Program* program);
+  void PrintProgram(const Program* program);
 
   /// @brief dispatch to custom printer function or PrintGeneralOperation
-  void PrintOperation(Operation* op);
+  void PrintOperation(const Operation* op);
   /// @brief print operation itself without its regions
-  void PrintGeneralOperation(Operation* op);
+  void PrintGeneralOperation(const Operation* op);
   /// @brief print operation and its regions
-  void PrintFullOperation(Operation* op);
+  void PrintFullOperation(const Operation* op);
 
   void PrintRegion(const Region& Region);
-  void PrintBlock(Block* block);
+  void PrintBlock(const Block* block);
 
-  void PrintValue(Value v);
+  void PrintValue(const Value& v);
 
-  void PrintOpResult(Operation* op);
+  void PrintOpResult(const Operation* op);
 
-  void PrintAttributeMap(Operation* op);
+  void PrintAttributeMap(const Operation* op);
 
-  void PrintOpOperands(Operation* op);
+  void PrintOpOperands(const Operation* op);
 
-  void PrintOperandsType(Operation* op);
+  void PrintOperandsType(const Operation* op);
 
-  void PrintOpReturnType(Operation* op);
+  void PrintOpReturnType(const Operation* op);
 
  private:
   size_t cur_var_number_{0};
diff --git a/paddle/ir/core/operation.cc b/paddle/ir/core/operation.cc
@@ -232,6 +232,11 @@ Region &Operation::region(unsigned index) {
   return regions_[index];
 }
 
+const Region &Operation::region(unsigned index) const {
+  assert(index < num_regions_ && "invalid region index");
+  return regions_[index];
+}
+
 void Operation::SetParent(Block *parent, const Block::iterator &position) {
   parent_ = parent;
   position_ = position;
diff --git a/paddle/ir/core/operation.h b/paddle/ir/core/operation.h
@@ -59,8 +59,9 @@ class IR_API alignas(8) Operation final {
 
   /// Returns the region held by this operation at position 'index'.
   Region &region(unsigned index);
+  const Region &region(unsigned index) const;
 
-  void Print(std::ostream &os);
+  void Print(std::ostream &os) const;
 
   const AttributeMap &attributes() const { return attributes_; }
 
diff --git a/paddle/ir/core/program.h b/paddle/ir/core/program.h
@@ -48,11 +48,12 @@ class IR_API Program {
   ~Program();
   size_t parameters_num() const { return parameters_.size(); }
 
-  ModuleOp module_op() { return module_; }
+  ModuleOp module_op() const { return module_; }
 
-  void Print(std::ostream& os);
+  void Print(std::ostream& os) const;
 
   Block* block() { return module_.block(); }
+  const Block* block() const { return module_op().block(); }
 
   Parameter* GetParameter(const std::string& name) const;
   void SetParameter(const std::string& name,
diff --git a/test/cpp/ir/core/ir_op_test.cc b/test/cpp/ir/core/ir_op_test.cc
@@ -155,7 +155,7 @@ class TestDialect : public ir::Dialect {
   }
   static const char *name() { return "test"; }
 
-  void PrintOperation(ir::Operation *op,
+  void PrintOperation(const ir::Operation *op,
                       ir::IrPrinter &printer) const override {
     printer.PrintOpResult(op);
     printer.os << " =";

Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ class IR_API Dialect {`
`145`	`145`	`IR_THROW("dialect has no registered attribute printing hook");`
`146`	`146`	`}`
`147`	`147`
`148`		`- virtual void PrintOperation(Operation *op,`
	`148`	`+ virtual void PrintOperation(const Operation *op,`
`149`	`149`	`IrPrinter &printer) const; // NOLINT`
`150`	`150`
`151`	`151`	`private:`
Original file line number	Diff line number	Diff line change
`@@ -115,15 +115,15 @@ void BasicIrPrinter::PrintAttribute(Attribute attr) {`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`118`		`-void IrPrinter::PrintProgram(Program* program) {`
	`118`	`+void IrPrinter::PrintProgram(const Program* program) {`
`119`	`119`	`auto top_level_op = program->module_op();`
`120`	`120`	`for (size_t i = 0; i < top_level_op->num_regions(); ++i) {`
`121`	`121`	`auto& region = top_level_op->region(i);`
`122`	`122`	`PrintRegion(region);`
`123`	`123`	`}`
`124`	`124`	`}`
`125`	`125`
`126`		`-void IrPrinter::PrintOperation(Operation* op) {`
	`126`	`+void IrPrinter::PrintOperation(const Operation* op) {`
`127`	`127`	`if (auto* dialect = op->dialect()) {`
`128`	`128`	`dialect->PrintOperation(op, *this);`
`129`	`129`	`return;`
`@@ -132,7 +132,7 @@ void IrPrinter::PrintOperation(Operation* op) {`
`132`	`132`	`PrintGeneralOperation(op);`
`133`	`133`	`}`
`134`	`134`
`135`		`-void IrPrinter::PrintGeneralOperation(Operation* op) {`
	`135`	`+void IrPrinter::PrintGeneralOperation(const Operation* op) {`
`136`	`136`	`// TODO(lyk): add API to get opresults directly`
`137`	`137`	`PrintOpResult(op);`
`138`	`138`	`os << " =";`
`@@ -153,7 +153,7 @@ void IrPrinter::PrintGeneralOperation(Operation* op) {`
`153`	`153`	`PrintOpReturnType(op);`
`154`	`154`	`}`
`155`	`155`
`156`		`-void IrPrinter::PrintFullOperation(Operation* op) {`
	`156`	`+void IrPrinter::PrintFullOperation(const Operation* op) {`
`157`	`157`	`PrintOperation(op);`
`158`	`158`	`if (op->num_regions() > 0) {`
`159`	`159`	`os << newline;`
`@@ -171,7 +171,7 @@ void IrPrinter::PrintRegion(const Region& region) {`
`171`	`171`	`}`
`172`	`172`	`}`
`173`	`173`
`174`		`-void IrPrinter::PrintBlock(Block* block) {`
	`174`	`+void IrPrinter::PrintBlock(const Block* block) {`
`175`	`175`	`os << "{\n";`
`176`	`176`	`for (auto it = block->begin(); it != block->end(); ++it) {`
`177`	`177`	`PrintOperation(*it);`
`@@ -180,7 +180,7 @@ void IrPrinter::PrintBlock(Block* block) {`
`180`	`180`	`os << "}\n";`
`181`	`181`	`}`
`182`	`182`
`183`		`-void IrPrinter::PrintValue(Value v) {`
	`183`	`+void IrPrinter::PrintValue(const Value& v) {`
`184`	`184`	`if (!v) {`
`185`	`185`	`os << "<<NULL VALUE>>";`
`186`	`186`	`return;`
`@@ -198,7 +198,7 @@ void IrPrinter::PrintValue(Value v) {`
`198`	`198`	`os << new_name;`
`199`	`199`	`}`
`200`	`200`
`201`		`-void IrPrinter::PrintOpResult(Operation* op) {`
	`201`	`+void IrPrinter::PrintOpResult(const Operation* op) {`
`202`	`202`	`os << " (";`
`203`	`203`	`auto num_op_result = op->num_results();`
`204`	`204`	`std::vector<OpResult> op_results;`
`@@ -214,7 +214,7 @@ void IrPrinter::PrintOpResult(Operation* op) {`
`214`	`214`	`os << ")";`
`215`	`215`	`}`
`216`	`216`
`217`		`-void IrPrinter::PrintAttributeMap(Operation* op) {`
	`217`	`+void IrPrinter::PrintAttributeMap(const Operation* op) {`
`218`	`218`	`os << " {";`
`219`	`219`
`220`	`220`	`PrintInterleave(`
`@@ -230,7 +230,7 @@ void IrPrinter::PrintAttributeMap(Operation* op) {`
`230`	`230`	`os << "}";`
`231`	`231`	`}`
`232`	`232`
`233`		`-void IrPrinter::PrintOpOperands(Operation* op) {`
	`233`	`+void IrPrinter::PrintOpOperands(const Operation* op) {`
`234`	`234`	`os << " (";`
`235`	`235`	`auto num_op_operands = op->num_operands();`
`236`	`236`	`std::vector<Value> op_operands;`
`@@ -246,7 +246,7 @@ void IrPrinter::PrintOpOperands(Operation* op) {`
`246`	`246`	`os << ")";`
`247`	`247`	`}`
`248`	`248`
`249`		`-void IrPrinter::PrintOperandsType(Operation* op) {`
	`249`	`+void IrPrinter::PrintOperandsType(const Operation* op) {`
`250`	`250`	`auto num_op_operands = op->num_operands();`
`251`	`251`	`std::vector<Type> op_operand_types;`
`252`	`252`	`op_operand_types.reserve(num_op_operands);`
`@@ -267,7 +267,7 @@ void IrPrinter::PrintOperandsType(Operation* op) {`
`267`	`267`	`os << ")";`
`268`	`268`	`}`
`269`	`269`
`270`		`-void IrPrinter::PrintOpReturnType(Operation* op) {`
	`270`	`+void IrPrinter::PrintOpReturnType(const Operation* op) {`
`271`	`271`	`auto num_op_result = op->num_results();`
`272`	`272`	`std::vector<Type> op_result_types;`
`273`	`273`	`op_result_types.reserve(num_op_result);`
`@@ -286,16 +286,16 @@ void IrPrinter::PrintOpReturnType(Operation* op) {`
`286`	`286`	`[this]() { this->os << ", "; });`
`287`	`287`	`}`
`288`	`288`
`289`		`-void Dialect::PrintOperation(Operation* op, IrPrinter& printer) const {`
	`289`	`+void Dialect::PrintOperation(const Operation* op, IrPrinter& printer) const {`
`290`	`290`	`printer.PrintGeneralOperation(op);`
`291`	`291`	`}`
`292`	`292`
`293`		`-void Program::Print(std::ostream& os) {`
	`293`	`+void Program::Print(std::ostream& os) const {`
`294`	`294`	`IrPrinter printer(os);`
`295`	`295`	`printer.PrintProgram(this);`
`296`	`296`	`}`
`297`	`297`
`298`		`-void Operation::Print(std::ostream& os) {`
	`298`	`+void Operation::Print(std::ostream& os) const {`
`299`	`299`	`IrPrinter printer(os);`
`300`	`300`	`printer.PrintFullOperation(this);`
`301`	`301`	`}`
Original file line number	Diff line number	Diff line change
`@@ -155,7 +155,7 @@ class TestDialect : public ir::Dialect {`
`155`	`155`	`}`
`156`	`156`	`static const char *name() { return "test"; }`
`157`	`157`
`158`		`- void PrintOperation(ir::Operation *op,`
	`158`	`+ void PrintOperation(const ir::Operation *op,`
`159`	`159`	`ir::IrPrinter &printer) const override {`
`160`	`160`	`printer.PrintOpResult(op);`
`161`	`161`	`printer.os << " =";`