-
-
Notifications
You must be signed in to change notification settings - Fork 5.5k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
This redoes `reinterpret` in julia rather than punning the memory
of the actual array. The motivation for this is to avoid the API
limitations of the current reinterpret implementation (Array only,
preventing strong TBAA, alignment problems). The surface API
essentially unchanged, though the shape argument to reinterpret
is removed, since those concepts are now orthogonal. The return
type from `reinterpret` is now `ReinterpretArray`, which implements
the AbstractArray interface and does the reinterpreting lazily on
demand. The compiler is able to fold away the abstraction and
generate very tight IR:
```
julia> ar = reinterpret(Complex{Int64}, rand(Int64, 1000));
julia> typeof(ar)
Base.ReinterpretArray{Complex{Int64},Int64,1,Array{Int64,1}}
julia> f(ar) = @inbounds return ar[1]
f (generic function with 1 method)
julia> @code_llvm f(ar)
; Function f
; Location: REPL[2]
define void @julia_f_63575({ i64, i64 } addrspace(11)* noalias nocapture sret, %jl_value_t addrspace(10)* dereferenceable(8)) #0 {
top:
; Location: REPL[2]:1
; Function getindex; {
; Location: reinterpretarray.jl:31
%2 = addrspacecast %jl_value_t addrspace(10)* %1 to %jl_value_t addrspace(11)*
%3 = bitcast %jl_value_t addrspace(11)* %2 to %jl_value_t addrspace(10)* addrspace(11)*
%4 = load %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)* addrspace(11)* %3, align 8
%5 = addrspacecast %jl_value_t addrspace(10)* %4 to %jl_value_t addrspace(11)*
%6 = bitcast %jl_value_t addrspace(11)* %5 to i64* addrspace(11)*
%7 = load i64*, i64* addrspace(11)* %6, align 8
%8 = load i64, i64* %7, align 8
%9 = getelementptr i64, i64* %7, i64 1
%10 = load i64, i64* %9, align 8
%.sroa.0.0..sroa_idx = getelementptr inbounds { i64, i64 }, { i64, i64 } addrspace(11)* %0, i64 0, i32 0
store i64 %8, i64 addrspace(11)* %.sroa.0.0..sroa_idx, align 8
%.sroa.3.0..sroa_idx13 = getelementptr inbounds { i64, i64 }, { i64, i64 } addrspace(11)* %0, i64 0, i32 1
store i64 %10, i64 addrspace(11)* %.sroa.3.0..sroa_idx13, align 8
;}
ret void
}
julia> g(a) = @inbounds return reinterpret(Complex{Int64}, a)[1]
g (generic function with 1 method)
julia> @code_llvm g(randn(1000))
; Function g
; Location: REPL[4]
define void @julia_g_63642({ i64, i64 } addrspace(11)* noalias nocapture sret, %jl_value_t addrspace(10)* dereferenceable(40)) #0 {
top:
; Location: REPL[4]:1
; Function getindex; {
; Location: reinterpretarray.jl:31
%2 = addrspacecast %jl_value_t addrspace(10)* %1 to %jl_value_t addrspace(11)*
%3 = bitcast %jl_value_t addrspace(11)* %2 to double* addrspace(11)*
%4 = load double*, double* addrspace(11)* %3, align 8
%5 = bitcast double* %4 to i64*
%6 = load i64, i64* %5, align 8
%7 = getelementptr double, double* %4, i64 1
%8 = bitcast double* %7 to i64*
%9 = load i64, i64* %8, align 8
%.sroa.0.0..sroa_idx = getelementptr inbounds { i64, i64 }, { i64, i64 } addrspace(11)* %0, i64 0, i32 0
store i64 %6, i64 addrspace(11)* %.sroa.0.0..sroa_idx, align 8
%.sroa.3.0..sroa_idx13 = getelementptr inbounds { i64, i64 }, { i64, i64 } addrspace(11)* %0, i64 0, i32 1
store i64 %9, i64 addrspace(11)* %.sroa.3.0..sroa_idx13, align 8
;}
ret void
}
```
In addition, the new `reinterpret` implementation is able to handle any AbstractArray
(whether useful or not is a separate decision):
```
invoke(reinterpret, Tuple{Type{Complex{Float64}}, AbstractArray}, Complex{Float64}, speye(10))
5×10 Base.ReinterpretArray{Complex{Float64},Float64,2,SparseMatrixCSC{Float64,Int64}}:
1.0+0.0im 0.0+1.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im
0.0+0.0im 0.0+0.0im 1.0+0.0im 0.0+1.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im
0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 1.0+0.0im 0.0+1.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im
0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 1.0+0.0im 0.0+1.0im 0.0+0.0im 0.0+0.0im
0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im 1.0+0.0im 0.0+1.0im
```
The remaining todo is to audit the uses of reinterpret in base. I've fixed up the uses themselves, but there's
code deeper in the array code that needs to be broadened to allow ReinterpretArray.
Fixes #22849
Fixes #19238- Loading branch information
Showing
15 changed files
with
141 additions
and
69 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,92 @@ | ||
| """ | ||
| Gives a reinterpreted view (of element type T) of the underlying array (of element type S). | ||
| If the size of `T` differs from the size of `S`, the array will be compressed/expanded in | ||
| the first dimension. | ||
| """ | ||
| struct ReinterpretArray{T,N,S,A<:AbstractArray{S, N}} <: AbstractArray{T, N} | ||
| parent::A | ||
| function reinterpret(::Type{T}, a::A) where {T,N,S,A<:AbstractArray{S, N}} | ||
| function throwbits(::Type{S}, ::Type{T}, ::Type{U}) where {S,T,U} | ||
| @_noinline_meta | ||
| throw(ArgumentError("cannot reinterpret `$(S)` `$(T)`, type `$(U)` is not a bits type")) | ||
| end | ||
| function throwsize0(::Type{S}, ::Type{T}) | ||
| @_noinline_meta | ||
| throw(ArgumentError("cannot reinterpret a zero-dimensional `$(S)` array to `$(T)` which is of a different size")) | ||
| end | ||
| isbits(T) || throwbits(S, T, T) | ||
| isbits(S) || throwbits(S, T, S) | ||
| (N != 0 || sizeof(T) == sizeof(S)) || throwsize0(S, T) | ||
| new{T, N, S, A}(a) | ||
| end | ||
| end | ||
|
|
||
| eltype(a::ReinterpretArray{T}) where {T} = T | ||
| function size(a::ReinterpretArray{T,N,S} where {N}) where {T,S} | ||
| psize = size(a.parent) | ||
| if sizeof(T) > sizeof(S) | ||
| size1 = div(psize[1], div(sizeof(T), sizeof(S))) | ||
| else | ||
| size1 = psize[1] * div(sizeof(S), sizeof(T)) | ||
| end | ||
| tuple(size1, tail(psize)...) | ||
| end | ||
|
|
||
| unsafe_convert(::Type{Ptr{T}}, a::ReinterpretArray{T,N,S} where N) where {T,S} = Ptr{T}(unsafe_convert(Ptr{S},a.parent)) | ||
|
|
||
| @inline @propagate_inbounds getindex(a::ReinterpretArray{T,0}) where {T} = reinterpret(T, a.parent[]) | ||
| @inline @propagate_inbounds getindex(a::ReinterpretArray) = a[1] | ||
|
|
||
| @inline @propagate_inbounds function getindex(a::ReinterpretArray{T,N,S}, inds::Vararg{Int, N}) where {T,N,S} | ||
| if sizeof(T) == sizeof(S) | ||
| return reinterpret(T, a.parent[inds...]) | ||
| elseif sizeof(T) > sizeof(S) | ||
| nels = div(sizeof(T), sizeof(S)) | ||
| ind_off = (inds[1]-1) * nels | ||
| o = Ref{T}() | ||
| @gc_preserve o begin | ||
| optr = unsafe_convert(Ref{T}, o) | ||
| for i = 1:nels | ||
| unsafe_store!(Ptr{S}(optr), a.parent[ind_off + i, tail(inds)...], i) | ||
| end | ||
| end | ||
| return o[] | ||
| else | ||
| ind, sub = divrem(inds[1]-1, div(sizeof(S), sizeof(T))) | ||
| r = Ref{S}(a.parent[1+ind, tail(inds)...]) | ||
| @gc_preserve r begin | ||
| rptr = unsafe_convert(Ref{S}, r) | ||
| ret = unsafe_load(Ptr{T}(rptr), sub+1) | ||
| end | ||
| return ret | ||
| end | ||
| end | ||
|
|
||
| @inline @propagate_inbounds setindex!(a::ReinterpretArray{T,0,S} where T, v) where {S} = (a.parent[] = reinterpret(S, v)) | ||
| @inline @propagate_inbounds setindex!(a::ReinterpretArray, v) = (a[1] = v) | ||
|
|
||
| @inline @propagate_inbounds function setindex!(a::ReinterpretArray{T,N,S}, v, inds::Vararg{Int, N}) where {T,N,S} | ||
| v = convert(T, v)::T | ||
| if sizeof(T) == sizeof(S) | ||
| return setindex!(a, reinterpret(S, v), inds...) | ||
| elseif sizeof(T) > sizeof(S) | ||
| nels = div(sizeof(T), sizeof(S)) | ||
| ind_off = (inds[1]-1) * nels | ||
| o = Ref{T}(v) | ||
| @gc_preserve o begin | ||
| optr = unsafe_convert(Ref{T}, o) | ||
| for i = 1:nels | ||
| a.parent[ind_off + i, tail(inds)...] = unsafe_load(Ptr{S}(optr), i) | ||
| end | ||
| end | ||
| else | ||
| ind, sub = divrem(inds[1]-1, div(sizeof(S), sizeof(T))) | ||
| r = Ref{S}(a.parent[1+ind, tail(inds)...]) | ||
| @gc_preserve r begin | ||
| rptr = unsafe_convert(Ref{S}, r) | ||
| unsafe_store!(Ptr{T}(rptr), v, sub+1) | ||
| end | ||
| a.parent[1+ind] = r[] | ||
| end | ||
| return a | ||
| end |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters