Merge pull request #7 from ChrisRackauckas/staticarrayinterface

update to StaticArrayInterface

Author: chriselrod

Project.toml

@@ -4,21 +4,17 @@ authors = ["chriselrod <[email protected]> and contributors"]
 version = "0.1.13"
 
 [deps]
-ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
-ArrayInterfaceOffsetArrays = "015c0d05-e682-4f19-8f0a-679ce4c54826"
-ArrayInterfaceStaticArrays = "b0d46f97-bff5-4637-a19a-dd75974142cd"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 ManualMemory = "d125e4d3-2237-4719-b19c-fa641b8a4667"
 SIMDTypes = "94e857df-77ce-4151-89e5-788b33177be4"
 Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
+StaticArrayInterface = "0d7ed370-da01-4f52-bd93-41d350b8b718"
 
 [compat]
-ArrayInterface = "3.1.24, 4, 5, 6"
-ArrayInterfaceOffsetArrays = "0.1"
-ArrayInterfaceStaticArrays = "0.1"
 ManualMemory = "0.1.6"
 SIMDTypes = "0.1"
-Static = "0.3, 0.4, 0.5, 0.6, 0.7, 0.8"
+Static = "0.8"
+StaticArrayInterface = "1"
 julia = "1.6"
 
 [extras]

src/LayoutPointers.jl

@@ -1,16 +1,12 @@
 module LayoutPointers
-if isdefined(Base, :Experimental) &&
-   isdefined(Base.Experimental, Symbol("@max_methods"))
-    @eval Base.Experimental.@max_methods 1
+if isdefined(Base, :Experimental) && isdefined(Base.Experimental, Symbol("@max_methods"))
+  @eval Base.Experimental.@max_methods 1
 end
 
-using ArrayInterface, Static, LinearAlgebra
-using ArrayInterface: CPUPointer, StrideIndex, offsets
-using ArrayInterfaceOffsetArrays
-using ArrayInterfaceStaticArrays
+using Static, LinearAlgebra, StaticArrayInterface
 using SIMDTypes: Bit, FloatingTypes, IntegerTypesHW
 using Static: Zero, One
-using ArrayInterface:
+using StaticArrayInterface:
   contiguous_axis,
   contiguous_axis_indicator,
   contiguous_batch_size,
@@ -20,12 +16,15 @@ using ArrayInterface:
   CPUTuple,
   static_first,
   static_step,
-  strides
+  static_strides,
+  CPUPointer,
+  StrideIndex,
+  offsets
 using ManualMemory: preserve_buffer, offsetsize
 
 export stridedpointer
 
-const IntegerTypes = Union{IntegerTypesHW, StaticInt}
+const IntegerTypes = Union{IntegerTypesHW,StaticInt}
 
 @inline _map(f::F, x::Tuple{}) where {F} = ()
 @inline _map(f::F, x::Tuple{X1}) where {F,X1} = (f(getfield(x, 1, false)),)

src/grouped_strided_pointers.jl

@@ -35,7 +35,7 @@ end
 @inline val_dense_dims(::DensePointerWrapper{D}) where {D} = Val{D}()
 
 @inline Base.pointer(A::DensePointerWrapper) = pointer(getfield(A, :p))
-@inline ArrayInterface.StrideIndex(sptr::DensePointerWrapper) =
+@inline StaticArrayInterface.StrideIndex(sptr::DensePointerWrapper) =
   StrideIndex(getfield(sptr, :p))
 
 
@@ -45,7 +45,7 @@ end
   DensePointerWrapper{D,T,N,C,B,R,X,O,P}(sp)
 
 @inline _gp_strides(x::StrideIndex) = getfield(x, :strides)
-@inline _gp_strides(x) = strides(x)
+@inline _gp_strides(x) = static_strides(x)
 @inline _gp_strides(::NoStrides) = NoStrides()
 grouped_strided_pointer(::Tuple{}, ::Val{()}) = ((), ())
 

src/stridedpointers.jl

@@ -11,10 +11,12 @@ end
 @inline mulsizeof(::Type{T}, x::Tuple{X1,X2,Vararg}) where {T,X1,X2} =
   (mulsizeof(T, getfield(x, 1, false)), mulsizeof(T, Base.tail(x))...)
 
-@inline bytestrides(A::AbstractArray{T}) where {T} = mulsizeof(T, ArrayInterface.strides(A))
+@inline bytestrides(A::AbstractArray{T}) where {T} =
+  mulsizeof(T, StaticArrayInterface.static_strides(A))
 
-@inline memory_reference(A::NTuple) = memory_reference(ArrayInterface.device(A), A)
-@inline memory_reference(A::AbstractArray) = memory_reference(ArrayInterface.device(A), A)
+@inline memory_reference(A::NTuple) = memory_reference(StaticArrayInterface.device(A), A)
+@inline memory_reference(A::AbstractArray) =
+  memory_reference(StaticArrayInterface.device(A), A)
 @inline memory_reference(A::BitArray) = Base.unsafe_convert(Ptr{Bit}, A.chunks), A.chunks
 @inline memory_reference(::CPUPointer, A) = pointer(A), preserve_buffer(A)
 @inline memory_reference(
@@ -39,34 +41,34 @@ end
 @inline function memory_reference_subarray(::PT, A::SubArray) where {PT}
   p, m = memory_reference(PT(), parent(A))
   pA = parent(A)
-  offset = ArrayInterface.reduce_tup(
+  offset = StaticArrayInterface.reduce_tup(
     +,
-    _map(*, _map(ind_diff, A.indices, offsets(pA)), strides(pA)),
+    _map(*, _map(ind_diff, A.indices, offsets(pA)), static_strides(pA)),
   )
   p + sizeof(eltype(A)) * offset, m
 end
 @inline function memory_reference(::CPUTuple, A)
   r = Ref(A)
   Base.unsafe_convert(Ptr{eltype(A)}, Base.pointer_from_objref(r)), r
 end
-@inline function memory_reference(::ArrayInterface.CheckParent, A)
+@inline function memory_reference(::StaticArrayInterface.CheckParent, A)
   P = parent(A)
   if P === A
-    memory_reference(ArrayInterface.CPUIndex(), A)
+    memory_reference(StaticArrayInterface.CPUIndex(), A)
   else
-    memory_reference(ArrayInterface.device(P), P)
+    memory_reference(StaticArrayInterface.device(P), P)
   end
 end
-@inline memory_reference(::ArrayInterface.CPUIndex, A) =
+@inline memory_reference(::StaticArrayInterface.CPUIndex, A) =
   throw("Memory access for $(typeof(A)) not implemented yet.")
 
-@inline ArrayInterface.contiguous_axis(
+@inline StaticArrayInterface.contiguous_axis(
   ::Type{A},
 ) where {T,N,C,A<:AbstractStridedPointer{T,N,C}} = StaticInt{C}()
-@inline ArrayInterface.contiguous_batch_size(
+@inline StaticArrayInterface.contiguous_batch_size(
   ::Type{A},
 ) where {T,N,C,B,A<:AbstractStridedPointer{T,N,C,B}} = StaticInt{B}()
-@inline ArrayInterface.stride_rank(
+@inline StaticArrayInterface.stride_rank(
   ::Type{A},
 ) where {T,N,C,B,R,A<:AbstractStridedPointer{T,N,C,B,R}} = _map(StaticInt, R)
 @inline memory_reference(A::AbstractStridedPointer) = pointer(A), nothing
@@ -92,21 +94,26 @@ end
 end
 @inline function stridedpointer(A::AbstractArray)
   p, r = memory_reference(A)
-  stridedpointer(p, bytestrideindex(A), ArrayInterface.contiguous_batch_size(A))
+  stridedpointer(p, bytestrideindex(A), StaticArrayInterface.contiguous_batch_size(A))
 end
 @inline function stridedpointer_preserve(A::AbstractArray)
   p, r = memory_reference(A)
-  stridedpointer(p, bytestrideindex(A), ArrayInterface.contiguous_batch_size(A)), r
+  stridedpointer(p, bytestrideindex(A), StaticArrayInterface.contiguous_batch_size(A)), r
 end
 @inline function stridedpointer_preserve(t::NTuple)
   p, r = memory_reference(t)
-  stridedpointer(p, ArrayInterface.StrideIndex{1,(1,),1}((static(sizeof(eltype(t))),), (static(1),)), static(0)), r
+  stridedpointer(
+    p,
+    StaticArrayInterface.StrideIndex{1,(1,),1}((static(sizeof(eltype(t))),), (static(1),)),
+    static(0),
+  ),
+  r
 end
 @inline val_stride_rank(::AbstractStridedPointer{T,N,C,B,R}) where {T,N,C,B,R} = Val{R}()
 @generated val_dense_dims(::AbstractStridedPointer{T,N}) where {T,N} =
   Val{ntuple(==(0), Val(N))}()
 @inline val_stride_rank(A) = Val(known(stride_rank(A)))
-@inline val_dense_dims(A) = Val(known(ArrayInterface.dense_dims(A)))
+@inline val_dense_dims(A) = Val(known(StaticArrayInterface.dense_dims(A)))
 
 function zerotupleexpr(N::Int)
   t = Expr(:tuple)
@@ -126,7 +133,7 @@ end
 )
 @inline zstridedpointer(A) = zero_offsets(stridedpointer(A))
 @inline function zstridedpointer_preserve(A::AbstractArray{T,N}) where {T,N}
-  strd = mulsizeof(T, ArrayInterface.strides(A))
+  strd = mulsizeof(T, StaticArrayInterface.static_strides(A))
   si = StrideIndex{N,known(stride_rank(A)),Int(contiguous_axis(A))}(
     strd,
     zerotuple(Val(N)),
@@ -148,7 +155,7 @@ Base.unsafe_convert(::Type{Ptr{T}}, ptr::AbstractStridedPointer{T}) where {T} =
 end
 
 @inline dynamic_offsets(si::StrideIndex{N,R,C}) where {N,R,C} =
-  StrideIndex{N,R,C}(strides(si), _map(Int, offsets(si)))
+  StrideIndex{N,R,C}(static_strides(si), _map(Int, offsets(si)))
 struct StridedBitPointer{N,C,B,R,X,O} <: AbstractStridedPointer{Bit,N,C,B,R,X,O}
   p::Ptr{Bit}
   si::StrideIndex{N,R,C,X,O}
@@ -162,18 +169,19 @@ end
   StridedBitPointer{N,C,0,R,X,NTuple{N,Int}}(p, dynamic_offsets(si))
 
 @inline Base.pointer(p::Union{StridedPointer,StridedBitPointer}) = getfield(p, :p)
-@inline ArrayInterface.StrideIndex(sptr::Union{StridedPointer,StridedBitPointer}) =
+@inline StaticArrayInterface.StrideIndex(sptr::Union{StridedPointer,StridedBitPointer}) =
   getfield(sptr, :si)
 @inline bytestrideindex(sptr::AbstractStridedPointer) = StrideIndex(sptr)
 
 @inline bytestrides(si::StrideIndex) =
   _map(Base.Fix2(*, StaticInt{8}()), getfield(si, :strides))
 @inline bytestrides(ptr::AbstractStridedPointer) = getfield(StrideIndex(ptr), :strides)
 @inline Base.strides(ptr::AbstractStridedPointer) = getfield(StrideIndex(ptr), :strides)
-@inline ArrayInterface.strides(ptr::AbstractStridedPointer) =
+@inline StaticArrayInterface.static_strides(ptr::AbstractStridedPointer) =
   getfield(StrideIndex(ptr), :strides)
-@inline ArrayInterface.offsets(ptr::AbstractStridedPointer) = offsets(StrideIndex(ptr))
-@inline ArrayInterface.contiguous_axis_indicator(
+@inline StaticArrayInterface.offsets(ptr::AbstractStridedPointer) =
+  offsets(StrideIndex(ptr))
+@inline StaticArrayInterface.contiguous_axis_indicator(
   ptr::AbstractStridedPointer{T,N,C},
 ) where {T,N,C} = contiguous_axis_indicator(StaticInt{C}(), Val{N}())
 
@@ -183,14 +191,14 @@ end
   ptr::Ptr,
   offset::Tuple,
 ) where {T,N,C,B,R}
-  si = StrideIndex{N,R,C}(strides(sptr), offset)
+  si = StrideIndex{N,R,C}(static_strides(sptr), offset)
   stridedpointer(ptr, si, contiguous_batch_size(sptr))
 end
 @inline function similar_no_offset(
   sptr::AbstractStridedPointer{T,N,C,B,R},
   ptr::Ptr,
 ) where {T,N,C,B,R}
-  si = StrideIndex{N,R,C}(strides(sptr), zerotuple(Val(N)))
+  si = StrideIndex{N,R,C}(static_strides(sptr), zerotuple(Val(N)))
   stridedpointer(ptr, si, contiguous_batch_size(sptr))
 end
 
@@ -203,7 +211,7 @@ end
 # s += A[i,i]
 # end
 # first access is at zero-based index
-# (first(6:16) - ArrayInterface.offsets(a)[1]) * ArrayInterface.strides(A)[1] + (first(6:16) - ArrayInterface.offsets(a)[2]) * ArrayInterface.strides(A)[2]
+# (first(6:16) - StaticArrayInterface.offsets(a)[1]) * StaticArrayInterface.static_strides(A)[1] + (first(6:16) - StaticArrayInterface.offsets(a)[2]) * StaticArrayInterface.static_strides(A)[2]
 # equal to
 #  (6 - 6)*1 + (6 - 5)*10 = 10
 # i.e., the 1-based index 11.
@@ -238,21 +246,21 @@ FastRange{T}(f::F, s::S) where {T<:FloatingTypes,F,S} = FastRange{T,F,S,Int}(f,
 # FastRange{T}(f::F,s::S,::False) where {T<:FloatingTypes,F,S} = FastRange{T,F,S,Int32}(f,s,zero(Int32))
 
 @inline function memory_reference(r::AbstractRange{T}) where {T}
-  s = ArrayInterface.static_step(r)
-  FastRange{T}(ArrayInterface.static_first(r) - s, s), nothing
+  s = StaticArrayInterface.static_step(r)
+  FastRange{T}(StaticArrayInterface.static_first(r) - s, s), nothing
 end
 @inline memory_reference(r::FastRange) = (r, nothing)
 @inline bytestrides(::FastRange{T}) where {T} = (StaticInt(sizeof(T)),)
-@inline ArrayInterface.offsets(::FastRange) = (One(),)
+@inline StaticArrayInterface.offsets(::FastRange) = (One(),)
 @inline val_stride_rank(::FastRange) = Val{(1,)}()
 @inline val_dense_dims(::FastRange) = Val{(true,)}()
-@inline ArrayInterface.contiguous_axis(::FastRange) = One()
-@inline ArrayInterface.contiguous_batch_size(::FastRange) = Zero()
+@inline StaticArrayInterface.contiguous_axis(::FastRange) = One()
+@inline StaticArrayInterface.contiguous_batch_size(::FastRange) = Zero()
 
 @inline stridedpointer(fr::FastRange, ::StrideIndex, ::StaticInt{0}) = fr
 struct NoStrides end
 @inline bytestrideindex(::FastRange) = NoStrides()
-@inline ArrayInterface.offsets(::NoStrides) = NoStrides()
+@inline StaticArrayInterface.offsets(::NoStrides) = NoStrides()
 @inline reconstruct_ptr(r::FastRange{T}, o) where {T} =
   FastRange{T}(getfield(r, :f), getfield(r, :s), o)
 

test/runtests.jl

@@ -1,4 +1,31 @@
-using LayoutPointers, ArrayInterface, ArrayInterfaceOffsetArrays, Aqua, Test
+using LayoutPointers, StaticArrayInterface, Aqua, Test
+struct SizedWrapper{M,N,T,AT<:AbstractMatrix{T}} <: AbstractMatrix{T}
+  A::AT
+end
+StaticArrayInterface.is_forwarding_wrapper(::Type{<:SizedWrapper}) = true
+SizedWrapper{M,N}(A::AT) where {M,N,T,AT<:AbstractMatrix{T}} = SizedWrapper{M,N,T,AT}(A)
+Base.size(::SizedWrapper{M,N}) where {M,N} = (M, N)
+Base.getindex(A::SizedWrapper, i...) = getindex(parent(A), i...)
+Base.parent(dw::SizedWrapper) = dw.A
+StaticArrayInterface.parent_type(::Type{SizedWrapper{M,N,T,AT}}) where {M,N,T,AT} = AT
+LayoutPointers.memory_reference(dw::SizedWrapper) =
+  LayoutPointers.memory_reference(parent(dw))
+StaticArrayInterface.contiguous_axis(dw::SizedWrapper) =
+  LayoutPointers.contiguous_axis(parent(dw))
+StaticArrayInterface.contiguous_batch_size(dw::SizedWrapper) =
+  LayoutPointers.contiguous_batch_size(parent(dw))
+LayoutPointers.val_stride_rank(dw::SizedWrapper) =
+  LayoutPointers.val_stride_rank(parent(dw))
+function StaticArrayInterface.static_strides(dw::SizedWrapper{M,N,T}) where {M,N,T}
+  if LayoutPointers.val_stride_rank(dw) === Val((1, 2))
+    return LayoutPointers.One(), LayoutPointers.StaticInt{M}()
+  else#if LayoutPointers.val_stride_rank(dw) === Val((2,1))
+    return LayoutPointers.StaticInt{N}(), LayoutPointers.One()
+  end
+end
+StaticArrayInterface.offsets(dw::SizedWrapper) = LayoutPointers.offsets(parent(dw))
+LayoutPointers.val_dense_dims(dw::SizedWrapper{T,N}) where {T,N} =
+  LayoutPointers.val_dense_dims(parent(dw))
 
 @testset "LayoutPointers.jl" begin
   Aqua.test_all(LayoutPointers)
@@ -9,33 +36,6 @@ using LayoutPointers, ArrayInterface, ArrayInterfaceOffsetArrays, Aqua, Test
     A = Matrix{Float64}(undef, M, K)
     B = Matrix{Float64}(undef, K, N)
     C = Matrix{Float64}(undef, M, N)
-    struct SizedWrapper{M,N,T,AT<:AbstractMatrix{T}} <: AbstractMatrix{T}
-      A::AT
-    end
-    ArrayInterface.is_forwarding_wrapper(::Type{<:SizedWrapper}) = true
-    SizedWrapper{M,N}(A::AT) where {M,N,T,AT<:AbstractMatrix{T}} = SizedWrapper{M,N,T,AT}(A)
-    Base.size(::SizedWrapper{M,N}) where {M,N} = (M, N)
-    Base.getindex(A::SizedWrapper, i...) = getindex(parent(A), i...)
-    Base.parent(dw::SizedWrapper) = dw.A
-    ArrayInterface.parent_type(::Type{SizedWrapper{M,N,T,AT}}) where {M,N,T,AT} = AT
-    LayoutPointers.memory_reference(dw::SizedWrapper) =
-      LayoutPointers.memory_reference(parent(dw))
-    ArrayInterface.contiguous_axis(dw::SizedWrapper) =
-      LayoutPointers.contiguous_axis(parent(dw))
-    ArrayInterface.contiguous_batch_size(dw::SizedWrapper) =
-      LayoutPointers.contiguous_batch_size(parent(dw))
-    LayoutPointers.val_stride_rank(dw::SizedWrapper) =
-      LayoutPointers.val_stride_rank(parent(dw))
-    function ArrayInterface.strides(dw::SizedWrapper{M,N,T}) where {M,N,T}
-      if LayoutPointers.val_stride_rank(dw) === Val((1, 2))
-        return LayoutPointers.One(), LayoutPointers.StaticInt{M}()
-      else#if LayoutPointers.val_stride_rank(dw) === Val((2,1))
-        return LayoutPointers.StaticInt{N}(), LayoutPointers.One()
-      end
-    end
-    ArrayInterface.offsets(dw::SizedWrapper) = LayoutPointers.offsets(parent(dw))
-    LayoutPointers.val_dense_dims(dw::SizedWrapper{T,N}) where {T,N} =
-      LayoutPointers.val_dense_dims(parent(dw))
 
     GC.@preserve A B C begin
       fs = (false, true)#[identity, adjoint]