test/loops/CASLoops.java

/*
 * Written by Doug Lea and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 */

/*
 * Estimates the difference in time for compareAndSet and CAS-like
 * operations versus unsynchronized, non-volatile pseudo-CAS when
 * updating random numbers. These estimates thus give the cost
 * of atomicity/barriers/exclusion over and above the time to
 * just compare and conditionally store (int) values, so are
 * not intended to measure the "raw" cost of a CAS.
 *
 * Outputs, for runs using 1 ... #cpus threads are, in nanoseconds:
 *  "Atomic CAS"      AtomicInteger.compareAndSet
 *  "Volatile"        pseudo-CAS using volatile store if comparison succeeds
 *  "Mutex"           emulated compare and set done under AQS-based mutex lock
 *  "Synchronized"    emulated compare and set done under a synchronized block.
 *
 * The last two are done only if this program is called with (any) argument
 */


import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public class CASLoops {

    static final int TRIALS = 2;
    static final long BASE_SECS_PER_RUN = 4;
    static final int NCPUS = Runtime.getRuntime().availableProcessors();

    static boolean includeLocks = false;

    public static void main(String[] args) throws Exception {
        if (args.length > 0)
            includeLocks = true;

        System.out.println("Warmup...");
        for (int j = 0; j < 2; ++j) {
            for (int i = 1; i <= NCPUS; ++i) {
                runCalibration(i, 1000);
                oneRun(i, loopIters[i] / 8, false);
            }
        }

        for (int i = 1; i <= NCPUS; ++i) 
            loopIters[i] = 0;

        for (int j = 0; j < TRIALS; ++j) {
            System.out.println("Trial " + j);
            for (int i = 1; i <= NCPUS; ++i) {
                runCalibration(i, BASE_SECS_PER_RUN * 1000L);
                oneRun(i, loopIters[i], true);
            }
        }
    }

    static final AtomicLong totalIters = new AtomicLong(0);
    static final AtomicLong successes = new AtomicLong(0);
    static final AtomicInteger sum = new AtomicInteger(0);

    static final LoopHelpers.MarsagliaRandom rng = new LoopHelpers.MarsagliaRandom();

    static final long[] loopIters = new long[NCPUS+1];

    static final class NonAtomicInteger {
        volatile int readBarrier;
        int value;

        NonAtomicInteger() {}
        int get() {
            int junk = readBarrier;
            return value;
        }
        boolean compareAndSet(int cmp, int val) {
            if (value == cmp) {
                value = val;
                return true;
            }
            return false;
        }
        void set(int val) { value = val; }
    }

    static final class VolatileInteger {
        volatile int value;

        VolatileInteger() {}
        int get() {
            return value;
        }
        boolean compareAndSet(int cmp, int val) {
            if (value == cmp) {
                value = val;
                return true;
            }
            return false;
        }
        void set(int val) { value = val; }
    }

    static final class SynchedInteger {
        int value;

        SynchedInteger() {}
        int get() {
            return value;
        }
        synchronized boolean compareAndSet(int cmp, int val) {
            if (value == cmp) {
                value = val;
                return true;
            }
            return false;
        }
        synchronized void set(int val) { value = val; }
    }


    static final class LockedInteger extends AbstractQueuedSynchronizer {
        int value;
        LockedInteger() {}

        public boolean tryAcquire(int acquires) {
            return compareAndSetState(0, 1);
        }
        public boolean tryRelease(int releases) {
            setState(0);
            return true;
        }
        void lock() { acquire(1); }
        void unlock() { release(1); }

        int get() {
            return value;
        }
        boolean compareAndSet(int cmp, int val) {
            lock();
            try {
                if (value == cmp) {
                    value = val;
                    return true;
                }
                return false;
            } finally {
                unlock();
            }
        }
        void set(int val) { 
            lock(); 
            try {
                value = val; 
            } finally {
                unlock();
            }
        }
    }

    // All these versions are copy-paste-hacked to avoid 
    // contamination with virtual call resolution etc.

    // Use fixed-length unrollable inner loops to reduce safepoint checks
    static final int innerPerOuter = 16;

    static final class NonAtomicLoop implements Runnable {
        final long iters;
        final NonAtomicInteger obj;
        final CyclicBarrier barrier;
        NonAtomicLoop(long iters, NonAtomicInteger obj, CyclicBarrier b) {
            this.iters = iters;
            this.obj = obj;
            this.barrier = b;
            obj.set(rng.next());
        }

        public void run() {
            try {
                barrier.await(); 
                long i = iters;
                int y = 0;
                int succ = 0;
                while (i > 0) {
                    for (int k = 0; k < innerPerOuter; ++k) {
                        int x = obj.get();
                        int z = y + LoopHelpers.compute6(x);
                        if (obj.compareAndSet(x, z))
                            ++succ;
                        y = LoopHelpers.compute7(z);
                    }
                    i -= innerPerOuter;
                }
                sum.getAndAdd(obj.get());
                successes.getAndAdd(succ);
                barrier.await();
            }
            catch (Exception ie) { 
                return; 
            }
        }
    }

    static final class AtomicLoop implements Runnable {
        final long iters;
        final AtomicInteger obj;
        final CyclicBarrier barrier;
        AtomicLoop(long iters, AtomicInteger obj, CyclicBarrier b) {
            this.iters = iters;
            this.obj = obj;
            this.barrier = b;
            obj.set(rng.next());
        }

        public void run() {
            try {
                barrier.await(); 
                long i = iters;
                int y = 0;
                int succ = 0;
                while (i > 0) {
                    for (int k = 0; k < innerPerOuter; ++k) {
                        int x = obj.get();
                        int z = y + LoopHelpers.compute6(x);
                        if (obj.compareAndSet(x, z))
                            ++succ;
                        y = LoopHelpers.compute7(z);
                    }
                    i -= innerPerOuter;
                }
                sum.getAndAdd(obj.get());
                successes.getAndAdd(succ);
                barrier.await();
            }
            catch (Exception ie) { 
                return; 
            }
        }
    }

    static final class VolatileLoop implements Runnable {
        final long iters;
        final VolatileInteger obj;
        final CyclicBarrier barrier;
        VolatileLoop(long iters, VolatileInteger obj, CyclicBarrier b) {
            this.iters = iters;
            this.obj = obj;
            this.barrier = b;
            obj.set(rng.next());
        }

        public void run() {
            try {
                barrier.await(); 
                long i = iters;
                int y = 0;
                int succ = 0;
                while (i > 0) {
                    for (int k = 0; k < innerPerOuter; ++k) {
                        int x = obj.get();
                        int z = y + LoopHelpers.compute6(x);
                        if (obj.compareAndSet(x, z))
                            ++succ;
                        y = LoopHelpers.compute7(z);
                    }
                    i -= innerPerOuter;
                }
                sum.getAndAdd(obj.get());
                successes.getAndAdd(succ);
                barrier.await();
            }
            catch (Exception ie) { 
                return; 
            }
        }
    }

    static final class SynchedLoop implements Runnable {
        final long iters;
        final SynchedInteger obj;
        final CyclicBarrier barrier;
        SynchedLoop(long iters, SynchedInteger obj, CyclicBarrier b) {
            this.iters = iters;
            this.obj = obj;
            this.barrier = b;
            obj.set(rng.next());
        }

        public void run() {
            try {
                barrier.await(); 
                long i = iters;
                int y = 0;
                int succ = 0;
                while (i > 0) {
                    for (int k = 0; k < innerPerOuter; ++k) {
                        int x = obj.get();
                        int z = y + LoopHelpers.compute6(x);
                        if (obj.compareAndSet(x, z))
                            ++succ;
                        y = LoopHelpers.compute7(z);
                    }
                    i -= innerPerOuter;
                }
                sum.getAndAdd(obj.get());
                successes.getAndAdd(succ);
                barrier.await();
            }
            catch (Exception ie) { 
                return; 
            }
        }
    }

    static final class LockedLoop implements Runnable {
        final long iters;
        final LockedInteger obj;
        final CyclicBarrier barrier;
        LockedLoop(long iters, LockedInteger obj, CyclicBarrier b) {
            this.iters = iters;
            this.obj = obj;
            this.barrier = b;
            obj.set(rng.next());
        }

        public void run() {
            try {
                barrier.await(); 
                long i = iters;
                int y = 0;
                int succ = 0;
                while (i > 0) {
                    for (int k = 0; k < innerPerOuter; ++k) {
                        int x = obj.get();
                        int z = y + LoopHelpers.compute6(x);
                        if (obj.compareAndSet(x, z))
                            ++succ;
                        y = LoopHelpers.compute7(z);
                    }
                    i -= innerPerOuter;
                }
                sum.getAndAdd(obj.get());
                successes.getAndAdd(succ);
                barrier.await();
            }
            catch (Exception ie) { 
                return; 
            }
        }
    }

    static final int loopsPerTimeCheck = 2048;

    static final class NACalibrationLoop implements Runnable {
        final long endTime;
        final NonAtomicInteger obj;
        final CyclicBarrier barrier;
        NACalibrationLoop(long endTime, NonAtomicInteger obj, CyclicBarrier b) {
            this.endTime = endTime;
            this.obj = obj;
            this.barrier = b;
            obj.set(rng.next());
        }

        public void run() {
            try {
                barrier.await(); 
                long iters = 0;
                int y = 0;
                int succ = 0;
                do {
                    int i = loopsPerTimeCheck;
                    while (i > 0) {
                        for (int k = 0; k < innerPerOuter; ++k) {
                            int x = obj.get();
                            int z = y + LoopHelpers.compute6(x);
                            if (obj.compareAndSet(x, z))
                                ++succ;
                            y = LoopHelpers.compute7(z);
                        }
                        i -= innerPerOuter;
                    }
                    iters += loopsPerTimeCheck;
                } while (System.currentTimeMillis() < endTime);
                totalIters.getAndAdd(iters);
                sum.getAndAdd(obj.get());
                successes.getAndAdd(succ);
                barrier.await();
            }
            catch (Exception ie) { 
                return; 
            }
        }
    }

    static void runCalibration(int n, long nms) throws Exception {
        long now = System.currentTimeMillis();
        long endTime = now + nms;
        CyclicBarrier b = new CyclicBarrier(n+1);
        totalIters.set(0);
        NonAtomicInteger a = new NonAtomicInteger();
        for (int j = 0; j < n; ++j) 
            new Thread(new NACalibrationLoop(endTime, a, b)).start();
        b.await();
        b.await();
        long ipt = totalIters.get() / n;
        if (ipt > loopIters[n])
            loopIters[n] = ipt;
        if (sum.get() == 0) System.out.print(" ");
    }

    static long runNonAtomic(int n, long iters) throws Exception {
        LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
        CyclicBarrier b = new CyclicBarrier(n+1, timer);
        NonAtomicInteger a = new NonAtomicInteger();
        for (int j = 0; j < n; ++j) 
            new Thread(new NonAtomicLoop(iters, a, b)).start();
        b.await();
        b.await();
        if (sum.get() == 0) System.out.print(" ");
        return timer.getTime();
    }

    static long runAtomic(int n, long iters) throws Exception {
        LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
        CyclicBarrier b = new CyclicBarrier(n+1, timer);
        AtomicInteger a = new AtomicInteger();
        for (int j = 0; j < n; ++j) 
            new Thread(new AtomicLoop(iters, a, b)).start();
        b.await();
        b.await();
        if (sum.get() == 0) System.out.print(" ");
        return timer.getTime();
    }

    static long runVolatile(int n, long iters) throws Exception {
        LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
        CyclicBarrier b = new CyclicBarrier(n+1, timer);
        VolatileInteger a = new VolatileInteger();
        for (int j = 0; j < n; ++j) 
            new Thread(new VolatileLoop(iters, a, b)).start();
        b.await();
        b.await();
        if (sum.get() == 0) System.out.print(" ");
        return timer.getTime();
    }


    static long runSynched(int n, long iters) throws Exception {
        LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
        CyclicBarrier b = new CyclicBarrier(n+1, timer);
        SynchedInteger a = new SynchedInteger();
        for (int j = 0; j < n; ++j) 
            new Thread(new SynchedLoop(iters, a, b)).start();
        b.await();
        b.await();
        if (sum.get() == 0) System.out.print(" ");
        return timer.getTime();
    }

    static long runLocked(int n, long iters) throws Exception {
        LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
        CyclicBarrier b = new CyclicBarrier(n+1, timer);
        LockedInteger a = new LockedInteger();
        for (int j = 0; j < n; ++j) 
            new Thread(new LockedLoop(iters, a, b)).start();
        b.await();
        b.await();
        if (sum.get() == 0) System.out.print(" ");
        return timer.getTime();
    }

    static void report(String tag, long runtime, long basetime, long iters) {
        System.out.print(tag);
        System.out.print(LoopHelpers.rightJustify((runtime - basetime) / iters) + " ns");
        double secs = (double)(runtime) / 1000000000.0;
        System.out.println("\t " + secs + "s run time");
    }
        

    static void oneRun(int i, long iters, boolean print) throws Exception {
        System.out.println("threads : " + i + 
                           " base iters per thread per run : " + 
                           LoopHelpers.rightJustify(loopIters[i]));
        long ntime = runNonAtomic(i,  iters);
        if (print)
            report("Base        : ", ntime, ntime, iters);
        Thread.sleep(100L);
        long atime = runAtomic(i, iters);
        if (print)
            report("Atomic CAS  : ", atime, ntime, iters);
        Thread.sleep(100L);
        long vtime = runVolatile(i, iters);
        if (print)
            report("Volatile    : ", vtime, ntime, iters);

        Thread.sleep(100L);
        if (!includeLocks) return;
        long mtime = runLocked(i, iters);
        if (print)
            report("Mutex       : ", mtime, ntime, iters);
        Thread.sleep(100L);
        long stime = runSynched(i, iters);
        if (print) 
            report("Synchronized: ", stime, ntime, iters);
        Thread.sleep(100L);
    }


}
Revision:	1.1
Committed:	Fri Jun 10 15:45:19 2005 UTC (18 years, 11 months ago) by dl
Branch:	MAIN
Log Message:	Add CAS timing test; use cheaper RNGs in others
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by Doug Lea and released to the public domain, as explained at
3			* http://creativecommons.org/licenses/publicdomain
4			*/
5
6			/*
7			* Estimates the difference in time for compareAndSet and CAS-like
8			* operations versus unsynchronized, non-volatile pseudo-CAS when
9			* updating random numbers. These estimates thus give the cost
10			* of atomicity/barriers/exclusion over and above the time to
11			* just compare and conditionally store (int) values, so are
12			* not intended to measure the "raw" cost of a CAS.
13			*
14			* Outputs, for runs using 1 ... #cpus threads are, in nanoseconds:
15			* "Atomic CAS" AtomicInteger.compareAndSet
16			* "Volatile" pseudo-CAS using volatile store if comparison succeeds
17			* "Mutex" emulated compare and set done under AQS-based mutex lock
18			* "Synchronized" emulated compare and set done under a synchronized block.
19			*
20			* The last two are done only if this program is called with (any) argument
21			*/
22
23
24			import java.util.concurrent.atomic.AtomicInteger;
25			import java.util.concurrent.atomic.AtomicLong;
26			import java.util.concurrent.*;
27			import java.util.concurrent.locks.*;
28
29			public class CASLoops {
30
31			static final int TRIALS = 2;
32			static final long BASE_SECS_PER_RUN = 4;
33			static final int NCPUS = Runtime.getRuntime().availableProcessors();
34
35			static boolean includeLocks = false;
36
37			public static void main(String[] args) throws Exception {
38			if (args.length > 0)
39			includeLocks = true;
40
41			System.out.println("Warmup...");
42			for (int j = 0; j < 2; ++j) {
43			for (int i = 1; i <= NCPUS; ++i) {
44			runCalibration(i, 1000);
45			oneRun(i, loopIters[i] / 8, false);
46			}
47			}
48
49			for (int i = 1; i <= NCPUS; ++i)
50			loopIters[i] = 0;
51
52			for (int j = 0; j < TRIALS; ++j) {
53			System.out.println("Trial " + j);
54			for (int i = 1; i <= NCPUS; ++i) {
55			runCalibration(i, BASE_SECS_PER_RUN * 1000L);
56			oneRun(i, loopIters[i], true);
57			}
58			}
59			}
60
61			static final AtomicLong totalIters = new AtomicLong(0);
62			static final AtomicLong successes = new AtomicLong(0);
63			static final AtomicInteger sum = new AtomicInteger(0);
64
65			static final LoopHelpers.MarsagliaRandom rng = new LoopHelpers.MarsagliaRandom();
66
67			static final long[] loopIters = new long[NCPUS+1];
68
69			static final class NonAtomicInteger {
70			volatile int readBarrier;
71			int value;
72
73			NonAtomicInteger() {}
74			int get() {
75			int junk = readBarrier;
76			return value;
77			}
78			boolean compareAndSet(int cmp, int val) {
79			if (value == cmp) {
80			value = val;
81			return true;
82			}
83			return false;
84			}
85			void set(int val) { value = val; }
86			}
87
88			static final class VolatileInteger {
89			volatile int value;
90
91			VolatileInteger() {}
92			int get() {
93			return value;
94			}
95			boolean compareAndSet(int cmp, int val) {
96			if (value == cmp) {
97			value = val;
98			return true;
99			}
100			return false;
101			}
102			void set(int val) { value = val; }
103			}
104
105			static final class SynchedInteger {
106			int value;
107
108			SynchedInteger() {}
109			int get() {
110			return value;
111			}
112			synchronized boolean compareAndSet(int cmp, int val) {
113			if (value == cmp) {
114			value = val;
115			return true;
116			}
117			return false;
118			}
119			synchronized void set(int val) { value = val; }
120			}
121
122
123			static final class LockedInteger extends AbstractQueuedSynchronizer {
124			int value;
125			LockedInteger() {}
126
127			public boolean tryAcquire(int acquires) {
128			return compareAndSetState(0, 1);
129			}
130			public boolean tryRelease(int releases) {
131			setState(0);
132			return true;
133			}
134			void lock() { acquire(1); }
135			void unlock() { release(1); }
136
137			int get() {
138			return value;
139			}
140			boolean compareAndSet(int cmp, int val) {
141			lock();
142			try {
143			if (value == cmp) {
144			value = val;
145			return true;
146			}
147			return false;
148			} finally {
149			unlock();
150			}
151			}
152			void set(int val) {
153			lock();
154			try {
155			value = val;
156			} finally {
157			unlock();
158			}
159			}
160			}
161
162			// All these versions are copy-paste-hacked to avoid
163			// contamination with virtual call resolution etc.
164
165			// Use fixed-length unrollable inner loops to reduce safepoint checks
166			static final int innerPerOuter = 16;
167
168			static final class NonAtomicLoop implements Runnable {
169			final long iters;
170			final NonAtomicInteger obj;
171			final CyclicBarrier barrier;
172			NonAtomicLoop(long iters, NonAtomicInteger obj, CyclicBarrier b) {
173			this.iters = iters;
174			this.obj = obj;
175			this.barrier = b;
176			obj.set(rng.next());
177			}
178
179			public void run() {
180			try {
181			barrier.await();
182			long i = iters;
183			int y = 0;
184			int succ = 0;
185			while (i > 0) {
186			for (int k = 0; k < innerPerOuter; ++k) {
187			int x = obj.get();
188			int z = y + LoopHelpers.compute6(x);
189			if (obj.compareAndSet(x, z))
190			++succ;
191			y = LoopHelpers.compute7(z);
192			}
193			i -= innerPerOuter;
194			}
195			sum.getAndAdd(obj.get());
196			successes.getAndAdd(succ);
197			barrier.await();
198			}
199			catch (Exception ie) {
200			return;
201			}
202			}
203			}
204
205			static final class AtomicLoop implements Runnable {
206			final long iters;
207			final AtomicInteger obj;
208			final CyclicBarrier barrier;
209			AtomicLoop(long iters, AtomicInteger obj, CyclicBarrier b) {
210			this.iters = iters;
211			this.obj = obj;
212			this.barrier = b;
213			obj.set(rng.next());
214			}
215
216			public void run() {
217			try {
218			barrier.await();
219			long i = iters;
220			int y = 0;
221			int succ = 0;
222			while (i > 0) {
223			for (int k = 0; k < innerPerOuter; ++k) {
224			int x = obj.get();
225			int z = y + LoopHelpers.compute6(x);
226			if (obj.compareAndSet(x, z))
227			++succ;
228			y = LoopHelpers.compute7(z);
229			}
230			i -= innerPerOuter;
231			}
232			sum.getAndAdd(obj.get());
233			successes.getAndAdd(succ);
234			barrier.await();
235			}
236			catch (Exception ie) {
237			return;
238			}
239			}
240			}
241
242			static final class VolatileLoop implements Runnable {
243			final long iters;
244			final VolatileInteger obj;
245			final CyclicBarrier barrier;
246			VolatileLoop(long iters, VolatileInteger obj, CyclicBarrier b) {
247			this.iters = iters;
248			this.obj = obj;
249			this.barrier = b;
250			obj.set(rng.next());
251			}
252
253			public void run() {
254			try {
255			barrier.await();
256			long i = iters;
257			int y = 0;
258			int succ = 0;
259			while (i > 0) {
260			for (int k = 0; k < innerPerOuter; ++k) {
261			int x = obj.get();
262			int z = y + LoopHelpers.compute6(x);
263			if (obj.compareAndSet(x, z))
264			++succ;
265			y = LoopHelpers.compute7(z);
266			}
267			i -= innerPerOuter;
268			}
269			sum.getAndAdd(obj.get());
270			successes.getAndAdd(succ);
271			barrier.await();
272			}
273			catch (Exception ie) {
274			return;
275			}
276			}
277			}
278
279			static final class SynchedLoop implements Runnable {
280			final long iters;
281			final SynchedInteger obj;
282			final CyclicBarrier barrier;
283			SynchedLoop(long iters, SynchedInteger obj, CyclicBarrier b) {
284			this.iters = iters;
285			this.obj = obj;
286			this.barrier = b;
287			obj.set(rng.next());
288			}
289
290			public void run() {
291			try {
292			barrier.await();
293			long i = iters;
294			int y = 0;
295			int succ = 0;
296			while (i > 0) {
297			for (int k = 0; k < innerPerOuter; ++k) {
298			int x = obj.get();
299			int z = y + LoopHelpers.compute6(x);
300			if (obj.compareAndSet(x, z))
301			++succ;
302			y = LoopHelpers.compute7(z);
303			}
304			i -= innerPerOuter;
305			}
306			sum.getAndAdd(obj.get());
307			successes.getAndAdd(succ);
308			barrier.await();
309			}
310			catch (Exception ie) {
311			return;
312			}
313			}
314			}
315
316			static final class LockedLoop implements Runnable {
317			final long iters;
318			final LockedInteger obj;
319			final CyclicBarrier barrier;
320			LockedLoop(long iters, LockedInteger obj, CyclicBarrier b) {
321			this.iters = iters;
322			this.obj = obj;
323			this.barrier = b;
324			obj.set(rng.next());
325			}
326
327			public void run() {
328			try {
329			barrier.await();
330			long i = iters;
331			int y = 0;
332			int succ = 0;
333			while (i > 0) {
334			for (int k = 0; k < innerPerOuter; ++k) {
335			int x = obj.get();
336			int z = y + LoopHelpers.compute6(x);
337			if (obj.compareAndSet(x, z))
338			++succ;
339			y = LoopHelpers.compute7(z);
340			}
341			i -= innerPerOuter;
342			}
343			sum.getAndAdd(obj.get());
344			successes.getAndAdd(succ);
345			barrier.await();
346			}
347			catch (Exception ie) {
348			return;
349			}
350			}
351			}
352
353			static final int loopsPerTimeCheck = 2048;
354
355			static final class NACalibrationLoop implements Runnable {
356			final long endTime;
357			final NonAtomicInteger obj;
358			final CyclicBarrier barrier;
359			NACalibrationLoop(long endTime, NonAtomicInteger obj, CyclicBarrier b) {
360			this.endTime = endTime;
361			this.obj = obj;
362			this.barrier = b;
363			obj.set(rng.next());
364			}
365
366			public void run() {
367			try {
368			barrier.await();
369			long iters = 0;
370			int y = 0;
371			int succ = 0;
372			do {
373			int i = loopsPerTimeCheck;
374			while (i > 0) {
375			for (int k = 0; k < innerPerOuter; ++k) {
376			int x = obj.get();
377			int z = y + LoopHelpers.compute6(x);
378			if (obj.compareAndSet(x, z))
379			++succ;
380			y = LoopHelpers.compute7(z);
381			}
382			i -= innerPerOuter;
383			}
384			iters += loopsPerTimeCheck;
385			} while (System.currentTimeMillis() < endTime);
386			totalIters.getAndAdd(iters);
387			sum.getAndAdd(obj.get());
388			successes.getAndAdd(succ);
389			barrier.await();
390			}
391			catch (Exception ie) {
392			return;
393			}
394			}
395			}
396
397			static void runCalibration(int n, long nms) throws Exception {
398			long now = System.currentTimeMillis();
399			long endTime = now + nms;
400			CyclicBarrier b = new CyclicBarrier(n+1);
401			totalIters.set(0);
402			NonAtomicInteger a = new NonAtomicInteger();
403			for (int j = 0; j < n; ++j)
404			new Thread(new NACalibrationLoop(endTime, a, b)).start();
405			b.await();
406			b.await();
407			long ipt = totalIters.get() / n;
408			if (ipt > loopIters[n])
409			loopIters[n] = ipt;
410			if (sum.get() == 0) System.out.print(" ");
411			}
412
413			static long runNonAtomic(int n, long iters) throws Exception {
414			LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
415			CyclicBarrier b = new CyclicBarrier(n+1, timer);
416			NonAtomicInteger a = new NonAtomicInteger();
417			for (int j = 0; j < n; ++j)
418			new Thread(new NonAtomicLoop(iters, a, b)).start();
419			b.await();
420			b.await();
421			if (sum.get() == 0) System.out.print(" ");
422			return timer.getTime();
423			}
424
425			static long runAtomic(int n, long iters) throws Exception {
426			LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
427			CyclicBarrier b = new CyclicBarrier(n+1, timer);
428			AtomicInteger a = new AtomicInteger();
429			for (int j = 0; j < n; ++j)
430			new Thread(new AtomicLoop(iters, a, b)).start();
431			b.await();
432			b.await();
433			if (sum.get() == 0) System.out.print(" ");
434			return timer.getTime();
435			}
436
437			static long runVolatile(int n, long iters) throws Exception {
438			LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
439			CyclicBarrier b = new CyclicBarrier(n+1, timer);
440			VolatileInteger a = new VolatileInteger();
441			for (int j = 0; j < n; ++j)
442			new Thread(new VolatileLoop(iters, a, b)).start();
443			b.await();
444			b.await();
445			if (sum.get() == 0) System.out.print(" ");
446			return timer.getTime();
447			}
448
449
450			static long runSynched(int n, long iters) throws Exception {
451			LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
452			CyclicBarrier b = new CyclicBarrier(n+1, timer);
453			SynchedInteger a = new SynchedInteger();
454			for (int j = 0; j < n; ++j)
455			new Thread(new SynchedLoop(iters, a, b)).start();
456			b.await();
457			b.await();
458			if (sum.get() == 0) System.out.print(" ");
459			return timer.getTime();
460			}
461
462			static long runLocked(int n, long iters) throws Exception {
463			LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
464			CyclicBarrier b = new CyclicBarrier(n+1, timer);
465			LockedInteger a = new LockedInteger();
466			for (int j = 0; j < n; ++j)
467			new Thread(new LockedLoop(iters, a, b)).start();
468			b.await();
469			b.await();
470			if (sum.get() == 0) System.out.print(" ");
471			return timer.getTime();
472			}
473
474			static void report(String tag, long runtime, long basetime, long iters) {
475			System.out.print(tag);
476			System.out.print(LoopHelpers.rightJustify((runtime - basetime) / iters) + " ns");
477			double secs = (double)(runtime) / 1000000000.0;
478			System.out.println("\t " + secs + "s run time");
479			}
480
481
482			static void oneRun(int i, long iters, boolean print) throws Exception {
483			System.out.println("threads : " + i +
484			" base iters per thread per run : " +
485			LoopHelpers.rightJustify(loopIters[i]));
486			long ntime = runNonAtomic(i, iters);
487			if (print)
488			report("Base : ", ntime, ntime, iters);
489			Thread.sleep(100L);
490			long atime = runAtomic(i, iters);
491			if (print)
492			report("Atomic CAS : ", atime, ntime, iters);
493			Thread.sleep(100L);
494			long vtime = runVolatile(i, iters);
495			if (print)
496			report("Volatile : ", vtime, ntime, iters);
497
498			Thread.sleep(100L);
499			if (!includeLocks) return;
500			long mtime = runLocked(i, iters);
501			if (print)
502			report("Mutex : ", mtime, ntime, iters);
503			Thread.sleep(100L);
504			long stime = runSynched(i, iters);
505			if (print)
506			report("Synchronized: ", stime, ntime, iters);
507			Thread.sleep(100L);
508			}
509
510
511			}