Committing before code review.

Author: coderodde

src/main/java/com/github/coderodde/util/ParallelRadixSort.java

@@ -47,13 +47,13 @@ public final class ParallelRadixSort {
      * The array slices smaller than this number of elements will be sorted with
      * merge sort.
      */
-    static final int DEFAULT_MERGESORT_THRESHOLD = 4001;
+    static final int DEFAULT_MERGESORT_THRESHOLD = 307;
 
     /**
      * The array slices smaller than this number of elements will be sorted with
      * insertion sort.
      */
-    static final int DEFAULT_INSERTION_SORT_THRESHOLD = 13;
+    static final int DEFAULT_INSERTION_SORT_THRESHOLD = 17;
 
     /**
      * The minimum workload for a thread.
@@ -63,7 +63,7 @@ public final class ParallelRadixSort {
     /**
      * Minimum merge sort threshold.
      */
-    private static final int MINIMUM_MERGESORT_THRESHOLD = 1;
+    private static final int MINIMUM_MERGESORT_THRESHOLD = 100;
 
     /**
      * Minimum insertion sort threshold.
@@ -73,7 +73,7 @@ public final class ParallelRadixSort {
     /**
      * Minimum thread workload.
      */
-    private static final int MINIMUM_THREAD_WORKLOAD = 1;
+    private static final int MINIMUM_THREAD_WORKLOAD = 14047;
 
     /**
      * The current actual threshold for the insertion sort.
@@ -152,6 +152,7 @@ public static void parallelSort(int[] array, int fromIndex, int toIndex) {
         int rangeLength = toIndex - fromIndex;
 
         if (rangeLength < 2) {
+            // Trivially sorted, return.
             return;
         }
 
@@ -287,9 +288,7 @@ private static void parallelRadixSortImpl(
 
         int[][] processedMaps = new int[spawnDegree][BUCKETS];
 
-        // On linear data, all processedMaps[i][j] must be 0!
-        
-        // Make the preprocessing map independent of each thread:
+        // Make the preprocessing maps independent of each thread:
         for (int i = 1; i != spawnDegree; i++) {
             int[] partialBucketSizeMap =
                     bucketSizeCounterThreads[i - 1].getLocalBucketSizeMap();

src/main/java/com/github/coderodde/util/ParallelRadixSortBenchmark.java

@@ -12,10 +12,14 @@ final class ParallelRadixSortBenchmark {
     private static final int MAXIMUM_SKIP_LAST_ELEMENTS = 1711;
 
     public static void main(String[] args) {
-        System.out.println("Warming up...");
+        System.out.println("Warming up benchmark 1...");
         benchmark(false);
-        System.out.println("Benchmarking...");
+        System.out.println("Warming up benchmark 2...");
+        benchmark2(false);
+        System.out.println("Benchmarking 1...");
         benchmark(true);
+        System.out.println("Benchmarking 2...");
+        benchmark2(true);
         System.out.println("Benchmark done!");
     }
 
@@ -25,7 +29,6 @@ private static void benchmark(boolean print) {
         long totalDuration2 = 0L;
 
         for (int iteration = 0; iteration < BENCHMARK_ITERATIONS; iteration++) {
-            System.gc();
 
             int arrayLength = 
                     MINIMUM_ARRAY_SIZE +-
@@ -71,4 +74,56 @@ private static void benchmark(boolean print) {
                             + totalDuration2);
         }
     }
+    
+    private static void benchmark2(boolean print) {
+        Random random = new Random();
+        long totalDuration1 = 0L;
+        long totalDuration2 = 0L;
+        
+        for (int iteration = 0; iteration < BENCHMARK_ITERATIONS; iteration++) {
+            
+            int arrayLength = 
+                    MINIMUM_ARRAY_SIZE +-
+                    random.nextInt(MAXIMUM_ARRAY_SIZE - MINIMUM_ARRAY_SIZE + 1);
+                            
+            int[] array1 = new int[arrayLength];
+            int[] array2 = array1.clone();
+            
+            int fromIndex = random.nextInt(MAXIMUM_FROM_INDEX + 1);
+            int toIndex = array1.length -
+                    random.nextInt(MAXIMUM_SKIP_LAST_ELEMENTS + 1);
+            
+            long startTime = System.currentTimeMillis();
+            Arrays.parallelSort(array1, fromIndex, toIndex);
+            long endTime = System.currentTimeMillis();
+            long duration1 = endTime - startTime;
+            totalDuration1 += duration1;
+            
+            startTime = System.currentTimeMillis();
+            ParallelRadixSort.parallelSort(array2, fromIndex, toIndex);
+            endTime = System.currentTimeMillis();
+            long duration2 = endTime - startTime;
+            totalDuration2 += duration2;
+            
+            boolean agreed = Arrays.equals(array1, array2);
+            
+            if (print) {
+                System.out.println(
+                        "Arrays.parallelSort: "
+                                + duration1 
+                                + " ms, ParallelRadixSort.parallelSort: " 
+                                + duration2
+                                + " ms, agreed: " 
+                                + agreed);
+            }
+        }
+        
+        if (print) {
+            System.out.println(
+                    "Total Arrays.parallelSort duration: " 
+                            + totalDuration1
+                            + ", total ParallelRadixSort.parallelSort: " 
+                            + totalDuration2);
+        }
+    }
 }