From a8eda352d36c68bf2fd5b80b4e7856e1f421bb22 Mon Sep 17 00:00:00 2001 From: Jameson Nash Date: Thu, 9 Nov 2023 09:22:29 -0500 Subject: [PATCH] Revert "Make `StridedReinterpretArray`'s `get/setindex` pointer based. (#44186)" This reverts commit 19724320faf0a5b8a4a61e2276d604d2211f6a61. --- base/reinterpretarray.jl | 62 ++----- test/reinterpretarray.jl | 235 ++++++++++--------------- test/testhelpers/arrayindexingtypes.jl | 3 - 3 files changed, 109 insertions(+), 191 deletions(-) diff --git a/base/reinterpretarray.jl b/base/reinterpretarray.jl index 23bfb38a28654..16d2716c7a2eb 100644 --- a/base/reinterpretarray.jl +++ b/base/reinterpretarray.jl @@ -352,7 +352,7 @@ has_offset_axes(a::ReinterpretArray) = has_offset_axes(a.parent) elsize(::Type{<:ReinterpretArray{T}}) where {T} = sizeof(T) cconvert(::Type{Ptr{T}}, a::ReinterpretArray{T,N,S} where N) where {T,S} = cconvert(Ptr{S}, a.parent) -@propagate_inbounds function getindex(a::NonReshapedReinterpretArray{T,0,S}) where {T,S} +@inline @propagate_inbounds function getindex(a::NonReshapedReinterpretArray{T,0,S}) where {T,S} if isprimitivetype(T) && isprimitivetype(S) reinterpret(T, a.parent[]) else @@ -360,24 +360,15 @@ cconvert(::Type{Ptr{T}}, a::ReinterpretArray{T,N,S} where N) where {T,S} = cconv end end -check_ptr_indexable(a::ReinterpretArray, sz = elsize(a)) = check_ptr_indexable(parent(a), sz) -check_ptr_indexable(a::ReshapedArray, sz) = check_ptr_indexable(parent(a), sz) -check_ptr_indexable(a::FastContiguousSubArray, sz) = check_ptr_indexable(parent(a), sz) -check_ptr_indexable(a::Array, sz) = sizeof(eltype(a)) !== sz -check_ptr_indexable(a::Memory, sz) = true -check_ptr_indexable(a::AbstractArray, sz) = false +@inline @propagate_inbounds getindex(a::ReinterpretArray) = a[firstindex(a)] -@propagate_inbounds getindex(a::ReinterpretArray) = a[firstindex(a)] - -@propagate_inbounds function getindex(a::ReinterpretArray{T,N,S}, inds::Vararg{Int, N}) where {T,N,S} +@inline @propagate_inbounds function getindex(a::ReinterpretArray{T,N,S}, inds::Vararg{Int, N}) where {T,N,S} check_readable(a) - check_ptr_indexable(a) && return _getindex_ptr(a, inds...) _getindex_ra(a, inds[1], tail(inds)) end -@propagate_inbounds function getindex(a::ReinterpretArray{T,N,S}, i::Int) where {T,N,S} +@inline @propagate_inbounds function getindex(a::ReinterpretArray{T,N,S}, i::Int) where {T,N,S} check_readable(a) - check_ptr_indexable(a) && return _getindex_ptr(a, i) if isa(IndexStyle(a), IndexLinear) return _getindex_ra(a, i, ()) end @@ -387,22 +378,16 @@ end isempty(inds) ? _getindex_ra(a, 1, ()) : _getindex_ra(a, inds[1], tail(inds)) end -@propagate_inbounds function getindex(a::ReshapedReinterpretArray{T,N,S}, ind::SCartesianIndex2) where {T,N,S} +@inline @propagate_inbounds function getindex(a::ReshapedReinterpretArray{T,N,S}, ind::SCartesianIndex2) where {T,N,S} check_readable(a) s = Ref{S}(a.parent[ind.j]) - tptr = Ptr{T}(unsafe_convert(Ref{S}, s)) - GC.@preserve s return unsafe_load(tptr, ind.i) -end - -@inline function _getindex_ptr(a::ReinterpretArray{T}, inds...) where {T} - @boundscheck checkbounds(a, inds...) - li = _to_linear_index(a, inds...) - ap = cconvert(Ptr{T}, a) - p = unsafe_convert(Ptr{T}, ap) + sizeof(T) * (li - 1) - GC.@preserve ap return unsafe_load(p) + GC.@preserve s begin + tptr = Ptr{T}(unsafe_convert(Ref{S}, s)) + return unsafe_load(tptr, ind.i) + end end -@propagate_inbounds function _getindex_ra(a::NonReshapedReinterpretArray{T,N,S}, i1::Int, tailinds::TT) where {T,N,S,TT} +@inline @propagate_inbounds function _getindex_ra(a::NonReshapedReinterpretArray{T,N,S}, i1::Int, tailinds::TT) where {T,N,S,TT} # Make sure to match the scalar reinterpret if that is applicable if sizeof(T) == sizeof(S) && (fieldcount(T) + fieldcount(S)) == 0 if issingletontype(T) # singleton types @@ -458,7 +443,7 @@ end end end -@propagate_inbounds function _getindex_ra(a::ReshapedReinterpretArray{T,N,S}, i1::Int, tailinds::TT) where {T,N,S,TT} +@inline @propagate_inbounds function _getindex_ra(a::ReshapedReinterpretArray{T,N,S}, i1::Int, tailinds::TT) where {T,N,S,TT} # Make sure to match the scalar reinterpret if that is applicable if sizeof(T) == sizeof(S) && (fieldcount(T) + fieldcount(S)) == 0 if issingletontype(T) # singleton types @@ -505,7 +490,7 @@ end end end -@propagate_inbounds function setindex!(a::NonReshapedReinterpretArray{T,0,S}, v) where {T,S} +@inline @propagate_inbounds function setindex!(a::NonReshapedReinterpretArray{T,0,S}, v) where {T,S} if isprimitivetype(S) && isprimitivetype(T) a.parent[] = reinterpret(S, v) return a @@ -513,17 +498,15 @@ end setindex!(a, v, firstindex(a)) end -@propagate_inbounds setindex!(a::ReinterpretArray, v) = setindex!(a, v, firstindex(a)) +@inline @propagate_inbounds setindex!(a::ReinterpretArray, v) = setindex!(a, v, firstindex(a)) -@propagate_inbounds function setindex!(a::ReinterpretArray{T,N,S}, v, inds::Vararg{Int, N}) where {T,N,S} +@inline @propagate_inbounds function setindex!(a::ReinterpretArray{T,N,S}, v, inds::Vararg{Int, N}) where {T,N,S} check_writable(a) - check_ptr_indexable(a) && return _setindex_ptr!(a, v, inds...) _setindex_ra!(a, v, inds[1], tail(inds)) end -@propagate_inbounds function setindex!(a::ReinterpretArray{T,N,S}, v, i::Int) where {T,N,S} +@inline @propagate_inbounds function setindex!(a::ReinterpretArray{T,N,S}, v, i::Int) where {T,N,S} check_writable(a) - check_ptr_indexable(a) && return _setindex_ptr!(a, v, i) if isa(IndexStyle(a), IndexLinear) return _setindex_ra!(a, v, i, ()) end @@ -531,7 +514,7 @@ end _setindex_ra!(a, v, inds[1], tail(inds)) end -@propagate_inbounds function setindex!(a::ReshapedReinterpretArray{T,N,S}, v, ind::SCartesianIndex2) where {T,N,S} +@inline @propagate_inbounds function setindex!(a::ReshapedReinterpretArray{T,N,S}, v, ind::SCartesianIndex2) where {T,N,S} check_writable(a) v = convert(T, v)::T s = Ref{S}(a.parent[ind.j]) @@ -543,16 +526,7 @@ end return a end -@inline function _setindex_ptr!(a::ReinterpretArray{T}, v, inds...) where {T} - @boundscheck checkbounds(a, inds...) - li = _to_linear_index(a, inds...) - ap = cconvert(Ptr{T}, a) - p = unsafe_convert(Ptr{T}, ap) + sizeof(T) * (li - 1) - GC.@preserve ap unsafe_store!(p, v) - return a -end - -@propagate_inbounds function _setindex_ra!(a::NonReshapedReinterpretArray{T,N,S}, v, i1::Int, tailinds::TT) where {T,N,S,TT} +@inline @propagate_inbounds function _setindex_ra!(a::NonReshapedReinterpretArray{T,N,S}, v, i1::Int, tailinds::TT) where {T,N,S,TT} v = convert(T, v)::T # Make sure to match the scalar reinterpret if that is applicable if sizeof(T) == sizeof(S) && (fieldcount(T) + fieldcount(S)) == 0 @@ -625,7 +599,7 @@ end return a end -@propagate_inbounds function _setindex_ra!(a::ReshapedReinterpretArray{T,N,S}, v, i1::Int, tailinds::TT) where {T,N,S,TT} +@inline @propagate_inbounds function _setindex_ra!(a::ReshapedReinterpretArray{T,N,S}, v, i1::Int, tailinds::TT) where {T,N,S,TT} v = convert(T, v)::T # Make sure to match the scalar reinterpret if that is applicable if sizeof(T) == sizeof(S) && (fieldcount(T) + fieldcount(S)) == 0 diff --git a/test/reinterpretarray.jl b/test/reinterpretarray.jl index 05a40895b7934..501e9f4a9b57f 100644 --- a/test/reinterpretarray.jl +++ b/test/reinterpretarray.jl @@ -6,28 +6,20 @@ using .Main.OffsetArrays isdefined(Main, :TSlow) || @eval Main include("testhelpers/arrayindexingtypes.jl") using .Main: TSlow, WrapperArray -tslow(a::AbstractArray) = TSlow(a) -wrapper(a::AbstractArray) = WrapperArray(a) -fcviews(a::AbstractArray) = view(a, ntuple(Returns(:),ndims(a)-1)..., axes(a)[end]) -fcviews(a::AbstractArray{<:Any, 0}) = view(a) -tslow(t::Tuple) = map(tslow, t) -wrapper(t::Tuple) = map(wrapper, t) -fcviews(t::Tuple) = map(fcviews, t) - -test_many_wrappers(testf, A, wrappers) = foreach(w -> testf(w(A)), wrappers) -test_many_wrappers(testf, A) = test_many_wrappers(testf, A, (identity, tslow, wrapper, fcviews)) - A = Int64[1, 2, 3, 4] +As = TSlow(A) Ars = Int64[1 3; 2 4] +Arss = TSlow(Ars) B = Complex{Int64}[5+6im, 7+8im, 9+10im] +Bs = TSlow(B) Av = [Int32[1,2], Int32[3,4]] -test_many_wrappers(Ars, (identity, tslow)) do Ar +for Ar in (Ars, Arss) @test @inferred(ndims(reinterpret(reshape, Complex{Int64}, Ar))) == 1 @test @inferred(axes(reinterpret(reshape, Complex{Int64}, Ar))) === (Base.OneTo(2),) @test @inferred(size(reinterpret(reshape, Complex{Int64}, Ar))) == (2,) end -test_many_wrappers(B, (identity, tslow)) do _B +for _B in (B, Bs) @test @inferred(ndims(reinterpret(reshape, Int64, _B))) == 2 @test @inferred(axes(reinterpret(reshape, Int64, _B))) === (Base.OneTo(2), Base.OneTo(3)) @test @inferred(size(reinterpret(reshape, Int64, _B))) == (2, 3) @@ -50,25 +42,24 @@ end @test_throws ArgumentError("cannot reinterpret a zero-dimensional `UInt8` array to `UInt16` which is of a larger size") reinterpret(reshape, UInt16, reshape([0x01])) # getindex -test_many_wrappers(A) do _A +for _A in (A, As) @test reinterpret(Complex{Int64}, _A) == [1 + 2im, 3 + 4im] @test reinterpret(Float64, _A) == reinterpret.(Float64, A) @test reinterpret(reshape, Float64, _A) == reinterpret.(Float64, A) end -test_many_wrappers(Ars) do Ar +for Ar in (Ars, Arss) @test reinterpret(reshape, Complex{Int64}, Ar) == [1 + 2im, 3 + 4im] @test reinterpret(reshape, Float64, Ar) == reinterpret.(Float64, Ars) end -test_many_wrappers(B) do _B +for _B in (B, Bs) @test reinterpret(NTuple{3, Int64}, _B) == [(5,6,7),(8,9,10)] @test reinterpret(reshape, Int64, _B) == [5 7 9; 6 8 10] end # setindex -test_many_wrappers((A, Ars, B)) do (A, Ars, B) - _A, Ar, _B = deepcopy(A), deepcopy(Ars), deepcopy(B) - let Ac = deepcopy(_A), Arsc = deepcopy(Ar), Bc = deepcopy(_B) +for (_A, Ar, _B) in ((A, Ars, B), (As, Arss, Bs)) + let Ac = copy(_A), Arsc = copy(Ar), Bc = copy(_B) reinterpret(Complex{Int64}, Ac)[2] = -1 - 2im @test Ac == [1, 2, -1, -2] reinterpret(Complex{Int64}, Arsc)[2] = -1 - 2im @@ -103,67 +94,50 @@ test_many_wrappers((A, Ars, B)) do (A, Ars, B) end end A3 = collect(reshape(1:18, 2, 3, 3)) -test_many_wrappers(A3) do A3_ - A3 = deepcopy(A3_) - A3r = reinterpret(reshape, Complex{Int}, A3) - @test A3r[4] === A3r[1,2] === A3r[CartesianIndex(1, 2)] === 7+8im - A3r[2,3] = -8-15im - @test A3[1,2,3] == -8 - @test A3[2,2,3] == -15 - A3r[4] = 100+200im - @test A3[1,1,2] == 100 - @test A3[2,1,2] == 200 - A3r[CartesianIndex(1,2)] = 300+400im - @test A3[1,1,2] == 300 - @test A3[2,1,2] == 400 -end +A3r = reinterpret(reshape, Complex{Int}, A3) +@test A3r[4] === A3r[1,2] === A3r[CartesianIndex(1, 2)] === 7+8im +A3r[2,3] = -8-15im +@test A3[1,2,3] == -8 +@test A3[2,2,3] == -15 +A3r[4] = 100+200im +@test A3[1,1,2] == 100 +@test A3[2,1,2] == 200 +A3r[CartesianIndex(1,2)] = 300+400im +@test A3[1,1,2] == 300 +@test A3[2,1,2] == 400 # same-size reinterpret where one of the types is non-primitive -let a = NTuple{4,UInt8}[(0x01,0x02,0x03,0x04)] - test_many_wrappers(a, (identity, wrapper, fcviews)) do a_ - a = deepcopy(a_) - ra = reinterpret(Float32, a) - @test ra[1] == reinterpret(Float32, 0x04030201) - @test setindex!(ra, 2.0) === ra - @test reinterpret(Float32, a)[1] == 2.0 - end +let a = NTuple{4,UInt8}[(0x01,0x02,0x03,0x04)], ra = reinterpret(Float32, a) + @test ra[1] == reinterpret(Float32, 0x04030201) + @test setindex!(ra, 2.0) === ra + @test reinterpret(Float32, a)[1] == 2.0 end -let a = NTuple{4,UInt8}[(0x01,0x02,0x03,0x04)] - test_many_wrappers(a, (identity, wrapper, fcviews)) do a_ - a = deepcopy(a_) - ra = reinterpret(reshape, Float32, a) - @test ra[1] == reinterpret(Float32, 0x04030201) - @test setindex!(ra, 2.0) === ra - @test reinterpret(reshape, Float32, a)[1] == 2.0 - end +let a = NTuple{4,UInt8}[(0x01,0x02,0x03,0x04)], ra = reinterpret(reshape, Float32, a) + @test ra[1] == reinterpret(Float32, 0x04030201) + @test setindex!(ra, 2.0) === ra + @test reinterpret(reshape, Float32, a)[1] == 2.0 end # Pass-through indexing B = Complex{Int64}[5+6im, 7+8im, 9+10im] -test_many_wrappers(B) do B_ - B = deepcopy(B_) - Br = reinterpret(reshape, Int64, B) - W = WrapperArray(Br) - for (b, w) in zip(5:10, W) - @test b == w - end - for (i, j) in zip(eachindex(W), 11:16) - W[i] = j - end - @test B[1] === Complex{Int64}(11+12im) - @test B[2] === Complex{Int64}(13+14im) - @test B[3] === Complex{Int64}(15+16im) +Br = reinterpret(reshape, Int64, B) +W = WrapperArray(Br) +for (b, w) in zip(5:10, W) + @test b == w +end +for (i, j) in zip(eachindex(W), 11:16) + W[i] = j end +@test B[1] === Complex{Int64}(11+12im) +@test B[2] === Complex{Int64}(13+14im) +@test B[3] === Complex{Int64}(15+16im) z3 = (0x00, 0x00, 0x00) Az = [z3 z3; z3 z3] -test_many_wrappers(Az, (identity, wrapper)) do Az_ - Az = deepcopy(Az_) - Azr = reinterpret(reshape, UInt8, Az) - W = WrapperArray(Azr) - copyto!(W, fill(0x01, 3, 2, 2)) - @test all(isequal((0x01, 0x01, 0x01)), Az) - @test eachindex(W, W) == eachindex(W) -end +Azr = reinterpret(reshape, UInt8, Az) +W = WrapperArray(Azr) +copyto!(W, fill(0x01, 3, 2, 2)) +@test all(isequal((0x01, 0x01, 0x01)), Az) +@test eachindex(W, W) == eachindex(W) # ensure that reinterpret arrays aren't erroneously classified as strided let A = reshape(1:20, 5, 4) @@ -195,7 +169,7 @@ function check_strides(A::AbstractArray) end @testset "strides for NonReshapedReinterpretArray" begin - A = WrapperArray(Array{Int32}(reshape(1:88, 11, 8))) + A = Array{Int32}(reshape(1:88, 11, 8)) for viewax2 in (1:8, 1:2:6, 7:-1:1, 5:-2:1, 2:3:8, 7:-6:1, 3:5:11) # dim1 is contiguous for T in (Int16, Float32) @@ -229,7 +203,7 @@ end end @testset "strides for ReshapedReinterpretArray" begin - A = WrapperArray(Array{Int32}(reshape(1:192, 3, 8, 8))) + A = Array{Int32}(reshape(1:192, 3, 8, 8)) for viewax1 in (1:8, 1:2:8, 8:-1:1, 8:-2:1), viewax2 in (1:2, 4:-1:1) for T in (Int16, Float32) @test check_strides(reinterpret(reshape, T, view(A, 1:2, viewax1, viewax2))) @@ -266,8 +240,7 @@ end end # IndexStyle -test_many_wrappers(fill(1.0, 5, 3), (identity, wrapper)) do a_ - a = deepcopy(a_) +let a = fill(1.0, 5, 3) r = reinterpret(Int64, a) @test @inferred(IndexStyle(r)) == IndexLinear() fill!(r, 2) @@ -320,13 +293,14 @@ test_many_wrappers(fill(1.0, 5, 3), (identity, wrapper)) do a_ @test setindex!(r, -5, goodinds...) === r @test r[goodinds...] == -5 end -end -let ar = [(1,2), (3,4)] + + ar = [(1,2), (3,4)] arr = reinterpret(reshape, Int, ar) @test @inferred(IndexStyle(arr)) == Base.IndexSCartesian2{2}() @test @inferred(eachindex(arr)) == Base.SCartesianIndices2{2}(Base.OneTo(2)) @test @inferred(eachindex(arr, arr)) == Base.SCartesianIndices2{2}(Base.OneTo(2)) end + # Error on reinterprets that would expose padding struct S1 a::Int8 @@ -340,14 +314,11 @@ end A1 = S1[S1(0, 0)] A2 = S2[S2(0, 0)] -test_many_wrappers((A1, A2), (identity, wrapper)) do (A1_, A2_) - A1, A2 = deepcopy(A1_), deepcopy(A2_) - @test reinterpret(S1, A2)[1] == S1(0, 0) - @test_throws Base.PaddingError (reinterpret(S1, A2)[1] = S2(1, 2)) - @test_throws Base.PaddingError reinterpret(S2, A1)[1] - reinterpret(S2, A1)[1] = S2(1, 2) - @test A1[1] == S1(1, 2) -end +@test reinterpret(S1, A2)[1] == S1(0, 0) +@test_throws Base.PaddingError (reinterpret(S1, A2)[1] = S2(1, 2)) +@test_throws Base.PaddingError reinterpret(S2, A1)[1] +reinterpret(S2, A1)[1] = S2(1, 2) +@test A1[1] == S1(1, 2) # Unconventional axes let a = [0.1 0.2; 0.3 0.4], at = reshape([(i,i+1) for i = 1:2:8], 2, 2) @@ -400,59 +371,50 @@ end # Test 0-dimensional Arrays A = zeros(UInt32) -test_many_wrappers(A, (identity, wrapper)) do A_ - A = deepcopy(A_) - B = reinterpret(Int32, A) - Brs = reinterpret(reshape,Int32, A) - C = reinterpret(Tuple{UInt32}, A) # non-primitive type - Crs = reinterpret(reshape, Tuple{UInt32}, A) # non-primitive type - @test size(B) == size(Brs) == size(C) == size(Crs) == () - @test axes(B) == axes(Brs) == axes(C) == axes(Crs) == () - @test setindex!(B, Int32(5)) === B - @test B[] === Int32(5) - @test Brs[] === Int32(5) - @test C[] === (UInt32(5),) - @test Crs[] === (UInt32(5),) - @test A[] === UInt32(5) - @test setindex!(Brs, Int32(12)) === Brs - @test A[] === UInt32(12) - @test setindex!(C, (UInt32(7),)) === C - @test A[] === UInt32(7) - @test setindex!(Crs, (UInt32(3),)) === Crs - @test A[] === UInt32(3) -end - -test_many_wrappers([(1.0,2.0)], (identity, wrapper)) do a - af = @inferred(reinterpret(reshape, Float64, a)) - anew = @inferred(reinterpret(reshape, Tuple{Float64,Float64}, vec(af))) - @test anew[1] == a[1] - @test ndims(anew) == 0 -end +B = reinterpret(Int32, A) +Brs = reinterpret(reshape,Int32, A) +C = reinterpret(Tuple{UInt32}, A) # non-primitive type +Crs = reinterpret(reshape, Tuple{UInt32}, A) # non-primitive type +@test size(B) == size(Brs) == size(C) == size(Crs) == () +@test axes(B) == axes(Brs) == axes(C) == axes(Crs) == () +@test setindex!(B, Int32(5)) === B +@test B[] === Int32(5) +@test Brs[] === Int32(5) +@test C[] === (UInt32(5),) +@test Crs[] === (UInt32(5),) +@test A[] === UInt32(5) +@test setindex!(Brs, Int32(12)) === Brs +@test A[] === UInt32(12) +@test setindex!(C, (UInt32(7),)) === C +@test A[] === UInt32(7) +@test setindex!(Crs, (UInt32(3),)) === Crs +@test A[] === UInt32(3) + + +a = [(1.0,2.0)] +af = @inferred(reinterpret(reshape, Float64, a)) +anew = @inferred(reinterpret(reshape, Tuple{Float64,Float64}, vec(af))) +@test anew[1] == a[1] +@test ndims(anew) == 0 # re-reinterpret a0 = reshape([0x22, 0x44, 0x88, 0xf0, 0x01, 0x02, 0x03, 0x04], 4, 2) -test_many_wrappers(a0, (identity, wrapper)) do a0 - a = reinterpret(reshape, NTuple{4,UInt8}, a0) - @test a == [(0x22, 0x44, 0x88, 0xf0), (0x01, 0x02, 0x03, 0x04)] - @test reinterpret(UInt8, a) == [0x22, 0x44, 0x88, 0xf0, 0x01, 0x02, 0x03, 0x04] - @test reinterpret(reshape, UInt8, a) === a0 -end +a = reinterpret(reshape, NTuple{4,UInt8}, a0) +@test a == [(0x22, 0x44, 0x88, 0xf0), (0x01, 0x02, 0x03, 0x04)] +@test reinterpret(UInt8, a) == [0x22, 0x44, 0x88, 0xf0, 0x01, 0x02, 0x03, 0x04] +@test reinterpret(reshape, UInt8, a) === a0 # reductions a = [(1,2,3), (4,5,6)] -test_many_wrappers(a, (identity, wrapper)) do a - ars = reinterpret(reshape, Int, a) - @test sum(ars) == 21 - @test sum(ars; dims=1) == [6 15] - @test sum(ars; dims=2) == reshape([5,7,9], (3, 1)) - @test sum(ars; dims=(1,2)) == reshape([21], (1, 1)) -end +ars = reinterpret(reshape, Int, a) +@test sum(ars) == 21 +@test sum(ars; dims=1) == [6 15] +@test sum(ars; dims=2) == reshape([5,7,9], (3, 1)) +@test sum(ars; dims=(1,2)) == reshape([21], (1, 1)) # also test large sizes for the pairwise algorithm a = [(k,k+1,k+2) for k = 1:3:4000] -test_many_wrappers(a, (identity, wrapper)) do a - ars = reinterpret(reshape, Int, a) - @test sum(ars) == 8010003 -end +ars = reinterpret(reshape, Int, a) +@test sum(ars) == 8010003 @testset "similar(::ReinterpretArray)" begin a = reinterpret(NTuple{2,Float64}, TSlow(rand(Float64, 4, 4))) @@ -552,21 +514,6 @@ end @test_throws MethodError x[2,4] = nothing end -@testset "pointer for StridedArray" begin - a = rand(Float64, 251) - v = view(a, UInt(2):UInt(251)); - A = reshape(v, 25, 10); - @test A isa StridedArray && pointer(A) === pointer(a, 2) - Av = view(A, 1:20, 1:2) - @test Av isa StridedArray && pointer(Av) === pointer(a, 2) - @test Av * Av' isa Array -end - -@testset "effect of StridedReinterpretArray's getindex" begin - eff = Base.infer_effects(getindex, Base.typesof(reinterpret(Int8, Int[1]), 1)) - @test Core.Compiler.is_effect_free(eff) -end - # reinterpret of arbitrary bitstypes @testset "Reinterpret arbitrary bitstypes" begin struct Bytes15 diff --git a/test/testhelpers/arrayindexingtypes.jl b/test/testhelpers/arrayindexingtypes.jl index 95c1f18e00903..0e956b5216c94 100644 --- a/test/testhelpers/arrayindexingtypes.jl +++ b/test/testhelpers/arrayindexingtypes.jl @@ -66,6 +66,3 @@ Base.axes(A::WrapperArray) = axes(A.parent) Base.getindex(A::WrapperArray, i::Int...) = A.parent[i...] Base.setindex!(A::WrapperArray, v, i::Int...) = A.parent[i...] = v Base.similar(A::WrapperArray, ::Type{T}, dims::Dims) where T = similar(A.parent, T, dims) -Base.cconvert(::Type{Ptr{T}}, A::WrapperArray{T}) where {T} = Base.cconvert(Ptr{T}, A.parent) -Base.strides(A::WrapperArray) = strides(A.parent) -Base.elsize(::Type{WrapperArray{T,N,A}}) where {T,N,A<:AbstractArray{T,N}} = Base.elsize(A)