The algorithm passes the unit tests and added the benchmark class.

Author: coderodde

.gitignore

@@ -1,2 +1,3 @@
 nbproject
-target
+target
+nbactions.xml

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

@@ -356,18 +356,18 @@ private static void parallelRadixSortImpl(
             }
         }
 
-        int[] testArray = source.clone();
-        
-        Arrays.sort(testArray);
-        
-        for (int i = 0; i != testArray.length; i++) {
-            int sourceElement = target[i];
-            int testElement = testArray[i];
-            
-            if (sourceElement != testElement) {
-                System.out.println("DEBUG: " + sourceElement + " vs. " + testElement + " at index " + i);
-            }
-        }
+//        int[] testArray = source.clone();
+//        
+//        Arrays.sort(testArray);
+//        
+//        for (int i = 0; i != testArray.length; i++) {
+//            int sourceElement = target[i];
+//            int testElement = testArray[i];
+//            
+//            if (sourceElement != testElement) {
+//                System.out.println("DEBUG: " + sourceElement + " vs. " + testElement + " at index " + i);
+//            }
+//        }
 
         if (recursionDepth == DEEPEST_RECURSION_DEPTH) {
             // Nowhere to recur, all bytes are processed. Return.

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

@@ -0,0 +1,72 @@
+package com.github.coderodde.util;
+
+import java.util.Arrays;
+import java.util.Random;
+
+final class ParallelRadixSortBenchmark {
+    
+    private static final int BENCHMARK_ITERATIONS = 20;
+    private static final int MAXIMUM_ARRAY_SIZE = 50_000_000;
+    private static final int MINIMUM_ARRAY_SIZE = 40_000_000;
+    private static final int MAXIMUM_FROM_INDEX = 1313;
+    private static final int MAXIMUM_SKIP_LAST_ELEMENTS = 1711;
+    
+    public static void main(String[] args) {
+        System.out.println("Warming up...");
+        benchmark(false);
+        System.out.println("Benchmarking...");
+        benchmark(true);
+        System.out.println("Benchmark done!");
+    }
+    
+    private static void benchmark(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 = Utils.createRandomIntArray(arrayLength, random);
+            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
+                                + ", agreed: " 
+                                + agreed);
+            }
+        }
+        
+        if (print) {
+            System.out.println(
+                    "Total Arrays.parallelSort duration: " 
+                            + totalDuration1
+                            + ", total ParallelRadixSort.parallelSort: " 
+                            + totalDuration2);
+        }
+    }
+}

src/test/java/com/github/coderodde/util/ParallelRadixSortTest.java

@@ -11,12 +11,12 @@ public final class ParallelRadixSortTest {
 
     @BeforeClass
     public static void setupBeforeClass() {
-        ParallelRadixSort.setInsertionSortThreshold(-1);
-        ParallelRadixSort.setMergesortThreshold(-1);
-        ParallelRadixSort.setMinimumThreadWorkload(-1);
+//        ParallelRadixSort.setInsertionSortThreshold(-1);
+//        ParallelRadixSort.setMergesortThreshold(-1);
+//        ParallelRadixSort.setMinimumThreadWorkload(-1);
     }
 
-//    @Test
+    @Test
     public void testInsertionSort() {
         Random random = new Random(13L);
 
@@ -33,7 +33,7 @@ public void testInsertionSort() {
         assertTrue(Arrays.equals(array1, array2));
     }
 
-//    @Test
+    @Test
     public void testMergesort() {
         Random random = new Random(123L);
 
@@ -54,7 +54,7 @@ public void testMergesort() {
         assertTrue(Arrays.equals(array1, array2));
    }
 
-//    @Test
+    @Test
     public void testSerialRadixSort() {
         Random random = new Random(26);
 
@@ -84,21 +84,18 @@ public void testSerialRadixSort() {
     public void testParallelRadixSort() {
         Random random = new Random(29);
 
-        final int SIZE = 256;
+        final int SIZE = 5_000_000;
+        final int FROM_INDEX = 13;
+        final int TO_INDEX = SIZE - 17;
 
-        int[] array1 = Utils.createLinearDebugIntArray(SIZE, random);
-//        int[] array1 = Utils.createRandomIntArray(
-//                SIZE, 
-//                Integer.MAX_VALUE - 1,
-//                random);
+        int[] array1 = 
+                Utils.createRandomIntArray(
+                        SIZE, 
+                        Integer.MAX_VALUE, 
+                        random);
 
         int[] array2 = array1.clone();
 
-//        final int FROM_INDEX = 13;
-//        final int TO_INDEX = SIZE - 15;
-        final int FROM_INDEX = 0;
-        final int TO_INDEX = SIZE;
-        
         Arrays.sort(array1, FROM_INDEX, TO_INDEX);
         ParallelRadixSort.parallelSort(
                 array2, 
@@ -108,7 +105,7 @@ public void testParallelRadixSort() {
         assertTrue(Arrays.equals(array1, array2));
     }
 
-//   @Test
+   @Test
    public void bruteForceTestInsertionsort() {
        final int ITERATIONS = 200;
        Random random = new Random(432);
@@ -153,7 +150,7 @@ public void bruteForceTestInsertionsort() {
        }
    }
 
-//   @Test
+   @Test
    public void bruteForceTestMergesort() {
        final int ITERATIONS = 200;
        Random random = new Random(3);