test/loops/UncheckedLockLoops.java

/*
 * @test
 * @summary basic safety and liveness of ReentrantLocks, and other locks based on them
 */

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

public final class UncheckedLockLoops {
    static final LoopHelpers.SimpleRandom rng = new LoopHelpers.SimpleRandom();
    static boolean print = false;
    static boolean doBuiltin = true;

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

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

        rng.setSeed(3122688L);

        print = false;
        System.out.println("Warmup...");
        oneTest(1, 100000);
        Thread.sleep(1000);
        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;

        System.out.println("Threads:" + 1);
        oneTest(1, iters / 1);
        Thread.sleep(100);

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

    }

    static void oneTest(int nthreads, int iters) throws Exception {
        int fairIters = (nthreads <= 1)? iters : iters/20;
        int v = rng.next();

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

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

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

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

        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, fairIters);
        Thread.sleep(10);

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

        if (print)
            System.out.print("FairRWriteLock         ");
        new FairReentrantWriteLockLoop().test(v, nthreads, fairIters);
        Thread.sleep(10);
        
        if (print)
            System.out.print("ReentrantReadWriteLock");
        new ReentrantReadWriteLockLoop().test(v, nthreads, iters);
        Thread.sleep(10);
        
        if (print)
            System.out.print("FairRReadWriteLock     ");
        new FairReentrantReadWriteLockLoop().test(v, nthreads, fairIters);
        Thread.sleep(10);

    }

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

        final int setValue(int v) {
            checkValue = v ^ 0x55555555;
            value = v;
            return v;
        }

        final int getValue() {
            int v = value;
            if (checkValue != ~(v ^ 0xAAAAAAAA)) 
                ++failures;
            return v;
        }

        final void test(int initialValue, int nthreads, int iters) throws Exception {
            setValue(initialValue);
            this.iters = iters;
            barrier = new CyclicBarrier(nthreads+1, timer);
            for (int i = 0; i < nthreads; ++i) 
                new Thread(this).start();
            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);
            if (failures != 0)
                throw new Error("protection failure?");
        }
        abstract int loop(int n);
        public final void run() {
            try {
                barrier.await(); 
                result += loop(iters);
                barrier.await();
            }
            catch (Exception ie) { 
                return; 
            }
        }

    }

    private static class NoLockLoop extends LockLoop {
        private volatile int readBarrier;
        final int loop(int n) {
            int sum = 0;
            int x = 0;;
            while (n-- > 0) {
                int r1 = readBarrier;
                x = setValue(LoopHelpers.compute1(getValue()));
                int r2 = readBarrier;
                if (r1 == r2 && (x & 255) == 0)
                    ++readBarrier;
                sum += LoopHelpers.compute2(x);
            }
            return sum;
        }
    }

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

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

    private static class MutexLoop extends LockLoop {
        final private Mutex lock = new Mutex();
        final int loop(int n) {
            final Mutex lock = this.lock;
            int sum = 0;
            int x = 0;
            while (n-- > 0) {
                lock.lock();
                try {
                    x = setValue(LoopHelpers.compute1(getValue()));
                }
                finally {
                    lock.unlock();
                }
                sum += LoopHelpers.compute2(x);
            }
            return sum;
        }
    }

    private static class LongMutexLoop extends LockLoop {
        final private LongMutex lock = new LongMutex();
        final int loop(int n) {
            final LongMutex lock = this.lock;
            int sum = 0;
            int x = 0;
            while (n-- > 0) {
                lock.lock();
                try {
                    x = setValue(LoopHelpers.compute1(getValue()));
                }
                finally {
                    lock.unlock();
                }
                sum += LoopHelpers.compute2(x);
            }
            return sum;
        }
    }

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

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

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

    private static class SemaphoreLoop extends LockLoop {
        final private Semaphore sem = new Semaphore(1, false);
        final int loop(int n) {
            final Semaphore sem = this.sem;
            int sum = 0;
            int x = 0;
            while (n-- > 0) {
                sem.acquireUninterruptibly();
                try {
                    x = setValue(LoopHelpers.compute1(getValue()));
                }
                finally {
                    sem.release();
                }
                sum += LoopHelpers.compute2(x);
            }
            return sum;
        }
    }
    private static class FairSemaphoreLoop extends LockLoop {
        final private Semaphore sem = new Semaphore(1, true);
        final int loop(int n) {
            final Semaphore sem = this.sem;
            int sum = 0;
            int x = 0;
            while (n-- > 0) {
                sem.acquireUninterruptibly();
                try {
                    x = setValue(LoopHelpers.compute1(getValue()));
                }
                finally {
                    sem.release();
                }
                sum += LoopHelpers.compute2(x);
            }
            return sum;
        }
    }

    private static class ReentrantReadWriteLockLoop extends LockLoop {
        final private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        final int loop(int n) {
            final Lock rlock = lock.readLock();
            final Lock wlock = lock.writeLock();
            int sum = 0;
            int x = 0;
            while (n-- > 0) {
                if ((n & 16) != 0) {
                    rlock.lock();
                    try {
                        x = LoopHelpers.compute1(getValue());
                        x = LoopHelpers.compute2(x);
                    }
                    finally {
                        rlock.unlock();
                    }
                }
                else {
                    wlock.lock();
                    try {
                        setValue(x);
                    }
                    finally {
                        wlock.unlock();
                    }
                    sum += LoopHelpers.compute2(x);
                }
            }
            return sum;
        }

    }


    private static class FairReentrantReadWriteLockLoop extends LockLoop {
        final private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
        final int loop(int n) {
            final Lock rlock = lock.readLock();
            final Lock wlock = lock.writeLock();
            int sum = 0;
            int x = 0;
            while (n-- > 0) {
                if ((n & 16) != 0) {
                    rlock.lock();
                    try {
                        x = LoopHelpers.compute1(getValue());
                        x = LoopHelpers.compute2(x);
                    }
                    finally {
                        rlock.unlock();
                    }
                }
                else {
                    wlock.lock();
                    try {
                        setValue(x);
                    }
                    finally {
                        wlock.unlock();
                    }
                    sum += LoopHelpers.compute2(x);
                }
            }
            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	* @test
3	* @summary basic safety and liveness of ReentrantLocks, and other locks based on them
4	*/
5
6	import java.util.concurrent.*;
7	import java.util.concurrent.locks.*;
8	import java.util.*;
9
10	public final class UncheckedLockLoops {
11	static final LoopHelpers.SimpleRandom rng = new LoopHelpers.SimpleRandom();
12	static boolean print = false;
13	static boolean doBuiltin = true;
14
15	public static void main(String[] args) throws Exception {
16	int maxThreads = 100;
17	int iters = 10000000;
18
19	if (args.length > 0)
20	maxThreads = Integer.parseInt(args[0]);
21
22	rng.setSeed(3122688L);
23
24	print = false;
25	System.out.println("Warmup...");
26	oneTest(1, 100000);
27	Thread.sleep(1000);
28	oneTest(3, 10000);
29	Thread.sleep(1000);
30	oneTest(2, 10000);
31	Thread.sleep(100);
32	oneTest(1, 100000);
33	Thread.sleep(100);
34	oneTest(1, 100000);
35	Thread.sleep(1000);
36	print = true;
37
38	System.out.println("Threads:" + 1);
39	oneTest(1, iters / 1);
40	Thread.sleep(100);
41
42	for (int i = 1; i <= maxThreads; i += (i+1) >>> 1) {
43	System.out.println("Threads:" + i);
44	oneTest(i, iters / i);
45	Thread.sleep(100);
46	}
47
48	}
49
50	static void oneTest(int nthreads, int iters) throws Exception {
51	int fairIters = (nthreads <= 1)? iters : iters/20;
52	int v = rng.next();
53
54	if (print)
55	System.out.print("NoLock (1 thread) ");
56	new NoLockLoop().test(v, 1, iters * nthreads);
57	Thread.sleep(10);
58
59	if (print)
60	System.out.print("ReentrantLock ");
61	new ReentrantLockLoop().test(v, nthreads, iters);
62	Thread.sleep(10);
63
64	if (false) {
65	if (print)
66	System.out.print("FairReentrantLock ");
67	new FairReentrantLockLoop().test(v, nthreads, fairIters);
68	Thread.sleep(10);
69	}
70	if (doBuiltin) {
71	if (print)
72	System.out.print("builtin lock ");
73	new BuiltinLockLoop().test(v, nthreads, fairIters);
74	Thread.sleep(10);
75	}
76
77	if (print)
78	System.out.print("Mutex ");
79	new MutexLoop().test(v, nthreads, iters);
80	Thread.sleep(10);
81
82	if (print)
83	System.out.print("LongMutex ");
84	new LongMutexLoop().test(v, nthreads, iters);
85	Thread.sleep(10);
86
87	if (print)
88	System.out.print("Semaphore ");
89	new SemaphoreLoop().test(v, nthreads, iters);
90	Thread.sleep(10);
91
92	if (print)
93	System.out.print("FairSemaphore ");
94	new FairSemaphoreLoop().test(v, nthreads, fairIters);
95	Thread.sleep(10);
96
97	if (print)
98	System.out.print("ReentrantWriteLock ");
99	new ReentrantWriteLockLoop().test(v, nthreads, iters);
100	Thread.sleep(10);
101
102	if (print)
103	System.out.print("FairRWriteLock ");
104	new FairReentrantWriteLockLoop().test(v, nthreads, fairIters);
105	Thread.sleep(10);
106
107	if (print)
108	System.out.print("ReentrantReadWriteLock");
109	new ReentrantReadWriteLockLoop().test(v, nthreads, iters);
110	Thread.sleep(10);
111
112	if (print)
113	System.out.print("FairRReadWriteLock ");
114	new FairReentrantReadWriteLockLoop().test(v, nthreads, fairIters);
115	Thread.sleep(10);
116
117	}
118
119	static abstract class LockLoop implements Runnable {
120	int value;
121	int checkValue;
122	int iters;
123	volatile int result;
124	volatile int failures;
125	final LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
126	CyclicBarrier barrier;
127
128	final int setValue(int v) {
129	checkValue = v ^ 0x55555555;
130	value = v;
131	return v;
132	}
133
134	final int getValue() {
135	int v = value;
136	if (checkValue != ~(v ^ 0xAAAAAAAA))
137	++failures;
138	return v;
139	}
140
141	final void test(int initialValue, int nthreads, int iters) throws Exception {
142	setValue(initialValue);
143	this.iters = iters;
144	barrier = new CyclicBarrier(nthreads+1, timer);
145	for (int i = 0; i < nthreads; ++i)
146	new Thread(this).start();
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	if (failures != 0)
161	throw new Error("protection failure?");
162	}
163	abstract int loop(int n);
164	public final void run() {
165	try {
166	barrier.await();
167	result += loop(iters);
168	barrier.await();
169	}
170	catch (Exception ie) {
171	return;
172	}
173	}
174
175	}
176
177	private static class NoLockLoop extends LockLoop {
178	private volatile int readBarrier;
179	final int loop(int n) {
180	int sum = 0;
181	int x = 0;;
182	while (n-- > 0) {
183	int r1 = readBarrier;
184	x = setValue(LoopHelpers.compute1(getValue()));
185	int r2 = readBarrier;
186	if (r1 == r2 && (x & 255) == 0)
187	++readBarrier;
188	sum += LoopHelpers.compute2(x);
189	}
190	return sum;
191	}
192	}
193
194	private static class BuiltinLockLoop extends LockLoop {
195	final int loop(int n) {
196	int sum = 0;
197	int x = 0;;
198	while (n-- > 0) {
199	synchronized(this) {
200	x = setValue(LoopHelpers.compute1(getValue()));
201	}
202	sum += LoopHelpers.compute2(x);
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	final ReentrantLock lock = this.lock;
212	int sum = 0;
213	int x = 0;
214	while (n-- > 0) {
215	lock.lock();
216	try {
217	x = setValue(LoopHelpers.compute1(getValue()));
218	}
219	finally {
220	lock.unlock();
221	}
222	sum += LoopHelpers.compute2(x);
223	}
224	return sum;
225	}
226	}
227
228	private static class MutexLoop extends LockLoop {
229	final private Mutex lock = new Mutex();
230	final int loop(int n) {
231	final Mutex lock = this.lock;
232	int sum = 0;
233	int x = 0;
234	while (n-- > 0) {
235	lock.lock();
236	try {
237	x = setValue(LoopHelpers.compute1(getValue()));
238	}
239	finally {
240	lock.unlock();
241	}
242	sum += LoopHelpers.compute2(x);
243	}
244	return sum;
245	}
246	}
247
248	private static class LongMutexLoop extends LockLoop {
249	final private LongMutex lock = new LongMutex();
250	final int loop(int n) {
251	final LongMutex lock = this.lock;
252	int sum = 0;
253	int x = 0;
254	while (n-- > 0) {
255	lock.lock();
256	try {
257	x = setValue(LoopHelpers.compute1(getValue()));
258	}
259	finally {
260	lock.unlock();
261	}
262	sum += LoopHelpers.compute2(x);
263	}
264	return sum;
265	}
266	}
267
268	private static class FairReentrantLockLoop extends LockLoop {
269	final private ReentrantLock lock = new ReentrantLock(true);
270	final int loop(int n) {
271	final ReentrantLock lock = this.lock;
272	int sum = 0;
273	int x = 0;
274	while (n-- > 0) {
275	lock.lock();
276	try {
277	x = setValue(LoopHelpers.compute1(getValue()));
278	}
279	finally {
280	lock.unlock();
281	}
282	sum += LoopHelpers.compute2(x);
283	}
284	return sum;
285	}
286	}
287
288	private static class ReentrantWriteLockLoop extends LockLoop {
289	final private Lock lock = new ReentrantReadWriteLock().writeLock();
290	final int loop(int n) {
291	final Lock lock = this.lock;
292	int sum = 0;
293	int x = 0;
294	while (n-- > 0) {
295	lock.lock();
296	try {
297	x = setValue(LoopHelpers.compute1(getValue()));
298	}
299	finally {
300	lock.unlock();
301	}
302	sum += LoopHelpers.compute2(x);
303	}
304	return sum;
305	}
306	}
307
308	private static class FairReentrantWriteLockLoop extends LockLoop {
309	final Lock lock = new ReentrantReadWriteLock(true).writeLock();
310	final int loop(int n) {
311	final Lock lock = this.lock;
312	int sum = 0;
313	int x = 0;
314	while (n-- > 0) {
315	lock.lock();
316	try {
317	x = setValue(LoopHelpers.compute1(getValue()));
318	}
319	finally {
320	lock.unlock();
321	}
322	sum += LoopHelpers.compute2(x);
323	}
324	return sum;
325	}
326	}
327
328	private static class SemaphoreLoop extends LockLoop {
329	final private Semaphore sem = new Semaphore(1, false);
330	final int loop(int n) {
331	final Semaphore sem = this.sem;
332	int sum = 0;
333	int x = 0;
334	while (n-- > 0) {
335	sem.acquireUninterruptibly();
336	try {
337	x = setValue(LoopHelpers.compute1(getValue()));
338	}
339	finally {
340	sem.release();
341	}
342	sum += LoopHelpers.compute2(x);
343	}
344	return sum;
345	}
346	}
347	private static class FairSemaphoreLoop extends LockLoop {
348	final private Semaphore sem = new Semaphore(1, true);
349	final int loop(int n) {
350	final Semaphore sem = this.sem;
351	int sum = 0;
352	int x = 0;
353	while (n-- > 0) {
354	sem.acquireUninterruptibly();
355	try {
356	x = setValue(LoopHelpers.compute1(getValue()));
357	}
358	finally {
359	sem.release();
360	}
361	sum += LoopHelpers.compute2(x);
362	}
363	return sum;
364	}
365	}
366
367	private static class ReentrantReadWriteLockLoop extends LockLoop {
368	final private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
369	final int loop(int n) {
370	final Lock rlock = lock.readLock();
371	final Lock wlock = lock.writeLock();
372	int sum = 0;
373	int x = 0;
374	while (n-- > 0) {
375	if ((n & 16) != 0) {
376	rlock.lock();
377	try {
378	x = LoopHelpers.compute1(getValue());
379	x = LoopHelpers.compute2(x);
380	}
381	finally {
382	rlock.unlock();
383	}
384	}
385	else {
386	wlock.lock();
387	try {
388	setValue(x);
389	}
390	finally {
391	wlock.unlock();
392	}
393	sum += LoopHelpers.compute2(x);
394	}
395	}
396	return sum;
397	}
398
399	}
400
401
402	private static class FairReentrantReadWriteLockLoop extends LockLoop {
403	final private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
404	final int loop(int n) {
405	final Lock rlock = lock.readLock();
406	final Lock wlock = lock.writeLock();
407	int sum = 0;
408	int x = 0;
409	while (n-- > 0) {
410	if ((n & 16) != 0) {
411	rlock.lock();
412	try {
413	x = LoopHelpers.compute1(getValue());
414	x = LoopHelpers.compute2(x);
415	}
416	finally {
417	rlock.unlock();
418	}
419	}
420	else {
421	wlock.lock();
422	try {
423	setValue(x);
424	}
425	finally {
426	wlock.unlock();
427	}
428	sum += LoopHelpers.compute2(x);
429	}
430	}
431	return sum;
432	}
433
434	}
435	}