ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/loops/MapLoops.java
(Generate patch)

Comparing jsr166/src/test/loops/MapLoops.java (file contents):
Revision 1.3 by dl, Mon Feb 19 00:46:06 2007 UTC vs.
Revision 1.13 by jsr166, Sun Oct 23 03:03:23 2016 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7   import java.util.*;
8   import java.util.concurrent.*;
9  
10   public class MapLoops {
11 <    static int nkeys       = 1000;
11 >    static int nkeys       = 1000;
12      static int pinsert     = 60;
13      static int premove     = 2;
14      static int maxThreads  = 100;
# Line 20 | Line 20 | public class MapLoops {
20  
21      public static void main(String[] args) throws Exception {
22  
23 <        Class mapClass = null;
23 >        Class<?> mapClass = null;
24          if (args.length > 0) {
25              try {
26                  mapClass = Class.forName(args[0]);
27 <            } catch(ClassNotFoundException e) {
27 >            } catch (ClassNotFoundException e) {
28                  throw new RuntimeException("Class " + args[0] + " not found.");
29              }
30          }
31 <        else
31 >        else
32              mapClass = java.util.concurrent.ConcurrentHashMap.class;
33  
34 <        if (args.length > 1)
34 >        if (args.length > 1)
35              maxThreads = Integer.parseInt(args[1]);
36  
37 <        if (args.length > 2)
37 >        if (args.length > 2)
38              nkeys = Integer.parseInt(args[2]);
39  
40 <        if (args.length > 3)
40 >        if (args.length > 3)
41              pinsert = Integer.parseInt(args[3]);
42  
43 <        if (args.length > 4)
43 >        if (args.length > 4)
44              premove = Integer.parseInt(args[4]);
45  
46 <        if (args.length > 5)
46 >        if (args.length > 5)
47              nops = Integer.parseInt(args[5]);
48  
49 +        if (nops < nkeys)
50 +            nops = nkeys;
51 +
52          // normalize probabilities wrt random number generator
53          removesPerMaxRandom = (int)(((double)premove/100.0 * 0x7FFFFFFFL));
54          insertsPerMaxRandom = (int)(((double)pinsert/100.0 * 0x7FFFFFFFL));
55 <        
55 >
56          System.out.print("Class: " + mapClass.getName());
57          System.out.print(" threads: " + maxThreads);
58          System.out.print(" size: " + nkeys);
# Line 58 | Line 61 | public class MapLoops {
61          System.out.print(" ops: " + nops);
62          System.out.println();
63  
61 –        int k = 1;
64          int warmups = 2;
65 <        for (int i = 1; i <= maxThreads;) {
66 <            Thread.sleep(100);
67 <            test(i, nkeys, mapClass);
68 <            if (warmups > 0)
69 <                --warmups;
70 <            else if (i == k) {
71 <                k = i << 1;
72 <                i = i + (i >>> 1);
73 <            }
74 <            else if (i == 1 && k == 2) {
75 <                i = k;
76 <                warmups = 1;
65 >        for (int reps = 0; reps < 3; ++reps) {
66 >            int k = 1;
67 >            for (int i = 1; i <= maxThreads;) {
68 >                Thread.sleep(100);
69 >                test(i, nkeys, mapClass);
70 >                if (warmups > 0)
71 >                    --warmups;
72 >                else if (i == k) {
73 >                    k = i << 1;
74 >                    i = i + (i >>> 1);
75 >                }
76 >                else if (i == 1 && k == 2) {
77 >                    i = k;
78 >                    warmups = 1;
79 >                }
80 >                else
81 >                    i = k;
82              }
76 –            else
77 –                i = k;
83          }
84          pool.shutdown();
85      }
# Line 82 | Line 87 | public class MapLoops {
87      static Integer[] makeKeys(int n) {
88          LoopHelpers.SimpleRandom rng = new LoopHelpers.SimpleRandom();
89          Integer[] key = new Integer[n];
90 <        for (int i = 0; i < key.length; ++i)
90 >        for (int i = 0; i < key.length; ++i)
91              key[i] = new Integer(rng.next());
92          return key;
93      }
# Line 97 | Line 102 | public class MapLoops {
102          }
103      }
104  
105 <    static void test(int i, int nkeys, Class mapClass) throws Exception {
105 >    static void test(int i, int nkeys, Class<?> mapClass) throws Exception {
106          System.out.print("Threads: " + i + "\t:");
107 <        Map<Integer, Integer> map = (Map<Integer,Integer>)mapClass.newInstance();
107 >        Map<Integer, Integer> map =
108 >            (Map<Integer,Integer>) mapClass.getConstructor().newInstance();
109          Integer[] key = makeKeys(nkeys);
110          // Uncomment to start with a non-empty table
111          //        for (int j = 0; j < nkeys; j += 4) // start 1/4 occupied
# Line 107 | Line 113 | public class MapLoops {
113          shuffleKeys(key);
114          LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
115          CyclicBarrier barrier = new CyclicBarrier(i+1, timer);
116 <        for (int t = 0; t < i; ++t)
116 >        for (int t = 0; t < i; ++t)
117              pool.execute(new Runner(t, map, key, barrier));
118          barrier.await();
119          barrier.await();
120          long time = timer.getTime();
121 <        long tpo = time / (i * (long)nops);
121 >        long tpo = time / (i * (long) nops);
122          System.out.print(LoopHelpers.rightJustify(tpo) + " ns per op");
123 <        double secs = (double)(time) / 1000000000.0;
123 >        double secs = (double) time / 1000000000.0;
124          System.out.println("\t " + secs + "s run time");
125          map.clear();
126      }
# Line 128 | Line 134 | public class MapLoops {
134          int total;
135  
136          Runner(int id, Map<Integer,Integer> map, Integer[] key,  CyclicBarrier barrier) {
137 <            this.map = map;
138 <            this.key = key;
137 >            this.map = map;
138 >            this.key = key;
139              this.barrier = barrier;
140 <            position = key.length / 2;
140 >            position = key.length / 2;
141              rng = new LoopHelpers.SimpleRandom((id + 1) * 8862213513L);
142              rng.next();
143          }
144  
145          int step() {
146 <            // random-walk around key positions,  bunching accesses
146 >            // random-walk around key positions, bunching accesses
147              int r = rng.next();
148              position += (r & 7) - 3;
149 <            while (position >= key.length) position -= key.length;  
149 >            while (position >= key.length) position -= key.length;
150              while (position < 0) position += key.length;
151  
152              Integer k = key[position];
153              Integer x = map.get(k);
154  
155              if (x != null) {
156 <                if (x.intValue() != k.intValue())
156 >                if (x.intValue() != k.intValue())
157                      throw new Error("bad mapping: " + x + " to " + k);
158  
159                  if (r < removesPerMaxRandom) {
# Line 159 | Line 165 | public class MapLoops {
165              }
166              else if (r < insertsPerMaxRandom) {
167                  ++position;
168 <                map.put(k, k);
168 >                map.putIfAbsent(k, k);
169                  return 2;
170 <            }
170 >            }
171  
172              // Uncomment to add a little computation between accesses
173              //            total += LoopHelpers.compute1(k.intValue());
# Line 173 | Line 179 | public class MapLoops {
179              try {
180                  barrier.await();
181                  int ops = nops;
182 <                while (ops > 0)
182 >                while (ops > 0)
183                      ops -= step();
184                  barrier.await();
185              }
# Line 183 | Line 189 | public class MapLoops {
189          }
190      }
191   }
186 –

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines