test/loops/CyclicBarrierLoops.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * Based loosely on Java Grande Forum barrierBench
 */
public class CyclicBarrierLoops {
    static final int NCPUS = Runtime.getRuntime().availableProcessors();
    static final ExecutorService pool = Executors.newCachedThreadPool();
    static final int FIRST_SIZE = 10000;
    static final int LAST_SIZE = 1000000;
    /** for time conversion */
    static final long NPS = (1000L * 1000 * 1000);

    static final class CyclicBarrierAction implements Runnable {
        final int id;
        final int size;
        final CyclicBarrier barrier;
        public CyclicBarrierAction(int id, CyclicBarrier b, int size) {
            this.id = id;
            this.barrier = b;
            this.size = size;
        }

        public void run() {
            try {
                int n = size;
                CyclicBarrier b = barrier;
                for (int i = 0; i < n; ++i)
                    b.await();
            }
            catch (Exception ex) {
                throw new Error(ex);
            }
        }
    }

    public static void main(String[] args) throws Exception {
        int nthreads = NCPUS;

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

        System.out.printf("max %d Threads\n", nthreads);

        for (int k = 2; k <= nthreads; k *= 2) {
            for (int size = FIRST_SIZE; size <= LAST_SIZE; size *= 10) {
                long startTime = System.nanoTime();

                CyclicBarrier barrier = new CyclicBarrier(k);
                CyclicBarrierAction[] actions = new CyclicBarrierAction[k];
                for (int i = 0; i < k; ++i) {
                    actions[i] = new CyclicBarrierAction(i, barrier, size);
                }

                Future<?>[] futures = new Future<?>[k];
                for (int i = 0; i < k; ++i) {
                    futures[i] = pool.submit(actions[i]);
                }
                for (int i = 0; i < k; ++i) {
                    futures[i].get();
                }
                long elapsed = System.nanoTime() - startTime;
                long bs = (NPS * size) / elapsed;
                System.out.printf("%4d Threads %8d iters: %11d barriers/sec\n",
                                  k, size, bs);
            }
        }
        pool.shutdown();
    }

}
Revision:	1.8
Committed:	Sat Dec 31 19:42:12 2016 UTC (7 years, 4 months ago) by jsr166
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.7:	+4 -3 lines
Log Message:	organize imports
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4	jsr166	1.4	* http://creativecommons.org/publicdomain/zero/1.0/
5	dl	1.1	*/
6
7	jsr166	1.8	import java.util.concurrent.CyclicBarrier;
8			import java.util.concurrent.ExecutorService;
9			import java.util.concurrent.Executors;
10			import java.util.concurrent.Future;
11	dl	1.1
12	jsr166	1.5	/**
13	dl	1.1	* Based loosely on Java Grande Forum barrierBench
14			*/
15			public class CyclicBarrierLoops {
16			static final int NCPUS = Runtime.getRuntime().availableProcessors();
17			static final ExecutorService pool = Executors.newCachedThreadPool();
18			static final int FIRST_SIZE = 10000;
19			static final int LAST_SIZE = 1000000;
20			/** for time conversion */
21			static final long NPS = (1000L * 1000 * 1000);
22
23			static final class CyclicBarrierAction implements Runnable {
24			final int id;
25			final int size;
26			final CyclicBarrier barrier;
27			public CyclicBarrierAction(int id, CyclicBarrier b, int size) {
28			this.id = id;
29			this.barrier = b;
30			this.size = size;
31			}
32
33			public void run() {
34			try {
35			int n = size;
36			CyclicBarrier b = barrier;
37	jsr166	1.3	for (int i = 0; i < n; ++i)
38	dl	1.1	b.await();
39			}
40	jsr166	1.3	catch (Exception ex) {
41	dl	1.1	throw new Error(ex);
42			}
43			}
44			}
45
46			public static void main(String[] args) throws Exception {
47			int nthreads = NCPUS;
48
49			if (args.length > 0)
50			nthreads = Integer.parseInt(args[0]);
51
52			System.out.printf("max %d Threads\n", nthreads);
53	jsr166	1.2
54	dl	1.1	for (int k = 2; k <= nthreads; k *= 2) {
55			for (int size = FIRST_SIZE; size <= LAST_SIZE; size *= 10) {
56			long startTime = System.nanoTime();
57	jsr166	1.2
58	dl	1.1	CyclicBarrier barrier = new CyclicBarrier(k);
59			CyclicBarrierAction[] actions = new CyclicBarrierAction[k];
60			for (int i = 0; i < k; ++i) {
61			actions[i] = new CyclicBarrierAction(i, barrier, size);
62			}
63	jsr166	1.2
64	jsr166	1.6	Future<?>[] futures = new Future<?>[k];
65	dl	1.1	for (int i = 0; i < k; ++i) {
66			futures[i] = pool.submit(actions[i]);
67			}
68			for (int i = 0; i < k; ++i) {
69			futures[i].get();
70			}
71			long elapsed = System.nanoTime() - startTime;
72			long bs = (NPS * size) / elapsed;
73			System.out.printf("%4d Threads %8d iters: %11d barriers/sec\n",
74			k, size, bs);
75			}
76			}
77			pool.shutdown();
78			}
79	jsr166	1.2
80	dl	1.1	}