ArrayInterface 5

Author: chriselrod

Project.toml

@@ -1,7 +1,7 @@
 name = "LoopVectorization"
 uuid = "bdcacae8-1622-11e9-2a5c-532679323890"
 authors = ["Chris Elrod <[email protected]>"]
-version = "0.12.102"
+version = "0.12.103"
 
 [deps]
 ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
@@ -25,8 +25,8 @@ UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed"
 VectorizationBase = "3d5dd08c-fd9d-11e8-17fa-ed2836048c2f"
 
 [compat]
-ArrayInterface = "3.1.32, 3.2.1"
-CPUSummary = "0.1.3"
+ArrayInterface = "3.1.32, 3.2.1, 5.0.1"
+CPUSummary = "0.1.3 - 0.1.8, 0.1.11"
 ChainRulesCore = "1"
 CloseOpenIntervals = "0.1.2"
 DocStringExtensions = "0.8"
@@ -39,7 +39,7 @@ PolyesterWeave = "0.1"
 SIMDDualNumbers = "0.1"
 SLEEFPirates = "0.6.23"
 SpecialFunctions = "1, 2"
-Static = "0.3.3, 0.4"
+Static = "0.3.3, 0.4, 0.6"
 ThreadingUtilities = "0.5"
 UnPack = "1"
 VectorizationBase = "0.21.21"

src/broadcast.jl

@@ -10,7 +10,7 @@ Base.@propagate_inbounds Base.getindex(A::LowDimArray, i::Vararg{Union{Integer,C
 
 @inline ArrayInterface.parent_type(::Type{LowDimArray{D,T,N,A}}) where {T,D,N,A} = A
 @inline Base.strides(A::LowDimArray) = map(Int, strides(A))
-@inline ArrayInterface.device(A::LowDimArray) = ArrayInterface.CPUPointer()
+@inline ArrayInterface.device(::LowDimArray) = ArrayInterface.CPUPointer()
 @generated function ArrayInterface.size(A::LowDimArray{D,T,N}) where {D,T,N}
   t = Expr(:tuple)
   gf = GlobalRef(Core,:getfield)
@@ -335,9 +335,8 @@ end
 
 function add_broadcast!(
     ls::LoopSet, destname::Symbol, bcname::Symbol, loopsyms::Vector{Symbol},
-    @nospecialize(LDA::Type{LowDimArray{D,T,N,A}}), elementbytes::Int
+    @nospecialize(_::Type{LowDimArray{D,T,N,A}}), elementbytes::Int
 ) where {D,T,N,A}
-    # D,T,N::Int,_ = LDA.parameters
     Dlen = length(D)
     if Dlen == N && !any(D) # array is a scalar, as it is broadcasted on all dimensions
         return extract_all_1_array!(ls, bcname, N, elementbytes)
@@ -422,7 +421,6 @@ function add_broadcast!(
         Instruction(bcname, f)
     end
     args = A.parameters
-    Nargs = length(args)
     bcargs = gensym!(ls, "bcargs")
     pushprepreamble!(ls, Expr(:(=), bcargs, Expr(:(.), bcname, QuoteNode(:args))))
     # this is the var name in the loop
@@ -447,7 +445,7 @@ end
 function add_broadcast_loops!(ls::LoopSet, loopsyms::Vector{Symbol}, destsym::Symbol)
     axes_tuple = Expr(:tuple)
     pushpreamble!(ls, Expr(:(=), axes_tuple, Expr(:call, :axes, destsym)))
-    for (n,itersym) ∈ enumerate(loopsyms)
+    for itersym ∈ loopsyms
         Nrange = gensym!(ls, "N")
         Nlower = gensym!(ls, "N")
         Nupper = gensym!(ls, "N")
@@ -464,15 +462,15 @@ end
 @generated function vmaterialize!(
     dest::AbstractArray{T,N}, bc::BC, ::Val{Mod}, ::Val{UNROLL}
 ) where {T <: NativeTypes, N, BC <: Union{Broadcasted,Product}, Mod, UNROLL}
-  # 2+1
+  2+1
   # we have an N dimensional loop.
   # need to construct the LoopSet
   # @show typeof(dest)
   ls = LoopSet(Mod)
-  inline, u₁, u₂, v, isbroadcast, W, rs, rc, cls, l1, l2, l3, threads, warncheckarg = UNROLL
+  inline, u₁, u₂, v, isbroadcast, _, rs, rc, cls, l1, l2, l3, threads, warncheckarg = UNROLL
   set_hw!(ls, rs, rc, cls, l1, l2, l3)
   ls.isbroadcast = isbroadcast # maybe set `false` in a DiffEq-like `@..` macro
-  loopsyms = [gensym!(ls, "n") for n ∈ 1:N]
+  loopsyms = [gensym!(ls, "n") for _ ∈ 1:N]
   add_broadcast_loops!(ls, loopsyms, :dest)
   elementbytes = sizeof(T)
   add_broadcast!(ls, :destination, :bc, loopsyms, BC, elementbytes)
@@ -481,6 +479,7 @@ end
   resize!(ls.loop_order, num_loops(ls)) # num_loops may be greater than N, eg Product
   # return ls
   sc = setup_call(ls, :(Base.Broadcast.materialize!(dest, bc)), LineNumberNode(0), inline, false, u₁, u₂, v, threads%Int, warncheckarg)
+  # for n in loopsyms; push!(sc.args, :(@show $n)); end
   Expr(:block, Expr(:meta,:inline), sc, :dest)
 end
 @generated function vmaterialize!(
@@ -489,10 +488,10 @@ end
   # we have an N dimensional loop.
   # need to construct the LoopSet
   ls = LoopSet(Mod)
-  inline, u₁, u₂, v, isbroadcast, W, rs, rc, cls, l1, l2, l3, threads, warncheckarg = UNROLL
+  inline, u₁, u₂, v, isbroadcast, _, rs, rc, cls, l1, l2, l3, threads, warncheckarg = UNROLL
   set_hw!(ls, rs, rc, cls, l1, l2, l3)
   ls.isbroadcast = isbroadcast # maybe set `false` in a DiffEq-like `@..` macro
-  loopsyms = [gensym!(ls, "n") for n ∈ 1:N]
+  loopsyms = [gensym!(ls, "n") for _ ∈ 1:N]
   pushprepreamble!(ls, Expr(:(=), :dest, Expr(:call, :parent, :dest′)))
   add_broadcast_loops!(ls, loopsyms, :dest′)
   elementbytes = sizeof(T)

test/broadcast.jl

@@ -1,14 +1,5 @@
 using LoopVectorization, Test
-# T = Float32
-
-macro outline(ex)
-  quote
-    (() -> begin
-       Base.@_noinline_meta
-       $(esc(ex))
-     end)()
-  end
-end
+T = Float32
 
 function test_broadcast(::Type{T}) where {T}
   M, N = 37, 47
@@ -22,35 +13,35 @@ function test_broadcast(::Type{T}) where {T}
 
   br = reshape(b, (99,99));
   c1 = a .+ b;
-  c2 = @outline @turbo a .+ bl;
+  c2 = @turbo inline=false a .+ bl;
   @test c1 ≈ c2
-  fill!(c2, 99999); @outline @turbo c2 .= a .+ br;
+  fill!(c2, 99999); @turbo inline=false c2 .= a .+ br;
   @test c1 ≈ c2
-  fill!(c2, 99999); @outline @turbo c2 .= a .+ b;
+  fill!(c2, 99999); @turbo inline=false c2 .= a .+ b;
   @test c1 ≈ c2
   br = reshape(b, (99,1,99));
   bl = LowDimArray{(true,false,true)}(br);
   @test size(bl) == size(br)
   @test LoopVectorization.ArrayInterface.size(bl) === (size(br,1),LoopVectorization.StaticInt(1),size(br,3))
   @. c1 = a + br;
-  fill!(c2, 99999); @outline @turbo @. c2 = a + bl;
+  fill!(c2, 99999); @turbo inline=false @. c2 = a + bl;
   @test c1 ≈ c2
-  fill!(c2, 99999); @outline @turbo @. c2 = a + br;
+  fill!(c2, 99999); @turbo inline=false @. c2 = a + br;
   @test c1 ≈ c2
   br = reshape(b, (1,99,99));
   bl = LowDimArray{(false,)}(br);
   @test size(bl) == size(br)
   @test LoopVectorization.ArrayInterface.size(bl) === (LoopVectorization.StaticInt(1),size(br,2),size(br,3))
   @. c1 = a + br;
   fill!(c2, 99999);
-  @test c1 ≈ @outline @turbo @. c2 = a + bl
+  @test c1 ≈ @turbo inline=false @. c2 = a + bl
   # @test c1 ≈ c2
   br = reshape(rand(R,99), (1,99,1));
   bl = LowDimArray{(false,)}(br);
   @test size(bl) == size(br)
   @. c1 = a + br;
   fill!(c2, 99999);
-  @outline @turbo @. c2 = a + bl;
+  @turbo inline=false @. c2 = a + bl;
   @test c1 ≈ c2
 
   if T <: Integer
@@ -59,76 +50,76 @@ function test_broadcast(::Type{T}) where {T}
     xs = rand(T, M);
   end
   max_ = maximum(xs, dims=1);
-  @test (@outline @turbo exp.(xs .- LowDimArray{(false,)}(max_))) ≈ exp.(xs .- LowDimArray{(false,)}(max_))
+  @test (@turbo inline=false exp.(xs .- LowDimArray{(false,)}(max_))) ≈ exp.(xs .- LowDimArray{(false,)}(max_))
   @test size(LowDimArray{(false,)}(max_)) == size(max_)
 
   if T === Int32
     a = rand(T(1):T(100), 73, 1);
-    @test sqrt.(Float32.(a)) ≈ @outline @turbo sqrt.(a)
+    @test sqrt.(Float32.(a)) ≈ @turbo inline=false sqrt.(a)
   elseif T === Int64
     a = rand(T(1):T(100), 73, 1);
-    @test sqrt.(a) ≈ @outline @tturbo sqrt.(a)
+    @test sqrt.(a) ≈ @tturbo inline=false sqrt.(a)
   else
     a = rand(T, 73, 1);
-    @test sqrt.(a) ≈ @outline @turbo sqrt.(a)
+    @test sqrt.(a) ≈ @turbo inline=false sqrt.(a)
   end
 
   a = rand(R, M); B = rand(R, M, N); c = rand(R, N); c′ = c';
   d1 =       @. a + B * c′;
-  d2 = @outline @tturbo @. a + B * c′;
+  d2 = @tturbo inline=false @. a + B * c′;
   @test d1 ≈ d2
 
   @.      d1 = a + B * c′;
-  @outline @turbo @. d2 = a + B * c′;
+  @turbo inline=false @. d2 = a + B * c′;
   @test d1 ≈ d2
 
   d3 = a .+ B * c;
-  d4 = @outline @turbo a .+ B *ˡ c;
+  d4 = @turbo inline=false a .+ B *ˡ c;
   @test d3 ≈ d4
 
   fill!(d3, -1000.0);
   fill!(d4, 91000.0);
 
   d3 .= a .+ B * c;
-  @outline @turbo d4 .= a .+ B *ˡ c;
+  @turbo inline=false d4 .= a .+ B *ˡ c;
   @test d3 ≈ d4
 
   fill!(d4, 91000.0);
-  @outline @turbo @. d4 = a + B *ˡ c;
+  @turbo inline=false @. d4 = a + B *ˡ c;
   @test d3 ≈ d4
 
   M, K, N = 77, 83, 57;
   A = rand(R,M,K); B = rand(R,K,N); C = rand(R,M,N);
   At = copy(A');
   D1 = C .+ A * B;
-  D2 = @outline @tturbo C .+ A .*ˡ B;
+  D2 = @tturbo inline=false C .+ A .*ˡ B;
   @test D1 ≈ D2
   if RUN_SLOW_TESTS
-    fill!(D2, -999999); D2 = @outline @turbo C .+ At' *ˡ B;
+    fill!(D2, -999999); D2 = @turbo inline=false C .+ At' *ˡ B;
     @test D1 ≈ D2
-    fill!(D2, -999999); @test A * B ≈ (@outline @turbo @. D2 = A *ˡ B)
+    fill!(D2, -999999); @test A * B ≈ (@turbo inline=false @. D2 = A *ˡ B)
     D1 .= view(C, 1, :)' .+ A * B;
     fill!(D2, -999999);
-    @outline @turbo D2 .= view(C, 1, :)' .+ A .*ˡ B;
+    @turbo inline=false D2 .= view(C, 1, :)' .+ A .*ˡ B;
     @test D1 ≈ D2
     C3d = rand(R,3,M,N);
     D1 .= view(C3d, 1, :, :) .+ A * B;
     fill!(D2, -999999);
-    @outline @tturbo D2 .= view(C3d, 1, :, :) .+ A .*ˡ B;
+    @tturbo inline=false D2 .= view(C3d, 1, :, :) .+ A .*ˡ B;
     @test D1 ≈ D2
   end
   D1 .= 9999;
-  @outline @turbo D2 .= 9999;
+  @turbo inline=false D2 .= 9999;
   @test D1 == D2
   D1 .= -99999;
-  @outline @tturbo D2' .= -99999;
+  @tturbo inline=false D2' .= -99999;
   @test D1 == D2
 
   b = rand(T,K); x = rand(R,N);
   D1 .= C .+ A * (b .+ x');
-  @outline @tturbo @. D2 = C + A *ˡ (b + x');
+  @tturbo inline=false @. D2 = C + A *ˡ (b + x');
   @test D1 ≈ D2
-  D2 = @outline @turbo @. C + A *ˡ (b + x');
+  D2 = @turbo inline=false @. C + A *ˡ (b + x');
   @test D1 ≈ D2
   if T === Int64
     xd = rand(-1_000_000_000_000:1_000_000_000_000,89);
@@ -143,43 +134,43 @@ function test_broadcast(::Type{T}) where {T}
 
   if T <: Union{Float32,Float64}
     D3 = cos.(B');
-    D4 = @outline @turbo cos.(B');
+    D4 = @turbo inline=false cos.(B');
     @test D3 ≈ D4
 
     fill!(D3, -1e3); fill!(D4, 9e9);
     Bt = transpose(B);
     @. D3 = exp(Bt);
-    @outline @tturbo @. D4 = exp(Bt);
+    @tturbo inline=false @. D4 = exp(Bt);
     @test D3 ≈ D4
 
     D1 = similar(B); D2 = similar(B);
     D1t = transpose(D1);
     D2t = transpose(D2);
     @. D1t = exp(Bt);
-    @outline @turbo @. D2t = exp(Bt);
+    @turbo inline=false @. D2t = exp(Bt);
     @test D1t ≈ D2t
 
     fill!(D1, -1e3);
     fill!(D2, 9e9);
     @. D1' = exp(Bt);
-    lset = @outline @tturbo @. D2' = exp(Bt);
+    lset = @tturbo inline=false @. D2' = exp(Bt);
 
     @test D1 ≈ D2
 
     a = rand(137);
-    b1 = @outline @turbo @. 3*a + sin(a) + sqrt(a);
+    b1 = @turbo inline=false @. 3*a + sin(a) + sqrt(a);
     b2 =      @. 3*a + sin(a) + sqrt(a);
     @test b1 ≈ b2
     three = 3; fill!(b1, -9999);
-    @outline @tturbo @. b1 = three*a + sin(a) + sqrt(a);
+    @tturbo inline=false @. b1 = three*a + sin(a) + sqrt(a);
     @test b1 ≈ b2
 
     C = rand(100,10,10);
     D1 = C .^ 0.3;
-    D2 = @outline @tturbo C .^ 0.3;
+    D2 = @tturbo inline=false C .^ 0.3;
     @test D1 ≈ D2
     @. D1 = C ^ 2;
-    @outline @turbo @. D2 = C ^ 2;
+    @turbo inline=false @. D2 = C ^ 2;
     @test D1 ≈ D2
     @turbo view(C,1:100,1:10,1:10) .= 0;
     @test all(==(0), C)