Removed dead code.

Author: coderodde

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

@@ -899,49 +899,6 @@ private static void radixSortImpl(long[] source,
         }
     }
 
-    /**
-     * Merges the runs 
-     * {@code source[leftIndex], ..., source[leftIndexBound - 1]} and
-     * {@code source[leftBoundIndex, ..., source[rightIndexBound - 1]} into one
-     * sorted run.
-     * 
-     * @param source          the source array.
-     * @param target          the target array.
-     * @param leftIndex       the lowest index of the left run to merge.
-     * @param leftIndexBound  the lowest index of the right run to merge.
-     * @param rightIndexBound the one past last index of the right run to merge.
-     * @param targetIndex     the starting index of the resulting, merged run.
-     */
-    private static void merge(int[] source,
-                              int[] target,
-                              int leftIndex,
-                              int leftIndexBound,
-                              int rightIndexBound,
-                              int targetIndex) {
-        int rightIndex = leftIndexBound;
-        
-        while (leftIndex != leftIndexBound && rightIndex != rightIndexBound) {
-            target[targetIndex++] = 
-                    source[leftIndex] < source[rightIndex] ?
-                    source[leftIndex++] :
-                    source[rightIndex++];
-        }
-        
-        System.arraycopy(
-                source,
-                leftIndex,
-                target,
-                targetIndex,
-                leftIndexBound - leftIndex);
-        
-        System.arraycopy(
-                source, 
-                rightIndex, 
-                target, 
-                targetIndex, 
-                rightIndexBound - rightIndex);
-    }
-    
     /**
      * Returns the bucket index of the {@code element} at the top-most recursion
      * level.

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

@@ -12,18 +12,21 @@ public final class ParallelRadixSortBenchmark {
     private static final int MAXIMUM_SKIP_LAST_ELEMENTS = 1711;
 
     public static void main(String[] args) {
-        System.out.println("Warming up benchmark 1...");
         benchmark(false);
-        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!");
     }
 
     private static void benchmark(boolean print) {
+        System.out.println(
+                "<<< " + 
+                        (print ? "Benchmarking" : "Warming") 
+                        + " on sorted data >>>");
+        
         Random random = new Random();
         long totalDuration1 = 0L;
         long totalDuration2 = 0L;
@@ -34,7 +37,7 @@ private static void benchmark(boolean print) {
                     MINIMUM_ARRAY_SIZE +-
                     random.nextInt(MAXIMUM_ARRAY_SIZE - MINIMUM_ARRAY_SIZE + 1);
 
-            long[] array1 = Utils.createRandomLongArray(arrayLength, random);
+            long[] array1 = Utils.createSortedLongArray(arrayLength);
             long[] array2 = array1.clone();
 
             int fromIndex = random.nextInt(MAXIMUM_FROM_INDEX + 1);
@@ -76,6 +79,11 @@ private static void benchmark(boolean print) {
     }
 
     private static void benchmark2(boolean print) {
+        System.out.println(
+                "<<< " + 
+                        (print ? "Benchmarking" : "Warming") 
+                        + " on random data >>>");
+        
         Random random = new Random();
         long totalDuration1 = 0L;
         long totalDuration2 = 0L;

src/main/java/io/github/coderodde/util/Utils.java

@@ -14,4 +14,15 @@ public static long[] createRandomLongArray(int size, Random random) {
 
         return a;
     }
+    
+    public static long[] createSortedLongArray(int size) {
+        
+        long[] a = new long[size];
+        
+        for (int i = 0; i < size; i++) {
+            a[i] = 0L;
+        }
+        
+        return a;
+    }
 }