[MLIR][Presburger] Simplex: remove redundant zeroing out of row

[arjunp]

Summary

This fillRow(..., 0) is redundant because when the size of the tableau is
consistent, the resize always creates a new row, which is zero-initialized.

Also added asserts throughout to ensure the dimensions of the tableau remain
consistent.

[arjunp]

format

[arjunp]

fix build

[Groverkss]

mlir/lib/Analysis/Presburger/Simplex.cpp

88

I think we can do it as part of this patch itself. Seems like a simple find and replace.

[arjunp]

mlir/lib/Analysis/Presburger/Simplex.cpp

88

It clutters the patch a lot, I prefer not to do it in the same one.

[Groverkss]

LGTM.

mlir/lib/Analysis/Presburger/Simplex.cpp

88

Sure.

mlir/lib/Analysis/Presburger/Simplex.cpp

 
 Simplex::Unknown &SimplexBase::unknownFromRow(unsigned row) {
   assert(row < nRow && "Invalid row");
   return unknownFromIndex(rowUnknown[row]);
 }
 
 unsigned SimplexBase::addZeroRow(bool makeRestricted) {
   ++nRow;
-  // If the tableau is not big enough to accomodate the extra row, we extend it.
-  if (nRow >= tableau.getNumRows())
-    tableau.resizeVertically(nRow);
+  // Resize the tableau to accommodate the extra row.
+  // TODO: consider eliminating nRow, as it stores redundant information.
+  assert(tableau.getNumRows() == nRow && "Inconsistent tableau size");
   rowUnknown.push_back(~con.size());
   con.emplace_back(Orientation::Row, makeRestricted, nRow - 1);
   undoLog.push_back(UndoLogEntry::RemoveLastConstraint);
-
-  // Zero out the new row.
-  tableau.fillRow(nRow - 1, 0);
-
   tableau(nRow - 1, 0) = 1;
   return con.size() - 1;
 }
 
 /// Add a new row to the tableau corresponding to the given constant term and
 /// list of coefficients. The coefficients are specified as a vector of
 /// (variable index, coefficient) pairs.
 unsigned SimplexBase::addRow(ArrayRef<int64_t> coeffs, bool makeRestricted) {
void SimplexBase::removeLastConstraintRowOrientation() {
 
   // Move this unknown to the last row and remove the last row from the
   // tableau.
   swapRows(con.back().pos, nRow - 1);
   // It is not strictly necessary to shrink the tableau, but for now we
   // maintain the invariant that the tableau has exactly nRow rows.
   tableau.resizeVertically(nRow - 1);
   nRow--;
+  assert(tableau.getNumRows() == nRow && "inconsistent tableau size!");
   rowUnknown.pop_back();
   con.pop_back();
 }
 
 // This doesn't find a pivot row only if the column has zero
 // coefficients for every row.
 //
 // If the unknown is a constraint, this can't happen, since it was added
if (entry == UndoLogEntry::RemoveLastConstraint) {
 
     // Move this variable to the last column and remove the column from the
     // tableau.
     swapColumns(var.back().pos, nCol - 1);
     tableau.resizeHorizontally(nCol - 1);
     var.pop_back();
     colUnknown.pop_back();
     nCol--;
+    assert(tableau.getNumColumns() == nCol && "inconsistent tableau size!");
   } else if (entry == UndoLogEntry::UnmarkEmpty) {
     empty = false;
   } else if (entry == UndoLogEntry::UnmarkLastRedundant) {
     nRedundant--;
   } else if (entry == UndoLogEntry::RestoreBasis) {
     assert(!savedBases.empty() && "No bases saved!");
 
     SmallVector<int, 8> basis = std::move(savedBases.back());
void SimplexBase::appendVariable(unsigned count) {
   colUnknown.reserve(colUnknown.size() + count);
   for (unsigned i = 0; i < count; ++i) {
     nCol++;
     var.emplace_back(Orientation::Column, /*restricted=*/false,
                      /*pos=*/nCol - 1);
     colUnknown.push_back(var.size() - 1);
   }
   tableau.resizeHorizontally(nCol);
+  assert(tableau.getNumColumns() == nCol);
   undoLog.insert(undoLog.end(), count, UndoLogEntry::RemoveLastVariable);
 }
 
 /// Add all the constraints from the given IntegerRelation.
 void SimplexBase::intersectIntegerRelation(const IntegerRelation &rel) {
   assert(rel.getNumIds() == getNumVariables() &&
          "IntegerRelation must have same dimensionality as simplex");
   for (unsigned i = 0, e = rel.getNumInequalities(); i < e; ++i)
for (unsigned row = 0; row < a.nRedundant; ++row)
     appendRowFromA(row);
   for (unsigned row = 0; row < b.nRedundant; ++row)
     appendRowFromB(row);
   for (unsigned row = a.nRedundant; row < a.nRow; ++row)
     appendRowFromA(row);
   for (unsigned row = b.nRedundant; row < b.nRow; ++row)
     appendRowFromB(row);
 
+  assert(result.tableau.getNumRows() == result.nRow &&
+         "inconsistent row size!");
+  assert(result.tableau.getNumColumns() == result.nCol &&
+         "inconsistent row size!");
   return result;
 }
 
 Optional<SmallVector<Fraction, 8>> Simplex::getRationalSample() const {
   if (empty)
     return {};
 
   SmallVector<Fraction, 8> sample;