start of new file

[IRC.git] / Robust / src / Benchmarks / Prefetch / MatrixMultiply / MatrixMultiply.java

diff --git a/Robust/src/Benchmarks/Prefetch/MatrixMultiply/MatrixMultiply.java b/Robust/src/Benchmarks/Prefetch/MatrixMultiply/MatrixMultiply.java
index f35dbb25d79b0200dc30117fa08b13397ea8179e..e56a6faa60d9bf9e3e154bd47def0a08e327dc2d 100644 (file)
--- a/Robust/src/Benchmarks/Prefetch/MatrixMultiply/MatrixMultiply.java
+++ b/Robust/src/Benchmarks/Prefetch/MatrixMultiply/MatrixMultiply.java
@@ -11,19 +11,22 @@ public class MatrixMultiply extends Thread{
        }
 
        public void run() {
-               int localresults[][];
+               double localresults[][];
 
                atomic {
                    //compute the results
-                   localresults=new int[1+x1-x0][1+y1-y0];
-               
+                   localresults=new double[1+x1-x0][1+y1-y0];
+                   double la[][]=mmul.a;
+                   double lbtranspose[][]=mmul.b;
+                   double lc[][]=mmul.c;
+                   int M=mmul.M;
+
                    //Use b transpose for cache performance
                    for(int i = x0; i<= x1; i++){
-                       int a[]=mmul.a[i];
-                       int M=mmul.M;
+                       double a[]=la[i];
                        for (int j = y0; j <= y1; j++) {
-                           int innerProduct=0;
-                           int b[] = mmul.btranspose[j];
+                           double innerProduct=0;
+                           double b[] = lbtranspose[j];
                            for(int k = 0; k < M; k++) {
                                innerProduct += a[k] *b[k];
                            }
@@ -35,7 +38,7 @@ public class MatrixMultiply extends Thread{
                atomic {
                    //write the results
                    for(int i=x0;i<=x1;i++) {
-                       int c[]=mmul.c[i];
+                       double c[]=mmul.c[i];
                        for(int j=y0;j<=y1;j++) {
                            c[j]=localresults[i-x0][j-y0];
                        }
@@ -44,11 +47,22 @@ public class MatrixMultiply extends Thread{
        }
 
        public static void main(String[] args) {
-               int mid1 = (128<<24)|(195<<16)|(175<<8)|73;
+<<<<<<< MatrixMultiply.java
+               int mid1 = (128<<24)|(195<<16)|(175<<8)|69;
                int mid2 = (128<<24)|(195<<16)|(175<<8)|69;
                int mid3 = (128<<24)|(195<<16)|(175<<8)|71;
                int NUM_THREADS = 1;
-               int i, j, p, q, r;
+=======
+      int NUM_THREADS = 4;
+      int[] mid = new int[NUM_THREADS];
+      mid[0] = (128<<24)|(195<<16)|(175<<8)|69;
+      mid[1] = (128<<24)|(195<<16)|(175<<8)|73;
+      mid[2] = (128<<24)|(195<<16)|(175<<8)|78;
+      mid[3] = (128<<24)|(195<<16)|(175<<8)|79;
+               //int mid1 = (128<<24)|(195<<16)|(175<<8)|69;
+               //int mid2 = (128<<24)|(195<<16)|(175<<8)|73;
+>>>>>>> 1.19
+               int p, q, r;
                MatrixMultiply[] mm;
                MatrixMultiply tmp;
                MMul matrix;
@@ -64,7 +78,10 @@ public class MatrixMultiply extends Thread{
                }
 
                atomic {
-                       mm[0] = global new MatrixMultiply(matrix,0,0,399,399);
+                       mm[0] = global new MatrixMultiply(matrix,0,0,200,200);
+                       mm[1] = global new MatrixMultiply(matrix,0,201,200,399);
+                       mm[2] = global new MatrixMultiply(matrix,201,0,399,200);
+                       mm[3] = global new MatrixMultiply(matrix,201,201,399,399);
                }
 
                atomic {
@@ -86,15 +103,15 @@ public class MatrixMultiply extends Thread{
                System.printString("\n");
 
                // start a thread to compute each c[l,n]
-               for (i = 0; i < NUM_THREADS; i++) {
+               for (int i = 0; i < NUM_THREADS; i++) {
                        atomic {
                                tmp = mm[i];
                        }
-                       tmp.start(mid1);
+                       tmp.start(mid[i]);
                }
 
                // wait for them to finish
-               for (i = 0; i < NUM_THREADS; i++) {
+               for (int i = 0; i < NUM_THREADS; i++) {
                        atomic {
                                tmp = mm[i];
                        }
@@ -104,11 +121,11 @@ public class MatrixMultiply extends Thread{
                // print out the result of the matrix multiply
                System.printString("Starting\n");
                System.printString("Matrix Product c =\n");
-               int val;
+               double val;
                atomic {
-                       for (i = 0; i < p; i++) {
-                               int c[]=matrix.c[i];
-                               for (j = 0; j < r; j++) {
+                       for (int i = 0; i < p; i++) {
+                               double c[]=matrix.c[i];
+                               for (int j = 0; j < r; j++) {
                                        val = c[j];
                                }
                        }
@@ -120,54 +137,55 @@ public class MatrixMultiply extends Thread{
 public class MMul{
 
        public int L, M, N;
-       public int[][] a;
-       public int[][] b;
-       public int[][] c;
-       public int[][] btranspose;
+       public double[][] a;
+       public double[][] b;
+       public double[][] c;
+       public double[][] btranspose;
 
        public MMul(int L, int M, int N) {
                this.L = L;
                this.M = M;
                this.N = N;
-               a = global new int[L][M];  
-               b = global new int[M][N]; 
-               c = global new int[L][N]; 
-               btranspose = global new int[N][M];
+               a = global new double[L][M];  
+               b = global new double[M][N]; 
+               c = global new double[L][N]; 
+               btranspose = global new double[N][M];
        }
 
        public void setValues() {
-               int i;
-               int j;
-               for(i = 0; i < L; i++) {
-                       for(j = 0; j < M; j++) {
-                               a[i][j] = j+1;
+               for(int i = 0; i < L; i++) {
+            double ai[] = a[i];
+                       for(int j = 0; j < M; j++) {
+                               ai[j] = j+1;
                        }
                }
 
-               for(i = 0; i < M; i++) {
-                       for(j = 0; j < N; j++) {
-                               b[i][j] = j+1;
+               for(int i = 0; i < M; i++) {
+            double bi[] = b[i];
+                       for(int j = 0; j < N; j++) {
+                               bi[j] = j+1;
                        }
                }
 
-               for(i = 0; i < L; i++) {
-                       for(j = 0; j < N; j++) {
-                               c[i][j] = 0;
+               for(int i = 0; i < L; i++) {
+            double ci[] = c[i];
+                       for(int j = 0; j < N; j++) {
+                               ci[j] = 0;
                        }
                }
-               for(i = 0; i < N; i++) {
-                       for(j = 0; j < M; j++) {
-                               btranspose[i][j] = 0;
+               for(int i = 0; i < N; i++) {
+            double btransposei[] = btranspose[i];
+                       for(int j = 0; j < M; j++) {
+                               btransposei[j] = 0;
                        }
                }
        }
 
        public void transpose() {
-               int row;
-               int col;
-               for(row = 0; row < M; row++) {
-                       for(col = 0; col < N; col++) {
-                               btranspose[col][row] = b[row][col];
+               for(int row = 0; row < M; row++) {
+            double brow[] = b[row];
+                       for(int col = 0; col < N; col++) {
+                               btranspose[col][row] = brow[col];
                        }
                }
        }