Change old PRG to be SkLCGRandom; change new one to SkRandom

bench/ScalarBench.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkBenchmark.h"
 #include "SkFloatBits.h"
 #include "SkRandom.h"
@@ skipping 38 matching lines @@
     do {                                    \
         if (pred) {                         \
             ++gScalarBench_NonStaticGlobal; \
         }                                   \
     } while (0)
 
 // having unknown values in our arrays can throw off the timing a lot, perhaps
 // handling NaN values is a lot slower. Anyway, this guy is just meant to put
 // reasonable values in our arrays.
 template <typename T> void init9(T array[9]) {
-    SkMWCRandom rand;
+    SkRandom rand;
     for (int i = 0; i < 9; i++) {
         array[i] = rand.nextSScalar1();
     }
 }
 
 class FloatComparisonBench : public ScalarBench {
 public:
     FloatComparisonBench(void* param) : INHERITED(param, "compare_float") {
         init9(fArray);
     }
@@ skipping 25 matching lines @@
     }
 private:
     static const int32_t kPersp1Int = 0x3f800000;
     SkScalar fArray[9];
     typedef ScalarBench INHERITED;
 };
 
 class IsFiniteScalarBench : public ScalarBench {
 public:
     IsFiniteScalarBench(void* param) : INHERITED(param, "isfinite") {
-        SkMWCRandom rand;
+        SkRandom rand;
         for (size_t i = 0; i < ARRAY_N; ++i) {
             fArray[i] = rand.nextSScalar1();
         }
     }
 protected:
     virtual int mulLoopCount() const { return 1; }
     virtual void performTest() SK_OVERRIDE {
         int sum = 0;
         for (size_t i = 0; i < ARRAY_N; ++i) {
             // We pass -fArray[i], so the compiler can't cheat and treat the
@@ skipping 18 matching lines @@
 
 class RectBoundsBench : public SkBenchmark {
     enum {
         PTS = 100,
         N = SkBENCHLOOP(10000)
     };
     SkPoint fPts[PTS];
 
 public:
     RectBoundsBench(void* param) : INHERITED(param) {
-        SkMWCRandom rand;
+        SkRandom rand;
         for (int i = 0; i < PTS; ++i) {
             fPts[i].fX = rand.nextSScalar1();
             fPts[i].fY = rand.nextSScalar1();
         }
         fIsRendering = false;
     }
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
         return "rect_bounds";
@@ skipping 14 matching lines @@
 
 static SkBenchmark* S0(void* p) { return new FloatComparisonBench(p); }
 static SkBenchmark* S1(void* p) { return new ForcedIntComparisonBench(p); }
 static SkBenchmark* S2(void* p) { return new RectBoundsBench(p); }
 static SkBenchmark* S3(void* p) { return new IsFiniteScalarBench(p); }
 
 static BenchRegistry gReg0(S0);
 static BenchRegistry gReg1(S1);
 static BenchRegistry gReg2(S2);
 static BenchRegistry gReg3(S3);