--- jsr166/src/test/loops/StringMapLoops.java	2005/08/07 19:25:55	1.1
+++ jsr166/src/test/loops/StringMapLoops.java	2009/11/03 01:04:02	1.6
@@ -1,28 +1,18 @@
-/* 
- * @test
- * @synopsis Exercise multithreaded maps, by default
- * ConcurrentHashMap.  Each thread does a random walk though elements
- * of "key" array. On each iteration, it checks if table includes key.
- * If absent, with probablility pinsert it inserts it, and if present,
- * with probablility premove it removes it.  (pinsert and premove are
- * expressed as percentages to simplify parsing from command line.)
- */
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
- * Expert Group and released to the public domain. Use, modify, and
- * redistribute this code in any way without acknowledgement.
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/licenses/publicdomain
  */
 
-
 import java.util.*;
 import java.util.concurrent.*;
 
 public class StringMapLoops {
-    static int nkeys       = 1000; 
+    static int nkeys       = 75000;
     static int pinsert     = 60;
-    static int premove     = 2;
+    static int premove     =  2;
     static int maxThreads  = 100;
-    static int nops        = 1000000;
+    static int nops        = 8000000;
     static int removesPerMaxRandom;
     static int insertsPerMaxRandom;
 
@@ -34,32 +24,32 @@ public class StringMapLoops {
         if (args.length > 0) {
             try {
                 mapClass = Class.forName(args[0]);
-            } catch(ClassNotFoundException e) {
+            } catch (ClassNotFoundException e) {
                 throw new RuntimeException("Class " + args[0] + " not found.");
             }
         }
-        else 
+        else
             mapClass = java.util.concurrent.ConcurrentHashMap.class;
 
-        if (args.length > 1) 
+        if (args.length > 1)
             maxThreads = Integer.parseInt(args[1]);
 
-        if (args.length > 2) 
+        if (args.length > 2)
             nkeys = Integer.parseInt(args[2]);
 
-        if (args.length > 3) 
+        if (args.length > 3)
             pinsert = Integer.parseInt(args[3]);
 
-        if (args.length > 4) 
+        if (args.length > 4)
             premove = Integer.parseInt(args[4]);
 
-        if (args.length > 5) 
+        if (args.length > 5)
             nops = Integer.parseInt(args[5]);
 
         // normalize probabilities wrt random number generator
         removesPerMaxRandom = (int)(((double)premove/100.0 * 0x7FFFFFFFL));
         insertsPerMaxRandom = (int)(((double)pinsert/100.0 * 0x7FFFFFFFL));
-        
+
         System.out.print("Class: " + mapClass.getName());
         System.out.print(" threads: " + maxThreads);
         System.out.print(" size: " + nkeys);
@@ -81,14 +71,19 @@ public class StringMapLoops {
             else if (i == k) {
                 k = i << 1;
                 i = i + (i >>> 1);
-            } 
+            }
             else if (i == 1 && k == 2) {
                 i = k;
                 warmups = 1;
             }
-            else 
+            else
                 i = k;
         }
+        for (int j = 0; j < 10; ++j) {
+            Thread.sleep(100);
+            test(1, nkeys, key, mapClass);
+            //            shuffleKeys(key);
+        }
         pool.shutdown();
     }
 
@@ -101,13 +96,13 @@ public class StringMapLoops {
             char[] c = new char[len * 4];
             for (int j = 0; j < len; ++j) {
                 int r = rng.next();
-                c[k++] = (char)(' ' + (r & 0x7f));
+                c[k++] = (char) (' ' + (r & 0x7f));
                 r >>>= 8;
-                c[k++] = (char)(' ' + (r & 0x7f));
+                c[k++] = (char) (' ' + (r & 0x7f));
                 r >>>= 8;
-                c[k++] = (char)(' ' + (r & 0x7f));
+                c[k++] = (char) (' ' + (r & 0x7f));
                 r >>>= 8;
-                c[k++] = (char)(' ' + (r & 0x7f));
+                c[k++] = (char) (' ' + (r & 0x7f));
             }
             key[i] = new String(c);
         }
@@ -130,16 +125,17 @@ public class StringMapLoops {
         // Uncomment to start with a non-empty table
         //        for (int j = 0; j < nkeys; j += 4) // start 1/4 occupied
         //            map.put(key[j], key[j]);
+
         LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
         CyclicBarrier barrier = new CyclicBarrier(i+1, timer);
-        for (int t = 0; t < i; ++t) 
+        for (int t = 0; t < i; ++t)
             pool.execute(new Runner(t, map, key, barrier));
         barrier.await();
         barrier.await();
         long time = timer.getTime();
-        long tpo = time / (i * (long)nops);
+        long tpo = time / (i * (long) nops);
         System.out.print(LoopHelpers.rightJustify(tpo) + " ns per op");
-        double secs = (double)(time) / 1000000000.0;
+        double secs = (double) time / 1000000000.0;
         System.out.println("\t " + secs + "s run time");
         map.clear();
     }
@@ -153,10 +149,10 @@ public class StringMapLoops {
         int total;
 
         Runner(int id, Map<String,String> map, String[] key,  CyclicBarrier barrier) {
-            this.map = map; 
-            this.key = key; 
+            this.map = map;
+            this.key = key;
             this.barrier = barrier;
-            position = key.length / 2; 
+            position = key.length / 2;
             rng = new LoopHelpers.SimpleRandom((id + 1) * 8862213513L);
             rng.next();
         }
@@ -165,7 +161,7 @@ public class StringMapLoops {
             // random-walk around key positions,  bunching accesses
             int r = rng.next();
             position += (r & 7) - 3;
-            while (position >= key.length) position -= key.length;  
+            while (position >= key.length) position -= key.length;
             while (position < 0) position += key.length;
 
             String k = key[position];
@@ -183,7 +179,7 @@ public class StringMapLoops {
                 ++position;
                 map.put(k, k);
                 return 2;
-            } 
+            }
 
             total += r;
             return 1;
@@ -193,7 +189,7 @@ public class StringMapLoops {
             try {
                 barrier.await();
                 int ops = nops;
-                while (ops > 0) 
+                while (ops > 0)
                     ops -= step();
                 barrier.await();
             }
@@ -203,4 +199,3 @@ public class StringMapLoops {
         }
     }
 }
-