Allocations in convert(Ptr{T}, Handle{T})

[staticfloat]

We appear to be getting unnecessary allocations due to the implementation of Handle{T}. In particular:

julia> @code_warntype convert(Ptr{Sundials.IDAMem}, integ.mem)
MethodInstance for convert(::Type{Ptr{Sundials.IDAMem}}, ::Sundials.Handle{Sundials.IDAMem})
  from convert(::Type{Ptr{T}}, h::Sundials.Handle{T}) where T @ Sundials ~/.julia/dev/Sundials/src/handle.jl:86
Static Parameters
  T = Sundials.IDAMem
Arguments
  #self#::Core.Const(convert)
  _::Core.Const(Ptr{Sundials.IDAMem})
  h::Sundials.Handle{Sundials.IDAMem}
Body::Any
1 ─ %1 = Base.getproperty(h, :ptr_ref)::Ref{Ptr{Sundials.IDAMem}}
│   %2 = Base.getindex(%1)::Any
└──      return %2

The ::Any from h.ptr_ref[] seems to force the allocation of a Box, and since this happens every time we ask the integrator for a state vector, it can add up to many thousands of allocations per solve, and if you're doing a large parameter sweep of simple systems, you can quickly spend more time GC'ing than solving.

[staticfloat]

@vtjnash Is this a fundamental limitation of Ref? Minimizing the example:

struct Handle{T}
    ptr_ref::Ref{Ptr{T}}
end
Base.unsafe_convert(::Type{Ptr{T}}, h::Handle{T}) where {T} = h.ptr_ref[]

h = Handle{Int}(Ref(Ptr{Int}(0)))
@code_warntype Base.unsafe_convert(Ptr{Int}, h)

Shows an ::Any where I would expect a Ptr{Int}:

MethodInstance for Base.unsafe_convert(::Type{Ptr{Int64}}, ::Handle{Int64})
  from unsafe_convert(::Type{Ptr{T}}, h::Handle{T}) where T @ Main REPL[26]:4
Static Parameters
  T = Int64
Arguments
  #self#::Core.Const(Base.unsafe_convert)
  _::Core.Const(Ptr{Int64})
  h::Handle{Int64}
Body::Any
1 ─ %1 = Base.getproperty(h, :ptr_ref)::Ref{Ptr{Int64}}
│   %2 = Base.getindex(%1)::Any
└──      return %2

[vtjnash]

It is an abstract type. A mutable struct usually makes more sense, since it performs better (if you don't need to pass it to C) and allocating a new Ref makes more sense if you do need to pass to C (since it can be stack allocated)

[staticfloat]

So if I'm understanding you correctly, you're suggesting Handle above instead be implemented as:

mutable struct Handle{T}
    ptr::Ptr{T}
end
Base.unsafe_convert(::Type{Ptr{T}}, h::Handle{T}) where {T} = h.ptr

h = Handle{Int}(Ptr{Int}(0))