[all-commits] [llvm/llvm-project] 727686: [MirNamer][Canonicalizer]: Perform instruction sem...

[proaditya via All-commits]

  Branch: refs/heads/master
  Home:   https://github.com/llvm/llvm-project
  Commit: 72768685567b5e2ef9820b80997c5aed615e9f57
      https://github.com/llvm/llvm-project/commit/72768685567b5e2ef9820b80997c5aed615e9f57
  Author: Aditya Nandakumar <aditya_nandakumar at apple.com>
  Date:   2019-11-15 (Fri, 15 Nov 2019)

  Changed paths:
    M llvm/lib/CodeGen/MIRCanonicalizerPass.cpp
    M llvm/lib/CodeGen/MIRNamerPass.cpp
    M llvm/lib/CodeGen/MIRVRegNamerUtils.cpp
    M llvm/lib/CodeGen/MIRVRegNamerUtils.h
    M llvm/test/CodeGen/MIR/AArch64/mirCanonCopyCopyProp.mir
    M llvm/test/CodeGen/MIR/AArch64/mirCanonIdempotent.mir
    M llvm/test/CodeGen/MIR/AArch64/mirnamer.mir
    M llvm/test/CodeGen/MIR/AMDGPU/mir-canon-multi.mir

  Log Message:
  -----------
  [MirNamer][Canonicalizer]: Perform instruction semantic based renaming

https://reviews.llvm.org/D70210

Previously:

Due to sensitivity of the algorithm with gaps, and extra instructions,
when diffing, often we see naming being off by a few. Makes the diff
unreadable even for tests with 7 and 8 instructions respectively.
Naming can change depending on candidates (and order of picking
candidates). Suddenly if there's one extra instruction somewhere, the
entire subtree would be named completely differently.
No consistent naming of similar instructions which occur in different
functions. If we try to do something like count the frequency
distribution of various differences across suite, then the above
sensitivity issues are going to result in poor results.
Instead:

Name instruction based on semantics of the instruction (hash of the
opcode and operands). Essentially for a given instruction that occurs in
any module/function it'll be named similarly (ie semantic). This has
some nice properties
Can easily look at many instructions and just check the hash and if
they're named similarly, then it's the same instruction. Makes it very
easy to spot the same instruction both multiple times, as well as across
many functions (useful for frequency distribution).
Independent of traversal/candidates/depth of graph. No need to keep
track of last index/gaps/skip count etc.
No off by few issues with diffs. I've tried the old vs new
implementation in files ranging from 30 to 700 instructions. In both
cases with the old algorithm, diffs are a sea of red, where as for the
semantic version, in both cases, the diffs line up beautifully.
Simplified implementation of the main loop (simple iteration) , no keep
track of what's visited and not.
Handle collision just by incrementing a counter. Roughly
bb[N]_hash_[CollisionCount].
Additionally with the new implementation, we can probably avoid doing
the hoisting of instructions to various places, as they'll likely be
named the same resulting in differences only based on collision (ie
regardless of whether the instruction is hoisted or not/close to use or
not, it'll be named the same hash which should result in use of the
instruction be identical with the only change being the collision count)
which is very easy to spot visually.