From: yeom <yeom>
Date: Mon, 26 Jul 2010 22:55:37 +0000 (+0000)
Subject: changes.
X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=cc769d85805dec0b4e3c5e912be771896474dd0a;p=IRC.git

changes.
---

diff --git a/Robust/src/Benchmarks/oooJava/mergesort/BMergeSort4.java b/Robust/src/Benchmarks/oooJava/mergesort/BMergeSort4.java
index ae7f5c35..74983e95 100644
--- a/Robust/src/Benchmarks/oooJava/mergesort/BMergeSort4.java
+++ b/Robust/src/Benchmarks/oooJava/mergesort/BMergeSort4.java
@@ -5,18 +5,18 @@
 public class MergeSort4 extends MergeSort {
 
   public static void main(String[] args) {
-    int problemSize= 1048576;
-    if(args.length>0){
-      problemSize=Integer.parseInt(args[0]);
+    int problemSize = 4194304;
+    if (args.length > 0) {
+      problemSize = Integer.parseInt(args[0]);
     }
     MergeSort4 sort = new MergeSort4();
     sort.run(problemSize);
   }
-  
-  public MergeSort4(){
+
+  public MergeSort4() {
     super();
   }
-  
+
   public void runWorkAndTest() {
     sese run{
       int output[]=sort(input, 0, input.length);
@@ -26,165 +26,174 @@ public class MergeSort4 extends MergeSort {
     }
   }
 
-
   public int[] serializedSort(int A[], int low, int high) {
-    if(A.length<=SERIALIZED_CUT_OFF){
-      return serializedSort(A, low, high);
-    }else{
-      if (A.length <= QUICK_SIZE) {
-	int[] R=new int[high-low];
-	int max=R.length;
-	int j=low;
-	for(int i=0;i<max;i++) {
-	  R[i]=A[j++];
-	}
-	quickSort(R, 0, R.length);
-	return R;
-      } else {
-	int q = A.length / 4;
-  
-        int idxs0 = q;
-        int idxs1 = 2 * q;
-        int idxs2 = 3 * q;
-	
-	int[] A_quarters0 = serializedSort(A, 0, idxs0);
-	int[] A_quarters1 = serializedSort(A, idxs0, idxs1);
-	int[] A_quarters2 = serializedSort(A, idxs1, idxs2);
-        int[] A_quarters3 = serializedSort(A, idxs2, A.length);
-
-	int[] R=new int[high-low];
-
-	merge(A_quarters0, A_quarters1, A_quarters2, A_quartes3, R);
-	return R;
+
+    int length = high - low;
+
+    if (length <= QUICK_SIZE) {
+      int[] R = new int[length];
+      int max = R.length;
+      int j = low;
+      for (int i = 0; i < max; i++) {
+        R[i] = A[j++];
       }
+      quickSort(R, 0, R.length - 1);
+      return R;
+    } else {
+
+      int q = length / 4;
+      int idxs0 = q + low;
+      int idxs1 = (2 * q) + low;
+      int idxs2 = (3 * q) + low;
+
+      int[] A_quarters0 = serializedSort(A, low, idxs0);
+      int[] A_quarters1 = serializedSort(A, idxs0, idxs1);
+      int[] A_quarters2 = serializedSort(A, idxs1, idxs2);
+      int[] A_quarters3 = serializedSort(A, idxs2, idxs2 + q);
+
+      int[] R = new int[high - low];
+
+      merge(A_quarters0, A_quarters1, A_quarters2, A_quarters3, R);
+      return R;
     }
   }
 
   public int[] sort(int A[], int low, int high) {
-    if(A.length<=SERIALIZED_CUT_OFF){
+    
+    int length=high-low;
+    
+    if (length <= SERIALIZED_CUT_OFF) {
       return serializedSort(A, low, high);
-    }else{
-      if (A.length <= QUICK_SIZE) {
-	int[] R=new int[high-low];
-	int max=R.length;
-	int j=low;
-	for(int i=0;i<max;i++) {
-	  R[i]=A[j++];
-	}
-	quickSort(R, 0, R.length);
-	return R;
+    } else {
+      if (length <= QUICK_SIZE) {
+        int[] R = new int[length];
+        int max = R.length;
+        int j = low;
+        for (int i = 0; i < max; i++) {
+          R[i] = A[j++];
+        }
+        quickSort(R, 0, R.length-1);
+        return R;
       } else {
-	int q = A.length / 4;
-  
-        int idxs0 = q;
-        int idxs1 = 2 * q;
-        int idxs2 = 3 * q;
-	
+        
+        int q=length/4;
+        int idxs0 = q+low;
+        int idxs1 = (2 * q)+low;
+        int idxs2 = (3 * q)+low;
+
         sese p1{
-	  int[] A_quarters0 = sort(A, 0, idxs0);
+          int[] A_quarters0 = sort(A, low, idxs0);
         }
         sese p2{
-	  int[] A_quarters1 = sort(A, idxs0, idxs1);
+          int[] A_quarters1 = sort(A, idxs0, idxs1);
         }
         sese p3{
-	  int[] A_quarters2 = sort(A, idxs1, idxs2);
+          int[] A_quarters2 = sort(A, idxs1, idxs2);
         }
-	//don't spawn off sese for last one...
-        int[] A_quarters3 = sort(A, idxs2, A.length);
+        // don't spawn off sese for last one...
+        int[] A_quarters3 = sort(A, idxs2, idxs2+q);
 
-	int[] R=new int[high-low];
+        int[] R = new int[high - low];
 
-	merge(A_quarters0, A_quarters1, A_quarters2, A_quartes3, R);
-	return R;
+        merge(A_quarters0, A_quarters1, A_quarters2, A_quarters3, R);
+        return R;
       }
     }
   }
 
-  public static void merge(int []a1, int []a2, int []a3, int[] a4, int[] a) {
-    int i1=0;
-    int i2=0;
-    int i3=0;
-    int i4=0;
-    int alength=a.length;
-    int v1=a1[0];
-    int v2=a2[0];
-    int v3=a3[0];
-    int v4=a4[0];
-    int v1m=a1.length;
-    int v2m=a2.length;
-    int v3m=a3.length;
-    int v4m=a4.length;
-    for(int i=0;i<alength;i++) {
-      if (v1<v2) {
-	if (v1<v3) {
-	  if (v1<v4) {
-	    a[i]=v1;
-	    //v1 smallest
-	    if (i1<v1m) {
-	      v1=a1[i1++];
-	    } else {
-	      v1=2147483647;
-	    }
-	  } else {
-	    //v4 smalles
-	    if (i4<v4m) {
-	      v4=a4[i4++];
-	    } else {
-	      v4=2147483647;
-	    }
-	  }
-	} else {
-	  if (v3<v4) {
-	    //v3 smallest
-	    if (i3<v3m) {
-	      v3=a3[i3++];
-	    } else {
-	      v3=2147483647;
-	    }
-	  } else {
-	    //v4 smallest
-	    if (i4<v4m) {
-	      v4=a4[i4++];
-	    } else {
-	      v4=2147483647;
-	    }
-	  }
-	}
+  public static void merge(int[] a1, int[] a2, int[] a3, int[] a4, int[] a) {
+    int i1 = 0;
+    int i2 = 0;
+    int i3 = 0;
+    int i4 = 0;
+    int alength = a.length;
+    int v1 = a1[0];
+    int v2 = a2[0];
+    int v3 = a3[0];
+    int v4 = a4[0];
+    int v1m = a1.length;
+    int v2m = a2.length;
+    int v3m = a3.length;
+    int v4m = a4.length;
+    for (int i = 0; i < alength; i++) {
+      if (v1 < v2) {
+        if (v1 < v3) {
+          if (v1 < v4) {
+            a[i] = v1;
+            // v1 smallest
+            if (i1 < v1m) {
+              v1 = a1[i1++];
+            } else {
+              v1 = 2147483647;
+            }
+          } else {
+            a[i] = v4;
+            // v4 smalles
+            if (i4 < v4m) {
+              v4 = a4[i4++];
+            } else {
+              v4 = 2147483647;
+            }
+          }
+        } else {
+          if (v3 < v4) {
+            a[i] = v3;
+            // v3 smallest
+            if (i3 < v3m) {
+              v3 = a3[i3++];
+            } else {
+              v3 = 2147483647;
+            }
+          } else {
+            a[i] = v4;
+            // v4 smallest
+            if (i4 < v4m) {
+              v4 = a4[i4++];
+            } else {
+              v4 = 2147483647;
+            }
+          }
+        }
       } else {
-	if (v2<v3) {
-	  if (v2<v4) {
-	    //v2 smallest
-	    if (i2<v2m) {
-	      v2=a2[i2++];
-	    } else {
-	      v2=2147483647;
-	    }
-	  } else {
-	    //v4 smallest
-	    if (i4<v4m) {
-	      v4=a4[i4++];
-	    } else {
-	      v4=2147483647;
-	    }
-	  }
-	} else {
-	  if (v3<v4) {
-	    //v3 smallest
-	    if (i3<v3m) {
-	      v3=a3[i3++];
-	    } else {
-	      v3=2147483647;
-	    }
-	  } else {
-	    //v4 smallest
-	    if (i4<v4m) {
-	      v4=a4[i4++];
-	    } else {
-	      v4=2147483647;
-	    }
-	  }
-	}
+        if (v2 < v3) {
+          if (v2 < v4) {
+            a[i] = v2;
+            // v2 smallest
+            if (i2 < v2m) {
+              v2 = a2[i2++];
+            } else {
+              v2 = 2147483647;
+            }
+          } else {
+            a[i] = v4;
+            // v4 smallest
+            if (i4 < v4m) {
+              v4 = a4[i4++];
+            } else {
+              v4 = 2147483647;
+            }
+          }
+        } else {
+          if (v3 < v4) {
+            a[i] = v3;
+            // v3 smallest
+            if (i3 < v3m) {
+              v3 = a3[i3++];
+            } else {
+              v3 = 2147483647;
+            }
+          } else {
+            a[i] = v4;
+            // v4 smallest
+            if (i4 < v4m) {
+              v4 = a4[i4++];
+            } else {
+              v4 = 2147483647;
+            }
+          }
+        }
       }
     }
   }
+
 }
diff --git a/Robust/src/Benchmarks/oooJava/mergesort/MergeSort.java b/Robust/src/Benchmarks/oooJava/mergesort/MergeSort.java
index 8cf566f6..755cfbfd 100644
--- a/Robust/src/Benchmarks/oooJava/mergesort/MergeSort.java
+++ b/Robust/src/Benchmarks/oooJava/mergesort/MergeSort.java
@@ -14,26 +14,25 @@ public class MergeSort {
   /* Threshold values */
 
   // Cutoff for when to do sequential versus parallel merges
-  public static  int MERGE_SIZE;
+  public static int MERGE_SIZE;
 
   // Cutoff for when to do sequential quicksort versus parallel mergesort
-  public static  int QUICK_SIZE;
+  public static int QUICK_SIZE;
 
   // Cutoff for when to use insertion-sort instead of quicksort
-  public static  int INSERTION_SIZE;
-  
-  public static  int SERIALIZED_CUT_OFF;
+  public static int INSERTION_SIZE;
 
+  public static int SERIALIZED_CUT_OFF;
 
   protected int[] input;
   protected int[] result;
   protected int size;
 
   public void run(int size) {
-    this.size=size;
-    long startT=System.currentTimeMillis();
+    this.size = size;
+    long startT = System.currentTimeMillis();
     initialize();
-    System.out.println("init time="+(System.currentTimeMillis()-startT));
+    System.out.println("init time=" + (System.currentTimeMillis() - startT));
     runWorkAndTest();
   }
 
@@ -44,9 +43,9 @@ public class MergeSort {
   }
 
   public void initialize() {
-    
-    SERIALIZED_CUT_OFF=size/16;
-      
+
+    SERIALIZED_CUT_OFF = size / 32;
+
     input = new int[size];
     result = new int[size];
 
@@ -65,12 +64,12 @@ public class MergeSort {
     sese run{
       sort(input);
     }
-    sese test{
-      checkSorted(input);
-    }
+//    sese test{
+//      checkSorted(input);
+//    }
   }
-  
-  public void sort(int A[]){
+
+  public void sort(int A[]) {
   }
 
   protected void checkSorted(int[] array) {
@@ -86,46 +85,50 @@ public class MergeSort {
 
   protected void merge(int A[], int B[], int out[]) {
 
-    if (A.length <= MERGE_SIZE) {
+    if (A.length <= SERIALIZED_CUT_OFF) {
       sequentialMerge(A, B, out);
     } else {
-      int aHalf = A.length >>> 1; /* l33t shifting h4x!!! */
-      int bSplit = findSplit(A[aHalf], B);
+      if (A.length <= MERGE_SIZE) {
+        sequentialMerge(A, B, out);
+      } else {
+        int aHalf = A.length >>> 1; /* l33t shifting h4x!!! */
+        int bSplit = findSplit(A[aHalf], B);
+
+        int[] A_split0 = new int[aHalf];
+        int[] A_split1 = new int[A.length - aHalf];
+        for (int i = 0; i < aHalf; i++) {
+          A_split0[i] = A[i];
+        }
+        for (int i = aHalf; i < A.length; i++) {
+          A_split1[i - aHalf] = A[i];
+        }
 
-      int[] A_split0 = new int[aHalf];
-      int[] A_split1 = new int[A.length - aHalf];
-      for (int i = 0; i < aHalf; i++) {
-        A_split0[i] = A[i];
-      }
-      for (int i = aHalf; i < A.length; i++) {
-        A_split1[i - aHalf] = A[i];
-      }
+        int[] B_split0 = new int[bSplit];
+        int[] B_split1 = new int[B.length - bSplit];
+        for (int i = 0; i < bSplit; i++) {
+          B_split0[i] = B[i];
+        }
+        for (int i = bSplit; i < B.length; i++) {
+          B_split1[i - bSplit] = B[i];
+        }
 
-      int[] B_split0 = new int[bSplit];
-      int[] B_split1 = new int[B.length - bSplit];
-      for (int i = 0; i < bSplit; i++) {
-        B_split0[i] = B[i];
-      }
-      for (int i = bSplit; i < B.length; i++) {
-        B_split1[i - bSplit] = B[i];
-      }
+        int outSplit = aHalf + bSplit;
+        int[] out_split0 = new int[outSplit];
+        int[] out_split1 = new int[out.length - outSplit];
 
-      int outSplit = aHalf + bSplit;
-      int[] out_split0 = new int[outSplit];
-      int[] out_split1 = new int[out.length - outSplit];
+        merge(A_split0, B_split0, out_split0);
+        merge(A_split1, B_split1, out_split1);
+
+        for (int i = 0; i < outSplit; i++) {
+          out[i] = out_split0[i];
+        }
+        for (int i = outSplit; i < out.length; i++) {
+          out[i] = out_split1[i - outSplit];
+        }
 
-      merge(A_split0, B_split0, out_split0);
-      merge(A_split1, B_split1, out_split1);
-      
-      for (int i = 0; i < outSplit; i++) {
-        out[i]=out_split0[i]; 
-      }
-      for (int i = outSplit; i < out.length; i++) {
-        out[i]=out_split1[i - outSplit];
       }
-      
     }
-    
+
   }
 
   /** A standard sequential merge **/
@@ -164,8 +167,8 @@ public class MergeSort {
 
   /** A standard sequential quicksort **/
   protected void quickSort(int array[], int lo, int hi) {
-//    int lo = 0;
-//    int hi = array.length - 1;
+    // int lo = 0;
+    // int hi = array.length - 1;
     // If under threshold, use insertion sort
     int[] arr = array;
     if (hi - lo + 1l <= INSERTION_SIZE) {
@@ -210,7 +213,7 @@ public class MergeSort {
 
     int partition = arr[mid];
 
-    while(true){
+    while (true) {
 
       while (arr[right] > partition)
         --right;
@@ -228,8 +231,8 @@ public class MergeSort {
 
     }
 
-    quickSort(arr,lo,left+1);
-    quickSort(arr,left+1,hi);
+    quickSort(arr, lo, left + 1);
+    quickSort(arr, left + 1, hi);
 
   }