From 26dfb9a1f4e526ba15150756737b3ae5f5626911 Mon Sep 17 00:00:00 2001
From: adash <adash>
Date: Tue, 8 Dec 2009 20:08:33 +0000
Subject: [PATCH] added new latency senstitive source files for 2dFFT

---
 .../Benchmarks/Prefetch/2DFFT/dsm/Makefile    |  17 +-
 .../Prefetch/2DFFT/dsm/Matrix1.java           |  58 ++
 .../Prefetch/2DFFT/dsm/fft2drect.java         | 601 ++++++++++++++++++
 .../Prefetch/2DFFT/javasingle/Matrix1.java    |  58 ++
 .../Prefetch/2DFFT/javasingle/fft2drect.java  | 544 ++++++++++++++++
 .../Prefetch/2DFFT/javasingle/makefile        |   6 +-
 6 files changed, 1278 insertions(+), 6 deletions(-)
 create mode 100644 Robust/src/Benchmarks/Prefetch/2DFFT/dsm/Matrix1.java
 create mode 100644 Robust/src/Benchmarks/Prefetch/2DFFT/dsm/fft2drect.java
 create mode 100644 Robust/src/Benchmarks/Prefetch/2DFFT/javasingle/Matrix1.java
 create mode 100644 Robust/src/Benchmarks/Prefetch/2DFFT/javasingle/fft2drect.java

diff --git a/Robust/src/Benchmarks/Prefetch/2DFFT/dsm/Makefile b/Robust/src/Benchmarks/Prefetch/2DFFT/dsm/Makefile
index b95f68c3..e2a0abff 100644
--- a/Robust/src/Benchmarks/Prefetch/2DFFT/dsm/Makefile
+++ b/Robust/src/Benchmarks/Prefetch/2DFFT/dsm/Makefile
@@ -3,14 +3,21 @@ SRC=${MAINCLASS}.java \
 	fft1d.java \
 	Matrix.java \
 	../../../../ClassLibrary/JavaDSM/Barrier.java
-FLAGS =-dsm -dsmcaching -prefetch -optimize -excprefetch fft2d.main -excprefetch fft2d.twiddle -excprefetch fft1d.factorize -excprefetch fft1d.printFactors -excprefetch Matrix.setValues -excprefetch Matrix.setZeros -excprefetch fft2d.transpose -trueprob 0.90 -mainclass ${MAINCLASS}
-FLAGS1=-dsm -optimize -mainclass ${MAINCLASS}
-FLAGS2=-dsm -optimize -dsmcaching -mainclass ${MAINCLASS}
+SRC1=${MAINCLASS}rect.java \
+	fft1d.java \
+	Matrix1.java \
+	../../../../ClassLibrary/JavaDSM/Barrier.java
+FLAGS =-dsm -dsmcaching -transstats -prefetch -optimize -excprefetch fft2d.main -excprefetch fft2d.twiddle -excprefetch fft1d.factorize -excprefetch fft1d.printFactors -excprefetch Matrix.setValues -excprefetch Matrix.setZeros -excprefetch fft2d.transpose -trueprob 0.95 -mainclass ${MAINCLASS}
+FLAGS1=-dsm -optimize -transstats -mainclass ${MAINCLASS}
+FLAGS2=-dsm -optimize -transstats -dsmcaching -mainclass ${MAINCLASS}
 
 default:
-	../../../../buildscript ${FLAGS1} ${SRC} -o ${MAINCLASS}NPNC
+#../../../../buildscript ${FLAGS1} ${SRC} -o ${MAINCLASS}NPNC
+#	../../../../buildscript ${FLAGS2} ${SRC} -o ${MAINCLASS}NPC
+#	../../../../buildscript ${FLAGS} ${SRC} -o ${MAINCLASS}N
+	../../../../buildscript ${FLAGS1} ${SRC1} -o ${MAINCLASS}NPNC
 #	../../../../buildscript ${FLAGS2} ${SRC} -o ${MAINCLASS}NPC
-	../../../../buildscript ${FLAGS} ${SRC} -o ${MAINCLASS}N
+	../../../../buildscript ${FLAGS} ${SRC1} -o ${MAINCLASS}N
 
 clean:
 	rm -rf tmpbuilddirectory
diff --git a/Robust/src/Benchmarks/Prefetch/2DFFT/dsm/Matrix1.java b/Robust/src/Benchmarks/Prefetch/2DFFT/dsm/Matrix1.java
new file mode 100644
index 00000000..aa067790
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/2DFFT/dsm/Matrix1.java
@@ -0,0 +1,58 @@
+public class Matrix {
+  public int M, N; //M = column, N = row
+  public double[][] dataRe;
+  public double[][] dataIm;
+  public double[][] dataRetrans;
+  public double[][] dataImtrans;
+
+  public Matrix(int M, int N) {
+    this.M = M;
+    this.N = N;
+    dataRe = global new double[M][N];
+    dataIm = global new double[M][N];
+    dataRetrans = global new double[N][M];
+    dataImtrans = global new double[N][M];
+  }
+
+  public void setValues() {
+    for (int i = 0; i<M; i++) {
+      double dataRei[] = dataRe[i];
+      double dataImi[] = dataIm[i];
+      for(int j = 0; j<N; j++) {
+	dataRei[j] = j + 1;
+	dataImi[j] = j + 1;
+      }
+    }
+
+    for (int i = 0; i<N; i++) {
+      double dataRei[] = dataRetrans[i];
+      double dataImi[] = dataImtrans[i];
+      for(int j = 0; j<M; j++) {
+        dataRei[j] = 0;
+        dataImi[j] = 0;
+      }
+    }
+  }
+
+  public void setZeros() {
+    for (int i = 0; i<M; i++) {
+      double dataRei[] = dataRe[i];
+      double dataImi[] = dataIm[i];
+      for(int j = 0; j<N; j++) {
+	dataRei[j] = 0;
+	dataImi[j] = 0;
+      }
+    }
+  }
+
+  //Transpose matrix input.
+  private float[][] transpose(float[][] input) {
+    float[][] output = new float[N][M];
+
+    for (int j = 0; j < N; j++)
+      for (int i = 0; i < M; i++)
+	output[j][i] = input[i][j];
+
+    return output;
+  } // End of function transpose().
+}
diff --git a/Robust/src/Benchmarks/Prefetch/2DFFT/dsm/fft2drect.java b/Robust/src/Benchmarks/Prefetch/2DFFT/dsm/fft2drect.java
new file mode 100644
index 00000000..3a69a451
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/2DFFT/dsm/fft2drect.java
@@ -0,0 +1,601 @@
+public class fft2d extends Thread {
+  //Title:        2-d mixed radix FFT.
+  //Version:
+  //Copyright:    Copyright (c) 1998
+  //Author:       Dongyan Wang
+  //Company:      University of Wisconsin-Milwaukee.
+  //Description:
+  //              . Use fft1d to perform fft2d.
+  //
+  // Code borrowed from :Java Digital Signal Processing book by Lyon and Rao
+
+  public Matrix data1;
+  public int x0, x1, y0,y1;
+
+  // Constructor: 2-d FFT of Complex data.
+  public fft2d(Matrix data1, int x0, int x1, int y0, int y1) {
+    this.data1 = data1;
+    this.x0 = x0;
+    this.x1 = x1;
+    this.y0 = y0;
+    this.y1 = y1;
+  }
+
+  public void run() {
+    fft1d fft1, fft2;
+    Barrier barr;
+    barr = new Barrier("128.195.136.162");
+    double tempdataRe[][];
+    double tempdataIm[][];
+    int rowlength, columnlength;
+    int start, end;
+
+    // Calculate FFT for each row of the data.
+    atomic {
+      rowlength = data1.M;
+      columnlength = data1.N;
+      tempdataRe = data1.dataRe;
+      tempdataIm = data1.dataIm;
+      start = y0;
+      end = y1;
+      System.out.println("x0= "+ x0 +" x1= " + x1); 
+      fft1 = new fft1d(columnlength);
+      fft2 = new fft1d(rowlength);
+      for (int i = x0; i < x1; i++) {
+        //input of FFT
+        double inputRe[] = tempdataRe[i]; //local array
+        double inputIm[] = tempdataIm[i];
+        fft(fft1, inputRe, inputIm);
+      } //end of for
+    }
+
+    //Start Barrier
+    Barrier.enterBarrier(barr);
+
+    // Tranpose data.
+    if (start == 0) {
+      atomic {
+        transpose(tempdataRe, tempdataIm, rowlength, columnlength, data1.dataRetrans, data1.dataImtrans);
+      }
+    }
+
+    //Start Barrier
+    Barrier.enterBarrier(barr);
+
+    // Calculate FFT for each column of the data.
+    double transtempRe[][];
+    double transtempIm[][];
+    atomic {
+      transtempRe = data1.dataRetrans;
+      transtempIm = data1.dataImtrans;
+      System.out.println("start= "+ start +" end= " + end); 
+      for (int j = start; j < end; j++) {
+        //input of FFT
+        double inputRe[] = transtempRe[j]; //local array
+        double inputIm[] = transtempIm[j];
+        fft(fft2, inputRe, inputIm);
+      } //end of fft2 for
+    }
+  } //end of run
+
+  public void transpose(double[][] tempdataRe, double[][] tempdataIm, int rowlength, int columnlength, double[][] tempdataRetrans, double[][] tempdataImtrans) {
+    for(int j = 0; j<columnlength; j++) {
+      for (int i=0; i<rowlength; i++) {
+        tempdataRetrans[j][i] = tempdataRe[i][j];
+        tempdataImtrans[j][i] = tempdataIm[i][j];
+      }
+    }
+    /*
+    for(int i = 0; i<rowlength; i++) {
+      double tRe[] = tempdataRe[i];
+      double tIm[] = tempdataIm[i];
+      double a;
+
+      for(int j = 0; j<columnlength; j++) {
+        a=tempdataRe[j][i];
+        tempdataRe[j][i] = tRe[j];
+        tRe[j]=a;
+        a=tempdataIm[j][i];
+        tempdataIm[j][i] = tIm[j];
+        tIm[j]=a;
+      }
+    }
+    */
+  }
+
+  public static void main(String[] args) {
+    int NUM_THREADS = 1;
+    int ROWS=800, COLUMNS=800;
+    int inputWidth = 10;
+    if(args.length>0) {
+      NUM_THREADS=Integer.parseInt(args[0]);
+      if(args.length > 1) {
+        ROWS = Integer.parseInt(args[1]);
+        if(args.length > 2) {
+          COLUMNS = Integer.parseInt(args[2]);
+        }
+      }
+    }
+
+    System.printString("Num threads = " + NUM_THREADS + " ROWS= " + ROWS + " COLUMNS= " + COLUMNS + "\n");
+
+    int[] mid = new int[8];
+    mid[0] = (128<<24)|(195<<16)|(136<<8)|162; //dw-10
+    mid[1] = (128<<24)|(195<<16)|(136<<8)|163; //dw-11
+    mid[2] = (128<<24)|(195<<16)|(136<<8)|164; //dw-12
+    mid[3] = (128<<24)|(195<<16)|(136<<8)|165; //dw-13
+    mid[4] = (128<<24)|(195<<16)|(136<<8)|166; //dw-14
+    mid[5] = (128<<24)|(195<<16)|(136<<8)|167; //dw-15
+    mid[6] = (128<<24)|(195<<16)|(136<<8)|168; //dw-16
+    mid[7] = (128<<24)|(195<<16)|(136<<8)|169; //dw-17
+
+
+    // Start Barrier Server
+    BarrierServer mybarr;
+    atomic {
+      mybarr = global new BarrierServer(NUM_THREADS);
+    }
+    mybarr.start(mid[0]);
+
+    Matrix data1;
+
+    // Create threads to do FFT
+    fft2d[] myfft2d;
+    atomic {
+      // Set up data for FFT transform
+      data1 = global new Matrix(ROWS, COLUMNS);
+      data1.setValues(); //Input Matrix
+      myfft2d = global new fft2d[NUM_THREADS];
+      int increment1 = COLUMNS/NUM_THREADS;
+      int increment2 = ROWS/NUM_THREADS;
+      int base1 = 0;
+      int base2 = 0;
+      for(int i =0 ; i<NUM_THREADS; i++) {
+        if((i+1)==NUM_THREADS)
+          myfft2d[i] = global new fft2d(data1, base2, ROWS, base1, COLUMNS);
+        else
+          myfft2d[i] = global new fft2d(data1, base2, base2+increment2, base1, base1+increment1);
+        base1+=increment1;
+        base2+=increment2;
+      }
+    }
+
+    boolean waitfordone=true;
+    while(waitfordone) {
+      atomic {
+        if (mybarr.done)
+          waitfordone=false;
+      }
+    }
+
+    fft2d tmp;
+    //Start a thread to compute each c[l,n]
+    for(int i = 0; i<NUM_THREADS; i++) {
+      atomic {
+        tmp = myfft2d[i];
+      }
+      tmp.start(mid[i]);
+    }
+
+    //Wait for thread to finish
+    for(int i = 0; i<NUM_THREADS; i++) {
+      atomic {
+        tmp = myfft2d[i];
+      }
+      tmp.join();
+    }
+
+    System.printString("2DFFT done! \n");
+  }
+
+  public static void fft(fft1d myfft, double inputRe[], double inputIm[]) {
+    //output of FFT
+    double outputRe[] = myfft.outputRe;
+    double outputIm[] = myfft.outputIm;
+    // intermediate results
+    double temRe[] = myfft.temRe;
+    double temIm[] = myfft.temIm;
+    //Permute() operation
+    permute(myfft, outputRe, outputIm, inputRe, inputIm);
+
+    //System.printString("ready to twiddle");
+    for (int factorIndex = 0; factorIndex < myfft.NumofFactors; factorIndex++)
+      twiddle(factorIndex, myfft, temRe, temIm, outputRe, outputIm);
+
+    //System.printString("ready to copy");
+    // Copy the output[] data to input[], so the output can be
+    // returned in the input array.
+    for (int i = 0; i < myfft.N; i++) {
+      inputRe[i] = outputRe[i];
+      inputIm[i] = outputIm[i];
+    }
+  }
+
+  private static void permute(fft1d myfft, double[] outputRe, double[] outputIm, double[] inputRe, double[] inputIm) {
+    int count[] = new int[myfft.MaxFactorsNumber];
+    int j;
+    int k = 0;
+
+    for (int i = 0; i < myfft.N - 1; i++) {
+      outputRe[i] = inputRe[k];
+      outputIm[i] = inputIm[k];
+      j = 0;
+      k = k + myfft.remain[j];
+      count[0] = count[0] + 1;
+      while (count[j] >= myfft.factors[j]) {
+        count[j] = 0;
+        int tmp;
+        if(j == 0)
+          tmp = myfft.N;
+        else
+          tmp = myfft.remain[j - 1];
+        k = k - tmp + myfft.remain[j + 1];
+        j++;
+        count[j] = count[j] + 1;
+      }
+    }
+    outputRe[myfft.N - 1] = inputRe[myfft.N - 1];
+    outputIm[myfft.N - 1] = inputIm[myfft.N - 1];
+  }   // End of function permute().
+
+  private static void twiddle(int factorIndex, fft1d myfft, double[] temRe, double[] temIm,
+      double[] outputRe, double[] outputIm) {
+    // Get factor data.
+    int sofarRadix = myfft.sofar[factorIndex];
+    int radix = myfft.factors[factorIndex];
+    int remainRadix = myfft.remain[factorIndex];
+
+    double tem;   // Temporary variable to do data exchange.
+
+    double W = 2 * (double) Math.setPI() / (sofarRadix * radix);
+    double cosW = (double) Math.cos(W);
+    double sinW = -(double) Math.sin(W);
+
+    double twiddleRe[] = new double[radix];
+    double twiddleIm[] = new double[radix];
+    double twRe = 1.0f, twIm = 0f;
+
+    //Initialize twiddle addBk.address variables.
+    int dataOffset = 0, groupOffset = 0, address = 0;
+
+    for (int dataNo = 0; dataNo < sofarRadix; dataNo++) {
+      //System.printString("datano="+dataNo);
+      if (sofarRadix > 1) {
+        twiddleRe[0] = 1.0f;
+        twiddleIm[0] = 0.0f;
+        twiddleRe[1] = twRe;
+        twiddleIm[1] = twIm;
+        for (int i = 2; i < radix; i++) {
+          twiddleRe[i] = twRe * twiddleRe[i - 1] - twIm * twiddleIm[i - 1];
+          twiddleIm[i] = twIm * twiddleRe[i - 1] + twRe * twiddleIm[i - 1];
+        }
+        tem = cosW * twRe - sinW * twIm;
+        twIm = sinW * twRe + cosW * twIm;
+        twRe = tem;
+      }
+      for (int groupNo = 0; groupNo < remainRadix; groupNo++) {
+        //System.printString("groupNo="+groupNo);
+        if ((sofarRadix > 1) && (dataNo > 0)) {
+          temRe[0] = outputRe[address];
+          temIm[0] = outputIm[address];
+          int blockIndex = 1;
+          do {
+            address = address + sofarRadix;
+            temRe[blockIndex] = twiddleRe[blockIndex] * outputRe[address] -
+              twiddleIm[blockIndex] * outputIm[address];
+            temIm[blockIndex] = twiddleRe[blockIndex] * outputIm[address] +
+              twiddleIm[blockIndex] * outputRe[address];
+            blockIndex++;
+          } while (blockIndex < radix);
+        } else {
+          for (int i = 0; i < radix; i++) {
+            //System.printString("temRe.length="+temRe.length);
+            //System.printString("i = "+i);
+            temRe[i] = outputRe[address];
+            temIm[i] = outputIm[address];
+            address += sofarRadix;
+          }
+        }
+        //System.printString("radix="+radix);
+        if(radix == 2) {
+          tem = temRe[0] + temRe[1];
+          temRe[1] = temRe[0] - temRe[1];
+	  temRe[0] = tem;
+	  tem = temIm[0] + temIm[1];
+	  temIm[1] = temIm[0] - temIm[1];
+	  temIm[0] = tem;
+	} else if( radix == 3) {
+	  double t1Re = temRe[1] + temRe[2];
+	  double t1Im = temIm[1] + temIm[2];
+	  temRe[0] = temRe[0] + t1Re;
+	  temIm[0] = temIm[0] + t1Im;
+
+	  double m1Re = myfft.cos2to3PI * t1Re;
+	  double m1Im = myfft.cos2to3PI * t1Im;
+	  double m2Re = myfft.sin2to3PI * (temIm[1] - temIm[2]);
+	  double m2Im = myfft.sin2to3PI * (temRe[2] - temRe[1]);
+	  double s1Re = temRe[0] + m1Re;
+	  double s1Im = temIm[0] + m1Im;
+
+	  temRe[1] = s1Re + m2Re;
+	  temIm[1] = s1Im + m2Im;
+	  temRe[2] = s1Re - m2Re;
+	  temIm[2] = s1Im - m2Im;
+	} else if(radix == 4) {
+	  fft4(temRe, temIm);
+	} else if(radix == 5) {
+	  fft5(myfft, temRe, temIm);
+	} else if(radix == 8) {
+	  fft8(myfft, temRe, temIm);
+	} else if(radix == 10) {
+	  fft10(myfft, temRe, temIm);
+	} else {
+	  fftPrime(radix, temRe, temIm);
+	}
+	address = groupOffset;
+	for (int i = 0; i < radix; i++) {
+	  outputRe[address] = temRe[i];
+	  outputIm[address] = temIm[i];
+	  address += sofarRadix;
+	}
+	groupOffset += sofarRadix * radix;
+	address = groupOffset;
+      }
+      groupOffset = ++dataOffset;
+      address = groupOffset;
+    }
+  } //twiddle operation
+
+  // The two arguments dataRe[], dataIm[] are mainly for using in fft8();
+  private static void fft4(double dataRe[], double dataIm[]) {
+    double t1Re,t1Im, t2Re,t2Im;
+    double m2Re,m2Im, m3Re,m3Im;
+
+    t1Re = dataRe[0] + dataRe[2];
+    t1Im = dataIm[0] + dataIm[2];
+    t2Re = dataRe[1] + dataRe[3];
+    t2Im = dataIm[1] + dataIm[3];
+
+    m2Re = dataRe[0] - dataRe[2];
+    m2Im = dataIm[0] - dataIm[2];
+    m3Re = dataIm[1] - dataIm[3];
+    m3Im = dataRe[3] - dataRe[1];
+
+    dataRe[0] = t1Re + t2Re;
+    dataIm[0] = t1Im + t2Im;
+    dataRe[2] = t1Re - t2Re;
+    dataIm[2] = t1Im - t2Im;
+    dataRe[1] = m2Re + m3Re;
+    dataIm[1] = m2Im + m3Im;
+    dataRe[3] = m2Re - m3Re;
+    dataIm[3] = m2Im - m3Im;
+  }   // End of function fft4().
+
+  // The two arguments dataRe[], dataIm[] are mainly for using in fft10();
+  private static void fft5(fft1d myfft, double dataRe[], double dataIm[]) {
+    double t1Re,t1Im, t2Re,t2Im, t3Re,t3Im, t4Re,t4Im, t5Re,t5Im;
+    double m1Re,m1Im, m2Re,m2Im, m3Re,m3Im, m4Re,m4Im, m5Re,m5Im;
+    double s1Re,s1Im, s2Re,s2Im, s3Re,s3Im, s4Re,s4Im, s5Re,s5Im;
+
+    t1Re = dataRe[1] + dataRe[4];
+    t1Im = dataIm[1] + dataIm[4];
+    t2Re = dataRe[2] + dataRe[3];
+    t2Im = dataIm[2] + dataIm[3];
+    t3Re = dataRe[1] - dataRe[4];
+    t3Im = dataIm[1] - dataIm[4];
+    t4Re = dataRe[3] - dataRe[2];
+    t4Im = dataIm[3] - dataIm[2];
+    t5Re = t1Re + t2Re;
+    t5Im = t1Im + t2Im;
+
+    dataRe[0] = dataRe[0] + t5Re;
+    dataIm[0] = dataIm[0] + t5Im;
+
+    m1Re = myfft.c51 * t5Re;
+    m1Im = myfft.c51 * t5Im;
+    m2Re = myfft.c52 * (t1Re - t2Re);
+    m2Im = myfft.c52 * (t1Im - t2Im);
+    m3Re = -(myfft.c53) * (t3Im + t4Im);
+    m3Im = myfft.c53 * (t3Re + t4Re);
+    m4Re = -(myfft.c54) * t4Im;
+    m4Im = myfft.c54 * t4Re;
+    m5Re = -(myfft.c55) * t3Im;
+    m5Im = myfft.c55 * t3Re;
+
+    s3Re = m3Re - m4Re;
+    s3Im = m3Im - m4Im;
+    s5Re = m3Re + m5Re;
+    s5Im = m3Im + m5Im;
+    s1Re = dataRe[0] + m1Re;
+    s1Im = dataIm[0] + m1Im;
+    s2Re = s1Re + m2Re;
+    s2Im = s1Im + m2Im;
+    s4Re = s1Re - m2Re;
+    s4Im = s1Im - m2Im;
+
+    dataRe[1] = s2Re + s3Re;
+    dataIm[1] = s2Im + s3Im;
+    dataRe[2] = s4Re + s5Re;
+    dataIm[2] = s4Im + s5Im;
+    dataRe[3] = s4Re - s5Re;
+    dataIm[3] = s4Im - s5Im;
+    dataRe[4] = s2Re - s3Re;
+    dataIm[4] = s2Im - s3Im;
+  }   // End of function fft5().
+
+  private static void fft8(fft1d myfft, double[] temRe, double[] temIm) {
+    double data1Re[] = new double[4];
+    double data1Im[] = new double[4];
+    double data2Re[] = new double[4];
+    double data2Im[] = new double[4];
+    double tem;
+
+    // To improve the speed, use direct assaignment instead for loop here.
+    data1Re[0] = temRe[0];
+    data2Re[0] = temRe[1];
+    data1Re[1] = temRe[2];
+    data2Re[1] = temRe[3];
+    data1Re[2] = temRe[4];
+    data2Re[2] = temRe[5];
+    data1Re[3] = temRe[6];
+    data2Re[3] = temRe[7];
+
+    data1Im[0] = temIm[0];
+    data2Im[0] = temIm[1];
+    data1Im[1] = temIm[2];
+    data2Im[1] = temIm[3];
+    data1Im[2] = temIm[4];
+    data2Im[2] = temIm[5];
+    data1Im[3] = temIm[6];
+    data2Im[3] = temIm[7];
+
+    fft4(data1Re, data1Im);
+    fft4(data2Re, data2Im);
+
+    tem = myfft.OnetoSqrt2 * (data2Re[1] + data2Im[1]);
+    data2Im[1] = myfft.OnetoSqrt2 * (data2Im[1] - data2Re[1]);
+    data2Re[1] = tem;
+    tem = data2Im[2];
+    data2Im[2] = -data2Re[2];
+    data2Re[2] = tem;
+    tem = myfft.OnetoSqrt2 * (data2Im[3] - data2Re[3]);
+    data2Im[3] = -(myfft.OnetoSqrt2) * (data2Re[3] + data2Im[3]);
+    data2Re[3] = tem;
+
+    temRe[0] = data1Re[0] + data2Re[0];
+    temRe[4] = data1Re[0] - data2Re[0];
+    temRe[1] = data1Re[1] + data2Re[1];
+    temRe[5] = data1Re[1] - data2Re[1];
+    temRe[2] = data1Re[2] + data2Re[2];
+    temRe[6] = data1Re[2] - data2Re[2];
+    temRe[3] = data1Re[3] + data2Re[3];
+    temRe[7] = data1Re[3] - data2Re[3];
+
+    temIm[0] = data1Im[0] + data2Im[0];
+    temIm[4] = data1Im[0] - data2Im[0];
+    temIm[1] = data1Im[1] + data2Im[1];
+    temIm[5] = data1Im[1] - data2Im[1];
+    temIm[2] = data1Im[2] + data2Im[2];
+    temIm[6] = data1Im[2] - data2Im[2];
+    temIm[3] = data1Im[3] + data2Im[3];
+    temIm[7] = data1Im[3] - data2Im[3];
+  }   // End of function fft8().
+
+  private static void fft10(fft1d myfft, double[] temRe, double[] temIm) {
+    double data1Re[] = new double[5];
+    double data1Im[] = new double[5];
+    double data2Re[] = new double[5];
+    double data2Im[] = new double[5];
+
+    // To improve the speed, use direct assaignment instead for loop here.
+    data1Re[0] = temRe[0];
+    data2Re[0] = temRe[5];
+    data1Re[1] = temRe[2];
+    data2Re[1] = temRe[7];
+    data1Re[2] = temRe[4];
+    data2Re[2] = temRe[9];
+    data1Re[3] = temRe[6];
+    data2Re[3] = temRe[1];
+    data1Re[4] = temRe[8];
+    data2Re[4] = temRe[3];
+
+    data1Im[0] = temIm[0];
+    data2Im[0] = temIm[5];
+    data1Im[1] = temIm[2];
+    data2Im[1] = temIm[7];
+    data1Im[2] = temIm[4];
+    data2Im[2] = temIm[9];
+    data1Im[3] = temIm[6];
+    data2Im[3] = temIm[1];
+    data1Im[4] = temIm[8];
+    data2Im[4] = temIm[3];
+
+    fft5(myfft, data1Re, data1Im);
+    fft5(myfft, data2Re, data2Im);
+
+    temRe[0] = data1Re[0] + data2Re[0];
+    temRe[5] = data1Re[0] - data2Re[0];
+    temRe[6] = data1Re[1] + data2Re[1];
+    temRe[1] = data1Re[1] - data2Re[1];
+    temRe[2] = data1Re[2] + data2Re[2];
+    temRe[7] = data1Re[2] - data2Re[2];
+    temRe[8] = data1Re[3] + data2Re[3];
+    temRe[3] = data1Re[3] - data2Re[3];
+    temRe[4] = data1Re[4] + data2Re[4];
+    temRe[9] = data1Re[4] - data2Re[4];
+
+    temIm[0] = data1Im[0] + data2Im[0];
+    temIm[5] = data1Im[0] - data2Im[0];
+    temIm[6] = data1Im[1] + data2Im[1];
+    temIm[1] = data1Im[1] - data2Im[1];
+    temIm[2] = data1Im[2] + data2Im[2];
+    temIm[7] = data1Im[2] - data2Im[2];
+    temIm[8] = data1Im[3] + data2Im[3];
+    temIm[3] = data1Im[3] - data2Im[3];
+    temIm[4] = data1Im[4] + data2Im[4];
+    temIm[9] = data1Im[4] - data2Im[4];
+  }   // End of function fft10().
+
+  private static void fftPrime(int radix, double[] temRe, double[] temIm) {
+    // Initial WRe, WIm.
+    double W = 2 * (double) Math.setPI() / radix;
+    double cosW = (double) Math.cos(W);
+    double sinW = -(double) Math.sin(W);
+    double WRe[] = new double[radix];
+    double WIm[] = new double[radix];
+
+    WRe[0] = 1;
+    WIm[0] = 0;
+    WRe[1] = cosW;
+    WIm[1] = sinW;
+
+    for (int i = 2; i < radix; i++) {
+      WRe[i] = cosW * WRe[i - 1] - sinW * WIm[i - 1];
+      WIm[i] = sinW * WRe[i - 1] + cosW * WIm[i - 1];
+    }
+
+    // FFT of prime length data, using DFT, can be improved in the future.
+    double rere, reim, imre, imim;
+    int j, k;
+    int max = (radix + 1) / 2;
+
+    double tem1Re[] = new double[max];
+    double tem1Im[] = new double[max];
+    double tem2Re[] = new double[max];
+    double tem2Im[] = new double[max];
+
+    for (j = 1; j < max; j++) {
+      tem1Re[j] = temRe[j] + temRe[radix - j];
+      tem1Im[j] = temIm[j] - temIm[radix - j];
+      tem2Re[j] = temRe[j] - temRe[radix - j];
+      tem2Im[j] = temIm[j] + temIm[radix - j];
+    }
+
+    for (j = 1; j < max; j++) {
+      temRe[j] = temRe[0];
+      temIm[j] = temIm[0];
+      temRe[radix - j] = temRe[0];
+      temIm[radix - j] = temIm[0];
+      k = j;
+      for (int i = 1; i < max; i++) {
+	rere = WRe[k] * tem1Re[i];
+	imim = WIm[k] * tem1Im[i];
+	reim = WRe[k] * tem2Im[i];
+	imre = WIm[k] * tem2Re[i];
+
+	temRe[radix - j] += rere + imim;
+	temIm[radix - j] += reim - imre;
+	temRe[j] += rere - imim;
+	temIm[j] += reim + imre;
+
+	k = k + j;
+	if (k >= radix)
+	  k = k - radix;
+      }
+    }
+    for (j = 1; j < max; j++) {
+      temRe[0] = temRe[0] + tem1Re[j];
+      temIm[0] = temIm[0] + tem2Im[j];
+    }
+  }   // End of function fftPrime().
+}
diff --git a/Robust/src/Benchmarks/Prefetch/2DFFT/javasingle/Matrix1.java b/Robust/src/Benchmarks/Prefetch/2DFFT/javasingle/Matrix1.java
new file mode 100644
index 00000000..2c2b8edc
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/2DFFT/javasingle/Matrix1.java
@@ -0,0 +1,58 @@
+public class Matrix {
+  public int M, N; //M = column, N = row
+  public double[][] dataRe;
+  public double[][] dataIm;
+  public double[][] dataRetrans;
+  public double[][] dataImtrans;
+
+  public Matrix(int M, int N) {
+    this.M = M;
+    this.N = N;
+    dataRe = new double[M][N];
+    dataIm = new double[M][N];
+    dataRetrans = new double[N][M];
+    dataImtrans = new double[N][M];
+  }
+
+  public void setValues() {
+    for (int i = 0; i<M; i++) {
+      double dataRei[] = dataRe[i];
+      double dataImi[] = dataIm[i];
+      for(int j = 0; j<N; j++) {
+	dataRei[j] = j + 1;
+	dataImi[j] = j + 1;
+      }
+    }
+
+    for (int i = 0; i<N; i++) {
+      double dataRei[] = dataRetrans[i];
+      double dataImi[] = dataImtrans[i];
+      for(int j = 0; j<M; j++) {
+        dataRei[j] = 0;
+        dataImi[j] = 0;
+      }
+    }
+  }
+
+  public void setZeros() {
+    for (int i = 0; i<M; i++) {
+      double dataRei[] = dataRe[i];
+      double dataImi[] = dataIm[i];
+      for(int j = 0; j<N; j++) {
+	dataRei[j] = 0;
+	dataImi[j] = 0;
+      }
+    }
+  }
+
+  //Transpose matrix input.
+  private float[][] transpose(float[][] input) {
+    float[][] output = new float[N][M];
+
+    for (int j = 0; j < N; j++)
+      for (int i = 0; i < M; i++)
+	output[j][i] = input[i][j];
+
+    return output;
+  } // End of function transpose().
+}
diff --git a/Robust/src/Benchmarks/Prefetch/2DFFT/javasingle/fft2drect.java b/Robust/src/Benchmarks/Prefetch/2DFFT/javasingle/fft2drect.java
new file mode 100644
index 00000000..23064be3
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/2DFFT/javasingle/fft2drect.java
@@ -0,0 +1,544 @@
+public class fft2d extends Thread {
+  //Title:        2-d mixed radix FFT.
+  //Version:
+  //Copyright:    Copyright (c) 1998
+  //Author:       Dongyan Wang
+  //Company:      University of Wisconsin-Milwaukee.
+  //Description:
+  //              . Use fft1d to perform fft2d.
+  //
+  // Code borrowed from :Java Digital Signal Processing book by Lyon and Rao
+
+  public Matrix data1;
+  public int x0, x1, y0,y1;
+
+  // Constructor: 2-d FFT of Complex data.
+  public fft2d(Matrix data1, int x0, int x1, int y0, int y1) {
+    this.data1 = data1;
+    this.x0 = x0;
+    this.x1 = x1;
+    this.y0 = y0;
+    this.y1 = y1;
+  }
+
+  public void run() {
+    fft1d fft1, fft2;
+    double tempdataRe[][];
+    double tempdataIm[][];
+    int rowlength, columnlength;
+    int start, end;
+
+    // Calculate FFT for each row of the data.
+    rowlength = data1.M;
+    columnlength = data1.N;
+    tempdataRe = data1.dataRe;
+    tempdataIm = data1.dataIm;
+    start = y0;
+    end = y1;
+    System.out.println("x0= "+ x0 +" x1= " + x1); 
+    fft1 = new fft1d(columnlength);
+    fft2 = new fft1d(rowlength);
+    for (int i = x0; i < x1; i++) {
+      //input of FFT
+      double inputRe[] = tempdataRe[i]; //local array
+      double inputIm[] = tempdataIm[i];
+      fft(fft1, inputRe, inputIm);
+    } //end of for
+
+    // Tranpose data.
+    if (start == 0) {
+      transpose(tempdataRe, tempdataIm, rowlength, columnlength, data1.dataRetrans, data1.dataImtrans);
+    }
+
+    // Calculate FFT for each column of the data.
+    double transtempRe[][];
+    double transtempIm[][];
+    transtempRe = data1.dataRetrans;
+    transtempIm = data1.dataImtrans;
+    System.out.println("start= "+ start +" end= " + end); 
+    for (int j = start; j < end; j++) {
+      //input of FFT
+      double inputRe[] = transtempRe[j]; //local array
+      double inputIm[] = transtempIm[j];
+      fft(fft2, inputRe, inputIm);
+    } //end of fft2 for
+  } //end of run
+
+  public void transpose(double[][] tempdataRe, double[][] tempdataIm, int rowlength, int columnlength, double[][] tempdataRetrans, double[][] tempdataImtrans) {
+    for(int j = 0; j<columnlength; j++) {
+      for (int i=0; i<rowlength; i++) {
+        tempdataRetrans[j][i] = tempdataRe[i][j];
+        tempdataImtrans[j][i] = tempdataIm[i][j];
+      }
+    }
+  }
+
+  public static void main(String[] args) {
+    int NUM_THREADS = 1;
+    int ROWS=800, COLUMNS=800;
+    int inputWidth = 10;
+    if(args.length>0) {
+      NUM_THREADS=Integer.parseInt(args[0]);
+      if(args.length > 1) {
+        ROWS = Integer.parseInt(args[1]);
+        if(args.length > 2) {
+          COLUMNS = Integer.parseInt(args[2]);
+        }
+      }
+    }
+
+    System.printString("Num threads = " + NUM_THREADS + " ROWS= " + ROWS + " COLUMNS= " + COLUMNS + "\n");
+
+    int[] mid = new int[8];
+    mid[0] = (128<<24)|(195<<16)|(136<<8)|162; //dw-10
+    mid[1] = (128<<24)|(195<<16)|(136<<8)|163; //dw-11
+    mid[2] = (128<<24)|(195<<16)|(136<<8)|164; //dw-12
+    mid[3] = (128<<24)|(195<<16)|(136<<8)|165; //dw-13
+    mid[4] = (128<<24)|(195<<16)|(136<<8)|166; //dw-14
+    mid[5] = (128<<24)|(195<<16)|(136<<8)|167; //dw-15
+    mid[6] = (128<<24)|(195<<16)|(136<<8)|168; //dw-16
+    mid[7] = (128<<24)|(195<<16)|(136<<8)|169; //dw-17
+
+
+    Matrix data1;
+
+    // Create threads to do FFT
+    fft2d[] myfft2d;
+    // Set up data for FFT transform
+    data1 = new Matrix(ROWS, COLUMNS);
+    data1.setValues(); //Input Matrix
+    myfft2d = new fft2d[NUM_THREADS];
+    int increment1 = COLUMNS/NUM_THREADS;
+    int increment2 = ROWS/NUM_THREADS;
+    int base1 = 0;
+    int base2 = 0;
+    for(int i =0 ; i<NUM_THREADS; i++) {
+      if((i+1)==NUM_THREADS)
+        myfft2d[i] = new fft2d(data1, base2, ROWS, base1, COLUMNS);
+      else
+        myfft2d[i] = new fft2d(data1, base2, base2+increment2, base1, base1+increment1);
+      base1+=increment1;
+      base2+=increment2;
+    }
+
+    fft2d tmp;
+    //Start a thread to compute each c[l,n]
+    for(int i = 0; i<NUM_THREADS; i++) {
+      tmp = myfft2d[i];
+      tmp.run();
+    }
+
+    System.printString("2DFFT done! \n");
+  }
+
+  public static void fft(fft1d myfft, double inputRe[], double inputIm[]) {
+    //output of FFT
+    double outputRe[] = myfft.outputRe;
+    double outputIm[] = myfft.outputIm;
+    // intermediate results
+    double temRe[] = myfft.temRe;
+    double temIm[] = myfft.temIm;
+    //Permute() operation
+    permute(myfft, outputRe, outputIm, inputRe, inputIm);
+
+    //System.printString("ready to twiddle");
+    for (int factorIndex = 0; factorIndex < myfft.NumofFactors; factorIndex++)
+      twiddle(factorIndex, myfft, temRe, temIm, outputRe, outputIm);
+
+    //System.printString("ready to copy");
+    // Copy the output[] data to input[], so the output can be
+    // returned in the input array.
+    for (int i = 0; i < myfft.N; i++) {
+      inputRe[i] = outputRe[i];
+      inputIm[i] = outputIm[i];
+    }
+  }
+
+  private static void permute(fft1d myfft, double[] outputRe, double[] outputIm, double[] inputRe, double[] inputIm) {
+    int count[] = new int[myfft.MaxFactorsNumber];
+    int j;
+    int k = 0;
+
+    for (int i = 0; i < myfft.N - 1; i++) {
+      outputRe[i] = inputRe[k];
+      outputIm[i] = inputIm[k];
+      j = 0;
+      k = k + myfft.remain[j];
+      count[0] = count[0] + 1;
+      while (count[j] >= myfft.factors[j]) {
+        count[j] = 0;
+        int tmp;
+        if(j == 0)
+          tmp = myfft.N;
+        else
+          tmp = myfft.remain[j - 1];
+        k = k - tmp + myfft.remain[j + 1];
+        j++;
+        count[j] = count[j] + 1;
+      }
+    }
+    outputRe[myfft.N - 1] = inputRe[myfft.N - 1];
+    outputIm[myfft.N - 1] = inputIm[myfft.N - 1];
+  }   // End of function permute().
+
+  private static void twiddle(int factorIndex, fft1d myfft, double[] temRe, double[] temIm,
+      double[] outputRe, double[] outputIm) {
+    // Get factor data.
+    int sofarRadix = myfft.sofar[factorIndex];
+    int radix = myfft.factors[factorIndex];
+    int remainRadix = myfft.remain[factorIndex];
+
+    double tem;   // Temporary variable to do data exchange.
+
+    double W = 2 * (double) Math.setPI() / (sofarRadix * radix);
+    double cosW = (double) Math.cos(W);
+    double sinW = -(double) Math.sin(W);
+
+    double twiddleRe[] = new double[radix];
+    double twiddleIm[] = new double[radix];
+    double twRe = 1.0f, twIm = 0f;
+
+    //Initialize twiddle addBk.address variables.
+    int dataOffset = 0, groupOffset = 0, address = 0;
+
+    for (int dataNo = 0; dataNo < sofarRadix; dataNo++) {
+      //System.printString("datano="+dataNo);
+      if (sofarRadix > 1) {
+        twiddleRe[0] = 1.0f;
+        twiddleIm[0] = 0.0f;
+        twiddleRe[1] = twRe;
+        twiddleIm[1] = twIm;
+        for (int i = 2; i < radix; i++) {
+          twiddleRe[i] = twRe * twiddleRe[i - 1] - twIm * twiddleIm[i - 1];
+          twiddleIm[i] = twIm * twiddleRe[i - 1] + twRe * twiddleIm[i - 1];
+        }
+        tem = cosW * twRe - sinW * twIm;
+        twIm = sinW * twRe + cosW * twIm;
+        twRe = tem;
+      }
+      for (int groupNo = 0; groupNo < remainRadix; groupNo++) {
+        //System.printString("groupNo="+groupNo);
+        if ((sofarRadix > 1) && (dataNo > 0)) {
+          temRe[0] = outputRe[address];
+          temIm[0] = outputIm[address];
+          int blockIndex = 1;
+          do {
+            address = address + sofarRadix;
+            temRe[blockIndex] = twiddleRe[blockIndex] * outputRe[address] -
+              twiddleIm[blockIndex] * outputIm[address];
+            temIm[blockIndex] = twiddleRe[blockIndex] * outputIm[address] +
+              twiddleIm[blockIndex] * outputRe[address];
+            blockIndex++;
+          } while (blockIndex < radix);
+        } else {
+          for (int i = 0; i < radix; i++) {
+            //System.printString("temRe.length="+temRe.length);
+            //System.printString("i = "+i);
+            temRe[i] = outputRe[address];
+            temIm[i] = outputIm[address];
+            address += sofarRadix;
+          }
+        }
+        //System.printString("radix="+radix);
+        if(radix == 2) {
+          tem = temRe[0] + temRe[1];
+          temRe[1] = temRe[0] - temRe[1];
+	  temRe[0] = tem;
+	  tem = temIm[0] + temIm[1];
+	  temIm[1] = temIm[0] - temIm[1];
+	  temIm[0] = tem;
+	} else if( radix == 3) {
+	  double t1Re = temRe[1] + temRe[2];
+	  double t1Im = temIm[1] + temIm[2];
+	  temRe[0] = temRe[0] + t1Re;
+	  temIm[0] = temIm[0] + t1Im;
+
+	  double m1Re = myfft.cos2to3PI * t1Re;
+	  double m1Im = myfft.cos2to3PI * t1Im;
+	  double m2Re = myfft.sin2to3PI * (temIm[1] - temIm[2]);
+	  double m2Im = myfft.sin2to3PI * (temRe[2] - temRe[1]);
+	  double s1Re = temRe[0] + m1Re;
+	  double s1Im = temIm[0] + m1Im;
+
+	  temRe[1] = s1Re + m2Re;
+	  temIm[1] = s1Im + m2Im;
+	  temRe[2] = s1Re - m2Re;
+	  temIm[2] = s1Im - m2Im;
+	} else if(radix == 4) {
+	  fft4(temRe, temIm);
+	} else if(radix == 5) {
+	  fft5(myfft, temRe, temIm);
+	} else if(radix == 8) {
+	  fft8(myfft, temRe, temIm);
+	} else if(radix == 10) {
+	  fft10(myfft, temRe, temIm);
+	} else {
+	  fftPrime(radix, temRe, temIm);
+	}
+	address = groupOffset;
+	for (int i = 0; i < radix; i++) {
+	  outputRe[address] = temRe[i];
+	  outputIm[address] = temIm[i];
+	  address += sofarRadix;
+	}
+	groupOffset += sofarRadix * radix;
+	address = groupOffset;
+      }
+      groupOffset = ++dataOffset;
+      address = groupOffset;
+    }
+  } //twiddle operation
+
+  // The two arguments dataRe[], dataIm[] are mainly for using in fft8();
+  private static void fft4(double dataRe[], double dataIm[]) {
+    double t1Re,t1Im, t2Re,t2Im;
+    double m2Re,m2Im, m3Re,m3Im;
+
+    t1Re = dataRe[0] + dataRe[2];
+    t1Im = dataIm[0] + dataIm[2];
+    t2Re = dataRe[1] + dataRe[3];
+    t2Im = dataIm[1] + dataIm[3];
+
+    m2Re = dataRe[0] - dataRe[2];
+    m2Im = dataIm[0] - dataIm[2];
+    m3Re = dataIm[1] - dataIm[3];
+    m3Im = dataRe[3] - dataRe[1];
+
+    dataRe[0] = t1Re + t2Re;
+    dataIm[0] = t1Im + t2Im;
+    dataRe[2] = t1Re - t2Re;
+    dataIm[2] = t1Im - t2Im;
+    dataRe[1] = m2Re + m3Re;
+    dataIm[1] = m2Im + m3Im;
+    dataRe[3] = m2Re - m3Re;
+    dataIm[3] = m2Im - m3Im;
+  }   // End of function fft4().
+
+  // The two arguments dataRe[], dataIm[] are mainly for using in fft10();
+  private static void fft5(fft1d myfft, double dataRe[], double dataIm[]) {
+    double t1Re,t1Im, t2Re,t2Im, t3Re,t3Im, t4Re,t4Im, t5Re,t5Im;
+    double m1Re,m1Im, m2Re,m2Im, m3Re,m3Im, m4Re,m4Im, m5Re,m5Im;
+    double s1Re,s1Im, s2Re,s2Im, s3Re,s3Im, s4Re,s4Im, s5Re,s5Im;
+
+    t1Re = dataRe[1] + dataRe[4];
+    t1Im = dataIm[1] + dataIm[4];
+    t2Re = dataRe[2] + dataRe[3];
+    t2Im = dataIm[2] + dataIm[3];
+    t3Re = dataRe[1] - dataRe[4];
+    t3Im = dataIm[1] - dataIm[4];
+    t4Re = dataRe[3] - dataRe[2];
+    t4Im = dataIm[3] - dataIm[2];
+    t5Re = t1Re + t2Re;
+    t5Im = t1Im + t2Im;
+
+    dataRe[0] = dataRe[0] + t5Re;
+    dataIm[0] = dataIm[0] + t5Im;
+
+    m1Re = myfft.c51 * t5Re;
+    m1Im = myfft.c51 * t5Im;
+    m2Re = myfft.c52 * (t1Re - t2Re);
+    m2Im = myfft.c52 * (t1Im - t2Im);
+    m3Re = -(myfft.c53) * (t3Im + t4Im);
+    m3Im = myfft.c53 * (t3Re + t4Re);
+    m4Re = -(myfft.c54) * t4Im;
+    m4Im = myfft.c54 * t4Re;
+    m5Re = -(myfft.c55) * t3Im;
+    m5Im = myfft.c55 * t3Re;
+
+    s3Re = m3Re - m4Re;
+    s3Im = m3Im - m4Im;
+    s5Re = m3Re + m5Re;
+    s5Im = m3Im + m5Im;
+    s1Re = dataRe[0] + m1Re;
+    s1Im = dataIm[0] + m1Im;
+    s2Re = s1Re + m2Re;
+    s2Im = s1Im + m2Im;
+    s4Re = s1Re - m2Re;
+    s4Im = s1Im - m2Im;
+
+    dataRe[1] = s2Re + s3Re;
+    dataIm[1] = s2Im + s3Im;
+    dataRe[2] = s4Re + s5Re;
+    dataIm[2] = s4Im + s5Im;
+    dataRe[3] = s4Re - s5Re;
+    dataIm[3] = s4Im - s5Im;
+    dataRe[4] = s2Re - s3Re;
+    dataIm[4] = s2Im - s3Im;
+  }   // End of function fft5().
+
+  private static void fft8(fft1d myfft, double[] temRe, double[] temIm) {
+    double data1Re[] = new double[4];
+    double data1Im[] = new double[4];
+    double data2Re[] = new double[4];
+    double data2Im[] = new double[4];
+    double tem;
+
+    // To improve the speed, use direct assaignment instead for loop here.
+    data1Re[0] = temRe[0];
+    data2Re[0] = temRe[1];
+    data1Re[1] = temRe[2];
+    data2Re[1] = temRe[3];
+    data1Re[2] = temRe[4];
+    data2Re[2] = temRe[5];
+    data1Re[3] = temRe[6];
+    data2Re[3] = temRe[7];
+
+    data1Im[0] = temIm[0];
+    data2Im[0] = temIm[1];
+    data1Im[1] = temIm[2];
+    data2Im[1] = temIm[3];
+    data1Im[2] = temIm[4];
+    data2Im[2] = temIm[5];
+    data1Im[3] = temIm[6];
+    data2Im[3] = temIm[7];
+
+    fft4(data1Re, data1Im);
+    fft4(data2Re, data2Im);
+
+    tem = myfft.OnetoSqrt2 * (data2Re[1] + data2Im[1]);
+    data2Im[1] = myfft.OnetoSqrt2 * (data2Im[1] - data2Re[1]);
+    data2Re[1] = tem;
+    tem = data2Im[2];
+    data2Im[2] = -data2Re[2];
+    data2Re[2] = tem;
+    tem = myfft.OnetoSqrt2 * (data2Im[3] - data2Re[3]);
+    data2Im[3] = -(myfft.OnetoSqrt2) * (data2Re[3] + data2Im[3]);
+    data2Re[3] = tem;
+
+    temRe[0] = data1Re[0] + data2Re[0];
+    temRe[4] = data1Re[0] - data2Re[0];
+    temRe[1] = data1Re[1] + data2Re[1];
+    temRe[5] = data1Re[1] - data2Re[1];
+    temRe[2] = data1Re[2] + data2Re[2];
+    temRe[6] = data1Re[2] - data2Re[2];
+    temRe[3] = data1Re[3] + data2Re[3];
+    temRe[7] = data1Re[3] - data2Re[3];
+
+    temIm[0] = data1Im[0] + data2Im[0];
+    temIm[4] = data1Im[0] - data2Im[0];
+    temIm[1] = data1Im[1] + data2Im[1];
+    temIm[5] = data1Im[1] - data2Im[1];
+    temIm[2] = data1Im[2] + data2Im[2];
+    temIm[6] = data1Im[2] - data2Im[2];
+    temIm[3] = data1Im[3] + data2Im[3];
+    temIm[7] = data1Im[3] - data2Im[3];
+  }   // End of function fft8().
+
+  private static void fft10(fft1d myfft, double[] temRe, double[] temIm) {
+    double data1Re[] = new double[5];
+    double data1Im[] = new double[5];
+    double data2Re[] = new double[5];
+    double data2Im[] = new double[5];
+
+    // To improve the speed, use direct assaignment instead for loop here.
+    data1Re[0] = temRe[0];
+    data2Re[0] = temRe[5];
+    data1Re[1] = temRe[2];
+    data2Re[1] = temRe[7];
+    data1Re[2] = temRe[4];
+    data2Re[2] = temRe[9];
+    data1Re[3] = temRe[6];
+    data2Re[3] = temRe[1];
+    data1Re[4] = temRe[8];
+    data2Re[4] = temRe[3];
+
+    data1Im[0] = temIm[0];
+    data2Im[0] = temIm[5];
+    data1Im[1] = temIm[2];
+    data2Im[1] = temIm[7];
+    data1Im[2] = temIm[4];
+    data2Im[2] = temIm[9];
+    data1Im[3] = temIm[6];
+    data2Im[3] = temIm[1];
+    data1Im[4] = temIm[8];
+    data2Im[4] = temIm[3];
+
+    fft5(myfft, data1Re, data1Im);
+    fft5(myfft, data2Re, data2Im);
+
+    temRe[0] = data1Re[0] + data2Re[0];
+    temRe[5] = data1Re[0] - data2Re[0];
+    temRe[6] = data1Re[1] + data2Re[1];
+    temRe[1] = data1Re[1] - data2Re[1];
+    temRe[2] = data1Re[2] + data2Re[2];
+    temRe[7] = data1Re[2] - data2Re[2];
+    temRe[8] = data1Re[3] + data2Re[3];
+    temRe[3] = data1Re[3] - data2Re[3];
+    temRe[4] = data1Re[4] + data2Re[4];
+    temRe[9] = data1Re[4] - data2Re[4];
+
+    temIm[0] = data1Im[0] + data2Im[0];
+    temIm[5] = data1Im[0] - data2Im[0];
+    temIm[6] = data1Im[1] + data2Im[1];
+    temIm[1] = data1Im[1] - data2Im[1];
+    temIm[2] = data1Im[2] + data2Im[2];
+    temIm[7] = data1Im[2] - data2Im[2];
+    temIm[8] = data1Im[3] + data2Im[3];
+    temIm[3] = data1Im[3] - data2Im[3];
+    temIm[4] = data1Im[4] + data2Im[4];
+    temIm[9] = data1Im[4] - data2Im[4];
+  }   // End of function fft10().
+
+  private static void fftPrime(int radix, double[] temRe, double[] temIm) {
+    // Initial WRe, WIm.
+    double W = 2 * (double) Math.setPI() / radix;
+    double cosW = (double) Math.cos(W);
+    double sinW = -(double) Math.sin(W);
+    double WRe[] = new double[radix];
+    double WIm[] = new double[radix];
+
+    WRe[0] = 1;
+    WIm[0] = 0;
+    WRe[1] = cosW;
+    WIm[1] = sinW;
+
+    for (int i = 2; i < radix; i++) {
+      WRe[i] = cosW * WRe[i - 1] - sinW * WIm[i - 1];
+      WIm[i] = sinW * WRe[i - 1] + cosW * WIm[i - 1];
+    }
+
+    // FFT of prime length data, using DFT, can be improved in the future.
+    double rere, reim, imre, imim;
+    int j, k;
+    int max = (radix + 1) / 2;
+
+    double tem1Re[] = new double[max];
+    double tem1Im[] = new double[max];
+    double tem2Re[] = new double[max];
+    double tem2Im[] = new double[max];
+
+    for (j = 1; j < max; j++) {
+      tem1Re[j] = temRe[j] + temRe[radix - j];
+      tem1Im[j] = temIm[j] - temIm[radix - j];
+      tem2Re[j] = temRe[j] - temRe[radix - j];
+      tem2Im[j] = temIm[j] + temIm[radix - j];
+    }
+
+    for (j = 1; j < max; j++) {
+      temRe[j] = temRe[0];
+      temIm[j] = temIm[0];
+      temRe[radix - j] = temRe[0];
+      temIm[radix - j] = temIm[0];
+      k = j;
+      for (int i = 1; i < max; i++) {
+	rere = WRe[k] * tem1Re[i];
+	imim = WIm[k] * tem1Im[i];
+	reim = WRe[k] * tem2Im[i];
+	imre = WIm[k] * tem2Re[i];
+
+	temRe[radix - j] += rere + imim;
+	temIm[radix - j] += reim - imre;
+	temRe[j] += rere - imim;
+	temIm[j] += reim + imre;
+
+	k = k + j;
+	if (k >= radix)
+	  k = k - radix;
+      }
+    }
+    for (j = 1; j < max; j++) {
+      temRe[0] = temRe[0] + tem1Re[j];
+      temIm[0] = temIm[0] + tem2Im[j];
+    }
+  }   // End of function fftPrime().
+}
diff --git a/Robust/src/Benchmarks/Prefetch/2DFFT/javasingle/makefile b/Robust/src/Benchmarks/Prefetch/2DFFT/javasingle/makefile
index d6256cbd..2d2e90cc 100644
--- a/Robust/src/Benchmarks/Prefetch/2DFFT/javasingle/makefile
+++ b/Robust/src/Benchmarks/Prefetch/2DFFT/javasingle/makefile
@@ -2,8 +2,12 @@ MAINCLASS=fft2d
 SRC=${MAINCLASS}.java \
 	fft1d.java \
 	Matrix.java
+SRC1=${MAINCLASS}rect.java \
+	fft1d.java \
+	Matrix1.java
 default:
-	../../../../buildscript -thread -optimize -mainclass ${MAINCLASS} ${SRC} -o ${MAINCLASS}
+#	../../../../buildscript -thread -optimize -mainclass ${MAINCLASS} ${SRC} -o ${MAINCLASS}
+	../../../../buildscript -thread -optimize -mainclass ${MAINCLASS} ${SRC1} -o ${MAINCLASS}
 
 clean:
 	rm -rf tmpbuilddirectory
-- 
2.34.1