test/loops/Integrate.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.concurrent.*;

/**
 * Sample program using Guassian Quadrature for numerical integration.
 * This version uses a simplified hardwired function.  Inspired by a
 * <A href="http://www.cs.uga.edu/~dkl/filaments/dist.html">
 * Filaments</A> demo program.
 * 
 */
public final class Integrate {

    static final double errorTolerance = 1.0e-12;
    /** for time conversion */
    static final long NPS = (1000L * 1000 * 1000);

    static final int SERIAL = -1;
    static final int DYNAMIC = 0;
    static final int FORK = 1;
    static int forkPolicy = DYNAMIC;
    static String forkArg = "dynamic";

    // the function to integrate
    static double computeFunction(double x)  {
        return (x * x + 1.0) * x;
    }

    static final double start = 0.0;
    static final double end = 1536.0;
    /* 
     * The number of recursive calls for 
     * integrate from start to end.
     * (Empirically determined)
     */
    static final int calls = 263479047;

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

        try {
            if (args.length > 0)
                procs = Integer.parseInt(args[0]);
            if (args.length > 1) {
                forkArg = args[1];
                if (forkArg.startsWith("s"))
                    forkPolicy = SERIAL;
                else if (forkArg.startsWith("f"))
                    forkPolicy = FORK;
            }
        }
        catch (Exception e) {
            System.out.println("Usage: java Integrate3 threads <s[erial] | d[ynamic] | f[ork] - default d>");
            return;
        }
        oneTest(procs);
        oneTest(procs);
        oneTest(procs);
    }

    static void oneTest(int procs) {
        ForkJoinPool g = procs == 0? new ForkJoinPool() : 
            new ForkJoinPool(procs);
        System.out.println("Number of procs=" + g.getParallelism());
        System.out.println("Integrating from " + start + " to " + end + 
                           " forkPolicy = " + forkArg);
        long lastTime = System.nanoTime();
        for (int i = 0; i < 20; ++i) {
            double a;
            if (forkPolicy == SERIAL)
                a = SQuad.computeArea(g, start, end);
            else if (forkPolicy == FORK) 
                a = FQuad.computeArea(g, start, end);
            else
                a = DQuad.computeArea(g, start, end);
            long now = System.nanoTime();
            double s = ((double)(now - lastTime))/NPS;
            lastTime = now;
            System.out.printf("Calls/sec: %12d", (long) (calls / s));
            System.out.printf(" Time: %7.3f", s);
            System.out.printf(" Threads: %5d", g.getPoolSize());
            //            System.out.printf(" Area: %12.1f", a);
            System.out.println();
        }
        System.out.println(g);
        g.shutdown();
    }


    // Sequential version
    static final class SQuad extends RecursiveAction {
        static double computeArea(ForkJoinPool pool, double l, double r) {
            SQuad q = new SQuad(l, r, 0);
            pool.invoke(q);
            return q.area;
        }

        final double left;       // lower bound
        final double right;      // upper bound
        double area;
        
        SQuad(double l, double r, double a) {
            this.left = l; this.right = r; this.area = a;
        }
        
        public final void compute() {
            double l = left;
            double r = right;
            area = recEval(l, r, (l * l + 1.0) * l, (r * r + 1.0) * r, area);
        }
        
        static final double recEval(double l, double r, double fl,
                                    double fr, double a) {
            double h = (r - l) * 0.5;
            double c = l + h;
            double fc = (c * c + 1.0) * c; 
            double hh = h * 0.5;
            double al = (fl + fc) * hh; 
            double ar = (fr + fc) * hh;
            double alr = al + ar;
            if (Math.abs(alr - a) <= errorTolerance)
                return alr;
            else
                return recEval(c, r, fc, fr, ar) + recEval(l, c, fl, fc, al);
        }

    }

    //....................................

    // ForkJoin version
    static final class FQuad extends RecursiveAction {
        static double computeArea(ForkJoinPool pool, double l, double r) {
            FQuad q = new FQuad(l, r, 0);
            pool.invoke(q);
            return q.area;
        }

        final double left;       // lower bound
        final double right;      // upper bound
        double area;
        
        FQuad(double l, double r, double a) {
            this.left = l; this.right = r; this.area = a;
        }
        
        public final void compute() {
            double l = left;
            double r = right;
            area = recEval(l, r, (l * l + 1.0) * l, (r * r + 1.0) * r, area);
        }
        
        static final double recEval(double l, double r, double fl,
                                    double fr, double a) {
            double h = (r - l) * 0.5;
            double c = l + h;
            double fc = (c * c + 1.0) * c; 
            double hh = h * 0.5;
            double al = (fl + fc) * hh; 
            double ar = (fr + fc) * hh;
            double alr = al + ar;
            if (Math.abs(alr - a) <= errorTolerance)
                return alr;
            FQuad q = new FQuad(l, c, al);
            q.fork();
            ar = recEval(c, r, fc, fr, ar);
            if (!q.tryUnfork()) {
                //                q.quietlyHelpJoin();
                q.quietlyJoin();
                return ar + q.area;
            }
            return ar + recEval(l, c, fl, fc, al);
        }

    }

    // ...........................

    // Version using on-demand Fork 
    static final class DQuad extends RecursiveAction {
        static double computeArea(ForkJoinPool pool, double l, double r) {
            DQuad q = new DQuad(l, r, 0);
            pool.invoke(q);
            return q.area;
        }

        final double left;       // lower bound
        final double right;      // upper bound
        double area;
        
        DQuad(double l, double r, double a) {
            this.left = l; this.right = r; this.area = a;
        }
        
        public final void compute() {
            double l = left;
            double r = right;
            area = recEval(l, r, (l * l + 1.0) * l, (r * r + 1.0) * r, area);
        }
        
        static final double recEval(double l, double r, double fl,
                                    double fr, double a) {
            double h = (r - l) * 0.5;
            double c = l + h;
            double fc = (c * c + 1.0) * c; 
            double hh = h * 0.5;
            double al = (fl + fc) * hh; 
            double ar = (fr + fc) * hh;
            double alr = al + ar;
            if (Math.abs(alr - a) <= errorTolerance)
                return alr;
            DQuad q = null;
            if (getSurplusQueuedTaskCount() <= 3)
                (q = new DQuad(l, c, al)).fork();
            ar = recEval(c, r, fc, fr, ar);
            if (q != null && !q.tryUnfork()) {
                //                q.quietlyHelpJoin();
                q.quietlyJoin();
                return ar + q.area;
            }
            return ar + recEval(l, c, fl, fc, al);
        }

    }

}

  
Revision:	1.8
Committed:	Sun Sep 19 12:55:37 2010 UTC (13 years, 8 months ago) by dl
Branch:	MAIN
Changes since 1.7:	+40 -28 lines
Log Message:	Add and update FJ and Queue tests
#	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/licenses/publicdomain
5	*/
6
7	import java.util.concurrent.*;
8
9	/**
10	* Sample program using Guassian Quadrature for numerical integration.
11	* This version uses a simplified hardwired function. Inspired by a
12	* <A href="http://www.cs.uga.edu/~dkl/filaments/dist.html">
13	* Filaments</A> demo program.
14	*
15	*/
16	public final class Integrate {
17
18	static final double errorTolerance = 1.0e-12;
19	/** for time conversion */
20	static final long NPS = (1000L * 1000 * 1000);
21
22	static final int SERIAL = -1;
23	static final int DYNAMIC = 0;
24	static final int FORK = 1;
25	static int forkPolicy = DYNAMIC;
26	static String forkArg = "dynamic";
27
28	// the function to integrate
29	static double computeFunction(double x) {
30	return (x * x + 1.0) * x;
31	}
32
33	static final double start = 0.0;
34	static final double end = 1536.0;
35	/*
36	* The number of recursive calls for
37	* integrate from start to end.
38	* (Empirically determined)
39	*/
40	static final int calls = 263479047;
41
42	public static void main(String[] args) throws Exception {
43	int procs = 0;
44
45	try {
46	if (args.length > 0)
47	procs = Integer.parseInt(args[0]);
48	if (args.length > 1) {
49	forkArg = args[1];
50	if (forkArg.startsWith("s"))
51	forkPolicy = SERIAL;
52	else if (forkArg.startsWith("f"))
53	forkPolicy = FORK;
54	}
55	}
56	catch (Exception e) {
57	System.out.println("Usage: java Integrate3 threads <s[erial] \| d[ynamic] \| f[ork] - default d>");
58	return;
59	}
60	oneTest(procs);
61	oneTest(procs);
62	oneTest(procs);
63	}
64
65	static void oneTest(int procs) {
66	ForkJoinPool g = procs == 0? new ForkJoinPool() :
67	new ForkJoinPool(procs);
68	System.out.println("Number of procs=" + g.getParallelism());
69	System.out.println("Integrating from " + start + " to " + end +
70	" forkPolicy = " + forkArg);
71	long lastTime = System.nanoTime();
72	for (int i = 0; i < 20; ++i) {
73	double a;
74	if (forkPolicy == SERIAL)
75	a = SQuad.computeArea(g, start, end);
76	else if (forkPolicy == FORK)
77	a = FQuad.computeArea(g, start, end);
78	else
79	a = DQuad.computeArea(g, start, end);
80	long now = System.nanoTime();
81	double s = ((double)(now - lastTime))/NPS;
82	lastTime = now;
83	System.out.printf("Calls/sec: %12d", (long) (calls / s));
84	System.out.printf(" Time: %7.3f", s);
85	System.out.printf(" Threads: %5d", g.getPoolSize());
86	// System.out.printf(" Area: %12.1f", a);
87	System.out.println();
88	}
89	System.out.println(g);
90	g.shutdown();
91	}
92
93
94	// Sequential version
95	static final class SQuad extends RecursiveAction {
96	static double computeArea(ForkJoinPool pool, double l, double r) {
97	SQuad q = new SQuad(l, r, 0);
98	pool.invoke(q);
99	return q.area;
100	}
101
102	final double left; // lower bound
103	final double right; // upper bound
104	double area;
105
106	SQuad(double l, double r, double a) {
107	this.left = l; this.right = r; this.area = a;
108	}
109
110	public final void compute() {
111	double l = left;
112	double r = right;
113	area = recEval(l, r, (l * l + 1.0) * l, (r * r + 1.0) * r, area);
114	}
115
116	static final double recEval(double l, double r, double fl,
117	double fr, double a) {
118	double h = (r - l) * 0.5;
119	double c = l + h;
120	double fc = (c * c + 1.0) * c;
121	double hh = h * 0.5;
122	double al = (fl + fc) * hh;
123	double ar = (fr + fc) * hh;
124	double alr = al + ar;
125	if (Math.abs(alr - a) <= errorTolerance)
126	return alr;
127	else
128	return recEval(c, r, fc, fr, ar) + recEval(l, c, fl, fc, al);
129	}
130
131	}
132
133	//....................................
134
135	// ForkJoin version
136	static final class FQuad extends RecursiveAction {
137	static double computeArea(ForkJoinPool pool, double l, double r) {
138	FQuad q = new FQuad(l, r, 0);
139	pool.invoke(q);
140	return q.area;
141	}
142
143	final double left; // lower bound
144	final double right; // upper bound
145	double area;
146
147	FQuad(double l, double r, double a) {
148	this.left = l; this.right = r; this.area = a;
149	}
150
151	public final void compute() {
152	double l = left;
153	double r = right;
154	area = recEval(l, r, (l * l + 1.0) * l, (r * r + 1.0) * r, area);
155	}
156
157	static final double recEval(double l, double r, double fl,
158	double fr, double a) {
159	double h = (r - l) * 0.5;
160	double c = l + h;
161	double fc = (c * c + 1.0) * c;
162	double hh = h * 0.5;
163	double al = (fl + fc) * hh;
164	double ar = (fr + fc) * hh;
165	double alr = al + ar;
166	if (Math.abs(alr - a) <= errorTolerance)
167	return alr;
168	FQuad q = new FQuad(l, c, al);
169	q.fork();
170	ar = recEval(c, r, fc, fr, ar);
171	if (!q.tryUnfork()) {
172	// q.quietlyHelpJoin();
173	q.quietlyJoin();
174	return ar + q.area;
175	}
176	return ar + recEval(l, c, fl, fc, al);
177	}
178
179	}
180
181	// ...........................
182
183	// Version using on-demand Fork
184	static final class DQuad extends RecursiveAction {
185	static double computeArea(ForkJoinPool pool, double l, double r) {
186	DQuad q = new DQuad(l, r, 0);
187	pool.invoke(q);
188	return q.area;
189	}
190
191	final double left; // lower bound
192	final double right; // upper bound
193	double area;
194
195	DQuad(double l, double r, double a) {
196	this.left = l; this.right = r; this.area = a;
197	}
198
199	public final void compute() {
200	double l = left;
201	double r = right;
202	area = recEval(l, r, (l * l + 1.0) * l, (r * r + 1.0) * r, area);
203	}
204
205	static final double recEval(double l, double r, double fl,
206	double fr, double a) {
207	double h = (r - l) * 0.5;
208	double c = l + h;
209	double fc = (c * c + 1.0) * c;
210	double hh = h * 0.5;
211	double al = (fl + fc) * hh;
212	double ar = (fr + fc) * hh;
213	double alr = al + ar;
214	if (Math.abs(alr - a) <= errorTolerance)
215	return alr;
216	DQuad q = null;
217	if (getSurplusQueuedTaskCount() <= 3)
218	(q = new DQuad(l, c, al)).fork();
219	ar = recEval(c, r, fc, fr, ar);
220	if (q != null && !q.tryUnfork()) {
221	// q.quietlyHelpJoin();
222	q.quietlyJoin();
223	return ar + q.area;
224	}
225	return ar + recEval(l, c, fl, fc, al);
226	}
227
228	}
229
230	}
231
232