test/loops/CheckedLockLoops.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 CheckedLockLoops {
    static final ExecutorService pool = Executors.newCachedThreadPool();
    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 = 2000000;
        if (args.length > 0) 
            maxThreads = Integer.parseInt(args[0]);
        rng.setSeed(3122688L);
        warmup(iters);
        runTest(maxThreads, iters);
        pool.shutdown();
    }

    static void runTest(int maxThreads, int iters) throws Exception {
        print = true;
        int k = 1;
        for (int i = 1; i <= maxThreads;) {
            System.out.println("Threads:" + i);
            oneTest(i, iters / i);
            if (i == k) {
                k = i << 1;
                i = i + (i >>> 1);
            } 
            else 
                i = k;
        }
    }    

    static void warmup(int iters) throws Exception {
        print = false;
        System.out.println("Warmup...");
        oneTest(1, iters);
        oneTest(2, iters / 2);
    }

    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 (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) 
                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");
                System.out.println();
            }

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