[GreedyRA ORE] Add stats for copy of virtual registers.

[skatkov]

Summary

Greedy RA adds copies of virtual registers when splitting live interval.
This stat might be useful.

[thegameg]

Is this really useful as a user-surfacing remark? Won't it have a really high false positive rate due to coalescing?

[skatkov]

In D100017#2673208, @thegameg wrote:

Is this really useful as a user-surfacing remark? Won't it have a really high false positive rate due to coalescing?

To be honest - not sure. But if RA can assigned physical register and can eliminate copy it a good sign.
So probably I also need to check reg map whether physical registers are different or not... Need to check...

[thegameg]

In D100017#2673209, @skatkov wrote:

In D100017#2673208, @thegameg wrote:

Is this really useful as a user-surfacing remark? Won't it have a really high false positive rate due to coalescing?

To be honest - not sure. But if RA can assigned physical register and can eliminate copy it a good sign.
So probably I also need to check reg map whether physical registers are different or not... Need to check...

IIRC, it actually inserts copies and relies on coalescing to remove most of them. It would be worth checking on large programs and such to see if you're actually seeing register copies for some of the remarks emitted.

[skatkov]

rebase + test update.

[skatkov]

Rebase + test update due to recent changes in RA.

[reames]

LGTM

llvm/lib/CodeGen/RegAllocGreedy.cpp

private:
 
   /// Greedy RA statistic to remark.
   struct RAGreedyStats {
     unsigned Reloads = 0;
     unsigned FoldedReloads = 0;
     unsigned ZeroCostFoldedReloads = 0;
     unsigned Spills = 0;
     unsigned FoldedSpills = 0;
+    unsigned Copies = 0;
 
     bool isEmpty() {
       return !(Reloads || FoldedReloads || Spills || FoldedSpills ||
-               ZeroCostFoldedReloads);
+               ZeroCostFoldedReloads || Copies);
     }
 
     void add(RAGreedyStats other) {
       Reloads += other.Reloads;
       FoldedReloads += other.FoldedReloads;
       ZeroCostFoldedReloads += other.ZeroCostFoldedReloads;
       Spills += other.Spills;
       FoldedSpills += other.FoldedSpills;
+      Copies += other.Copies;
     }
 
     void report(MachineOptimizationRemarkMissed &R);
   };
 
-  /// Compute the number of spills and reloads for a basic block.
-  RAGreedyStats computeNumberOfSplillsReloads(MachineBasicBlock &MBB);
+  /// Compute statistic for a basic block.
+  RAGreedyStats computeStats(MachineBasicBlock &MBB);
 
-  /// Compute and report the number of spills through a remark.
-  RAGreedyStats reportNumberOfSplillsReloads(MachineLoop *L);
+  /// Compute and report statistic through a remark.
+  RAGreedyStats reportStats(MachineLoop *L);
 
-  /// Report the number of spills and reloads for each loop.
-  void reportNumberOfSplillsReloads();
+  /// Report the statistic for each loop.
+  void reportStats();
 };
 
 } // end anonymous namespace
 
 char RAGreedy::ID = 0;
 char &llvm::RAGreedyID = RAGreedy::ID;
 
 INITIALIZE_PASS_BEGIN(RAGreedy, "greedy",
if (FoldedSpills)
     R << NV("NumFoldedSpills", FoldedSpills) << " folded spills ";
   if (Reloads)
     R << NV("NumReloads", Reloads) << " reloads ";
   if (FoldedReloads)
     R << NV("NumFoldedReloads", FoldedReloads) << " folded reloads ";
   if (ZeroCostFoldedReloads)
     R << NV("NumZeroCostFoldedReloads", ZeroCostFoldedReloads)
       << " zero cost folded reloads ";
+  if (Copies)
+    R << NV("NumVRCopies", Copies) << " virtual registers copies ";
 }
 
-RAGreedy::RAGreedyStats
-RAGreedy::computeNumberOfSplillsReloads(MachineBasicBlock &MBB) {
+RAGreedy::RAGreedyStats RAGreedy::computeStats(MachineBasicBlock &MBB) {
   RAGreedyStats Stats;
   const MachineFrameInfo &MFI = MF->getFrameInfo();
   int FI;
 
   auto isSpillSlotAccess = [&MFI](const MachineMemOperand *A) {
     return MFI.isSpillSlotObjectIndex(cast<FixedStackPseudoSourceValue>(
         A->getPseudoValue())->getFrameIndex());
   };
   auto isPatchpointInstr = [](const MachineInstr &MI) {
     return MI.getOpcode() == TargetOpcode::PATCHPOINT ||
            MI.getOpcode() == TargetOpcode::STACKMAP ||
            MI.getOpcode() == TargetOpcode::STATEPOINT;
   };
   for (MachineInstr &MI : MBB) {
-    SmallVector<const MachineMemOperand *, 2> Accesses;
+    if (MI.isCopy()) {
+      MachineOperand &Dest = MI.getOperand(0);
+      MachineOperand &Src = MI.getOperand(1);
+      if (Dest.isReg() && Src.isReg() && Dest.getReg().isVirtual() &&
+          Src.getReg().isVirtual())
+        ++Stats.Copies;
+      continue;
+    }
 
+    SmallVector<const MachineMemOperand *, 2> Accesses;
     if (TII->isLoadFromStackSlot(MI, FI) && MFI.isSpillSlotObjectIndex(FI)) {
       ++Stats.Reloads;
       continue;
     }
     if (TII->isStoreToStackSlot(MI, FI) && MFI.isSpillSlotObjectIndex(FI)) {
       ++Stats.Spills;
       continue;
     }
for (MachineInstr &MI : MBB) {
     if (TII->hasStoreToStackSlot(MI, Accesses) &&
         llvm::any_of(Accesses, isSpillSlotAccess)) {
       Stats.FoldedSpills += Accesses.size();
     }
   }
   return Stats;
 }
 
-RAGreedy::RAGreedyStats RAGreedy::reportNumberOfSplillsReloads(MachineLoop *L) {
+RAGreedy::RAGreedyStats RAGreedy::reportStats(MachineLoop *L) {
   RAGreedyStats Stats;
 
   // Sum up the spill and reloads in subloops.
   for (MachineLoop *SubLoop : *L)
-    Stats.add(reportNumberOfSplillsReloads(SubLoop));
+    Stats.add(reportStats(SubLoop));
 
   for (MachineBasicBlock *MBB : L->getBlocks())
     // Handle blocks that were not included in subloops.
     if (Loops->getLoopFor(MBB) == L)
-      Stats.add(computeNumberOfSplillsReloads(*MBB));
+      Stats.add(computeStats(*MBB));
 
   if (!Stats.isEmpty()) {
     using namespace ore;
 
     ORE->emit([&]() {
-      MachineOptimizationRemarkMissed R(DEBUG_TYPE, "LoopSpillReload",
+      MachineOptimizationRemarkMissed R(DEBUG_TYPE, "LoopSpillReloadCopies",
                                         L->getStartLoc(), L->getHeader());
       Stats.report(R);
       R << "generated in loop";
       return R;
     });
   }
   return Stats;
 }
 
-void RAGreedy::reportNumberOfSplillsReloads() {
+void RAGreedy::reportStats() {
   if (!ORE->allowExtraAnalysis(DEBUG_TYPE))
     return;
   RAGreedyStats Stats;
   for (MachineLoop *L : *Loops)
-    Stats.add(reportNumberOfSplillsReloads(L));
+    Stats.add(reportStats(L));
   // Process non-loop blocks.
   for (MachineBasicBlock &MBB : *MF)
     if (!Loops->getLoopFor(&MBB))
-      Stats.add(computeNumberOfSplillsReloads(MBB));
+      Stats.add(computeStats(MBB));
   if (!Stats.isEmpty()) {
     using namespace ore;
 
     ORE->emit([&]() {
       DebugLoc Loc;
       if (auto *SP = MF->getFunction().getSubprogram())
         Loc = DILocation::get(SP->getContext(), SP->getLine(), 1, SP);
-      MachineOptimizationRemarkMissed R(DEBUG_TYPE, "SpillReload", Loc,
+      MachineOptimizationRemarkMissed R(DEBUG_TYPE, "SpillReloadCopies", Loc,
                                         &MF->front());
       Stats.report(R);
       R << "generated in function";
       return R;
     });
   }
 }
 
bool RAGreedy::runOnMachineFunction(MachineFunction &mf) {
   LastEvicted.clear();
 
   allocatePhysRegs();
   tryHintsRecoloring();
 
   if (VerifyEnabled)
     MF->verify(this, "Before post optimization");
   postOptimization();
-  reportNumberOfSplillsReloads();
+  reportStats();
 
   releaseMemory();
   return true;
 }

llvm/test/CodeGen/AArch64/arm64-spill-remarks.ll

 
 ; NO_REMARK-NOT: remark
 
 ; THRESHOLD-NOT: (hotness: 300)
 ; THRESHOLD: remark: /tmp/kk.c:2:20: 1 spills 1 reloads generated in loop (hotness: 30000)
 
 ; YAML: --- !Missed
 ; YAML: Pass:            regalloc
-; YAML: Name:            LoopSpillReload
+; YAML: Name:            LoopSpillReloadCopies
 ; YAML: DebugLoc:        { File: '/tmp/kk.c', Line: 3, Column: 20 }
 ; YAML: Function:        fpr128
 ; YAML: Hotness:         300
 ; YAML: Args:
 ; YAML:   - NumSpills:       '1'
 ; YAML:   - String:          ' spills '
 ; YAML:   - NumReloads:      '1'
 ; YAML:   - String:          ' reloads '
 ; YAML:   - String:          generated in loop
 ; YAML: ...
 ; YAML: --- !Missed
 ; YAML: Pass:            regalloc
-; YAML: Name:            LoopSpillReload
+; YAML: Name:            LoopSpillReloadCopies
 ; YAML: DebugLoc:        { File: '/tmp/kk.c', Line: 2, Column: 20 }
 ; YAML: Function:        fpr128
 ; YAML: Hotness:         30000
 ; YAML: Args:
 ; YAML:   - NumSpills:       '1'
 ; YAML:   - String:          ' spills '
 ; YAML:   - NumReloads:      '1'
 ; YAML:   - String:          ' reloads '
 ; YAML:   - String:          generated in loop
 ; YAML: ...
 ; YAML: --- !Missed
 ; YAML: Pass:            regalloc
-; YAML: Name:            LoopSpillReload
+; YAML: Name:            LoopSpillReloadCopies
 ; YAML: DebugLoc:        { File: '/tmp/kk.c', Line: 1, Column: 20 }
 ; YAML: Function:        fpr128
 ; YAML: Hotness:         300
 ; YAML: Args:
 ; YAML:   - NumSpills:       '2'
 ; YAML:   - String:          ' spills '
 ; YAML:   - NumReloads:      '2'
 ; YAML:   - String:          ' reloads '
 ; YAML:   - String:          generated in loop
 ; YAML: ...
 ; YAML: --- !Missed
 ; YAML: Pass:            regalloc
-; YAML: Name:            SpillReload
+; YAML: Name:            SpillReloadCopies
 ; YAML: DebugLoc:        { File: '/tmp/kk.c', Line: 1, Column: 1 }
 ; YAML: Function:        fpr128
 ; YAML: Hotness:         3
 ; YAML: Args:
 ; YAML:   - NumSpills:       '3'
 ; YAML:   - String:          ' spills '
 ; YAML:   - NumReloads:      '3'
 ; YAML:   - String:          ' reloads '
 ; YAML:   - String:          generated in function
 ; YAML: ...
 
 ; THRESHOLD_YAML-NOT: Hotness:         300{{$}}
 ; THRESHOLD_YAML: --- !Missed
 ; THRESHOLD_YAML: Pass:            regalloc
-; THRESHOLD_YAML: Name:            LoopSpillReload
+; THRESHOLD_YAML: Name:            LoopSpillReloadCopies
 ; THRESHOLD_YAML: DebugLoc:        { File: '/tmp/kk.c', Line: 2, Column: 20 }
 ; THRESHOLD_YAML: Function:        fpr128
 ; THRESHOLD_YAML: Hotness:         30000
 ; THRESHOLD_YAML: Args:
 ; THRESHOLD_YAML:   - NumSpills:       '1'
 ; THRESHOLD_YAML:   - String:          ' spills '
 ; THRESHOLD_YAML:   - NumReloads:      '1'
 ; THRESHOLD_YAML:   - String:          ' reloads '

llvm/test/CodeGen/X86/statepoint-ra.ll

 ; RUN: llc -verify-machineinstrs -O3 -use-registers-for-deopt-values -restrict-statepoint-remat=true -pass-remarks-filter=regalloc -pass-remarks-output=%t.yaml -stop-after=greedy -o - < %s 2>&1 | FileCheck %s
 ; RUN: cat %t.yaml | FileCheck -check-prefix=YAML %s
 
 target triple = "x86_64-unknown-linux-gnu"
 
 ;CHECK-NOT: error: ran out of registers during register allocation
 
 ;YAML: --- !Missed
 ;YAML: Pass:            regalloc
-;YAML: Name:            SpillReload
+;YAML: Name:            SpillReloadCopies
 ;YAML: Function:        barney
 ;YAML: Args:
 ;YAML:   - NumSpills:       '10'
 ;YAML:   - String:          ' spills '
 ;YAML:   - NumReloads:      '7'
 ;YAML:   - String:          ' reloads '
 ;YAML:   - NumZeroCostFoldedReloads: '20'
 ;YAML:   - String:          ' zero cost folded reloads '
+;YAML:   - NumVRCopies:     '2'
+;YAML:   - String:          ' virtual registers copies '
 ;YAML:   - String:          generated in function
 
 define void @barney(i8 addrspace(1)* %arg, double %arg1, double %arg2, double %arg3, double %arg4, double %arg5, double %arg6, double %arg7, double %arg8, double %arg9, double %arg10, double %arg11, double %arg12) gc "statepoint-example" personality i32* ()* @widget {
 bb:
   %tmp = call coldcc token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* nonnull @blam, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 1, i32 0, i32 0, i32 0, i32 26, i32 0, i32 0, i8 addrspace(1)* %arg, i32 4, double %arg1, i32 7, i8* null, i32 4, double %arg2, i32 7, i8* null, i32 4, double %arg3, i32 7, i8* null, i32 4, double %arg4, i32 7, i8* null, i32 4, double %arg5, i32 7, i8* null, i32 4, double %arg6, i32 7, i8* null, i32 4, double %arg7, i32 7, i8* null, i32 4, double %arg8, i32 7, i8* null, i32 4, double %arg9, i32 7, i8* null, i32 4, double %arg10, i32 7, i8* null, i32 4, double %arg11, i32 7, i8* null, i32 4, double %arg12, i32 7, i8* null, i32 7, i8* null), "gc-live"(i8 addrspace(1)* %arg) ]
   br i1 undef, label %bb13, label %bb15
 
 bb13:                                             ; preds = %bb