test/loops/LockLoops.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

/*
 * Simple benchmark comparing various locking techniques.
 */

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public final class LockLoops {
    static final ExecutorService pool = Executors.newCachedThreadPool();
    static final LoopHelpers.SimpleRandom rng = new LoopHelpers.SimpleRandom();
    static boolean print = false;
    static boolean doBuiltin = true;
    static boolean doReadWrite = true;
    static boolean doSemaphore = true;
    static boolean doStampedLock = true;
    static boolean doFair = true;

    public static void main(String[] args) throws Exception {
        int maxThreads = 100;
        int iters = 1000000;
        int replications = 1;

        if (args.length > 0)
            maxThreads = Integer.parseInt(args[0]);

        if (args.length > 1)
            iters = Integer.parseInt(args[1]);

        if (args.length > 2)
            replications = Integer.parseInt(args[2]);

        rng.setSeed(3122688L);

        print = false;
        System.out.println("Warmup...");
        oneTest(3, 10000);
        Thread.sleep(1000);
        oneTest(2, 10000);
        Thread.sleep(100);
        oneTest(1, 100000);
        Thread.sleep(100);
        oneTest(1, 100000);
        Thread.sleep(1000);
        print = true;

        for (int i = 1; i <= maxThreads; ++i) {
            for (int j = 0; j < replications; ++j) {
                System.out.println("Threads:" + i);
                oneTest(i, iters / i);
                Thread.sleep(100);
            }
        }
        pool.shutdown();
    }

    static void oneTest(int nthreads, int iters) throws Exception {
        int v = rng.next();

        if (print)
            System.out.print("No shared vars        ");
        new NoLockLoop().test(v, nthreads, iters * 10);
        Thread.sleep(10);

        if (print)
            System.out.print("No Lock + volatile    ");
        new NoLockVolatileLoop().test(v, nthreads, iters);
        Thread.sleep(10);

        if (doBuiltin) {
            if (print)
                System.out.print("builtin lock          ");
            new BuiltinLockLoop().test(v, nthreads, iters);
            Thread.sleep(10);
        }

        if (print)
            System.out.print("ReentrantLock         ");
        new ReentrantLockLoop().test(v, nthreads, iters);
        Thread.sleep(10);

        if (doReadWrite) {
            if (print)
                System.out.print("ReentrantWriteLock    ");
            new ReentrantWriteLockLoop().test(v, nthreads, iters);
            Thread.sleep(10);

            if (print)
                System.out.print("ReentrantReadLock    ");
            new ReentrantReadLockLoop().test(v, nthreads, iters);
            Thread.sleep(10);

            if (print)
                System.out.print("ReentrantReadWriteLock");
            new ReentrantReadWriteLockLoop().test(v, nthreads, iters);
            Thread.sleep(10);
        }

        if (doSemaphore) {
            if (print)
                System.out.print("Semaphore             ");
            new SemaphoreLoop().test(v, nthreads, iters);
            Thread.sleep(10);

            if (print)
                System.out.print("FairSemaphore         ");
            new FairSemaphoreLoop().test(v, nthreads, iters);
            Thread.sleep(10);
        }

        if (doFair) {
            if (print)
                System.out.print("FairReentrantLock     ");
            new FairReentrantLockLoop().test(v, nthreads, iters);
            Thread.sleep(10);

            if (doReadWrite) {
                if (print)
                    System.out.print("FairRWriteLock         ");
                new FairReentrantWriteLockLoop().test(v, nthreads, iters);
                Thread.sleep(10);

                if (print)
                    System.out.print("FairRReadWriteLock     ");
                new FairReentrantReadWriteLockLoop().test(v, nthreads, iters);
                Thread.sleep(10);
            }
        }

        if (doStampedLock) {
            if (print)
                System.out.print("StampedLockWrite   ");
            new StampedLockWriteLoop().test(v, nthreads, iters);
            Thread.sleep(10);

            if (print)
                System.out.print("StampedLockRead    ");
            new StampedLockReadLoop().test(v, nthreads, iters);
            Thread.sleep(10);

            if (print)
                System.out.print("StampedLockOptRead");
            new StampedLockOptimisticReadLoop().test(v, nthreads, iters);
            Thread.sleep(10);

            if (print)
                System.out.print("StampedLockReadWrite");
            new StampedLockReadWriteLoop().test(v, nthreads, iters);
            Thread.sleep(10);
        }
    }

    abstract static class LockLoop implements Runnable {
        int v;
        int iters;
        volatile int result;
        final LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
        CyclicBarrier barrier;

        final void test(int initialValue, int nthreads, int iters) throws Exception {
            v = initialValue;
            this.iters = iters;
            barrier = new CyclicBarrier(nthreads+1, timer);
            for (int i = 0; i < nthreads; ++i)
                pool.execute(this);
            barrier.await();
            barrier.await();
            long time = timer.getTime();
            if (print) {
                long tpi = time / (iters * nthreads);
                System.out.print("\t" + LoopHelpers.rightJustify(tpi) + " ns per update");
                //                double secs = (double) time / 1000000000.0;
                //                System.out.print("\t " + secs + "s run time");
                System.out.println();
            }

            if (result == 0) // avoid overoptimization
                System.out.println("useless result: " + result);
        }
        abstract int loop(int n);
        public final void run() {
            try {
                barrier.await();
                result += loop(iters);
                barrier.await();
            }
            catch (Exception ie) {
                return;
            }
        }

    }

    private static class BuiltinLockLoop extends LockLoop {
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                synchronized (this) {
                    v = LoopHelpers.compute1(v);
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class NoLockLoop extends LockLoop {
        final int loop(int n) {
            int sum = 0;
            int y = v;
            while (n-- > 0) {
                y = LoopHelpers.compute1(y);
                sum += LoopHelpers.compute2(y);
            }
            return sum;
        }
    }

    private static class NoLockVolatileLoop extends LockLoop {
        private volatile int vv;
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                int y = LoopHelpers.compute1(vv);
                vv = y;
                sum += LoopHelpers.compute2(y);
            }
            return sum;
        }
    }

    private static class ReentrantLockLoop extends LockLoop {
        private final ReentrantLock lock = new ReentrantLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                lock.lock();
                try {
                    v = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlock();
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class FairReentrantLockLoop extends LockLoop {
        private final ReentrantLock lock = new ReentrantLock(true);
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                lock.lock();
                try {
                    v = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlock();
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class ReentrantWriteLockLoop extends LockLoop {
        private final Lock lock = new ReentrantReadWriteLock().writeLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                lock.lock();
                try {
                    v = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlock();
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class ReentrantReadLockLoop extends LockLoop {
        private final Lock lock = new ReentrantReadWriteLock().readLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                lock.lock();
                try {
                    v = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlock();
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class ReentrantReadWriteLockLoop extends LockLoop {
        private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                int x;
                lock.readLock().lock();
                try {
                    x = LoopHelpers.compute1(v);
                }
                finally {
                    lock.readLock().unlock();
                }
                lock.writeLock().lock();
                try {
                    v = x;
                }
                finally {
                    lock.writeLock().unlock();
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class FairReentrantWriteLockLoop extends LockLoop {
        final Lock lock = new ReentrantReadWriteLock(true).writeLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                lock.lock();
                try {
                    v = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlock();
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class SemaphoreLoop extends LockLoop {
        private final Semaphore sem = new Semaphore(1, false);
        final int loop(int n) {
            int sum = 0;
            try {
                while (n-- > 0) {
                    sem.acquire();
                    try {
                        v = LoopHelpers.compute1(v);
                    }
                    finally {
                        sem.release();
                    }
                    sum += LoopHelpers.compute2(v);
                }
            }
            catch (InterruptedException ie) {
                return sum;
            }
            return sum;
        }
    }

    private static class FairSemaphoreLoop extends LockLoop {
        private final Semaphore sem = new Semaphore(1, true);
        final int loop(int n) {
            int sum = 0;
            try {
                while (n-- > 0) {
                    sem.acquire();
                    try {
                        v = LoopHelpers.compute1(v);
                    }
                    finally {
                        sem.release();
                    }
                    sum += LoopHelpers.compute2(v);
                }
            }
            catch (InterruptedException ie) {
                return sum;
            }
            return sum;
        }
    }

    private static class FairReentrantReadWriteLockLoop extends LockLoop {
        private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                int x;
                lock.readLock().lock();
                try {
                    x = LoopHelpers.compute1(v);
                }
                finally {
                    lock.readLock().unlock();
                }
                lock.writeLock().lock();
                try {
                    v = x;
                }
                finally {
                    lock.writeLock().unlock();
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class StampedLockWriteLoop extends LockLoop {
        private final StampedLock lock = new StampedLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                long stamp = lock.writeLock();
                try {
                    v = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlockWrite(stamp);
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class StampedLockReadLoop extends LockLoop {
        private final StampedLock lock = new StampedLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                long stamp = lock.readLock();
                try {
                    v = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlockRead(stamp);
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class StampedLockOptimisticReadLoop extends LockLoop {
        private final StampedLock lock = new StampedLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                long stamp;
                do {
                    stamp = lock.tryOptimisticRead();
                    v = LoopHelpers.compute1(v);
                } while (!lock.validate(stamp));
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }

    private static class StampedLockReadWriteLoop extends LockLoop {
        private final StampedLock lock = new StampedLock();
        final int loop(int n) {
            int sum = 0;
            while (n-- > 0) {
                int x;
                long stamp = lock.readLock();
                try {
                    x = LoopHelpers.compute1(v);
                }
                finally {
                    lock.unlockRead(stamp);
                }
                stamp = lock.writeLock();
                try {
                    v = x;
                } finally {
                    lock.unlockWrite(stamp);
                }
                sum += LoopHelpers.compute2(v);
            }
            return sum;
        }
    }
}
Revision:	1.15
Committed:	Thu Jun 9 15:28:19 2016 UTC (7 years, 11 months ago) by jsr166
Branch:	MAIN
Changes since 1.14:	+25 -1 lines
Log Message:	add ReentrantReadLockLoop
#	Content
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/publicdomain/zero/1.0/
5	*/
6
7	/*
8	* Simple benchmark comparing various locking techniques.
9	*/
10
11	import java.util.*;
12	import java.util.concurrent.*;
13	import java.util.concurrent.locks.*;
14
15	public final class LockLoops {
16	static final ExecutorService pool = Executors.newCachedThreadPool();
17	static final LoopHelpers.SimpleRandom rng = new LoopHelpers.SimpleRandom();
18	static boolean print = false;
19	static boolean doBuiltin = true;
20	static boolean doReadWrite = true;
21	static boolean doSemaphore = true;
22	static boolean doStampedLock = true;
23	static boolean doFair = true;
24
25	public static void main(String[] args) throws Exception {
26	int maxThreads = 100;
27	int iters = 1000000;
28	int replications = 1;
29
30	if (args.length > 0)
31	maxThreads = Integer.parseInt(args[0]);
32
33	if (args.length > 1)
34	iters = Integer.parseInt(args[1]);
35
36	if (args.length > 2)
37	replications = Integer.parseInt(args[2]);
38
39	rng.setSeed(3122688L);
40
41	print = false;
42	System.out.println("Warmup...");
43	oneTest(3, 10000);
44	Thread.sleep(1000);
45	oneTest(2, 10000);
46	Thread.sleep(100);
47	oneTest(1, 100000);
48	Thread.sleep(100);
49	oneTest(1, 100000);
50	Thread.sleep(1000);
51	print = true;
52
53	for (int i = 1; i <= maxThreads; ++i) {
54	for (int j = 0; j < replications; ++j) {
55	System.out.println("Threads:" + i);
56	oneTest(i, iters / i);
57	Thread.sleep(100);
58	}
59	}
60	pool.shutdown();
61	}
62
63	static void oneTest(int nthreads, int iters) throws Exception {
64	int v = rng.next();
65
66	if (print)
67	System.out.print("No shared vars ");
68	new NoLockLoop().test(v, nthreads, iters * 10);
69	Thread.sleep(10);
70
71	if (print)
72	System.out.print("No Lock + volatile ");
73	new NoLockVolatileLoop().test(v, nthreads, iters);
74	Thread.sleep(10);
75
76	if (doBuiltin) {
77	if (print)
78	System.out.print("builtin lock ");
79	new BuiltinLockLoop().test(v, nthreads, iters);
80	Thread.sleep(10);
81	}
82
83	if (print)
84	System.out.print("ReentrantLock ");
85	new ReentrantLockLoop().test(v, nthreads, iters);
86	Thread.sleep(10);
87
88	if (doReadWrite) {
89	if (print)
90	System.out.print("ReentrantWriteLock ");
91	new ReentrantWriteLockLoop().test(v, nthreads, iters);
92	Thread.sleep(10);
93
94	if (print)
95	System.out.print("ReentrantReadLock ");
96	new ReentrantReadLockLoop().test(v, nthreads, iters);
97	Thread.sleep(10);
98
99	if (print)
100	System.out.print("ReentrantReadWriteLock");
101	new ReentrantReadWriteLockLoop().test(v, nthreads, iters);
102	Thread.sleep(10);
103	}
104
105	if (doSemaphore) {
106	if (print)
107	System.out.print("Semaphore ");
108	new SemaphoreLoop().test(v, nthreads, iters);
109	Thread.sleep(10);
110
111	if (print)
112	System.out.print("FairSemaphore ");
113	new FairSemaphoreLoop().test(v, nthreads, iters);
114	Thread.sleep(10);
115	}
116
117	if (doFair) {
118	if (print)
119	System.out.print("FairReentrantLock ");
120	new FairReentrantLockLoop().test(v, nthreads, iters);
121	Thread.sleep(10);
122
123	if (doReadWrite) {
124	if (print)
125	System.out.print("FairRWriteLock ");
126	new FairReentrantWriteLockLoop().test(v, nthreads, iters);
127	Thread.sleep(10);
128
129	if (print)
130	System.out.print("FairRReadWriteLock ");
131	new FairReentrantReadWriteLockLoop().test(v, nthreads, iters);
132	Thread.sleep(10);
133	}
134	}
135
136	if (doStampedLock) {
137	if (print)
138	System.out.print("StampedLockWrite ");
139	new StampedLockWriteLoop().test(v, nthreads, iters);
140	Thread.sleep(10);
141
142	if (print)
143	System.out.print("StampedLockRead ");
144	new StampedLockReadLoop().test(v, nthreads, iters);
145	Thread.sleep(10);
146
147	if (print)
148	System.out.print("StampedLockOptRead");
149	new StampedLockOptimisticReadLoop().test(v, nthreads, iters);
150	Thread.sleep(10);
151
152	if (print)
153	System.out.print("StampedLockReadWrite");
154	new StampedLockReadWriteLoop().test(v, nthreads, iters);
155	Thread.sleep(10);
156	}
157	}
158
159	abstract static class LockLoop implements Runnable {
160	int v;
161	int iters;
162	volatile int result;
163	final LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
164	CyclicBarrier barrier;
165
166	final void test(int initialValue, int nthreads, int iters) throws Exception {
167	v = initialValue;
168	this.iters = iters;
169	barrier = new CyclicBarrier(nthreads+1, timer);
170	for (int i = 0; i < nthreads; ++i)
171	pool.execute(this);
172	barrier.await();
173	barrier.await();
174	long time = timer.getTime();
175	if (print) {
176	long tpi = time / (iters * nthreads);
177	System.out.print("\t" + LoopHelpers.rightJustify(tpi) + " ns per update");
178	// double secs = (double) time / 1000000000.0;
179	// System.out.print("\t " + secs + "s run time");
180	System.out.println();
181	}
182
183	if (result == 0) // avoid overoptimization
184	System.out.println("useless result: " + result);
185	}
186	abstract int loop(int n);
187	public final void run() {
188	try {
189	barrier.await();
190	result += loop(iters);
191	barrier.await();
192	}
193	catch (Exception ie) {
194	return;
195	}
196	}
197
198	}
199
200	private static class BuiltinLockLoop extends LockLoop {
201	final int loop(int n) {
202	int sum = 0;
203	while (n-- > 0) {
204	synchronized (this) {
205	v = LoopHelpers.compute1(v);
206	}
207	sum += LoopHelpers.compute2(v);
208	}
209	return sum;
210	}
211	}
212
213	private static class NoLockLoop extends LockLoop {
214	final int loop(int n) {
215	int sum = 0;
216	int y = v;
217	while (n-- > 0) {
218	y = LoopHelpers.compute1(y);
219	sum += LoopHelpers.compute2(y);
220	}
221	return sum;
222	}
223	}
224
225	private static class NoLockVolatileLoop extends LockLoop {
226	private volatile int vv;
227	final int loop(int n) {
228	int sum = 0;
229	while (n-- > 0) {
230	int y = LoopHelpers.compute1(vv);
231	vv = y;
232	sum += LoopHelpers.compute2(y);
233	}
234	return sum;
235	}
236	}
237
238	private static class ReentrantLockLoop extends LockLoop {
239	private final ReentrantLock lock = new ReentrantLock();
240	final int loop(int n) {
241	int sum = 0;
242	while (n-- > 0) {
243	lock.lock();
244	try {
245	v = LoopHelpers.compute1(v);
246	}
247	finally {
248	lock.unlock();
249	}
250	sum += LoopHelpers.compute2(v);
251	}
252	return sum;
253	}
254	}
255
256	private static class FairReentrantLockLoop extends LockLoop {
257	private final ReentrantLock lock = new ReentrantLock(true);
258	final int loop(int n) {
259	int sum = 0;
260	while (n-- > 0) {
261	lock.lock();
262	try {
263	v = LoopHelpers.compute1(v);
264	}
265	finally {
266	lock.unlock();
267	}
268	sum += LoopHelpers.compute2(v);
269	}
270	return sum;
271	}
272	}
273
274	private static class ReentrantWriteLockLoop extends LockLoop {
275	private final Lock lock = new ReentrantReadWriteLock().writeLock();
276	final int loop(int n) {
277	int sum = 0;
278	while (n-- > 0) {
279	lock.lock();
280	try {
281	v = LoopHelpers.compute1(v);
282	}
283	finally {
284	lock.unlock();
285	}
286	sum += LoopHelpers.compute2(v);
287	}
288	return sum;
289	}
290	}
291
292	private static class ReentrantReadLockLoop extends LockLoop {
293	private final Lock lock = new ReentrantReadWriteLock().readLock();
294	final int loop(int n) {
295	int sum = 0;
296	while (n-- > 0) {
297	lock.lock();
298	try {
299	v = LoopHelpers.compute1(v);
300	}
301	finally {
302	lock.unlock();
303	}
304	sum += LoopHelpers.compute2(v);
305	}
306	return sum;
307	}
308	}
309
310	private static class ReentrantReadWriteLockLoop extends LockLoop {
311	private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
312	final int loop(int n) {
313	int sum = 0;
314	while (n-- > 0) {
315	int x;
316	lock.readLock().lock();
317	try {
318	x = LoopHelpers.compute1(v);
319	}
320	finally {
321	lock.readLock().unlock();
322	}
323	lock.writeLock().lock();
324	try {
325	v = x;
326	}
327	finally {
328	lock.writeLock().unlock();
329	}
330	sum += LoopHelpers.compute2(v);
331	}
332	return sum;
333	}
334	}
335
336	private static class FairReentrantWriteLockLoop extends LockLoop {
337	final Lock lock = new ReentrantReadWriteLock(true).writeLock();
338	final int loop(int n) {
339	int sum = 0;
340	while (n-- > 0) {
341	lock.lock();
342	try {
343	v = LoopHelpers.compute1(v);
344	}
345	finally {
346	lock.unlock();
347	}
348	sum += LoopHelpers.compute2(v);
349	}
350	return sum;
351	}
352	}
353
354	private static class SemaphoreLoop extends LockLoop {
355	private final Semaphore sem = new Semaphore(1, false);
356	final int loop(int n) {
357	int sum = 0;
358	try {
359	while (n-- > 0) {
360	sem.acquire();
361	try {
362	v = LoopHelpers.compute1(v);
363	}
364	finally {
365	sem.release();
366	}
367	sum += LoopHelpers.compute2(v);
368	}
369	}
370	catch (InterruptedException ie) {
371	return sum;
372	}
373	return sum;
374	}
375	}
376
377	private static class FairSemaphoreLoop extends LockLoop {
378	private final Semaphore sem = new Semaphore(1, true);
379	final int loop(int n) {
380	int sum = 0;
381	try {
382	while (n-- > 0) {
383	sem.acquire();
384	try {
385	v = LoopHelpers.compute1(v);
386	}
387	finally {
388	sem.release();
389	}
390	sum += LoopHelpers.compute2(v);
391	}
392	}
393	catch (InterruptedException ie) {
394	return sum;
395	}
396	return sum;
397	}
398	}
399
400	private static class FairReentrantReadWriteLockLoop extends LockLoop {
401	private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
402	final int loop(int n) {
403	int sum = 0;
404	while (n-- > 0) {
405	int x;
406	lock.readLock().lock();
407	try {
408	x = LoopHelpers.compute1(v);
409	}
410	finally {
411	lock.readLock().unlock();
412	}
413	lock.writeLock().lock();
414	try {
415	v = x;
416	}
417	finally {
418	lock.writeLock().unlock();
419	}
420	sum += LoopHelpers.compute2(v);
421	}
422	return sum;
423	}
424	}
425
426	private static class StampedLockWriteLoop extends LockLoop {
427	private final StampedLock lock = new StampedLock();
428	final int loop(int n) {
429	int sum = 0;
430	while (n-- > 0) {
431	long stamp = lock.writeLock();
432	try {
433	v = LoopHelpers.compute1(v);
434	}
435	finally {
436	lock.unlockWrite(stamp);
437	}
438	sum += LoopHelpers.compute2(v);
439	}
440	return sum;
441	}
442	}
443
444	private static class StampedLockReadLoop extends LockLoop {
445	private final StampedLock lock = new StampedLock();
446	final int loop(int n) {
447	int sum = 0;
448	while (n-- > 0) {
449	long stamp = lock.readLock();
450	try {
451	v = LoopHelpers.compute1(v);
452	}
453	finally {
454	lock.unlockRead(stamp);
455	}
456	sum += LoopHelpers.compute2(v);
457	}
458	return sum;
459	}
460	}
461
462	private static class StampedLockOptimisticReadLoop extends LockLoop {
463	private final StampedLock lock = new StampedLock();
464	final int loop(int n) {
465	int sum = 0;
466	while (n-- > 0) {
467	long stamp;
468	do {
469	stamp = lock.tryOptimisticRead();
470	v = LoopHelpers.compute1(v);
471	} while (!lock.validate(stamp));
472	sum += LoopHelpers.compute2(v);
473	}
474	return sum;
475	}
476	}
477
478	private static class StampedLockReadWriteLoop extends LockLoop {
479	private final StampedLock lock = new StampedLock();
480	final int loop(int n) {
481	int sum = 0;
482	while (n-- > 0) {
483	int x;
484	long stamp = lock.readLock();
485	try {
486	x = LoopHelpers.compute1(v);
487	}
488	finally {
489	lock.unlockRead(stamp);
490	}
491	stamp = lock.writeLock();
492	try {
493	v = x;
494	} finally {
495	lock.unlockWrite(stamp);
496	}
497	sum += LoopHelpers.compute2(v);
498	}
499	return sum;
500	}
501	}
502	}