[MLIR][Presburger] Move Presburger/ files to presburger namespace

[Groverkss]

Summary

This patch moves the Presburger library to a new presburger namespace.

This allows to shorten some names, helps to avoid polluting the mlir namespace,
and also provides some structure.

mlir/include/mlir/Analysis/Presburger/Fraction.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_ANALYSIS_PRESBURGER_FRACTION_H
 #define MLIR_ANALYSIS_PRESBURGER_FRACTION_H
 
 #include "mlir/Support/MathExtras.h"
 
 namespace mlir {
+namespace presburger {
 
 /// A class to represent fractions. The sign of the fraction is represented
 /// in the sign of the numerator; the denominator is always positive.
 ///
 /// Note that overflows may occur if the numerator or denominator are not
 /// representable by 64-bit integers.
 struct Fraction {
   /// Default constructor initializes the represented rational number to zero.

 inline bool operator>(Fraction x, Fraction y) { return compare(x, y) > 0; }
 
 inline bool operator>=(Fraction x, Fraction y) { return compare(x, y) >= 0; }
 
 inline Fraction operator*(Fraction x, Fraction y) {
   return Fraction(x.num * y.num, x.den * y.den);
 }
 
+} // namespace presburger
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_PRESBURGER_FRACTION_H

mlir/include/mlir/Analysis/Presburger/IntegerPolyhedron.h

 
 #include "mlir/Analysis/Presburger/Fraction.h"
 #include "mlir/Analysis/Presburger/Matrix.h"
 #include "mlir/Analysis/Presburger/PresburgerSpace.h"
 #include "mlir/Analysis/Presburger/Utils.h"
 #include "mlir/Support/LogicalResult.h"
 
 namespace mlir {
+namespace presburger {
 
 /// An IntegerRelation is a PresburgerLocalSpace subject to affine constraints.
 /// Affine constraints can be inequalities or equalities in the form:
 ///
 /// Inequality: c_0*x_0 + c_1*x_1 + .... + c_{n-1}*x_{n-1} + c_n >= 0
 /// Equality  : c_0*x_0 + c_1*x_1 + .... + c_{n-1}*x_{n-1} + c_n == 0
 ///
 /// where c_0, c_1, ..., c_n are integers and n is the total number of
public:
   /// Remove the (in)equalities at positions [start, end).
   void removeEqualityRange(unsigned start, unsigned end);
   void removeInequalityRange(unsigned start, unsigned end);
 
   /// Get the lexicographically minimum rational point satisfying the
   /// constraints. Returns an empty optional if the polyhedron is empty or if
   /// the lexmin is unbounded. Symbols are not supported and will result in
   /// assert-failure.
-  presburger_utils::MaybeOptimum<SmallVector<Fraction, 8>>
-  findRationalLexMin() const;
+  MaybeOptimum<SmallVector<Fraction, 8>> findRationalLexMin() const;
 
   /// Same as above, but returns lexicographically minimal integer point.
   /// Note: this should be used only when the lexmin is really required.
   /// For a generic integer sampling operation, findIntegerSample is more
   /// robust and should be preferred.
-  presburger_utils::MaybeOptimum<SmallVector<int64_t, 8>>
-  findIntegerLexMin() const;
+  MaybeOptimum<SmallVector<int64_t, 8>> findIntegerLexMin() const;
 
   /// Swap the posA^th identifier with the posB^th identifier.
   virtual void swapId(unsigned posA, unsigned posB);
 
   /// Removes all equalities and inequalities.
   void clearConstraints();
 
   /// Sets the `values.size()` identifiers starting at `po`s to the specified
public:
   /// in `MaybeLocalRepr` is set to None.
   ///
   /// The dividends of the explicit representations are stored in `dividends`
   /// and the denominators in `denominators`. If no explicit representation
   /// could be found for the `i^th` local identifier, `denominators[i]` is set
   /// to 0.
   void getLocalReprs(std::vector<SmallVector<int64_t, 8>> &dividends,
                      SmallVector<unsigned, 4> &denominators,
-                     std::vector<presburger_utils::MaybeLocalRepr> &repr) const;
-  void getLocalReprs(std::vector<presburger_utils::MaybeLocalRepr> &repr) const;
+                     std::vector<MaybeLocalRepr> &repr) const;
+  void getLocalReprs(std::vector<MaybeLocalRepr> &repr) const;
   void getLocalReprs(std::vector<SmallVector<int64_t, 8>> &dividends,
                      SmallVector<unsigned, 4> &denominators) const;
 
   /// The type of bound: equal, lower bound or upper bound.
   enum BoundType { EQ, LB, UB };
 
   /// Adds a constant bound for the specified identifier.
   void addBound(BoundType type, unsigned pos, int64_t value);
protected:
   // identifier is expected to have one lower bound and one upper bound
   // constraint. With a level of tiling or a connection to another identifier
   // through a div or mod, an extra pair of bounds gets added. As a limit, we
   // don't expect an identifier to have more than 32 lower/upper/equality
   // constraints. This is conservatively set low and can be raised if needed.
   constexpr static unsigned kExplosionFactor = 32;
 };
 
+} // namespace presburger
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_PRESBURGER_INTEGERPOLYHEDRON_H

mlir/include/mlir/Analysis/Presburger/LinearTransform.h

 #ifndef MLIR_ANALYSIS_PRESBURGER_LINEARTRANSFORM_H
 #define MLIR_ANALYSIS_PRESBURGER_LINEARTRANSFORM_H
 
 #include "mlir/Analysis/Presburger/IntegerPolyhedron.h"
 #include "mlir/Analysis/Presburger/Matrix.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace mlir {
+namespace presburger {
 
 class LinearTransform {
 public:
   explicit LinearTransform(Matrix &&oMatrix);
   explicit LinearTransform(const Matrix &oMatrix);
 
   // Returns a linear transform T such that MT is M in column echelon form.
   // Also returns the number of non-zero columns in MT.
public:
   postMultiplyWithColumn(ArrayRef<int64_t> colVec) const {
     return matrix.postMultiplyWithColumn(colVec);
   }
 
 private:
   Matrix matrix;
 };
 
+} // namespace presburger
 } // namespace mlir
+
 #endif // MLIR_ANALYSIS_PRESBURGER_LINEARTRANSFORM_H

mlir/include/mlir/Analysis/Presburger/Matrix.h

 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <cassert>
 
 namespace mlir {
+namespace presburger {
 
 /// This is a class to represent a resizable matrix.
 ///
 /// More columns and rows can be reserved than are currently used. The data is
 /// stored as a single 1D array, viewed as a 2D matrix with nRows rows and
 /// nReservedColumns columns, stored in row major form. Thus the element at
 /// (i, j) is stored at data[i*nReservedColumns + j]. The reserved but unused
 /// columns always have all zero values. The reserved rows are just reserved
private:
   /// reserved columns filled with zeros.
   unsigned nRows, nColumns, nReservedColumns;
 
   /// Stores the data. data.size() is equal to nRows * nReservedColumns.
   /// data.capacity() / nReservedColumns is the number of reserved rows.
   SmallVector<int64_t, 64> data;
 };
 
+} // namespace presburger
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_PRESBURGER_MATRIX_H

mlir/include/mlir/Analysis/Presburger/PWMAFunction.h

 
 #ifndef MLIR_ANALYSIS_PRESBURGER_PWMAFUNCTION_H
 #define MLIR_ANALYSIS_PRESBURGER_PWMAFUNCTION_H
 
 #include "mlir/Analysis/Presburger/IntegerPolyhedron.h"
 #include "mlir/Analysis/Presburger/PresburgerSet.h"
 
 namespace mlir {
+namespace presburger {
 
 /// This class represents a multi-affine function whose domain is given by an
 /// IntegerPolyhedron. This can be thought of as an IntegerPolyhedron with a
 /// tuple of integer values attached to every point in the polyhedron, with the
 /// value of each element of the tuple given by an affine expression in the ids
 /// of the polyhedron. For example we could have the domain
 ///
 /// (x, y) : (x >= 5, y >= x)

 private:
   /// The list of pieces in this piece-wise MultiAffineFunction.
   SmallVector<MultiAffineFunction, 4> pieces;
 
   /// The number of output ids.
   unsigned numOutputs;
 };
 
+} // namespace presburger
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_PRESBURGER_PWMAFUNCTION_H

mlir/include/mlir/Analysis/Presburger/PresburgerSet.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_ANALYSIS_PRESBURGER_PRESBURGERSET_H
 #define MLIR_ANALYSIS_PRESBURGER_PRESBURGERSET_H
 
 #include "mlir/Analysis/Presburger/IntegerPolyhedron.h"
 
 namespace mlir {
+namespace presburger {
 
 /// This class can represent a union of IntegerPolyhedrons, with support for
 /// union, intersection, subtraction and complement operations, as well as
 /// sampling.
 ///
 /// The IntegerPolyhedrons (Polys) are stored in a vector, and the set
 /// represents the union of these Polys. An empty list corresponds to the empty
 /// set.
private:
   /// Return the set difference poly \ set.
   static PresburgerSet getSetDifference(IntegerPolyhedron poly,
                                         const PresburgerSet &set);
 
   /// The list of integerPolyhedrons that this set is the union of.
   SmallVector<IntegerPolyhedron, 2> integerPolyhedrons;
 };
 
+} // namespace presburger
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_PRESBURGER_PRESBURGERSET_H

mlir/include/mlir/Analysis/Presburger/PresburgerSpace.h

 
 #ifndef MLIR_ANALYSIS_PRESBURGER_PRESBURGERSPACE_H
 #define MLIR_ANALYSIS_PRESBURGER_PRESBURGERSPACE_H
 
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
+namespace presburger {
 
 class PresburgerLocalSpace;
 
 /// PresburgerSpace is the space of all possible values of a tuple of integer
 /// valued variables/identifiers. Each identifier has one of the three types:
 ///
 /// Dimension: Ordinary variables over which the space is represented.
 ///
PresburgerLocalSpace(unsigned numDomain, unsigned numRange,
       : PresburgerSpace(Relation, numDomain, numRange, numSymbols, numLocals) {}
 
   /// Local Space constructor for Set space type.
   PresburgerLocalSpace(unsigned numDims, unsigned numSymbols,
                        unsigned numLocals)
       : PresburgerSpace(Set, /*numDomain=*/0, numDims, numSymbols, numLocals) {}
 };
 
+} // namespace presburger
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_PRESBURGER_PRESBURGERSPACE_H

mlir/include/mlir/Analysis/Presburger/Simplex.h

 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
+namespace presburger {
 
 class GBRSimplex;
 
 /// The Simplex class implements a version of the Simplex and Generalized Basis
 /// Reduction algorithms, which can perform analysis of integer sets with affine
 /// inequalities and equalities. A Simplex can be constructed
 /// by specifying the dimensionality of the set. It supports adding affine
 /// inequalities and equalities, and can perform emptiness checks, i.e., it can
public:
   void addInequality(ArrayRef<int64_t> coeffs) final {
     addRow(coeffs, /*makeRestricted=*/true);
   }
 
   /// Get a snapshot of the current state. This is used for rolling back.
   unsigned getSnapshot() { return SimplexBase::getSnapshotBasis(); }
 
   /// Return the lexicographically minimum rational solution to the constraints.
-  presburger_utils::MaybeOptimum<SmallVector<Fraction, 8>> findRationalLexMin();
+  MaybeOptimum<SmallVector<Fraction, 8>> findRationalLexMin();
 
   /// Return the lexicographically minimum integer solution to the constraints.
   ///
   /// Note: this should be used only when the lexmin is really needed. To obtain
   /// any integer sample, use Simplex::findIntegerSample as that is more robust.
-  presburger_utils::MaybeOptimum<SmallVector<int64_t, 8>> findIntegerLexMin();
+  MaybeOptimum<SmallVector<int64_t, 8>> findIntegerLexMin();
 
 protected:
   /// Returns the current sample point, which may contain non-integer (rational)
   /// coordinates. Returns an empty optimum when the tableau is empty.
   ///
   /// Returns an unbounded optimum when the big M parameter is used and a
   /// variable has a non-zero big M coefficient, meaning its value is infinite
   /// or unbounded.
-  presburger_utils::MaybeOptimum<SmallVector<Fraction, 8>>
-  getRationalSample() const;
+  MaybeOptimum<SmallVector<Fraction, 8>> getRationalSample() const;
 
   /// Given a row that has a non-integer sample value, add an inequality such
   /// that this fractional sample value is cut away from the polytope. The added
   /// inequality will be such that no integer points are removed.
   ///
   /// Returns whether the cut constraint could be enforced, i.e. failure if the
   /// cut made the polytope empty, and success if it didn't. Failure status
   /// indicates that the polytope didn't have any integer points.
public:
   void addInequality(ArrayRef<int64_t> coeffs) final;
 
   /// Compute the maximum or minimum value of the given row, depending on
   /// direction. The specified row is never pivoted. On return, the row may
   /// have a negative sample value if the direction is down.
   ///
   /// Returns a Fraction denoting the optimum, or a null value if no optimum
   /// exists, i.e., if the expression is unbounded in this direction.
-  presburger_utils::MaybeOptimum<Fraction>
-  computeRowOptimum(Direction direction, unsigned row);
+  MaybeOptimum<Fraction> computeRowOptimum(Direction direction, unsigned row);
 
   /// Compute the maximum or minimum value of the given expression, depending on
   /// direction. Should not be called when the Simplex is empty.
   ///
   /// Returns a Fraction denoting the optimum, or a null value if no optimum
   /// exists, i.e., if the expression is unbounded in this direction.
-  presburger_utils::MaybeOptimum<Fraction>
-  computeOptimum(Direction direction, ArrayRef<int64_t> coeffs);
+  MaybeOptimum<Fraction> computeOptimum(Direction direction,
+                                        ArrayRef<int64_t> coeffs);
 
   /// Returns whether the perpendicular of the specified constraint is a
   /// is a direction along which the polytope is bounded.
   bool isBoundedAlongConstraint(unsigned constraintIndex);
 
   /// Returns whether the specified constraint has been marked as redundant.
   /// Constraints are numbered from 0 starting at the first added inequality.
   /// Equalities are added as a pair of inequalities and so correspond to two
   /// inequalities with successive indices.
   bool isMarkedRedundant(unsigned constraintIndex) const;
 
   /// Finds a subset of constraints that is redundant, i.e., such that
   /// the set of solutions does not change if these constraints are removed.
   /// Marks these constraints as redundant. Whether a specific constraint has
   /// been marked redundant can be queried using isMarkedRedundant.
   void detectRedundant();
 
   /// Returns a (min, max) pair denoting the minimum and maximum integer values
   /// of the given expression. If no integer value exists, both results will be
   /// of kind Empty.
-  std::pair<presburger_utils::MaybeOptimum<int64_t>,
-            presburger_utils::MaybeOptimum<int64_t>>
+  std::pair<MaybeOptimum<int64_t>, MaybeOptimum<int64_t>>
   computeIntegerBounds(ArrayRef<int64_t> coeffs);
 
   /// Returns true if the polytope is unbounded, i.e., extends to infinity in
   /// some direction. Otherwise, returns false.
   bool isUnbounded();
 
   /// Make a tableau to represent a pair of points in the given tableaus, one in
   /// tableau A and one in B.
private:
 
   /// Compute the maximum or minimum of the specified Unknown, depending on
   /// direction. The specified unknown may be pivoted. If the unknown is
   /// restricted, it will have a non-negative sample value on return.
   /// Should not be called if the Simplex is empty.
   ///
   /// Returns a Fraction denoting the optimum, or a null value if no optimum
   /// exists, i.e., if the expression is unbounded in this direction.
-  presburger_utils::MaybeOptimum<Fraction> computeOptimum(Direction direction,
-                                                          Unknown &u);
+  MaybeOptimum<Fraction> computeOptimum(Direction direction, Unknown &u);
 
   /// Mark the specified unknown redundant. This operation is added to the undo
   /// log and will be undone by rollbacks. The specified unknown must be in row
   /// orientation.
   void markRowRedundant(Unknown &u);
 
   /// Reduce the given basis, starting at the specified level, using general
   /// basis reduction.
   void reduceBasis(Matrix &basis, unsigned level);
 };
 
+} // namespace presburger
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_PRESBURGER_SIMPLEX_H

mlir/include/mlir/Analysis/Presburger/Utils.h

 
 #ifndef MLIR_ANALYSIS_PRESBURGER_UTILS_H
 #define MLIR_ANALYSIS_PRESBURGER_UTILS_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/STLExtras.h"
 
 namespace mlir {
+namespace presburger {
 
 class IntegerPolyhedron;
 
-namespace presburger_utils {
-
 /// This class represents the result of operations optimizing something subject
 /// to some constraints. If the constraints were not satisfiable the, kind will
 /// be Empty. If the optimum is unbounded, the kind is Unbounded, and if the
 /// optimum is bounded, the kind will be Bounded and `optimum` holds the optimal
 /// value.
 enum class OptimumKind { Empty, Unbounded, Bounded };
 template <typename T>
 class MaybeOptimum {

 /// it's each instance is replaced by `i^th` division. If it returns `false`,
 /// the divisions are not merged. `merge` can also do side effects, For example
 /// it can merge the local identifiers in IntegerPolyhedron.
 void removeDuplicateDivs(
     std::vector<SmallVector<int64_t, 8>> &divs,
     SmallVectorImpl<unsigned> &denoms, unsigned localOffset,
     llvm::function_ref<bool(unsigned i, unsigned j)> merge);
 
-} // namespace presburger_utils
+} // namespace presburger
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_PRESBURGER_UTILS_H

mlir/include/mlir/Dialect/Affine/Analysis/AffineStructures.h

 /// representational power. Each local identifier is always (by construction) a
 /// floordiv of a pure add/mul affine function of dimensional, symbolic, and
 /// other local identifiers, in a non-mutually recursive way. Hence, every local
 /// identifier can ultimately always be recovered as an affine function of
 /// dimensional and symbolic identifiers (involving floordiv's); note however
 /// that some floordiv combinations are converted to mod's by AffineExpr
 /// construction.
 ///
-class FlatAffineConstraints : public IntegerPolyhedron {
+class FlatAffineConstraints : public presburger::IntegerPolyhedron {
 public:
   /// Constructs a constraint system reserving memory for the specified number
   /// of constraints and identifiers.
   FlatAffineConstraints(unsigned numReservedInequalities,
                         unsigned numReservedEqualities,
                         unsigned numReservedCols, unsigned numDims,
                         unsigned numSymbols, unsigned numLocals)
       : IntegerPolyhedron(numReservedInequalities, numReservedEqualities,

mlir/lib/Analysis/Presburger/IntegerPolyhedron.cpp

 #include "mlir/Analysis/Presburger/Utils.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "presburger"
 
 using namespace mlir;
-using namespace presburger_utils;
+using namespace presburger;
+
 using llvm::SmallDenseMap;
 using llvm::SmallDenseSet;
 
 std::unique_ptr<IntegerPolyhedron> IntegerPolyhedron::clone() const {
   return std::make_unique<IntegerPolyhedron>(*this);
 }
 
 void IntegerPolyhedron::reset(unsigned numReservedInequalities,

mlir/lib/Analysis/Presburger/LinearTransform.cpp

 //===- LinearTransform.cpp - MLIR LinearTransform Class -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Presburger/LinearTransform.h"
 #include "mlir/Analysis/Presburger/IntegerPolyhedron.h"
 
-namespace mlir {
+using namespace mlir;
+using namespace presburger;
 
 LinearTransform::LinearTransform(Matrix &&oMatrix) : matrix(oMatrix) {}
 LinearTransform::LinearTransform(const Matrix &oMatrix) : matrix(oMatrix) {}
 
 // Set M(row, targetCol) to its remainder on division by M(row, sourceCol)
 // by subtracting from column targetCol an appropriate integer multiple of
 // sourceCol. This brings M(row, targetCol) to the range [0, M(row, sourceCol)).
 // Apply the same column operation to otherMatrix, with the same integer
for (unsigned i = 0, e = poly.getNumInequalities(); i < e; ++i) {
 
     SmallVector<int64_t, 8> newIneq = preMultiplyWithRow(ineq.drop_back());
     newIneq.push_back(c);
     result.addInequality(newIneq);
   }
 
   return result;
 }
-
-} // namespace mlir

mlir/lib/Analysis/Presburger/Matrix.cpp

 //===- Matrix.cpp - MLIR Matrix Class -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Presburger/Matrix.h"
 #include "llvm/Support/MathExtras.h"
 
-namespace mlir {
+using namespace mlir;
+using namespace presburger;
 
 Matrix::Matrix(unsigned rows, unsigned columns, unsigned reservedRows,
                unsigned reservedColumns)
     : nRows(rows), nColumns(columns),
       nReservedColumns(std::max(nColumns, reservedColumns)),
       data(nRows * nReservedColumns) {
   data.reserve(std::max(nRows, reservedRows) * nReservedColumns);
 }
bool Matrix::hasConsistentState() const {
   if (nColumns > nReservedColumns)
     return false;
   for (unsigned r = 0; r < nRows; ++r)
     for (unsigned c = nColumns; c < nReservedColumns; ++c)
       if (data[r * nReservedColumns + c] != 0)
         return false;
   return true;
 }
-
-} // namespace mlir

mlir/lib/Analysis/Presburger/PWMAFunction.cpp

 //===- PWMAFunction.cpp - MLIR PWMAFunction Class -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Presburger/PWMAFunction.h"
 #include "mlir/Analysis/Presburger/Simplex.h"
 
 using namespace mlir;
+using namespace presburger;
 
 // Return the result of subtracting the two given vectors pointwise.
 // The vectors must be of the same size.
 // e.g., [3, 4, 6] - [2, 5, 1] = [1, -1, 5].
 static SmallVector<int64_t, 8> subtract(ArrayRef<int64_t> vecA,
                                         ArrayRef<int64_t> vecB) {
   assert(vecA.size() == vecB.size() &&
          "Cannot subtract vectors of differing lengths!");

mlir/lib/Analysis/Presburger/PresburgerSet.cpp

 //===- Set.cpp - MLIR PresburgerSet Class ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Presburger/PresburgerSet.h"
 #include "mlir/Analysis/Presburger/Simplex.h"
 #include "mlir/Analysis/Presburger/Utils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallBitVector.h"
 
 using namespace mlir;
-using namespace presburger_utils;
+using namespace presburger;
 
 PresburgerSet::PresburgerSet(const IntegerPolyhedron &poly)
     : PresburgerSpace(poly) {
   unionPolyInPlace(poly);
 }
 
 unsigned PresburgerSet::getNumPolys() const {
   return integerPolyhedrons.size();

mlir/lib/Analysis/Presburger/PresburgerSpace.cpp

 //===- PresburgerSpace.cpp - MLIR PresburgerSpace Class -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Presburger/PresburgerSpace.h"
 #include <algorithm>
 #include <cassert>
 
 using namespace mlir;
+using namespace presburger;
 
 PresburgerSpace PresburgerSpace::getRelationSpace(unsigned numDomain,
                                                   unsigned numRange,
                                                   unsigned numSymbols) {
   return PresburgerSpace(numDomain, numRange, numSymbols);
 }
 
 PresburgerSpace PresburgerSpace::getSetSpace(unsigned numDims,

mlir/lib/Analysis/Presburger/Simplex.cpp

 //===- Simplex.cpp - MLIR Simplex Class -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Presburger/Simplex.h"
 #include "mlir/Analysis/Presburger/Matrix.h"
 #include "mlir/Support/MathExtras.h"
 #include "llvm/ADT/Optional.h"
 
-namespace mlir {
+using namespace mlir;
+using namespace presburger;
 
-using namespace presburger_utils;
 using Direction = Simplex::Direction;
 
 const int nullIndex = std::numeric_limits<int>::max();
 
 SimplexBase::SimplexBase(unsigned nVar, bool mustUseBigM)
     : usingBigM(mustUseBigM), nRow(0), nCol(getNumFixedCols() + nVar),
       nRedundant(0), tableau(0, nCol), empty(false) {
   colUnknown.insert(colUnknown.begin(), getNumFixedCols(), nullIndex);

 /// some operations needed for generalized basis reduction. In what follows,
 /// dotProduct(x, y) = x_1 * y_1 + x_2 * y_2 + ... x_n * y_n where n is the
 /// dimension of the original polytope.
 ///
 /// This supports adding equality constraints dotProduct(dir, x - y) == 0. It
 /// also supports rolling back this addition, by maintaining a snapshot stack
 /// that contains a snapshot of the Simplex's state for each equality, just
 /// before that equality was added.
-class GBRSimplex {
+class presburger::GBRSimplex {
   using Orientation = Simplex::Orientation;
 
 public:
   GBRSimplex(const Simplex &originalSimplex)
       : simplex(Simplex::makeProduct(originalSimplex, originalSimplex)),
         simplexConstraintOffset(simplex.getNumConstraints()) {}
 
   /// Add an equality dotProduct(dir, x - y) == 0.
assert(!empty &&
          "It is not meaningful to ask about redundancy in an empty set!");
   MaybeOptimum<Fraction> minimum = computeOptimum(Direction::Down, coeffs);
   MaybeOptimum<Fraction> maximum = computeOptimum(Direction::Up, coeffs);
   assert((!minimum.isEmpty() && !maximum.isEmpty()) &&
          "Optima should be non-empty for a non-empty set");
   return minimum.isBounded() && maximum.isBounded() &&
          *maximum == Fraction(0, 1) && *minimum == Fraction(0, 1);
 }
-
-} // namespace mlir

mlir/lib/Analysis/Presburger/Utils.cpp

 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Presburger/Utils.h"
 #include "mlir/Analysis/Presburger/IntegerPolyhedron.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Support/MathExtras.h"
 
 using namespace mlir;
-using namespace presburger_utils;
+using namespace presburger;
 
 /// Normalize a division's `dividend` and the `divisor` by their GCD. For
 /// example: if the dividend and divisor are [2,0,4] and 4 respectively,
 /// they get normalized to [1,0,2] and 2.
 static void normalizeDivisionByGCD(SmallVectorImpl<int64_t> &dividend,
                                    unsigned &divisor) {
   if (divisor == 0 || dividend.empty())
     return;

 /// function of other identifiers (where the divisor is a positive constant).
 /// `foundRepr` contains a boolean for each identifier indicating if the
 /// explicit representation for that identifier has already been computed.
 /// Returns the `MaybeLocalRepr` struct which contains the indices of the
 /// constraints that can be expressed as a floordiv of an affine function. If
 /// the representation could be computed, `dividend` and `denominator` are set.
 /// If the representation could not be computed, the kind attribute in
 /// `MaybeLocalRepr` is set to None.
-MaybeLocalRepr presburger_utils::computeSingleVarRepr(
+MaybeLocalRepr presburger::computeSingleVarRepr(
     const IntegerPolyhedron &cst, ArrayRef<bool> foundRepr, unsigned pos,
     SmallVector<int64_t, 8> &dividend, unsigned &divisor) {
   assert(pos < cst.getNumIds() && "invalid position");
   assert(foundRepr.size() == cst.getNumIds() &&
          "Size of foundRepr does not match total number of variables");
 
   SmallVector<unsigned, 4> lbIndices, ubIndices, eqIndices;
   cst.getLowerAndUpperBoundIndices(pos, &lbIndices, &ubIndices, &eqIndices);
for (unsigned eqPos : eqIndices) {
 
     repr.kind = ReprKind::Equality;
     repr.repr.equalityIdx = eqPos;
     return repr;
   }
   return repr;
 }
 
-void presburger_utils::removeDuplicateDivs(
+void presburger::removeDuplicateDivs(
     std::vector<SmallVector<int64_t, 8>> &divs,
     SmallVectorImpl<unsigned> &denoms, unsigned localOffset,
     llvm::function_ref<bool(unsigned i, unsigned j)> merge) {
 
   // Find and merge duplicate divisions.
   // TODO: Add division normalization to support divisions that differ by
   // a constant.
   // TODO: Add division ordering such that a division representation for local

mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp

 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "affine-structures"
 
 using namespace mlir;
-using namespace presburger_utils;
+using namespace presburger;
 
 namespace {
 
 // See comments for SimpleAffineExprFlattener.
 // An AffineExprFlattener extends a SimpleAffineExprFlattener by recording
 // constraint information associated with mod's, floordiv's, and ceildiv's
 // in FlatAffineConstraints 'localVarCst'.
 struct AffineExprFlattener : public SimpleAffineExprFlattener {

mlir/lib/Dialect/Affine/Analysis/Utils.cpp

 #include "mlir/IR/IntegerSet.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "analysis-utils"
 
 using namespace mlir;
+using namespace presburger;
 
 using llvm::SmallDenseMap;
 
 /// Populates 'loops' with IVs of the loops surrounding 'op' ordered from
 /// the outermost 'affine.for' operation to the innermost one.
 void mlir::getLoopIVs(Operation &op, SmallVectorImpl<AffineForOp> *loops) {
   auto *currOp = op.getParentOp();
   AffineForOp currAffineForOp;

mlir/unittests/Analysis/Presburger/IntegerPolyhedronTest.cpp

 #include "mlir/Analysis/Presburger/Simplex.h"
 #include "mlir/IR/MLIRContext.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 #include <numeric>
 
-namespace mlir {
-using namespace presburger_utils;
+using namespace mlir;
+using namespace presburger;
+
 using testing::ElementsAre;
 
 enum class TestFunction { Sample, Empty };
 
 /// Construct a IntegerPolyhedron from a set of inequality and
 /// equality constraints.
 static IntegerPolyhedron
 makeSetFromConstraints(unsigned ids, ArrayRef<SmallVector<int64_t, 4>> ineqs,
expectComputedVolumeIsValidOverapprox(
                 "y - 2*(y floordiv 2) == 0)"),
       /*trueVolume=*/61ull, /*resultBound=*/441ull);
 
   // Unbounded polytope.
   expectComputedVolumeIsValidOverapprox(
       parsePoly("(x, y) : (2*x - y >= 0, y - 3*x >= 0)"),
       /*trueVolume=*/{}, /*resultBound=*/{});
 }
-
-} // namespace mlir

mlir/unittests/Analysis/Presburger/LinearTransformTest.cpp

 //===- LinearTransformTest.cpp - Tests for LinearTransform ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Presburger/LinearTransform.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-namespace mlir {
+using namespace mlir;
+using namespace presburger;
 
 void testColumnEchelonForm(const Matrix &m, unsigned expectedRank) {
   unsigned lastAllowedNonZeroCol = 0;
   std::pair<unsigned, LinearTransform> result =
       LinearTransform::makeTransformToColumnEchelon(m);
   unsigned rank = result.first;
   EXPECT_EQ(rank, expectedRank);
   LinearTransform transform = result.second;
TEST(LinearTransformTest, transformToColumnEchelonTest) {
 
   Matrix m6(2, 2);
   m6(0, 0) = -4;
   m6(0, 1) = -7;
   m6(1, 0) = 4;
   m6(1, 1) = -7;
   testColumnEchelonForm(m5, 2u);
 }
-} // namespace mlir

mlir/unittests/Analysis/Presburger/MatrixTest.cpp

 //===- MatrixTest.cpp - Tests for Matrix ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Presburger/Matrix.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-namespace mlir {
+using namespace mlir;
+using namespace presburger;
 
 TEST(MatrixTest, ReadWrite) {
   Matrix mat(5, 5);
   for (unsigned row = 0; row < 5; ++row)
     for (unsigned col = 0; col < 5; ++col)
       mat(row, col) = 10 * row + col;
   for (unsigned row = 0; row < 5; ++row)
     for (unsigned col = 0; col < 5; ++col)
TEST(MatrixTest, resize) {
   mat.resize(7, 7);
   ASSERT_TRUE(mat.hasConsistentState());
   EXPECT_EQ(mat.getNumRows(), 7u);
   EXPECT_EQ(mat.getNumColumns(), 7u);
   for (unsigned row = 0; row < 7; ++row)
     for (unsigned col = 0; col < 7; ++col)
       EXPECT_EQ(mat(row, col), row >= 3 || col >= 3 ? 0 : int(10 * row + col));
 }
-
-} // namespace mlir

mlir/unittests/Analysis/Presburger/PWMAFunctionTest.cpp

 
 #include "mlir/Analysis/Presburger/PWMAFunction.h"
 #include "mlir/Analysis/Presburger/PresburgerSet.h"
 #include "mlir/IR/MLIRContext.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-namespace mlir {
+using namespace mlir;
+using namespace presburger;
+
 using testing::ElementsAre;
 
 static Matrix makeMatrix(unsigned numRow, unsigned numColumns,
                          ArrayRef<SmallVector<int64_t, 8>> matrix) {
   Matrix results(numRow, numColumns);
   assert(matrix.size() == numRow);
   for (unsigned i = 0; i < numRow; ++i) {
     assert(matrix[i].size() == numColumns &&
PWMAFunction nonNegPWAF = parsePWMAF(
           {"(x, y) : (x >= 0)", {{1, 2, 3}, {3, 4, 5}}}, // (x, y).
           {"(x, y) : (y >= 0, -x - 1 >= 0)", {{-1, 2, 3}, {-3, 4, 5}}} // (x, y)
       });
   EXPECT_THAT(*nonNegPWAF.valueAt({2, 3}), ElementsAre(11, 23));
   EXPECT_THAT(*nonNegPWAF.valueAt({-2, 3}), ElementsAre(11, 23));
   EXPECT_THAT(*nonNegPWAF.valueAt({2, -3}), ElementsAre(-1, -1));
   EXPECT_FALSE(nonNegPWAF.valueAt({-2, -3}).hasValue());
 }
-
-} // namespace mlir

mlir/unittests/Analysis/Presburger/PresburgerSetTest.cpp

 
 #include "mlir/Analysis/Presburger/PresburgerSet.h"
 #include "./Utils.h"
 #include "mlir/IR/MLIRContext.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-namespace mlir {
+using namespace mlir;
+using namespace presburger;
+
 /// Parse a list of StringRefs to IntegerPolyhedron and combine them into a
 /// PresburgerSet be using the union operation. It is expected that the strings
 /// are all valid IntegerSet representation and that all of them have the same
 /// number of dimensions as is specified by the numDims argument.
 static PresburgerSet
 parsePresburgerSetFromPolyStrings(unsigned numDims, ArrayRef<StringRef> strs) {
   PresburgerSet set = PresburgerSet::getEmptySet(numDims);
   for (StringRef str : strs)
TEST(SetTest, computeVolume) {
   expectComputedVolumeIsValidOverapprox(unbounded, /*trueVolume=*/{},
                                         /*resultBound=*/{});
 
   // Union of unbounded with bounded is unbounded.
   expectComputedVolumeIsValidOverapprox(unbounded.unionSet(diamond),
                                         /*trueVolume=*/{},
                                         /*resultBound=*/{});
 }
-
-} // namespace mlir

mlir/unittests/Analysis/Presburger/PresburgerSpaceTest.cpp

 //===- PresburgerSpaceTest.cpp - Tests for PresburgerSpace ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Presburger/PresburgerSpace.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 using namespace mlir;
+using namespace presburger;
+
 using IdKind = PresburgerSpace::IdKind;
 
 TEST(PresburgerSpaceTest, insertId) {
   PresburgerSpace space = PresburgerSpace::getRelationSpace(2, 2, 1);
 
   // Try inserting 2 domain ids.
   space.insertId(PresburgerSpace::IdKind::Domain, 0, 2);
   EXPECT_EQ(space.getNumDomainIds(), 4u);

mlir/unittests/Analysis/Presburger/SimplexTest.cpp

 //===- SimplexTest.cpp - Tests for Simplex --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "./Utils.h"
 
 #include "mlir/Analysis/Presburger/Simplex.h"
 #include "mlir/IR/MLIRContext.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-namespace mlir {
-using namespace presburger_utils;
+using namespace mlir;
+using namespace presburger;
 
 /// Take a snapshot, add constraints making the set empty, and rollback.
 /// The set should not be empty after rolling back. We add additional
 /// constraints after the set is already empty and roll back the addition
 /// of these. The set should be marked non-empty only once we rollback
 /// past the addition of the first constraint that made it empty.
 TEST(SimplexTest, emptyRollback) {
   Simplex simplex(2);
TEST(SimplexTest, IsRationalSubsetOf) {
   EXPECT_FALSE(sim1.isRationalSubsetOf(s2));
   EXPECT_FALSE(sim1.isRationalSubsetOf(empty));
 
   EXPECT_TRUE(sim2.isRationalSubsetOf(univ));
   EXPECT_TRUE(sim2.isRationalSubsetOf(s1));
   EXPECT_TRUE(sim2.isRationalSubsetOf(s2));
   EXPECT_FALSE(sim2.isRationalSubsetOf(empty));
 }
-
-} // namespace mlir

mlir/unittests/Analysis/Presburger/Utils.h

 #include "../../Dialect/Affine/Analysis/AffineStructuresParser.h"
 #include "mlir/Analysis/Presburger/IntegerPolyhedron.h"
 #include "mlir/Analysis/Presburger/PresburgerSet.h"
 #include "mlir/IR/MLIRContext.h"
 
 #include <gtest/gtest.h>
 
 namespace mlir {
+namespace presburger {
+
 /// Parses a IntegerPolyhedron from a StringRef. It is expected that the
 /// string represents a valid IntegerSet, otherwise it will violate a gtest
 /// assertion.
 inline IntegerPolyhedron parsePoly(StringRef str) {
   MLIRContext context(MLIRContext::Threading::DISABLED);
   FailureOr<IntegerPolyhedron> poly = parseIntegerSetToFAC(str, &context);
   EXPECT_TRUE(succeeded(poly));
   return *poly;

 expectComputedVolumeIsValidOverapprox(Optional<uint64_t> computedVolume,
                                       Optional<uint64_t> trueVolume,
                                       Optional<uint64_t> resultBound) {
   assert(infinityOrUInt64LE(trueVolume, resultBound) &&
          "can't expect result to be less than the true volume");
   EXPECT_TRUE(infinityOrUInt64LE(trueVolume, computedVolume));
   EXPECT_TRUE(infinityOrUInt64LE(computedVolume, resultBound));
 }
+
+} // namespace presburger
 } // namespace mlir
 
 #endif // MLIR_UNITTESTS_ANALYSIS_PRESBURGER_UTILS_H

mlir/unittests/Dialect/Affine/Analysis/AffineStructuresParser.h

 
 #ifndef MLIR_UNITTEST_ANALYSIS_AFFINESTRUCTURESPARSER_H
 #define MLIR_UNITTEST_ANALYSIS_AFFINESTRUCTURESPARSER_H
 
 #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
 #include "mlir/Support/LogicalResult.h"
 
 namespace mlir {
+
 /// This parses a single IntegerSet to an MLIR context and transforms it to
 /// FlatAffineConstraints if it was valid. If not, a failure is returned. If the
 /// passed `str` has additional tokens that were not part of the IntegerSet, a
 /// failure is returned. Diagnostics are printed on failure if
 /// `printDiagnosticInfo` is true.
 
 FailureOr<FlatAffineConstraints>
 parseIntegerSetToFAC(llvm::StringRef, MLIRContext *context,
                      bool printDiagnosticInfo = true);
 
 } // namespace mlir
 
 #endif // MLIR_UNITTEST_ANALYSIS_AFFINESTRUCTURESPARSER_H

mlir/unittests/Dialect/Affine/Analysis/AffineStructuresParserTest.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "./AffineStructuresParser.h"
 #include "mlir/Analysis/Presburger/PresburgerSet.h"
 
 #include <gtest/gtest.h>
 
-namespace mlir {
+using namespace mlir;
+using namespace presburger;
 
 /// Construct a FlatAffineConstraints from a set of inequality, equality, and
 /// division onstraints.
 static FlatAffineConstraints makeFACFromConstraints(
     unsigned dims, unsigned syms, ArrayRef<SmallVector<int64_t, 4>> ineqs,
     ArrayRef<SmallVector<int64_t, 4>> eqs = {},
     ArrayRef<std::pair<SmallVector<int64_t, 4>, int64_t>> divs = {}) {
   FlatAffineConstraints fac(ineqs.size(), eqs.size(), dims + syms + 1, dims,
TEST(ParseFACTest, ParseAndCompareTest) {
 
   // nested floordiv
   EXPECT_TRUE(parseAndCompare(
       "(x, y) : (y - (x + y floordiv 2) floordiv 3 == 0)",
       makeFACFromConstraints(2, 0, {}, {{0, 1, 0, -1, 0}},
                              {{{0, 1, 0}, 2}, {{1, 0, 1, 0}, 3}}),
       &context));
 }
-
-} // namespace mlir