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

Comparing jsr166/src/test/loops/CheckedLockLoops.java (file contents):
Revision 1.1 by dl, Mon May 2 19:19:38 2005 UTC vs.
Revision 1.7 by jsr166, Mon Sep 27 19:15:15 2010 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
5 + */
6 + /*
7   * @test
8   * @summary basic safety and liveness of ReentrantLocks, and other locks based on them
9   */
# Line 16 | Line 21 | public final class CheckedLockLoops {
21      public static void main(String[] args) throws Exception {
22          int maxThreads = 100;
23          int iters = 2000000;
24 <        if (args.length > 0)
24 >        if (args.length > 0)
25              maxThreads = Integer.parseInt(args[0]);
26          rng.setSeed(3122688L);
27          warmup(iters);
# Line 33 | Line 38 | public final class CheckedLockLoops {
38              if (i == k) {
39                  k = i << 1;
40                  i = i + (i >>> 1);
41 <            }
42 <            else
41 >            }
42 >            else
43                  i = k;
44          }
45 <    }    
45 >    }
46  
47      static void warmup(int iters) throws Exception {
48          print = false;
# Line 47 | Line 52 | public final class CheckedLockLoops {
52      }
53  
54      static void oneTest(int nthreads, int iters) throws Exception {
55 <        int fairIters = (nthreads <= 1)? iters : iters/20;
55 >        int fairIters = (nthreads <= 1) ? iters : iters/20;
56          int v = rng.next();
57  
58          if (print)
59              System.out.print("NoLock (1 thread)     ");
60          new NoLockLoop().test(v, 1, iters * nthreads);
61          Thread.sleep(10);
62 <
62 >
63          if (print)
64              System.out.print("ReentrantLock         ");
65          new ReentrantLockLoop().test(v, nthreads, iters);
# Line 86 | Line 91 | public final class CheckedLockLoops {
91              System.out.print("Semaphore             ");
92          new SemaphoreLoop().test(v, nthreads, iters);
93          Thread.sleep(10);
94 <        
94 >
95          if (print)
96              System.out.print("FairSemaphore         ");
97          new FairSemaphoreLoop().test(v, nthreads, fairIters);
# Line 101 | Line 106 | public final class CheckedLockLoops {
106              System.out.print("FairRWriteLock         ");
107          new FairReentrantWriteLockLoop().test(v, nthreads, fairIters);
108          Thread.sleep(10);
109 <        
109 >
110          if (print)
111              System.out.print("ReentrantReadWriteLock");
112          new ReentrantReadWriteLockLoop().test(v, nthreads, iters);
113          Thread.sleep(10);
114 <        
114 >
115          if (print)
116              System.out.print("FairRReadWriteLock     ");
117          new FairReentrantReadWriteLockLoop().test(v, nthreads, fairIters);
118          Thread.sleep(10);
119      }
120  
121 <    static abstract class LockLoop implements Runnable {
121 >    abstract static class LockLoop implements Runnable {
122          int value;
123          int checkValue;
124          int iters;
# Line 130 | Line 135 | public final class CheckedLockLoops {
135  
136          final int getValue() {
137              int v = value;
138 <            if (checkValue != ~(v ^ 0xAAAAAAAA))
138 >            if (checkValue != ~(v ^ 0xAAAAAAAA))
139                  ++failures;
140              return v;
141          }
# Line 139 | Line 144 | public final class CheckedLockLoops {
144              setValue(initialValue);
145              this.iters = iters;
146              barrier = new CyclicBarrier(nthreads+1, timer);
147 <            for (int i = 0; i < nthreads; ++i)
147 >            for (int i = 0; i < nthreads; ++i)
148                  pool.execute(this);
149              barrier.await();
150              barrier.await();
# Line 159 | Line 164 | public final class CheckedLockLoops {
164          abstract int loop(int n);
165          public final void run() {
166              try {
167 <                barrier.await();
167 >                barrier.await();
168                  result += loop(iters);
169                  barrier.await();
170              }
171 <            catch (Exception ie) {
172 <                return;
171 >            catch (Exception ie) {
172 >                return;
173              }
174          }
175  
# Line 174 | Line 179 | public final class CheckedLockLoops {
179          private volatile int readBarrier;
180          final int loop(int n) {
181              int sum = 0;
182 <            int x = 0;;
182 >            int x = 0;
183              while (n-- > 0) {
184                  int r1 = readBarrier;
185                  x = setValue(LoopHelpers.compute1(getValue()));
# Line 190 | Line 195 | public final class CheckedLockLoops {
195      private static class BuiltinLockLoop extends LockLoop {
196          final int loop(int n) {
197              int sum = 0;
198 <            int x = 0;;
198 >            int x = 0;
199              while (n-- > 0) {
200 <                synchronized(this) {
200 >                synchronized (this) {
201                      x = setValue(LoopHelpers.compute1(getValue()));
202                  }
203                  sum += LoopHelpers.compute2(x);
# Line 202 | Line 207 | public final class CheckedLockLoops {
207      }
208  
209      private static class ReentrantLockLoop extends LockLoop {
210 <        final private ReentrantLock lock = new ReentrantLock();
210 >        private final ReentrantLock lock = new ReentrantLock();
211          final int loop(int n) {
212              final ReentrantLock lock = this.lock;
213              int sum = 0;
# Line 222 | Line 227 | public final class CheckedLockLoops {
227      }
228  
229      private static class MutexLoop extends LockLoop {
230 <        final private Mutex lock = new Mutex();
230 >        private final Mutex lock = new Mutex();
231          final int loop(int n) {
232              final Mutex lock = this.lock;
233              int sum = 0;
# Line 242 | Line 247 | public final class CheckedLockLoops {
247      }
248  
249      private static class LongMutexLoop extends LockLoop {
250 <        final private LongMutex lock = new LongMutex();
250 >        private final LongMutex lock = new LongMutex();
251          final int loop(int n) {
252              final LongMutex lock = this.lock;
253              int sum = 0;
# Line 262 | Line 267 | public final class CheckedLockLoops {
267      }
268  
269      private static class FairReentrantLockLoop extends LockLoop {
270 <        final private ReentrantLock lock = new ReentrantLock(true);
270 >        private final ReentrantLock lock = new ReentrantLock(true);
271          final int loop(int n) {
272              final ReentrantLock lock = this.lock;
273              int sum = 0;
# Line 282 | Line 287 | public final class CheckedLockLoops {
287      }
288  
289      private static class ReentrantWriteLockLoop extends LockLoop {
290 <        final private Lock lock = new ReentrantReadWriteLock().writeLock();
290 >        private final Lock lock = new ReentrantReadWriteLock().writeLock();
291          final int loop(int n) {
292              final Lock lock = this.lock;
293              int sum = 0;
# Line 322 | Line 327 | public final class CheckedLockLoops {
327      }
328  
329      private static class SemaphoreLoop extends LockLoop {
330 <        final private Semaphore sem = new Semaphore(1, false);
330 >        private final Semaphore sem = new Semaphore(1, false);
331          final int loop(int n) {
332              final Semaphore sem = this.sem;
333              int sum = 0;
# Line 341 | Line 346 | public final class CheckedLockLoops {
346          }
347      }
348      private static class FairSemaphoreLoop extends LockLoop {
349 <        final private Semaphore sem = new Semaphore(1, true);
349 >        private final Semaphore sem = new Semaphore(1, true);
350          final int loop(int n) {
351              final Semaphore sem = this.sem;
352              int sum = 0;
# Line 361 | Line 366 | public final class CheckedLockLoops {
366      }
367  
368      private static class ReentrantReadWriteLockLoop extends LockLoop {
369 <        final private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
369 >        private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
370          final int loop(int n) {
371              final Lock rlock = lock.readLock();
372              final Lock wlock = lock.writeLock();
# Line 396 | Line 401 | public final class CheckedLockLoops {
401  
402  
403      private static class FairReentrantReadWriteLockLoop extends LockLoop {
404 <        final private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
404 >        private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
405          final int loop(int n) {
406              final Lock rlock = lock.readLock();
407              final Lock wlock = lock.writeLock();

Diff Legend

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