Found and fixed one bug in BucketInserterThread.

Author: coderodde

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

@@ -1,6 +1,7 @@
 package com.github.coderodde.util;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Random;
 
@@ -286,6 +287,8 @@ 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:
         for (int i = 1; i != spawnDegree; i++) {
             int[] partialBucketSizeMap =
@@ -318,7 +321,7 @@ private static void parallelRadixSortImpl(
                             recursionDepth);
 
             sourceStartIndex += subrangeLength;
-            targetStartIndex += subrangeLength;
+//            targetStartIndex += subrangeLength;
 
             bucketInserterThread.start();
             bucketInserterThreads[i] = bucketInserterThread;
@@ -353,6 +356,19 @@ 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);
+            }
+        }
+        
         if (recursionDepth == DEEPEST_RECURSION_DEPTH) {
             // Nowhere to recur, all bytes are processed. Return.
             return;

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

@@ -23,4 +23,32 @@ public static int[] createRandomIntArray(
     public static int[] createRandomIntArray(int size, Random random) {
         return createRandomIntArray(size, MAX_VALUE, random);
     }
+    
+    public static int[] createDebugIntArray(int size, Random random) {
+        int[] array = new int[size];
+        
+        for (int i = 0; i != size; i++) {
+            array[i] = random.nextInt(256) << 24;
+        }
+        
+        return array;
+    }
+    
+    public static int[] createLinearDebugIntArray(int size, Random random) {
+        int[] array = new int[size];
+        
+        for (int i = 0; i != size; i++) {
+            array[i] = i << 24;
+        }
+        
+        for (int i = 0; i != 2 * size; i++) {
+            int index1 = random.nextInt(size);
+            int index2 = random.nextInt(size);
+            int a = array[index1];
+            array[index1] = array[index2];
+            array[index2] = a;
+        }
+        
+        return array;
+    }
 }

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

@@ -84,17 +84,20 @@ public void testSerialRadixSort() {
     public void testParallelRadixSort() {
         Random random = new Random(29);
 
-        final int SIZE = 200;
+        final int SIZE = 256;
 
-        int[] array1 = Utils.createRandomIntArray(
-                SIZE, 
-                Integer.MAX_VALUE - 1,
-                random);
+        int[] array1 = Utils.createLinearDebugIntArray(SIZE, random);
+//        int[] array1 = Utils.createRandomIntArray(
+//                SIZE, 
+//                Integer.MAX_VALUE - 1,
+//                random);
 
         int[] array2 = array1.clone();
 
-        final int FROM_INDEX = 13;
-        final int TO_INDEX = SIZE - 15;
+//        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(