Julia @code_warntype reveals hidden temporary variable #temp#

Question

I ran a type-stability check on my code recently. When I call @code_warntype on it, I get the following output:

Variables:
  #unused#::IHT.#kw##L0_reg
  #temp#@_2::Array{Any,1}
  ::IHT.#L0_reg
  x::Array{Float64,2}
  y::Array{Float64,1}
  k::Int64
  #temp#@_7::Bool
  #temp#@_8::Bool
  max_iter::Int64
  max_step::Int64
  quiet::Bool
  v::IHT.IHTVariables{Float64,Array{Float64,1}}
  tol::Float64
  #temp#@_14::Int64
  #temp#@_15::Int64
  #temp#@_16::Int64
  #temp#@_17::Any
  ###...###
  #temp#@_17::Any = (Core.arrayref(#temp#@_2::Array{Any,1},#temp#@_16::Int64)::Any
  ###...###
  v::IHT.IHTVariables{Float64,Array{Float64,1}} = (Core.typeassert)((Core.arrayref)(#temp#@_2::Array{Any,1},(Base.box)(Int64,(Base.add_int)(#temp#@_16::Int64,1)))::Any,IHT.IHTVariables{Float64,Array{Float64,1}})::IHT.IHTVariables{Float64,Array{Float64,1}}

Minimal working example, using my IHT.jl package:

Pkg.clone("https://github.com/klkeys/IHT.jl")
n = 100; p = 250; k = 2;
x = randn(n,p)
b = zeros(p); b[1:k] = randn(k); shuffle!(b)
y = x*b + randn(n)
@code_warntype L0_reg(x, y, k, quiet=true)

It would seem like the compiler is using #temp# to read the arguments to the function L0_reg. The function arguments are completely specified. From where does this evil little #temp#@_2 variable arise? Am I able to tell the compiler what its type is? (hopefully not Array{Any,1}...)

Answer 1

You can use @code_lowered to view where the #temp# variables are coming from:

julia> @code_lowered L0_reg(x, y, k, quiet=true)
LambdaInfo template for (::IHT.#kw##L0_reg){T<:Union{Float32,Float64}}(::Array{Any,1}, ::IHT.#L0_reg, x::DenseArray{T,2}, y::DenseArray{T,1}, k::Int64)
:(begin 
        NewvarNode(:(temp))
        NewvarNode(:(tol))
        #temp#@_7 = true
        #temp#@_8 = true
        max_iter = 100
        max_step = 50
        quiet = true
        SSAValue(0) = (IHT.colon)(1,(Base.length)(#temp#@_2) >> 1)
        #temp#@_14 = (Base.start)(SSAValue(0))
        10: 
        unless !((Base.done)(SSAValue(0),#temp#@_14)) goto 42
        SSAValue(1) = (Base.next)(SSAValue(0),#temp#@_14)
        #temp#@_15 = (Core.getfield)(SSAValue(1),1)
        #temp#@_14 = (Core.getfield)(SSAValue(1),2)
        #temp#@_16 = #temp#@_15 * 2 - 1
        #temp#@_17 = (Core.arrayref)(#temp#@_2,#temp#@_16)
        unless #temp#@_17 === :quiet goto 20
        quiet = (Core.typeassert)((Core.arrayref)(#temp#@_2,#temp#@_16 + 1),IHT.Bool)
        goto 40
        20: 
        unless #temp#@_17 === :max_step goto 24
        max_step = (Core.typeassert)((Core.arrayref)(#temp#@_2,#temp#@_16 + 1),IHT.Int)
        goto 40
        24: 
        unless #temp#@_17 === :max_iter goto 28
        max_iter = (Core.typeassert)((Core.arrayref)(#temp#@_2,#temp#@_16 + 1),IHT.Int)
        goto 40
        28: 
        unless #temp#@_17 === :tol goto 33
        tol = (Core.typeassert)((Core.arrayref)(#temp#@_2,#temp#@_16 + 1),IHT.Float)
        #temp#@_8 = false
        goto 40
        33: 
        unless #temp#@_17 === :temp goto 38
        temp = (Core.typeassert)((Core.arrayref)(#temp#@_2,#temp#@_16 + 1),(Core.apply_type)(IHT.IHTVariables,$(Expr(:static_parameter, 1))))
        #temp#@_7 = false
        goto 40
        38: 
        (Base.kwerr)(#temp#@_2,,x,y,k)
        40: 
        goto 10
        42: 
        unless #temp#@_7 goto 45
        temp = (IHT.IHTVariables)(x,y,k)
        45: 
        unless #temp#@_8 goto 48
        tol = (IHT.convert)($(Expr(:static_parameter, 1)),0.0001)
        48: 
        return (IHT.#L0_reg#75)(temp,tol,max_iter,max_step,quiet,,x,y,k)
    end)

In this case, the temps (in particular #temp#@_2) are coming from the keyword arguments. This is quite normal for keyword arguments.

julia> f(; x=1) = x
f (generic function with 1 method)

julia> @code_warntype f(x=1)
Variables:
  #unused#::#kw##f
  #temp#@_2::Array{Any,1}
  ::#f
  x::Any
  #temp#@_5::Int64
  #temp#@_6::Int64
  #temp#@_7::Int64
  #temp#@_8::Any

Body:
  begin 
      x::Any = 1
      SSAValue(2) = (Base.arraylen)(#temp#@_2::Array{Any,1})::Int64
      SSAValue(3) = (Base.select_value)((Base.sle_int)(0,1)::Bool,(Base.box)(Int64,(Base.ashr_int)(SSAValue(2),(Base.box)(UInt64,1))),(Base.box)(Int64,(Base.shl_int)(SSAValue(2),(Base.box)(UInt64,(Base.box)(Int64,(Base.neg_int)(1))))))::Int64
      SSAValue(4) = (Base.select_value)((Base.sle_int)(1,SSAValue(3))::Bool,SSAValue(3),(Base.box)(Int64,(Base.sub_int)(1,1)))::Int64
      #temp#@_5::Int64 = 1
      6: 
      unless (Base.box)(Base.Bool,(Base.not_int)((#temp#@_5::Int64 === (Base.box)(Int64,(Base.add_int)(SSAValue(4),1)))::Bool)) goto 21
      SSAValue(5) = #temp#@_5::Int64
      SSAValue(6) = (Base.box)(Int64,(Base.add_int)(#temp#@_5::Int64,1))
      #temp#@_6::Int64 = SSAValue(5)
      #temp#@_5::Int64 = SSAValue(6)
      #temp#@_7::Int64 = (Base.box)(Int64,(Base.sub_int)((Base.box)(Int64,(Base.mul_int)(#temp#@_6::Int64,2)),1))
      #temp#@_8::Any = (Core.arrayref)(#temp#@_2::Array{Any,1},#temp#@_7::Int64)::Any
      unless (#temp#@_8::Any === :x)::Bool goto 17
      x::Any = (Core.arrayref)(#temp#@_2::Array{Any,1},(Base.box)(Int64,(Base.add_int)(#temp#@_7::Int64,1)))::Any
      goto 19
      17: 
      (Base.throw)($(Expr(:new, :(Base.MethodError), :((Core.getfield)((Core.getfield)((Core.getfield)(#f,:name)::TypeName,:mt),:kwsorter)), :((Core.tuple)(#temp#@_2,)::Tuple{Array{Any,1},#f}))))::Union{}
      19: 
      goto 6
      21: 
      return x::Any
  end::Any

Keyword arguments are known to have callsite overhead that can be somewhat worked around by declaring types. Note that unless your function does very little, it's unlikely the sorting of keyword arguments is actually a huge bottleneck (despite the nasty @code_warntype output).

When you do @code_warntype on a keyword argument call, you're actually viewing the type instabilities of the keyword argument sorter, an autogenerated wrapper around the real function. As you can see, the code ends up calling (IHT.#L0_reg#75)(temp,tol,max_iter,max_step,quiet,,x,y,k), which is a plain function that takes positional arguments. So the output of @code_warntype is almost useless in this case.