Add SubArray optimization to sorting (#52072)

base/sort.jl

@@ -528,6 +528,34 @@ internal or recursive calls.
 """
 function _sort! end
 
+# TODO: delete this optimization when views have no overhead.
+const UnwrappableSubArray = SubArray{T, 1, <:AbstractArray{T}, <:Tuple{AbstractUnitRange, Vararg{Number}}, true} where T
+"""
+ SubArrayOptimization(next) <: Algorithm
+
+Unwrap certain known SubArrays because views have a performance overhead 😢
+
+Specifically, unwraps some instances of the type
+
+ $UnwrappableSubArray
+"""
+struct SubArrayOptimization{T <: Algorithm} <: Algorithm
+ next::T
+end
+
+_sort!(v::AbstractVector, a::SubArrayOptimization, o::Ordering, kw) = _sort!(v, a.next, o, kw)
+function _sort!(v::UnwrappableSubArray, a::SubArrayOptimization, o::Ordering, kw)
+ @getkw lo hi
+ # @assert v.stride1 == 1
+ parent = v.parent
+ if parent isa Array && !(parent isa Vector) && hi - lo < 100
+ # vec(::Array{T, ≠1}) allocates and is therefore somewhat expensive.
+ # We don't want that for small inputs.
+ _sort!(v, a.next, o, kw)
+ else
+ _sort!(vec(parent), a.next, o, (;kw..., lo = lo + v.offset1, hi = hi + v.offset1))
+ end
+end
 
 """
  MissingOptimization(next) <: Algorithm
@@ -1223,14 +1251,16 @@ future versions of Julia.
 If `next` is stable, then `InitialOptimizations(next)` is also stable.
 
 The specific optimizations attempted by `InitialOptimizations` are
-[`MissingOptimization`](@ref), [`BoolOptimization`](@ref), dispatch to
-[`InsertionSort`](@ref) for inputs with `length <= 10`, and [`IEEEFloatOptimization`](@ref).
-"""
-InitialOptimizations(next) = MissingOptimization(
- BoolOptimization(
- Small{10}(
- IEEEFloatOptimization(
- next))))
+[`SubArrayOptimization`](@ref), [`MissingOptimization`](@ref), [`BoolOptimization`](@ref),
+dispatch to [`InsertionSort`](@ref) for inputs with `length <= 10`, and
+[`IEEEFloatOptimization`](@ref).
+"""
+InitialOptimizations(next) = SubArrayOptimization(
+ MissingOptimization(
+ BoolOptimization(
+ Small{10}(
+ IEEEFloatOptimization(
+ next)))))
 """
  DEFAULT_STABLE
 

test/sorting.jl

@@ -791,9 +791,9 @@ end
  let
  requires_uint_mappable = Union{Base.Sort.RadixSort, Base.Sort.ConsiderRadixSort,
  Base.Sort.CountingSort, Base.Sort.ConsiderCountingSort,
- typeof(Base.Sort.DEFAULT_STABLE.next.next.big.next.yes),
- typeof(Base.Sort.DEFAULT_STABLE.next.next.big.next.yes.big),
- typeof(Base.Sort.DEFAULT_STABLE.next.next.big.next.yes.big.next)}
+ typeof(Base.Sort.DEFAULT_STABLE.next.next.next.big.next.yes),
+ typeof(Base.Sort.DEFAULT_STABLE.next.next.next.big.next.yes.big),
+ typeof(Base.Sort.DEFAULT_STABLE.next.next.next.big.next.yes.big.next)}
 
  function test_alg(kw, alg, float=true)
  for order in [Base.Forward, Base.Reverse, Base.By(x -> x^2)]