Revert "[MLIR][Presburger] Template Matrix to allow MPInt and Fraction (llvm#65272)"

This reverts commit efca035. Reverting due to windows build bot failure: https://lab.llvm.org/buildbot/#/builders/13/builds/40242/steps/6/logs/stdio

Author: Superty

mlir/include/mlir/Analysis/Presburger/IntegerRelation.h

@@ -366,7 +366,7 @@ class IntegerRelation {
  /// bounded. The span of the returned vectors is guaranteed to contain all
  /// such vectors. The returned vectors are NOT guaranteed to be linearly
  /// independent. This function should not be called on empty sets.
- Matrix<MPInt> getBoundedDirections() const;
+ Matrix getBoundedDirections() const;
 
  /// Find an integer sample point satisfying the constraints using a
  /// branch and bound algorithm with generalized basis reduction, with some
@@ -792,10 +792,10 @@ class IntegerRelation {
  PresburgerSpace space;
 
  /// Coefficients of affine equalities (in == 0 form).
- Matrix<MPInt> equalities;
+ Matrix equalities;
 
  /// Coefficients of affine inequalities (in >= 0 form).
- Matrix<MPInt> inequalities;
+ Matrix inequalities;
 };
 
 /// An IntegerPolyhedron represents the set of points from a PresburgerSpace

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

@@ -22,8 +22,8 @@ namespace presburger {
 
 class LinearTransform {
 public:
- explicit LinearTransform(Matrix<MPInt> &&oMatrix);
- explicit LinearTransform(const Matrix<MPInt> &oMatrix);
+ 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.
@@ -32,7 +32,7 @@ class LinearTransform {
  // strictly below that of the previous column, and all columns which have only
  // zeros are at the end.
  static std::pair<unsigned, LinearTransform>
- makeTransformToColumnEchelon(const Matrix<MPInt> &m);
+ makeTransformToColumnEchelon(const Matrix &m);
 
  // Returns an IntegerRelation having a constraint vector vT for every
  // constraint vector v in rel, where T is this transform.
@@ -50,12 +50,8 @@ class LinearTransform {
  return matrix.postMultiplyWithColumn(colVec);
  }
 
- // Compute the determinant of the transform by converting it to row echelon
- // form and then taking the product of the diagonal.
- MPInt determinant();
-
 private:
- Matrix<MPInt> matrix;
+ Matrix matrix;
 };
 
 } // namespace presburger

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

@@ -7,17 +7,15 @@
 //===----------------------------------------------------------------------===//
 //
 // This is a simple 2D matrix class that supports reading, writing, resizing,
-// swapping rows, and swapping columns. It can hold integers (MPInt) or rational
-// numbers (Fraction).
+// swapping rows, and swapping columns.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_ANALYSIS_PRESBURGER_MATRIX_H
 #define MLIR_ANALYSIS_PRESBURGER_MATRIX_H
 
+#include "mlir/Analysis/Presburger/MPInt.h"
 #include "mlir/Support/LLVM.h"
-#include "mlir/Analysis/Presburger/Fraction.h"
-#include "mlir/Analysis/Presburger/Matrix.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -34,12 +32,7 @@ namespace presburger {
 /// (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
 /// space in the underlying SmallVector's capacity.
-/// This class only works for the types MPInt and Fraction, since the method
-/// implementations are in the Matrix.cpp file. Only these two types have
-/// been explicitly instantiated there.
-template<typename T>
 class Matrix {
-static_assert(std::is_same_v<T,MPInt> || std::is_same_v<T,Fraction>, "T must be MPInt or Fraction.");
 public:
  Matrix() = delete;
 
@@ -56,21 +49,21 @@ static_assert(std::is_same_v<T,MPInt> || std::is_same_v<T,Fraction>, "T must be
  static Matrix identity(unsigned dimension);
 
  /// Access the element at the specified row and column.
- T &at(unsigned row, unsigned column) {
+ MPInt &at(unsigned row, unsigned column) {
  assert(row < nRows && "Row outside of range");
  assert(column < nColumns && "Column outside of range");
  return data[row * nReservedColumns + column];
  }
 
- T at(unsigned row, unsigned column) const {
+ MPInt at(unsigned row, unsigned column) const {
  assert(row < nRows && "Row outside of range");
  assert(column < nColumns && "Column outside of range");
  return data[row * nReservedColumns + column];
  }
 
- T &operator()(unsigned row, unsigned column) { return at(row, column); }
+ MPInt &operator()(unsigned row, unsigned column) { return at(row, column); }
 
- T operator()(unsigned row, unsigned column) const {
+ MPInt operator()(unsigned row, unsigned column) const {
  return at(row, column);
  }
 
@@ -94,11 +87,11 @@ static_assert(std::is_same_v<T,MPInt> || std::is_same_v<T,Fraction>, "T must be
  void reserveRows(unsigned rows);
 
  /// Get a [Mutable]ArrayRef corresponding to the specified row.
- MutableArrayRef<T> getRow(unsigned row);
- ArrayRef<T> getRow(unsigned row) const;
+ MutableArrayRef<MPInt> getRow(unsigned row);
+ ArrayRef<MPInt> getRow(unsigned row) const;
 
  /// Set the specified row to `elems`.
- void setRow(unsigned row, ArrayRef<T> elems);
+ void setRow(unsigned row, ArrayRef<MPInt> elems);
 
  /// Insert columns having positions pos, pos + 1, ... pos + count - 1.
  /// Columns that were at positions 0 to pos - 1 will stay where they are;
@@ -132,23 +125,23 @@ static_assert(std::is_same_v<T,MPInt> || std::is_same_v<T,Fraction>, "T must be
 
  void copyRow(unsigned sourceRow, unsigned targetRow);
 
- void fillRow(unsigned row, const T &value);
- void fillRow(unsigned row, int64_t value) { fillRow(row, T(value)); }
+ void fillRow(unsigned row, const MPInt &value);
+ void fillRow(unsigned row, int64_t value) { fillRow(row, MPInt(value)); }
 
  /// Add `scale` multiples of the source row to the target row.
- void addToRow(unsigned sourceRow, unsigned targetRow, const T &scale);
+ void addToRow(unsigned sourceRow, unsigned targetRow, const MPInt &scale);
  void addToRow(unsigned sourceRow, unsigned targetRow, int64_t scale) {
- addToRow(sourceRow, targetRow, T(scale));
+ addToRow(sourceRow, targetRow, MPInt(scale));
  }
  /// Add `scale` multiples of the rowVec row to the specified row.
- void addToRow(unsigned row, ArrayRef<T> rowVec, const T &scale);
+ void addToRow(unsigned row, ArrayRef<MPInt> rowVec, const MPInt &scale);
 
  /// Add `scale` multiples of the source column to the target column.
  void addToColumn(unsigned sourceColumn, unsigned targetColumn,
- const T &scale);
+ const MPInt &scale);
  void addToColumn(unsigned sourceColumn, unsigned targetColumn,
  int64_t scale) {
- addToColumn(sourceColumn, targetColumn, T(scale));
+ addToColumn(sourceColumn, targetColumn, MPInt(scale));
  }
 
  /// Negate the specified column.
@@ -159,18 +152,18 @@ static_assert(std::is_same_v<T,MPInt> || std::is_same_v<T,Fraction>, "T must be
 
  /// Divide the first `nCols` of the specified row by their GCD.
  /// Returns the GCD of the first `nCols` of the specified row.
- T normalizeRow(unsigned row, unsigned nCols);
+ MPInt normalizeRow(unsigned row, unsigned nCols);
  /// Divide the columns of the specified row by their GCD.
  /// Returns the GCD of the columns of the specified row.
- T normalizeRow(unsigned row);
+ MPInt normalizeRow(unsigned row);
 
  /// The given vector is interpreted as a row vector v. Post-multiply v with
  /// this matrix, say M, and return vM.
- SmallVector<T, 8> preMultiplyWithRow(ArrayRef<T> rowVec) const;
+ SmallVector<MPInt, 8> preMultiplyWithRow(ArrayRef<MPInt> rowVec) const;
 
  /// The given vector is interpreted as a column vector v. Pre-multiply v with
  /// this matrix, say M, and return Mv.
- SmallVector<T, 8> postMultiplyWithColumn(ArrayRef<T> colVec) const;
+ SmallVector<MPInt, 8> postMultiplyWithColumn(ArrayRef<MPInt> colVec) const;
 
  /// Given the current matrix M, returns the matrices H, U such that H is the
  /// column hermite normal form of M, i.e. H = M * U, where U is unimodular and
@@ -199,7 +192,7 @@ static_assert(std::is_same_v<T,MPInt> || std::is_same_v<T,Fraction>, "T must be
  unsigned appendExtraRow();
  /// Same as above, but copy the given elements into the row. The length of
  /// `elems` must be equal to the number of columns.
- unsigned appendExtraRow(ArrayRef<T> elems);
+ unsigned appendExtraRow(ArrayRef<MPInt> elems);
 
  /// Print the matrix.
  void print(raw_ostream &os) const;
@@ -218,7 +211,7 @@ static_assert(std::is_same_v<T,MPInt> || std::is_same_v<T,Fraction>, "T must be
 
  /// Stores the data. data.size() is equal to nRows * nReservedColumns.
  /// data.capacity() / nReservedColumns is the number of reserved rows.
- SmallVector<T, 16> data;
+ SmallVector<MPInt, 16> data;
 };
 
 } // namespace presburger

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

@@ -40,13 +40,13 @@ enum class OrderingKind { EQ, NE, LT, LE, GT, GE };
 /// value of the function at a specified point.
 class MultiAffineFunction {
 public:
- MultiAffineFunction(const PresburgerSpace &space, const Matrix<MPInt> &output)
+ MultiAffineFunction(const PresburgerSpace &space, const Matrix &output)
  : space(space), output(output),
  divs(space.getNumVars() - space.getNumRangeVars()) {
  assertIsConsistent();
  }
 
- MultiAffineFunction(const PresburgerSpace &space, const Matrix<MPInt> &output,
+ MultiAffineFunction(const PresburgerSpace &space, const Matrix &output,
  const DivisionRepr &divs)
  : space(space), output(output), divs(divs) {
  assertIsConsistent();
@@ -65,7 +65,7 @@ class MultiAffineFunction {
  PresburgerSpace getOutputSpace() const { return space.getRangeSpace(); }
 
  /// Get a matrix with each row representing row^th output expression.
- const Matrix<MPInt> &getOutputMatrix() const { return output; }
+ const Matrix &getOutputMatrix() const { return output; }
  /// Get the `i^th` output expression.
  ArrayRef<MPInt> getOutputExpr(unsigned i) const { return output.getRow(i); }
 
@@ -124,7 +124,7 @@ class MultiAffineFunction {
  /// The function's output is a tuple of integers, with the ith element of the
  /// tuple defined by the affine expression given by the ith row of this output
  /// matrix.
- Matrix<MPInt> output;
+ Matrix output;
 
  /// Storage for division representation for each local variable in space.
  DivisionRepr divs;

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

@@ -338,7 +338,7 @@ class SimplexBase {
  unsigned nSymbol;
 
  /// The matrix representing the tableau.
- Matrix<MPInt> tableau;
+ Matrix tableau;
 
  /// This is true if the tableau has been detected to be empty, false
  /// otherwise.
@@ -861,7 +861,7 @@ class Simplex : public SimplexBase {
 
  /// Reduce the given basis, starting at the specified level, using general
  /// basis reduction.
- void reduceBasis(Matrix<MPInt> &basis, unsigned level);
+ void reduceBasis(Matrix &basis, unsigned level);
 };
 
 /// Takes a snapshot of the simplex state on construction and rolls back to the

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

@@ -182,7 +182,7 @@ class DivisionRepr {
  /// Each row of the Matrix represents a single division dividend. The
  /// `i^th` row represents the dividend of the variable at `divOffset + i`
  /// in the constraint system (and the `i^th` local variable).
- Matrix<MPInt> dividends;
+ Matrix dividends;
 
  /// Denominators of each division. If a denominator of a division is `0`, the
  /// division variable is considered to not have a division representation.

mlir/lib/Analysis/FlatLinearValueConstraints.cpp

@@ -1292,7 +1292,7 @@ mlir::getMultiAffineFunctionFromMap(AffineMap map,
  "AffineMap cannot produce divs without local representation");
 
  // TODO: We shouldn't have to do this conversion.
- Matrix<MPInt> mat(map.getNumResults(), map.getNumInputs() + divs.getNumDivs() + 1);
+ Matrix mat(map.getNumResults(), map.getNumInputs() + divs.getNumDivs() + 1);
  for (unsigned i = 0, e = flattenedExprs.size(); i < e; ++i)
  for (unsigned j = 0, f = flattenedExprs[i].size(); j < f; ++j)
  mat(i, j) = flattenedExprs[i][j];

mlir/lib/Analysis/Presburger/IntegerRelation.cpp

@@ -304,7 +304,7 @@ SymbolicLexOpt IntegerRelation::findSymbolicIntegerLexMax() const {
  // Get lexmax by flipping range sign in the PWMA constraints.
  for (auto &flippedPiece :
  flippedSymbolicIntegerLexMax.lexopt.getAllPieces()) {
- Matrix<MPInt> mat = flippedPiece.output.getOutputMatrix();
+ Matrix mat = flippedPiece.output.getOutputMatrix();
  for (unsigned i = 0, e = mat.getNumRows(); i < e; i++)
  mat.negateRow(i);
  MultiAffineFunction maf(flippedPiece.output.getSpace(), mat);
@@ -738,7 +738,7 @@ bool IntegerRelation::isEmptyByGCDTest() const {
 //
 // It is sufficient to check the perpendiculars of the constraints, as the set
 // of perpendiculars which are bounded must span all bounded directions.
-Matrix<MPInt> IntegerRelation::getBoundedDirections() const {
+Matrix IntegerRelation::getBoundedDirections() const {
  // Note that it is necessary to add the equalities too (which the constructor
  // does) even though we don't need to check if they are bounded; whether an
  // inequality is bounded or not depends on what other constraints, including
@@ -759,7 +759,7 @@ Matrix<MPInt> IntegerRelation::getBoundedDirections() const {
  // The direction vector is given by the coefficients and does not include the
  // constant term, so the matrix has one fewer column.
  unsigned dirsNumCols = getNumCols() - 1;
- Matrix<MPInt> dirs(boundedIneqs.size() + getNumEqualities(), dirsNumCols);
+ Matrix dirs(boundedIneqs.size() + getNumEqualities(), dirsNumCols);
 
  // Copy the bounded inequalities.
  unsigned row = 0;
@@ -845,7 +845,7 @@ IntegerRelation::findIntegerSample() const {
  // m is a matrix containing, in each row, a vector in which S is
  // bounded, such that the linear span of all these dimensions contains all
  // bounded dimensions in S.
- Matrix<MPInt> m = getBoundedDirections();
+ Matrix m = getBoundedDirections();
  // In column echelon form, each row of m occupies only the first rank(m)
  // columns and has zeros on the other columns. The transform T that brings S
  // to column echelon form is unimodular as well, so this is a suitable

mlir/lib/Analysis/Presburger/LinearTransform.cpp

@@ -12,11 +12,11 @@
 using namespace mlir;
 using namespace presburger;
 
-LinearTransform::LinearTransform(Matrix<MPInt> &&oMatrix) : matrix(oMatrix) {}
-LinearTransform::LinearTransform(const Matrix<MPInt> &oMatrix) : matrix(oMatrix) {}
+LinearTransform::LinearTransform(Matrix &&oMatrix) : matrix(oMatrix) {}
+LinearTransform::LinearTransform(const Matrix &oMatrix) : matrix(oMatrix) {}
 
 std::pair<unsigned, LinearTransform>
-LinearTransform::makeTransformToColumnEchelon(const Matrix<MPInt> &m) {
+LinearTransform::makeTransformToColumnEchelon(const Matrix &m) {
  // Compute the hermite normal form of m. This, is by definition, is in column
  // echelon form.
  auto [h, u] = m.computeHermiteNormalForm();