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) {
     Func->getTarget()->makeRandomRegisterPermutation(

[Jim Stichnoth, 2015/08/19 19:03:04]

Can you make it so that the RNG is initialized using a different passID when
Kind==RAK_Phi?  (This means having two separate randomization pass IDs for
register allocation.)  The issue is that register allocation is called twice for
O2, once before and once after phi lowering.

[qining, 2015/08/19 23:25:49]

Done. The salt will be calculated here and then passed down to
makeRandomRegisterPermutation() to create RNG.

         Permutation, PreDefinedRegisters | ~RegMaskFull);
   }
 
   // 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()) {
@@ skipping 58 matching lines @@
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice