`CategoricalValue` allocates on julia 1.11

[tiemvanderdeure]

MWE

using CategoricalArrays
A = rand(1:10, 1000)
Acat = categorical(A)
@allocations getindex.(Ref(Acat),eachindex(Acat))

On julia 1.11.2, this gives 1020 allocations (vs 17 on julia 1.10.7). The computation time is also ~ doubled. I profiled and it seems each call to CategoricalValue generates an allocation.

[nalimilan]

Sorry for the slow response, I had missed the issue.

There's something weird in the @code_warntype output on 1.11:

julia> @code_warntype Acat[1]
MethodInstance for getindex(::CategoricalVector{Int64, UInt32, Int64, CategoricalValue{Int64, UInt32}, Union{}}, ::Int64)
  from getindex(A::CategoricalArray{T}, I...) where T @ CategoricalArrays ~/.julia/dev/CategoricalArrays/src/array.jl:738
Static Parameters
  T = Int64
Arguments
  #self#::Core.Const(getindex)
  A::CategoricalVector{Int64, UInt32, Int64, CategoricalValue{Int64, UInt32}, Union{}}
  I::Tuple{Int64}
Locals
  val@_4::CategoricalValue{Int64, UInt32}
  val@_5::UInt32
  res::CategoricalValue{Int64, UInt32}
  r::UInt32
Body::CategoricalValue{Int64, UInt32}
1 ─       nothing
│         Core.NewvarNode(:(val@_4))
│         Core.NewvarNode(:(val@_5))
│         Core.NewvarNode(:(res))
│         Core.NewvarNode(:(r))
│   %6  = $(Expr(:boundscheck))::Bool
└──       goto #3 if not %6
2 ─ %8  = CategoricalArrays.checkbounds::Core.Const(checkbounds)
│   %9  = Core.tuple(A)::Tuple{CategoricalVector{Int64, UInt32, Int64, CategoricalValue{Int64, UInt32}, Union{}}}
└──       Core._apply_iterate(Base.iterate, %8, %9, I)
3 ┄       nothing
│   %12 = I::Tuple{Int64}
│   %13 = Base.getproperty(A, :refs)::Vector{UInt32}
│   %14 = Core.tuple(%13)::Tuple{Vector{UInt32}}
│   %15 = Core._apply_iterate(Base.iterate, Base.getindex, %14, %12)::UInt32
│         (r = %15)
│         (val@_5 = %15)
│         nothing
│         val@_5
│   %20 = CategoricalArrays.isa::Core.Const(isa)
│   %21 = r::UInt32
│   %22 = (%20)(%21, CategoricalArrays.Array)::Core.Const(false)
└──       goto #5 if not %22
4 ─       Core.Const(:(CategoricalArrays.CategoricalArray))
│         Core.Const(:($(Expr(:static_parameter, 1))))
│         Core.Const(:(CategoricalArrays.ndims))
│         Core.Const(:(r))
│         Core.Const(:((%26)(%27)))
│         Core.Const(:(Core.apply_type(%24, %25, %28)))
│         Core.Const(:(r))
│         Core.Const(:(CategoricalArrays.copy))
│         Core.Const(:(Base.getproperty(A, :pool)))
│         Core.Const(:((%31)(%32)))
│         Core.Const(:(res = (%29)(%30, %33)))
│         Core.Const(:(CategoricalArrays.ordered!))
│         Core.Const(:(res))
│         Core.Const(:(CategoricalArrays.isordered(A)))
│         Core.Const(:((%35)(%36, %37)))
└──       Core.Const(:(return %38))
5 ┄ %40 = CategoricalArrays.:>::Core.Const(>)
│   %41 = r::UInt32
│   %42 = (%40)(%41, 0)::Bool
└──       goto #7 if not %42
6 ─       goto #8
7 ─ %45 = CategoricalArrays.throw::Core.Const(throw)
│   %46 = CategoricalArrays.UndefRefError::Core.Const(UndefRefError)
│   %47 = (%46)()::Any
└──       (%45)(%47)
8 ┄       nothing
│   %50 = Base.getproperty(A, :pool)::CategoricalPool{Int64, UInt32, CategoricalValue{Int64, UInt32}}
│   %51 = r::UInt32
│   %52 = Base.getindex(%50, %51)::CategoricalValue{Int64, UInt32}
│         (res = %52)
│         (val@_4 = %52)
│         nothing
│         val@_4
│   %57 = res::CategoricalValue{Int64, UInt32}
└──       return %57

I don't understand where the ::Any comes from. This seems to correspond to this line:

CategoricalArrays.jl/src/array.jl

Line 747 in d0f7081

r > 0 || throw(UndefRefError())

Could be worth reporting against Julia or asking for comments.

[nalimilan]

That ::Any may be a red herring, as I still see it with a MWE which doesn't make any allocations:

julia> struct MyArray
           refs::Vector{Int}
       end

julia> @inline function Base.getindex(A::MyArray, I...)
           r = A.refs[I...]

           r > 0 || throw(UndefRefError())
           return r
       end

julia> A = MyArray([1, 2, 3])
MyArray([1, 2, 3])

julia> @code_warntype A[1]
MethodInstance for getindex(::MyArray, ::Int64)
  from getindex(A::MyArray, I...) @ Main REPL[47]:1
Arguments
  #self#::Core.Const(getindex)
  A::MyArray
  I::Tuple{Int64}
Locals
  r::Int64
Body::Int64
1 ─       nothing
│   %2  = I::Tuple{Int64}
│   %3  = Base.getproperty(A, :refs)::Vector{Int64}
│   %4  = Core.tuple(%3)::Tuple{Vector{Int64}}
│         (r = Core._apply_iterate(Base.iterate, Base.getindex, %4, %2))
│   %6  = r::Int64
│   %7  = (%6 > 0)::Bool
└──       goto #3 if not %7
2 ─       goto #4
3 ─ %10 = Main.throw::Core.Const(throw)
│   %11 = Main.UndefRefError()::Any
└──       (%10)(%11)
4 ┄ %13 = r::Int64
└──       return %13


julia> @allocated A[1]
102720

julia> @allocated A[1]
0

[nalimilan]

I've filed JuliaLang/julia#58169.

[tiemvanderdeure]

Thanks for following up here @nalimilan! I'm afraid I don't have enough time (or knowledge) to dive much deeper into this right now. But I guess you're right that this is more of a Julia issue than a CategoricalArrays issue.