Parallel Matrix Multiplication in Java 6

Question

Yesterday I asked a question about parallel matrix multiplication in Java 7 using the fork/join framework here. With the help of axtavt I got my example program to work. Now I’m implementing an equivalent program using Java 6 functionality only. I get the same problem as yesterday, dispite applying the the feedback axtavt gave me (I think). Am I overlooking something? Code: ``` package algorithms; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class Java6MatrixMultiply implements Algorithm { private static final int SIZE = 1024; private static final int THRESHOLD = 64; private static final int MAX_THREADS = Runtime.getRuntime().availableProcessors(); private final ExecutorService executor = Executors.newFixedThreadPool(MAX_THREADS); private float[][] a = new float[SIZE][SIZE]; private float[][] b = new float[SIZE][SIZE]; private float[][] c = new float[SIZE][SIZE]; @Override public void initialize() { in…

Accepted Answer

After reading this this question I decided to adapt my program. My new program works very well without synchronization. Thanks for your thoughts Peter.

New code:

```
package algorithms;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class Java6MatrixMultiply implements Algorithm {

private static final int SIZE = 2048;
    private static final int THRESHOLD = 64;
    private static final int MAX_THREADS = Runtime.getRuntime().availableProcessors();

private final ExecutorService executor = Executors.newFixedThreadPool(MAX_THREADS);

private float[][] a = new float[SIZE][SIZE];
    private float[][] b = new float[SIZE][SIZE];
    private float[][] c = new float[SIZE][SIZE];

@Override
    public void initialize() {
        init(a, b, SIZE);
    }

@Override
    public void execute() {
        MatrixMultiplyTask mainTask =  new MatrixMultiplyTask(a, 0, 0, b, 0, 0, c, 0, 0, SIZE);
        Future future = executor.submit(mainTask);

try {
            future.get();
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }

@Override
    public void printResult() {
        check(c, SIZE);

for (int i = 0; i < SIZE && i <= 10; i++) {
            for (int j = 0; j < SIZE && j <= 10; j++) {         
                if(j == 10) {
                    System.out.print("...");
                }
                else {
                    System.out.print(c[i][j] + " ");
                }
            }

if(i == 10) {
                System.out.println();
                for(int k = 0; k < 10; k++) System.out.print(" ... ");
            }

System.out.println();
        }

System.out.println();
    }

// To simplify checking, fill with all 1's. Answer should be all n's.
    static void init(float[][] a, float[][] b, int n) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                a[i][j] = 1.0F;
                b[i][j] = 1.0F;
            }
        }
    }

static void check(float[][] c, int n) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (c[i][j] != n) {
                    throw new Error("Check Failed at [" + i + "][" + j + "]: " + c[i][j]);
                    //System.out.println("Check Failed at [" + i + "][" + j + "]: " + c[i][j]); 
                }
            }
        }       
    }

public class Seq implements Runnable {

private final MatrixMultiplyTask a;
        private final MatrixMultiplyTask b;

public Seq(MatrixMultiplyTask a, MatrixMultiplyTask b) {
            this.a = a;
            this.b = b;     
        }

public void run() {
            a.run();
            b.run();
        }   
    }

private class MatrixMultiplyTask implements Runnable {
        private final float[][] A; // Matrix A
        private final int aRow; // first row of current quadrant of A
        private final int aCol; // first column of current quadrant of A

private final float[][] B; // Similarly for B
        private final int bRow;
        private final int bCol;

private final float[][] C; // Similarly for result matrix C
        private final int cRow;
        private final int cCol;

private final int size;

public MatrixMultiplyTask(float[][] A, int aRow, int aCol, float[][] B,
                int bRow, int bCol, float[][] C, int cRow, int cCol, int size) {

this.A = A;
            this.aRow = aRow;
            this.aCol = aCol;
            this.B = B;
            this.bRow = bRow;
            this.bCol = bCol;
            this.C = C;
            this.cRow = cRow;
            this.cCol = cCol;
            this.size = size;
        }

public void run() {

//System.out.println("Thread: " + Thread.currentThread().getName());

if (size <= THRESHOLD) {
                multiplyStride2();
            } else {

int h = size / 2;

Seq seq1 = new Seq(new MatrixMultiplyTask(A,
                                aRow, aCol, // A11
                                B, bRow, bCol, // B11
                                C, cRow, cCol, // C11
                                h),

new MatrixMultiplyTask(A, aRow, aCol + h, // A12
                                B, bRow + h, bCol, // B21
                                C, cRow, cCol, // C11
                                h));

Seq seq2 = new Seq(new MatrixMultiplyTask(A,
                                aRow, aCol, // A11
                                B, bRow, bCol + h, // B12
                                C, cRow, cCol + h, // C12
                                h),

new MatrixMultiplyTask(A, aRow, aCol + h, // A1…

Parallel Matrix Multiplication in Java 6

Solution

Problem