test/loops/SpinningTieredPhaserLoops.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/licenses/publicdomain
 */

import java.util.*;
import java.util.concurrent.*;
//import jsr166y.*;

/*
 * Based loosely on Java Grande Forum barrierBench
 */

public class SpinningTieredPhaserLoops {
    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 int tasksPerPhaser = Math.max(NCPUS / 4, 4);

    static void build(Runnable[] actions, int sz, int lo, int hi, Phaser b) {
        if (hi - lo > tasksPerPhaser) {
            for (int i = lo; i < hi; i += tasksPerPhaser) {
                int j = Math.min(i + tasksPerPhaser, hi);
                build(actions, sz, i, j, new Phaser(b));
            }
        } else {
            for (int i = lo; i < hi; ++i)
                actions[i] = new PhaserAction(i, b, sz);
        }
    }

    static final class PhaserAction implements Runnable {
        final int id;
        final int size;
        final Phaser phaser;
        public PhaserAction(int id, Phaser b, int size) {
            this.id = id;
            this.phaser = b;
            this.size = size;
            phaser.register();
        }


        public void run() {
            int n = size;
            Phaser b = phaser;
            for (int i = 0; i < n; ++i) {
                int p = b.arrive();
                while (b.getPhase() == p) {
                    if ((ThreadLocalRandom.current().nextInt() & 127) == 0)
                        Thread.yield();
                }
            }
        }
    }

    public static void main(String[] args) throws Exception {
        int nthreads = NCPUS;
        if (args.length > 0)
            nthreads = Integer.parseInt(args[0]);
        if (args.length > 1)
            tasksPerPhaser = Integer.parseInt(args[1]);

        System.out.printf("Max %d Threads, %d tasks per phaser\n", nthreads, tasksPerPhaser);

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

                Runnable[] actions = new Runnable [k];
                build(actions, size, 0, k, new Phaser());
                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.4
Committed:	Tue Nov 3 12:37:26 2009 UTC (14 years, 6 months ago) by dl
Branch:	MAIN
Changes since 1.3:	+5 -9 lines
Log Message:	Use version of build from javadocs
#	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			* http://creativecommons.org/licenses/publicdomain
5			*/
6
7			import java.util.*;
8			import java.util.concurrent.*;
9			//import jsr166y.*;
10
11			/*
12			* Based loosely on Java Grande Forum barrierBench
13			*/
14
15			public class SpinningTieredPhaserLoops {
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 int tasksPerPhaser = Math.max(NCPUS / 4, 4);
24	jsr166	1.2
25	dl	1.1	static void build(Runnable[] actions, int sz, int lo, int hi, Phaser b) {
26	dl	1.4	if (hi - lo > tasksPerPhaser) {
27			for (int i = lo; i < hi; i += tasksPerPhaser) {
28			int j = Math.min(i + tasksPerPhaser, hi);
29			build(actions, sz, i, j, new Phaser(b));
30	dl	1.1	}
31	dl	1.4	} else {
32	jsr166	1.2	for (int i = lo; i < hi; ++i)
33	dl	1.1	actions[i] = new PhaserAction(i, b, sz);
34			}
35			}
36
37			static final class PhaserAction implements Runnable {
38			final int id;
39			final int size;
40			final Phaser phaser;
41			public PhaserAction(int id, Phaser b, int size) {
42			this.id = id;
43			this.phaser = b;
44			this.size = size;
45			phaser.register();
46			}
47
48
49			public void run() {
50			int n = size;
51			Phaser b = phaser;
52	jsr166	1.3	for (int i = 0; i < n; ++i) {
53	dl	1.1	int p = b.arrive();
54			while (b.getPhase() == p) {
55			if ((ThreadLocalRandom.current().nextInt() & 127) == 0)
56			Thread.yield();
57			}
58			}
59			}
60			}
61
62			public static void main(String[] args) throws Exception {
63			int nthreads = NCPUS;
64			if (args.length > 0)
65			nthreads = Integer.parseInt(args[0]);
66			if (args.length > 1)
67			tasksPerPhaser = Integer.parseInt(args[1]);
68	jsr166	1.2
69	dl	1.1	System.out.printf("Max %d Threads, %d tasks per phaser\n", nthreads, tasksPerPhaser);
70
71			for (int k = 2; k <= nthreads; k *= 2) {
72			for (int size = FIRST_SIZE; size <= LAST_SIZE; size *= 10) {
73			long startTime = System.nanoTime();
74	jsr166	1.2
75	dl	1.1	Runnable[] actions = new Runnable [k];
76			build(actions, size, 0, k, new Phaser());
77			Future[] futures = new Future[k];
78			for (int i = 0; i < k; ++i) {
79			futures[i] = pool.submit(actions[i]);
80			}
81			for (int i = 0; i < k; ++i) {
82			futures[i].get();
83			}
84			long elapsed = System.nanoTime() - startTime;
85			long bs = (NPS * size) / elapsed;
86			System.out.printf("%4d Threads %8d iters: %11d barriers/sec\n",
87			k, size, bs);
88			}
89			}
90			pool.shutdown();
91			}
92	jsr166	1.2
93	dl	1.1	}