Merge branch 'main' of https://github.com/coderodde/ParallelRadixSort.java

Author: coderodde

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

@@ -36,18 +36,59 @@ public final class ParallelRadixSort {
      * The array slices smaller than this number of elements will be sorted with
      * merge sort.
      */
-    static final int MERGESORT_THRESHOLD = 4096;
+    static final int DEFAULT_MERGESORT_THRESHOLD = 4096;
 
     /**
      * The array slices smaller than this number of elements will be sorted with
      * insertion sort.
      */
-    static final int INSERTION_SORT_THRESHOLD = 16;
+    static final int DEFAULT_INSERTION_SORT_THRESHOLD = 16;
 
     /**
      * The minimum workload for a thread.
      */
-    private static final int THREAD_THRESHOLD = 65536;
+    private static final int DEFAULT_THREAD_THRESHOLD = 65536;
+    
+    /**
+     * Minimum mergesort threshold.
+     */
+    private static final int MINIMUM_MERGESORT_THRESHOLD = 7;
+    
+    /**
+     * Minimum insertion sort threshold.
+     */
+    private static final int MINIMUM_INSERTION_SORT_THRESHOLD = 7;
+    
+    /**
+     * Minimum thread workload.
+     */
+    private static final int MINIMUM_THREAD_WORKLOAD = 4001;
+    
+    private static int insertionSortThreshold = DEFAULT_INSERTION_SORT_THRESHOLD;
+    private static int mergesortThreshold = DEFAULT_MERGESORT_THRESHOLD;
+    private static int threadWorkload = DEFAULT_THREAD_THRESHOLD;
+    
+    public static void setInsertionSortThreshold(
+            int newInsertionSortThreshold) {
+        insertionSortThreshold = 
+                Math.max(
+                        newInsertionSortThreshold, 
+                        MINIMUM_INSERTION_SORT_THRESHOLD);
+    }
+    
+    public static void setMergesortThreshold(int newMergesortThreshold) {
+        mergesortThreshold = 
+                Math.max(
+                    newMergesortThreshold,
+                    MINIMUM_MERGESORT_THRESHOLD);
+    }
+    
+    public static void setThreadWorkload(int newThreadWorkload) {
+        threadWorkload = 
+                Math.max(
+                        MINIMUM_THREAD_WORKLOAD,
+                        newThreadWorkload);
+    }
 
     public static void parallelSort(int[] array) {
         parallelSort(array, 0, array.length);
@@ -62,14 +103,14 @@ public static void parallelSort(int[] array, int fromIndex, int toIndex) {
             return;
         }
 
-        if (rangeLength <= INSERTION_SORT_THRESHOLD) {
+        if (rangeLength <= insertionSortThreshold) {
             insertionSort(array, fromIndex, rangeLength);
             return;
         }
 
         int[] buffer = new int[rangeLength];
 
-        if (rangeLength <= MERGESORT_THRESHOLD) {
+        if (rangeLength <= mergesortThreshold) {
             mergesort(
                     array, 
                     buffer, 
@@ -84,7 +125,7 @@ public static void parallelSort(int[] array, int fromIndex, int toIndex) {
         int threads = 
                 Math.min(
                         Runtime.getRuntime().availableProcessors(), 
-                        rangeLength / THREAD_THRESHOLD);
+                        rangeLength / threadWorkload);
 
         threads = Math.max(threads, 1);
 
@@ -172,7 +213,7 @@ private static void radixSortImpl(int[] source,
                                       int rangeLength,
                                       int recursionDepth) {
 
-        if (rangeLength <= MERGESORT_THRESHOLD) {
+        if (rangeLength <= mergesortThreshold) {
             mergesort(
                     source, 
                     target, 
@@ -235,7 +276,7 @@ private static void radixSortImpl(int[] source,
                         target,
                         source,
                         startIndexMap[i],
-                        startIndexMap[i] + bucketSizeMap[i],
+                        startIndexMap[i],
                         bucketSizeMap[i],
                         recursionDepth + 1);
             }
@@ -254,18 +295,17 @@ private static void mergesort(int[] source,
         int[] t = target;
         int sFromIndex = sourceFromIndex;
         int tFromIndex = targetFromIndex;
-        int runs = rangeLength / INSERTION_SORT_THRESHOLD;
+        int runs = rangeLength / insertionSortThreshold;
 
         for (int i = 0; i != runs; ++i) {
-            insertionSort(
-                    source,
+            insertionSort(source,
                     offset, 
-                    INSERTION_SORT_THRESHOLD);
+                    insertionSortThreshold);
 
-            offset += INSERTION_SORT_THRESHOLD;
+            offset += insertionSortThreshold;
        }
 
-        if (rangeLength % INSERTION_SORT_THRESHOLD != 0) {
+        if (rangeLength % insertionSortThreshold != 0) {
             // Sort the rightmost run that is smaller than 
             // INSERTION_SORT_THRESHOLD elements.
             insertionSort(
@@ -276,7 +316,7 @@ private static void mergesort(int[] source,
             runs++;
         }
 
-        int runWidth = INSERTION_SORT_THRESHOLD;
+        int runWidth = insertionSortThreshold;
         int passes = 0;
 
         while (runs != 1) {

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

@@ -6,13 +6,21 @@ public final class Utils {
 
     private static final int MAX_VALUE = 1000;
 
-    public static int[] createRandomIntArray(int size, Random random) {
+    public static int[] createRandomIntArray(
+            int size,
+            int maxValue,
+            Random random) {
+        
         int[] a = new int[size];
 
         for (int i = 0; i < size; i++) {
-            a[i] = random.nextInt(MAX_VALUE + 1);
+            a[i] = random.nextInt(maxValue);
         }
 
         return a;
     }
+    
+    public static int[] createRandomIntArray(int size, Random random) {
+        return createRandomIntArray(size, MAX_VALUE, random);
+    }
 }

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

@@ -4,10 +4,17 @@
 import java.util.Random;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 public final class ParallelRadixSortTest {
 
+    @BeforeClass
+    public static void setupBeforeClass() {
+        ParallelRadixSort.setInsertionSortThreshold(-1);
+        ParallelRadixSort.setMergesortThreshold(-1);
+    }
+    
     @Test
     public void testInsertionSort() {
         Random random = new Random(13L);
@@ -49,12 +56,16 @@ public void testMergesort() {
     @Test
     public void testSerialRadixSort() {
         Random random = new Random(26);
-        final int SIZE = 50_000;
-        int[] array1 = Utils.createRandomIntArray(SIZE, random);
+        final int SIZE = 128;
+        int[] array1 = Utils.createRandomIntArray(
+                SIZE, 
+                Integer.MAX_VALUE - 1,
+                random);
+        
         int[] array2 = array1.clone();
 
-        final int FROM_INDEX = 20;
-        final int TO_INDEX = SIZE - 20;
+        final int FROM_INDEX = 14;
+        final int TO_INDEX = SIZE - 14;
 
         Arrays.sort(array1, FROM_INDEX, TO_INDEX);
         ParallelRadixSort.parallelSort(
@@ -73,7 +84,7 @@ public void bruteForceTestInsertionsort() {
        for (int iteration = 0; iteration < ITERATIONS; iteration++) {
            int arrayLength = 
                    random.nextInt(
-                           ParallelRadixSort.INSERTION_SORT_THRESHOLD + 1);
+                           ParallelRadixSort.DEFAULT_INSERTION_SORT_THRESHOLD + 1);
 
            int[] array1 = Utils.createRandomIntArray(arrayLength, random);
            int[] array2 = array1.clone();
@@ -118,7 +129,7 @@ public void bruteForceTestMergesort() {
        for (int iteration = 0; iteration < ITERATIONS; iteration++) {
            int arrayLength = 
                    random.nextInt(
-                           ParallelRadixSort.MERGESORT_THRESHOLD + 1);
+                           ParallelRadixSort.DEFAULT_MERGESORT_THRESHOLD + 1);
 
            int[] array1 = Utils.createRandomIntArray(arrayLength, random);
            int[] array2 = array1.clone();