make gather / scatter operations work on Vector{Bool} (#153)

Author: KristofferC

src/SIMD.jl

@@ -18,7 +18,8 @@ const IntegerTypes  = Union{IntTypes, UIntTypes}
 const BIntegerTypes = Union{IntegerTypes, Bool}
 const FloatingTypes = Union{Float16, Float32, Float64}
 const ScalarTypes   = Union{IntegerTypes, FloatingTypes}
-const VecTypes      = Union{ScalarTypes, Ptr, LLVMPtr, Bool}
+const BScalarTypes  = Union{BIntegerTypes, FloatingTypes}
+const VecTypes      = Union{BScalarTypes, Ptr, LLVMPtr}
 include("LLVM_intrinsics.jl")
 include("simdvec.jl")
 include("arrayops.jl")

src/arrayops.jl

@@ -151,13 +151,13 @@ end
 # therefore use @propagate_inbounds
 @inline vgather(ptrs::Vec{N,<:AnyPtr{T}},
                  mask::Vec{N,Bool}=one(Vec{N,Bool}),
-                 ::Val{Aligned}=Val(false)) where {N, T<:ScalarTypes, Aligned} =
+                 ::Val{Aligned}=Val(false)) where {N, T<:BScalarTypes, Aligned} =
     return Vec(Intrinsics.maskedgather(ptrs.data, mask.data))
-@inline vgather(ptrs::Vec{<:Any,<:AnyPtr{<:ScalarTypes}}, ::Nothing, aligned::Val = Val(false)) =
+@inline vgather(ptrs::Vec{<:Any,<:AnyPtr{<:BScalarTypes}}, ::Nothing, aligned::Val = Val(false)) =
     vgather(ptrs, one(Vec{length(ptrs),Bool}), aligned)
 @propagate_inbounds function vgather(a::FastContiguousArray{T,1}, idx::Vec{N, <:Integer},
                                      mask::Vec{N,Bool}=one(Vec{N,Bool}),
-                                     ::Val{Aligned}=Val(false)) where {N, T<:ScalarTypes, Aligned}
+                                     ::Val{Aligned}=Val(false)) where {N, T<:BScalarTypes, Aligned}
     @boundscheck for i in 1:N
         checkbounds(a, @inbounds idx[i])
     end
@@ -176,14 +176,14 @@ end
 
 
 @propagate_inbounds vscatter(x::Vec{N,T}, ptrs::Vec{N,<:AnyPtr{T}},
-                             mask::Vec{N,Bool}, ::Val{Aligned}=Val(false)) where {N, T<:ScalarTypes, Aligned} =
+                             mask::Vec{N,Bool}, ::Val{Aligned}=Val(false)) where {N, T<:BScalarTypes, Aligned} =
     Intrinsics.maskedscatter(x.data, ptrs.data, mask.data)
 @inline vscatter(x::Vec{N,T}, ptrs::Vec{N,<:AnyPtr{T}},
-                 ::Nothing, aligned::Val=Val(false)) where {N, T<:ScalarTypes} =
+                 ::Nothing, aligned::Val=Val(false)) where {N, T<:BScalarTypes} =
     vscatter(x, ptrs, one(Vec{N, Bool}), aligned)
 @propagate_inbounds function vscatter(x::Vec{N,T}, a::FastContiguousArray{T,1}, idx::Vec{N, <:Integer},
                                       mask::Vec{N,Bool}=one(Vec{N, Bool}),
-                                      ::Val{Aligned}=Val(false)) where {N, T<:ScalarTypes, Aligned}
+                                      ::Val{Aligned}=Val(false)) where {N, T<:BScalarTypes, Aligned}
     @boundscheck for i in 1:N
         checkbounds(a, @inbounds idx[i])
     end

test/runtests.jl

@@ -419,6 +419,7 @@ llvm_ir(f, args) = sprint(code_llvm, f, Base.typesof(args...))
         end
 
         global const arrf64 = valloc(Float64, L4, 4*L4) do i i end
+        global const arrbool = valloc(Bool, L8, 2*L8) do i isodd(i) end
         for i in 1:length(arrf64)-(L4-1)
             @test vload(V4F64, arrf64, i) === V4F64(ntuple(j->i+j-1, L4))
         end
@@ -593,6 +594,58 @@ llvm_ir(f, args) = sprint(code_llvm, f, Base.typesof(args...))
                 end
             end
         end
+
+        # Test Bool gather/scatter operations (issue #150)
+        @testset "Bool gather and scatter" begin
+            V8BOOL = Vec{L8,Bool}
+            arrbool .= [isodd(i) for i in 1:length(arrbool)]
+            idxarr = floor.(Int, range(1, stop=length(arrbool), length=L8))
+
+            idx = Vec(Tuple(idxarr))
+            expected_vals = [arrbool[i] for i in idxarr]
+            expected_vec = V8BOOL(Tuple(expected_vals))
+
+            @test vgather(arrbool, idx) === expected_vec
+            @test vgathera(arrbool, idx) === expected_vec
+            @test arrbool[idx] === expected_vec
+
+            # Masked gather for Bool
+            maskarr = zeros(Bool, L8)
+            for i in 1:L8
+                maskarr[i] = true
+                mask = Vec(Tuple(maskarr))
+                expected_masked = V8BOOL(Tuple(expected_vals .* maskarr))
+                @test vgather(arrbool, idx, mask) === expected_masked
+                @test vgathera(arrbool, idx, mask) === expected_masked
+                @test arrbool[idx, mask] === expected_masked
+            end
+
+            # Scatter for Bool
+            varr = [isodd(i*3) for i in 1:L8]  # Different pattern for scatter
+            v = Vec(Tuple(varr))
+
+            vscatter(v, fill!(arrbool, false), idx)
+            @test [arrbool[i] for i in idxarr] == varr
+            vscattera(v, fill!(arrbool, false), idx)
+            @test [arrbool[i] for i in idxarr] == varr
+            fill!(arrbool, false)
+            arrbool[idx] = v
+            @test [arrbool[i] for i in idxarr] == varr
+
+            # Masked scatter for Bool
+            maskarr = zeros(Bool, L8)
+            for i in 1:L8
+                maskarr[i] = true
+                mask = Vec(Tuple(maskarr))
+                vscatter(v, fill!(arrbool, false), idx, mask)
+                @test [arrbool[i] for i in idxarr] == varr .* maskarr
+                vscattera(v, fill!(arrbool, false), idx, mask)
+                @test [arrbool[i] for i in idxarr] == varr .* maskarr
+                fill!(arrbool, false)
+                arrbool[idx, mask] = v
+                @test [arrbool[i] for i in idxarr] == varr .* maskarr
+            end
+        end
     end
 
     @testset "expandload" begin