[llvm] e5e55c0 - [GlobalMerge][NFC] Skip sorting by profitability when it is not needed (#124146)

[via llvm-commits]

Author: Michael Maitland
Date: 2025-01-24T09:08:34-05:00
New Revision: e5e55c04d6af4ae32c99d574f59e632595abf607

URL: https://github.com/llvm/llvm-project/commit/e5e55c04d6af4ae32c99d574f59e632595abf607
DIFF: https://github.com/llvm/llvm-project/commit/e5e55c04d6af4ae32c99d574f59e632595abf607.diff

LOG: [GlobalMerge][NFC] Skip sorting by profitability when it is not needed (#124146)

We were previously sorting by profitability even if we were choosing to
merge all globals together, which is not impacted by UsedGlobalSet
order.

We can also remove iteration of UsedGlobalSets in reverse order in both
cases. In the first csae, the order does not matter. In the second case,
we just sort by the order we need instead of sorting in the opposite
direction and calling reverse.

This change should only be an improvement on compile time. I have not
measured it, but I think it would never make things worse.

Added: 
    

Modified: 
    llvm/lib/CodeGen/GlobalMerge.cpp

Removed: 
    


################################################################################
diff  --git a/llvm/lib/CodeGen/GlobalMerge.cpp b/llvm/lib/CodeGen/GlobalMerge.cpp
index 7b76155b175d1d..41e01a1d3ccd52 100644
--- a/llvm/lib/CodeGen/GlobalMerge.cpp
+++ b/llvm/lib/CodeGen/GlobalMerge.cpp
@@ -423,24 +423,12 @@ bool GlobalMergeImpl::doMerge(SmallVectorImpl<GlobalVariable *> &Globals,
     }
   }
 
-  // Now we found a bunch of sets of globals used together.  We accumulated
-  // the number of times we encountered the sets (i.e., the number of functions
-  // that use that exact set of globals).
-  //
-  // Multiply that by the size of the set to give us a crude profitability
-  // metric.
-  llvm::stable_sort(UsedGlobalSets,
-                    [](const UsedGlobalSet &UGS1, const UsedGlobalSet &UGS2) {
-                      return UGS1.Globals.count() * UGS1.UsageCount <
-                             UGS2.Globals.count() * UGS2.UsageCount;
-                    });
-
   // We can choose to merge all globals together, but ignore globals never used
   // with another global.  This catches the obviously non-profitable cases of
   // having a single global, but is aggressive enough for any other case.
   if (GlobalMergeIgnoreSingleUse) {
     BitVector AllGlobals(Globals.size());
-    for (const UsedGlobalSet &UGS : llvm::reverse(UsedGlobalSets)) {
+    for (const UsedGlobalSet &UGS : UsedGlobalSets) {
       if (UGS.UsageCount == 0)
         continue;
       if (UGS.Globals.count() > 1)
@@ -449,6 +437,16 @@ bool GlobalMergeImpl::doMerge(SmallVectorImpl<GlobalVariable *> &Globals,
     return doMerge(Globals, AllGlobals, M, isConst, AddrSpace);
   }
 
+  // Now we found a bunch of sets of globals used together. We accumulated
+  // the number of times we encountered the sets (i.e., the number of functions
+  // that use that exact set of globals). Multiply that by the size of the set
+  // to give us a crude profitability metric.
+  llvm::stable_sort(UsedGlobalSets,
+                    [](const UsedGlobalSet &UGS1, const UsedGlobalSet &UGS2) {
+                      return UGS1.Globals.count() * UGS1.UsageCount >=
+                             UGS2.Globals.count() * UGS2.UsageCount;
+                    });
+
   // Starting from the sets with the best (=biggest) profitability, find a
   // good combination.
   // The ideal (and expensive) solution can only be found by trying all
@@ -458,7 +456,7 @@ bool GlobalMergeImpl::doMerge(SmallVectorImpl<GlobalVariable *> &Globals,
   BitVector PickedGlobals(Globals.size());
   bool Changed = false;
 
-  for (const UsedGlobalSet &UGS : llvm::reverse(UsedGlobalSets)) {
+  for (const UsedGlobalSet &UGS : UsedGlobalSets) {
     if (UGS.UsageCount == 0)
       continue;
     if (PickedGlobals.anyCommon(UGS.Globals))