add mergesort benchmark ported from dpj

diff --git a/Robust/src/Benchmarks/oooJava/mergesort/MergeSort.java b/Robust/src/Benchmarks/oooJava/mergesort/MergeSort.java
new file mode 100644 (file)
index 0000000..5e8f9a5
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/mergesort/MergeSort.java
@@ -0,0 +1,236 @@
+/**\r
+ * Sample sort program adapted from a demo in <A\r
+ * href="http://supertech.lcs.mit.edu/cilk/"> Cilk</A> and <A\r
+ * href="http://www.cs.utexas.edu/users/hood/"> Hood</A>.\r
+ * \r
+ * There are two versions of MergeSort here: One that splits the array into four\r
+ * pieces at each recursive step, and one that splits the array into eight\r
+ * pieces. This abstract class represents the common elements of both versions.\r
+ * \r
+ **/\r
+\r
+public class MergeSort {\r
+\r
+  /* Threshold values */\r
+\r
+  // Cutoff for when to do sequential versus parallel merges\r
+  public static  int MERGE_SIZE;\r
+\r
+  // Cutoff for when to do sequential quicksort versus parallel mergesort\r
+  public static  int QUICK_SIZE;\r
+\r
+  // Cutoff for when to use insertion-sort instead of quicksort\r
+  public static  int INSERTION_SIZE;\r
+  \r
+  public static  int SERIALIZED_CUT_OFF;\r
+\r
+\r
+  protected int[] input;\r
+  protected int[] result;\r
+  protected int size;\r
+\r
+  public void run(int size) {\r
+    this.size=size;\r
+    long startT=System.currentTimeMillis();\r
+    initialize();\r
+    System.out.println("init time="+(System.currentTimeMillis()-startT));\r
+    runWorkAndTest();\r
+  }\r
+\r
+  public MergeSort() {\r
+    MERGE_SIZE = 2048;\r
+    QUICK_SIZE = 2048;\r
+    INSERTION_SIZE = 2000;\r
+  }\r
+\r
+  public void initialize() {\r
+    \r
+    SERIALIZED_CUT_OFF=size/16;\r
+      \r
+    input = new int[size];\r
+    result = new int[size];\r
+\r
+    Random random = new Random(100100);\r
+    for (int i = 0; i < size; ++i) {\r
+      int k = random.nextInt();\r
+      if (k < 0) {\r
+        k *= -1;\r
+      }\r
+      k = k % 10000;\r
+      input[i] = k;\r
+    }\r
+  }\r
+\r
+  public void runWorkAndTest() {\r
+    sese run{\r
+      sort(input, result);\r
+    }\r
+//    sese test{\r
+//      checkSorted(input);\r
+//    }\r
+  }\r
+  \r
+  public void sort(int A[], int B[]){\r
+  }\r
+\r
+  protected void checkSorted(int[] array) {\r
+    System.out.println("Verifying results- size of " + array.length);\r
+    for (int i = 1; i < array.length; i++) {\r
+      if (array[i - 1] > array[i]) {\r
+        System.out.println("Validation Failed.");\r
+        return;\r
+      }\r
+    }\r
+    System.out.println("Validation Success.");\r
+  }\r
+\r
+  protected void merge(int A[], int B[], int out[]) {\r
+\r
+    if (A.length <= MERGE_SIZE) {\r
+      sequentialMerge(A, B, out);\r
+    } else {\r
+      int aHalf = A.length >>> 1; /* l33t shifting h4x!!! */\r
+      int bSplit = findSplit(A[aHalf], B);\r
+\r
+      int[] A_split0 = new int[aHalf];\r
+      int[] A_split1 = new int[A.length - aHalf];\r
+      for (int i = 0; i < aHalf; i++) {\r
+        A_split0[i] = A[i];\r
+      }\r
+      for (int i = aHalf; i < A.length; i++) {\r
+        A_split1[i - aHalf] = A[i];\r
+      }\r
+\r
+      int[] B_split0 = new int[bSplit];\r
+      int[] B_split1 = new int[B.length - bSplit];\r
+      for (int i = 0; i < bSplit; i++) {\r
+        B_split0[i] = B[i];\r
+      }\r
+      for (int i = bSplit; i < B.length; i++) {\r
+        B_split1[i - bSplit] = B[i];\r
+      }\r
+\r
+      int outSplit = aHalf + bSplit;\r
+      int[] out_split0 = new int[outSplit];\r
+      int[] out_split1 = new int[out.length - outSplit];\r
+\r
+      merge(A_split0, B_split0, out_split0);\r
+      merge(A_split1, B_split1, out_split1);\r
+      \r
+      for (int i = 0; i < outSplit; i++) {\r
+        out[i]=out_split0[i]; \r
+      }\r
+      for (int i = outSplit; i < out.length; i++) {\r
+        out[i]=out_split1[i - outSplit];\r
+      }\r
+      \r
+    }\r
+    \r
+  }\r
+\r
+  /** A standard sequential merge **/\r
+  protected void sequentialMerge(int A[], int B[], int out[]) {\r
+    int a = 0;\r
+    int aFence = A.length;\r
+    int b = 0;\r
+    int bFence = B.length;\r
+    int k = 0;\r
+\r
+    while (a < aFence && b < bFence) {\r
+      if (A[a] < B[b])\r
+        out[k++] = A[a++];\r
+      else\r
+        out[k++] = B[b++];\r
+    }\r
+\r
+    while (a < aFence)\r
+      out[k++] = A[a++];\r
+    while (b < bFence)\r
+      out[k++] = B[b++];\r
+  }\r
+\r
+  protected int findSplit(int value, int B[]) {\r
+    int low = 0;\r
+    int high = B.length;\r
+    while (low < high) {\r
+      int middle = low + ((high - low) >>> 1);\r
+      if (value <= B[middle])\r
+        high = middle;\r
+      else\r
+        low = middle + 1;\r
+    }\r
+    return high;\r
+  }\r
+\r
+  /** A standard sequential quicksort **/\r
+  protected void quickSort(int array[], int lo, int hi) {\r
+//    int lo = 0;\r
+//    int hi = array.length - 1;\r
+    // If under threshold, use insertion sort\r
+    int[] arr = array;\r
+    if (hi - lo + 1l <= INSERTION_SIZE) {\r
+      for (int i = lo + 1; i <= hi; i++) {\r
+        int t = arr[i];\r
+        int j = i - 1;\r
+        while (j >= lo && arr[j] > t) {\r
+          arr[j + 1] = arr[j];\r
+          --j;\r
+        }\r
+        arr[j + 1] = t;\r
+      }\r
+      return;\r
+    }\r
+\r
+    // Use median-of-three(lo, mid, hi) to pick a partition.\r
+    // Also swap them into relative order while we are at it.\r
+\r
+    int mid = (lo + hi) >>> 1;\r
+\r
+    if (arr[lo] > arr[mid]) {\r
+      int t = arr[lo];\r
+      arr[lo] = arr[mid];\r
+      arr[lo] = arr[mid];\r
+      arr[mid] = t;\r
+    }\r
+    if (arr[mid] > arr[hi]) {\r
+      int t = arr[mid];\r
+      arr[mid] = arr[hi];\r
+      arr[hi] = t;\r
+\r
+      if (arr[lo] > arr[mid]) {\r
+        t = arr[lo];\r
+        arr[lo] = arr[mid];\r
+        arr[mid] = t;\r
+      }\r
+\r
+    }\r
+\r
+    int left = lo + 1; // start one past lo since already handled lo\r
+    int right = hi - 1; // similarly\r
+\r
+    int partition = arr[mid];\r
+\r
+    while(true){\r
+\r
+      while (arr[right] > partition)\r
+        --right;\r
+\r
+      while (left < right && arr[left] <= partition)\r
+        ++left;\r
+\r
+      if (left < right) {\r
+        int t = arr[left];\r
+        arr[left] = arr[right];\r
+        arr[right] = t;\r
+        --right;\r
+      } else\r
+        break;\r
+\r
+    }\r
+\r
+    quickSort(arr,lo,left+1);\r
+    quickSort(arr,left+1,hi);\r
+\r
+  }\r
+\r
+}\r

diff --git a/Robust/src/Benchmarks/oooJava/mergesort/MergeSort4.java b/Robust/src/Benchmarks/oooJava/mergesort/MergeSort4.java
new file mode 100644 (file)
index 0000000..e35cbfa
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/mergesort/MergeSort4.java
@@ -0,0 +1,181 @@
+/**\r
+ * 4-way split version of merge sort\r
+ */\r
+\r
+public class MergeSort4 extends MergeSort {\r
+\r
+  public static void main(String[] args) {\r
+    int problemSize= 1048576;\r
+    if(args.length>0){\r
+      problemSize=Integer.parseInt(args[0]);\r
+    }\r
+    MergeSort4 sort = new MergeSort4();\r
+    sort.run(problemSize);\r
+  }\r
+  \r
+  public MergeSort4(){\r
+    super();\r
+  }\r
+  \r
+  public void serializedSort(int A[], int B[]){\r
+\r
+    if (A.length <= QUICK_SIZE) {\r
+      quickSort(A,0,A.length-1);\r
+    } else {\r
+\r
+      int q = A.length / 4;\r
+\r
+      int[] idxs = new int[3];\r
+      idxs[0] = q;\r
+      idxs[1] = 2 * q;\r
+      idxs[2] = 3 * q;\r
+\r
+      int size0 = idxs[0];\r
+      int size1 = idxs[1] - idxs[0];\r
+      int size2 = idxs[2] - idxs[1];\r
+      int size3 = A.length - idxs[2];\r
+\r
+      int[] A_quarters0 = new int[size0];\r
+      int[] A_quarters1 = new int[size1];\r
+      int[] A_quarters2 = new int[size2];\r
+      int[] A_quarters3 = new int[size3];\r
+\r
+      for (int i = 0; i < idxs[0]; i++) {\r
+        A_quarters0[i] = A[i];\r
+      }\r
+      for (int i = idxs[0]; i < idxs[1]; i++) {\r
+        A_quarters1[i - idxs[0]] = A[i];\r
+      }\r
+      for (int i = idxs[1]; i < idxs[2]; i++) {\r
+        A_quarters2[i - idxs[1]] = A[i];\r
+      }\r
+      for (int i = idxs[2]; i < A.length; i++) {\r
+        A_quarters3[i - idxs[2]] = A[i];\r
+      }\r
+\r
+      int[] B_quarters0 = new int[size0];\r
+      int[] B_quarters1 = new int[size1];\r
+      int[] B_quarters2 = new int[size2];\r
+      int[] B_quarters3 = new int[size3];\r
+\r
+      for (int i = 0; i < idxs[0]; i++) {\r
+        B_quarters0[i] = B[i];\r
+      }\r
+      for (int i = idxs[0]; i < idxs[1]; i++) {\r
+        B_quarters1[i - idxs[0]] = B[i];\r
+      }\r
+      for (int i = idxs[1]; i < idxs[2]; i++) {\r
+        B_quarters2[i - idxs[1]] = B[i];\r
+      }\r
+      for (int i = idxs[2]; i < B.length; i++) {\r
+        B_quarters3[i - idxs[2]] = B[i];\r
+      }\r
+\r
+      int halfSize = B.length - (2 * q);\r
+      int[] B_halves0 = new int[halfSize];\r
+      int[] B_halves1 = new int[halfSize];\r
+\r
+      sort(A_quarters0, B_quarters0);\r
+      sort(A_quarters1, B_quarters1);\r
+      sort(A_quarters2, B_quarters2);\r
+      sort(A_quarters3, B_quarters3);\r
+\r
+      merge(A_quarters0, A_quarters1, B_halves0);\r
+      merge(A_quarters2, A_quarters3, B_halves1);\r
+      merge(B_halves0, B_halves1, A);\r
+      \r
+    }\r
+  \r
+  }\r
+\r
+  public void sort(int A[], int B[]) {\r
+    \r
+    if(A.length<=SERIALIZED_CUT_OFF){\r
+      serializedSort(A, B);\r
+    }else{\r
+      if (A.length <= QUICK_SIZE) {\r
+        quickSort(A,0,A.length-1);\r
+      } else {\r
+  \r
+        int q = A.length / 4;\r
+  \r
+        int[] idxs = new int[3];\r
+        idxs[0] = q;\r
+        idxs[1] = 2 * q;\r
+        idxs[2] = 3 * q;\r
+  \r
+        int size0 = idxs[0];\r
+        int size1 = idxs[1] - idxs[0];\r
+        int size2 = idxs[2] - idxs[1];\r
+        int size3 = A.length - idxs[2];\r
+  \r
+        int[] A_quarters0 = new int[size0];\r
+        int[] A_quarters1 = new int[size1];\r
+        int[] A_quarters2 = new int[size2];\r
+        int[] A_quarters3 = new int[size3];\r
+  \r
+        for (int i = 0; i < idxs[0]; i++) {\r
+          A_quarters0[i] = A[i];\r
+        }\r
+        for (int i = idxs[0]; i < idxs[1]; i++) {\r
+          A_quarters1[i - idxs[0]] = A[i];\r
+        }\r
+        for (int i = idxs[1]; i < idxs[2]; i++) {\r
+          A_quarters2[i - idxs[1]] = A[i];\r
+        }\r
+        for (int i = idxs[2]; i < A.length; i++) {\r
+          A_quarters3[i - idxs[2]] = A[i];\r
+        }\r
+  \r
+        int[] B_quarters0 = new int[size0];\r
+        int[] B_quarters1 = new int[size1];\r
+        int[] B_quarters2 = new int[size2];\r
+        int[] B_quarters3 = new int[size3];\r
+  \r
+        for (int i = 0; i < idxs[0]; i++) {\r
+          B_quarters0[i] = B[i];\r
+        }\r
+        for (int i = idxs[0]; i < idxs[1]; i++) {\r
+          B_quarters1[i - idxs[0]] = B[i];\r
+        }\r
+        for (int i = idxs[1]; i < idxs[2]; i++) {\r
+          B_quarters2[i - idxs[1]] = B[i];\r
+        }\r
+        for (int i = idxs[2]; i < B.length; i++) {\r
+          B_quarters3[i - idxs[2]] = B[i];\r
+        }\r
+  \r
+        int halfSize = B.length - (2 * q);\r
+        int[] B_halves0 = new int[halfSize];\r
+        int[] B_halves1 = new int[halfSize];\r
+  \r
+        sese p1{\r
+          sort(A_quarters0, B_quarters0);\r
+        }\r
+        sese p2{\r
+          sort(A_quarters1, B_quarters1);\r
+        }\r
+        sese p3{\r
+          sort(A_quarters2, B_quarters2);\r
+        }\r
+        sese p4{\r
+          sort(A_quarters3, B_quarters3);\r
+        }\r
+  \r
+        sese m1{\r
+          merge(A_quarters0, A_quarters1, B_halves0);\r
+        }\r
+        \r
+        sese m2{\r
+          merge(A_quarters2, A_quarters3, B_halves1);\r
+        }\r
+        \r
+        sese m3{\r
+         merge(B_halves0, B_halves1, A);\r
+        }\r
+        \r
+      }\r
+    }\r
+  }\r
+\r
+}\r

diff --git a/Robust/src/Benchmarks/oooJava/mergesort/makefile b/Robust/src/Benchmarks/oooJava/mergesort/makefile
new file mode 100644 (file)
index 0000000..c97479b
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/mergesort/makefile
@@ -0,0 +1,32 @@
+#raytracer
+PROGRAM=MergeSort4
+
+SOURCE_FILES=MergeSort4.java
+
+BUILDSCRIPT=../../../buildscript
+
+USEOOO= -ooojava 31 2  -ooodebug  
+BSFLAGS= -64bit -mainclass $(PROGRAM) -garbagestats -joptimize #-debug
+#USEOOO= -ooojava 8 2  -ooodebug  
+#BSFLAGS= -64bit -nooptimize -mainclass $(PROGRAM) -debug -garbagestats -joptimize
+DISJOINT= -disjoint -disjoint-k 1 -enable-assertions 
+
+default:
+       $(BUILDSCRIPT) -nojava $(USEOOO) $(BSFLAGS) $(DISJOINT) -o $(PROGRAM)p $(SOURCE_FILES) -builddir par
+
+single:
+       $(BUILDSCRIPT) $(BSFLAGS) -o $(PROGRAM)s -builddir sing $(SOURCE_FILES) 
+
+ooo:
+       $(BUILDSCRIPT) $(USEOOO) $(BSFLAGS) $(DISJOINT) -o $(PROGRAM)p -builddir par $(SOURCE_FILES) 
+
+clean:
+       rm -f  $(PROGRAM)p.bin $(PROGRAM)s.bin
+       rm -fr par sing
+       rm -f  *~
+       rm -f  *.dot
+       rm -f  *.png
+       rm -f  *.txt
+       rm -f  aliases.txt
+       rm -f  mlpReport*txt
+       rm -f  results*txt