--- jsr166/src/test/loops/LoopHelpers.java	2005/05/09 19:33:30	1.2
+++ jsr166/src/test/loops/LoopHelpers.java	2009/10/29 23:09:07	1.7
@@ -17,10 +17,10 @@ class LoopHelpers {
     // Some mindless computation to do between synchronizations...
 
     /**
-     * generates 32 bit pseudo-random numbers. 
+     * generates 32 bit pseudo-random numbers.
      * Adapted from http://www.snippets.org
      */
-    public static int compute1(int x) { 
+    public static int compute1(int x) {
         int lo = 16807 * (x & 0xFFFF);
         int hi = 16807 * (x >>> 16);
         lo += (hi & 0x7FFF) << 16;
@@ -40,7 +40,7 @@ class LoopHelpers {
      *  Computes a linear congruential random number a random number
      *  of times.
      */
-    public static int compute2(int x) { 
+    public static int compute2(int x) {
         int loops = (x >>> 4) & 7;
         while (loops-- > 0) {
             x = (x * 2147483647) % 16807;
@@ -51,7 +51,7 @@ class LoopHelpers {
     /**
      * Yet another random number generator
      */
-    public static int compute3(int x) { 
+    public static int compute3(int x) {
         int t = (x % 127773) * 16807 - (x / 127773) * 2836;
         return (t > 0)? t : t + 0x7fffffff;
     }
@@ -59,7 +59,7 @@ class LoopHelpers {
     /**
      * Yet another random number generator
      */
-    public static int compute4(int x) { 
+    public static int compute4(int x) {
         return x * 134775813 + 1;
     }
 
@@ -67,21 +67,95 @@ class LoopHelpers {
     /**
      * Yet another random number generator
      */
-    public static int compute5(int x) { 
+    public static int compute5(int x) {
         return 36969 * (x & 65535) + (x >> 16);
     }
 
+    /**
+     * Marsaglia xorshift (1, 3, 10)
+     */
+    public static int compute6(int seed) {
+        seed ^= seed << 1;
+        seed ^= seed >>> 3;
+        seed ^= (seed << 10);
+        return seed;
+    }
+
+    /**
+     * Marsaglia xorshift (6, 21, 7)
+     */
+    public static int compute7(int y) {
+        y ^= y << 6;
+        y ^= y >>> 21;
+        y ^= (y << 7);
+        return y;
+    }
+
+    // FNV: (x ^ 0x811c9dc5) * 0x01000193;  15485863;
+
+    /**
+     * Marsaglia xorshift for longs
+     */
+    public static long compute8(long x) {
+        x ^= x << 13;
+        x ^= x >>> 7;
+        x ^= (x << 17);
+        return x;
+    }
+
+    public static final class XorShift32Random {
+        static final AtomicInteger seq = new AtomicInteger(8862213);
+        int x = -1831433054;
+        public XorShift32Random(int seed) { x = seed;  }
+        public XorShift32Random() {
+            this((int)System.nanoTime() + seq.getAndAdd(129));
+        }
+        public int next() {
+            x ^= x << 6;
+            x ^= x >>> 21;
+            x ^= (x << 7);
+            return x;
+        }
+    }
+
+
+    /** Multiplication-free RNG from Marsaglia "Xorshift RNGs" paper */
+    public static final class MarsagliaRandom {
+        static final AtomicInteger seq = new AtomicInteger(3122688);
+        int x;
+        int y = 842502087;
+        int z = -715159705;
+        int w = 273326509;
+        public MarsagliaRandom(int seed) { x = seed; }
+        public MarsagliaRandom() {
+            this((int)System.nanoTime() + seq.getAndAdd(129));
+        }
+        public int next() {
+            int t = x ^ (x << 11);
+            x = y;
+            y = z;
+            z = w;
+            return w = (w ^ (w >>> 19) ^ (t ^ (t >>> 8)));
+        }
+    }
 
     /**
-     * An actually useful random number generator, but unsynchronized.
-     * Basically same as java.util.Random.
+     * Unsynchronized version of java.util.Random algorithm.
      */
-    public static class SimpleRandom {
+    public static final class SimpleRandom {
         private final static long multiplier = 0x5DEECE66DL;
         private final static long addend = 0xBL;
         private final static long mask = (1L << 48) - 1;
-        static final AtomicLong seq = new AtomicLong(1);
-        private long seed = System.nanoTime() + seq.getAndIncrement();
+        static final AtomicLong seq = new AtomicLong( -715159705);
+        private long seed;
+
+        SimpleRandom(long s) {
+            seed = s;
+        }
+
+        SimpleRandom() {
+            seed = System.nanoTime() + seq.getAndAdd(129);
+        }
 
         public void setSeed(long s) {
             seed = s;
@@ -95,18 +169,19 @@ class LoopHelpers {
     }
 
     public static class BarrierTimer implements Runnable {
-        public volatile long startTime;
-        public volatile long endTime;
+        volatile boolean started;
+        volatile long startTime;
+        volatile long endTime;
         public void run() {
             long t = System.nanoTime();
-            if (startTime == 0)
+            if (!started) {
+                started = true;
                 startTime = t;
-            else
+            } else
                 endTime = t;
         }
         public void clear() {
-            startTime = 0;
-            endTime = 0;
+            started = false;
         }
         public long getTime() {
             return endTime - startTime;
@@ -123,5 +198,5 @@ class LoopHelpers {
         b.replace(b.length()-num.length(), b.length(), num);
         return b.toString();
     }
-   
+
 }