test/extra166y/DoubleCumulateDemo.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 jsr166y.*;
import extra166y.*;
import static extra166y.Ops.*;
import java.util.*;
import java.util.concurrent.*;

public class DoubleCumulateDemo {
    static final int NCPU = Runtime.getRuntime().availableProcessors();
    /** for time conversion */
    static final long NPS = (1000L * 1000 * 1000);

    static boolean check = false; // true;

    public static void main(String[] args) throws Exception {
        check = args.length > 0;
        int n = 1 << 19;
        int reps = 1 << 9;
        int tests = 4;
        double[] array = new double[n];
        long last, now;
        double elapsed;

        for (int j = 0; j < tests; ++j) {
            fill(array);
            last = System.nanoTime();
            for (int k = 0; k < reps; ++k) {
                seqCumulate(array);
                if (k == 0 && check)
                    check(array);
            }
            now = System.nanoTime();
            elapsed = (double)(now - last) / (NPS);
            System.out.printf("seq  :  %9.5f\n", elapsed);
        }

        for (int sweeps = 0; sweeps < 2; ++sweeps) {
            for (int i = 2; i <= NCPU; i <<= 1) {
                ForkJoinPool fjp = new ForkJoinPool(i);
                oneRun(fjp, array, i, reps, tests);
                fjp.shutdown();
            }
            for (int i = NCPU; i >= 1; i >>>= 1) {
                ForkJoinPool fjp = new ForkJoinPool(i);
                oneRun(fjp, array, i, reps, tests);
                fjp.shutdown();
            }
        }
    }

    static void oneRun(ForkJoinPool fjp,
                       double[] array, int nthreads,
                       int reps, int tests) throws Exception {
        ParallelDoubleArray pa = ParallelDoubleArray.createUsingHandoff(array, fjp);
        long last, now;
        long steals = fjp.getStealCount();
        //        long syncs = fjp.getSyncCount();
        for (int j = 0; j < tests; ++j) {
            fill(array);
            last = System.nanoTime();
            for (int k = 0; k < reps; ++k) {
                pa.cumulateSum();
                if (k == 0 && check)
                    check(array);
            }
            now = System.nanoTime();
            double elapsed = (double)(now - last) / (NPS);
            last = now;
            long sc = fjp.getStealCount();
            long scount = (sc - steals) / reps;
            steals = sc;
            //            long tc = fjp.getSyncCount();
            //            long tcount = (tc - syncs) / reps;
            //            syncs = tc;

            //            System.out.printf("ps %2d:  %9.5f Steals:%6d Syncs %6d\n", nthreads, elapsed, scount, tcount);
            System.out.printf("ps %2d:  %9.5f Steals:%6d\n", nthreads, elapsed, scount);
        }
        Thread.sleep(100);
    }

    static void check(double[] array) {
        for (int i = 0; i < array.length; ++i) {
            double sum = i + 1;
            if (array[i] != sum) {
                System.out.println("i: " + i + " sum: " + sum + " element:" + array[i]);
                throw new Error();
            }
        }
        //        System.out.print("*");
    }

    static void fill(double[] array) {
        for (int i = 0; i < array.length; ++i)
            array[i] = 1;
    }

    static double seqCumulate(double[] array) {
        double sum = 0;
        for (int i = 0; i < array.length; ++i)
            sum = array[i] += sum;
        return sum;
    }
}
Revision:	1.4
Committed:	Tue Mar 15 19:47:04 2011 UTC (13 years, 1 month ago) by jsr166
Branch:	MAIN
CVS Tags:	release-1_7_0, HEAD
Changes since 1.3:	+1 -1 lines
Log Message:	Update Creative Commons license URL in legal notices
#	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
8			import jsr166y.*;
9			import extra166y.*;
10			import static extra166y.Ops.*;
11			import java.util.*;
12			import java.util.concurrent.*;
13
14			public class DoubleCumulateDemo {
15			static final int NCPU = Runtime.getRuntime().availableProcessors();
16			/** for time conversion */
17			static final long NPS = (1000L * 1000 * 1000);
18
19			static boolean check = false; // true;
20
21			public static void main(String[] args) throws Exception {
22			check = args.length > 0;
23			int n = 1 << 19;
24			int reps = 1 << 9;
25			int tests = 4;
26			double[] array = new double[n];
27			long last, now;
28			double elapsed;
29
30			for (int j = 0; j < tests; ++j) {
31			fill(array);
32			last = System.nanoTime();
33			for (int k = 0; k < reps; ++k) {
34			seqCumulate(array);
35			if (k == 0 && check)
36			check(array);
37			}
38			now = System.nanoTime();
39			elapsed = (double)(now - last) / (NPS);
40			System.out.printf("seq : %9.5f\n", elapsed);
41			}
42
43	dl	1.3	for (int sweeps = 0; sweeps < 2; ++sweeps) {
44			for (int i = 2; i <= NCPU; i <<= 1) {
45			ForkJoinPool fjp = new ForkJoinPool(i);
46			oneRun(fjp, array, i, reps, tests);
47			fjp.shutdown();
48			}
49			for (int i = NCPU; i >= 1; i >>>= 1) {
50			ForkJoinPool fjp = new ForkJoinPool(i);
51			oneRun(fjp, array, i, reps, tests);
52			fjp.shutdown();
53			}
54	dl	1.1	}
55			}
56
57	jsr166	1.2	static void oneRun(ForkJoinPool fjp,
58			double[] array, int nthreads,
59	dl	1.1	int reps, int tests) throws Exception {
60			ParallelDoubleArray pa = ParallelDoubleArray.createUsingHandoff(array, fjp);
61			long last, now;
62			long steals = fjp.getStealCount();
63			// long syncs = fjp.getSyncCount();
64			for (int j = 0; j < tests; ++j) {
65			fill(array);
66			last = System.nanoTime();
67			for (int k = 0; k < reps; ++k) {
68			pa.cumulateSum();
69			if (k == 0 && check)
70			check(array);
71			}
72			now = System.nanoTime();
73			double elapsed = (double)(now - last) / (NPS);
74			last = now;
75			long sc = fjp.getStealCount();
76			long scount = (sc - steals) / reps;
77			steals = sc;
78			// long tc = fjp.getSyncCount();
79			// long tcount = (tc - syncs) / reps;
80			// syncs = tc;
81
82			// System.out.printf("ps %2d: %9.5f Steals:%6d Syncs %6d\n", nthreads, elapsed, scount, tcount);
83			System.out.printf("ps %2d: %9.5f Steals:%6d\n", nthreads, elapsed, scount);
84			}
85			Thread.sleep(100);
86			}
87
88			static void check(double[] array) {
89			for (int i = 0; i < array.length; ++i) {
90			double sum = i + 1;
91			if (array[i] != sum) {
92			System.out.println("i: " + i + " sum: " + sum + " element:" + array[i]);
93			throw new Error();
94			}
95			}
96			// System.out.print("*");
97			}
98
99			static void fill(double[] array) {
100			for (int i = 0; i < array.length; ++i)
101			array[i] = 1;
102			}
103
104			static double seqCumulate(double[] array) {
105			double sum = 0;
106			for (int i = 0; i < array.length; ++i)
107			sum = array[i] += sum;
108			return sum;
109			}
110			}