radixSort | A GPU radix sorter using the OpenGL compute shader | GPU library

You just need to reverse your offsetting loop in countingSort (where you adjust the 'count' values to calculate the correct spot in the output array to place the values with that digit):

For the returned array it doesn't matter which of those alternatives you use, but if the tests expect you to sort the given array, so that after the call the input array has been sorted itself, then indeed, the commented-out alternatives will not work. This is because those alternatives assign to numbers instead of mutating it.

Just check the difference between the alternatives when ignoring the returned array, but looking at the given array:

The maximum number of threads should be limited to the number of cores on your system, or two times the number of cores if each core has hyper-threading. You've since updated your question to note that you only had one core using a virtual machine, and the multi-threaded version is faster with multiple cores.

Other potential issues: if the distribution of the data is not uniform, then splitting into bins will result in uneven sized bins. Using a base larger than 2, such as 256, will reduce this effect somewhat. On the initial pass, there can be cache line conflicts, where each write to a cache line on one core will invalidate all instances of that cache line on other cores.

Example code that uses a single thread to do a MSD first radix sort base 256, to create 256 bins, which are then sorted using LSD first radix sort, using 4 threads. This example uses Windows specific thread API. This relies on having reasonably uniform data so that the 256 bins are somewhat equal in size. I didn't try to use multi-threading for the initial MSD pass used to create the 256 bins, as one potential issue is cache line conflicts on the array of index updates, which would need an atomic increment operation, which may limit the performance benefit.

It's because you call

return radixSortFunc(flatten(lsdArray),maxDigits,counter);

after the first loop.

lsdArray is an array almost full of null value (because you didn't initialize them in Integer[][] lsdArray = new Integer[10][15];).

So, when you pass in int term = (array[i] % powOfTen ); with array[i] = null you get a NPE.

By the way, you also have an issue with your getMaxDigits, it's not returning the maxlength element of your array.

The problem was the color name. Instead of 'turqoise' it should've been 'turquoise'.

I've modified your code and added a driver code also:

Using base 2^16 = 65536 ends up a bit slower because L1 cache is typically 32768 bytes per core, and base 2^16 counts|indexes arrays each use 2^20 = 262144 bytes.

The issue with radix sort is that the reads are sequential, but the writes are as random as the data. Based on the comment, the program is sorting 20 million longs at 8 bytes each, so 80 MB of data, and assuming 8MB L3 cache, most of those writes are going to be cache misses. The parallel operations aren't helping much because most of the writes are competing for the same 80 MB of non-cached main memory.

To avoid this issue, I used an alternate implementation where the first pass does a most significant digit radix sort to produce 256 bins (each bin contains integers with the same most significant byte). Then each bin is sorted using conventional radix sort least significant digit first. For reasonably uniform psuedo random data, the 256 bins end up nearly equal in size, so the 80MB is split into 256 bins, about 312500 bytes each, and for 4 threads, there are 8 of these bins, 4 for reads, 4 for writes, plus the count|index arrays, and all of this will fit into the 8MB L3 16 way associative L3 cache common to all 4 cores.

For larger arrays, the initial pass could split up the array into 512 to 4096 or more bins.

I did some testing with some old C++ code I have for radix sort for sorting pseudo random 64 bit integers, using base 2^8 = 256. I tested 3 implementations, single thread least significant digit, single thread most significant digit first, and quad thread most significant digit first. When the number of integers was a power of 2, it resulted in some cache conflicts, affecting the time in some cases.

16000000 - 8 bins + index arrays fit in 8MB L3 cache.
16777216 = 2^24, 8 bins + index arrays fit in 8MB L3 cache.
30000000 - 8 bins + index arrays fit in 8MB L3 cache.
33554432 = 2^25, 8 bins + index arrays a bit larger than 8MB
36000000 - 8 bins + index arrays a bit larger than the 8MB.

The current code will not work for same length input too.

These lines: