Use separate random number generator for each randomization pass

src/IceRegAlloc.cpp

 //===- subzero/src/IceRegAlloc.cpp - Linear-scan implementation -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 232 matching lines @@
   case RAK_Global:
   case RAK_Phi:
     initForGlobal();
     break;
   case RAK_InfOnly:
     initForInfOnly();
     break;
   }
 
   auto CompareRanges = [](const Variable *L, const Variable *R) {
-      InstNumberT Lstart = L->getLiveRange().getStart();
-      InstNumberT Rstart = R->getLiveRange().getStart();
-      if (Lstart == Rstart)
-        return L->getIndex() < R->getIndex();
-      return Lstart < Rstart;
+    InstNumberT Lstart = L->getLiveRange().getStart();
+    InstNumberT Rstart = R->getLiveRange().getStart();
+    if (Lstart == Rstart)
+      return L->getIndex() < R->getIndex();
+    return Lstart < Rstart;
   };
   // Do a reverse sort so that erasing elements (from the end) is fast.
   std::sort(Unhandled.rbegin(), Unhandled.rend(), CompareRanges);
   std::sort(UnhandledPrecolored.rbegin(), UnhandledPrecolored.rend(),
             CompareRanges);
 
   Handled.reserve(Unhandled.size());
   Inactive.reserve(Unhandled.size());
   Active.reserve(Unhandled.size());
 }
@@ skipping 501 matching lines @@
   for (Variable *I : Active)
     Handled.push_back(I);
   Active.clear();
   for (Variable *I : Inactive)
     Handled.push_back(I);
   Inactive.clear();
   dump(Func);
 
   llvm::SmallVector<int32_t, REGS_SIZE> Permutation(NumRegisters);
   if (Randomized) {
+    // Create a random number generator for regalloc randomization. Merge
+    // function's sequence and Kind value as the Salt. Because regalloc()

[Jim Stichnoth, 2015/08/20 20:01:33]

regAlloc

+    // are called twice under O2, the second time with RAK_Phi, we check

[Jim Stichnoth, 2015/08/20 20:01:33]

is called

+    // Kind == RAK_Phi to determine the least bit to make sure the Salt is

[Jim Stichnoth, 2015/08/20 20:01:33]

I would say "lowest-order" instead of "least".

+    // different.
+    uint64_t Salt =
+        (Func->getSequenceNumber() << 1) ^ (Kind == RAK_Phi ? 0u : 1u);
     Func->getTarget()->makeRandomRegisterPermutation(
-        Permutation, PreDefinedRegisters | ~RegMaskFull);
+        Permutation, PreDefinedRegisters | ~RegMaskFull, Salt);
   }
 
   // Finish up by assigning RegNumTmp->RegNum (or a random permutation
   // thereof) for each Variable.
   for (Variable *Item : Handled) {
     int32_t RegNum = Item->getRegNumTmp();
     int32_t AssignedRegNum = RegNum;
 
     if (Randomized && Item->hasRegTmp() && !Item->hasReg()) {
       AssignedRegNum = Permutation[RegNum];
@@ skipping 57 matching lines @@
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice