srishti-pm added a comment. In D124750#3500748 <https://reviews.llvm.org/D124750#3500748>, @mehdi_amini wrote:
> Seems like this should be added to canonicalization? The "push constants to > the right hand side" is there already. I think this was not added to canonicalization because we wanted it to be an independent utility that can be used if needed and not be used if not needed. Yes, the "push constants to the right hand side" is there already and that's actually the reason why this utility also pushes the constants to the right. I didn't want this utility to do something else and clash with the "push constants to the right hand side" canonicalization if and when both were being used together. So, when we decided what our sorting order will be, we made sure that this order kept constants to the right. For more context, you could refer to this RFC's discussion, starting from this comment: https://discourse.llvm.org/t/mlir-pdl-extending-pdl-pdlinterp-bytecode-to-enable-commutative-matching/60798/12?u=srishtisrivastava. But, note this: Right now, the code shows that I am sorting the constants alphabetically (as in, theoretically, we can say that `arith.constant` comes before `tf.Const`). I will remove this "alphabetical sorting" among the constants. It isn't consistent with the existing "pushing of constants" and moreover adds unnecessary computation too. I'll ensure that the sorting is stable and pushes all the constants to the right. > I also don't understand the complexity of the implementation, I may need an > example to understand why you're recursively operating on the producer ops > for the operands. > From the revision description: (1) the operands defined by non-constant-like > ops come first, followed by (2) block arguments, and these are followed by > (3) the operands defined by constant-like ops` which all seems like a fairly > local check: a stable-sort on the operands would be deterministic and local > to a single operation. I do this because, firstly, in the description, if you look below this paragraph, you will see the following: "And, if two operands come from the same op, the function backtracks and looks even further to sort them. This backtracking is done over the backward slice of the operand, in a breadth-first traversal." So, in essence, we are looking at the entire origin of each of the operands, in a breadth-first fashion, to decide the ordering of the operands. Secondly, we need to sort the producers of the operands so that we have a deterministic sorting (because if the producers are not sorted, we don't know if we are doing the right sorting or not, even if we are looking at the entire backward slice). This is because since the producers are not sorted, the breadth-first traversal becomes non-deterministic to a user who is writing a pattern matching function (say, `matchAndRewrite()`). Repository: rG LLVM Github Monorepo CHANGES SINCE LAST ACTION https://reviews.llvm.org/D124750/new/ https://reviews.llvm.org/D124750 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
