Improved a little bit radixSortImpl.

Author: coderodde

nb-configuration.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project-shared-configuration>
+    <!--
+This file contains additional configuration written by modules in the NetBeans IDE.
+The configuration is intended to be shared among all the users of project and
+therefore it is assumed to be part of version control checkout.
+Without this configuration present, some functionality in the IDE may be limited or fail altogether.
+-->
+    <spellchecker-wordlist xmlns="http://www.netbeans.org/ns/spellchecker-wordlist/1">
+        <word>multithreaded</word>
+    </spellchecker-wordlist>
+</project-shared-configuration>

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

@@ -356,19 +356,6 @@ 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;
@@ -411,22 +398,24 @@ private static void parallelRadixSortImpl(
         nonEmptyBucketIndices.shuffle(new Random());
 
         // Distributed the buckets over sorter task lists:
-        int f = 0;
-        int j = 0;
+        int frontIndex = 0;
+        int cursorIndex = 0;
         int listIndex = 0;
         int optimalSubrangeLength = rangeLength / spawnDegree;
         int packed = 0;
-        int sz = nonEmptyBucketIndices.size();
+        int numberOfNonEmptyBuckets = nonEmptyBucketIndices.size();
 
-        while (j != sz) {
-            int bucketKey = nonEmptyBucketIndices.getBucketKey(j++);
+        while (cursorIndex != numberOfNonEmptyBuckets) {
+            int bucketKey = nonEmptyBucketIndices.getBucketKey(cursorIndex++);
             int tmp = globalBucketSizeMap[bucketKey];
             packed += tmp;
 
-            if (packed >= optimalSubrangeLength || j == sz) {
+            if (packed >= optimalSubrangeLength 
+                    || cursorIndex == numberOfNonEmptyBuckets) {
+                
                 packed = 0;
 
-                for (int i = f; i != j; i++) {
+                for (int i = frontIndex; i != cursorIndex; i++) {
                     int bucketKey2 = nonEmptyBucketIndices.getBucketKey(i);
 
                     BucketKeyList bucketKeyList = 
@@ -436,7 +425,7 @@ private static void parallelRadixSortImpl(
                 }
 
                 listIndex++;
-                f = j;
+                frontIndex = cursorIndex;
             }
         }
 
@@ -557,6 +546,8 @@ private static void radixSortImpl(int[] source,
             bucketSizeMap[bucketIndex]++;
         }
 
+        startIndexMap[0] = targetFromIndex;
+        
         // Compute starting indices for buckets in the target array. This is 
         // actually just an accumulated array of bucketSizeMap, such that
         // startIndexMap[0] = 0, startIndexMap[1] = bucketSizeMap[0], ...,
@@ -571,7 +562,7 @@ private static void radixSortImpl(int[] source,
             int datum = source[i];
             int bucketKey = getBucketIndex(datum, recursionDepth);
 
-            target[targetFromIndex + startIndexMap[bucketKey] + 
+            target[/*targetFromIndex + */startIndexMap[bucketKey] + 
                                       processedMap[bucketKey]++] = datum;
         }
 
@@ -592,8 +583,8 @@ private static void radixSortImpl(int[] source,
                 radixSortImpl(
                         target,
                         source,
-                        targetFromIndex + startIndexMap[i],
-                        sourceFromIndex + startIndexMap[i],
+                        startIndexMap[i],
+                        startIndexMap[i] - targetFromIndex + sourceFromIndex,
                         bucketSizeMap[i],
                         recursionDepth + 1);
             }

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

@@ -6,8 +6,8 @@
 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_ARRAY_SIZE = 100_000_000;
+    private static final int MINIMUM_ARRAY_SIZE = 90_000_000;
     private static final int MAXIMUM_FROM_INDEX = 1313;
     private static final int MAXIMUM_SKIP_LAST_ELEMENTS = 1711;
 
@@ -25,6 +25,8 @@ private static void benchmark(boolean print) {
         long totalDuration2 = 0L;
 
         for (int iteration = 0; iteration < BENCHMARK_ITERATIONS; iteration++) {
+            System.gc();
+            
             int arrayLength = 
                     MINIMUM_ARRAY_SIZE +-
                     random.nextInt(MAXIMUM_ARRAY_SIZE - MINIMUM_ARRAY_SIZE + 1);
@@ -56,7 +58,7 @@ private static void benchmark(boolean print) {
                                 + duration1 
                                 + " ms, ParallelRadixSort.parallelSort: " 
                                 + duration2
-                                + ", agreed: " 
+                                + " ms, agreed: " 
                                 + agreed);
             }
         }

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

@@ -0,0 +1,64 @@
+package com.github.coderodde.util;
+
+import java.util.concurrent.Semaphore;
+
+/**
+ * This class provides the facilities for sorting and setting the thresholds in
+ * multithreaded environments.
+ * 
+ * @author Rodion "rodde" Efremov
+ * @version 1.6 (Jun 30, 2023)
+ */
+public final class ThreadSafeWrapper {
+    
+    private static final Semaphore MUTEX = new Semaphore(1, true);
+    
+    public static void setInsertionsortThreshold(
+            int newInsertionsortThreshold) {
+        
+        MUTEX.acquireUninterruptibly();
+        
+        ParallelRadixSort.setInsertionSortThreshold(
+                newInsertionsortThreshold);
+        
+        MUTEX.release();
+    }
+    
+    public static void setMergesortThreshold(
+            int newMergesortThreshold) {
+        
+        MUTEX.acquireUninterruptibly();
+        
+        ParallelRadixSort.setMergesortThreshold(
+                newMergesortThreshold);
+        
+        MUTEX.release();
+    }
+    
+    public static void setThreadWorkloadThreshold(
+            int newThreadWorkloadThreshold) {
+        
+        MUTEX.acquireUninterruptibly();
+        
+        ParallelRadixSort.setMinimumThreadWorkload(
+                newThreadWorkloadThreshold);
+        
+        MUTEX.release();
+    }
+    
+    public static void parallelSort(int[] array) {
+        MUTEX.acquireUninterruptibly();
+        
+        ParallelRadixSort.parallelSort(array);
+        
+        MUTEX.release();
+    }
+    
+    public static void parallelSort(int[] array, int fromIndex, int toIndex) {
+        MUTEX.acquireUninterruptibly();
+        
+        ParallelRadixSort.parallelSort(array, fromIndex, toIndex);
+        
+        MUTEX.release();
+    }
+}