FranckQC opened a new pull request, #11574:
URL: https://github.com/apache/tvm/pull/11574

   NOTE : NOT READY FOR REVIEW YET. USING CI FOR FIXING FORMATTING, ETC.
   I WILL REMOVE THIS TAG WHEN IT'S READY FOR REVIEW.
   
   This PR addresses the issue described in 
https://github.com/apache/tvm/pull/11423/ .
   Here is some context : 
   
   The CSE pass had been designed for potentially allowing comparisons (and 
commonings) of equivalent terms (like (x+y)+z and x+(y+z)), where **the notion 
of being equivalent was customizable, and no assumption was made about it**. 
That means that the implementation of the equality test function 
`EquivalentTerms()` - which was at the moment just calling the syntactical 
equality test `EqualTerms()` - could be replaced later by a cleverer equality 
test.
   
   However, having such a generic way of comparing elements meant that in the 
function `SyntacticToSemanticComputations()`, where we were going from a 
hashtable of syntactical entities to what I called a vector of "semantical 
entites" (which are just canonical forms/representants of classes of 
equivalence of terms), **the only way was to compare each pair**.
   That resulted in a quadratic behavior of this function, but there was no way 
around it as in order to merge equivalent entities into their class of 
equivalence, we had to compare them.
   
   **This PR essentially does the following:**
   
       - When computing the classes of equivalences of terms (therefore 
transforming a ComputationTable (i.e. a hashtable) into a vector of classes of 
equivalence) : **instead of comparing each pair of terms, relies on a 
normalization procedure to obtain a normal form for each of them**.
   That transforms a small part of the algorithm that was quadratic to n.logn. 
However, it's difficult to see improvements in practice, in particular for 
average sized programs, as that part was a "small" quadratic to a "big" n.logn 
(finding things in a hash-table, copying it to a vector, etc).
   It was probably going from a complexity of ~O(((n²-n)/2) + n.logn) to a 
complexity of ~O(3n + n.logn), so potential gains would only be expected for 
very large programs.
   
       - Completely gives the user the possibility to turn ON/OFF the 
semantical comparisons of terms. It is turned OFF by default (as it's quite 
longer to compile with it ON, unsurprisingly), which means that by default, the 
equivalence coincides with the (syntactical) equality of terms.
       As the pass was written with the possibility to do these additional 
commonings (like (x+y)+z and x+(y+z)), it was a good time to fully plug that 
completely, up to the Python user who can now turn that ON if he wants to. But 
again, it is OFF by default, so no real change on that.
   
   To run it ON, simply do:
   `with 
tvm.transform.PassContext(config={'tir.enable_equiv_terms_in_cse_tir':True}):`
   before calling `build()`
   
       - When this boolean is set to ON, it uses a simple implementation of the 
normalization function with equivalences that uses `arith::Analyzer::Simplify` 
as noted by @yuanfz98 on his PR https://github.com/apache/tvm/pull/10544 . Note 
that this is not a real normalization procedure as it is incomplete (i.e., it 
is not guarantee to converge to the normal form), but it is correct, and it 
works well with most properties : associativity of +, distributivity of * on +, 
etc.
   
       - Clarifies and enhance the test base for the pass. In particular, it 
adds the tests that were written in https://github.com/apache/tvm/pull/10544 
but which did not make it through.
   
       - Also add the test ( 
https://github.com/AndrewZhaoLuo/TVM-Sandbox/blob/19284ddbd6bb28af61c0c2aa8bb334c5c53731a7/tir/test_inconsistent_tir_lowering.py#L1
 ) from @AndrewZhaoLuo demonstrating the (older) non-deterministic lowering and 
put it into a proper test, as I found it useful for making sure that this does 
not happen again. It has been copied from 
https://github.com/apache/tvm/pull/10663 and only slightly adapted (in 
particular for doing the comparison of hashes automatically instead of printing 
them and relying on a human to compare them).
   
   Many thanks!


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: commits-unsubscr...@tvm.apache.org

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org

Reply via email to