test/loops/LockLoops.java

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

        }

    }

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