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/
 */
/*
 * A simple test program. Feel free to play.
 */

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