[ARITH] Introduce iterator (quasi)affine map detection.#6667
Merged
tqchen merged 2 commits intoapache:mainfrom Oct 14, 2020
Merged
[ARITH] Introduce iterator (quasi)affine map detection.#6667tqchen merged 2 commits intoapache:mainfrom
tqchen merged 2 commits intoapache:mainfrom
Conversation
Member
Author
Contributor
spectrometerHBH
left a comment
spectrometerHBH
left a comment
There was a problem hiding this comment.
Some quick comments
|
|
||
|
|
||
| def isplit(axis, factor): | ||
| """Fuse iterators""" |
| The input indices. | ||
|
|
||
| input_iters : Map[Var, Range] | ||
| The domain of each input iterators. |
Contributor
There was a problem hiding this comment.
May be good to add Returns in comment here.
| Additional scale to the split. | ||
| """ | ||
|
|
||
| def __init__(self, min_value, max_value): |
Contributor
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) |
Contributor
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.
| * \brief Base class of all iter map expressions. | ||
| * | ||
| * An IterMapExpr is a special expression to store | ||
| * the result of IterMapDetection, it should not |
Contributor
There was a problem hiding this comment.
Would be great to complete the comments
| } | ||
| }; | ||
|
|
||
| // Rewriter to rewrite oinformations in iter |
spectrometerHBH
approved these changes
Oct 13, 2020
Contributor
spectrometerHBH
left a comment
spectrometerHBH
left a comment
There was a problem hiding this comment.
Other parts LGTM
| results.push_back(rewriter.Rewrite(value)); | ||
| if (rewriter.unresolved_count() != 0) return Array<IterSumExpr>(); | ||
| } | ||
| if (!rewriter.CheckBijective(results)) return Array<IterSumExpr>(); |
Contributor
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?
Member
Author
There was a problem hiding this comment.
It also checks all the intermediate marks(including the input) are being covered without overlapping
Contributor
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?
Member
Author
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
Member
Author
There was a problem hiding this comment.
The checks are via the TryNormalizeSplits function
Member
Author
|
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
Contributor
spectrometerHBH
left a comment
spectrometerHBH
left a comment
There was a problem hiding this comment.
Thanks, @tqchen!
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
This file contains hidden or 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
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
3 participants
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.