Support pointers as memory backend

[giordano]

Today at JuliaCon I was talking with @MasonProtter about this package, and he brought up the idea of making the memory backend type a parameter, so that instead of Memory{T} one could use, say, Ptr{T}.

[giordano]

Actually, that's probably going to work already with #52?

[nsajko]

Currently #52 has the constraint on the Mem type parameter: <:GenericMemory{<:Any,T}. At some point in development I considered generalizing the constraint to <:DenseVector{T} (relevant for #35), but I guess I decided to leave that for later.

Perhaps Ptr could be supported, too, can't tell right away.

[giordano]

With #52, a good chunk of the work to extend the memory backend to a Ptr is done. A minimal patch to allow creating fixed-size arrays backed by pointers can be something like (very unsafe, as is dealing with pointers directly)

diff --git a/src/FixedSizeArrays.jl b/src/FixedSizeArrays.jl
index 41c1394..8be5990 100644
--- a/src/FixedSizeArrays.jl
+++ b/src/FixedSizeArrays.jl
@@ -11,10 +11,10 @@ Implementation detail. Do not use.
 """
 struct Internal end
 
-struct FixedSizeArray{T,N,Mem<:GenericMemory{<:Any,T}} <: DenseArray{T,N}
+struct FixedSizeArray{T,N,Mem<:Union{GenericMemory{<:Any,T},Ptr{T}}} <: DenseArray{T,N}
     mem::Mem
     size::NTuple{N,Int}
-    function FixedSizeArray{T,N,M}(::Internal, mem::M, size::NTuple{N,Int}) where {T,N,M<:GenericMemory{<:Any,T}}
+    function FixedSizeArray{T,N,M}(::Internal, mem::M, size::NTuple{N,Int}) where {T,N,M<:Union{GenericMemory{<:Any,T},Ptr{T}}}
         new{T,N,M}(mem, size)
     end
 end
@@ -53,9 +53,19 @@ function FixedSizeArray{T}(::UndefInitializer, size::NTuple{N,Integer}) where {T
     FixedSizeArray{T,N}(undef, size)
 end
 
+function FixedSizeArray{T,N}(ptr::Ptr{T}, size::NTuple{N,Integer}) where {T,N}
+    FixedSizeArray{T,N,Ptr{T}}(Internal(), ptr, size)
+end
+function FixedSizeArray{T}(ptr::Ptr{T}, size::NTuple{N,Integer}) where {T,N}
+    FixedSizeArray{T,N}(ptr, size)
+end
+
+
 Base.IndexStyle(::Type{<:FixedSizeArray}) = IndexLinear()
 Base.@propagate_inbounds Base.getindex(A::FixedSizeArray, i::Int) = A.mem[i]
 Base.@propagate_inbounds Base.setindex!(A::FixedSizeArray, v, i::Int) = A.mem[i] = v
+Base.getindex(A::FixedSizeArray{T,N,Ptr{T}}, i::Int) where {T,N} = unsafe_load(A.mem, i)
+Base.setindex!(A::FixedSizeArray{T,N,Ptr{T}}, v, i::Int) where {T,N} = unsafe_store!(A.mem, v, i)
 
 Base.size(a::FixedSizeArray) = a.size

At least with this patch you can wrap a pointer into a FixedSizeArray, get and set its elements, but I'm not sure how to further extend this: for example displaying a pointer-backed fixed-size array fails due to isassigned not being defined for pointers, which is used internally by matrix-printing functions:

Error showing value of type FixedSizeVector{Float64, Ptr{Float64}}:
ERROR: MethodError: no method matching isassigned(::Ptr{Float64}, ::Int64)
The function `isassigned` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  isassigned(::Core.SimpleVector, ::Int64)
   @ Base essentials.jl:984
  isassigned(::Vector, ::Int64)
   @ Base array.jl:245
  isassigned(::Array, ::Int64...)
   @ Base array.jl:237
  ...

Stacktrace:
  [1] isassigned(a::FixedSizeVector{Float64, Ptr{Float64}}, i::Int64)
    @ FixedSizeArrays ~/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:76
  [2] isassigned(::FixedSizeVector{Float64, Ptr{Float64}}, ::Int64, ::Int64)
    @ Base ./multidimensional.jl:1642
  [3] alignment(io::IOContext{Base.TTY}, X::AbstractVecOrMat, rows::Vector{Int64}, cols::Vector{Int64}, cols_if_complete::Int64, cols_otherwise::Int64, sep::Int64, ncols::Int64)
    @ Base ./arrayshow.jl:68
  [4] _print_matrix(io::IOContext{…}, X::AbstractVecOrMat, pre::String, sep::String, post::String, hdots::String, vdots::String, ddots::String, hmod::Int64, vmod::Int64, rowsA::UnitRange{…}, colsA::UnitRange{…})
    @ Base ./arrayshow.jl:207

Memory plays much more nicely with all of this, but I don't think we want to go down the path of extending all these internal Base functions for pointer-backed fixed-size arrays.

[nsajko]

@LilithHafner's PtrArrays seems possibly relevant, in at least one way: PtrArrays does basically what you're requesting here, wrapping a Ptr into a DenseArray, so it basically manifests a workaround for this issue: instead of wrapping a Ptr, wrap a PtrArray.

That said, first we'd need a way to wrap other DenseArrays, we could add a function wrap_dense_vector_as_fixed_size_array that would just call the internal constructor after checking the dimension sizes match as expected.

Furthermore, we might want to expand, apart of to Ptr, to certain dense arrays which are not DenseArray, like here in Base:

# We can avoid a multiplication if the first parent index is a Colon or AbstractUnitRange,
# or if all the indices are scalars, i.e. the view is for a single value only
FastContiguousSubArray{T,N,P,I<:Union{Tuple{AbstractUnitRange, Vararg{Any}},
                                      Tuple{Vararg{ScalarIndex}}}} = SubArray{T,N,P,I,true}

"""
An internal type representing arrays stored contiguously in memory.
"""
const DenseArrayType{T,N} = Union{
    DenseArray{T,N},
    <:FastContiguousSubArray{T,N,<:DenseArray},
}

https://github.com/JuliaLang/julia/blob/2ca125f6f3d4e49d1ae0db762270edc1b4875bb0/base/subarray.jl#L343-L357

[nsajko]

not sure how to further extend this: for example displaying a pointer-backed fixed-size array fails due to isassigned not being defined for pointers

I think we'd want something like this:

function Base.isassigned(a::FixedSizePtrArray, indices::Vararg{Int})
    # `unsafe_load` seems to never throw `UndefRefError`, so just check if the
    # indices are in bounds
    checkbounds(Bool, a, indices...)
end

NB: Base actually provides a correct fallback, although it relies on try-catch, so it has bad performance:

https://github.com/JuliaLang/julia/blob/f91436eae7265a01bff17e35887cd9b8e15c8fdc/base/multidimensional.jl#L1639-L1661

[nsajko]

I'm not sure how elsize is supposed to be implemented, though. I think we may need to worry about things like alignment and whether the element type is concrete:

https://github.com/JuliaLang/julia/blob/f91436eae7265a01bff17e35887cd9b8e15c8fdc/base/array.jl#L224-L232