test/loops/ThreadPhaserJacobi.java

// Barrier version of Jacobi iteration

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

public class ThreadPhaserJacobi {

    static final int nprocs = Runtime.getRuntime().availableProcessors();

    /** 
     * The maximum submatrix length (both row-wise and column-wise)
     * for any Segment
     **/

    static final double EPSILON = 0.0001;  // convergence criterion

    static int dimGran;

    public static void main(String[] args) throws Exception {
        int n = 2048;
        int steps = 1000;
        try {
            if (args.length > 0)
                n = Integer.parseInt(args[0]);
            if (args.length > 1)
                steps = Integer.parseInt(args[1]);
        }
      
        catch (Exception e) {
            System.out.println("Usage: java ThreadPhaserJacobi <matrix size> <max steps>");
            return;
        }

        int granularity = n * n / nprocs;
        dimGran = (int)(Math.sqrt(granularity));

        // allocate enough space for edges
        int dim = n+2;
        int ncells = dim * dim;
        double[][] a = new double[dim][dim];
        double[][] b = new double[dim][dim];
        // Initialize interiors to small value
        double smallVal = 1.0/dim; 
        for (int i = 1; i < dim-1; ++i) {
            for (int j = 1; j < dim-1; ++j)
                a[i][j] = smallVal;
        }
      
        int nreps = 3;
        for (int rep = 0; rep < nreps; ++rep) {
            // Fill all edges with 1's.
            for (int k = 0; k < dim; ++k) {
                a[k][0] += 1.0;
                a[k][n+1] += 1.0;
                a[0][k] += 1.0;
                a[n+1][k] += 1.0;
            }
            Driver driver = new Driver(a, b, 1, n, 1, n, steps);
            long startTime = System.currentTimeMillis();
            driver.compute();
          
            long time = System.currentTimeMillis() - startTime;
            double secs = ((double)time) / 1000.0;
          
            System.out.println("Compute Time: " + secs);
        }
    }

    static class Segment implements Runnable {

        double[][] A; // matrix to get old values from
        double[][] B; // matrix to put new values into

        // indices of current submatrix
        final int loRow;   
        final int hiRow;
        final int loCol;
        final int hiCol;
        final int steps;
        final Phaser barrier;
        double maxDiff; // maximum difference between old and new values

        Segment(double[][] A, double[][] B, 
                int loRow, int hiRow,
                int loCol, int hiCol,
                int steps,
                Phaser barrier) {
            this.A = A;   this.B = B;
            this.loRow = loRow; this.hiRow = hiRow;
            this.loCol = loCol; this.hiCol = hiCol;
            this.steps = steps;
            this.barrier = barrier;
            barrier.register();
        }


        public void run() {
            try {
                double[][] a = A;
                double[][] b = B;
        
                for (int i = 0; i < steps; ++i) {
                    maxDiff = update(a, b);
                    if (barrier.awaitAdvance(barrier.arrive()) < 0)
                        break;
                    double[][] tmp = a; a = b; b = tmp;
                }
            }
            catch(Exception ex) { 
                ex.printStackTrace();
                return;
            }
        }

        double update(double[][] a, double[][] b) {
            double md = 0.0; // local for computing max diff

            for (int i = loRow; i <= hiRow; ++i) {
                for (int j = loCol; j <= hiCol; ++j) {
                    double v = 0.25 * (a[i-1][j] + a[i][j-1] +
                                       a[i+1][j] + a[i][j+1]);
                    b[i][j] = v;

                    double diff = v - a[i][j];
                    if (diff < 0) diff = -diff;
                    if (diff > md) md = diff;
                }
            }

            return md;
        }
        
    }
        

    static class Driver { 
        double[][] A; // matrix to get old values from
        double[][] B; // matrix to put new values into

        final int loRow;   // indices of current submatrix
        final int hiRow;
        final int loCol;
        final int hiCol;
        final int steps;
        Segment[] allSegments;

        Driver(double[][] mat1, double[][] mat2, 
               int firstRow, int lastRow,
               int firstCol, int lastCol,
               int steps) {
      
            this.A = mat1;   this.B = mat2;
            this.loRow = firstRow; this.hiRow = lastRow;
            this.loCol = firstCol; this.hiCol = lastCol;
            this.steps = steps;

            int rows = hiRow - loRow + 1;
            int cols = hiCol - loCol + 1;
            int rblocks = (int)(Math.round((float)rows / dimGran));
            int cblocks = (int)(Math.round((float)cols / dimGran));
            
            int n = rblocks * cblocks;
            
            Segment[] segs = new Segment[n];
            Phaser barrier = new Phaser();
            int k = 0;
            for (int i = 0; i < rblocks; ++i) {
                int lr = loRow + i * dimGran;
                int hr = lr + dimGran;
                if (i == rblocks-1) hr = hiRow;
                
                for (int j = 0; j < cblocks; ++j) {
                    int lc = loCol + j * dimGran;
                    int hc = lc + dimGran;
                    if (j == cblocks-1) hc = hiCol;
                    
                    segs[k] = new Segment(A, B, lr, hr, lc, hc, steps, barrier);
                    ++k;
                }
            }
            System.out.println("Using " + n + " segments (threads)");
            allSegments = segs;
        }

        public void compute() throws InterruptedException {
            Segment[] segs = allSegments;
            int n = segs.length;
            Thread[] threads = new Thread[n];

            for (int k = 0; k < n; ++k) threads[k] = new Thread(segs[k]);
            for (int k = 0; k < n; ++k) threads[k].start();
            for (int k = 0; k < n; ++k) threads[k].join();

            double maxd = 0;
            for (int k = 0; k < n; ++k) {
                double md = segs[k].maxDiff;
                if (md > maxd) maxd = md;
            }

            System.out.println("Max diff after " + steps + " steps = " + maxd);
        }
    }


}
Revision:	1.1
Committed:	Fri Oct 23 19:57:07 2009 UTC (14 years, 6 months ago) by dl
Branch:	MAIN
Log Message:	Update misc tests for JDK7
#	User	Rev	Content
1	dl	1.1	// Barrier version of Jacobi iteration
2
3			import java.util.*;
4			import java.util.concurrent.*;
5			//import jsr166y.*;
6
7			public class ThreadPhaserJacobi {
8
9			static final int nprocs = Runtime.getRuntime().availableProcessors();
10
11			/**
12			* The maximum submatrix length (both row-wise and column-wise)
13			* for any Segment
14			**/
15
16			static final double EPSILON = 0.0001; // convergence criterion
17
18			static int dimGran;
19
20			public static void main(String[] args) throws Exception {
21			int n = 2048;
22			int steps = 1000;
23			try {
24			if (args.length > 0)
25			n = Integer.parseInt(args[0]);
26			if (args.length > 1)
27			steps = Integer.parseInt(args[1]);
28			}
29
30			catch (Exception e) {
31			System.out.println("Usage: java ThreadPhaserJacobi <matrix size> <max steps>");
32			return;
33			}
34
35			int granularity = n * n / nprocs;
36			dimGran = (int)(Math.sqrt(granularity));
37
38			// allocate enough space for edges
39			int dim = n+2;
40			int ncells = dim * dim;
41			double[][] a = new double[dim][dim];
42			double[][] b = new double[dim][dim];
43			// Initialize interiors to small value
44			double smallVal = 1.0/dim;
45			for (int i = 1; i < dim-1; ++i) {
46			for (int j = 1; j < dim-1; ++j)
47			a[i][j] = smallVal;
48			}
49
50			int nreps = 3;
51			for (int rep = 0; rep < nreps; ++rep) {
52			// Fill all edges with 1's.
53			for (int k = 0; k < dim; ++k) {
54			a[k][0] += 1.0;
55			a[k][n+1] += 1.0;
56			a[0][k] += 1.0;
57			a[n+1][k] += 1.0;
58			}
59			Driver driver = new Driver(a, b, 1, n, 1, n, steps);
60			long startTime = System.currentTimeMillis();
61			driver.compute();
62
63			long time = System.currentTimeMillis() - startTime;
64			double secs = ((double)time) / 1000.0;
65
66			System.out.println("Compute Time: " + secs);
67			}
68			}
69
70			static class Segment implements Runnable {
71
72			double[][] A; // matrix to get old values from
73			double[][] B; // matrix to put new values into
74
75			// indices of current submatrix
76			final int loRow;
77			final int hiRow;
78			final int loCol;
79			final int hiCol;
80			final int steps;
81			final Phaser barrier;
82			double maxDiff; // maximum difference between old and new values
83
84			Segment(double[][] A, double[][] B,
85			int loRow, int hiRow,
86			int loCol, int hiCol,
87			int steps,
88			Phaser barrier) {
89			this.A = A; this.B = B;
90			this.loRow = loRow; this.hiRow = hiRow;
91			this.loCol = loCol; this.hiCol = hiCol;
92			this.steps = steps;
93			this.barrier = barrier;
94			barrier.register();
95			}
96
97
98			public void run() {
99			try {
100			double[][] a = A;
101			double[][] b = B;
102
103			for (int i = 0; i < steps; ++i) {
104			maxDiff = update(a, b);
105			if (barrier.awaitAdvance(barrier.arrive()) < 0)
106			break;
107			double[][] tmp = a; a = b; b = tmp;
108			}
109			}
110			catch(Exception ex) {
111			ex.printStackTrace();
112			return;
113			}
114			}
115
116			double update(double[][] a, double[][] b) {
117			double md = 0.0; // local for computing max diff
118
119			for (int i = loRow; i <= hiRow; ++i) {
120			for (int j = loCol; j <= hiCol; ++j) {
121			double v = 0.25 * (a[i-1][j] + a[i][j-1] +
122			a[i+1][j] + a[i][j+1]);
123			b[i][j] = v;
124
125			double diff = v - a[i][j];
126			if (diff < 0) diff = -diff;
127			if (diff > md) md = diff;
128			}
129			}
130
131			return md;
132			}
133
134			}
135
136
137			static class Driver {
138			double[][] A; // matrix to get old values from
139			double[][] B; // matrix to put new values into
140
141			final int loRow; // indices of current submatrix
142			final int hiRow;
143			final int loCol;
144			final int hiCol;
145			final int steps;
146			Segment[] allSegments;
147
148			Driver(double[][] mat1, double[][] mat2,
149			int firstRow, int lastRow,
150			int firstCol, int lastCol,
151			int steps) {
152
153			this.A = mat1; this.B = mat2;
154			this.loRow = firstRow; this.hiRow = lastRow;
155			this.loCol = firstCol; this.hiCol = lastCol;
156			this.steps = steps;
157
158			int rows = hiRow - loRow + 1;
159			int cols = hiCol - loCol + 1;
160			int rblocks = (int)(Math.round((float)rows / dimGran));
161			int cblocks = (int)(Math.round((float)cols / dimGran));
162
163			int n = rblocks * cblocks;
164
165			Segment[] segs = new Segment[n];
166			Phaser barrier = new Phaser();
167			int k = 0;
168			for (int i = 0; i < rblocks; ++i) {
169			int lr = loRow + i * dimGran;
170			int hr = lr + dimGran;
171			if (i == rblocks-1) hr = hiRow;
172
173			for (int j = 0; j < cblocks; ++j) {
174			int lc = loCol + j * dimGran;
175			int hc = lc + dimGran;
176			if (j == cblocks-1) hc = hiCol;
177
178			segs[k] = new Segment(A, B, lr, hr, lc, hc, steps, barrier);
179			++k;
180			}
181			}
182			System.out.println("Using " + n + " segments (threads)");
183			allSegments = segs;
184			}
185
186			public void compute() throws InterruptedException {
187			Segment[] segs = allSegments;
188			int n = segs.length;
189			Thread[] threads = new Thread[n];
190
191			for (int k = 0; k < n; ++k) threads[k] = new Thread(segs[k]);
192			for (int k = 0; k < n; ++k) threads[k].start();
193			for (int k = 0; k < n; ++k) threads[k].join();
194
195			double maxd = 0;
196			for (int k = 0; k < n; ++k) {
197			double md = segs[k].maxDiff;
198			if (md > maxd) maxd = md;
199			}
200
201			System.out.println("Max diff after " + steps + " steps = " + maxd);
202			}
203			}
204
205
206			}