union-types: use insertion (stable) sort instead of qsort

[vtjnash]

Different platforms implement qsort differently, leading to
platform-specific errors. This is a quick port of the ml_matches
algorithm for use instead. For small unions (almost always), this should
also be slightly faster, though insignificant.

Refs #45874

[quinnj]

Totally forgot about this code. Silly qsort on windows.

[LilithHafner]

Do we have any case where the compiler doesn't already do this optimization?
The only case I can think of would be stateful getindex

function getindex(x::LogAtReadArray, i::Int)
    println(i)
    getindex(x.data, i)
end

which isn't particularly compelling.

[vtjnash]

any moderately complex or non-inlined getindex might not be eliminated

[LilithHafner]

I guess those likely exist, I've just never seen a subtype of AbstractVector with a complex getindex.

[vtjnash]

any non-inlined lt user-method will also disallow this from occurring as a direct optimization (it would be semantically invalid)

[LilithHafner]

I don't see how that would be semantically invalid, but I'm not familiar with the relevant compiler semantics.

[KristofferC]

It could throw for example.

[LilithHafner]

I'm still not seeing it. Even if lt throws, y = v[j-1]; lt(o, x, y) is indistinguishable from lt(o, x, v[j-1]).

As a sanity check,

using Primes

@noinline function lt(x, y)
    isprime(x) && error()
    x < y
end

@code_llvm sort!([1,2,3], 1, 3, Lt(lt))

Looks the same before and after.

[vtjnash]

That looks different before/after to me. There is an excess load in the before case.

[LilithHafner]

I see now! lt could mutate v. That would make this optimization change behavior. That behavior change is okay with me, but not okay with the compiler. The compiler cannot store the result of v[j - 1] unless v[j - 1] is pure with respect to the interleaving calls (including lt) which it can only know if both getindex and lt are simple and inlined.

I must have made a mistake in diffing. You're right, there is an extra load in the before case.

I'd be hard-pressed to find a case where this makes a measurable runtime difference, but I now see why it is an improvement in theory.

Thanks, @KristofferC and @vtjnash for explaining this to me!