Rename IntegerSet to PresburgerSet

Author: Min Chen

python/tvm/arith/__init__.py

@@ -19,7 +19,7 @@
 from .int_set import (
     IntSet,
     IntervalSet,
-    IntegerSet,
+    PresburgerSet,
     estimate_region_lower_bound,
     estimate_region_strict_bound,
     estimate_region_upper_bound,

python/tvm/arith/int_set.py

@@ -81,8 +81,8 @@ def __init__(self, min_value, max_value):
         self.__init_handle_by_constructor__(_ffi_api.IntervalSet, min_value, max_value)
 
 
-@tvm._ffi.register_object("arith.IntegerSet")
-class IntegerSet(IntSet):
+@tvm._ffi.register_object("arith.PresburgerSet")
+class PresburgerSet(IntSet):
     """Represent of Presburger Set
 
     Parameters
@@ -95,7 +95,7 @@ class IntegerSet(IntSet):
     """
 
     def __init__(self, constraint, domain_vars):
-        self.__init_handle_by_constructor__(_ffi_api.IntegerSet, constraint, domain_vars)
+        self.__init_handle_by_constructor__(_ffi_api.PresburgerSet, constraint, domain_vars)
 
 
 def estimate_region_lower_bound(region, var_dom, predicate):

src/arith/integer_set.cc renamed to src/arith/presburger_set.cc

@@ -18,8 +18,8 @@
  */
 
 /*!
- * \file integer_set.cc
- * \brief The integer set functions
+ * \file presburger_set.cc
+ * \brief The presburger set functions
  */
 #include <tvm/arith/int_set.h>
 #include <tvm/runtime/registry.h>
@@ -34,7 +34,7 @@
 #include <utility>
 
 #include "constraint_extract.h"
-#include "integer_set.h"
+#include "presburger_set.h"
 #include "interval_set.h"
 
 namespace tvm {
@@ -45,7 +45,7 @@ using namespace tir;
 
 
 void Update(const PrimExpr& constraint,
-            IntegerSetNode& intset) {
+            PresburgerSetNode& intset) {
   auto& space = intset.space;
   auto constraints_union = ExtractComponents(constraint);
   for (const PrimExpr& subconstraint : constraints_union) {
@@ -87,7 +87,7 @@ void Update(const PrimExpr& constraint,
   }
 }
 
-IntegerSet::IntegerSet(const PrimExpr& constraint) {
+PresburgerSet::PresburgerSet(const PrimExpr& constraint) {
   Array<Var> vars;
   PostOrderVisit(constraint, [&vars](const ObjectRef& obj) {
     if (const VarNode* new_var = obj.as<VarNode>()) {
@@ -102,25 +102,25 @@ IntegerSet::IntegerSet(const PrimExpr& constraint) {
   Analyzer analyzer;
   PrimExpr simplified_constraint = analyzer.Simplify(constraint, kSimplifyRewriteCanonicalRewrite);
   auto space = PresburgerSpace::getRelationSpace(vars.size(), 0, 0, 0);
-  auto node = make_object<IntegerSetNode>(std::move(space), vars);
+  auto node = make_object<PresburgerSetNode>(std::move(space), vars);
   node->SetVars(vars);
   Update(simplified_constraint, *node);
   data_ = std::move(node);
 }
 
-IntegerSet::IntegerSet(const std::vector<IntegerRelation>& disjuncts, const Array<Var>& vars) {
-  auto node = make_object<IntegerSetNode>(disjuncts, disjuncts[0].getSpace(), vars);
+PresburgerSet::PresburgerSet(const std::vector<IntegerRelation>& disjuncts, const Array<Var>& vars) {
+  auto node = make_object<PresburgerSetNode>(disjuncts, disjuncts[0].getSpace(), vars);
   data_ = std::move(node);
 }
 
-void IntegerSetNode::UpdateConstraint(const PrimExpr& constraint, const Array<Var>& vars) {
+void PresburgerSetNode::UpdateConstraint(const PrimExpr& constraint, const Array<Var>& vars) {
   Analyzer analyzer;
   PrimExpr simplified_constraint = analyzer.Simplify(constraint, kSimplifyRewriteCanonicalRewrite);
   Update(simplified_constraint, *this);
   SetVars(vars);
 }
 
-PrimExpr IntegerSetNode::GenerateConstraint() const {
+PrimExpr PresburgerSetNode::GenerateConstraint() const {
   PrimExpr constraint = Bool(0);
   for (const IntegerRelation &disjunct : disjuncts) {
     PrimExpr union_entry = Bool(1);
@@ -166,18 +166,18 @@ PrimExpr IntegerSetNode::GenerateConstraint() const {
   return constraint;
 }
 
-IntegerSet Union(Array<IntegerSet> sets) {
+PresburgerSet Union(Array<PresburgerSet> sets) {
   CHECK_GT(sets.size(), 0);
   if (sets.size() == 1) return sets[0];
   auto relations = sets[0]->disjuncts;
   for (size_t i = 1; i < sets.size(); ++i) {
     for (const auto rel : sets[i]->disjuncts)
       relations.push_back(rel);
   }
-  return IntegerSet(std::move(relations), sets[0]->GetVars());
+  return PresburgerSet(std::move(relations), sets[0]->GetVars());
 }
 
-IntegerSet Intersect(const Array<IntegerSet>& sets) {
+PresburgerSet Intersect(const Array<PresburgerSet>& sets) {
   CHECK_GT(sets.size(), 0);
   if (sets.size() == 1) return sets[0];
   auto relations = sets[0]->disjuncts;
@@ -193,10 +193,10 @@ IntegerSet Intersect(const Array<IntegerSet>& sets) {
       }
     }
   }
-  return IntegerSet(std::move(relations), sets[0]->GetVars());
+  return PresburgerSet(std::move(relations), sets[0]->GetVars());
 }
 
-IntSet EvalSet(const PrimExpr& e, const IntegerSet& set) {
+IntSet EvalSet(const PrimExpr& e, const PresburgerSet& set) {
   auto tvm_coeffs = DetectLinearEquation(e, set->GetVars());
   SmallVector<int64_t> coeffs;
   coeffs.reserve(tvm_coeffs.size());
@@ -221,24 +221,24 @@ IntSet EvalSet(const PrimExpr& e, const IntegerSet& set) {
 }
 
 TVM_STATIC_IR_FUNCTOR(ReprPrinter, vtable)
-    .set_dispatch<IntegerSetNode>([](const ObjectRef& node, ReprPrinter* p) {
-      auto set = node.as<IntegerSetNode>();
+    .set_dispatch<PresburgerSetNode>([](const ObjectRef& node, ReprPrinter* p) {
+      auto set = node.as<PresburgerSetNode>();
       ICHECK(ret) << "Unknown type:" << node->GetTypeKey();
       p->stream << "{";
       p->stream << set->GetVars() << ": ";
-      p->stream << node.as<IntegerSetNode>()->GenerateConstraint();
+      p->stream << node.as<PresburgerSetNode>()->GenerateConstraint();
       p->stream << "}";
     });
 
 #endif
 
-IntegerSet MakeIntegerSet(const PrimExpr& constraint) {
-  return IntegerSet(constraint);
+PresburgerSet MakePresburgerSet(const PrimExpr& constraint) {
+  return PresburgerSet(constraint);
 }
 
-TVM_REGISTER_GLOBAL("arith.IntegerSet").set_body_typed(MakeIntegerSet);
+TVM_REGISTER_GLOBAL("arith.PresburgerSet").set_body_typed(MakePresburgerSet);
 
-TVM_REGISTER_NODE_TYPE(IntegerSetNode);
+TVM_REGISTER_NODE_TYPE(PresburgerSetNode);
 
 }  // namespace arith
 }  // namespace tvm

src/arith/integer_set.h renamed to src/arith/presburger_set.h

@@ -18,11 +18,11 @@
  */
 
 /*!
- * \file integer_set.h
+ * \file presburger_set.h
  * \brief Integer set based on MLIR Presburger set
  */
-#ifndef TVM_ARITH_INTEGER_SET_H_
-#define TVM_ARITH_INTEGER_SET_H_
+#ifndef TVM_ARITH_PRESBURGER_SET_H_
+#define TVM_ARITH_PRESBURGER_SET_H_
 
 #ifdef TVM_MLIR_VERSION
 #include <mlir/Analysis/Presburger/PresburgerRelation.h>
@@ -44,20 +44,20 @@ namespace arith {
 using namespace mlir;
 using namespace presburger;
 
-// Acknowledgement: IntegerSet is based on Presburger set of MLIR.
+// Acknowledgement: PresburgerSet is based on Presburger set of MLIR.
 /*!
  * \brief Symbolic integer set.
  *
- * \note IntegerSet aims to provide compatible APIs with IntSet,
+ * \note PresburgerSet aims to provide compatible APIs with IntSet,
  *       and some additional APIs that analyze and solve
  *       multi-dimension interger set problems
  */
-class IntegerSetNode : public IntSetNode {
+class PresburgerSetNode : public IntSetNode {
  public:
-  explicit IntegerSetNode(const PresburgerSpace &space, const Array<Var> &vars)
+  explicit PresburgerSetNode(const PresburgerSpace &space, const Array<Var> &vars)
     : disjuncts({}), space(space),  vars(vars) {};
-  explicit IntegerSetNode() : space(PresburgerSpace::getRelationSpace()) {};
-  explicit IntegerSetNode(const std::vector<IntegerRelation> &disjuncts,
+  explicit PresburgerSetNode() : space(PresburgerSpace::getRelationSpace()) {};
+  explicit PresburgerSetNode(const std::vector<IntegerRelation> &disjuncts,
                           const PresburgerSpace &space,
                           const Array<Var> &vars)
     : disjuncts(disjuncts), space(space), vars(vars) {}
@@ -90,7 +90,7 @@ class IntegerSetNode : public IntSetNode {
 
   /*!
    * \brief Update int set with given constraint
-   * \param constraint The added constraint to the IntegerSet.
+   * \param constraint The added constraint to the PresburgerSet.
    * \param vars The specified domain vars in constraint expression.
    */
   void UpdateConstraint(const PrimExpr& constraint, const Array<Var>& vars);
@@ -120,58 +120,58 @@ class IntegerSetNode : public IntSetNode {
                        std::mem_fn(&IntegerRelation::isIntegerEmpty));
   }
 
-  static constexpr const char* _type_key = "arith.IntegerSet";
-  TVM_DECLARE_FINAL_OBJECT_INFO(IntegerSetNode, IntSetNode);
+  static constexpr const char* _type_key = "arith.PresburgerSet";
+  TVM_DECLARE_FINAL_OBJECT_INFO(PresburgerSetNode, IntSetNode);
 
  private:
   Array<Var> vars;
 };
 
 /*!
  * \brief Integer set used for multi-dimension integer analysis.
- * \sa IntegerSetNode
+ * \sa PresburgerSetNode
  */
-class IntegerSet : public IntSet {
+class PresburgerSet : public IntSet {
  public:
   /*!
-   * \brief Make a new instance of IntegerSet.
+   * \brief Make a new instance of PresburgerSet.
    * \param disjuncts The disjunts to construct the set.
    * \param vars The variables that the constraint describes about.
-   * \return The created IntegerSet.
+   * \return The created PresburgerSet.
    */
-  TVM_DLL IntegerSet(const std::vector<IntegerRelation>& disjuncts, const Array<Var>& vars);
+  TVM_DLL PresburgerSet(const std::vector<IntegerRelation>& disjuncts, const Array<Var>& vars);
 
   /*!
-   * \brief Make a new instance of IntegerSet, collect all vars as space vars.
+   * \brief Make a new instance of PresburgerSet, collect all vars as space vars.
    * \param constraint The constraint to construct the set.
-   * \return The created IntegerSet.
+   * \return The created PresburgerSet.
    */
-  TVM_DLL IntegerSet(const PrimExpr& constraint);
+  TVM_DLL PresburgerSet(const PrimExpr& constraint);
 
-  TVM_DEFINE_OBJECT_REF_COW_METHOD(IntegerSetNode);
-  TVM_DEFINE_OBJECT_REF_METHODS(IntegerSet, IntSet, IntegerSetNode);
+  TVM_DEFINE_OBJECT_REF_COW_METHOD(PresburgerSetNode);
+  TVM_DEFINE_OBJECT_REF_METHODS(PresburgerSet, IntSet, PresburgerSetNode);
 };
 #else
 // Class definition when MLIR is not enabled, to prevent compile-time error.
-class IntegerSetNode : public IntSetNode {
+class PresburgerSetNode : public IntSetNode {
  public:
   // dummy visitor overload.
   void VisitAttrs(tvm::AttrVisitor* v) {
     LOG(FATAL) << "MLIR is not enabled!";
   }
 
-  static constexpr const char* _type_key = "arith.IntegerSet";
-  TVM_DECLARE_FINAL_OBJECT_INFO(IntegerSetNode, IntSetNode);
+  static constexpr const char* _type_key = "arith.PresburgerSet";
+  TVM_DECLARE_FINAL_OBJECT_INFO(PresburgerSetNode, IntSetNode);
 };
 
-class IntegerSet : public IntSet {
+class PresburgerSet : public IntSet {
  public:
    /*!
    * \brief Constructor interface to prompt when MLIR is not enabled.
    * \param constraint The constraint to construct the set.
    * \return The created set.
    */
-  TVM_DLL IntegerSet(const PrimExpr& constraint) {
+  TVM_DLL PresburgerSet(const PrimExpr& constraint) {
     LOG(FATAL) << "MLIR is not enabled!";
   }
 };
@@ -181,24 +181,24 @@ class IntegerSet : public IntSet {
  * \param sets The sets to be combined
  * \return the set after union
  */
-IntegerSet Union(const Array<IntegerSet> sets);
+PresburgerSet Union(const Array<PresburgerSet> sets);
 
 /*!
  * \brief Create an intersected set of all sets
  * \param sets The sets to be intersected
  * \return The intersect set
  */
-IntegerSet Intersect(const Array<IntegerSet>& sets);
+PresburgerSet Intersect(const Array<PresburgerSet>& sets);
 
 /*!
  * \brief Evaluate the range of given expression based on the constraint
- * in given IntegerSet
+ * in given PresburgerSet
  * \param e The target expresision to be evaluated.
- * \param set The IntegerSet defining the constraint.
+ * \param set The PresburgerSet defining the constraint.
  */
-IntSet EvalSet(const PrimExpr& e, const IntegerSet& set);
+IntSet EvalSet(const PrimExpr& e, const PresburgerSet& set);
 
 }  // namespace arith
 }  // namespace tvm
 
-#endif  // TVM_ARITH_INTEGER_SET_H_
+#endif  // TVM_ARITH_PRESBURGER_SET_H_

tests/cpp/arith_integer_set_test.cc

@@ -23,15 +23,15 @@
 #include <tvm/arith/analyzer.h>
 #include <tvm/te/operation.h>
 
-#include "../src/arith/integer_set.h"
+#include "../src/arith/presburger_set.h"
 
-TEST(IntegerSet, eval) {
+TEST(PresburgerSet, eval) {
   auto x = tvm::tir::Var("x");
   auto y = tvm::tir::Var("y");
   auto sub_constraint0 = (x + y < 20) && (x - y <= 0);
   auto sub_constraint1 = x >= 0 && x < 20 && y >=0 && y < 20;
   auto constraint = sub_constraint0 && sub_constraint1;
-  auto set = tvm::arith::IntegerSet(constraint);
+  auto set = tvm::arith::PresburgerSet(constraint);
 
   auto target = x + 2*y;
   auto result = EvalSet(target, set);