case where immutable struct is 30% slower than mutable (and much slower on 1.6-dev)

[clarkevans]

To slow this script down by 30%, remove mutable in front of struct Bypass

mutable struct Bypass{T} content::T end
Base.print(io::IO, x::Bypass) = print(io, x.content)
struct Reprint content::Function end
Base.print(io::IO, t::Reprint) = t.content(io)

function printable()
    parts = (Bypass("<span>"), "data", Bypass("</span"))
    Reprint() do io::IO
        for x in parts
             print(io, x)
        end
    end
end

harness() = begin
   io = IOBuffer()
   ob = printable()
   print(io, ob)
end

using BenchmarkTools
println(@benchmark harness())

Julia Version 1.5.3
Commit 788b2c77c1 (2020-11-09 13:37 UTC)
Platform Info:
  OS: Linux (x86_64-pc-linux-gnu)
  CPU: Intel(R) Celeron(R) CPU J3455 @ 1.50GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-9.0.1 (ORCJIT, goldmont)

[clarkevans]

I would further note that this script, as-is, takes ~2x longer (~200ns to ~600ns) on my hardware. This might explain aspects of #38911

Julia Version 1.6.0-DEV.1722
Commit 599d3299c9 (2020-12-09 09:00 UTC)
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: Intel(R) Celeron(R) CPU J3455 @ 1.50GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-11.0.0 (ORCJIT, goldmont)

[JeffBezanson]

The 2x regression since 1.5 bisects to bee6546 (#36524). It relates to iterating over small tuples. The problem might be that we switched from inferring a tuple of unions to a union of tuples.

1.5:

│         (@_3 = Base.iterate(%1))::Union{Nothing, Tuple{Union{String, Bypass{String}},Int64}}
│   %3  = (@_3 === nothing)::Bool
│   %4  = Base.not_int(%3)::Bool
└──       goto #4 if not %4
2 ┄ %6  = @_3::Tuple{Union{String, Bypass{String}},Int64}::Tuple{Union{String, Bypass{String}},Int64}

1.6:

│         (@_3 = Base.iterate(%1))::Core.PartialStruct(Tuple{Bypass{String},Int64}, Any[Bypass{String}, Core.Const(2, false)])
│   %3  = (@_3::Core.PartialStruct(Tuple{Bypass{String},Int64}, Any[Bypass{String}, Core.Const(2, false)]) === nothing)::Core.Const(false, false)
│   %4  = Base.not_int(%3)::Core.Const(true, false)
└──       goto #4 if not %4
2 ┄ %6  = @_3::Union{Tuple{String,Int64}, Tuple{Bypass{String},Int64}}::Union{Tuple{String,Int64}, Tuple{Bypass{String},Int64}}

[clarkevans]

Thanks Jeff. This code snippet is somewhat representative of the kinds of string construction that occurs in hard-loops (ie, rows in a 10k table). Typically the parts tuple close to 12, not 3. It is also nested construct (that's the point of Reprint), sometimes 2-3 deep. In the interest of keeping the example minimalist, these two details were omitted. If there's anyway I can be helpful, please let me know. A representative benchmark is included in HypertextLiteral.jl and has only a few dependencies.

[JeffBezanson]

The regression since 1.5 is fixed; the original mutable issue seems to be more general.