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.concurrent.*;
import java.util.concurrent.locks.*;
import java.util.*;

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 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);
            }

        }

    }

    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;
        }
    }


}
Revision:	1.7
Committed:	Tue Mar 15 19:47:05 2011 UTC (13 years, 2 months ago) by jsr166
Branch:	MAIN
CVS Tags:	release-1_7_0
Changes since 1.6:	+1 -1 lines
Log Message:	Update Creative Commons license URL in legal notices
#	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.concurrent.*;
11	import java.util.concurrent.locks.*;
12	import java.util.*;
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 doFair = true;
22
23	public static void main(String[] args) throws Exception {
24	int maxThreads = 100;
25	int iters = 1000000;
26	int replications = 1;
27
28	if (args.length > 0)
29	maxThreads = Integer.parseInt(args[0]);
30
31	if (args.length > 1)
32	iters = Integer.parseInt(args[1]);
33
34	if (args.length > 2)
35	replications = Integer.parseInt(args[2]);
36
37	rng.setSeed(3122688L);
38
39	print = false;
40	System.out.println("Warmup...");
41	oneTest(3, 10000);
42	Thread.sleep(1000);
43	oneTest(2, 10000);
44	Thread.sleep(100);
45	oneTest(1, 100000);
46	Thread.sleep(100);
47	oneTest(1, 100000);
48	Thread.sleep(1000);
49	print = true;
50
51	for (int i = 1; i <= maxThreads; ++i) {
52	for (int j = 0; j < replications; ++j) {
53	System.out.println("Threads:" + i);
54	oneTest(i, iters / i);
55	Thread.sleep(100);
56	}
57	}
58	pool.shutdown();
59	}
60
61	static void oneTest(int nthreads, int iters) throws Exception {
62	int v = rng.next();
63
64	if (print)
65	System.out.print("No shared vars ");
66	new NoLockLoop().test(v, nthreads, iters * 10);
67	Thread.sleep(10);
68
69	if (print)
70	System.out.print("No Lock + volatile ");
71	new NoLockVolatileLoop().test(v, nthreads, iters);
72	Thread.sleep(10);
73
74	if (doBuiltin) {
75	if (print)
76	System.out.print("builtin lock ");
77	new BuiltinLockLoop().test(v, nthreads, iters);
78	Thread.sleep(10);
79	}
80
81	if (print)
82	System.out.print("ReentrantLock ");
83	new ReentrantLockLoop().test(v, nthreads, iters);
84	Thread.sleep(10);
85
86	if (doReadWrite) {
87	if (print)
88	System.out.print("ReentrantWriteLock ");
89	new ReentrantWriteLockLoop().test(v, nthreads, iters);
90	Thread.sleep(10);
91
92	if (print)
93	System.out.print("ReentrantReadWriteLock");
94	new ReentrantReadWriteLockLoop().test(v, nthreads, iters);
95	Thread.sleep(10);
96
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
112	if (doFair) {
113	if (print)
114	System.out.print("FairReentrantLock ");
115	new FairReentrantLockLoop().test(v, nthreads, iters);
116	Thread.sleep(10);
117
118	if (doReadWrite) {
119	if (print)
120	System.out.print("FairRWriteLock ");
121	new FairReentrantWriteLockLoop().test(v, nthreads, iters);
122	Thread.sleep(10);
123
124	if (print)
125	System.out.print("FairRReadWriteLock ");
126	new FairReentrantReadWriteLockLoop().test(v, nthreads, iters);
127	Thread.sleep(10);
128	}
129
130	}
131
132	}
133
134	abstract static class LockLoop implements Runnable {
135	int v;
136	int iters;
137	volatile int result;
138	final LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
139	CyclicBarrier barrier;
140
141	final void test(int initialValue, int nthreads, int iters) throws Exception {
142	v = initialValue;
143	this.iters = iters;
144	barrier = new CyclicBarrier(nthreads+1, timer);
145	for (int i = 0; i < nthreads; ++i)
146	pool.execute(this);
147	barrier.await();
148	barrier.await();
149	long time = timer.getTime();
150	if (print) {
151	long tpi = time / (iters * nthreads);
152	System.out.print("\t" + LoopHelpers.rightJustify(tpi) + " ns per update");
153	// double secs = (double) time / 1000000000.0;
154	// System.out.print("\t " + secs + "s run time");
155	System.out.println();
156	}
157
158	if (result == 0) // avoid overoptimization
159	System.out.println("useless result: " + result);
160	}
161	abstract int loop(int n);
162	public final void run() {
163	try {
164	barrier.await();
165	result += loop(iters);
166	barrier.await();
167	}
168	catch (Exception ie) {
169	return;
170	}
171	}
172
173	}
174
175	private static class BuiltinLockLoop extends LockLoop {
176	final int loop(int n) {
177	int sum = 0;
178	while (n-- > 0) {
179	synchronized (this) {
180	v = LoopHelpers.compute1(v);
181	}
182	sum += LoopHelpers.compute2(v);
183	}
184	return sum;
185	}
186	}
187
188	private static class NoLockLoop extends LockLoop {
189	final int loop(int n) {
190	int sum = 0;
191	int y = v;
192	while (n-- > 0) {
193	y = LoopHelpers.compute1(y);
194	sum += LoopHelpers.compute2(y);
195	}
196	return sum;
197	}
198	}
199
200	private static class NoLockVolatileLoop extends LockLoop {
201	private volatile int vv;
202	final int loop(int n) {
203	int sum = 0;
204	while (n-- > 0) {
205	int y = LoopHelpers.compute1(vv);
206	vv = y;
207	sum += LoopHelpers.compute2(y);
208	}
209	return sum;
210	}
211	}
212
213	private static class ReentrantLockLoop extends LockLoop {
214	private final ReentrantLock lock = new ReentrantLock();
215	final int loop(int n) {
216	int sum = 0;
217	while (n-- > 0) {
218	lock.lock();
219	try {
220	v = LoopHelpers.compute1(v);
221	}
222	finally {
223	lock.unlock();
224	}
225	sum += LoopHelpers.compute2(v);
226	}
227	return sum;
228	}
229	}
230
231	private static class FairReentrantLockLoop extends LockLoop {
232	private final ReentrantLock lock = new ReentrantLock(true);
233	final int loop(int n) {
234	int sum = 0;
235	while (n-- > 0) {
236	lock.lock();
237	try {
238	v = LoopHelpers.compute1(v);
239	}
240	finally {
241	lock.unlock();
242	}
243	sum += LoopHelpers.compute2(v);
244	}
245	return sum;
246	}
247	}
248
249	private static class ReentrantWriteLockLoop extends LockLoop {
250	private final Lock lock = new ReentrantReadWriteLock().writeLock();
251	final int loop(int n) {
252	int sum = 0;
253	while (n-- > 0) {
254	lock.lock();
255	try {
256	v = LoopHelpers.compute1(v);
257	}
258	finally {
259	lock.unlock();
260	}
261	sum += LoopHelpers.compute2(v);
262	}
263	return sum;
264	}
265	}
266
267	private static class ReentrantReadWriteLockLoop extends LockLoop {
268	private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
269	final int loop(int n) {
270	int sum = 0;
271	while (n-- > 0) {
272	int x;
273	lock.readLock().lock();
274	try {
275	x = LoopHelpers.compute1(v);
276	}
277	finally {
278	lock.readLock().unlock();
279	}
280	lock.writeLock().lock();
281	try {
282	v = x;
283	}
284	finally {
285	lock.writeLock().unlock();
286	}
287	sum += LoopHelpers.compute2(v);
288	}
289	return sum;
290	}
291	}
292
293	private static class FairReentrantWriteLockLoop extends LockLoop {
294	final Lock lock = new ReentrantReadWriteLock(true).writeLock();
295	final int loop(int n) {
296	int sum = 0;
297	while (n-- > 0) {
298	lock.lock();
299	try {
300	v = LoopHelpers.compute1(v);
301	}
302	finally {
303	lock.unlock();
304	}
305	sum += LoopHelpers.compute2(v);
306	}
307	return sum;
308	}
309	}
310
311	private static class SemaphoreLoop extends LockLoop {
312	private final Semaphore sem = new Semaphore(1, false);
313	final int loop(int n) {
314	int sum = 0;
315	try {
316	while (n-- > 0) {
317	sem.acquire();
318	try {
319	v = LoopHelpers.compute1(v);
320	}
321	finally {
322	sem.release();
323	}
324	sum += LoopHelpers.compute2(v);
325	}
326	}
327	catch (InterruptedException ie) {
328	return sum;
329	}
330	return sum;
331	}
332	}
333	private static class FairSemaphoreLoop extends LockLoop {
334	private final Semaphore sem = new Semaphore(1, true);
335	final int loop(int n) {
336	int sum = 0;
337	try {
338	while (n-- > 0) {
339	sem.acquire();
340	try {
341	v = LoopHelpers.compute1(v);
342	}
343	finally {
344	sem.release();
345	}
346	sum += LoopHelpers.compute2(v);
347	}
348	}
349	catch (InterruptedException ie) {
350	return sum;
351	}
352	return sum;
353	}
354	}
355
356	private static class FairReentrantReadWriteLockLoop extends LockLoop {
357	private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
358	final int loop(int n) {
359	int sum = 0;
360	while (n-- > 0) {
361	int x;
362	lock.readLock().lock();
363	try {
364	x = LoopHelpers.compute1(v);
365	}
366	finally {
367	lock.readLock().unlock();
368	}
369	lock.writeLock().lock();
370	try {
371	v = x;
372	}
373	finally {
374	lock.writeLock().unlock();
375	}
376	sum += LoopHelpers.compute2(v);
377	}
378	return sum;
379	}
380	}
381
382
383	}