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.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.StampedLock;

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