sum types can be much slower than unions

[matthias314]

The benchmark example in the README file suggests that sum types are faster than unions. In the following minimal modification of that example it's suddenly 5x slower.

using LightSumTypes, Chairmarks

struct A end
struct B x::Int end; B() = B(0)
struct C end
struct D end
struct E end
struct F end

const U = Union{A, B, C, D, E, F}
@sumtype S(A, B, C, D, E, F)

f(::A) = 1
f(::B) = 2
f(::C) = 3
f(::D) = 4
f(::E) = 5
f(::F) = 6
f(s::S) = f(variant(s))

vec_manytypes = collect(U, rand((A(), B(), C(), D(), E(), F()), 1000));
iter_manytypes = (x for x in vec_manytypes);
vec_sumtypes = map(S, vec_manytypes);
iter_sumtypes = (x for x in vec_sumtypes);

julia> @b sum(f, $vec_manytypes), sum(f, $vec_sumtypes)
(462.444 ns, 2.412 μs)

julia> @b sum(f, $iter_manytypes), sum(f, $iter_sumtypes)
(1.706 μs, 2.165 μs)

If A has the x field and not B, then the timings change:

julia> @b sum(f, $vec_manytypes), sum(f, $vec_sumtypes)
(466.571 ns, 828.714 ns)

julia> @b sum(f, $iter_manytypes), sum(f, $iter_sumtypes)
(1.603 μs, 541.417 ns)

Same for F instead of B. So the potential benefits of sum types seems to be very fragile. Is this a bug, or can one otherwise say what to do in order to get better performance?

Status `/tmp/jl_aYOKNY/Project.toml`
  [0ca39b1e] Chairmarks v1.3.1
  [f56206fc] LightSumTypes v5.2.0

Julia Version 1.11.4
Commit 8561cc3d68d (2025-03-10 11:36 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 4 × Intel(R) Core(TM) i3-10110U CPU @ 2.10GHz
  WORD_SIZE: 64
  LLVM: libLLVM-16.0.6 (ORCJIT, skylake)
Threads: 1 default, 0 interactive, 1 GC (on 4 virtual cores)

[Tortar]

I can't reproduce the 5x slower difference on my system somehow, it is still true that I see a slight difference between changing A and B which I don't know how to explain:

# changing B
julia> @b sum(f, $vec_manytypes), sum(f, $vec_sumtypes)
(364.939 ns, 487.576 ns)

julia> @b sum(f, $iter_manytypes), sum(f, $iter_sumtypes)
(1.247 μs, 510.154 ns)

# changing A
julia> @b sum(f, $vec_manytypes), sum(f, $vec_sumtypes)
(356.711 ns, 406.026 ns)

julia> @b sum(f, $iter_manytypes), sum(f, $iter_sumtypes)
(1.185 μs, 379.529 ns)

Julia Version 1.11.5
Commit 760b2e5b739 (2025-04-14 06:53 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 12 × AMD Ryzen 5 5600H with Radeon Graphics
  WORD_SIZE: 64
  LLVM: libLLVM-16.0.6 (ORCJIT, znver3)
Threads: 1 default, 0 interactive, 1 GC (on 12 virtual cores)

[Tortar]

I tried a more heterogeneous benchmark and this is what I get:

using LightSumTypes, Chairmarks, Random

const rng = Xoshiro(42)

struct A x::Int end
struct B end
struct C end
struct D x::Int end
struct E end
struct F 
    x::Int
    y::Int
end

const U = Union{A, B, C, D, E, F}
@sumtype S(A, B, C, D, E, F)

f(a::A) = a.x
f(::B) = 1
f(::C) = 4
f(d::D) = 3 + d.x
f(::E) = 6
f(f::F) = 5 + f.x + f.y
f(s::S) = f(variant(s))

vec_manytypes = collect(U, rand((A(rand(1:100)), B(), C(), D(rand(1:1000)), E(), F(rand(1:1000), rand(1:1000))), 1000));
iter_manytypes = (x for x in vec_manytypes);
vec_sumtypes = map(S, vec_manytypes);
iter_sumtypes = (x for x in vec_sumtypes);

@b sum($f, $vec_manytypes), sum($f, $vec_sumtypes)
@b sum($f, $iter_manytypes), sum($f, $iter_sumtypes)

julia> @b sum($f, $vec_manytypes), sum($f, $vec_sumtypes)
(1.576 μs, 1.359 μs)

julia> @b sum($f, $iter_manytypes), sum($f, $iter_sumtypes)
(4.531 μs, 1.641 μs)

In general, 1.11 is much better than 1.10 in dealing with Union types, and the competition between the methodologies is greater (in 1.10 the version with Union allocates and it is 30x slower)

[matthias314]

I tried two other computers, and there I cannot reproduce it, either. However, on my laptop I also see it with Julia 1.11.5 (instead of 1.11.4) and 1.12.0-beta2. In your modified example with several fields, I get timings similar to yours on my laptop.

What do you get for the following? Done on my laptop with your modified example; with my original example the timings are roughly the same.

g(x) = x
g(s::S) = S(g(variant(s)))

julia> @b similar(vec_manytypes) map!(g, _, $vec_manytypes)
4.368 μs

julia> @b similar(vec_sumtypes) map!(g, _, $vec_sumtypes)
7.658 μs