type inference issue with vectors if ints and floats in julia 1.10 #526

NilsNiggemann · 2024-01-18T05:21:23Z

Apparently, multiplying a vector of floats with a vector of ints causes problems with the julia compiler. The return type res cannot be inferred anymore (red::Any) and this causes performance losses.
I have tested this on Julia 1.9.3, and there the example below works fine there, but not on Julia 1.10.
Of course, one can manually promote Integers to Floats before multiplying, at least as a workaround.

Minimum working example:

using LoopVectorization
function LVTest(a1,a2)
    res = zero(eltype(a1))
    @turbo for i in eachindex(a1,a2)
        res += a1[i]*a2[i]
    end
    return res
end

aFloat = zeros(10)
aInt = zeros(Int,10)

@code_warntype LVTest(aFloat,aInt) #prints type Any for res on Julia 1.10 and does not show any type instabilities for 1.9

function checkAllocs()
    aFloat = zeros(10)
    aInt = zeros(Int,10)
    LVTest(aFloat,aInt) # compile
    println("Allocations: ",@allocated LVTest(aFloat,aInt))
end

checkAllocs() # prints 0 on Julia 1.9 but 2304 on Julia 1.10

The output of versioninfo():

Julia Version 1.9.3
Commit bed2cd540a1 (2023-08-24 14:43 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 8 × Intel(R) Core(TM) i7-4770 CPU @ 3.40GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-14.0.6 (ORCJIT, haswell)
  Threads: 1 on 8 virtual cores
Environment:
  JULIA_PKG_USE_CLI_GIT = true
  JULIA_DEPOT_PATH = /storage/niggeni/.julia_hexagon
  JULIA_IMAGE_THREADS = 1

Julia Version 1.10.0
Commit 3120989f39b (2023-12-25 18:01 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 8 × Intel(R) Core(TM) i7-4770 CPU @ 3.40GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-15.0.7 (ORCJIT, haswell)
  Threads: 1 on 8 virtual cores
Environment:
  JULIA_PKG_USE_CLI_GIT = true
  JULIA_DEPOT_PATH = /storage/niggeni/.julia_hexagon

The text was updated successfully, but these errors were encountered:

chriselrod · 2024-01-18T18:01:40Z

Base.promote seems to have a problem:

julia> using VectorizationBase

julia> vxi = Vec(ntuple(identity, 4)...);

julia> vxf = Vec(ntuple(float, 4)...);

julia> vxiu = VecUnroll((vxi,vxi,vxi,vxi));

julia> vxfu = VecUnroll((vxf,vxf,vxf,vxf));

julia> @code_warntype VectorizationBase.promote(vxiu,vxfu,vxfu)
MethodInstance for promote(::VecUnroll{3, 4, Int64, Vec{4, Int64}}, ::VecUnroll{3, 4, Float64, Vec{4, Float64}}, ::VecUnroll{3, 4, Float64, Vec{4, Float64}})
  from promote(x, y, z) @ Base promotion.jl:397
Arguments
  #self#::Core.Const(promote)
  x::VecUnroll{3, 4, Int64, Vec{4, Int64}}
  y::VecUnroll{3, 4, Float64, Vec{4, Float64}}
  z::VecUnroll{3, 4, Float64, Vec{4, Float64}}
Locals
  @_5::Int64
  pz::VecUnroll{3, 4, Float64, Vec{4, Float64}}
  py::VecUnroll{3, 4, Float64, Vec{4, Float64}}
  px::Any
Body::Tuple{Any, VecUnroll{3, 4, Float64, Vec{4, Float64}}, VecUnroll{3, 4, Float64, Vec{4, Float64}}}
1 ─       nothing
│   %2  = Base._promote(x, y, z)::Tuple{Any, VecUnroll{3, 4, Float64, Vec{4, Float64}}, VecUnroll{3, 4, Float64, Vec{4, Float64}}}
│   %3  = Base.indexed_iterate(%2, 1)::Core.PartialStruct(Tuple{Any, Int64}, Any[Any, Core.Const(2)])
│         (px = Core.getfield(%3, 1))
│         (@_5 = Core.getfield(%3, 2))
│   %6  = Base.indexed_iterate(%2, 2, @_5::Core.Const(2))::Core.PartialStruct(Tuple{VecUnroll{3, 4, Float64, Vec{4, Float64}}, Int64}, Any[VecUnroll{3, 4, Float64, Vec{4, Float64}}, Core.Const(3)])
│         (py = Core.getfield(%6, 1))
│         (@_5 = Core.getfield(%6, 2))
│   %9  = Base.indexed_iterate(%2, 3, @_5::Core.Const(3))::Core.PartialStruct(Tuple{VecUnroll{3, 4, Float64, Vec{4, Float64}}, Int64}, Any[VecUnroll{3, 4, Float64, Vec{4, Float64}}, Core.Const(4)])
│         (pz = Core.getfield(%9, 1))
│   %11 = Core.tuple(x, y, z)::Tuple{VecUnroll{3, 4, Int64, Vec{4, Int64}}, VecUnroll{3, 4, Float64, Vec{4, Float64}}, VecUnroll{3, 4, Float64, Vec{4, Float64}}}
│   %12 = Core.tuple(px, py, pz)::Tuple{Any, VecUnroll{3, 4, Float64, Vec{4, Float64}}, VecUnroll{3, 4, Float64, Vec{4, Float64}}}
│         Base.not_sametype(%11, %12)
│   %14 = Core.tuple(px, py, pz)::Tuple{Any, VecUnroll{3, 4, Float64, Vec{4, Float64}}, VecUnroll{3, 4, Float64, Vec{4, Float64}}}
└──       return %14

Note that Base._promote is inferred as returning ::Tuple{Any,...}. Yet, @code_warntype Base._promote is fine:

julia> @code_warntype Base._promote(vxiu,vxfu,vxfu)
MethodInstance for Base._promote(::VecUnroll{3, 4, Int64, Vec{4, Int64}}, ::VecUnroll{3, 4, Float64, Vec{4, Float64}}, ::VecUnroll{3, 4, Float64, Vec{4, Float64}})
  from _promote(x, y, z) @ Base promotion.jl:374
Arguments
  #self#::Core.Const(Base._promote)
  x::VecUnroll{3, 4, Int64, Vec{4, Int64}}
  y::VecUnroll{3, 4, Float64, Vec{4, Float64}}
  z::VecUnroll{3, 4, Float64, Vec{4, Float64}}
Locals
  R::Type{VecUnroll{3, 4, Float64, Vec{4, Float64}}}
Body::Tuple{VecUnroll{3, 4, Float64, Vec{4, Float64}}, VecUnroll{3, 4, Float64, Vec{4, Float64}}, VecUnroll{3, 4, Float64, Vec{4, Float64}}}
1 ─      nothing
│        (R = Base.promote_typeof(x, y, z))
│   %3 = Base.convert(R::Core.Const(VecUnroll{3, 4, Float64, Vec{4, Float64}}), x)::VecUnroll{3, 4, Float64, Vec{4, Float64}}
│   %4 = Base.convert(R::Core.Const(VecUnroll{3, 4, Float64, Vec{4, Float64}}), y)::VecUnroll{3, 4, Float64, Vec{4, Float64}}
│   %5 = Base.convert(R::Core.Const(VecUnroll{3, 4, Float64, Vec{4, Float64}}), z)::VecUnroll{3, 4, Float64, Vec{4, Float64}}
│   %6 = Core.tuple(%3, %4, %5)::Tuple{VecUnroll{3, 4, Float64, Vec{4, Float64}}, VecUnroll{3, 4, Float64, Vec{4, Float64}}, VecUnroll{3, 4, Float64, Vec{4, Float64}}}
└──      return %6

Julia type inference being a PITA as usual.

chriselrod · 2024-01-18T18:05:19Z

I marked this as a good first issue.
I'd suggest deving VectorizationBase, and playing with some promote definitions to try and get it to infer.

Then also add tests that it does infer correctly.

NilsNiggemann · 2024-01-23T11:06:45Z

I tried to do this, but it still seems somewhat complicated:
To keep it simple, I first tried whether straight forwardly fixing your promotion example also fixes the issue.
The type inference of Base.promote is actually resolved by basically copy-pasting code from Base insrc/promotion.jl (But why though?)

"""copy-pasted code from Base._promote"""
@inline function __Base_stolen_promote(x,y,z)
  R = Base.promote_typeof(x, y, z)
  return (convert(R, x), convert(R, y), convert(R, z))
end

"""copy-pasted code from Base.promote, inserted __Base_stolen_promote"""
@inline function Base.promote(
  x::VecUnroll,
  y::VecUnroll,
  z::VecUnroll
)
  px, py, pz = Base._promote(x, y, z) # this is type unstable
  px, py, pz = __Base_stolen_promote(x, y, z) # this infers correctly

  Base.not_sametype((x,y,z), (px,py,pz))
  px, py, pz
end

If I run your example from above

promotion

using VectorizationBase

vxi = Vec(ntuple(identity, 4)...);

vxf = Vec(ntuple(float, 4)...);

vxiu = VecUnroll((vxi,vxi,vxi,vxi));

vxfu = VecUnroll((vxf,vxf,vxf,vxf));

@code_warntype VectorizationBase.promote(vxiu,vxfu,vxfu)

I see that this does indeed remove the instability. (Of course this would not be the PR, since I am using unexported Base functions but for now its worth to try)

However, my function LVTest() still does not infer correctly

code_warntype output


MethodInstance for LVTest(::Vector{Float64}, ::Vector{Int64})
  from LVTest(a1, a2) @ Main /storage/niggeni/.julia_hexagon/dev/VectorizationBase/promotiontest/promotion.jl:31
Arguments
  #self#::Core.Const(LVTest)
  a1::Vector{Float64}
  a2::Vector{Int64}
Locals
  @_4::Union{}
  val@_5::Union{}
  @_6::Int64
  @_7::Int64
  val@_8::Base.OneTo{Int64}
  res::Any
  res_##onevec##::Any
  Wvecwidth##::StaticInt{4}
  Tloopeltype##::Type{Float64}
  vargsym#332::Tuple{Tuple{CloseOpenIntervals.CloseOpen{StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}, DataType}}
  ##grouped#strided#pointer####7###::LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}
  preserve#buffer#@_15::Vector{Int64}
  vptr##_a2::LayoutPointers.StridedPointer{Int64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{1}}}
  preserve#buffer#@_17::Vector{Float64}
  vptr##_a1::LayoutPointers.StridedPointer{Float64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{1}}}
  #i_loop_upper_bound###4###::Int64
  #i_loop_lower_bound###3###::StaticInt{1}
  #loopleni###2###::Int64
  #looprangei###1###::Static.OptionallyStaticUnitRange{StaticInt{1}, Int64}
  msg::Union{}
  kwargs::Union{}
  line::Union{}
  file::Union{}
  id::Union{}
  logger::Union{}
  _module::Union{}
  group::Union{}
  std_level::Union{}
  level::Union{}
  err::Union{}
  i::Union{}
  @_35::Union{}
Body::Any
1 ─        Core.NewvarNode(:(@_4))
│          Core.NewvarNode(:(val@_5))
│          Core.NewvarNode(:(@_6))
│          Core.NewvarNode(:(@_7))
│          Core.NewvarNode(:(res_##onevec##))
│          Core.NewvarNode(:(Wvecwidth##))
│          Core.NewvarNode(:(Tloopeltype##))
│          Core.NewvarNode(:(vargsym#332))
│          Core.NewvarNode(:(##grouped#strided#pointer####7###))
│          Core.NewvarNode(:(preserve#buffer#@_15))
│          Core.NewvarNode(:(vptr##_a2))
│          Core.NewvarNode(:(preserve#buffer#@_17))
│          Core.NewvarNode(:(vptr##_a1))
│   %14  = Main.eltype(a1)::Core.Const(Float64)
│          (res = Main.zero(%14))
│          Main.nothing
│          Main.nothing
│          Main.nothing
│          nothing
│          (val@_8 = Main.eachindex(a1, a2))
│          nothing
│   %22  = val@_8::Base.OneTo{Int64}
│          (#looprangei###1### = LoopVectorization.canonicalize_range(%22))
│          (#loopleni###2### = StaticArrayInterface.static_length(#looprangei###1###))
│          (#i_loop_lower_bound###3### = LoopVectorization.maybestaticfirst(#looprangei###1###))
│          (#i_loop_upper_bound###4### = LoopVectorization.maybestaticlast(#looprangei###1###))
│   %27  = Main.typeof(res::Core.Const(0.0))::Core.Const(Float64)
│   %28  = LoopVectorization.check_args(a1, a2, %27)::Core.Const(true)
└──        goto #5 if not %28
2 ─        goto #5 if not true
3 ─ %31  = (LoopVectorization.can_turbo)(LoopVectorization.vfmadd_fast, Val{3}())::Core.Const(true)
└──        goto #5 if not %31
4 ─ %33  = LoopVectorization.stridedpointer_preserve(a1)::Tuple{LayoutPointers.StridedPointer{Float64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{1}}}, Vector{Float64}}
│   %34  = Base.indexed_iterate(%33, 1)::Core.PartialStruct(Tuple{LayoutPointers.StridedPointer{Float64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{1}}}, Int64}, Any[LayoutPointers.StridedPointer{Float64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{1}}}, Core.Const(2)])
│          (vptr##_a1 = Core.getfield(%34, 1))
│          (@_7 = Core.getfield(%34, 2))
│   %37  = Base.indexed_iterate(%33, 2, @_7::Core.Const(2))::Core.PartialStruct(Tuple{Vector{Float64}, Int64}, Any[Vector{Float64}, Core.Const(3)])
│          (preserve#buffer#@_17 = Core.getfield(%37, 1))
│   %39  = LoopVectorization.stridedpointer_preserve(a2)::Tuple{LayoutPointers.StridedPointer{Int64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{1}}}, Vector{Int64}}
│   %40  = Base.indexed_iterate(%39, 1)::Core.PartialStruct(Tuple{LayoutPointers.StridedPointer{Int64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{1}}}, Int64}, Any[LayoutPointers.StridedPointer{Int64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{1}}}, Core.Const(2)])
│          (vptr##_a2 = Core.getfield(%40, 1))
│          (@_6 = Core.getfield(%40, 2))
│   %43  = Base.indexed_iterate(%39, 2, @_6::Core.Const(2))::Core.PartialStruct(Tuple{Vector{Int64}, Int64}, Any[Vector{Int64}, Core.Const(3)])
│          (preserve#buffer#@_15 = Core.getfield(%43, 1))
│   %45  = vptr##_a1::LayoutPointers.StridedPointer{Float64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{1}}}
│   %46  = Core.tuple(#i_loop_lower_bound###3###)::Core.Const((static(1),))
│   %47  = LoopVectorization.gespf1(%45, %46)::LayoutPointers.StridedPointer{Float64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{0}}}
│   %48  = LoopVectorization.densewrapper(%47, a1)::LayoutPointers.DensePointerWrapper{(true,), Float64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{0}}, LayoutPointers.StridedPointer{Float64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{0}}}}
│   %49  = vptr##_a2::LayoutPointers.StridedPointer{Int64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{1}}}
│   %50  = Core.tuple(#i_loop_lower_bound###3###)::Core.Const((static(1),))
│   %51  = LoopVectorization.gespf1(%49, %50)::LayoutPointers.StridedPointer{Int64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{0}}}
│   %52  = LoopVectorization.densewrapper(%51, a2)::LayoutPointers.DensePointerWrapper{(true,), Int64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{0}}, LayoutPointers.StridedPointer{Int64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{0}}}}
│   %53  = Core.tuple(%48, %52)::Tuple{LayoutPointers.DensePointerWrapper{(true,), Float64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{0}}, LayoutPointers.StridedPointer{Float64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{0}}}}, LayoutPointers.DensePointerWrapper{(true,), Int64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{0}}, LayoutPointers.StridedPointer{Int64, 1, 1, 0, (1,), Tuple{StaticInt{8}}, Tuple{StaticInt{0}}}}}
│   %54  = Main.Val::Core.Const(Val)
│   %55  = ()::Core.Const(())
│   %56  = Core.apply_type(%54, %55)::Core.Const(Val{()})
│   %57  = (%56)()::Core.Const(Val{()}())
│   %58  = LoopVectorization.grouped_strided_pointer(%53, %57)::Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}, Tuple{Nothing, Nothing}}
│          (##grouped#strided#pointer####7### = (getfield)(%58, 1))
│   %60  = $(Expr(:gc_preserve_begin, :(preserve#buffer#@_17), :(preserve#buffer#@_15)))
│   %61  = LoopVectorization.zerorangestart(#looprangei###1###)::CloseOpenIntervals.CloseOpen{StaticInt{0}, Int64}
│   %62  = Core.tuple(%61)::Tuple{CloseOpenIntervals.CloseOpen{StaticInt{0}, Int64}}
│   %63  = ##grouped#strided#pointer####7###::LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}
│   %64  = Base.eltype(res::Core.Const(0.0))::Core.Const(Float64)
│   %65  = Core.tuple(%63, %64)::Core.PartialStruct(Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}, DataType}, Any[LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}, Type{Float64}])
│          (vargsym#332 = Core.tuple(%62, %65))
│   %67  = LoopVectorization.eltype(a1)::Core.Const(Float64)
│   %68  = LoopVectorization.eltype(a2)::Core.Const(Int64)
│   %69  = Base.eltype(res::Core.Const(0.0))::Core.Const(Float64)
│          (Tloopeltype## = LoopVectorization.promote_type(%67, %68, %69))
│          (Wvecwidth## = LoopVectorization.pick_vector_width(Tloopeltype##::Core.Const(Float64)))
│   %72  = LoopVectorization._turbo_!::Core.Const(LoopVectorization._turbo_!)
│   %73  = Core.apply_type(Main.Val, (false, 0, 0, 0, false, 0x0000000000000001, 1, true))::Core.Const(Val{(false, 0, 0, 0, false, 0x0000000000000001, 1, true)})
│   %74  = (%73)()::Core.Const(Val{(false, 0, 0, 0, false, 0x0000000000000001, 1, true)}())
│   %75  = LoopVectorization.avx_config_val(%74, Wvecwidth##)::Core.Const(Val{(false, 0, 0, 0, false, 4, 32, 15, 64, 0x0000000000000001, 1, true)}())
│   %76  = Main.Val::Core.Const(Val)
│   %77  = Core.tuple(:LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.memload, 0x0001, 0x0001), :LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.memload, 0x0002, 0x0002), Symbol("##DROPPED#CONSTANT##"), Symbol("##DROPPED#CONSTANT##"), LoopVectorization.OperationStruct(0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.constant, 0x0003, 0x0000), :LoopVectorization, :vfmadd_fast, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000100020003, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.compute, 0x0003, 0x0000))::Core.Const((:LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.memload, 0x0001, 0x0001), :LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.memload, 0x0002, 0x0002), Symbol("##DROPPED#CONSTANT##"), Symbol("##DROPPED#CONSTANT##"), LoopVectorization.OperationStruct(0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.constant, 0x0003, 0x0000), :LoopVectorization, :vfmadd_fast, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000100020003, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.compute, 0x0003, 0x0000)))
│   %78  = Core.apply_type(%76, %77)::Core.Const(Val{(:LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.memload, 0x0001, 0x0001), :LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.memload, 0x0002, 0x0002), Symbol("##DROPPED#CONSTANT##"), Symbol("##DROPPED#CONSTANT##"), LoopVectorization.OperationStruct(0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.constant, 0x0003, 0x0000), :LoopVectorization, :vfmadd_fast, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000100020003, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.compute, 0x0003, 0x0000))})
│   %79  = (%78)()::Core.Const(Val{(:LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.memload, 0x0001, 0x0001), :LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.memload, 0x0002, 0x0002), Symbol("##DROPPED#CONSTANT##"), Symbol("##DROPPED#CONSTANT##"), LoopVectorization.OperationStruct(0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.constant, 0x0003, 0x0000), :LoopVectorization, :vfmadd_fast, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000100020003, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.compute, 0x0003, 0x0000))}())
│   %80  = Main.Val::Core.Const(Val)
│   %81  = Core.tuple(LoopVectorization.ArrayRefStruct{:a1, Symbol("##vptr##_a1")}(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001), LoopVectorization.ArrayRefStruct{:a2, Symbol("##vptr##_a2")}(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001))::Core.Const((LoopVectorization.ArrayRefStruct{:a1, Symbol("##vptr##_a1")}(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001), LoopVectorization.ArrayRefStruct{:a2, Symbol("##vptr##_a2")}(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001)))
│   %82  = Core.apply_type(%80, %81)::Core.Const(Val{(LoopVectorization.ArrayRefStruct{:a1, Symbol("##vptr##_a1")}(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001), LoopVectorization.ArrayRefStruct{:a2, Symbol("##vptr##_a2")}(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001))})
│   %83  = (%82)()::Core.Const(Val{(LoopVectorization.ArrayRefStruct{:a1, Symbol("##vptr##_a1")}(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001), LoopVectorization.ArrayRefStruct{:a2, Symbol("##vptr##_a2")}(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001))}())
│   %84  = Main.Val::Core.Const(Val)
│   %85  = Core.tuple(4)::Core.Const((4,))
│   %86  = Core.tuple(3)::Core.Const((3,))
│   %87  = ()::Core.Const(())
│   %88  = ()::Core.Const(())
│   %89  = ()::Core.Const(())
│   %90  = ()::Core.Const(())
│   %91  = Core.tuple(0, %85, %86, %87, %88, %89, %90)::Core.Const((0, (4,), (3,), (), (), (), ()))
│   %92  = Core.apply_type(%84, %91)::Core.Const(Val{(0, (4,), (3,), (), (), (), ())})
│   %93  = (%92)()::Core.Const(Val{(0, (4,), (3,), (), (), (), ())}())
│   %94  = Main.Val::Core.Const(Val)
│   %95  = (:i,)::Core.Const((:i,))
│   %96  = Core.apply_type(%94, %95)::Core.Const(Val{(:i,)})
│   %97  = (%96)()::Core.Const(Val{(:i,)}())
│   %98  = Base.typeof(vargsym#332::Core.PartialStruct(Tuple{Tuple{CloseOpenIntervals.CloseOpen{StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}, DataType}}, Any[Tuple{CloseOpenIntervals.CloseOpen{StaticInt{0}, Int64}}, Core.PartialStruct(Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}, DataType}, Any[LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}, Type{Float64}])]))::Core.Const(Tuple{Tuple{CloseOpenIntervals.CloseOpen{StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}, DataType}})
│   %99  = Base.Val(%98)::Core.Const(Val{Tuple{Tuple{CloseOpenIntervals.CloseOpen{StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}, DataType}}}())
│   %100 = Core.tuple(%75, %79, %83, %93, %97, %99)::Core.Const((Val{(false, 0, 0, 0, false, 4, 32, 15, 64, 0x0000000000000001, 1, true)}(), Val{(:LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.memload, 0x0001, 0x0001), :LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.memload, 0x0002, 0x0002), Symbol("##DROPPED#CONSTANT##"), Symbol("##DROPPED#CONSTANT##"), LoopVectorization.OperationStruct(0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.constant, 0x0003, 0x0000), :LoopVectorization, :vfmadd_fast, LoopVectorization.OperationStruct(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000100020003, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, 0x00000000000000000000000000000000, LoopVectorization.compute, 0x0003, 0x0000))}(), Val{(LoopVectorization.ArrayRefStruct{:a1, Symbol("##vptr##_a1")}(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001), LoopVectorization.ArrayRefStruct{:a2, Symbol("##vptr##_a2")}(0x00000000000000000000000000000001, 0x00000000000000000000000000000001, 0x00000000000000000000000000000000, 0x00000000000000000000000000000001))}(), Val{(0, (4,), (3,), (), (), (), ())}(), Val{(:i,)}(), Val{Tuple{Tuple{CloseOpenIntervals.CloseOpen{StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}, DataType}}}()))
│   %101 = LoopVectorization.flatten_to_tuple(vargsym#332::Core.PartialStruct(Tuple{Tuple{CloseOpenIntervals.CloseOpen{StaticInt{0}, Int64}}, Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}, DataType}}, Any[Tuple{CloseOpenIntervals.CloseOpen{StaticInt{0}, Int64}}, Core.PartialStruct(Tuple{LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}, DataType}, Any[LayoutPointers.GroupedStridedPointers{Tuple{Ptr{Float64}, Ptr{Int64}}, (1, 1), (0, 0), ((1,), (1,)), ((1,), (2,)), Tuple{StaticInt{8}, StaticInt{8}}, Tuple{StaticInt{0}, StaticInt{0}}}, Type{Float64}])]))::Tuple{Int64, Ptr{Float64}, Ptr{Int64}, LoopVectorization.StaticType{Float64}}
│   %102 = Core._apply_iterate(Base.iterate, %72, %100, %101)::Any
│          (res_##onevec## = %102)
│          $(Expr(:gc_preserve_end, :(%60)))
│   %105 = LoopVectorization.vecmemaybe(res_##onevec##)::Any
│          (res = LoopVectorization.reduced_add(%105, res::Core.Const(0.0)))
└──        goto #6
5 ┄        Core.Const(Core.NewvarNode(:(msg)))
│          Core.Const(Core.NewvarNode(:(kwargs)))
│          Core.Const(Core.NewvarNode(:(line)))
│          Core.Const(Core.NewvarNode(:(file)))
│          Core.Const(Core.NewvarNode(:(id)))
│          Core.Const(Core.NewvarNode(:(logger)))
│          Core.Const(Core.NewvarNode(:(_module)))
│          Core.Const(Core.NewvarNode(:(group)))
│          Core.Const(:(level = Base.CoreLogging.Warn))
│          Core.Const(:(std_level = level))
│          Core.Const(:(std_level))
│          Core.Const(:(Base.getindex(Base.RefValue{Base.CoreLogging.LogLevel}(Debug))))
│          Core.Const(:(%118 >= %119))
│          Core.Const(:(goto %159 if not %120))
│          Core.Const(:(group = :condense_loopset))
│          Core.Const(:(_module = Main))
│          Core.Const(:(logger = (Base.CoreLogging.current_logger_for_env)(std_level, group, _module)))
│          Core.Const(:(logger === Base.CoreLogging.nothing))
│          Core.Const(:(!%125))
│          Core.Const(:(goto %159 if not %126))
│          Core.Const(:(id = :Main_8a836deb))
│          Core.Const(:(Base.CoreLogging.invokelatest(Base.CoreLogging.shouldlog, logger, level, _module, group, id)))
│          Core.Const(:(goto %159 if not %129))
│          Core.Const(:(file = "/storage/niggeni/.julia_hexagon/packages/LoopVectorization/7gWfp/src/condense_loopset.jl"))
│          Core.Const(:(file isa Base.CoreLogging.String))
│          Core.Const(:(goto %136 if not %132))
│          Core.Const(:(Base.fixup_stdlib_path))
│          Core.Const(:(file = (%134)(file)))
│          Core.Const(:(line = 1148))
│          Core.Const(nothing)
│          Core.Const(:(err = %137))
│          Core.Const(:(err === Base.CoreLogging.nothing))
│          Core.Const(:(goto %148 if not %139))
│          Core.Const(:(msg = "#= /storage/niggeni/.julia_hexagon/dev/VectorizationBase/promotiontest/promotion.jl:33 =#:\n`LoopVectorization.check_args` on your inputs failed; running fallback `@inbounds @fastmath` loop instead.\nUse `warn_check_args=false`, e.g. `@turbo warn_check_args=false ...`, to disable this warning."))
│          Core.Const((:maxlog,))
│          Core.Const(:(Core.apply_type(Core.NamedTuple, %142)))
│          Core.Const(:(Core.tuple(1)))
│          Core.Const(:(kwargs = (%143)(%144)))
│          Core.Const(:(@_35 = true))
│          Core.Const(:(goto %150))
│          Core.Const(:(Base.invokelatest(Base.CoreLogging.logging_error, logger, level, _module, group, id, file, line, err, false)))
│          Core.Const(:(@_35 = false))
│          Core.Const(:(goto %159 if not @_35))
│          Core.Const(:(Base.NamedTuple()))
│          Core.Const(:(Base.merge(%151, kwargs)))
│          Core.Const(:(Base.isempty(%152)))
│          Core.Const(:(goto %157 if not %153))
│          Core.Const(:(Base.CoreLogging.invokelatest(Base.CoreLogging.handle_message, logger, level, msg, _module, group, id, file, line)))
│          Core.Const(:(goto %158))
│          Core.Const(:(Core.kwcall(%152, Base.CoreLogging.invokelatest, Base.CoreLogging.handle_message, logger, level, msg, _module, group, id, file, line)))
│          Core.Const(:(goto %159))
│          Core.Const(:(Base.CoreLogging.nothing))
│          Core.Const(nothing)
│          Core.Const(:(Main.eachindex(a1, a2)))
│          Core.Const(:(@_4 = Base.iterate(%161)))
│          Core.Const(:(@_4 === nothing))
│          Core.Const(:(Base.not_int(%163)))
│          Core.Const(:(goto %183 if not %164))
│          Core.Const(:(@_4))
│          Core.Const(:(i = Core.getfield(%166, 1)))
│          Core.Const(:(Core.getfield(%166, 2)))
│          Core.Const(:(Base.FastMath))
│          Core.Const(:(Base.getproperty(%169, :add_fast)))
│          Core.Const(:(res))
│          Core.Const(:(Base.FastMath))
│          Core.Const(:(Base.getproperty(%172, :mul_fast)))
│          Core.Const(:(Base.getindex(a1, i)))
│          Core.Const(:(Base.getindex(a2, i)))
│          Core.Const(:((%173)(%174, %175)))
│          Core.Const(:(res = (%170)(%171, %176)))
│          Core.Const(:(@_4 = Base.iterate(%161, %168)))
│          Core.Const(:(@_4 === nothing))
│          Core.Const(:(Base.not_int(%179)))
│          Core.Const(:(goto %183 if not %180))
│          Core.Const(:(goto %166))
│          Core.Const(:(val@_5 = nothing))
│          Core.Const(nothing)
└──        Core.Const(:(val@_5))
6 ┄        return res

Any ideas on how to make progress?
Another weird thing is that I found VectorizationBase.promote(vxiu,vxfu,vxfu) to throw an error on one of my other machines, (from Base.note_sametype).
Should I open a separate issue on this?

chriselrod added the good first issue Good for newcomers label Jan 18, 2024

GianlucaFuwa mentioned this issue Apr 14, 2024

Type-assert vconverts to circumvent inference restriction on recursion JuliaSIMD/VectorizationBase.jl#109

Merged

chriselrod closed this as completed in JuliaSIMD/VectorizationBase.jl#109 Apr 15, 2024

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

type inference issue with vectors if ints and floats in julia 1.10 #526

type inference issue with vectors if ints and floats in julia 1.10 #526

NilsNiggemann commented Jan 18, 2024

chriselrod commented Jan 18, 2024 •

edited

Loading

chriselrod commented Jan 18, 2024

NilsNiggemann commented Jan 23, 2024

type inference issue with vectors if ints and floats in julia 1.10 #526

type inference issue with vectors if ints and floats in julia 1.10 #526

Comments

NilsNiggemann commented Jan 18, 2024

chriselrod commented Jan 18, 2024 • edited Loading

chriselrod commented Jan 18, 2024

NilsNiggemann commented Jan 23, 2024

chriselrod commented Jan 18, 2024 •

edited

Loading