test/loops/FJSums.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.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;

// parallel sums and cumulations

public class FJSums {
    static final long NPS = (1000L * 1000 * 1000);
    static int THRESHOLD;

    public static void main(String[] args) throws Exception {
        int procs = 0;
        int n = 1 << 25;
        int reps = 10;
        try {
            if (args.length > 0)
                procs = Integer.parseInt(args[0]);
            if (args.length > 1)
                n = Integer.parseInt(args[1]);
            if (args.length > 2)
                reps = Integer.parseInt(args[2]);
        }
        catch (Exception e) {
            System.out.println("Usage: java FJSums threads n reps");
            return;
        }
        ForkJoinPool g = (procs == 0) ? new ForkJoinPool() :
            new ForkJoinPool(procs);
        System.out.println("Number of procs=" + g.getParallelism());
        // for now hardwire Cumulate threshold to 8 * #CPUs leaf tasks
        THRESHOLD = 1 + ((n + 7) >>> 3) / g.getParallelism();

        long[] a = new long[n];
        for (int i = 0; i < n; ++i)
            a[i] = i;
        long expected = ((long)n * (long)(n - 1)) / 2;
        for (int i = 0; i < 2; ++i) {
            System.out.print("Seq: ");
            long last = System.nanoTime();
            long ss = seqSum(a, 0, n);
            double elapsed = elapsedTime(last);
            System.out.printf("sum = %24d  time:  %7.3f\n", ss, elapsed);
            if (ss != expected)
                throw new Error("expected " + expected + " != " + ss);
        }
        for (int i = 0; i < reps; ++i) {
            System.out.print("Par: ");
            long last = System.nanoTime();
            Summer s = new Summer(a, 0, a.length, null);
            g.invoke(s);
            long ss = s.result;
            double elapsed = elapsedTime(last);
            System.out.printf("sum = %24d  time:  %7.3f\n", ss, elapsed);
            if (i == 0 && ss != expected)
                throw new Error("expected " + expected + " != " + ss);
            System.out.print("Cum: ");
            last = System.nanoTime();
            g.invoke(new Cumulater(null, a, 0, n));
            long sc = a[n - 1];
            elapsed = elapsedTime(last);
            System.out.printf("sum = %24d  time:  %7.3f\n", ss, elapsed);
            if (sc != ss)
                throw new Error("expected " + ss + " != " + sc);
        }
        System.out.println(g);
        g.shutdown();
    }

    static double elapsedTime(long startTime) {
        return (double)(System.nanoTime() - startTime) / NPS;
    }

    static long seqSum(long[] array, int l, int h) {
        long sum = 0;
        for (int i = l; i < h; ++i)
            sum += array[i];
        return sum;
    }

    static long seqCumulate(long[] array, int lo, int hi, long base) {
        long sum = base;
        for (int i = lo; i < hi; ++i)
            array[i] = sum += array[i];
        return sum;
    }

    /**
     * Adapted from Applyer demo in RecursiveAction docs
     */
    static final class Summer extends RecursiveAction {
        final long[] array;
        final int lo, hi;
        long result;
        Summer next; // keeps track of right-hand-side tasks
        Summer(long[] array, int lo, int hi, Summer next) {
            this.array = array; this.lo = lo; this.hi = hi;
            this.next = next;
        }

        protected void compute() {
            int l = lo;
            int h = hi;
            Summer right = null;
            while (h - l > 1 && getSurplusQueuedTaskCount() <= 3) {
                int mid = (l + h) >>> 1;
                right = new Summer(array, mid, h, right);
                right.fork();
                h = mid;
            }
            long sum = seqSum(array, l, h);
            while (right != null) {
                if (right.tryUnfork()) // directly calculate if not stolen
                    sum += seqSum(array, right.lo, right.hi);
                else {
                    right.join();
                    sum += right.result;
                }
                right = right.next;
            }
            result = sum;
        }
    }

    /**
     * Cumulative scan, adapted from ParallelArray code
     *
     * A basic version of scan is straightforward.
     *  Keep dividing by two to threshold segment size, and then:
     *   Pass 1: Create tree of partial sums for each segment
     *   Pass 2: For each segment, cumulate with offset of left sibling
     * See G. Blelloch's http://www.cs.cmu.edu/~scandal/alg/scan.html
     *
     * This version improves performance within FJ framework mainly by
     * allowing second pass of ready left-hand sides to proceed even
     * if some right-hand side first passes are still executing.  It
     * also combines first and second pass for leftmost segment, and
     * for cumulate (not precumulate) also skips first pass for
     * rightmost segment (whose result is not needed for second pass).
     *
     * To manage this, it relies on "phase" phase/state control field
     * maintaining bits CUMULATE, SUMMED, and FINISHED. CUMULATE is
     * main phase bit. When false, segments compute only their sum.
     * When true, they cumulate array elements. CUMULATE is set at
     * root at beginning of second pass and then propagated down. But
     * it may also be set earlier for subtrees with lo==0 (the
     * left spine of tree). SUMMED is a one bit join count. For leafs,
     * set when summed. For internal nodes, becomes true when one
     * child is summed.  When second child finishes summing, it then
     * moves up tree to trigger cumulate phase. FINISHED is also a one
     * bit join count. For leafs, it is set when cumulated. For
     * internal nodes, it becomes true when one child is cumulated.
     * When second child finishes cumulating, it then moves up tree,
     * executing complete() at the root.
     */
    static final class Cumulater extends ForkJoinTask<Void> {
        static final short CUMULATE = (short)1;
        static final short SUMMED   = (short)2;
        static final short FINISHED = (short)4;

        final Cumulater parent;
        final long[] array;
        Cumulater left, right;
        final int lo;
        final int hi;
        volatile int phase;  // phase/state
        long in, out; // initially zero

        static final AtomicIntegerFieldUpdater<Cumulater> phaseUpdater =
            AtomicIntegerFieldUpdater.newUpdater(Cumulater.class, "phase");

        Cumulater(Cumulater parent, long[] array, int lo, int hi) {
            this.parent = parent;
            this.array = array;
            this.lo = lo;
            this.hi = hi;
        }

        public final Void getRawResult() { return null; }
        protected final void setRawResult(Void mustBeNull) { }

        /** Returns true if can CAS CUMULATE bit true */
        final boolean transitionToCumulate() {
            int c;
            while (((c = phase) & CUMULATE) == 0)
                if (phaseUpdater.compareAndSet(this, c, c | CUMULATE))
                    return true;
            return false;
        }

        public final boolean exec() {
            if (hi - lo > THRESHOLD) {
                if (left == null) { // first pass
                    int mid = (lo + hi) >>> 1;
                    left =  new Cumulater(this, array, lo, mid);
                    right = new Cumulater(this, array, mid, hi);
                }

                boolean cumulate = (phase & CUMULATE) != 0;
                if (cumulate) {
                    long pin = in;
                    left.in = pin;
                    right.in = pin + left.out;
                }

                if (!cumulate || right.transitionToCumulate())
                    right.fork();
                if (!cumulate || left.transitionToCumulate())
                    left.exec();
            }
            else {
                int cb;
                for (;;) { // Establish action: sum, cumulate, or both
                    int b = phase;
                    if ((b & FINISHED) != 0) // already done
                        return false;
                    if ((b & CUMULATE) != 0)
                        cb = FINISHED;
                    else if (lo == 0) // combine leftmost
                        cb = (SUMMED|FINISHED);
                    else
                        cb = SUMMED;
                    if (phaseUpdater.compareAndSet(this, b, b|cb))
                        break;
                }

                if (cb == SUMMED)
                    out = seqSum(array, lo, hi);
                else if (cb == FINISHED)
                    seqCumulate(array, lo, hi, in);
                else if (cb == (SUMMED|FINISHED))
                    out = seqCumulate(array, lo, hi, 0L);

                // propagate up
                Cumulater ch = this;
                Cumulater par = parent;
                for (;;) {
                    if (par == null) {
                        if ((cb & FINISHED) != 0)
                            ch.complete(null);
                        break;
                    }
                    int pb = par.phase;
                    if ((pb & cb & FINISHED) != 0) { // both finished
                        ch = par;
                        par = par.parent;
                    }
                    else if ((pb & cb & SUMMED) != 0) { // both summed
                        par.out = par.left.out + par.right.out;
                        int refork =
                            ((pb & CUMULATE) == 0 &&
                             par.lo == 0) ? CUMULATE : 0;
                        int nextPhase = pb|cb|refork;
                        if (pb == nextPhase ||
                            phaseUpdater.compareAndSet(par, pb, nextPhase)) {
                            if (refork != 0)
                                par.fork();
                            cb = SUMMED; // drop finished bit
                            ch = par;
                            par = par.parent;
                        }
                    }
                    else if (phaseUpdater.compareAndSet(par, pb, pb|cb))
                        break;
                }
            }
            return false;
        }

    }

}
Revision:	1.8
Committed:	Sun Oct 21 06:14:12 2012 UTC (11 years, 6 months ago) by jsr166
Branch:	MAIN
Changes since 1.7:	+0 -1 lines
Log Message:	delete trailing empty lines of javadoc
#	Content
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/publicdomain/zero/1.0/
5	*/
6
7	import java.util.*;
8	import java.util.concurrent.*;
9	import java.util.concurrent.atomic.*;
10
11	// parallel sums and cumulations
12
13	public class FJSums {
14	static final long NPS = (1000L * 1000 * 1000);
15	static int THRESHOLD;
16
17	public static void main(String[] args) throws Exception {
18	int procs = 0;
19	int n = 1 << 25;
20	int reps = 10;
21	try {
22	if (args.length > 0)
23	procs = Integer.parseInt(args[0]);
24	if (args.length > 1)
25	n = Integer.parseInt(args[1]);
26	if (args.length > 2)
27	reps = Integer.parseInt(args[2]);
28	}
29	catch (Exception e) {
30	System.out.println("Usage: java FJSums threads n reps");
31	return;
32	}
33	ForkJoinPool g = (procs == 0) ? new ForkJoinPool() :
34	new ForkJoinPool(procs);
35	System.out.println("Number of procs=" + g.getParallelism());
36	// for now hardwire Cumulate threshold to 8 * #CPUs leaf tasks
37	THRESHOLD = 1 + ((n + 7) >>> 3) / g.getParallelism();
38
39	long[] a = new long[n];
40	for (int i = 0; i < n; ++i)
41	a[i] = i;
42	long expected = ((long)n * (long)(n - 1)) / 2;
43	for (int i = 0; i < 2; ++i) {
44	System.out.print("Seq: ");
45	long last = System.nanoTime();
46	long ss = seqSum(a, 0, n);
47	double elapsed = elapsedTime(last);
48	System.out.printf("sum = %24d time: %7.3f\n", ss, elapsed);
49	if (ss != expected)
50	throw new Error("expected " + expected + " != " + ss);
51	}
52	for (int i = 0; i < reps; ++i) {
53	System.out.print("Par: ");
54	long last = System.nanoTime();
55	Summer s = new Summer(a, 0, a.length, null);
56	g.invoke(s);
57	long ss = s.result;
58	double elapsed = elapsedTime(last);
59	System.out.printf("sum = %24d time: %7.3f\n", ss, elapsed);
60	if (i == 0 && ss != expected)
61	throw new Error("expected " + expected + " != " + ss);
62	System.out.print("Cum: ");
63	last = System.nanoTime();
64	g.invoke(new Cumulater(null, a, 0, n));
65	long sc = a[n - 1];
66	elapsed = elapsedTime(last);
67	System.out.printf("sum = %24d time: %7.3f\n", ss, elapsed);
68	if (sc != ss)
69	throw new Error("expected " + ss + " != " + sc);
70	}
71	System.out.println(g);
72	g.shutdown();
73	}
74
75	static double elapsedTime(long startTime) {
76	return (double)(System.nanoTime() - startTime) / NPS;
77	}
78
79	static long seqSum(long[] array, int l, int h) {
80	long sum = 0;
81	for (int i = l; i < h; ++i)
82	sum += array[i];
83	return sum;
84	}
85
86	static long seqCumulate(long[] array, int lo, int hi, long base) {
87	long sum = base;
88	for (int i = lo; i < hi; ++i)
89	array[i] = sum += array[i];
90	return sum;
91	}
92
93	/**
94	* Adapted from Applyer demo in RecursiveAction docs
95	*/
96	static final class Summer extends RecursiveAction {
97	final long[] array;
98	final int lo, hi;
99	long result;
100	Summer next; // keeps track of right-hand-side tasks
101	Summer(long[] array, int lo, int hi, Summer next) {
102	this.array = array; this.lo = lo; this.hi = hi;
103	this.next = next;
104	}
105
106	protected void compute() {
107	int l = lo;
108	int h = hi;
109	Summer right = null;
110	while (h - l > 1 && getSurplusQueuedTaskCount() <= 3) {
111	int mid = (l + h) >>> 1;
112	right = new Summer(array, mid, h, right);
113	right.fork();
114	h = mid;
115	}
116	long sum = seqSum(array, l, h);
117	while (right != null) {
118	if (right.tryUnfork()) // directly calculate if not stolen
119	sum += seqSum(array, right.lo, right.hi);
120	else {
121	right.join();
122	sum += right.result;
123	}
124	right = right.next;
125	}
126	result = sum;
127	}
128	}
129
130	/**
131	* Cumulative scan, adapted from ParallelArray code
132	*
133	* A basic version of scan is straightforward.
134	* Keep dividing by two to threshold segment size, and then:
135	* Pass 1: Create tree of partial sums for each segment
136	* Pass 2: For each segment, cumulate with offset of left sibling
137	* See G. Blelloch's http://www.cs.cmu.edu/~scandal/alg/scan.html
138	*
139	* This version improves performance within FJ framework mainly by
140	* allowing second pass of ready left-hand sides to proceed even
141	* if some right-hand side first passes are still executing. It
142	* also combines first and second pass for leftmost segment, and
143	* for cumulate (not precumulate) also skips first pass for
144	* rightmost segment (whose result is not needed for second pass).
145	*
146	* To manage this, it relies on "phase" phase/state control field
147	* maintaining bits CUMULATE, SUMMED, and FINISHED. CUMULATE is
148	* main phase bit. When false, segments compute only their sum.
149	* When true, they cumulate array elements. CUMULATE is set at
150	* root at beginning of second pass and then propagated down. But
151	* it may also be set earlier for subtrees with lo==0 (the
152	* left spine of tree). SUMMED is a one bit join count. For leafs,
153	* set when summed. For internal nodes, becomes true when one
154	* child is summed. When second child finishes summing, it then
155	* moves up tree to trigger cumulate phase. FINISHED is also a one
156	* bit join count. For leafs, it is set when cumulated. For
157	* internal nodes, it becomes true when one child is cumulated.
158	* When second child finishes cumulating, it then moves up tree,
159	* executing complete() at the root.
160	*/
161	static final class Cumulater extends ForkJoinTask<Void> {
162	static final short CUMULATE = (short)1;
163	static final short SUMMED = (short)2;
164	static final short FINISHED = (short)4;
165
166	final Cumulater parent;
167	final long[] array;
168	Cumulater left, right;
169	final int lo;
170	final int hi;
171	volatile int phase; // phase/state
172	long in, out; // initially zero
173
174	static final AtomicIntegerFieldUpdater<Cumulater> phaseUpdater =
175	AtomicIntegerFieldUpdater.newUpdater(Cumulater.class, "phase");
176
177	Cumulater(Cumulater parent, long[] array, int lo, int hi) {
178	this.parent = parent;
179	this.array = array;
180	this.lo = lo;
181	this.hi = hi;
182	}
183
184	public final Void getRawResult() { return null; }
185	protected final void setRawResult(Void mustBeNull) { }
186
187	/** Returns true if can CAS CUMULATE bit true */
188	final boolean transitionToCumulate() {
189	int c;
190	while (((c = phase) & CUMULATE) == 0)
191	if (phaseUpdater.compareAndSet(this, c, c \| CUMULATE))
192	return true;
193	return false;
194	}
195
196	public final boolean exec() {
197	if (hi - lo > THRESHOLD) {
198	if (left == null) { // first pass
199	int mid = (lo + hi) >>> 1;
200	left = new Cumulater(this, array, lo, mid);
201	right = new Cumulater(this, array, mid, hi);
202	}
203
204	boolean cumulate = (phase & CUMULATE) != 0;
205	if (cumulate) {
206	long pin = in;
207	left.in = pin;
208	right.in = pin + left.out;
209	}
210
211	if (!cumulate \|\| right.transitionToCumulate())
212	right.fork();
213	if (!cumulate \|\| left.transitionToCumulate())
214	left.exec();
215	}
216	else {
217	int cb;
218	for (;;) { // Establish action: sum, cumulate, or both
219	int b = phase;
220	if ((b & FINISHED) != 0) // already done
221	return false;
222	if ((b & CUMULATE) != 0)
223	cb = FINISHED;
224	else if (lo == 0) // combine leftmost
225	cb = (SUMMED\|FINISHED);
226	else
227	cb = SUMMED;
228	if (phaseUpdater.compareAndSet(this, b, b\|cb))
229	break;
230	}
231
232	if (cb == SUMMED)
233	out = seqSum(array, lo, hi);
234	else if (cb == FINISHED)
235	seqCumulate(array, lo, hi, in);
236	else if (cb == (SUMMED\|FINISHED))
237	out = seqCumulate(array, lo, hi, 0L);
238
239	// propagate up
240	Cumulater ch = this;
241	Cumulater par = parent;
242	for (;;) {
243	if (par == null) {
244	if ((cb & FINISHED) != 0)
245	ch.complete(null);
246	break;
247	}
248	int pb = par.phase;
249	if ((pb & cb & FINISHED) != 0) { // both finished
250	ch = par;
251	par = par.parent;
252	}
253	else if ((pb & cb & SUMMED) != 0) { // both summed
254	par.out = par.left.out + par.right.out;
255	int refork =
256	((pb & CUMULATE) == 0 &&
257	par.lo == 0) ? CUMULATE : 0;
258	int nextPhase = pb\|cb\|refork;
259	if (pb == nextPhase \|\|
260	phaseUpdater.compareAndSet(par, pb, nextPhase)) {
261	if (refork != 0)
262	par.fork();
263	cb = SUMMED; // drop finished bit
264	ch = par;
265	par = par.parent;
266	}
267	}
268	else if (phaseUpdater.compareAndSet(par, pb, pb\|cb))
269	break;
270	}
271	}
272	return false;
273	}
274
275	}
276
277	}