Have OffsetArray tests look for out of bounds stores. Allow LowDimArrays to only specify leading dimensions.

Author: chriselrod

src/broadcast.jl

@@ -118,7 +118,8 @@ end
 Base.@propagate_inbounds Base.getindex(A::LowDimArray, i...) = getindex(A.data, i...)
 Base.size(A::LowDimArray) = Base.size(A.data)
 @generated function VectorizationBase.stridedpointer(A::LowDimArray{D,T,N}) where {D,T,N}
-    s = Expr(:call, Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:VectorizationBase)), QuoteNode(:staticmul)), T, Expr(:tuple, [Expr(:ref, :strideA, n) for n ∈ 1+D[1]:N if D[n]]...))
+    smul = Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:VectorizationBase)), QuoteNode(:staticmul))
+    s = Expr(:call, smul, T, Expr(:tuple, [Expr(:ref, :strideA, n) for n ∈ 1+D[1]:N if ((length(D) < n) || D[n])]...))
     f = D[1] ? :PackedStridedPointer : :SparseStridedPointer
     Expr(:block, Expr(:meta,:inline), Expr(:(=), :strideA, Expr(:call, :strides, Expr(:(.), :A, QuoteNode(:data)))),
          Expr(:call, Expr(:(.), :VectorizationBase, QuoteNode(f)), Expr(:call, :pointer, Expr(:(.), :A, QuoteNode(:data))), s))
@@ -137,10 +138,11 @@ function add_broadcast!(
     @nospecialize(LDA::Type{<:LowDimArray}), elementbytes::Int
 )
     D,T,N::Int,_ = LDA.parameters
-    if !any(D)
+    Dlen = length(D)
+    if Dlen == N && !any(D)
         return extract_all_1_array!(ls, bcname, N, elementbytes)
     end
-    fulldims = Symbol[loopsyms[n] for n ∈ 1:N if D[n]::Bool]
+    fulldims = Symbol[loopsyms[n] for n ∈ 1:N if ((Dlen < n) || D[n]::Bool)]
     ref = ArrayReference(bcname, fulldims)
     add_simple_load!(ls, destname, ref, elementbytes, true, false )::Operation
 end

test/broadcast.jl

@@ -23,7 +23,7 @@
         fill!(c2, 99999); @avx @. c2 = a + br;
         @test c1 ≈ c2
         br = reshape(b, (1,99,99));
-        bl = LowDimArray{(false,true,true)}(br);
+        bl = LowDimArray{(false,)}(br);
         @. c1 = a + br;
         fill!(c2, 99999);
         @avx @. c2 = a + bl;

test/offsetarrays.jl

@@ -188,19 +188,20 @@ using LoopVectorization.VectorizationBase: StaticUnitRange
        out
     end
     function avxgeneric2!(out, A, kern)
-       @avx for I in CartesianIndices(out)
-           tmp = zero(eltype(out))
-           for J in CartesianIndices(kern)
-               tmp += A[I+J]*kern[J]
-           end
-           out[I] = tmp
-       end
-       out
-   end
+        @avx for I in CartesianIndices(out)
+            tmp = zero(eltype(out))
+            for J in CartesianIndices(kern)
+                tmp += A[I+J]*kern[J]
+            end
+            out[I] = tmp
+        end
+        out
+    end
 
     for T ∈ (Float32, Float64)
         @show T, @__LINE__
         Abase = fill(T(NaN), 200, 200);
+        # out of bounds reads load NaNs, poisoning results leading to test failure.
         A = view(Abase, 51:150, 51:150);
         A .= rand.();
         Atbase = copy(Abase');
@@ -209,56 +210,57 @@ using LoopVectorization.VectorizationBase: StaticUnitRange
             @show r
             fr = first(r); lr = last(r);
             kern = OffsetArray(rand(T, length(r), length(r)), r, r);
-            out1 = OffsetArray(view(similar(A, size(A) .+ 32), (1+lr:100-lr) .+ 32, (1+lr:100-lr) .+ 32), lr, lr);   # stay away from the edges of A
+            # We test parent equality so that an accidental write out of bounds leading to test failure.
+            out1 = OffsetArray(view(fill(T(-123456.789), size(A) .+ 32), (1+lr:100-lr) .+ 32, (1+lr:100-lr) .+ 32), lr, lr);   # stay away from the edges of A
             # out1 = OffsetArray(similar(A, size(A).-2), 1, 1);   # stay away from the edges of A
-            out2 = similar(out1); out3 = similar(out1); out4 = similar(out1);
+            out2 = deepcopy(out1); out3 = deepcopy(out1); out4 = deepcopy(out1);
             skern = SizedOffsetMatrix{T,fr,lr,fr,lr}(parent(kern));
 
             old2d!(out1, A, kern);
             avx2d!(out2, A, kern);
-            @test out1 ≈ out2
+            @test parent(out1) ≈ parent(out2)
 
             avx2douter!(out3, A, kern);
-            @test out1 ≈ out3
+            @test parent(out1) ≈ parent(out3)
 
             fill!(out2, NaN); avx2d!(out2, A, skern);
-            @test out1 ≈ out2
+            @test parent(out1) ≈ parent(out2)
 
             fill!(out2, NaN); avx2douter!(out2, At', kern);
-            @test out1 ≈ out2
+            @test parent(out1) ≈ parent(out2)
 
             fill!(out2, NaN); avx2douter!(out2', A, kern);
-            @test out1 ≈ out2'
+            @test parent(out1) ≈ parent(out2)'
 
             fill!(out2, NaN); avx2douter!(out2', At', kern);
-            @test out1 ≈ out2'
+            @test parent(out1) ≈ parent(out2)'
 
             fill!(out3, NaN); avx2douter!(out3, A, skern);
-            @test out1 ≈ out3
+            @test parent(out1) ≈ parent(out3)
 
             if r == -1:1
                 fill!(out3, NaN); avx2dunrolled!(out3, A, skern);
-                @test out1 ≈ out3
+                @test parent(out1) ≈ parent(out3)
 
                 fill!(out3, NaN); avx2dunrolled2x2!(out3, A, skern);
-                @test out1 ≈ out3
+                @test parent(out1) ≈ parent(out3)
 
                 fill!(out3, NaN); avx2dunrolled3x3!(out3, A, skern);
-                @test out1 ≈ out3
+                @test parent(out1) ≈ parent(out3)
             end
 
-            @test avxgeneric!(out4, A, kern) ≈ out1
+            @test parent(avxgeneric!(out4, A, kern)) ≈ parent(out1)
             fill!(out4, NaN);
-            @test avxgeneric!(out4, A, skern) ≈ out1
+            @test parent(avxgeneric!(out4, A, skern)) ≈ parent(out1)
 
-            fill!(out4, NaN); @test avxgeneric2!(out4, A, kern) ≈ out1
-            fill!(out4, NaN); @test avxgeneric2!(out4, A, skern) ≈ out1
-            fill!(out4, NaN); @test avxgeneric2!(out4, At', kern) ≈ out1
-            fill!(out4, NaN); @test avxgeneric2!(out4, At', skern) ≈ out1
-            fill!(out4, NaN); @test avxgeneric2!(out4', A, kern) ≈ out1
-            fill!(out4, NaN); @test avxgeneric2!(out4', A, skern) ≈ out1
-            fill!(out4, NaN); @test avxgeneric2!(out4', At', kern) ≈ out1
-            fill!(out4, NaN); @test avxgeneric2!(out4', At', skern) ≈ out1
+            fill!(out4, NaN); @test parent(avxgeneric2!(out4, A, kern)) ≈ parent(out1)
+            fill!(out4, NaN); @test parent(avxgeneric2!(out4, A, skern)) ≈ parent(out1)
+            fill!(out4, NaN); @test parent(avxgeneric2!(out4, At', kern)) ≈ parent(out1)
+            fill!(out4, NaN); @test parent(avxgeneric2!(out4, At', skern)) ≈ parent(out1)
+            fill!(out4, NaN); @test parent(avxgeneric2!(out4', A, kern)')' ≈ parent(out1)
+            fill!(out4, NaN); @test parent(avxgeneric2!(out4', A, skern)')' ≈ parent(out1)
+            fill!(out4, NaN); @test parent(avxgeneric2!(out4', At', kern)')' ≈ parent(out1)
+            fill!(out4, NaN); @test parent(avxgeneric2!(out4', At', skern)')' ≈ parent(out1)
         end
     end