[llvm-stress] Use C++11 mersenne_twister_engine random device instead of our own (PR32585)

[RKSimon]

Summary

As discussed on D34089, this patch replaces the existing custom Random class with the C++ mersenne_twister_engine instead, which should maintain equivalent values on different targets.

llvm-stress is still driven by an input seed, but the change in randomizer will mean that the fuzz test codegen won't match previous results.

[chandlerc]

Rather than using the RNG engine directly and using mod operations, the correct usage pattern is to use a distribution over the desired range and let it pull raw entropy out of the engine while mapping it into whatever distribution the use case requires.

See http://en.cppreference.com/w/cpp/numeric/random/uniform_int_distribution for more details.

[RKSimon]

Updated as requested by @chandlerc - my only concern is I have no idea if uniform_int_distribution guarantees the same behaviour on different targets as mersene does.

[mclow.lists]

my only concern is I have no idea if uniform_int_distribution guarantees the same behaviour on different targets as mersene does

It does not.
[rand.dist.general]/3:

The algorithms for producing each of the specified distributions are implementation-defined.

[RKSimon]

ping?

[chandlerc]

In D34157#781369, @mclow.lists wrote:

my only concern is I have no idea if uniform_int_distribution guarantees the same behaviour on different targets as mersene does

It does not.
[rand.dist.general]/3:

The algorithms for producing each of the specified distributions are implementation-defined.

Wait, really? This makes using a seeded PRNG inside any of the standard distributions pretty much useless -- you can seed things all you want but you can't actually reproduce the particular results when fed through a distribution...

If this is true, it seems like yet another horrible and glaring hole in the entire PRNG system of the C++ standard library, which is pretty sad IMO.

We still shouldn't (IMO) use the raw and undistributed results of the PRNG engine. But maybe we have to build our own API (perhaps based in part on libc++'s code) since we can't actually use the standard library.

[hfinkel]

In D34157#788527, @chandlerc wrote:

In D34157#781369, @mclow.lists wrote:

my only concern is I have no idea if uniform_int_distribution guarantees the same behaviour on different targets as mersene does

It does not.
[rand.dist.general]/3:

The algorithms for producing each of the specified distributions are implementation-defined.

Wait, really? This makes using a seeded PRNG inside any of the standard distributions pretty much useless -- you can seed things all you want but you can't actually reproduce the particular results when fed through a distribution...

I wouldn't go so far as to say that makes the seeding useless, there are still plenty of use cases (and, FWIW, makes them no better than the system *rand*() functions). It does rule out this use case, however.

[jroelofs]

tools/llvm-stress/llvm-stress.cpp

47

Can you use the llvm::RandomNumberGenerator wrapper instead? That prevents accidentally copying it.

[RKSimon]

tools/llvm-stress/llvm-stress.cpp

47

Maybe, although it'll need a slight refactor of how the salt/seeding system works. llvm::RandomNumberGenerator creates a salt based on the pass' name and module id. We need the ability to support llvm-stress providing a seed value at the command line

[RKSimon]

Abandoning ancient patch

tools/llvm-stress/llvm-stress.cpp

static cl::opt<unsigned> SizeCL("size",
   cl::desc("The estimated size of the generated function (# of instrs)"),
   cl::init(100));
 static cl::opt<std::string>
 OutputFilename("o", cl::desc("Override output filename"),
                cl::value_desc("filename"));
 
 static LLVMContext Context;
 
+typedef std::mt19937_64 RandomGen;
+typedef std::uniform_int_distribution<uint64_t> RandomDist;
+
 namespace cl {
 template <> class parser<Type*> final : public basic_parser<Type*> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Parse options as IR types. Return true on error.
   bool parse(Option &O, StringRef, StringRef Arg, Type *&Value) {
     if      (Arg == "half")      Value = Type::getHalfTy(Context);

 }
 
 
 static cl::list<Type*> AdditionalScalarTypes("types", cl::CommaSeparated,
   cl::desc("Additional IR scalar types "
            "(always includes i1, i8, i16, i32, i64, float and double)"));
 
 namespace {
-/// A utility class to provide a pseudo-random number generator which is
-/// the same across all platforms. This is somewhat close to the libc
-/// implementation. Note: This is not a cryptographically secure pseudorandom
-/// number generator.
-class Random {
-public:
-  /// C'tor
-  Random(unsigned _seed):Seed(_seed) {}
-
-  /// Return a random integer, up to a
-  /// maximum of 2**19 - 1.
-  uint32_t Rand() {
-    uint32_t Val = Seed + 0x000b07a1;
-    Seed = (Val * 0x3c7c0ac1);
-    // Only lowest 19 bits are random-ish.
-    return Seed & 0x7ffff;
-  }
-
-  /// Return a random 32 bit integer.
-  uint32_t Rand32() {
-    uint32_t Val = Rand();
-    Val &= 0xffff;
-    return Val | (Rand() << 16);
-  }
-
-  /// Return a random 64 bit integer.
-  uint64_t Rand64() {
-    uint64_t Val = Rand32();
-    return Val | (uint64_t(Rand32()) << 32);
-  }
-
-  /// Rand operator for STL algorithms.
-  ptrdiff_t operator()(ptrdiff_t y) {
-    return  Rand64() % y;
-  }
-
-  /// Make this like a C++11 random device
-  typedef uint32_t result_type;
-  uint32_t operator()() { return Rand32(); }
-  static constexpr result_type min() { return 0; }
-  static constexpr result_type max() { return 0x7ffff; }
-  
-private:
-  unsigned Seed;
-};
-
 /// Generate an empty function with a default argument list.
 Function *GenEmptyFunction(Module *M) {
   // Define a few arguments
   LLVMContext &Context = M->getContext();
   Type* ArgsTy[] = {
     Type::getInt8PtrTy(Context),
     Type::getInt32PtrTy(Context),
     Type::getInt64PtrTy(Context),

 /// A base class, implementing utilities needed for
 /// modifying and adding new random instructions.
 struct Modifier {
   /// Used to store the randomly generated values.
   typedef std::vector<Value*> PieceTable;
 
 public:
   /// C'tor
-  Modifier(BasicBlock *Block, PieceTable *PT, Random *R):
-    BB(Block),PT(PT),Ran(R),Context(BB->getContext()) {}
+  Modifier(BasicBlock *Block, PieceTable *PT, RandomGen *RG, RandomDist *RD):
+    BB(Block),PT(PT),RanG(RG),RanD(RD),Context(BB->getContext()) {}
 
   /// virtual D'tor to silence warnings.
   virtual ~Modifier() {}
 
   /// Add a new instruction.
   virtual void Act() = 0;
   /// Add N new instructions,
   virtual void ActN(unsigned n) {
     for (unsigned i=0; i<n; ++i)
       Act();
   }
 
 protected:
+  /// Return a random integer.
+  uint64_t getRandom() {
+    return (*RanD)(*RanG);
+  }
+
   /// Return a random value from the list of known values.
   Value *getRandomVal() {
     assert(PT->size());
-    return PT->at(Ran->Rand() % PT->size());
+    return PT->at(getRandom() % PT->size());
   }
 
   Constant *getRandomConstant(Type *Tp) {
     if (Tp->isIntegerTy()) {
-      if (Ran->Rand() & 1)
+      if (getRandom() & 1)
         return ConstantInt::getAllOnesValue(Tp);
       return ConstantInt::getNullValue(Tp);
     } else if (Tp->isFloatingPointTy()) {
-      if (Ran->Rand() & 1)
+      if (getRandom() & 1)
         return ConstantFP::getAllOnesValue(Tp);
       return ConstantFP::getNullValue(Tp);
     }
     return UndefValue::get(Tp);
   }
 
   /// Return a random value with a known type.
   Value *getRandomValue(Type *Tp) {
-    unsigned index = Ran->Rand();
+    unsigned index = getRandom();
     for (unsigned i=0; i<PT->size(); ++i) {
       Value *V = PT->at((index + i) % PT->size());
       if (V->getType() == Tp)
         return V;
     }
 
     // If the requested type was not found, generate a constant value.
     if (Tp->isIntegerTy()) {
-      if (Ran->Rand() & 1)
+      if (getRandom() & 1)
         return ConstantInt::getAllOnesValue(Tp);
       return ConstantInt::getNullValue(Tp);
     } else if (Tp->isFloatingPointTy()) {
-      if (Ran->Rand() & 1)
+      if (getRandom() & 1)
         return ConstantFP::getAllOnesValue(Tp);
       return ConstantFP::getNullValue(Tp);
     } else if (Tp->isVectorTy()) {
       VectorType *VTp = cast<VectorType>(Tp);
 
       std::vector<Constant*> TempValues;
       TempValues.reserve(VTp->getNumElements());
       for (unsigned i = 0; i < VTp->getNumElements(); ++i)
         TempValues.push_back(getRandomConstant(VTp->getScalarType()));
 
       ArrayRef<Constant*> VectorValue(TempValues);
       return ConstantVector::get(VectorValue);
     }
 
     return UndefValue::get(Tp);
   }
 
   /// Return a random value of any pointer type.
   Value *getRandomPointerValue() {
-    unsigned index = Ran->Rand();
+    unsigned index = getRandom();
     for (unsigned i=0; i<PT->size(); ++i) {
       Value *V = PT->at((index + i) % PT->size());
       if (V->getType()->isPointerTy())
         return V;
     }
     return UndefValue::get(pickPointerType());
   }
 
   /// Return a random value of any vector type.
   Value *getRandomVectorValue() {
-    unsigned index = Ran->Rand();
+    unsigned index = getRandom();
     for (unsigned i=0; i<PT->size(); ++i) {
       Value *V = PT->at((index + i) % PT->size());
       if (V->getType()->isVectorTy())
         return V;
     }
     return UndefValue::get(pickVectorType());
   }
 
   /// Pick a random type.
   Type *pickType() {
-    return (Ran->Rand() & 1 ? pickVectorType() : pickScalarType());
+    return (getRandom() & 1 ? pickVectorType() : pickScalarType());
   }
 
   /// Pick a random pointer type.
   Type *pickPointerType() {
     Type *Ty = pickType();
     return PointerType::get(Ty, 0);
   }
 
   /// Pick a random vector type.
   Type *pickVectorType(unsigned len = (unsigned)-1) {
     // Pick a random vector width in the range 2**0 to 2**4.
     // by adding two randoms we are generating a normal-like distribution
     // around 2**3.
-    unsigned width = 1<<((Ran->Rand() % 3) + (Ran->Rand() % 3));
+    unsigned width = 1<<((getRandom() % 3) + (getRandom() % 3));
     Type *Ty;
 
     // Vectors of x86mmx are illegal; keep trying till we get something else.
     do {
       Ty = pickScalarType();
     } while (Ty->isX86_MMXTy());
 
     if (len != (unsigned)-1)
if (ScalarTypes.empty()) {
         Type::getInt64Ty(Context),
         Type::getFloatTy(Context),
         Type::getDoubleTy(Context)
       });
       ScalarTypes.insert(ScalarTypes.end(),
         AdditionalScalarTypes.begin(), AdditionalScalarTypes.end());
     }
 
-    return ScalarTypes[Ran->Rand() % ScalarTypes.size()];
+    return ScalarTypes[getRandom() % ScalarTypes.size()];
   }
 
   /// Basic block to populate
   BasicBlock *BB;
   /// Value table
   PieceTable *PT;
   /// Random number generator
-  Random *Ran;
+  RandomGen *RanG;
+  RandomDist *RanD;
   /// Context
   LLVMContext &Context;
 };
 
 struct LoadModifier: public Modifier {
-  LoadModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
+  LoadModifier(BasicBlock *BB, PieceTable *PT, RandomGen *RG, RandomDist *RD):
+    Modifier(BB, PT, RG, RD) {}
+
   void Act() override {
     // Try to use predefined pointers. If non-exist, use undef pointer value;
     Value *Ptr = getRandomPointerValue();
     Value *V = new LoadInst(Ptr, "L", BB->getTerminator());
     PT->push_back(V);
   }
 };
 
 struct StoreModifier: public Modifier {
-  StoreModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
+  StoreModifier(BasicBlock *BB, PieceTable *PT, RandomGen *RG, RandomDist *RD):
+    Modifier(BB, PT, RG, RD) {}
+
   void Act() override {
     // Try to use predefined pointers. If non-exist, use undef pointer value;
     Value *Ptr = getRandomPointerValue();
     Type  *Tp = Ptr->getType();
     Value *Val = getRandomValue(Tp->getContainedType(0));
     Type  *ValTy = Val->getType();
 
     // Do not store vectors of i1s because they are unsupported
     // by the codegen.
     if (ValTy->isVectorTy() && ValTy->getScalarSizeInBits() == 1)
       return;
 
     new StoreInst(Val, Ptr, BB->getTerminator());
   }
 };
 
 struct BinModifier: public Modifier {
-  BinModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
+  BinModifier(BasicBlock *BB, PieceTable *PT, RandomGen *RG, RandomDist *RD):
+    Modifier(BB, PT, RG, RD) {}
 
   void Act() override {
     Value *Val0 = getRandomVal();
     Value *Val1 = getRandomValue(Val0->getType());
 
     // Don't handle pointer types.
     if (Val0->getType()->isPointerTy() ||
         Val1->getType()->isPointerTy())
       return;
 
     // Don't handle i1 types.
     if (Val0->getType()->getScalarSizeInBits() == 1)
       return;
 
 
     bool isFloat = Val0->getType()->getScalarType()->isFloatingPointTy();
     Instruction* Term = BB->getTerminator();
-    unsigned R = Ran->Rand() % (isFloat ? 7 : 13);
+    unsigned R = getRandom() % (isFloat ? 7 : 13);
     Instruction::BinaryOps Op;
 
     switch (R) {
     default: llvm_unreachable("Invalid BinOp");
     case 0:{Op = (isFloat?Instruction::FAdd : Instruction::Add); break; }
     case 1:{Op = (isFloat?Instruction::FSub : Instruction::Sub); break; }
     case 2:{Op = (isFloat?Instruction::FMul : Instruction::Mul); break; }
     case 3:{Op = (isFloat?Instruction::FDiv : Instruction::SDiv); break; }
void Act() override {
     }
 
     PT->push_back(BinaryOperator::Create(Op, Val0, Val1, "B", Term));
   }
 };
 
 /// Generate constant values.
 struct ConstModifier: public Modifier {
-  ConstModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
+  ConstModifier(BasicBlock *BB, PieceTable *PT, RandomGen *RG, RandomDist *RD):
+    Modifier(BB, PT, RG, RD) {}
+
   void Act() override {
     Type *Ty = pickType();
 
     if (Ty->isVectorTy()) {
-      switch (Ran->Rand() % 2) {
+      switch (getRandom() % 2) {
       case 0: if (Ty->getScalarType()->isIntegerTy())
                 return PT->push_back(ConstantVector::getAllOnesValue(Ty));
               break;
       case 1: if (Ty->getScalarType()->isIntegerTy())
                 return PT->push_back(ConstantVector::getNullValue(Ty));
       }
     }
 
     if (Ty->isFloatingPointTy()) {
       // Generate 128 random bits, the size of the (currently)
       // largest floating-point types.
       uint64_t RandomBits[2];
       for (unsigned i = 0; i < 2; ++i)
-        RandomBits[i] = Ran->Rand64();
+        RandomBits[i] = getRandom();
 
       APInt RandomInt(Ty->getPrimitiveSizeInBits(), makeArrayRef(RandomBits));
       APFloat RandomFloat(Ty->getFltSemantics(), RandomInt);
 
-      if (Ran->Rand() & 1)
+      if (getRandom() & 1)
         return PT->push_back(ConstantFP::getNullValue(Ty));
       return PT->push_back(ConstantFP::get(Ty->getContext(), RandomFloat));
     }
 
     if (Ty->isIntegerTy()) {
-      switch (Ran->Rand() % 7) {
+      switch (getRandom() % 7) {
       case 0:
         return PT->push_back(ConstantInt::get(
             Ty, APInt::getAllOnesValue(Ty->getPrimitiveSizeInBits())));
       case 1:
         return PT->push_back(ConstantInt::get(
             Ty, APInt::getNullValue(Ty->getPrimitiveSizeInBits())));
       case 2: case 3: case 4: case 5:
       case 6:
-        PT->push_back(ConstantInt::get(Ty, Ran->Rand()));
+        PT->push_back(ConstantInt::get(Ty, getRandom()));
       }
     }
 
   }
 };
 
 struct AllocaModifier: public Modifier {
-  AllocaModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R){}
+  AllocaModifier(BasicBlock *BB, PieceTable *PT, RandomGen *RG, RandomDist *RD):
+    Modifier(BB, PT, RG, RD){}
 
   void Act() override {
     Type *Tp = pickType();
     const DataLayout &DL = BB->getModule()->getDataLayout();
     PT->push_back(new AllocaInst(Tp, DL.getAllocaAddrSpace(),
                                  "A", BB->getFirstNonPHI()));
   }
 };
 
 struct ExtractElementModifier: public Modifier {
-  ExtractElementModifier(BasicBlock *BB, PieceTable *PT, Random *R):
-    Modifier(BB, PT, R) {}
+  ExtractElementModifier(BasicBlock *BB, PieceTable *PT, RandomGen *RG, RandomDist *RD):
+    Modifier(BB, PT, RG, RD) {}
 
   void Act() override {
     Value *Val0 = getRandomVectorValue();
     Value *V = ExtractElementInst::Create(Val0,
              ConstantInt::get(Type::getInt32Ty(BB->getContext()),
-             Ran->Rand() % cast<VectorType>(Val0->getType())->getNumElements()),
+             getRandom() % cast<VectorType>(Val0->getType())->getNumElements()),
              "E", BB->getTerminator());
     return PT->push_back(V);
   }
 };
 
 struct ShuffModifier: public Modifier {
-  ShuffModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
-  void Act() override {
+  ShuffModifier(BasicBlock *BB, PieceTable *PT, RandomGen *RG, RandomDist *RD):
+    Modifier(BB, PT, RG, RD) {}
 
+  void Act() override {
     Value *Val0 = getRandomVectorValue();
     Value *Val1 = getRandomValue(Val0->getType());
 
     unsigned Width = cast<VectorType>(Val0->getType())->getNumElements();
     std::vector<Constant*> Idxs;
 
     Type *I32 = Type::getInt32Ty(BB->getContext());
     for (unsigned i=0; i<Width; ++i) {
-      Constant *CI = ConstantInt::get(I32, Ran->Rand() % (Width*2));
+      Constant *CI = ConstantInt::get(I32, getRandom() % (Width*2));
       // Pick some undef values.
-      if (!(Ran->Rand() % 5))
+      if (!(getRandom() % 5))
         CI = UndefValue::get(I32);
       Idxs.push_back(CI);
     }
 
     Constant *Mask = ConstantVector::get(Idxs);
 
     Value *V = new ShuffleVectorInst(Val0, Val1, Mask, "Shuff",
                                      BB->getTerminator());
     PT->push_back(V);
   }
 };
 
 struct InsertElementModifier: public Modifier {
-  InsertElementModifier(BasicBlock *BB, PieceTable *PT, Random *R):
-    Modifier(BB, PT, R) {}
+  InsertElementModifier(BasicBlock *BB, PieceTable *PT, RandomGen *RG, RandomDist *RD):
+    Modifier(BB, PT, RG, RD) {}
 
   void Act() override {
     Value *Val0 = getRandomVectorValue();
     Value *Val1 = getRandomValue(Val0->getType()->getScalarType());
 
     Value *V = InsertElementInst::Create(Val0, Val1,
               ConstantInt::get(Type::getInt32Ty(BB->getContext()),
-              Ran->Rand() % cast<VectorType>(Val0->getType())->getNumElements()),
+              getRandom() % cast<VectorType>(Val0->getType())->getNumElements()),
               "I",  BB->getTerminator());
     return PT->push_back(V);
   }
 
 };
 
 struct CastModifier: public Modifier {
-  CastModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
-  void Act() override {
+  CastModifier(BasicBlock *BB, PieceTable *PT, RandomGen *RG, RandomDist *RD):
+    Modifier(BB, PT, RG, RD) {}
 
+  void Act() override {
     Value *V = getRandomVal();
     Type *VTy = V->getType();
     Type *DestTy = pickScalarType();
 
     // Handle vector casts vectors.
     if (VTy->isVectorTy()) {
       VectorType *VecTy = cast<VectorType>(VTy);
       DestTy = pickVectorType(VecTy->getNumElements());
if (VTy->isPointerTy()) {
       return PT->push_back(
         new BitCastInst(V, DestTy, "PC", BB->getTerminator()));
     }
 
     unsigned VSize = VTy->getScalarType()->getPrimitiveSizeInBits();
     unsigned DestSize = DestTy->getScalarType()->getPrimitiveSizeInBits();
 
     // Generate lots of bitcasts.
-    if ((Ran->Rand() & 1) && VSize == DestSize) {
+    if ((getRandom() & 1) && VSize == DestSize) {
       return PT->push_back(
         new BitCastInst(V, DestTy, "BC", BB->getTerminator()));
     }
 
     // Both types are integers:
     if (VTy->getScalarType()->isIntegerTy() &&
         DestTy->getScalarType()->isIntegerTy()) {
       if (VSize > DestSize) {
         return PT->push_back(
           new TruncInst(V, DestTy, "Tr", BB->getTerminator()));
       } else {
         assert(VSize < DestSize && "Different int types with the same size?");
-        if (Ran->Rand() & 1)
+        if (getRandom() & 1)
           return PT->push_back(
             new ZExtInst(V, DestTy, "ZE", BB->getTerminator()));
         return PT->push_back(new SExtInst(V, DestTy, "Se", BB->getTerminator()));
       }
     }
 
     // Fp to int.
     if (VTy->getScalarType()->isFloatingPointTy() &&
         DestTy->getScalarType()->isIntegerTy()) {
-      if (Ran->Rand() & 1)
+      if (getRandom() & 1)
         return PT->push_back(
           new FPToSIInst(V, DestTy, "FC", BB->getTerminator()));
       return PT->push_back(new FPToUIInst(V, DestTy, "FC", BB->getTerminator()));
     }
 
     // Int to fp.
     if (VTy->getScalarType()->isIntegerTy() &&
         DestTy->getScalarType()->isFloatingPointTy()) {
-      if (Ran->Rand() & 1)
+      if (getRandom() & 1)
         return PT->push_back(
           new SIToFPInst(V, DestTy, "FC", BB->getTerminator()));
       return PT->push_back(new UIToFPInst(V, DestTy, "FC", BB->getTerminator()));
 
     }
 
     // Both floats.
     if (VTy->getScalarType()->isFloatingPointTy() &&
         DestTy->getScalarType()->isFloatingPointTy()) {
       if (VSize > DestSize) {
         return PT->push_back(
           new FPTruncInst(V, DestTy, "Tr", BB->getTerminator()));
       } else if (VSize < DestSize) {
         return PT->push_back(
           new FPExtInst(V, DestTy, "ZE", BB->getTerminator()));
       }
       // If VSize == DestSize, then the two types must be fp128 and ppc_fp128,
       // for which there is no defined conversion. So do nothing.
     }
   }
 
 };
 
 struct SelectModifier: public Modifier {
-  SelectModifier(BasicBlock *BB, PieceTable *PT, Random *R):
-    Modifier(BB, PT, R) {}
+  SelectModifier(BasicBlock *BB, PieceTable *PT, RandomGen *RG, RandomDist *RD):
+    Modifier(BB, PT, RG, RD) {}
 
   void Act() override {
     // Try a bunch of different select configuration until a valid one is found.
       Value *Val0 = getRandomVal();
       Value *Val1 = getRandomValue(Val0->getType());
 
       Type *CondTy = Type::getInt1Ty(Context);
 
       // If the value type is a vector, and we allow vector select, then in 50%
       // of the cases generate a vector select.
-      if (Val0->getType()->isVectorTy() && (Ran->Rand() % 1)) {
+      if (Val0->getType()->isVectorTy() && (getRandom() % 1)) {
         unsigned NumElem = cast<VectorType>(Val0->getType())->getNumElements();
         CondTy = VectorType::get(CondTy, NumElem);
       }
 
       Value *Cond = getRandomValue(CondTy);
       Value *V = SelectInst::Create(Cond, Val0, Val1, "Sl", BB->getTerminator());
       return PT->push_back(V);
   }
 };
 
 
 struct CmpModifier: public Modifier {
-  CmpModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
-  void Act() override {
+  CmpModifier(BasicBlock *BB, PieceTable *PT, RandomGen *RG, RandomDist *RD):
+    Modifier(BB, PT, RG, RD) {}
 
+  void Act() override {
     Value *Val0 = getRandomVal();
     Value *Val1 = getRandomValue(Val0->getType());
 
     if (Val0->getType()->isPointerTy()) return;
     bool fp = Val0->getType()->getScalarType()->isFloatingPointTy();
 
     int op;
     if (fp) {
-      op = Ran->Rand() %
+      op = getRandom() %
       (CmpInst::LAST_FCMP_PREDICATE - CmpInst::FIRST_FCMP_PREDICATE) +
        CmpInst::FIRST_FCMP_PREDICATE;
     } else {
-      op = Ran->Rand() %
+      op = getRandom() %
       (CmpInst::LAST_ICMP_PREDICATE - CmpInst::FIRST_ICMP_PREDICATE) +
        CmpInst::FIRST_ICMP_PREDICATE;
     }
 
     Value *V = CmpInst::Create(fp ? Instruction::FCmp : Instruction::ICmp,
                                (CmpInst::Predicate)op, Val0, Val1, "Cmp",
                                BB->getTerminator());
     return PT->push_back(V);
   }
 };
 
 } // end anonymous namespace
 
-static void FillFunction(Function *F, Random &R) {
+static void FillFunction(Function *F, RandomGen &RG, RandomDist &RD) {
   // Create a legal entry block.
   BasicBlock *BB = BasicBlock::Create(F->getContext(), "BB", F);
   ReturnInst::Create(F->getContext(), BB);
 
   // Create the value table.
   Modifier::PieceTable PT;
 
   // Consider arguments as legal values.
   for (auto &arg : F->args())
     PT.push_back(&arg);
 
   // List of modifiers which add new random instructions.
   std::vector<std::unique_ptr<Modifier>> Modifiers;
-  Modifiers.emplace_back(new LoadModifier(BB, &PT, &R));
-  Modifiers.emplace_back(new StoreModifier(BB, &PT, &R));
+  Modifiers.emplace_back(new LoadModifier(BB, &PT, &RG, &RD));
+  Modifiers.emplace_back(new StoreModifier(BB, &PT, &RG, &RD));
   auto SM = Modifiers.back().get();
-  Modifiers.emplace_back(new ExtractElementModifier(BB, &PT, &R));
-  Modifiers.emplace_back(new ShuffModifier(BB, &PT, &R));
-  Modifiers.emplace_back(new InsertElementModifier(BB, &PT, &R));
-  Modifiers.emplace_back(new BinModifier(BB, &PT, &R));
-  Modifiers.emplace_back(new CastModifier(BB, &PT, &R));
-  Modifiers.emplace_back(new SelectModifier(BB, &PT, &R));
-  Modifiers.emplace_back(new CmpModifier(BB, &PT, &R));
+  Modifiers.emplace_back(new ExtractElementModifier(BB, &PT, &RG, &RD));
+  Modifiers.emplace_back(new ShuffModifier(BB, &PT, &RG, &RD));
+  Modifiers.emplace_back(new InsertElementModifier(BB, &PT, &RG, &RD));
+  Modifiers.emplace_back(new BinModifier(BB, &PT, &RG, &RD));
+  Modifiers.emplace_back(new CastModifier(BB, &PT, &RG, &RD));
+  Modifiers.emplace_back(new SelectModifier(BB, &PT, &RG, &RD));
+  Modifiers.emplace_back(new CmpModifier(BB, &PT, &RG, &RD));
 
   // Generate the random instructions
-  AllocaModifier{BB, &PT, &R}.ActN(5); // Throw in a few allocas
-  ConstModifier{BB, &PT, &R}.ActN(40); // Throw in a few constants
+  AllocaModifier{BB, &PT, &RG, &RD}.ActN(5); // Throw in a few allocas
+  ConstModifier{BB, &PT, &RG, &RD}.ActN(40); // Throw in a few constants
 
   for (unsigned i = 0; i < SizeCL / Modifiers.size(); ++i)
     for (auto &Mod : Modifiers)
       Mod->Act();
 
   SM->ActN(5); // Throw in a few stores.
 }
 
-static void IntroduceControlFlow(Function *F, Random &R) {
+static void IntroduceControlFlow(Function *F, RandomGen &RG) {
   std::vector<Instruction*> BoolInst;
   for (auto &Instr : F->front()) {
     if (Instr.getType() == IntegerType::getInt1Ty(F->getContext()))
       BoolInst.push_back(&Instr);
   }
 
-  std::shuffle(BoolInst.begin(), BoolInst.end(), R);
+  std::shuffle(BoolInst.begin(), BoolInst.end(), RG);
 
   for (auto *Instr : BoolInst) {
     BasicBlock *Curr = Instr->getParent();
     BasicBlock::iterator Loc = Instr->getIterator();
     BasicBlock *Next = Curr->splitBasicBlock(Loc, "CF");
     Instr->moveBefore(Curr->getTerminator());
     if (Curr != &F->getEntryBlock()) {
       BranchInst::Create(Curr, Next, Instr, Curr->getTerminator());
int main(int argc, char **argv) {
   PrettyStackTraceProgram X(argc, argv);
   cl::ParseCommandLineOptions(argc, argv, "llvm codegen stress-tester\n");
   llvm_shutdown_obj Y;
 
   auto M = make_unique<Module>("/tmp/autogen.bc", Context);
   Function *F = GenEmptyFunction(M.get());
 
   // Pick an initial seed value
-  Random R(SeedCL);
+  RandomGen RndG(SeedCL);
+  // Pick a random distribution
+  RandomDist RndD(0, UINT64_MAX);
   // Generate lots of random instructions inside a single basic block.
-  FillFunction(F, R);
+  FillFunction(F, RndG, RndD);
   // Break the basic block into many loops.
-  IntroduceControlFlow(F, R);
+  IntroduceControlFlow(F, RndG);
 
   // Figure out what stream we are supposed to write to...
   std::unique_ptr<tool_output_file> Out;
   // Default to standard output.
   if (OutputFilename.empty())
     OutputFilename = "-";
 
   std::error_code EC;