[ARITH] Introduce iterator (quasi)affine map detection. #6667
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
|
||
|
|
||
| def isplit(axis, factor): | ||
| """Fuse iterators""" |
| The input indices. | ||
|
|
||
| input_iters : Map[Var, Range] | ||
| The domain of each input iterators. |
There was a problem hiding this comment.
May be good to add Returns in comment here.
python/tvm/arith/iter_affine_map.py
Outdated
| Additional scale to the split. | ||
| """ | ||
|
|
||
| def __init__(self, min_value, max_value): |
There was a problem hiding this comment.
Incorrect arguments
| """ | ||
|
|
||
| def __init__(self, min_value, max_value): | ||
| self.__init_handle_by_constructor__(_ffi_api.IterMark, source, extent) |
There was a problem hiding this comment.
Inconsistent with function arguments
tqchen
force-pushed
the
qaffine
branch
2 times, most recently
from
468db05
to
0260e33
Compare
The loop transformations (split, fuse) create bijective maps from a collection of source iterators to target iterators. DetectIterMap is a function that detects such bijective mappings from the lowered index expression. We choose the term quasi affine to be consistent with the terminology used by in polyhedral compilation. DetectIterMap can handle symbolic integers(in split/fuse) to some extent. The utility can be useful in detecting loop transformation patterns and data layout change patterns in TIR.
include/tvm/arith/iter_affine_map.h
Outdated
| * \brief Base class of all iter map expressions. | ||
| * | ||
| * An IterMapExpr is a special expression to store | ||
| * the result of IterMapDetection, it should not |
There was a problem hiding this comment.
Would be great to complete the comments
src/arith/iter_affine_map.cc
Outdated
| } | ||
| }; | ||
|
|
||
| // Rewriter to rewrite oinformations in iter |
spectrometerHBH
approved these changes
Oct 13, 2020
| results.push_back(rewriter.Rewrite(value)); | ||
| if (rewriter.unresolved_count() != 0) return Array<IterSumExpr>(); | ||
| } | ||
| if (!rewriter.CheckBijective(results)) return Array<IterSumExpr>(); |
There was a problem hiding this comment.
Currently, the Independence check seems to only check that all input marks are iterated. Is that sufficient to ensure independence?
There was a problem hiding this comment.
It also checks all the intermediate marks(including the input) are being covered without overlapping
There was a problem hiding this comment.
If the indices are y, x, x+1 and input_iters are y, x, will this be checked?
There was a problem hiding this comment.
yes, in this case, x and x+1 will contribute two Split entries to mark2split of x, (one contributed by x and another by x+1)
mark2split[x]= [ Split(x, extent), Split(x, extent)]
And it will results in an error because the two splits overlaps with each other
There was a problem hiding this comment.
The checks are via the TryNormalizeSplits function
|
Thanks @spectrometerHBH I addressed your comment and added more explaination about bijective check, I also added your example as a testcase |
spectrometerHBH
approved these changes
Oct 14, 2020
ZihengJiang
approved these changes
Oct 14, 2020
trevor-m
pushed a commit
to trevor-m/tvm
that referenced
this pull request
Oct 29, 2020
* [ARITH] Introduce iterator (quasi)affine map detection. The loop transformations (split, fuse) create bijective maps from a collection of source iterators to target iterators. DetectIterMap is a function that detects such bijective mappings from the lowered index expression. We choose the term quasi affine to be consistent with the terminology used by in polyhedral compilation. DetectIterMap can handle symbolic integers(in split/fuse) to some extent. The utility can be useful in detecting loop transformation patterns and data layout change patterns in TIR. * Update per feedback
trevor-m
pushed a commit
to trevor-m/tvm
that referenced
this pull request
Dec 2, 2020
* [ARITH] Introduce iterator (quasi)affine map detection. The loop transformations (split, fuse) create bijective maps from a collection of source iterators to target iterators. DetectIterMap is a function that detects such bijective mappings from the lowered index expression. We choose the term quasi affine to be consistent with the terminology used by in polyhedral compilation. DetectIterMap can handle symbolic integers(in split/fuse) to some extent. The utility can be useful in detecting loop transformation patterns and data layout change patterns in TIR. * Update per feedback
trevor-m
pushed a commit
to trevor-m/tvm
that referenced
this pull request
Dec 4, 2020
* [ARITH] Introduce iterator (quasi)affine map detection. The loop transformations (split, fuse) create bijective maps from a collection of source iterators to target iterators. DetectIterMap is a function that detects such bijective mappings from the lowered index expression. We choose the term quasi affine to be consistent with the terminology used by in polyhedral compilation. DetectIterMap can handle symbolic integers(in split/fuse) to some extent. The utility can be useful in detecting loop transformation patterns and data layout change patterns in TIR. * Update per feedback
trevor-m
pushed a commit
to neo-ai/tvm
that referenced
this pull request
Dec 4, 2020
* [ARITH] Introduce iterator (quasi)affine map detection. The loop transformations (split, fuse) create bijective maps from a collection of source iterators to target iterators. DetectIterMap is a function that detects such bijective mappings from the lowered index expression. We choose the term quasi affine to be consistent with the terminology used by in polyhedral compilation. DetectIterMap can handle symbolic integers(in split/fuse) to some extent. The utility can be useful in detecting loop transformation patterns and data layout change patterns in TIR. * Update per feedback
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
The loop transformations (split, fuse) create bijective
maps from a collection of source iterators to target iterators.
DetectIterMap is a function that detects such bijective mappings
from lowered index expressions.
We choose the term quasi affine to be consistent with the
terminology used in polyhedral compilation.
DetectIterMap can handle symbolic integers(in split/fuse) to some extent.
The utility can be useful in detecting loop transformation
patterns and data layout change patterns in TIR.