radix sort fallback to Base on small input

Project.toml

@@ -4,6 +4,7 @@ version = "1.0.1"
 
 [deps]
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
+OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 
 [compat]
 julia = "1"

src/SortingAlgorithms.jl

@@ -3,6 +3,7 @@ __precompile__()
 module SortingAlgorithms
 
 using DataStructures
+using OffsetArrays
 using Base.Sort
 using Base.Order
 
@@ -61,9 +62,34 @@ uint_mapping(o::Lt,   x     ) = error("uint_mapping does not work with general L
 const RADIX_SIZE = 11
 const RADIX_MASK = 0x7FF
 
-function sort!(vs::AbstractVector, lo::Int, hi::Int, ::RadixSortAlg, o::Ordering, ts=similar(vs))
-    # Input checking
-    if lo >= hi;  return vs;  end
+# Fallback to default algorithm for short vectors as radix sort is slower for them
+# The threshold has been chosen because radix sort allocates an array of that size
+# and validated by benchmarks
+const RADIX_SMALL_THRESHOLD = 2^RADIX_SIZE
+
+
+function sort!(vs::AbstractVector, lo::Int, hi::Int, a::RadixSortAlg, o::Ordering)
+    if hi <= lo
+        vs
+    elseif hi - lo < RADIX_SMALL_THRESHOLD
+        sort!(vs, lo, hi, Base.Sort.defalg(vs), o)
+    else
+        _sort!(vs, lo, hi, a, o, similar(vs, lo:hi))
+    end
+end
+function sort!(vs::AbstractVector{T}, lo::Int, hi::Int, a::RadixSortAlg, o::Ordering, ts::AbstractVector{T}) where T
+    if hi <= lo
+        vs
+    elseif hi - lo < RADIX_SMALL_THRESHOLD
+        checkbounds(ts, lo:hi) # Consistently throw an error for insufficient ts.
+        sort!(vs, lo, hi, Base.Sort.defalg(vs), o)
+    else
+        _sort!(vs, lo, hi, a, o, ts)
+    end
+end
+function _sort!(vs::AbstractVector{T}, lo::Int, hi::Int, a::RadixSortAlg, o::Ordering, ts::AbstractVector{T}) where T
+    checkbounds(vs, lo:hi)
+    checkbounds(ts, lo:hi)
 
     # Make sure we're sorting a bits type
     T = Base.Order.ordtype(o, vs)

test/runtests.jl

@@ -3,44 +3,44 @@ using Test
 using StatsBase
 using Random
 
-a = rand(1:10000, 1000)
-
-for alg in [TimSort, HeapSort, RadixSort]
-    b = sort(a, alg=alg)
-    @test issorted(b)
-    ix = sortperm(a, alg=alg)
-    b = a[ix]
-    @test issorted(b)
-    @test a[ix] == b
-
-    b = sort(a, alg=alg, rev=true)
-    @test issorted(b, rev=true)
-    ix = sortperm(a, alg=alg, rev=true)
-    b = a[ix]
-    @test issorted(b, rev=true)
-    @test a[ix] == b
-
-    b = sort(a, alg=alg, by=x->1/x)
-    @test issorted(b, by=x->1/x)
-    ix = sortperm(a, alg=alg, by=x->1/x)
-    b = a[ix]
-    @test issorted(b, by=x->1/x)
-    @test a[ix] == b
-
-    c = copy(a)
-    permute!(c, ix)
-    @test c == b
-
-    invpermute!(c, ix)
-    @test c == a
-
-    if alg != RadixSort  # RadixSort does not work with Lt orderings
-        c = sort(a, alg=alg, lt=(>))
+for a in [rand(1:10000, 2200), rand(1:10000, 1000)]
+    for alg in [TimSort, HeapSort, RadixSort]
+        b = sort(a, alg=alg)
+        @test issorted(b)
+        ix = sortperm(a, alg=alg)
+        b = a[ix]
+        @test issorted(b)
+        @test a[ix] == b
+
+        b = sort(a, alg=alg, rev=true)
+        @test issorted(b, rev=true)
+        ix = sortperm(a, alg=alg, rev=true)
+        b = a[ix]
+        @test issorted(b, rev=true)
+        @test a[ix] == b
+
+        b = sort(a, alg=alg, by=x->1/x)
+        @test issorted(b, by=x->1/x)
+        ix = sortperm(a, alg=alg, by=x->1/x)
+        b = a[ix]
+        @test issorted(b, by=x->1/x)
+        @test a[ix] == b
+
+        c = copy(a)
+        permute!(c, ix)
+        @test c == b
+
+        invpermute!(c, ix)
+        @test c == a
+
+        if alg != RadixSort  # RadixSort does not work with Lt orderings
+            c = sort(a, alg=alg, lt=(>))
+            @test b == c
+        end
+
+        c = sort(a, alg=alg, by=x->1/x)
         @test b == c
     end
-
-    c = sort(a, alg=alg, by=x->1/x)
-    @test b == c
 end
 
 randnans(n) = reinterpret(Float64,[rand(UInt64)|0x7ff8000000000000 for i=1:n])
@@ -54,7 +54,7 @@ end
 
 Random.seed!(0xdeadbeef)
 
-for n in [0:10..., 100, 101, 1000, 1001]
+for n in [0:10..., 100, 101, 1000, 1001, 2200, 2201]
     r = 1:10
     v = rand(1:10,n)
     h = fit(Histogram, v, r)