Canonicalize affine set + operands while adding affine.if op domain

[bondhugula]

Summary

Canonicalize affine set + operands in addAffineIfOpDomain. This is to
ensure a unique set of operands for FlatAffineValueConstraints and in
general to provide a simplified set of constraints. For the latter
scenario, this just leads to efficiency improvements as opposed to
functionality.

Fixes: https://github.com/llvm/llvm-project/issues/59461

[bondhugula]

NFC - remove dead stuff from AffineStructures.h

[Lewuathe]

mlir/test/Transforms/memref-dependence-check.mlir

1090

Do we need to call multiple affine.store to reproduce the situation originally reported?

[bondhugula]

mlir/test/Transforms/memref-dependence-check.mlir

1090

Not for dependence checking. To test this change, a single store is sufficient when exercised from dependence analysis. It's the load in the empty set that's key. For scalrep, yes, dependence analysis is triggered when you have multiple stores - to check whether the second store intervenes.

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

public:
   }
 
   /// Create a flat affine constraint system from an AffineValueMap or a list of
   /// these. The constructed system will only include equalities.
   explicit FlatAffineValueConstraints(const AffineValueMap &avm);
   explicit FlatAffineValueConstraints(ArrayRef<const AffineValueMap *> avmRef);
 
   /// Creates an affine constraint system from an IntegerSet.
-  explicit FlatAffineValueConstraints(IntegerSet set);
-
-  FlatAffineValueConstraints(ArrayRef<const AffineValueMap *> avmRef,
-                             IntegerSet set);
+  explicit FlatAffineValueConstraints(IntegerSet set, ValueRange operands = {});
 
   // Construct a hyperrectangular constraint set from ValueRanges that represent
   // induction variables, lower and upper bounds. `ivs`, `lbs` and `ubs` are
   // expected to match one to one. The order of variables and constraints is:
   //
   // ivs | lbs | ubs | eq/ineq
   // ----+-----+-----+---------
   //   1   -1     0      >= 0
public:
   /// operation's Value using IR information stored in its bound maps. The
   /// right variable is first looked up using `forOp`'s Value. Asserts if the
   /// Value corresponding to the 'affine.for' operation isn't found in the
   /// constraint system. Returns failure for the yet unimplemented/unsupported
   /// cases.  Any new variables that are found in the bound operands of the
   /// 'affine.for' operation are added as trailing variables (either
   /// dimensional or symbolic depending on whether the operand is a valid
   /// symbol).
-  //  TODO: add support for non-unit strides.
   LogicalResult addAffineForOpDomain(AffineForOp forOp);
 
   /// Add constraints (lower and upper bounds) for the specified
   /// 'affine.parallel' operation's Value using IR information stored in its
   /// bound maps. Returns failure for the yet unimplemented/unsupported cases.
   /// Asserts if the Value corresponding to the 'affine.parallel' operation
   /// isn't found in the constraint system.
   LogicalResult addAffineParallelOpDomain(AffineParallelOp parallelOp);
public:
 
   /// Looks up the position of the variable with the specified Value. Returns
   /// true if found (false otherwise). `pos` is set to the (column) position of
   /// the variable.
   bool findVar(Value val, unsigned *pos) const;
 
   /// Returns true if an variable with the specified Value exists, false
   /// otherwise.
-  bool containsVar(Value mayBeVar) const;
+  bool containsVar(Value val) const;
 
   /// Swap the posA^th variable with the posB^th variable.
   void swapVar(unsigned posA, unsigned posB) override;
 
   /// Insert variables of the specified kind at position `pos`. Positions are
   /// relative to the kind of variable. The coefficient columns corresponding
   /// to the added variables are initialized to zero. `vals` are the Values
   /// corresponding to the variables. Values should not be used with

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

 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<FlatAffineValueConstraints>
 FlatAffineValueConstraints::clone() const {
   return std::make_unique<FlatAffineValueConstraints>(*this);
 }
 
 // Construct from an IntegerSet.
-FlatAffineValueConstraints::FlatAffineValueConstraints(IntegerSet set)
+FlatAffineValueConstraints::FlatAffineValueConstraints(IntegerSet set,
+                                                       ValueRange operands)
     : IntegerPolyhedron(set.getNumInequalities(), set.getNumEqualities(),
                         set.getNumDims() + set.getNumSymbols() + 1,
                         PresburgerSpace::getSetSpace(set.getNumDims(),
                                                      set.getNumSymbols(),
                                                      /*numLocals=*/0)) {
-
-  // Resize values.
+  // Populate values.
+  if (operands.empty()) {
     values.resize(getNumDimAndSymbolVars(), std::nullopt);
+  } else {
+    assert(set.getNumInputs() == operands.size() && "operand count mismatch");
+    values.assign(operands.begin(), operands.end());
+  }
 
   // Flatten expressions and add them to the constraint system.
   std::vector<SmallVector<int64_t, 8>> flatExprs;
   FlatAffineValueConstraints localVarCst;
   if (failed(getFlattenedAffineExprs(set, &flatExprs, &localVarCst))) {
     assert(false && "flattening unimplemented for semi-affine integer sets");
     return;
   }
if (lbMap && failed(addBound(BoundType::LB, i, lbMap, operands)))
       return failure();
     if (ubMap && failed(addBound(BoundType::UB, i, ubMap, operands)))
       return failure();
   }
   return success();
 }
 
 void FlatAffineValueConstraints::addAffineIfOpDomain(AffineIfOp ifOp) {
-  // Create the base constraints from the integer set attached to ifOp.
-  FlatAffineValueConstraints cst(ifOp.getIntegerSet());
+  IntegerSet set = ifOp.getIntegerSet();
+  // Canonicalize set and operands to ensure unique values for
+  // FlatAffineValueConstraints below and for early simplification.
+  SmallVector<Value> operands(ifOp.getOperands());
+  canonicalizeSetAndOperands(&set, &operands);
 
-  // Bind vars in the constraints to ifOp operands.
-  SmallVector<Value, 4> operands = ifOp.getOperands();
-  cst.setValues(0, cst.getNumDimAndSymbolVars(), operands);
+  // Create the base constraints from the integer set attached to ifOp.
+  FlatAffineValueConstraints cst(set, operands);
 
   // Merge the constraints from ifOp to the current domain. We need first merge
   // and align the IDs from both constraints, and then append the constraints
   // from the ifOp into the current one.
   mergeAndAlignVarsWithOther(0, &cst);
   append(cst);
 }
 

mlir/test/Transforms/memref-dependence-check.mlir

affine.parallel (%i0) = (0) to (10) {
     affine.store %cst, %0[%i0] : memref<10xf32>
   }
   affine.parallel (%i1) = (0) to (10) {
     // expected-error @+1 {{dependence check failed}}
     %1 = affine.load %0[%i1] : memref<10xf32>
   }
   return
 }
+
+// -----
+
+func.func @affine_if_no_dependence() {
+  %c1 = arith.constant 1 : index
+  %alloc = memref.alloc() : memref<15xi1>
+  %true = arith.constant true
+  affine.store %true, %alloc[%c1] : memref<15xi1>
+  // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
+  // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
+  // This set is empty.
+  affine.if affine_set<(d0, d1, d2, d3) : ((d0 + 1) mod 8 >= 0, d0 * -8 >= 0)>(%c1, %c1, %c1, %c1){
+    %265 = affine.load %alloc[%c1] : memref<15xi1>
+    // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
+    // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
+  }
+  return
+}