Changes in AffineExpr.cpp

aba43035 - Use llvm::sort instead of std::sort where possible

Sat, 23 Jul 2022 13:14:14 +0000

Use llvm::sort instead of std::sort where possiblellvm::sort is beneficial even when we use the iterator-based overload,since it can optionally shuffle the elements (to detectnon-determinism). However llvm::sort is not usable everywhere, forexample, in compiler-rt.Reviewed By: nhaehnleDifferential Revision: https://reviews.llvm.org/D130406 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

360c1111 - Use llvm::is_contained (NFC)

Wed, 20 Jul 2022 16:09:19 +0000

Use llvm::is_contained (NFC) List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

b7f93c28 - [mlir] (NFC) run clang-format on all files

Thu, 14 Jul 2022 20:31:47 +0000

[mlir] (NFC) run clang-format on all files List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

6d5fc1e3 - [mlir] Don't use Optional::getValue (NFC)

Tue, 21 Jun 2022 06:20:25 +0000

[mlir] Don't use Optional::getValue (NFC) List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

e1f389a8 - Apply clang-tidy fixes for readability-simplify-boolean-expr to MLIR (NFC)

Mon, 07 Mar 2022 10:12:48 +0000

Apply clang-tidy fixes for readability-simplify-boolean-expr to MLIR (NFC) List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

e4853be2 - Apply clang-tidy fixes for performance-for-range-copy to MLIR (NFC)

Sun, 02 Jan 2022 22:02:14 +0000

Apply clang-tidy fixes for performance-for-range-copy to MLIR (NFC) List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

1fc096af - Apply clang-tidy fixes for performance-unnecessary-value-param to MLIR (NFC)

Sun, 02 Jan 2022 01:26:44 +0000

Apply clang-tidy fixes for performance-unnecessary-value-param to MLIR (NFC)Reviewed By: MogballDifferential Revision: https://reviews.llvm.org/D116250 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

ec7b0d4d - [MLIR] Simplify Semi-affine expressions by rule based matching and replacing "expr - q * (expr floordiv q)" with "expr mod q" expression.

Sat, 20 Nov 2021 15:34:59 +0000

[MLIR] Simplify Semi-affine expressions by rule based matching and replacing "expr - q * (expr floordiv q)" with "expr mod q" expression.Add rule based matching for detecting and transforming "expr - q * (expr floordiv q)"to "expr mod q", where q is a symbolic exxpression, in simplifyAdd function.Reviewed By: bondhugula, dcaballeDifferential Revision: https://reviews.llvm.org/D112985 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

14022992 - [MLIR] Simplify semi-affine expressions using flattening

Tue, 16 Nov 2021 09:36:45 +0000

[MLIR] Simplify semi-affine expressions using flatteningFor the semi affine expressions, whenever rhs of a floordiv, ceildiv, modor product expression is a symbolic expression, we introduce a local variablerepresenting the result, and store the floordiv/ceildiv, mod or productaffine expression in LocalExprs. In this way the expression is flattened,and trivial addition and subtraction related simplifications are performed.Also rule based matching for detecting and transforming "expr - q * (expr floordiv q)"to "expr mod q", where q is a symbolic exxpression, in simplifyAdd function.Differential Revision: https://reviews.llvm.org/D112808 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

41a8b460 - [MLIR] Fix AffineExpr getLargestKnownDivisor for ceildiv and floordiv

Mon, 11 Oct 2021 10:18:06 +0000

[MLIR] Fix AffineExpr getLargestKnownDivisor for ceildiv and floordivFix AffineExpr `getLargestKnownDivisor` for ceil/floor div cases.In these cases, nothing can be inferred on the divisor of theresult.Add test case for `mod` as well.Differential Revision: https://reviews.llvm.org/D112523 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

121aab84 - [MLIR][Affine] Simplify nested modulo operations when able

Thu, 16 Sep 2021 21:25:20 +0000

[MLIR][Affine] Simplify nested modulo operations when ableIt is the case that, for all positive a and b such that b divides a(e mod (a * b)) mod b = e mod b. For example, ((d0 mod 35) mod 5) canbe simplified to (d0 mod 5), but ((d0 mod 35) mod 4) cannot be simplifiedfurther (x = 36 is a counterexample).This change enables more complex simplifications. For example,((d0 * 72 + d1) mod 144) mod 9 can now simplify to (d0 * 72 + d1) mod 9and thus to d1 mod 9. Expressions with chained modulus operators arereasonably common in tensor applications, and this change _should_improve code generation for such expressions.Reviewed By: nicolasvasilacheDifferential Revision: https://reviews.llvm.org/D109930 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

8e8b70aa - [mlir][scf] Simplify affine.min ops after loop peeling

Thu, 19 Aug 2021 08:08:21 +0000

[mlir][scf] Simplify affine.min ops after loop peelingSimplify affine.min ops, enabling various other canonicalizations inside the peeled loop body.affine.min ops such as:```map = affine_map<(d0)[s0, s1] -> (s0, -d0 + s1)>%r = affine.min #affine.min #map(%iv)[%step, %ub]```are rewritten them into (in the case the peeled loop):```%r = %step```To determine how an affine.min op should be rewritten and to prove its correctness, FlatAffineConstraints is utilized.Differential Revision: https://reviews.llvm.org/D107222 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

5bc4f884 - s[mlir] Tighten computation of inferred SubView result type.

Thu, 11 Feb 2021 22:26:49 +0000

s[mlir] Tighten computation of inferred SubView result type.The AffineMap in the MemRef inferred by SubViewOp may have uncompressed symbols which result in type mismatch on otherwise unused symbols. Make the computation of the AffineMap compress those unused symbols which results in better canonical types.Additionally, improve the error message to report which inferred type was expected.Differential Revision: https://reviews.llvm.org/D96551 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

93a873df - [mlir][Affine] Revisit and simplify composeAffineMapAndOperands.

Tue, 19 Jan 2021 13:48:08 +0000

[mlir][Affine] Revisit and simplify composeAffineMapAndOperands.In prehistorical times, AffineApplyOp was allowed to produce multiple values.This allowed the creation of intricate SSA use-def chains.AffineApplyNormalizer was originally introduced as a means of reusing the AffineMap::compose method to write SSA use-def chains.Unfortunately, symbols that were produced by an AffineApplyOp needed to be promoted to dims and reordered for the mathematical composition to be valid.Since then, single result AffineApplyOp became the law of the land but the original assumptions were not revisited.This revision revisits these assumptions and retires AffineApplyNormalizer.Differential Revision: https://reviews.llvm.org/D94920 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

250f43d3 - [mlir] Remove the use of "kinds" from Attributes and Types

Tue, 18 Aug 2020 22:59:53 +0000

[mlir] Remove the use of "kinds" from Attributes and TypesThis greatly simplifies a large portion of the underlying infrastructure, allows for lookups of singleton classes to be much more efficient and always thread-safe(no locking). As a result of this, the dialect symbol registry has been removed as it is no longer necessary.For users broken by this change, an alert was sent out(https://llvm.discourse.group/t/removing-kinds-from-attributes-and-types) that helps prevent a majority of the breakage surface area. All that should be necessary, if the advice in that alert was followed, is removing the kind passed to the ::get methods.Differential Revision: https://reviews.llvm.org/D86121 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

86646be3 - [mlir] Refactor StorageUniquer to require registration of possible storage types

Fri, 07 Aug 2020 20:29:11 +0000

[mlir] Refactor StorageUniquer to require registration of possible storage typesThis allows for bucketing the different possible storage types, with each bucket having its own allocator/mutex/instance map. This greatly reduces the amount of lock contention when multi-threading is enabled. On some non-trivial .mlir modules (>300K operations), this led to a compile time decrease of a single conversion pass by around half a second(>25%).Differential Revision: https://reviews.llvm.org/D82596 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

3110e7b0 - [mlir] Introduce AffineMinSCF folding as a pattern

Fri, 07 Aug 2020 18:28:40 +0000

[mlir] Introduce AffineMinSCF folding as a patternThis revision adds a folding pattern to replace affine.min ops by the actual min value, when it can be determined statically from the strides and bounds of enclosing scf loop .This matches the type of expressions that Linalg produces during tiling and simplifies boundary checks. For now Linalg depends both on Affine and SCF but they do not depend on each other, so the pattern is added there.In the future this will move to a more appropriate place when it is determined.The canonicalization of AffineMinOp operations in the context of enclosing scf.for and scf.parallel proceeds by: 1. building an affine map where uses of the induction variable of a loop are replaced by `%lb + %step * floordiv(%iv - %lb, %step)` expressions. 2. checking if any of the results of this affine map divides all the other results (in which case it is also guaranteed to be the min). 3. replacing the AffineMinOp by the result of (2).The algorithm is functional in simple parametric tiling cases by using semi-affine maps. However simplifications of such semi-affine maps are not yet available and the canonicalization does not succeed yet.Differential Revision: https://reviews.llvm.org/D82009 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

56593fa3 - [MLIR] Simplify semi-affine expressions

Tue, 04 Aug 2020 14:51:13 +0000

[MLIR] Simplify semi-affine expressionsSimplify semi-affine expression for the operations like ceildiv,floordiv and modulo by any given symbol by checking divisibilty by thatsymbol.Some properties used in simplification are:1) Commutative property of the floordiv and ceildiv:((expr1 floordiv expr2) floordiv expr3 ) = ((expr1 floordiv expr3) floordiv expr2)((expr1 ceildiv expr2) ceildiv expr3 ) = ((expr1 ceildiv expr3) ceildiv expr2)While simplification if operations are different no simplification ispossible as there is no property that simplify expressions like these:((expr1 ceildiv expr2) floordiv expr3) or ((expr1 floordiv expr2)ceildiv expr3).2) If both expr1 and expr2 are divisible by the expr3 then:(expr1 % expr2) / expr3 = ((expr1 / expr3) % (expr2 / expr3))where / is divide symbol.3) If expr1 is divisible by expr2 then expr1 % expr2 = 0.Signed-off-by: Yash Jain Differential Revision: https://reviews.llvm.org/D84920 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

f9c8febc - [mlir] Added support for symbols inside linalg.generic and map concatenation

Mon, 20 Jul 2020 16:30:10 +0000

[mlir] Added support for symbols inside linalg.generic and map concatenationThis commit adds functionality needed for implementation of convolutions withlinalg.generic op. Since linalg.generic right now expects indexing maps to bejust permutations, offset indexing needed in convolutions is not possible.Therefore in this commit we address the issue by adding support for symbols insideindexing maps which enables more advanced indexing. The upcoming commit willsolve the problem of computing loop bounds from such maps.Differential Revision: https://reviews.llvm.org/D83158 List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp

9db53a18 - [mlir][NFC] Remove usernames and google bug numbers from TODO comments.

Tue, 07 Jul 2020 08:35:23 +0000

[mlir][NFC] Remove usernames and google bug numbers from TODO comments.These were largely leftover from when MLIR was a google project, and don't really follow LLVM guidelines. List of files: /llvm-project-15.0.7/mlir/lib/IR/AffineExpr.cpp